xfs_super.c 21.3 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"
50
#include "xfs_vfsops.h"
L
Linus Torvalds 已提交
51 52 53 54 55
#include "xfs_version.h"

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

61 62 63 64
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;
65
mempool_t *xfs_ioend_pool;
L
Linus Torvalds 已提交
66 67 68

STATIC struct xfs_mount_args *
xfs_args_allocate(
69 70
	struct super_block	*sb,
	int			silent)
L
Linus Torvalds 已提交
71 72 73 74 75 76 77 78 79 80 81 82
{
	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;
83 84
	if (silent)
		args->flags |= XFSMNT_QUIET;
L
Linus Torvalds 已提交
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 123
	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;
}

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

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

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

	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 已提交
171
		inode->i_rdev = 0;
172
		break;
L
Linus Torvalds 已提交
173
	}
174

L
Linus Torvalds 已提交
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 200
	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;
201
	xfs_iflags_clear(ip, XFS_IMODIFIED);
L
Linus Torvalds 已提交
202 203 204 205
}

void
xfs_initialize_vnode(
206
	struct xfs_mount	*mp,
207
	bhv_vnode_t		*vp,
208
	struct xfs_inode	*ip)
L
Linus Torvalds 已提交
209
{
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
	}

	/*
	 * 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.
	 */
