fs/xfs/xfs_super.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (c) 2000-2006 Silicon Graphics, Inc.
   4  * All Rights Reserved.
   5  */
   6
   7 #include "xfs.h"
   8 #include "xfs_shared.h"
   9 #include "xfs_format.h"
  10 #include "xfs_log_format.h"
  11 #include "xfs_trans_resv.h"
  12 #include "xfs_sb.h"
  13 #include "xfs_mount.h"
  14 #include "xfs_inode.h"
  15 #include "xfs_btree.h"
  16 #include "xfs_bmap.h"
  17 #include "xfs_alloc.h"
  18 #include "xfs_fsops.h"
  19 #include "xfs_trans.h"
  20 #include "xfs_buf_item.h"
  21 #include "xfs_log.h"
  22 #include "xfs_log_priv.h"
  23 #include "xfs_dir2.h"
  24 #include "xfs_extfree_item.h"
  25 #include "xfs_mru_cache.h"
  26 #include "xfs_inode_item.h"
  27 #include "xfs_icache.h"
  28 #include "xfs_trace.h"
  29 #include "xfs_icreate_item.h"
  30 #include "xfs_filestream.h"
  31 #include "xfs_quota.h"
  32 #include "xfs_sysfs.h"
  33 #include "xfs_ondisk.h"
  34 #include "xfs_rmap_item.h"
  35 #include "xfs_refcount_item.h"
  36 #include "xfs_bmap_item.h"
  37 #include "xfs_reflink.h"
  38
  39 #include <linux/magic.h>
  40 #include <linux/fs_context.h>
  41 #include <linux/fs_parser.h>
  42
  43 static const struct super_operations xfs_super_operations;
  44
  45 static struct kset *xfs_kset;           /* top-level xfs sysfs dir */
  46 #ifdef DEBUG
  47 static struct xfs_kobj xfs_dbg_kobj;    /* global debug sysfs attrs */
  48 #endif
  49
  50 /*
  51  * Table driven mount option parser.
  52  */
  53 enum {
  54         Opt_logbufs, Opt_logbsize, Opt_logdev, Opt_rtdev,
  55         Opt_wsync, Opt_noalign, Opt_swalloc, Opt_sunit, Opt_swidth, Opt_nouuid,
  56         Opt_grpid, Opt_nogrpid, Opt_bsdgroups, Opt_sysvgroups,
  57         Opt_allocsize, Opt_norecovery, Opt_inode64, Opt_inode32, Opt_ikeep,
  58         Opt_noikeep, Opt_largeio, Opt_nolargeio, Opt_attr2, Opt_noattr2,
  59         Opt_filestreams, Opt_quota, Opt_noquota, Opt_usrquota, Opt_grpquota,
  60         Opt_prjquota, Opt_uquota, Opt_gquota, Opt_pquota,
  61         Opt_uqnoenforce, Opt_gqnoenforce, Opt_pqnoenforce, Opt_qnoenforce,
  62         Opt_discard, Opt_nodiscard, Opt_dax,
  63 };
  64
  65 static const struct fs_parameter_spec xfs_fs_parameters[] = {
  66         fsparam_u32("logbufs",          Opt_logbufs),
  67         fsparam_string("logbsize",      Opt_logbsize),
  68         fsparam_string("logdev",        Opt_logdev),
  69         fsparam_string("rtdev",         Opt_rtdev),
  70         fsparam_flag("wsync",           Opt_wsync),
  71         fsparam_flag("noalign",         Opt_noalign),
  72         fsparam_flag("swalloc",         Opt_swalloc),
  73         fsparam_u32("sunit",            Opt_sunit),
  74         fsparam_u32("swidth",           Opt_swidth),
  75         fsparam_flag("nouuid",          Opt_nouuid),
  76         fsparam_flag("grpid",           Opt_grpid),
  77         fsparam_flag("nogrpid",         Opt_nogrpid),
  78         fsparam_flag("bsdgroups",       Opt_bsdgroups),
  79         fsparam_flag("sysvgroups",      Opt_sysvgroups),
  80         fsparam_string("allocsize",     Opt_allocsize),
  81         fsparam_flag("norecovery",      Opt_norecovery),
  82         fsparam_flag("inode64",         Opt_inode64),
  83         fsparam_flag("inode32",         Opt_inode32),
  84         fsparam_flag("ikeep",           Opt_ikeep),
  85         fsparam_flag("noikeep",         Opt_noikeep),
  86         fsparam_flag("largeio",         Opt_largeio),
  87         fsparam_flag("nolargeio",       Opt_nolargeio),
  88         fsparam_flag("attr2",           Opt_attr2),
  89         fsparam_flag("noattr2",         Opt_noattr2),
  90         fsparam_flag("filestreams",     Opt_filestreams),
  91         fsparam_flag("quota",           Opt_quota),
  92         fsparam_flag("noquota",         Opt_noquota),
  93         fsparam_flag("usrquota",        Opt_usrquota),
  94         fsparam_flag("grpquota",        Opt_grpquota),
  95         fsparam_flag("prjquota",        Opt_prjquota),
  96         fsparam_flag("uquota",          Opt_uquota),
  97         fsparam_flag("gquota",          Opt_gquota),
  98         fsparam_flag("pquota",          Opt_pquota),
  99         fsparam_flag("uqnoenforce",     Opt_uqnoenforce),
 100         fsparam_flag("gqnoenforce",     Opt_gqnoenforce),
 101         fsparam_flag("pqnoenforce",     Opt_pqnoenforce),
 102         fsparam_flag("qnoenforce",      Opt_qnoenforce),
 103         fsparam_flag("discard",         Opt_discard),
 104         fsparam_flag("nodiscard",       Opt_nodiscard),
 105         fsparam_flag("dax",             Opt_dax),
 106         {}
 107 };
 108
 109 struct proc_xfs_info {
 110         uint64_t        flag;
 111         char            *str;
 112 };
 113
 114 static int
 115 xfs_fs_show_options(
 116         struct seq_file         *m,
 117         struct dentry           *root)
 118 {
 119         static struct proc_xfs_info xfs_info_set[] = {
 120                 /* the few simple ones we can get from the mount struct */
 121                 { XFS_MOUNT_IKEEP,              ",ikeep" },
 122                 { XFS_MOUNT_WSYNC,              ",wsync" },
 123                 { XFS_MOUNT_NOALIGN,            ",noalign" },
 124                 { XFS_MOUNT_SWALLOC,            ",swalloc" },
 125                 { XFS_MOUNT_NOUUID,             ",nouuid" },
 126                 { XFS_MOUNT_NORECOVERY,         ",norecovery" },
 127                 { XFS_MOUNT_ATTR2,              ",attr2" },
 128                 { XFS_MOUNT_FILESTREAMS,        ",filestreams" },
 129                 { XFS_MOUNT_GRPID,              ",grpid" },
 130                 { XFS_MOUNT_DISCARD,            ",discard" },
 131                 { XFS_MOUNT_LARGEIO,            ",largeio" },
 132                 { XFS_MOUNT_DAX,                ",dax" },
 133                 { 0, NULL }
 134         };
 135         struct xfs_mount        *mp = XFS_M(root->d_sb);
 136         struct proc_xfs_info    *xfs_infop;
 137
 138         for (xfs_infop = xfs_info_set; xfs_infop->flag; xfs_infop++) {
 139                 if (mp->m_flags & xfs_infop->flag)
 140                         seq_puts(m, xfs_infop->str);
 141         }
 142
 143         seq_printf(m, ",inode%d",
 144                 (mp->m_flags & XFS_MOUNT_SMALL_INUMS) ? 32 : 64);
 145
 146         if (mp->m_flags & XFS_MOUNT_ALLOCSIZE)
 147                 seq_printf(m, ",allocsize=%dk",
 148                            (1 << mp->m_allocsize_log) >> 10);
 149
 150         if (mp->m_logbufs > 0)
 151                 seq_printf(m, ",logbufs=%d", mp->m_logbufs);
 152         if (mp->m_logbsize > 0)
 153                 seq_printf(m, ",logbsize=%dk", mp->m_logbsize >> 10);
 154
 155         if (mp->m_logname)
 156                 seq_show_option(m, "logdev", mp->m_logname);
 157         if (mp->m_rtname)
 158                 seq_show_option(m, "rtdev", mp->m_rtname);
 159
 160         if (mp->m_dalign > 0)
 161                 seq_printf(m, ",sunit=%d",
 162                                 (int)XFS_FSB_TO_BB(mp, mp->m_dalign));
 163         if (mp->m_swidth > 0)
 164                 seq_printf(m, ",swidth=%d",
 165                                 (int)XFS_FSB_TO_BB(mp, mp->m_swidth));
 166
 167         if (mp->m_qflags & (XFS_UQUOTA_ACCT|XFS_UQUOTA_ENFD))
 168                 seq_puts(m, ",usrquota");
 169         else if (mp->m_qflags & XFS_UQUOTA_ACCT)
 170                 seq_puts(m, ",uqnoenforce");
 171
 172         if (mp->m_qflags & XFS_PQUOTA_ACCT) {
 173                 if (mp->m_qflags & XFS_PQUOTA_ENFD)
 174                         seq_puts(m, ",prjquota");
 175                 else
 176                         seq_puts(m, ",pqnoenforce");
 177         }
 178         if (mp->m_qflags & XFS_GQUOTA_ACCT) {
 179                 if (mp->m_qflags & XFS_GQUOTA_ENFD)
 180                         seq_puts(m, ",grpquota");
 181                 else
 182                         seq_puts(m, ",gqnoenforce");
 183         }
 184
 185         if (!(mp->m_qflags & XFS_ALL_QUOTA_ACCT))
 186                 seq_puts(m, ",noquota");
 187
 188         return 0;
 189 }
 190
 191 /*
 192  * Set parameters for inode allocation heuristics, taking into account
 193  * filesystem size and inode32/inode64 mount options; i.e. specifically
 194  * whether or not XFS_MOUNT_SMALL_INUMS is set.
 195  *
 196  * Inode allocation patterns are altered only if inode32 is requested
 197  * (XFS_MOUNT_SMALL_INUMS), and the filesystem is sufficiently large.
 198  * If altered, XFS_MOUNT_32BITINODES is set as well.
 199  *
 200  * An agcount independent of that in the mount structure is provided
 201  * because in the growfs case, mp->m_sb.sb_agcount is not yet updated
 202  * to the potentially higher ag count.
 203  *
 204  * Returns the maximum AG index which may contain inodes.
 205  */
 206 xfs_agnumber_t
 207 xfs_set_inode_alloc(
 208         struct xfs_mount *mp,
 209         xfs_agnumber_t  agcount)
 210 {
 211         xfs_agnumber_t  index;
 212         xfs_agnumber_t  maxagi = 0;
 213         xfs_sb_t        *sbp = &mp->m_sb;
 214         xfs_agnumber_t  max_metadata;
 215         xfs_agino_t     agino;
 216         xfs_ino_t       ino;
 217
 218         /*
 219          * Calculate how much should be reserved for inodes to meet
 220          * the max inode percentage.  Used only for inode32.
 221          */
 222         if (M_IGEO(mp)->maxicount) {
 223                 uint64_t        icount;
 224
 225                 icount = sbp->sb_dblocks * sbp->sb_imax_pct;
 226                 do_div(icount, 100);
 227                 icount += sbp->sb_agblocks - 1;
 228                 do_div(icount, sbp->sb_agblocks);
 229                 max_metadata = icount;
 230         } else {
 231                 max_metadata = agcount;
 232         }
 233
 234         /* Get the last possible inode in the filesystem */
 235         agino = XFS_AGB_TO_AGINO(mp, sbp->sb_agblocks - 1);
 236         ino = XFS_AGINO_TO_INO(mp, agcount - 1, agino);
 237
 238         /*
 239          * If user asked for no more than 32-bit inodes, and the fs is
 240          * sufficiently large, set XFS_MOUNT_32BITINODES if we must alter
 241          * the allocator to accommodate the request.
 242          */
 243         if ((mp->m_flags & XFS_MOUNT_SMALL_INUMS) && ino > XFS_MAXINUMBER_32)
 244                 mp->m_flags |= XFS_MOUNT_32BITINODES;
 245         else
 246                 mp->m_flags &= ~XFS_MOUNT_32BITINODES;
 247
 248         for (index = 0; index < agcount; index++) {
 249                 struct xfs_perag        *pag;
 250
 251                 ino = XFS_AGINO_TO_INO(mp, index, agino);
 252
 253                 pag = xfs_perag_get(mp, index);
 254
 255                 if (mp->m_flags & XFS_MOUNT_32BITINODES) {
 256                         if (ino > XFS_MAXINUMBER_32) {
 257                                 pag->pagi_inodeok = 0;
 258                                 pag->pagf_metadata = 0;
 259                         } else {
 260                                 pag->pagi_inodeok = 1;
 261                                 maxagi++;
 262                                 if (index < max_metadata)
 263                                         pag->pagf_metadata = 1;
 264                                 else
 265                                         pag->pagf_metadata = 0;
 266                         }
 267                 } else {
 268                         pag->pagi_inodeok = 1;
 269                         pag->pagf_metadata = 0;
 270                 }
 271
 272                 xfs_perag_put(pag);
 273         }
 274
 275         return (mp->m_flags & XFS_MOUNT_32BITINODES) ? maxagi : agcount;
 276 }
 277
 278 STATIC int
 279 xfs_blkdev_get(
 280         xfs_mount_t             *mp,
 281         const char              *name,
 282         struct block_device     **bdevp)
 283 {
 284         int                     error = 0;
 285
 286         *bdevp = blkdev_get_by_path(name, FMODE_READ|FMODE_WRITE|FMODE_EXCL,
 287                                     mp);
 288         if (IS_ERR(*bdevp)) {
 289                 error = PTR_ERR(*bdevp);
 290                 xfs_warn(mp, "Invalid device [%s], error=%d", name, error);
 291         }
 292
 293         return error;
 294 }
 295
 296 STATIC void
 297 xfs_blkdev_put(
 298         struct block_device     *bdev)
 299 {
 300         if (bdev)
 301                 blkdev_put(bdev, FMODE_READ|FMODE_WRITE|FMODE_EXCL);
 302 }
 303
 304 void
 305 xfs_blkdev_issue_flush(
 306         xfs_buftarg_t           *buftarg)
 307 {
 308         blkdev_issue_flush(buftarg->bt_bdev, GFP_NOFS, NULL);
 309 }
 310
 311 STATIC void
 312 xfs_close_devices(
 313         struct xfs_mount        *mp)
 314 {
 315         struct dax_device *dax_ddev = mp->m_ddev_targp->bt_daxdev;
 316
 317         if (mp->m_logdev_targp && mp->m_logdev_targp != mp->m_ddev_targp) {
 318                 struct block_device *logdev = mp->m_logdev_targp->bt_bdev;
 319                 struct dax_device *dax_logdev = mp->m_logdev_targp->bt_daxdev;
 320
 321                 xfs_free_buftarg(mp->m_logdev_targp);
 322                 xfs_blkdev_put(logdev);
 323                 fs_put_dax(dax_logdev);
 324         }
 325         if (mp->m_rtdev_targp) {
 326                 struct block_device *rtdev = mp->m_rtdev_targp->bt_bdev;
 327                 struct dax_device *dax_rtdev = mp->m_rtdev_targp->bt_daxdev;
 328
 329                 xfs_free_buftarg(mp->m_rtdev_targp);
 330                 xfs_blkdev_put(rtdev);
 331                 fs_put_dax(dax_rtdev);
 332         }
 333         xfs_free_buftarg(mp->m_ddev_targp);
 334         fs_put_dax(dax_ddev);
 335 }
 336
 337 /*
 338  * The file system configurations are:
 339  *      (1) device (partition) with data and internal log
 340  *      (2) logical volume with data and log subvolumes.
 341  *      (3) logical volume with data, log, and realtime subvolumes.
 342  *
 343  * We only have to handle opening the log and realtime volumes here if
 344  * they are present.  The data subvolume has already been opened by
 345  * get_sb_bdev() and is stored in sb->s_bdev.
 346  */
 347 STATIC int
 348 xfs_open_devices(
 349         struct xfs_mount        *mp)
 350 {
 351         struct block_device     *ddev = mp->m_super->s_bdev;
 352         struct dax_device       *dax_ddev = fs_dax_get_by_bdev(ddev);
 353         struct dax_device       *dax_logdev = NULL, *dax_rtdev = NULL;
 354         struct block_device     *logdev = NULL, *rtdev = NULL;
 355         int                     error;
 356
 357         /*
 358          * Open real time and log devices - order is important.
 359          */
 360         if (mp->m_logname) {
 361                 error = xfs_blkdev_get(mp, mp->m_logname, &logdev);
 362                 if (error)
 363                         goto out;
 364                 dax_logdev = fs_dax_get_by_bdev(logdev);
 365         }
 366
 367         if (mp->m_rtname) {
 368                 error = xfs_blkdev_get(mp, mp->m_rtname, &rtdev);
 369                 if (error)
 370                         goto out_close_logdev;
 371
 372                 if (rtdev == ddev || rtdev == logdev) {
 373                         xfs_warn(mp,
 374         "Cannot mount filesystem with identical rtdev and ddev/logdev.");
 375                         error = -EINVAL;
 376                         goto out_close_rtdev;
 377                 }
 378                 dax_rtdev = fs_dax_get_by_bdev(rtdev);
 379         }
 380
 381         /*
 382          * Setup xfs_mount buffer target pointers
 383          */
 384         error = -ENOMEM;
 385         mp->m_ddev_targp = xfs_alloc_buftarg(mp, ddev, dax_ddev);
 386         if (!mp->m_ddev_targp)
 387                 goto out_close_rtdev;
 388
 389         if (rtdev) {
 390                 mp->m_rtdev_targp = xfs_alloc_buftarg(mp, rtdev, dax_rtdev);
 391                 if (!mp->m_rtdev_targp)
 392                         goto out_free_ddev_targ;
 393         }
 394
 395         if (logdev && logdev != ddev) {
 396                 mp->m_logdev_targp = xfs_alloc_buftarg(mp, logdev, dax_logdev);
 397                 if (!mp->m_logdev_targp)
 398                         goto out_free_rtdev_targ;
 399         } else {
 400                 mp->m_logdev_targp = mp->m_ddev_targp;
 401         }
 402
 403         return 0;
 404
 405  out_free_rtdev_targ:
 406         if (mp->m_rtdev_targp)
 407                 xfs_free_buftarg(mp->m_rtdev_targp);
 408  out_free_ddev_targ:
 409         xfs_free_buftarg(mp->m_ddev_targp);
 410  out_close_rtdev:
 411         xfs_blkdev_put(rtdev);
 412         fs_put_dax(dax_rtdev);
 413  out_close_logdev:
 414         if (logdev && logdev != ddev) {
 415                 xfs_blkdev_put(logdev);
 416                 fs_put_dax(dax_logdev);
 417         }
 418  out:
 419         fs_put_dax(dax_ddev);
 420         return error;
 421 }
 422
 423 /*
 424  * Setup xfs_mount buffer target pointers based on superblock
 425  */
 426 STATIC int
 427 xfs_setup_devices(
 428         struct xfs_mount        *mp)
 429 {
 430         int                     error;
 431
 432         error = xfs_setsize_buftarg(mp->m_ddev_targp, mp->m_sb.sb_sectsize);
 433         if (error)
 434                 return error;
 435
 436         if (mp->m_logdev_targp && mp->m_logdev_targp != mp->m_ddev_targp) {
 437                 unsigned int    log_sector_size = BBSIZE;
 438
 439                 if (xfs_sb_version_hassector(&mp->m_sb))
 440                         log_sector_size = mp->m_sb.sb_logsectsize;
 441                 error = xfs_setsize_buftarg(mp->m_logdev_targp,
 442                                             log_sector_size);
 443                 if (error)
 444                         return error;
 445         }
 446         if (mp->m_rtdev_targp) {
 447                 error = xfs_setsize_buftarg(mp->m_rtdev_targp,
 448                                             mp->m_sb.sb_sectsize);
 449                 if (error)
 450                         return error;
 451         }
 452
 453         return 0;
 454 }
 455
 456 STATIC int
 457 xfs_init_mount_workqueues(
 458         struct xfs_mount        *mp)
 459 {
 460         mp->m_buf_workqueue = alloc_workqueue("xfs-buf/%s",
 461                         WQ_MEM_RECLAIM|WQ_FREEZABLE, 1, mp->m_super->s_id);
 462         if (!mp->m_buf_workqueue)
 463                 goto out;
 464
 465         mp->m_unwritten_workqueue = alloc_workqueue("xfs-conv/%s",
 466                         WQ_MEM_RECLAIM|WQ_FREEZABLE, 0, mp->m_super->s_id);
 467         if (!mp->m_unwritten_workqueue)
 468                 goto out_destroy_buf;
 469
 470         mp->m_cil_workqueue = alloc_workqueue("xfs-cil/%s",
 471                         WQ_MEM_RECLAIM | WQ_FREEZABLE | WQ_UNBOUND,
 472                         0, mp->m_super->s_id);
 473         if (!mp->m_cil_workqueue)
 474                 goto out_destroy_unwritten;
 475
 476         mp->m_reclaim_workqueue = alloc_workqueue("xfs-reclaim/%s",
 477                         WQ_MEM_RECLAIM|WQ_FREEZABLE, 0, mp->m_super->s_id);
 478         if (!mp->m_reclaim_workqueue)
 479                 goto out_destroy_cil;
 480
 481         mp->m_eofblocks_workqueue = alloc_workqueue("xfs-eofblocks/%s",
 482                         WQ_MEM_RECLAIM|WQ_FREEZABLE, 0, mp->m_super->s_id);
 483         if (!mp->m_eofblocks_workqueue)
 484                 goto out_destroy_reclaim;
 485
 486         mp->m_sync_workqueue = alloc_workqueue("xfs-sync/%s", WQ_FREEZABLE, 0,
 487                                                mp->m_super->s_id);
 488         if (!mp->m_sync_workqueue)
 489                 goto out_destroy_eofb;
 490
 491         return 0;
 492
 493 out_destroy_eofb:
 494         destroy_workqueue(mp->m_eofblocks_workqueue);
 495 out_destroy_reclaim:
 496         destroy_workqueue(mp->m_reclaim_workqueue);
 497 out_destroy_cil:
 498         destroy_workqueue(mp->m_cil_workqueue);
 499 out_destroy_unwritten:
 500         destroy_workqueue(mp->m_unwritten_workqueue);
 501 out_destroy_buf:
 502         destroy_workqueue(mp->m_buf_workqueue);
 503 out:
 504         return -ENOMEM;
 505 }
 506
 507 STATIC void
 508 xfs_destroy_mount_workqueues(
 509         struct xfs_mount        *mp)
 510 {
 511         destroy_workqueue(mp->m_sync_workqueue);
 512         destroy_workqueue(mp->m_eofblocks_workqueue);
 513         destroy_workqueue(mp->m_reclaim_workqueue);
 514         destroy_workqueue(mp->m_cil_workqueue);
 515         destroy_workqueue(mp->m_unwritten_workqueue);
 516         destroy_workqueue(mp->m_buf_workqueue);
 517 }
 518
 519 /*
 520  * Flush all dirty data to disk. Must not be called while holding an XFS_ILOCK
 521  * or a page lock. We use sync_inodes_sb() here to ensure we block while waiting
 522  * for IO to complete so that we effectively throttle multiple callers to the
 523  * rate at which IO is completing.
 524  */
 525 void
 526 xfs_flush_inodes(
 527         struct xfs_mount        *mp)
 528 {
 529         struct super_block      *sb = mp->m_super;
 530
 531         if (!__ratelimit(&mp->m_flush_inodes_ratelimit))
 532                 return;
 533
 534         if (down_read_trylock(&sb->s_umount)) {
 535                 sync_inodes_sb(sb);
 536                 up_read(&sb->s_umount);
 537         }
 538 }
 539
 540 /* Catch misguided souls that try to use this interface on XFS */
 541 STATIC struct inode *
 542 xfs_fs_alloc_inode(
 543         struct super_block      *sb)
 544 {
 545         BUG();
 546         return NULL;
 547 }
 548
 549 #ifdef DEBUG
 550 static void
 551 xfs_check_delalloc(
 552         struct xfs_inode        *ip,
 553         int                     whichfork)
 554 {
 555         struct xfs_ifork        *ifp = XFS_IFORK_PTR(ip, whichfork);
 556         struct xfs_bmbt_irec    got;
 557         struct xfs_iext_cursor  icur;
 558
 559         if (!ifp || !xfs_iext_lookup_extent(ip, ifp, 0, &icur, &got))
 560                 return;
 561         do {
 562                 if (isnullstartblock(got.br_startblock)) {
 563                         xfs_warn(ip->i_mount,
 564         "ino %llx %s fork has delalloc extent at [0x%llx:0x%llx]",
 565                                 ip->i_ino,
 566                                 whichfork == XFS_DATA_FORK ? "data" : "cow",
 567                                 got.br_startoff, got.br_blockcount);
 568                 }
 569         } while (xfs_iext_next_extent(ifp, &icur, &got));
 570 }
 571 #else
 572 #define xfs_check_delalloc(ip, whichfork)       do { } while (0)
 573 #endif
 574
 575 /*
 576  * Now that the generic code is guaranteed not to be accessing
 577  * the linux inode, we can inactivate and reclaim the inode.
 578  */
 579 STATIC void
 580 xfs_fs_destroy_inode(
 581         struct inode            *inode)
 582 {
 583         struct xfs_inode        *ip = XFS_I(inode);
 584
 585         trace_xfs_destroy_inode(ip);
 586
 587         ASSERT(!rwsem_is_locked(&inode->i_rwsem));
 588         XFS_STATS_INC(ip->i_mount, vn_rele);
 589         XFS_STATS_INC(ip->i_mount, vn_remove);
 590
 591         xfs_inactive(ip);
 592
 593         if (!XFS_FORCED_SHUTDOWN(ip->i_mount) && ip->i_delayed_blks) {
 594                 xfs_check_delalloc(ip, XFS_DATA_FORK);
 595                 xfs_check_delalloc(ip, XFS_COW_FORK);
 596                 ASSERT(0);
 597         }
 598
 599         XFS_STATS_INC(ip->i_mount, vn_reclaim);
 600
 601         /*
 602          * We should never get here with one of the reclaim flags already set.
 603          */
 604         ASSERT_ALWAYS(!xfs_iflags_test(ip, XFS_IRECLAIMABLE));
 605         ASSERT_ALWAYS(!xfs_iflags_test(ip, XFS_IRECLAIM));
 606
 607         /*
 608          * We always use background reclaim here because even if the
 609          * inode is clean, it still may be under IO and hence we have
 610          * to take the flush lock. The background reclaim path handles
 611          * this more efficiently than we can here, so simply let background
 612          * reclaim tear down all inodes.
 613          */
 614         xfs_inode_set_reclaim_tag(ip);
 615 }
 616
 617 static void
 618 xfs_fs_dirty_inode(
 619         struct inode                    *inode,
 620         int                             flag)
 621 {
 622         struct xfs_inode                *ip = XFS_I(inode);
 623         struct xfs_mount                *mp = ip->i_mount;
 624         struct xfs_trans                *tp;
 625
 626         if (!(inode->i_sb->s_flags & SB_LAZYTIME))
 627                 return;
 628         if (flag != I_DIRTY_SYNC || !(inode->i_state & I_DIRTY_TIME))
 629                 return;
 630
 631         if (xfs_trans_alloc(mp, &M_RES(mp)->tr_fsyncts, 0, 0, 0, &tp))
 632                 return;
 633         xfs_ilock(ip, XFS_ILOCK_EXCL);
 634         xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
 635         xfs_trans_log_inode(tp, ip, XFS_ILOG_TIMESTAMP);
 636         xfs_trans_commit(tp);
 637 }
 638
 639 /*
 640  * Slab object creation initialisation for the XFS inode.
 641  * This covers only the idempotent fields in the XFS inode;
 642  * all other fields need to be initialised on allocation
 643  * from the slab. This avoids the need to repeatedly initialise
 644  * fields in the xfs inode that left in the initialise state
 645  * when freeing the inode.
 646  */
 647 STATIC void
 648 xfs_fs_inode_init_once(
 649         void                    *inode)
 650 {
 651         struct xfs_inode        *ip = inode;
 652
 653         memset(ip, 0, sizeof(struct xfs_inode));
 654
 655         /* vfs inode */
 656         inode_init_once(VFS_I(ip));
 657
 658         /* xfs inode */
 659         atomic_set(&ip->i_pincount, 0);
 660         spin_lock_init(&ip->i_flags_lock);
 661
 662         mrlock_init(&ip->i_mmaplock, MRLOCK_ALLOW_EQUAL_PRI|MRLOCK_BARRIER,
 663                      "xfsino", ip->i_ino);
 664         mrlock_init(&ip->i_lock, MRLOCK_ALLOW_EQUAL_PRI|MRLOCK_BARRIER,
 665                      "xfsino", ip->i_ino);
 666 }
 667
 668 /*
 669  * We do an unlocked check for XFS_IDONTCACHE here because we are already
 670  * serialised against cache hits here via the inode->i_lock and igrab() in
 671  * xfs_iget_cache_hit(). Hence a lookup that might clear this flag will not be
 672  * racing with us, and it avoids needing to grab a spinlock here for every inode
 673  * we drop the final reference on.
 674  */
 675 STATIC int
 676 xfs_fs_drop_inode(
 677         struct inode            *inode)
 678 {
 679         struct xfs_inode        *ip = XFS_I(inode);
 680
 681         /*
 682          * If this unlinked inode is in the middle of recovery, don't
 683          * drop the inode just yet; log recovery will take care of
 684          * that.  See the comment for this inode flag.
 685          */
 686         if (ip->i_flags & XFS_IRECOVERY) {
 687                 ASSERT(ip->i_mount->m_log->l_flags & XLOG_RECOVERY_NEEDED);
 688                 return 0;
 689         }
 690
 691         return generic_drop_inode(inode) || (ip->i_flags & XFS_IDONTCACHE);
 692 }
 693
 694 static void
 695 xfs_mount_free(
 696         struct xfs_mount        *mp)
 697 {
 698         kfree(mp->m_rtname);
 699         kfree(mp->m_logname);
 700         kmem_free(mp);
 701 }
 702
 703 STATIC int
 704 xfs_fs_sync_fs(
 705         struct super_block      *sb,
 706         int                     wait)
 707 {
 708         struct xfs_mount        *mp = XFS_M(sb);
 709
 710         /*
 711          * Doing anything during the async pass would be counterproductive.
 712          */
 713         if (!wait)
 714                 return 0;
 715
 716         xfs_log_force(mp, XFS_LOG_SYNC);
 717         if (laptop_mode) {
 718                 /*
 719                  * The disk must be active because we're syncing.
 720                  * We schedule log work now (now that the disk is
 721                  * active) instead of later (when it might not be).
 722                  */
 723                 flush_delayed_work(&mp->m_log->l_work);
 724         }
 725
 726         return 0;
 727 }
 728
 729 STATIC int
 730 xfs_fs_statfs(
 731         struct dentry           *dentry,
 732         struct kstatfs          *statp)
 733 {
 734         struct xfs_mount        *mp = XFS_M(dentry->d_sb);
 735         xfs_sb_t                *sbp = &mp->m_sb;
 736         struct xfs_inode        *ip = XFS_I(d_inode(dentry));
 737         uint64_t                fakeinos, id;
 738         uint64_t                icount;
 739         uint64_t                ifree;
 740         uint64_t                fdblocks;
 741         xfs_extlen_t            lsize;
 742         int64_t                 ffree;
 743
 744         statp->f_type = XFS_SUPER_MAGIC;
 745         statp->f_namelen = MAXNAMELEN - 1;
 746
 747         id = huge_encode_dev(mp->m_ddev_targp->bt_dev);
 748         statp->f_fsid.val[0] = (u32)id;
 749         statp->f_fsid.val[1] = (u32)(id >> 32);
 750
 751         icount = percpu_counter_sum(&mp->m_icount);
 752         ifree = percpu_counter_sum(&mp->m_ifree);
 753         fdblocks = percpu_counter_sum(&mp->m_fdblocks);
 754
 755         spin_lock(&mp->m_sb_lock);
 756         statp->f_bsize = sbp->sb_blocksize;
 757         lsize = sbp->sb_logstart ? sbp->sb_logblocks : 0;
 758         statp->f_blocks = sbp->sb_dblocks - lsize;
 759         spin_unlock(&mp->m_sb_lock);
 760
 761         statp->f_bfree = fdblocks - mp->m_alloc_set_aside;
 762         statp->f_bavail = statp->f_bfree;
 763
 764         fakeinos = XFS_FSB_TO_INO(mp, statp->f_bfree);
 765         statp->f_files = min(icount + fakeinos, (uint64_t)XFS_MAXINUMBER);
 766         if (M_IGEO(mp)->maxicount)
 767                 statp->f_files = min_t(typeof(statp->f_files),
 768                                         statp->f_files,
 769                                         M_IGEO(mp)->maxicount);
 770
 771         /* If sb_icount overshot maxicount, report actual allocation */
 772         statp->f_files = max_t(typeof(statp->f_files),
 773                                         statp->f_files,
 774                                         sbp->sb_icount);
 775
 776         /* make sure statp->f_ffree does not underflow */
 777         ffree = statp->f_files - (icount - ifree);
 778         statp->f_ffree = max_t(int64_t, ffree, 0);
 779
 780
 781         if ((ip->i_d.di_flags & XFS_DIFLAG_PROJINHERIT) &&
 782             ((mp->m_qflags & (XFS_PQUOTA_ACCT|XFS_PQUOTA_ENFD))) ==
 783                               (XFS_PQUOTA_ACCT|XFS_PQUOTA_ENFD))
 784                 xfs_qm_statvfs(ip, statp);
 785
 786         if (XFS_IS_REALTIME_MOUNT(mp) &&
 787             (ip->i_d.di_flags & (XFS_DIFLAG_RTINHERIT | XFS_DIFLAG_REALTIME))) {
 788                 statp->f_blocks = sbp->sb_rblocks;
 789                 statp->f_bavail = statp->f_bfree =
 790                         sbp->sb_frextents * sbp->sb_rextsize;
 791         }
 792
 793         return 0;
 794 }
 795
 796 STATIC void
 797 xfs_save_resvblks(struct xfs_mount *mp)
 798 {
 799         uint64_t resblks = 0;
 800
 801         mp->m_resblks_save = mp->m_resblks;
 802         xfs_reserve_blocks(mp, &resblks, NULL);
 803 }
 804
 805 STATIC void
 806 xfs_restore_resvblks(struct xfs_mount *mp)
 807 {
 808         uint64_t resblks;
 809
 810         if (mp->m_resblks_save) {
 811                 resblks = mp->m_resblks_save;
 812                 mp->m_resblks_save = 0;
 813         } else
 814                 resblks = xfs_default_resblks(mp);
 815
 816         xfs_reserve_blocks(mp, &resblks, NULL);
 817 }
 818
 819 /*
 820  * Trigger writeback of all the dirty metadata in the file system.
 821  *
 822  * This ensures that the metadata is written to their location on disk rather
 823  * than just existing in transactions in the log. This means after a quiesce
 824  * there is no log replay required to write the inodes to disk - this is the
 825  * primary difference between a sync and a quiesce.
 826  *
 827  * Note: xfs_log_quiesce() stops background log work - the callers must ensure
 828  * it is started again when appropriate.
 829  */
 830 void
 831 xfs_quiesce_attr(
 832         struct xfs_mount        *mp)
 833 {
 834         int     error = 0;
 835
 836         /* wait for all modifications to complete */
 837         while (atomic_read(&mp->m_active_trans) > 0)
 838                 delay(100);
 839
 840         /* force the log to unpin objects from the now complete transactions */
 841         xfs_log_force(mp, XFS_LOG_SYNC);
 842
 843         /* reclaim inodes to do any IO before the freeze completes */
 844         xfs_reclaim_inodes(mp, 0);
 845         xfs_reclaim_inodes(mp, SYNC_WAIT);
 846
 847         /* Push the superblock and write an unmount record */
 848         error = xfs_log_sbcount(mp);
 849         if (error)
 850                 xfs_warn(mp, "xfs_attr_quiesce: failed to log sb changes. "
 851                                 "Frozen image may not be consistent.");
 852         /*
 853          * Just warn here till VFS can correctly support
 854          * read-only remount without racing.
 855          */
 856         WARN_ON(atomic_read(&mp->m_active_trans) != 0);
 857
 858         xfs_log_quiesce(mp);
 859 }
 860
 861 /*
 862  * Second stage of a freeze. The data is already frozen so we only
 863  * need to take care of the metadata. Once that's done sync the superblock
 864  * to the log to dirty it in case of a crash while frozen. This ensures that we
 865  * will recover the unlinked inode lists on the next mount.
 866  */
 867 STATIC int
 868 xfs_fs_freeze(
 869         struct super_block      *sb)
 870 {
 871         struct xfs_mount        *mp = XFS_M(sb);
 872
 873         xfs_stop_block_reaping(mp);
 874         xfs_save_resvblks(mp);
 875         xfs_quiesce_attr(mp);
 876         return xfs_sync_sb(mp, true);
 877 }
 878
 879 STATIC int
 880 xfs_fs_unfreeze(
 881         struct super_block      *sb)
 882 {
 883         struct xfs_mount        *mp = XFS_M(sb);
 884
 885         xfs_restore_resvblks(mp);
 886         xfs_log_work_queue(mp);
 887         xfs_start_block_reaping(mp);
 888         return 0;
 889 }
 890
 891 /*
 892  * This function fills in xfs_mount_t fields based on mount args.
 893  * Note: the superblock _has_ now been read in.
 894  */
 895 STATIC int
 896 xfs_finish_flags(
 897         struct xfs_mount        *mp)
 898 {
 899         int                     ronly = (mp->m_flags & XFS_MOUNT_RDONLY);
 900
 901         /* Fail a mount where the logbuf is smaller than the log stripe */
 902         if (xfs_sb_version_haslogv2(&mp->m_sb)) {
 903                 if (mp->m_logbsize <= 0 &&
 904                     mp->m_sb.sb_logsunit > XLOG_BIG_RECORD_BSIZE) {
 905                         mp->m_logbsize = mp->m_sb.sb_logsunit;
 906                 } else if (mp->m_logbsize > 0 &&
 907                            mp->m_logbsize < mp->m_sb.sb_logsunit) {
 908                         xfs_warn(mp,
 909                 "logbuf size must be greater than or equal to log stripe size");
 910                         return -EINVAL;
 911                 }
 912         } else {
 913                 /* Fail a mount if the logbuf is larger than 32K */
 914                 if (mp->m_logbsize > XLOG_BIG_RECORD_BSIZE) {
 915                         xfs_warn(mp,
 916                 "logbuf size for version 1 logs must be 16K or 32K");
 917                         return -EINVAL;
 918                 }
 919         }
 920
 921         /*
 922          * V5 filesystems always use attr2 format for attributes.
 923          */
 924         if (xfs_sb_version_hascrc(&mp->m_sb) &&
 925             (mp->m_flags & XFS_MOUNT_NOATTR2)) {
 926                 xfs_warn(mp, "Cannot mount a V5 filesystem as noattr2. "
 927                              "attr2 is always enabled for V5 filesystems.");
 928                 return -EINVAL;
 929         }
 930
 931         /*
 932          * mkfs'ed attr2 will turn on attr2 mount unless explicitly
 933          * told by noattr2 to turn it off
 934          */
 935         if (xfs_sb_version_hasattr2(&mp->m_sb) &&
 936             !(mp->m_flags & XFS_MOUNT_NOATTR2))
 937                 mp->m_flags |= XFS_MOUNT_ATTR2;
 938
 939         /*
 940          * prohibit r/w mounts of read-only filesystems
 941          */
 942         if ((mp->m_sb.sb_flags & XFS_SBF_READONLY) && !ronly) {
 943                 xfs_warn(mp,
 944                         "cannot mount a read-only filesystem as read-write");
 945                 return -EROFS;
 946         }
 947
 948         if ((mp->m_qflags & (XFS_GQUOTA_ACCT | XFS_GQUOTA_ACTIVE)) &&
 949             (mp->m_qflags & (XFS_PQUOTA_ACCT | XFS_PQUOTA_ACTIVE)) &&
 950             !xfs_sb_version_has_pquotino(&mp->m_sb)) {
 951                 xfs_warn(mp,
 952                   "Super block does not support project and group quota together");
 953                 return -EINVAL;
 954         }
 955
 956         return 0;
 957 }
 958
 959 static int
 960 xfs_init_percpu_counters(
 961         struct xfs_mount        *mp)
 962 {
 963         int             error;
 964
 965         error = percpu_counter_init(&mp->m_icount, 0, GFP_KERNEL);
 966         if (error)
 967                 return -ENOMEM;
 968
 969         error = percpu_counter_init(&mp->m_ifree, 0, GFP_KERNEL);
 970         if (error)
 971                 goto free_icount;
 972
 973         error = percpu_counter_init(&mp->m_fdblocks, 0, GFP_KERNEL);
 974         if (error)
 975                 goto free_ifree;
 976
 977         error = percpu_counter_init(&mp->m_delalloc_blks, 0, GFP_KERNEL);
 978         if (error)
 979                 goto free_fdblocks;
 980
 981         return 0;
 982
 983 free_fdblocks:
 984         percpu_counter_destroy(&mp->m_fdblocks);
 985 free_ifree:
 986         percpu_counter_destroy(&mp->m_ifree);
 987 free_icount:
 988         percpu_counter_destroy(&mp->m_icount);
 989         return -ENOMEM;
 990 }
 991
 992 void
 993 xfs_reinit_percpu_counters(
 994         struct xfs_mount        *mp)
 995 {
 996         percpu_counter_set(&mp->m_icount, mp->m_sb.sb_icount);
 997         percpu_counter_set(&mp->m_ifree, mp->m_sb.sb_ifree);
 998         percpu_counter_set(&mp->m_fdblocks, mp->m_sb.sb_fdblocks);
 999 }
