xfs_super.c 49.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
#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 30
#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"
31
#include "xfs_alloc_btree.h"
L
Linus Torvalds 已提交
32 33
#include "xfs_ialloc_btree.h"
#include "xfs_dir2_sf.h"
34
#include "xfs_attr_sf.h"
L
Linus Torvalds 已提交
35 36
#include "xfs_dinode.h"
#include "xfs_inode.h"
37
#include "xfs_btree.h"
38
#include "xfs_btree_trace.h"
39
#include "xfs_ialloc.h"
L
Linus Torvalds 已提交
40 41 42 43
#include "xfs_bmap.h"
#include "xfs_rtalloc.h"
#include "xfs_error.h"
#include "xfs_itable.h"
C
Christoph Hellwig 已提交
44
#include "xfs_fsops.h"
L
Linus Torvalds 已提交
45 46 47 48 49
#include "xfs_rw.h"
#include "xfs_acl.h"
#include "xfs_attr.h"
#include "xfs_buf_item.h"
#include "xfs_utils.h"
50
#include "xfs_vnodeops.h"
51
#include "xfs_vfsops.h"
L
Linus Torvalds 已提交
52
#include "xfs_version.h"
53
#include "xfs_log_priv.h"
54
#include "xfs_trans_priv.h"
55
#include "xfs_filestream.h"
56 57 58 59 60
#include "xfs_da_btree.h"
#include "xfs_dir2_trace.h"
#include "xfs_extfree_item.h"
#include "xfs_mru_cache.h"
#include "xfs_inode_item.h"
61
#include "xfs_sync.h"
L
Linus Torvalds 已提交
62 63 64 65

#include <linux/namei.h>
#include <linux/init.h>
#include <linux/mount.h>
66
#include <linux/mempool.h>
L
Linus Torvalds 已提交
67
#include <linux/writeback.h>
68
#include <linux/kthread.h>
69
#include <linux/freezer.h>
70
#include <linux/parser.h>
L
Linus Torvalds 已提交
71

72 73 74
static struct quotactl_ops xfs_quotactl_operations;
static struct super_operations xfs_super_operations;
static kmem_zone_t *xfs_ioend_zone;
75
mempool_t *xfs_ioend_pool;
L
Linus Torvalds 已提交
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 111 112 113 114 115 116 117 118 119 120 121 122 123 124
#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_INO64	"ino64"		/* force inodes into 64-bit range */
#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_OSYNCISOSYNC "osyncisosync" /* o_sync is REALLY o_sync */
#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 */
#define MNTOPT_DMAPI	"dmapi"		/* DMI enabled (DMAPI / XDSM) */
#define MNTOPT_XDSM	"xdsm"		/* DMI enabled (DMAPI / XDSM) */
#define MNTOPT_DMI	"dmi"		/* DMI enabled (DMAPI / XDSM) */

125 126 127 128 129 130 131 132 133 134
/*
 * Table driven mount option parser.
 *
 * Currently only used for remount, but it will be used for mount
 * in the future, too.
 */
enum {
	Opt_barrier, Opt_nobarrier, Opt_err
};

135
static const match_table_t tokens = {
136 137 138 139 140 141
	{Opt_barrier, "barrier"},
	{Opt_nobarrier, "nobarrier"},
	{Opt_err, NULL}
};


142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164
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;
}

165 166 167 168 169 170 171
/*
 * 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.
 */
172 173 174 175
STATIC int
xfs_parseargs(
	struct xfs_mount	*mp,
	char			*options,
176
	char			**mtpt)
