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         struct xfs_mount        *mp)
 619 {
 620         struct xfs_sb           *sbp = &(mp->m_sb);
 621         struct xfs_inode        *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          * If enabled, sparse inode chunk alignment is expected to match the
 729          * cluster size. Full inode chunk alignment must match the chunk size,
 730          * but that is checked on sb read verification...
 731          */
 732         if (xfs_sb_version_hassparseinodes(&mp->m_sb) &&
 733             mp->m_sb.sb_spino_align !=
 734                         XFS_B_TO_FSBT(mp, mp->m_inode_cluster_size)) {
 735                 xfs_warn(mp,
 736         "Sparse inode block alignment (%u) must match cluster size (%llu).",
 737                          mp->m_sb.sb_spino_align,
 738                          XFS_B_TO_FSBT(mp, mp->m_inode_cluster_size));
 739                 error = -EINVAL;
 740                 goto out_remove_uuid;
 741         }
 742
 743         /*
 744          * Set inode alignment fields
 745          */
 746         xfs_set_inoalignment(mp);
 747
 748         /*
 749          * Check that the data (and log if separate) is an ok size.
 750          */
 751         error = xfs_check_sizes(mp);
 752         if (error)
 753                 goto out_remove_uuid;
 754
 755         /*
 756          * Initialize realtime fields in the mount structure
 757          */
 758         error = xfs_rtmount_init(mp);
 759         if (error) {
 760                 xfs_warn(mp, "RT mount failed");
 761                 goto out_remove_uuid;
 762         }
 763
 764         /*
 765          *  Copies the low order bits of the timestamp and the randomly
 766          *  set "sequence" number out of a UUID.
 767          */
 768         uuid_getnodeuniq(&sbp->sb_uuid, mp->m_fixedfsid);
 769
 770         mp->m_dmevmask = 0;     /* not persistent; set after each mount */
 771
 772         error = xfs_da_mount(mp);
 773         if (error) {
 774                 xfs_warn(mp, "Failed dir/attr init: %d", error);
 775                 goto out_remove_uuid;
 776         }
 777
 778         /*
 779          * Initialize the precomputed transaction reservations values.
 780          */
 781         xfs_trans_init(mp);
 782
 783         /*
 784          * Allocate and initialize the per-ag data.
 785          */
 786         spin_lock_init(&mp->m_perag_lock);
 787         INIT_RADIX_TREE(&mp->m_perag_tree, GFP_ATOMIC);
 788         error = xfs_initialize_perag(mp, sbp->sb_agcount, &mp->m_maxagi);
 789         if (error) {
 790                 xfs_warn(mp, "Failed per-ag init: %d", error);
 791                 goto out_free_dir;
 792         }
 793
 794         if (!sbp->sb_logblocks) {
 795                 xfs_warn(mp, "no log defined");
 796                 XFS_ERROR_REPORT("xfs_mountfs", XFS_ERRLEVEL_LOW, mp);
 797                 error = -EFSCORRUPTED;
 798                 goto out_free_perag;
 799         }
 800
 801         /*
 802          * Log's mount-time initialization. The first part of recovery can place
 803          * some items on the AIL, to be handled when recovery is finished or
 804          * cancelled.
 805          */
 806         error = xfs_log_mount(mp, mp->m_logdev_targp,
 807                               XFS_FSB_TO_DADDR(mp, sbp->sb_logstart),
 808                               XFS_FSB_TO_BB(mp, sbp->sb_logblocks));
 809         if (error) {
 810                 xfs_warn(mp, "log mount failed");
 811                 goto out_fail_wait;
 812         }
 813
 814         /*
 815          * Now the log is mounted, we know if it was an unclean shutdown or
 816          * not. If it was, with the first phase of recovery has completed, we
 817          * have consistent AG blocks on disk. We have not recovered EFIs yet,
 818          * but they are recovered transactionally in the second recovery phase
 819          * later.
 820          *
 821          * Hence we can safely re-initialise incore superblock counters from
 822          * the per-ag data. These may not be correct if the filesystem was not
 823          * cleanly unmounted, so we need to wait for recovery to finish before
 824          * doing this.
 825          *
 826          * If the filesystem was cleanly unmounted, then we can trust the
 827          * values in the superblock to be correct and we don't need to do
 828          * anything here.
 829          *
 830          * If we are currently making the filesystem, the initialisation will
 831          * fail as the perag data is in an undefined state.
 832          */
 833         if (xfs_sb_version_haslazysbcount(&mp->m_sb) &&
 834             !XFS_LAST_UNMOUNT_WAS_CLEAN(mp) &&
 835              !mp->m_sb.sb_inprogress) {
 836                 error = xfs_initialize_perag_data(mp, sbp->sb_agcount);
 837                 if (error)
 838                         goto out_log_dealloc;
 839         }
 840
 841         /*
 842          * Get and sanity-check the root inode.
 843          * Save the pointer to it in the mount structure.
 844          */
 845         error = xfs_iget(mp, NULL, sbp->sb_rootino, 0, XFS_ILOCK_EXCL, &rip);
 846         if (error) {
 847                 xfs_warn(mp, "failed to read root inode");
 848                 goto out_log_dealloc;
 849         }
 850
 851         ASSERT(rip != NULL);
 852
 853         if (unlikely(!S_ISDIR(rip->i_d.di_mode))) {
 854                 xfs_warn(mp, "corrupted root inode %llu: not a directory",
 855                         (unsigned long long)rip->i_ino);
 856                 xfs_iunlock(rip, XFS_ILOCK_EXCL);
 857                 XFS_ERROR_REPORT("xfs_mountfs_int(2)", XFS_ERRLEVEL_LOW,
 858                                  mp);
 859                 error = -EFSCORRUPTED;
 860                 goto out_rele_rip;
 861         }
 862         mp->m_rootip = rip;     /* save it */
 863
 864         xfs_iunlock(rip, XFS_ILOCK_EXCL);
 865
 866         /*
 867          * Initialize realtime inode pointers in the mount structure
 868          */
 869         error = xfs_rtmount_inodes(mp);
 870         if (error) {
 871                 /*
 872                  * Free up the root inode.
 873                  */
 874                 xfs_warn(mp, "failed to read RT inodes");
 875                 goto out_rele_rip;
 876         }
 877
 878         /*
 879          * If this is a read-only mount defer the superblock updates until
 880          * the next remount into writeable mode.  Otherwise we would never
 881          * perform the update e.g. for the root filesystem.
 882          */
 883         if (mp->m_update_sb && !(mp->m_flags & XFS_MOUNT_RDONLY)) {
 884                 error = xfs_sync_sb(mp, false);
 885                 if (error) {
 886                         xfs_warn(mp, "failed to write sb changes");
 887                         goto out_rtunmount;
 888                 }
 889         }
 890
 891         /*
 892          * Initialise the XFS quota management subsystem for this mount
 893          */
 894         if (XFS_IS_QUOTA_RUNNING(mp)) {
 895                 error = xfs_qm_newmount(mp, &quotamount, &quotaflags);
 896                 if (error)
 897                         goto out_rtunmount;
 898         } else {
 899                 ASSERT(!XFS_IS_QUOTA_ON(mp));
 900
 901                 /*
 902                  * If a file system had quotas running earlier, but decided to
 903                  * mount without -o uquota/pquota/gquota options, revoke the
 904                  * quotachecked license.
 905                  */
 906                 if (mp->m_sb.sb_qflags & XFS_ALL_QUOTA_ACCT) {
 907                         xfs_notice(mp, "resetting quota flags");
 908                         error = xfs_mount_reset_sbqflags(mp);
 909                         if (error)
 910                                 goto out_rtunmount;
 911                 }
 912         }
 913
 914         /*
 915          * Finish recovering the file system.  This part needed to be delayed
 916          * until after the root and real-time bitmap inodes were consistently
 917          * read in.
 918          */
 919         error = xfs_log_mount_finish(mp);
 920         if (error) {
 921                 xfs_warn(mp, "log mount finish failed");
 922                 goto out_rtunmount;
 923         }
 924
 925         /*
 926          * Complete the quota initialisation, post-log-replay component.
 927          */
 928         if (quotamount) {
 929                 ASSERT(mp->m_qflags == 0);
 930                 mp->m_qflags = quotaflags;
 931
 932                 xfs_qm_mount_quotas(mp);
 933         }
 934
 935         /*
 936          * Now we are mounted, reserve a small amount of unused space for
 937          * privileged transactions. This is needed so that transaction
 938          * space required for critical operations can dip into this pool
 939          * when at ENOSPC. This is needed for operations like create with
 940          * attr, unwritten extent conversion at ENOSPC, etc. Data allocations
 941          * are not allowed to use this reserved space.
 942          *
 943          * This may drive us straight to ENOSPC on mount, but that implies
 944          * we were already there on the last unmount. Warn if this occurs.
 945          */
 946         if (!(mp->m_flags & XFS_MOUNT_RDONLY)) {
 947                 resblks = xfs_default_resblks(mp);
 948                 error = xfs_reserve_blocks(mp, &resblks, NULL);
 949                 if (error)
 950                         xfs_warn(mp,
 951         "Unable to allocate reserve blocks. Continuing without reserve pool.");
 952         }
 953
 954         return 0;
 955
 956  out_rtunmount:
 957         xfs_rtunmount_inodes(mp);
 958  out_rele_rip:
 959         IRELE(rip);
 960         cancel_delayed_work_sync(&mp->m_reclaim_work);
 961         xfs_reclaim_inodes(mp, SYNC_WAIT);
 962  out_log_dealloc:
 963         xfs_log_mount_cancel(mp);
 964  out_fail_wait:
 965         if (mp->m_logdev_targp && mp->m_logdev_targp != mp->m_ddev_targp)
 966                 xfs_wait_buftarg(mp->m_logdev_targp);
 967         xfs_wait_buftarg(mp->m_ddev_targp);
 968  out_free_perag:
 969         xfs_free_perag(mp);
 970  out_free_dir:
 971         xfs_da_unmount(mp);
 972  out_remove_uuid:
 973         xfs_uuid_unmount(mp);
 974  out_remove_sysfs:
 975         xfs_sysfs_del(&mp->m_kobj);
 976  out:
 977         return error;
 978 }
 979
 980 /*
 981  * This flushes out the inodes,dquots and the superblock, unmounts the
 982  * log and makes sure that incore structures are freed.
 983  */
 984 void
 985 xfs_unmountfs(
 986         struct xfs_mount        *mp)
 987 {
 988         __uint64_t              resblks;
 989         int                     error;
 990
 991         cancel_delayed_work_sync(&mp->m_eofblocks_work);
 992
 993         xfs_qm_unmount_quotas(mp);
 994         xfs_rtunmount_inodes(mp);
 995         IRELE(mp->m_rootip);
 996
 997         /*
 998          * We can potentially deadlock here if we have an inode cluster
 999          * that has been freed has its buffer still pinned in memory because
1000          * the transaction is still sitting in a iclog. The stale inodes
1001          * on that buffer will have their flush locks held until the
1002          * transaction hits the disk and the callbacks run. the inode
1003          * flush takes the flush lock unconditionally and with nothing to
1004          * push out the iclog we will never get that unlocked. hence we
1005          * need to force the log first.
1006          */
1007         xfs_log_force(mp, XFS_LOG_SYNC);
1008
1009         /*
1010          * Flush all pending changes from the AIL.
1011          */
1012         xfs_ail_push_all_sync(mp->m_ail);
1013
1014         /*
1015          * And reclaim all inodes.  At this point there should be no dirty
1016          * inodes and none should be pinned or locked, but use synchronous
1017          * reclaim just to be sure. We can stop background inode reclaim
1018          * here as well if it is still running.
1019          */
1020         cancel_delayed_work_sync(&mp->m_reclaim_work);
1021         xfs_reclaim_inodes(mp, SYNC_WAIT);
1022
1023         xfs_qm_unmount(mp);
1024
1025         /*
1026          * Unreserve any blocks we have so that when we unmount we don't account
1027          * the reserved free space as used. This is really only necessary for
1028          * lazy superblock counting because it trusts the incore superblock
1029          * counters to be absolutely correct on clean unmount.
1030          *
1031          * We don't bother correcting this elsewhere for lazy superblock
1032          * counting because on mount of an unclean filesystem we reconstruct the
1033          * correct counter value and this is irrelevant.
1034          *
1035          * For non-lazy counter filesystems, this doesn't matter at all because
1036          * we only every apply deltas to the superblock and hence the incore
1037          * value does not matter....
1038          */
1039         resblks = 0;
1040         error = xfs_reserve_blocks(mp, &resblks, NULL);
1041         if (error)
1042                 xfs_warn(mp, "Unable to free reserved block pool. "
1043                                 "Freespace may not be correct on next mount.");
1044
1045         error = xfs_log_sbcount(mp);
1046         if (error)
1047                 xfs_warn(mp, "Unable to update superblock counters. "
1048                                 "Freespace may not be correct on next mount.");
1049
1050         xfs_log_unmount(mp);
1051         xfs_da_unmount(mp);
1052         xfs_uuid_unmount(mp);
1053
1054 #if defined(DEBUG)
1055         xfs_errortag_clearall(mp, 0);
1056 #endif
1057         xfs_free_perag(mp);
1058
1059         xfs_sysfs_del(&mp->m_kobj);
1060 }
1061
1062 /*
1063  * Determine whether modifications can proceed. The caller specifies the minimum
1064  * freeze level for which modifications should not be allowed. This allows
1065  * certain operations to proceed while the freeze sequence is in progress, if
1066  * necessary.
1067  */
1068 bool
1069 xfs_fs_writable(
1070         struct xfs_mount        *mp,
1071         int                     level)
1072 {
1073         ASSERT(level > SB_UNFROZEN);
1074         if ((mp->m_super->s_writers.frozen >= level) ||
1075             XFS_FORCED_SHUTDOWN(mp) || (mp->m_flags & XFS_MOUNT_RDONLY))
1076                 return false;
1077
1078         return true;
1079 }
1080
1081 /*
1082  * xfs_log_sbcount
1083  *
1084  * Sync the superblock counters to disk.
1085  *
1086  * Note this code can be called during the process of freezing, so we use the
1087  * transaction allocator that does not block when the transaction subsystem is
1088  * in its frozen state.
1089  */
1090 int
1091 xfs_log_sbcount(xfs_mount_t *mp)
1092 {
1093         /* allow this to proceed during the freeze sequence... */
1094         if (!xfs_fs_writable(mp, SB_FREEZE_COMPLETE))
1095                 return 0;
1096
1097         /*
1098          * we don't need to do this if we are updating the superblock
1099          * counters on every modification.
1100          */
1101         if (!xfs_sb_version_haslazysbcount(&mp->m_sb))
1102                 return 0;
1103
1104         return xfs_sync_sb(mp, true);
1105 }
1106
1107 /*
1108  * Deltas for the inode count are +/-64, hence we use a large batch size
1109  * of 128 so we don't need to take the counter lock on every update.
1110  */
1111 #define XFS_ICOUNT_BATCH        128
1112 int
1113 xfs_mod_icount(
1114         struct xfs_mount        *mp,
1115         int64_t                 delta)
1116 {
1117         __percpu_counter_add(&mp->m_icount, delta, XFS_ICOUNT_BATCH);
1118         if (__percpu_counter_compare(&mp->m_icount, 0, XFS_ICOUNT_BATCH) < 0) {
1119                 ASSERT(0);
1120                 percpu_counter_add(&mp->m_icount, -delta);
1121                 return -EINVAL;
1122         }
1123         return 0;
1124 }
1125
1126 int
1127 xfs_mod_ifree(
1128         struct xfs_mount        *mp,
1129         int64_t                 delta)
1130 {
1131         percpu_counter_add(&mp->m_ifree, delta);
1132         if (percpu_counter_compare(&mp->m_ifree, 0) < 0) {
1133                 ASSERT(0);
1134                 percpu_counter_add(&mp->m_ifree, -delta);
1135                 return -EINVAL;
1136         }
1137         return 0;
1138 }
1139
1140 /*
1141  * Deltas for the block count can vary from 1 to very large, but lock contention
1142  * only occurs on frequent small block count updates such as in the delayed
1143  * allocation path for buffered writes (page a time updates). Hence we set
1144  * a large batch count (1024) to minimise global counter updates except when
1145  * we get near to ENOSPC and we have to be very accurate with our updates.
1146  */
1147 #define XFS_FDBLOCKS_BATCH      1024
1148 int
1149 xfs_mod_fdblocks(
1150         struct xfs_mount        *mp,
1151         int64_t                 delta,
1152         bool                    rsvd)
1153 {
1154         int64_t                 lcounter;
1155         long long               res_used;
1156         s32                     batch;
1157
1158         if (delta > 0) {
1159                 /*
1160                  * If the reserve pool is depleted, put blocks back into it
1161                  * first. Most of the time the pool is full.
1162                  */
1163                 if (likely(mp->m_resblks == mp->m_resblks_avail)) {
1164                         percpu_counter_add(&mp->m_fdblocks, delta);
1165                         return 0;
1166                 }
1167
1168                 spin_lock(&mp->m_sb_lock);
1169                 res_used = (long long)(mp->m_resblks - mp->m_resblks_avail);
1170
1171                 if (res_used > delta) {
1172                         mp->m_resblks_avail += delta;
1173                 } else {
1174                         delta -= res_used;
1175                         mp->m_resblks_avail = mp->m_resblks;
1176                         percpu_counter_add(&mp->m_fdblocks, delta);
1177                 }
1178                 spin_unlock(&mp->m_sb_lock);
1179                 return 0;
1180         }
1181
1182         /*
1183          * Taking blocks away, need to be more accurate the closer we
1184          * are to zero.
1185          *
1186          * If the counter has a value of less than 2 * max batch size,
1187          * then make everything serialise as we are real close to
1188          * ENOSPC.
1189          */
1190         if (__percpu_counter_compare(&mp->m_fdblocks, 2 * XFS_FDBLOCKS_BATCH,
1191                                      XFS_FDBLOCKS_BATCH) < 0)
1192                 batch = 1;
1193         else
1194                 batch = XFS_FDBLOCKS_BATCH;
1195
1196         __percpu_counter_add(&mp->m_fdblocks, delta, batch);
1197         if (__percpu_counter_compare(&mp->m_fdblocks, XFS_ALLOC_SET_ASIDE(mp),
1198                                      XFS_FDBLOCKS_BATCH) >= 0) {
1199                 /* we had space! */
1200                 return 0;
1201         }
1202
1203         /*
1204          * lock up the sb for dipping into reserves before releasing the space
1205          * that took us to ENOSPC.
1206          */
1207         spin_lock(&mp->m_sb_lock);
1208         percpu_counter_add(&mp->m_fdblocks, -delta);
1209         if (!rsvd)
1210                 goto fdblocks_enospc;
1211
1212         lcounter = (long long)mp->m_resblks_avail + delta;
1213         if (lcounter >= 0) {
1214                 mp->m_resblks_avail = lcounter;
1215                 spin_unlock(&mp->m_sb_lock);
1216                 return 0;
1217         }
1218         printk_once(KERN_WARNING
1219                 "Filesystem \"%s\": reserve blocks depleted! "
1220                 "Consider increasing reserve pool size.",
1221                 mp->m_fsname);
1222 fdblocks_enospc:
1223         spin_unlock(&mp->m_sb_lock);
1224         return -ENOSPC;
1225 }
1226
1227 int
1228 xfs_mod_frextents(
1229         struct xfs_mount        *mp,
1230         int64_t                 delta)
1231 {
1232         int64_t                 lcounter;
1233         int                     ret = 0;
1234
1235         spin_lock(&mp->m_sb_lock);
1236         lcounter = mp->m_sb.sb_frextents + delta;
1237         if (lcounter < 0)
1238                 ret = -ENOSPC;
1239         else
1240                 mp->m_sb.sb_frextents = lcounter;
1241         spin_unlock(&mp->m_sb_lock);
1242         return ret;
1243 }
1244
1245 /*
1246  * xfs_getsb() is called to obtain the buffer for the superblock.
1247  * The buffer is returned locked and read in from disk.
1248  * The buffer should be released with a call to xfs_brelse().
1249  *
1250  * If the flags parameter is BUF_TRYLOCK, then we'll only return
1251  * the superblock buffer if it can be locked without sleeping.
1252  * If it can't then we'll return NULL.
1253  */
1254 struct xfs_buf *
1255 xfs_getsb(
1256         struct xfs_mount        *mp,
1257         int                     flags)
1258 {
1259         struct xfs_buf          *bp = mp->m_sb_bp;
1260
1261         if (!xfs_buf_trylock(bp)) {
1262                 if (flags & XBF_TRYLOCK)
1263                         return NULL;
1264                 xfs_buf_lock(bp);
1265         }
1266
1267         xfs_buf_hold(bp);
1268         ASSERT(XFS_BUF_ISDONE(bp));
1269         return bp;
1270 }
1271
1272 /*
1273  * Used to free the superblock along various error paths.
1274  */
1275 void
1276 xfs_freesb(
1277         struct xfs_mount        *mp)
1278 {
1279         struct xfs_buf          *bp = mp->m_sb_bp;
1280
1281         xfs_buf_lock(bp);
1282         mp->m_sb_bp = NULL;
1283         xfs_buf_relse(bp);
1284 }
1285
1286 /*
1287  * If the underlying (data/log/rt) device is readonly, there are some
1288  * operations that cannot proceed.
1289  */
1290 int
1291 xfs_dev_is_read_only(
1292         struct xfs_mount        *mp,
1293         char                    *message)
1294 {
1295         if (xfs_readonly_buftarg(mp->m_ddev_targp) ||
1296             xfs_readonly_buftarg(mp->m_logdev_targp) ||
1297             (mp->m_rtdev_targp && xfs_readonly_buftarg(mp->m_rtdev_targp))) {
1298                 xfs_notice(mp, "%s required on read-only device.", message);
1299                 xfs_notice(mp, "write access unavailable, cannot proceed.");
1300                 return -EROFS;
1301         }
1302         return 0;
1303 }