1 // SPDX-License-Identifier: GPL-2.0+
3 * the_nilfs.c - the_nilfs shared structure.
5 * Copyright (C) 2005-2008 Nippon Telegraph and Telephone Corporation.
7 * Written by Ryusuke Konishi.
11 #include <linux/buffer_head.h>
12 #include <linux/slab.h>
13 #include <linux/blkdev.h>
14 #include <linux/backing-dev.h>
15 #include <linux/random.h>
16 #include <linux/crc32.h>
26 static int nilfs_valid_sb(struct nilfs_super_block
*sbp
);
28 void nilfs_set_last_segment(struct the_nilfs
*nilfs
,
29 sector_t start_blocknr
, u64 seq
, __u64 cno
)
31 spin_lock(&nilfs
->ns_last_segment_lock
);
32 nilfs
->ns_last_pseg
= start_blocknr
;
33 nilfs
->ns_last_seq
= seq
;
34 nilfs
->ns_last_cno
= cno
;
36 if (!nilfs_sb_dirty(nilfs
)) {
37 if (nilfs
->ns_prev_seq
== nilfs
->ns_last_seq
)
40 set_nilfs_sb_dirty(nilfs
);
42 nilfs
->ns_prev_seq
= nilfs
->ns_last_seq
;
45 spin_unlock(&nilfs
->ns_last_segment_lock
);
49 * alloc_nilfs - allocate a nilfs object
50 * @sb: super block instance
52 * Return Value: On success, pointer to the_nilfs is returned.
53 * On error, NULL is returned.
55 struct the_nilfs
*alloc_nilfs(struct super_block
*sb
)
57 struct the_nilfs
*nilfs
;
59 nilfs
= kzalloc(sizeof(*nilfs
), GFP_KERNEL
);
64 nilfs
->ns_bdev
= sb
->s_bdev
;
65 atomic_set(&nilfs
->ns_ndirtyblks
, 0);
66 init_rwsem(&nilfs
->ns_sem
);
67 mutex_init(&nilfs
->ns_snapshot_mount_mutex
);
68 INIT_LIST_HEAD(&nilfs
->ns_dirty_files
);
69 INIT_LIST_HEAD(&nilfs
->ns_gc_inodes
);
70 spin_lock_init(&nilfs
->ns_inode_lock
);
71 spin_lock_init(&nilfs
->ns_next_gen_lock
);
72 spin_lock_init(&nilfs
->ns_last_segment_lock
);
73 nilfs
->ns_cptree
= RB_ROOT
;
74 spin_lock_init(&nilfs
->ns_cptree_lock
);
75 init_rwsem(&nilfs
->ns_segctor_sem
);
76 nilfs
->ns_sb_update_freq
= NILFS_SB_FREQ
;
82 * destroy_nilfs - destroy nilfs object
83 * @nilfs: nilfs object to be released
85 void destroy_nilfs(struct the_nilfs
*nilfs
)
88 if (nilfs_init(nilfs
)) {
89 nilfs_sysfs_delete_device_group(nilfs
);
90 brelse(nilfs
->ns_sbh
[0]);
91 brelse(nilfs
->ns_sbh
[1]);
96 static int nilfs_load_super_root(struct the_nilfs
*nilfs
,
97 struct super_block
*sb
, sector_t sr_block
)
99 struct buffer_head
*bh_sr
;
100 struct nilfs_super_root
*raw_sr
;
101 struct nilfs_super_block
**sbp
= nilfs
->ns_sbp
;
102 struct nilfs_inode
*rawi
;
103 unsigned int dat_entry_size
, segment_usage_size
, checkpoint_size
;
104 unsigned int inode_size
;
107 err
= nilfs_read_super_root_block(nilfs
, sr_block
, &bh_sr
, 1);
111 down_read(&nilfs
->ns_sem
);
112 dat_entry_size
= le16_to_cpu(sbp
[0]->s_dat_entry_size
);
113 checkpoint_size
= le16_to_cpu(sbp
[0]->s_checkpoint_size
);
114 segment_usage_size
= le16_to_cpu(sbp
[0]->s_segment_usage_size
);
115 up_read(&nilfs
->ns_sem
);
117 inode_size
= nilfs
->ns_inode_size
;
119 rawi
= (void *)bh_sr
->b_data
+ NILFS_SR_DAT_OFFSET(inode_size
);
120 err
= nilfs_dat_read(sb
, dat_entry_size
, rawi
, &nilfs
->ns_dat
);
124 rawi
= (void *)bh_sr
->b_data
+ NILFS_SR_CPFILE_OFFSET(inode_size
);
125 err
= nilfs_cpfile_read(sb
, checkpoint_size
, rawi
, &nilfs
->ns_cpfile
);
129 rawi
= (void *)bh_sr
->b_data
+ NILFS_SR_SUFILE_OFFSET(inode_size
);
130 err
= nilfs_sufile_read(sb
, segment_usage_size
, rawi
,
135 raw_sr
= (struct nilfs_super_root
*)bh_sr
->b_data
;
136 nilfs
->ns_nongc_ctime
= le64_to_cpu(raw_sr
->sr_nongc_ctime
);
143 iput(nilfs
->ns_cpfile
);
150 static void nilfs_init_recovery_info(struct nilfs_recovery_info
*ri
)
152 memset(ri
, 0, sizeof(*ri
));
153 INIT_LIST_HEAD(&ri
->ri_used_segments
);
156 static void nilfs_clear_recovery_info(struct nilfs_recovery_info
*ri
)
158 nilfs_dispose_segment_list(&ri
->ri_used_segments
);
162 * nilfs_store_log_cursor - load log cursor from a super block
163 * @nilfs: nilfs object
164 * @sbp: buffer storing super block to be read
166 * nilfs_store_log_cursor() reads the last position of the log
167 * containing a super root from a given super block, and initializes
168 * relevant information on the nilfs object preparatory for log
169 * scanning and recovery.
171 static int nilfs_store_log_cursor(struct the_nilfs
*nilfs
,
172 struct nilfs_super_block
*sbp
)
176 nilfs
->ns_last_pseg
= le64_to_cpu(sbp
->s_last_pseg
);
177 nilfs
->ns_last_cno
= le64_to_cpu(sbp
->s_last_cno
);
178 nilfs
->ns_last_seq
= le64_to_cpu(sbp
->s_last_seq
);
180 nilfs
->ns_prev_seq
= nilfs
->ns_last_seq
;
181 nilfs
->ns_seg_seq
= nilfs
->ns_last_seq
;
183 nilfs_get_segnum_of_block(nilfs
, nilfs
->ns_last_pseg
);
184 nilfs
->ns_cno
= nilfs
->ns_last_cno
+ 1;
185 if (nilfs
->ns_segnum
>= nilfs
->ns_nsegments
) {
186 nilfs_err(nilfs
->ns_sb
,
187 "pointed segment number is out of range: segnum=%llu, nsegments=%lu",
188 (unsigned long long)nilfs
->ns_segnum
,
189 nilfs
->ns_nsegments
);
196 * load_nilfs - load and recover the nilfs
197 * @nilfs: the_nilfs structure to be released
198 * @sb: super block instance used to recover past segment
200 * load_nilfs() searches and load the latest super root,
201 * attaches the last segment, and does recovery if needed.
202 * The caller must call this exclusively for simultaneous mounts.
204 int load_nilfs(struct the_nilfs
*nilfs
, struct super_block
*sb
)
206 struct nilfs_recovery_info ri
;
207 unsigned int s_flags
= sb
->s_flags
;
208 int really_read_only
= bdev_read_only(nilfs
->ns_bdev
);
209 int valid_fs
= nilfs_valid_fs(nilfs
);
213 nilfs_warn(sb
, "mounting unchecked fs");
214 if (s_flags
& SB_RDONLY
) {
216 "recovery required for readonly filesystem");
218 "write access will be enabled during recovery");
222 nilfs_init_recovery_info(&ri
);
224 err
= nilfs_search_super_root(nilfs
, &ri
);
226 struct nilfs_super_block
**sbp
= nilfs
->ns_sbp
;
232 if (!nilfs_valid_sb(sbp
[1])) {
234 "unable to fall back to spare super block");
237 nilfs_info(sb
, "trying rollback from an earlier position");
240 * restore super block with its spare and reconfigure
241 * relevant states of the nilfs object.
243 memcpy(sbp
[0], sbp
[1], nilfs
->ns_sbsize
);
244 nilfs
->ns_crc_seed
= le32_to_cpu(sbp
[0]->s_crc_seed
);
245 nilfs
->ns_sbwtime
= le64_to_cpu(sbp
[0]->s_wtime
);
247 /* verify consistency between two super blocks */
248 blocksize
= BLOCK_SIZE
<< le32_to_cpu(sbp
[0]->s_log_block_size
);
249 if (blocksize
!= nilfs
->ns_blocksize
) {
251 "blocksize differs between two super blocks (%d != %d)",
252 blocksize
, nilfs
->ns_blocksize
);
256 err
= nilfs_store_log_cursor(nilfs
, sbp
[0]);
260 /* drop clean flag to allow roll-forward and recovery */
261 nilfs
->ns_mount_state
&= ~NILFS_VALID_FS
;
264 err
= nilfs_search_super_root(nilfs
, &ri
);
269 err
= nilfs_load_super_root(nilfs
, sb
, ri
.ri_super_root
);
271 nilfs_err(sb
, "error %d while loading super root", err
);
278 if (s_flags
& SB_RDONLY
) {
281 if (nilfs_test_opt(nilfs
, NORECOVERY
)) {
283 "norecovery option specified, skipping roll-forward recovery");
286 features
= le64_to_cpu(nilfs
->ns_sbp
[0]->s_feature_compat_ro
) &
287 ~NILFS_FEATURE_COMPAT_RO_SUPP
;
290 "couldn't proceed with recovery because of unsupported optional features (%llx)",
291 (unsigned long long)features
);
295 if (really_read_only
) {
297 "write access unavailable, cannot proceed");
301 sb
->s_flags
&= ~SB_RDONLY
;
302 } else if (nilfs_test_opt(nilfs
, NORECOVERY
)) {
304 "recovery cancelled because norecovery option was specified for a read/write mount");
309 err
= nilfs_salvage_orphan_logs(nilfs
, sb
, &ri
);
313 down_write(&nilfs
->ns_sem
);
314 nilfs
->ns_mount_state
|= NILFS_VALID_FS
; /* set "clean" flag */
315 err
= nilfs_cleanup_super(sb
);
316 up_write(&nilfs
->ns_sem
);
320 "error %d updating super block. recovery unfinished.",
324 nilfs_info(sb
, "recovery complete");
327 nilfs_clear_recovery_info(&ri
);
328 sb
->s_flags
= s_flags
;
332 nilfs_err(sb
, "error %d while searching super root", err
);
336 iput(nilfs
->ns_cpfile
);
337 iput(nilfs
->ns_sufile
);
341 nilfs_clear_recovery_info(&ri
);
342 sb
->s_flags
= s_flags
;
346 static unsigned long long nilfs_max_size(unsigned int blkbits
)
348 unsigned int max_bits
;
349 unsigned long long res
= MAX_LFS_FILESIZE
; /* page cache limit */
351 max_bits
= blkbits
+ NILFS_BMAP_KEY_BIT
; /* bmap size limit */
353 res
= min_t(unsigned long long, res
, (1ULL << max_bits
) - 1);
358 * nilfs_nrsvsegs - calculate the number of reserved segments
359 * @nilfs: nilfs object
360 * @nsegs: total number of segments
362 unsigned long nilfs_nrsvsegs(struct the_nilfs
*nilfs
, unsigned long nsegs
)
364 return max_t(unsigned long, NILFS_MIN_NRSVSEGS
,
365 DIV_ROUND_UP(nsegs
* nilfs
->ns_r_segments_percentage
,
369 void nilfs_set_nsegments(struct the_nilfs
*nilfs
, unsigned long nsegs
)
371 nilfs
->ns_nsegments
= nsegs
;
372 nilfs
->ns_nrsvsegs
= nilfs_nrsvsegs(nilfs
, nsegs
);
375 static int nilfs_store_disk_layout(struct the_nilfs
*nilfs
,
376 struct nilfs_super_block
*sbp
)
378 if (le32_to_cpu(sbp
->s_rev_level
) < NILFS_MIN_SUPP_REV
) {
379 nilfs_err(nilfs
->ns_sb
,
380 "unsupported revision (superblock rev.=%d.%d, current rev.=%d.%d). Please check the version of mkfs.nilfs(2).",
381 le32_to_cpu(sbp
->s_rev_level
),
382 le16_to_cpu(sbp
->s_minor_rev_level
),
383 NILFS_CURRENT_REV
, NILFS_MINOR_REV
);
386 nilfs
->ns_sbsize
= le16_to_cpu(sbp
->s_bytes
);
387 if (nilfs
->ns_sbsize
> BLOCK_SIZE
)
390 nilfs
->ns_inode_size
= le16_to_cpu(sbp
->s_inode_size
);
391 if (nilfs
->ns_inode_size
> nilfs
->ns_blocksize
) {
392 nilfs_err(nilfs
->ns_sb
, "too large inode size: %d bytes",
393 nilfs
->ns_inode_size
);
395 } else if (nilfs
->ns_inode_size
< NILFS_MIN_INODE_SIZE
) {
396 nilfs_err(nilfs
->ns_sb
, "too small inode size: %d bytes",
397 nilfs
->ns_inode_size
);
401 nilfs
->ns_first_ino
= le32_to_cpu(sbp
->s_first_ino
);
403 nilfs
->ns_blocks_per_segment
= le32_to_cpu(sbp
->s_blocks_per_segment
);
404 if (nilfs
->ns_blocks_per_segment
< NILFS_SEG_MIN_BLOCKS
) {
405 nilfs_err(nilfs
->ns_sb
, "too short segment: %lu blocks",
406 nilfs
->ns_blocks_per_segment
);
410 nilfs
->ns_first_data_block
= le64_to_cpu(sbp
->s_first_data_block
);
411 nilfs
->ns_r_segments_percentage
=
412 le32_to_cpu(sbp
->s_r_segments_percentage
);
413 if (nilfs
->ns_r_segments_percentage
< 1 ||
414 nilfs
->ns_r_segments_percentage
> 99) {
415 nilfs_err(nilfs
->ns_sb
,
416 "invalid reserved segments percentage: %lu",
417 nilfs
->ns_r_segments_percentage
);
421 nilfs_set_nsegments(nilfs
, le64_to_cpu(sbp
->s_nsegments
));
422 nilfs
->ns_crc_seed
= le32_to_cpu(sbp
->s_crc_seed
);
426 static int nilfs_valid_sb(struct nilfs_super_block
*sbp
)
428 static unsigned char sum
[4];
429 const int sumoff
= offsetof(struct nilfs_super_block
, s_sum
);
433 if (!sbp
|| le16_to_cpu(sbp
->s_magic
) != NILFS_SUPER_MAGIC
)
435 bytes
= le16_to_cpu(sbp
->s_bytes
);
436 if (bytes
< sumoff
+ 4 || bytes
> BLOCK_SIZE
)
438 crc
= crc32_le(le32_to_cpu(sbp
->s_crc_seed
), (unsigned char *)sbp
,
440 crc
= crc32_le(crc
, sum
, 4);
441 crc
= crc32_le(crc
, (unsigned char *)sbp
+ sumoff
+ 4,
443 return crc
== le32_to_cpu(sbp
->s_sum
);
446 static int nilfs_sb2_bad_offset(struct nilfs_super_block
*sbp
, u64 offset
)
448 return offset
< ((le64_to_cpu(sbp
->s_nsegments
) *
449 le32_to_cpu(sbp
->s_blocks_per_segment
)) <<
450 (le32_to_cpu(sbp
->s_log_block_size
) + 10));
453 static void nilfs_release_super_block(struct the_nilfs
*nilfs
)
457 for (i
= 0; i
< 2; i
++) {
458 if (nilfs
->ns_sbp
[i
]) {
459 brelse(nilfs
->ns_sbh
[i
]);
460 nilfs
->ns_sbh
[i
] = NULL
;
461 nilfs
->ns_sbp
[i
] = NULL
;
466 void nilfs_fall_back_super_block(struct the_nilfs
*nilfs
)
468 brelse(nilfs
->ns_sbh
[0]);
469 nilfs
->ns_sbh
[0] = nilfs
->ns_sbh
[1];
470 nilfs
->ns_sbp
[0] = nilfs
->ns_sbp
[1];
471 nilfs
->ns_sbh
[1] = NULL
;
472 nilfs
->ns_sbp
[1] = NULL
;
475 void nilfs_swap_super_block(struct the_nilfs
*nilfs
)
477 struct buffer_head
*tsbh
= nilfs
->ns_sbh
[0];
478 struct nilfs_super_block
*tsbp
= nilfs
->ns_sbp
[0];
480 nilfs
->ns_sbh
[0] = nilfs
->ns_sbh
[1];
481 nilfs
->ns_sbp
[0] = nilfs
->ns_sbp
[1];
482 nilfs
->ns_sbh
[1] = tsbh
;
483 nilfs
->ns_sbp
[1] = tsbp
;
486 static int nilfs_load_super_block(struct the_nilfs
*nilfs
,
487 struct super_block
*sb
, int blocksize
,
488 struct nilfs_super_block
**sbpp
)
490 struct nilfs_super_block
**sbp
= nilfs
->ns_sbp
;
491 struct buffer_head
**sbh
= nilfs
->ns_sbh
;
492 u64 sb2off
= NILFS_SB2_OFFSET_BYTES(nilfs
->ns_bdev
->bd_inode
->i_size
);
493 int valid
[2], swp
= 0;
495 sbp
[0] = nilfs_read_super_block(sb
, NILFS_SB_OFFSET_BYTES
, blocksize
,
497 sbp
[1] = nilfs_read_super_block(sb
, sb2off
, blocksize
, &sbh
[1]);
501 nilfs_err(sb
, "unable to read superblock");
505 "unable to read primary superblock (blocksize = %d)",
507 } else if (!sbp
[1]) {
509 "unable to read secondary superblock (blocksize = %d)",
514 * Compare two super blocks and set 1 in swp if the secondary
515 * super block is valid and newer. Otherwise, set 0 in swp.
517 valid
[0] = nilfs_valid_sb(sbp
[0]);
518 valid
[1] = nilfs_valid_sb(sbp
[1]);
519 swp
= valid
[1] && (!valid
[0] ||
520 le64_to_cpu(sbp
[1]->s_last_cno
) >
521 le64_to_cpu(sbp
[0]->s_last_cno
));
523 if (valid
[swp
] && nilfs_sb2_bad_offset(sbp
[swp
], sb2off
)) {
531 nilfs_release_super_block(nilfs
);
532 nilfs_err(sb
, "couldn't find nilfs on the device");
538 "broken superblock, retrying with spare superblock (blocksize = %d)",
541 nilfs_swap_super_block(nilfs
);
543 nilfs
->ns_sbwcount
= 0;
544 nilfs
->ns_sbwtime
= le64_to_cpu(sbp
[0]->s_wtime
);
545 nilfs
->ns_prot_seq
= le64_to_cpu(sbp
[valid
[1] & !swp
]->s_last_seq
);
551 * init_nilfs - initialize a NILFS instance.
552 * @nilfs: the_nilfs structure
554 * @data: mount options
556 * init_nilfs() performs common initialization per block device (e.g.
557 * reading the super block, getting disk layout information, initializing
558 * shared fields in the_nilfs).
560 * Return Value: On success, 0 is returned. On error, a negative error
563 int init_nilfs(struct the_nilfs
*nilfs
, struct super_block
*sb
, char *data
)
565 struct nilfs_super_block
*sbp
;
569 down_write(&nilfs
->ns_sem
);
571 blocksize
= sb_min_blocksize(sb
, NILFS_MIN_BLOCK_SIZE
);
573 nilfs_err(sb
, "unable to set blocksize");
577 err
= nilfs_load_super_block(nilfs
, sb
, blocksize
, &sbp
);
581 err
= nilfs_store_magic_and_option(sb
, sbp
, data
);
585 err
= nilfs_check_feature_compatibility(sb
, sbp
);
589 blocksize
= BLOCK_SIZE
<< le32_to_cpu(sbp
->s_log_block_size
);
590 if (blocksize
< NILFS_MIN_BLOCK_SIZE
||
591 blocksize
> NILFS_MAX_BLOCK_SIZE
) {
593 "couldn't mount because of unsupported filesystem blocksize %d",
598 if (sb
->s_blocksize
!= blocksize
) {
599 int hw_blocksize
= bdev_logical_block_size(sb
->s_bdev
);
601 if (blocksize
< hw_blocksize
) {
603 "blocksize %d too small for device (sector-size = %d)",
604 blocksize
, hw_blocksize
);
608 nilfs_release_super_block(nilfs
);
609 sb_set_blocksize(sb
, blocksize
);
611 err
= nilfs_load_super_block(nilfs
, sb
, blocksize
, &sbp
);
615 * Not to failed_sbh; sbh is released automatically
616 * when reloading fails.
619 nilfs
->ns_blocksize_bits
= sb
->s_blocksize_bits
;
620 nilfs
->ns_blocksize
= blocksize
;
622 get_random_bytes(&nilfs
->ns_next_generation
,
623 sizeof(nilfs
->ns_next_generation
));
625 err
= nilfs_store_disk_layout(nilfs
, sbp
);
629 sb
->s_maxbytes
= nilfs_max_size(sb
->s_blocksize_bits
);
631 nilfs
->ns_mount_state
= le16_to_cpu(sbp
->s_state
);
633 err
= nilfs_store_log_cursor(nilfs
, sbp
);
637 err
= nilfs_sysfs_create_device_group(sb
);
641 set_nilfs_init(nilfs
);
644 up_write(&nilfs
->ns_sem
);
648 nilfs_release_super_block(nilfs
);
652 int nilfs_discard_segments(struct the_nilfs
*nilfs
, __u64
*segnump
,
655 sector_t seg_start
, seg_end
;
656 sector_t start
= 0, nblocks
= 0;
657 unsigned int sects_per_block
;
661 sects_per_block
= (1 << nilfs
->ns_blocksize_bits
) /
662 bdev_logical_block_size(nilfs
->ns_bdev
);
663 for (sn
= segnump
; sn
< segnump
+ nsegs
; sn
++) {
664 nilfs_get_segment_range(nilfs
, *sn
, &seg_start
, &seg_end
);
668 nblocks
= seg_end
- seg_start
+ 1;
669 } else if (start
+ nblocks
== seg_start
) {
670 nblocks
+= seg_end
- seg_start
+ 1;
672 ret
= blkdev_issue_discard(nilfs
->ns_bdev
,
673 start
* sects_per_block
,
674 nblocks
* sects_per_block
,
682 ret
= blkdev_issue_discard(nilfs
->ns_bdev
,
683 start
* sects_per_block
,
684 nblocks
* sects_per_block
,
689 int nilfs_count_free_blocks(struct the_nilfs
*nilfs
, sector_t
*nblocks
)
691 unsigned long ncleansegs
;
693 down_read(&NILFS_MDT(nilfs
->ns_dat
)->mi_sem
);
694 ncleansegs
= nilfs_sufile_get_ncleansegs(nilfs
->ns_sufile
);
695 up_read(&NILFS_MDT(nilfs
->ns_dat
)->mi_sem
);
696 *nblocks
= (sector_t
)ncleansegs
* nilfs
->ns_blocks_per_segment
;
700 int nilfs_near_disk_full(struct the_nilfs
*nilfs
)
702 unsigned long ncleansegs
, nincsegs
;
704 ncleansegs
= nilfs_sufile_get_ncleansegs(nilfs
->ns_sufile
);
705 nincsegs
= atomic_read(&nilfs
->ns_ndirtyblks
) /
706 nilfs
->ns_blocks_per_segment
+ 1;
708 return ncleansegs
<= nilfs
->ns_nrsvsegs
+ nincsegs
;
711 struct nilfs_root
*nilfs_lookup_root(struct the_nilfs
*nilfs
, __u64 cno
)
714 struct nilfs_root
*root
;
716 spin_lock(&nilfs
->ns_cptree_lock
);
717 n
= nilfs
->ns_cptree
.rb_node
;
719 root
= rb_entry(n
, struct nilfs_root
, rb_node
);
721 if (cno
< root
->cno
) {
723 } else if (cno
> root
->cno
) {
726 refcount_inc(&root
->count
);
727 spin_unlock(&nilfs
->ns_cptree_lock
);
731 spin_unlock(&nilfs
->ns_cptree_lock
);
737 nilfs_find_or_create_root(struct the_nilfs
*nilfs
, __u64 cno
)
739 struct rb_node
**p
, *parent
;
740 struct nilfs_root
*root
, *new;
743 root
= nilfs_lookup_root(nilfs
, cno
);
747 new = kzalloc(sizeof(*root
), GFP_KERNEL
);
751 spin_lock(&nilfs
->ns_cptree_lock
);
753 p
= &nilfs
->ns_cptree
.rb_node
;
758 root
= rb_entry(parent
, struct nilfs_root
, rb_node
);
760 if (cno
< root
->cno
) {
762 } else if (cno
> root
->cno
) {
765 refcount_inc(&root
->count
);
766 spin_unlock(&nilfs
->ns_cptree_lock
);
775 refcount_set(&new->count
, 1);
776 atomic64_set(&new->inodes_count
, 0);
777 atomic64_set(&new->blocks_count
, 0);
779 rb_link_node(&new->rb_node
, parent
, p
);
780 rb_insert_color(&new->rb_node
, &nilfs
->ns_cptree
);
782 spin_unlock(&nilfs
->ns_cptree_lock
);
784 err
= nilfs_sysfs_create_snapshot_group(new);
793 void nilfs_put_root(struct nilfs_root
*root
)
795 if (refcount_dec_and_test(&root
->count
)) {
796 struct the_nilfs
*nilfs
= root
->nilfs
;
798 nilfs_sysfs_delete_snapshot_group(root
);
800 spin_lock(&nilfs
->ns_cptree_lock
);
801 rb_erase(&root
->rb_node
, &nilfs
->ns_cptree
);
802 spin_unlock(&nilfs
->ns_cptree_lock
);