fs/xfs/xfs_super.c

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