224
	if (ip->i_d.di_mode != 0 && (inode->i_state & I_NEW)) {
225
		xfs_revalidate_inode(mp, vp, ip);
L
Linus Torvalds 已提交
226
		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
	vn_trace_entry(XFS_I(inode), __FUNCTION__,
407 408 409 410 411 412 413 414 415 416 417 418
			(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
	xfs_inode_t		*ip = XFS_I(inode);
429

430
	/*
431
	 * ip can be null when xfs_iget_core calls xfs_idestroy if we
432 433
	 * find an inode with di_mode == 0 but without IGET_CREATE set.
	 */
434 435 436 437 438 439 440 441 442 443 444 445
	if (ip) {
		vn_trace_entry(ip, __FUNCTION__, (inst_t *)__return_address);

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

		xfs_inactive(ip);
		xfs_iflags_clear(ip, XFS_IMODIFIED);
		if (xfs_reclaim(ip))
			panic("%s: cannot reclaim 0x%p\n", __FUNCTION__, inode);
446
	}
447

448
	ASSERT(XFS_I(inode) == NULL);
449
}
L
Linus Torvalds 已提交
450 451 452 453 454 455 456 457 458 459

/*
 * 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(
460
	struct xfs_mount *mp,
L
Linus Torvalds 已提交
461
	void		*data,
462
	void		(*syncer)(struct xfs_mount *, void *))
L
Linus Torvalds 已提交
463
{
464
	struct bhv_vfs_sync_work *work;
L
Linus Torvalds 已提交
465

466
	work = kmem_alloc(sizeof(struct bhv_vfs_sync_work), KM_SLEEP);
L
Linus Torvalds 已提交
467 468 469
	INIT_LIST_HEAD(&work->w_list);
	work->w_syncer = syncer;
	work->w_data = data;
470 471 472 473 474
	work->w_mount = mp;
	spin_lock(&mp->m_sync_lock);
	list_add_tail(&work->w_list, &mp->m_sync_list);
	spin_unlock(&mp->m_sync_lock);
	wake_up_process(mp->m_sync_task);
L
Linus Torvalds 已提交
475 476 477 478 479 480 481 482 483 484
}

/*
 * 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(
485 486
	struct xfs_mount *mp,
	void		*arg)
L
Linus Torvalds 已提交
487
{
488 489 490
	struct inode	*inode = arg;
	filemap_flush(inode->i_mapping);
	iput(inode);
L
Linus Torvalds 已提交
491 492 493 494 495 496
}

void
xfs_flush_inode(
	xfs_inode_t	*ip)
{
497
	struct inode	*inode = ip->i_vnode;
L
Linus Torvalds 已提交
498 499

	igrab(inode);
500
	xfs_syncd_queue_work(ip->i_mount, inode, xfs_flush_inode_work);
501
	delay(msecs_to_jiffies(500));
L
Linus Torvalds 已提交
502 503 504 505 506 507 508 509
}

/*
 * 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(
510 511
	struct xfs_mount *mp,
	void		*arg)
L
Linus Torvalds 已提交
512
{
513 514 515
	struct inode	*inode = arg;
	sync_blockdev(mp->m_vfsp->vfs_super->s_bdev);
	iput(inode);
L
Linus Torvalds 已提交
516 517 518 519 520 521
}

void
xfs_flush_device(
	xfs_inode_t	*ip)
{
522
	struct inode	*inode = vn_to_inode(XFS_ITOV(ip));
L
Linus Torvalds 已提交
523 524

	igrab(inode);
525
	xfs_syncd_queue_work(ip->i_mount, inode, xfs_flush_device_work);
526
	delay(msecs_to_jiffies(500));
L
Linus Torvalds 已提交
527 528 529 530
	xfs_log_force(ip->i_mount, (xfs_lsn_t)0, XFS_LOG_FORCE|XFS_LOG_SYNC);
}

STATIC void
531 532
xfs_sync_worker(
	struct xfs_mount *mp,
L
Linus Torvalds 已提交
533 534 535 536
	void		*unused)
{
	int		error;

537 538 539 540 541
	if (!(mp->m_flags & XFS_MOUNT_RDONLY))
		error = xfs_sync(mp, SYNC_FSDATA | SYNC_BDFLUSH | SYNC_ATTR |
				     SYNC_REFCACHE | SYNC_SUPER);
	mp->m_sync_seq++;
	wake_up(&mp->m_wait_single_sync_task);
L
Linus Torvalds 已提交
542 543 544 545 546 547
}

STATIC int
xfssyncd(
	void			*arg)
{
548
	struct xfs_mount	*mp = arg;
L
Linus Torvalds 已提交
549
	long			timeleft;
550
	bhv_vfs_sync_work_t	*work, *n;
551
	LIST_HEAD		(tmp);
L
Linus Torvalds 已提交
552

553
	set_freezable();
554
	timeleft = xfs_syncd_centisecs * msecs_to_jiffies(10);
L
Linus Torvalds 已提交
555
	for (;;) {
556
		timeleft = schedule_timeout_interruptible(timeleft);
L
Linus Torvalds 已提交
557
		/* swsusp */
558
		try_to_freeze();
559
		if (kthread_should_stop() && list_empty(&mp->m_sync_list))
L
Linus Torvalds 已提交
560 561
			break;

562
		spin_lock(&mp->m_sync_lock);
L
Linus Torvalds 已提交
563 564 565 566 567
		/*
		 * 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.
		 */
568
		if (!timeleft || list_empty(&mp->m_sync_list)) {
L
Linus Torvalds 已提交
569
			if (!timeleft)
570 571
				timeleft = xfs_syncd_centisecs *
							msecs_to_jiffies(10);
572 573 574
			INIT_LIST_HEAD(&mp->m_sync_work.w_list);
			list_add_tail(&mp->m_sync_work.w_list,
					&mp->m_sync_list);
L
Linus Torvalds 已提交
575
		}
576
		list_for_each_entry_safe(work, n, &mp->m_sync_list, w_list)
L
Linus Torvalds 已提交
577
			list_move(&work->w_list, &tmp);
578
		spin_unlock(&mp->m_sync_lock);
L
Linus Torvalds 已提交
579 580

		list_for_each_entry_safe(work, n, &tmp, w_list) {
581
			(*work->w_syncer)(mp, work->w_data);
L
Linus Torvalds 已提交
582
			list_del(&work->w_list);
583
			if (work == &mp->m_sync_work)
L
Linus Torvalds 已提交
584
				continue;
585
			kmem_free(work, sizeof(struct bhv_vfs_sync_work));
L
Linus Torvalds 已提交
586 587 588 589 590 591 592
		}
	}

	return 0;
}

