xfs_super.c 43.9 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
 */
C
Christoph Hellwig 已提交
18

L
Linus Torvalds 已提交
19 20
#include "xfs.h"
#include "xfs_log.h"
21
#include "xfs_inum.h"
L
Linus Torvalds 已提交
22 23
#include "xfs_trans.h"
#include "xfs_sb.h"
24
#include "xfs_ag.h"
L
Linus Torvalds 已提交
25 26 27 28 29
#include "xfs_dir2.h"
#include "xfs_alloc.h"
#include "xfs_quota.h"
#include "xfs_mount.h"
#include "xfs_bmap_btree.h"
30
#include "xfs_alloc_btree.h"
L
Linus Torvalds 已提交
31 32 33
#include "xfs_ialloc_btree.h"
#include "xfs_dinode.h"
#include "xfs_inode.h"
34 35
#include "xfs_btree.h"
#include "xfs_ialloc.h"
L
Linus Torvalds 已提交
36 37 38 39
#include "xfs_bmap.h"
#include "xfs_rtalloc.h"
#include "xfs_error.h"
#include "xfs_itable.h"
C
Christoph Hellwig 已提交
40
#include "xfs_fsops.h"
L
Linus Torvalds 已提交
41 42 43
#include "xfs_attr.h"
#include "xfs_buf_item.h"
#include "xfs_utils.h"
44
#include "xfs_vnodeops.h"
45
#include "xfs_log_priv.h"
46
#include "xfs_trans_priv.h"
47
#include "xfs_filestream.h"
48 49 50 51
#include "xfs_da_btree.h"
#include "xfs_extfree_item.h"
#include "xfs_mru_cache.h"
#include "xfs_inode_item.h"
52
#include "xfs_sync.h"
C
Christoph Hellwig 已提交
53
#include "xfs_trace.h"
L
Linus Torvalds 已提交
54 55 56

#include <linux/namei.h>
#include <linux/init.h>
57
#include <linux/slab.h>
L
Linus Torvalds 已提交
58
#include <linux/mount.h>
59
#include <linux/mempool.h>
L
Linus Torvalds 已提交
60
#include <linux/writeback.h>
61
#include <linux/kthread.h>
62
#include <linux/freezer.h>
63
#include <linux/parser.h>
L
Linus Torvalds 已提交
64

65
static const struct super_operations xfs_super_operations;
66
static kmem_zone_t *xfs_ioend_zone;
67
mempool_t *xfs_ioend_pool;
L
Linus Torvalds 已提交
68

69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 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
#define MNTOPT_LOGBUFS	"logbufs"	/* number of XFS log buffers */
#define MNTOPT_LOGBSIZE	"logbsize"	/* size of XFS log buffers */
#define MNTOPT_LOGDEV	"logdev"	/* log device */
#define MNTOPT_RTDEV	"rtdev"		/* realtime I/O device */
#define MNTOPT_BIOSIZE	"biosize"	/* log2 of preferred buffered io size */
#define MNTOPT_WSYNC	"wsync"		/* safe-mode nfs compatible mount */
#define MNTOPT_NOALIGN	"noalign"	/* turn off stripe alignment */
#define MNTOPT_SWALLOC	"swalloc"	/* turn on stripe width allocation */
#define MNTOPT_SUNIT	"sunit"		/* data volume stripe unit */
#define MNTOPT_SWIDTH	"swidth"	/* data volume stripe width */
#define MNTOPT_NOUUID	"nouuid"	/* ignore filesystem UUID */
#define MNTOPT_MTPT	"mtpt"		/* filesystem mount point */
#define MNTOPT_GRPID	"grpid"		/* group-ID from parent directory */
#define MNTOPT_NOGRPID	"nogrpid"	/* group-ID from current process */
#define MNTOPT_BSDGROUPS    "bsdgroups"    /* group-ID from parent directory */
#define MNTOPT_SYSVGROUPS   "sysvgroups"   /* group-ID from current process */
#define MNTOPT_ALLOCSIZE    "allocsize"    /* preferred allocation size */
#define MNTOPT_NORECOVERY   "norecovery"   /* don't run XFS recovery */
#define MNTOPT_BARRIER	"barrier"	/* use writer barriers for log write and
					 * unwritten extent conversion */
#define MNTOPT_NOBARRIER "nobarrier"	/* .. disable */
#define MNTOPT_64BITINODE   "inode64"	/* inodes can be allocated anywhere */
#define MNTOPT_IKEEP	"ikeep"		/* do not free empty inode clusters */
#define MNTOPT_NOIKEEP	"noikeep"	/* free empty inode clusters */
#define MNTOPT_LARGEIO	   "largeio"	/* report large I/O sizes in stat() */
#define MNTOPT_NOLARGEIO   "nolargeio"	/* do not report large I/O sizes
					 * in stat(). */
#define MNTOPT_ATTR2	"attr2"		/* do use attr2 attribute format */
#define MNTOPT_NOATTR2	"noattr2"	/* do not use attr2 attribute format */
#define MNTOPT_FILESTREAM  "filestreams" /* use filestreams allocator */
#define MNTOPT_QUOTA	"quota"		/* disk quotas (user) */
#define MNTOPT_NOQUOTA	"noquota"	/* no quotas */
#define MNTOPT_USRQUOTA	"usrquota"	/* user quota enabled */
#define MNTOPT_GRPQUOTA	"grpquota"	/* group quota enabled */
#define MNTOPT_PRJQUOTA	"prjquota"	/* project quota enabled */
#define MNTOPT_UQUOTA	"uquota"	/* user quota (IRIX variant) */
#define MNTOPT_GQUOTA	"gquota"	/* group quota (IRIX variant) */
#define MNTOPT_PQUOTA	"pquota"	/* project quota (IRIX variant) */
#define MNTOPT_UQUOTANOENF "uqnoenforce"/* user quota limit enforcement */
#define MNTOPT_GQUOTANOENF "gqnoenforce"/* group quota limit enforcement */
#define MNTOPT_PQUOTANOENF "pqnoenforce"/* project quota limit enforcement */
#define MNTOPT_QUOTANOENF  "qnoenforce"	/* same as uqnoenforce */
111 112 113 114
#define MNTOPT_DELAYLOG    "delaylog"	/* Delayed logging enabled */
#define MNTOPT_NODELAYLOG  "nodelaylog"	/* Delayed logging disabled */
#define MNTOPT_DISCARD	   "discard"	/* Discard unused blocks */
#define MNTOPT_NODISCARD   "nodiscard"	/* Do not discard unused blocks */
115

116 117 118 119 120 121 122
/*
 * Table driven mount option parser.
 *
 * Currently only used for remount, but it will be used for mount
 * in the future, too.
 */
enum {
123
	Opt_barrier, Opt_nobarrier, Opt_inode64, Opt_err
124 125
};

126
static const match_table_t tokens = {
127 128
	{Opt_barrier, "barrier"},
	{Opt_nobarrier, "nobarrier"},
129
	{Opt_inode64, "inode64"},
130 131 132 133
	{Opt_err, NULL}
};


134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156
STATIC unsigned long
suffix_strtoul(char *s, char **endp, unsigned int base)
{
	int	last, shift_left_factor = 0;
	char	*value = s;

	last = strlen(value) - 1;
	if (value[last] == 'K' || value[last] == 'k') {
		shift_left_factor = 10;
		value[last] = '\0';
	}
	if (value[last] == 'M' || value[last] == 'm') {
		shift_left_factor = 20;
		value[last] = '\0';
	}
	if (value[last] == 'G' || value[last] == 'g') {
		shift_left_factor = 30;
		value[last] = '\0';
	}

	return simple_strtoul((const char *)s, endp, base) << shift_left_factor;
}

157 158 159 160 161 162 163
/*
 * This function fills in xfs_mount_t fields based on mount args.
 * Note: the superblock has _not_ yet been read in.
 *
 * Note that this function leaks the various device name allocations on
 * failure.  The caller takes care of them.
 */
164 165 166
STATIC int
xfs_parseargs(
	struct xfs_mount	*mp,
C
Christoph Hellwig 已提交
167
	char			*options)
