xfs_super.c 21.7 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
2
 * Copyright (c) 2000-2006 Silicon Graphics, Inc.
3
 * All Rights Reserved.
L
Linus Torvalds 已提交
4
 *
5 6
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
L
Linus Torvalds 已提交
7 8
 * published by the Free Software Foundation.
 *
9 10 11 12
 * This program is distributed in the hope that it would be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
L
Linus Torvalds 已提交
13
 *
14 15 16
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write the Free Software Foundation,
 * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
L
Linus Torvalds 已提交
17 18
 */
#include "xfs.h"
19
#include "xfs_bit.h"
L
Linus Torvalds 已提交
20 21
#include "xfs_log.h"
#include "xfs_clnt.h"
22
#include "xfs_inum.h"
L
Linus Torvalds 已提交
23 24
#include "xfs_trans.h"
#include "xfs_sb.h"
25
#include "xfs_ag.h"
L
Linus Torvalds 已提交
26 27 28 29 30 31
#include "xfs_dir2.h"
#include "xfs_alloc.h"
#include "xfs_dmapi.h"
#include "xfs_quota.h"
#include "xfs_mount.h"
#include "xfs_bmap_btree.h"
32
#include "xfs_alloc_btree.h"
L
Linus Torvalds 已提交
33 34
#include "xfs_ialloc_btree.h"
#include "xfs_dir2_sf.h"
35
#include "xfs_attr_sf.h"
L
Linus Torvalds 已提交
36 37
#include "xfs_dinode.h"
#include "xfs_inode.h"
38 39
#include "xfs_btree.h"
#include "xfs_ialloc.h"
L
Linus Torvalds 已提交
40 41 42 43 44 45 46 47 48
#include "xfs_bmap.h"
#include "xfs_rtalloc.h"
#include "xfs_error.h"
#include "xfs_itable.h"
#include "xfs_rw.h"
#include "xfs_acl.h"
#include "xfs_attr.h"
#include "xfs_buf_item.h"
#include "xfs_utils.h"
49
#include "xfs_vnodeops.h"
L
Linus Torvalds 已提交
50 51 52 53 54
#include "xfs_version.h"

#include <linux/namei.h>
#include <linux/init.h>
#include <linux/mount.h>
55
#include <linux/mempool.h>
L
Linus Torvalds 已提交
56
#include <linux/writeback.h>
57
#include <linux/kthread.h>
58
#include <linux/freezer.h>
L
Linus Torvalds 已提交
59

60 61 62 63
static struct quotactl_ops xfs_quotactl_operations;
static struct super_operations xfs_super_operations;
static kmem_zone_t *xfs_vnode_zone;
static kmem_zone_t *xfs_ioend_zone;
64
mempool_t *xfs_ioend_pool;
L
Linus Torvalds 已提交
65 66 67

STATIC struct xfs_mount_args *
xfs_args_allocate(
68 69
	struct super_block	*sb,
	int			silent)
L
Linus Torvalds 已提交
70 71 72 73 74 75 76 77 78 79 80 81
{
	struct xfs_mount_args	*args;

	args = kmem_zalloc(sizeof(struct xfs_mount_args), KM_SLEEP);
	args->logbufs = args->logbufsize = -1;
	strncpy(args->fsname, sb->s_id, MAXNAMELEN);

	/* Copy the already-parsed mount(2) flags we're interested in */
	if (sb->s_flags & MS_DIRSYNC)
		args->flags |= XFSMNT_DIRSYNC;
	if (sb->s_flags & MS_SYNCHRONOUS)
		args->flags |= XFSMNT_WSYNC;
82 83
	if (silent)
		args->flags |= XFSMNT_QUIET;
L
Linus Torvalds 已提交
84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122
	args->flags |= XFSMNT_32BITINODES;

	return args;
}

__uint64_t
xfs_max_file_offset(
	unsigned int		blockshift)
{
	unsigned int		pagefactor = 1;
	unsigned int		bitshift = BITS_PER_LONG - 1;

	/* Figure out maximum filesize, on Linux this can depend on
	 * the filesystem blocksize (on 32 bit platforms).
	 * __block_prepare_write does this in an [unsigned] long...
	 *      page->index << (PAGE_CACHE_SHIFT - bbits)
	 * So, for page sized blocks (4K on 32 bit platforms),
	 * this wraps at around 8Tb (hence MAX_LFS_FILESIZE which is
	 *      (((u64)PAGE_CACHE_SIZE << (BITS_PER_LONG-1))-1)
	 * but for smaller blocksizes it is less (bbits = log2 bsize).
	 * Note1: get_block_t takes a long (implicit cast from above)
	 * Note2: The Large Block Device (LBD and HAVE_SECTOR_T) patch
	 * can optionally convert the [unsigned] long from above into
	 * an [unsigned] long long.
	 */

#if BITS_PER_LONG == 32
# if defined(CONFIG_LBD)
	ASSERT(sizeof(sector_t) == 8);
	pagefactor = PAGE_CACHE_SIZE;
	bitshift = BITS_PER_LONG;
# else
	pagefactor = PAGE_CACHE_SIZE >> (PAGE_CACHE_SHIFT - blockshift);
# endif
#endif

	return (((__uint64_t)pagefactor) << bitshift) - 1;
}

