1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
   4 * All Rights Reserved.
   5 */
   6#include "xfs.h"
   7#include "xfs_fs.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_bit.h"
  13#include "xfs_sb.h"
  14#include "xfs_mount.h"
  15#include "xfs_inode.h"
  16#include "xfs_dir2.h"
  17#include "xfs_ialloc.h"
  18#include "xfs_alloc.h"
  19#include "xfs_rtalloc.h"
  20#include "xfs_bmap.h"
  21#include "xfs_trans.h"
  22#include "xfs_trans_priv.h"
  23#include "xfs_log.h"
  24#include "xfs_log_priv.h"
  25#include "xfs_error.h"
  26#include "xfs_quota.h"
  27#include "xfs_fsops.h"
  28#include "xfs_icache.h"
  29#include "xfs_sysfs.h"
  30#include "xfs_rmap_btree.h"
  31#include "xfs_refcount_btree.h"
  32#include "xfs_reflink.h"
  33#include "xfs_extent_busy.h"
  34#include "xfs_health.h"
  35#include "xfs_trace.h"
  36#include "xfs_ag.h"
  37
  38static DEFINE_MUTEX(xfs_uuid_table_mutex);
  39static int xfs_uuid_table_size;
  40static uuid_t *xfs_uuid_table;
  41
  42void
  43xfs_uuid_table_free(void)
  44{
  45	if (xfs_uuid_table_size == 0)
  46		return;
  47	kmem_free(xfs_uuid_table);
  48	xfs_uuid_table = NULL;
  49	xfs_uuid_table_size = 0;
  50}
  51
  52/*
  53 * See if the UUID is unique among mounted XFS filesystems.
  54 * Mount fails if UUID is nil or a FS with the same UUID is already mounted.
  55 */
  56STATIC int
  57xfs_uuid_mount(
  58	struct xfs_mount	*mp)
  59{
  60	uuid_t			*uuid = &mp->m_sb.sb_uuid;
  61	int			hole, i;
  62
  63	/* Publish UUID in struct super_block */
  64	uuid_copy(&mp->m_super->s_uuid, uuid);
  65
  66	if (xfs_has_nouuid(mp))
  67		return 0;
  68
  69	if (uuid_is_null(uuid)) {
  70		xfs_warn(mp, "Filesystem has null UUID - can't mount");
  71		return -EINVAL;
  72	}
  73
  74	mutex_lock(&xfs_uuid_table_mutex);
  75	for (i = 0, hole = -1; i < xfs_uuid_table_size; i++) {
  76		if (uuid_is_null(&xfs_uuid_table[i])) {
  77			hole = i;
  78			continue;
  79		}
  80		if (uuid_equal(uuid, &xfs_uuid_table[i]))
  81			goto out_duplicate;
  82	}
  83
  84	if (hole < 0) {
  85		xfs_uuid_table = krealloc(xfs_uuid_table,
  86			(xfs_uuid_table_size + 1) * sizeof(*xfs_uuid_table),
  87			GFP_KERNEL | __GFP_NOFAIL);
  88		hole = xfs_uuid_table_size++;
  89	}
  90	xfs_uuid_table[hole] = *uuid;
  91	mutex_unlock(&xfs_uuid_table_mutex);
  92
  93	return 0;
  94
  95 out_duplicate:
  96	mutex_unlock(&xfs_uuid_table_mutex);
  97	xfs_warn(mp, "Filesystem has duplicate UUID %pU - can't mount", uuid);
  98	return -EINVAL;
  99}
 100
 101STATIC void
 102xfs_uuid_unmount(
 103	struct xfs_mount	*mp)
 104{
 105	uuid_t			*uuid = &mp->m_sb.sb_uuid;
 106	int			i;
 107
 108	if (xfs_has_nouuid(mp))
 109		return;
 110
 111	mutex_lock(&xfs_uuid_table_mutex);
 112	for (i = 0; i < xfs_uuid_table_size; i++) {
 113		if (uuid_is_null(&xfs_uuid_table[i]))
 114			continue;
 115		if (!uuid_equal(uuid, &xfs_uuid_table[i]))
 116			continue;
 117		memset(&xfs_uuid_table[i], 0, sizeof(uuid_t));
 118		break;
 119	}
 120	ASSERT(i < xfs_uuid_table_size);
 121	mutex_unlock(&xfs_uuid_table_mutex);
 122}
 123
 124/*
 125 * Check size of device based on the (data/realtime) block count.
 126 * Note: this check is used by the growfs code as well as mount.
 127 */
 128int
 129xfs_sb_validate_fsb_count(
 130	xfs_sb_t	*sbp,
 131	uint64_t	nblocks)
 132{
 133	ASSERT(PAGE_SHIFT >= sbp->sb_blocklog);
 134	ASSERT(sbp->sb_blocklog >= BBSHIFT);
 135
 136	/* Limited by ULONG_MAX of page cache index */
 137	if (nblocks >> (PAGE_SHIFT - sbp->sb_blocklog) > ULONG_MAX)
 138		return -EFBIG;
 139	return 0;
 140}
 141
 142/*
 143 * xfs_readsb
 144 *
 145 * Does the initial read of the superblock.
 146 */
 147int
 148xfs_readsb(
 149	struct xfs_mount *mp,
 150	int		flags)
 151{
 152	unsigned int	sector_size;
 153	struct xfs_buf	*bp;
 154	struct xfs_sb	*sbp = &mp->m_sb;
 155	int		error;
 156	int		loud = !(flags & XFS_MFSI_QUIET);
 157	const struct xfs_buf_ops *buf_ops;
 158
 159	ASSERT(mp->m_sb_bp == NULL);
 160	ASSERT(mp->m_ddev_targp != NULL);
 161
 162	/*
 163	 * For the initial read, we must guess at the sector
 164	 * size based on the block device.  It's enough to
 165	 * get the sb_sectsize out of the superblock and
 166	 * then reread with the proper length.
 167	 * We don't verify it yet, because it may not be complete.
 168	 */
 169	sector_size = xfs_getsize_buftarg(mp->m_ddev_targp);
 170	buf_ops = NULL;
 171
 172	/*
 173	 * Allocate a (locked) buffer to hold the superblock. This will be kept
 174	 * around at all times to optimize access to the superblock. Therefore,
 175	 * set XBF_NO_IOACCT to make sure it doesn't hold the buftarg count
 176	 * elevated.
 177	 */
 178reread:
 179	error = xfs_buf_read_uncached(mp->m_ddev_targp, XFS_SB_DADDR,
 180				      BTOBB(sector_size), XBF_NO_IOACCT, &bp,
 181				      buf_ops);
 182	if (error) {
 183		if (loud)
 184			xfs_warn(mp, "SB validate failed with error %d.", error);
 185		/* bad CRC means corrupted metadata */
 186		if (error == -EFSBADCRC)
 187			error = -EFSCORRUPTED;
 188		return error;
 189	}
 190
 191	/*
 192	 * Initialize the mount structure from the superblock.
 193	 */
 194	xfs_sb_from_disk(sbp, bp->b_addr);
 195
 196	/*
 197	 * If we haven't validated the superblock, do so now before we try
 198	 * to check the sector size and reread the superblock appropriately.
 199	 */
 200	if (sbp->sb_magicnum != XFS_SB_MAGIC) {
 201		if (loud)
 202			xfs_warn(mp, "Invalid superblock magic number");
 203		error = -EINVAL;
 204		goto release_buf;
 205	}
 206
 207	/*
 208	 * We must be able to do sector-sized and sector-aligned IO.
 209	 */
 210	if (sector_size > sbp->sb_sectsize) {
 211		if (loud)
 212			xfs_warn(mp, "device supports %u byte sectors (not %u)",
 213				sector_size, sbp->sb_sectsize);
 214		error = -ENOSYS;
 215		goto release_buf;
 216	}
 217
 218	if (buf_ops == NULL) {
 219		/*
 220		 * Re-read the superblock so the buffer is correctly sized,
 221		 * and properly verified.
 222		 */
 223		xfs_buf_relse(bp);
 224		sector_size = sbp->sb_sectsize;
 225		buf_ops = loud ? &xfs_sb_buf_ops : &xfs_sb_quiet_buf_ops;
 226		goto reread;
 227	}
 228
 229	mp->m_features |= xfs_sb_version_to_features(sbp);
 230	xfs_reinit_percpu_counters(mp);
 231
 232	/* no need to be quiet anymore, so reset the buf ops */
 233	bp->b_ops = &xfs_sb_buf_ops;
 234
 235	mp->m_sb_bp = bp;
 236	xfs_buf_unlock(bp);
 237	return 0;
 238
 239release_buf:
 240	xfs_buf_relse(bp);
 241	return error;
 242}
 243
 244/*
 245 * If the sunit/swidth change would move the precomputed root inode value, we
 246 * must reject the ondisk change because repair will stumble over that.
 247 * However, we allow the mount to proceed because we never rejected this
 248 * combination before.  Returns true to update the sb, false otherwise.
 249 */
 250static inline int
 251xfs_check_new_dalign(
 252	struct xfs_mount	*mp,
 253	int			new_dalign,
 254	bool			*update_sb)
 255{
 256	struct xfs_sb		*sbp = &mp->m_sb;
 257	xfs_ino_t		calc_ino;
 258
 259	calc_ino = xfs_ialloc_calc_rootino(mp, new_dalign);
 260	trace_xfs_check_new_dalign(mp, new_dalign, calc_ino);
 261
 262	if (sbp->sb_rootino == calc_ino) {
 263		*update_sb = true;
 264		return 0;
 265	}
 266
 267	xfs_warn(mp,
 268"Cannot change stripe alignment; would require moving root inode.");
 269
 270	/*
 271	 * XXX: Next time we add a new incompat feature, this should start
 272	 * returning -EINVAL to fail the mount.  Until then, spit out a warning
 273	 * that we're ignoring the administrator's instructions.
 274	 */
 275	xfs_warn(mp, "Skipping superblock stripe alignment update.");
 276	*update_sb = false;
 277	return 0;
 278}
 279
 280/*
 281 * If we were provided with new sunit/swidth values as mount options, make sure
 282 * that they pass basic alignment and superblock feature checks, and convert
 283 * them into the same units (FSB) that everything else expects.  This step
 284 * /must/ be done before computing the inode geometry.
 285 */
 286STATIC int
 287xfs_validate_new_dalign(
 288	struct xfs_mount	*mp)
 289{
 290	if (mp->m_dalign == 0)
 291		return 0;
 292
 293	/*
 294	 * If stripe unit and stripe width are not multiples
 295	 * of the fs blocksize turn off alignment.
 296	 */
 297	if ((BBTOB(mp->m_dalign) & mp->m_blockmask) ||
 298	    (BBTOB(mp->m_swidth) & mp->m_blockmask)) {
 299		xfs_warn(mp,
 300	"alignment check failed: sunit/swidth vs. blocksize(%d)",
 301			mp->m_sb.sb_blocksize);
 302		return -EINVAL;
 303	}
 304
 305	/*
 306	 * Convert the stripe unit and width to FSBs.
 307	 */
 308	mp->m_dalign = XFS_BB_TO_FSBT(mp, mp->m_dalign);
 309	if (mp->m_dalign && (mp->m_sb.sb_agblocks % mp->m_dalign)) {
 310		xfs_warn(mp,
 311	"alignment check failed: sunit/swidth vs. agsize(%d)",
 312			mp->m_sb.sb_agblocks);
 313		return -EINVAL;
 314	}
 315
 316	if (!mp->m_dalign) {
 317		xfs_warn(mp,
 318	"alignment check failed: sunit(%d) less than bsize(%d)",
 319			mp->m_dalign, mp->m_sb.sb_blocksize);
 320		return -EINVAL;
 321	}
 322
 323	mp->m_swidth = XFS_BB_TO_FSBT(mp, mp->m_swidth);
 324
 325	if (!xfs_has_dalign(mp)) {
 326		xfs_warn(mp,
 327"cannot change alignment: superblock does not support data alignment");
 328		return -EINVAL;
 329	}
 330
 331	return 0;
 332}
 333
 334/* Update alignment values based on mount options and sb values. */
 335STATIC int
 336xfs_update_alignment(
 337	struct xfs_mount	*mp)
 338{
 339	struct xfs_sb		*sbp = &mp->m_sb;
 340
 341	if (mp->m_dalign) {
 342		bool		update_sb;
 343		int		error;
 344
 345		if (sbp->sb_unit == mp->m_dalign &&
 346		    sbp->sb_width == mp->m_swidth)
 347			return 0;
 348
 349		error = xfs_check_new_dalign(mp, mp->m_dalign, &update_sb);
 350		if (error || !update_sb)
 351			return error;
 352
 353		sbp->sb_unit = mp->m_dalign;
 354		sbp->sb_width = mp->m_swidth;
 355		mp->m_update_sb = true;
 356	} else if (!xfs_has_noalign(mp) && xfs_has_dalign(mp)) {
 357		mp->m_dalign = sbp->sb_unit;
 358		mp->m_swidth = sbp->sb_width;
 359	}
 360
 361	return 0;
 362}
 363
 364/*
 365 * precalculate the low space thresholds for dynamic speculative preallocation.
 366 */
 367void
 368xfs_set_low_space_thresholds(
 369	struct xfs_mount	*mp)
 370{
 371	uint64_t		dblocks = mp->m_sb.sb_dblocks;
 372	uint64_t		rtexts = mp->m_sb.sb_rextents;
 373	int			i;
 374
 375	do_div(dblocks, 100);
 376	do_div(rtexts, 100);
 377
 378	for (i = 0; i < XFS_LOWSP_MAX; i++) {
 379		mp->m_low_space[i] = dblocks * (i + 1);
 380		mp->m_low_rtexts[i] = rtexts * (i + 1);
 381	}
 382}
 383
 384/*
 385 * Check that the data (and log if separate) is an ok size.
 386 */
 387STATIC int
 388xfs_check_sizes(
 389	struct xfs_mount *mp)
 390{
 391	struct xfs_buf	*bp;
 392	xfs_daddr_t	d;
 393	int		error;
 394
 395	d = (xfs_daddr_t)XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks);
 396	if (XFS_BB_TO_FSB(mp, d) != mp->m_sb.sb_dblocks) {
 397		xfs_warn(mp, "filesystem size mismatch detected");
 398		return -EFBIG;
 399	}
 400	error = xfs_buf_read_uncached(mp->m_ddev_targp,
 401					d - XFS_FSS_TO_BB(mp, 1),
 402					XFS_FSS_TO_BB(mp, 1), 0, &bp, NULL);
 403	if (error) {
 404		xfs_warn(mp, "last sector read failed");
 405		return error;
 406	}
 407	xfs_buf_relse(bp);
 408
 409	if (mp->m_logdev_targp == mp->m_ddev_targp)
 410		return 0;
 411
 412	d = (xfs_daddr_t)XFS_FSB_TO_BB(mp, mp->m_sb.sb_logblocks);
 413	if (XFS_BB_TO_FSB(mp, d) != mp->m_sb.sb_logblocks) {
 414		xfs_warn(mp, "log size mismatch detected");
 415		return -EFBIG;
 416	}
 417	error = xfs_buf_read_uncached(mp->m_logdev_targp,
 418					d - XFS_FSB_TO_BB(mp, 1),
 419					XFS_FSB_TO_BB(mp, 1), 0, &bp, NULL);
 420	if (error) {
 421		xfs_warn(mp, "log device read failed");
 422		return error;
 423	}
 424	xfs_buf_relse(bp);
 425	return 0;
 426}
 427
 428/*
 429 * Clear the quotaflags in memory and in the superblock.
 430 */
 431int
 432xfs_mount_reset_sbqflags(
 433	struct xfs_mount	*mp)
 434{
 435	mp->m_qflags = 0;
 436
 437	/* It is OK to look at sb_qflags in the mount path without m_sb_lock. */
 438	if (mp->m_sb.sb_qflags == 0)
 439		return 0;
 440	spin_lock(&mp->m_sb_lock);
 441	mp->m_sb.sb_qflags = 0;
 442	spin_unlock(&mp->m_sb_lock);
 443
 444	if (!xfs_fs_writable(mp, SB_FREEZE_WRITE))
 445		return 0;
 446
 447	return xfs_sync_sb(mp, false);
 448}
 449
 450uint64_t
 451xfs_default_resblks(xfs_mount_t *mp)
 452{
 453	uint64_t resblks;
 454
 455	/*
 456	 * We default to 5% or 8192 fsbs of space reserved, whichever is
 457	 * smaller.  This is intended to cover concurrent allocation
 458	 * transactions when we initially hit enospc. These each require a 4
 459	 * block reservation. Hence by default we cover roughly 2000 concurrent
 460	 * allocation reservations.
 461	 */
 462	resblks = mp->m_sb.sb_dblocks;
 463	do_div(resblks, 20);
 464	resblks = min_t(uint64_t, resblks, 8192);
 465	return resblks;
 466}
 467
 468/* Ensure the summary counts are correct. */
 469STATIC int
 470xfs_check_summary_counts(
 471	struct xfs_mount	*mp)
 472{
 473	int			error = 0;
 474
 475	/*
 476	 * The AG0 superblock verifier rejects in-progress filesystems,
 477	 * so we should never see the flag set this far into mounting.
 478	 */
 479	if (mp->m_sb.sb_inprogress) {
 480		xfs_err(mp, "sb_inprogress set after log recovery??");
 481		WARN_ON(1);
 482		return -EFSCORRUPTED;
 483	}
 484
 485	/*
 486	 * Now the log is mounted, we know if it was an unclean shutdown or
 487	 * not. If it was, with the first phase of recovery has completed, we
 488	 * have consistent AG blocks on disk. We have not recovered EFIs yet,
 489	 * but they are recovered transactionally in the second recovery phase
 490	 * later.
 491	 *
 492	 * If the log was clean when we mounted, we can check the summary
 493	 * counters.  If any of them are obviously incorrect, we can recompute
 494	 * them from the AGF headers in the next step.
 495	 */
 496	if (xfs_is_clean(mp) &&
 497	    (mp->m_sb.sb_fdblocks > mp->m_sb.sb_dblocks ||
 498	     !xfs_verify_icount(mp, mp->m_sb.sb_icount) ||
 499	     mp->m_sb.sb_ifree > mp->m_sb.sb_icount))
 500		xfs_fs_mark_sick(mp, XFS_SICK_FS_COUNTERS);
 501
 502	/*
 503	 * We can safely re-initialise incore superblock counters from the
 504	 * per-ag data. These may not be correct if the filesystem was not
 505	 * cleanly unmounted, so we waited for recovery to finish before doing
 506	 * this.
 507	 *
 508	 * If the filesystem was cleanly unmounted or the previous check did
 509	 * not flag anything weird, then we can trust the values in the
 510	 * superblock to be correct and we don't need to do anything here.
 511	 * Otherwise, recalculate the summary counters.
 512	 */
 513	if ((xfs_has_lazysbcount(mp) && !xfs_is_clean(mp)) ||
 514	    xfs_fs_has_sickness(mp, XFS_SICK_FS_COUNTERS)) {
 515		error = xfs_initialize_perag_data(mp, mp->m_sb.sb_agcount);
 516		if (error)
 517			return error;
 518	}
 519
 520	/*
 521	 * Older kernels misused sb_frextents to reflect both incore
 522	 * reservations made by running transactions and the actual count of
 523	 * free rt extents in the ondisk metadata.  Transactions committed
 524	 * during runtime can therefore contain a superblock update that
 525	 * undercounts the number of free rt extents tracked in the rt bitmap.
 526	 * A clean unmount record will have the correct frextents value since
 527	 * there can be no other transactions running at that point.
 528	 *
 529	 * If we're mounting the rt volume after recovering the log, recompute
 530	 * frextents from the rtbitmap file to fix the inconsistency.
 531	 */
 532	if (xfs_has_realtime(mp) && !xfs_is_clean(mp)) {
 533		error = xfs_rtalloc_reinit_frextents(mp);
 534		if (error)
 535			return error;
 536	}
 537
 538	return 0;
 539}
 540
 541static void
 542xfs_unmount_check(
 543	struct xfs_mount	*mp)
 544{
 545	if (xfs_is_shutdown(mp))
 546		return;
 547
 548	if (percpu_counter_sum(&mp->m_ifree) >
 549			percpu_counter_sum(&mp->m_icount)) {
 550		xfs_alert(mp, "ifree/icount mismatch at unmount");
 551		xfs_fs_mark_sick(mp, XFS_SICK_FS_COUNTERS);
 552	}
 553}
 554
 555/*
 556 * Flush and reclaim dirty inodes in preparation for unmount. Inodes and
 557 * internal inode structures can be sitting in the CIL and AIL at this point,
 558 * so we need to unpin them, write them back and/or reclaim them before unmount
 559 * can proceed.  In other words, callers are required to have inactivated all
 560 * inodes.
 561 *
 562 * An inode cluster that has been freed can have its buffer still pinned in
 563 * memory because the transaction is still sitting in a iclog. The stale inodes
 564 * on that buffer will be pinned to the buffer until the transaction hits the
 565 * disk and the callbacks run. Pushing the AIL will skip the stale inodes and
 566 * may never see the pinned buffer, so nothing will push out the iclog and
 567 * unpin the buffer.
 568 *
 569 * Hence we need to force the log to unpin everything first. However, log
 570 * forces don't wait for the discards they issue to complete, so we have to
 571 * explicitly wait for them to complete here as well.
 572 *
 573 * Then we can tell the world we are unmounting so that error handling knows
 574 * that the filesystem is going away and we should error out anything that we
 575 * have been retrying in the background.  This will prevent never-ending
 576 * retries in AIL pushing from hanging the unmount.
 577 *
 578 * Finally, we can push the AIL to clean all the remaining dirty objects, then
 579 * reclaim the remaining inodes that are still in memory at this point in time.
 580 */
 581static void
 582xfs_unmount_flush_inodes(
 583	struct xfs_mount	*mp)
 584{
 585	xfs_log_force(mp, XFS_LOG_SYNC);
 586	xfs_extent_busy_wait_all(mp);
 587	flush_workqueue(xfs_discard_wq);
 588
 589	set_bit(XFS_OPSTATE_UNMOUNTING, &mp->m_opstate);
 590
 591	xfs_ail_push_all_sync(mp->m_ail);
 592	xfs_inodegc_stop(mp);
 593	cancel_delayed_work_sync(&mp->m_reclaim_work);
 594	xfs_reclaim_inodes(mp);
 595	xfs_health_unmount(mp);
 596}
 597
 598static void
 599xfs_mount_setup_inode_geom(
 600	struct xfs_mount	*mp)
 601{
 602	struct xfs_ino_geometry *igeo = M_IGEO(mp);
 603
 604	igeo->attr_fork_offset = xfs_bmap_compute_attr_offset(mp);
 605	ASSERT(igeo->attr_fork_offset < XFS_LITINO(mp));
 606
 607	xfs_ialloc_setup_geometry(mp);
 608}
 609
 610/* Compute maximum possible height for per-AG btree types for this fs. */
 611static inline void
 612xfs_agbtree_compute_maxlevels(
 613	struct xfs_mount	*mp)
 614{
 615	unsigned int		levels;
 616
 617	levels = max(mp->m_alloc_maxlevels, M_IGEO(mp)->inobt_maxlevels);
 618	levels = max(levels, mp->m_rmap_maxlevels);
 619	mp->m_agbtree_maxlevels = max(levels, mp->m_refc_maxlevels);
 620}
 621
 622/*
 623 * This function does the following on an initial mount of a file system:
 624 *	- reads the superblock from disk and init the mount struct
 625 *	- if we're a 32-bit kernel, do a size check on the superblock
 626 *		so we don't mount terabyte filesystems
 627 *	- init mount struct realtime fields
 628 *	- allocate inode hash table for fs
 629 *	- init directory manager
 630 *	- perform recovery and init the log manager
 631 */
 632int
 633xfs_mountfs(
 634	struct xfs_mount	*mp)
 635{
 636	struct xfs_sb		*sbp = &(mp->m_sb);
 637	struct xfs_inode	*rip;
 638	struct xfs_ino_geometry	*igeo = M_IGEO(mp);
 639	uint64_t		resblks;
 640	uint			quotamount = 0;
 641	uint			quotaflags = 0;
 642	int			error = 0;
 643
 644	xfs_sb_mount_common(mp, sbp);
 645
 646	/*
 647	 * Check for a mismatched features2 values.  Older kernels read & wrote
 648	 * into the wrong sb offset for sb_features2 on some platforms due to
 649	 * xfs_sb_t not being 64bit size aligned when sb_features2 was added,
 650	 * which made older superblock reading/writing routines swap it as a
 651	 * 64-bit value.
 652	 *
 653	 * For backwards compatibility, we make both slots equal.
 654	 *
 655	 * If we detect a mismatched field, we OR the set bits into the existing
 656	 * features2 field in case it has already been modified; we don't want
 657	 * to lose any features.  We then update the bad location with the ORed
 658	 * value so that older kernels will see any features2 flags. The
 659	 * superblock writeback code ensures the new sb_features2 is copied to
 660	 * sb_bad_features2 before it is logged or written to disk.
 661	 */
 662	if (xfs_sb_has_mismatched_features2(sbp)) {
 663		xfs_warn(mp, "correcting sb_features alignment problem");
 664		sbp->sb_features2 |= sbp->sb_bad_features2;
 665		mp->m_update_sb = true;
 666	}
 667
 668
 669	/* always use v2 inodes by default now */
 670	if (!(mp->m_sb.sb_versionnum & XFS_SB_VERSION_NLINKBIT)) {
 671		mp->m_sb.sb_versionnum |= XFS_SB_VERSION_NLINKBIT;
 672		mp->m_features |= XFS_FEAT_NLINK;
 673		mp->m_update_sb = true;
 674	}
 675
 676	/*
 677	 * If we were given new sunit/swidth options, do some basic validation
 678	 * checks and convert the incore dalign and swidth values to the
 679	 * same units (FSB) that everything else uses.  This /must/ happen
 680	 * before computing the inode geometry.
 681	 */
 682	error = xfs_validate_new_dalign(mp);
 683	if (error)
 684		goto out;
 685
 686	xfs_alloc_compute_maxlevels(mp);
 687	xfs_bmap_compute_maxlevels(mp, XFS_DATA_FORK);
 688	xfs_bmap_compute_maxlevels(mp, XFS_ATTR_FORK);
 689	xfs_mount_setup_inode_geom(mp);
 690	xfs_rmapbt_compute_maxlevels(mp);
 691	xfs_refcountbt_compute_maxlevels(mp);
 692
 693	xfs_agbtree_compute_maxlevels(mp);
 694
 695	/*
 696	 * Check if sb_agblocks is aligned at stripe boundary.  If sb_agblocks
 697	 * is NOT aligned turn off m_dalign since allocator alignment is within
 698	 * an ag, therefore ag has to be aligned at stripe boundary.  Note that
 699	 * we must compute the free space and rmap btree geometry before doing
 700	 * this.
 701	 */
 702	error = xfs_update_alignment(mp);
 703	if (error)
 704		goto out;
 705
 706	/* enable fail_at_unmount as default */
 707	mp->m_fail_unmount = true;
 708
 709	error = xfs_sysfs_init(&mp->m_kobj, &xfs_mp_ktype,
 710			       NULL, mp->m_super->s_id);
 711	if (error)
 712		goto out;
 713
 714	error = xfs_sysfs_init(&mp->m_stats.xs_kobj, &xfs_stats_ktype,
 715			       &mp->m_kobj, "stats");
 716	if (error)
 717		goto out_remove_sysfs;
 718
 719	error = xfs_error_sysfs_init(mp);
 720	if (error)
 721		goto out_del_stats;
 722
 723	error = xfs_errortag_init(mp);
 724	if (error)
 725		goto out_remove_error_sysfs;
 726
 727	error = xfs_uuid_mount(mp);
 728	if (error)
 729		goto out_remove_errortag;
 730
 731	/*
 732	 * Update the preferred write size based on the information from the
 733	 * on-disk superblock.
 734	 */
 735	mp->m_allocsize_log =
 736		max_t(uint32_t, sbp->sb_blocklog, mp->m_allocsize_log);
 737	mp->m_allocsize_blocks = 1U << (mp->m_allocsize_log - sbp->sb_blocklog);
 738
 739	/* set the low space thresholds for dynamic preallocation */
 740	xfs_set_low_space_thresholds(mp);
 741
 742	/*
 743	 * If enabled, sparse inode chunk alignment is expected to match the
 744	 * cluster size. Full inode chunk alignment must match the chunk size,
 745	 * but that is checked on sb read verification...
 746	 */
 747	if (xfs_has_sparseinodes(mp) &&
 748	    mp->m_sb.sb_spino_align !=
 749			XFS_B_TO_FSBT(mp, igeo->inode_cluster_size_raw)) {
 750		xfs_warn(mp,
 751	"Sparse inode block alignment (%u) must match cluster size (%llu).",
 752			 mp->m_sb.sb_spino_align,
 753			 XFS_B_TO_FSBT(mp, igeo->inode_cluster_size_raw));
 754		error = -EINVAL;
 755		goto out_remove_uuid;
 756	}
 757
 758	/*
 759	 * Check that the data (and log if separate) is an ok size.
 760	 */
 761	error = xfs_check_sizes(mp);
 762	if (error)
 763		goto out_remove_uuid;
 764
 765	/*
 766	 * Initialize realtime fields in the mount structure
 767	 */
 768	error = xfs_rtmount_init(mp);
 769	if (error) {
 770		xfs_warn(mp, "RT mount failed");
 771		goto out_remove_uuid;
 772	}
 773
 774	/*
 775	 *  Copies the low order bits of the timestamp and the randomly
 776	 *  set "sequence" number out of a UUID.
 777	 */
 778	mp->m_fixedfsid[0] =
 779		(get_unaligned_be16(&sbp->sb_uuid.b[8]) << 16) |
 780		 get_unaligned_be16(&sbp->sb_uuid.b[4]);
 781	mp->m_fixedfsid[1] = get_unaligned_be32(&sbp->sb_uuid.b[0]);
 782
 783	error = xfs_da_mount(mp);
 784	if (error) {
 785		xfs_warn(mp, "Failed dir/attr init: %d", error);
 786		goto out_remove_uuid;
 787	}
 788
 789	/*
 790	 * Initialize the precomputed transaction reservations values.
 791	 */
 792	xfs_trans_init(mp);
 793
 794	/*
 795	 * Allocate and initialize the per-ag data.
 796	 */
 797	error = xfs_initialize_perag(mp, sbp->sb_agcount, mp->m_sb.sb_dblocks,
 798			&mp->m_maxagi);
 799	if (error) {
 800		xfs_warn(mp, "Failed per-ag init: %d", error);
 801		goto out_free_dir;
 802	}
 803
 804	if (XFS_IS_CORRUPT(mp, !sbp->sb_logblocks)) {
 805		xfs_warn(mp, "no log defined");
 806		error = -EFSCORRUPTED;
 807		goto out_free_perag;
 808	}
 809
 810	error = xfs_inodegc_register_shrinker(mp);
 811	if (error)
 812		goto out_fail_wait;
 813
 814	/*
 815	 * Log's mount-time initialization. The first part of recovery can place
 816	 * some items on the AIL, to be handled when recovery is finished or
 817	 * cancelled.
 818	 */
 819	error = xfs_log_mount(mp, mp->m_logdev_targp,
 820			      XFS_FSB_TO_DADDR(mp, sbp->sb_logstart),
 821			      XFS_FSB_TO_BB(mp, sbp->sb_logblocks));
 822	if (error) {
 823		xfs_warn(mp, "log mount failed");
 824		goto out_inodegc_shrinker;
 825	}
 826
 827	/* Enable background inode inactivation workers. */
 828	xfs_inodegc_start(mp);
 829	xfs_blockgc_start(mp);
 830
 831	/*
 832	 * Now that we've recovered any pending superblock feature bit
 833	 * additions, we can finish setting up the attr2 behaviour for the
 834	 * mount. The noattr2 option overrides the superblock flag, so only
 835	 * check the superblock feature flag if the mount option is not set.
 836	 */
 837	if (xfs_has_noattr2(mp)) {
 838		mp->m_features &= ~XFS_FEAT_ATTR2;
 839	} else if (!xfs_has_attr2(mp) &&
 840		   (mp->m_sb.sb_features2 & XFS_SB_VERSION2_ATTR2BIT)) {
 841		mp->m_features |= XFS_FEAT_ATTR2;
 842	}
 843
 844	/*
 845	 * Get and sanity-check the root inode.
 846	 * Save the pointer to it in the mount structure.
 847	 */
 848	error = xfs_iget(mp, NULL, sbp->sb_rootino, XFS_IGET_UNTRUSTED,
 849			 XFS_ILOCK_EXCL, &rip);
 850	if (error) {
 851		xfs_warn(mp,
 852			"Failed to read root inode 0x%llx, error %d",
 853			sbp->sb_rootino, -error);
 854		goto out_log_dealloc;
 855	}
 856
 857	ASSERT(rip != NULL);
 858
 859	if (XFS_IS_CORRUPT(mp, !S_ISDIR(VFS_I(rip)->i_mode))) {
 860		xfs_warn(mp, "corrupted root inode %llu: not a directory",
 861			(unsigned long long)rip->i_ino);
 862		xfs_iunlock(rip, XFS_ILOCK_EXCL);
 863		error = -EFSCORRUPTED;
 864		goto out_rele_rip;
 865	}
 866	mp->m_rootip = rip;	/* save it */
 867
 868	xfs_iunlock(rip, XFS_ILOCK_EXCL);
 869
 870	/*
 871	 * Initialize realtime inode pointers in the mount structure
 872	 */
 873	error = xfs_rtmount_inodes(mp);
 874	if (error) {
 875		/*
 876		 * Free up the root inode.
 877		 */
 878		xfs_warn(mp, "failed to read RT inodes");
 879		goto out_rele_rip;
 880	}
 881
 882	/* Make sure the summary counts are ok. */
 883	error = xfs_check_summary_counts(mp);
 884	if (error)
 885		goto out_rtunmount;
 886
 887	/*
 888	 * If this is a read-only mount defer the superblock updates until
 889	 * the next remount into writeable mode.  Otherwise we would never
 890	 * perform the update e.g. for the root filesystem.
 891	 */
 892	if (mp->m_update_sb && !xfs_is_readonly(mp)) {
 893		error = xfs_sync_sb(mp, false);
 894		if (error) {
 895			xfs_warn(mp, "failed to write sb changes");
 896			goto out_rtunmount;
 897		}
 898	}
 899
 900	/*
 901	 * Initialise the XFS quota management subsystem for this mount
 902	 */
 903	if (XFS_IS_QUOTA_ON(mp)) {
 904		error = xfs_qm_newmount(mp, &quotamount, &quotaflags);
 905		if (error)
 906			goto out_rtunmount;
 907	} else {
 908		/*
 909		 * If a file system had quotas running earlier, but decided to
 910		 * mount without -o uquota/pquota/gquota options, revoke the
 911		 * quotachecked license.
 912		 */
 913		if (mp->m_sb.sb_qflags & XFS_ALL_QUOTA_ACCT) {
 914			xfs_notice(mp, "resetting quota flags");
 915			error = xfs_mount_reset_sbqflags(mp);
 916			if (error)
 917				goto out_rtunmount;
 918		}
 919	}
 920
 921	/*
 922	 * Finish recovering the file system.  This part needed to be delayed
 923	 * until after the root and real-time bitmap inodes were consistently
 924	 * read in.  Temporarily create per-AG space reservations for metadata
 925	 * btree shape changes because space freeing transactions (for inode
 926	 * inactivation) require the per-AG reservation in lieu of reserving
 927	 * blocks.
 928	 */
 929	error = xfs_fs_reserve_ag_blocks(mp);
 930	if (error && error == -ENOSPC)
 931		xfs_warn(mp,
 932	"ENOSPC reserving per-AG metadata pool, log recovery may fail.");
 933	error = xfs_log_mount_finish(mp);
 934	xfs_fs_unreserve_ag_blocks(mp);
 935	if (error) {
 936		xfs_warn(mp, "log mount finish failed");
 937		goto out_rtunmount;
 938	}
 939
 940	/*
 941	 * Now the log is fully replayed, we can transition to full read-only
 942	 * mode for read-only mounts. This will sync all the metadata and clean
 943	 * the log so that the recovery we just performed does not have to be
 944	 * replayed again on the next mount.
 945	 *
 946	 * We use the same quiesce mechanism as the rw->ro remount, as they are
 947	 * semantically identical operations.
 948	 */
 949	if (xfs_is_readonly(mp) && !xfs_has_norecovery(mp))
 950		xfs_log_clean(mp);
 951
 952	/*
 953	 * Complete the quota initialisation, post-log-replay component.
 954	 */
 955	if (quotamount) {
 956		ASSERT(mp->m_qflags == 0);
 957		mp->m_qflags = quotaflags;
 958
 959		xfs_qm_mount_quotas(mp);
 960	}
 961
 962	/*
 963	 * Now we are mounted, reserve a small amount of unused space for
 964	 * privileged transactions. This is needed so that transaction
 965	 * space required for critical operations can dip into this pool
 966	 * when at ENOSPC. This is needed for operations like create with
 967	 * attr, unwritten extent conversion at ENOSPC, etc. Data allocations
 968	 * are not allowed to use this reserved space.
 969	 *
 970	 * This may drive us straight to ENOSPC on mount, but that implies
 971	 * we were already there on the last unmount. Warn if this occurs.
 972	 */
 973	if (!xfs_is_readonly(mp)) {
 974		resblks = xfs_default_resblks(mp);
 975		error = xfs_reserve_blocks(mp, &resblks, NULL);
 976		if (error)
 977			xfs_warn(mp,
 978	"Unable to allocate reserve blocks. Continuing without reserve pool.");
 979
 980		/* Reserve AG blocks for future btree expansion. */
 981		error = xfs_fs_reserve_ag_blocks(mp);
 982		if (error && error != -ENOSPC)
 983			goto out_agresv;
 984	}
 985
 986	return 0;
 987
 988 out_agresv:
 989	xfs_fs_unreserve_ag_blocks(mp);
 990	xfs_qm_unmount_quotas(mp);
 991 out_rtunmount:
 992	xfs_rtunmount_inodes(mp);
 993 out_rele_rip:
 994	xfs_irele(rip);
 995	/* Clean out dquots that might be in memory after quotacheck. */
 996	xfs_qm_unmount(mp);
 997
 998	/*
 999	 * Inactivate all inodes that might still be in memory after a log
1000	 * intent recovery failure so that reclaim can free them.  Metadata
1001	 * inodes and the root directory shouldn't need inactivation, but the
1002	 * mount failed for some reason, so pull down all the state and flee.
1003	 */
1004	xfs_inodegc_flush(mp);
1005
1006	/*
1007	 * Flush all inode reclamation work and flush the log.
1008	 * We have to do this /after/ rtunmount and qm_unmount because those
1009	 * two will have scheduled delayed reclaim for the rt/quota inodes.
1010	 *
1011	 * This is slightly different from the unmountfs call sequence
1012	 * because we could be tearing down a partially set up mount.  In
1013	 * particular, if log_mount_finish fails we bail out without calling
1014	 * qm_unmount_quotas and therefore rely on qm_unmount to release the
1015	 * quota inodes.
1016	 */
1017	xfs_unmount_flush_inodes(mp);
1018 out_log_dealloc:
1019	xfs_log_mount_cancel(mp);
1020 out_inodegc_shrinker:
1021	unregister_shrinker(&mp->m_inodegc_shrinker);
1022 out_fail_wait:
1023	if (mp->m_logdev_targp && mp->m_logdev_targp != mp->m_ddev_targp)
1024		xfs_buftarg_drain(mp->m_logdev_targp);
1025	xfs_buftarg_drain(mp->m_ddev_targp);
1026 out_free_perag:
1027	xfs_free_perag(mp);
1028 out_free_dir:
1029	xfs_da_unmount(mp);
1030 out_remove_uuid:
1031	xfs_uuid_unmount(mp);
1032 out_remove_errortag:
1033	xfs_errortag_del(mp);
1034 out_remove_error_sysfs:
1035	xfs_error_sysfs_del(mp);
1036 out_del_stats:
1037	xfs_sysfs_del(&mp->m_stats.xs_kobj);
1038 out_remove_sysfs:
1039	xfs_sysfs_del(&mp->m_kobj);
1040 out:
1041	return error;
1042}
1043
1044/*
1045 * This flushes out the inodes,dquots and the superblock, unmounts the
1046 * log and makes sure that incore structures are freed.
1047 */
1048void
1049xfs_unmountfs(
1050	struct xfs_mount	*mp)
1051{
1052	uint64_t		resblks;
1053	int			error;
1054
1055	/*
1056	 * Perform all on-disk metadata updates required to inactivate inodes
1057	 * that the VFS evicted earlier in the unmount process.  Freeing inodes
1058	 * and discarding CoW fork preallocations can cause shape changes to
1059	 * the free inode and refcount btrees, respectively, so we must finish
1060	 * this before we discard the metadata space reservations.  Metadata
1061	 * inodes and the root directory do not require inactivation.
1062	 */
1063	xfs_inodegc_flush(mp);
1064
1065	xfs_blockgc_stop(mp);
1066	xfs_fs_unreserve_ag_blocks(mp);
1067	xfs_qm_unmount_quotas(mp);
1068	xfs_rtunmount_inodes(mp);
1069	xfs_irele(mp->m_rootip);
1070
1071	xfs_unmount_flush_inodes(mp);
1072
1073	xfs_qm_unmount(mp);
1074
1075	/*
1076	 * Unreserve any blocks we have so that when we unmount we don't account
1077	 * the reserved free space as used. This is really only necessary for
1078	 * lazy superblock counting because it trusts the incore superblock
1079	 * counters to be absolutely correct on clean unmount.
1080	 *
1081	 * We don't bother correcting this elsewhere for lazy superblock
1082	 * counting because on mount of an unclean filesystem we reconstruct the
1083	 * correct counter value and this is irrelevant.
1084	 *
1085	 * For non-lazy counter filesystems, this doesn't matter at all because
1086	 * we only every apply deltas to the superblock and hence the incore
1087	 * value does not matter....
1088	 */
1089	resblks = 0;
1090	error = xfs_reserve_blocks(mp, &resblks, NULL);
1091	if (error)
1092		xfs_warn(mp, "Unable to free reserved block pool. "
1093				"Freespace may not be correct on next mount.");
1094	xfs_unmount_check(mp);
1095
1096	xfs_log_unmount(mp);
1097	xfs_da_unmount(mp);
1098	xfs_uuid_unmount(mp);
1099
1100#if defined(DEBUG)
1101	xfs_errortag_clearall(mp);
1102#endif
1103	unregister_shrinker(&mp->m_inodegc_shrinker);
1104	xfs_free_perag(mp);
1105
1106	xfs_errortag_del(mp);
1107	xfs_error_sysfs_del(mp);
1108	xfs_sysfs_del(&mp->m_stats.xs_kobj);
1109	xfs_sysfs_del(&mp->m_kobj);
1110}
1111
1112/*
1113 * Determine whether modifications can proceed. The caller specifies the minimum
1114 * freeze level for which modifications should not be allowed. This allows
1115 * certain operations to proceed while the freeze sequence is in progress, if
1116 * necessary.
1117 */
1118bool
1119xfs_fs_writable(
1120	struct xfs_mount	*mp,
1121	int			level)
1122{
1123	ASSERT(level > SB_UNFROZEN);
1124	if ((mp->m_super->s_writers.frozen >= level) ||
1125	    xfs_is_shutdown(mp) || xfs_is_readonly(mp))
1126		return false;
1127
1128	return true;
1129}
1130
1131/* Adjust m_fdblocks or m_frextents. */
1132int
1133xfs_mod_freecounter(
1134	struct xfs_mount	*mp,
1135	struct percpu_counter	*counter,
1136	int64_t			delta,
1137	bool			rsvd)
1138{
1139	int64_t			lcounter;
1140	long long		res_used;
1141	uint64_t		set_aside = 0;
1142	s32			batch;
1143	bool			has_resv_pool;
1144
1145	ASSERT(counter == &mp->m_fdblocks || counter == &mp->m_frextents);
1146	has_resv_pool = (counter == &mp->m_fdblocks);
1147	if (rsvd)
1148		ASSERT(has_resv_pool);
1149
1150	if (delta > 0) {
1151		/*
1152		 * If the reserve pool is depleted, put blocks back into it
1153		 * first. Most of the time the pool is full.
1154		 */
1155		if (likely(!has_resv_pool ||
1156			   mp->m_resblks == mp->m_resblks_avail)) {
1157			percpu_counter_add(counter, delta);
1158			return 0;
1159		}
1160
1161		spin_lock(&mp->m_sb_lock);
1162		res_used = (long long)(mp->m_resblks - mp->m_resblks_avail);
1163
1164		if (res_used > delta) {
1165			mp->m_resblks_avail += delta;
1166		} else {
1167			delta -= res_used;
1168			mp->m_resblks_avail = mp->m_resblks;
1169			percpu_counter_add(counter, delta);
1170		}
1171		spin_unlock(&mp->m_sb_lock);
1172		return 0;
1173	}
1174
1175	/*
1176	 * Taking blocks away, need to be more accurate the closer we
1177	 * are to zero.
1178	 *
1179	 * If the counter has a value of less than 2 * max batch size,
1180	 * then make everything serialise as we are real close to
1181	 * ENOSPC.
1182	 */
1183	if (__percpu_counter_compare(counter, 2 * XFS_FDBLOCKS_BATCH,
1184				     XFS_FDBLOCKS_BATCH) < 0)
1185		batch = 1;
1186	else
1187		batch = XFS_FDBLOCKS_BATCH;
1188
1189	/*
1190	 * Set aside allocbt blocks because these blocks are tracked as free
1191	 * space but not available for allocation. Technically this means that a
1192	 * single reservation cannot consume all remaining free space, but the
1193	 * ratio of allocbt blocks to usable free blocks should be rather small.
1194	 * The tradeoff without this is that filesystems that maintain high
1195	 * perag block reservations can over reserve physical block availability
1196	 * and fail physical allocation, which leads to much more serious
1197	 * problems (i.e. transaction abort, pagecache discards, etc.) than
1198	 * slightly premature -ENOSPC.
1199	 */
1200	if (has_resv_pool)
1201		set_aside = xfs_fdblocks_unavailable(mp);
1202	percpu_counter_add_batch(counter, delta, batch);
1203	if (__percpu_counter_compare(counter, set_aside,
1204				     XFS_FDBLOCKS_BATCH) >= 0) {
1205		/* we had space! */
1206		return 0;
1207	}
1208
1209	/*
1210	 * lock up the sb for dipping into reserves before releasing the space
1211	 * that took us to ENOSPC.
1212	 */
1213	spin_lock(&mp->m_sb_lock);
1214	percpu_counter_add(counter, -delta);
1215	if (!has_resv_pool || !rsvd)
1216		goto fdblocks_enospc;
1217
1218	lcounter = (long long)mp->m_resblks_avail + delta;
1219	if (lcounter >= 0) {
1220		mp->m_resblks_avail = lcounter;
1221		spin_unlock(&mp->m_sb_lock);
1222		return 0;
1223	}
1224	xfs_warn_once(mp,
1225"Reserve blocks depleted! Consider increasing reserve pool size.");
1226
1227fdblocks_enospc:
1228	spin_unlock(&mp->m_sb_lock);
1229	return -ENOSPC;
1230}
1231
1232/*
1233 * Used to free the superblock along various error paths.
1234 */
1235void
1236xfs_freesb(
1237	struct xfs_mount	*mp)
1238{
1239	struct xfs_buf		*bp = mp->m_sb_bp;
1240
1241	xfs_buf_lock(bp);
1242	mp->m_sb_bp = NULL;
1243	xfs_buf_relse(bp);
1244}
1245
1246/*
1247 * If the underlying (data/log/rt) device is readonly, there are some
1248 * operations that cannot proceed.
1249 */
1250int
1251xfs_dev_is_read_only(
1252	struct xfs_mount	*mp,
1253	char			*message)
1254{
1255	if (xfs_readonly_buftarg(mp->m_ddev_targp) ||
1256	    xfs_readonly_buftarg(mp->m_logdev_targp) ||
1257	    (mp->m_rtdev_targp && xfs_readonly_buftarg(mp->m_rtdev_targp))) {
1258		xfs_notice(mp, "%s required on read-only device.", message);
1259		xfs_notice(mp, "write access unavailable, cannot proceed.");
1260		return -EROFS;
1261	}
1262	return 0;
1263}
1264
1265/* Force the summary counters to be recalculated at next mount. */
1266void
1267xfs_force_summary_recalc(
1268	struct xfs_mount	*mp)
1269{
1270	if (!xfs_has_lazysbcount(mp))
1271		return;
1272
1273	xfs_fs_mark_sick(mp, XFS_SICK_FS_COUNTERS);
1274}
1275
1276/*
1277 * Enable a log incompat feature flag in the primary superblock.  The caller
1278 * cannot have any other transactions in progress.
1279 */
1280int
1281xfs_add_incompat_log_feature(
1282	struct xfs_mount	*mp,
1283	uint32_t		feature)
1284{
1285	struct xfs_dsb		*dsb;
1286	int			error;
1287
1288	ASSERT(hweight32(feature) == 1);
1289	ASSERT(!(feature & XFS_SB_FEAT_INCOMPAT_LOG_UNKNOWN));
1290
1291	/*
1292	 * Force the log to disk and kick the background AIL thread to reduce
1293	 * the chances that the bwrite will stall waiting for the AIL to unpin
1294	 * the primary superblock buffer.  This isn't a data integrity
1295	 * operation, so we don't need a synchronous push.
1296	 */
1297	error = xfs_log_force(mp, XFS_LOG_SYNC);
1298	if (error)
1299		return error;
1300	xfs_ail_push_all(mp->m_ail);
1301
1302	/*
1303	 * Lock the primary superblock buffer to serialize all callers that
1304	 * are trying to set feature bits.
1305	 */
1306	xfs_buf_lock(mp->m_sb_bp);
1307	xfs_buf_hold(mp->m_sb_bp);
1308
1309	if (xfs_is_shutdown(mp)) {
1310		error = -EIO;
1311		goto rele;
1312	}
1313
1314	if (xfs_sb_has_incompat_log_feature(&mp->m_sb, feature))
1315		goto rele;
1316
1317	/*
1318	 * Write the primary superblock to disk immediately, because we need
1319	 * the log_incompat bit to be set in the primary super now to protect
1320	 * the log items that we're going to commit later.
1321	 */
1322	dsb = mp->m_sb_bp->b_addr;
1323	xfs_sb_to_disk(dsb, &mp->m_sb);
1324	dsb->sb_features_log_incompat |= cpu_to_be32(feature);
1325	error = xfs_bwrite(mp->m_sb_bp);
1326	if (error)
1327		goto shutdown;
1328
1329	/*
1330	 * Add the feature bits to the incore superblock before we unlock the
1331	 * buffer.
1332	 */
1333	xfs_sb_add_incompat_log_features(&mp->m_sb, feature);
1334	xfs_buf_relse(mp->m_sb_bp);
1335
1336	/* Log the superblock to disk. */
1337	return xfs_sync_sb(mp, false);
1338shutdown:
1339	xfs_force_shutdown(mp, SHUTDOWN_META_IO_ERROR);
1340rele:
1341	xfs_buf_relse(mp->m_sb_bp);
1342	return error;
1343}
1344
1345/*
1346 * Clear all the log incompat flags from the superblock.
1347 *
1348 * The caller cannot be in a transaction, must ensure that the log does not
1349 * contain any log items protected by any log incompat bit, and must ensure
1350 * that there are no other threads that depend on the state of the log incompat
1351 * feature flags in the primary super.
1352 *
1353 * Returns true if the superblock is dirty.
1354 */
1355bool
1356xfs_clear_incompat_log_features(
1357	struct xfs_mount	*mp)
1358{
1359	bool			ret = false;
1360
1361	if (!xfs_has_crc(mp) ||
1362	    !xfs_sb_has_incompat_log_feature(&mp->m_sb,
1363				XFS_SB_FEAT_INCOMPAT_LOG_ALL) ||
1364	    xfs_is_shutdown(mp))
1365		return false;
1366
1367	/*
1368	 * Update the incore superblock.  We synchronize on the primary super
1369	 * buffer lock to be consistent with the add function, though at least
1370	 * in theory this shouldn't be necessary.
1371	 */
1372	xfs_buf_lock(mp->m_sb_bp);
1373	xfs_buf_hold(mp->m_sb_bp);
1374
1375	if (xfs_sb_has_incompat_log_feature(&mp->m_sb,
1376				XFS_SB_FEAT_INCOMPAT_LOG_ALL)) {
1377		xfs_sb_remove_incompat_log_features(&mp->m_sb);
1378		ret = true;
1379	}
1380
1381	xfs_buf_relse(mp->m_sb_bp);
1382	return ret;
1383}
1384
1385/*
1386 * Update the in-core delayed block counter.
1387 *
1388 * We prefer to update the counter without having to take a spinlock for every
1389 * counter update (i.e. batching).  Each change to delayed allocation
1390 * reservations can change can easily exceed the default percpu counter
1391 * batching, so we use a larger batch factor here.
1392 *
1393 * Note that we don't currently have any callers requiring fast summation
1394 * (e.g. percpu_counter_read) so we can use a big batch value here.
1395 */
1396#define XFS_DELALLOC_BATCH	(4096)
1397void
1398xfs_mod_delalloc(
1399	struct xfs_mount	*mp,
1400	int64_t			delta)
1401{
1402	percpu_counter_add_batch(&mp->m_delalloc_blks, delta,
1403			XFS_DELALLOC_BATCH);
1404}