168
{
169
	struct super_block	*sb = mp->m_super;
170
	char			*this_char, *value, *eov;
171 172 173
	int			dsunit = 0;
	int			dswidth = 0;
	int			iosize = 0;
174
	__uint8_t		iosizelog = 0;
175

176 177 178 179 180 181 182 183 184
	/*
	 * set up the mount name first so all the errors will refer to the
	 * correct device.
	 */
	mp->m_fsname = kstrndup(sb->s_id, MAXNAMELEN, GFP_KERNEL);
	if (!mp->m_fsname)
		return ENOMEM;
	mp->m_fsname_len = strlen(mp->m_fsname) + 1;

185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201
	/*
	 * Copy binary VFS mount flags we are interested in.
	 */
	if (sb->s_flags & MS_RDONLY)
		mp->m_flags |= XFS_MOUNT_RDONLY;
	if (sb->s_flags & MS_DIRSYNC)
		mp->m_flags |= XFS_MOUNT_DIRSYNC;
	if (sb->s_flags & MS_SYNCHRONOUS)
		mp->m_flags |= XFS_MOUNT_WSYNC;

	/*
	 * Set some default flags that could be cleared by the mount option
	 * parsing.
	 */
	mp->m_flags |= XFS_MOUNT_BARRIER;
	mp->m_flags |= XFS_MOUNT_COMPAT_IOSIZE;
	mp->m_flags |= XFS_MOUNT_SMALL_INUMS;
202

203 204 205 206 207
	/*
	 * These can be overridden by the mount option parsing.
	 */
	mp->m_logbufs = -1;
	mp->m_logbsize = -1;
208 209 210 211 212 213 214 215 216 217 218 219

	if (!options)
		goto done;

	while ((this_char = strsep(&options, ",")) != NULL) {
		if (!*this_char)
			continue;
		if ((value = strchr(this_char, '=')) != NULL)
			*value++ = 0;

		if (!strcmp(this_char, MNTOPT_LOGBUFS)) {
			if (!value || !*value) {
220
				xfs_warn(mp, "%s option requires an argument",
221 222 223
					this_char);
				return EINVAL;
			}
224
			mp->m_logbufs = simple_strtoul(value, &eov, 10);
225 226
		} else if (!strcmp(this_char, MNTOPT_LOGBSIZE)) {
			if (!value || !*value) {
227
				xfs_warn(mp, "%s option requires an argument",
228 229 230
					this_char);
				return EINVAL;
			}
231
			mp->m_logbsize = suffix_strtoul(value, &eov, 10);
232 233
		} else if (!strcmp(this_char, MNTOPT_LOGDEV)) {
			if (!value || !*value) {
234
				xfs_warn(mp, "%s option requires an argument",
235 236 237
					this_char);
				return EINVAL;
			}
238 239 240
			mp->m_logname = kstrndup(value, MAXNAMELEN, GFP_KERNEL);
			if (!mp->m_logname)
				return ENOMEM;
241
		} else if (!strcmp(this_char, MNTOPT_MTPT)) {
242
			xfs_warn(mp, "%s option not allowed on this system",
C
Christoph Hellwig 已提交
243 244
				this_char);
			return EINVAL;
245 246
		} else if (!strcmp(this_char, MNTOPT_RTDEV)) {
			if (!value || !*value) {
247
				xfs_warn(mp, "%s option requires an argument",
248 249 250
					this_char);
				return EINVAL;
			}
251 252 253
			mp->m_rtname = kstrndup(value, MAXNAMELEN, GFP_KERNEL);
			if (!mp->m_rtname)
				return ENOMEM;
254 255
		} else if (!strcmp(this_char, MNTOPT_BIOSIZE)) {
			if (!value || !*value) {
256
				xfs_warn(mp, "%s option requires an argument",
257 258 259 260
					this_char);
				return EINVAL;
			}
			iosize = simple_strtoul(value, &eov, 10);
C
Christoph Hellwig 已提交
261
			iosizelog = ffs(iosize) - 1;
262 263
		} else if (!strcmp(this_char, MNTOPT_ALLOCSIZE)) {
			if (!value || !*value) {
264
				xfs_warn(mp, "%s option requires an argument",
265 266 267 268
					this_char);
				return EINVAL;
			}
			iosize = suffix_strtoul(value, &eov, 10);
269
			iosizelog = ffs(iosize) - 1;
270 271 272 273 274 275 276
		} else if (!strcmp(this_char, MNTOPT_GRPID) ||
			   !strcmp(this_char, MNTOPT_BSDGROUPS)) {
			mp->m_flags |= XFS_MOUNT_GRPID;
		} else if (!strcmp(this_char, MNTOPT_NOGRPID) ||
			   !strcmp(this_char, MNTOPT_SYSVGROUPS)) {
			mp->m_flags &= ~XFS_MOUNT_GRPID;
		} else if (!strcmp(this_char, MNTOPT_WSYNC)) {
277
			mp->m_flags |= XFS_MOUNT_WSYNC;
278
		} else if (!strcmp(this_char, MNTOPT_NORECOVERY)) {
279
			mp->m_flags |= XFS_MOUNT_NORECOVERY;
280
		} else if (!strcmp(this_char, MNTOPT_NOALIGN)) {
281
			mp->m_flags |= XFS_MOUNT_NOALIGN;
282
		} else if (!strcmp(this_char, MNTOPT_SWALLOC)) {
283
			mp->m_flags |= XFS_MOUNT_SWALLOC;
284 285
		} else if (!strcmp(this_char, MNTOPT_SUNIT)) {
			if (!value || !*value) {
286
				xfs_warn(mp, "%s option requires an argument",
287 288 289 290 291 292
					this_char);
				return EINVAL;
			}
			dsunit = simple_strtoul(value, &eov, 10);
		} else if (!strcmp(this_char, MNTOPT_SWIDTH)) {
			if (!value || !*value) {
293
				xfs_warn(mp, "%s option requires an argument",
294 295 296 297 298
					this_char);
				return EINVAL;
			}
			dswidth = simple_strtoul(value, &eov, 10);
		} else if (!strcmp(this_char, MNTOPT_64BITINODE)) {
299
			mp->m_flags &= ~XFS_MOUNT_SMALL_INUMS;
300
#if !XFS_BIG_INUMS
301
			xfs_warn(mp, "%s option not allowed on this system",
302 303 304 305
				this_char);
			return EINVAL;
#endif
		} else if (!strcmp(this_char, MNTOPT_NOUUID)) {
306
			mp->m_flags |= XFS_MOUNT_NOUUID;
307
		} else if (!strcmp(this_char, MNTOPT_BARRIER)) {
308
			mp->m_flags |= XFS_MOUNT_BARRIER;
309
		} else if (!strcmp(this_char, MNTOPT_NOBARRIER)) {
310
			mp->m_flags &= ~XFS_MOUNT_BARRIER;
311
		} else if (!strcmp(this_char, MNTOPT_IKEEP)) {
312
			mp->m_flags |= XFS_MOUNT_IKEEP;
313
		} else if (!strcmp(this_char, MNTOPT_NOIKEEP)) {
314
			mp->m_flags &= ~XFS_MOUNT_IKEEP;
315
		} else if (!strcmp(this_char, MNTOPT_LARGEIO)) {
316
			mp->m_flags &= ~XFS_MOUNT_COMPAT_IOSIZE;
317
		} else if (!strcmp(this_char, MNTOPT_NOLARGEIO)) {
318
			mp->m_flags |= XFS_MOUNT_COMPAT_IOSIZE;
319
		} else if (!strcmp(this_char, MNTOPT_ATTR2)) {
320
			mp->m_flags |= XFS_MOUNT_ATTR2;
321
		} else if (!strcmp(this_char, MNTOPT_NOATTR2)) {
322 323
			mp->m_flags &= ~XFS_MOUNT_ATTR2;
			mp->m_flags |= XFS_MOUNT_NOATTR2;
324
		} else if (!strcmp(this_char, MNTOPT_FILESTREAM)) {
325
			mp->m_flags |= XFS_MOUNT_FILESTREAMS;
326
		} else if (!strcmp(this_char, MNTOPT_NOQUOTA)) {
327 328 329
			mp->m_qflags &= ~XFS_ALL_QUOTA_ACCT;
			mp->m_qflags &= ~XFS_ALL_QUOTA_ENFD;
			mp->m_qflags &= ~XFS_ALL_QUOTA_ACTIVE;
330 331 332
		} else if (!strcmp(this_char, MNTOPT_QUOTA) ||
			   !strcmp(this_char, MNTOPT_UQUOTA) ||
			   !strcmp(this_char, MNTOPT_USRQUOTA)) {
333 334
			mp->m_qflags |= (XFS_UQUOTA_ACCT | XFS_UQUOTA_ACTIVE |
					 XFS_UQUOTA_ENFD);
335 336
		} else if (!strcmp(this_char, MNTOPT_QUOTANOENF) ||
			   !strcmp(this_char, MNTOPT_UQUOTANOENF)) {
337 338
			mp->m_qflags |= (XFS_UQUOTA_ACCT | XFS_UQUOTA_ACTIVE);
			mp->m_qflags &= ~XFS_UQUOTA_ENFD;
339 340
		} else if (!strcmp(this_char, MNTOPT_PQUOTA) ||
			   !strcmp(this_char, MNTOPT_PRJQUOTA)) {
341 342
			mp->m_qflags |= (XFS_PQUOTA_ACCT | XFS_PQUOTA_ACTIVE |
					 XFS_OQUOTA_ENFD);
343
		} else if (!strcmp(this_char, MNTOPT_PQUOTANOENF)) {
344 345
			mp->m_qflags |= (XFS_PQUOTA_ACCT | XFS_PQUOTA_ACTIVE);
			mp->m_qflags &= ~XFS_OQUOTA_ENFD;
346 347
		} else if (!strcmp(this_char, MNTOPT_GQUOTA) ||
			   !strcmp(this_char, MNTOPT_GRPQUOTA)) {
348 349
			mp->m_qflags |= (XFS_GQUOTA_ACCT | XFS_GQUOTA_ACTIVE |
					 XFS_OQUOTA_ENFD);
350
		} else if (!strcmp(this_char, MNTOPT_GQUOTANOENF)) {
351 352
			mp->m_qflags |= (XFS_GQUOTA_ACCT | XFS_GQUOTA_ACTIVE);
			mp->m_qflags &= ~XFS_OQUOTA_ENFD;
353
		} else if (!strcmp(this_char, MNTOPT_DELAYLOG)) {
354 355
			xfs_warn(mp,
	"delaylog is the default now, option is deprecated.");
356
		} else if (!strcmp(this_char, MNTOPT_NODELAYLOG)) {
357
			xfs_warn(mp,
358
	"nodelaylog support has been removed, option is deprecated.");
359 360 361 362
		} else if (!strcmp(this_char, MNTOPT_DISCARD)) {
			mp->m_flags |= XFS_MOUNT_DISCARD;
		} else if (!strcmp(this_char, MNTOPT_NODISCARD)) {
			mp->m_flags &= ~XFS_MOUNT_DISCARD;
363
		} else if (!strcmp(this_char, "ihashsize")) {
364 365
			xfs_warn(mp,
	"ihashsize no longer used, option is deprecated.");
366
		} else if (!strcmp(this_char, "osyncisdsync")) {
367 368
			xfs_warn(mp,
	"osyncisdsync has no effect, option is deprecated.");
369
		} else if (!strcmp(this_char, "osyncisosync")) {
370 371
			xfs_warn(mp,
	"osyncisosync has no effect, option is deprecated.");
372
		} else if (!strcmp(this_char, "irixsgid")) {
373 374
			xfs_warn(mp,
	"irixsgid is now a sysctl(2) variable, option is deprecated.");
375
		} else {
376
			xfs_warn(mp, "unknown mount option [%s].", this_char);
377 378 379 380
			return EINVAL;
		}
	}

381 382 383 384 385
	/*
	 * no recovery flag requires a read-only mount
	 */
	if ((mp->m_flags & XFS_MOUNT_NORECOVERY) &&
	    !(mp->m_flags & XFS_MOUNT_RDONLY)) {
386
		xfs_warn(mp, "no-recovery mounts must be read-only.");
387
		return EINVAL;
388 389
	}

390
	if ((mp->m_flags & XFS_MOUNT_NOALIGN) && (dsunit || dswidth)) {
391 392
		xfs_warn(mp,
	"sunit and swidth options incompatible with the noalign option");
393 394 395
		return EINVAL;
	}

C
Christoph Hellwig 已提交
396 397
#ifndef CONFIG_XFS_QUOTA
	if (XFS_IS_QUOTA_RUNNING(mp)) {
398
		xfs_warn(mp, "quota support not available in this kernel.");
C
Christoph Hellwig 已提交
399 400 401 402
		return EINVAL;
	}
#endif

403 404
	if ((mp->m_qflags & (XFS_GQUOTA_ACCT | XFS_GQUOTA_ACTIVE)) &&
	    (mp->m_qflags & (XFS_PQUOTA_ACCT | XFS_PQUOTA_ACTIVE))) {
405
		xfs_warn(mp, "cannot mount with both project and group quota");
406 407 408 409
		return EINVAL;
	}

	if ((dsunit && !dswidth) || (!dsunit && dswidth)) {
410
		xfs_warn(mp, "sunit and swidth must be specified together");
411 412 413 414
		return EINVAL;
	}

	if (dsunit && (dswidth % dsunit != 0)) {
415 416
		xfs_warn(mp,
	"stripe width (%d) must be a multiple of the stripe unit (%d)",
417 418 419 420
			dswidth, dsunit);
		return EINVAL;
	}

421 422 423 424 425 426 427 428
done:
	if (!(mp->m_flags & XFS_MOUNT_NOALIGN)) {
		/*
		 * At this point the superblock has not been read
		 * in, therefore we do not know the block size.
		 * Before the mount call ends we will convert
		 * these to FSBs.
		 */
429
		if (dsunit) {
430 431
			mp->m_dalign = dsunit;
			mp->m_flags |= XFS_MOUNT_RETERR;
432
		}
433 434 435 436 437 438 439 440 441

		if (dswidth)
			mp->m_swidth = dswidth;
	}

	if (mp->m_logbufs != -1 &&
	    mp->m_logbufs != 0 &&
	    (mp->m_logbufs < XLOG_MIN_ICLOGS ||
	     mp->m_logbufs > XLOG_MAX_ICLOGS)) {
442
		xfs_warn(mp, "invalid logbufs value: %d [not %d-%d]",
443 444 445 446 447 448 449 450
			mp->m_logbufs, XLOG_MIN_ICLOGS, XLOG_MAX_ICLOGS);
		return XFS_ERROR(EINVAL);
	}
	if (mp->m_logbsize != -1 &&
	    mp->m_logbsize !=  0 &&
	    (mp->m_logbsize < XLOG_MIN_RECORD_BSIZE ||
	     mp->m_logbsize > XLOG_MAX_RECORD_BSIZE ||
	     !is_power_of_2(mp->m_logbsize))) {
451 452
		xfs_warn(mp,
			"invalid logbufsize: %d [not 16k,32k,64k,128k or 256k]",
453 454 455 456 457 458 459
			mp->m_logbsize);
		return XFS_ERROR(EINVAL);
	}

	if (iosizelog) {
		if (iosizelog > XFS_MAX_IO_LOG ||
		    iosizelog < XFS_MIN_IO_LOG) {
460
			xfs_warn(mp, "invalid log iosize: %d [not %d-%d]",
461 462 463 464 465 466 467 468
				iosizelog, XFS_MIN_IO_LOG,
				XFS_MAX_IO_LOG);
			return XFS_ERROR(EINVAL);
		}

		mp->m_flags |= XFS_MOUNT_DFLT_IOSIZE;
		mp->m_readio_log = iosizelog;
		mp->m_writeio_log = iosizelog;
469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485
	}

	return 0;
}