123
STATIC_INLINE void
L
Linus Torvalds 已提交
124 125 126
xfs_set_inodeops(
	struct inode		*inode)
{
127 128
	switch (inode->i_mode & S_IFMT) {
	case S_IFREG:
129
		inode->i_op = &xfs_inode_operations;
130
		inode->i_fop = &xfs_file_operations;
131
		inode->i_mapping->a_ops = &xfs_address_space_operations;
132 133
		break;
	case S_IFDIR:
134
		inode->i_op = &xfs_dir_inode_operations;
135
		inode->i_fop = &xfs_dir_file_operations;
136 137
		break;
	case S_IFLNK:
138
		inode->i_op = &xfs_symlink_inode_operations;
L
Linus Torvalds 已提交
139
		if (inode->i_blocks)
140
			inode->i_mapping->a_ops = &xfs_address_space_operations;
141 142
		break;
	default:
143
		inode->i_op = &xfs_inode_operations;
L
Linus Torvalds 已提交
144
		init_special_inode(inode, inode->i_mode, inode->i_rdev);
145
		break;
L
Linus Torvalds 已提交
146 147 148
	}
}

149
STATIC_INLINE void
L
Linus Torvalds 已提交
150 151
xfs_revalidate_inode(
	xfs_mount_t		*mp,
152
	bhv_vnode_t		*vp,
L
Linus Torvalds 已提交
153 154
	xfs_inode_t		*ip)
{
155
	struct inode		*inode = vn_to_inode(vp);
L
Linus Torvalds 已提交
156

157
	inode->i_mode	= ip->i_d.di_mode;
L
Linus Torvalds 已提交
158 159 160
	inode->i_nlink	= ip->i_d.di_nlink;
	inode->i_uid	= ip->i_d.di_uid;
	inode->i_gid	= ip->i_d.di_gid;
161 162 163 164 165 166 167 168 169

	switch (inode->i_mode & S_IFMT) {
	case S_IFBLK:
	case S_IFCHR:
		inode->i_rdev =
			MKDEV(sysv_major(ip->i_df.if_u2.if_rdev) & 0x1ff,
			      sysv_minor(ip->i_df.if_u2.if_rdev));
		break;
	default:
L
Linus Torvalds 已提交
170
		inode->i_rdev = 0;
171
		break;
L
Linus Torvalds 已提交
172
	}
173

L
Linus Torvalds 已提交
174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199
	inode->i_generation = ip->i_d.di_gen;
	i_size_write(inode, ip->i_d.di_size);
	inode->i_blocks =
		XFS_FSB_TO_BB(mp, ip->i_d.di_nblocks + ip->i_delayed_blks);
	inode->i_atime.tv_sec	= ip->i_d.di_atime.t_sec;
	inode->i_atime.tv_nsec	= ip->i_d.di_atime.t_nsec;
	inode->i_mtime.tv_sec	= ip->i_d.di_mtime.t_sec;
	inode->i_mtime.tv_nsec	= ip->i_d.di_mtime.t_nsec;
	inode->i_ctime.tv_sec	= ip->i_d.di_ctime.t_sec;
	inode->i_ctime.tv_nsec	= ip->i_d.di_ctime.t_nsec;
	if (ip->i_d.di_flags & XFS_DIFLAG_IMMUTABLE)
		inode->i_flags |= S_IMMUTABLE;
	else
		inode->i_flags &= ~S_IMMUTABLE;
	if (ip->i_d.di_flags & XFS_DIFLAG_APPEND)
		inode->i_flags |= S_APPEND;
	else
		inode->i_flags &= ~S_APPEND;
	if (ip->i_d.di_flags & XFS_DIFLAG_SYNC)
		inode->i_flags |= S_SYNC;
	else
		inode->i_flags &= ~S_SYNC;
	if (ip->i_d.di_flags & XFS_DIFLAG_NOATIME)
		inode->i_flags |= S_NOATIME;
	else
		inode->i_flags &= ~S_NOATIME;
200
	xfs_iflags_clear(ip, XFS_IMODIFIED);
L
Linus Torvalds 已提交
201 202 203 204 205
}

void
xfs_initialize_vnode(
	bhv_desc_t		*bdp,
206
	bhv_vnode_t		*vp,
207
	struct xfs_inode	*ip,
L
Linus Torvalds 已提交
208 209
	int			unlock)
{
210
	struct inode		*inode = vn_to_inode(vp);
L
Linus Torvalds 已提交
211

212 213 214
	if (!ip->i_vnode) {
		ip->i_vnode = vp;
		inode->i_private = ip;
L
Linus Torvalds 已提交
215 216 217 218 219 220 221 222 223 224 225 226
	}

	/*
	 * We need to set the ops vectors, and unlock the inode, but if
	 * we have been called during the new inode create process, it is
	 * too early to fill in the Linux inode.  We will get called a
	 * second time once the inode is properly set up, and then we can
	 * finish our work.
	 */
	if (ip->i_d.di_mode != 0 && unlock && (inode->i_state & I_NEW)) {
		xfs_revalidate_inode(XFS_BHVTOM(bdp), vp, ip);
		xfs_set_inodeops(inode);
227

228
		xfs_iflags_clear(ip, XFS_INEW);
L
Linus Torvalds 已提交
229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259
		barrier();

		unlock_new_inode(inode);
	}
}