177
{
178
	struct super_block	*sb = mp->m_super;
179
	char			*this_char, *value, *eov;
180 181 182
	int			dsunit = 0;
	int			dswidth = 0;
	int			iosize = 0;
183
	int			dmapi_implies_ikeep = 1;
184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202
	uchar_t			iosizelog = 0;

	/*
	 * 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;
203

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

	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) {
				cmn_err(CE_WARN,
					"XFS: %s option requires an argument",
					this_char);
				return EINVAL;
			}
226
			mp->m_logbufs = simple_strtoul(value, &eov, 10);
227 228 229 230 231 232 233
		} else if (!strcmp(this_char, MNTOPT_LOGBSIZE)) {
			if (!value || !*value) {
				cmn_err(CE_WARN,
					"XFS: %s option requires an argument",
					this_char);
				return EINVAL;
			}
234
			mp->m_logbsize = suffix_strtoul(value, &eov, 10);
235 236 237 238 239 240 241
		} else if (!strcmp(this_char, MNTOPT_LOGDEV)) {
			if (!value || !*value) {
				cmn_err(CE_WARN,
					"XFS: %s option requires an argument",
					this_char);
				return EINVAL;
			}
242 243 244
			mp->m_logname = kstrndup(value, MAXNAMELEN, GFP_KERNEL);
			if (!mp->m_logname)
				return ENOMEM;
245 246 247 248 249 250 251
		} else if (!strcmp(this_char, MNTOPT_MTPT)) {
			if (!value || !*value) {
				cmn_err(CE_WARN,
					"XFS: %s option requires an argument",
					this_char);
				return EINVAL;
			}
252 253 254
			*mtpt = kstrndup(value, MAXNAMELEN, GFP_KERNEL);
			if (!*mtpt)
				return ENOMEM;
255 256 257 258 259 260 261
		} else if (!strcmp(this_char, MNTOPT_RTDEV)) {
			if (!value || !*value) {
				cmn_err(CE_WARN,
					"XFS: %s option requires an argument",
					this_char);
				return EINVAL;
			}
262 263 264
			mp->m_rtname = kstrndup(value, MAXNAMELEN, GFP_KERNEL);
			if (!mp->m_rtname)
				return ENOMEM;
265 266 267 268 269 270 271 272
		} else if (!strcmp(this_char, MNTOPT_BIOSIZE)) {
			if (!value || !*value) {
				cmn_err(CE_WARN,
					"XFS: %s option requires an argument",
					this_char);
				return EINVAL;
			}
			iosize = simple_strtoul(value, &eov, 10);
273
			iosizelog = (uint8_t) iosize;
274 275 276 277 278 279 280 281
		} else if (!strcmp(this_char, MNTOPT_ALLOCSIZE)) {
			if (!value || !*value) {
				cmn_err(CE_WARN,
					"XFS: %s option requires an argument",
					this_char);
				return EINVAL;
			}
			iosize = suffix_strtoul(value, &eov, 10);
282
			iosizelog = ffs(iosize) - 1;
283 284 285 286 287 288 289
		} 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)) {
290
			mp->m_flags |= XFS_MOUNT_WSYNC;
291
		} else if (!strcmp(this_char, MNTOPT_OSYNCISOSYNC)) {
292
			mp->m_flags |= XFS_MOUNT_OSYNCISOSYNC;
293
		} else if (!strcmp(this_char, MNTOPT_NORECOVERY)) {
294
			mp->m_flags |= XFS_MOUNT_NORECOVERY;
295
		} else if (!strcmp(this_char, MNTOPT_INO64)) {
296 297 298 299
#if XFS_BIG_INUMS
			mp->m_flags |= XFS_MOUNT_INO64;
			mp->m_inoadd = XFS_INO64_OFFSET;
#else
300 301 302 303 304 305
			cmn_err(CE_WARN,
				"XFS: %s option not allowed on this system",
				this_char);
			return EINVAL;
#endif
		} else if (!strcmp(this_char, MNTOPT_NOALIGN)) {
306
			mp->m_flags |= XFS_MOUNT_NOALIGN;
307
		} else if (!strcmp(this_char, MNTOPT_SWALLOC)) {
308
			mp->m_flags |= XFS_MOUNT_SWALLOC;
309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325
		} else if (!strcmp(this_char, MNTOPT_SUNIT)) {
			if (!value || !*value) {
				cmn_err(CE_WARN,
					"XFS: %s option requires an argument",
					this_char);
				return EINVAL;
			}
			dsunit = simple_strtoul(value, &eov, 10);
		} else if (!strcmp(this_char, MNTOPT_SWIDTH)) {
			if (!value || !*value) {
				cmn_err(CE_WARN,
					"XFS: %s option requires an argument",
					this_char);
				return EINVAL;
			}
			dswidth = simple_strtoul(value, &eov, 10);
		} else if (!strcmp(this_char, MNTOPT_64BITINODE)) {
326
			mp->m_flags &= ~XFS_MOUNT_SMALL_INUMS;
327 328 329 330 331 332 333
#if !XFS_BIG_INUMS
			cmn_err(CE_WARN,
				"XFS: %s option not allowed on this system",
				this_char);
			return EINVAL;
#endif
		} else if (!strcmp(this_char, MNTOPT_NOUUID)) {
334
			mp->m_flags |= XFS_MOUNT_NOUUID;
335
		} else if (!strcmp(this_char, MNTOPT_BARRIER)) {
336
			mp->m_flags |= XFS_MOUNT_BARRIER;
337
		} else if (!strcmp(this_char, MNTOPT_NOBARRIER)) {
338
			mp->m_flags &= ~XFS_MOUNT_BARRIER;
339
		} else if (!strcmp(this_char, MNTOPT_IKEEP)) {
340
			mp->m_flags |= XFS_MOUNT_IKEEP;
341
		} else if (!strcmp(this_char, MNTOPT_NOIKEEP)) {
342
			dmapi_implies_ikeep = 0;
343
			mp->m_flags &= ~XFS_MOUNT_IKEEP;
344
		} else if (!strcmp(this_char, MNTOPT_LARGEIO)) {
345
			mp->m_flags &= ~XFS_MOUNT_COMPAT_IOSIZE;
346
		} else if (!strcmp(this_char, MNTOPT_NOLARGEIO)) {
347
			mp->m_flags |= XFS_MOUNT_COMPAT_IOSIZE;
348
		} else if (!strcmp(this_char, MNTOPT_ATTR2)) {
349
			mp->m_flags |= XFS_MOUNT_ATTR2;
350
		} else if (!strcmp(this_char, MNTOPT_NOATTR2)) {
351 352
			mp->m_flags &= ~XFS_MOUNT_ATTR2;
			mp->m_flags |= XFS_MOUNT_NOATTR2;
353
		} else if (!strcmp(this_char, MNTOPT_FILESTREAM)) {
354
			mp->m_flags |= XFS_MOUNT_FILESTREAMS;
355
		} else if (!strcmp(this_char, MNTOPT_NOQUOTA)) {
356 357
			mp->m_qflags &= ~(XFS_UQUOTA_ACCT | XFS_UQUOTA_ACTIVE |
					  XFS_GQUOTA_ACCT | XFS_GQUOTA_ACTIVE |
358
					  XFS_PQUOTA_ACCT | XFS_PQUOTA_ACTIVE |
359
					  XFS_UQUOTA_ENFD | XFS_OQUOTA_ENFD);
360 361 362
		} else if (!strcmp(this_char, MNTOPT_QUOTA) ||
			   !strcmp(this_char, MNTOPT_UQUOTA) ||
			   !strcmp(this_char, MNTOPT_USRQUOTA)) {
363 364
			mp->m_qflags |= (XFS_UQUOTA_ACCT | XFS_UQUOTA_ACTIVE |
					 XFS_UQUOTA_ENFD);
365 366
		} else if (!strcmp(this_char, MNTOPT_QUOTANOENF) ||
			   !strcmp(this_char, MNTOPT_UQUOTANOENF)) {
367 368
			mp->m_qflags |= (XFS_UQUOTA_ACCT | XFS_UQUOTA_ACTIVE);
			mp->m_qflags &= ~XFS_UQUOTA_ENFD;
369 370
		} else if (!strcmp(this_char, MNTOPT_PQUOTA) ||
			   !strcmp(this_char, MNTOPT_PRJQUOTA)) {
371 372
			mp->m_qflags |= (XFS_PQUOTA_ACCT | XFS_PQUOTA_ACTIVE |
					 XFS_OQUOTA_ENFD);
373
		} else if (!strcmp(this_char, MNTOPT_PQUOTANOENF)) {
374 375
			mp->m_qflags |= (XFS_PQUOTA_ACCT | XFS_PQUOTA_ACTIVE);
			mp->m_qflags &= ~XFS_OQUOTA_ENFD;
376 377
		} else if (!strcmp(this_char, MNTOPT_GQUOTA) ||
			   !strcmp(this_char, MNTOPT_GRPQUOTA)) {
378 379
			mp->m_qflags |= (XFS_GQUOTA_ACCT | XFS_GQUOTA_ACTIVE |
					 XFS_OQUOTA_ENFD);
380
		} else if (!strcmp(this_char, MNTOPT_GQUOTANOENF)) {
381 382
			mp->m_qflags |= (XFS_GQUOTA_ACCT | XFS_GQUOTA_ACTIVE);
			mp->m_qflags &= ~XFS_OQUOTA_ENFD;
383
		} else if (!strcmp(this_char, MNTOPT_DMAPI)) {
384
			mp->m_flags |= XFS_MOUNT_DMAPI;
385
		} else if (!strcmp(this_char, MNTOPT_XDSM)) {
386
			mp->m_flags |= XFS_MOUNT_DMAPI;
387
		} else if (!strcmp(this_char, MNTOPT_DMI)) {
388
			mp->m_flags |= XFS_MOUNT_DMAPI;
389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405
		} else if (!strcmp(this_char, "ihashsize")) {
			cmn_err(CE_WARN,
	"XFS: ihashsize no longer used, option is deprecated.");
		} else if (!strcmp(this_char, "osyncisdsync")) {
			/* no-op, this is now the default */
			cmn_err(CE_WARN,
	"XFS: osyncisdsync is now the default, option is deprecated.");
		} else if (!strcmp(this_char, "irixsgid")) {
			cmn_err(CE_WARN,
	"XFS: irixsgid is now a sysctl(2) variable, option is deprecated.");
		} else {
			cmn_err(CE_WARN,
				"XFS: unknown mount option [%s].", this_char);
			return EINVAL;
		}
	}

406 407 408 409 410 411 412
	/*
	 * no recovery flag requires a read-only mount
	 */
	if ((mp->m_flags & XFS_MOUNT_NORECOVERY) &&
	    !(mp->m_flags & XFS_MOUNT_RDONLY)) {
		cmn_err(CE_WARN, "XFS: no-recovery mounts must be read-only.");
		return EINVAL;
413 414
	}

415
	if ((mp->m_flags & XFS_MOUNT_NOALIGN) && (dsunit || dswidth)) {
416 417 418 419 420
		cmn_err(CE_WARN,
	"XFS: sunit and swidth options incompatible with the noalign option");
		return EINVAL;
	}