struct proc_xfs_info {
	int	flag;
	char	*str;
};

STATIC int
xfs_showargs(
	struct xfs_mount	*mp,
	struct seq_file		*m)
{
	static struct proc_xfs_info xfs_info_set[] = {
		/* the few simple ones we can get from the mount struct */
486
		{ XFS_MOUNT_IKEEP,		"," MNTOPT_IKEEP },
487 488 489 490 491 492 493 494
		{ XFS_MOUNT_WSYNC,		"," MNTOPT_WSYNC },
		{ XFS_MOUNT_NOALIGN,		"," MNTOPT_NOALIGN },
		{ XFS_MOUNT_SWALLOC,		"," MNTOPT_SWALLOC },
		{ XFS_MOUNT_NOUUID,		"," MNTOPT_NOUUID },
		{ XFS_MOUNT_NORECOVERY,		"," MNTOPT_NORECOVERY },
		{ XFS_MOUNT_ATTR2,		"," MNTOPT_ATTR2 },
		{ XFS_MOUNT_FILESTREAMS,	"," MNTOPT_FILESTREAM },
		{ XFS_MOUNT_GRPID,		"," MNTOPT_GRPID },
495
		{ XFS_MOUNT_DISCARD,		"," MNTOPT_DISCARD },
496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541
		{ 0, NULL }
	};
	static struct proc_xfs_info xfs_info_unset[] = {
		/* the few simple ones we can get from the mount struct */
		{ XFS_MOUNT_COMPAT_IOSIZE,	"," MNTOPT_LARGEIO },
		{ XFS_MOUNT_BARRIER,		"," MNTOPT_NOBARRIER },
		{ XFS_MOUNT_SMALL_INUMS,	"," MNTOPT_64BITINODE },
		{ 0, NULL }
	};
	struct proc_xfs_info	*xfs_infop;

	for (xfs_infop = xfs_info_set; xfs_infop->flag; xfs_infop++) {
		if (mp->m_flags & xfs_infop->flag)
			seq_puts(m, xfs_infop->str);
	}
	for (xfs_infop = xfs_info_unset; xfs_infop->flag; xfs_infop++) {
		if (!(mp->m_flags & xfs_infop->flag))
			seq_puts(m, xfs_infop->str);
	}

	if (mp->m_flags & XFS_MOUNT_DFLT_IOSIZE)
		seq_printf(m, "," MNTOPT_ALLOCSIZE "=%dk",
				(int)(1 << mp->m_writeio_log) >> 10);

	if (mp->m_logbufs > 0)
		seq_printf(m, "," MNTOPT_LOGBUFS "=%d", mp->m_logbufs);
	if (mp->m_logbsize > 0)
		seq_printf(m, "," MNTOPT_LOGBSIZE "=%dk", mp->m_logbsize >> 10);

	if (mp->m_logname)
		seq_printf(m, "," MNTOPT_LOGDEV "=%s", mp->m_logname);
	if (mp->m_rtname)
		seq_printf(m, "," MNTOPT_RTDEV "=%s", mp->m_rtname);

	if (mp->m_dalign > 0)
		seq_printf(m, "," MNTOPT_SUNIT "=%d",
				(int)XFS_FSB_TO_BB(mp, mp->m_dalign));
	if (mp->m_swidth > 0)
		seq_printf(m, "," MNTOPT_SWIDTH "=%d",
				(int)XFS_FSB_TO_BB(mp, mp->m_swidth));

	if (mp->m_qflags & (XFS_UQUOTA_ACCT|XFS_UQUOTA_ENFD))
		seq_puts(m, "," MNTOPT_USRQUOTA);
	else if (mp->m_qflags & XFS_UQUOTA_ACCT)
		seq_puts(m, "," MNTOPT_UQUOTANOENF);

542 543 544 545 546 547 548 549 550 551 552 553 554
	/* Either project or group quotas can be active, not both */