int
xfs_blkdev_get(
	xfs_mount_t		*mp,
	const char		*name,
	struct block_device	**bdevp)
{
	int			error = 0;

	*bdevp = open_bdev_excl(name, 0, mp);
	if (IS_ERR(*bdevp)) {
		error = PTR_ERR(*bdevp);
		printk("XFS: Invalid device [%s], error=%d\n", name, error);
	}

	return -error;
}

void
xfs_blkdev_put(
	struct block_device	*bdev)
{
	if (bdev)
		close_bdev_excl(bdev);
}

260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302
/*
 * Try to write out the superblock using barriers.
 */
STATIC int
xfs_barrier_test(
	xfs_mount_t	*mp)
{
	xfs_buf_t	*sbp = xfs_getsb(mp, 0);
	int		error;

	XFS_BUF_UNDONE(sbp);
	XFS_BUF_UNREAD(sbp);
	XFS_BUF_UNDELAYWRITE(sbp);
	XFS_BUF_WRITE(sbp);
	XFS_BUF_UNASYNC(sbp);
	XFS_BUF_ORDERED(sbp);

	xfsbdstrat(mp, sbp);
	error = xfs_iowait(sbp);

	/*
	 * Clear all the flags we set and possible error state in the
	 * buffer.  We only did the write to try out whether barriers
	 * worked and shouldn't leave any traces in the superblock
	 * buffer.
	 */
	XFS_BUF_DONE(sbp);
	XFS_BUF_ERROR(sbp, 0);
	XFS_BUF_UNORDERED(sbp);

	xfs_buf_relse(sbp);
	return error;
}

void
xfs_mountfs_check_barriers(xfs_mount_t *mp)
{
	int error;

	if (mp->m_logdev_targp != mp->m_ddev_targp) {
		xfs_fs_cmn_err(CE_NOTE, mp,
		  "Disabling barriers, not supported with external log device");
		mp->m_flags &= ~XFS_MOUNT_BARRIER;
303
		return;
304 305
	}

306 307 308 309 310 311 312
	if (xfs_readonly_buftarg(mp->m_ddev_targp)) {
		xfs_fs_cmn_err(CE_NOTE, mp,
		  "Disabling barriers, underlying device is readonly");
		mp->m_flags &= ~XFS_MOUNT_BARRIER;
		return;
	}

313 314 315 316 317
	error = xfs_barrier_test(mp);
	if (error) {
		xfs_fs_cmn_err(CE_NOTE, mp,
		  "Disabling barriers, trial barrier write failed");
		mp->m_flags &= ~XFS_MOUNT_BARRIER;
318
		return;
319 320 321 322 323 324 325
	}
}

void
xfs_blkdev_issue_flush(
	xfs_buftarg_t		*buftarg)
{
326
	blkdev_issue_flush(buftarg->bt_bdev, NULL);
327
}
L
Linus Torvalds 已提交
328 329

STATIC struct inode *
330
xfs_fs_alloc_inode(
L
Linus Torvalds 已提交
331 332
	struct super_block	*sb)
{
333
	bhv_vnode_t		*vp;
L
Linus Torvalds 已提交
334

335 336
	vp = kmem_zone_alloc(xfs_vnode_zone, KM_SLEEP);
	if (unlikely(!vp))
L
Linus Torvalds 已提交
337
		return NULL;
338
	return vn_to_inode(vp);
L
Linus Torvalds 已提交
339 340 341
}

STATIC void
342
xfs_fs_destroy_inode(
L
Linus Torvalds 已提交
343 344
	struct inode		*inode)
{
345
	kmem_zone_free(xfs_vnode_zone, vn_from_inode(inode));
L
Linus Torvalds 已提交
346 347 348
}

STATIC void
349
xfs_fs_inode_init_once(
350 351
	void			*vnode,
	kmem_zone_t		*zonep,
L
Linus Torvalds 已提交
352 353
	unsigned long		flags)
{
C
Christoph Lameter 已提交
354
	inode_init_once(vn_to_inode((bhv_vnode_t *)vnode));
L
Linus Torvalds 已提交
355 356 357
}