STATIC void
593
xfs_fs_put_super(
L
Linus Torvalds 已提交
594 595
	struct super_block	*sb)
{
596
	bhv_vfs_t		*vfsp = vfs_from_sb(sb);
597
	struct xfs_mount	*mp = XFS_M(sb);
L
Linus Torvalds 已提交
598 599
	int			error;

600 601
	kthread_stop(mp->m_sync_task);

602 603
	xfs_sync(mp, SYNC_ATTR | SYNC_DELWRI);
	error = xfs_unmount(mp, 0, NULL);
L
Linus Torvalds 已提交
604
	if (error) {
605 606 607 608
		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 已提交
609 610 611 612
	}
}

STATIC void
613
xfs_fs_write_super(
L
Linus Torvalds 已提交
614 615
	struct super_block	*sb)
{
616
	if (!(sb->s_flags & MS_RDONLY))
617
		xfs_sync(XFS_M(sb), SYNC_FSDATA);
L
Linus Torvalds 已提交
618 619 620 621
	sb->s_dirt = 0;
}

STATIC int
622
xfs_fs_sync_super(
L
Linus Torvalds 已提交
623 624 625
	struct super_block	*sb,
	int			wait)
{
626
	struct xfs_mount	*mp = XFS_M(sb);
627 628
	int			error;
	int			flags;
L
Linus Torvalds 已提交
629

630 631 632 633 634 635 636 637 638
	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.
		 */
639
		flags = SYNC_DATA_QUIESCE;
640
	} else
641
		flags = SYNC_FSDATA | (wait ? SYNC_WAIT : 0);
L
Linus Torvalds 已提交
642

643
	error = xfs_sync(mp, flags);
L
Linus Torvalds 已提交
644 645 646
	sb->s_dirt = 0;

	if (unlikely(laptop_mode)) {
647
		int	prev_sync_seq = mp->m_sync_seq;
L
Linus Torvalds 已提交
648 649 650 651 652 653

		/*
		 * 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).
		 */
654
		wake_up_process(mp->m_sync_task);
L
Linus Torvalds 已提交
655 656 657 658 659 660
		/*
		 * 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.
		 */
661 662
		wait_event(mp->m_wait_single_sync_task,
				mp->m_sync_seq != prev_sync_seq);
L
Linus Torvalds 已提交
663 664 665 666 667 668
	}

	return -error;
}

STATIC int
669
xfs_fs_statfs(
670
	struct dentry		*dentry,
L
Linus Torvalds 已提交
671 672
	struct kstatfs		*statp)
{
673
	return -xfs_statvfs(XFS_M(dentry->d_sb), statp,
674
				vn_from_inode(dentry->d_inode));
L
Linus Torvalds 已提交
675 676 677
}

STATIC int
678
xfs_fs_remount(
L
Linus Torvalds 已提交
679 680 681 682
	struct super_block	*sb,
	int			*flags,
	char			*options)
{
683
	struct xfs_mount	*mp = XFS_M(sb);
684
	struct xfs_mount_args	*args = xfs_args_allocate(sb, 0);
L
Linus Torvalds 已提交
685 686
	int			error;

687
	error = xfs_parseargs(mp, options, args, 1);
L
Linus Torvalds 已提交
688
	if (!error)
689
		error = xfs_mntupdate(mp, flags, args);
L
Linus Torvalds 已提交
690 691 692 693 694
	kmem_free(args, sizeof(*args));
	return -error;
}

STATIC void
695
xfs_fs_lockfs(
L
Linus Torvalds 已提交
696 697
	struct super_block	*sb)
{
698
	xfs_freeze(XFS_M(sb));
L
Linus Torvalds 已提交
699 700 701
}