	if (mp->m_qflags & XFS_PQUOTA_ACCT) {
		if (mp->m_qflags & XFS_OQUOTA_ENFD)
			seq_puts(m, "," MNTOPT_PRJQUOTA);
		else
			seq_puts(m, "," MNTOPT_PQUOTANOENF);
	} else if (mp->m_qflags & XFS_GQUOTA_ACCT) {
		if (mp->m_qflags & XFS_OQUOTA_ENFD)
			seq_puts(m, "," MNTOPT_GRPQUOTA);
		else
			seq_puts(m, "," MNTOPT_GQUOTANOENF);
	}
555 556 557 558 559 560

	if (!(mp->m_qflags & XFS_ALL_QUOTA_ACCT))
		seq_puts(m, "," MNTOPT_NOQUOTA);

	return 0;
}
L
Linus Torvalds 已提交
561 562 563 564 565 566 567 568 569
__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).
C
Christoph Hellwig 已提交
570
	 * __block_write_begin does this in an [unsigned] long...
L
Linus Torvalds 已提交
571 572 573 574 575 576 577 578 579 580 581 582
	 *      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
583
# if defined(CONFIG_LBDAF)
L
Linus Torvalds 已提交
584 585 586 587 588 589 590 591 592 593 594
	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;
}

H
Hannes Eder 已提交
595
STATIC int
L
Linus Torvalds 已提交
596 597 598 599 600 601 602
xfs_blkdev_get(
	xfs_mount_t		*mp,
	const char		*name,
	struct block_device	**bdevp)
{
	int			error = 0;

603 604
	*bdevp = blkdev_get_by_path(name, FMODE_READ|FMODE_WRITE|FMODE_EXCL,
				    mp);
L
Linus Torvalds 已提交
605 606
	if (IS_ERR(*bdevp)) {
		error = PTR_ERR(*bdevp);
607
		xfs_warn(mp, "Invalid device [%s], error=%d\n", name, error);
L
Linus Torvalds 已提交
608 609 610 611 612
	}

	return -error;
}

H
Hannes Eder 已提交
613
STATIC void
L
Linus Torvalds 已提交
614 615 616 617
xfs_blkdev_put(
	struct block_device	*bdev)
{
	if (bdev)
618
		blkdev_put(bdev, FMODE_READ|FMODE_WRITE|FMODE_EXCL);
L
Linus Torvalds 已提交
619 620
}

621 622 623 624
void
xfs_blkdev_issue_flush(
	xfs_buftarg_t		*buftarg)
{
625
	blkdev_issue_flush(buftarg->bt_bdev, GFP_NOFS, NULL);
626
}
L
Linus Torvalds 已提交
627

628 629 630 631 632
STATIC void
xfs_close_devices(
	struct xfs_mount	*mp)
{
	if (mp->m_logdev_targp && mp->m_logdev_targp != mp->m_ddev_targp) {
633
		struct block_device *logdev = mp->m_logdev_targp->bt_bdev;
634
		xfs_free_buftarg(mp, mp->m_logdev_targp);
635
		xfs_blkdev_put(logdev);
636 637
	}
	if (mp->m_rtdev_targp) {
638
		struct block_device *rtdev = mp->m_rtdev_targp->bt_bdev;
639
		xfs_free_buftarg(mp, mp->m_rtdev_targp);
640
		xfs_blkdev_put(rtdev);
641
	}
642
	xfs_free_buftarg(mp, mp->m_ddev_targp);
643 644 645 646 647 648 649 650 651 652 653 654 655 656
}

/*
 * The file system configurations are:
 *	(1) device (partition) with data and internal log
 *	(2) logical volume with data and log subvolumes.
 *	(3) logical volume with data, log, and realtime subvolumes.
 *
 * We only have to handle opening the log and realtime volumes here if
 * they are present.  The data subvolume has already been opened by
 * get_sb_bdev() and is stored in sb->s_bdev.
 */
STATIC int
xfs_open_devices(
657
	struct xfs_mount	*mp)
658 659 660 661 662 663 664 665
{
	struct block_device	*ddev = mp->m_super->s_bdev;
	struct block_device	*logdev = NULL, *rtdev = NULL;
	int			error;

	/*
	 * Open real time and log devices - order is important.
	 */
666 667
	if (mp->m_logname) {
		error = xfs_blkdev_get(mp, mp->m_logname, &logdev);
668 669 670 671
		if (error)
			goto out;
	}

672 673
	if (mp->m_rtname) {
		error = xfs_blkdev_get(mp, mp->m_rtname, &rtdev);
674 675 676 677
		if (error)
			goto out_close_logdev;

		if (rtdev == ddev || rtdev == logdev) {
678 679
			xfs_warn(mp,
	"Cannot mount filesystem with identical rtdev and ddev/logdev.");
680 681 682 683 684 685 686 687 688
			error = EINVAL;
			goto out_close_rtdev;
		}
	}

	/*
	 * Setup xfs_mount buffer target pointers
	 */
	error = ENOMEM;
689
	mp->m_ddev_targp = xfs_alloc_buftarg(mp, ddev, 0, mp->m_fsname);
690 691 692 693
	if (!mp->m_ddev_targp)
		goto out_close_rtdev;

	if (rtdev) {
694 695
		mp->m_rtdev_targp = xfs_alloc_buftarg(mp, rtdev, 1,
							mp->m_fsname);
696 697 698 699 700
		if (!mp->m_rtdev_targp)
			goto out_free_ddev_targ;
	}

	if (logdev && logdev != ddev) {
701 702
		mp->m_logdev_targp = xfs_alloc_buftarg(mp, logdev, 1,
							mp->m_fsname);
703 704 705 706 707 708 709 710 711 712
		if (!mp->m_logdev_targp)
			goto out_free_rtdev_targ;
	} else {
		mp->m_logdev_targp = mp->m_ddev_targp;
	}

	return 0;

 out_free_rtdev_targ:
	if (mp->m_rtdev_targp)
713
		xfs_free_buftarg(mp, mp->m_rtdev_targp);
714
 out_free_ddev_targ:
715
	xfs_free_buftarg(mp, mp->m_ddev_targp);
716 717 718 719 720 721 722 723 724 725
 out_close_rtdev:
	if (rtdev)
		xfs_blkdev_put(rtdev);
 out_close_logdev:
	if (logdev && logdev != ddev)
		xfs_blkdev_put(logdev);
 out:
	return error;
}

726 727 728 729 730 731 732 733
/*
 * Setup xfs_mount buffer target pointers based on superblock
 */
STATIC int
xfs_setup_devices(
	struct xfs_mount	*mp)
{
	int			error;
734

735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760
	error = xfs_setsize_buftarg(mp->m_ddev_targp, mp->m_sb.sb_blocksize,
				    mp->m_sb.sb_sectsize);
	if (error)
		return error;

	if (mp->m_logdev_targp && mp->m_logdev_targp != mp->m_ddev_targp) {
		unsigned int	log_sector_size = BBSIZE;

		if (xfs_sb_version_hassector(&mp->m_sb))
			log_sector_size = mp->m_sb.sb_logsectsize;
		error = xfs_setsize_buftarg(mp->m_logdev_targp,
					    mp->m_sb.sb_blocksize,
					    log_sector_size);
		if (error)
			return error;
	}
	if (mp->m_rtdev_targp) {
		error = xfs_setsize_buftarg(mp->m_rtdev_targp,
					    mp->m_sb.sb_blocksize,
					    mp->m_sb.sb_sectsize);
		if (error)
			return error;
	}

	return 0;
}
761

762 763 764 765 766 767 768 769 770 771 772 773 774 775
STATIC int
xfs_init_mount_workqueues(
	struct xfs_mount	*mp)
{
	mp->m_data_workqueue = alloc_workqueue("xfs-data/%s",
			WQ_MEM_RECLAIM, 0, mp->m_fsname);
	if (!mp->m_data_workqueue)
		goto out;

	mp->m_unwritten_workqueue = alloc_workqueue("xfs-conv/%s",
			WQ_MEM_RECLAIM, 0, mp->m_fsname);
	if (!mp->m_unwritten_workqueue)
		goto out_destroy_data_iodone_queue;

776 777 778 779
	mp->m_cil_workqueue = alloc_workqueue("xfs-cil/%s",
			WQ_MEM_RECLAIM, 0, mp->m_fsname);
	if (!mp->m_cil_workqueue)
		goto out_destroy_unwritten;
780 781
	return 0;

782 783
out_destroy_unwritten:
	destroy_workqueue(mp->m_unwritten_workqueue);
784 785 786 787 788 789 790 791 792 793
out_destroy_data_iodone_queue:
	destroy_workqueue(mp->m_data_workqueue);
out:
	return -ENOMEM;
}

STATIC void
xfs_destroy_mount_workqueues(
	struct xfs_mount	*mp)
{
794
	destroy_workqueue(mp->m_cil_workqueue);
795 796 797 798
	destroy_workqueue(mp->m_data_workqueue);
	destroy_workqueue(mp->m_unwritten_workqueue);
}

