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