fs/xfs/linux-2.6/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 #include "xfs.h"
  19 #include "xfs_bit.h"
  20 #include "xfs_log.h"
  21 #include "xfs_clnt.h"
  22 #include "xfs_inum.h"
  23 #include "xfs_trans.h"
  24 #include "xfs_sb.h"
  25 #include "xfs_ag.h"
  26 #include "xfs_dir2.h"
  27 #include "xfs_alloc.h"
  28 #include "xfs_dmapi.h"
  29 #include "xfs_quota.h"
  30 #include "xfs_mount.h"
  31 #include "xfs_bmap_btree.h"
  32 #include "xfs_alloc_btree.h"
  33 #include "xfs_ialloc_btree.h"
  34 #include "xfs_dir2_sf.h"
  35 #include "xfs_attr_sf.h"
  36 #include "xfs_dinode.h"
  37 #include "xfs_inode.h"
  38 #include "xfs_btree.h"
  39 #include "xfs_ialloc.h"
  40 #include "xfs_bmap.h"
  41 #include "xfs_rtalloc.h"
  42 #include "xfs_error.h"
  43 #include "xfs_itable.h"
  44 #include "xfs_fsops.h"
  45 #include "xfs_rw.h"
  46 #include "xfs_acl.h"
  47 #include "xfs_attr.h"
  48 #include "xfs_buf_item.h"
  49 #include "xfs_utils.h"
  50 #include "xfs_vnodeops.h"
  51 #include "xfs_vfsops.h"
  52 #include "xfs_version.h"
  53 #include "xfs_log_priv.h"
  54 #include "xfs_trans_priv.h"
  55
  56 #include <linux/namei.h>
  57 #include <linux/init.h>
  58 #include <linux/mount.h>
  59 #include <linux/mempool.h>
  60 #include <linux/writeback.h>
  61 #include <linux/kthread.h>
  62 #include <linux/freezer.h>
  63
  64 static struct quotactl_ops xfs_quotactl_operations;
  65 static struct super_operations xfs_super_operations;
  66 static kmem_zone_t *xfs_vnode_zone;
  67 static kmem_zone_t *xfs_ioend_zone;
  68 mempool_t *xfs_ioend_pool;
  69
  70 STATIC struct xfs_mount_args *
  71 xfs_args_allocate(
  72         struct super_block      *sb,
  73         int                     silent)
  74 {
  75         struct xfs_mount_args   *args;
  76
  77         args = kmem_zalloc(sizeof(struct xfs_mount_args), KM_SLEEP);
  78         args->logbufs = args->logbufsize = -1;
  79         strncpy(args->fsname, sb->s_id, MAXNAMELEN);
  80
  81         /* Copy the already-parsed mount(2) flags we're interested in */
  82         if (sb->s_flags & MS_DIRSYNC)
  83                 args->flags |= XFSMNT_DIRSYNC;
  84         if (sb->s_flags & MS_SYNCHRONOUS)
  85                 args->flags |= XFSMNT_WSYNC;
  86         if (silent)
  87                 args->flags |= XFSMNT_QUIET;
  88         args->flags |= XFSMNT_32BITINODES;
  89
  90         return args;
  91 }
  92
  93 #define MNTOPT_LOGBUFS  "logbufs"       /* number of XFS log buffers */
  94 #define MNTOPT_LOGBSIZE "logbsize"      /* size of XFS log buffers */
  95 #define MNTOPT_LOGDEV   "logdev"        /* log device */
  96 #define MNTOPT_RTDEV    "rtdev"         /* realtime I/O device */
  97 #define MNTOPT_BIOSIZE  "biosize"       /* log2 of preferred buffered io size */
  98 #define MNTOPT_WSYNC    "wsync"         /* safe-mode nfs compatible mount */
  99 #define MNTOPT_INO64    "ino64"         /* force inodes into 64-bit range */
 100 #define MNTOPT_NOALIGN  "noalign"       /* turn off stripe alignment */
 101 #define MNTOPT_SWALLOC  "swalloc"       /* turn on stripe width allocation */
 102 #define MNTOPT_SUNIT    "sunit"         /* data volume stripe unit */
 103 #define MNTOPT_SWIDTH   "swidth"        /* data volume stripe width */
 104 #define MNTOPT_NOUUID   "nouuid"        /* ignore filesystem UUID */
 105 #define MNTOPT_MTPT     "mtpt"          /* filesystem mount point */
 106 #define MNTOPT_GRPID    "grpid"         /* group-ID from parent directory */
 107 #define MNTOPT_NOGRPID  "nogrpid"       /* group-ID from current process */
 108 #define MNTOPT_BSDGROUPS    "bsdgroups"    /* group-ID from parent directory */
 109 #define MNTOPT_SYSVGROUPS   "sysvgroups"   /* group-ID from current process */
 110 #define MNTOPT_ALLOCSIZE    "allocsize"    /* preferred allocation size */
 111 #define MNTOPT_NORECOVERY   "norecovery"   /* don't run XFS recovery */
 112 #define MNTOPT_BARRIER  "barrier"       /* use writer barriers for log write and
 113                                          * unwritten extent conversion */
 114 #define MNTOPT_NOBARRIER "nobarrier"    /* .. disable */
 115 #define MNTOPT_OSYNCISOSYNC "osyncisosync" /* o_sync is REALLY o_sync */
 116 #define MNTOPT_64BITINODE   "inode64"   /* inodes can be allocated anywhere */
 117 #define MNTOPT_IKEEP    "ikeep"         /* do not free empty inode clusters */
 118 #define MNTOPT_NOIKEEP  "noikeep"       /* free empty inode clusters */
 119 #define MNTOPT_LARGEIO     "largeio"    /* report large I/O sizes in stat() */
 120 #define MNTOPT_NOLARGEIO   "nolargeio"  /* do not report large I/O sizes
 121                                          * in stat(). */
 122 #define MNTOPT_ATTR2    "attr2"         /* do use attr2 attribute format */
 123 #define MNTOPT_NOATTR2  "noattr2"       /* do not use attr2 attribute format */
 124 #define MNTOPT_FILESTREAM  "filestreams" /* use filestreams allocator */
 125 #define MNTOPT_QUOTA    "quota"         /* disk quotas (user) */
 126 #define MNTOPT_NOQUOTA  "noquota"       /* no quotas */
 127 #define MNTOPT_USRQUOTA "usrquota"      /* user quota enabled */
 128 #define MNTOPT_GRPQUOTA "grpquota"      /* group quota enabled */
 129 #define MNTOPT_PRJQUOTA "prjquota"      /* project quota enabled */
 130 #define MNTOPT_UQUOTA   "uquota"        /* user quota (IRIX variant) */
 131 #define MNTOPT_GQUOTA   "gquota"        /* group quota (IRIX variant) */
 132 #define MNTOPT_PQUOTA   "pquota"        /* project quota (IRIX variant) */
 133 #define MNTOPT_UQUOTANOENF "uqnoenforce"/* user quota limit enforcement */
 134 #define MNTOPT_GQUOTANOENF "gqnoenforce"/* group quota limit enforcement */
 135 #define MNTOPT_PQUOTANOENF "pqnoenforce"/* project quota limit enforcement */
 136 #define MNTOPT_QUOTANOENF  "qnoenforce" /* same as uqnoenforce */
 137 #define MNTOPT_DMAPI    "dmapi"         /* DMI enabled (DMAPI / XDSM) */
 138 #define MNTOPT_XDSM     "xdsm"          /* DMI enabled (DMAPI / XDSM) */
 139 #define MNTOPT_DMI      "dmi"           /* DMI enabled (DMAPI / XDSM) */
 140
 141 STATIC unsigned long
 142 suffix_strtoul(char *s, char **endp, unsigned int base)
 143 {
 144         int     last, shift_left_factor = 0;
 145         char    *value = s;
 146
 147         last = strlen(value) - 1;
 148         if (value[last] == 'K' || value[last] == 'k') {
 149                 shift_left_factor = 10;
 150                 value[last] = '\0';
 151         }
 152         if (value[last] == 'M' || value[last] == 'm') {
 153                 shift_left_factor = 20;
 154                 value[last] = '\0';
 155         }
 156         if (value[last] == 'G' || value[last] == 'g') {
 157                 shift_left_factor = 30;
 158                 value[last] = '\0';
 159         }
 160
 161         return simple_strtoul((const char *)s, endp, base) << shift_left_factor;
 162 }
 163
 164 STATIC int
 165 xfs_parseargs(
 166         struct xfs_mount        *mp,
 167         char                    *options,
 168         struct xfs_mount_args   *args,
 169         int                     update)
 170 {
 171         char                    *this_char, *value, *eov;
 172         int                     dsunit, dswidth, vol_dsunit, vol_dswidth;
 173         int                     iosize;
 174         int                     dmapi_implies_ikeep = 1;
 175
 176         args->flags |= XFSMNT_BARRIER;
 177         args->flags2 |= XFSMNT2_COMPAT_IOSIZE;
 178
 179         if (!options)
 180                 goto done;
 181
 182         iosize = dsunit = dswidth = vol_dsunit = vol_dswidth = 0;
 183
 184         while ((this_char = strsep(&options, ",")) != NULL) {
 185                 if (!*this_char)
 186                         continue;
 187                 if ((value = strchr(this_char, '=')) != NULL)
 188                         *value++ = 0;
 189
 190                 if (!strcmp(this_char, MNTOPT_LOGBUFS)) {
 191                         if (!value || !*value) {
 192                                 cmn_err(CE_WARN,
 193                                         "XFS: %s option requires an argument",
 194                                         this_char);
 195                                 return EINVAL;
 196                         }
 197                         args->logbufs = simple_strtoul(value, &eov, 10);
 198                 } else if (!strcmp(this_char, MNTOPT_LOGBSIZE)) {
 199                         if (!value || !*value) {
 200                                 cmn_err(CE_WARN,
 201                                         "XFS: %s option requires an argument",
 202                                         this_char);
 203                                 return EINVAL;
 204                         }
 205                         args->logbufsize = suffix_strtoul(value, &eov, 10);
 206                 } else if (!strcmp(this_char, MNTOPT_LOGDEV)) {
 207                         if (!value || !*value) {
 208                                 cmn_err(CE_WARN,
 209                                         "XFS: %s option requires an argument",
 210                                         this_char);
 211                                 return EINVAL;
 212                         }
 213                         strncpy(args->logname, value, MAXNAMELEN);
 214                 } else if (!strcmp(this_char, MNTOPT_MTPT)) {
 215                         if (!value || !*value) {
 216                                 cmn_err(CE_WARN,
 217                                         "XFS: %s option requires an argument",
 218                                         this_char);
 219                                 return EINVAL;
 220                         }
 221                         strncpy(args->mtpt, value, MAXNAMELEN);
 222                 } else if (!strcmp(this_char, MNTOPT_RTDEV)) {
 223                         if (!value || !*value) {
 224                                 cmn_err(CE_WARN,
 225                                         "XFS: %s option requires an argument",
 226                                         this_char);
 227                                 return EINVAL;
 228                         }
 229                         strncpy(args->rtname, value, MAXNAMELEN);
 230                 } else if (!strcmp(this_char, MNTOPT_BIOSIZE)) {
 231                         if (!value || !*value) {
 232                                 cmn_err(CE_WARN,
 233                                         "XFS: %s option requires an argument",
 234                                         this_char);
 235                                 return EINVAL;
 236                         }
 237                         iosize = simple_strtoul(value, &eov, 10);
 238                         args->flags |= XFSMNT_IOSIZE;
 239                         args->iosizelog = (uint8_t) iosize;
 240                 } else if (!strcmp(this_char, MNTOPT_ALLOCSIZE)) {
 241                         if (!value || !*value) {
 242                                 cmn_err(CE_WARN,
 243                                         "XFS: %s option requires an argument",
 244                                         this_char);
 245                                 return EINVAL;
 246                         }
 247                         iosize = suffix_strtoul(value, &eov, 10);
 248                         args->flags |= XFSMNT_IOSIZE;
 249                         args->iosizelog = ffs(iosize) - 1;
 250                 } else if (!strcmp(this_char, MNTOPT_GRPID) ||
 251                            !strcmp(this_char, MNTOPT_BSDGROUPS)) {
 252                         mp->m_flags |= XFS_MOUNT_GRPID;
 253                 } else if (!strcmp(this_char, MNTOPT_NOGRPID) ||
 254                            !strcmp(this_char, MNTOPT_SYSVGROUPS)) {
 255                         mp->m_flags &= ~XFS_MOUNT_GRPID;
 256                 } else if (!strcmp(this_char, MNTOPT_WSYNC)) {
 257                         args->flags |= XFSMNT_WSYNC;
 258                 } else if (!strcmp(this_char, MNTOPT_OSYNCISOSYNC)) {
 259                         args->flags |= XFSMNT_OSYNCISOSYNC;
 260                 } else if (!strcmp(this_char, MNTOPT_NORECOVERY)) {
 261                         args->flags |= XFSMNT_NORECOVERY;
 262                 } else if (!strcmp(this_char, MNTOPT_INO64)) {
 263                         args->flags |= XFSMNT_INO64;
 264 #if !XFS_BIG_INUMS
 265                         cmn_err(CE_WARN,
 266                                 "XFS: %s option not allowed on this system",
 267                                 this_char);
 268                         return EINVAL;
 269 #endif
 270                 } else if (!strcmp(this_char, MNTOPT_NOALIGN)) {
 271                         args->flags |= XFSMNT_NOALIGN;
 272                 } else if (!strcmp(this_char, MNTOPT_SWALLOC)) {
 273                         args->flags |= XFSMNT_SWALLOC;
 274                 } else if (!strcmp(this_char, MNTOPT_SUNIT)) {
 275                         if (!value || !*value) {
 276                                 cmn_err(CE_WARN,
 277                                         "XFS: %s option requires an argument",
 278                                         this_char);
 279                                 return EINVAL;
 280                         }
 281                         dsunit = simple_strtoul(value, &eov, 10);
 282                 } else if (!strcmp(this_char, MNTOPT_SWIDTH)) {
 283                         if (!value || !*value) {
 284                                 cmn_err(CE_WARN,
 285                                         "XFS: %s option requires an argument",
 286                                         this_char);
 287                                 return EINVAL;
 288                         }
 289                         dswidth = simple_strtoul(value, &eov, 10);
 290                 } else if (!strcmp(this_char, MNTOPT_64BITINODE)) {
 291                         args->flags &= ~XFSMNT_32BITINODES;
 292 #if !XFS_BIG_INUMS
 293                         cmn_err(CE_WARN,
 294                                 "XFS: %s option not allowed on this system",
 295                                 this_char);
 296                         return EINVAL;
 297 #endif
 298                 } else if (!strcmp(this_char, MNTOPT_NOUUID)) {
 299                         args->flags |= XFSMNT_NOUUID;
 300                 } else if (!strcmp(this_char, MNTOPT_BARRIER)) {
 301                         args->flags |= XFSMNT_BARRIER;
 302                 } else if (!strcmp(this_char, MNTOPT_NOBARRIER)) {
 303                         args->flags &= ~XFSMNT_BARRIER;
 304                 } else if (!strcmp(this_char, MNTOPT_IKEEP)) {
 305                         args->flags |= XFSMNT_IKEEP;
 306                 } else if (!strcmp(this_char, MNTOPT_NOIKEEP)) {
 307                         dmapi_implies_ikeep = 0;
 308                         args->flags &= ~XFSMNT_IKEEP;
 309                 } else if (!strcmp(this_char, MNTOPT_LARGEIO)) {
 310                         args->flags2 &= ~XFSMNT2_COMPAT_IOSIZE;
 311                 } else if (!strcmp(this_char, MNTOPT_NOLARGEIO)) {
 312                         args->flags2 |= XFSMNT2_COMPAT_IOSIZE;
 313                 } else if (!strcmp(this_char, MNTOPT_ATTR2)) {
 314                         args->flags |= XFSMNT_ATTR2;
 315                 } else if (!strcmp(this_char, MNTOPT_NOATTR2)) {
 316                         args->flags &= ~XFSMNT_ATTR2;
 317                         args->flags |= XFSMNT_NOATTR2;
 318                 } else if (!strcmp(this_char, MNTOPT_FILESTREAM)) {
 319                         args->flags2 |= XFSMNT2_FILESTREAMS;
 320                 } else if (!strcmp(this_char, MNTOPT_NOQUOTA)) {
 321                         args->flags &= ~(XFSMNT_UQUOTAENF|XFSMNT_UQUOTA);
 322                         args->flags &= ~(XFSMNT_GQUOTAENF|XFSMNT_GQUOTA);
 323                 } else if (!strcmp(this_char, MNTOPT_QUOTA) ||
 324                            !strcmp(this_char, MNTOPT_UQUOTA) ||
 325                            !strcmp(this_char, MNTOPT_USRQUOTA)) {
 326                         args->flags |= XFSMNT_UQUOTA | XFSMNT_UQUOTAENF;
 327                 } else if (!strcmp(this_char, MNTOPT_QUOTANOENF) ||
 328                            !strcmp(this_char, MNTOPT_UQUOTANOENF)) {
 329                         args->flags |= XFSMNT_UQUOTA;
 330                         args->flags &= ~XFSMNT_UQUOTAENF;
 331                 } else if (!strcmp(this_char, MNTOPT_PQUOTA) ||
 332                            !strcmp(this_char, MNTOPT_PRJQUOTA)) {
 333                         args->flags |= XFSMNT_PQUOTA | XFSMNT_PQUOTAENF;
 334                 } else if (!strcmp(this_char, MNTOPT_PQUOTANOENF)) {
 335                         args->flags |= XFSMNT_PQUOTA;
 336                         args->flags &= ~XFSMNT_PQUOTAENF;
 337                 } else if (!strcmp(this_char, MNTOPT_GQUOTA) ||
 338                            !strcmp(this_char, MNTOPT_GRPQUOTA)) {
 339                         args->flags |= XFSMNT_GQUOTA | XFSMNT_GQUOTAENF;
 340                 } else if (!strcmp(this_char, MNTOPT_GQUOTANOENF)) {
 341                         args->flags |= XFSMNT_GQUOTA;
 342                         args->flags &= ~XFSMNT_GQUOTAENF;
 343                 } else if (!strcmp(this_char, MNTOPT_DMAPI)) {
 344                         args->flags |= XFSMNT_DMAPI;
 345                 } else if (!strcmp(this_char, MNTOPT_XDSM)) {
 346                         args->flags |= XFSMNT_DMAPI;
 347                 } else if (!strcmp(this_char, MNTOPT_DMI)) {
 348                         args->flags |= XFSMNT_DMAPI;
 349                 } else if (!strcmp(this_char, "ihashsize")) {
 350                         cmn_err(CE_WARN,
 351         "XFS: ihashsize no longer used, option is deprecated.");
 352                 } else if (!strcmp(this_char, "osyncisdsync")) {
 353                         /* no-op, this is now the default */
 354                         cmn_err(CE_WARN,
 355         "XFS: osyncisdsync is now the default, option is deprecated.");
 356                 } else if (!strcmp(this_char, "irixsgid")) {
 357                         cmn_err(CE_WARN,
 358         "XFS: irixsgid is now a sysctl(2) variable, option is deprecated.");
 359                 } else {
 360                         cmn_err(CE_WARN,
 361                                 "XFS: unknown mount option [%s].", this_char);
 362                         return EINVAL;
 363                 }
 364         }
 365
 366         if (args->flags & XFSMNT_NORECOVERY) {
 367                 if ((mp->m_flags & XFS_MOUNT_RDONLY) == 0) {
 368                         cmn_err(CE_WARN,
 369                                 "XFS: no-recovery mounts must be read-only.");
 370                         return EINVAL;
 371                 }
 372         }
 373
 374         if ((args->flags & XFSMNT_NOALIGN) && (dsunit || dswidth)) {
 375                 cmn_err(CE_WARN,
 376         "XFS: sunit and swidth options incompatible with the noalign option");
 377                 return EINVAL;
 378         }
 379
 380         if ((args->flags & XFSMNT_GQUOTA) && (args->flags & XFSMNT_PQUOTA)) {
 381                 cmn_err(CE_WARN,
 382                         "XFS: cannot mount with both project and group quota");
 383                 return EINVAL;
 384         }
 385
 386         if ((args->flags & XFSMNT_DMAPI) && *args->mtpt == '\0') {
 387                 printk("XFS: %s option needs the mount point option as well\n",
 388                         MNTOPT_DMAPI);
 389                 return EINVAL;
 390         }
 391
 392         if ((dsunit && !dswidth) || (!dsunit && dswidth)) {
 393                 cmn_err(CE_WARN,
 394                         "XFS: sunit and swidth must be specified together");
 395                 return EINVAL;
 396         }
 397
 398         if (dsunit && (dswidth % dsunit != 0)) {
 399                 cmn_err(CE_WARN,
 400         "XFS: stripe width (%d) must be a multiple of the stripe unit (%d)",
 401                         dswidth, dsunit);
 402                 return EINVAL;
 403         }
 404
 405         /*
 406          * Applications using DMI filesystems often expect the
 407          * inode generation number to be monotonically increasing.
 408          * If we delete inode chunks we break this assumption, so
 409          * keep unused inode chunks on disk for DMI filesystems
 410          * until we come up with a better solution.
 411          * Note that if "ikeep" or "noikeep" mount options are
 412          * supplied, then they are honored.
 413          */
 414         if ((args->flags & XFSMNT_DMAPI) && dmapi_implies_ikeep)
 415                 args->flags |= XFSMNT_IKEEP;
 416
 417         if ((args->flags & XFSMNT_NOALIGN) != XFSMNT_NOALIGN) {
 418                 if (dsunit) {
 419                         args->sunit = dsunit;
 420                         args->flags |= XFSMNT_RETERR;
 421                 } else {
 422                         args->sunit = vol_dsunit;
 423                 }
 424                 dswidth ? (args->swidth = dswidth) :
 425                           (args->swidth = vol_dswidth);
 426         } else {
 427                 args->sunit = args->swidth = 0;
 428         }
 429
 430 done:
 431         if (args->flags & XFSMNT_32BITINODES)
 432                 mp->m_flags |= XFS_MOUNT_SMALL_INUMS;
 433         if (args->flags2)
 434                 args->flags |= XFSMNT_FLAGS2;
 435         return 0;
 436 }
 437
 438 struct proc_xfs_info {
 439         int     flag;
 440         char    *str;
 441 };
 442
 443 STATIC int
 444 xfs_showargs(
 445         struct xfs_mount        *mp,
 446         struct seq_file         *m)
 447 {
 448         static struct proc_xfs_info xfs_info_set[] = {
 449                 /* the few simple ones we can get from the mount struct */
 450                 { XFS_MOUNT_IKEEP,              "," MNTOPT_IKEEP },
 451                 { XFS_MOUNT_WSYNC,              "," MNTOPT_WSYNC },
 452                 { XFS_MOUNT_INO64,              "," MNTOPT_INO64 },
 453                 { XFS_MOUNT_NOALIGN,            "," MNTOPT_NOALIGN },
 454                 { XFS_MOUNT_SWALLOC,            "," MNTOPT_SWALLOC },
 455                 { XFS_MOUNT_NOUUID,             "," MNTOPT_NOUUID },
 456                 { XFS_MOUNT_NORECOVERY,         "," MNTOPT_NORECOVERY },
 457                 { XFS_MOUNT_OSYNCISOSYNC,       "," MNTOPT_OSYNCISOSYNC },
 458                 { XFS_MOUNT_ATTR2,              "," MNTOPT_ATTR2 },
 459                 { XFS_MOUNT_FILESTREAMS,        "," MNTOPT_FILESTREAM },
 460                 { XFS_MOUNT_DMAPI,              "," MNTOPT_DMAPI },
 461                 { XFS_MOUNT_GRPID,              "," MNTOPT_GRPID },
 462                 { 0, NULL }
 463         };
 464         static struct proc_xfs_info xfs_info_unset[] = {
 465                 /* the few simple ones we can get from the mount struct */
 466                 { XFS_MOUNT_COMPAT_IOSIZE,      "," MNTOPT_LARGEIO },
 467                 { XFS_MOUNT_BARRIER,            "," MNTOPT_NOBARRIER },
 468                 { XFS_MOUNT_SMALL_INUMS,        "," MNTOPT_64BITINODE },
 469                 { 0, NULL }
 470         };
 471         struct proc_xfs_info    *xfs_infop;
 472
 473         for (xfs_infop = xfs_info_set; xfs_infop->flag; xfs_infop++) {
 474                 if (mp->m_flags & xfs_infop->flag)
 475                         seq_puts(m, xfs_infop->str);
 476         }
 477         for (xfs_infop = xfs_info_unset; xfs_infop->flag; xfs_infop++) {
 478                 if (!(mp->m_flags & xfs_infop->flag))
 479                         seq_puts(m, xfs_infop->str);
 480         }
 481
 482         if (mp->m_flags & XFS_MOUNT_DFLT_IOSIZE)
 483                 seq_printf(m, "," MNTOPT_ALLOCSIZE "=%dk",
 484                                 (int)(1 << mp->m_writeio_log) >> 10);
 485
 486         if (mp->m_logbufs > 0)
 487                 seq_printf(m, "," MNTOPT_LOGBUFS "=%d", mp->m_logbufs);
 488         if (mp->m_logbsize > 0)
 489                 seq_printf(m, "," MNTOPT_LOGBSIZE "=%dk", mp->m_logbsize >> 10);
 490
 491         if (mp->m_logname)
 492                 seq_printf(m, "," MNTOPT_LOGDEV "=%s", mp->m_logname);
 493         if (mp->m_rtname)
 494                 seq_printf(m, "," MNTOPT_RTDEV "=%s", mp->m_rtname);
 495
 496         if (mp->m_dalign > 0)
 497                 seq_printf(m, "," MNTOPT_SUNIT "=%d",
 498                                 (int)XFS_FSB_TO_BB(mp, mp->m_dalign));
 499         if (mp->m_swidth > 0)
 500                 seq_printf(m, "," MNTOPT_SWIDTH "=%d",
 501                                 (int)XFS_FSB_TO_BB(mp, mp->m_swidth));
 502
 503         if (mp->m_qflags & (XFS_UQUOTA_ACCT|XFS_UQUOTA_ENFD))
 504                 seq_puts(m, "," MNTOPT_USRQUOTA);
 505         else if (mp->m_qflags & XFS_UQUOTA_ACCT)
 506                 seq_puts(m, "," MNTOPT_UQUOTANOENF);
 507
 508         if (mp->m_qflags & (XFS_PQUOTA_ACCT|XFS_OQUOTA_ENFD))
 509                 seq_puts(m, "," MNTOPT_PRJQUOTA);
 510         else if (mp->m_qflags & XFS_PQUOTA_ACCT)
 511                 seq_puts(m, "," MNTOPT_PQUOTANOENF);
 512
 513         if (mp->m_qflags & (XFS_GQUOTA_ACCT|XFS_OQUOTA_ENFD))
 514                 seq_puts(m, "," MNTOPT_GRPQUOTA);
 515         else if (mp->m_qflags & XFS_GQUOTA_ACCT)
 516                 seq_puts(m, "," MNTOPT_GQUOTANOENF);
 517
 518         if (!(mp->m_qflags & XFS_ALL_QUOTA_ACCT))
 519                 seq_puts(m, "," MNTOPT_NOQUOTA);
 520
 521         return 0;
 522 }
 523 __uint64_t
 524 xfs_max_file_offset(
 525         unsigned int            blockshift)
 526 {
 527         unsigned int            pagefactor = 1;
 528         unsigned int            bitshift = BITS_PER_LONG - 1;
 529
 530         /* Figure out maximum filesize, on Linux this can depend on
 531          * the filesystem blocksize (on 32 bit platforms).
 532          * __block_prepare_write does this in an [unsigned] long...
 533          *      page->index << (PAGE_CACHE_SHIFT - bbits)
 534          * So, for page sized blocks (4K on 32 bit platforms),
 535          * this wraps at around 8Tb (hence MAX_LFS_FILESIZE which is
 536          *      (((u64)PAGE_CACHE_SIZE << (BITS_PER_LONG-1))-1)
 537          * but for smaller blocksizes it is less (bbits = log2 bsize).
 538          * Note1: get_block_t takes a long (implicit cast from above)
 539          * Note2: The Large Block Device (LBD and HAVE_SECTOR_T) patch
 540          * can optionally convert the [unsigned] long from above into
 541          * an [unsigned] long long.
 542          */
 543
 544 #if BITS_PER_LONG == 32
 545 # if defined(CONFIG_LBD)
 546         ASSERT(sizeof(sector_t) == 8);
 547         pagefactor = PAGE_CACHE_SIZE;
 548         bitshift = BITS_PER_LONG;
 549 # else
 550         pagefactor = PAGE_CACHE_SIZE >> (PAGE_CACHE_SHIFT - blockshift);
 551 # endif
 552 #endif
 553
 554         return (((__uint64_t)pagefactor) << bitshift) - 1;
 555 }
 556
 557 STATIC_INLINE void
 558 xfs_set_inodeops(
 559         struct inode            *inode)
 560 {
 561         switch (inode->i_mode & S_IFMT) {
 562         case S_IFREG:
 563                 inode->i_op = &xfs_inode_operations;
 564                 inode->i_fop = &xfs_file_operations;
 565                 inode->i_mapping->a_ops = &xfs_address_space_operations;
 566                 break;
 567         case S_IFDIR:
 568                 inode->i_op = &xfs_dir_inode_operations;
 569                 inode->i_fop = &xfs_dir_file_operations;
 570                 break;
 571         case S_IFLNK:
 572                 inode->i_op = &xfs_symlink_inode_operations;
 573                 if (!(XFS_I(inode)->i_df.if_flags & XFS_IFINLINE))
 574                         inode->i_mapping->a_ops = &xfs_address_space_operations;
 575                 break;
 576         default:
 577                 inode->i_op = &xfs_inode_operations;
 578                 init_special_inode(inode, inode->i_mode, inode->i_rdev);
 579                 break;
 580         }
 581 }
 582
 583 STATIC_INLINE void
 584 xfs_revalidate_inode(
 585         xfs_mount_t             *mp,
 586         bhv_vnode_t             *vp,
 587         xfs_inode_t             *ip)
 588 {
 589         struct inode            *inode = vn_to_inode(vp);
 590
 591         inode->i_mode   = ip->i_d.di_mode;
 592         inode->i_nlink  = ip->i_d.di_nlink;
 593         inode->i_uid    = ip->i_d.di_uid;
 594         inode->i_gid    = ip->i_d.di_gid;
 595
 596         switch (inode->i_mode & S_IFMT) {
 597         case S_IFBLK:
 598         case S_IFCHR:
 599                 inode->i_rdev =
 600                         MKDEV(sysv_major(ip->i_df.if_u2.if_rdev) & 0x1ff,
 601                               sysv_minor(ip->i_df.if_u2.if_rdev));
 602                 break;
 603         default:
 604                 inode->i_rdev = 0;
 605                 break;
 606         }
 607
 608         inode->i_generation = ip->i_d.di_gen;
 609         i_size_write(inode, ip->i_d.di_size);
 610         inode->i_atime.tv_sec   = ip->i_d.di_atime.t_sec;
 611         inode->i_atime.tv_nsec  = ip->i_d.di_atime.t_nsec;
 612         inode->i_mtime.tv_sec   = ip->i_d.di_mtime.t_sec;
 613         inode->i_mtime.tv_nsec  = ip->i_d.di_mtime.t_nsec;
 614         inode->i_ctime.tv_sec   = ip->i_d.di_ctime.t_sec;
 615         inode->i_ctime.tv_nsec  = ip->i_d.di_ctime.t_nsec;
 616         if (ip->i_d.di_flags & XFS_DIFLAG_IMMUTABLE)
 617                 inode->i_flags |= S_IMMUTABLE;
 618         else
 619                 inode->i_flags &= ~S_IMMUTABLE;
 620         if (ip->i_d.di_flags & XFS_DIFLAG_APPEND)
 621                 inode->i_flags |= S_APPEND;
 622         else
 623                 inode->i_flags &= ~S_APPEND;
 624         if (ip->i_d.di_flags & XFS_DIFLAG_SYNC)
 625                 inode->i_flags |= S_SYNC;
 626         else
 627                 inode->i_flags &= ~S_SYNC;
 628         if (ip->i_d.di_flags & XFS_DIFLAG_NOATIME)
 629                 inode->i_flags |= S_NOATIME;
 630         else
 631                 inode->i_flags &= ~S_NOATIME;
 632         xfs_iflags_clear(ip, XFS_IMODIFIED);
 633 }
 634
 635 void
 636 xfs_initialize_vnode(
 637         struct xfs_mount        *mp,
 638         bhv_vnode_t             *vp,
 639         struct xfs_inode        *ip)
 640 {
 641         struct inode            *inode = vn_to_inode(vp);
 642
 643         if (!ip->i_vnode) {
 644                 ip->i_vnode = vp;
 645                 inode->i_private = ip;
 646         }
 647
 648         /*
 649          * We need to set the ops vectors, and unlock the inode, but if
 650          * we have been called during the new inode create process, it is
 651          * too early to fill in the Linux inode.  We will get called a
 652          * second time once the inode is properly set up, and then we can
 653          * finish our work.
 654          */
 655         if (ip->i_d.di_mode != 0 && (inode->i_state & I_NEW)) {
 656                 xfs_revalidate_inode(mp, vp, ip);
 657                 xfs_set_inodeops(inode);
 658
 659                 xfs_iflags_clear(ip, XFS_INEW);
 660                 barrier();
 661
 662                 unlock_new_inode(inode);
 663         }
 664 }
 665
 666 int
 667 xfs_blkdev_get(
 668         xfs_mount_t             *mp,
 669         const char              *name,
 670         struct block_device     **bdevp)
 671 {
 672         int                     error = 0;
 673
 674         *bdevp = open_bdev_excl(name, 0, mp);
 675         if (IS_ERR(*bdevp)) {
 676                 error = PTR_ERR(*bdevp);
 677                 printk("XFS: Invalid device [%s], error=%d\n", name, error);
 678         }
 679
 680         return -error;
 681 }
 682
 683 void
 684 xfs_blkdev_put(
 685         struct block_device     *bdev)
 686 {
 687         if (bdev)
 688                 close_bdev_excl(bdev);
 689 }
 690
 691 /*
 692  * Try to write out the superblock using barriers.
 693  */
 694 STATIC int
 695 xfs_barrier_test(
 696         xfs_mount_t     *mp)
 697 {
 698         xfs_buf_t       *sbp = xfs_getsb(mp, 0);
 699         int             error;
 700
 701         XFS_BUF_UNDONE(sbp);
 702         XFS_BUF_UNREAD(sbp);
 703         XFS_BUF_UNDELAYWRITE(sbp);
 704         XFS_BUF_WRITE(sbp);
 705         XFS_BUF_UNASYNC(sbp);
 706         XFS_BUF_ORDERED(sbp);
 707
 708         xfsbdstrat(mp, sbp);
 709         error = xfs_iowait(sbp);
 710
 711         /*
 712          * Clear all the flags we set and possible error state in the
 713          * buffer.  We only did the write to try out whether barriers
 714          * worked and shouldn't leave any traces in the superblock
 715          * buffer.
 716          */
 717         XFS_BUF_DONE(sbp);
 718         XFS_BUF_ERROR(sbp, 0);
 719         XFS_BUF_UNORDERED(sbp);
 720
 721         xfs_buf_relse(sbp);
 722         return error;
 723 }
 724
 725 void
 726 xfs_mountfs_check_barriers(xfs_mount_t *mp)
 727 {
 728         int error;
 729
 730         if (mp->m_logdev_targp != mp->m_ddev_targp) {
 731                 xfs_fs_cmn_err(CE_NOTE, mp,
 732                   "Disabling barriers, not supported with external log device");
 733                 mp->m_flags &= ~XFS_MOUNT_BARRIER;
 734                 return;
 735         }
 736
 737         if (mp->m_ddev_targp->bt_bdev->bd_disk->queue->ordered ==
 738                                         QUEUE_ORDERED_NONE) {
 739                 xfs_fs_cmn_err(CE_NOTE, mp,
 740                   "Disabling barriers, not supported by the underlying device");
 741                 mp->m_flags &= ~XFS_MOUNT_BARRIER;
 742                 return;
 743         }
 744
 745         if (xfs_readonly_buftarg(mp->m_ddev_targp)) {
 746                 xfs_fs_cmn_err(CE_NOTE, mp,
 747                   "Disabling barriers, underlying device is readonly");
 748                 mp->m_flags &= ~XFS_MOUNT_BARRIER;
 749                 return;
 750         }
 751
 752         error = xfs_barrier_test(mp);
 753         if (error) {
 754                 xfs_fs_cmn_err(CE_NOTE, mp,
 755                   "Disabling barriers, trial barrier write failed");
 756                 mp->m_flags &= ~XFS_MOUNT_BARRIER;
 757                 return;
 758         }
 759 }
 760
 761 void
 762 xfs_blkdev_issue_flush(
 763         xfs_buftarg_t           *buftarg)
 764 {
 765         blkdev_issue_flush(buftarg->bt_bdev, NULL);
 766 }
 767
 768 /*
 769  * XFS AIL push thread support
 770  */
 771 void
 772 xfsaild_wakeup(
 773         xfs_mount_t             *mp,
 774         xfs_lsn_t               threshold_lsn)
 775 {
 776         mp->m_ail.xa_target = threshold_lsn;
 777         wake_up_process(mp->m_ail.xa_task);
 778 }
 779
 780 int
 781 xfsaild(
 782         void    *data)
 783 {
 784         xfs_mount_t     *mp = (xfs_mount_t *)data;
 785         xfs_lsn_t       last_pushed_lsn = 0;
 786         long            tout = 0;
 787
 788         while (!kthread_should_stop()) {
 789                 if (tout)
 790                         schedule_timeout_interruptible(msecs_to_jiffies(tout));
 791                 tout = 1000;
 792
 793                 /* swsusp */
 794                 try_to_freeze();
 795
 796                 ASSERT(mp->m_log);
 797                 if (XFS_FORCED_SHUTDOWN(mp))
 798                         continue;
 799
 800                 tout = xfsaild_push(mp, &last_pushed_lsn);
 801         }
 802
 803         return 0;
 804 }       /* xfsaild */
 805
 806 int
 807 xfsaild_start(
 808         xfs_mount_t     *mp)
 809 {
 810         mp->m_ail.xa_target = 0;
 811         mp->m_ail.xa_task = kthread_run(xfsaild, mp, "xfsaild");
 812         if (IS_ERR(mp->m_ail.xa_task))
 813                 return -PTR_ERR(mp->m_ail.xa_task);
 814         return 0;
 815 }
 816
 817 void
 818 xfsaild_stop(
 819         xfs_mount_t     *mp)
 820 {
 821         kthread_stop(mp->m_ail.xa_task);
 822 }
 823
 824
 825
 826 STATIC struct inode *
 827 xfs_fs_alloc_inode(
 828         struct super_block      *sb)
 829 {
 830         bhv_vnode_t             *vp;
 831
 832         vp = kmem_zone_alloc(xfs_vnode_zone, KM_SLEEP);
 833         if (unlikely(!vp))
 834                 return NULL;
 835         return vn_to_inode(vp);
 836 }
 837
 838 STATIC void
 839 xfs_fs_destroy_inode(
 840         struct inode            *inode)
 841 {
 842         kmem_zone_free(xfs_vnode_zone, vn_from_inode(inode));
 843 }
 844
 845 STATIC void
 846 xfs_fs_inode_init_once(
 847         void                    *vnode)
 848 {
 849         inode_init_once(vn_to_inode((bhv_vnode_t *)vnode));
 850 }
 851
 852 STATIC int __init
 853 xfs_init_zones(void)
 854 {
 855         xfs_vnode_zone = kmem_zone_init_flags(sizeof(bhv_vnode_t), "xfs_vnode",
 856                                         KM_ZONE_HWALIGN | KM_ZONE_RECLAIM |
 857                                         KM_ZONE_SPREAD,
 858                                         xfs_fs_inode_init_once);
 859         if (!xfs_vnode_zone)
 860                 goto out;
 861
 862         xfs_ioend_zone = kmem_zone_init(sizeof(xfs_ioend_t), "xfs_ioend");
 863         if (!xfs_ioend_zone)
 864                 goto out_destroy_vnode_zone;
 865
 866         xfs_ioend_pool = mempool_create_slab_pool(4 * MAX_BUF_PER_PAGE,
 867                                                   xfs_ioend_zone);
 868         if (!xfs_ioend_pool)
 869                 goto out_free_ioend_zone;
 870         return 0;
 871
 872  out_free_ioend_zone:
 873         kmem_zone_destroy(xfs_ioend_zone);
 874  out_destroy_vnode_zone:
 875         kmem_zone_destroy(xfs_vnode_zone);
 876  out:
 877         return -ENOMEM;
 878 }
 879
 880 STATIC void
 881 xfs_destroy_zones(void)
 882 {
 883         mempool_destroy(xfs_ioend_pool);
 884         kmem_zone_destroy(xfs_vnode_zone);
 885         kmem_zone_destroy(xfs_ioend_zone);
 886 }
 887
 888 /*
 889  * Attempt to flush the inode, this will actually fail
 890  * if the inode is pinned, but we dirty the inode again
 891  * at the point when it is unpinned after a log write,
 892  * since this is when the inode itself becomes flushable.
 893  */
 894 STATIC int
 895 xfs_fs_write_inode(
 896         struct inode            *inode,
 897         int                     sync)
 898 {
 899         int                     error = 0;
 900         int                     flags = 0;
 901
 902         xfs_itrace_entry(XFS_I(inode));
 903         if (sync) {
 904                 filemap_fdatawait(inode->i_mapping);
 905                 flags |= FLUSH_SYNC;
 906         }
 907         error = xfs_inode_flush(XFS_I(inode), flags);
 908         /*
 909          * if we failed to write out the inode then mark
 910          * it dirty again so we'll try again later.
 911          */
 912         if (error)
 913                 mark_inode_dirty_sync(inode);
 914
 915         return -error;
 916 }
 917
 918 STATIC void
 919 xfs_fs_clear_inode(
 920         struct inode            *inode)
 921 {
 922         xfs_inode_t             *ip = XFS_I(inode);
 923
 924         /*
 925          * ip can be null when xfs_iget_core calls xfs_idestroy if we
 926          * find an inode with di_mode == 0 but without IGET_CREATE set.
 927          */
 928         if (ip) {
 929                 xfs_itrace_entry(ip);
 930                 XFS_STATS_INC(vn_rele);
 931                 XFS_STATS_INC(vn_remove);
 932                 XFS_STATS_INC(vn_reclaim);
 933                 XFS_STATS_DEC(vn_active);
 934
 935                 xfs_inactive(ip);
 936                 xfs_iflags_clear(ip, XFS_IMODIFIED);
 937                 if (xfs_reclaim(ip))
 938                         panic("%s: cannot reclaim 0x%p\n", __func__, inode);
 939         }
 940
 941         ASSERT(XFS_I(inode) == NULL);
 942 }
 943
 944 /*
 945  * Enqueue a work item to be picked up by the vfs xfssyncd thread.
 946  * Doing this has two advantages:
 947  * - It saves on stack space, which is tight in certain situations
 948  * - It can be used (with care) as a mechanism to avoid deadlocks.
 949  * Flushing while allocating in a full filesystem requires both.
 950  */
 951 STATIC void
 952 xfs_syncd_queue_work(
 953         struct xfs_mount *mp,
 954         void            *data,
 955         void            (*syncer)(struct xfs_mount *, void *))
 956 {
 957         struct bhv_vfs_sync_work *work;
 958
 959         work = kmem_alloc(sizeof(struct bhv_vfs_sync_work), KM_SLEEP);
 960         INIT_LIST_HEAD(&work->w_list);
 961         work->w_syncer = syncer;
 962         work->w_data = data;
 963         work->w_mount = mp;
 964         spin_lock(&mp->m_sync_lock);
 965         list_add_tail(&work->w_list, &mp->m_sync_list);
 966         spin_unlock(&mp->m_sync_lock);
 967         wake_up_process(mp->m_sync_task);
 968 }
 969
 970 /*
 971  * Flush delayed allocate data, attempting to free up reserved space
 972  * from existing allocations.  At this point a new allocation attempt
 973  * has failed with ENOSPC and we are in the process of scratching our
 974  * heads, looking about for more room...
 975  */
 976 STATIC void
 977 xfs_flush_inode_work(
 978         struct xfs_mount *mp,
 979         void            *arg)
 980 {
 981         struct inode    *inode = arg;
 982         filemap_flush(inode->i_mapping);
 983         iput(inode);
 984 }
 985
 986 void
 987 xfs_flush_inode(
 988         xfs_inode_t     *ip)
 989 {
 990         struct inode    *inode = ip->i_vnode;
 991
 992         igrab(inode);
 993         xfs_syncd_queue_work(ip->i_mount, inode, xfs_flush_inode_work);
 994         delay(msecs_to_jiffies(500));
 995 }
 996
 997 /*
 998  * This is the "bigger hammer" version of xfs_flush_inode_work...
 999  * (IOW, "If at first you don't succeed, use a Bigger Hammer").
1000  */
1001 STATIC void
1002 xfs_flush_device_work(
1003         struct xfs_mount *mp,
1004         void            *arg)
1005 {
1006         struct inode    *inode = arg;
1007         sync_blockdev(mp->m_super->s_bdev);
1008         iput(inode);
1009 }
1010
1011 void
1012 xfs_flush_device(
1013         xfs_inode_t     *ip)
1014 {
1015         struct inode    *inode = vn_to_inode(XFS_ITOV(ip));
1016
1017         igrab(inode);
1018         xfs_syncd_queue_work(ip->i_mount, inode, xfs_flush_device_work);
1019         delay(msecs_to_jiffies(500));
1020         xfs_log_force(ip->i_mount, (xfs_lsn_t)0, XFS_LOG_FORCE|XFS_LOG_SYNC);
1021 }
1022
1023 STATIC void
1024 xfs_sync_worker(
1025         struct xfs_mount *mp,
1026         void            *unused)
1027 {
1028         int             error;
1029
1030         if (!(mp->m_flags & XFS_MOUNT_RDONLY))
1031                 error = xfs_sync(mp, SYNC_FSDATA | SYNC_BDFLUSH | SYNC_ATTR);
1032         mp->m_sync_seq++;
1033         wake_up(&mp->m_wait_single_sync_task);
1034 }
1035
1036 STATIC int
1037 xfssyncd(
1038         void                    *arg)
1039 {
1040         struct xfs_mount        *mp = arg;
1041         long                    timeleft;
1042         bhv_vfs_sync_work_t     *work, *n;
1043         LIST_HEAD               (tmp);
1044
1045         set_freezable();
1046         timeleft = xfs_syncd_centisecs * msecs_to_jiffies(10);
1047         for (;;) {
1048                 timeleft = schedule_timeout_interruptible(timeleft);
1049                 /* swsusp */
1050                 try_to_freeze();
1051                 if (kthread_should_stop() && list_empty(&mp->m_sync_list))
1052                         break;
1053
1054                 spin_lock(&mp->m_sync_lock);
1055                 /*
1056                  * We can get woken by laptop mode, to do a sync -
1057                  * that's the (only!) case where the list would be
1058                  * empty with time remaining.
1059                  */
1060                 if (!timeleft || list_empty(&mp->m_sync_list)) {
1061                         if (!timeleft)
1062                                 timeleft = xfs_syncd_centisecs *
1063                                                         msecs_to_jiffies(10);
1064                         INIT_LIST_HEAD(&mp->m_sync_work.w_list);
1065                         list_add_tail(&mp->m_sync_work.w_list,
1066                                         &mp->m_sync_list);
1067                 }
1068                 list_for_each_entry_safe(work, n, &mp->m_sync_list, w_list)
1069                         list_move(&work->w_list, &tmp);
1070                 spin_unlock(&mp->m_sync_lock);
1071
1072                 list_for_each_entry_safe(work, n, &tmp, w_list) {
1073                         (*work->w_syncer)(mp, work->w_data);
1074                         list_del(&work->w_list);
1075                         if (work == &mp->m_sync_work)
1076                                 continue;
1077                         kmem_free(work);
1078                 }
1079         }
1080
1081         return 0;
1082 }
1083
1084 STATIC void
1085 xfs_fs_put_super(
1086         struct super_block      *sb)
1087 {
1088         struct xfs_mount        *mp = XFS_M(sb);
1089         int                     error;
1090
1091         kthread_stop(mp->m_sync_task);
1092
1093         xfs_sync(mp, SYNC_ATTR | SYNC_DELWRI);
1094         error = xfs_unmount(mp, 0, NULL);
1095         if (error)
1096                 printk("XFS: unmount got error=%d\n", error);
1097 }
1098
1099 STATIC void
1100 xfs_fs_write_super(
1101         struct super_block      *sb)
1102 {
1103         if (!(sb->s_flags & MS_RDONLY))
1104                 xfs_sync(XFS_M(sb), SYNC_FSDATA);
1105         sb->s_dirt = 0;
1106 }
1107
1108 STATIC int
1109 xfs_fs_sync_super(
1110         struct super_block      *sb,
1111         int                     wait)
1112 {
1113         struct xfs_mount        *mp = XFS_M(sb);
1114         int                     error;
1115         int                     flags;
1116
1117         /*
1118          * Treat a sync operation like a freeze.  This is to work
1119          * around a race in sync_inodes() which works in two phases
1120          * - an asynchronous flush, which can write out an inode
1121          * without waiting for file size updates to complete, and a
1122          * synchronous flush, which wont do anything because the
1123          * async flush removed the inode's dirty flag.  Also
1124          * sync_inodes() will not see any files that just have
1125          * outstanding transactions to be flushed because we don't
1126          * dirty the Linux inode until after the transaction I/O
1127          * completes.
1128          */
1129         if (wait || unlikely(sb->s_frozen == SB_FREEZE_WRITE)) {
1130                 /*
1131                  * First stage of freeze - no more writers will make progress
1132                  * now we are here, so we flush delwri and delalloc buffers
1133                  * here, then wait for all I/O to complete.  Data is frozen at
1134                  * that point. Metadata is not frozen, transactions can still
1135                  * occur here so don't bother flushing the buftarg (i.e
1136                  * SYNC_QUIESCE) because it'll just get dirty again.
1137                  */
1138                 flags = SYNC_DATA_QUIESCE;
1139         } else
1140                 flags = SYNC_FSDATA;
1141
1142         error = xfs_sync(mp, flags);
1143         sb->s_dirt = 0;
1144
1145         if (unlikely(laptop_mode)) {
1146                 int     prev_sync_seq = mp->m_sync_seq;
1147
1148                 /*
1149                  * The disk must be active because we're syncing.
1150                  * We schedule xfssyncd now (now that the disk is
1151                  * active) instead of later (when it might not be).
1152                  */
1153                 wake_up_process(mp->m_sync_task);
1154                 /*
1155                  * We have to wait for the sync iteration to complete.
1156                  * If we don't, the disk activity caused by the sync
1157                  * will come after the sync is completed, and that
1158                  * triggers another sync from laptop mode.
1159                  */
1160                 wait_event(mp->m_wait_single_sync_task,
1161                                 mp->m_sync_seq != prev_sync_seq);
1162         }
1163
1164         return -error;
1165 }
1166
1167 STATIC int
1168 xfs_fs_statfs(
1169         struct dentry           *dentry,
1170         struct kstatfs          *statp)
1171 {
1172         struct xfs_mount        *mp = XFS_M(dentry->d_sb);
1173         xfs_sb_t                *sbp = &mp->m_sb;
1174         __uint64_t              fakeinos, id;
1175         xfs_extlen_t            lsize;
1176
1177         statp->f_type = XFS_SB_MAGIC;
1178         statp->f_namelen = MAXNAMELEN - 1;
1179
1180         id = huge_encode_dev(mp->m_ddev_targp->bt_dev);
1181         statp->f_fsid.val[0] = (u32)id;
1182         statp->f_fsid.val[1] = (u32)(id >> 32);
1183
1184         xfs_icsb_sync_counters(mp, XFS_ICSB_LAZY_COUNT);
1185
1186         spin_lock(&mp->m_sb_lock);
1187         statp->f_bsize = sbp->sb_blocksize;
1188         lsize = sbp->sb_logstart ? sbp->sb_logblocks : 0;
1189         statp->f_blocks = sbp->sb_dblocks - lsize;
1190         statp->f_bfree = statp->f_bavail =
1191                                 sbp->sb_fdblocks - XFS_ALLOC_SET_ASIDE(mp);
1192         fakeinos = statp->f_bfree << sbp->sb_inopblog;
1193 #if XFS_BIG_INUMS
1194         fakeinos += mp->m_inoadd;
1195 #endif
1196         statp->f_files =
1197             MIN(sbp->sb_icount + fakeinos, (__uint64_t)XFS_MAXINUMBER);
1198         if (mp->m_maxicount)
1199 #if XFS_BIG_INUMS
1200                 if (!mp->m_inoadd)
1201 #endif
1202                         statp->f_files = min_t(typeof(statp->f_files),
1203                                                 statp->f_files,
1204                                                 mp->m_maxicount);
1205         statp->f_ffree = statp->f_files - (sbp->sb_icount - sbp->sb_ifree);
1206         spin_unlock(&mp->m_sb_lock);
1207
1208         XFS_QM_DQSTATVFS(XFS_I(dentry->d_inode), statp);
1209         return 0;
1210 }
1211
1212 STATIC int
1213 xfs_fs_remount(
1214         struct super_block      *sb,
1215         int                     *flags,
1216         char                    *options)
1217 {
1218         struct xfs_mount        *mp = XFS_M(sb);
1219         struct xfs_mount_args   *args = xfs_args_allocate(sb, 0);
1220         int                     error;
1221
1222         error = xfs_parseargs(mp, options, args, 1);
1223         if (!error)
1224                 error = xfs_mntupdate(mp, flags, args);
1225         kmem_free(args);
1226         return -error;
1227 }
1228
1229 /*
1230  * Second stage of a freeze. The data is already frozen so we only
1231  * need to take care of themetadata. Once that's done write a dummy
1232  * record to dirty the log in case of a crash while frozen.
1233  */
1234 STATIC void
1235 xfs_fs_lockfs(
1236         struct super_block      *sb)
1237 {
1238         struct xfs_mount        *mp = XFS_M(sb);
1239
1240         xfs_attr_quiesce(mp);
1241         xfs_fs_log_dummy(mp);
1242 }
1243
1244 STATIC int
1245 xfs_fs_show_options(
1246         struct seq_file         *m,
1247         struct vfsmount         *mnt)
1248 {
1249         return -xfs_showargs(XFS_M(mnt->mnt_sb), m);
1250 }
1251
1252 STATIC int
1253 xfs_fs_quotasync(
1254         struct super_block      *sb,
1255         int                     type)
1256 {
1257         return -XFS_QM_QUOTACTL(XFS_M(sb), Q_XQUOTASYNC, 0, NULL);
1258 }
1259
1260 STATIC int
1261 xfs_fs_getxstate(
1262         struct super_block      *sb,
1263         struct fs_quota_stat    *fqs)
1264 {
1265         return -XFS_QM_QUOTACTL(XFS_M(sb), Q_XGETQSTAT, 0, (caddr_t)fqs);
1266 }
1267
1268 STATIC int
1269 xfs_fs_setxstate(
1270         struct super_block      *sb,
1271         unsigned int            flags,
1272         int                     op)
1273 {
1274         return -XFS_QM_QUOTACTL(XFS_M(sb), op, 0, (caddr_t)&flags);
1275 }
1276
1277 STATIC int
1278 xfs_fs_getxquota(
1279         struct super_block      *sb,
1280         int                     type,
1281         qid_t                   id,
1282         struct fs_disk_quota    *fdq)
1283 {
1284         return -XFS_QM_QUOTACTL(XFS_M(sb),
1285                                  (type == USRQUOTA) ? Q_XGETQUOTA :
1286                                   ((type == GRPQUOTA) ? Q_XGETGQUOTA :
1287                                    Q_XGETPQUOTA), id, (caddr_t)fdq);
1288 }
1289
1290 STATIC int
1291 xfs_fs_setxquota(
1292         struct super_block      *sb,
1293         int                     type,
1294         qid_t                   id,
1295         struct fs_disk_quota    *fdq)
1296 {
1297         return -XFS_QM_QUOTACTL(XFS_M(sb),
1298                                  (type == USRQUOTA) ? Q_XSETQLIM :
1299                                   ((type == GRPQUOTA) ? Q_XSETGQLIM :
1300                                    Q_XSETPQLIM), id, (caddr_t)fdq);
1301 }
1302
1303 STATIC int
1304 xfs_fs_fill_super(
1305         struct super_block      *sb,
1306         void                    *data,
1307         int                     silent)
1308 {
1309         struct inode            *root;
1310         struct xfs_mount        *mp = NULL;
1311         struct xfs_mount_args   *args = xfs_args_allocate(sb, silent);
1312         int                     error;
1313
1314         mp = xfs_mount_init();
1315
1316         INIT_LIST_HEAD(&mp->m_sync_list);
1317         spin_lock_init(&mp->m_sync_lock);
1318         init_waitqueue_head(&mp->m_wait_single_sync_task);
1319
1320         mp->m_super = sb;
1321         sb->s_fs_info = mp;
1322
1323         if (sb->s_flags & MS_RDONLY)
1324                 mp->m_flags |= XFS_MOUNT_RDONLY;
1325
1326         error = xfs_parseargs(mp, (char *)data, args, 0);
1327         if (error)
1328                 goto fail_vfsop;
1329
1330         sb_min_blocksize(sb, BBSIZE);
1331         sb->s_export_op = &xfs_export_operations;
1332         sb->s_qcop = &xfs_quotactl_operations;
1333         sb->s_op = &xfs_super_operations;
1334
1335         error = xfs_mount(mp, args, NULL);
1336         if (error)
1337                 goto fail_vfsop;
1338
1339         sb->s_dirt = 1;
1340         sb->s_magic = XFS_SB_MAGIC;
1341         sb->s_blocksize = mp->m_sb.sb_blocksize;
1342         sb->s_blocksize_bits = ffs(sb->s_blocksize) - 1;
1343         sb->s_maxbytes = xfs_max_file_offset(sb->s_blocksize_bits);
1344         sb->s_time_gran = 1;
1345         set_posix_acl_flag(sb);
1346
1347         root = igrab(mp->m_rootip->i_vnode);
1348         if (!root) {
1349                 error = ENOENT;
1350                 goto fail_unmount;
1351         }
1352         if (is_bad_inode(root)) {
1353                 error = EINVAL;
1354                 goto fail_vnrele;
1355         }
1356         sb->s_root = d_alloc_root(root);
1357         if (!sb->s_root) {
1358                 error = ENOMEM;
1359                 goto fail_vnrele;
1360         }
1361
1362         mp->m_sync_work.w_syncer = xfs_sync_worker;
1363         mp->m_sync_work.w_mount = mp;
1364         mp->m_sync_task = kthread_run(xfssyncd, mp, "xfssyncd");
1365         if (IS_ERR(mp->m_sync_task)) {
1366                 error = -PTR_ERR(mp->m_sync_task);
1367                 goto fail_vnrele;
1368         }
1369
1370         xfs_itrace_exit(XFS_I(sb->s_root->d_inode));
1371
1372         kmem_free(args);
1373         return 0;
1374
1375 fail_vnrele:
1376         if (sb->s_root) {
1377                 dput(sb->s_root);
1378                 sb->s_root = NULL;
1379         } else {
1380                 iput(root);
1381         }
1382
1383 fail_unmount:
1384         xfs_unmount(mp, 0, NULL);
1385
1386 fail_vfsop:
1387         kmem_free(args);
1388         return -error;
1389 }
1390
1391 STATIC int
1392 xfs_fs_get_sb(
1393         struct file_system_type *fs_type,
1394         int                     flags,
1395         const char              *dev_name,
1396         void                    *data,
1397         struct vfsmount         *mnt)
1398 {
1399         return get_sb_bdev(fs_type, flags, dev_name, data, xfs_fs_fill_super,
1400                            mnt);
1401 }
1402
1403 static struct super_operations xfs_super_operations = {
1404         .alloc_inode            = xfs_fs_alloc_inode,
1405         .destroy_inode          = xfs_fs_destroy_inode,
1406         .write_inode            = xfs_fs_write_inode,
1407         .clear_inode            = xfs_fs_clear_inode,
1408         .put_super              = xfs_fs_put_super,
1409         .write_super            = xfs_fs_write_super,
1410         .sync_fs                = xfs_fs_sync_super,
1411         .write_super_lockfs     = xfs_fs_lockfs,
1412         .statfs                 = xfs_fs_statfs,
1413         .remount_fs             = xfs_fs_remount,
1414         .show_options           = xfs_fs_show_options,
1415 };
1416
1417 static struct quotactl_ops xfs_quotactl_operations = {
1418         .quota_sync             = xfs_fs_quotasync,
1419         .get_xstate             = xfs_fs_getxstate,
1420         .set_xstate             = xfs_fs_setxstate,
1421         .get_xquota             = xfs_fs_getxquota,
1422         .set_xquota             = xfs_fs_setxquota,
1423 };
1424
1425 static struct file_system_type xfs_fs_type = {
1426         .owner                  = THIS_MODULE,
1427         .name                   = "xfs",
1428         .get_sb                 = xfs_fs_get_sb,
1429         .kill_sb                = kill_block_super,
1430         .fs_flags               = FS_REQUIRES_DEV,
1431 };
1432
1433
1434 STATIC int __init
1435 init_xfs_fs( void )
1436 {
1437         int                     error;
1438         static char             message[] __initdata = KERN_INFO \
1439                 XFS_VERSION_STRING " with " XFS_BUILD_OPTIONS " enabled\n";
1440
1441         printk(message);
1442
1443         ktrace_init(64);
1444
1445         error = xfs_init_zones();
1446         if (error < 0)
1447                 goto undo_zones;
1448
1449         error = xfs_buf_init();
1450         if (error < 0)
1451                 goto undo_buffers;
1452
1453         vn_init();
1454         xfs_init();
1455         uuid_init();
1456         vfs_initquota();
1457
1458         error = register_filesystem(&xfs_fs_type);
1459         if (error)
1460                 goto undo_register;
1461         return 0;
1462
1463 undo_register:
1464         xfs_buf_terminate();
1465
1466 undo_buffers:
1467         xfs_destroy_zones();
1468
1469 undo_zones:
1470         return error;
1471 }
1472
1473 STATIC void __exit
1474 exit_xfs_fs( void )
1475 {
1476         vfs_exitquota();
1477         unregister_filesystem(&xfs_fs_type);
1478         xfs_cleanup();
1479         xfs_buf_terminate();
1480         xfs_destroy_zones();
1481         ktrace_uninit();
1482 }
1483
1484 module_init(init_xfs_fs);
1485 module_exit(exit_xfs_fs);
1486
1487 MODULE_AUTHOR("Silicon Graphics, Inc.");
1488 MODULE_DESCRIPTION(XFS_VERSION_STRING " with " XFS_BUILD_OPTIONS " enabled");
1489 MODULE_LICENSE("GPL");