799
/* Catch misguided souls that try to use this interface on XFS */
L
Linus Torvalds 已提交
800
STATIC struct inode *
801
xfs_fs_alloc_inode(
L
Linus Torvalds 已提交
802 803
	struct super_block	*sb)
{
804
	BUG();
805
	return NULL;
L
Linus Torvalds 已提交
806 807
}

808
/*
809 810
 * Now that the generic code is guaranteed not to be accessing
 * the linux inode, we can reclaim the inode.
811
 */
L
Linus Torvalds 已提交
812
STATIC void
813
xfs_fs_destroy_inode(
C
Christoph Hellwig 已提交
814
	struct inode		*inode)
L
Linus Torvalds 已提交
815
{
C
Christoph Hellwig 已提交
816 817
	struct xfs_inode	*ip = XFS_I(inode);

C
Christoph Hellwig 已提交
818
	trace_xfs_destroy_inode(ip);
819 820

	XFS_STATS_INC(vn_reclaim);
C
Christoph Hellwig 已提交
821 822 823 824 825 826 827 828 829 830 831 832 833 834

	/* bad inode, get out here ASAP */
	if (is_bad_inode(inode))
		goto out_reclaim;

	ASSERT(XFS_FORCED_SHUTDOWN(ip->i_mount) || ip->i_delayed_blks == 0);

	/*
	 * We should never get here with one of the reclaim flags already set.
	 */
	ASSERT_ALWAYS(!xfs_iflags_test(ip, XFS_IRECLAIMABLE));
	ASSERT_ALWAYS(!xfs_iflags_test(ip, XFS_IRECLAIM));

	/*
835 836 837 838 839
	 * We always use background reclaim here because even if the
	 * inode is clean, it still may be under IO and hence we have
	 * to take the flush lock. The background reclaim path handles
	 * this more efficiently than we can here, so simply let background
	 * reclaim tear down all inodes.
C
Christoph Hellwig 已提交
840 841
	 */
out_reclaim:
842
	xfs_inode_set_reclaim_tag(ip);
L
Linus Torvalds 已提交
843 844
}

845 846 847 848
/*
 * Slab object creation initialisation for the XFS inode.
 * This covers only the idempotent fields in the XFS inode;
 * all other fields need to be initialised on allocation
849
 * from the slab. This avoids the need to repeatedly initialise
850 851 852
 * fields in the xfs inode that left in the initialise state
 * when freeing the inode.
 */
853 854
STATIC void
xfs_fs_inode_init_once(
855 856 857 858 859
	void			*inode)
{
	struct xfs_inode	*ip = inode;

	memset(ip, 0, sizeof(struct xfs_inode));
860 861 862 863 864

	/* vfs inode */
	inode_init_once(VFS_I(ip));

	/* xfs inode */
865 866 867 868 869 870 871
	atomic_set(&ip->i_pincount, 0);
	spin_lock_init(&ip->i_flags_lock);

	mrlock_init(&ip->i_lock, MRLOCK_ALLOW_EQUAL_PRI|MRLOCK_BARRIER,
		     "xfsino", ip->i_ino);
}

L
Linus Torvalds 已提交
872
STATIC void
873
xfs_fs_evict_inode(
L
Linus Torvalds 已提交
874 875
	struct inode		*inode)
{
876
	xfs_inode_t		*ip = XFS_I(inode);
877

878 879
	ASSERT(!rwsem_is_locked(&ip->i_iolock.mr_lock));

880
	trace_xfs_evict_inode(ip);
C
Christoph Hellwig 已提交
881

882
	truncate_inode_pages(&inode->i_data, 0);
883
	clear_inode(inode);
884 885 886 887 888
	XFS_STATS_INC(vn_rele);
	XFS_STATS_INC(vn_remove);
	XFS_STATS_DEC(vn_active);

	xfs_inactive(ip);
889
}
L
Linus Torvalds 已提交
890

891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906
/*
 * We do an unlocked check for XFS_IDONTCACHE here because we are already
 * serialised against cache hits here via the inode->i_lock and igrab() in
 * xfs_iget_cache_hit(). Hence a lookup that might clear this flag will not be
 * racing with us, and it avoids needing to grab a spinlock here for every inode
 * we drop the final reference on.
 */
STATIC int
xfs_fs_drop_inode(
	struct inode		*inode)
{
	struct xfs_inode	*ip = XFS_I(inode);

	return generic_drop_inode(inode) || (ip->i_flags & XFS_IDONTCACHE);
}

907 908 909 910 911 912 913 914 915
STATIC void
xfs_free_fsname(
	struct xfs_mount	*mp)
{
	kfree(mp->m_fsname);
	kfree(mp->m_rtname);
	kfree(mp->m_logname);
}

L
Linus Torvalds 已提交
916
STATIC void
917
xfs_fs_put_super(
L
Linus Torvalds 已提交
918 919
	struct super_block	*sb)
{
920
	struct xfs_mount	*mp = XFS_M(sb);
L
Linus Torvalds 已提交
921

922
	xfs_filestream_unmount(mp);
923
	cancel_delayed_work_sync(&mp->m_sync_work);
924
	xfs_unmountfs(mp);
925
	xfs_syncd_stop(mp);
926
	xfs_freesb(mp);
C
Christoph Hellwig 已提交
927
	xfs_icsb_destroy_counters(mp);
928
	xfs_destroy_mount_workqueues(mp);
929
	xfs_close_devices(mp);
930
	xfs_free_fsname(mp);
C
Christoph Hellwig 已提交
931
	kfree(mp);
L
Linus Torvalds 已提交
932 933 934
}

STATIC int
C
Christoph Hellwig 已提交
935
xfs_fs_sync_fs(
L
Linus Torvalds 已提交
936 937 938
	struct super_block	*sb,
	int			wait)
{
939
	struct xfs_mount	*mp = XFS_M(sb);
940
	int			error;
L
Linus Torvalds 已提交
941

942
	/*
C
Christoph Hellwig 已提交
943
	 * Doing anything during the async pass would be counterproductive.
944
	 */
C
Christoph Hellwig 已提交
945
	if (!wait)
C
Christoph Hellwig 已提交
946 947 948 949 950
		return 0;

	error = xfs_quiesce_data(mp);
	if (error)
		return -error;
L
Linus Torvalds 已提交
951

C
Christoph Hellwig 已提交
952
	if (laptop_mode) {
L
Linus Torvalds 已提交
953 954 955 956 957
		/*
		 * 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).
		 */
958
		flush_delayed_work_sync(&mp->m_sync_work);
L
Linus Torvalds 已提交
959 960
	}

C
Christoph Hellwig 已提交
961
	return 0;
L
Linus Torvalds 已提交
962 963 964
}

STATIC int
965
xfs_fs_statfs(
966
	struct dentry		*dentry,
L
Linus Torvalds 已提交
967 968
	struct kstatfs		*statp)
{
C
Christoph Hellwig 已提交
969 970
	struct xfs_mount	*mp = XFS_M(dentry->d_sb);
	xfs_sb_t		*sbp = &mp->m_sb;
C
Christoph Hellwig 已提交
971
	struct xfs_inode	*ip = XFS_I(dentry->d_inode);
C
Christoph Hellwig 已提交
972 973
	__uint64_t		fakeinos, id;
	xfs_extlen_t		lsize;
974
	__int64_t		ffree;
C
Christoph Hellwig 已提交
975 976 977 978 979 980 981 982

	statp->f_type = XFS_SB_MAGIC;
	statp->f_namelen = MAXNAMELEN - 1;

	id = huge_encode_dev(mp->m_ddev_targp->bt_dev);
	statp->f_fsid.val[0] = (u32)id;
	statp->f_fsid.val[1] = (u32)(id >> 32);

983
	xfs_icsb_sync_counters(mp, XFS_ICSB_LAZY_COUNT);
C
Christoph Hellwig 已提交
984 985 986 987 988 989 990 991 992 993 994

	spin_lock(&mp->m_sb_lock);
	statp->f_bsize = sbp->sb_blocksize;
	lsize = sbp->sb_logstart ? sbp->sb_logblocks : 0;
	statp->f_blocks = sbp->sb_dblocks - lsize;
	statp->f_bfree = statp->f_bavail =
				sbp->sb_fdblocks - XFS_ALLOC_SET_ASIDE(mp);
	fakeinos = statp->f_bfree << sbp->sb_inopblog;
	statp->f_files =
	    MIN(sbp->sb_icount + fakeinos, (__uint64_t)XFS_MAXINUMBER);
	if (mp->m_maxicount)
C
Christoph Hellwig 已提交
995 996 997
		statp->f_files = min_t(typeof(statp->f_files),
					statp->f_files,
					mp->m_maxicount);
998 999 1000 1001 1002

	/* make sure statp->f_ffree does not underflow */
	ffree = statp->f_files - (sbp->sb_icount - sbp->sb_ifree);
	statp->f_ffree = max_t(__int64_t, ffree, 0);

C
Christoph Hellwig 已提交
1003 1004
	spin_unlock(&mp->m_sb_lock);

1005
	if ((ip->i_d.di_flags & XFS_DIFLAG_PROJINHERIT) &&
C
Christoph Hellwig 已提交
1006 1007 1008
	    ((mp->m_qflags & (XFS_PQUOTA_ACCT|XFS_OQUOTA_ENFD))) ==
			      (XFS_PQUOTA_ACCT|XFS_OQUOTA_ENFD))
		xfs_qm_statvfs(ip, statp);
C
Christoph Hellwig 已提交
1009
	return 0;
L
Linus Torvalds 已提交
1010 1011
}