STATIC int
358
xfs_init_zones(void)
L
Linus Torvalds 已提交
359
{
360
	xfs_vnode_zone = kmem_zone_init_flags(sizeof(bhv_vnode_t), "xfs_vnode",
361 362
					KM_ZONE_HWALIGN | KM_ZONE_RECLAIM |
					KM_ZONE_SPREAD,
363
					xfs_fs_inode_init_once);
364 365 366 367 368 369 370
	if (!xfs_vnode_zone)
		goto out;

	xfs_ioend_zone = kmem_zone_init(sizeof(xfs_ioend_t), "xfs_ioend");
	if (!xfs_ioend_zone)
		goto out_destroy_vnode_zone;

371 372
	xfs_ioend_pool = mempool_create_slab_pool(4 * MAX_BUF_PER_PAGE,
						  xfs_ioend_zone);
373 374
	if (!xfs_ioend_pool)
		goto out_free_ioend_zone;
L
Linus Torvalds 已提交
375
	return 0;
376 377 378 379 380 381 382

 out_free_ioend_zone:
	kmem_zone_destroy(xfs_ioend_zone);
 out_destroy_vnode_zone:
	kmem_zone_destroy(xfs_vnode_zone);
 out:
	return -ENOMEM;
L
Linus Torvalds 已提交
383 384 385
}

STATIC void
386
xfs_destroy_zones(void)
L
Linus Torvalds 已提交
387
{
388 389 390
	mempool_destroy(xfs_ioend_pool);
	kmem_zone_destroy(xfs_vnode_zone);
	kmem_zone_destroy(xfs_ioend_zone);
L
Linus Torvalds 已提交
391 392 393 394 395 396
}

/*
 * Attempt to flush the inode, this will actually fail
 * if the inode is pinned, but we dirty the inode again
 * at the point when it is unpinned after a log write,
397
 * since this is when the inode itself becomes flushable.
L
Linus Torvalds 已提交
398 399
 */
STATIC int
400
xfs_fs_write_inode(
L
Linus Torvalds 已提交
401 402 403 404 405
	struct inode		*inode,
	int			sync)
{
	int			error = 0, flags = FLUSH_INODE;

406 407 408 409 410 411 412 413 414 415 416 417 418
	vn_trace_entry(vn_from_inode(inode), __FUNCTION__,
			(inst_t *)__return_address);
	if (sync) {
		filemap_fdatawait(inode->i_mapping);
		flags |= FLUSH_SYNC;
	}
	error = xfs_inode_flush(XFS_I(inode), flags);
	if (error == EAGAIN) {
		if (sync)
			error = xfs_inode_flush(XFS_I(inode),
						       flags | FLUSH_LOG);
		else
			error = 0;
L
Linus Torvalds 已提交
419
	}
420

L
Linus Torvalds 已提交
421 422 423 424
	return -error;
}

STATIC void
425
xfs_fs_clear_inode(
L
Linus Torvalds 已提交
426 427
	struct inode		*inode)
{
428
	bhv_vnode_t		*vp = vn_from_inode(inode);
L
Linus Torvalds 已提交
429

430
	vn_trace_entry(vp, __FUNCTION__, (inst_t *)__return_address);
431 432 433 434 435 436

	XFS_STATS_INC(vn_rele);
	XFS_STATS_INC(vn_remove);
	XFS_STATS_INC(vn_reclaim);
	XFS_STATS_DEC(vn_active);

437 438 439 440
	/*
	 * This can happen because xfs_iget_core calls xfs_idestroy if we
	 * find an inode with di_mode == 0 but without IGET_CREATE set.
	 */
441 442
	if (XFS_I(inode))
		xfs_inactive(XFS_I(inode));
L
Linus Torvalds 已提交
443

444

445 446
	if (XFS_I(inode)) {
		xfs_iflags_clear(XFS_I(inode), XFS_IMODIFIED);
447
		if (xfs_reclaim(XFS_I(inode)))
448
			panic("%s: cannot reclaim 0x%p\n", __FUNCTION__, vp);
449
	}
450

451
	ASSERT(XFS_I(inode) == NULL);
452 453 454 455 456

#ifdef XFS_VNODE_TRACE
	ktrace_free(vp->v_trace);
#endif
}
L
Linus Torvalds 已提交
457 458 459 460 461 462 463 464 465 466

/*
 * Enqueue a work item to be picked up by the vfs xfssyncd thread.
 * Doing this has two advantages:
 * - It saves on stack space, which is tight in certain situations
 * - It can be used (with care) as a mechanism to avoid deadlocks.
 * Flushing while allocating in a full filesystem requires both.
 */
STATIC void
xfs_syncd_queue_work(
467
	struct bhv_vfs	*vfs,
L
Linus Torvalds 已提交
468
	void		*data,
469
	void		(*syncer)(bhv_vfs_t *, void *))
L
Linus Torvalds 已提交
470
{
471
	struct bhv_vfs_sync_work *work;
L
Linus Torvalds 已提交
472

473
	work = kmem_alloc(sizeof(struct bhv_vfs_sync_work), KM_SLEEP);
L
Linus Torvalds 已提交
474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491
	INIT_LIST_HEAD(&work->w_list);
	work->w_syncer = syncer;
	work->w_data = data;
	work->w_vfs = vfs;
	spin_lock(&vfs->vfs_sync_lock);
	list_add_tail(&work->w_list, &vfs->vfs_sync_list);
	spin_unlock(&vfs->vfs_sync_lock);
	wake_up_process(vfs->vfs_sync_task);
}

/*
 * Flush delayed allocate data, attempting to free up reserved space
 * from existing allocations.  At this point a new allocation attempt
 * has failed with ENOSPC and we are in the process of scratching our
 * heads, looking about for more room...
 */
