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