E
Eric Sandeen 已提交
1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034
STATIC void
xfs_save_resvblks(struct xfs_mount *mp)
{
	__uint64_t resblks = 0;

	mp->m_resblks_save = mp->m_resblks;
	xfs_reserve_blocks(mp, &resblks, NULL);
}

STATIC void
xfs_restore_resvblks(struct xfs_mount *mp)
{
	__uint64_t resblks;

	if (mp->m_resblks_save) {
		resblks = mp->m_resblks_save;
		mp->m_resblks_save = 0;
	} else
		resblks = xfs_default_resblks(mp);

	xfs_reserve_blocks(mp, &resblks, NULL);
}

1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058
STATIC void
xfs_set_inode64(struct xfs_mount *mp)
{
	int i = 0;

	for (i = 0; i < mp->m_sb.sb_agcount; i++) {
		struct xfs_perag	*pag;

		pag = xfs_perag_get(mp, i);
		pag->pagi_inodeok = 1;
		pag->pagf_metadata = 0;
		xfs_perag_put(pag);
	}

	/* There is no need for lock protection on m_flags,
	 * the rw_semaphore of the VFS superblock is locked
	 * during mount/umount/remount operations, so this is
	 * enough to avoid concurency on the m_flags field
	 */
	mp->m_flags &= ~(XFS_MOUNT_32BITINODES |
			 XFS_MOUNT_SMALL_INUMS);
	mp->m_maxagi = i;
}

L
Linus Torvalds 已提交
1059
STATIC int
1060
xfs_fs_remount(
L
Linus Torvalds 已提交
1061 1062 1063 1064
	struct super_block	*sb,
	int			*flags,
	char			*options)
{
1065
	struct xfs_mount	*mp = XFS_M(sb);
1066 1067
	substring_t		args[MAX_OPT_ARGS];
	char			*p;
1068
	int			error;
L
Linus Torvalds 已提交
1069

1070 1071
	while ((p = strsep(&options, ",")) != NULL) {
		int token;
1072

1073 1074
		if (!*p)
			continue;
1075

1076 1077 1078
		token = match_token(p, tokens, args);
		switch (token) {
		case Opt_barrier:
1079
			mp->m_flags |= XFS_MOUNT_BARRIER;
1080 1081
			break;
		case Opt_nobarrier:
1082
			mp->m_flags &= ~XFS_MOUNT_BARRIER;
1083
			break;
1084 1085 1086
		case Opt_inode64:
			xfs_set_inode64(mp);
			break;
1087
		default:
1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104
			/*
			 * Logically we would return an error here to prevent
			 * users from believing they might have changed
			 * mount options using remount which can't be changed.
			 *
			 * But unfortunately mount(8) adds all options from
			 * mtab and fstab to the mount arguments in some cases
			 * so we can't blindly reject options, but have to
			 * check for each specified option if it actually
			 * differs from the currently set option and only
			 * reject it if that's the case.
			 *
			 * Until that is implemented we return success for
			 * every remount request, and silently ignore all
			 * options that we can't actually change.
			 */
#if 0
1105 1106
			xfs_info(mp,
		"mount option \"%s\" not supported for remount\n", p);
1107
			return -EINVAL;
1108
#else
1109
			break;
1110
#endif
1111
		}
1112 1113
	}

1114
	/* ro -> rw */
1115 1116
	if ((mp->m_flags & XFS_MOUNT_RDONLY) && !(*flags & MS_RDONLY)) {
		mp->m_flags &= ~XFS_MOUNT_RDONLY;
1117 1118 1119 1120 1121 1122 1123 1124

		/*
		 * If this is the first remount to writeable state we
		 * might have some superblock changes to update.
		 */
		if (mp->m_update_flags) {
			error = xfs_mount_log_sb(mp, mp->m_update_flags);
			if (error) {
1125
				xfs_warn(mp, "failed to write sb changes");
1126 1127 1128 1129
				return error;
			}
			mp->m_update_flags = 0;
		}
1130 1131 1132 1133 1134

		/*
		 * Fill out the reserve pool if it is empty. Use the stashed
		 * value if it is non-zero, otherwise go with the default.
		 */
E
Eric Sandeen 已提交
1135
		xfs_restore_resvblks(mp);
1136 1137 1138 1139
	}

	/* rw -> ro */
	if (!(mp->m_flags & XFS_MOUNT_RDONLY) && (*flags & MS_RDONLY)) {
1140 1141 1142 1143 1144 1145 1146 1147 1148
		/*
		 * After we have synced the data but before we sync the
		 * metadata, we need to free up the reserve block pool so that
		 * the used block count in the superblock on disk is correct at
		 * the end of the remount. Stash the current reserve pool size
		 * so that if we get remounted rw, we can return it to the same
		 * size.
		 */

1149
		xfs_quiesce_data(mp);
E
Eric Sandeen 已提交
1150
		xfs_save_resvblks(mp);
D
David Chinner 已提交
1151
		xfs_quiesce_attr(mp);
1152 1153 1154
		mp->m_flags |= XFS_MOUNT_RDONLY;
	}

1155
	return 0;
L
Linus Torvalds 已提交
1156 1157
}

C
Christoph Hellwig 已提交
1158 1159
/*
 * Second stage of a freeze. The data is already frozen so we only
D
David Chinner 已提交
1160
 * need to take care of the metadata. Once that's done write a dummy
C
Christoph Hellwig 已提交
1161 1162
 * record to dirty the log in case of a crash while frozen.
 */
1163 1164
STATIC int
xfs_fs_freeze(
L
Linus Torvalds 已提交
1165 1166
	struct super_block	*sb)
{
C
Christoph Hellwig 已提交
1167 1168
	struct xfs_mount	*mp = XFS_M(sb);

E
Eric Sandeen 已提交
1169
	xfs_save_resvblks(mp);
D
David Chinner 已提交
1170
	xfs_quiesce_attr(mp);
1171
	return -xfs_fs_log_dummy(mp);
L
Linus Torvalds 已提交
1172 1173
}

E
Eric Sandeen 已提交
1174 1175 1176 1177 1178 1179 1180 1181 1182 1183
STATIC int
xfs_fs_unfreeze(
	struct super_block	*sb)
{
	struct xfs_mount	*mp = XFS_M(sb);

	xfs_restore_resvblks(mp);
	return 0;
}

L
Linus Torvalds 已提交
1184
STATIC int
1185
xfs_fs_show_options(
L
Linus Torvalds 已提交
1186
	struct seq_file		*m,
1187
	struct dentry		*root)
L
Linus Torvalds 已提交
1188
{
1189
	return -xfs_showargs(XFS_M(root->d_sb), m);
L
Linus Torvalds 已提交
1190 1191
}

1192 1193 1194 1195 1196 1197 1198 1199 1200 1201
/*
 * This function fills in xfs_mount_t fields based on mount args.
 * Note: the superblock _has_ now been read in.
 */
STATIC int
xfs_finish_flags(
	struct xfs_mount	*mp)
{
	int			ronly = (mp->m_flags & XFS_MOUNT_RDONLY);

1202
	/* Fail a mount where the logbuf is smaller than the log stripe */
1203
	if (xfs_sb_version_haslogv2(&mp->m_sb)) {
1204 1205
		if (mp->m_logbsize <= 0 &&
		    mp->m_sb.sb_logsunit > XLOG_BIG_RECORD_BSIZE) {
1206
			mp->m_logbsize = mp->m_sb.sb_logsunit;
1207 1208
		} else if (mp->m_logbsize > 0 &&
			   mp->m_logbsize < mp->m_sb.sb_logsunit) {
1209 1210
			xfs_warn(mp,
		"logbuf size must be greater than or equal to log stripe size");
1211 1212 1213 1214
			return XFS_ERROR(EINVAL);
		}
	} else {
		/* Fail a mount if the logbuf is larger than 32K */
1215
		if (mp->m_logbsize > XLOG_BIG_RECORD_BSIZE) {
1216 1217
			xfs_warn(mp,
		"logbuf size for version 1 logs must be 16K or 32K");
1218 1219 1220 1221 1222 1223 1224 1225 1226
			return XFS_ERROR(EINVAL);
		}
	}

	/*
	 * mkfs'ed attr2 will turn on attr2 mount unless explicitly
	 * told by noattr2 to turn it off
	 */
	if (xfs_sb_version_hasattr2(&mp->m_sb) &&
1227
	    !(mp->m_flags & XFS_MOUNT_NOATTR2))
1228 1229 1230 1231 1232 1233
		mp->m_flags |= XFS_MOUNT_ATTR2;

	/*
	 * prohibit r/w mounts of read-only filesystems
	 */
	if ((mp->m_sb.sb_flags & XFS_SBF_READONLY) && !ronly) {
1234 1235
		xfs_warn(mp,
			"cannot mount a read-only filesystem as read-write");
1236 1237 1238 1239 1240 1241
		return XFS_ERROR(EROFS);
	}

	return 0;
}

