2 * Copyright (c) 2000-2006 Silicon Graphics, Inc.
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.
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.
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
23 #include "xfs_trans.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"
41 #include "xfs_rtalloc.h"
42 #include "xfs_error.h"
43 #include "xfs_itable.h"
44 #include "xfs_fsops.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 #include "xfs_filestream.h"
56 #include "xfs_da_btree.h"
57 #include "xfs_dir2_trace.h"
58 #include "xfs_extfree_item.h"
59 #include "xfs_mru_cache.h"
60 #include "xfs_inode_item.h"
62 #include <linux/namei.h>
63 #include <linux/init.h>
64 #include <linux/mount.h>
65 #include <linux/mempool.h>
66 #include <linux/writeback.h>
67 #include <linux/kthread.h>
68 #include <linux/freezer.h>
69 #include <linux/parser.h>
71 static struct quotactl_ops xfs_quotactl_operations
;
72 static struct super_operations xfs_super_operations
;
73 static kmem_zone_t
*xfs_vnode_zone
;
74 static kmem_zone_t
*xfs_ioend_zone
;
75 mempool_t
*xfs_ioend_pool
;
77 STATIC
struct xfs_mount_args
*
79 struct super_block
*sb
,
82 struct xfs_mount_args
*args
;
84 args
= kzalloc(sizeof(struct xfs_mount_args
), GFP_KERNEL
);
88 args
->logbufs
= args
->logbufsize
= -1;
89 strncpy(args
->fsname
, sb
->s_id
, MAXNAMELEN
);
91 /* Copy the already-parsed mount(2) flags we're interested in */
92 if (sb
->s_flags
& MS_DIRSYNC
)
93 args
->flags
|= XFSMNT_DIRSYNC
;
94 if (sb
->s_flags
& MS_SYNCHRONOUS
)
95 args
->flags
|= XFSMNT_WSYNC
;
97 args
->flags
|= XFSMNT_QUIET
;
98 args
->flags
|= XFSMNT_32BITINODES
;
103 #define MNTOPT_LOGBUFS "logbufs" /* number of XFS log buffers */
104 #define MNTOPT_LOGBSIZE "logbsize" /* size of XFS log buffers */
105 #define MNTOPT_LOGDEV "logdev" /* log device */
106 #define MNTOPT_RTDEV "rtdev" /* realtime I/O device */
107 #define MNTOPT_BIOSIZE "biosize" /* log2 of preferred buffered io size */
108 #define MNTOPT_WSYNC "wsync" /* safe-mode nfs compatible mount */
109 #define MNTOPT_INO64 "ino64" /* force inodes into 64-bit range */
110 #define MNTOPT_NOALIGN "noalign" /* turn off stripe alignment */
111 #define MNTOPT_SWALLOC "swalloc" /* turn on stripe width allocation */
112 #define MNTOPT_SUNIT "sunit" /* data volume stripe unit */
113 #define MNTOPT_SWIDTH "swidth" /* data volume stripe width */
114 #define MNTOPT_NOUUID "nouuid" /* ignore filesystem UUID */
115 #define MNTOPT_MTPT "mtpt" /* filesystem mount point */
116 #define MNTOPT_GRPID "grpid" /* group-ID from parent directory */
117 #define MNTOPT_NOGRPID "nogrpid" /* group-ID from current process */
118 #define MNTOPT_BSDGROUPS "bsdgroups" /* group-ID from parent directory */
119 #define MNTOPT_SYSVGROUPS "sysvgroups" /* group-ID from current process */
120 #define MNTOPT_ALLOCSIZE "allocsize" /* preferred allocation size */
121 #define MNTOPT_NORECOVERY "norecovery" /* don't run XFS recovery */
122 #define MNTOPT_BARRIER "barrier" /* use writer barriers for log write and
123 * unwritten extent conversion */
124 #define MNTOPT_NOBARRIER "nobarrier" /* .. disable */
125 #define MNTOPT_OSYNCISOSYNC "osyncisosync" /* o_sync is REALLY o_sync */
126 #define MNTOPT_64BITINODE "inode64" /* inodes can be allocated anywhere */
127 #define MNTOPT_IKEEP "ikeep" /* do not free empty inode clusters */
128 #define MNTOPT_NOIKEEP "noikeep" /* free empty inode clusters */
129 #define MNTOPT_LARGEIO "largeio" /* report large I/O sizes in stat() */
130 #define MNTOPT_NOLARGEIO "nolargeio" /* do not report large I/O sizes
132 #define MNTOPT_ATTR2 "attr2" /* do use attr2 attribute format */
133 #define MNTOPT_NOATTR2 "noattr2" /* do not use attr2 attribute format */
134 #define MNTOPT_FILESTREAM "filestreams" /* use filestreams allocator */
135 #define MNTOPT_QUOTA "quota" /* disk quotas (user) */
136 #define MNTOPT_NOQUOTA "noquota" /* no quotas */
137 #define MNTOPT_USRQUOTA "usrquota" /* user quota enabled */
138 #define MNTOPT_GRPQUOTA "grpquota" /* group quota enabled */
139 #define MNTOPT_PRJQUOTA "prjquota" /* project quota enabled */
140 #define MNTOPT_UQUOTA "uquota" /* user quota (IRIX variant) */
141 #define MNTOPT_GQUOTA "gquota" /* group quota (IRIX variant) */
142 #define MNTOPT_PQUOTA "pquota" /* project quota (IRIX variant) */
143 #define MNTOPT_UQUOTANOENF "uqnoenforce"/* user quota limit enforcement */
144 #define MNTOPT_GQUOTANOENF "gqnoenforce"/* group quota limit enforcement */
145 #define MNTOPT_PQUOTANOENF "pqnoenforce"/* project quota limit enforcement */
146 #define MNTOPT_QUOTANOENF "qnoenforce" /* same as uqnoenforce */
147 #define MNTOPT_DMAPI "dmapi" /* DMI enabled (DMAPI / XDSM) */
148 #define MNTOPT_XDSM "xdsm" /* DMI enabled (DMAPI / XDSM) */
149 #define MNTOPT_DMI "dmi" /* DMI enabled (DMAPI / XDSM) */
152 * Table driven mount option parser.
154 * Currently only used for remount, but it will be used for mount
155 * in the future, too.
158 Opt_barrier
, Opt_nobarrier
, Opt_err
161 static match_table_t tokens
= {
162 {Opt_barrier
, "barrier"},
163 {Opt_nobarrier
, "nobarrier"},
169 suffix_strtoul(char *s
, char **endp
, unsigned int base
)
171 int last
, shift_left_factor
= 0;
174 last
= strlen(value
) - 1;
175 if (value
[last
] == 'K' || value
[last
] == 'k') {
176 shift_left_factor
= 10;
179 if (value
[last
] == 'M' || value
[last
] == 'm') {
180 shift_left_factor
= 20;
183 if (value
[last
] == 'G' || value
[last
] == 'g') {
184 shift_left_factor
= 30;
188 return simple_strtoul((const char *)s
, endp
, base
) << shift_left_factor
;
193 struct xfs_mount
*mp
,
195 struct xfs_mount_args
*args
,
198 char *this_char
, *value
, *eov
;
199 int dsunit
, dswidth
, vol_dsunit
, vol_dswidth
;
201 int dmapi_implies_ikeep
= 1;
203 args
->flags
|= XFSMNT_BARRIER
;
204 args
->flags2
|= XFSMNT2_COMPAT_IOSIZE
;
209 iosize
= dsunit
= dswidth
= vol_dsunit
= vol_dswidth
= 0;
211 while ((this_char
= strsep(&options
, ",")) != NULL
) {
214 if ((value
= strchr(this_char
, '=')) != NULL
)
217 if (!strcmp(this_char
, MNTOPT_LOGBUFS
)) {
218 if (!value
|| !*value
) {
220 "XFS: %s option requires an argument",
224 args
->logbufs
= simple_strtoul(value
, &eov
, 10);
225 } else if (!strcmp(this_char
, MNTOPT_LOGBSIZE
)) {
226 if (!value
|| !*value
) {
228 "XFS: %s option requires an argument",
232 args
->logbufsize
= suffix_strtoul(value
, &eov
, 10);
233 } else if (!strcmp(this_char
, MNTOPT_LOGDEV
)) {
234 if (!value
|| !*value
) {
236 "XFS: %s option requires an argument",
240 strncpy(args
->logname
, value
, MAXNAMELEN
);
241 } else if (!strcmp(this_char
, MNTOPT_MTPT
)) {
242 if (!value
|| !*value
) {
244 "XFS: %s option requires an argument",
248 strncpy(args
->mtpt
, value
, MAXNAMELEN
);
249 } else if (!strcmp(this_char
, MNTOPT_RTDEV
)) {
250 if (!value
|| !*value
) {
252 "XFS: %s option requires an argument",
256 strncpy(args
->rtname
, value
, MAXNAMELEN
);
257 } else if (!strcmp(this_char
, MNTOPT_BIOSIZE
)) {
258 if (!value
|| !*value
) {
260 "XFS: %s option requires an argument",
264 iosize
= simple_strtoul(value
, &eov
, 10);
265 args
->flags
|= XFSMNT_IOSIZE
;
266 args
->iosizelog
= (uint8_t) iosize
;
267 } else if (!strcmp(this_char
, MNTOPT_ALLOCSIZE
)) {
268 if (!value
|| !*value
) {
270 "XFS: %s option requires an argument",
274 iosize
= suffix_strtoul(value
, &eov
, 10);
275 args
->flags
|= XFSMNT_IOSIZE
;
276 args
->iosizelog
= ffs(iosize
) - 1;
277 } else if (!strcmp(this_char
, MNTOPT_GRPID
) ||
278 !strcmp(this_char
, MNTOPT_BSDGROUPS
)) {
279 mp
->m_flags
|= XFS_MOUNT_GRPID
;
280 } else if (!strcmp(this_char
, MNTOPT_NOGRPID
) ||
281 !strcmp(this_char
, MNTOPT_SYSVGROUPS
)) {
282 mp
->m_flags
&= ~XFS_MOUNT_GRPID
;
283 } else if (!strcmp(this_char
, MNTOPT_WSYNC
)) {
284 args
->flags
|= XFSMNT_WSYNC
;
285 } else if (!strcmp(this_char
, MNTOPT_OSYNCISOSYNC
)) {
286 args
->flags
|= XFSMNT_OSYNCISOSYNC
;
287 } else if (!strcmp(this_char
, MNTOPT_NORECOVERY
)) {
288 args
->flags
|= XFSMNT_NORECOVERY
;
289 } else if (!strcmp(this_char
, MNTOPT_INO64
)) {
290 args
->flags
|= XFSMNT_INO64
;
293 "XFS: %s option not allowed on this system",
297 } else if (!strcmp(this_char
, MNTOPT_NOALIGN
)) {
298 args
->flags
|= XFSMNT_NOALIGN
;
299 } else if (!strcmp(this_char
, MNTOPT_SWALLOC
)) {
300 args
->flags
|= XFSMNT_SWALLOC
;
301 } else if (!strcmp(this_char
, MNTOPT_SUNIT
)) {
302 if (!value
|| !*value
) {
304 "XFS: %s option requires an argument",
308 dsunit
= simple_strtoul(value
, &eov
, 10);
309 } else if (!strcmp(this_char
, MNTOPT_SWIDTH
)) {
310 if (!value
|| !*value
) {
312 "XFS: %s option requires an argument",
316 dswidth
= simple_strtoul(value
, &eov
, 10);
317 } else if (!strcmp(this_char
, MNTOPT_64BITINODE
)) {
318 args
->flags
&= ~XFSMNT_32BITINODES
;
321 "XFS: %s option not allowed on this system",
325 } else if (!strcmp(this_char
, MNTOPT_NOUUID
)) {
326 args
->flags
|= XFSMNT_NOUUID
;
327 } else if (!strcmp(this_char
, MNTOPT_BARRIER
)) {
328 args
->flags
|= XFSMNT_BARRIER
;
329 } else if (!strcmp(this_char
, MNTOPT_NOBARRIER
)) {
330 args
->flags
&= ~XFSMNT_BARRIER
;
331 } else if (!strcmp(this_char
, MNTOPT_IKEEP
)) {
332 args
->flags
|= XFSMNT_IKEEP
;
333 } else if (!strcmp(this_char
, MNTOPT_NOIKEEP
)) {
334 dmapi_implies_ikeep
= 0;
335 args
->flags
&= ~XFSMNT_IKEEP
;
336 } else if (!strcmp(this_char
, MNTOPT_LARGEIO
)) {
337 args
->flags2
&= ~XFSMNT2_COMPAT_IOSIZE
;
338 } else if (!strcmp(this_char
, MNTOPT_NOLARGEIO
)) {
339 args
->flags2
|= XFSMNT2_COMPAT_IOSIZE
;
340 } else if (!strcmp(this_char
, MNTOPT_ATTR2
)) {
341 args
->flags
|= XFSMNT_ATTR2
;
342 } else if (!strcmp(this_char
, MNTOPT_NOATTR2
)) {
343 args
->flags
&= ~XFSMNT_ATTR2
;
344 args
->flags
|= XFSMNT_NOATTR2
;
345 } else if (!strcmp(this_char
, MNTOPT_FILESTREAM
)) {
346 args
->flags2
|= XFSMNT2_FILESTREAMS
;
347 } else if (!strcmp(this_char
, MNTOPT_NOQUOTA
)) {
348 args
->flags
&= ~(XFSMNT_UQUOTAENF
|XFSMNT_UQUOTA
);
349 args
->flags
&= ~(XFSMNT_GQUOTAENF
|XFSMNT_GQUOTA
);
350 } else if (!strcmp(this_char
, MNTOPT_QUOTA
) ||
351 !strcmp(this_char
, MNTOPT_UQUOTA
) ||
352 !strcmp(this_char
, MNTOPT_USRQUOTA
)) {
353 args
->flags
|= XFSMNT_UQUOTA
| XFSMNT_UQUOTAENF
;
354 } else if (!strcmp(this_char
, MNTOPT_QUOTANOENF
) ||
355 !strcmp(this_char
, MNTOPT_UQUOTANOENF
)) {
356 args
->flags
|= XFSMNT_UQUOTA
;
357 args
->flags
&= ~XFSMNT_UQUOTAENF
;
358 } else if (!strcmp(this_char
, MNTOPT_PQUOTA
) ||
359 !strcmp(this_char
, MNTOPT_PRJQUOTA
)) {
360 args
->flags
|= XFSMNT_PQUOTA
| XFSMNT_PQUOTAENF
;
361 } else if (!strcmp(this_char
, MNTOPT_PQUOTANOENF
)) {
362 args
->flags
|= XFSMNT_PQUOTA
;
363 args
->flags
&= ~XFSMNT_PQUOTAENF
;
364 } else if (!strcmp(this_char
, MNTOPT_GQUOTA
) ||
365 !strcmp(this_char
, MNTOPT_GRPQUOTA
)) {
366 args
->flags
|= XFSMNT_GQUOTA
| XFSMNT_GQUOTAENF
;
367 } else if (!strcmp(this_char
, MNTOPT_GQUOTANOENF
)) {
368 args
->flags
|= XFSMNT_GQUOTA
;
369 args
->flags
&= ~XFSMNT_GQUOTAENF
;
370 } else if (!strcmp(this_char
, MNTOPT_DMAPI
)) {
371 args
->flags
|= XFSMNT_DMAPI
;
372 } else if (!strcmp(this_char
, MNTOPT_XDSM
)) {
373 args
->flags
|= XFSMNT_DMAPI
;
374 } else if (!strcmp(this_char
, MNTOPT_DMI
)) {
375 args
->flags
|= XFSMNT_DMAPI
;
376 } else if (!strcmp(this_char
, "ihashsize")) {
378 "XFS: ihashsize no longer used, option is deprecated.");
379 } else if (!strcmp(this_char
, "osyncisdsync")) {
380 /* no-op, this is now the default */
382 "XFS: osyncisdsync is now the default, option is deprecated.");
383 } else if (!strcmp(this_char
, "irixsgid")) {
385 "XFS: irixsgid is now a sysctl(2) variable, option is deprecated.");
388 "XFS: unknown mount option [%s].", this_char
);
393 if (args
->flags
& XFSMNT_NORECOVERY
) {
394 if ((mp
->m_flags
& XFS_MOUNT_RDONLY
) == 0) {
396 "XFS: no-recovery mounts must be read-only.");
401 if ((args
->flags
& XFSMNT_NOALIGN
) && (dsunit
|| dswidth
)) {
403 "XFS: sunit and swidth options incompatible with the noalign option");
407 if ((args
->flags
& XFSMNT_GQUOTA
) && (args
->flags
& XFSMNT_PQUOTA
)) {
409 "XFS: cannot mount with both project and group quota");
413 if ((args
->flags
& XFSMNT_DMAPI
) && *args
->mtpt
== '\0') {
414 printk("XFS: %s option needs the mount point option as well\n",
419 if ((dsunit
&& !dswidth
) || (!dsunit
&& dswidth
)) {
421 "XFS: sunit and swidth must be specified together");
425 if (dsunit
&& (dswidth
% dsunit
!= 0)) {
427 "XFS: stripe width (%d) must be a multiple of the stripe unit (%d)",
433 * Applications using DMI filesystems often expect the
434 * inode generation number to be monotonically increasing.
435 * If we delete inode chunks we break this assumption, so
436 * keep unused inode chunks on disk for DMI filesystems
437 * until we come up with a better solution.
438 * Note that if "ikeep" or "noikeep" mount options are
439 * supplied, then they are honored.
441 if ((args
->flags
& XFSMNT_DMAPI
) && dmapi_implies_ikeep
)
442 args
->flags
|= XFSMNT_IKEEP
;
444 if ((args
->flags
& XFSMNT_NOALIGN
) != XFSMNT_NOALIGN
) {
446 args
->sunit
= dsunit
;
447 args
->flags
|= XFSMNT_RETERR
;
449 args
->sunit
= vol_dsunit
;
451 dswidth
? (args
->swidth
= dswidth
) :
452 (args
->swidth
= vol_dswidth
);
454 args
->sunit
= args
->swidth
= 0;
458 if (args
->flags
& XFSMNT_32BITINODES
)
459 mp
->m_flags
|= XFS_MOUNT_SMALL_INUMS
;
461 args
->flags
|= XFSMNT_FLAGS2
;
465 struct proc_xfs_info
{
472 struct xfs_mount
*mp
,
475 static struct proc_xfs_info xfs_info_set
[] = {
476 /* the few simple ones we can get from the mount struct */
477 { XFS_MOUNT_IKEEP
, "," MNTOPT_IKEEP
},
478 { XFS_MOUNT_WSYNC
, "," MNTOPT_WSYNC
},
479 { XFS_MOUNT_INO64
, "," MNTOPT_INO64
},
480 { XFS_MOUNT_NOALIGN
, "," MNTOPT_NOALIGN
},
481 { XFS_MOUNT_SWALLOC
, "," MNTOPT_SWALLOC
},
482 { XFS_MOUNT_NOUUID
, "," MNTOPT_NOUUID
},
483 { XFS_MOUNT_NORECOVERY
, "," MNTOPT_NORECOVERY
},
484 { XFS_MOUNT_OSYNCISOSYNC
, "," MNTOPT_OSYNCISOSYNC
},
485 { XFS_MOUNT_ATTR2
, "," MNTOPT_ATTR2
},
486 { XFS_MOUNT_FILESTREAMS
, "," MNTOPT_FILESTREAM
},
487 { XFS_MOUNT_DMAPI
, "," MNTOPT_DMAPI
},
488 { XFS_MOUNT_GRPID
, "," MNTOPT_GRPID
},
491 static struct proc_xfs_info xfs_info_unset
[] = {
492 /* the few simple ones we can get from the mount struct */
493 { XFS_MOUNT_COMPAT_IOSIZE
, "," MNTOPT_LARGEIO
},
494 { XFS_MOUNT_BARRIER
, "," MNTOPT_NOBARRIER
},
495 { XFS_MOUNT_SMALL_INUMS
, "," MNTOPT_64BITINODE
},
498 struct proc_xfs_info
*xfs_infop
;
500 for (xfs_infop
= xfs_info_set
; xfs_infop
->flag
; xfs_infop
++) {
501 if (mp
->m_flags
& xfs_infop
->flag
)
502 seq_puts(m
, xfs_infop
->str
);
504 for (xfs_infop
= xfs_info_unset
; xfs_infop
->flag
; xfs_infop
++) {
505 if (!(mp
->m_flags
& xfs_infop
->flag
))
506 seq_puts(m
, xfs_infop
->str
);
509 if (mp
->m_flags
& XFS_MOUNT_DFLT_IOSIZE
)
510 seq_printf(m
, "," MNTOPT_ALLOCSIZE
"=%dk",
511 (int)(1 << mp
->m_writeio_log
) >> 10);
513 if (mp
->m_logbufs
> 0)
514 seq_printf(m
, "," MNTOPT_LOGBUFS
"=%d", mp
->m_logbufs
);
515 if (mp
->m_logbsize
> 0)
516 seq_printf(m
, "," MNTOPT_LOGBSIZE
"=%dk", mp
->m_logbsize
>> 10);
519 seq_printf(m
, "," MNTOPT_LOGDEV
"=%s", mp
->m_logname
);
521 seq_printf(m
, "," MNTOPT_RTDEV
"=%s", mp
->m_rtname
);
523 if (mp
->m_dalign
> 0)
524 seq_printf(m
, "," MNTOPT_SUNIT
"=%d",
525 (int)XFS_FSB_TO_BB(mp
, mp
->m_dalign
));
526 if (mp
->m_swidth
> 0)
527 seq_printf(m
, "," MNTOPT_SWIDTH
"=%d",
528 (int)XFS_FSB_TO_BB(mp
, mp
->m_swidth
));
530 if (mp
->m_qflags
& (XFS_UQUOTA_ACCT
|XFS_UQUOTA_ENFD
))
531 seq_puts(m
, "," MNTOPT_USRQUOTA
);
532 else if (mp
->m_qflags
& XFS_UQUOTA_ACCT
)
533 seq_puts(m
, "," MNTOPT_UQUOTANOENF
);
535 if (mp
->m_qflags
& (XFS_PQUOTA_ACCT
|XFS_OQUOTA_ENFD
))
536 seq_puts(m
, "," MNTOPT_PRJQUOTA
);
537 else if (mp
->m_qflags
& XFS_PQUOTA_ACCT
)
538 seq_puts(m
, "," MNTOPT_PQUOTANOENF
);
540 if (mp
->m_qflags
& (XFS_GQUOTA_ACCT
|XFS_OQUOTA_ENFD
))
541 seq_puts(m
, "," MNTOPT_GRPQUOTA
);
542 else if (mp
->m_qflags
& XFS_GQUOTA_ACCT
)
543 seq_puts(m
, "," MNTOPT_GQUOTANOENF
);
545 if (!(mp
->m_qflags
& XFS_ALL_QUOTA_ACCT
))
546 seq_puts(m
, "," MNTOPT_NOQUOTA
);
552 unsigned int blockshift
)
554 unsigned int pagefactor
= 1;
555 unsigned int bitshift
= BITS_PER_LONG
- 1;
557 /* Figure out maximum filesize, on Linux this can depend on
558 * the filesystem blocksize (on 32 bit platforms).
559 * __block_prepare_write does this in an [unsigned] long...
560 * page->index << (PAGE_CACHE_SHIFT - bbits)
561 * So, for page sized blocks (4K on 32 bit platforms),
562 * this wraps at around 8Tb (hence MAX_LFS_FILESIZE which is
563 * (((u64)PAGE_CACHE_SIZE << (BITS_PER_LONG-1))-1)
564 * but for smaller blocksizes it is less (bbits = log2 bsize).
565 * Note1: get_block_t takes a long (implicit cast from above)
566 * Note2: The Large Block Device (LBD and HAVE_SECTOR_T) patch
567 * can optionally convert the [unsigned] long from above into
568 * an [unsigned] long long.
571 #if BITS_PER_LONG == 32
572 # if defined(CONFIG_LBD)
573 ASSERT(sizeof(sector_t
) == 8);
574 pagefactor
= PAGE_CACHE_SIZE
;
575 bitshift
= BITS_PER_LONG
;
577 pagefactor
= PAGE_CACHE_SIZE
>> (PAGE_CACHE_SHIFT
- blockshift
);
581 return (((__uint64_t
)pagefactor
) << bitshift
) - 1;
588 switch (inode
->i_mode
& S_IFMT
) {
590 inode
->i_op
= &xfs_inode_operations
;
591 inode
->i_fop
= &xfs_file_operations
;
592 inode
->i_mapping
->a_ops
= &xfs_address_space_operations
;
595 if (xfs_sb_version_hasasciici(&XFS_M(inode
->i_sb
)->m_sb
))
596 inode
->i_op
= &xfs_dir_ci_inode_operations
;
598 inode
->i_op
= &xfs_dir_inode_operations
;
599 inode
->i_fop
= &xfs_dir_file_operations
;
602 inode
->i_op
= &xfs_symlink_inode_operations
;
603 if (!(XFS_I(inode
)->i_df
.if_flags
& XFS_IFINLINE
))
604 inode
->i_mapping
->a_ops
= &xfs_address_space_operations
;
607 inode
->i_op
= &xfs_inode_operations
;
608 init_special_inode(inode
, inode
->i_mode
, inode
->i_rdev
);
614 xfs_revalidate_inode(
619 struct inode
*inode
= vn_to_inode(vp
);
621 inode
->i_mode
= ip
->i_d
.di_mode
;
622 inode
->i_nlink
= ip
->i_d
.di_nlink
;
623 inode
->i_uid
= ip
->i_d
.di_uid
;
624 inode
->i_gid
= ip
->i_d
.di_gid
;
626 switch (inode
->i_mode
& S_IFMT
) {
630 MKDEV(sysv_major(ip
->i_df
.if_u2
.if_rdev
) & 0x1ff,
631 sysv_minor(ip
->i_df
.if_u2
.if_rdev
));
638 inode
->i_generation
= ip
->i_d
.di_gen
;
639 i_size_write(inode
, ip
->i_d
.di_size
);
640 inode
->i_atime
.tv_sec
= ip
->i_d
.di_atime
.t_sec
;
641 inode
->i_atime
.tv_nsec
= ip
->i_d
.di_atime
.t_nsec
;
642 inode
->i_mtime
.tv_sec
= ip
->i_d
.di_mtime
.t_sec
;
643 inode
->i_mtime
.tv_nsec
= ip
->i_d
.di_mtime
.t_nsec
;
644 inode
->i_ctime
.tv_sec
= ip
->i_d
.di_ctime
.t_sec
;
645 inode
->i_ctime
.tv_nsec
= ip
->i_d
.di_ctime
.t_nsec
;
646 if (ip
->i_d
.di_flags
& XFS_DIFLAG_IMMUTABLE
)
647 inode
->i_flags
|= S_IMMUTABLE
;
649 inode
->i_flags
&= ~S_IMMUTABLE
;
650 if (ip
->i_d
.di_flags
& XFS_DIFLAG_APPEND
)
651 inode
->i_flags
|= S_APPEND
;
653 inode
->i_flags
&= ~S_APPEND
;
654 if (ip
->i_d
.di_flags
& XFS_DIFLAG_SYNC
)
655 inode
->i_flags
|= S_SYNC
;
657 inode
->i_flags
&= ~S_SYNC
;
658 if (ip
->i_d
.di_flags
& XFS_DIFLAG_NOATIME
)
659 inode
->i_flags
|= S_NOATIME
;
661 inode
->i_flags
&= ~S_NOATIME
;
662 xfs_iflags_clear(ip
, XFS_IMODIFIED
);
666 xfs_initialize_vnode(
667 struct xfs_mount
*mp
,
669 struct xfs_inode
*ip
)
671 struct inode
*inode
= vn_to_inode(vp
);
675 inode
->i_private
= ip
;
679 * We need to set the ops vectors, and unlock the inode, but if
680 * we have been called during the new inode create process, it is
681 * too early to fill in the Linux inode. We will get called a
682 * second time once the inode is properly set up, and then we can
685 if (ip
->i_d
.di_mode
!= 0 && (inode
->i_state
& I_NEW
)) {
686 xfs_revalidate_inode(mp
, vp
, ip
);
687 xfs_set_inodeops(inode
);
689 xfs_iflags_clear(ip
, XFS_INEW
);
692 unlock_new_inode(inode
);
700 struct block_device
**bdevp
)
704 *bdevp
= open_bdev_excl(name
, 0, mp
);
705 if (IS_ERR(*bdevp
)) {
706 error
= PTR_ERR(*bdevp
);
707 printk("XFS: Invalid device [%s], error=%d\n", name
, error
);
715 struct block_device
*bdev
)
718 close_bdev_excl(bdev
);
722 * Try to write out the superblock using barriers.
728 xfs_buf_t
*sbp
= xfs_getsb(mp
, 0);
733 XFS_BUF_UNDELAYWRITE(sbp
);
735 XFS_BUF_UNASYNC(sbp
);
736 XFS_BUF_ORDERED(sbp
);
739 error
= xfs_iowait(sbp
);
742 * Clear all the flags we set and possible error state in the
743 * buffer. We only did the write to try out whether barriers
744 * worked and shouldn't leave any traces in the superblock
748 XFS_BUF_ERROR(sbp
, 0);
749 XFS_BUF_UNORDERED(sbp
);
756 xfs_mountfs_check_barriers(xfs_mount_t
*mp
)
760 if (mp
->m_logdev_targp
!= mp
->m_ddev_targp
) {
761 xfs_fs_cmn_err(CE_NOTE
, mp
,
762 "Disabling barriers, not supported with external log device");
763 mp
->m_flags
&= ~XFS_MOUNT_BARRIER
;
767 if (xfs_readonly_buftarg(mp
->m_ddev_targp
)) {
768 xfs_fs_cmn_err(CE_NOTE
, mp
,
769 "Disabling barriers, underlying device is readonly");
770 mp
->m_flags
&= ~XFS_MOUNT_BARRIER
;
774 error
= xfs_barrier_test(mp
);
776 xfs_fs_cmn_err(CE_NOTE
, mp
,
777 "Disabling barriers, trial barrier write failed");
778 mp
->m_flags
&= ~XFS_MOUNT_BARRIER
;
784 xfs_blkdev_issue_flush(
785 xfs_buftarg_t
*buftarg
)
787 blkdev_issue_flush(buftarg
->bt_bdev
, NULL
);
792 struct xfs_mount
*mp
)
794 if (mp
->m_logdev_targp
&& mp
->m_logdev_targp
!= mp
->m_ddev_targp
) {
795 struct block_device
*logdev
= mp
->m_logdev_targp
->bt_bdev
;
796 xfs_free_buftarg(mp
->m_logdev_targp
);
797 xfs_blkdev_put(logdev
);
799 if (mp
->m_rtdev_targp
) {
800 struct block_device
*rtdev
= mp
->m_rtdev_targp
->bt_bdev
;
801 xfs_free_buftarg(mp
->m_rtdev_targp
);
802 xfs_blkdev_put(rtdev
);
804 xfs_free_buftarg(mp
->m_ddev_targp
);
808 * The file system configurations are:
809 * (1) device (partition) with data and internal log
810 * (2) logical volume with data and log subvolumes.
811 * (3) logical volume with data, log, and realtime subvolumes.
813 * We only have to handle opening the log and realtime volumes here if
814 * they are present. The data subvolume has already been opened by
815 * get_sb_bdev() and is stored in sb->s_bdev.
819 struct xfs_mount
*mp
,
820 struct xfs_mount_args
*args
)
822 struct block_device
*ddev
= mp
->m_super
->s_bdev
;
823 struct block_device
*logdev
= NULL
, *rtdev
= NULL
;
827 * Open real time and log devices - order is important.
829 if (args
->logname
[0]) {
830 error
= xfs_blkdev_get(mp
, args
->logname
, &logdev
);
835 if (args
->rtname
[0]) {
836 error
= xfs_blkdev_get(mp
, args
->rtname
, &rtdev
);
838 goto out_close_logdev
;
840 if (rtdev
== ddev
|| rtdev
== logdev
) {
842 "XFS: Cannot mount filesystem with identical rtdev and ddev/logdev.");
844 goto out_close_rtdev
;
849 * Setup xfs_mount buffer target pointers
852 mp
->m_ddev_targp
= xfs_alloc_buftarg(ddev
, 0);
853 if (!mp
->m_ddev_targp
)
854 goto out_close_rtdev
;
857 mp
->m_rtdev_targp
= xfs_alloc_buftarg(rtdev
, 1);
858 if (!mp
->m_rtdev_targp
)
859 goto out_free_ddev_targ
;
862 if (logdev
&& logdev
!= ddev
) {
863 mp
->m_logdev_targp
= xfs_alloc_buftarg(logdev
, 1);
864 if (!mp
->m_logdev_targp
)
865 goto out_free_rtdev_targ
;
867 mp
->m_logdev_targp
= mp
->m_ddev_targp
;
873 if (mp
->m_rtdev_targp
)
874 xfs_free_buftarg(mp
->m_rtdev_targp
);
876 xfs_free_buftarg(mp
->m_ddev_targp
);
879 xfs_blkdev_put(rtdev
);
881 if (logdev
&& logdev
!= ddev
)
882 xfs_blkdev_put(logdev
);
888 * Setup xfs_mount buffer target pointers based on superblock
892 struct xfs_mount
*mp
)
896 error
= xfs_setsize_buftarg(mp
->m_ddev_targp
, mp
->m_sb
.sb_blocksize
,
897 mp
->m_sb
.sb_sectsize
);
901 if (mp
->m_logdev_targp
&& mp
->m_logdev_targp
!= mp
->m_ddev_targp
) {
902 unsigned int log_sector_size
= BBSIZE
;
904 if (xfs_sb_version_hassector(&mp
->m_sb
))
905 log_sector_size
= mp
->m_sb
.sb_logsectsize
;
906 error
= xfs_setsize_buftarg(mp
->m_logdev_targp
,
907 mp
->m_sb
.sb_blocksize
,
912 if (mp
->m_rtdev_targp
) {
913 error
= xfs_setsize_buftarg(mp
->m_rtdev_targp
,
914 mp
->m_sb
.sb_blocksize
,
915 mp
->m_sb
.sb_sectsize
);
924 * XFS AIL push thread support
929 xfs_lsn_t threshold_lsn
)
931 mp
->m_ail
.xa_target
= threshold_lsn
;
932 wake_up_process(mp
->m_ail
.xa_task
);
939 xfs_mount_t
*mp
= (xfs_mount_t
*)data
;
940 xfs_lsn_t last_pushed_lsn
= 0;
943 while (!kthread_should_stop()) {
945 schedule_timeout_interruptible(msecs_to_jiffies(tout
));
952 if (XFS_FORCED_SHUTDOWN(mp
))
955 tout
= xfsaild_push(mp
, &last_pushed_lsn
);
965 mp
->m_ail
.xa_target
= 0;
966 mp
->m_ail
.xa_task
= kthread_run(xfsaild
, mp
, "xfsaild");
967 if (IS_ERR(mp
->m_ail
.xa_task
))
968 return -PTR_ERR(mp
->m_ail
.xa_task
);
976 kthread_stop(mp
->m_ail
.xa_task
);
981 STATIC
struct inode
*
983 struct super_block
*sb
)
987 vp
= kmem_zone_alloc(xfs_vnode_zone
, KM_SLEEP
);
990 return vn_to_inode(vp
);
994 xfs_fs_destroy_inode(
997 kmem_zone_free(xfs_vnode_zone
, vn_from_inode(inode
));
1001 xfs_fs_inode_init_once(
1004 inode_init_once(vn_to_inode((bhv_vnode_t
*)vnode
));
1008 * Attempt to flush the inode, this will actually fail
1009 * if the inode is pinned, but we dirty the inode again
1010 * at the point when it is unpinned after a log write,
1011 * since this is when the inode itself becomes flushable.
1015 struct inode
*inode
,
1021 xfs_itrace_entry(XFS_I(inode
));
1023 filemap_fdatawait(inode
->i_mapping
);
1024 flags
|= FLUSH_SYNC
;
1026 error
= xfs_inode_flush(XFS_I(inode
), flags
);
1028 * if we failed to write out the inode then mark
1029 * it dirty again so we'll try again later.
1032 mark_inode_dirty_sync(inode
);
1039 struct inode
*inode
)
1041 xfs_inode_t
*ip
= XFS_I(inode
);
1044 * ip can be null when xfs_iget_core calls xfs_idestroy if we
1045 * find an inode with di_mode == 0 but without IGET_CREATE set.
1048 xfs_itrace_entry(ip
);
1049 XFS_STATS_INC(vn_rele
);
1050 XFS_STATS_INC(vn_remove
);
1051 XFS_STATS_INC(vn_reclaim
);
1052 XFS_STATS_DEC(vn_active
);
1055 xfs_iflags_clear(ip
, XFS_IMODIFIED
);
1056 if (xfs_reclaim(ip
))
1057 panic("%s: cannot reclaim 0x%p\n", __func__
, inode
);
1060 ASSERT(XFS_I(inode
) == NULL
);
1064 * Enqueue a work item to be picked up by the vfs xfssyncd thread.
1065 * Doing this has two advantages:
1066 * - It saves on stack space, which is tight in certain situations
1067 * - It can be used (with care) as a mechanism to avoid deadlocks.
1068 * Flushing while allocating in a full filesystem requires both.
1071 xfs_syncd_queue_work(
1072 struct xfs_mount
*mp
,
1074 void (*syncer
)(struct xfs_mount
*, void *))
1076 struct bhv_vfs_sync_work
*work
;
1078 work
= kmem_alloc(sizeof(struct bhv_vfs_sync_work
), KM_SLEEP
);
1079 INIT_LIST_HEAD(&work
->w_list
);
1080 work
->w_syncer
= syncer
;
1081 work
->w_data
= data
;
1083 spin_lock(&mp
->m_sync_lock
);
1084 list_add_tail(&work
->w_list
, &mp
->m_sync_list
);
1085 spin_unlock(&mp
->m_sync_lock
);
1086 wake_up_process(mp
->m_sync_task
);
1090 * Flush delayed allocate data, attempting to free up reserved space
1091 * from existing allocations. At this point a new allocation attempt
1092 * has failed with ENOSPC and we are in the process of scratching our
1093 * heads, looking about for more room...
1096 xfs_flush_inode_work(
1097 struct xfs_mount
*mp
,
1100 struct inode
*inode
= arg
;
1101 filemap_flush(inode
->i_mapping
);
1109 struct inode
*inode
= VFS_I(ip
);
1112 xfs_syncd_queue_work(ip
->i_mount
, inode
, xfs_flush_inode_work
);
1113 delay(msecs_to_jiffies(500));
1117 * This is the "bigger hammer" version of xfs_flush_inode_work...
1118 * (IOW, "If at first you don't succeed, use a Bigger Hammer").
1121 xfs_flush_device_work(
1122 struct xfs_mount
*mp
,
1125 struct inode
*inode
= arg
;
1126 sync_blockdev(mp
->m_super
->s_bdev
);
1134 struct inode
*inode
= VFS_I(ip
);
1137 xfs_syncd_queue_work(ip
->i_mount
, inode
, xfs_flush_device_work
);
1138 delay(msecs_to_jiffies(500));
1139 xfs_log_force(ip
->i_mount
, (xfs_lsn_t
)0, XFS_LOG_FORCE
|XFS_LOG_SYNC
);
1144 struct xfs_mount
*mp
,
1149 if (!(mp
->m_flags
& XFS_MOUNT_RDONLY
))
1150 error
= xfs_sync(mp
, SYNC_FSDATA
| SYNC_BDFLUSH
| SYNC_ATTR
);
1152 wake_up(&mp
->m_wait_single_sync_task
);
1159 struct xfs_mount
*mp
= arg
;
1161 bhv_vfs_sync_work_t
*work
, *n
;
1165 timeleft
= xfs_syncd_centisecs
* msecs_to_jiffies(10);
1167 timeleft
= schedule_timeout_interruptible(timeleft
);
1170 if (kthread_should_stop() && list_empty(&mp
->m_sync_list
))
1173 spin_lock(&mp
->m_sync_lock
);
1175 * We can get woken by laptop mode, to do a sync -
1176 * that's the (only!) case where the list would be
1177 * empty with time remaining.
1179 if (!timeleft
|| list_empty(&mp
->m_sync_list
)) {
1181 timeleft
= xfs_syncd_centisecs
*
1182 msecs_to_jiffies(10);
1183 INIT_LIST_HEAD(&mp
->m_sync_work
.w_list
);
1184 list_add_tail(&mp
->m_sync_work
.w_list
,
1187 list_for_each_entry_safe(work
, n
, &mp
->m_sync_list
, w_list
)
1188 list_move(&work
->w_list
, &tmp
);
1189 spin_unlock(&mp
->m_sync_lock
);
1191 list_for_each_entry_safe(work
, n
, &tmp
, w_list
) {
1192 (*work
->w_syncer
)(mp
, work
->w_data
);
1193 list_del(&work
->w_list
);
1194 if (work
== &mp
->m_sync_work
)
1205 struct super_block
*sb
)
1207 struct xfs_mount
*mp
= XFS_M(sb
);
1208 struct xfs_inode
*rip
= mp
->m_rootip
;
1209 int unmount_event_flags
= 0;
1212 kthread_stop(mp
->m_sync_task
);
1214 xfs_sync(mp
, SYNC_ATTR
| SYNC_DELWRI
);
1217 if (mp
->m_flags
& XFS_MOUNT_DMAPI
) {
1218 unmount_event_flags
=
1219 (mp
->m_dmevmask
& (1 << DM_EVENT_UNMOUNT
)) ?
1220 0 : DM_FLAGS_UNWANTED
;
1222 * Ignore error from dmapi here, first unmount is not allowed
1223 * to fail anyway, and second we wouldn't want to fail a
1224 * unmount because of dmapi.
1226 XFS_SEND_PREUNMOUNT(mp
, rip
, DM_RIGHT_NULL
, rip
, DM_RIGHT_NULL
,
1227 NULL
, NULL
, 0, 0, unmount_event_flags
);
1232 * Blow away any referenced inode in the filestreams cache.
1233 * This can and will cause log traffic as inodes go inactive
1236 xfs_filestream_unmount(mp
);
1238 XFS_bflush(mp
->m_ddev_targp
);
1239 error
= xfs_unmount_flush(mp
, 0);
1245 * If we're forcing a shutdown, typically because of a media error,
1246 * we want to make sure we invalidate dirty pages that belong to
1247 * referenced vnodes as well.
1249 if (XFS_FORCED_SHUTDOWN(mp
)) {
1250 error
= xfs_sync(mp
, SYNC_WAIT
| SYNC_CLOSE
);
1251 ASSERT(error
!= EFSCORRUPTED
);
1254 if (mp
->m_flags
& XFS_MOUNT_DMAPI
) {
1255 XFS_SEND_UNMOUNT(mp
, rip
, DM_RIGHT_NULL
, 0, 0,
1256 unmount_event_flags
);
1260 xfs_icsb_destroy_counters(mp
);
1261 xfs_close_devices(mp
);
1269 struct super_block
*sb
)
1271 if (!(sb
->s_flags
& MS_RDONLY
))
1272 xfs_sync(XFS_M(sb
), SYNC_FSDATA
);
1278 struct super_block
*sb
,
1281 struct xfs_mount
*mp
= XFS_M(sb
);
1286 * Treat a sync operation like a freeze. This is to work
1287 * around a race in sync_inodes() which works in two phases
1288 * - an asynchronous flush, which can write out an inode
1289 * without waiting for file size updates to complete, and a
1290 * synchronous flush, which wont do anything because the
1291 * async flush removed the inode's dirty flag. Also
1292 * sync_inodes() will not see any files that just have
1293 * outstanding transactions to be flushed because we don't
1294 * dirty the Linux inode until after the transaction I/O
1297 if (wait
|| unlikely(sb
->s_frozen
== SB_FREEZE_WRITE
)) {
1299 * First stage of freeze - no more writers will make progress
1300 * now we are here, so we flush delwri and delalloc buffers
1301 * here, then wait for all I/O to complete. Data is frozen at
1302 * that point. Metadata is not frozen, transactions can still
1303 * occur here so don't bother flushing the buftarg (i.e
1304 * SYNC_QUIESCE) because it'll just get dirty again.
1306 flags
= SYNC_DATA_QUIESCE
;
1308 flags
= SYNC_FSDATA
;
1310 error
= xfs_sync(mp
, flags
);
1313 if (unlikely(laptop_mode
)) {
1314 int prev_sync_seq
= mp
->m_sync_seq
;
1317 * The disk must be active because we're syncing.
1318 * We schedule xfssyncd now (now that the disk is
1319 * active) instead of later (when it might not be).
1321 wake_up_process(mp
->m_sync_task
);
1323 * We have to wait for the sync iteration to complete.
1324 * If we don't, the disk activity caused by the sync
1325 * will come after the sync is completed, and that
1326 * triggers another sync from laptop mode.
1328 wait_event(mp
->m_wait_single_sync_task
,
1329 mp
->m_sync_seq
!= prev_sync_seq
);
1337 struct dentry
*dentry
,
1338 struct kstatfs
*statp
)
1340 struct xfs_mount
*mp
= XFS_M(dentry
->d_sb
);
1341 xfs_sb_t
*sbp
= &mp
->m_sb
;
1342 __uint64_t fakeinos
, id
;
1345 statp
->f_type
= XFS_SB_MAGIC
;
1346 statp
->f_namelen
= MAXNAMELEN
- 1;
1348 id
= huge_encode_dev(mp
->m_ddev_targp
->bt_dev
);
1349 statp
->f_fsid
.val
[0] = (u32
)id
;
1350 statp
->f_fsid
.val
[1] = (u32
)(id
>> 32);
1352 xfs_icsb_sync_counters(mp
, XFS_ICSB_LAZY_COUNT
);
1354 spin_lock(&mp
->m_sb_lock
);
1355 statp
->f_bsize
= sbp
->sb_blocksize
;
1356 lsize
= sbp
->sb_logstart
? sbp
->sb_logblocks
: 0;
1357 statp
->f_blocks
= sbp
->sb_dblocks
- lsize
;
1358 statp
->f_bfree
= statp
->f_bavail
=
1359 sbp
->sb_fdblocks
- XFS_ALLOC_SET_ASIDE(mp
);
1360 fakeinos
= statp
->f_bfree
<< sbp
->sb_inopblog
;
1362 fakeinos
+= mp
->m_inoadd
;
1365 MIN(sbp
->sb_icount
+ fakeinos
, (__uint64_t
)XFS_MAXINUMBER
);
1366 if (mp
->m_maxicount
)
1370 statp
->f_files
= min_t(typeof(statp
->f_files
),
1373 statp
->f_ffree
= statp
->f_files
- (sbp
->sb_icount
- sbp
->sb_ifree
);
1374 spin_unlock(&mp
->m_sb_lock
);
1376 XFS_QM_DQSTATVFS(XFS_I(dentry
->d_inode
), statp
);
1382 struct super_block
*sb
,
1386 struct xfs_mount
*mp
= XFS_M(sb
);
1387 substring_t args
[MAX_OPT_ARGS
];
1390 while ((p
= strsep(&options
, ",")) != NULL
) {
1396 token
= match_token(p
, tokens
, args
);
1399 mp
->m_flags
|= XFS_MOUNT_BARRIER
;
1402 * Test if barriers are actually working if we can,
1403 * else delay this check until the filesystem is
1406 if (!(mp
->m_flags
& XFS_MOUNT_RDONLY
))
1407 xfs_mountfs_check_barriers(mp
);
1410 mp
->m_flags
&= ~XFS_MOUNT_BARRIER
;
1414 "XFS: mount option \"%s\" not supported for remount\n", p
);
1420 if ((mp
->m_flags
& XFS_MOUNT_RDONLY
) && !(*flags
& MS_RDONLY
)) {
1421 mp
->m_flags
&= ~XFS_MOUNT_RDONLY
;
1422 if (mp
->m_flags
& XFS_MOUNT_BARRIER
)
1423 xfs_mountfs_check_barriers(mp
);
1427 if (!(mp
->m_flags
& XFS_MOUNT_RDONLY
) && (*flags
& MS_RDONLY
)) {
1428 xfs_filestream_flush(mp
);
1429 xfs_sync(mp
, SYNC_DATA_QUIESCE
);
1430 xfs_attr_quiesce(mp
);
1431 mp
->m_flags
|= XFS_MOUNT_RDONLY
;
1438 * Second stage of a freeze. The data is already frozen so we only
1439 * need to take care of themetadata. Once that's done write a dummy
1440 * record to dirty the log in case of a crash while frozen.
1444 struct super_block
*sb
)
1446 struct xfs_mount
*mp
= XFS_M(sb
);
1448 xfs_attr_quiesce(mp
);
1449 xfs_fs_log_dummy(mp
);
1453 xfs_fs_show_options(
1455 struct vfsmount
*mnt
)
1457 return -xfs_showargs(XFS_M(mnt
->mnt_sb
), m
);
1462 struct super_block
*sb
,
1465 return -XFS_QM_QUOTACTL(XFS_M(sb
), Q_XQUOTASYNC
, 0, NULL
);
1470 struct super_block
*sb
,
1471 struct fs_quota_stat
*fqs
)
1473 return -XFS_QM_QUOTACTL(XFS_M(sb
), Q_XGETQSTAT
, 0, (caddr_t
)fqs
);
1478 struct super_block
*sb
,
1482 return -XFS_QM_QUOTACTL(XFS_M(sb
), op
, 0, (caddr_t
)&flags
);
1487 struct super_block
*sb
,
1490 struct fs_disk_quota
*fdq
)
1492 return -XFS_QM_QUOTACTL(XFS_M(sb
),
1493 (type
== USRQUOTA
) ? Q_XGETQUOTA
:
1494 ((type
== GRPQUOTA
) ? Q_XGETGQUOTA
:
1495 Q_XGETPQUOTA
), id
, (caddr_t
)fdq
);
1500 struct super_block
*sb
,
1503 struct fs_disk_quota
*fdq
)
1505 return -XFS_QM_QUOTACTL(XFS_M(sb
),
1506 (type
== USRQUOTA
) ? Q_XSETQLIM
:
1507 ((type
== GRPQUOTA
) ? Q_XSETGQLIM
:
1508 Q_XSETPQLIM
), id
, (caddr_t
)fdq
);
1512 * This function fills in xfs_mount_t fields based on mount args.
1513 * Note: the superblock has _not_ yet been read in.
1517 struct xfs_mount_args
*ap
,
1518 struct xfs_mount
*mp
)
1520 /* Values are in BBs */
1521 if ((ap
->flags
& XFSMNT_NOALIGN
) != XFSMNT_NOALIGN
) {
1523 * At this point the superblock has not been read
1524 * in, therefore we do not know the block size.
1525 * Before the mount call ends we will convert
1528 mp
->m_dalign
= ap
->sunit
;
1529 mp
->m_swidth
= ap
->swidth
;
1532 if (ap
->logbufs
!= -1 &&
1534 (ap
->logbufs
< XLOG_MIN_ICLOGS
||
1535 ap
->logbufs
> XLOG_MAX_ICLOGS
)) {
1537 "XFS: invalid logbufs value: %d [not %d-%d]",
1538 ap
->logbufs
, XLOG_MIN_ICLOGS
, XLOG_MAX_ICLOGS
);
1539 return XFS_ERROR(EINVAL
);
1541 mp
->m_logbufs
= ap
->logbufs
;
1542 if (ap
->logbufsize
!= -1 &&
1543 ap
->logbufsize
!= 0 &&
1544 (ap
->logbufsize
< XLOG_MIN_RECORD_BSIZE
||
1545 ap
->logbufsize
> XLOG_MAX_RECORD_BSIZE
||
1546 !is_power_of_2(ap
->logbufsize
))) {
1548 "XFS: invalid logbufsize: %d [not 16k,32k,64k,128k or 256k]",
1550 return XFS_ERROR(EINVAL
);
1552 mp
->m_logbsize
= ap
->logbufsize
;
1553 mp
->m_fsname_len
= strlen(ap
->fsname
) + 1;
1554 mp
->m_fsname
= kmem_alloc(mp
->m_fsname_len
, KM_SLEEP
);
1555 strcpy(mp
->m_fsname
, ap
->fsname
);
1556 if (ap
->rtname
[0]) {
1557 mp
->m_rtname
= kmem_alloc(strlen(ap
->rtname
) + 1, KM_SLEEP
);
1558 strcpy(mp
->m_rtname
, ap
->rtname
);
1560 if (ap
->logname
[0]) {
1561 mp
->m_logname
= kmem_alloc(strlen(ap
->logname
) + 1, KM_SLEEP
);
1562 strcpy(mp
->m_logname
, ap
->logname
);
1565 if (ap
->flags
& XFSMNT_WSYNC
)
1566 mp
->m_flags
|= XFS_MOUNT_WSYNC
;
1568 if (ap
->flags
& XFSMNT_INO64
) {
1569 mp
->m_flags
|= XFS_MOUNT_INO64
;
1570 mp
->m_inoadd
= XFS_INO64_OFFSET
;
1573 if (ap
->flags
& XFSMNT_RETERR
)
1574 mp
->m_flags
|= XFS_MOUNT_RETERR
;
1575 if (ap
->flags
& XFSMNT_NOALIGN
)
1576 mp
->m_flags
|= XFS_MOUNT_NOALIGN
;
1577 if (ap
->flags
& XFSMNT_SWALLOC
)
1578 mp
->m_flags
|= XFS_MOUNT_SWALLOC
;
1579 if (ap
->flags
& XFSMNT_OSYNCISOSYNC
)
1580 mp
->m_flags
|= XFS_MOUNT_OSYNCISOSYNC
;
1581 if (ap
->flags
& XFSMNT_32BITINODES
)
1582 mp
->m_flags
|= XFS_MOUNT_32BITINODES
;
1584 if (ap
->flags
& XFSMNT_IOSIZE
) {
1585 if (ap
->iosizelog
> XFS_MAX_IO_LOG
||
1586 ap
->iosizelog
< XFS_MIN_IO_LOG
) {
1588 "XFS: invalid log iosize: %d [not %d-%d]",
1589 ap
->iosizelog
, XFS_MIN_IO_LOG
,
1591 return XFS_ERROR(EINVAL
);
1594 mp
->m_flags
|= XFS_MOUNT_DFLT_IOSIZE
;
1595 mp
->m_readio_log
= mp
->m_writeio_log
= ap
->iosizelog
;
1598 if (ap
->flags
& XFSMNT_IKEEP
)
1599 mp
->m_flags
|= XFS_MOUNT_IKEEP
;
1600 if (ap
->flags
& XFSMNT_DIRSYNC
)
1601 mp
->m_flags
|= XFS_MOUNT_DIRSYNC
;
1602 if (ap
->flags
& XFSMNT_ATTR2
)
1603 mp
->m_flags
|= XFS_MOUNT_ATTR2
;
1604 if (ap
->flags
& XFSMNT_NOATTR2
)
1605 mp
->m_flags
|= XFS_MOUNT_NOATTR2
;
1607 if (ap
->flags2
& XFSMNT2_COMPAT_IOSIZE
)
1608 mp
->m_flags
|= XFS_MOUNT_COMPAT_IOSIZE
;
1611 * no recovery flag requires a read-only mount
1613 if (ap
->flags
& XFSMNT_NORECOVERY
) {
1614 if (!(mp
->m_flags
& XFS_MOUNT_RDONLY
)) {
1616 "XFS: tried to mount a FS read-write without recovery!");
1617 return XFS_ERROR(EINVAL
);
1619 mp
->m_flags
|= XFS_MOUNT_NORECOVERY
;
1622 if (ap
->flags
& XFSMNT_NOUUID
)
1623 mp
->m_flags
|= XFS_MOUNT_NOUUID
;
1624 if (ap
->flags
& XFSMNT_BARRIER
)
1625 mp
->m_flags
|= XFS_MOUNT_BARRIER
;
1627 mp
->m_flags
&= ~XFS_MOUNT_BARRIER
;
1629 if (ap
->flags2
& XFSMNT2_FILESTREAMS
)
1630 mp
->m_flags
|= XFS_MOUNT_FILESTREAMS
;
1632 if (ap
->flags
& XFSMNT_DMAPI
)
1633 mp
->m_flags
|= XFS_MOUNT_DMAPI
;
1638 * This function fills in xfs_mount_t fields based on mount args.
1639 * Note: the superblock _has_ now been read in.
1643 struct xfs_mount_args
*ap
,
1644 struct xfs_mount
*mp
)
1646 int ronly
= (mp
->m_flags
& XFS_MOUNT_RDONLY
);
1648 /* Fail a mount where the logbuf is smaller then the log stripe */
1649 if (xfs_sb_version_haslogv2(&mp
->m_sb
)) {
1650 if ((ap
->logbufsize
<= 0) &&
1651 (mp
->m_sb
.sb_logsunit
> XLOG_BIG_RECORD_BSIZE
)) {
1652 mp
->m_logbsize
= mp
->m_sb
.sb_logsunit
;
1653 } else if (ap
->logbufsize
> 0 &&
1654 ap
->logbufsize
< mp
->m_sb
.sb_logsunit
) {
1656 "XFS: logbuf size must be greater than or equal to log stripe size");
1657 return XFS_ERROR(EINVAL
);
1660 /* Fail a mount if the logbuf is larger than 32K */
1661 if (ap
->logbufsize
> XLOG_BIG_RECORD_BSIZE
) {
1663 "XFS: logbuf size for version 1 logs must be 16K or 32K");
1664 return XFS_ERROR(EINVAL
);
1669 * mkfs'ed attr2 will turn on attr2 mount unless explicitly
1670 * told by noattr2 to turn it off
1672 if (xfs_sb_version_hasattr2(&mp
->m_sb
) &&
1673 !(ap
->flags
& XFSMNT_NOATTR2
))
1674 mp
->m_flags
|= XFS_MOUNT_ATTR2
;
1677 * prohibit r/w mounts of read-only filesystems
1679 if ((mp
->m_sb
.sb_flags
& XFS_SBF_READONLY
) && !ronly
) {
1681 "XFS: cannot mount a read-only filesystem as read-write");
1682 return XFS_ERROR(EROFS
);
1686 * check for shared mount.
1688 if (ap
->flags
& XFSMNT_SHARED
) {
1689 if (!xfs_sb_version_hasshared(&mp
->m_sb
))
1690 return XFS_ERROR(EINVAL
);
1693 * For IRIX 6.5, shared mounts must have the shared
1694 * version bit set, have the persistent readonly
1695 * field set, must be version 0 and can only be mounted
1698 if (!ronly
|| !(mp
->m_sb
.sb_flags
& XFS_SBF_READONLY
) ||
1699 (mp
->m_sb
.sb_shared_vn
!= 0))
1700 return XFS_ERROR(EINVAL
);
1702 mp
->m_flags
|= XFS_MOUNT_SHARED
;
1705 * Shared XFS V0 can't deal with DMI. Return EINVAL.
1707 if (mp
->m_sb
.sb_shared_vn
== 0 && (ap
->flags
& XFSMNT_DMAPI
))
1708 return XFS_ERROR(EINVAL
);
1711 if (ap
->flags
& XFSMNT_UQUOTA
) {
1712 mp
->m_qflags
|= (XFS_UQUOTA_ACCT
| XFS_UQUOTA_ACTIVE
);
1713 if (ap
->flags
& XFSMNT_UQUOTAENF
)
1714 mp
->m_qflags
|= XFS_UQUOTA_ENFD
;
1717 if (ap
->flags
& XFSMNT_GQUOTA
) {
1718 mp
->m_qflags
|= (XFS_GQUOTA_ACCT
| XFS_GQUOTA_ACTIVE
);
1719 if (ap
->flags
& XFSMNT_GQUOTAENF
)
1720 mp
->m_qflags
|= XFS_OQUOTA_ENFD
;
1721 } else if (ap
->flags
& XFSMNT_PQUOTA
) {
1722 mp
->m_qflags
|= (XFS_PQUOTA_ACCT
| XFS_PQUOTA_ACTIVE
);
1723 if (ap
->flags
& XFSMNT_PQUOTAENF
)
1724 mp
->m_qflags
|= XFS_OQUOTA_ENFD
;
1732 struct super_block
*sb
,
1737 struct xfs_mount
*mp
= NULL
;
1738 struct xfs_mount_args
*args
;
1739 int flags
= 0, error
= ENOMEM
;
1741 args
= xfs_args_allocate(sb
, silent
);
1745 mp
= kzalloc(sizeof(struct xfs_mount
), GFP_KERNEL
);
1749 spin_lock_init(&mp
->m_sb_lock
);
1750 mutex_init(&mp
->m_ilock
);
1751 mutex_init(&mp
->m_growlock
);
1752 atomic_set(&mp
->m_active_trans
, 0);
1753 INIT_LIST_HEAD(&mp
->m_sync_list
);
1754 spin_lock_init(&mp
->m_sync_lock
);
1755 init_waitqueue_head(&mp
->m_wait_single_sync_task
);
1760 if (sb
->s_flags
& MS_RDONLY
)
1761 mp
->m_flags
|= XFS_MOUNT_RDONLY
;
1763 error
= xfs_parseargs(mp
, (char *)data
, args
, 0);
1767 sb_min_blocksize(sb
, BBSIZE
);
1768 sb
->s_xattr
= xfs_xattr_handlers
;
1769 sb
->s_export_op
= &xfs_export_operations
;
1770 sb
->s_qcop
= &xfs_quotactl_operations
;
1771 sb
->s_op
= &xfs_super_operations
;
1773 error
= xfs_dmops_get(mp
, args
);
1776 error
= xfs_qmops_get(mp
, args
);
1780 if (args
->flags
& XFSMNT_QUIET
)
1781 flags
|= XFS_MFSI_QUIET
;
1783 error
= xfs_open_devices(mp
, args
);
1787 if (xfs_icsb_init_counters(mp
))
1788 mp
->m_flags
|= XFS_MOUNT_NO_PERCPU_SB
;
1791 * Setup flags based on mount(2) options and then the superblock
1793 error
= xfs_start_flags(args
, mp
);
1795 goto out_destroy_counters
;
1796 error
= xfs_readsb(mp
, flags
);
1798 goto out_destroy_counters
;
1799 error
= xfs_finish_flags(args
, mp
);
1803 error
= xfs_setup_devices(mp
);
1807 if (mp
->m_flags
& XFS_MOUNT_BARRIER
)
1808 xfs_mountfs_check_barriers(mp
);
1810 error
= xfs_filestream_mount(mp
);
1814 error
= xfs_mountfs(mp
, flags
);
1816 goto out_filestream_unmount
;
1818 XFS_SEND_MOUNT(mp
, DM_RIGHT_NULL
, args
->mtpt
, args
->fsname
);
1821 sb
->s_magic
= XFS_SB_MAGIC
;
1822 sb
->s_blocksize
= mp
->m_sb
.sb_blocksize
;
1823 sb
->s_blocksize_bits
= ffs(sb
->s_blocksize
) - 1;
1824 sb
->s_maxbytes
= xfs_max_file_offset(sb
->s_blocksize_bits
);
1825 sb
->s_time_gran
= 1;
1826 set_posix_acl_flag(sb
);
1828 root
= igrab(VFS_I(mp
->m_rootip
));
1833 if (is_bad_inode(root
)) {
1837 sb
->s_root
= d_alloc_root(root
);
1843 mp
->m_sync_work
.w_syncer
= xfs_sync_worker
;
1844 mp
->m_sync_work
.w_mount
= mp
;
1845 mp
->m_sync_task
= kthread_run(xfssyncd
, mp
, "xfssyncd");
1846 if (IS_ERR(mp
->m_sync_task
)) {
1847 error
= -PTR_ERR(mp
->m_sync_task
);
1851 xfs_itrace_exit(XFS_I(sb
->s_root
->d_inode
));
1856 out_filestream_unmount
:
1857 xfs_filestream_unmount(mp
);
1860 out_destroy_counters
:
1861 xfs_icsb_destroy_counters(mp
);
1862 xfs_close_devices(mp
);
1883 * Blow away any referenced inode in the filestreams cache.
1884 * This can and will cause log traffic as inodes go inactive
1887 xfs_filestream_unmount(mp
);
1889 XFS_bflush(mp
->m_ddev_targp
);
1890 error
= xfs_unmount_flush(mp
, 0);
1893 IRELE(mp
->m_rootip
);
1896 goto out_destroy_counters
;
1901 struct file_system_type
*fs_type
,
1903 const char *dev_name
,
1905 struct vfsmount
*mnt
)
1907 return get_sb_bdev(fs_type
, flags
, dev_name
, data
, xfs_fs_fill_super
,
1911 static struct super_operations xfs_super_operations
= {
1912 .alloc_inode
= xfs_fs_alloc_inode
,
1913 .destroy_inode
= xfs_fs_destroy_inode
,
1914 .write_inode
= xfs_fs_write_inode
,
1915 .clear_inode
= xfs_fs_clear_inode
,
1916 .put_super
= xfs_fs_put_super
,
1917 .write_super
= xfs_fs_write_super
,
1918 .sync_fs
= xfs_fs_sync_super
,
1919 .write_super_lockfs
= xfs_fs_lockfs
,
1920 .statfs
= xfs_fs_statfs
,
1921 .remount_fs
= xfs_fs_remount
,
1922 .show_options
= xfs_fs_show_options
,
1925 static struct quotactl_ops xfs_quotactl_operations
= {
1926 .quota_sync
= xfs_fs_quotasync
,
1927 .get_xstate
= xfs_fs_getxstate
,
1928 .set_xstate
= xfs_fs_setxstate
,
1929 .get_xquota
= xfs_fs_getxquota
,
1930 .set_xquota
= xfs_fs_setxquota
,
1933 static struct file_system_type xfs_fs_type
= {
1934 .owner
= THIS_MODULE
,
1936 .get_sb
= xfs_fs_get_sb
,
1937 .kill_sb
= kill_block_super
,
1938 .fs_flags
= FS_REQUIRES_DEV
,
1942 xfs_alloc_trace_bufs(void)
1944 #ifdef XFS_ALLOC_TRACE
1945 xfs_alloc_trace_buf
= ktrace_alloc(XFS_ALLOC_TRACE_SIZE
, KM_MAYFAIL
);
1946 if (!xfs_alloc_trace_buf
)
1949 #ifdef XFS_BMAP_TRACE
1950 xfs_bmap_trace_buf
= ktrace_alloc(XFS_BMAP_TRACE_SIZE
, KM_MAYFAIL
);
1951 if (!xfs_bmap_trace_buf
)
1952 goto out_free_alloc_trace
;
1954 #ifdef XFS_BMBT_TRACE
1955 xfs_bmbt_trace_buf
= ktrace_alloc(XFS_BMBT_TRACE_SIZE
, KM_MAYFAIL
);
1956 if (!xfs_bmbt_trace_buf
)
1957 goto out_free_bmap_trace
;
1959 #ifdef XFS_ATTR_TRACE
1960 xfs_attr_trace_buf
= ktrace_alloc(XFS_ATTR_TRACE_SIZE
, KM_MAYFAIL
);
1961 if (!xfs_attr_trace_buf
)
1962 goto out_free_bmbt_trace
;
1964 #ifdef XFS_DIR2_TRACE
1965 xfs_dir2_trace_buf
= ktrace_alloc(XFS_DIR2_GTRACE_SIZE
, KM_MAYFAIL
);
1966 if (!xfs_dir2_trace_buf
)
1967 goto out_free_attr_trace
;
1972 #ifdef XFS_DIR2_TRACE
1973 out_free_attr_trace
:
1975 #ifdef XFS_ATTR_TRACE
1976 ktrace_free(xfs_attr_trace_buf
);
1977 out_free_bmbt_trace
:
1979 #ifdef XFS_BMBT_TRACE
1980 ktrace_free(xfs_bmbt_trace_buf
);
1981 out_free_bmap_trace
:
1983 #ifdef XFS_BMAP_TRACE
1984 ktrace_free(xfs_bmap_trace_buf
);
1985 out_free_alloc_trace
:
1987 #ifdef XFS_ALLOC_TRACE
1988 ktrace_free(xfs_alloc_trace_buf
);
1995 xfs_free_trace_bufs(void)
1997 #ifdef XFS_DIR2_TRACE
1998 ktrace_free(xfs_dir2_trace_buf
);
2000 #ifdef XFS_ATTR_TRACE
2001 ktrace_free(xfs_attr_trace_buf
);
2003 #ifdef XFS_BMBT_TRACE
2004 ktrace_free(xfs_bmbt_trace_buf
);
2006 #ifdef XFS_BMAP_TRACE
2007 ktrace_free(xfs_bmap_trace_buf
);
2009 #ifdef XFS_ALLOC_TRACE
2010 ktrace_free(xfs_alloc_trace_buf
);
2015 xfs_init_zones(void)
2017 xfs_vnode_zone
= kmem_zone_init_flags(sizeof(bhv_vnode_t
), "xfs_vnode",
2018 KM_ZONE_HWALIGN
| KM_ZONE_RECLAIM
|
2020 xfs_fs_inode_init_once
);
2021 if (!xfs_vnode_zone
)
2024 xfs_ioend_zone
= kmem_zone_init(sizeof(xfs_ioend_t
), "xfs_ioend");
2025 if (!xfs_ioend_zone
)
2026 goto out_destroy_vnode_zone
;
2028 xfs_ioend_pool
= mempool_create_slab_pool(4 * MAX_BUF_PER_PAGE
,
2030 if (!xfs_ioend_pool
)
2031 goto out_destroy_ioend_zone
;
2033 xfs_log_ticket_zone
= kmem_zone_init(sizeof(xlog_ticket_t
),
2035 if (!xfs_log_ticket_zone
)
2036 goto out_destroy_ioend_pool
;
2038 xfs_bmap_free_item_zone
= kmem_zone_init(sizeof(xfs_bmap_free_item_t
),
2039 "xfs_bmap_free_item");
2040 if (!xfs_bmap_free_item_zone
)
2041 goto out_destroy_log_ticket_zone
;
2042 xfs_btree_cur_zone
= kmem_zone_init(sizeof(xfs_btree_cur_t
),
2044 if (!xfs_btree_cur_zone
)
2045 goto out_destroy_bmap_free_item_zone
;
2047 xfs_da_state_zone
= kmem_zone_init(sizeof(xfs_da_state_t
),
2049 if (!xfs_da_state_zone
)
2050 goto out_destroy_btree_cur_zone
;
2052 xfs_dabuf_zone
= kmem_zone_init(sizeof(xfs_dabuf_t
), "xfs_dabuf");
2053 if (!xfs_dabuf_zone
)
2054 goto out_destroy_da_state_zone
;
2056 xfs_ifork_zone
= kmem_zone_init(sizeof(xfs_ifork_t
), "xfs_ifork");
2057 if (!xfs_ifork_zone
)
2058 goto out_destroy_dabuf_zone
;
2060 xfs_trans_zone
= kmem_zone_init(sizeof(xfs_trans_t
), "xfs_trans");
2061 if (!xfs_trans_zone
)
2062 goto out_destroy_ifork_zone
;
2065 * The size of the zone allocated buf log item is the maximum
2066 * size possible under XFS. This wastes a little bit of memory,
2067 * but it is much faster.
2069 xfs_buf_item_zone
= kmem_zone_init((sizeof(xfs_buf_log_item_t
) +
2070 (((XFS_MAX_BLOCKSIZE
/ XFS_BLI_CHUNK
) /
2071 NBWORD
) * sizeof(int))), "xfs_buf_item");
2072 if (!xfs_buf_item_zone
)
2073 goto out_destroy_trans_zone
;
2075 xfs_efd_zone
= kmem_zone_init((sizeof(xfs_efd_log_item_t
) +
2076 ((XFS_EFD_MAX_FAST_EXTENTS
- 1) *
2077 sizeof(xfs_extent_t
))), "xfs_efd_item");
2079 goto out_destroy_buf_item_zone
;
2081 xfs_efi_zone
= kmem_zone_init((sizeof(xfs_efi_log_item_t
) +
2082 ((XFS_EFI_MAX_FAST_EXTENTS
- 1) *
2083 sizeof(xfs_extent_t
))), "xfs_efi_item");
2085 goto out_destroy_efd_zone
;
2088 kmem_zone_init_flags(sizeof(xfs_inode_t
), "xfs_inode",
2089 KM_ZONE_HWALIGN
| KM_ZONE_RECLAIM
|
2090 KM_ZONE_SPREAD
, NULL
);
2091 if (!xfs_inode_zone
)
2092 goto out_destroy_efi_zone
;
2095 kmem_zone_init_flags(sizeof(xfs_inode_log_item_t
), "xfs_ili",
2096 KM_ZONE_SPREAD
, NULL
);
2098 goto out_destroy_inode_zone
;
2100 #ifdef CONFIG_XFS_POSIX_ACL
2101 xfs_acl_zone
= kmem_zone_init(sizeof(xfs_acl_t
), "xfs_acl");
2103 goto out_destroy_ili_zone
;
2108 #ifdef CONFIG_XFS_POSIX_ACL
2109 out_destroy_ili_zone
:
2111 kmem_zone_destroy(xfs_ili_zone
);
2112 out_destroy_inode_zone
:
2113 kmem_zone_destroy(xfs_inode_zone
);
2114 out_destroy_efi_zone
:
2115 kmem_zone_destroy(xfs_efi_zone
);
2116 out_destroy_efd_zone
:
2117 kmem_zone_destroy(xfs_efd_zone
);
2118 out_destroy_buf_item_zone
:
2119 kmem_zone_destroy(xfs_buf_item_zone
);
2120 out_destroy_trans_zone
:
2121 kmem_zone_destroy(xfs_trans_zone
);
2122 out_destroy_ifork_zone
:
2123 kmem_zone_destroy(xfs_ifork_zone
);
2124 out_destroy_dabuf_zone
:
2125 kmem_zone_destroy(xfs_dabuf_zone
);
2126 out_destroy_da_state_zone
:
2127 kmem_zone_destroy(xfs_da_state_zone
);
2128 out_destroy_btree_cur_zone
:
2129 kmem_zone_destroy(xfs_btree_cur_zone
);
2130 out_destroy_bmap_free_item_zone
:
2131 kmem_zone_destroy(xfs_bmap_free_item_zone
);
2132 out_destroy_log_ticket_zone
:
2133 kmem_zone_destroy(xfs_log_ticket_zone
);
2134 out_destroy_ioend_pool
:
2135 mempool_destroy(xfs_ioend_pool
);
2136 out_destroy_ioend_zone
:
2137 kmem_zone_destroy(xfs_ioend_zone
);
2138 out_destroy_vnode_zone
:
2139 kmem_zone_destroy(xfs_vnode_zone
);
2145 xfs_destroy_zones(void)
2147 #ifdef CONFIG_XFS_POSIX_ACL
2148 kmem_zone_destroy(xfs_acl_zone
);
2150 kmem_zone_destroy(xfs_ili_zone
);
2151 kmem_zone_destroy(xfs_inode_zone
);
2152 kmem_zone_destroy(xfs_efi_zone
);
2153 kmem_zone_destroy(xfs_efd_zone
);
2154 kmem_zone_destroy(xfs_buf_item_zone
);
2155 kmem_zone_destroy(xfs_trans_zone
);
2156 kmem_zone_destroy(xfs_ifork_zone
);
2157 kmem_zone_destroy(xfs_dabuf_zone
);
2158 kmem_zone_destroy(xfs_da_state_zone
);
2159 kmem_zone_destroy(xfs_btree_cur_zone
);
2160 kmem_zone_destroy(xfs_bmap_free_item_zone
);
2161 kmem_zone_destroy(xfs_log_ticket_zone
);
2162 mempool_destroy(xfs_ioend_pool
);
2163 kmem_zone_destroy(xfs_ioend_zone
);
2164 kmem_zone_destroy(xfs_vnode_zone
);
2172 static char message
[] __initdata
= KERN_INFO \
2173 XFS_VERSION_STRING
" with " XFS_BUILD_OPTIONS
" enabled\n";
2181 error
= xfs_init_zones();
2185 error
= xfs_alloc_trace_bufs();
2187 goto out_destroy_zones
;
2189 error
= xfs_mru_cache_init();
2191 goto out_free_trace_buffers
;
2193 error
= xfs_filestream_init();
2195 goto out_mru_cache_uninit
;
2197 error
= xfs_buf_init();
2199 goto out_filestream_uninit
;
2201 error
= xfs_init_procfs();
2203 goto out_buf_terminate
;
2205 error
= xfs_sysctl_register();
2207 goto out_cleanup_procfs
;
2211 error
= register_filesystem(&xfs_fs_type
);
2213 goto out_sysctl_unregister
;
2216 out_sysctl_unregister
:
2217 xfs_sysctl_unregister();
2219 xfs_cleanup_procfs();
2221 xfs_buf_terminate();
2222 out_filestream_uninit
:
2223 xfs_filestream_uninit();
2224 out_mru_cache_uninit
:
2225 xfs_mru_cache_uninit();
2226 out_free_trace_buffers
:
2227 xfs_free_trace_bufs();
2229 xfs_destroy_zones();
2238 unregister_filesystem(&xfs_fs_type
);
2239 xfs_sysctl_unregister();
2240 xfs_cleanup_procfs();
2241 xfs_buf_terminate();
2242 xfs_filestream_uninit();
2243 xfs_mru_cache_uninit();
2244 xfs_free_trace_bufs();
2245 xfs_destroy_zones();
2249 module_init(init_xfs_fs
);
2250 module_exit(exit_xfs_fs
);
2252 MODULE_AUTHOR("Silicon Graphics, Inc.");
2253 MODULE_DESCRIPTION(XFS_VERSION_STRING
" with " XFS_BUILD_OPTIONS
" enabled");
2254 MODULE_LICENSE("GPL");