1 // SPDX-License-Identifier: GPL-2.0+
3 * 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/log2.h>
17 #include <linux/crc32.h>
27 static int nilfs_valid_sb(struct nilfs_super_block
*sbp
);
29 void nilfs_set_last_segment(struct the_nilfs
*nilfs
,
30 sector_t start_blocknr
, u64 seq
, __u64 cno
)
32 spin_lock(&nilfs
->ns_last_segment_lock
);
33 nilfs
->ns_last_pseg
= start_blocknr
;
34 nilfs
->ns_last_seq
= seq
;
35 nilfs
->ns_last_cno
= cno
;
37 if (!nilfs_sb_dirty(nilfs
)) {
38 if (nilfs
->ns_prev_seq
== nilfs
->ns_last_seq
)
41 set_nilfs_sb_dirty(nilfs
);
43 nilfs
->ns_prev_seq
= nilfs
->ns_last_seq
;
46 spin_unlock(&nilfs
->ns_last_segment_lock
);
50 * alloc_nilfs - allocate a nilfs object
51 * @sb: super block instance
53 * Return Value: On success, pointer to the_nilfs is returned.
54 * On error, NULL is returned.
56 struct the_nilfs
*alloc_nilfs(struct super_block
*sb
)
58 struct the_nilfs
*nilfs
;
60 nilfs
= kzalloc(sizeof(*nilfs
), GFP_KERNEL
);
65 nilfs
->ns_bdev
= sb
->s_bdev
;
66 atomic_set(&nilfs
->ns_ndirtyblks
, 0);
67 init_rwsem(&nilfs
->ns_sem
);
68 mutex_init(&nilfs
->ns_snapshot_mount_mutex
);
69 INIT_LIST_HEAD(&nilfs
->ns_dirty_files
);
70 INIT_LIST_HEAD(&nilfs
->ns_gc_inodes
);
71 spin_lock_init(&nilfs
->ns_inode_lock
);
72 spin_lock_init(&nilfs
->ns_next_gen_lock
);
73 spin_lock_init(&nilfs
->ns_last_segment_lock
);
74 nilfs
->ns_cptree
= RB_ROOT
;
75 spin_lock_init(&nilfs
->ns_cptree_lock
);
76 init_rwsem(&nilfs
->ns_segctor_sem
);
77 nilfs
->ns_sb_update_freq
= NILFS_SB_FREQ
;
83 * destroy_nilfs - destroy nilfs object
84 * @nilfs: nilfs object to be released
86 void destroy_nilfs(struct the_nilfs
*nilfs
)
89 if (nilfs_init(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 * nilfs_get_blocksize - get block size from raw superblock data
197 * @sb: super block instance
198 * @sbp: superblock raw data buffer
199 * @blocksize: place to store block size
201 * nilfs_get_blocksize() calculates the block size from the block size
202 * exponent information written in @sbp and stores it in @blocksize,
203 * or aborts with an error message if it's too large.
205 * Return Value: On success, 0 is returned. If the block size is too
206 * large, -EINVAL is returned.
208 static int nilfs_get_blocksize(struct super_block
*sb
,
209 struct nilfs_super_block
*sbp
, int *blocksize
)
211 unsigned int shift_bits
= le32_to_cpu(sbp
->s_log_block_size
);
213 if (unlikely(shift_bits
>
214 ilog2(NILFS_MAX_BLOCK_SIZE
) - BLOCK_SIZE_BITS
)) {
215 nilfs_err(sb
, "too large filesystem blocksize: 2 ^ %u KiB",
219 *blocksize
= BLOCK_SIZE
<< shift_bits
;
224 * load_nilfs - load and recover the nilfs
225 * @nilfs: the_nilfs structure to be released
226 * @sb: super block instance used to recover past segment
228 * load_nilfs() searches and load the latest super root,
229 * attaches the last segment, and does recovery if needed.
230 * The caller must call this exclusively for simultaneous mounts.
232 int load_nilfs(struct the_nilfs
*nilfs
, struct super_block
*sb
)
234 struct nilfs_recovery_info ri
;
235 unsigned int s_flags
= sb
->s_flags
;
236 int really_read_only
= bdev_read_only(nilfs
->ns_bdev
);
237 int valid_fs
= nilfs_valid_fs(nilfs
);
241 nilfs_warn(sb
, "mounting unchecked fs");
242 if (s_flags
& SB_RDONLY
) {
244 "recovery required for readonly filesystem");
246 "write access will be enabled during recovery");
250 nilfs_init_recovery_info(&ri
);
252 err
= nilfs_search_super_root(nilfs
, &ri
);
254 struct nilfs_super_block
**sbp
= nilfs
->ns_sbp
;
260 if (!nilfs_valid_sb(sbp
[1])) {
262 "unable to fall back to spare super block");
265 nilfs_info(sb
, "trying rollback from an earlier position");
268 * restore super block with its spare and reconfigure
269 * relevant states of the nilfs object.
271 memcpy(sbp
[0], sbp
[1], nilfs
->ns_sbsize
);
272 nilfs
->ns_crc_seed
= le32_to_cpu(sbp
[0]->s_crc_seed
);
273 nilfs
->ns_sbwtime
= le64_to_cpu(sbp
[0]->s_wtime
);
275 /* verify consistency between two super blocks */
276 err
= nilfs_get_blocksize(sb
, sbp
[0], &blocksize
);
280 if (blocksize
!= nilfs
->ns_blocksize
) {
282 "blocksize differs between two super blocks (%d != %d)",
283 blocksize
, nilfs
->ns_blocksize
);
288 err
= nilfs_store_log_cursor(nilfs
, sbp
[0]);
292 /* drop clean flag to allow roll-forward and recovery */
293 nilfs
->ns_mount_state
&= ~NILFS_VALID_FS
;
296 err
= nilfs_search_super_root(nilfs
, &ri
);
301 err
= nilfs_load_super_root(nilfs
, sb
, ri
.ri_super_root
);
303 nilfs_err(sb
, "error %d while loading super root", err
);
307 err
= nilfs_sysfs_create_device_group(sb
);
314 if (s_flags
& SB_RDONLY
) {
317 if (nilfs_test_opt(nilfs
, NORECOVERY
)) {
319 "norecovery option specified, skipping roll-forward recovery");
322 features
= le64_to_cpu(nilfs
->ns_sbp
[0]->s_feature_compat_ro
) &
323 ~NILFS_FEATURE_COMPAT_RO_SUPP
;
326 "couldn't proceed with recovery because of unsupported optional features (%llx)",
327 (unsigned long long)features
);
331 if (really_read_only
) {
333 "write access unavailable, cannot proceed");
337 sb
->s_flags
&= ~SB_RDONLY
;
338 } else if (nilfs_test_opt(nilfs
, NORECOVERY
)) {
340 "recovery cancelled because norecovery option was specified for a read/write mount");
345 err
= nilfs_salvage_orphan_logs(nilfs
, sb
, &ri
);
349 down_write(&nilfs
->ns_sem
);
350 nilfs
->ns_mount_state
|= NILFS_VALID_FS
; /* set "clean" flag */
351 err
= nilfs_cleanup_super(sb
);
352 up_write(&nilfs
->ns_sem
);
356 "error %d updating super block. recovery unfinished.",
360 nilfs_info(sb
, "recovery complete");
363 nilfs_clear_recovery_info(&ri
);
364 sb
->s_flags
= s_flags
;
368 nilfs_err(sb
, "error %d while searching super root", err
);
372 nilfs_sysfs_delete_device_group(nilfs
);
375 iput(nilfs
->ns_cpfile
);
376 iput(nilfs
->ns_sufile
);
380 nilfs_clear_recovery_info(&ri
);
381 sb
->s_flags
= s_flags
;
385 static unsigned long long nilfs_max_size(unsigned int blkbits
)
387 unsigned int max_bits
;
388 unsigned long long res
= MAX_LFS_FILESIZE
; /* page cache limit */
390 max_bits
= blkbits
+ NILFS_BMAP_KEY_BIT
; /* bmap size limit */
392 res
= min_t(unsigned long long, res
, (1ULL << max_bits
) - 1);
397 * nilfs_nrsvsegs - calculate the number of reserved segments
398 * @nilfs: nilfs object
399 * @nsegs: total number of segments
401 unsigned long nilfs_nrsvsegs(struct the_nilfs
*nilfs
, unsigned long nsegs
)
403 return max_t(unsigned long, NILFS_MIN_NRSVSEGS
,
404 DIV_ROUND_UP(nsegs
* nilfs
->ns_r_segments_percentage
,
409 * nilfs_max_segment_count - calculate the maximum number of segments
410 * @nilfs: nilfs object
412 static u64
nilfs_max_segment_count(struct the_nilfs
*nilfs
)
414 u64 max_count
= U64_MAX
;
416 do_div(max_count
, nilfs
->ns_blocks_per_segment
);
417 return min_t(u64
, max_count
, ULONG_MAX
);
420 void nilfs_set_nsegments(struct the_nilfs
*nilfs
, unsigned long nsegs
)
422 nilfs
->ns_nsegments
= nsegs
;
423 nilfs
->ns_nrsvsegs
= nilfs_nrsvsegs(nilfs
, nsegs
);
426 static int nilfs_store_disk_layout(struct the_nilfs
*nilfs
,
427 struct nilfs_super_block
*sbp
)
429 u64 nsegments
, nblocks
;
431 if (le32_to_cpu(sbp
->s_rev_level
) < NILFS_MIN_SUPP_REV
) {
432 nilfs_err(nilfs
->ns_sb
,
433 "unsupported revision (superblock rev.=%d.%d, current rev.=%d.%d). Please check the version of mkfs.nilfs(2).",
434 le32_to_cpu(sbp
->s_rev_level
),
435 le16_to_cpu(sbp
->s_minor_rev_level
),
436 NILFS_CURRENT_REV
, NILFS_MINOR_REV
);
439 nilfs
->ns_sbsize
= le16_to_cpu(sbp
->s_bytes
);
440 if (nilfs
->ns_sbsize
> BLOCK_SIZE
)
443 nilfs
->ns_inode_size
= le16_to_cpu(sbp
->s_inode_size
);
444 if (nilfs
->ns_inode_size
> nilfs
->ns_blocksize
) {
445 nilfs_err(nilfs
->ns_sb
, "too large inode size: %d bytes",
446 nilfs
->ns_inode_size
);
448 } else if (nilfs
->ns_inode_size
< NILFS_MIN_INODE_SIZE
) {
449 nilfs_err(nilfs
->ns_sb
, "too small inode size: %d bytes",
450 nilfs
->ns_inode_size
);
454 nilfs
->ns_first_ino
= le32_to_cpu(sbp
->s_first_ino
);
456 nilfs
->ns_blocks_per_segment
= le32_to_cpu(sbp
->s_blocks_per_segment
);
457 if (nilfs
->ns_blocks_per_segment
< NILFS_SEG_MIN_BLOCKS
) {
458 nilfs_err(nilfs
->ns_sb
, "too short segment: %lu blocks",
459 nilfs
->ns_blocks_per_segment
);
463 nilfs
->ns_first_data_block
= le64_to_cpu(sbp
->s_first_data_block
);
464 nilfs
->ns_r_segments_percentage
=
465 le32_to_cpu(sbp
->s_r_segments_percentage
);
466 if (nilfs
->ns_r_segments_percentage
< 1 ||
467 nilfs
->ns_r_segments_percentage
> 99) {
468 nilfs_err(nilfs
->ns_sb
,
469 "invalid reserved segments percentage: %lu",
470 nilfs
->ns_r_segments_percentage
);
474 nsegments
= le64_to_cpu(sbp
->s_nsegments
);
475 if (nsegments
> nilfs_max_segment_count(nilfs
)) {
476 nilfs_err(nilfs
->ns_sb
,
477 "segment count %llu exceeds upper limit (%llu segments)",
478 (unsigned long long)nsegments
,
479 (unsigned long long)nilfs_max_segment_count(nilfs
));
483 nblocks
= sb_bdev_nr_blocks(nilfs
->ns_sb
);
485 u64 min_block_count
= nsegments
* nilfs
->ns_blocks_per_segment
;
487 * To avoid failing to mount early device images without a
488 * second superblock, exclude that block count from the
489 * "min_block_count" calculation.
492 if (nblocks
< min_block_count
) {
493 nilfs_err(nilfs
->ns_sb
,
494 "total number of segment blocks %llu exceeds device size (%llu blocks)",
495 (unsigned long long)min_block_count
,
496 (unsigned long long)nblocks
);
501 nilfs_set_nsegments(nilfs
, nsegments
);
502 nilfs
->ns_crc_seed
= le32_to_cpu(sbp
->s_crc_seed
);
506 static int nilfs_valid_sb(struct nilfs_super_block
*sbp
)
508 static unsigned char sum
[4];
509 const int sumoff
= offsetof(struct nilfs_super_block
, s_sum
);
513 if (!sbp
|| le16_to_cpu(sbp
->s_magic
) != NILFS_SUPER_MAGIC
)
515 bytes
= le16_to_cpu(sbp
->s_bytes
);
516 if (bytes
< sumoff
+ 4 || bytes
> BLOCK_SIZE
)
518 crc
= crc32_le(le32_to_cpu(sbp
->s_crc_seed
), (unsigned char *)sbp
,
520 crc
= crc32_le(crc
, sum
, 4);
521 crc
= crc32_le(crc
, (unsigned char *)sbp
+ sumoff
+ 4,
523 return crc
== le32_to_cpu(sbp
->s_sum
);
527 * nilfs_sb2_bad_offset - check the location of the second superblock
528 * @sbp: superblock raw data buffer
529 * @offset: byte offset of second superblock calculated from device size
531 * nilfs_sb2_bad_offset() checks if the position on the second
532 * superblock is valid or not based on the filesystem parameters
533 * stored in @sbp. If @offset points to a location within the segment
534 * area, or if the parameters themselves are not normal, it is
535 * determined to be invalid.
537 * Return Value: true if invalid, false if valid.
539 static bool nilfs_sb2_bad_offset(struct nilfs_super_block
*sbp
, u64 offset
)
541 unsigned int shift_bits
= le32_to_cpu(sbp
->s_log_block_size
);
542 u32 blocks_per_segment
= le32_to_cpu(sbp
->s_blocks_per_segment
);
543 u64 nsegments
= le64_to_cpu(sbp
->s_nsegments
);
546 if (blocks_per_segment
< NILFS_SEG_MIN_BLOCKS
||
547 shift_bits
> ilog2(NILFS_MAX_BLOCK_SIZE
) - BLOCK_SIZE_BITS
)
550 index
= offset
>> (shift_bits
+ BLOCK_SIZE_BITS
);
551 do_div(index
, blocks_per_segment
);
552 return index
< nsegments
;
555 static void nilfs_release_super_block(struct the_nilfs
*nilfs
)
559 for (i
= 0; i
< 2; i
++) {
560 if (nilfs
->ns_sbp
[i
]) {
561 brelse(nilfs
->ns_sbh
[i
]);
562 nilfs
->ns_sbh
[i
] = NULL
;
563 nilfs
->ns_sbp
[i
] = NULL
;
568 void nilfs_fall_back_super_block(struct the_nilfs
*nilfs
)
570 brelse(nilfs
->ns_sbh
[0]);
571 nilfs
->ns_sbh
[0] = nilfs
->ns_sbh
[1];
572 nilfs
->ns_sbp
[0] = nilfs
->ns_sbp
[1];
573 nilfs
->ns_sbh
[1] = NULL
;
574 nilfs
->ns_sbp
[1] = NULL
;
577 void nilfs_swap_super_block(struct the_nilfs
*nilfs
)
579 struct buffer_head
*tsbh
= nilfs
->ns_sbh
[0];
580 struct nilfs_super_block
*tsbp
= nilfs
->ns_sbp
[0];
582 nilfs
->ns_sbh
[0] = nilfs
->ns_sbh
[1];
583 nilfs
->ns_sbp
[0] = nilfs
->ns_sbp
[1];
584 nilfs
->ns_sbh
[1] = tsbh
;
585 nilfs
->ns_sbp
[1] = tsbp
;
588 static int nilfs_load_super_block(struct the_nilfs
*nilfs
,
589 struct super_block
*sb
, int blocksize
,
590 struct nilfs_super_block
**sbpp
)
592 struct nilfs_super_block
**sbp
= nilfs
->ns_sbp
;
593 struct buffer_head
**sbh
= nilfs
->ns_sbh
;
594 u64 sb2off
, devsize
= bdev_nr_bytes(nilfs
->ns_bdev
);
595 int valid
[2], swp
= 0;
597 if (devsize
< NILFS_SEG_MIN_BLOCKS
* NILFS_MIN_BLOCK_SIZE
+ 4096) {
598 nilfs_err(sb
, "device size too small");
601 sb2off
= NILFS_SB2_OFFSET_BYTES(devsize
);
603 sbp
[0] = nilfs_read_super_block(sb
, NILFS_SB_OFFSET_BYTES
, blocksize
,
605 sbp
[1] = nilfs_read_super_block(sb
, sb2off
, blocksize
, &sbh
[1]);
609 nilfs_err(sb
, "unable to read superblock");
613 "unable to read primary superblock (blocksize = %d)",
615 } else if (!sbp
[1]) {
617 "unable to read secondary superblock (blocksize = %d)",
622 * Compare two super blocks and set 1 in swp if the secondary
623 * super block is valid and newer. Otherwise, set 0 in swp.
625 valid
[0] = nilfs_valid_sb(sbp
[0]);
626 valid
[1] = nilfs_valid_sb(sbp
[1]);
627 swp
= valid
[1] && (!valid
[0] ||
628 le64_to_cpu(sbp
[1]->s_last_cno
) >
629 le64_to_cpu(sbp
[0]->s_last_cno
));
631 if (valid
[swp
] && nilfs_sb2_bad_offset(sbp
[swp
], sb2off
)) {
639 nilfs_release_super_block(nilfs
);
640 nilfs_err(sb
, "couldn't find nilfs on the device");
646 "broken superblock, retrying with spare superblock (blocksize = %d)",
649 nilfs_swap_super_block(nilfs
);
651 nilfs
->ns_sbwcount
= 0;
652 nilfs
->ns_sbwtime
= le64_to_cpu(sbp
[0]->s_wtime
);
653 nilfs
->ns_prot_seq
= le64_to_cpu(sbp
[valid
[1] & !swp
]->s_last_seq
);
659 * init_nilfs - initialize a NILFS instance.
660 * @nilfs: the_nilfs structure
662 * @data: mount options
664 * init_nilfs() performs common initialization per block device (e.g.
665 * reading the super block, getting disk layout information, initializing
666 * shared fields in the_nilfs).
668 * Return Value: On success, 0 is returned. On error, a negative error
671 int init_nilfs(struct the_nilfs
*nilfs
, struct super_block
*sb
, char *data
)
673 struct nilfs_super_block
*sbp
;
677 down_write(&nilfs
->ns_sem
);
679 blocksize
= sb_min_blocksize(sb
, NILFS_MIN_BLOCK_SIZE
);
681 nilfs_err(sb
, "unable to set blocksize");
685 err
= nilfs_load_super_block(nilfs
, sb
, blocksize
, &sbp
);
689 err
= nilfs_store_magic_and_option(sb
, sbp
, data
);
693 err
= nilfs_check_feature_compatibility(sb
, sbp
);
697 err
= nilfs_get_blocksize(sb
, sbp
, &blocksize
);
701 if (blocksize
< NILFS_MIN_BLOCK_SIZE
) {
703 "couldn't mount because of unsupported filesystem blocksize %d",
708 if (sb
->s_blocksize
!= blocksize
) {
709 int hw_blocksize
= bdev_logical_block_size(sb
->s_bdev
);
711 if (blocksize
< hw_blocksize
) {
713 "blocksize %d too small for device (sector-size = %d)",
714 blocksize
, hw_blocksize
);
718 nilfs_release_super_block(nilfs
);
719 if (!sb_set_blocksize(sb
, blocksize
)) {
720 nilfs_err(sb
, "bad blocksize %d", blocksize
);
725 err
= nilfs_load_super_block(nilfs
, sb
, blocksize
, &sbp
);
729 * Not to failed_sbh; sbh is released automatically
730 * when reloading fails.
733 nilfs
->ns_blocksize_bits
= sb
->s_blocksize_bits
;
734 nilfs
->ns_blocksize
= blocksize
;
736 get_random_bytes(&nilfs
->ns_next_generation
,
737 sizeof(nilfs
->ns_next_generation
));
739 err
= nilfs_store_disk_layout(nilfs
, sbp
);
743 sb
->s_maxbytes
= nilfs_max_size(sb
->s_blocksize_bits
);
745 nilfs
->ns_mount_state
= le16_to_cpu(sbp
->s_state
);
747 err
= nilfs_store_log_cursor(nilfs
, sbp
);
751 set_nilfs_init(nilfs
);
754 up_write(&nilfs
->ns_sem
);
758 nilfs_release_super_block(nilfs
);
762 int nilfs_discard_segments(struct the_nilfs
*nilfs
, __u64
*segnump
,
765 sector_t seg_start
, seg_end
;
766 sector_t start
= 0, nblocks
= 0;
767 unsigned int sects_per_block
;
771 sects_per_block
= (1 << nilfs
->ns_blocksize_bits
) /
772 bdev_logical_block_size(nilfs
->ns_bdev
);
773 for (sn
= segnump
; sn
< segnump
+ nsegs
; sn
++) {
774 nilfs_get_segment_range(nilfs
, *sn
, &seg_start
, &seg_end
);
778 nblocks
= seg_end
- seg_start
+ 1;
779 } else if (start
+ nblocks
== seg_start
) {
780 nblocks
+= seg_end
- seg_start
+ 1;
782 ret
= blkdev_issue_discard(nilfs
->ns_bdev
,
783 start
* sects_per_block
,
784 nblocks
* sects_per_block
,
792 ret
= blkdev_issue_discard(nilfs
->ns_bdev
,
793 start
* sects_per_block
,
794 nblocks
* sects_per_block
,
799 int nilfs_count_free_blocks(struct the_nilfs
*nilfs
, sector_t
*nblocks
)
801 unsigned long ncleansegs
;
803 ncleansegs
= nilfs_sufile_get_ncleansegs(nilfs
->ns_sufile
);
804 *nblocks
= (sector_t
)ncleansegs
* nilfs
->ns_blocks_per_segment
;
808 int nilfs_near_disk_full(struct the_nilfs
*nilfs
)
810 unsigned long ncleansegs
, nincsegs
;
812 ncleansegs
= nilfs_sufile_get_ncleansegs(nilfs
->ns_sufile
);
813 nincsegs
= atomic_read(&nilfs
->ns_ndirtyblks
) /
814 nilfs
->ns_blocks_per_segment
+ 1;
816 return ncleansegs
<= nilfs
->ns_nrsvsegs
+ nincsegs
;
819 struct nilfs_root
*nilfs_lookup_root(struct the_nilfs
*nilfs
, __u64 cno
)
822 struct nilfs_root
*root
;
824 spin_lock(&nilfs
->ns_cptree_lock
);
825 n
= nilfs
->ns_cptree
.rb_node
;
827 root
= rb_entry(n
, struct nilfs_root
, rb_node
);
829 if (cno
< root
->cno
) {
831 } else if (cno
> root
->cno
) {
834 refcount_inc(&root
->count
);
835 spin_unlock(&nilfs
->ns_cptree_lock
);
839 spin_unlock(&nilfs
->ns_cptree_lock
);
845 nilfs_find_or_create_root(struct the_nilfs
*nilfs
, __u64 cno
)
847 struct rb_node
**p
, *parent
;
848 struct nilfs_root
*root
, *new;
851 root
= nilfs_lookup_root(nilfs
, cno
);
855 new = kzalloc(sizeof(*root
), GFP_KERNEL
);
859 spin_lock(&nilfs
->ns_cptree_lock
);
861 p
= &nilfs
->ns_cptree
.rb_node
;
866 root
= rb_entry(parent
, struct nilfs_root
, rb_node
);
868 if (cno
< root
->cno
) {
870 } else if (cno
> root
->cno
) {
873 refcount_inc(&root
->count
);
874 spin_unlock(&nilfs
->ns_cptree_lock
);
883 refcount_set(&new->count
, 1);
884 atomic64_set(&new->inodes_count
, 0);
885 atomic64_set(&new->blocks_count
, 0);
887 rb_link_node(&new->rb_node
, parent
, p
);
888 rb_insert_color(&new->rb_node
, &nilfs
->ns_cptree
);
890 spin_unlock(&nilfs
->ns_cptree_lock
);
892 err
= nilfs_sysfs_create_snapshot_group(new);
901 void nilfs_put_root(struct nilfs_root
*root
)
903 struct the_nilfs
*nilfs
= root
->nilfs
;
905 if (refcount_dec_and_lock(&root
->count
, &nilfs
->ns_cptree_lock
)) {
906 rb_erase(&root
->rb_node
, &nilfs
->ns_cptree
);
907 spin_unlock(&nilfs
->ns_cptree_lock
);
909 nilfs_sysfs_delete_snapshot_group(root
);