L
Linus Torvalds 已提交
1242
STATIC int
1243
xfs_fs_fill_super(
L
Linus Torvalds 已提交
1244 1245 1246 1247
	struct super_block	*sb,
	void			*data,
	int			silent)
{
1248
	struct inode		*root;
1249
	struct xfs_mount	*mp = NULL;
C
Christoph Hellwig 已提交
1250
	int			flags = 0, error = ENOMEM;
1251

C
Christoph Hellwig 已提交
1252 1253
	mp = kzalloc(sizeof(struct xfs_mount), GFP_KERNEL);
	if (!mp)
1254
		goto out;
L
Linus Torvalds 已提交
1255

C
Christoph Hellwig 已提交
1256 1257 1258
	spin_lock_init(&mp->m_sb_lock);
	mutex_init(&mp->m_growlock);
	atomic_set(&mp->m_active_trans, 0);
1259

C
Christoph Hellwig 已提交
1260 1261
	mp->m_super = sb;
	sb->s_fs_info = mp;
L
Linus Torvalds 已提交
1262

C
Christoph Hellwig 已提交
1263
	error = xfs_parseargs(mp, (char *)data);
1264
	if (error)
1265
		goto out_free_fsname;
L
Linus Torvalds 已提交
1266 1267

	sb_min_blocksize(sb, BBSIZE);
1268
	sb->s_xattr = xfs_xattr_handlers;
1269
	sb->s_export_op = &xfs_export_operations;
1270
#ifdef CONFIG_XFS_QUOTA
1271
	sb->s_qcop = &xfs_quotactl_operations;
1272
#endif
1273
	sb->s_op = &xfs_super_operations;
L
Linus Torvalds 已提交
1274

1275
	if (silent)
1276 1277
		flags |= XFS_MFSI_QUIET;

1278
	error = xfs_open_devices(mp);
1279
	if (error)
C
Christoph Hellwig 已提交
1280
		goto out_free_fsname;
1281

1282
	error = xfs_init_mount_workqueues(mp);
1283 1284
	if (error)
		goto out_close_devices;
C
Christoph Hellwig 已提交
1285

1286 1287 1288 1289
	error = xfs_icsb_init_counters(mp);
	if (error)
		goto out_destroy_workqueues;

1290 1291
	error = xfs_readsb(mp, flags);
	if (error)
1292 1293 1294
		goto out_destroy_counters;

	error = xfs_finish_flags(mp);
1295
	if (error)
1296
		goto out_free_sb;
1297

1298
	error = xfs_setup_devices(mp);
1299
	if (error)
1300
		goto out_free_sb;
1301 1302 1303

	error = xfs_filestream_mount(mp);
	if (error)
1304
		goto out_free_sb;
1305

1306 1307 1308 1309 1310 1311 1312 1313
	/*
	 * we must configure the block size in the superblock before we run the
	 * full mount process as the mount process can lookup and cache inodes.
	 * For the same reason we must also initialise the syncd and register
	 * the inode cache shrinker so that inodes can be reclaimed during
	 * operations like a quotacheck that iterate all inodes in the
	 * filesystem.
	 */
C
Christoph Hellwig 已提交
1314 1315 1316
	sb->s_magic = XFS_SB_MAGIC;
	sb->s_blocksize = mp->m_sb.sb_blocksize;
	sb->s_blocksize_bits = ffs(sb->s_blocksize) - 1;
L
Linus Torvalds 已提交
1317
	sb->s_maxbytes = xfs_max_file_offset(sb->s_blocksize_bits);
1318
	sb->s_max_links = XFS_MAXLINK;
L
Linus Torvalds 已提交
1319 1320 1321
	sb->s_time_gran = 1;
	set_posix_acl_flag(sb);

1322
	error = xfs_syncd_init(mp);
1323
	if (error)
1324 1325
		goto out_filestream_unmount;

1326
	error = xfs_mountfs(mp);
1327
	if (error)
1328
		goto out_syncd_stop;
1329

1330
	root = igrab(VFS_I(mp->m_rootip));
1331
	if (!root) {
C
Christoph Hellwig 已提交
1332
		error = ENOENT;
1333
		goto out_unmount;
C
Christoph Hellwig 已提交
1334
	}
1335 1336
	if (is_bad_inode(root)) {
		error = EINVAL;
1337
		goto out_unmount;
L
Linus Torvalds 已提交
1338
	}
1339
	sb->s_root = d_make_root(root);
1340 1341
	if (!sb->s_root) {
		error = ENOMEM;
1342
		goto out_unmount;
L
Linus Torvalds 已提交
1343
	}
1344

L
Linus Torvalds 已提交
1345
	return 0;
1346 1347
 out_syncd_stop:
	xfs_syncd_stop(mp);
1348 1349
 out_filestream_unmount:
	xfs_filestream_unmount(mp);
1350 1351
 out_free_sb:
	xfs_freesb(mp);
1352
 out_destroy_counters:
C
Christoph Hellwig 已提交
1353
	xfs_icsb_destroy_counters(mp);
1354 1355
out_destroy_workqueues:
	xfs_destroy_mount_workqueues(mp);
1356
 out_close_devices:
1357
	xfs_close_devices(mp);
1358 1359
 out_free_fsname:
	xfs_free_fsname(mp);
C
Christoph Hellwig 已提交
1360
	kfree(mp);
1361
 out:
C
Christoph Hellwig 已提交
1362
	return -error;
1363

1364
 out_unmount:
1365
	xfs_filestream_unmount(mp);
1366
	xfs_unmountfs(mp);
1367
	xfs_syncd_stop(mp);
1368
	goto out_free_sb;
L
Linus Torvalds 已提交
1369 1370
}

A
Al Viro 已提交
1371 1372
STATIC struct dentry *
xfs_fs_mount(
L
Linus Torvalds 已提交
1373 1374 1375
	struct file_system_type	*fs_type,
	int			flags,
	const char		*dev_name,
A
Al Viro 已提交
1376
	void			*data)
L
Linus Torvalds 已提交
1377
{
A
Al Viro 已提交
1378
	return mount_bdev(fs_type, flags, dev_name, data, xfs_fs_fill_super);
1379 1380
}

1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395
static int
xfs_fs_nr_cached_objects(
	struct super_block	*sb)
{
	return xfs_reclaim_inodes_count(XFS_M(sb));
}

static void
xfs_fs_free_cached_objects(
	struct super_block	*sb,
	int			nr_to_scan)
{
	xfs_reclaim_inodes_nr(XFS_M(sb), nr_to_scan);
}

1396
static const struct super_operations xfs_super_operations = {
1397 1398
	.alloc_inode		= xfs_fs_alloc_inode,
	.destroy_inode		= xfs_fs_destroy_inode,
1399
	.evict_inode		= xfs_fs_evict_inode,
1400
	.drop_inode		= xfs_fs_drop_inode,
1401
	.put_super		= xfs_fs_put_super,
C
Christoph Hellwig 已提交
1402
	.sync_fs		= xfs_fs_sync_fs,
1403
	.freeze_fs		= xfs_fs_freeze,
E
Eric Sandeen 已提交
1404
	.unfreeze_fs		= xfs_fs_unfreeze,
1405 1406 1407
	.statfs			= xfs_fs_statfs,
	.remount_fs		= xfs_fs_remount,
	.show_options		= xfs_fs_show_options,
1408 1409
	.nr_cached_objects	= xfs_fs_nr_cached_objects,
	.free_cached_objects	= xfs_fs_free_cached_objects,
L
Linus Torvalds 已提交
1410 1411
};

A
Andrew Morton 已提交
1412
static struct file_system_type xfs_fs_type = {
L
Linus Torvalds 已提交
1413 1414
	.owner			= THIS_MODULE,
	.name			= "xfs",
A
Al Viro 已提交
1415
	.mount			= xfs_fs_mount,
L
Linus Torvalds 已提交
1416 1417 1418 1419
	.kill_sb		= kill_block_super,
	.fs_flags		= FS_REQUIRES_DEV,
};

