1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * Copyright (c) 2000-2006 Silicon Graphics, Inc.
   4 * All Rights Reserved.
   5 */
   6
   7#include "xfs.h"
   8#include "xfs_shared.h"
   9#include "xfs_format.h"
  10#include "xfs_log_format.h"
  11#include "xfs_trans_resv.h"
  12#include "xfs_sb.h"
  13#include "xfs_mount.h"
  14#include "xfs_inode.h"
  15#include "xfs_btree.h"
  16#include "xfs_bmap.h"
  17#include "xfs_alloc.h"
  18#include "xfs_fsops.h"
  19#include "xfs_trans.h"
  20#include "xfs_buf_item.h"
  21#include "xfs_log.h"
  22#include "xfs_log_priv.h"
  23#include "xfs_dir2.h"
  24#include "xfs_extfree_item.h"
  25#include "xfs_mru_cache.h"
  26#include "xfs_inode_item.h"
  27#include "xfs_icache.h"
  28#include "xfs_trace.h"
  29#include "xfs_icreate_item.h"
  30#include "xfs_filestream.h"
  31#include "xfs_quota.h"
  32#include "xfs_sysfs.h"
  33#include "xfs_ondisk.h"
  34#include "xfs_rmap_item.h"
  35#include "xfs_refcount_item.h"
  36#include "xfs_bmap_item.h"
  37#include "xfs_reflink.h"
  38#include "xfs_pwork.h"
  39#include "xfs_ag.h"
  40#include "xfs_defer.h"
  41#include "xfs_attr_item.h"
  42#include "xfs_xattr.h"
  43#include "xfs_iunlink_item.h"
  44#include "xfs_dahash_test.h"
  45#include "xfs_rtbitmap.h"
 
 
 
  46#include "scrub/stats.h"
  47#include "scrub/rcbag_btree.h"
  48
  49#include <linux/magic.h>
  50#include <linux/fs_context.h>
  51#include <linux/fs_parser.h>
  52
  53static const struct super_operations xfs_super_operations;
  54
  55static struct dentry *xfs_debugfs;	/* top-level xfs debugfs dir */
  56static struct kset *xfs_kset;		/* top-level xfs sysfs dir */
  57#ifdef DEBUG
  58static struct xfs_kobj xfs_dbg_kobj;	/* global debug sysfs attrs */
  59#endif
  60
  61enum xfs_dax_mode {
  62	XFS_DAX_INODE = 0,
  63	XFS_DAX_ALWAYS = 1,
  64	XFS_DAX_NEVER = 2,
  65};
  66
 
 
 
  67static void
  68xfs_mount_set_dax_mode(
  69	struct xfs_mount	*mp,
  70	enum xfs_dax_mode	mode)
  71{
  72	switch (mode) {
  73	case XFS_DAX_INODE:
  74		mp->m_features &= ~(XFS_FEAT_DAX_ALWAYS | XFS_FEAT_DAX_NEVER);
  75		break;
  76	case XFS_DAX_ALWAYS:
  77		mp->m_features |= XFS_FEAT_DAX_ALWAYS;
  78		mp->m_features &= ~XFS_FEAT_DAX_NEVER;
  79		break;
  80	case XFS_DAX_NEVER:
  81		mp->m_features |= XFS_FEAT_DAX_NEVER;
  82		mp->m_features &= ~XFS_FEAT_DAX_ALWAYS;
  83		break;
  84	}
  85}
  86
  87static const struct constant_table dax_param_enums[] = {
  88	{"inode",	XFS_DAX_INODE },
  89	{"always",	XFS_DAX_ALWAYS },
  90	{"never",	XFS_DAX_NEVER },
  91	{}
  92};
  93
  94/*
  95 * Table driven mount option parser.
  96 */
  97enum {
  98	Opt_logbufs, Opt_logbsize, Opt_logdev, Opt_rtdev,
  99	Opt_wsync, Opt_noalign, Opt_swalloc, Opt_sunit, Opt_swidth, Opt_nouuid,
 100	Opt_grpid, Opt_nogrpid, Opt_bsdgroups, Opt_sysvgroups,
 101	Opt_allocsize, Opt_norecovery, Opt_inode64, Opt_inode32, Opt_ikeep,
 102	Opt_noikeep, Opt_largeio, Opt_nolargeio, Opt_attr2, Opt_noattr2,
 103	Opt_filestreams, Opt_quota, Opt_noquota, Opt_usrquota, Opt_grpquota,
 104	Opt_prjquota, Opt_uquota, Opt_gquota, Opt_pquota,
 105	Opt_uqnoenforce, Opt_gqnoenforce, Opt_pqnoenforce, Opt_qnoenforce,
 106	Opt_discard, Opt_nodiscard, Opt_dax, Opt_dax_enum,
 107};
 108
 109static const struct fs_parameter_spec xfs_fs_parameters[] = {
 110	fsparam_u32("logbufs",		Opt_logbufs),
 111	fsparam_string("logbsize",	Opt_logbsize),
 112	fsparam_string("logdev",	Opt_logdev),
 113	fsparam_string("rtdev",		Opt_rtdev),
 114	fsparam_flag("wsync",		Opt_wsync),
 115	fsparam_flag("noalign",		Opt_noalign),
 116	fsparam_flag("swalloc",		Opt_swalloc),
 117	fsparam_u32("sunit",		Opt_sunit),
 118	fsparam_u32("swidth",		Opt_swidth),
 119	fsparam_flag("nouuid",		Opt_nouuid),
 120	fsparam_flag("grpid",		Opt_grpid),
 121	fsparam_flag("nogrpid",		Opt_nogrpid),
 122	fsparam_flag("bsdgroups",	Opt_bsdgroups),
 123	fsparam_flag("sysvgroups",	Opt_sysvgroups),
 124	fsparam_string("allocsize",	Opt_allocsize),
 125	fsparam_flag("norecovery",	Opt_norecovery),
 126	fsparam_flag("inode64",		Opt_inode64),
 127	fsparam_flag("inode32",		Opt_inode32),
 128	fsparam_flag("ikeep",		Opt_ikeep),
 129	fsparam_flag("noikeep",		Opt_noikeep),
 130	fsparam_flag("largeio",		Opt_largeio),
 131	fsparam_flag("nolargeio",	Opt_nolargeio),
 132	fsparam_flag("attr2",		Opt_attr2),
 133	fsparam_flag("noattr2",		Opt_noattr2),
 134	fsparam_flag("filestreams",	Opt_filestreams),
 135	fsparam_flag("quota",		Opt_quota),
 136	fsparam_flag("noquota",		Opt_noquota),
 137	fsparam_flag("usrquota",	Opt_usrquota),
 138	fsparam_flag("grpquota",	Opt_grpquota),
 139	fsparam_flag("prjquota",	Opt_prjquota),
 140	fsparam_flag("uquota",		Opt_uquota),
 141	fsparam_flag("gquota",		Opt_gquota),
 142	fsparam_flag("pquota",		Opt_pquota),
 143	fsparam_flag("uqnoenforce",	Opt_uqnoenforce),
 144	fsparam_flag("gqnoenforce",	Opt_gqnoenforce),
 145	fsparam_flag("pqnoenforce",	Opt_pqnoenforce),
 146	fsparam_flag("qnoenforce",	Opt_qnoenforce),
 147	fsparam_flag("discard",		Opt_discard),
 148	fsparam_flag("nodiscard",	Opt_nodiscard),
 149	fsparam_flag("dax",		Opt_dax),
 150	fsparam_enum("dax",		Opt_dax_enum, dax_param_enums),
 151	{}
 152};
 153
 154struct proc_xfs_info {
 155	uint64_t	flag;
 156	char		*str;
 157};
 158
 159static int
 160xfs_fs_show_options(
 161	struct seq_file		*m,
 162	struct dentry		*root)
 163{
 164	static struct proc_xfs_info xfs_info_set[] = {
 165		/* the few simple ones we can get from the mount struct */
 166		{ XFS_FEAT_IKEEP,		",ikeep" },
 167		{ XFS_FEAT_WSYNC,		",wsync" },
 168		{ XFS_FEAT_NOALIGN,		",noalign" },
 169		{ XFS_FEAT_SWALLOC,		",swalloc" },
 170		{ XFS_FEAT_NOUUID,		",nouuid" },
 171		{ XFS_FEAT_NORECOVERY,		",norecovery" },
 172		{ XFS_FEAT_ATTR2,		",attr2" },
 173		{ XFS_FEAT_FILESTREAMS,		",filestreams" },
 174		{ XFS_FEAT_GRPID,		",grpid" },
 175		{ XFS_FEAT_DISCARD,		",discard" },
 176		{ XFS_FEAT_LARGE_IOSIZE,	",largeio" },
 177		{ XFS_FEAT_DAX_ALWAYS,		",dax=always" },
 178		{ XFS_FEAT_DAX_NEVER,		",dax=never" },
 179		{ 0, NULL }
 180	};
 181	struct xfs_mount	*mp = XFS_M(root->d_sb);
 182	struct proc_xfs_info	*xfs_infop;
 183
 184	for (xfs_infop = xfs_info_set; xfs_infop->flag; xfs_infop++) {
 185		if (mp->m_features & xfs_infop->flag)
 186			seq_puts(m, xfs_infop->str);
 187	}
 188
 189	seq_printf(m, ",inode%d", xfs_has_small_inums(mp) ? 32 : 64);
 190
 191	if (xfs_has_allocsize(mp))
 192		seq_printf(m, ",allocsize=%dk",
 193			   (1 << mp->m_allocsize_log) >> 10);
 194
 195	if (mp->m_logbufs > 0)
 196		seq_printf(m, ",logbufs=%d", mp->m_logbufs);
 197	if (mp->m_logbsize > 0)
 198		seq_printf(m, ",logbsize=%dk", mp->m_logbsize >> 10);
 199
 200	if (mp->m_logname)
 201		seq_show_option(m, "logdev", mp->m_logname);
 202	if (mp->m_rtname)
 203		seq_show_option(m, "rtdev", mp->m_rtname);
 204
 205	if (mp->m_dalign > 0)
 206		seq_printf(m, ",sunit=%d",
 207				(int)XFS_FSB_TO_BB(mp, mp->m_dalign));
 208	if (mp->m_swidth > 0)
 209		seq_printf(m, ",swidth=%d",
 210				(int)XFS_FSB_TO_BB(mp, mp->m_swidth));
 211
 212	if (mp->m_qflags & XFS_UQUOTA_ENFD)
 213		seq_puts(m, ",usrquota");
 214	else if (mp->m_qflags & XFS_UQUOTA_ACCT)
 215		seq_puts(m, ",uqnoenforce");
 216
 217	if (mp->m_qflags & XFS_PQUOTA_ENFD)
 218		seq_puts(m, ",prjquota");
 219	else if (mp->m_qflags & XFS_PQUOTA_ACCT)
 220		seq_puts(m, ",pqnoenforce");
 221
 222	if (mp->m_qflags & XFS_GQUOTA_ENFD)
 223		seq_puts(m, ",grpquota");
 224	else if (mp->m_qflags & XFS_GQUOTA_ACCT)
 225		seq_puts(m, ",gqnoenforce");
 226
 227	if (!(mp->m_qflags & XFS_ALL_QUOTA_ACCT))
 228		seq_puts(m, ",noquota");
 229
 230	return 0;
 231}
 232
 233static bool
 234xfs_set_inode_alloc_perag(
 235	struct xfs_perag	*pag,
 236	xfs_ino_t		ino,
 237	xfs_agnumber_t		max_metadata)
 238{
 239	if (!xfs_is_inode32(pag->pag_mount)) {
 240		set_bit(XFS_AGSTATE_ALLOWS_INODES, &pag->pag_opstate);
 241		clear_bit(XFS_AGSTATE_PREFERS_METADATA, &pag->pag_opstate);
 242		return false;
 243	}
 244
 245	if (ino > XFS_MAXINUMBER_32) {
 246		clear_bit(XFS_AGSTATE_ALLOWS_INODES, &pag->pag_opstate);
 247		clear_bit(XFS_AGSTATE_PREFERS_METADATA, &pag->pag_opstate);
 248		return false;
 249	}
 250
 251	set_bit(XFS_AGSTATE_ALLOWS_INODES, &pag->pag_opstate);
 252	if (pag->pag_agno < max_metadata)
 253		set_bit(XFS_AGSTATE_PREFERS_METADATA, &pag->pag_opstate);
 254	else
 255		clear_bit(XFS_AGSTATE_PREFERS_METADATA, &pag->pag_opstate);
 256	return true;
 257}
 258
 259/*
 260 * Set parameters for inode allocation heuristics, taking into account
 261 * filesystem size and inode32/inode64 mount options; i.e. specifically
 262 * whether or not XFS_FEAT_SMALL_INUMS is set.
 263 *
 264 * Inode allocation patterns are altered only if inode32 is requested
 265 * (XFS_FEAT_SMALL_INUMS), and the filesystem is sufficiently large.
 266 * If altered, XFS_OPSTATE_INODE32 is set as well.
 267 *
 268 * An agcount independent of that in the mount structure is provided
 269 * because in the growfs case, mp->m_sb.sb_agcount is not yet updated
 270 * to the potentially higher ag count.
 271 *
 272 * Returns the maximum AG index which may contain inodes.
 273 */
 274xfs_agnumber_t
 275xfs_set_inode_alloc(
 276	struct xfs_mount *mp,
 277	xfs_agnumber_t	agcount)
 278{
 279	xfs_agnumber_t	index;
 280	xfs_agnumber_t	maxagi = 0;
 281	xfs_sb_t	*sbp = &mp->m_sb;
 282	xfs_agnumber_t	max_metadata;
 283	xfs_agino_t	agino;
 284	xfs_ino_t	ino;
 285
 286	/*
 287	 * Calculate how much should be reserved for inodes to meet
 288	 * the max inode percentage.  Used only for inode32.
 289	 */
 290	if (M_IGEO(mp)->maxicount) {
 291		uint64_t	icount;
 292
 293		icount = sbp->sb_dblocks * sbp->sb_imax_pct;
 294		do_div(icount, 100);
 295		icount += sbp->sb_agblocks - 1;
 296		do_div(icount, sbp->sb_agblocks);
 297		max_metadata = icount;
 298	} else {
 299		max_metadata = agcount;
 300	}
 301
 302	/* Get the last possible inode in the filesystem */
 303	agino =	XFS_AGB_TO_AGINO(mp, sbp->sb_agblocks - 1);
 304	ino = XFS_AGINO_TO_INO(mp, agcount - 1, agino);
 305
 306	/*
 307	 * If user asked for no more than 32-bit inodes, and the fs is
 308	 * sufficiently large, set XFS_OPSTATE_INODE32 if we must alter
 309	 * the allocator to accommodate the request.
 310	 */
 311	if (xfs_has_small_inums(mp) && ino > XFS_MAXINUMBER_32)
 312		set_bit(XFS_OPSTATE_INODE32, &mp->m_opstate);
 313	else
 314		clear_bit(XFS_OPSTATE_INODE32, &mp->m_opstate);
 315
 316	for (index = 0; index < agcount; index++) {
 317		struct xfs_perag	*pag;
 318
 319		ino = XFS_AGINO_TO_INO(mp, index, agino);
 320
 321		pag = xfs_perag_get(mp, index);
 322		if (xfs_set_inode_alloc_perag(pag, ino, max_metadata))
 323			maxagi++;
 324		xfs_perag_put(pag);
 325	}
 326
 327	return xfs_is_inode32(mp) ? maxagi : agcount;
 328}
 329
 330static int
 331xfs_setup_dax_always(
 332	struct xfs_mount	*mp)
 333{
 334	if (!mp->m_ddev_targp->bt_daxdev &&
 335	    (!mp->m_rtdev_targp || !mp->m_rtdev_targp->bt_daxdev)) {
 336		xfs_alert(mp,
 337			"DAX unsupported by block device. Turning off DAX.");
 338		goto disable_dax;
 339	}
 340
 341	if (mp->m_super->s_blocksize != PAGE_SIZE) {
 342		xfs_alert(mp,
 343			"DAX not supported for blocksize. Turning off DAX.");
 344		goto disable_dax;
 345	}
 346
 347	if (xfs_has_reflink(mp) &&
 348	    bdev_is_partition(mp->m_ddev_targp->bt_bdev)) {
 349		xfs_alert(mp,
 350			"DAX and reflink cannot work with multi-partitions!");
 351		return -EINVAL;
 352	}
 353
 354	return 0;
 355
 356disable_dax:
 357	xfs_mount_set_dax_mode(mp, XFS_DAX_NEVER);
 358	return 0;
 359}
 360
 361STATIC int
 362xfs_blkdev_get(
 363	xfs_mount_t		*mp,
 364	const char		*name,
 365	struct file		**bdev_filep)
 366{
 367	int			error = 0;
 368
 369	*bdev_filep = bdev_file_open_by_path(name,
 370		BLK_OPEN_READ | BLK_OPEN_WRITE | BLK_OPEN_RESTRICT_WRITES,
 371		mp->m_super, &fs_holder_ops);
 372	if (IS_ERR(*bdev_filep)) {
 373		error = PTR_ERR(*bdev_filep);
 374		*bdev_filep = NULL;
 375		xfs_warn(mp, "Invalid device [%s], error=%d", name, error);
 376	}
 377
 378	return error;
 379}
 380
 381STATIC void
 382xfs_shutdown_devices(
 383	struct xfs_mount	*mp)
 384{
 385	/*
 386	 * Udev is triggered whenever anyone closes a block device or unmounts
 387	 * a file systemm on a block device.
 388	 * The default udev rules invoke blkid to read the fs super and create
 389	 * symlinks to the bdev under /dev/disk.  For this, it uses buffered
 390	 * reads through the page cache.
 391	 *
 392	 * xfs_db also uses buffered reads to examine metadata.  There is no
 393	 * coordination between xfs_db and udev, which means that they can run
 394	 * concurrently.  Note there is no coordination between the kernel and
 395	 * blkid either.
 396	 *
 397	 * On a system with 64k pages, the page cache can cache the superblock
 398	 * and the root inode (and hence the root directory) with the same 64k
 399	 * page.  If udev spawns blkid after the mkfs and the system is busy
 400	 * enough that it is still running when xfs_db starts up, they'll both
 401	 * read from the same page in the pagecache.
 402	 *
 403	 * The unmount writes updated inode metadata to disk directly.  The XFS
 404	 * buffer cache does not use the bdev pagecache, so it needs to
 405	 * invalidate that pagecache on unmount.  If the above scenario occurs,
 406	 * the pagecache no longer reflects what's on disk, xfs_db reads the
 407	 * stale metadata, and fails to find /a.  Most of the time this succeeds
 408	 * because closing a bdev invalidates the page cache, but when processes
 409	 * race, everyone loses.
 410	 */
 411	if (mp->m_logdev_targp && mp->m_logdev_targp != mp->m_ddev_targp) {
 412		blkdev_issue_flush(mp->m_logdev_targp->bt_bdev);
 413		invalidate_bdev(mp->m_logdev_targp->bt_bdev);
 414	}
 415	if (mp->m_rtdev_targp) {
 416		blkdev_issue_flush(mp->m_rtdev_targp->bt_bdev);
 417		invalidate_bdev(mp->m_rtdev_targp->bt_bdev);
 418	}
 419	blkdev_issue_flush(mp->m_ddev_targp->bt_bdev);
 420	invalidate_bdev(mp->m_ddev_targp->bt_bdev);
 421}
 422
 423/*
 424 * The file system configurations are:
 425 *	(1) device (partition) with data and internal log
 426 *	(2) logical volume with data and log subvolumes.
 427 *	(3) logical volume with data, log, and realtime subvolumes.
 428 *
 429 * We only have to handle opening the log and realtime volumes here if
 430 * they are present.  The data subvolume has already been opened by
 431 * get_sb_bdev() and is stored in sb->s_bdev.
 432 */
 433STATIC int
 434xfs_open_devices(
 435	struct xfs_mount	*mp)
 436{
 437	struct super_block	*sb = mp->m_super;
 438	struct block_device	*ddev = sb->s_bdev;
 439	struct file		*logdev_file = NULL, *rtdev_file = NULL;
 440	int			error;
 441
 442	/*
 443	 * Open real time and log devices - order is important.
 444	 */
 445	if (mp->m_logname) {
 446		error = xfs_blkdev_get(mp, mp->m_logname, &logdev_file);
 447		if (error)
 448			return error;
 449	}
 450
 451	if (mp->m_rtname) {
 452		error = xfs_blkdev_get(mp, mp->m_rtname, &rtdev_file);
 453		if (error)
 454			goto out_close_logdev;
 455
 456		if (file_bdev(rtdev_file) == ddev ||
 457		    (logdev_file &&
 458		     file_bdev(rtdev_file) == file_bdev(logdev_file))) {
 459			xfs_warn(mp,
 460	"Cannot mount filesystem with identical rtdev and ddev/logdev.");
 461			error = -EINVAL;
 462			goto out_close_rtdev;
 463		}
 464	}
 465
 466	/*
 467	 * Setup xfs_mount buffer target pointers
 468	 */
 469	error = -ENOMEM;
 470	mp->m_ddev_targp = xfs_alloc_buftarg(mp, sb->s_bdev_file);
 471	if (!mp->m_ddev_targp)
 472		goto out_close_rtdev;
 473
 474	if (rtdev_file) {
 475		mp->m_rtdev_targp = xfs_alloc_buftarg(mp, rtdev_file);
 476		if (!mp->m_rtdev_targp)
 477			goto out_free_ddev_targ;
 478	}
 479
 480	if (logdev_file && file_bdev(logdev_file) != ddev) {
 481		mp->m_logdev_targp = xfs_alloc_buftarg(mp, logdev_file);
 482		if (!mp->m_logdev_targp)
 483			goto out_free_rtdev_targ;
 484	} else {
 485		mp->m_logdev_targp = mp->m_ddev_targp;
 486		/* Handle won't be used, drop it */
 487		if (logdev_file)
 488			bdev_fput(logdev_file);
 489	}
 490
 491	return 0;
 492
 493 out_free_rtdev_targ:
 494	if (mp->m_rtdev_targp)
 495		xfs_free_buftarg(mp->m_rtdev_targp);
 496 out_free_ddev_targ:
 497	xfs_free_buftarg(mp->m_ddev_targp);
 498 out_close_rtdev:
 499	 if (rtdev_file)
 500		bdev_fput(rtdev_file);
 501 out_close_logdev:
 502	if (logdev_file)
 503		bdev_fput(logdev_file);
 504	return error;
 505}
 506
 507/*
 508 * Setup xfs_mount buffer target pointers based on superblock
 509 */
 510STATIC int
 511xfs_setup_devices(
 512	struct xfs_mount	*mp)
 513{
 514	int			error;
 515
 516	error = xfs_setsize_buftarg(mp->m_ddev_targp, mp->m_sb.sb_sectsize);
 517	if (error)
 518		return error;
 519
 520	if (mp->m_logdev_targp && mp->m_logdev_targp != mp->m_ddev_targp) {
 521		unsigned int	log_sector_size = BBSIZE;
 522
 523		if (xfs_has_sector(mp))
 524			log_sector_size = mp->m_sb.sb_logsectsize;
 525		error = xfs_setsize_buftarg(mp->m_logdev_targp,
 526					    log_sector_size);
 527		if (error)
 528			return error;
 529	}
 530	if (mp->m_rtdev_targp) {
 531		error = xfs_setsize_buftarg(mp->m_rtdev_targp,
 532					    mp->m_sb.sb_sectsize);
 533		if (error)
 534			return error;
 535	}
 536
 537	return 0;
 538}
 539
 540STATIC int
 541xfs_init_mount_workqueues(
 542	struct xfs_mount	*mp)
 543{
 544	mp->m_buf_workqueue = alloc_workqueue("xfs-buf/%s",
 545			XFS_WQFLAGS(WQ_FREEZABLE | WQ_MEM_RECLAIM),
 546			1, mp->m_super->s_id);
 547	if (!mp->m_buf_workqueue)
 548		goto out;
 549
 550	mp->m_unwritten_workqueue = alloc_workqueue("xfs-conv/%s",
 551			XFS_WQFLAGS(WQ_FREEZABLE | WQ_MEM_RECLAIM),
 552			0, mp->m_super->s_id);
 553	if (!mp->m_unwritten_workqueue)
 554		goto out_destroy_buf;
 555
 556	mp->m_reclaim_workqueue = alloc_workqueue("xfs-reclaim/%s",
 557			XFS_WQFLAGS(WQ_FREEZABLE | WQ_MEM_RECLAIM),
 558			0, mp->m_super->s_id);
 559	if (!mp->m_reclaim_workqueue)
 560		goto out_destroy_unwritten;
 561
 562	mp->m_blockgc_wq = alloc_workqueue("xfs-blockgc/%s",
 563			XFS_WQFLAGS(WQ_UNBOUND | WQ_FREEZABLE | WQ_MEM_RECLAIM),
 564			0, mp->m_super->s_id);
 565	if (!mp->m_blockgc_wq)
 566		goto out_destroy_reclaim;
 567
 568	mp->m_inodegc_wq = alloc_workqueue("xfs-inodegc/%s",
 569			XFS_WQFLAGS(WQ_FREEZABLE | WQ_MEM_RECLAIM),
 570			1, mp->m_super->s_id);
 571	if (!mp->m_inodegc_wq)
 572		goto out_destroy_blockgc;
 573
 574	mp->m_sync_workqueue = alloc_workqueue("xfs-sync/%s",
 575			XFS_WQFLAGS(WQ_FREEZABLE), 0, mp->m_super->s_id);
 576	if (!mp->m_sync_workqueue)
 577		goto out_destroy_inodegc;
 578
 579	return 0;
 580
 581out_destroy_inodegc:
 582	destroy_workqueue(mp->m_inodegc_wq);
 583out_destroy_blockgc:
 584	destroy_workqueue(mp->m_blockgc_wq);
 585out_destroy_reclaim:
 586	destroy_workqueue(mp->m_reclaim_workqueue);
 587out_destroy_unwritten:
 588	destroy_workqueue(mp->m_unwritten_workqueue);
 589out_destroy_buf:
 590	destroy_workqueue(mp->m_buf_workqueue);
 591out:
 592	return -ENOMEM;
 593}
 594
 595STATIC void
 596xfs_destroy_mount_workqueues(
 597	struct xfs_mount	*mp)
 598{
 599	destroy_workqueue(mp->m_sync_workqueue);
 600	destroy_workqueue(mp->m_blockgc_wq);
 601	destroy_workqueue(mp->m_inodegc_wq);
 602	destroy_workqueue(mp->m_reclaim_workqueue);
 603	destroy_workqueue(mp->m_unwritten_workqueue);
 604	destroy_workqueue(mp->m_buf_workqueue);
 605}
 606
 607static void
 608xfs_flush_inodes_worker(
 609	struct work_struct	*work)
 610{
 611	struct xfs_mount	*mp = container_of(work, struct xfs_mount,
 612						   m_flush_inodes_work);
 613	struct super_block	*sb = mp->m_super;
 614
 615	if (down_read_trylock(&sb->s_umount)) {
 616		sync_inodes_sb(sb);
 617		up_read(&sb->s_umount);
 618	}
 619}
 620
 621/*
 622 * Flush all dirty data to disk. Must not be called while holding an XFS_ILOCK
 623 * or a page lock. We use sync_inodes_sb() here to ensure we block while waiting
 624 * for IO to complete so that we effectively throttle multiple callers to the
 625 * rate at which IO is completing.
 626 */
 627void
 628xfs_flush_inodes(
 629	struct xfs_mount	*mp)
 630{
 631	/*
 632	 * If flush_work() returns true then that means we waited for a flush
 633	 * which was already in progress.  Don't bother running another scan.
 634	 */
 635	if (flush_work(&mp->m_flush_inodes_work))
 636		return;
 637
 638	queue_work(mp->m_sync_workqueue, &mp->m_flush_inodes_work);
 639	flush_work(&mp->m_flush_inodes_work);
 640}
 641
 642/* Catch misguided souls that try to use this interface on XFS */
 643STATIC struct inode *
 644xfs_fs_alloc_inode(
 645	struct super_block	*sb)
 646{
 647	BUG();
 648	return NULL;
 649}
 650
 651/*
 652 * Now that the generic code is guaranteed not to be accessing
 653 * the linux inode, we can inactivate and reclaim the inode.
 654 */
 655STATIC void
 656xfs_fs_destroy_inode(
 657	struct inode		*inode)
 658{
 659	struct xfs_inode	*ip = XFS_I(inode);
 660
 661	trace_xfs_destroy_inode(ip);
 662
 663	ASSERT(!rwsem_is_locked(&inode->i_rwsem));
 664	XFS_STATS_INC(ip->i_mount, vn_rele);
 665	XFS_STATS_INC(ip->i_mount, vn_remove);
 666	xfs_inode_mark_reclaimable(ip);
 667}
 668
 669static void
 670xfs_fs_dirty_inode(
 671	struct inode			*inode,
 672	int				flags)
 673{
 674	struct xfs_inode		*ip = XFS_I(inode);
 675	struct xfs_mount		*mp = ip->i_mount;
 676	struct xfs_trans		*tp;
 677
 678	if (!(inode->i_sb->s_flags & SB_LAZYTIME))
 679		return;
 680
 681	/*
 682	 * Only do the timestamp update if the inode is dirty (I_DIRTY_SYNC)
 683	 * and has dirty timestamp (I_DIRTY_TIME). I_DIRTY_TIME can be passed
 684	 * in flags possibly together with I_DIRTY_SYNC.
 685	 */
 686	if ((flags & ~I_DIRTY_TIME) != I_DIRTY_SYNC || !(flags & I_DIRTY_TIME))
 687		return;
 688
 689	if (xfs_trans_alloc(mp, &M_RES(mp)->tr_fsyncts, 0, 0, 0, &tp))
 690		return;
 691	xfs_ilock(ip, XFS_ILOCK_EXCL);
 692	xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
 693	xfs_trans_log_inode(tp, ip, XFS_ILOG_TIMESTAMP);
 694	xfs_trans_commit(tp);
 695}
 696
 697/*
 698 * Slab object creation initialisation for the XFS inode.
 699 * This covers only the idempotent fields in the XFS inode;
 700 * all other fields need to be initialised on allocation
 701 * from the slab. This avoids the need to repeatedly initialise
 702 * fields in the xfs inode that left in the initialise state
 703 * when freeing the inode.
 704 */
 705STATIC void
 706xfs_fs_inode_init_once(
 707	void			*inode)
 708{
 709	struct xfs_inode	*ip = inode;
 710
 711	memset(ip, 0, sizeof(struct xfs_inode));
 712
 713	/* vfs inode */
 714	inode_init_once(VFS_I(ip));
 715
 716	/* xfs inode */
 717	atomic_set(&ip->i_pincount, 0);
 718	spin_lock_init(&ip->i_flags_lock);
 719	init_rwsem(&ip->i_lock);
 720}
 721
 722/*
 723 * We do an unlocked check for XFS_IDONTCACHE here because we are already
 724 * serialised against cache hits here via the inode->i_lock and igrab() in
 725 * xfs_iget_cache_hit(). Hence a lookup that might clear this flag will not be
 726 * racing with us, and it avoids needing to grab a spinlock here for every inode
 727 * we drop the final reference on.
 728 */
 729STATIC int
 730xfs_fs_drop_inode(
 731	struct inode		*inode)
 732{
 733	struct xfs_inode	*ip = XFS_I(inode);
 734
 735	/*
 736	 * If this unlinked inode is in the middle of recovery, don't
 737	 * drop the inode just yet; log recovery will take care of
 738	 * that.  See the comment for this inode flag.
 739	 */
 740	if (ip->i_flags & XFS_IRECOVERY) {
 741		ASSERT(xlog_recovery_needed(ip->i_mount->m_log));
 742		return 0;
 743	}
 744
 745	return generic_drop_inode(inode);
 746}
 747
 748static void
 749xfs_mount_free(
 750	struct xfs_mount	*mp)
 751{
 752	if (mp->m_logdev_targp && mp->m_logdev_targp != mp->m_ddev_targp)
 753		xfs_free_buftarg(mp->m_logdev_targp);
 754	if (mp->m_rtdev_targp)
 755		xfs_free_buftarg(mp->m_rtdev_targp);
 756	if (mp->m_ddev_targp)
 757		xfs_free_buftarg(mp->m_ddev_targp);
 758
 759	debugfs_remove(mp->m_debugfs);
 760	kfree(mp->m_rtname);
 761	kfree(mp->m_logname);
 762	kfree(mp);
 763}
 764
 765STATIC int
 766xfs_fs_sync_fs(
 767	struct super_block	*sb,
 768	int			wait)
 769{
 770	struct xfs_mount	*mp = XFS_M(sb);
 771	int			error;
 772
 773	trace_xfs_fs_sync_fs(mp, __return_address);
 774
 775	/*
 776	 * Doing anything during the async pass would be counterproductive.
 777	 */
 778	if (!wait)
 779		return 0;
 780
 781	error = xfs_log_force(mp, XFS_LOG_SYNC);
 782	if (error)
 783		return error;
 784
 785	if (laptop_mode) {
 786		/*
 787		 * The disk must be active because we're syncing.
 788		 * We schedule log work now (now that the disk is
 789		 * active) instead of later (when it might not be).
 790		 */
 791		flush_delayed_work(&mp->m_log->l_work);
 792	}
 793
 794	/*
 795	 * If we are called with page faults frozen out, it means we are about
 796	 * to freeze the transaction subsystem. Take the opportunity to shut
 797	 * down inodegc because once SB_FREEZE_FS is set it's too late to
 798	 * prevent inactivation races with freeze. The fs doesn't get called
 799	 * again by the freezing process until after SB_FREEZE_FS has been set,
 800	 * so it's now or never.  Same logic applies to speculative allocation
 801	 * garbage collection.
 802	 *
 803	 * We don't care if this is a normal syncfs call that does this or
 804	 * freeze that does this - we can run this multiple times without issue
 805	 * and we won't race with a restart because a restart can only occur
 806	 * when the state is either SB_FREEZE_FS or SB_FREEZE_COMPLETE.
 807	 */
 808	if (sb->s_writers.frozen == SB_FREEZE_PAGEFAULT) {
 809		xfs_inodegc_stop(mp);
 810		xfs_blockgc_stop(mp);
 811	}
 812
 813	return 0;
 814}
 815
 816STATIC int
 817xfs_fs_statfs(
 818	struct dentry		*dentry,
 819	struct kstatfs		*statp)
 820{
 821	struct xfs_mount	*mp = XFS_M(dentry->d_sb);
 822	xfs_sb_t		*sbp = &mp->m_sb;
 823	struct xfs_inode	*ip = XFS_I(d_inode(dentry));
 824	uint64_t		fakeinos, id;
 825	uint64_t		icount;
 826	uint64_t		ifree;
 827	uint64_t		fdblocks;
 828	xfs_extlen_t		lsize;
 829	int64_t			ffree;
 830
 831	/*
 832	 * Expedite background inodegc but don't wait. We do not want to block
 833	 * here waiting hours for a billion extent file to be truncated.
 834	 */
 835	xfs_inodegc_push(mp);
 836
 837	statp->f_type = XFS_SUPER_MAGIC;
 838	statp->f_namelen = MAXNAMELEN - 1;
 839
 840	id = huge_encode_dev(mp->m_ddev_targp->bt_dev);
 841	statp->f_fsid = u64_to_fsid(id);
 842
 843	icount = percpu_counter_sum(&mp->m_icount);
 844	ifree = percpu_counter_sum(&mp->m_ifree);
 845	fdblocks = percpu_counter_sum(&mp->m_fdblocks);
 846
 847	spin_lock(&mp->m_sb_lock);
 848	statp->f_bsize = sbp->sb_blocksize;
 849	lsize = sbp->sb_logstart ? sbp->sb_logblocks : 0;
 850	statp->f_blocks = sbp->sb_dblocks - lsize;
 851	spin_unlock(&mp->m_sb_lock);
 852
 853	/* make sure statp->f_bfree does not underflow */
 854	statp->f_bfree = max_t(int64_t, 0,
 855				fdblocks - xfs_fdblocks_unavailable(mp));
 856	statp->f_bavail = statp->f_bfree;
 857
 858	fakeinos = XFS_FSB_TO_INO(mp, statp->f_bfree);
 859	statp->f_files = min(icount + fakeinos, (uint64_t)XFS_MAXINUMBER);
 860	if (M_IGEO(mp)->maxicount)
 861		statp->f_files = min_t(typeof(statp->f_files),
 862					statp->f_files,
 863					M_IGEO(mp)->maxicount);
 864
 865	/* If sb_icount overshot maxicount, report actual allocation */
 866	statp->f_files = max_t(typeof(statp->f_files),
 867					statp->f_files,
 868					sbp->sb_icount);
 869
 870	/* make sure statp->f_ffree does not underflow */
 871	ffree = statp->f_files - (icount - ifree);
 872	statp->f_ffree = max_t(int64_t, ffree, 0);
 873
 874
 875	if ((ip->i_diflags & XFS_DIFLAG_PROJINHERIT) &&
 876	    ((mp->m_qflags & (XFS_PQUOTA_ACCT|XFS_PQUOTA_ENFD))) ==
 877			      (XFS_PQUOTA_ACCT|XFS_PQUOTA_ENFD))
 878		xfs_qm_statvfs(ip, statp);
 879
 880	if (XFS_IS_REALTIME_MOUNT(mp) &&
 881	    (ip->i_diflags & (XFS_DIFLAG_RTINHERIT | XFS_DIFLAG_REALTIME))) {
 882		s64	freertx;
 883
 884		statp->f_blocks = sbp->sb_rblocks;
 885		freertx = percpu_counter_sum_positive(&mp->m_frextents);
 886		statp->f_bavail = statp->f_bfree = xfs_rtx_to_rtb(mp, freertx);
 
 887	}
 888
 
 
 
 
 
 889	return 0;
 890}
 891
 892STATIC void
 893xfs_save_resvblks(struct xfs_mount *mp)
 894{
 895	mp->m_resblks_save = mp->m_resblks;
 896	xfs_reserve_blocks(mp, 0);
 897}
 898
 899STATIC void
 900xfs_restore_resvblks(struct xfs_mount *mp)
 901{
 902	uint64_t resblks;
 903
 904	if (mp->m_resblks_save) {
 905		resblks = mp->m_resblks_save;
 906		mp->m_resblks_save = 0;
 907	} else
 908		resblks = xfs_default_resblks(mp);
 909
 910	xfs_reserve_blocks(mp, resblks);
 911}
 912
 913/*
 914 * Second stage of a freeze. The data is already frozen so we only
 915 * need to take care of the metadata. Once that's done sync the superblock
 916 * to the log to dirty it in case of a crash while frozen. This ensures that we
 917 * will recover the unlinked inode lists on the next mount.
 918 */
 919STATIC int
 920xfs_fs_freeze(
 921	struct super_block	*sb)
 922{
 923	struct xfs_mount	*mp = XFS_M(sb);
 924	unsigned int		flags;
 925	int			ret;
 926
 927	/*
 928	 * The filesystem is now frozen far enough that memory reclaim
 929	 * cannot safely operate on the filesystem. Hence we need to
 930	 * set a GFP_NOFS context here to avoid recursion deadlocks.
 931	 */
 932	flags = memalloc_nofs_save();
 933	xfs_save_resvblks(mp);
 934	ret = xfs_log_quiesce(mp);
 935	memalloc_nofs_restore(flags);
 936
 937	/*
 938	 * For read-write filesystems, we need to restart the inodegc on error
 939	 * because we stopped it at SB_FREEZE_PAGEFAULT level and a thaw is not
 940	 * going to be run to restart it now.  We are at SB_FREEZE_FS level
 941	 * here, so we can restart safely without racing with a stop in
 942	 * xfs_fs_sync_fs().
 943	 */
 944	if (ret && !xfs_is_readonly(mp)) {
 945		xfs_blockgc_start(mp);
 946		xfs_inodegc_start(mp);
 947	}
 948
 949	return ret;
 950}
 951
 952STATIC int
 953xfs_fs_unfreeze(
 954	struct super_block	*sb)
 955{
 956	struct xfs_mount	*mp = XFS_M(sb);
 957
 958	xfs_restore_resvblks(mp);
 959	xfs_log_work_queue(mp);
 960
 961	/*
 962	 * Don't reactivate the inodegc worker on a readonly filesystem because
 963	 * inodes are sent directly to reclaim.  Don't reactivate the blockgc
 964	 * worker because there are no speculative preallocations on a readonly
 965	 * filesystem.
 966	 */
 967	if (!xfs_is_readonly(mp)) {
 968		xfs_blockgc_start(mp);
 969		xfs_inodegc_start(mp);
 970	}
 971
 972	return 0;
 973}
 974
 975/*
 976 * This function fills in xfs_mount_t fields based on mount args.
 977 * Note: the superblock _has_ now been read in.
 978 */
 979STATIC int
 980xfs_finish_flags(
 981	struct xfs_mount	*mp)
 982{
 983	/* Fail a mount where the logbuf is smaller than the log stripe */
 984	if (xfs_has_logv2(mp)) {
 985		if (mp->m_logbsize <= 0 &&
 986		    mp->m_sb.sb_logsunit > XLOG_BIG_RECORD_BSIZE) {
 987			mp->m_logbsize = mp->m_sb.sb_logsunit;
 988		} else if (mp->m_logbsize > 0 &&
 989			   mp->m_logbsize < mp->m_sb.sb_logsunit) {
 990			xfs_warn(mp,
 991		"logbuf size must be greater than or equal to log stripe size");
 992			return -EINVAL;
 993		}
 994	} else {
 995		/* Fail a mount if the logbuf is larger than 32K */
 996		if (mp->m_logbsize > XLOG_BIG_RECORD_BSIZE) {
 997			xfs_warn(mp,
 998		"logbuf size for version 1 logs must be 16K or 32K");
 999			return -EINVAL;
1000		}
1001	}
1002
1003	/*
1004	 * V5 filesystems always use attr2 format for attributes.
1005	 */
1006	if (xfs_has_crc(mp) && xfs_has_noattr2(mp)) {
1007		xfs_warn(mp, "Cannot mount a V5 filesystem as noattr2. "
1008			     "attr2 is always enabled for V5 filesystems.");
1009		return -EINVAL;
1010	}
1011
1012	/*
1013	 * prohibit r/w mounts of read-only filesystems
1014	 */
1015	if ((mp->m_sb.sb_flags & XFS_SBF_READONLY) && !xfs_is_readonly(mp)) {
1016		xfs_warn(mp,
1017			"cannot mount a read-only filesystem as read-write");
1018		return -EROFS;
1019	}
1020
1021	if ((mp->m_qflags & XFS_GQUOTA_ACCT) &&
1022	    (mp->m_qflags & XFS_PQUOTA_ACCT) &&
1023	    !xfs_has_pquotino(mp)) {
1024		xfs_warn(mp,
1025		  "Super block does not support project and group quota together");
1026		return -EINVAL;
1027	}
1028
1029	return 0;
1030}
1031
1032static int
1033xfs_init_percpu_counters(
1034	struct xfs_mount	*mp)
1035{
1036	int		error;
1037
1038	error = percpu_counter_init(&mp->m_icount, 0, GFP_KERNEL);
1039	if (error)
1040		return -ENOMEM;
1041
1042	error = percpu_counter_init(&mp->m_ifree, 0, GFP_KERNEL);
1043	if (error)
1044		goto free_icount;
1045
1046	error = percpu_counter_init(&mp->m_fdblocks, 0, GFP_KERNEL);
1047	if (error)
1048		goto free_ifree;
1049
1050	error = percpu_counter_init(&mp->m_delalloc_blks, 0, GFP_KERNEL);
1051	if (error)
1052		goto free_fdblocks;
1053
1054	error = percpu_counter_init(&mp->m_frextents, 0, GFP_KERNEL);
1055	if (error)
1056		goto free_delalloc;
1057
 
 
 
 
1058	return 0;
1059
 
 
1060free_delalloc:
1061	percpu_counter_destroy(&mp->m_delalloc_blks);
1062free_fdblocks:
1063	percpu_counter_destroy(&mp->m_fdblocks);
1064free_ifree:
1065	percpu_counter_destroy(&mp->m_ifree);
1066free_icount:
1067	percpu_counter_destroy(&mp->m_icount);
1068	return -ENOMEM;
1069}
1070
1071void
1072xfs_reinit_percpu_counters(
1073	struct xfs_mount	*mp)
1074{
1075	percpu_counter_set(&mp->m_icount, mp->m_sb.sb_icount);
1076	percpu_counter_set(&mp->m_ifree, mp->m_sb.sb_ifree);
1077	percpu_counter_set(&mp->m_fdblocks, mp->m_sb.sb_fdblocks);
1078	percpu_counter_set(&mp->m_frextents, mp->m_sb.sb_frextents);
1079}
1080
1081static void
1082xfs_destroy_percpu_counters(
1083	struct xfs_mount	*mp)
1084{
1085	percpu_counter_destroy(&mp->m_icount);
1086	percpu_counter_destroy(&mp->m_ifree);
1087	percpu_counter_destroy(&mp->m_fdblocks);
1088	ASSERT(xfs_is_shutdown(mp) ||
 
 
 
1089	       percpu_counter_sum(&mp->m_delalloc_blks) == 0);
1090	percpu_counter_destroy(&mp->m_delalloc_blks);
1091	percpu_counter_destroy(&mp->m_frextents);
1092}
1093
1094static int
1095xfs_inodegc_init_percpu(
1096	struct xfs_mount	*mp)
1097{
1098	struct xfs_inodegc	*gc;
1099	int			cpu;
1100
1101	mp->m_inodegc = alloc_percpu(struct xfs_inodegc);
1102	if (!mp->m_inodegc)
1103		return -ENOMEM;
1104
1105	for_each_possible_cpu(cpu) {
1106		gc = per_cpu_ptr(mp->m_inodegc, cpu);
1107		gc->cpu = cpu;
1108		gc->mp = mp;
1109		init_llist_head(&gc->list);
1110		gc->items = 0;
1111		gc->error = 0;
1112		INIT_DELAYED_WORK(&gc->work, xfs_inodegc_worker);
1113	}
1114	return 0;
1115}
1116
1117static void
1118xfs_inodegc_free_percpu(
1119	struct xfs_mount	*mp)
1120{
1121	if (!mp->m_inodegc)
1122		return;
1123	free_percpu(mp->m_inodegc);
1124}
1125
1126static void
1127xfs_fs_put_super(
1128	struct super_block	*sb)
1129{
1130	struct xfs_mount	*mp = XFS_M(sb);
1131
1132	xfs_notice(mp, "Unmounting Filesystem %pU", &mp->m_sb.sb_uuid);
1133	xfs_filestream_unmount(mp);
1134	xfs_unmountfs(mp);
1135
 
1136	xfs_freesb(mp);
1137	xchk_mount_stats_free(mp);
1138	free_percpu(mp->m_stats.xs_stats);
1139	xfs_inodegc_free_percpu(mp);
1140	xfs_destroy_percpu_counters(mp);
1141	xfs_destroy_mount_workqueues(mp);
1142	xfs_shutdown_devices(mp);
1143}
1144
1145static long
1146xfs_fs_nr_cached_objects(
1147	struct super_block	*sb,
1148	struct shrink_control	*sc)
1149{
1150	/* Paranoia: catch incorrect calls during mount setup or teardown */
1151	if (WARN_ON_ONCE(!sb->s_fs_info))
1152		return 0;
1153	return xfs_reclaim_inodes_count(XFS_M(sb));
1154}
1155
1156static long
1157xfs_fs_free_cached_objects(
1158	struct super_block	*sb,
1159	struct shrink_control	*sc)
1160{
1161	return xfs_reclaim_inodes_nr(XFS_M(sb), sc->nr_to_scan);
1162}
1163
1164static void
1165xfs_fs_shutdown(
1166	struct super_block	*sb)
1167{
1168	xfs_force_shutdown(XFS_M(sb), SHUTDOWN_DEVICE_REMOVED);
1169}
1170
1171static const struct super_operations xfs_super_operations = {
1172	.alloc_inode		= xfs_fs_alloc_inode,
1173	.destroy_inode		= xfs_fs_destroy_inode,
1174	.dirty_inode		= xfs_fs_dirty_inode,
1175	.drop_inode		= xfs_fs_drop_inode,
1176	.put_super		= xfs_fs_put_super,
1177	.sync_fs		= xfs_fs_sync_fs,
1178	.freeze_fs		= xfs_fs_freeze,
1179	.unfreeze_fs		= xfs_fs_unfreeze,
1180	.statfs			= xfs_fs_statfs,
1181	.show_options		= xfs_fs_show_options,
1182	.nr_cached_objects	= xfs_fs_nr_cached_objects,
1183	.free_cached_objects	= xfs_fs_free_cached_objects,
1184	.shutdown		= xfs_fs_shutdown,
1185};
1186
1187static int
1188suffix_kstrtoint(
1189	const char	*s,
1190	unsigned int	base,
1191	int		*res)
1192{
1193	int		last, shift_left_factor = 0, _res;
1194	char		*value;
1195	int		ret = 0;
1196
1197	value = kstrdup(s, GFP_KERNEL);
1198	if (!value)
1199		return -ENOMEM;
1200
1201	last = strlen(value) - 1;
1202	if (value[last] == 'K' || value[last] == 'k') {
1203		shift_left_factor = 10;
1204		value[last] = '\0';
1205	}
1206	if (value[last] == 'M' || value[last] == 'm') {
1207		shift_left_factor = 20;
1208		value[last] = '\0';
1209	}
1210	if (value[last] == 'G' || value[last] == 'g') {
1211		shift_left_factor = 30;
1212		value[last] = '\0';
1213	}
1214
1215	if (kstrtoint(value, base, &_res))
1216		ret = -EINVAL;
1217	kfree(value);
1218	*res = _res << shift_left_factor;
1219	return ret;
1220}
1221
1222static inline void
1223xfs_fs_warn_deprecated(
1224	struct fs_context	*fc,
1225	struct fs_parameter	*param,
1226	uint64_t		flag,
1227	bool			value)
1228{
1229	/* Don't print the warning if reconfiguring and current mount point
1230	 * already had the flag set
1231	 */
1232	if ((fc->purpose & FS_CONTEXT_FOR_RECONFIGURE) &&
1233            !!(XFS_M(fc->root->d_sb)->m_features & flag) == value)
1234		return;
1235	xfs_warn(fc->s_fs_info, "%s mount option is deprecated.", param->key);
1236}
1237
1238/*
1239 * Set mount state from a mount option.
1240 *
1241 * NOTE: mp->m_super is NULL here!
1242 */
1243static int
1244xfs_fs_parse_param(
1245	struct fs_context	*fc,
1246	struct fs_parameter	*param)
1247{
1248	struct xfs_mount	*parsing_mp = fc->s_fs_info;
1249	struct fs_parse_result	result;
1250	int			size = 0;
1251	int			opt;
1252
 
 
1253	opt = fs_parse(fc, xfs_fs_parameters, param, &result);
1254	if (opt < 0)
1255		return opt;
1256
1257	switch (opt) {
1258	case Opt_logbufs:
1259		parsing_mp->m_logbufs = result.uint_32;
1260		return 0;
1261	case Opt_logbsize:
1262		if (suffix_kstrtoint(param->string, 10, &parsing_mp->m_logbsize))
1263			return -EINVAL;
1264		return 0;
1265	case Opt_logdev:
1266		kfree(parsing_mp->m_logname);
1267		parsing_mp->m_logname = kstrdup(param->string, GFP_KERNEL);
1268		if (!parsing_mp->m_logname)
1269			return -ENOMEM;
1270		return 0;
1271	case Opt_rtdev:
1272		kfree(parsing_mp->m_rtname);
1273		parsing_mp->m_rtname = kstrdup(param->string, GFP_KERNEL);
1274		if (!parsing_mp->m_rtname)
1275			return -ENOMEM;
1276		return 0;
1277	case Opt_allocsize:
1278		if (suffix_kstrtoint(param->string, 10, &size))
1279			return -EINVAL;
1280		parsing_mp->m_allocsize_log = ffs(size) - 1;
1281		parsing_mp->m_features |= XFS_FEAT_ALLOCSIZE;
1282		return 0;
1283	case Opt_grpid:
1284	case Opt_bsdgroups:
1285		parsing_mp->m_features |= XFS_FEAT_GRPID;
1286		return 0;
1287	case Opt_nogrpid:
1288	case Opt_sysvgroups:
1289		parsing_mp->m_features &= ~XFS_FEAT_GRPID;
1290		return 0;
1291	case Opt_wsync:
1292		parsing_mp->m_features |= XFS_FEAT_WSYNC;
1293		return 0;
1294	case Opt_norecovery:
1295		parsing_mp->m_features |= XFS_FEAT_NORECOVERY;
1296		return 0;
1297	case Opt_noalign:
1298		parsing_mp->m_features |= XFS_FEAT_NOALIGN;
1299		return 0;
1300	case Opt_swalloc:
1301		parsing_mp->m_features |= XFS_FEAT_SWALLOC;
1302		return 0;
1303	case Opt_sunit:
1304		parsing_mp->m_dalign = result.uint_32;
1305		return 0;
1306	case Opt_swidth:
1307		parsing_mp->m_swidth = result.uint_32;
1308		return 0;
1309	case Opt_inode32:
1310		parsing_mp->m_features |= XFS_FEAT_SMALL_INUMS;
1311		return 0;
1312	case Opt_inode64:
1313		parsing_mp->m_features &= ~XFS_FEAT_SMALL_INUMS;
1314		return 0;
1315	case Opt_nouuid:
1316		parsing_mp->m_features |= XFS_FEAT_NOUUID;
1317		return 0;
1318	case Opt_largeio:
1319		parsing_mp->m_features |= XFS_FEAT_LARGE_IOSIZE;
1320		return 0;
1321	case Opt_nolargeio:
1322		parsing_mp->m_features &= ~XFS_FEAT_LARGE_IOSIZE;
1323		return 0;
1324	case Opt_filestreams:
1325		parsing_mp->m_features |= XFS_FEAT_FILESTREAMS;
1326		return 0;
1327	case Opt_noquota:
1328		parsing_mp->m_qflags &= ~XFS_ALL_QUOTA_ACCT;
1329		parsing_mp->m_qflags &= ~XFS_ALL_QUOTA_ENFD;
 
1330		return 0;
1331	case Opt_quota:
1332	case Opt_uquota:
1333	case Opt_usrquota:
1334		parsing_mp->m_qflags |= (XFS_UQUOTA_ACCT | XFS_UQUOTA_ENFD);
 
1335		return 0;
1336	case Opt_qnoenforce:
1337	case Opt_uqnoenforce:
1338		parsing_mp->m_qflags |= XFS_UQUOTA_ACCT;
1339		parsing_mp->m_qflags &= ~XFS_UQUOTA_ENFD;
 
1340		return 0;
1341	case Opt_pquota:
1342	case Opt_prjquota:
1343		parsing_mp->m_qflags |= (XFS_PQUOTA_ACCT | XFS_PQUOTA_ENFD);
 
1344		return 0;
1345	case Opt_pqnoenforce:
1346		parsing_mp->m_qflags |= XFS_PQUOTA_ACCT;
1347		parsing_mp->m_qflags &= ~XFS_PQUOTA_ENFD;
 
1348		return 0;
1349	case Opt_gquota:
1350	case Opt_grpquota:
1351		parsing_mp->m_qflags |= (XFS_GQUOTA_ACCT | XFS_GQUOTA_ENFD);
 
1352		return 0;
1353	case Opt_gqnoenforce:
1354		parsing_mp->m_qflags |= XFS_GQUOTA_ACCT;
1355		parsing_mp->m_qflags &= ~XFS_GQUOTA_ENFD;
 
1356		return 0;
1357	case Opt_discard:
1358		parsing_mp->m_features |= XFS_FEAT_DISCARD;
1359		return 0;
1360	case Opt_nodiscard:
1361		parsing_mp->m_features &= ~XFS_FEAT_DISCARD;
1362		return 0;
1363#ifdef CONFIG_FS_DAX
1364	case Opt_dax:
1365		xfs_mount_set_dax_mode(parsing_mp, XFS_DAX_ALWAYS);
1366		return 0;
1367	case Opt_dax_enum:
1368		xfs_mount_set_dax_mode(parsing_mp, result.uint_32);
1369		return 0;
1370#endif
1371	/* Following mount options will be removed in September 2025 */
1372	case Opt_ikeep:
1373		xfs_fs_warn_deprecated(fc, param, XFS_FEAT_IKEEP, true);
1374		parsing_mp->m_features |= XFS_FEAT_IKEEP;
1375		return 0;
1376	case Opt_noikeep:
1377		xfs_fs_warn_deprecated(fc, param, XFS_FEAT_IKEEP, false);
1378		parsing_mp->m_features &= ~XFS_FEAT_IKEEP;
1379		return 0;
1380	case Opt_attr2:
1381		xfs_fs_warn_deprecated(fc, param, XFS_FEAT_ATTR2, true);
1382		parsing_mp->m_features |= XFS_FEAT_ATTR2;
1383		return 0;
1384	case Opt_noattr2:
1385		xfs_fs_warn_deprecated(fc, param, XFS_FEAT_NOATTR2, true);
1386		parsing_mp->m_features |= XFS_FEAT_NOATTR2;
1387		return 0;
1388	default:
1389		xfs_warn(parsing_mp, "unknown mount option [%s].", param->key);
1390		return -EINVAL;
1391	}
1392
1393	return 0;
1394}
1395
1396static int
1397xfs_fs_validate_params(
1398	struct xfs_mount	*mp)
1399{
1400	/* No recovery flag requires a read-only mount */
1401	if (xfs_has_norecovery(mp) && !xfs_is_readonly(mp)) {
1402		xfs_warn(mp, "no-recovery mounts must be read-only.");
1403		return -EINVAL;
1404	}
1405
1406	/*
1407	 * We have not read the superblock at this point, so only the attr2
1408	 * mount option can set the attr2 feature by this stage.
1409	 */
1410	if (xfs_has_attr2(mp) && xfs_has_noattr2(mp)) {
1411		xfs_warn(mp, "attr2 and noattr2 cannot both be specified.");
1412		return -EINVAL;
1413	}
1414
1415
1416	if (xfs_has_noalign(mp) && (mp->m_dalign || mp->m_swidth)) {
1417		xfs_warn(mp,
1418	"sunit and swidth options incompatible with the noalign option");
1419		return -EINVAL;
1420	}
1421
1422	if (!IS_ENABLED(CONFIG_XFS_QUOTA) && mp->m_qflags != 0) {
 
1423		xfs_warn(mp, "quota support not available in this kernel.");
1424		return -EINVAL;
1425	}
1426
1427	if ((mp->m_dalign && !mp->m_swidth) ||
1428	    (!mp->m_dalign && mp->m_swidth)) {
1429		xfs_warn(mp, "sunit and swidth must be specified together");
1430		return -EINVAL;
1431	}
1432
1433	if (mp->m_dalign && (mp->m_swidth % mp->m_dalign != 0)) {
1434		xfs_warn(mp,
1435	"stripe width (%d) must be a multiple of the stripe unit (%d)",
1436			mp->m_swidth, mp->m_dalign);
1437		return -EINVAL;
1438	}
1439
1440	if (mp->m_logbufs != -1 &&
1441	    mp->m_logbufs != 0 &&
1442	    (mp->m_logbufs < XLOG_MIN_ICLOGS ||
1443	     mp->m_logbufs > XLOG_MAX_ICLOGS)) {
1444		xfs_warn(mp, "invalid logbufs value: %d [not %d-%d]",
1445			mp->m_logbufs, XLOG_MIN_ICLOGS, XLOG_MAX_ICLOGS);
1446		return -EINVAL;
1447	}
1448
1449	if (mp->m_logbsize != -1 &&
1450	    mp->m_logbsize !=  0 &&
1451	    (mp->m_logbsize < XLOG_MIN_RECORD_BSIZE ||
1452	     mp->m_logbsize > XLOG_MAX_RECORD_BSIZE ||
1453	     !is_power_of_2(mp->m_logbsize))) {
1454		xfs_warn(mp,
1455			"invalid logbufsize: %d [not 16k,32k,64k,128k or 256k]",
1456			mp->m_logbsize);
1457		return -EINVAL;
1458	}
1459
1460	if (xfs_has_allocsize(mp) &&
1461	    (mp->m_allocsize_log > XFS_MAX_IO_LOG ||
1462	     mp->m_allocsize_log < XFS_MIN_IO_LOG)) {
1463		xfs_warn(mp, "invalid log iosize: %d [not %d-%d]",
1464			mp->m_allocsize_log, XFS_MIN_IO_LOG, XFS_MAX_IO_LOG);
1465		return -EINVAL;
1466	}
1467
1468	return 0;
1469}
1470
1471struct dentry *
1472xfs_debugfs_mkdir(
1473	const char	*name,
1474	struct dentry	*parent)
1475{
1476	struct dentry	*child;
1477
1478	/* Apparently we're expected to ignore error returns?? */
1479	child = debugfs_create_dir(name, parent);
1480	if (IS_ERR(child))
1481		return NULL;
1482
1483	return child;
1484}
1485
1486static int
1487xfs_fs_fill_super(
1488	struct super_block	*sb,
1489	struct fs_context	*fc)
1490{
1491	struct xfs_mount	*mp = sb->s_fs_info;
1492	struct inode		*root;
1493	int			flags = 0, error;
1494
1495	mp->m_super = sb;
1496
1497	/*
1498	 * Copy VFS mount flags from the context now that all parameter parsing
1499	 * is guaranteed to have been completed by either the old mount API or
1500	 * the newer fsopen/fsconfig API.
1501	 */
1502	if (fc->sb_flags & SB_RDONLY)
1503		set_bit(XFS_OPSTATE_READONLY, &mp->m_opstate);
1504	if (fc->sb_flags & SB_DIRSYNC)
1505		mp->m_features |= XFS_FEAT_DIRSYNC;
1506	if (fc->sb_flags & SB_SYNCHRONOUS)
1507		mp->m_features |= XFS_FEAT_WSYNC;
1508
1509	error = xfs_fs_validate_params(mp);
1510	if (error)
1511		return error;
1512
1513	sb_min_blocksize(sb, BBSIZE);
1514	sb->s_xattr = xfs_xattr_handlers;
1515	sb->s_export_op = &xfs_export_operations;
1516#ifdef CONFIG_XFS_QUOTA
1517	sb->s_qcop = &xfs_quotactl_operations;
1518	sb->s_quota_types = QTYPE_MASK_USR | QTYPE_MASK_GRP | QTYPE_MASK_PRJ;
1519#endif
1520	sb->s_op = &xfs_super_operations;
1521
1522	/*
1523	 * Delay mount work if the debug hook is set. This is debug
1524	 * instrumention to coordinate simulation of xfs mount failures with
1525	 * VFS superblock operations
1526	 */
1527	if (xfs_globals.mount_delay) {
1528		xfs_notice(mp, "Delaying mount for %d seconds.",
1529			xfs_globals.mount_delay);
1530		msleep(xfs_globals.mount_delay * 1000);
1531	}
1532
1533	if (fc->sb_flags & SB_SILENT)
1534		flags |= XFS_MFSI_QUIET;
1535
1536	error = xfs_open_devices(mp);
1537	if (error)
1538		return error;
1539
1540	if (xfs_debugfs) {
1541		mp->m_debugfs = xfs_debugfs_mkdir(mp->m_super->s_id,
1542						  xfs_debugfs);
1543	} else {
1544		mp->m_debugfs = NULL;
1545	}
1546
1547	error = xfs_init_mount_workqueues(mp);
1548	if (error)
1549		goto out_shutdown_devices;
1550
1551	error = xfs_init_percpu_counters(mp);
1552	if (error)
1553		goto out_destroy_workqueues;
1554
1555	error = xfs_inodegc_init_percpu(mp);
1556	if (error)
1557		goto out_destroy_counters;
1558
1559	/* Allocate stats memory before we do operations that might use it */
1560	mp->m_stats.xs_stats = alloc_percpu(struct xfsstats);
1561	if (!mp->m_stats.xs_stats) {
1562		error = -ENOMEM;
1563		goto out_destroy_inodegc;
1564	}
1565
1566	error = xchk_mount_stats_alloc(mp);
1567	if (error)
1568		goto out_free_stats;
1569
1570	error = xfs_readsb(mp, flags);
1571	if (error)
1572		goto out_free_scrub_stats;
1573
1574	error = xfs_finish_flags(mp);
1575	if (error)
1576		goto out_free_sb;
1577
1578	error = xfs_setup_devices(mp);
1579	if (error)
1580		goto out_free_sb;
1581
1582	/* V4 support is undergoing deprecation. */
1583	if (!xfs_has_crc(mp)) {
1584#ifdef CONFIG_XFS_SUPPORT_V4
 
 
 
 
 
 
 
 
 
 
1585		xfs_warn_once(mp,
1586	"Deprecated V4 format (crc=0) will not be supported after September 2030.");
1587#else
1588		xfs_warn(mp,
1589	"Deprecated V4 format (crc=0) not supported by kernel.");
1590		error = -EINVAL;
1591		goto out_free_sb;
1592#endif
1593	}
1594
1595	/* ASCII case insensitivity is undergoing deprecation. */
1596	if (xfs_has_asciici(mp)) {
1597#ifdef CONFIG_XFS_SUPPORT_ASCII_CI
1598		xfs_warn_once(mp,
1599	"Deprecated ASCII case-insensitivity feature (ascii-ci=1) will not be supported after September 2030.");
1600#else
1601		xfs_warn(mp,
1602	"Deprecated ASCII case-insensitivity feature (ascii-ci=1) not supported by kernel.");
1603		error = -EINVAL;
1604		goto out_free_sb;
1605#endif
1606	}
1607
1608	/* Filesystem claims it needs repair, so refuse the mount. */
1609	if (xfs_has_needsrepair(mp)) {
1610		xfs_warn(mp, "Filesystem needs repair.  Please run xfs_repair.");
1611		error = -EFSCORRUPTED;
1612		goto out_free_sb;
1613	}
1614
1615	/*
1616	 * Don't touch the filesystem if a user tool thinks it owns the primary
1617	 * superblock.  mkfs doesn't clear the flag from secondary supers, so
1618	 * we don't check them at all.
1619	 */
1620	if (mp->m_sb.sb_inprogress) {
1621		xfs_warn(mp, "Offline file system operation in progress!");
1622		error = -EFSCORRUPTED;
1623		goto out_free_sb;
1624	}
1625
1626	/*
1627	 * Until this is fixed only page-sized or smaller data blocks work.
1628	 */
1629	if (mp->m_sb.sb_blocksize > PAGE_SIZE) {
1630		xfs_warn(mp,
1631		"File system with blocksize %d bytes. "
1632		"Only pagesize (%ld) or less will currently work.",
 
 
1633				mp->m_sb.sb_blocksize, PAGE_SIZE);
1634		error = -ENOSYS;
1635		goto out_free_sb;
 
 
 
 
 
 
 
 
 
 
 
1636	}
1637
1638	/* Ensure this filesystem fits in the page cache limits */
1639	if (xfs_sb_validate_fsb_count(&mp->m_sb, mp->m_sb.sb_dblocks) ||
1640	    xfs_sb_validate_fsb_count(&mp->m_sb, mp->m_sb.sb_rblocks)) {
1641		xfs_warn(mp,
1642		"file system too large to be mounted on this system.");
1643		error = -EFBIG;
1644		goto out_free_sb;
1645	}
1646
1647	/*
1648	 * XFS block mappings use 54 bits to store the logical block offset.
1649	 * This should suffice to handle the maximum file size that the VFS
1650	 * supports (currently 2^63 bytes on 64-bit and ULONG_MAX << PAGE_SHIFT
1651	 * bytes on 32-bit), but as XFS and VFS have gotten the s_maxbytes
1652	 * calculation wrong on 32-bit kernels in the past, we'll add a WARN_ON
1653	 * to check this assertion.
1654	 *
1655	 * Avoid integer overflow by comparing the maximum bmbt offset to the
1656	 * maximum pagecache offset in units of fs blocks.
1657	 */
1658	if (!xfs_verify_fileoff(mp, XFS_B_TO_FSBT(mp, MAX_LFS_FILESIZE))) {
1659		xfs_warn(mp,
1660"MAX_LFS_FILESIZE block offset (%llu) exceeds extent map maximum (%llu)!",
1661			 XFS_B_TO_FSBT(mp, MAX_LFS_FILESIZE),
1662			 XFS_MAX_FILEOFF);
1663		error = -EINVAL;
1664		goto out_free_sb;
1665	}
1666
1667	error = xfs_filestream_mount(mp);
1668	if (error)
1669		goto out_free_sb;
1670
 
 
 
 
1671	/*
1672	 * we must configure the block size in the superblock before we run the
1673	 * full mount process as the mount process can lookup and cache inodes.
1674	 */
1675	sb->s_magic = XFS_SUPER_MAGIC;
1676	sb->s_blocksize = mp->m_sb.sb_blocksize;
1677	sb->s_blocksize_bits = ffs(sb->s_blocksize) - 1;
1678	sb->s_maxbytes = MAX_LFS_FILESIZE;
1679	sb->s_max_links = XFS_MAXLINK;
1680	sb->s_time_gran = 1;
1681	if (xfs_has_bigtime(mp)) {
1682		sb->s_time_min = xfs_bigtime_to_unix(XFS_BIGTIME_TIME_MIN);
1683		sb->s_time_max = xfs_bigtime_to_unix(XFS_BIGTIME_TIME_MAX);
1684	} else {
1685		sb->s_time_min = XFS_LEGACY_TIME_MIN;
1686		sb->s_time_max = XFS_LEGACY_TIME_MAX;
1687	}
1688	trace_xfs_inode_timestamp_range(mp, sb->s_time_min, sb->s_time_max);
1689	sb->s_iflags |= SB_I_CGROUPWB;
1690
1691	set_posix_acl_flag(sb);
1692
1693	/* version 5 superblocks support inode version counters. */
1694	if (xfs_has_crc(mp))
1695		sb->s_flags |= SB_I_VERSION;
1696
1697	if (xfs_has_dax_always(mp)) {
1698		error = xfs_setup_dax_always(mp);
1699		if (error)
1700			goto out_filestream_unmount;
1701	}
1702
1703	if (xfs_has_discard(mp) && !bdev_max_discard_sectors(sb->s_bdev)) {
1704		xfs_warn(mp,
1705	"mounting with \"discard\" option, but the device does not support discard");
1706		mp->m_features &= ~XFS_FEAT_DISCARD;
1707	}
1708
 
 
 
1709	if (xfs_has_reflink(mp)) {
1710		if (mp->m_sb.sb_rblocks) {
1711			xfs_alert(mp,
1712	"reflink not compatible with realtime device!");
1713			error = -EINVAL;
1714			goto out_filestream_unmount;
1715		}
1716
1717		if (xfs_globals.always_cow) {
1718			xfs_info(mp, "using DEBUG-only always_cow mode.");
1719			mp->m_always_cow = true;
1720		}
1721	}
1722
1723	if (xfs_has_rmapbt(mp) && mp->m_sb.sb_rblocks) {
1724		xfs_alert(mp,
1725	"reverse mapping btree not compatible with realtime device!");
1726		error = -EINVAL;
1727		goto out_filestream_unmount;
1728	}
1729
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1730	error = xfs_mountfs(mp);
1731	if (error)
1732		goto out_filestream_unmount;
1733
1734	root = igrab(VFS_I(mp->m_rootip));
1735	if (!root) {
1736		error = -ENOENT;
1737		goto out_unmount;
1738	}
1739	sb->s_root = d_make_root(root);
1740	if (!sb->s_root) {
1741		error = -ENOMEM;
1742		goto out_unmount;
1743	}
1744
1745	return 0;
1746
1747 out_filestream_unmount:
1748	xfs_filestream_unmount(mp);
 
 
1749 out_free_sb:
1750	xfs_freesb(mp);
1751 out_free_scrub_stats:
1752	xchk_mount_stats_free(mp);
1753 out_free_stats:
1754	free_percpu(mp->m_stats.xs_stats);
1755 out_destroy_inodegc:
1756	xfs_inodegc_free_percpu(mp);
1757 out_destroy_counters:
1758	xfs_destroy_percpu_counters(mp);
1759 out_destroy_workqueues:
1760	xfs_destroy_mount_workqueues(mp);
1761 out_shutdown_devices:
1762	xfs_shutdown_devices(mp);
1763	return error;
1764
1765 out_unmount:
1766	xfs_filestream_unmount(mp);
1767	xfs_unmountfs(mp);
1768	goto out_free_sb;
1769}
1770
1771static int
1772xfs_fs_get_tree(
1773	struct fs_context	*fc)
1774{
1775	return get_tree_bdev(fc, xfs_fs_fill_super);
1776}
1777
1778static int
1779xfs_remount_rw(
1780	struct xfs_mount	*mp)
1781{
1782	struct xfs_sb		*sbp = &mp->m_sb;
1783	int error;
1784
1785	if (xfs_has_norecovery(mp)) {
1786		xfs_warn(mp,
1787			"ro->rw transition prohibited on norecovery mount");
1788		return -EINVAL;
1789	}
1790
1791	if (xfs_sb_is_v5(sbp) &&
1792	    xfs_sb_has_ro_compat_feature(sbp, XFS_SB_FEAT_RO_COMPAT_UNKNOWN)) {
1793		xfs_warn(mp,
1794	"ro->rw transition prohibited on unknown (0x%x) ro-compat filesystem",
1795			(sbp->sb_features_ro_compat &
1796				XFS_SB_FEAT_RO_COMPAT_UNKNOWN));
1797		return -EINVAL;
1798	}
1799
1800	clear_bit(XFS_OPSTATE_READONLY, &mp->m_opstate);
1801
1802	/*
1803	 * If this is the first remount to writeable state we might have some
1804	 * superblock changes to update.
1805	 */
1806	if (mp->m_update_sb) {
1807		error = xfs_sync_sb(mp, false);
1808		if (error) {
1809			xfs_warn(mp, "failed to write sb changes");
1810			return error;
1811		}
1812		mp->m_update_sb = false;
1813	}
1814
1815	/*
1816	 * Fill out the reserve pool if it is empty. Use the stashed value if
1817	 * it is non-zero, otherwise go with the default.
1818	 */
1819	xfs_restore_resvblks(mp);
1820	xfs_log_work_queue(mp);
1821	xfs_blockgc_start(mp);
1822
1823	/* Create the per-AG metadata reservation pool .*/
1824	error = xfs_fs_reserve_ag_blocks(mp);
1825	if (error && error != -ENOSPC)
1826		return error;
1827
1828	/* Re-enable the background inode inactivation worker. */
1829	xfs_inodegc_start(mp);
1830
1831	return 0;
1832}
1833
1834static int
1835xfs_remount_ro(
1836	struct xfs_mount	*mp)
1837{
1838	struct xfs_icwalk	icw = {
1839		.icw_flags	= XFS_ICWALK_FLAG_SYNC,
1840	};
1841	int			error;
1842
1843	/* Flush all the dirty data to disk. */
1844	error = sync_filesystem(mp->m_super);
1845	if (error)
1846		return error;
1847
1848	/*
1849	 * Cancel background eofb scanning so it cannot race with the final
1850	 * log force+buftarg wait and deadlock the remount.
1851	 */
1852	xfs_blockgc_stop(mp);
1853
1854	/*
1855	 * Clear out all remaining COW staging extents and speculative post-EOF
1856	 * preallocations so that we don't leave inodes requiring inactivation
1857	 * cleanups during reclaim on a read-only mount.  We must process every
1858	 * cached inode, so this requires a synchronous cache scan.
1859	 */
1860	error = xfs_blockgc_free_space(mp, &icw);
1861	if (error) {
1862		xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
1863		return error;
1864	}
1865
1866	/*
1867	 * Stop the inodegc background worker.  xfs_fs_reconfigure already
1868	 * flushed all pending inodegc work when it sync'd the filesystem.
1869	 * The VFS holds s_umount, so we know that inodes cannot enter
1870	 * xfs_fs_destroy_inode during a remount operation.  In readonly mode
1871	 * we send inodes straight to reclaim, so no inodes will be queued.
1872	 */
1873	xfs_inodegc_stop(mp);
1874
1875	/* Free the per-AG metadata reservation pool. */
1876	error = xfs_fs_unreserve_ag_blocks(mp);
1877	if (error) {
1878		xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
1879		return error;
1880	}
1881
1882	/*
1883	 * Before we sync the metadata, we need to free up the reserve block
1884	 * pool so that the used block count in the superblock on disk is
1885	 * correct at the end of the remount. Stash the current* reserve pool
1886	 * size so that if we get remounted rw, we can return it to the same
1887	 * size.
1888	 */
1889	xfs_save_resvblks(mp);
1890
1891	xfs_log_clean(mp);
1892	set_bit(XFS_OPSTATE_READONLY, &mp->m_opstate);
1893
1894	return 0;
1895}
1896
1897/*
1898 * Logically we would return an error here to prevent users from believing
1899 * they might have changed mount options using remount which can't be changed.
1900 *
1901 * But unfortunately mount(8) adds all options from mtab and fstab to the mount
1902 * arguments in some cases so we can't blindly reject options, but have to
1903 * check for each specified option if it actually differs from the currently
1904 * set option and only reject it if that's the case.
1905 *
1906 * Until that is implemented we return success for every remount request, and
1907 * silently ignore all options that we can't actually change.
1908 */
1909static int
1910xfs_fs_reconfigure(
1911	struct fs_context *fc)
1912{
1913	struct xfs_mount	*mp = XFS_M(fc->root->d_sb);
1914	struct xfs_mount        *new_mp = fc->s_fs_info;
1915	int			flags = fc->sb_flags;
1916	int			error;
1917
 
 
1918	/* version 5 superblocks always support version counters. */
1919	if (xfs_has_crc(mp))
1920		fc->sb_flags |= SB_I_VERSION;
1921
1922	error = xfs_fs_validate_params(new_mp);
1923	if (error)
1924		return error;
1925
1926	/* inode32 -> inode64 */
1927	if (xfs_has_small_inums(mp) && !xfs_has_small_inums(new_mp)) {
1928		mp->m_features &= ~XFS_FEAT_SMALL_INUMS;
1929		mp->m_maxagi = xfs_set_inode_alloc(mp, mp->m_sb.sb_agcount);
1930	}
1931
1932	/* inode64 -> inode32 */
1933	if (!xfs_has_small_inums(mp) && xfs_has_small_inums(new_mp)) {
1934		mp->m_features |= XFS_FEAT_SMALL_INUMS;
1935		mp->m_maxagi = xfs_set_inode_alloc(mp, mp->m_sb.sb_agcount);
1936	}
1937
1938	/* ro -> rw */
1939	if (xfs_is_readonly(mp) && !(flags & SB_RDONLY)) {
1940		error = xfs_remount_rw(mp);
1941		if (error)
1942			return error;
1943	}
1944
1945	/* rw -> ro */
1946	if (!xfs_is_readonly(mp) && (flags & SB_RDONLY)) {
1947		error = xfs_remount_ro(mp);
1948		if (error)
1949			return error;
1950	}
1951
1952	return 0;
1953}
1954
1955static void
1956xfs_fs_free(
1957	struct fs_context	*fc)
1958{
1959	struct xfs_mount	*mp = fc->s_fs_info;
1960
1961	/*
1962	 * mp is stored in the fs_context when it is initialized.
1963	 * mp is transferred to the superblock on a successful mount,
1964	 * but if an error occurs before the transfer we have to free
1965	 * it here.
1966	 */
1967	if (mp)
1968		xfs_mount_free(mp);
1969}
1970
1971static const struct fs_context_operations xfs_context_ops = {
1972	.parse_param = xfs_fs_parse_param,
1973	.get_tree    = xfs_fs_get_tree,
1974	.reconfigure = xfs_fs_reconfigure,
1975	.free        = xfs_fs_free,
1976};
1977
1978/*
1979 * WARNING: do not initialise any parameters in this function that depend on
1980 * mount option parsing having already been performed as this can be called from
1981 * fsopen() before any parameters have been set.
1982 */
1983static int xfs_init_fs_context(
 
1984	struct fs_context	*fc)
1985{
1986	struct xfs_mount	*mp;
 
1987
1988	mp = kzalloc(sizeof(struct xfs_mount), GFP_KERNEL | __GFP_NOFAIL);
1989	if (!mp)
1990		return -ENOMEM;
1991
1992	spin_lock_init(&mp->m_sb_lock);
1993	INIT_RADIX_TREE(&mp->m_perag_tree, GFP_ATOMIC);
1994	spin_lock_init(&mp->m_perag_lock);
1995	mutex_init(&mp->m_growlock);
1996	INIT_WORK(&mp->m_flush_inodes_work, xfs_flush_inodes_worker);
1997	INIT_DELAYED_WORK(&mp->m_reclaim_work, xfs_reclaim_worker);
1998	mp->m_kobj.kobject.kset = xfs_kset;
1999	/*
2000	 * We don't create the finobt per-ag space reservation until after log
2001	 * recovery, so we must set this to true so that an ifree transaction
2002	 * started during log recovery will not depend on space reservations
2003	 * for finobt expansion.
2004	 */
2005	mp->m_finobt_nores = true;
2006
2007	/*
2008	 * These can be overridden by the mount option parsing.
2009	 */
2010	mp->m_logbufs = -1;
2011	mp->m_logbsize = -1;
2012	mp->m_allocsize_log = 16; /* 64k */
2013
2014	xfs_hooks_init(&mp->m_dir_update_hooks);
2015
2016	fc->s_fs_info = mp;
2017	fc->ops = &xfs_context_ops;
2018
2019	return 0;
2020}
2021
2022static void
2023xfs_kill_sb(
2024	struct super_block		*sb)
2025{
2026	kill_block_super(sb);
2027	xfs_mount_free(XFS_M(sb));
2028}
2029
2030static struct file_system_type xfs_fs_type = {
2031	.owner			= THIS_MODULE,
2032	.name			= "xfs",
2033	.init_fs_context	= xfs_init_fs_context,
2034	.parameters		= xfs_fs_parameters,
2035	.kill_sb		= xfs_kill_sb,
2036	.fs_flags		= FS_REQUIRES_DEV | FS_ALLOW_IDMAP,
2037};
2038MODULE_ALIAS_FS("xfs");
2039
2040STATIC int __init
2041xfs_init_caches(void)
2042{
2043	int		error;
2044
2045	xfs_buf_cache = kmem_cache_create("xfs_buf", sizeof(struct xfs_buf), 0,
2046					 SLAB_HWCACHE_ALIGN |
2047					 SLAB_RECLAIM_ACCOUNT,
2048					 NULL);
2049	if (!xfs_buf_cache)
2050		goto out;
2051
2052	xfs_log_ticket_cache = kmem_cache_create("xfs_log_ticket",
2053						sizeof(struct xlog_ticket),
2054						0, 0, NULL);
2055	if (!xfs_log_ticket_cache)
2056		goto out_destroy_buf_cache;
2057
2058	error = xfs_btree_init_cur_caches();
2059	if (error)
2060		goto out_destroy_log_ticket_cache;
2061
2062	error = rcbagbt_init_cur_cache();
2063	if (error)
2064		goto out_destroy_btree_cur_cache;
2065
2066	error = xfs_defer_init_item_caches();
2067	if (error)
2068		goto out_destroy_rcbagbt_cur_cache;
2069
2070	xfs_da_state_cache = kmem_cache_create("xfs_da_state",
2071					      sizeof(struct xfs_da_state),
2072					      0, 0, NULL);
2073	if (!xfs_da_state_cache)
2074		goto out_destroy_defer_item_cache;
2075
2076	xfs_ifork_cache = kmem_cache_create("xfs_ifork",
2077					   sizeof(struct xfs_ifork),
2078					   0, 0, NULL);
2079	if (!xfs_ifork_cache)
2080		goto out_destroy_da_state_cache;
2081
2082	xfs_trans_cache = kmem_cache_create("xfs_trans",
2083					   sizeof(struct xfs_trans),
2084					   0, 0, NULL);
2085	if (!xfs_trans_cache)
2086		goto out_destroy_ifork_cache;
2087
2088
2089	/*
2090	 * The size of the cache-allocated buf log item is the maximum
2091	 * size possible under XFS.  This wastes a little bit of memory,
2092	 * but it is much faster.
2093	 */
2094	xfs_buf_item_cache = kmem_cache_create("xfs_buf_item",
2095					      sizeof(struct xfs_buf_log_item),
2096					      0, 0, NULL);
2097	if (!xfs_buf_item_cache)
2098		goto out_destroy_trans_cache;
2099
2100	xfs_efd_cache = kmem_cache_create("xfs_efd_item",
2101			xfs_efd_log_item_sizeof(XFS_EFD_MAX_FAST_EXTENTS),
2102			0, 0, NULL);
2103	if (!xfs_efd_cache)
2104		goto out_destroy_buf_item_cache;
2105
2106	xfs_efi_cache = kmem_cache_create("xfs_efi_item",
2107			xfs_efi_log_item_sizeof(XFS_EFI_MAX_FAST_EXTENTS),
2108			0, 0, NULL);
2109	if (!xfs_efi_cache)
2110		goto out_destroy_efd_cache;
2111
2112	xfs_inode_cache = kmem_cache_create("xfs_inode",
2113					   sizeof(struct xfs_inode), 0,
2114					   (SLAB_HWCACHE_ALIGN |
2115					    SLAB_RECLAIM_ACCOUNT |
2116					    SLAB_ACCOUNT),
2117					   xfs_fs_inode_init_once);
2118	if (!xfs_inode_cache)
2119		goto out_destroy_efi_cache;
2120
2121	xfs_ili_cache = kmem_cache_create("xfs_ili",
2122					 sizeof(struct xfs_inode_log_item), 0,
2123					 SLAB_RECLAIM_ACCOUNT,
2124					 NULL);
2125	if (!xfs_ili_cache)
2126		goto out_destroy_inode_cache;
2127
2128	xfs_icreate_cache = kmem_cache_create("xfs_icr",
2129					     sizeof(struct xfs_icreate_item),
2130					     0, 0, NULL);
2131	if (!xfs_icreate_cache)
2132		goto out_destroy_ili_cache;
2133
2134	xfs_rud_cache = kmem_cache_create("xfs_rud_item",
2135					 sizeof(struct xfs_rud_log_item),
2136					 0, 0, NULL);
2137	if (!xfs_rud_cache)
2138		goto out_destroy_icreate_cache;
2139
2140	xfs_rui_cache = kmem_cache_create("xfs_rui_item",
2141			xfs_rui_log_item_sizeof(XFS_RUI_MAX_FAST_EXTENTS),
2142			0, 0, NULL);
2143	if (!xfs_rui_cache)
2144		goto out_destroy_rud_cache;
2145
2146	xfs_cud_cache = kmem_cache_create("xfs_cud_item",
2147					 sizeof(struct xfs_cud_log_item),
2148					 0, 0, NULL);
2149	if (!xfs_cud_cache)
2150		goto out_destroy_rui_cache;
2151
2152	xfs_cui_cache = kmem_cache_create("xfs_cui_item",
2153			xfs_cui_log_item_sizeof(XFS_CUI_MAX_FAST_EXTENTS),
2154			0, 0, NULL);
2155	if (!xfs_cui_cache)
2156		goto out_destroy_cud_cache;
2157
2158	xfs_bud_cache = kmem_cache_create("xfs_bud_item",
2159					 sizeof(struct xfs_bud_log_item),
2160					 0, 0, NULL);
2161	if (!xfs_bud_cache)
2162		goto out_destroy_cui_cache;
2163
2164	xfs_bui_cache = kmem_cache_create("xfs_bui_item",
2165			xfs_bui_log_item_sizeof(XFS_BUI_MAX_FAST_EXTENTS),
2166			0, 0, NULL);
2167	if (!xfs_bui_cache)
2168		goto out_destroy_bud_cache;
2169
2170	xfs_attrd_cache = kmem_cache_create("xfs_attrd_item",
2171					    sizeof(struct xfs_attrd_log_item),
2172					    0, 0, NULL);
2173	if (!xfs_attrd_cache)
2174		goto out_destroy_bui_cache;
2175
2176	xfs_attri_cache = kmem_cache_create("xfs_attri_item",
2177					    sizeof(struct xfs_attri_log_item),
2178					    0, 0, NULL);
2179	if (!xfs_attri_cache)
2180		goto out_destroy_attrd_cache;
2181
2182	xfs_iunlink_cache = kmem_cache_create("xfs_iul_item",
2183					     sizeof(struct xfs_iunlink_item),
2184					     0, 0, NULL);
2185	if (!xfs_iunlink_cache)
2186		goto out_destroy_attri_cache;
2187
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2188	return 0;
2189
 
 
 
 
 
 
2190 out_destroy_attri_cache:
2191	kmem_cache_destroy(xfs_attri_cache);
2192 out_destroy_attrd_cache:
2193	kmem_cache_destroy(xfs_attrd_cache);
2194 out_destroy_bui_cache:
2195	kmem_cache_destroy(xfs_bui_cache);
2196 out_destroy_bud_cache:
2197	kmem_cache_destroy(xfs_bud_cache);
2198 out_destroy_cui_cache:
2199	kmem_cache_destroy(xfs_cui_cache);
2200 out_destroy_cud_cache:
2201	kmem_cache_destroy(xfs_cud_cache);
2202 out_destroy_rui_cache:
2203	kmem_cache_destroy(xfs_rui_cache);
2204 out_destroy_rud_cache:
2205	kmem_cache_destroy(xfs_rud_cache);
2206 out_destroy_icreate_cache:
2207	kmem_cache_destroy(xfs_icreate_cache);
2208 out_destroy_ili_cache:
2209	kmem_cache_destroy(xfs_ili_cache);
2210 out_destroy_inode_cache:
2211	kmem_cache_destroy(xfs_inode_cache);
2212 out_destroy_efi_cache:
2213	kmem_cache_destroy(xfs_efi_cache);
2214 out_destroy_efd_cache:
2215	kmem_cache_destroy(xfs_efd_cache);
2216 out_destroy_buf_item_cache:
2217	kmem_cache_destroy(xfs_buf_item_cache);
2218 out_destroy_trans_cache:
2219	kmem_cache_destroy(xfs_trans_cache);
2220 out_destroy_ifork_cache:
2221	kmem_cache_destroy(xfs_ifork_cache);
2222 out_destroy_da_state_cache:
2223	kmem_cache_destroy(xfs_da_state_cache);
2224 out_destroy_defer_item_cache:
2225	xfs_defer_destroy_item_caches();
2226 out_destroy_rcbagbt_cur_cache:
2227	rcbagbt_destroy_cur_cache();
2228 out_destroy_btree_cur_cache:
2229	xfs_btree_destroy_cur_caches();
2230 out_destroy_log_ticket_cache:
2231	kmem_cache_destroy(xfs_log_ticket_cache);
2232 out_destroy_buf_cache:
2233	kmem_cache_destroy(xfs_buf_cache);
2234 out:
2235	return -ENOMEM;
2236}
2237
2238STATIC void
2239xfs_destroy_caches(void)
2240{
2241	/*
2242	 * Make sure all delayed rcu free are flushed before we
2243	 * destroy caches.
2244	 */
2245	rcu_barrier();
 
 
 
2246	kmem_cache_destroy(xfs_iunlink_cache);
2247	kmem_cache_destroy(xfs_attri_cache);
2248	kmem_cache_destroy(xfs_attrd_cache);
2249	kmem_cache_destroy(xfs_bui_cache);
2250	kmem_cache_destroy(xfs_bud_cache);
2251	kmem_cache_destroy(xfs_cui_cache);
2252	kmem_cache_destroy(xfs_cud_cache);
2253	kmem_cache_destroy(xfs_rui_cache);
2254	kmem_cache_destroy(xfs_rud_cache);
2255	kmem_cache_destroy(xfs_icreate_cache);
2256	kmem_cache_destroy(xfs_ili_cache);
2257	kmem_cache_destroy(xfs_inode_cache);
2258	kmem_cache_destroy(xfs_efi_cache);
2259	kmem_cache_destroy(xfs_efd_cache);
2260	kmem_cache_destroy(xfs_buf_item_cache);
2261	kmem_cache_destroy(xfs_trans_cache);
2262	kmem_cache_destroy(xfs_ifork_cache);
2263	kmem_cache_destroy(xfs_da_state_cache);
2264	xfs_defer_destroy_item_caches();
2265	rcbagbt_destroy_cur_cache();
2266	xfs_btree_destroy_cur_caches();
2267	kmem_cache_destroy(xfs_log_ticket_cache);
2268	kmem_cache_destroy(xfs_buf_cache);
2269}
2270
2271STATIC int __init
2272xfs_init_workqueues(void)
2273{
2274	/*
2275	 * The allocation workqueue can be used in memory reclaim situations
2276	 * (writepage path), and parallelism is only limited by the number of
2277	 * AGs in all the filesystems mounted. Hence use the default large
2278	 * max_active value for this workqueue.
2279	 */
2280	xfs_alloc_wq = alloc_workqueue("xfsalloc",
2281			XFS_WQFLAGS(WQ_MEM_RECLAIM | WQ_FREEZABLE), 0);
2282	if (!xfs_alloc_wq)
2283		return -ENOMEM;
2284
2285	xfs_discard_wq = alloc_workqueue("xfsdiscard", XFS_WQFLAGS(WQ_UNBOUND),
2286			0);
2287	if (!xfs_discard_wq)
2288		goto out_free_alloc_wq;
2289
2290	return 0;
2291out_free_alloc_wq:
2292	destroy_workqueue(xfs_alloc_wq);
2293	return -ENOMEM;
2294}
2295
2296STATIC void
2297xfs_destroy_workqueues(void)
2298{
2299	destroy_workqueue(xfs_discard_wq);
2300	destroy_workqueue(xfs_alloc_wq);
2301}
2302
2303STATIC int __init
2304init_xfs_fs(void)
2305{
2306	int			error;
2307
2308	xfs_check_ondisk_structs();
2309
2310	error = xfs_dahash_test();
2311	if (error)
2312		return error;
2313
2314	printk(KERN_INFO XFS_VERSION_STRING " with "
2315			 XFS_BUILD_OPTIONS " enabled\n");
2316
2317	xfs_dir_startup();
2318
2319	error = xfs_init_caches();
2320	if (error)
2321		goto out;
2322
2323	error = xfs_init_workqueues();
2324	if (error)
2325		goto out_destroy_caches;
2326
2327	error = xfs_mru_cache_init();
2328	if (error)
2329		goto out_destroy_wq;
2330
2331	error = xfs_init_procfs();
2332	if (error)
2333		goto out_mru_cache_uninit;
2334
2335	error = xfs_sysctl_register();
2336	if (error)
2337		goto out_cleanup_procfs;
2338
2339	xfs_debugfs = xfs_debugfs_mkdir("xfs", NULL);
2340
2341	xfs_kset = kset_create_and_add("xfs", NULL, fs_kobj);
2342	if (!xfs_kset) {
2343		error = -ENOMEM;
2344		goto out_debugfs_unregister;
2345	}
2346
2347	xfsstats.xs_kobj.kobject.kset = xfs_kset;
2348
2349	xfsstats.xs_stats = alloc_percpu(struct xfsstats);
2350	if (!xfsstats.xs_stats) {
2351		error = -ENOMEM;
2352		goto out_kset_unregister;
2353	}
2354
2355	error = xfs_sysfs_init(&xfsstats.xs_kobj, &xfs_stats_ktype, NULL,
2356			       "stats");
2357	if (error)
2358		goto out_free_stats;
2359
2360	error = xchk_global_stats_setup(xfs_debugfs);
2361	if (error)
2362		goto out_remove_stats_kobj;
2363
2364#ifdef DEBUG
2365	xfs_dbg_kobj.kobject.kset = xfs_kset;
2366	error = xfs_sysfs_init(&xfs_dbg_kobj, &xfs_dbg_ktype, NULL, "debug");
2367	if (error)
2368		goto out_remove_scrub_stats;
2369#endif
2370
2371	error = xfs_qm_init();
2372	if (error)
2373		goto out_remove_dbg_kobj;
2374
2375	error = register_filesystem(&xfs_fs_type);
2376	if (error)
2377		goto out_qm_exit;
2378	return 0;
2379
2380 out_qm_exit:
2381	xfs_qm_exit();
2382 out_remove_dbg_kobj:
2383#ifdef DEBUG
2384	xfs_sysfs_del(&xfs_dbg_kobj);
2385 out_remove_scrub_stats:
2386#endif
2387	xchk_global_stats_teardown();
2388 out_remove_stats_kobj:
2389	xfs_sysfs_del(&xfsstats.xs_kobj);
2390 out_free_stats:
2391	free_percpu(xfsstats.xs_stats);
2392 out_kset_unregister:
2393	kset_unregister(xfs_kset);
2394 out_debugfs_unregister:
2395	debugfs_remove(xfs_debugfs);
2396	xfs_sysctl_unregister();
2397 out_cleanup_procfs:
2398	xfs_cleanup_procfs();
2399 out_mru_cache_uninit:
2400	xfs_mru_cache_uninit();
2401 out_destroy_wq:
2402	xfs_destroy_workqueues();
2403 out_destroy_caches:
2404	xfs_destroy_caches();
2405 out:
2406	return error;
2407}
2408
2409STATIC void __exit
2410exit_xfs_fs(void)
2411{
2412	xfs_qm_exit();
2413	unregister_filesystem(&xfs_fs_type);
2414#ifdef DEBUG
2415	xfs_sysfs_del(&xfs_dbg_kobj);
2416#endif
2417	xchk_global_stats_teardown();
2418	xfs_sysfs_del(&xfsstats.xs_kobj);
2419	free_percpu(xfsstats.xs_stats);
2420	kset_unregister(xfs_kset);
2421	debugfs_remove(xfs_debugfs);
2422	xfs_sysctl_unregister();
2423	xfs_cleanup_procfs();
2424	xfs_mru_cache_uninit();
2425	xfs_destroy_workqueues();
2426	xfs_destroy_caches();
2427	xfs_uuid_table_free();
2428}
2429
2430module_init(init_xfs_fs);
2431module_exit(exit_xfs_fs);
2432
2433MODULE_AUTHOR("Silicon Graphics, Inc.");
2434MODULE_DESCRIPTION(XFS_VERSION_STRING " with " XFS_BUILD_OPTIONS " enabled");
2435MODULE_LICENSE("GPL");