STATIC int
702
xfs_fs_show_options(
L
Linus Torvalds 已提交
703 704 705
	struct seq_file		*m,
	struct vfsmount		*mnt)
{
706
	return -xfs_showargs(XFS_M(mnt->mnt_sb), m);
L
Linus Torvalds 已提交
707 708
}

709
STATIC int
710
xfs_fs_quotasync(
711 712 713
	struct super_block	*sb,
	int			type)
{
714
	return -XFS_QM_QUOTACTL(XFS_M(sb), Q_XQUOTASYNC, 0, NULL);
715 716
}

L
Linus Torvalds 已提交
717
STATIC int
718
xfs_fs_getxstate(
L
Linus Torvalds 已提交
719 720 721
	struct super_block	*sb,
	struct fs_quota_stat	*fqs)
{
722
	return -XFS_QM_QUOTACTL(XFS_M(sb), Q_XGETQSTAT, 0, (caddr_t)fqs);
L
Linus Torvalds 已提交
723 724 725
}

STATIC int
726
xfs_fs_setxstate(
L
Linus Torvalds 已提交
727 728 729 730
	struct super_block	*sb,
	unsigned int		flags,
	int			op)
{
731
	return -XFS_QM_QUOTACTL(XFS_M(sb), op, 0, (caddr_t)&flags);
L
Linus Torvalds 已提交
732 733 734
}

STATIC int
735
xfs_fs_getxquota(
L
Linus Torvalds 已提交
736 737 738 739 740
	struct super_block	*sb,
	int			type,
	qid_t			id,
	struct fs_disk_quota	*fdq)
{
741
	return -XFS_QM_QUOTACTL(XFS_M(sb),
742 743 744
				 (type == USRQUOTA) ? Q_XGETQUOTA :
				  ((type == GRPQUOTA) ? Q_XGETGQUOTA :
				   Q_XGETPQUOTA), id, (caddr_t)fdq);
L
Linus Torvalds 已提交
745 746 747
}

STATIC int
748
xfs_fs_setxquota(
L
Linus Torvalds 已提交
749 750 751 752 753
	struct super_block	*sb,
	int			type,
	qid_t			id,
	struct fs_disk_quota	*fdq)
{
754
	return -XFS_QM_QUOTACTL(XFS_M(sb),
755 756 757
				 (type == USRQUOTA) ? Q_XSETQLIM :
				  ((type == GRPQUOTA) ? Q_XSETGQLIM :
				   Q_XSETPQLIM), id, (caddr_t)fdq);
L
Linus Torvalds 已提交
758 759 760
}

STATIC int
761
xfs_fs_fill_super(
L
Linus Torvalds 已提交
762 763 764 765
	struct super_block	*sb,
	void			*data,
	int			silent)
{
C
Christoph Hellwig 已提交
766
	struct inode		*rootvp;
767
	struct bhv_vfs		*vfsp = vfs_allocate(sb);
768
	struct xfs_mount	*mp = NULL;
769
	struct xfs_mount_args	*args = xfs_args_allocate(sb, silent);
L
Linus Torvalds 已提交
770
	struct kstatfs		statvfs;
771
	int			error;
L
Linus Torvalds 已提交
772

773
	mp = xfs_mount_init();
774 775 776 777 778

	INIT_LIST_HEAD(&mp->m_sync_list);
	spin_lock_init(&mp->m_sync_lock);
	init_waitqueue_head(&mp->m_wait_single_sync_task);

779 780
	mp->m_vfsp = vfsp;
	vfsp->vfs_mount = mp;
L
Linus Torvalds 已提交
781

782 783 784
	if (sb->s_flags & MS_RDONLY)
		mp->m_flags |= XFS_MOUNT_RDONLY;

785 786
	error = xfs_parseargs(mp, (char *)data, args, 0);
	if (error)
L
Linus Torvalds 已提交
787 788 789
		goto fail_vfsop;

	sb_min_blocksize(sb, BBSIZE);
790 791 792
	sb->s_export_op = &xfs_export_operations;
	sb->s_qcop = &xfs_quotactl_operations;
	sb->s_op = &xfs_super_operations;
L
Linus Torvalds 已提交
793

794 795
	error = xfs_mount(mp, args, NULL);
	if (error)
L
Linus Torvalds 已提交
796 797
		goto fail_vfsop;

798
	error = xfs_statvfs(mp, &statvfs, NULL);
L
Linus Torvalds 已提交
799 800 801 802 803 804 805 806 807 808 809
	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);