STATIC void
xfs_flush_inode_work(
492
	bhv_vfs_t	*vfs,
L
Linus Torvalds 已提交
493 494 495 496 497 498 499 500 501 502
	void		*inode)
{
	filemap_flush(((struct inode *)inode)->i_mapping);
	iput((struct inode *)inode);
}

void
xfs_flush_inode(
	xfs_inode_t	*ip)
{
503
	struct inode	*inode = vn_to_inode(XFS_ITOV(ip));
504
	struct bhv_vfs	*vfs = XFS_MTOVFS(ip->i_mount);
L
Linus Torvalds 已提交
505 506 507

	igrab(inode);
	xfs_syncd_queue_work(vfs, inode, xfs_flush_inode_work);
508
	delay(msecs_to_jiffies(500));
L
Linus Torvalds 已提交
509 510 511 512 513 514 515 516
}

/*
 * This is the "bigger hammer" version of xfs_flush_inode_work...
 * (IOW, "If at first you don't succeed, use a Bigger Hammer").
 */
STATIC void
xfs_flush_device_work(
517
	bhv_vfs_t	*vfs,
L
Linus Torvalds 已提交
518 519 520 521 522 523 524 525 526 527
	void		*inode)
{
	sync_blockdev(vfs->vfs_super->s_bdev);
	iput((struct inode *)inode);
}

void
xfs_flush_device(
	xfs_inode_t	*ip)
{
528
	struct inode	*inode = vn_to_inode(XFS_ITOV(ip));
529
	struct bhv_vfs	*vfs = XFS_MTOVFS(ip->i_mount);
L
Linus Torvalds 已提交
530 531 532

	igrab(inode);
	xfs_syncd_queue_work(vfs, inode, xfs_flush_device_work);
533
	delay(msecs_to_jiffies(500));
L
Linus Torvalds 已提交
534 535 536 537 538
	xfs_log_force(ip->i_mount, (xfs_lsn_t)0, XFS_LOG_FORCE|XFS_LOG_SYNC);
}

STATIC void
vfs_sync_worker(
539
	bhv_vfs_t	*vfsp,
L
Linus Torvalds 已提交
540 541 542 543 544
	void		*unused)
{
	int		error;

	if (!(vfsp->vfs_flag & VFS_RDONLY))
545
		error = bhv_vfs_sync(vfsp, SYNC_FSDATA | SYNC_BDFLUSH | \
D
David Chinner 已提交
546 547
					SYNC_ATTR | SYNC_REFCACHE | SYNC_SUPER,
					NULL);
L
Linus Torvalds 已提交
548 549 550 551 552 553 554 555 556
	vfsp->vfs_sync_seq++;
	wake_up(&vfsp->vfs_wait_single_sync_task);
}

STATIC int
xfssyncd(
	void			*arg)
{
	long			timeleft;
557 558
	bhv_vfs_t		*vfsp = (bhv_vfs_t *) arg;
	bhv_vfs_sync_work_t	*work, *n;
559
	LIST_HEAD		(tmp);
L
Linus Torvalds 已提交
560

561
	set_freezable();
562
	timeleft = xfs_syncd_centisecs * msecs_to_jiffies(10);
L
Linus Torvalds 已提交
563
	for (;;) {
564
		timeleft = schedule_timeout_interruptible(timeleft);
L
Linus Torvalds 已提交
565
		/* swsusp */
566
		try_to_freeze();
567
		if (kthread_should_stop() && list_empty(&vfsp->vfs_sync_list))
L
Linus Torvalds 已提交
568 569 570 571 572 573 574 575 576 577
			break;

		spin_lock(&vfsp->vfs_sync_lock);
		/*
		 * We can get woken by laptop mode, to do a sync -
		 * that's the (only!) case where the list would be
		 * empty with time remaining.
		 */
		if (!timeleft || list_empty(&vfsp->vfs_sync_list)) {
			if (!timeleft)
578 579
				timeleft = xfs_syncd_centisecs *
							msecs_to_jiffies(10);
L
Linus Torvalds 已提交
580 581 582 583 584 585 586 587 588 589 590 591 592
			INIT_LIST_HEAD(&vfsp->vfs_sync_work.w_list);
			list_add_tail(&vfsp->vfs_sync_work.w_list,
					&vfsp->vfs_sync_list);
		}
		list_for_each_entry_safe(work, n, &vfsp->vfs_sync_list, w_list)
			list_move(&work->w_list, &tmp);
		spin_unlock(&vfsp->vfs_sync_lock);

		list_for_each_entry_safe(work, n, &tmp, w_list) {
			(*work->w_syncer)(vfsp, work->w_data);
			list_del(&work->w_list);
			if (work == &vfsp->vfs_sync_work)
				continue;
593
			kmem_free(work, sizeof(struct bhv_vfs_sync_work));
L
Linus Torvalds 已提交
594 595 596 597 598 599 600
		}
	}

	return 0;
}

STATIC int
601
xfs_fs_start_syncd(
602
	bhv_vfs_t		*vfsp)
