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