1000
1001 static void
1002 xfs_destroy_percpu_counters(
1003         struct xfs_mount        *mp)
1004 {
1005         percpu_counter_destroy(&mp->m_icount);
1006         percpu_counter_destroy(&mp->m_ifree);
1007         percpu_counter_destroy(&mp->m_fdblocks);
1008         ASSERT(XFS_FORCED_SHUTDOWN(mp) ||
1009                percpu_counter_sum(&mp->m_delalloc_blks) == 0);
1010         percpu_counter_destroy(&mp->m_delalloc_blks);
1011 }
1012
1013 static void
1014 xfs_fs_put_super(
1015         struct super_block      *sb)
1016 {
1017         struct xfs_mount        *mp = XFS_M(sb);
1018
1019         /* if ->fill_super failed, we have no mount to tear down */
1020         if (!sb->s_fs_info)
1021                 return;
1022
1023         xfs_notice(mp, "Unmounting Filesystem");
1024         xfs_filestream_unmount(mp);
1025         xfs_unmountfs(mp);
1026
1027         xfs_freesb(mp);
1028         free_percpu(mp->m_stats.xs_stats);
1029         xfs_destroy_percpu_counters(mp);
1030         xfs_destroy_mount_workqueues(mp);
1031         xfs_close_devices(mp);
1032
1033         sb->s_fs_info = NULL;
1034         xfs_mount_free(mp);
1035 }
1036
1037 static long
1038 xfs_fs_nr_cached_objects(
1039         struct super_block      *sb,
1040         struct shrink_control   *sc)
1041 {
1042         /* Paranoia: catch incorrect calls during mount setup or teardown */
1043         if (WARN_ON_ONCE(!sb->s_fs_info))
1044                 return 0;
1045         return xfs_reclaim_inodes_count(XFS_M(sb));
1046 }
1047
1048 static long
1049 xfs_fs_free_cached_objects(
1050         struct super_block      *sb,
1051         struct shrink_control   *sc)
1052 {
1053         return xfs_reclaim_inodes_nr(XFS_M(sb), sc->nr_to_scan);
1054 }
1055
1056 static const struct super_operations xfs_super_operations = {
1057         .alloc_inode            = xfs_fs_alloc_inode,
1058         .destroy_inode          = xfs_fs_destroy_inode,
1059         .dirty_inode            = xfs_fs_dirty_inode,
1060         .drop_inode             = xfs_fs_drop_inode,
1061         .put_super              = xfs_fs_put_super,
1062         .sync_fs                = xfs_fs_sync_fs,
1063         .freeze_fs              = xfs_fs_freeze,
1064         .unfreeze_fs            = xfs_fs_unfreeze,
1065         .statfs                 = xfs_fs_statfs,
1066         .show_options           = xfs_fs_show_options,
1067         .nr_cached_objects      = xfs_fs_nr_cached_objects,
1068         .free_cached_objects    = xfs_fs_free_cached_objects,
1069 };
1070
1071 static int
1072 suffix_kstrtoint(
1073         const char      *s,
1074         unsigned int    base,
1075         int             *res)
1076 {
1077         int             last, shift_left_factor = 0, _res;
1078         char            *value;
1079         int             ret = 0;
1080
1081         value = kstrdup(s, GFP_KERNEL);
1082         if (!value)
1083                 return -ENOMEM;
1084
1085         last = strlen(value) - 1;
1086         if (value[last] == 'K' || value[last] == 'k') {
1087                 shift_left_factor = 10;
1088                 value[last] = '\0';
1089         }
1090         if (value[last] == 'M' || value[last] == 'm') {
1091                 shift_left_factor = 20;
1092                 value[last] = '\0';
1093         }
1094         if (value[last] == 'G' || value[last] == 'g') {
1095                 shift_left_factor = 30;
1096                 value[last] = '\0';
1097         }
1098
1099         if (kstrtoint(value, base, &_res))
1100                 ret = -EINVAL;
1101         kfree(value);
1102         *res = _res << shift_left_factor;
1103         return ret;
1104 }
1105
1106 /*
1107  * Set mount state from a mount option.
1108  *
1109  * NOTE: mp->m_super is NULL here!
1110  */
1111 static int
1112 xfs_fc_parse_param(
1113         struct fs_context       *fc,
1114         struct fs_parameter     *param)
1115 {
1116         struct xfs_mount        *mp = fc->s_fs_info;
1117         struct fs_parse_result  result;
1118         int                     size = 0;
1119         int                     opt;
1120
1121         opt = fs_parse(fc, xfs_fs_parameters, param, &result);
1122         if (opt < 0)
1123                 return opt;
1124
1125         switch (opt) {
1126         case Opt_logbufs:
1127                 mp->m_logbufs = result.uint_32;
1128                 return 0;
1129         case Opt_logbsize:
1130                 if (suffix_kstrtoint(param->string, 10, &mp->m_logbsize))
1131                         return -EINVAL;
1132                 return 0;
1133         case Opt_logdev:
1134                 kfree(mp->m_logname);
1135                 mp->m_logname = kstrdup(param->string, GFP_KERNEL);
1136                 if (!mp->m_logname)
1137                         return -ENOMEM;
1138                 return 0;
1139         case Opt_rtdev:
1140                 kfree(mp->m_rtname);
1141                 mp->m_rtname = kstrdup(param->string, GFP_KERNEL);
1142                 if (!mp->m_rtname)
1143                         return -ENOMEM;
1144                 return 0;
1145         case Opt_allocsize:
1146                 if (suffix_kstrtoint(param->string, 10, &size))
1147                         return -EINVAL;
1148                 mp->m_allocsize_log = ffs(size) - 1;
1149                 mp->m_flags |= XFS_MOUNT_ALLOCSIZE;
1150                 return 0;
1151         case Opt_grpid:
1152         case Opt_bsdgroups:
1153                 mp->m_flags |= XFS_MOUNT_GRPID;
1154                 return 0;
1155         case Opt_nogrpid:
1156         case Opt_sysvgroups:
1157                 mp->m_flags &= ~XFS_MOUNT_GRPID;
1158                 return 0;
1159         case Opt_wsync:
1160                 mp->m_flags |= XFS_MOUNT_WSYNC;
1161                 return 0;
1162         case Opt_norecovery:
1163                 mp->m_flags |= XFS_MOUNT_NORECOVERY;
1164                 return 0;
1165         case Opt_noalign:
1166                 mp->m_flags |= XFS_MOUNT_NOALIGN;
1167                 return 0;
1168         case Opt_swalloc:
1169                 mp->m_flags |= XFS_MOUNT_SWALLOC;
1170                 return 0;
1171         case Opt_sunit:
1172                 mp->m_dalign = result.uint_32;
1173                 return 0;
1174         case Opt_swidth:
1175                 mp->m_swidth = result.uint_32;
1176                 return 0;
1177         case Opt_inode32:
1178                 mp->m_flags |= XFS_MOUNT_SMALL_INUMS;
1179                 return 0;
1180         case Opt_inode64:
1181                 mp->m_flags &= ~XFS_MOUNT_SMALL_INUMS;
1182                 return 0;
1183         case Opt_nouuid:
1184                 mp->m_flags |= XFS_MOUNT_NOUUID;
1185                 return 0;
1186         case Opt_ikeep:
1187                 mp->m_flags |= XFS_MOUNT_IKEEP;
1188                 return 0;
1189         case Opt_noikeep:
1190                 mp->m_flags &= ~XFS_MOUNT_IKEEP;
1191                 return 0;
1192         case Opt_largeio:
1193                 mp->m_flags |= XFS_MOUNT_LARGEIO;
1194                 return 0;
1195         case Opt_nolargeio:
1196                 mp->m_flags &= ~XFS_MOUNT_LARGEIO;
1197                 return 0;
1198         case Opt_attr2:
1199                 mp->m_flags |= XFS_MOUNT_ATTR2;
1200                 return 0;
1201         case Opt_noattr2:
1202                 mp->m_flags &= ~XFS_MOUNT_ATTR2;
1203                 mp->m_flags |= XFS_MOUNT_NOATTR2;
1204                 return 0;
1205         case Opt_filestreams:
1206                 mp->m_flags |= XFS_MOUNT_FILESTREAMS;
1207                 return 0;
1208         case Opt_noquota:
1209                 mp->m_qflags &= ~XFS_ALL_QUOTA_ACCT;
1210                 mp->m_qflags &= ~XFS_ALL_QUOTA_ENFD;
1211                 mp->m_qflags &= ~XFS_ALL_QUOTA_ACTIVE;
1212                 return 0;
1213         case Opt_quota:
1214         case Opt_uquota:
1215         case Opt_usrquota:
1216                 mp->m_qflags |= (XFS_UQUOTA_ACCT | XFS_UQUOTA_ACTIVE |
1217                                  XFS_UQUOTA_ENFD);
1218                 return 0;
1219         case Opt_qnoenforce:
1220         case Opt_uqnoenforce:
1221                 mp->m_qflags |= (XFS_UQUOTA_ACCT | XFS_UQUOTA_ACTIVE);
1222                 mp->m_qflags &= ~XFS_UQUOTA_ENFD;
1223                 return 0;
1224         case Opt_pquota:
1225         case Opt_prjquota:
1226                 mp->m_qflags |= (XFS_PQUOTA_ACCT | XFS_PQUOTA_ACTIVE |
1227                                  XFS_PQUOTA_ENFD);
1228                 return 0;
1229         case Opt_pqnoenforce:
1230                 mp->m_qflags |= (XFS_PQUOTA_ACCT | XFS_PQUOTA_ACTIVE);
1231                 mp->m_qflags &= ~XFS_PQUOTA_ENFD;
1232                 return 0;
1233         case Opt_gquota:
1234         case Opt_grpquota:
1235                 mp->m_qflags |= (XFS_GQUOTA_ACCT | XFS_GQUOTA_ACTIVE |
1236                                  XFS_GQUOTA_ENFD);
1237                 return 0;
1238         case Opt_gqnoenforce:
1239                 mp->m_qflags |= (XFS_GQUOTA_ACCT | XFS_GQUOTA_ACTIVE);
1240                 mp->m_qflags &= ~XFS_GQUOTA_ENFD;
1241                 return 0;
1242         case Opt_discard:
1243                 mp->m_flags |= XFS_MOUNT_DISCARD;
1244                 return 0;
1245         case Opt_nodiscard:
1246                 mp->m_flags &= ~XFS_MOUNT_DISCARD;
1247                 return 0;
1248 #ifdef CONFIG_FS_DAX
1249         case Opt_dax:
1250                 mp->m_flags |= XFS_MOUNT_DAX;
1251                 return 0;
1252 #endif
1253         default:
1254                 xfs_warn(mp, "unknown mount option [%s].", param->key);
1255                 return -EINVAL;
1256         }
1257
1258         return 0;
1259 }
1260
1261 static int
1262 xfs_fc_validate_params(
1263         struct xfs_mount        *mp)
1264 {
1265         /*
1266          * no recovery flag requires a read-only mount
1267          */
1268         if ((mp->m_flags & XFS_MOUNT_NORECOVERY) &&
1269             !(mp->m_flags & XFS_MOUNT_RDONLY)) {
1270                 xfs_warn(mp, "no-recovery mounts must be read-only.");
1271                 return -EINVAL;
1272         }
1273
1274         if ((mp->m_flags & XFS_MOUNT_NOALIGN) &&
1275             (mp->m_dalign || mp->m_swidth)) {
1276                 xfs_warn(mp,
1277         "sunit and swidth options incompatible with the noalign option");
1278                 return -EINVAL;
1279         }
1280
1281         if (!IS_ENABLED(CONFIG_XFS_QUOTA) && mp->m_qflags != 0) {
1282                 xfs_warn(mp, "quota support not available in this kernel.");
1283                 return -EINVAL;
1284         }
1285
1286         if ((mp->m_dalign && !mp->m_swidth) ||
1287             (!mp->m_dalign && mp->m_swidth)) {
1288                 xfs_warn(mp, "sunit and swidth must be specified together");
1289                 return -EINVAL;
1290         }
1291
1292         if (mp->m_dalign && (mp->m_swidth % mp->m_dalign != 0)) {
1293                 xfs_warn(mp,
1294         "stripe width (%d) must be a multiple of the stripe unit (%d)",
1295                         mp->m_swidth, mp->m_dalign);
1296                 return -EINVAL;
1297         }
1298
1299         if (mp->m_logbufs != -1 &&
1300             mp->m_logbufs != 0 &&
1301             (mp->m_logbufs < XLOG_MIN_ICLOGS ||
1302              mp->m_logbufs > XLOG_MAX_ICLOGS)) {
1303                 xfs_warn(mp, "invalid logbufs value: %d [not %d-%d]",
1304                         mp->m_logbufs, XLOG_MIN_ICLOGS, XLOG_MAX_ICLOGS);
1305                 return -EINVAL;
1306         }
1307
1308         if (mp->m_logbsize != -1 &&
1309             mp->m_logbsize !=  0 &&
1310             (mp->m_logbsize < XLOG_MIN_RECORD_BSIZE ||
1311              mp->m_logbsize > XLOG_MAX_RECORD_BSIZE ||
1312              !is_power_of_2(mp->m_logbsize))) {
1313                 xfs_warn(mp,
1314                         "invalid logbufsize: %d [not 16k,32k,64k,128k or 256k]",
1315                         mp->m_logbsize);
1316                 return -EINVAL;
1317         }
1318
1319         if ((mp->m_flags & XFS_MOUNT_ALLOCSIZE) &&
1320             (mp->m_allocsize_log > XFS_MAX_IO_LOG ||
1321              mp->m_allocsize_log < XFS_MIN_IO_LOG)) {
1322                 xfs_warn(mp, "invalid log iosize: %d [not %d-%d]",
1323                         mp->m_allocsize_log, XFS_MIN_IO_LOG, XFS_MAX_IO_LOG);
1324                 return -EINVAL;
1325         }
1326
1327         return 0;
1328 }
1329
1330 static int
1331 xfs_fc_fill_super(
1332         struct super_block      *sb,
1333         struct fs_context       *fc)
1334 {
1335         struct xfs_mount        *mp = sb->s_fs_info;
1336         struct inode            *root;
1337         int                     flags = 0, error;
1338
1339         mp->m_super = sb;
1340
1341         error = xfs_fc_validate_params(mp);
1342         if (error)
1343                 goto out_free_names;
1344
1345         sb_min_blocksize(sb, BBSIZE);
1346         sb->s_xattr = xfs_xattr_handlers;
1347         sb->s_export_op = &xfs_export_operations;
1348 #ifdef CONFIG_XFS_QUOTA
1349         sb->s_qcop = &xfs_quotactl_operations;
1350         sb->s_quota_types = QTYPE_MASK_USR | QTYPE_MASK_GRP | QTYPE_MASK_PRJ;
1351 #endif
1352         sb->s_op = &xfs_super_operations;
1353
1354         /*
1355          * Delay mount work if the debug hook is set. This is debug
1356          * instrumention to coordinate simulation of xfs mount failures with
1357          * VFS superblock operations
1358          */
1359         if (xfs_globals.mount_delay) {
1360                 xfs_notice(mp, "Delaying mount for %d seconds.",
1361                         xfs_globals.mount_delay);
1362                 msleep(xfs_globals.mount_delay * 1000);
1363         }
1364
1365         if (fc->sb_flags & SB_SILENT)
1366                 flags |= XFS_MFSI_QUIET;
1367
1368         error = xfs_open_devices(mp);
1369         if (error)
1370                 goto out_free_names;
1371
1372         /*
1373          * Cap the number of invocations of xfs_flush_inodes to 16 for every
1374          * quarter of a second.  The magic numbers here were determined by
1375          * observation neither to cause stalls in writeback when there are a
1376          * lot of IO threads and the fs is near ENOSPC, nor cause any fstest
1377          * regressions.  YMMV.
1378          */
1379         ratelimit_state_init(&mp->m_flush_inodes_ratelimit, HZ / 4, 16);
1380         ratelimit_set_flags(&mp->m_flush_inodes_ratelimit,
1381                         RATELIMIT_MSG_ON_RELEASE);
1382
1383         error = xfs_init_mount_workqueues(mp);
1384         if (error)
1385                 goto out_close_devices;
1386
1387         error = xfs_init_percpu_counters(mp);
1388         if (error)
1389                 goto out_destroy_workqueues;
1390
1391         /* Allocate stats memory before we do operations that might use it */
1392         mp->m_stats.xs_stats = alloc_percpu(struct xfsstats);
1393         if (!mp->m_stats.xs_stats) {
1394                 error = -ENOMEM;
1395                 goto out_destroy_counters;
1396         }
1397
1398         error = xfs_readsb(mp, flags);
1399         if (error)
1400                 goto out_free_stats;
1401
1402         error = xfs_finish_flags(mp);
1403         if (error)
1404                 goto out_free_sb;
1405
1406         error = xfs_setup_devices(mp);
1407         if (error)
1408                 goto out_free_sb;
1409
1410         /*
1411          * XFS block mappings use 54 bits to store the logical block offset.
1412          * This should suffice to handle the maximum file size that the VFS
1413          * supports (currently 2^63 bytes on 64-bit and ULONG_MAX << PAGE_SHIFT
1414          * bytes on 32-bit), but as XFS and VFS have gotten the s_maxbytes
1415          * calculation wrong on 32-bit kernels in the past, we'll add a WARN_ON
1416          * to check this assertion.
1417          *
1418          * Avoid integer overflow by comparing the maximum bmbt offset to the
1419          * maximum pagecache offset in units of fs blocks.
1420          */
1421         if (XFS_B_TO_FSBT(mp, MAX_LFS_FILESIZE) > XFS_MAX_FILEOFF) {
1422                 xfs_warn(mp,
1423 "MAX_LFS_FILESIZE block offset (%llu) exceeds extent map maximum (%llu)!",
1424                          XFS_B_TO_FSBT(mp, MAX_LFS_FILESIZE),
1425                          XFS_MAX_FILEOFF);
1426                 error = -EINVAL;
1427                 goto out_free_sb;
1428         }
1429
1430         error = xfs_filestream_mount(mp);
1431         if (error)
1432                 goto out_free_sb;
1433
1434         /*
1435          * we must configure the block size in the superblock before we run the
1436          * full mount process as the mount process can lookup and cache inodes.
1437          */
1438         sb->s_magic = XFS_SUPER_MAGIC;
1439         sb->s_blocksize = mp->m_sb.sb_blocksize;
1440         sb->s_blocksize_bits = ffs(sb->s_blocksize) - 1;
1441         sb->s_maxbytes = MAX_LFS_FILESIZE;
1442         sb->s_max_links = XFS_MAXLINK;
1443         sb->s_time_gran = 1;
1444         sb->s_time_min = S32_MIN;
1445         sb->s_time_max = S32_MAX;
1446         sb->s_iflags |= SB_I_CGROUPWB;
1447
1448         set_posix_acl_flag(sb);
1449
1450         /* version 5 superblocks support inode version counters. */
1451         if (XFS_SB_VERSION_NUM(&mp->m_sb) == XFS_SB_VERSION_5)
1452                 sb->s_flags |= SB_I_VERSION;
1453
1454         if (mp->m_flags & XFS_MOUNT_DAX) {
1455                 bool rtdev_is_dax = false, datadev_is_dax;
1456
1457                 xfs_warn(mp,
1458                 "DAX enabled. Warning: EXPERIMENTAL, use at your own risk");
1459
1460                 datadev_is_dax = bdev_dax_supported(mp->m_ddev_targp->bt_bdev,
1461                         sb->s_blocksize);
1462                 if (mp->m_rtdev_targp)
1463                         rtdev_is_dax = bdev_dax_supported(
1464                                 mp->m_rtdev_targp->bt_bdev, sb->s_blocksize);
1465                 if (!rtdev_is_dax && !datadev_is_dax) {
1466                         xfs_alert(mp,
1467                         "DAX unsupported by block device. Turning off DAX.");
1468                         mp->m_flags &= ~XFS_MOUNT_DAX;
1469                 }
1470                 if (xfs_sb_version_hasreflink(&mp->m_sb)) {
1471                         xfs_alert(mp,
1472                 "DAX and reflink cannot be used together!");
1473                         error = -EINVAL;
1474                         goto out_filestream_unmount;
1475                 }
1476         }
1477
1478         if (mp->m_flags & XFS_MOUNT_DISCARD) {
1479                 struct request_queue *q = bdev_get_queue(sb->s_bdev);
1480
1481                 if (!blk_queue_discard(q)) {
1482                         xfs_warn(mp, "mounting with \"discard\" option, but "
1483                                         "the device does not support discard");
1484                         mp->m_flags &= ~XFS_MOUNT_DISCARD;
1485                 }
1486         }
1487
1488         if (xfs_sb_version_hasreflink(&mp->m_sb)) {
1489                 if (mp->m_sb.sb_rblocks) {
1490                         xfs_alert(mp,
1491         "reflink not compatible with realtime device!");
1492                         error = -EINVAL;
1493                         goto out_filestream_unmount;
1494                 }
1495
1496                 if (xfs_globals.always_cow) {
1497                         xfs_info(mp, "using DEBUG-only always_cow mode.");
1498                         mp->m_always_cow = true;
1499                 }
1500         }
1501
1502         if (xfs_sb_version_hasrmapbt(&mp->m_sb) && mp->m_sb.sb_rblocks) {
1503                 xfs_alert(mp,
1504         "reverse mapping btree not compatible with realtime device!");
1505                 error = -EINVAL;
1506                 goto out_filestream_unmount;
1507         }
1508
1509         error = xfs_mountfs(mp);
1510         if (error)
1511                 goto out_filestream_unmount;
1512
1513         root = igrab(VFS_I(mp->m_rootip));
1514         if (!root) {
1515                 error = -ENOENT;
1516                 goto out_unmount;
1517         }
1518         sb->s_root = d_make_root(root);
1519         if (!sb->s_root) {
1520                 error = -ENOMEM;
1521                 goto out_unmount;
1522         }
1523
1524         return 0;
1525
1526  out_filestream_unmount:
1527         xfs_filestream_unmount(mp);
1528  out_free_sb:
1529         xfs_freesb(mp);
1530  out_free_stats:
1531         free_percpu(mp->m_stats.xs_stats);
1532  out_destroy_counters:
1533         xfs_destroy_percpu_counters(mp);
1534  out_destroy_workqueues:
1535         xfs_destroy_mount_workqueues(mp);
1536  out_close_devices:
1537         xfs_close_devices(mp);
1538  out_free_names:
1539         sb->s_fs_info = NULL;
1540         xfs_mount_free(mp);
1541         return error;
1542
1543  out_unmount:
1544         xfs_filestream_unmount(mp);
1545         xfs_unmountfs(mp);
1546         goto out_free_sb;
1547 }
1548
1549 static int
1550 xfs_fc_get_tree(
1551         struct fs_context       *fc)
1552 {
1553         return get_tree_bdev(fc, xfs_fc_fill_super);
1554 }
1555
1556 static int
1557 xfs_remount_rw(
1558         struct xfs_mount        *mp)
1559 {
1560         struct xfs_sb           *sbp = &mp->m_sb;
1561         int error;
1562
1563         if (mp->m_flags & XFS_MOUNT_NORECOVERY) {
1564                 xfs_warn(mp,
1565                         "ro->rw transition prohibited on norecovery mount");
1566                 return -EINVAL;
1567         }
1568
1569         if (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_5 &&
1570             xfs_sb_has_ro_compat_feature(sbp, XFS_SB_FEAT_RO_COMPAT_UNKNOWN)) {
1571                 xfs_warn(mp,
1572         "ro->rw transition prohibited on unknown (0x%x) ro-compat filesystem",
1573                         (sbp->sb_features_ro_compat &
1574                                 XFS_SB_FEAT_RO_COMPAT_UNKNOWN));
1575                 return -EINVAL;
1576         }
1577
1578         mp->m_flags &= ~XFS_MOUNT_RDONLY;
1579
1580         /*
1581          * If this is the first remount to writeable state we might have some
1582          * superblock changes to update.
1583          */
1584         if (mp->m_update_sb) {
1585                 error = xfs_sync_sb(mp, false);
1586                 if (error) {
1587                         xfs_warn(mp, "failed to write sb changes");
1588                         return error;
1589                 }
1590                 mp->m_update_sb = false;
1591         }
1592
1593         /*
1594          * Fill out the reserve pool if it is empty. Use the stashed value if
1595          * it is non-zero, otherwise go with the default.
1596          */
1597         xfs_restore_resvblks(mp);
1598         xfs_log_work_queue(mp);
1599
1600         /* Recover any CoW blocks that never got remapped. */
1601         error = xfs_reflink_recover_cow(mp);
1602         if (error) {
1603                 xfs_err(mp,
1604                         "Error %d recovering leftover CoW allocations.", error);
1605                 xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
1606                 return error;
1607         }
1608         xfs_start_block_reaping(mp);
1609
1610         /* Create the per-AG metadata reservation pool .*/
1611         error = xfs_fs_reserve_ag_blocks(mp);
1612         if (error && error != -ENOSPC)
1613                 return error;
1614
1615         return 0;
1616 }
1617
1618 static int
1619 xfs_remount_ro(
1620         struct xfs_mount        *mp)
1621 {
1622         int error;
1623
1624         /*
1625          * Cancel background eofb scanning so it cannot race with the final
1626          * log force+buftarg wait and deadlock the remount.
1627          */
1628         xfs_stop_block_reaping(mp);
1629
1630         /* Get rid of any leftover CoW reservations... */
1631         error = xfs_icache_free_cowblocks(mp, NULL);
1632         if (error) {
1633                 xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
1634                 return error;
1635         }
1636
1637         /* Free the per-AG metadata reservation pool. */
1638         error = xfs_fs_unreserve_ag_blocks(mp);
1639         if (error) {
1640                 xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
1641                 return error;
1642         }
1643
1644         /*
1645          * Before we sync the metadata, we need to free up the reserve block
1646          * pool so that the used block count in the superblock on disk is
1647          * correct at the end of the remount. Stash the current* reserve pool
1648          * size so that if we get remounted rw, we can return it to the same
1649          * size.
1650          */
1651         xfs_save_resvblks(mp);
1652
1653         xfs_quiesce_attr(mp);
1654         mp->m_flags |= XFS_MOUNT_RDONLY;
1655
1656         return 0;
1657 }
1658
1659 /*
1660  * Logically we would return an error here to prevent users from believing
1661  * they might have changed mount options using remount which can't be changed.
1662  *
1663  * But unfortunately mount(8) adds all options from mtab and fstab to the mount
1664  * arguments in some cases so we can't blindly reject options, but have to
1665  * check for each specified option if it actually differs from the currently
1666  * set option and only reject it if that's the case.
1667  *
1668  * Until that is implemented we return success for every remount request, and
1669  * silently ignore all options that we can't actually change.
1670  */
1671 static int
1672 xfs_fc_reconfigure(
1673         struct fs_context *fc)
1674 {
1675         struct xfs_mount        *mp = XFS_M(fc->root->d_sb);
1676         struct xfs_mount        *new_mp = fc->s_fs_info;
1677         xfs_sb_t                *sbp = &mp->m_sb;
1678         int                     flags = fc->sb_flags;
1679         int                     error;
1680
1681         error = xfs_fc_validate_params(new_mp);
1682         if (error)
1683                 return error;
1684
1685         sync_filesystem(mp->m_super);
1686
1687         /* inode32 -> inode64 */
1688         if ((mp->m_flags & XFS_MOUNT_SMALL_INUMS) &&
1689             !(new_mp->m_flags & XFS_MOUNT_SMALL_INUMS)) {
1690                 mp->m_flags &= ~XFS_MOUNT_SMALL_INUMS;
1691                 mp->m_maxagi = xfs_set_inode_alloc(mp, sbp->sb_agcount);
1692         }
1693
1694         /* inode64 -> inode32 */
1695         if (!(mp->m_flags & XFS_MOUNT_SMALL_INUMS) &&
1696             (new_mp->m_flags & XFS_MOUNT_SMALL_INUMS)) {
1697                 mp->m_flags |= XFS_MOUNT_SMALL_INUMS;
1698                 mp->m_maxagi = xfs_set_inode_alloc(mp, sbp->sb_agcount);
1699         }
1700
1701         /* ro -> rw */
1702         if ((mp->m_flags & XFS_MOUNT_RDONLY) && !(flags & SB_RDONLY)) {
1703                 error = xfs_remount_rw(mp);
1704                 if (error)
1705                         return error;
1706         }
1707
1708         /* rw -> ro */
1709         if (!(mp->m_flags & XFS_MOUNT_RDONLY) && (flags & SB_RDONLY)) {
1710                 error = xfs_remount_ro(mp);
1711                 if (error)
1712                         return error;
1713         }
1714
1715         return 0;
1716 }
1717
1718 static void xfs_fc_free(
1719         struct fs_context       *fc)
1720 {
1721         struct xfs_mount        *mp = fc->s_fs_info;
1722
1723         /*
1724          * mp is stored in the fs_context when it is initialized.
1725          * mp is transferred to the superblock on a successful mount,
1726          * but if an error occurs before the transfer we have to free
1727          * it here.
1728          */
1729         if (mp)
1730                 xfs_mount_free(mp);
1731 }
1732
1733 static const struct fs_context_operations xfs_context_ops = {
1734         .parse_param = xfs_fc_parse_param,
1735         .get_tree    = xfs_fc_get_tree,
1736         .reconfigure = xfs_fc_reconfigure,
1737         .free        = xfs_fc_free,
1738 };
1739
1740 static int xfs_init_fs_context(
1741         struct fs_context       *fc)
1742 {
1743         struct xfs_mount        *mp;
1744
1745         mp = kmem_alloc(sizeof(struct xfs_mount), KM_ZERO);
1746         if (!mp)
1747                 return -ENOMEM;
1748
1749         spin_lock_init(&mp->m_sb_lock);
1750         spin_lock_init(&mp->m_agirotor_lock);
1751         INIT_RADIX_TREE(&mp->m_perag_tree, GFP_ATOMIC);
1752         spin_lock_init(&mp->m_perag_lock);
1753         mutex_init(&mp->m_growlock);
1754         atomic_set(&mp->m_active_trans, 0);
1755         INIT_DELAYED_WORK(&mp->m_reclaim_work, xfs_reclaim_worker);
1756         INIT_DELAYED_WORK(&mp->m_eofblocks_work, xfs_eofblocks_worker);
1757         INIT_DELAYED_WORK(&mp->m_cowblocks_work, xfs_cowblocks_worker);
1758         mp->m_kobj.kobject.kset = xfs_kset;
1759         /*
1760          * We don't create the finobt per-ag space reservation until after log
1761          * recovery, so we must set this to true so that an ifree transaction
1762          * started during log recovery will not depend on space reservations
1763          * for finobt expansion.
1764          */
1765         mp->m_finobt_nores = true;
1766
1767         /*
1768          * These can be overridden by the mount option parsing.
1769          */
1770         mp->m_logbufs = -1;
1771         mp->m_logbsize = -1;
1772         mp->m_allocsize_log = 16; /* 64k */
1773
1774         /*
1775          * Copy binary VFS mount flags we are interested in.
1776          */
1777         if (fc->sb_flags & SB_RDONLY)
1778                 mp->m_flags |= XFS_MOUNT_RDONLY;
1779         if (fc->sb_flags & SB_DIRSYNC)
1780                 mp->m_flags |= XFS_MOUNT_DIRSYNC;
1781         if (fc->sb_flags & SB_SYNCHRONOUS)
1782                 mp->m_flags |= XFS_MOUNT_WSYNC;
1783
1784         fc->s_fs_info = mp;
1785         fc->ops = &xfs_context_ops;
1786
1787         return 0;
1788 }
1789
1790 static struct file_system_type xfs_fs_type = {
1791         .owner                  = THIS_MODULE,
1792         .name                   = "xfs",
1793         .init_fs_context        = xfs_init_fs_context,
1794         .parameters             = xfs_fs_parameters,
1795         .kill_sb                = kill_block_super,
1796         .fs_flags               = FS_REQUIRES_DEV,
1797 };
1798 MODULE_ALIAS_FS("xfs");
1799
1800 STATIC int __init
1801 xfs_init_zones(void)
1802 {
1803         xfs_log_ticket_zone = kmem_cache_create("xfs_log_ticket",
1804                                                 sizeof(struct xlog_ticket),
1805                                                 0, 0, NULL);
1806         if (!xfs_log_ticket_zone)
1807                 goto out;
1808
1809         xfs_bmap_free_item_zone = kmem_cache_create("xfs_bmap_free_item",
1810                                         sizeof(struct xfs_extent_free_item),
1811                                         0, 0, NULL);
1812         if (!xfs_bmap_free_item_zone)
1813                 goto out_destroy_log_ticket_zone;
1814
1815         xfs_btree_cur_zone = kmem_cache_create("xfs_btree_cur",
1816                                                sizeof(struct xfs_btree_cur),
1817                                                0, 0, NULL);
1818         if (!xfs_btree_cur_zone)
1819                 goto out_destroy_bmap_free_item_zone;
1820
1821         xfs_da_state_zone = kmem_cache_create("xfs_da_state",
1822                                               sizeof(struct xfs_da_state),
1823                                               0, 0, NULL);
1824         if (!xfs_da_state_zone)
1825                 goto out_destroy_btree_cur_zone;
1826
1827         xfs_ifork_zone = kmem_cache_create("xfs_ifork",
1828                                            sizeof(struct xfs_ifork),
1829                                            0, 0, NULL);
1830         if (!xfs_ifork_zone)
1831                 goto out_destroy_da_state_zone;
1832
1833         xfs_trans_zone = kmem_cache_create("xf_trans",
1834                                            sizeof(struct xfs_trans),
1835                                            0, 0, NULL);
1836         if (!xfs_trans_zone)
1837                 goto out_destroy_ifork_zone;
1838
1839
1840         /*
1841          * The size of the zone allocated buf log item is the maximum
1842          * size possible under XFS.  This wastes a little bit of memory,
1843          * but it is much faster.
1844          */
1845         xfs_buf_item_zone = kmem_cache_create("xfs_buf_item",
1846                                               sizeof(struct xfs_buf_log_item),
1847                                               0, 0, NULL);
1848         if (!xfs_buf_item_zone)
1849                 goto out_destroy_trans_zone;
1850
1851         xfs_efd_zone = kmem_cache_create("xfs_efd_item",
1852                                         (sizeof(struct xfs_efd_log_item) +
1853                                         (XFS_EFD_MAX_FAST_EXTENTS - 1) *
1854                                         sizeof(struct xfs_extent)),
1855                                         0, 0, NULL);
1856         if (!xfs_efd_zone)
1857                 goto out_destroy_buf_item_zone;
1858
1859         xfs_efi_zone = kmem_cache_create("xfs_efi_item",
1860                                          (sizeof(struct xfs_efi_log_item) +
1861                                          (XFS_EFI_MAX_FAST_EXTENTS - 1) *
1862                                          sizeof(struct xfs_extent)),
1863                                          0, 0, NULL);
1864         if (!xfs_efi_zone)
1865                 goto out_destroy_efd_zone;
1866
1867         xfs_inode_zone = kmem_cache_create("xfs_inode",
1868                                            sizeof(struct xfs_inode), 0,
1869                                            (SLAB_HWCACHE_ALIGN |
1870                                             SLAB_RECLAIM_ACCOUNT |
1871                                             SLAB_MEM_SPREAD | SLAB_ACCOUNT),
1872                                            xfs_fs_inode_init_once);
1873         if (!xfs_inode_zone)
1874                 goto out_destroy_efi_zone;
1875
1876         xfs_ili_zone = kmem_cache_create("xfs_ili",
1877                                          sizeof(struct xfs_inode_log_item), 0,
1878                                          SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD,
1879                                          NULL);
1880         if (!xfs_ili_zone)
1881                 goto out_destroy_inode_zone;
1882
1883         xfs_icreate_zone = kmem_cache_create("xfs_icr",
1884                                              sizeof(struct xfs_icreate_item),
1885                                              0, 0, NULL);
1886         if (!xfs_icreate_zone)
1887                 goto out_destroy_ili_zone;
1888
1889         xfs_rud_zone = kmem_cache_create("xfs_rud_item",
1890                                          sizeof(struct xfs_rud_log_item),
1891                                          0, 0, NULL);
1892         if (!xfs_rud_zone)
1893                 goto out_destroy_icreate_zone;
1894
1895         xfs_rui_zone = kmem_cache_create("xfs_rui_item",
1896                         xfs_rui_log_item_sizeof(XFS_RUI_MAX_FAST_EXTENTS),
1897                         0, 0, NULL);
1898         if (!xfs_rui_zone)
1899                 goto out_destroy_rud_zone;
1900
1901         xfs_cud_zone = kmem_cache_create("xfs_cud_item",
1902                                          sizeof(struct xfs_cud_log_item),
1903                                          0, 0, NULL);
1904         if (!xfs_cud_zone)
1905                 goto out_destroy_rui_zone;
1906
1907         xfs_cui_zone = kmem_cache_create("xfs_cui_item",
1908                         xfs_cui_log_item_sizeof(XFS_CUI_MAX_FAST_EXTENTS),
1909                         0, 0, NULL);
1910         if (!xfs_cui_zone)
1911                 goto out_destroy_cud_zone;
1912
1913         xfs_bud_zone = kmem_cache_create("xfs_bud_item",
1914                                          sizeof(struct xfs_bud_log_item),
1915                                          0, 0, NULL);
1916         if (!xfs_bud_zone)
1917                 goto out_destroy_cui_zone;
1918
1919         xfs_bui_zone = kmem_cache_create("xfs_bui_item",
1920                         xfs_bui_log_item_sizeof(XFS_BUI_MAX_FAST_EXTENTS),
1921                         0, 0, NULL);
1922         if (!xfs_bui_zone)
1923                 goto out_destroy_bud_zone;
1924
1925         return 0;
1926
1927  out_destroy_bud_zone:
1928         kmem_cache_destroy(xfs_bud_zone);
1929  out_destroy_cui_zone:
1930         kmem_cache_destroy(xfs_cui_zone);
1931  out_destroy_cud_zone:
1932         kmem_cache_destroy(xfs_cud_zone);
1933  out_destroy_rui_zone:
1934         kmem_cache_destroy(xfs_rui_zone);
1935  out_destroy_rud_zone:
1936         kmem_cache_destroy(xfs_rud_zone);
1937  out_destroy_icreate_zone:
1938         kmem_cache_destroy(xfs_icreate_zone);
1939  out_destroy_ili_zone:
1940         kmem_cache_destroy(xfs_ili_zone);
1941  out_destroy_inode_zone:
1942         kmem_cache_destroy(xfs_inode_zone);
1943  out_destroy_efi_zone:
1944         kmem_cache_destroy(xfs_efi_zone);
1945  out_destroy_efd_zone:
1946         kmem_cache_destroy(xfs_efd_zone);
1947  out_destroy_buf_item_zone:
1948         kmem_cache_destroy(xfs_buf_item_zone);
1949  out_destroy_trans_zone:
1950         kmem_cache_destroy(xfs_trans_zone);
1951  out_destroy_ifork_zone:
1952         kmem_cache_destroy(xfs_ifork_zone);
1953  out_destroy_da_state_zone:
1954         kmem_cache_destroy(xfs_da_state_zone);
1955  out_destroy_btree_cur_zone:
1956         kmem_cache_destroy(xfs_btree_cur_zone);
1957  out_destroy_bmap_free_item_zone:
1958         kmem_cache_destroy(xfs_bmap_free_item_zone);
1959  out_destroy_log_ticket_zone:
1960         kmem_cache_destroy(xfs_log_ticket_zone);
1961  out:
1962         return -ENOMEM;
1963 }
1964
1965 STATIC void
1966 xfs_destroy_zones(void)
1967 {
1968         /*
1969          * Make sure all delayed rcu free are flushed before we
1970          * destroy caches.
1971          */
1972         rcu_barrier();
1973         kmem_cache_destroy(xfs_bui_zone);
1974         kmem_cache_destroy(xfs_bud_zone);
1975         kmem_cache_destroy(xfs_cui_zone);
1976         kmem_cache_destroy(xfs_cud_zone);
1977         kmem_cache_destroy(xfs_rui_zone);
1978         kmem_cache_destroy(xfs_rud_zone);
1979         kmem_cache_destroy(xfs_icreate_zone);
1980         kmem_cache_destroy(xfs_ili_zone);
1981         kmem_cache_destroy(xfs_inode_zone);
1982         kmem_cache_destroy(xfs_efi_zone);
1983         kmem_cache_destroy(xfs_efd_zone);
1984         kmem_cache_destroy(xfs_buf_item_zone);
1985         kmem_cache_destroy(xfs_trans_zone);
1986         kmem_cache_destroy(xfs_ifork_zone);
1987         kmem_cache_destroy(xfs_da_state_zone);
1988         kmem_cache_destroy(xfs_btree_cur_zone);
1989         kmem_cache_destroy(xfs_bmap_free_item_zone);
1990         kmem_cache_destroy(xfs_log_ticket_zone);
1991 }
1992
1993 STATIC int __init
1994 xfs_init_workqueues(void)
1995 {
1996         /*
1997          * The allocation workqueue can be used in memory reclaim situations
1998          * (writepage path), and parallelism is only limited by the number of
1999          * AGs in all the filesystems mounted. Hence use the default large
2000          * max_active value for this workqueue.
2001          */
2002         xfs_alloc_wq = alloc_workqueue("xfsalloc",
2003                         WQ_MEM_RECLAIM|WQ_FREEZABLE, 0);
2004         if (!xfs_alloc_wq)
2005                 return -ENOMEM;
2006
2007         xfs_discard_wq = alloc_workqueue("xfsdiscard", WQ_UNBOUND, 0);
2008         if (!xfs_discard_wq)
2009                 goto out_free_alloc_wq;
2010
2011         return 0;
2012 out_free_alloc_wq:
2013         destroy_workqueue(xfs_alloc_wq);
2014         return -ENOMEM;
2015 }
2016
2017 STATIC void
2018 xfs_destroy_workqueues(void)
2019 {
2020         destroy_workqueue(xfs_discard_wq);
2021         destroy_workqueue(xfs_alloc_wq);
2022 }
2023
2024 STATIC int __init
2025 init_xfs_fs(void)
2026 {
2027         int                     error;
2028
2029         xfs_check_ondisk_structs();
2030
2031         printk(KERN_INFO XFS_VERSION_STRING " with "
2032                          XFS_BUILD_OPTIONS " enabled\n");
2033
2034         xfs_dir_startup();
2035
2036         error = xfs_init_zones();
2037         if (error)
2038                 goto out;
2039
2040         error = xfs_init_workqueues();
2041         if (error)
2042                 goto out_destroy_zones;
2043
2044         error = xfs_mru_cache_init();
2045         if (error)
2046                 goto out_destroy_wq;
2047
2048         error = xfs_buf_init();
2049         if (error)
2050                 goto out_mru_cache_uninit;
2051
2052         error = xfs_init_procfs();
2053         if (error)
2054                 goto out_buf_terminate;
2055
2056         error = xfs_sysctl_register();
2057         if (error)
2058                 goto out_cleanup_procfs;
2059
2060         xfs_kset = kset_create_and_add("xfs", NULL, fs_kobj);
2061         if (!xfs_kset) {
2062                 error = -ENOMEM;
2063                 goto out_sysctl_unregister;
2064         }
2065
2066         xfsstats.xs_kobj.kobject.kset = xfs_kset;
2067
2068         xfsstats.xs_stats = alloc_percpu(struct xfsstats);
2069         if (!xfsstats.xs_stats) {
2070                 error = -ENOMEM;
2071                 goto out_kset_unregister;
2072         }
2073
2074         error = xfs_sysfs_init(&xfsstats.xs_kobj, &xfs_stats_ktype, NULL,
2075                                "stats");
2076         if (error)
2077                 goto out_free_stats;
2078
2079 #ifdef DEBUG
2080         xfs_dbg_kobj.kobject.kset = xfs_kset;
2081         error = xfs_sysfs_init(&xfs_dbg_kobj, &xfs_dbg_ktype, NULL, "debug");
2082         if (error)
2083                 goto out_remove_stats_kobj;
2084 #endif
2085
2086         error = xfs_qm_init();
2087         if (error)
2088                 goto out_remove_dbg_kobj;
2089
2090         error = register_filesystem(&xfs_fs_type);
2091         if (error)
2092                 goto out_qm_exit;
2093         return 0;
2094
2095  out_qm_exit:
2096         xfs_qm_exit();
2097  out_remove_dbg_kobj:
2098 #ifdef DEBUG
2099         xfs_sysfs_del(&xfs_dbg_kobj);
2100  out_remove_stats_kobj:
2101 #endif
2102         xfs_sysfs_del(&xfsstats.xs_kobj);
2103  out_free_stats:
2104         free_percpu(xfsstats.xs_stats);
2105  out_kset_unregister:
2106         kset_unregister(xfs_kset);
2107  out_sysctl_unregister:
2108         xfs_sysctl_unregister();
2109  out_cleanup_procfs:
2110         xfs_cleanup_procfs();
2111  out_buf_terminate:
2112         xfs_buf_terminate();
2113  out_mru_cache_uninit:
2114         xfs_mru_cache_uninit();
2115  out_destroy_wq:
2116         xfs_destroy_workqueues();
2117  out_destroy_zones:
2118         xfs_destroy_zones();
2119  out:
2120         return error;
2121 }
2122
2123 STATIC void __exit
2124 exit_xfs_fs(void)
2125 {
2126         xfs_qm_exit();
2127         unregister_filesystem(&xfs_fs_type);
2128 #ifdef DEBUG
2129         xfs_sysfs_del(&xfs_dbg_kobj);
2130 #endif
2131         xfs_sysfs_del(&xfsstats.xs_kobj);
2132         free_percpu(xfsstats.xs_stats);
2133         kset_unregister(xfs_kset);
2134         xfs_sysctl_unregister();
2135         xfs_cleanup_procfs();
2136         xfs_buf_terminate();
2137         xfs_mru_cache_uninit();
2138         xfs_destroy_workqueues();
2139         xfs_destroy_zones();
2140         xfs_uuid_table_free();
2141 }
2142
2143 module_init(init_xfs_fs);
2144 module_exit(exit_xfs_fs);
2145
2146 MODULE_AUTHOR("Silicon Graphics, Inc.");
2147 MODULE_DESCRIPTION(XFS_VERSION_STRING " with " XFS_BUILD_OPTIONS " enabled");
2148 MODULE_LICENSE("GPL");