L
Linus Torvalds 已提交
603
{
604 605 606 607 608
	vfsp->vfs_sync_work.w_syncer = vfs_sync_worker;
	vfsp->vfs_sync_work.w_vfs = vfsp;
	vfsp->vfs_sync_task = kthread_run(xfssyncd, vfsp, "xfssyncd");
	if (IS_ERR(vfsp->vfs_sync_task))
		return -PTR_ERR(vfsp->vfs_sync_task);
L
Linus Torvalds 已提交
609 610 611 612
	return 0;
}

STATIC void
613
xfs_fs_stop_syncd(
614
	bhv_vfs_t		*vfsp)
L
Linus Torvalds 已提交
615
{
616
	kthread_stop(vfsp->vfs_sync_task);
L
Linus Torvalds 已提交
617 618 619
}

STATIC void
620
xfs_fs_put_super(
L
Linus Torvalds 已提交
621 622
	struct super_block	*sb)
{
623
	bhv_vfs_t		*vfsp = vfs_from_sb(sb);
L
Linus Torvalds 已提交
624 625
	int			error;

626
	xfs_fs_stop_syncd(vfsp);
627 628
	bhv_vfs_sync(vfsp, SYNC_ATTR | SYNC_DELWRI, NULL);
	error = bhv_vfs_unmount(vfsp, 0, NULL);
L
Linus Torvalds 已提交
629
	if (error) {
630 631 632 633
		printk("XFS: unmount got error=%d\n", error);
		printk("%s: vfs=0x%p left dangling!\n", __FUNCTION__, vfsp);
	} else {
		vfs_deallocate(vfsp);
L
Linus Torvalds 已提交
634 635 636 637
	}
}

STATIC void
638
xfs_fs_write_super(
L
Linus Torvalds 已提交
639 640
	struct super_block	*sb)
{
641 642
	if (!(sb->s_flags & MS_RDONLY))
		bhv_vfs_sync(vfs_from_sb(sb), SYNC_FSDATA, NULL);
L
Linus Torvalds 已提交
643 644 645 646
	sb->s_dirt = 0;
}

STATIC int
647
xfs_fs_sync_super(
L
Linus Torvalds 已提交
648 649 650
	struct super_block	*sb,
	int			wait)
{
651 652 653
	bhv_vfs_t		*vfsp = vfs_from_sb(sb);
	int			error;
	int			flags;
L
Linus Torvalds 已提交
654

655 656 657 658 659 660 661 662 663
	if (unlikely(sb->s_frozen == SB_FREEZE_WRITE)) {
		/*
		 * First stage of freeze - no more writers will make progress
		 * now we are here, so we flush delwri and delalloc buffers
		 * here, then wait for all I/O to complete.  Data is frozen at
		 * that point. Metadata is not frozen, transactions can still
		 * occur here so don't bother flushing the buftarg (i.e
		 * SYNC_QUIESCE) because it'll just get dirty again.
		 */
664
		flags = SYNC_DATA_QUIESCE;
665
	} else
666
		flags = SYNC_FSDATA | (wait ? SYNC_WAIT : 0);
L
Linus Torvalds 已提交
667

668
	error = bhv_vfs_sync(vfsp, flags, NULL);
L
Linus Torvalds 已提交
669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693
	sb->s_dirt = 0;

	if (unlikely(laptop_mode)) {
		int	prev_sync_seq = vfsp->vfs_sync_seq;

		/*
		 * The disk must be active because we're syncing.
		 * We schedule xfssyncd now (now that the disk is
		 * active) instead of later (when it might not be).
		 */
		wake_up_process(vfsp->vfs_sync_task);
		/*
		 * We have to wait for the sync iteration to complete.
		 * If we don't, the disk activity caused by the sync
		 * will come after the sync is completed, and that
		 * triggers another sync from laptop mode.
		 */
		wait_event(vfsp->vfs_wait_single_sync_task,
				vfsp->vfs_sync_seq != prev_sync_seq);
	}

	return -error;
}

STATIC int
694
xfs_fs_statfs(
695
	struct dentry		*dentry,
L
Linus Torvalds 已提交
696 697
	struct kstatfs		*statp)
{
698 699
	return -bhv_vfs_statvfs(vfs_from_sb(dentry->d_sb), statp,
				vn_from_inode(dentry->d_inode));
L
Linus Torvalds 已提交
700 701 702
}

STATIC int
703
xfs_fs_remount(
L
Linus Torvalds 已提交
704 705 706 707
	struct super_block	*sb,
	int			*flags,
	char			*options)
{
708
	bhv_vfs_t		*vfsp = vfs_from_sb(sb);
709
	struct xfs_mount_args	*args = xfs_args_allocate(sb, 0);
L
Linus Torvalds 已提交
710 711
	int			error;

712
	error = bhv_vfs_parseargs(vfsp, options, args, 1);
L
Linus Torvalds 已提交
713
	if (!error)
714
		error = bhv_vfs_mntupdate(vfsp, flags, args);
L
Linus Torvalds 已提交
715 716 717 718 719
	kmem_free(args, sizeof(*args));
	return -error;
}

