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