xref: /linux/fs/nilfs2/super.c (revision c159dfbdd4fc62fa08f6715d9d6c34d39cf40446)
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 
53 MODULE_AUTHOR("NTT Corp.");
54 MODULE_DESCRIPTION("A New Implementation of the Log-structured Filesystem "
55 		   "(NILFS)");
56 MODULE_LICENSE("GPL");
57 
58 static struct kmem_cache *nilfs_inode_cachep;
59 struct kmem_cache *nilfs_transaction_cachep;
60 struct kmem_cache *nilfs_segbuf_cachep;
61 struct kmem_cache *nilfs_btree_path_cache;
62 
63 static int nilfs_setup_super(struct super_block *sb, int is_mount);
64 
65 void __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(fmt);
74 	vaf.fmt = printk_skip_level(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 
87 static 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(&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, 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, NILFS_SB_COMMIT_ALL);
101 		}
102 	}
103 	up_write(&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  */
123 void __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("NILFS (device %s): panic forced after error\n",
151 		      sb->s_id);
152 }
153 
154 struct 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 
170 static 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(nilfs_inode_cachep, NILFS_I(inode));
176 }
177 
178 static 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(nilfs->ns_sbh[0],
187 					  REQ_SYNC | REQ_PREFLUSH | REQ_FUA);
188 	} else {
189 		err = sync_dirty_buffer(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(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(&nilfs->ns_last_segment_lock);
228 		nilfs->ns_prot_seq = le64_to_cpu(sbp->s_last_seq);
229 		spin_unlock(&nilfs->ns_last_segment_lock);
230 	}
231  out:
232 	return err;
233 }
234 
235 void 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(&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(&nilfs->ns_last_segment_lock);
249 }
250 
251 struct 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 
277 int 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  */
315 int 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, 0);
323 	if (sbp) {
324 		sbp[0]->s_state = cpu_to_le16(nilfs->ns_mount_state);
325 		nilfs_set_log_cursor(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  */
347 static 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, 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(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(nsbh);
407 
408 	if (sb2i >= 0) {
409 		brelse(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(nsbh);
418 	}
419 out:
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  */
430 int 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(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(&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(nilfs->ns_sufile, newnsegs);
464 	up_write(&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(&nilfs->ns_sem);
473 	nilfs_move_2nd_super(sb, sb2off);
474 	ret = -EIO;
475 	sbp = nilfs_prepare_super(sb, 0);
476 	if (likely(sbp)) {
477 		nilfs_set_log_cursor(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, NILFS_SB_COMMIT_ALL);
490 	}
491 	up_write(&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(nilfs->ns_sufile, 0, newnsegs - 1);
501 out:
502 	return ret;
503 }
504 
505 static 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(&nilfs->ns_sem);
513 		nilfs_cleanup_super(sb);
514 		up_write(&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 
526 static 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(&nilfs->ns_sem);
537 	if (nilfs_sb_dirty(nilfs)) {
538 		sbp = nilfs_prepare_super(sb, nilfs_sb_will_flip(nilfs));
539 		if (likely(sbp)) {
540 			nilfs_set_log_cursor(sbp[0], nilfs);
541 			nilfs_commit_super(sb, NILFS_SB_COMMIT);
542 		}
543 	}
544 	up_write(&nilfs->ns_sem);
545 
546 	if (!err)
547 		err = nilfs_flush_device(nilfs);
548 
549 	return err;
550 }
551 
552 int 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, 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(&nilfs->ns_segctor_sem);
568 	err = nilfs_ifile_read(sb, root, cno, nilfs->ns_inode_size);
569 	up_read(&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 
586 static 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(&nilfs->ns_sem);
596 	err = nilfs_cleanup_super(sb);
597 	up_write(&nilfs->ns_sem);
598 	return err;
599 }
600 
601 static 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(&nilfs->ns_sem);
609 	nilfs_setup_super(sb, false);
610 	up_write(&nilfs->ns_sem);
611 	return 0;
612 }
613 
614 static 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(d_inode(dentry))->i_root;
618 	struct the_nilfs *nilfs = root->nilfs;
619 	u64 id = huge_encode_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(&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(id);
677 
678 	return 0;
679 }
680 
681 static 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(d_inode(dentry))->i_root;
686 
687 	if (!nilfs_test_opt(nilfs, BARRIER))
688 		seq_puts(seq, ",nobarrier");
689 	if (root->cno != NILFS_CPTREE_CURRENT_CNO)
690 		seq_printf(seq, ",cp=%llu", (unsigned long long)root->cno);
691 	if (nilfs_test_opt(nilfs, ERRORS_PANIC))
692 		seq_puts(seq, ",errors=panic");
693 	if (nilfs_test_opt(nilfs, ERRORS_CONT))
694 		seq_puts(seq, ",errors=continue");
695 	if (nilfs_test_opt(nilfs, STRICT_ORDER))
696 		seq_puts(seq, ",order=strict");
697 	if (nilfs_test_opt(nilfs, NORECOVERY))
698 		seq_puts(seq, ",norecovery");
699 	if (nilfs_test_opt(nilfs, DISCARD))
700 		seq_puts(seq, ",discard");
701 
702 	return 0;
703 }
704 
705 static 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 
718 enum {
719 	Opt_err, Opt_barrier, Opt_snapshot, Opt_order, Opt_norecovery,
720 	Opt_discard,
721 };
722 
723 static 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 
730 static 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 
740 struct nilfs_fs_context {
741 	unsigned long ns_mount_opt;
742 	__u64 cno;
743 };
744 
745 static 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, nilfs_param_spec, param, &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 
809 static 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, 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 
840 skip_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, NILFS_SB_COMMIT_ALL);
847 }
848 
849 struct 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, sb_index);
858 	if (!*pbh)
859 		return NULL;
860 	return (struct nilfs_super_block *)((char *)(*pbh)->b_data + offset);
861 }
862 
863 int 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 
883 int 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 
907 static 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(inode)) {
917 		ret = PTR_ERR(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(dentry)) {
942 			ret = PTR_ERR(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 
955 static 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(&nilfs->ns_segctor_sem);
965 	ret = nilfs_cpfile_is_snapshot(nilfs->ns_cpfile, cno);
966 	up_read(&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(s, cno, false, &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(s, root, root_dentry);
986 	nilfs_put_root(root);
987  out:
988 	mutex_unlock(&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  */
998 static bool nilfs_tree_is_busy(struct dentry *root_dentry)
999 {
1000 	shrink_dcache_parent(root_dentry);
1001 	return d_count(root_dentry) > 1;
1002 }
1003 
1004 int 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(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  */
1045 static int
1046 nilfs_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(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, nilfs->ns_sbp[0]->s_uuid,
1080 		       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, true, &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, fsroot);
1094 		if (err)
1095 			goto failed_checkpoint;
1096 	}
1097 
1098 	err = nilfs_get_root_dentry(sb, fsroot, &sb->s_root);
1099 	if (err)
1100 		goto failed_segctor;
1101 
1102 	nilfs_put_root(fsroot);
1103 
1104 	if (!sb_rdonly(sb)) {
1105 		down_write(&nilfs->ns_sem);
1106 		nilfs_setup_super(sb, true);
1107 		up_write(&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(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 
1129 static 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(&nilfs->ns_sem);
1155 		nilfs_cleanup_super(sb);
1156 		up_write(&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(&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(&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(d_inode(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(&nilfs->ns_sem);
1188 		nilfs_setup_super(sb, true);
1189 		up_write(&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 
1202 static int
1203 nilfs_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(fc->source, &dev);
1218 	if (err)
1219 		return err;
1220 
1221 	s = sget_dev(fc, dev);
1222 	if (IS_ERR(s))
1223 		return PTR_ERR(s);
1224 
1225 	if (!s->s_root) {
1226 		err = setup_bdev_super(s, fc->sb_flags, fc);
1227 		if (!err)
1228 			err = nilfs_fill_super(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(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(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, ctx->cno, &root_dentry);
1265 		if (err)
1266 			goto failed_super;
1267 		fc->root = root_dentry;
1268 		return 0;
1269 	}
1270 
1271 	fc->root = dget(s->s_root);
1272 	return 0;
1273 
1274  failed_super:
1275 	deactivate_locked_super(s);
1276 	return err;
1277 }
1278 
1279 static void nilfs_free_fc(struct fs_context *fc)
1280 {
1281 	kfree(fc->fs_private);
1282 }
1283 
1284 static 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 
1291 static 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 
1306 struct 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 };
1314 MODULE_ALIAS_FS("nilfs2");
1315 
1316 static void nilfs_inode_init_once(void *obj)
1317 {
1318 	struct nilfs_inode_info *ii = obj;
1319 
1320 	INIT_LIST_HEAD(&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 
1327 static void nilfs_segbuf_init_once(void *obj)
1328 {
1329 	memset(obj, 0, sizeof(struct nilfs_segment_buffer));
1330 }
1331 
1332 static 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(nilfs_inode_cachep);
1341 	kmem_cache_destroy(nilfs_transaction_cachep);
1342 	kmem_cache_destroy(nilfs_segbuf_cachep);
1343 	kmem_cache_destroy(nilfs_btree_path_cache);
1344 }
1345 
1346 static 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 
1375 fail:
1376 	nilfs_destroy_cachep();
1377 	return -ENOMEM;
1378 }
1379 
1380 static 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 
1399 deinit_sysfs_entry:
1400 	nilfs_sysfs_exit();
1401 free_cachep:
1402 	nilfs_destroy_cachep();
1403 fail:
1404 	return err;
1405 }
1406 
1407 static void __exit exit_nilfs_fs(void)
1408 {
1409 	nilfs_destroy_cachep();
1410 	nilfs_sysfs_exit();
1411 	unregister_filesystem(&nilfs_fs_type);
1412 }
1413 
1414 module_init(init_nilfs_fs)
1415 module_exit(exit_nilfs_fs)
1416