421 422
	if ((mp->m_qflags & (XFS_GQUOTA_ACCT | XFS_GQUOTA_ACTIVE)) &&
	    (mp->m_qflags & (XFS_PQUOTA_ACCT | XFS_PQUOTA_ACTIVE))) {
423 424 425 426 427
		cmn_err(CE_WARN,
			"XFS: cannot mount with both project and group quota");
		return EINVAL;
	}

428
	if ((mp->m_flags & XFS_MOUNT_DMAPI) && (!*mtpt || *mtpt[0] == '\0')) {
429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455
		printk("XFS: %s option needs the mount point option as well\n",
			MNTOPT_DMAPI);
		return EINVAL;
	}

	if ((dsunit && !dswidth) || (!dsunit && dswidth)) {
		cmn_err(CE_WARN,
			"XFS: sunit and swidth must be specified together");
		return EINVAL;
	}

	if (dsunit && (dswidth % dsunit != 0)) {
		cmn_err(CE_WARN,
	"XFS: stripe width (%d) must be a multiple of the stripe unit (%d)",
			dswidth, dsunit);
		return EINVAL;
	}

	/*
	 * Applications using DMI filesystems often expect the
	 * inode generation number to be monotonically increasing.
	 * If we delete inode chunks we break this assumption, so
	 * keep unused inode chunks on disk for DMI filesystems
	 * until we come up with a better solution.
	 * Note that if "ikeep" or "noikeep" mount options are
	 * supplied, then they are honored.
	 */
456 457
	if ((mp->m_flags & XFS_MOUNT_DMAPI) && dmapi_implies_ikeep)
		mp->m_flags |= XFS_MOUNT_IKEEP;
458

459 460 461 462 463 464 465 466
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.
		 */
467
		if (dsunit) {
468 469
			mp->m_dalign = dsunit;
			mp->m_flags |= XFS_MOUNT_RETERR;
470
		}
471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513

		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)) {
		cmn_err(CE_WARN,
			"XFS: invalid logbufs value: %d [not %d-%d]",
			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))) {
		cmn_err(CE_WARN,
	"XFS: invalid logbufsize: %d [not 16k,32k,64k,128k or 256k]",
			mp->m_logbsize);
		return XFS_ERROR(EINVAL);
	}

	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;

	if (iosizelog) {
		if (iosizelog > XFS_MAX_IO_LOG ||
		    iosizelog < XFS_MIN_IO_LOG) {
			cmn_err(CE_WARN,
		"XFS: invalid log iosize: %d [not %d-%d]",
				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;
514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530
	}

	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 */
531
		{ XFS_MOUNT_IKEEP,		"," MNTOPT_IKEEP },
532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603
		{ XFS_MOUNT_WSYNC,		"," MNTOPT_WSYNC },
		{ XFS_MOUNT_INO64,		"," MNTOPT_INO64 },
		{ XFS_MOUNT_NOALIGN,		"," MNTOPT_NOALIGN },
		{ XFS_MOUNT_SWALLOC,		"," MNTOPT_SWALLOC },
		{ XFS_MOUNT_NOUUID,		"," MNTOPT_NOUUID },
		{ XFS_MOUNT_NORECOVERY,		"," MNTOPT_NORECOVERY },
		{ XFS_MOUNT_OSYNCISOSYNC,	"," MNTOPT_OSYNCISOSYNC },
		{ XFS_MOUNT_ATTR2,		"," MNTOPT_ATTR2 },
		{ XFS_MOUNT_FILESTREAMS,	"," MNTOPT_FILESTREAM },
		{ XFS_MOUNT_DMAPI,		"," MNTOPT_DMAPI },
		{ XFS_MOUNT_GRPID,		"," MNTOPT_GRPID },
		{ 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);

	if (mp->m_qflags & (XFS_PQUOTA_ACCT|XFS_OQUOTA_ENFD))
		seq_puts(m, "," MNTOPT_PRJQUOTA);
	else if (mp->m_qflags & XFS_PQUOTA_ACCT)
		seq_puts(m, "," MNTOPT_PQUOTANOENF);

	if (mp->m_qflags & (XFS_GQUOTA_ACCT|XFS_OQUOTA_ENFD))
		seq_puts(m, "," MNTOPT_GRPQUOTA);
	else if (mp->m_qflags & XFS_GQUOTA_ACCT)
		seq_puts(m, "," MNTOPT_GQUOTANOENF);

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

	return 0;
}
L
Linus Torvalds 已提交
604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645
__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;
}

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

646
	*bdevp = open_bdev_exclusive(name, FMODE_READ|FMODE_WRITE, mp);
L
Linus Torvalds 已提交
647 648 649 650 651 652 653 654 655 656 657 658 659
	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)
660
		close_bdev_exclusive(bdev, FMODE_READ|FMODE_WRITE);
L
Linus Torvalds 已提交
661 662
}

663 664 665 666 667 668 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 694 695 696 697 698 699 700 701 702 703 704 705
/*
 * 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;
706
		return;
707 708
	}

709 710 711 712 713 714 715
	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;
	}

716 717 718 719 720
	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;
721
		return;
722 723 724 725 726 727 728
	}
}

void
xfs_blkdev_issue_flush(
	xfs_buftarg_t		*buftarg)
{
729
	blkdev_issue_flush(buftarg->bt_bdev, NULL);
730
}
L
Linus Torvalds 已提交
731

732 733 734 735 736
STATIC void
xfs_close_devices(
	struct xfs_mount	*mp)
{
	if (mp->m_logdev_targp && mp->m_logdev_targp != mp->m_ddev_targp) {
737
		struct block_device *logdev = mp->m_logdev_targp->bt_bdev;
738
		xfs_free_buftarg(mp->m_logdev_targp);
739
		xfs_blkdev_put(logdev);
740 741
	}
	if (mp->m_rtdev_targp) {
742
		struct block_device *rtdev = mp->m_rtdev_targp->bt_bdev;
743
		xfs_free_buftarg(mp->m_rtdev_targp);
744
		xfs_blkdev_put(rtdev);
745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760
	}
	xfs_free_buftarg(mp->m_ddev_targp);
}

/*
 * 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(
761
	struct xfs_mount	*mp)
762 763 764 765 766 767 768 769
{
	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.
	 */
770 771
	if (mp->m_logname) {
		error = xfs_blkdev_get(mp, mp->m_logname, &logdev);
772 773 774 775
		if (error)
			goto out;
	}

776 777
	if (mp->m_rtname) {
		error = xfs_blkdev_get(mp, mp->m_rtname, &rtdev);
778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827
		if (error)
			goto out_close_logdev;

		if (rtdev == ddev || rtdev == logdev) {
			cmn_err(CE_WARN,
	"XFS: Cannot mount filesystem with identical rtdev and ddev/logdev.");
			error = EINVAL;
			goto out_close_rtdev;
		}
	}

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

	if (rtdev) {
		mp->m_rtdev_targp = xfs_alloc_buftarg(rtdev, 1);
		if (!mp->m_rtdev_targp)
			goto out_free_ddev_targ;
	}

	if (logdev && logdev != ddev) {
		mp->m_logdev_targp = xfs_alloc_buftarg(logdev, 1);
		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)
		xfs_free_buftarg(mp->m_rtdev_targp);
 out_free_ddev_targ:
	xfs_free_buftarg(mp->m_ddev_targp);
 out_close_rtdev:
	if (rtdev)
		xfs_blkdev_put(rtdev);
 out_close_logdev:
	if (logdev && logdev != ddev)
		xfs_blkdev_put(logdev);
 out:
	return error;
}