STATIC void
720
xfs_fs_lockfs(
L
Linus Torvalds 已提交
721 722
	struct super_block	*sb)
{
723
	bhv_vfs_freeze(vfs_from_sb(sb));
L
Linus Torvalds 已提交
724 725 726
}

STATIC int
727
xfs_fs_show_options(
L
Linus Torvalds 已提交
728 729 730
	struct seq_file		*m,
	struct vfsmount		*mnt)
{
731
	return -bhv_vfs_showargs(vfs_from_sb(mnt->mnt_sb), m);
L
Linus Torvalds 已提交
732 733
}

734
STATIC int
735
xfs_fs_quotasync(
736 737 738
	struct super_block	*sb,
	int			type)
{
739
	return -bhv_vfs_quotactl(vfs_from_sb(sb), Q_XQUOTASYNC, 0, NULL);
740 741
}

L
Linus Torvalds 已提交
742
STATIC int
743
xfs_fs_getxstate(
L
Linus Torvalds 已提交
744 745 746
	struct super_block	*sb,
	struct fs_quota_stat	*fqs)
{
747
	return -bhv_vfs_quotactl(vfs_from_sb(sb), Q_XGETQSTAT, 0, (caddr_t)fqs);
L
Linus Torvalds 已提交
748 749 750
}

STATIC int
751
xfs_fs_setxstate(
L
Linus Torvalds 已提交
752 753 754 755
	struct super_block	*sb,
	unsigned int		flags,
	int			op)
{
756
	return -bhv_vfs_quotactl(vfs_from_sb(sb), op, 0, (caddr_t)&flags);
L
Linus Torvalds 已提交
757 758 759
}

STATIC int
760
xfs_fs_getxquota(
L
Linus Torvalds 已提交
761 762 763 764 765
	struct super_block	*sb,
	int			type,
	qid_t			id,
	struct fs_disk_quota	*fdq)
{
766 767 768 769
	return -bhv_vfs_quotactl(vfs_from_sb(sb),
				 (type == USRQUOTA) ? Q_XGETQUOTA :
				  ((type == GRPQUOTA) ? Q_XGETGQUOTA :
				   Q_XGETPQUOTA), id, (caddr_t)fdq);
L
Linus Torvalds 已提交
770 771 772
}

STATIC int
773
xfs_fs_setxquota(
L
Linus Torvalds 已提交
774 775 776 777 778
	struct super_block	*sb,
	int			type,
	qid_t			id,
	struct fs_disk_quota	*fdq)
{
779 780 781 782
	return -bhv_vfs_quotactl(vfs_from_sb(sb),
				 (type == USRQUOTA) ? Q_XSETQLIM :
				  ((type == GRPQUOTA) ? Q_XSETGQLIM :
				   Q_XSETPQLIM), id, (caddr_t)fdq);
L
Linus Torvalds 已提交
783 784 785
}

STATIC int
786
xfs_fs_fill_super(
L
Linus Torvalds 已提交
787 788 789 790
	struct super_block	*sb,
	void			*data,
	int			silent)
{
791
	struct bhv_vnode	*rootvp;
792
	struct bhv_vfs		*vfsp = vfs_allocate(sb);
793
	struct xfs_mount_args	*args = xfs_args_allocate(sb, silent);
L
Linus Torvalds 已提交
794
	struct kstatfs		statvfs;
795
	int			error;
L
Linus Torvalds 已提交
796 797 798

	bhv_insert_all_vfsops(vfsp);

799
	error = bhv_vfs_parseargs(vfsp, (char *)data, args, 0);
L
Linus Torvalds 已提交
800 801 802 803 804 805
	if (error) {
		bhv_remove_all_vfsops(vfsp, 1);
		goto fail_vfsop;
	}

	sb_min_blocksize(sb, BBSIZE);
806 807 808
	sb->s_export_op = &xfs_export_operations;
	sb->s_qcop = &xfs_quotactl_operations;
	sb->s_op = &xfs_super_operations;
L
Linus Torvalds 已提交
809

810
	error = bhv_vfs_mount(vfsp, args, NULL);
L
Linus Torvalds 已提交
811 812 813 814 815
	if (error) {
		bhv_remove_all_vfsops(vfsp, 1);
		goto fail_vfsop;
	}

816
	error = bhv_vfs_statvfs(vfsp, &statvfs, NULL);
L
Linus Torvalds 已提交
817 818 819 820 821 822 823 824 825 826 827
	if (error)
		goto fail_unmount;

	sb->s_dirt = 1;
	sb->s_magic = statvfs.f_type;
	sb->s_blocksize = statvfs.f_bsize;
	sb->s_blocksize_bits = ffs(statvfs.f_bsize) - 1;
	sb->s_maxbytes = xfs_max_file_offset(sb->s_blocksize_bits);
	sb->s_time_gran = 1;
	set_posix_acl_flag(sb);

828
	error = bhv_vfs_root(vfsp, &rootvp);
L
Linus Torvalds 已提交
829 830 831
	if (error)
		goto fail_unmount;

832
	sb->s_root = d_alloc_root(vn_to_inode(rootvp));
L
Linus Torvalds 已提交
833 834 835 836 837 838 839 840
	if (!sb->s_root) {
		error = ENOMEM;
		goto fail_vnrele;
	}
	if (is_bad_inode(sb->s_root->d_inode)) {
		error = EINVAL;
		goto fail_vnrele;
	}
841
	if ((error = xfs_fs_start_syncd(vfsp)))
L
Linus Torvalds 已提交
842 843 844 845 846 847 848 849 850 851 852 853 854 855 856
		goto fail_vnrele;
	vn_trace_exit(rootvp, __FUNCTION__, (inst_t *)__return_address);

	kmem_free(args, sizeof(*args));
	return 0;

fail_vnrele:
	if (sb->s_root) {
		dput(sb->s_root);
		sb->s_root = NULL;
	} else {
		VN_RELE(rootvp);
	}

fail_unmount:
857
	bhv_vfs_unmount(vfsp, 0, NULL);
L
Linus Torvalds 已提交
858 859 860 861 862 863 864

fail_vfsop:
	vfs_deallocate(vfsp);
	kmem_free(args, sizeof(*args));
	return -error;
}

