kernel/fs/xfs/xfs_mount.c

   1 /*
   2  * Copyright (c) 2000-2005 Silicon Graphics, Inc.
   3  * All Rights Reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License as
   7  * published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it would be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write the Free Software Foundation,
  16  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  17  */
  18 #include "xfs.h"
  19 #include "xfs_fs.h"
  20 #include "xfs_shared.h"
  21 #include "xfs_format.h"
  22 #include "xfs_log_format.h"
  23 #include "xfs_trans_resv.h"
  24 #include "xfs_bit.h"
  25 #include "xfs_sb.h"
  26 #include "xfs_mount.h"
  27 #include "xfs_da_format.h"
  28 #include "xfs_da_btree.h"
  29 #include "xfs_inode.h"
  30 #include "xfs_dir2.h"
  31 #include "xfs_ialloc.h"
  32 #include "xfs_alloc.h"
  33 #include "xfs_rtalloc.h"
  34 #include "xfs_bmap.h"
  35 #include "xfs_trans.h"
  36 #include "xfs_trans_priv.h"
  37 #include "xfs_log.h"
  38 #include "xfs_error.h"
  39 #include "xfs_quota.h"
  40 #include "xfs_fsops.h"
  41 #include "xfs_trace.h"
  42 #include "xfs_icache.h"
  43 #include "xfs_sysfs.h"
  44
  45
  46 static DEFINE_MUTEX(xfs_uuid_table_mutex);
  47 static int xfs_uuid_table_size;
  48 static uuid_t *xfs_uuid_table;
  49
  50 /*
  51  * See if the UUID is unique among mounted XFS filesystems.
  52  * Mount fails if UUID is nil or a FS with the same UUID is already mounted.
  53  */
  54 STATIC int
  55 xfs_uuid_mount(
  56         struct xfs_mount        *mp)
  57 {
  58         uuid_t                  *uuid = &mp->m_sb.sb_uuid;
  59         int                     hole, i;
  60
  61         if (mp->m_flags & XFS_MOUNT_NOUUID)
  62                 return 0;
  63
  64         if (uuid_is_nil(uuid)) {
  65                 xfs_warn(mp, "Filesystem has nil UUID - can't mount");
  66                 return -EINVAL;
  67         }
  68
  69         mutex_lock(&xfs_uuid_table_mutex);
  70         for (i = 0, hole = -1; i < xfs_uuid_table_size; i++) {
  71                 if (uuid_is_nil(&xfs_uuid_table[i])) {
  72                         hole = i;
  73                         continue;
  74                 }
  75                 if (uuid_equal(uuid, &xfs_uuid_table[i]))
  76                         goto out_duplicate;
  77         }
  78
  79         if (hole < 0) {
  80                 xfs_uuid_table = kmem_realloc(xfs_uuid_table,
  81                         (xfs_uuid_table_size + 1) * sizeof(*xfs_uuid_table),
  82                         xfs_uuid_table_size  * sizeof(*xfs_uuid_table),
  83                         KM_SLEEP);
  84                 hole = xfs_uuid_table_size++;
  85         }
  86         xfs_uuid_table[hole] = *uuid;
  87         mutex_unlock(&xfs_uuid_table_mutex);
  88
  89         return 0;
  90
  91  out_duplicate:
  92         mutex_unlock(&xfs_uuid_table_mutex);
  93         xfs_warn(mp, "Filesystem has duplicate UUID %pU - can't mount", uuid);
  94         return -EINVAL;
  95 }
  96
  97 STATIC void
  98 xfs_uuid_unmount(
  99         struct xfs_mount        *mp)
 100 {
 101         uuid_t                  *uuid = &mp->m_sb.sb_uuid;
 102         int                     i;
 103
 104         if (mp->m_flags & XFS_MOUNT_NOUUID)
 105                 return;
 106
 107         mutex_lock(&xfs_uuid_table_mutex);
 108         for (i = 0; i < xfs_uuid_table_size; i++) {
 109                 if (uuid_is_nil(&xfs_uuid_table[i]))
 110                         continue;
 111                 if (!uuid_equal(uuid, &xfs_uuid_table[i]))
 112                         continue;
 113                 memset(&xfs_uuid_table[i], 0, sizeof(uuid_t));
 114                 break;
 115         }
 116         ASSERT(i < xfs_uuid_table_size);
 117         mutex_unlock(&xfs_uuid_table_mutex);
 118 }
 119
 120
 121 STATIC void
 122 __xfs_free_perag(
 123         struct rcu_head *head)
 124 {
 125         struct xfs_perag *pag = container_of(head, struct xfs_perag, rcu_head);
 126
 127         ASSERT(atomic_read(&pag->pag_ref) == 0);
 128         kmem_free(pag);
 129 }
 130
 131 /*
 132  * Free up the per-ag resources associated with the mount structure.
 133  */
 134 STATIC void
 135 xfs_free_perag(
 136         xfs_mount_t     *mp)
 137 {
 138         xfs_agnumber_t  agno;
 139         struct xfs_perag *pag;
 140
 141         for (agno = 0; agno < mp->m_sb.sb_agcount; agno++) {
 142                 spin_lock(&mp->m_perag_lock);
 143                 pag = radix_tree_delete(&mp->m_perag_tree, agno);
 144                 spin_unlock(&mp->m_perag_lock);
 145                 ASSERT(pag);
 146                 ASSERT(atomic_read(&pag->pag_ref) == 0);
 147                 call_rcu(&pag->rcu_head, __xfs_free_perag);
 148         }
 149 }
 150
 151 /*
 152  * Check size of device based on the (data/realtime) block count.
 153  * Note: this check is used by the growfs code as well as mount.
 154  */
 155 int
 156 xfs_sb_validate_fsb_count(
 157         xfs_sb_t        *sbp,
 158         __uint64_t      nblocks)
 159 {
 160         ASSERT(PAGE_SHIFT >= sbp->sb_blocklog);
 161         ASSERT(sbp->sb_blocklog >= BBSHIFT);
 162
 163         /* Limited by ULONG_MAX of page cache index */
 164         if (nblocks >> (PAGE_CACHE_SHIFT - sbp->sb_blocklog) > ULONG_MAX)
 165                 return -EFBIG;
 166         return 0;
 167 }
 168
 169 int
 170 xfs_initialize_perag(
 171         xfs_mount_t     *mp,
 172         xfs_agnumber_t  agcount,
 173         xfs_agnumber_t  *maxagi)
 174 {
 175         xfs_agnumber_t  index;
 176         xfs_agnumber_t  first_initialised = 0;
 177         xfs_perag_t     *pag;
 178         xfs_agino_t     agino;
 179         xfs_ino_t       ino;
 180         xfs_sb_t        *sbp = &mp->m_sb;
 181         int             error = -ENOMEM;
 182
 183         /*
 184          * Walk the current per-ag tree so we don't try to initialise AGs
 185          * that already exist (growfs case). Allocate and insert all the
 186          * AGs we don't find ready for initialisation.
 187          */
 188         for (index = 0; index < agcount; index++) {
 189                 pag = xfs_perag_get(mp, index);
 190                 if (pag) {
 191                         xfs_perag_put(pag);
 192                         continue;
 193                 }
 194                 if (!first_initialised)
 195                         first_initialised = index;
 196
 197                 pag = kmem_zalloc(sizeof(*pag), KM_MAYFAIL);
 198                 if (!pag)
 199                         goto out_unwind;
 200                 pag->pag_agno = index;
 201                 pag->pag_mount = mp;
 202                 spin_lock_init(&pag->pag_ici_lock);
 203                 mutex_init(&pag->pag_ici_reclaim_lock);
 204                 INIT_RADIX_TREE(&pag->pag_ici_root, GFP_ATOMIC);
 205                 spin_lock_init(&pag->pag_buf_lock);
 206                 pag->pag_buf_tree = RB_ROOT;
 207
 208                 if (radix_tree_preload(GFP_NOFS))
 209                         goto out_unwind;
 210
 211                 spin_lock(&mp->m_perag_lock);
 212                 if (radix_tree_insert(&mp->m_perag_tree, index, pag)) {
 213                         BUG();
 214                         spin_unlock(&mp->m_perag_lock);
 215                         radix_tree_preload_end();
 216                         error = -EEXIST;
 217                         goto out_unwind;
 218                 }
 219                 spin_unlock(&mp->m_perag_lock);
 220                 radix_tree_preload_end();
 221         }
 222
 223         /*
 224          * If we mount with the inode64 option, or no inode overflows
 225          * the legacy 32-bit address space clear the inode32 option.
 226          */
 227         agino = XFS_OFFBNO_TO_AGINO(mp, sbp->sb_agblocks - 1, 0);
 228         ino = XFS_AGINO_TO_INO(mp, agcount - 1, agino);
 229
 230         if ((mp->m_flags & XFS_MOUNT_SMALL_INUMS) && ino > XFS_MAXINUMBER_32)
 231                 mp->m_flags |= XFS_MOUNT_32BITINODES;
 232         else
 233                 mp->m_flags &= ~XFS_MOUNT_32BITINODES;
 234
 235         if (mp->m_flags & XFS_MOUNT_32BITINODES)
 236                 index = xfs_set_inode32(mp, agcount);
 237         else
 238                 index = xfs_set_inode64(mp, agcount);
 239
 240         if (maxagi)
 241                 *maxagi = index;
 242         return 0;
 243
 244 out_unwind:
 245         kmem_free(pag);
 246         for (; index > first_initialised; index--) {
 247                 pag = radix_tree_delete(&mp->m_perag_tree, index);
 248                 kmem_free(pag);
 249         }
 250         return error;
 251 }
 252
 253 /*
 254  * xfs_readsb
 255  *
 256  * Does the initial read of the superblock.
 257  */
 258 int
 259 xfs_readsb(
 260         struct xfs_mount *mp,
 261         int             flags)
 262 {
 263         unsigned int    sector_size;
 264         struct xfs_buf  *bp;
 265         struct xfs_sb   *sbp = &mp->m_sb;
 266         int             error;
 267         int             loud = !(flags & XFS_MFSI_QUIET);
 268         const struct xfs_buf_ops *buf_ops;
 269
 270         ASSERT(mp->m_sb_bp == NULL);
 271         ASSERT(mp->m_ddev_targp != NULL);
 272
 273         /*
 274          * For the initial read, we must guess at the sector
 275          * size based on the block device.  It's enough to
 276          * get the sb_sectsize out of the superblock and
 277          * then reread with the proper length.
 278          * We don't verify it yet, because it may not be complete.
 279          */
 280         sector_size = xfs_getsize_buftarg(mp->m_ddev_targp);
 281         buf_ops = NULL;
 282
 283         /*
 284          * Allocate a (locked) buffer to hold the superblock.
 285          * This will be kept around at all times to optimize
 286          * access to the superblock.
 287          */
 288 reread:
 289         error = xfs_buf_read_uncached(mp->m_ddev_targp, XFS_SB_DADDR,
 290                                    BTOBB(sector_size), 0, &bp, buf_ops);
 291         if (error) {
 292                 if (loud)
 293                         xfs_warn(mp, "SB validate failed with error %d.", error);
 294                 /* bad CRC means corrupted metadata */
 295                 if (error == -EFSBADCRC)
 296                         error = -EFSCORRUPTED;
 297                 return error;
 298         }
 299
 300         /*
 301          * Initialize the mount structure from the superblock.
 302          */
 303         xfs_sb_from_disk(sbp, XFS_BUF_TO_SBP(bp));
 304
 305         /*
 306          * If we haven't validated the superblock, do so now before we try
 307          * to check the sector size and reread the superblock appropriately.
 308          */
 309         if (sbp->sb_magicnum != XFS_SB_MAGIC) {
 310                 if (loud)
 311                         xfs_warn(mp, "Invalid superblock magic number");
 312                 error = -EINVAL;
 313                 goto release_buf;
 314         }
 315
 316         /*
 317          * We must be able to do sector-sized and sector-aligned IO.
 318          */
 319         if (sector_size > sbp->sb_sectsize) {
 320                 if (loud)
 321                         xfs_warn(mp, "device supports %u byte sectors (not %u)",
 322                                 sector_size, sbp->sb_sectsize);
 323                 error = -ENOSYS;
 324                 goto release_buf;
 325         }
 326
 327         if (buf_ops == NULL) {
 328                 /*
 329                  * Re-read the superblock so the buffer is correctly sized,
 330                  * and properly verified.
 331                  */
 332                 xfs_buf_relse(bp);
 333                 sector_size = sbp->sb_sectsize;
 334                 buf_ops = loud ? &xfs_sb_buf_ops : &xfs_sb_quiet_buf_ops;
 335                 goto reread;
 336         }
 337
 338         xfs_reinit_percpu_counters(mp);
 339
 340         /* no need to be quiet anymore, so reset the buf ops */
 341         bp->b_ops = &xfs_sb_buf_ops;
 342
 343         mp->m_sb_bp = bp;
 344         xfs_buf_unlock(bp);
 345         return 0;
 346
 347 release_buf:
 348         xfs_buf_relse(bp);
 349         return error;
 350 }
 351
 352 /*
 353  * Update alignment values based on mount options and sb values
 354  */
 355 STATIC int
 356 xfs_update_alignment(xfs_mount_t *mp)
 357 {
 358         xfs_sb_t        *sbp = &(mp->m_sb);
 359
 360         if (mp->m_dalign) {
 361                 /*
 362                  * If stripe unit and stripe width are not multiples
 363                  * of the fs blocksize turn off alignment.
 364                  */
 365                 if ((BBTOB(mp->m_dalign) & mp->m_blockmask) ||
 366                     (BBTOB(mp->m_swidth) & mp->m_blockmask)) {
 367                         xfs_warn(mp,
 368                 "alignment check failed: sunit/swidth vs. blocksize(%d)",
 369                                 sbp->sb_blocksize);
 370                         return -EINVAL;
 371                 } else {
 372                         /*
 373                          * Convert the stripe unit and width to FSBs.
 374                          */
 375                         mp->m_dalign = XFS_BB_TO_FSBT(mp, mp->m_dalign);
 376                         if (mp->m_dalign && (sbp->sb_agblocks % mp->m_dalign)) {
 377                                 xfs_warn(mp,
 378                         "alignment check failed: sunit/swidth vs. agsize(%d)",
 379                                          sbp->sb_agblocks);
 380                                 return -EINVAL;
 381                         } else if (mp->m_dalign) {
 382                                 mp->m_swidth = XFS_BB_TO_FSBT(mp, mp->m_swidth);
 383                         } else {
 384                                 xfs_warn(mp,
 385                         "alignment check failed: sunit(%d) less than bsize(%d)",
 386                                          mp->m_dalign, sbp->sb_blocksize);
 387                                 return -EINVAL;
 388                         }
 389                 }
 390
 391                 /*
 392                  * Update superblock with new values
 393                  * and log changes
 394                  */
 395                 if (xfs_sb_version_hasdalign(sbp)) {
 396                         if (sbp->sb_unit != mp->m_dalign) {
 397                                 sbp->sb_unit = mp->m_dalign;
 398                                 mp->m_update_sb = true;
 399                         }
 400                         if (sbp->sb_width != mp->m_swidth) {
 401                                 sbp->sb_width = mp->m_swidth;
 402                                 mp->m_update_sb = true;
 403                         }
 404                 } else {
 405                         xfs_warn(mp,
 406         "cannot change alignment: superblock does not support data alignment");
 407                         return -EINVAL;
 408                 }
 409         } else if ((mp->m_flags & XFS_MOUNT_NOALIGN) != XFS_MOUNT_NOALIGN &&
 410                     xfs_sb_version_hasdalign(&mp->m_sb)) {
 411                         mp->m_dalign = sbp->sb_unit;
 412                         mp->m_swidth = sbp->sb_width;
 413         }
 414
 415         return 0;
 416 }
 417
 418 /*
 419  * Set the maximum inode count for this filesystem
 420  */
 421 STATIC void
 422 xfs_set_maxicount(xfs_mount_t *mp)
 423 {
 424         xfs_sb_t        *sbp = &(mp->m_sb);
 425         __uint64_t      icount;
 426
 427         if (sbp->sb_imax_pct) {
 428                 /*
 429                  * Make sure the maximum inode count is a multiple
 430                  * of the units we allocate inodes in.
 431                  */
 432                 icount = sbp->sb_dblocks * sbp->sb_imax_pct;
 433                 do_div(icount, 100);
 434                 do_div(icount, mp->m_ialloc_blks);
 435                 mp->m_maxicount = (icount * mp->m_ialloc_blks)  <<
 436                                    sbp->sb_inopblog;
 437         } else {
 438                 mp->m_maxicount = 0;
 439         }
 440 }
 441
 442 /*
 443  * Set the default minimum read and write sizes unless
 444  * already specified in a mount option.
 445  * We use smaller I/O sizes when the file system
 446  * is being used for NFS service (wsync mount option).
 447  */
 448 STATIC void
 449 xfs_set_rw_sizes(xfs_mount_t *mp)
 450 {
 451         xfs_sb_t        *sbp = &(mp->m_sb);
 452         int             readio_log, writeio_log;
 453
 454         if (!(mp->m_flags & XFS_MOUNT_DFLT_IOSIZE)) {
 455                 if (mp->m_flags & XFS_MOUNT_WSYNC) {
 456                         readio_log = XFS_WSYNC_READIO_LOG;
 457                         writeio_log = XFS_WSYNC_WRITEIO_LOG;
 458                 } else {
 459                         readio_log = XFS_READIO_LOG_LARGE;
 460                         writeio_log = XFS_WRITEIO_LOG_LARGE;
 461                 }
 462         } else {
 463                 readio_log = mp->m_readio_log;
 464                 writeio_log = mp->m_writeio_log;
 465         }
 466
 467         if (sbp->sb_blocklog > readio_log) {
 468                 mp->m_readio_log = sbp->sb_blocklog;
 469         } else {
 470                 mp->m_readio_log = readio_log;
 471         }
 472         mp->m_readio_blocks = 1 << (mp->m_readio_log - sbp->sb_blocklog);
 473         if (sbp->sb_blocklog > writeio_log) {
 474                 mp->m_writeio_log = sbp->sb_blocklog;
 475         } else {
 476                 mp->m_writeio_log = writeio_log;
 477         }
 478         mp->m_writeio_blocks = 1 << (mp->m_writeio_log - sbp->sb_blocklog);
 479 }
 480
 481 /*
 482  * precalculate the low space thresholds for dynamic speculative preallocation.
 483  */
 484 void
 485 xfs_set_low_space_thresholds(
 486         struct xfs_mount        *mp)
 487 {
 488         int i;
 489
 490         for (i = 0; i < XFS_LOWSP_MAX; i++) {
 491                 __uint64_t space = mp->m_sb.sb_dblocks;
 492
 493                 do_div(space, 100);
 494                 mp->m_low_space[i] = space * (i + 1);
 495         }
 496 }
 497
 498
 499 /*
 500  * Set whether we're using inode alignment.
 501  */
 502 STATIC void
 503 xfs_set_inoalignment(xfs_mount_t *mp)
 504 {
 505         if (xfs_sb_version_hasalign(&mp->m_sb) &&
 506             mp->m_sb.sb_inoalignmt >=
 507             XFS_B_TO_FSBT(mp, mp->m_inode_cluster_size))
 508                 mp->m_inoalign_mask = mp->m_sb.sb_inoalignmt - 1;
 509         else
 510                 mp->m_inoalign_mask = 0;
 511         /*
 512          * If we are using stripe alignment, check whether
 513          * the stripe unit is a multiple of the inode alignment
 514          */
 515         if (mp->m_dalign && mp->m_inoalign_mask &&
 516             !(mp->m_dalign & mp->m_inoalign_mask))
 517                 mp->m_sinoalign = mp->m_dalign;
 518         else
 519                 mp->m_sinoalign = 0;
 520 }
 521
 522 /*
 523  * Check that the data (and log if separate) is an ok size.
 524  */
 525 STATIC int
 526 xfs_check_sizes(
 527         struct xfs_mount *mp)
 528 {
 529         struct xfs_buf  *bp;
 530         xfs_daddr_t     d;
 531         int             error;
 532
 533         d = (xfs_daddr_t)XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks);
 534         if (XFS_BB_TO_FSB(mp, d) != mp->m_sb.sb_dblocks) {
 535                 xfs_warn(mp, "filesystem size mismatch detected");
 536                 return -EFBIG;
 537         }
 538         error = xfs_buf_read_uncached(mp->m_ddev_targp,
 539                                         d - XFS_FSS_TO_BB(mp, 1),
 540                                         XFS_FSS_TO_BB(mp, 1), 0, &bp, NULL);
 541         if (error) {
 542                 xfs_warn(mp, "last sector read failed");
 543                 return error;
 544         }
 545         xfs_buf_relse(bp);
 546
 547         if (mp->m_logdev_targp == mp->m_ddev_targp)
 548                 return 0;
 549
 550         d = (xfs_daddr_t)XFS_FSB_TO_BB(mp, mp->m_sb.sb_logblocks);
 551         if (XFS_BB_TO_FSB(mp, d) != mp->m_sb.sb_logblocks) {
 552                 xfs_warn(mp, "log size mismatch detected");
 553                 return -EFBIG;
 554         }
 555         error = xfs_buf_read_uncached(mp->m_logdev_targp,
 556                                         d - XFS_FSB_TO_BB(mp, 1),
 557                                         XFS_FSB_TO_BB(mp, 1), 0, &bp, NULL);
 558         if (error) {
 559                 xfs_warn(mp, "log device read failed");
 560                 return error;
 561         }
 562         xfs_buf_relse(bp);
 563         return 0;
 564 }
 565
 566 /*
 567  * Clear the quotaflags in memory and in the superblock.
 568  */
 569 int
 570 xfs_mount_reset_sbqflags(
 571         struct xfs_mount        *mp)
 572 {
 573         mp->m_qflags = 0;
 574
 575         /* It is OK to look at sb_qflags in the mount path without m_sb_lock. */
 576         if (mp->m_sb.sb_qflags == 0)
 577                 return 0;
 578         spin_lock(&mp->m_sb_lock);
 579         mp->m_sb.sb_qflags = 0;
 580         spin_unlock(&mp->m_sb_lock);
 581
 582         if (!xfs_fs_writable(mp, SB_FREEZE_WRITE))
 583                 return 0;
 584
 585         return xfs_sync_sb(mp, false);
 586 }
 587
 588 __uint64_t
 589 xfs_default_resblks(xfs_mount_t *mp)
 590 {
 591         __uint64_t resblks;
 592
 593         /*
 594          * We default to 5% or 8192 fsbs of space reserved, whichever is
 595          * smaller.  This is intended to cover concurrent allocation
 596          * transactions when we initially hit enospc. These each require a 4
 597          * block reservation. Hence by default we cover roughly 2000 concurrent
 598          * allocation reservations.
 599          */
 600         resblks = mp->m_sb.sb_dblocks;
 601         do_div(resblks, 20);
 602         resblks = min_t(__uint64_t, resblks, 8192);
 603         return resblks;
 604 }
 605
 606 /*
 607  * This function does the following on an initial mount of a file system:
 608  *      - reads the superblock from disk and init the mount struct
 609  *      - if we're a 32-bit kernel, do a size check on the superblock
 610  *              so we don't mount terabyte filesystems
 611  *      - init mount struct realtime fields
 612  *      - allocate inode hash table for fs
 613  *      - init directory manager
 614  *      - perform recovery and init the log manager
 615  */
 616 int
 617 xfs_mountfs(
 618         xfs_mount_t     *mp)
 619 {
 620         xfs_sb_t        *sbp = &(mp->m_sb);
 621         xfs_inode_t     *rip;
 622         __uint64_t      resblks;
 623         uint            quotamount = 0;
 624         uint            quotaflags = 0;
 625         int             error = 0;
 626
 627         xfs_sb_mount_common(mp, sbp);
 628
 629         /*
 630          * Check for a mismatched features2 values.  Older kernels read & wrote
 631          * into the wrong sb offset for sb_features2 on some platforms due to
 632          * xfs_sb_t not being 64bit size aligned when sb_features2 was added,
 633          * which made older superblock reading/writing routines swap it as a
 634          * 64-bit value.
 635          *
 636          * For backwards compatibility, we make both slots equal.
 637          *
 638          * If we detect a mismatched field, we OR the set bits into the existing
 639          * features2 field in case it has already been modified; we don't want
 640          * to lose any features.  We then update the bad location with the ORed
 641          * value so that older kernels will see any features2 flags. The
 642          * superblock writeback code ensures the new sb_features2 is copied to
 643          * sb_bad_features2 before it is logged or written to disk.
 644          */
 645         if (xfs_sb_has_mismatched_features2(sbp)) {
 646                 xfs_warn(mp, "correcting sb_features alignment problem");
 647                 sbp->sb_features2 |= sbp->sb_bad_features2;
 648                 mp->m_update_sb = true;
 649
 650                 /*
 651                  * Re-check for ATTR2 in case it was found in bad_features2
 652                  * slot.
 653                  */
 654                 if (xfs_sb_version_hasattr2(&mp->m_sb) &&
 655                    !(mp->m_flags & XFS_MOUNT_NOATTR2))
 656                         mp->m_flags |= XFS_MOUNT_ATTR2;
 657         }
 658
 659         if (xfs_sb_version_hasattr2(&mp->m_sb) &&
 660            (mp->m_flags & XFS_MOUNT_NOATTR2)) {
 661                 xfs_sb_version_removeattr2(&mp->m_sb);
 662                 mp->m_update_sb = true;
 663
 664                 /* update sb_versionnum for the clearing of the morebits */
 665                 if (!sbp->sb_features2)
 666                         mp->m_update_sb = true;
 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_update_sb = true;
 673         }
 674
 675         /*
 676          * Check if sb_agblocks is aligned at stripe boundary
 677          * If sb_agblocks is NOT aligned turn off m_dalign since
 678          * allocator alignment is within an ag, therefore ag has
 679          * to be aligned at stripe boundary.
 680          */
 681         error = xfs_update_alignment(mp);
 682         if (error)
 683                 goto out;
 684
 685         xfs_alloc_compute_maxlevels(mp);
 686         xfs_bmap_compute_maxlevels(mp, XFS_DATA_FORK);
 687         xfs_bmap_compute_maxlevels(mp, XFS_ATTR_FORK);
 688         xfs_ialloc_compute_maxlevels(mp);
 689
 690         xfs_set_maxicount(mp);
 691
 692         error = xfs_sysfs_init(&mp->m_kobj, &xfs_mp_ktype, NULL, mp->m_fsname);
 693         if (error)
 694                 goto out;
 695
 696         error = xfs_uuid_mount(mp);
 697         if (error)
 698                 goto out_remove_sysfs;
 699
 700         /*
 701          * Set the minimum read and write sizes
 702          */
 703         xfs_set_rw_sizes(mp);
 704
 705         /* set the low space thresholds for dynamic preallocation */
 706         xfs_set_low_space_thresholds(mp);
 707
 708         /*
 709          * Set the inode cluster size.
 710          * This may still be overridden by the file system
 711          * block size if it is larger than the chosen cluster size.
 712          *
 713          * For v5 filesystems, scale the cluster size with the inode size to
 714          * keep a constant ratio of inode per cluster buffer, but only if mkfs
 715          * has set the inode alignment value appropriately for larger cluster
 716          * sizes.
 717          */
 718         mp->m_inode_cluster_size = XFS_INODE_BIG_CLUSTER_SIZE;
 719         if (xfs_sb_version_hascrc(&mp->m_sb)) {
 720                 int     new_size = mp->m_inode_cluster_size;
 721
 722                 new_size *= mp->m_sb.sb_inodesize / XFS_DINODE_MIN_SIZE;
 723                 if (mp->m_sb.sb_inoalignmt >= XFS_B_TO_FSBT(mp, new_size))
 724                         mp->m_inode_cluster_size = new_size;
 725         }
 726
 727         /*
 728          * Set inode alignment fields
 729          */
 730         xfs_set_inoalignment(mp);
 731
 732         /*
 733          * Check that the data (and log if separate) is an ok size.
 734          */
 735         error = xfs_check_sizes(mp);
 736         if (error)
 737                 goto out_remove_uuid;
 738
 739         /*
 740          * Initialize realtime fields in the mount structure
 741          */
 742         error = xfs_rtmount_init(mp);
 743         if (error) {
 744                 xfs_warn(mp, "RT mount failed");
 745                 goto out_remove_uuid;
 746         }
 747
 748         /*
 749          *  Copies the low order bits of the timestamp and the randomly
 750          *  set "sequence" number out of a UUID.
 751          */
 752         uuid_getnodeuniq(&sbp->sb_uuid, mp->m_fixedfsid);
 753
 754         mp->m_dmevmask = 0;     /* not persistent; set after each mount */
 755
 756         error = xfs_da_mount(mp);
 757         if (error) {
 758                 xfs_warn(mp, "Failed dir/attr init: %d", error);
 759                 goto out_remove_uuid;
 760         }
 761
 762         /*
 763          * Initialize the precomputed transaction reservations values.
 764          */
 765         xfs_trans_init(mp);
 766
 767         /*
 768          * Allocate and initialize the per-ag data.
 769          */
 770         spin_lock_init(&mp->m_perag_lock);
 771         INIT_RADIX_TREE(&mp->m_perag_tree, GFP_ATOMIC);
 772         error = xfs_initialize_perag(mp, sbp->sb_agcount, &mp->m_maxagi);
 773         if (error) {
 774                 xfs_warn(mp, "Failed per-ag init: %d", error);
 775                 goto out_free_dir;
 776         }
 777
 778         if (!sbp->sb_logblocks) {
 779                 xfs_warn(mp, "no log defined");
 780                 XFS_ERROR_REPORT("xfs_mountfs", XFS_ERRLEVEL_LOW, mp);
 781                 error = -EFSCORRUPTED;
 782                 goto out_free_perag;
 783         }
 784
 785         /*
 786          * log's mount-time initialization. Perform 1st part recovery if needed
 787          */
 788         error = xfs_log_mount(mp, mp->m_logdev_targp,
 789                               XFS_FSB_TO_DADDR(mp, sbp->sb_logstart),
 790                               XFS_FSB_TO_BB(mp, sbp->sb_logblocks));
 791         if (error) {
 792                 xfs_warn(mp, "log mount failed");
 793                 goto out_fail_wait;
 794         }
 795
 796         /*
 797          * Now the log is mounted, we know if it was an unclean shutdown or
 798          * not. If it was, with the first phase of recovery has completed, we
 799          * have consistent AG blocks on disk. We have not recovered EFIs yet,
 800          * but they are recovered transactionally in the second recovery phase
 801          * later.
 802          *
 803          * Hence we can safely re-initialise incore superblock counters from
 804          * the per-ag data. These may not be correct if the filesystem was not
 805          * cleanly unmounted, so we need to wait for recovery to finish before
 806          * doing this.
 807          *
 808          * If the filesystem was cleanly unmounted, then we can trust the
 809          * values in the superblock to be correct and we don't need to do
 810          * anything here.
 811          *
 812          * If we are currently making the filesystem, the initialisation will
 813          * fail as the perag data is in an undefined state.
 814          */
 815         if (xfs_sb_version_haslazysbcount(&mp->m_sb) &&
 816             !XFS_LAST_UNMOUNT_WAS_CLEAN(mp) &&
 817              !mp->m_sb.sb_inprogress) {
 818                 error = xfs_initialize_perag_data(mp, sbp->sb_agcount);
 819                 if (error)
 820                         goto out_log_dealloc;
 821         }
 822
 823         /*
 824          * Get and sanity-check the root inode.
 825          * Save the pointer to it in the mount structure.
 826          */
 827         error = xfs_iget(mp, NULL, sbp->sb_rootino, 0, XFS_ILOCK_EXCL, &rip);
 828         if (error) {
 829                 xfs_warn(mp, "failed to read root inode");
 830                 goto out_log_dealloc;
 831         }
 832
 833         ASSERT(rip != NULL);
 834
 835         if (unlikely(!S_ISDIR(rip->i_d.di_mode))) {
 836                 xfs_warn(mp, "corrupted root inode %llu: not a directory",
 837                         (unsigned long long)rip->i_ino);
 838                 xfs_iunlock(rip, XFS_ILOCK_EXCL);
 839                 XFS_ERROR_REPORT("xfs_mountfs_int(2)", XFS_ERRLEVEL_LOW,
 840                                  mp);
 841                 error = -EFSCORRUPTED;
 842                 goto out_rele_rip;
 843         }
 844         mp->m_rootip = rip;     /* save it */
 845
 846         xfs_iunlock(rip, XFS_ILOCK_EXCL);
 847
 848         /*
 849          * Initialize realtime inode pointers in the mount structure
 850          */
 851         error = xfs_rtmount_inodes(mp);
 852         if (error) {
 853                 /*
 854                  * Free up the root inode.
 855                  */
 856                 xfs_warn(mp, "failed to read RT inodes");
 857                 goto out_rele_rip;
 858         }
 859
 860         /*
 861          * If this is a read-only mount defer the superblock updates until
 862          * the next remount into writeable mode.  Otherwise we would never
 863          * perform the update e.g. for the root filesystem.
 864          */
 865         if (mp->m_update_sb && !(mp->m_flags & XFS_MOUNT_RDONLY)) {
 866                 error = xfs_sync_sb(mp, false);
 867                 if (error) {
 868                         xfs_warn(mp, "failed to write sb changes");
 869                         goto out_rtunmount;
 870                 }
 871         }
 872
 873         /*
 874          * Initialise the XFS quota management subsystem for this mount
 875          */
 876         if (XFS_IS_QUOTA_RUNNING(mp)) {
 877                 error = xfs_qm_newmount(mp, &quotamount, &quotaflags);
 878                 if (error)
 879                         goto out_rtunmount;
 880         } else {
 881                 ASSERT(!XFS_IS_QUOTA_ON(mp));
 882
 883                 /*
 884                  * If a file system had quotas running earlier, but decided to
 885                  * mount without -o uquota/pquota/gquota options, revoke the
 886                  * quotachecked license.
 887                  */
 888                 if (mp->m_sb.sb_qflags & XFS_ALL_QUOTA_ACCT) {
 889                         xfs_notice(mp, "resetting quota flags");
 890                         error = xfs_mount_reset_sbqflags(mp);
 891                         if (error)
 892                                 goto out_rtunmount;
 893                 }
 894         }
 895
 896         /*
 897          * Finish recovering the file system.  This part needed to be
 898          * delayed until after the root and real-time bitmap inodes
 899          * were consistently read in.
 900          */
 901         error = xfs_log_mount_finish(mp);
 902         if (error) {
 903                 xfs_warn(mp, "log mount finish failed");
 904                 goto out_rtunmount;
 905         }
 906
 907         /*
 908          * Complete the quota initialisation, post-log-replay component.
 909          */
 910         if (quotamount) {
 911                 ASSERT(mp->m_qflags == 0);
 912                 mp->m_qflags = quotaflags;
 913
 914                 xfs_qm_mount_quotas(mp);
 915         }
 916
 917         /*
 918          * Now we are mounted, reserve a small amount of unused space for
 919          * privileged transactions. This is needed so that transaction
 920          * space required for critical operations can dip into this pool
 921          * when at ENOSPC. This is needed for operations like create with
 922          * attr, unwritten extent conversion at ENOSPC, etc. Data allocations
 923          * are not allowed to use this reserved space.
 924          *
 925          * This may drive us straight to ENOSPC on mount, but that implies
 926          * we were already there on the last unmount. Warn if this occurs.
 927          */
 928         if (!(mp->m_flags & XFS_MOUNT_RDONLY)) {
 929                 resblks = xfs_default_resblks(mp);
 930                 error = xfs_reserve_blocks(mp, &resblks, NULL);
 931                 if (error)
 932                         xfs_warn(mp,
 933         "Unable to allocate reserve blocks. Continuing without reserve pool.");
 934         }
 935
 936         return 0;
 937
 938  out_rtunmount:
 939         xfs_rtunmount_inodes(mp);
 940  out_rele_rip:
 941         IRELE(rip);
 942  out_log_dealloc:
 943         xfs_log_unmount(mp);
 944  out_fail_wait:
 945         if (mp->m_logdev_targp && mp->m_logdev_targp != mp->m_ddev_targp)
 946                 xfs_wait_buftarg(mp->m_logdev_targp);
 947         xfs_wait_buftarg(mp->m_ddev_targp);
 948  out_free_perag:
 949         xfs_free_perag(mp);
 950  out_free_dir:
 951         xfs_da_unmount(mp);
 952  out_remove_uuid:
 953         xfs_uuid_unmount(mp);
 954  out_remove_sysfs:
 955         xfs_sysfs_del(&mp->m_kobj);
 956  out:
 957         return error;
 958 }
 959
 960 /*
 961  * This flushes out the inodes,dquots and the superblock, unmounts the
 962  * log and makes sure that incore structures are freed.
 963  */
 964 void
 965 xfs_unmountfs(
 966         struct xfs_mount        *mp)
 967 {
 968         __uint64_t              resblks;
 969         int                     error;
 970
 971         cancel_delayed_work_sync(&mp->m_eofblocks_work);
 972
 973         xfs_qm_unmount_quotas(mp);
 974         xfs_rtunmount_inodes(mp);
 975         IRELE(mp->m_rootip);
 976
 977         /*
 978          * We can potentially deadlock here if we have an inode cluster
 979          * that has been freed has its buffer still pinned in memory because
 980          * the transaction is still sitting in a iclog. The stale inodes
 981          * on that buffer will have their flush locks held until the
 982          * transaction hits the disk and the callbacks run. the inode
 983          * flush takes the flush lock unconditionally and with nothing to
 984          * push out the iclog we will never get that unlocked. hence we
 985          * need to force the log first.
 986          */
 987         xfs_log_force(mp, XFS_LOG_SYNC);
 988
 989         /*
 990          * Flush all pending changes from the AIL.
 991          */
 992         xfs_ail_push_all_sync(mp->m_ail);
 993
 994         /*
 995          * And reclaim all inodes.  At this point there should be no dirty
 996          * inodes and none should be pinned or locked, but use synchronous
 997          * reclaim just to be sure. We can stop background inode reclaim
 998          * here as well if it is still running.
 999          */
1000         cancel_delayed_work_sync(&mp->m_reclaim_work);
1001         xfs_reclaim_inodes(mp, SYNC_WAIT);
1002
1003         xfs_qm_unmount(mp);
1004
1005         /*
1006          * Unreserve any blocks we have so that when we unmount we don't account
1007          * the reserved free space as used. This is really only necessary for
1008          * lazy superblock counting because it trusts the incore superblock
1009          * counters to be absolutely correct on clean unmount.
1010          *
1011          * We don't bother correcting this elsewhere for lazy superblock
1012          * counting because on mount of an unclean filesystem we reconstruct the
1013          * correct counter value and this is irrelevant.
1014          *
1015          * For non-lazy counter filesystems, this doesn't matter at all because
1016          * we only every apply deltas to the superblock and hence the incore
1017          * value does not matter....
1018          */
1019         resblks = 0;
1020         error = xfs_reserve_blocks(mp, &resblks, NULL);
1021         if (error)
1022                 xfs_warn(mp, "Unable to free reserved block pool. "
1023                                 "Freespace may not be correct on next mount.");
1024
1025         error = xfs_log_sbcount(mp);
1026         if (error)
1027                 xfs_warn(mp, "Unable to update superblock counters. "
1028                                 "Freespace may not be correct on next mount.");
1029
1030         xfs_log_unmount(mp);
1031         xfs_da_unmount(mp);
1032         xfs_uuid_unmount(mp);
1033
1034 #if defined(DEBUG)
1035         xfs_errortag_clearall(mp, 0);
1036 #endif
1037         xfs_free_perag(mp);
1038
1039         xfs_sysfs_del(&mp->m_kobj);
1040 }
1041
1042 /*
1043  * Determine whether modifications can proceed. The caller specifies the minimum
1044  * freeze level for which modifications should not be allowed. This allows
1045  * certain operations to proceed while the freeze sequence is in progress, if
1046  * necessary.
1047  */
1048 bool
1049 xfs_fs_writable(
1050         struct xfs_mount        *mp,
1051         int                     level)
1052 {
1053         ASSERT(level > SB_UNFROZEN);
1054         if ((mp->m_super->s_writers.frozen >= level) ||
1055             XFS_FORCED_SHUTDOWN(mp) || (mp->m_flags & XFS_MOUNT_RDONLY))
1056                 return false;
1057
1058         return true;
1059 }
1060
1061 /*
1062  * xfs_log_sbcount
1063  *
1064  * Sync the superblock counters to disk.
1065  *
1066  * Note this code can be called during the process of freezing, so we use the
1067  * transaction allocator that does not block when the transaction subsystem is
1068  * in its frozen state.
1069  */
1070 int
1071 xfs_log_sbcount(xfs_mount_t *mp)
1072 {
1073         /* allow this to proceed during the freeze sequence... */
1074         if (!xfs_fs_writable(mp, SB_FREEZE_COMPLETE))
1075                 return 0;
1076
1077         /*
1078          * we don't need to do this if we are updating the superblock
1079          * counters on every modification.
1080          */
1081         if (!xfs_sb_version_haslazysbcount(&mp->m_sb))
1082                 return 0;
1083
1084         return xfs_sync_sb(mp, true);
1085 }
1086
1087 /*
1088  * Deltas for the inode count are +/-64, hence we use a large batch size
1089  * of 128 so we don't need to take the counter lock on every update.
1090  */
1091 #define XFS_ICOUNT_BATCH        128
1092 int
1093 xfs_mod_icount(
1094         struct xfs_mount        *mp,
1095         int64_t                 delta)
1096 {
1097         __percpu_counter_add(&mp->m_icount, delta, XFS_ICOUNT_BATCH);
1098         if (__percpu_counter_compare(&mp->m_icount, 0, XFS_ICOUNT_BATCH) < 0) {
1099                 ASSERT(0);
1100                 percpu_counter_add(&mp->m_icount, -delta);
1101                 return -EINVAL;
1102         }
1103         return 0;
1104 }
1105
1106 int
1107 xfs_mod_ifree(
1108         struct xfs_mount        *mp,
1109         int64_t                 delta)
1110 {
1111         percpu_counter_add(&mp->m_ifree, delta);
1112         if (percpu_counter_compare(&mp->m_ifree, 0) < 0) {
1113                 ASSERT(0);
1114                 percpu_counter_add(&mp->m_ifree, -delta);
1115                 return -EINVAL;
1116         }
1117         return 0;
1118 }
1119
1120 /*
1121  * Deltas for the block count can vary from 1 to very large, but lock contention
1122  * only occurs on frequent small block count updates such as in the delayed
1123  * allocation path for buffered writes (page a time updates). Hence we set
1124  * a large batch count (1024) to minimise global counter updates except when
1125  * we get near to ENOSPC and we have to be very accurate with our updates.
1126  */
1127 #define XFS_FDBLOCKS_BATCH      1024
1128 int
1129 xfs_mod_fdblocks(
1130         struct xfs_mount        *mp,
1131         int64_t                 delta,
1132         bool                    rsvd)
1133 {
1134         int64_t                 lcounter;
1135         long long               res_used;
1136         s32                     batch;
1137
1138         if (delta > 0) {
1139                 /*
1140                  * If the reserve pool is depleted, put blocks back into it
1141                  * first. Most of the time the pool is full.
1142                  */
1143                 if (likely(mp->m_resblks == mp->m_resblks_avail)) {
1144                         percpu_counter_add(&mp->m_fdblocks, delta);
1145                         return 0;
1146                 }
1147
1148                 spin_lock(&mp->m_sb_lock);
1149                 res_used = (long long)(mp->m_resblks - mp->m_resblks_avail);
1150
1151                 if (res_used > delta) {
1152                         mp->m_resblks_avail += delta;
1153                 } else {
1154                         delta -= res_used;
1155                         mp->m_resblks_avail = mp->m_resblks;
1156                         percpu_counter_add(&mp->m_fdblocks, delta);
1157                 }
1158                 spin_unlock(&mp->m_sb_lock);
1159                 return 0;
1160         }
1161
1162         /*
1163          * Taking blocks away, need to be more accurate the closer we
1164          * are to zero.
1165          *
1166          * If the counter has a value of less than 2 * max batch size,
1167          * then make everything serialise as we are real close to
1168          * ENOSPC.
1169          */
1170         if (__percpu_counter_compare(&mp->m_fdblocks, 2 * XFS_FDBLOCKS_BATCH,
1171                                      XFS_FDBLOCKS_BATCH) < 0)
1172                 batch = 1;
1173         else
1174                 batch = XFS_FDBLOCKS_BATCH;
1175
1176         __percpu_counter_add(&mp->m_fdblocks, delta, batch);
1177         if (__percpu_counter_compare(&mp->m_fdblocks, XFS_ALLOC_SET_ASIDE(mp),
1178                                      XFS_FDBLOCKS_BATCH) >= 0) {
1179                 /* we had space! */
1180                 return 0;
1181         }
1182
1183         /*
1184          * lock up the sb for dipping into reserves before releasing the space
1185          * that took us to ENOSPC.
1186          */
1187         spin_lock(&mp->m_sb_lock);
1188         percpu_counter_add(&mp->m_fdblocks, -delta);
1189         if (!rsvd)
1190                 goto fdblocks_enospc;
1191
1192         lcounter = (long long)mp->m_resblks_avail + delta;
1193         if (lcounter >= 0) {
1194                 mp->m_resblks_avail = lcounter;
1195                 spin_unlock(&mp->m_sb_lock);
1196                 return 0;
1197         }
1198         printk_once(KERN_WARNING
1199                 "Filesystem \"%s\": reserve blocks depleted! "
1200                 "Consider increasing reserve pool size.",
1201                 mp->m_fsname);
1202 fdblocks_enospc:
1203         spin_unlock(&mp->m_sb_lock);
1204         return -ENOSPC;
1205 }
1206
1207 int
1208 xfs_mod_frextents(
1209         struct xfs_mount        *mp,
1210         int64_t                 delta)
1211 {
1212         int64_t                 lcounter;
1213         int                     ret = 0;
1214
1215         spin_lock(&mp->m_sb_lock);
1216         lcounter = mp->m_sb.sb_frextents + delta;
1217         if (lcounter < 0)
1218                 ret = -ENOSPC;
1219         else
1220                 mp->m_sb.sb_frextents = lcounter;
1221         spin_unlock(&mp->m_sb_lock);
1222         return ret;
1223 }
1224
1225 /*
1226  * xfs_getsb() is called to obtain the buffer for the superblock.
1227  * The buffer is returned locked and read in from disk.
1228  * The buffer should be released with a call to xfs_brelse().
1229  *
1230  * If the flags parameter is BUF_TRYLOCK, then we'll only return
1231  * the superblock buffer if it can be locked without sleeping.
1232  * If it can't then we'll return NULL.
1233  */
1234 struct xfs_buf *
1235 xfs_getsb(
1236         struct xfs_mount        *mp,
1237         int                     flags)
1238 {
1239         struct xfs_buf          *bp = mp->m_sb_bp;
1240
1241         if (!xfs_buf_trylock(bp)) {
1242                 if (flags & XBF_TRYLOCK)
1243                         return NULL;
1244                 xfs_buf_lock(bp);
1245         }
1246
1247         xfs_buf_hold(bp);
1248         ASSERT(XFS_BUF_ISDONE(bp));
1249         return bp;
1250 }
1251
1252 /*
1253  * Used to free the superblock along various error paths.
1254  */
1255 void
1256 xfs_freesb(
1257         struct xfs_mount        *mp)
1258 {
1259         struct xfs_buf          *bp = mp->m_sb_bp;
1260
1261         xfs_buf_lock(bp);
1262         mp->m_sb_bp = NULL;
1263         xfs_buf_relse(bp);
1264 }
1265
1266 /*
1267  * If the underlying (data/log/rt) device is readonly, there are some
1268  * operations that cannot proceed.
1269  */
1270 int
1271 xfs_dev_is_read_only(
1272         struct xfs_mount        *mp,
1273         char                    *message)
1274 {
1275         if (xfs_readonly_buftarg(mp->m_ddev_targp) ||
1276             xfs_readonly_buftarg(mp->m_logdev_targp) ||
1277             (mp->m_rtdev_targp && xfs_readonly_buftarg(mp->m_rtdev_targp))) {
1278                 xfs_notice(mp, "%s required on read-only device.", message);
1279                 xfs_notice(mp, "write access unavailable, cannot proceed.");
1280                 return -EROFS;
1281         }
1282         return 0;
1283 }