828 829 830 831 832 833 834 835
/*
 * Setup xfs_mount buffer target pointers based on superblock
 */
STATIC int
xfs_setup_devices(
	struct xfs_mount	*mp)
{
	int			error;
836

837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862
	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;
}
863

864 865 866 867 868
/*
 * XFS AIL push thread support
 */
void
xfsaild_wakeup(
D
David Chinner 已提交
869
	struct xfs_ail		*ailp,
870 871
	xfs_lsn_t		threshold_lsn)
{
D
David Chinner 已提交
872 873
	ailp->xa_target = threshold_lsn;
	wake_up_process(ailp->xa_task);
874 875 876 877 878 879
}

int
xfsaild(
	void	*data)
{
D
David Chinner 已提交
880
	struct xfs_ail	*ailp = data;
881 882 883 884 885 886 887 888 889 890 891
	xfs_lsn_t	last_pushed_lsn = 0;
	long		tout = 0;

	while (!kthread_should_stop()) {
		if (tout)
			schedule_timeout_interruptible(msecs_to_jiffies(tout));
		tout = 1000;

		/* swsusp */
		try_to_freeze();

D
David Chinner 已提交
892 893
		ASSERT(ailp->xa_mount->m_log);
		if (XFS_FORCED_SHUTDOWN(ailp->xa_mount))
894 895
			continue;

D
David Chinner 已提交
896
		tout = xfsaild_push(ailp, &last_pushed_lsn);
897 898 899 900 901 902 903
	}

	return 0;
}	/* xfsaild */

int
xfsaild_start(
D
David Chinner 已提交
904
	struct xfs_ail	*ailp)
905
{
D
David Chinner 已提交
906 907 908 909
	ailp->xa_target = 0;
	ailp->xa_task = kthread_run(xfsaild, ailp, "xfsaild");
	if (IS_ERR(ailp->xa_task))
		return -PTR_ERR(ailp->xa_task);
910 911 912 913 914
	return 0;
}

void
xfsaild_stop(
D
David Chinner 已提交
915
	struct xfs_ail	*ailp)
916
{
D
David Chinner 已提交
917
	kthread_stop(ailp->xa_task);
918 919 920
}


921
/* Catch misguided souls that try to use this interface on XFS */
L
Linus Torvalds 已提交
922
STATIC struct inode *
923
xfs_fs_alloc_inode(
L
Linus Torvalds 已提交
924 925
	struct super_block	*sb)
{
926
	BUG();
927
	return NULL;
L
Linus Torvalds 已提交
928 929
}

930
/*
931 932
 * Now that the generic code is guaranteed not to be accessing
 * the linux inode, we can reclaim the inode.
933
 */
L
Linus Torvalds 已提交
934
STATIC void
935
xfs_fs_destroy_inode(
936
	struct inode	*inode)
L
Linus Torvalds 已提交
937
{
938 939 940 941 942
	xfs_inode_t		*ip = XFS_I(inode);

	XFS_STATS_INC(vn_reclaim);
	if (xfs_reclaim(ip))
		panic("%s: cannot reclaim 0x%p\n", __func__, inode);
L
Linus Torvalds 已提交
943 944
}

945 946 947 948 949 950 951 952
/*
 * 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
 * from the slab. This avoids the need to repeatedly intialise
 * fields in the xfs inode that left in the initialise state
 * when freeing the inode.
 */
