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