865
STATIC int
866
xfs_fs_get_sb(
L
Linus Torvalds 已提交
867 868 869
	struct file_system_type	*fs_type,
	int			flags,
	const char		*dev_name,
870 871
	void			*data,
	struct vfsmount		*mnt)
L
Linus Torvalds 已提交
872
{
873 874
	return get_sb_bdev(fs_type, flags, dev_name, data, xfs_fs_fill_super,
			   mnt);
875 876
}

877
static struct super_operations xfs_super_operations = {
878 879 880 881 882 883 884 885 886 887 888
	.alloc_inode		= xfs_fs_alloc_inode,
	.destroy_inode		= xfs_fs_destroy_inode,
	.write_inode		= xfs_fs_write_inode,
	.clear_inode		= xfs_fs_clear_inode,
	.put_super		= xfs_fs_put_super,
	.write_super		= xfs_fs_write_super,
	.sync_fs		= xfs_fs_sync_super,
	.write_super_lockfs	= xfs_fs_lockfs,
	.statfs			= xfs_fs_statfs,
	.remount_fs		= xfs_fs_remount,
	.show_options		= xfs_fs_show_options,
L
Linus Torvalds 已提交
889 890
};

891
static struct quotactl_ops xfs_quotactl_operations = {
892 893 894 895 896
	.quota_sync		= xfs_fs_quotasync,
	.get_xstate		= xfs_fs_getxstate,
	.set_xstate		= xfs_fs_setxstate,
	.get_xquota		= xfs_fs_getxquota,
	.set_xquota		= xfs_fs_setxquota,
L
Linus Torvalds 已提交
897 898
};

A
Andrew Morton 已提交
899
static struct file_system_type xfs_fs_type = {
L
Linus Torvalds 已提交
900 901
	.owner			= THIS_MODULE,
	.name			= "xfs",
902
	.get_sb			= xfs_fs_get_sb,
L
Linus Torvalds 已提交
903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918
	.kill_sb		= kill_block_super,
	.fs_flags		= FS_REQUIRES_DEV,
};


STATIC int __init
init_xfs_fs( void )
{
	int			error;
	static char		message[] __initdata = KERN_INFO \
		XFS_VERSION_STRING " with " XFS_BUILD_OPTIONS " enabled\n";

	printk(message);

	ktrace_init(64);

919
	error = xfs_init_zones();
L
Linus Torvalds 已提交
920
	if (error < 0)
921
		goto undo_zones;
L
Linus Torvalds 已提交
922

923
	error = xfs_buf_init();
L
Linus Torvalds 已提交
924
	if (error < 0)
925
		goto undo_buffers;
L
Linus Torvalds 已提交
926 927 928 929 930 931 932 933 934 935 936 937

	vn_init();
	xfs_init();
	uuid_init();
	vfs_initquota();

	error = register_filesystem(&xfs_fs_type);
	if (error)
		goto undo_register;
	return 0;

undo_register:
938
	xfs_buf_terminate();
L
Linus Torvalds 已提交
939

940
undo_buffers:
941
	xfs_destroy_zones();
L
Linus Torvalds 已提交
942

943
undo_zones:
L
Linus Torvalds 已提交
944 945 946 947 948 949 950 951 952
	return error;
}

STATIC void __exit
exit_xfs_fs( void )
{
	vfs_exitquota();
	unregister_filesystem(&xfs_fs_type);
	xfs_cleanup();
953
	xfs_buf_terminate();
954
	xfs_destroy_zones();
L
Linus Torvalds 已提交
955 956 957 958 959 960 961 962 963
	ktrace_uninit();
}

module_init(init_xfs_fs);
module_exit(exit_xfs_fs);

MODULE_AUTHOR("Silicon Graphics, Inc.");
MODULE_DESCRIPTION(XFS_VERSION_STRING " with " XFS_BUILD_OPTIONS " enabled");
MODULE_LICENSE("GPL");