953 954
STATIC void
xfs_fs_inode_init_once(
955 956 957 958 959
	void			*inode)
{
	struct xfs_inode	*ip = inode;

	memset(ip, 0, sizeof(struct xfs_inode));
960 961 962 963 964

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

	/* xfs inode */
965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981
	atomic_set(&ip->i_iocount, 0);
	atomic_set(&ip->i_pincount, 0);
	spin_lock_init(&ip->i_flags_lock);
	init_waitqueue_head(&ip->i_ipin_wait);
	/*
	 * Because we want to use a counting completion, complete
	 * the flush completion once to allow a single access to
	 * the flush completion without blocking.
	 */
	init_completion(&ip->i_flush);
	complete(&ip->i_flush);

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

L
Linus Torvalds 已提交
982 983 984 985
/*
 * 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,
986
 * since this is when the inode itself becomes flushable.
L
Linus Torvalds 已提交
987 988
 */
STATIC int
989
xfs_fs_write_inode(
L
Linus Torvalds 已提交
990 991 992
	struct inode		*inode,
	int			sync)
{
993 994
	int			error = 0;
	int			flags = 0;
L
Linus Torvalds 已提交
995

996
	xfs_itrace_entry(XFS_I(inode));
997 998 999
	if (sync) {
		filemap_fdatawait(inode->i_mapping);
		flags |= FLUSH_SYNC;
L
Linus Torvalds 已提交
1000
	}
1001
	error = xfs_inode_flush(XFS_I(inode), flags);
1002 1003 1004 1005 1006
	/*
	 * if we failed to write out the inode then mark
	 * it dirty again so we'll try again later.
	 */
	if (error)
1007
		xfs_mark_inode_dirty_sync(XFS_I(inode));
1008

L
Linus Torvalds 已提交
1009 1010 1011 1012
	return -error;
}

STATIC void
1013
xfs_fs_clear_inode(
L
Linus Torvalds 已提交
1014 1015
	struct inode		*inode)
{
1016
	xfs_inode_t		*ip = XFS_I(inode);
1017

1018 1019 1020 1021 1022 1023 1024
	xfs_itrace_entry(ip);
	XFS_STATS_INC(vn_rele);
	XFS_STATS_INC(vn_remove);
	XFS_STATS_DEC(vn_active);

	xfs_inactive(ip);
	xfs_iflags_clear(ip, XFS_IMODIFIED);
1025
}
L
Linus Torvalds 已提交
1026

1027 1028 1029 1030 1031 1032 1033 1034 1035
STATIC void
xfs_free_fsname(
	struct xfs_mount	*mp)
{
	kfree(mp->m_fsname);
	kfree(mp->m_rtname);
	kfree(mp->m_logname);
}

L
Linus Torvalds 已提交
1036
STATIC void
1037
xfs_fs_put_super(
L
Linus Torvalds 已提交
1038 1039
	struct super_block	*sb)
{
1040
	struct xfs_mount	*mp = XFS_M(sb);
1041 1042
	struct xfs_inode	*rip = mp->m_rootip;
	int			unmount_event_flags = 0;
L
Linus Torvalds 已提交
1043 1044
	int			error;

1045
	xfs_syncd_stop(mp);
1046
	xfs_sync_inodes(mp, SYNC_ATTR|SYNC_DELWRI);
1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078

#ifdef HAVE_DMAPI
	if (mp->m_flags & XFS_MOUNT_DMAPI) {
		unmount_event_flags =
			(mp->m_dmevmask & (1 << DM_EVENT_UNMOUNT)) ?
				0 : DM_FLAGS_UNWANTED;
		/*
		 * Ignore error from dmapi here, first unmount is not allowed
		 * to fail anyway, and second we wouldn't want to fail a
		 * unmount because of dmapi.
		 */
		XFS_SEND_PREUNMOUNT(mp, rip, DM_RIGHT_NULL, rip, DM_RIGHT_NULL,
				NULL, NULL, 0, 0, unmount_event_flags);
	}
#endif

	/*
	 * Blow away any referenced inode in the filestreams cache.
	 * This can and will cause log traffic as inodes go inactive
	 * here.
	 */
	xfs_filestream_unmount(mp);

	XFS_bflush(mp->m_ddev_targp);
	error = xfs_unmount_flush(mp, 0);
	WARN_ON(error);

	if (mp->m_flags & XFS_MOUNT_DMAPI) {
		XFS_SEND_UNMOUNT(mp, rip, DM_RIGHT_NULL, 0, 0,
				unmount_event_flags);
	}

1079
	xfs_unmountfs(mp);
1080
	xfs_freesb(mp);
C
Christoph Hellwig 已提交
1081
	xfs_icsb_destroy_counters(mp);
1082
	xfs_close_devices(mp);
1083 1084
	xfs_qmops_put(mp);
	xfs_dmops_put(mp);
1085
	xfs_free_fsname(mp);
C
Christoph Hellwig 已提交
1086
	kfree(mp);
L
Linus Torvalds 已提交
1087 1088 1089
}

STATIC void
1090
xfs_fs_write_super(
L
Linus Torvalds 已提交
1091 1092
	struct super_block	*sb)
{
1093
	if (!(sb->s_flags & MS_RDONLY))
1094
		xfs_sync_fsdata(XFS_M(sb), 0);
L
Linus Torvalds 已提交
1095 1096 1097 1098
	sb->s_dirt = 0;
}

STATIC int
1099
xfs_fs_sync_super(
L
Linus Torvalds 已提交
1100 1101 1102
	struct super_block	*sb,
	int			wait)
{
1103
	struct xfs_mount	*mp = XFS_M(sb);
1104
	int			error;
L
Linus Torvalds 已提交
1105

1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117
	/*
	 * Treat a sync operation like a freeze.  This is to work
	 * around a race in sync_inodes() which works in two phases
	 * - an asynchronous flush, which can write out an inode
	 * without waiting for file size updates to complete, and a
	 * synchronous flush, which wont do anything because the
	 * async flush removed the inode's dirty flag.  Also
	 * sync_inodes() will not see any files that just have
	 * outstanding transactions to be flushed because we don't
	 * dirty the Linux inode until after the transaction I/O
	 * completes.
	 */
1118 1119 1120 1121
	if (wait || unlikely(sb->s_frozen == SB_FREEZE_WRITE))
		error = xfs_quiesce_data(mp);
	else
		error = xfs_sync_fsdata(mp, 0);
L
Linus Torvalds 已提交
1122 1123 1124
	sb->s_dirt = 0;

	if (unlikely(laptop_mode)) {
1125
		int	prev_sync_seq = mp->m_sync_seq;
L
Linus Torvalds 已提交
1126 1127 1128 1129 1130 1131

		/*
		 * 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).
		 */
1132
		wake_up_process(mp->m_sync_task);
L
Linus Torvalds 已提交
1133 1134 1135 1136 1137 1138
		/*
		 * 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.
		 */
1139 1140
		wait_event(mp->m_wait_single_sync_task,
				mp->m_sync_seq != prev_sync_seq);
L
Linus Torvalds 已提交
1141 1142 1143 1144 1145 1146
	}

	return -error;
}

STATIC int
1147
xfs_fs_statfs(
1148
	struct dentry		*dentry,
L
Linus Torvalds 已提交
1149 1150
	struct kstatfs		*statp)
{
C
Christoph Hellwig 已提交
1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162
	struct xfs_mount	*mp = XFS_M(dentry->d_sb);
	xfs_sb_t		*sbp = &mp->m_sb;
	__uint64_t		fakeinos, id;
	xfs_extlen_t		lsize;

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

1163
	xfs_icsb_sync_counters(mp, XFS_ICSB_LAZY_COUNT);
C
Christoph Hellwig 已提交
1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188

	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;
#if XFS_BIG_INUMS
	fakeinos += mp->m_inoadd;
#endif
	statp->f_files =
	    MIN(sbp->sb_icount + fakeinos, (__uint64_t)XFS_MAXINUMBER);
	if (mp->m_maxicount)
#if XFS_BIG_INUMS
		if (!mp->m_inoadd)
#endif
			statp->f_files = min_t(typeof(statp->f_files),
						statp->f_files,
						mp->m_maxicount);
	statp->f_ffree = statp->f_files - (sbp->sb_icount - sbp->sb_ifree);
	spin_unlock(&mp->m_sb_lock);

	XFS_QM_DQSTATVFS(XFS_I(dentry->d_inode), statp);
	return 0;
L
Linus Torvalds 已提交
1189 1190 1191
}

STATIC int
1192
xfs_fs_remount(
L
Linus Torvalds 已提交
1193 1194 1195 1196
	struct super_block	*sb,
	int			*flags,
	char			*options)
{
1197
	struct xfs_mount	*mp = XFS_M(sb);
1198 1199
	substring_t		args[MAX_OPT_ARGS];
	char			*p;
L
Linus Torvalds 已提交
1200

1201 1202
	while ((p = strsep(&options, ",")) != NULL) {
		int token;
1203

1204 1205
		if (!*p)
			continue;
1206

1207 1208 1209
		token = match_token(p, tokens, args);
		switch (token) {
		case Opt_barrier:
1210
			mp->m_flags |= XFS_MOUNT_BARRIER;
1211 1212 1213 1214 1215 1216 1217 1218 1219 1220

			/*
			 * Test if barriers are actually working if we can,
			 * else delay this check until the filesystem is
			 * marked writeable.
			 */
			if (!(mp->m_flags & XFS_MOUNT_RDONLY))
				xfs_mountfs_check_barriers(mp);
			break;
		case Opt_nobarrier:
1221
			mp->m_flags &= ~XFS_MOUNT_BARRIER;
1222 1223
			break;
		default:
1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240
			/*
			 * 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
1241 1242 1243
			printk(KERN_INFO
	"XFS: mount option \"%s\" not supported for remount\n", p);
			return -EINVAL;
1244
#else
1245
			break;
1246
#endif
1247
		}
1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258
	}

	/* rw/ro -> rw */
	if ((mp->m_flags & XFS_MOUNT_RDONLY) && !(*flags & MS_RDONLY)) {
		mp->m_flags &= ~XFS_MOUNT_RDONLY;
		if (mp->m_flags & XFS_MOUNT_BARRIER)
			xfs_mountfs_check_barriers(mp);
	}

	/* rw -> ro */
	if (!(mp->m_flags & XFS_MOUNT_RDONLY) && (*flags & MS_RDONLY)) {
1259
		xfs_quiesce_data(mp);
D
David Chinner 已提交
1260
		xfs_quiesce_attr(mp);
1261 1262 1263
		mp->m_flags |= XFS_MOUNT_RDONLY;
	}

1264
	return 0;
L
Linus Torvalds 已提交
1265 1266
}

C
Christoph Hellwig 已提交
1267 1268
/*
 * Second stage of a freeze. The data is already frozen so we only
D
David Chinner 已提交
1269
 * need to take care of the metadata. Once that's done write a dummy
C
Christoph Hellwig 已提交
1270 1271
 * record to dirty the log in case of a crash while frozen.
 */
L
Linus Torvalds 已提交
1272
STATIC void
1273
xfs_fs_lockfs(
L
Linus Torvalds 已提交
1274 1275
	struct super_block	*sb)
{
C
Christoph Hellwig 已提交
1276 1277
	struct xfs_mount	*mp = XFS_M(sb);

D
David Chinner 已提交
1278
	xfs_quiesce_attr(mp);
C
Christoph Hellwig 已提交
1279
	xfs_fs_log_dummy(mp);
L
Linus Torvalds 已提交
1280 1281 1282
}

STATIC int
1283
xfs_fs_show_options(
L
Linus Torvalds 已提交
1284 1285 1286
	struct seq_file		*m,
	struct vfsmount		*mnt)
{
1287
	return -xfs_showargs(XFS_M(mnt->mnt_sb), m);
L
Linus Torvalds 已提交
1288 1289
}

1290
STATIC int
1291
xfs_fs_quotasync(
1292 1293 1294
	struct super_block	*sb,
	int			type)
{
1295
	return -XFS_QM_QUOTACTL(XFS_M(sb), Q_XQUOTASYNC, 0, NULL);
1296 1297
}

L
Linus Torvalds 已提交
1298
STATIC int
1299
xfs_fs_getxstate(
L
Linus Torvalds 已提交
1300 1301 1302
	struct super_block	*sb,
	struct fs_quota_stat	*fqs)
{
1303
	return -XFS_QM_QUOTACTL(XFS_M(sb), Q_XGETQSTAT, 0, (caddr_t)fqs);
L
Linus Torvalds 已提交
1304 1305 1306
}

STATIC int
1307
xfs_fs_setxstate(
L
Linus Torvalds 已提交
1308 1309 1310 1311
	struct super_block	*sb,
	unsigned int		flags,
	int			op)
{
1312
	return -XFS_QM_QUOTACTL(XFS_M(sb), op, 0, (caddr_t)&flags);
L
Linus Torvalds 已提交
1313 1314 1315
}

STATIC int
1316
xfs_fs_getxquota(
L
Linus Torvalds 已提交
1317 1318 1319 1320 1321
	struct super_block	*sb,
	int			type,
	qid_t			id,
	struct fs_disk_quota	*fdq)
{
1322
	return -XFS_QM_QUOTACTL(XFS_M(sb),
1323 1324 1325
				 (type == USRQUOTA) ? Q_XGETQUOTA :
				  ((type == GRPQUOTA) ? Q_XGETGQUOTA :
				   Q_XGETPQUOTA), id, (caddr_t)fdq);
L
Linus Torvalds 已提交
1326 1327 1328
}

STATIC int
1329
xfs_fs_setxquota(
L
Linus Torvalds 已提交
1330 1331 1332 1333 1334
	struct super_block	*sb,
	int			type,
	qid_t			id,
	struct fs_disk_quota	*fdq)
{
1335
	return -XFS_QM_QUOTACTL(XFS_M(sb),
1336 1337 1338
				 (type == USRQUOTA) ? Q_XSETQLIM :
				  ((type == GRPQUOTA) ? Q_XSETGQLIM :
				   Q_XSETPQLIM), id, (caddr_t)fdq);
L
Linus Torvalds 已提交
1339 1340
}

1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352
/*
 * 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);

	/* Fail a mount where the logbuf is smaller then the log stripe */
	if (xfs_sb_version_haslogv2(&mp->m_sb)) {
1353 1354
		if (mp->m_logbsize <= 0 &&
		    mp->m_sb.sb_logsunit > XLOG_BIG_RECORD_BSIZE) {
1355
			mp->m_logbsize = mp->m_sb.sb_logsunit;
1356 1357
		} else if (mp->m_logbsize > 0 &&
			   mp->m_logbsize < mp->m_sb.sb_logsunit) {
1358 1359 1360 1361 1362 1363
			cmn_err(CE_WARN,
	"XFS: logbuf size must be greater than or equal to log stripe size");
			return XFS_ERROR(EINVAL);
		}
	} else {
		/* Fail a mount if the logbuf is larger than 32K */
1364
		if (mp->m_logbsize > XLOG_BIG_RECORD_BSIZE) {
1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375
			cmn_err(CE_WARN,
	"XFS: logbuf size for version 1 logs must be 16K or 32K");
			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) &&
1376
	    !(mp->m_flags & XFS_MOUNT_NOATTR2))
1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387
		mp->m_flags |= XFS_MOUNT_ATTR2;

	/*
	 * prohibit r/w mounts of read-only filesystems
	 */
	if ((mp->m_sb.sb_flags & XFS_SBF_READONLY) && !ronly) {
		cmn_err(CE_WARN,
	"XFS: cannot mount a read-only filesystem as read-write");
		return XFS_ERROR(EROFS);
	}

1388
#if 0 /* shared mounts were never supported on Linux */
1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410
	/*
	 * check for shared mount.
	 */
	if (ap->flags & XFSMNT_SHARED) {
		if (!xfs_sb_version_hasshared(&mp->m_sb))
			return XFS_ERROR(EINVAL);

		/*
		 * For IRIX 6.5, shared mounts must have the shared
		 * version bit set, have the persistent readonly
		 * field set, must be version 0 and can only be mounted
		 * read-only.
		 */
		if (!ronly || !(mp->m_sb.sb_flags & XFS_SBF_READONLY) ||
		     (mp->m_sb.sb_shared_vn != 0))
			return XFS_ERROR(EINVAL);

		mp->m_flags |= XFS_MOUNT_SHARED;

		/*
		 * Shared XFS V0 can't deal with DMI.  Return EINVAL.
		 */
1411 1412
		if (mp->m_sb.sb_shared_vn == 0 &&
		    (mp->m_flags & XFS_MOUNT_DMAPI))
1413 1414
			return XFS_ERROR(EINVAL);
	}
1415
#endif
1416 1417 1418 1419

	return 0;
}

L
Linus Torvalds 已提交
1420
STATIC int
1421
xfs_fs_fill_super(
L
Linus Torvalds 已提交
1422 1423 1424 1425
	struct super_block	*sb,
	void			*data,
	int			silent)
{
1426
	struct inode		*root;
1427
	struct xfs_mount	*mp = NULL;
C
Christoph Hellwig 已提交
1428
	int			flags = 0, error = ENOMEM;
1429
	char			*mtpt = NULL;
1430

C
Christoph Hellwig 已提交
1431 1432
	mp = kzalloc(sizeof(struct xfs_mount), GFP_KERNEL);
	if (!mp)
1433
		goto out;
L
Linus Torvalds 已提交
1434

C
Christoph Hellwig 已提交
1435 1436 1437
	spin_lock_init(&mp->m_sb_lock);
	mutex_init(&mp->m_growlock);
	atomic_set(&mp->m_active_trans, 0);
1438 1439 1440 1441
	INIT_LIST_HEAD(&mp->m_sync_list);
	spin_lock_init(&mp->m_sync_lock);
	init_waitqueue_head(&mp->m_wait_single_sync_task);

C
Christoph Hellwig 已提交
1442 1443
	mp->m_super = sb;
	sb->s_fs_info = mp;
L
Linus Torvalds 已提交
1444

1445
	error = xfs_parseargs(mp, (char *)data, &mtpt);
1446
	if (error)
1447
		goto out_free_fsname;
L
Linus Torvalds 已提交
1448 1449

	sb_min_blocksize(sb, BBSIZE);
1450
	sb->s_xattr = xfs_xattr_handlers;
1451 1452 1453
	sb->s_export_op = &xfs_export_operations;
	sb->s_qcop = &xfs_quotactl_operations;
	sb->s_op = &xfs_super_operations;
L
Linus Torvalds 已提交
1454

1455
	error = xfs_dmops_get(mp);
1456
	if (error)
1457 1458
		goto out_free_fsname;
	error = xfs_qmops_get(mp);
1459
	if (error)
1460
		goto out_put_dmops;
L
Linus Torvalds 已提交
1461

1462
	if (silent)
1463 1464
		flags |= XFS_MFSI_QUIET;

1465
	error = xfs_open_devices(mp);
1466 1467
	if (error)
		goto out_put_qmops;
1468

C
Christoph Hellwig 已提交
1469 1470 1471
	if (xfs_icsb_init_counters(mp))
		mp->m_flags |= XFS_MOUNT_NO_PERCPU_SB;

1472 1473
	error = xfs_readsb(mp, flags);
	if (error)
1474 1475 1476
		goto out_destroy_counters;

	error = xfs_finish_flags(mp);
1477
	if (error)
1478
		goto out_free_sb;
1479

1480
	error = xfs_setup_devices(mp);
1481
	if (error)
1482
		goto out_free_sb;
1483 1484 1485 1486 1487 1488

	if (mp->m_flags & XFS_MOUNT_BARRIER)
		xfs_mountfs_check_barriers(mp);

	error = xfs_filestream_mount(mp);
	if (error)
1489
		goto out_free_sb;
1490

C
Christoph Hellwig 已提交
1491
	error = xfs_mountfs(mp);
1492
	if (error)
1493
		goto out_filestream_unmount;
1494

1495
	XFS_SEND_MOUNT(mp, DM_RIGHT_NULL, mtpt, mp->m_fsname);
1496

L
Linus Torvalds 已提交
1497
	sb->s_dirt = 1;
C
Christoph Hellwig 已提交
1498 1499 1500
	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 已提交
1501 1502 1503 1504
	sb->s_maxbytes = xfs_max_file_offset(sb->s_blocksize_bits);
	sb->s_time_gran = 1;
	set_posix_acl_flag(sb);

1505
	root = igrab(VFS_I(mp->m_rootip));
1506
	if (!root) {
C
Christoph Hellwig 已提交
1507
		error = ENOENT;
L
Linus Torvalds 已提交
1508
		goto fail_unmount;
C
Christoph Hellwig 已提交
1509
	}
1510 1511
	if (is_bad_inode(root)) {
		error = EINVAL;
L
Linus Torvalds 已提交
1512 1513
		goto fail_vnrele;
	}
1514 1515 1516
	sb->s_root = d_alloc_root(root);
	if (!sb->s_root) {
		error = ENOMEM;
L
Linus Torvalds 已提交
1517 1518
		goto fail_vnrele;
	}
1519

1520 1521
	error = xfs_syncd_init(mp);
	if (error)
L
Linus Torvalds 已提交
1522
		goto fail_vnrele;
1523

1524
	kfree(mtpt);
L
Linus Torvalds 已提交
1525

1526
	xfs_itrace_exit(XFS_I(sb->s_root->d_inode));
L
Linus Torvalds 已提交
1527 1528
	return 0;

1529 1530
 out_filestream_unmount:
	xfs_filestream_unmount(mp);
1531 1532
 out_free_sb:
	xfs_freesb(mp);
1533
 out_destroy_counters:
C
Christoph Hellwig 已提交
1534
	xfs_icsb_destroy_counters(mp);
1535 1536
	xfs_close_devices(mp);
 out_put_qmops:
1537
	xfs_qmops_put(mp);
1538
 out_put_dmops:
1539
	xfs_dmops_put(mp);
1540 1541 1542
 out_free_fsname:
	xfs_free_fsname(mp);
	kfree(mtpt);
C
Christoph Hellwig 已提交
1543
	kfree(mp);
1544
 out:
C
Christoph Hellwig 已提交
1545
	return -error;
1546 1547

 fail_vnrele:
L
Linus Torvalds 已提交
1548 1549 1550 1551
	if (sb->s_root) {
		dput(sb->s_root);
		sb->s_root = NULL;
	} else {
1552
		iput(root);
L
Linus Torvalds 已提交
1553 1554
	}

1555
 fail_unmount:
1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566
	/*
	 * Blow away any referenced inode in the filestreams cache.
	 * This can and will cause log traffic as inodes go inactive
	 * here.
	 */
	xfs_filestream_unmount(mp);

	XFS_bflush(mp->m_ddev_targp);
	error = xfs_unmount_flush(mp, 0);
	WARN_ON(error);

1567
	xfs_unmountfs(mp);
1568
	goto out_free_sb;
L
Linus Torvalds 已提交
1569 1570
}

1571
STATIC int
1572
xfs_fs_get_sb(
L
Linus Torvalds 已提交
1573 1574 1575
	struct file_system_type	*fs_type,
	int			flags,
	const char		*dev_name,
1576 1577
	void			*data,
	struct vfsmount		*mnt)
L
Linus Torvalds 已提交
1578
{
1579 1580
	return get_sb_bdev(fs_type, flags, dev_name, data, xfs_fs_fill_super,
			   mnt);
1581 1582
}

1583
static struct super_operations xfs_super_operations = {
1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594
	.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 已提交
1595 1596
};

1597
static struct quotactl_ops xfs_quotactl_operations = {
1598 1599 1600 1601 1602
	.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 已提交
1603 1604
};

A
Andrew Morton 已提交
1605
static struct file_system_type xfs_fs_type = {
L
Linus Torvalds 已提交
1606 1607
	.owner			= THIS_MODULE,
	.name			= "xfs",
1608
	.get_sb			= xfs_fs_get_sb,
L
Linus Torvalds 已提交
1609 1610 1611 1612
	.kill_sb		= kill_block_super,
	.fs_flags		= FS_REQUIRES_DEV,
};

1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625
STATIC int __init
xfs_alloc_trace_bufs(void)
{
#ifdef XFS_ALLOC_TRACE
	xfs_alloc_trace_buf = ktrace_alloc(XFS_ALLOC_TRACE_SIZE, KM_MAYFAIL);
	if (!xfs_alloc_trace_buf)
		goto out;
#endif
#ifdef XFS_BMAP_TRACE
	xfs_bmap_trace_buf = ktrace_alloc(XFS_BMAP_TRACE_SIZE, KM_MAYFAIL);
	if (!xfs_bmap_trace_buf)
		goto out_free_alloc_trace;
#endif
1626 1627 1628 1629 1630 1631 1632 1633 1634 1635
#ifdef XFS_BTREE_TRACE
	xfs_allocbt_trace_buf = ktrace_alloc(XFS_ALLOCBT_TRACE_SIZE,
					     KM_MAYFAIL);
	if (!xfs_allocbt_trace_buf)
		goto out_free_bmap_trace;

	xfs_inobt_trace_buf = ktrace_alloc(XFS_INOBT_TRACE_SIZE, KM_MAYFAIL);
	if (!xfs_inobt_trace_buf)
		goto out_free_allocbt_trace;

1636 1637
	xfs_bmbt_trace_buf = ktrace_alloc(XFS_BMBT_TRACE_SIZE, KM_MAYFAIL);
	if (!xfs_bmbt_trace_buf)
1638
		goto out_free_inobt_trace;
1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659
#endif
#ifdef XFS_ATTR_TRACE
	xfs_attr_trace_buf = ktrace_alloc(XFS_ATTR_TRACE_SIZE, KM_MAYFAIL);
	if (!xfs_attr_trace_buf)
		goto out_free_bmbt_trace;
#endif
#ifdef XFS_DIR2_TRACE
	xfs_dir2_trace_buf = ktrace_alloc(XFS_DIR2_GTRACE_SIZE, KM_MAYFAIL);
	if (!xfs_dir2_trace_buf)
		goto out_free_attr_trace;
#endif

	return 0;

#ifdef XFS_DIR2_TRACE
 out_free_attr_trace:
#endif
#ifdef XFS_ATTR_TRACE
	ktrace_free(xfs_attr_trace_buf);
 out_free_bmbt_trace:
#endif
1660
#ifdef XFS_BTREE_TRACE
1661
	ktrace_free(xfs_bmbt_trace_buf);
1662 1663 1664 1665
 out_free_inobt_trace:
	ktrace_free(xfs_inobt_trace_buf);
 out_free_allocbt_trace:
	ktrace_free(xfs_allocbt_trace_buf);
1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687
 out_free_bmap_trace:
#endif
#ifdef XFS_BMAP_TRACE
	ktrace_free(xfs_bmap_trace_buf);
 out_free_alloc_trace:
#endif
#ifdef XFS_ALLOC_TRACE
	ktrace_free(xfs_alloc_trace_buf);
 out:
#endif
	return -ENOMEM;
}

STATIC void
xfs_free_trace_bufs(void)
{
#ifdef XFS_DIR2_TRACE
	ktrace_free(xfs_dir2_trace_buf);
#endif
#ifdef XFS_ATTR_TRACE
	ktrace_free(xfs_attr_trace_buf);
#endif
1688
#ifdef XFS_BTREE_TRACE
1689
	ktrace_free(xfs_bmbt_trace_buf);
1690 1691
	ktrace_free(xfs_inobt_trace_buf);
	ktrace_free(xfs_allocbt_trace_buf);
1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706
#endif
#ifdef XFS_BMAP_TRACE
	ktrace_free(xfs_bmap_trace_buf);
#endif
#ifdef XFS_ALLOC_TRACE
	ktrace_free(xfs_alloc_trace_buf);
#endif
}

STATIC int __init
xfs_init_zones(void)
{

	xfs_ioend_zone = kmem_zone_init(sizeof(xfs_ioend_t), "xfs_ioend");
	if (!xfs_ioend_zone)
1707
		goto out;
1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722

	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;
1723

1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770
	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_dabuf_zone = kmem_zone_init(sizeof(xfs_dabuf_t), "xfs_dabuf");
	if (!xfs_dabuf_zone)
		goto out_destroy_da_state_zone;

	xfs_ifork_zone = kmem_zone_init(sizeof(xfs_ifork_t), "xfs_ifork");
	if (!xfs_ifork_zone)
		goto out_destroy_dabuf_zone;

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

	/*
	 * 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.
	 */
	xfs_buf_item_zone = kmem_zone_init((sizeof(xfs_buf_log_item_t) +
				(((XFS_MAX_BLOCKSIZE / XFS_BLI_CHUNK) /
				  NBWORD) * sizeof(int))), "xfs_buf_item");
	if (!xfs_buf_item_zone)
		goto out_destroy_trans_zone;

	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",
1771 1772
			KM_ZONE_HWALIGN | KM_ZONE_RECLAIM | KM_ZONE_SPREAD,
			xfs_fs_inode_init_once);
1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845
	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;

#ifdef CONFIG_XFS_POSIX_ACL
	xfs_acl_zone = kmem_zone_init(sizeof(xfs_acl_t), "xfs_acl");
	if (!xfs_acl_zone)
		goto out_destroy_ili_zone;
#endif

	return 0;

#ifdef CONFIG_XFS_POSIX_ACL
 out_destroy_ili_zone:
#endif
	kmem_zone_destroy(xfs_ili_zone);
 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);
 out_destroy_trans_zone:
	kmem_zone_destroy(xfs_trans_zone);
 out_destroy_ifork_zone:
	kmem_zone_destroy(xfs_ifork_zone);
 out_destroy_dabuf_zone:
	kmem_zone_destroy(xfs_dabuf_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)
{
#ifdef CONFIG_XFS_POSIX_ACL
	kmem_zone_destroy(xfs_acl_zone);
#endif
	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);
	kmem_zone_destroy(xfs_trans_zone);
	kmem_zone_destroy(xfs_ifork_zone);
	kmem_zone_destroy(xfs_dabuf_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 已提交
1846 1847

STATIC int __init
1848
init_xfs_fs(void)
L
Linus Torvalds 已提交
1849 1850 1851 1852 1853 1854 1855 1856
{
	int			error;
	static char		message[] __initdata = KERN_INFO \
		XFS_VERSION_STRING " with " XFS_BUILD_OPTIONS " enabled\n";

	printk(message);

	ktrace_init(64);
1857 1858
	vn_init();
	xfs_dir_startup();
L
Linus Torvalds 已提交
1859

1860
	error = xfs_init_zones();
1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874
	if (error)
		goto out;

	error = xfs_alloc_trace_bufs();
	if (error)
		goto out_destroy_zones;

	error = xfs_mru_cache_init();
	if (error)
		goto out_free_trace_buffers;

	error = xfs_filestream_init();
	if (error)
		goto out_mru_cache_uninit;
L
Linus Torvalds 已提交
1875

1876
	error = xfs_buf_init();
1877 1878 1879 1880 1881 1882 1883 1884 1885 1886
	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 已提交
1887 1888 1889 1890 1891

	vfs_initquota();

	error = register_filesystem(&xfs_fs_type);
	if (error)
1892
		goto out_sysctl_unregister;
L
Linus Torvalds 已提交
1893 1894
	return 0;

1895 1896 1897 1898 1899
 out_sysctl_unregister:
	xfs_sysctl_unregister();
 out_cleanup_procfs:
	xfs_cleanup_procfs();
 out_buf_terminate:
1900
	xfs_buf_terminate();
1901 1902 1903 1904 1905 1906 1907
 out_filestream_uninit:
	xfs_filestream_uninit();
 out_mru_cache_uninit:
	xfs_mru_cache_uninit();
 out_free_trace_buffers:
	xfs_free_trace_bufs();
 out_destroy_zones:
1908
	xfs_destroy_zones();
1909
 out:
L
Linus Torvalds 已提交
1910 1911 1912 1913
	return error;
}

STATIC void __exit
1914
exit_xfs_fs(void)
L
Linus Torvalds 已提交
1915 1916 1917
{
	vfs_exitquota();
	unregister_filesystem(&xfs_fs_type);
1918 1919
	xfs_sysctl_unregister();
	xfs_cleanup_procfs();
1920
	xfs_buf_terminate();
1921 1922 1923
	xfs_filestream_uninit();
	xfs_mru_cache_uninit();
	xfs_free_trace_bufs();
1924
	xfs_destroy_zones();
L
Linus Torvalds 已提交
1925 1926 1927 1928 1929 1930 1931 1932 1933
	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");