1420 1421 1422 1423 1424 1425
STATIC int __init
xfs_init_zones(void)
{

	xfs_ioend_zone = kmem_zone_init(sizeof(xfs_ioend_t), "xfs_ioend");
	if (!xfs_ioend_zone)
1426
		goto out;
1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441

	xfs_ioend_pool = mempool_create_slab_pool(4 * MAX_BUF_PER_PAGE,
						  xfs_ioend_zone);
	if (!xfs_ioend_pool)
		goto out_destroy_ioend_zone;

	xfs_log_ticket_zone = kmem_zone_init(sizeof(xlog_ticket_t),
						"xfs_log_ticket");
	if (!xfs_log_ticket_zone)
		goto out_destroy_ioend_pool;

	xfs_bmap_free_item_zone = kmem_zone_init(sizeof(xfs_bmap_free_item_t),
						"xfs_bmap_free_item");
	if (!xfs_bmap_free_item_zone)
		goto out_destroy_log_ticket_zone;
1442

1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454
	xfs_btree_cur_zone = kmem_zone_init(sizeof(xfs_btree_cur_t),
						"xfs_btree_cur");
	if (!xfs_btree_cur_zone)
		goto out_destroy_bmap_free_item_zone;

	xfs_da_state_zone = kmem_zone_init(sizeof(xfs_da_state_t),
						"xfs_da_state");
	if (!xfs_da_state_zone)
		goto out_destroy_btree_cur_zone;

	xfs_ifork_zone = kmem_zone_init(sizeof(xfs_ifork_t), "xfs_ifork");
	if (!xfs_ifork_zone)
1455
		goto out_destroy_da_state_zone;
1456 1457 1458 1459 1460

	xfs_trans_zone = kmem_zone_init(sizeof(xfs_trans_t), "xfs_trans");
	if (!xfs_trans_zone)
		goto out_destroy_ifork_zone;

1461 1462 1463 1464 1465 1466
	xfs_log_item_desc_zone =
		kmem_zone_init(sizeof(struct xfs_log_item_desc),
			       "xfs_log_item_desc");
	if (!xfs_log_item_desc_zone)
		goto out_destroy_trans_zone;

1467 1468 1469 1470 1471
	/*
	 * The size of the zone allocated buf log item is the maximum
	 * size possible under XFS.  This wastes a little bit of memory,
	 * but it is much faster.
	 */
1472 1473
	xfs_buf_item_zone = kmem_zone_init(sizeof(struct xfs_buf_log_item),
					   "xfs_buf_item");
1474
	if (!xfs_buf_item_zone)
1475
		goto out_destroy_log_item_desc_zone;
1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490

	xfs_efd_zone = kmem_zone_init((sizeof(xfs_efd_log_item_t) +
			((XFS_EFD_MAX_FAST_EXTENTS - 1) *
				 sizeof(xfs_extent_t))), "xfs_efd_item");
	if (!xfs_efd_zone)
		goto out_destroy_buf_item_zone;

	xfs_efi_zone = kmem_zone_init((sizeof(xfs_efi_log_item_t) +
			((XFS_EFI_MAX_FAST_EXTENTS - 1) *
				sizeof(xfs_extent_t))), "xfs_efi_item");
	if (!xfs_efi_zone)
		goto out_destroy_efd_zone;

	xfs_inode_zone =
		kmem_zone_init_flags(sizeof(xfs_inode_t), "xfs_inode",
1491 1492
			KM_ZONE_HWALIGN | KM_ZONE_RECLAIM | KM_ZONE_SPREAD,
			xfs_fs_inode_init_once);
1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511
	if (!xfs_inode_zone)
		goto out_destroy_efi_zone;

	xfs_ili_zone =
		kmem_zone_init_flags(sizeof(xfs_inode_log_item_t), "xfs_ili",
					KM_ZONE_SPREAD, NULL);
	if (!xfs_ili_zone)
		goto out_destroy_inode_zone;

	return 0;

 out_destroy_inode_zone:
	kmem_zone_destroy(xfs_inode_zone);
 out_destroy_efi_zone:
	kmem_zone_destroy(xfs_efi_zone);
 out_destroy_efd_zone:
	kmem_zone_destroy(xfs_efd_zone);
 out_destroy_buf_item_zone:
	kmem_zone_destroy(xfs_buf_item_zone);
1512 1513
 out_destroy_log_item_desc_zone:
	kmem_zone_destroy(xfs_log_item_desc_zone);
1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541
 out_destroy_trans_zone:
	kmem_zone_destroy(xfs_trans_zone);
 out_destroy_ifork_zone:
	kmem_zone_destroy(xfs_ifork_zone);
 out_destroy_da_state_zone:
	kmem_zone_destroy(xfs_da_state_zone);
 out_destroy_btree_cur_zone:
	kmem_zone_destroy(xfs_btree_cur_zone);
 out_destroy_bmap_free_item_zone:
	kmem_zone_destroy(xfs_bmap_free_item_zone);
 out_destroy_log_ticket_zone:
	kmem_zone_destroy(xfs_log_ticket_zone);
 out_destroy_ioend_pool:
	mempool_destroy(xfs_ioend_pool);
 out_destroy_ioend_zone:
	kmem_zone_destroy(xfs_ioend_zone);
 out:
	return -ENOMEM;
}

STATIC void
xfs_destroy_zones(void)
{
	kmem_zone_destroy(xfs_ili_zone);
	kmem_zone_destroy(xfs_inode_zone);
	kmem_zone_destroy(xfs_efi_zone);
	kmem_zone_destroy(xfs_efd_zone);
	kmem_zone_destroy(xfs_buf_item_zone);
1542
	kmem_zone_destroy(xfs_log_item_desc_zone);
1543 1544 1545 1546 1547 1548 1549 1550 1551 1552
	kmem_zone_destroy(xfs_trans_zone);
	kmem_zone_destroy(xfs_ifork_zone);
	kmem_zone_destroy(xfs_da_state_zone);
	kmem_zone_destroy(xfs_btree_cur_zone);
	kmem_zone_destroy(xfs_bmap_free_item_zone);
	kmem_zone_destroy(xfs_log_ticket_zone);
	mempool_destroy(xfs_ioend_pool);
	kmem_zone_destroy(xfs_ioend_zone);

}
L
Linus Torvalds 已提交
1553

1554 1555 1556 1557
STATIC int __init
xfs_init_workqueues(void)
{
	/*
1558 1559 1560 1561
	 * We never want to the same work item to run twice, reclaiming inodes
	 * or idling the log is not going to get any faster by multiple CPUs
	 * competing for ressources.  Use the default large max_active value
	 * so that even lots of filesystems can perform these task in parallel.
1562
	 */
1563
	xfs_syncd_wq = alloc_workqueue("xfssyncd", WQ_NON_REENTRANT, 0);
1564
	if (!xfs_syncd_wq)
1565
		return -ENOMEM;
1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576

	/*
	 * The allocation workqueue can be used in memory reclaim situations
	 * (writepage path), and parallelism is only limited by the number of
	 * AGs in all the filesystems mounted. Hence use the default large
	 * max_active value for this workqueue.
	 */
	xfs_alloc_wq = alloc_workqueue("xfsalloc", WQ_MEM_RECLAIM, 0);
	if (!xfs_alloc_wq)
		goto out_destroy_syncd;

1577
	return 0;
1578 1579 1580 1581

out_destroy_syncd:
	destroy_workqueue(xfs_syncd_wq);
	return -ENOMEM;
1582 1583
}

1584
STATIC void
1585 1586
xfs_destroy_workqueues(void)
{
1587
	destroy_workqueue(xfs_alloc_wq);
1588 1589 1590
	destroy_workqueue(xfs_syncd_wq);
}

L
Linus Torvalds 已提交
1591
STATIC int __init
1592
init_xfs_fs(void)
L
Linus Torvalds 已提交
1593 1594 1595
{
	int			error;

1596 1597
	printk(KERN_INFO XFS_VERSION_STRING " with "
			 XFS_BUILD_OPTIONS " enabled\n");
L
Linus Torvalds 已提交
1598

1599
	xfs_dir_startup();
L
Linus Torvalds 已提交
1600

1601
	error = xfs_init_zones();
1602 1603 1604
	if (error)
		goto out;

1605
	error = xfs_init_workqueues();
1606
	if (error)
C
Christoph Hellwig 已提交
1607
		goto out_destroy_zones;
1608

1609 1610 1611 1612
	error = xfs_mru_cache_init();
	if (error)
		goto out_destroy_wq;

1613 1614 1615
	error = xfs_filestream_init();
	if (error)
		goto out_mru_cache_uninit;
L
Linus Torvalds 已提交
1616

1617
	error = xfs_buf_init();
1618 1619 1620 1621 1622 1623 1624 1625 1626 1627
	if (error)
		goto out_filestream_uninit;

	error = xfs_init_procfs();
	if (error)
		goto out_buf_terminate;

	error = xfs_sysctl_register();
	if (error)
		goto out_cleanup_procfs;
L
Linus Torvalds 已提交
1628

1629 1630 1631
	error = xfs_qm_init();
	if (error)
		goto out_sysctl_unregister;
L
Linus Torvalds 已提交
1632 1633 1634

	error = register_filesystem(&xfs_fs_type);
	if (error)
1635
		goto out_qm_exit;
L
Linus Torvalds 已提交
1636 1637
	return 0;

1638 1639
 out_qm_exit:
	xfs_qm_exit();
1640 1641 1642 1643 1644
 out_sysctl_unregister:
	xfs_sysctl_unregister();
 out_cleanup_procfs:
	xfs_cleanup_procfs();
 out_buf_terminate:
1645
	xfs_buf_terminate();
1646 1647 1648 1649
 out_filestream_uninit:
	xfs_filestream_uninit();
 out_mru_cache_uninit:
	xfs_mru_cache_uninit();
1650 1651
 out_destroy_wq:
	xfs_destroy_workqueues();
1652
 out_destroy_zones:
1653
	xfs_destroy_zones();
1654
 out:
L
Linus Torvalds 已提交
1655 1656 1657 1658
	return error;
}

STATIC void __exit
1659
exit_xfs_fs(void)
L
Linus Torvalds 已提交
1660
{
1661
	xfs_qm_exit();
L
Linus Torvalds 已提交
1662
	unregister_filesystem(&xfs_fs_type);
1663 1664
	xfs_sysctl_unregister();
	xfs_cleanup_procfs();
1665
	xfs_buf_terminate();
1666 1667
	xfs_filestream_uninit();
	xfs_mru_cache_uninit();
1668
	xfs_destroy_workqueues();
1669
	xfs_destroy_zones();
L
Linus Torvalds 已提交
1670 1671 1672 1673 1674 1675 1676 1677
}

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");