810
	error = xfs_root(mp, &rootvp);
L
Linus Torvalds 已提交
811 812 813
	if (error)
		goto fail_unmount;

814
	sb->s_root = d_alloc_root(vn_to_inode(rootvp));
L
Linus Torvalds 已提交
815 816 817 818 819 820 821 822
	if (!sb->s_root) {
		error = ENOMEM;
		goto fail_vnrele;
	}
	if (is_bad_inode(sb->s_root->d_inode)) {
		error = EINVAL;
		goto fail_vnrele;
	}
823 824 825 826 827 828

	mp->m_sync_work.w_syncer = xfs_sync_worker;
	mp->m_sync_work.w_mount = mp;
	mp->m_sync_task = kthread_run(xfssyncd, mp, "xfssyncd");
	if (IS_ERR(mp->m_sync_task)) {
		error = -PTR_ERR(mp->m_sync_task);
L
Linus Torvalds 已提交
829
		goto fail_vnrele;
830 831
	}

832 833
	vn_trace_exit(XFS_I(sb->s_root->d_inode), __FUNCTION__,
			(inst_t *)__return_address);
L
Linus Torvalds 已提交
834 835 836 837 838 839 840 841 842 843 844 845 846

	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:
847
	xfs_unmount(mp, 0, NULL);
L
Linus Torvalds 已提交
848 849 850 851 852 853 854

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

855
STATIC int
856
xfs_fs_get_sb(
L
Linus Torvalds 已提交
857 858 859
	struct file_system_type	*fs_type,
	int			flags,
	const char		*dev_name,
860 861
	void			*data,
	struct vfsmount		*mnt)
L
Linus Torvalds 已提交
862
{
863 864
	return get_sb_bdev(fs_type, flags, dev_name, data, xfs_fs_fill_super,
			   mnt);
865 866
}

867
static struct super_operations xfs_super_operations = {
868 869 870 871 872 873 874 875 876 877 878
	.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 已提交
879 880
};

881
static struct quotactl_ops xfs_quotactl_operations = {
882 883 884 885 886
	.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 已提交
887 888
};

A
Andrew Morton 已提交
889
static struct file_system_type xfs_fs_type = {
L
Linus Torvalds 已提交
890 891
	.owner			= THIS_MODULE,
	.name			= "xfs",
892
	.get_sb			= xfs_fs_get_sb,
L
Linus Torvalds 已提交
893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908
	.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);

909
	error = xfs_init_zones();
L
Linus Torvalds 已提交
910
	if (error < 0)
911
		goto undo_zones;
L
Linus Torvalds 已提交
912

913
	error = xfs_buf_init();
L
Linus Torvalds 已提交
914
	if (error < 0)
915
		goto undo_buffers;
L
Linus Torvalds 已提交
916 917 918 919 920 921 922 923 924 925 926 927

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

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

undo_register:
928
	xfs_buf_terminate();
L
Linus Torvalds 已提交
929

930
undo_buffers:
931
	xfs_destroy_zones();
L
Linus Torvalds 已提交
932

933
undo_zones:
L
Linus Torvalds 已提交
934 935 936 937 938 939 940 941 942
	return error;
}

STATIC void __exit
exit_xfs_fs( void )
{
	vfs_exitquota();
	unregister_filesystem(&xfs_fs_type);
	xfs_cleanup();
943
	xfs_buf_terminate();
944
	xfs_destroy_zones();
L
Linus Torvalds 已提交
945 946 947 948 949 950 951 952 953
	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");