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