1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * NILFS module and super block management.
4 *
5 * Copyright (C) 2005-2008 Nippon Telegraph and Telephone Corporation.
6 *
7 * Written by Ryusuke Konishi.
8 */
9/*
10 * linux/fs/ext2/super.c
11 *
12 * Copyright (C) 1992, 1993, 1994, 1995
13 * Remy Card (card@masi.ibp.fr)
14 * Laboratoire MASI - Institut Blaise Pascal
15 * Universite Pierre et Marie Curie (Paris VI)
16 *
17 * from
18 *
19 * linux/fs/minix/inode.c
20 *
21 * Copyright (C) 1991, 1992 Linus Torvalds
22 *
23 * Big-endian to little-endian byte-swapping/bitmaps by
24 * David S. Miller (davem@caip.rutgers.edu), 1995
25 */
26
27#include <linux/module.h>
28#include <linux/string.h>
29#include <linux/slab.h>
30#include <linux/init.h>
31#include <linux/blkdev.h>
32#include <linux/crc32.h>
33#include <linux/vfs.h>
34#include <linux/writeback.h>
35#include <linux/seq_file.h>
36#include <linux/mount.h>
37#include <linux/fs_context.h>
38#include <linux/fs_parser.h>
39#include "nilfs.h"
40#include "export.h"
41#include "mdt.h"
42#include "alloc.h"
43#include "btree.h"
44#include "btnode.h"
45#include "page.h"
46#include "cpfile.h"
47#include "sufile.h" /* nilfs_sufile_resize(), nilfs_sufile_set_alloc_range() */
48#include "ifile.h"
49#include "dat.h"
50#include "segment.h"
51#include "segbuf.h"
52
53MODULE_AUTHOR("NTT Corp.");
54MODULE_DESCRIPTION("A New Implementation of the Log-structured Filesystem "
55 "(NILFS)");
56MODULE_LICENSE("GPL");
57
58static struct kmem_cache *nilfs_inode_cachep;
59struct kmem_cache *nilfs_transaction_cachep;
60struct kmem_cache *nilfs_segbuf_cachep;
61struct kmem_cache *nilfs_btree_path_cache;
62
63static int nilfs_setup_super(struct super_block *sb, int is_mount);
64
65void __nilfs_msg(struct super_block *sb, const char *fmt, ...)
66{
67 struct va_format vaf;
68 va_list args;
69 int level;
70
71 va_start(args, fmt);
72
73 level = printk_get_level(buffer: fmt);
74 vaf.fmt = printk_skip_level(buffer: fmt);
75 vaf.va = &args;
76
77 if (sb)
78 printk("%c%cNILFS (%s): %pV\n",
79 KERN_SOH_ASCII, level, sb->s_id, &vaf);
80 else
81 printk("%c%cNILFS: %pV\n",
82 KERN_SOH_ASCII, level, &vaf);
83
84 va_end(args);
85}
86
87static void nilfs_set_error(struct super_block *sb)
88{
89 struct the_nilfs *nilfs = sb->s_fs_info;
90 struct nilfs_super_block **sbp;
91
92 down_write(sem: &nilfs->ns_sem);
93 if (!(nilfs->ns_mount_state & NILFS_ERROR_FS)) {
94 nilfs->ns_mount_state |= NILFS_ERROR_FS;
95 sbp = nilfs_prepare_super(sb, flip: 0);
96 if (likely(sbp)) {
97 sbp[0]->s_state |= cpu_to_le16(NILFS_ERROR_FS);
98 if (sbp[1])
99 sbp[1]->s_state |= cpu_to_le16(NILFS_ERROR_FS);
100 nilfs_commit_super(sb, flag: NILFS_SB_COMMIT_ALL);
101 }
102 }
103 up_write(sem: &nilfs->ns_sem);
104}
105
106/**
107 * __nilfs_error() - report failure condition on a filesystem
108 * @sb: super block instance
109 * @function: name of calling function
110 * @fmt: format string for message to be output
111 * @...: optional arguments to @fmt
112 *
113 * __nilfs_error() sets an ERROR_FS flag on the superblock as well as
114 * reporting an error message. This function should be called when
115 * NILFS detects incoherences or defects of meta data on disk.
116 *
117 * This implements the body of nilfs_error() macro. Normally,
118 * nilfs_error() should be used. As for sustainable errors such as a
119 * single-shot I/O error, nilfs_err() should be used instead.
120 *
121 * Callers should not add a trailing newline since this will do it.
122 */
123void __nilfs_error(struct super_block *sb, const char *function,
124 const char *fmt, ...)
125{
126 struct the_nilfs *nilfs = sb->s_fs_info;
127 struct va_format vaf;
128 va_list args;
129
130 va_start(args, fmt);
131
132 vaf.fmt = fmt;
133 vaf.va = &args;
134
135 printk(KERN_CRIT "NILFS error (device %s): %s: %pV\n",
136 sb->s_id, function, &vaf);
137
138 va_end(args);
139
140 if (!sb_rdonly(sb)) {
141 nilfs_set_error(sb);
142
143 if (nilfs_test_opt(nilfs, ERRORS_RO)) {
144 printk(KERN_CRIT "Remounting filesystem read-only\n");
145 sb->s_flags |= SB_RDONLY;
146 }
147 }
148
149 if (nilfs_test_opt(nilfs, ERRORS_PANIC))
150 panic(fmt: "NILFS (device %s): panic forced after error\n",
151 sb->s_id);
152}
153
154struct inode *nilfs_alloc_inode(struct super_block *sb)
155{
156 struct nilfs_inode_info *ii;
157
158 ii = alloc_inode_sb(sb, nilfs_inode_cachep, GFP_NOFS);
159 if (!ii)
160 return NULL;
161 ii->i_bh = NULL;
162 ii->i_state = 0;
163 ii->i_type = 0;
164 ii->i_cno = 0;
165 ii->i_assoc_inode = NULL;
166 ii->i_bmap = &ii->i_bmap_data;
167 return &ii->vfs_inode;
168}
169
170static void nilfs_free_inode(struct inode *inode)
171{
172 if (nilfs_is_metadata_file_inode(inode))
173 nilfs_mdt_destroy(inode);
174
175 kmem_cache_free(s: nilfs_inode_cachep, objp: NILFS_I(inode));
176}
177
178static int nilfs_sync_super(struct super_block *sb, int flag)
179{
180 struct the_nilfs *nilfs = sb->s_fs_info;
181 int err;
182
183 retry:
184 set_buffer_dirty(nilfs->ns_sbh[0]);
185 if (nilfs_test_opt(nilfs, BARRIER)) {
186 err = __sync_dirty_buffer(bh: nilfs->ns_sbh[0],
187 REQ_SYNC | REQ_PREFLUSH | REQ_FUA);
188 } else {
189 err = sync_dirty_buffer(bh: nilfs->ns_sbh[0]);
190 }
191
192 if (unlikely(err)) {
193 nilfs_err(sb, "unable to write superblock: err=%d", err);
194 if (err == -EIO && nilfs->ns_sbh[1]) {
195 /*
196 * sbp[0] points to newer log than sbp[1],
197 * so copy sbp[0] to sbp[1] to take over sbp[0].
198 */
199 memcpy(nilfs->ns_sbp[1], nilfs->ns_sbp[0],
200 nilfs->ns_sbsize);
201 nilfs_fall_back_super_block(nilfs);
202 goto retry;
203 }
204 } else {
205 struct nilfs_super_block *sbp = nilfs->ns_sbp[0];
206
207 nilfs->ns_sbwcount++;
208
209 /*
210 * The latest segment becomes trailable from the position
211 * written in superblock.
212 */
213 clear_nilfs_discontinued(nilfs);
214
215 /* update GC protection for recent segments */
216 if (nilfs->ns_sbh[1]) {
217 if (flag == NILFS_SB_COMMIT_ALL) {
218 set_buffer_dirty(nilfs->ns_sbh[1]);
219 if (sync_dirty_buffer(bh: nilfs->ns_sbh[1]) < 0)
220 goto out;
221 }
222 if (le64_to_cpu(nilfs->ns_sbp[1]->s_last_cno) <
223 le64_to_cpu(nilfs->ns_sbp[0]->s_last_cno))
224 sbp = nilfs->ns_sbp[1];
225 }
226
227 spin_lock(lock: &nilfs->ns_last_segment_lock);
228 nilfs->ns_prot_seq = le64_to_cpu(sbp->s_last_seq);
229 spin_unlock(lock: &nilfs->ns_last_segment_lock);
230 }
231 out:
232 return err;
233}
234
235void nilfs_set_log_cursor(struct nilfs_super_block *sbp,
236 struct the_nilfs *nilfs)
237{
238 sector_t nfreeblocks;
239
240 /* nilfs->ns_sem must be locked by the caller. */
241 nilfs_count_free_blocks(nilfs, &nfreeblocks);
242 sbp->s_free_blocks_count = cpu_to_le64(nfreeblocks);
243
244 spin_lock(lock: &nilfs->ns_last_segment_lock);
245 sbp->s_last_seq = cpu_to_le64(nilfs->ns_last_seq);
246 sbp->s_last_pseg = cpu_to_le64(nilfs->ns_last_pseg);
247 sbp->s_last_cno = cpu_to_le64(nilfs->ns_last_cno);
248 spin_unlock(lock: &nilfs->ns_last_segment_lock);
249}
250
251struct nilfs_super_block **nilfs_prepare_super(struct super_block *sb,
252 int flip)
253{
254 struct the_nilfs *nilfs = sb->s_fs_info;
255 struct nilfs_super_block **sbp = nilfs->ns_sbp;
256
257 /* nilfs->ns_sem must be locked by the caller. */
258 if (sbp[0]->s_magic != cpu_to_le16(NILFS_SUPER_MAGIC)) {
259 if (sbp[1] &&
260 sbp[1]->s_magic == cpu_to_le16(NILFS_SUPER_MAGIC)) {
261 memcpy(sbp[0], sbp[1], nilfs->ns_sbsize);
262 } else {
263 nilfs_crit(sb, "superblock broke");
264 return NULL;
265 }
266 } else if (sbp[1] &&
267 sbp[1]->s_magic != cpu_to_le16(NILFS_SUPER_MAGIC)) {
268 memcpy(sbp[1], sbp[0], nilfs->ns_sbsize);
269 }
270
271 if (flip && sbp[1])
272 nilfs_swap_super_block(nilfs);
273
274 return sbp;
275}
276
277int nilfs_commit_super(struct super_block *sb, int flag)
278{
279 struct the_nilfs *nilfs = sb->s_fs_info;
280 struct nilfs_super_block **sbp = nilfs->ns_sbp;
281 time64_t t;
282
283 /* nilfs->ns_sem must be locked by the caller. */
284 t = ktime_get_real_seconds();
285 nilfs->ns_sbwtime = t;
286 sbp[0]->s_wtime = cpu_to_le64(t);
287 sbp[0]->s_sum = 0;
288 sbp[0]->s_sum = cpu_to_le32(crc32_le(nilfs->ns_crc_seed,
289 (unsigned char *)sbp[0],
290 nilfs->ns_sbsize));
291 if (flag == NILFS_SB_COMMIT_ALL && sbp[1]) {
292 sbp[1]->s_wtime = sbp[0]->s_wtime;
293 sbp[1]->s_sum = 0;
294 sbp[1]->s_sum = cpu_to_le32(crc32_le(nilfs->ns_crc_seed,
295 (unsigned char *)sbp[1],
296 nilfs->ns_sbsize));
297 }
298 clear_nilfs_sb_dirty(nilfs);
299 nilfs->ns_flushed_device = 1;
300 /* make sure store to ns_flushed_device cannot be reordered */
301 smp_wmb();
302 return nilfs_sync_super(sb, flag);
303}
304
305/**
306 * nilfs_cleanup_super() - write filesystem state for cleanup
307 * @sb: super block instance to be unmounted or degraded to read-only
308 *
309 * This function restores state flags in the on-disk super block.
310 * This will set "clean" flag (i.e. NILFS_VALID_FS) unless the
311 * filesystem was not clean previously.
312 *
313 * Return: 0 on success, %-EIO if I/O error or superblock is corrupted.
314 */
315int nilfs_cleanup_super(struct super_block *sb)
316{
317 struct the_nilfs *nilfs = sb->s_fs_info;
318 struct nilfs_super_block **sbp;
319 int flag = NILFS_SB_COMMIT;
320 int ret = -EIO;
321
322 sbp = nilfs_prepare_super(sb, flip: 0);
323 if (sbp) {
324 sbp[0]->s_state = cpu_to_le16(nilfs->ns_mount_state);
325 nilfs_set_log_cursor(sbp: sbp[0], nilfs);
326 if (sbp[1] && sbp[0]->s_last_cno == sbp[1]->s_last_cno) {
327 /*
328 * make the "clean" flag also to the opposite
329 * super block if both super blocks point to
330 * the same checkpoint.
331 */
332 sbp[1]->s_state = sbp[0]->s_state;
333 flag = NILFS_SB_COMMIT_ALL;
334 }
335 ret = nilfs_commit_super(sb, flag);
336 }
337 return ret;
338}
339
340/**
341 * nilfs_move_2nd_super - relocate secondary super block
342 * @sb: super block instance
343 * @sb2off: new offset of the secondary super block (in bytes)
344 *
345 * Return: 0 on success, or a negative error code on failure.
346 */
347static int nilfs_move_2nd_super(struct super_block *sb, loff_t sb2off)
348{
349 struct the_nilfs *nilfs = sb->s_fs_info;
350 struct buffer_head *nsbh;
351 struct nilfs_super_block *nsbp;
352 sector_t blocknr, newblocknr;
353 unsigned long offset;
354 int sb2i; /* array index of the secondary superblock */
355 int ret = 0;
356
357 /* nilfs->ns_sem must be locked by the caller. */
358 if (nilfs->ns_sbh[1] &&
359 nilfs->ns_sbh[1]->b_blocknr > nilfs->ns_first_data_block) {
360 sb2i = 1;
361 blocknr = nilfs->ns_sbh[1]->b_blocknr;
362 } else if (nilfs->ns_sbh[0]->b_blocknr > nilfs->ns_first_data_block) {
363 sb2i = 0;
364 blocknr = nilfs->ns_sbh[0]->b_blocknr;
365 } else {
366 sb2i = -1;
367 blocknr = 0;
368 }
369 if (sb2i >= 0 && (u64)blocknr << nilfs->ns_blocksize_bits == sb2off)
370 goto out; /* super block location is unchanged */
371
372 /* Get new super block buffer */
373 newblocknr = sb2off >> nilfs->ns_blocksize_bits;
374 offset = sb2off & (nilfs->ns_blocksize - 1);
375 nsbh = sb_getblk(sb, block: newblocknr);
376 if (!nsbh) {
377 nilfs_warn(sb,
378 "unable to move secondary superblock to block %llu",
379 (unsigned long long)newblocknr);
380 ret = -EIO;
381 goto out;
382 }
383 nsbp = (void *)nsbh->b_data + offset;
384
385 lock_buffer(bh: nsbh);
386 if (sb2i >= 0) {
387 /*
388 * The position of the second superblock only changes by 4KiB,
389 * which is larger than the maximum superblock data size
390 * (= 1KiB), so there is no need to use memmove() to allow
391 * overlap between source and destination.
392 */
393 memcpy(nsbp, nilfs->ns_sbp[sb2i], nilfs->ns_sbsize);
394
395 /*
396 * Zero fill after copy to avoid overwriting in case of move
397 * within the same block.
398 */
399 memset(nsbh->b_data, 0, offset);
400 memset((void *)nsbp + nilfs->ns_sbsize, 0,
401 nsbh->b_size - offset - nilfs->ns_sbsize);
402 } else {
403 memset(nsbh->b_data, 0, nsbh->b_size);
404 }
405 set_buffer_uptodate(nsbh);
406 unlock_buffer(bh: nsbh);
407
408 if (sb2i >= 0) {
409 brelse(bh: nilfs->ns_sbh[sb2i]);
410 nilfs->ns_sbh[sb2i] = nsbh;
411 nilfs->ns_sbp[sb2i] = nsbp;
412 } else if (nilfs->ns_sbh[0]->b_blocknr < nilfs->ns_first_data_block) {
413 /* secondary super block will be restored to index 1 */
414 nilfs->ns_sbh[1] = nsbh;
415 nilfs->ns_sbp[1] = nsbp;
416 } else {
417 brelse(bh: nsbh);
418 }
419out:
420 return ret;
421}
422
423/**
424 * nilfs_resize_fs - resize the filesystem
425 * @sb: super block instance
426 * @newsize: new size of the filesystem (in bytes)
427 *
428 * Return: 0 on success, or a negative error code on failure.
429 */
430int nilfs_resize_fs(struct super_block *sb, __u64 newsize)
431{
432 struct the_nilfs *nilfs = sb->s_fs_info;
433 struct nilfs_super_block **sbp;
434 __u64 devsize, newnsegs;
435 loff_t sb2off;
436 int ret;
437
438 ret = -ERANGE;
439 devsize = bdev_nr_bytes(bdev: sb->s_bdev);
440 if (newsize > devsize)
441 goto out;
442
443 /*
444 * Prevent underflow in second superblock position calculation.
445 * The exact minimum size check is done in nilfs_sufile_resize().
446 */
447 if (newsize < 4096) {
448 ret = -ENOSPC;
449 goto out;
450 }
451
452 /*
453 * Write lock is required to protect some functions depending
454 * on the number of segments, the number of reserved segments,
455 * and so forth.
456 */
457 down_write(sem: &nilfs->ns_segctor_sem);
458
459 sb2off = NILFS_SB2_OFFSET_BYTES(newsize);
460 newnsegs = sb2off >> nilfs->ns_blocksize_bits;
461 newnsegs = div64_ul(newnsegs, nilfs->ns_blocks_per_segment);
462
463 ret = nilfs_sufile_resize(sufile: nilfs->ns_sufile, newnsegs);
464 up_write(sem: &nilfs->ns_segctor_sem);
465 if (ret < 0)
466 goto out;
467
468 ret = nilfs_construct_segment(sb);
469 if (ret < 0)
470 goto out;
471
472 down_write(sem: &nilfs->ns_sem);
473 nilfs_move_2nd_super(sb, sb2off);
474 ret = -EIO;
475 sbp = nilfs_prepare_super(sb, flip: 0);
476 if (likely(sbp)) {
477 nilfs_set_log_cursor(sbp: sbp[0], nilfs);
478 /*
479 * Drop NILFS_RESIZE_FS flag for compatibility with
480 * mount-time resize which may be implemented in a
481 * future release.
482 */
483 sbp[0]->s_state = cpu_to_le16(le16_to_cpu(sbp[0]->s_state) &
484 ~NILFS_RESIZE_FS);
485 sbp[0]->s_dev_size = cpu_to_le64(newsize);
486 sbp[0]->s_nsegments = cpu_to_le64(nilfs->ns_nsegments);
487 if (sbp[1])
488 memcpy(sbp[1], sbp[0], nilfs->ns_sbsize);
489 ret = nilfs_commit_super(sb, flag: NILFS_SB_COMMIT_ALL);
490 }
491 up_write(sem: &nilfs->ns_sem);
492
493 /*
494 * Reset the range of allocatable segments last. This order
495 * is important in the case of expansion because the secondary
496 * superblock must be protected from log write until migration
497 * completes.
498 */
499 if (!ret)
500 nilfs_sufile_set_alloc_range(sufile: nilfs->ns_sufile, start: 0, end: newnsegs - 1);
501out:
502 return ret;
503}
504
505static void nilfs_put_super(struct super_block *sb)
506{
507 struct the_nilfs *nilfs = sb->s_fs_info;
508
509 nilfs_detach_log_writer(sb);
510
511 if (!sb_rdonly(sb)) {
512 down_write(sem: &nilfs->ns_sem);
513 nilfs_cleanup_super(sb);
514 up_write(sem: &nilfs->ns_sem);
515 }
516
517 nilfs_sysfs_delete_device_group(nilfs);
518 iput(nilfs->ns_sufile);
519 iput(nilfs->ns_cpfile);
520 iput(nilfs->ns_dat);
521
522 destroy_nilfs(nilfs);
523 sb->s_fs_info = NULL;
524}
525
526static int nilfs_sync_fs(struct super_block *sb, int wait)
527{
528 struct the_nilfs *nilfs = sb->s_fs_info;
529 struct nilfs_super_block **sbp;
530 int err = 0;
531
532 /* This function is called when super block should be written back */
533 if (wait)
534 err = nilfs_construct_segment(sb);
535
536 down_write(sem: &nilfs->ns_sem);
537 if (nilfs_sb_dirty(nilfs)) {
538 sbp = nilfs_prepare_super(sb, flip: nilfs_sb_will_flip(nilfs));
539 if (likely(sbp)) {
540 nilfs_set_log_cursor(sbp: sbp[0], nilfs);
541 nilfs_commit_super(sb, flag: NILFS_SB_COMMIT);
542 }
543 }
544 up_write(sem: &nilfs->ns_sem);
545
546 if (!err)
547 err = nilfs_flush_device(nilfs);
548
549 return err;
550}
551
552int nilfs_attach_checkpoint(struct super_block *sb, __u64 cno, int curr_mnt,
553 struct nilfs_root **rootp)
554{
555 struct the_nilfs *nilfs = sb->s_fs_info;
556 struct nilfs_root *root;
557 int err = -ENOMEM;
558
559 root = nilfs_find_or_create_root(
560 nilfs, cno: curr_mnt ? NILFS_CPTREE_CURRENT_CNO : cno);
561 if (!root)
562 return err;
563
564 if (root->ifile)
565 goto reuse; /* already attached checkpoint */
566
567 down_read(sem: &nilfs->ns_segctor_sem);
568 err = nilfs_ifile_read(sb, root, cno, inode_size: nilfs->ns_inode_size);
569 up_read(sem: &nilfs->ns_segctor_sem);
570 if (unlikely(err))
571 goto failed;
572
573 reuse:
574 *rootp = root;
575 return 0;
576
577 failed:
578 if (err == -EINVAL)
579 nilfs_err(sb, "Invalid checkpoint (checkpoint number=%llu)",
580 (unsigned long long)cno);
581 nilfs_put_root(root);
582
583 return err;
584}
585
586static int nilfs_freeze(struct super_block *sb)
587{
588 struct the_nilfs *nilfs = sb->s_fs_info;
589 int err;
590
591 if (sb_rdonly(sb))
592 return 0;
593
594 /* Mark super block clean */
595 down_write(sem: &nilfs->ns_sem);
596 err = nilfs_cleanup_super(sb);
597 up_write(sem: &nilfs->ns_sem);
598 return err;
599}
600
601static int nilfs_unfreeze(struct super_block *sb)
602{
603 struct the_nilfs *nilfs = sb->s_fs_info;
604
605 if (sb_rdonly(sb))
606 return 0;
607
608 down_write(sem: &nilfs->ns_sem);
609 nilfs_setup_super(sb, is_mount: false);
610 up_write(sem: &nilfs->ns_sem);
611 return 0;
612}
613
614static int nilfs_statfs(struct dentry *dentry, struct kstatfs *buf)
615{
616 struct super_block *sb = dentry->d_sb;
617 struct nilfs_root *root = NILFS_I(inode: d_inode(dentry))->i_root;
618 struct the_nilfs *nilfs = root->nilfs;
619 u64 id = huge_encode_dev(dev: sb->s_bdev->bd_dev);
620 unsigned long long blocks;
621 unsigned long overhead;
622 unsigned long nrsvblocks;
623 sector_t nfreeblocks;
624 u64 nmaxinodes, nfreeinodes;
625 int err;
626
627 /*
628 * Compute all of the segment blocks
629 *
630 * The blocks before first segment and after last segment
631 * are excluded.
632 */
633 blocks = nilfs->ns_blocks_per_segment * nilfs->ns_nsegments
634 - nilfs->ns_first_data_block;
635 nrsvblocks = nilfs->ns_nrsvsegs * nilfs->ns_blocks_per_segment;
636
637 /*
638 * Compute the overhead
639 *
640 * When distributing meta data blocks outside segment structure,
641 * We must count them as the overhead.
642 */
643 overhead = 0;
644
645 err = nilfs_count_free_blocks(nilfs, &nfreeblocks);
646 if (unlikely(err))
647 return err;
648
649 err = nilfs_ifile_count_free_inodes(root->ifile,
650 &nmaxinodes, &nfreeinodes);
651 if (unlikely(err)) {
652 nilfs_warn(sb, "failed to count free inodes: err=%d", err);
653 if (err == -ERANGE) {
654 /*
655 * If nilfs_palloc_count_max_entries() returns
656 * -ERANGE error code then we simply treat
657 * curent inodes count as maximum possible and
658 * zero as free inodes value.
659 */
660 nmaxinodes = atomic64_read(v: &root->inodes_count);
661 nfreeinodes = 0;
662 err = 0;
663 } else
664 return err;
665 }
666
667 buf->f_type = NILFS_SUPER_MAGIC;
668 buf->f_bsize = sb->s_blocksize;
669 buf->f_blocks = blocks - overhead;
670 buf->f_bfree = nfreeblocks;
671 buf->f_bavail = (buf->f_bfree >= nrsvblocks) ?
672 (buf->f_bfree - nrsvblocks) : 0;
673 buf->f_files = nmaxinodes;
674 buf->f_ffree = nfreeinodes;
675 buf->f_namelen = NILFS_NAME_LEN;
676 buf->f_fsid = u64_to_fsid(v: id);
677
678 return 0;
679}
680
681static int nilfs_show_options(struct seq_file *seq, struct dentry *dentry)
682{
683 struct super_block *sb = dentry->d_sb;
684 struct the_nilfs *nilfs = sb->s_fs_info;
685 struct nilfs_root *root = NILFS_I(inode: d_inode(dentry))->i_root;
686
687 if (!nilfs_test_opt(nilfs, BARRIER))
688 seq_puts(m: seq, s: ",nobarrier");
689 if (root->cno != NILFS_CPTREE_CURRENT_CNO)
690 seq_printf(m: seq, fmt: ",cp=%llu", (unsigned long long)root->cno);
691 if (nilfs_test_opt(nilfs, ERRORS_PANIC))
692 seq_puts(m: seq, s: ",errors=panic");
693 if (nilfs_test_opt(nilfs, ERRORS_CONT))
694 seq_puts(m: seq, s: ",errors=continue");
695 if (nilfs_test_opt(nilfs, STRICT_ORDER))
696 seq_puts(m: seq, s: ",order=strict");
697 if (nilfs_test_opt(nilfs, NORECOVERY))
698 seq_puts(m: seq, s: ",norecovery");
699 if (nilfs_test_opt(nilfs, DISCARD))
700 seq_puts(m: seq, s: ",discard");
701
702 return 0;
703}
704
705static const struct super_operations nilfs_sops = {
706 .alloc_inode = nilfs_alloc_inode,
707 .free_inode = nilfs_free_inode,
708 .dirty_inode = nilfs_dirty_inode,
709 .evict_inode = nilfs_evict_inode,
710 .put_super = nilfs_put_super,
711 .sync_fs = nilfs_sync_fs,
712 .freeze_fs = nilfs_freeze,
713 .unfreeze_fs = nilfs_unfreeze,
714 .statfs = nilfs_statfs,
715 .show_options = nilfs_show_options
716};
717
718enum {
719 Opt_err, Opt_barrier, Opt_snapshot, Opt_order, Opt_norecovery,
720 Opt_discard,
721};
722
723static const struct constant_table nilfs_param_err[] = {
724 {"continue", NILFS_MOUNT_ERRORS_CONT},
725 {"panic", NILFS_MOUNT_ERRORS_PANIC},
726 {"remount-ro", NILFS_MOUNT_ERRORS_RO},
727 {}
728};
729
730static const struct fs_parameter_spec nilfs_param_spec[] = {
731 fsparam_enum ("errors", Opt_err, nilfs_param_err),
732 fsparam_flag_no ("barrier", Opt_barrier),
733 fsparam_u64 ("cp", Opt_snapshot),
734 fsparam_string ("order", Opt_order),
735 fsparam_flag ("norecovery", Opt_norecovery),
736 fsparam_flag_no ("discard", Opt_discard),
737 {}
738};
739
740struct nilfs_fs_context {
741 unsigned long ns_mount_opt;
742 __u64 cno;
743};
744
745static int nilfs_parse_param(struct fs_context *fc, struct fs_parameter *param)
746{
747 struct nilfs_fs_context *nilfs = fc->fs_private;
748 int is_remount = fc->purpose == FS_CONTEXT_FOR_RECONFIGURE;
749 struct fs_parse_result result;
750 int opt;
751
752 opt = fs_parse(fc, desc: nilfs_param_spec, param, result: &result);
753 if (opt < 0)
754 return opt;
755
756 switch (opt) {
757 case Opt_barrier:
758 if (result.negated)
759 nilfs_clear_opt(nilfs, BARRIER);
760 else
761 nilfs_set_opt(nilfs, BARRIER);
762 break;
763 case Opt_order:
764 if (strcmp(param->string, "relaxed") == 0)
765 /* Ordered data semantics */
766 nilfs_clear_opt(nilfs, STRICT_ORDER);
767 else if (strcmp(param->string, "strict") == 0)
768 /* Strict in-order semantics */
769 nilfs_set_opt(nilfs, STRICT_ORDER);
770 else
771 return -EINVAL;
772 break;
773 case Opt_err:
774 nilfs->ns_mount_opt &= ~NILFS_MOUNT_ERROR_MODE;
775 nilfs->ns_mount_opt |= result.uint_32;
776 break;
777 case Opt_snapshot:
778 if (is_remount) {
779 struct super_block *sb = fc->root->d_sb;
780
781 nilfs_err(sb,
782 "\"%s\" option is invalid for remount",
783 param->key);
784 return -EINVAL;
785 }
786 if (result.uint_64 == 0) {
787 nilfs_err(NULL,
788 "invalid option \"cp=0\": invalid checkpoint number 0");
789 return -EINVAL;
790 }
791 nilfs->cno = result.uint_64;
792 break;
793 case Opt_norecovery:
794 nilfs_set_opt(nilfs, NORECOVERY);
795 break;
796 case Opt_discard:
797 if (result.negated)
798 nilfs_clear_opt(nilfs, DISCARD);
799 else
800 nilfs_set_opt(nilfs, DISCARD);
801 break;
802 default:
803 return -EINVAL;
804 }
805
806 return 0;
807}
808
809static int nilfs_setup_super(struct super_block *sb, int is_mount)
810{
811 struct the_nilfs *nilfs = sb->s_fs_info;
812 struct nilfs_super_block **sbp;
813 int max_mnt_count;
814 int mnt_count;
815
816 /* nilfs->ns_sem must be locked by the caller. */
817 sbp = nilfs_prepare_super(sb, flip: 0);
818 if (!sbp)
819 return -EIO;
820
821 if (!is_mount)
822 goto skip_mount_setup;
823
824 max_mnt_count = le16_to_cpu(sbp[0]->s_max_mnt_count);
825 mnt_count = le16_to_cpu(sbp[0]->s_mnt_count);
826
827 if (nilfs->ns_mount_state & NILFS_ERROR_FS) {
828 nilfs_warn(sb, "mounting fs with errors");
829#if 0
830 } else if (max_mnt_count >= 0 && mnt_count >= max_mnt_count) {
831 nilfs_warn(sb, "maximal mount count reached");
832#endif
833 }
834 if (!max_mnt_count)
835 sbp[0]->s_max_mnt_count = cpu_to_le16(NILFS_DFL_MAX_MNT_COUNT);
836
837 sbp[0]->s_mnt_count = cpu_to_le16(mnt_count + 1);
838 sbp[0]->s_mtime = cpu_to_le64(ktime_get_real_seconds());
839
840skip_mount_setup:
841 sbp[0]->s_state =
842 cpu_to_le16(le16_to_cpu(sbp[0]->s_state) & ~NILFS_VALID_FS);
843 /* synchronize sbp[1] with sbp[0] */
844 if (sbp[1])
845 memcpy(sbp[1], sbp[0], nilfs->ns_sbsize);
846 return nilfs_commit_super(sb, flag: NILFS_SB_COMMIT_ALL);
847}
848
849struct nilfs_super_block *nilfs_read_super_block(struct super_block *sb,
850 u64 pos, int blocksize,
851 struct buffer_head **pbh)
852{
853 unsigned long long sb_index = pos;
854 unsigned long offset;
855
856 offset = do_div(sb_index, blocksize);
857 *pbh = sb_bread(sb, block: sb_index);
858 if (!*pbh)
859 return NULL;
860 return (struct nilfs_super_block *)((char *)(*pbh)->b_data + offset);
861}
862
863int nilfs_store_magic(struct super_block *sb,
864 struct nilfs_super_block *sbp)
865{
866 struct the_nilfs *nilfs = sb->s_fs_info;
867
868 sb->s_magic = le16_to_cpu(sbp->s_magic);
869
870 /* FS independent flags */
871#ifdef NILFS_ATIME_DISABLE
872 sb->s_flags |= SB_NOATIME;
873#endif
874
875 nilfs->ns_resuid = le16_to_cpu(sbp->s_def_resuid);
876 nilfs->ns_resgid = le16_to_cpu(sbp->s_def_resgid);
877 nilfs->ns_interval = le32_to_cpu(sbp->s_c_interval);
878 nilfs->ns_watermark = le32_to_cpu(sbp->s_c_block_max);
879
880 return 0;
881}
882
883int nilfs_check_feature_compatibility(struct super_block *sb,
884 struct nilfs_super_block *sbp)
885{
886 __u64 features;
887
888 features = le64_to_cpu(sbp->s_feature_incompat) &
889 ~NILFS_FEATURE_INCOMPAT_SUPP;
890 if (features) {
891 nilfs_err(sb,
892 "couldn't mount because of unsupported optional features (%llx)",
893 (unsigned long long)features);
894 return -EINVAL;
895 }
896 features = le64_to_cpu(sbp->s_feature_compat_ro) &
897 ~NILFS_FEATURE_COMPAT_RO_SUPP;
898 if (!sb_rdonly(sb) && features) {
899 nilfs_err(sb,
900 "couldn't mount RDWR because of unsupported optional features (%llx)",
901 (unsigned long long)features);
902 return -EINVAL;
903 }
904 return 0;
905}
906
907static int nilfs_get_root_dentry(struct super_block *sb,
908 struct nilfs_root *root,
909 struct dentry **root_dentry)
910{
911 struct inode *inode;
912 struct dentry *dentry;
913 int ret = 0;
914
915 inode = nilfs_iget(sb, root, NILFS_ROOT_INO);
916 if (IS_ERR(ptr: inode)) {
917 ret = PTR_ERR(ptr: inode);
918 nilfs_err(sb, "error %d getting root inode", ret);
919 goto out;
920 }
921 if (!S_ISDIR(inode->i_mode) || !inode->i_blocks || !inode->i_size) {
922 iput(inode);
923 nilfs_err(sb, "corrupt root inode");
924 ret = -EINVAL;
925 goto out;
926 }
927
928 if (root->cno == NILFS_CPTREE_CURRENT_CNO) {
929 dentry = d_find_alias(inode);
930 if (!dentry) {
931 dentry = d_make_root(inode);
932 if (!dentry) {
933 ret = -ENOMEM;
934 goto failed_dentry;
935 }
936 } else {
937 iput(inode);
938 }
939 } else {
940 dentry = d_obtain_root(inode);
941 if (IS_ERR(ptr: dentry)) {
942 ret = PTR_ERR(ptr: dentry);
943 goto failed_dentry;
944 }
945 }
946 *root_dentry = dentry;
947 out:
948 return ret;
949
950 failed_dentry:
951 nilfs_err(sb, "error %d getting root dentry", ret);
952 goto out;
953}
954
955static int nilfs_attach_snapshot(struct super_block *s, __u64 cno,
956 struct dentry **root_dentry)
957{
958 struct the_nilfs *nilfs = s->s_fs_info;
959 struct nilfs_root *root;
960 int ret;
961
962 mutex_lock(&nilfs->ns_snapshot_mount_mutex);
963
964 down_read(sem: &nilfs->ns_segctor_sem);
965 ret = nilfs_cpfile_is_snapshot(nilfs->ns_cpfile, cno);
966 up_read(sem: &nilfs->ns_segctor_sem);
967 if (ret < 0) {
968 ret = (ret == -ENOENT) ? -EINVAL : ret;
969 goto out;
970 } else if (!ret) {
971 nilfs_err(s,
972 "The specified checkpoint is not a snapshot (checkpoint number=%llu)",
973 (unsigned long long)cno);
974 ret = -EINVAL;
975 goto out;
976 }
977
978 ret = nilfs_attach_checkpoint(sb: s, cno, curr_mnt: false, rootp: &root);
979 if (ret) {
980 nilfs_err(s,
981 "error %d while loading snapshot (checkpoint number=%llu)",
982 ret, (unsigned long long)cno);
983 goto out;
984 }
985 ret = nilfs_get_root_dentry(sb: s, root, root_dentry);
986 nilfs_put_root(root);
987 out:
988 mutex_unlock(lock: &nilfs->ns_snapshot_mount_mutex);
989 return ret;
990}
991
992/**
993 * nilfs_tree_is_busy() - try to shrink dentries of a checkpoint
994 * @root_dentry: root dentry of the tree to be shrunk
995 *
996 * Return: true if the tree was in-use, false otherwise.
997 */
998static bool nilfs_tree_is_busy(struct dentry *root_dentry)
999{
1000 shrink_dcache_parent(root_dentry);
1001 return d_count(dentry: root_dentry) > 1;
1002}
1003
1004int nilfs_checkpoint_is_mounted(struct super_block *sb, __u64 cno)
1005{
1006 struct the_nilfs *nilfs = sb->s_fs_info;
1007 struct nilfs_root *root;
1008 struct inode *inode;
1009 struct dentry *dentry;
1010 int ret;
1011
1012 if (cno > nilfs->ns_cno)
1013 return false;
1014
1015 if (cno >= nilfs_last_cno(nilfs))
1016 return true; /* protect recent checkpoints */
1017
1018 ret = false;
1019 root = nilfs_lookup_root(nilfs, cno);
1020 if (root) {
1021 inode = nilfs_ilookup(sb, root, NILFS_ROOT_INO);
1022 if (inode) {
1023 dentry = d_find_alias(inode);
1024 if (dentry) {
1025 ret = nilfs_tree_is_busy(root_dentry: dentry);
1026 dput(dentry);
1027 }
1028 iput(inode);
1029 }
1030 nilfs_put_root(root);
1031 }
1032 return ret;
1033}
1034
1035/**
1036 * nilfs_fill_super() - initialize a super block instance
1037 * @sb: super_block
1038 * @fc: filesystem context
1039 *
1040 * This function is called exclusively by nilfs->ns_mount_mutex.
1041 * So, the recovery process is protected from other simultaneous mounts.
1042 *
1043 * Return: 0 on success, or a negative error code on failure.
1044 */
1045static int
1046nilfs_fill_super(struct super_block *sb, struct fs_context *fc)
1047{
1048 struct the_nilfs *nilfs;
1049 struct nilfs_root *fsroot;
1050 struct nilfs_fs_context *ctx = fc->fs_private;
1051 __u64 cno;
1052 int err;
1053
1054 nilfs = alloc_nilfs(sb);
1055 if (!nilfs)
1056 return -ENOMEM;
1057
1058 sb->s_fs_info = nilfs;
1059
1060 err = init_nilfs(nilfs, sb);
1061 if (err)
1062 goto failed_nilfs;
1063
1064 /* Copy in parsed mount options */
1065 nilfs->ns_mount_opt = ctx->ns_mount_opt;
1066
1067 sb->s_op = &nilfs_sops;
1068 sb->s_export_op = &nilfs_export_ops;
1069 sb->s_root = NULL;
1070 sb->s_time_gran = 1;
1071 sb->s_max_links = NILFS_LINK_MAX;
1072
1073 sb->s_bdi = bdi_get(bdi: sb->s_bdev->bd_disk->bdi);
1074
1075 err = load_nilfs(nilfs, sb);
1076 if (err)
1077 goto failed_nilfs;
1078
1079 super_set_uuid(sb, uuid: nilfs->ns_sbp[0]->s_uuid,
1080 len: sizeof(nilfs->ns_sbp[0]->s_uuid));
1081 super_set_sysfs_name_bdev(sb);
1082
1083 cno = nilfs_last_cno(nilfs);
1084 err = nilfs_attach_checkpoint(sb, cno, curr_mnt: true, rootp: &fsroot);
1085 if (err) {
1086 nilfs_err(sb,
1087 "error %d while loading last checkpoint (checkpoint number=%llu)",
1088 err, (unsigned long long)cno);
1089 goto failed_unload;
1090 }
1091
1092 if (!sb_rdonly(sb)) {
1093 err = nilfs_attach_log_writer(sb, root: fsroot);
1094 if (err)
1095 goto failed_checkpoint;
1096 }
1097
1098 err = nilfs_get_root_dentry(sb, root: fsroot, root_dentry: &sb->s_root);
1099 if (err)
1100 goto failed_segctor;
1101
1102 nilfs_put_root(root: fsroot);
1103
1104 if (!sb_rdonly(sb)) {
1105 down_write(sem: &nilfs->ns_sem);
1106 nilfs_setup_super(sb, is_mount: true);
1107 up_write(sem: &nilfs->ns_sem);
1108 }
1109
1110 return 0;
1111
1112 failed_segctor:
1113 nilfs_detach_log_writer(sb);
1114
1115 failed_checkpoint:
1116 nilfs_put_root(root: fsroot);
1117
1118 failed_unload:
1119 nilfs_sysfs_delete_device_group(nilfs);
1120 iput(nilfs->ns_sufile);
1121 iput(nilfs->ns_cpfile);
1122 iput(nilfs->ns_dat);
1123
1124 failed_nilfs:
1125 destroy_nilfs(nilfs);
1126 return err;
1127}
1128
1129static int nilfs_reconfigure(struct fs_context *fc)
1130{
1131 struct nilfs_fs_context *ctx = fc->fs_private;
1132 struct super_block *sb = fc->root->d_sb;
1133 struct the_nilfs *nilfs = sb->s_fs_info;
1134 int err;
1135
1136 sync_filesystem(sb);
1137
1138 err = -EINVAL;
1139
1140 if (!nilfs_valid_fs(nilfs)) {
1141 nilfs_warn(sb,
1142 "couldn't remount because the filesystem is in an incomplete recovery state");
1143 goto ignore_opts;
1144 }
1145 if ((bool)(fc->sb_flags & SB_RDONLY) == sb_rdonly(sb))
1146 goto out;
1147 if (fc->sb_flags & SB_RDONLY) {
1148 sb->s_flags |= SB_RDONLY;
1149
1150 /*
1151 * Remounting a valid RW partition RDONLY, so set
1152 * the RDONLY flag and then mark the partition as valid again.
1153 */
1154 down_write(sem: &nilfs->ns_sem);
1155 nilfs_cleanup_super(sb);
1156 up_write(sem: &nilfs->ns_sem);
1157 } else {
1158 __u64 features;
1159 struct nilfs_root *root;
1160
1161 /*
1162 * Mounting a RDONLY partition read-write, so reread and
1163 * store the current valid flag. (It may have been changed
1164 * by fsck since we originally mounted the partition.)
1165 */
1166 down_read(sem: &nilfs->ns_sem);
1167 features = le64_to_cpu(nilfs->ns_sbp[0]->s_feature_compat_ro) &
1168 ~NILFS_FEATURE_COMPAT_RO_SUPP;
1169 up_read(sem: &nilfs->ns_sem);
1170 if (features) {
1171 nilfs_warn(sb,
1172 "couldn't remount RDWR because of unsupported optional features (%llx)",
1173 (unsigned long long)features);
1174 err = -EROFS;
1175 goto ignore_opts;
1176 }
1177
1178 sb->s_flags &= ~SB_RDONLY;
1179
1180 root = NILFS_I(inode: d_inode(dentry: sb->s_root))->i_root;
1181 err = nilfs_attach_log_writer(sb, root);
1182 if (err) {
1183 sb->s_flags |= SB_RDONLY;
1184 goto ignore_opts;
1185 }
1186
1187 down_write(sem: &nilfs->ns_sem);
1188 nilfs_setup_super(sb, is_mount: true);
1189 up_write(sem: &nilfs->ns_sem);
1190 }
1191 out:
1192 sb->s_flags = (sb->s_flags & ~SB_POSIXACL);
1193 /* Copy over parsed remount options */
1194 nilfs->ns_mount_opt = ctx->ns_mount_opt;
1195
1196 return 0;
1197
1198 ignore_opts:
1199 return err;
1200}
1201
1202static int
1203nilfs_get_tree(struct fs_context *fc)
1204{
1205 struct nilfs_fs_context *ctx = fc->fs_private;
1206 struct super_block *s;
1207 dev_t dev;
1208 int err;
1209
1210 if (ctx->cno && !(fc->sb_flags & SB_RDONLY)) {
1211 nilfs_err(NULL,
1212 "invalid option \"cp=%llu\": read-only option is not specified",
1213 ctx->cno);
1214 return -EINVAL;
1215 }
1216
1217 err = lookup_bdev(pathname: fc->source, dev: &dev);
1218 if (err)
1219 return err;
1220
1221 s = sget_dev(fc, dev);
1222 if (IS_ERR(ptr: s))
1223 return PTR_ERR(ptr: s);
1224
1225 if (!s->s_root) {
1226 err = setup_bdev_super(sb: s, sb_flags: fc->sb_flags, fc);
1227 if (!err)
1228 err = nilfs_fill_super(sb: s, fc);
1229 if (err)
1230 goto failed_super;
1231
1232 s->s_flags |= SB_ACTIVE;
1233 } else if (!ctx->cno) {
1234 if (nilfs_tree_is_busy(root_dentry: s->s_root)) {
1235 if ((fc->sb_flags ^ s->s_flags) & SB_RDONLY) {
1236 nilfs_err(s,
1237 "the device already has a %s mount.",
1238 sb_rdonly(s) ? "read-only" : "read/write");
1239 err = -EBUSY;
1240 goto failed_super;
1241 }
1242 } else {
1243 /*
1244 * Try reconfigure to setup mount states if the current
1245 * tree is not mounted and only snapshots use this sb.
1246 *
1247 * Since nilfs_reconfigure() requires fc->root to be
1248 * set, set it first and release it on failure.
1249 */
1250 fc->root = dget(dentry: s->s_root);
1251 err = nilfs_reconfigure(fc);
1252 if (err) {
1253 dput(fc->root);
1254 fc->root = NULL; /* prevent double release */
1255 goto failed_super;
1256 }
1257 return 0;
1258 }
1259 }
1260
1261 if (ctx->cno) {
1262 struct dentry *root_dentry;
1263
1264 err = nilfs_attach_snapshot(s, cno: ctx->cno, root_dentry: &root_dentry);
1265 if (err)
1266 goto failed_super;
1267 fc->root = root_dentry;
1268 return 0;
1269 }
1270
1271 fc->root = dget(dentry: s->s_root);
1272 return 0;
1273
1274 failed_super:
1275 deactivate_locked_super(sb: s);
1276 return err;
1277}
1278
1279static void nilfs_free_fc(struct fs_context *fc)
1280{
1281 kfree(objp: fc->fs_private);
1282}
1283
1284static const struct fs_context_operations nilfs_context_ops = {
1285 .parse_param = nilfs_parse_param,
1286 .get_tree = nilfs_get_tree,
1287 .reconfigure = nilfs_reconfigure,
1288 .free = nilfs_free_fc,
1289};
1290
1291static int nilfs_init_fs_context(struct fs_context *fc)
1292{
1293 struct nilfs_fs_context *ctx;
1294
1295 ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
1296 if (!ctx)
1297 return -ENOMEM;
1298
1299 ctx->ns_mount_opt = NILFS_MOUNT_ERRORS_RO | NILFS_MOUNT_BARRIER;
1300 fc->fs_private = ctx;
1301 fc->ops = &nilfs_context_ops;
1302
1303 return 0;
1304}
1305
1306struct file_system_type nilfs_fs_type = {
1307 .owner = THIS_MODULE,
1308 .name = "nilfs2",
1309 .kill_sb = kill_block_super,
1310 .fs_flags = FS_REQUIRES_DEV,
1311 .init_fs_context = nilfs_init_fs_context,
1312 .parameters = nilfs_param_spec,
1313};
1314MODULE_ALIAS_FS("nilfs2");
1315
1316static void nilfs_inode_init_once(void *obj)
1317{
1318 struct nilfs_inode_info *ii = obj;
1319
1320 INIT_LIST_HEAD(list: &ii->i_dirty);
1321#ifdef CONFIG_NILFS_XATTR
1322 init_rwsem(&ii->xattr_sem);
1323#endif
1324 inode_init_once(&ii->vfs_inode);
1325}
1326
1327static void nilfs_segbuf_init_once(void *obj)
1328{
1329 memset(obj, 0, sizeof(struct nilfs_segment_buffer));
1330}
1331
1332static void nilfs_destroy_cachep(void)
1333{
1334 /*
1335 * Make sure all delayed rcu free inodes are flushed before we
1336 * destroy cache.
1337 */
1338 rcu_barrier();
1339
1340 kmem_cache_destroy(s: nilfs_inode_cachep);
1341 kmem_cache_destroy(s: nilfs_transaction_cachep);
1342 kmem_cache_destroy(s: nilfs_segbuf_cachep);
1343 kmem_cache_destroy(s: nilfs_btree_path_cache);
1344}
1345
1346static int __init nilfs_init_cachep(void)
1347{
1348 nilfs_inode_cachep = kmem_cache_create("nilfs2_inode_cache",
1349 sizeof(struct nilfs_inode_info), 0,
1350 SLAB_RECLAIM_ACCOUNT|SLAB_ACCOUNT,
1351 nilfs_inode_init_once);
1352 if (!nilfs_inode_cachep)
1353 goto fail;
1354
1355 nilfs_transaction_cachep = kmem_cache_create("nilfs2_transaction_cache",
1356 sizeof(struct nilfs_transaction_info), 0,
1357 SLAB_RECLAIM_ACCOUNT, NULL);
1358 if (!nilfs_transaction_cachep)
1359 goto fail;
1360
1361 nilfs_segbuf_cachep = kmem_cache_create("nilfs2_segbuf_cache",
1362 sizeof(struct nilfs_segment_buffer), 0,
1363 SLAB_RECLAIM_ACCOUNT, nilfs_segbuf_init_once);
1364 if (!nilfs_segbuf_cachep)
1365 goto fail;
1366
1367 nilfs_btree_path_cache = kmem_cache_create("nilfs2_btree_path_cache",
1368 sizeof(struct nilfs_btree_path) * NILFS_BTREE_LEVEL_MAX,
1369 0, 0, NULL);
1370 if (!nilfs_btree_path_cache)
1371 goto fail;
1372
1373 return 0;
1374
1375fail:
1376 nilfs_destroy_cachep();
1377 return -ENOMEM;
1378}
1379
1380static int __init init_nilfs_fs(void)
1381{
1382 int err;
1383
1384 err = nilfs_init_cachep();
1385 if (err)
1386 goto fail;
1387
1388 err = nilfs_sysfs_init();
1389 if (err)
1390 goto free_cachep;
1391
1392 err = register_filesystem(&nilfs_fs_type);
1393 if (err)
1394 goto deinit_sysfs_entry;
1395
1396 printk(KERN_INFO "NILFS version 2 loaded\n");
1397 return 0;
1398
1399deinit_sysfs_entry:
1400 nilfs_sysfs_exit();
1401free_cachep:
1402 nilfs_destroy_cachep();
1403fail:
1404 return err;
1405}
1406
1407static void __exit exit_nilfs_fs(void)
1408{
1409 nilfs_destroy_cachep();
1410 nilfs_sysfs_exit();
1411 unregister_filesystem(&nilfs_fs_type);
1412}
1413
1414module_init(init_nilfs_fs)
1415module_exit(exit_nilfs_fs)
1416

source code of linux/fs/nilfs2/super.c