Commit | Line | Data |
---|---|---|
ae98043f | 1 | // SPDX-License-Identifier: GPL-2.0+ |
8a9d2191 | 2 | /* |
94ee1d91 | 3 | * the_nilfs shared structure. |
8a9d2191 RK |
4 | * |
5 | * Copyright (C) 2005-2008 Nippon Telegraph and Telephone Corporation. | |
6 | * | |
4b420ab4 | 7 | * Written by Ryusuke Konishi. |
8a9d2191 RK |
8 | * |
9 | */ | |
10 | ||
11 | #include <linux/buffer_head.h> | |
12 | #include <linux/slab.h> | |
13 | #include <linux/blkdev.h> | |
14 | #include <linux/backing-dev.h> | |
9b1fc4e4 | 15 | #include <linux/random.h> |
610a2a3d | 16 | #include <linux/log2.h> |
e339ad31 | 17 | #include <linux/crc32.h> |
8a9d2191 RK |
18 | #include "nilfs.h" |
19 | #include "segment.h" | |
20 | #include "alloc.h" | |
21 | #include "cpfile.h" | |
22 | #include "sufile.h" | |
23 | #include "dat.h" | |
8a9d2191 RK |
24 | #include "segbuf.h" |
25 | ||
33c8e57c | 26 | |
6c125160 RK |
27 | static int nilfs_valid_sb(struct nilfs_super_block *sbp); |
28 | ||
8a9d2191 RK |
29 | void nilfs_set_last_segment(struct the_nilfs *nilfs, |
30 | sector_t start_blocknr, u64 seq, __u64 cno) | |
31 | { | |
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; | |
32502047 RK |
36 | |
37 | if (!nilfs_sb_dirty(nilfs)) { | |
38 | if (nilfs->ns_prev_seq == nilfs->ns_last_seq) | |
39 | goto stay_cursor; | |
40 | ||
41 | set_nilfs_sb_dirty(nilfs); | |
42 | } | |
43 | nilfs->ns_prev_seq = nilfs->ns_last_seq; | |
44 | ||
45 | stay_cursor: | |
8a9d2191 RK |
46 | spin_unlock(&nilfs->ns_last_segment_lock); |
47 | } | |
48 | ||
49 | /** | |
348fe8da | 50 | * alloc_nilfs - allocate a nilfs object |
6625689e | 51 | * @sb: super block instance |
8a9d2191 | 52 | * |
8a9d2191 RK |
53 | * Return Value: On success, pointer to the_nilfs is returned. |
54 | * On error, NULL is returned. | |
55 | */ | |
6625689e | 56 | struct the_nilfs *alloc_nilfs(struct super_block *sb) |
8a9d2191 RK |
57 | { |
58 | struct the_nilfs *nilfs; | |
59 | ||
60 | nilfs = kzalloc(sizeof(*nilfs), GFP_KERNEL); | |
61 | if (!nilfs) | |
62 | return NULL; | |
63 | ||
6625689e RK |
64 | nilfs->ns_sb = sb; |
65 | nilfs->ns_bdev = sb->s_bdev; | |
8a9d2191 RK |
66 | atomic_set(&nilfs->ns_ndirtyblks, 0); |
67 | init_rwsem(&nilfs->ns_sem); | |
572d8b39 | 68 | mutex_init(&nilfs->ns_snapshot_mount_mutex); |
693dd321 | 69 | INIT_LIST_HEAD(&nilfs->ns_dirty_files); |
263d90ce | 70 | INIT_LIST_HEAD(&nilfs->ns_gc_inodes); |
693dd321 | 71 | spin_lock_init(&nilfs->ns_inode_lock); |
9b1fc4e4 | 72 | spin_lock_init(&nilfs->ns_next_gen_lock); |
8a9d2191 | 73 | spin_lock_init(&nilfs->ns_last_segment_lock); |
ba65ae47 RK |
74 | nilfs->ns_cptree = RB_ROOT; |
75 | spin_lock_init(&nilfs->ns_cptree_lock); | |
8a9d2191 | 76 | init_rwsem(&nilfs->ns_segctor_sem); |
caa05d49 | 77 | nilfs->ns_sb_update_freq = NILFS_SB_FREQ; |
8a9d2191 RK |
78 | |
79 | return nilfs; | |
80 | } | |
81 | ||
33c8e57c | 82 | /** |
348fe8da RK |
83 | * destroy_nilfs - destroy nilfs object |
84 | * @nilfs: nilfs object to be released | |
8a9d2191 | 85 | */ |
348fe8da | 86 | void destroy_nilfs(struct the_nilfs *nilfs) |
8a9d2191 | 87 | { |
8a9d2191 | 88 | might_sleep(); |
8a9d2191 | 89 | if (nilfs_init(nilfs)) { |
dd70edbd | 90 | nilfs_sysfs_delete_device_group(nilfs); |
e339ad31 RK |
91 | brelse(nilfs->ns_sbh[0]); |
92 | brelse(nilfs->ns_sbh[1]); | |
8a9d2191 RK |
93 | } |
94 | kfree(nilfs); | |
95 | } | |
96 | ||
f1e89c86 RK |
97 | static int nilfs_load_super_root(struct the_nilfs *nilfs, |
98 | struct super_block *sb, sector_t sr_block) | |
8a9d2191 RK |
99 | { |
100 | struct buffer_head *bh_sr; | |
101 | struct nilfs_super_root *raw_sr; | |
e339ad31 | 102 | struct nilfs_super_block **sbp = nilfs->ns_sbp; |
f1e89c86 | 103 | struct nilfs_inode *rawi; |
0c6c44cb RK |
104 | unsigned int dat_entry_size, segment_usage_size, checkpoint_size; |
105 | unsigned int inode_size; | |
8a9d2191 RK |
106 | int err; |
107 | ||
8b94025c | 108 | err = nilfs_read_super_root_block(nilfs, sr_block, &bh_sr, 1); |
8a9d2191 RK |
109 | if (unlikely(err)) |
110 | return err; | |
111 | ||
112 | down_read(&nilfs->ns_sem); | |
e339ad31 RK |
113 | dat_entry_size = le16_to_cpu(sbp[0]->s_dat_entry_size); |
114 | checkpoint_size = le16_to_cpu(sbp[0]->s_checkpoint_size); | |
115 | segment_usage_size = le16_to_cpu(sbp[0]->s_segment_usage_size); | |
8a9d2191 RK |
116 | up_read(&nilfs->ns_sem); |
117 | ||
118 | inode_size = nilfs->ns_inode_size; | |
119 | ||
f1e89c86 RK |
120 | rawi = (void *)bh_sr->b_data + NILFS_SR_DAT_OFFSET(inode_size); |
121 | err = nilfs_dat_read(sb, dat_entry_size, rawi, &nilfs->ns_dat); | |
122 | if (err) | |
8a9d2191 RK |
123 | goto failed; |
124 | ||
f1e89c86 RK |
125 | rawi = (void *)bh_sr->b_data + NILFS_SR_CPFILE_OFFSET(inode_size); |
126 | err = nilfs_cpfile_read(sb, checkpoint_size, rawi, &nilfs->ns_cpfile); | |
127 | if (err) | |
8a9d2191 RK |
128 | goto failed_dat; |
129 | ||
f1e89c86 RK |
130 | rawi = (void *)bh_sr->b_data + NILFS_SR_SUFILE_OFFSET(inode_size); |
131 | err = nilfs_sufile_read(sb, segment_usage_size, rawi, | |
132 | &nilfs->ns_sufile); | |
133 | if (err) | |
8a9d2191 RK |
134 | goto failed_cpfile; |
135 | ||
8a9d2191 RK |
136 | raw_sr = (struct nilfs_super_root *)bh_sr->b_data; |
137 | nilfs->ns_nongc_ctime = le64_to_cpu(raw_sr->sr_nongc_ctime); | |
138 | ||
139 | failed: | |
140 | brelse(bh_sr); | |
141 | return err; | |
142 | ||
8a9d2191 | 143 | failed_cpfile: |
f1e89c86 | 144 | iput(nilfs->ns_cpfile); |
8a9d2191 RK |
145 | |
146 | failed_dat: | |
f1e89c86 | 147 | iput(nilfs->ns_dat); |
8a9d2191 RK |
148 | goto failed; |
149 | } | |
150 | ||
151 | static void nilfs_init_recovery_info(struct nilfs_recovery_info *ri) | |
152 | { | |
153 | memset(ri, 0, sizeof(*ri)); | |
154 | INIT_LIST_HEAD(&ri->ri_used_segments); | |
155 | } | |
156 | ||
157 | static void nilfs_clear_recovery_info(struct nilfs_recovery_info *ri) | |
158 | { | |
159 | nilfs_dispose_segment_list(&ri->ri_used_segments); | |
160 | } | |
161 | ||
843d63ba RK |
162 | /** |
163 | * nilfs_store_log_cursor - load log cursor from a super block | |
164 | * @nilfs: nilfs object | |
165 | * @sbp: buffer storing super block to be read | |
166 | * | |
167 | * nilfs_store_log_cursor() reads the last position of the log | |
168 | * containing a super root from a given super block, and initializes | |
169 | * relevant information on the nilfs object preparatory for log | |
170 | * scanning and recovery. | |
171 | */ | |
172 | static int nilfs_store_log_cursor(struct the_nilfs *nilfs, | |
173 | struct nilfs_super_block *sbp) | |
174 | { | |
175 | int ret = 0; | |
176 | ||
177 | nilfs->ns_last_pseg = le64_to_cpu(sbp->s_last_pseg); | |
178 | nilfs->ns_last_cno = le64_to_cpu(sbp->s_last_cno); | |
179 | nilfs->ns_last_seq = le64_to_cpu(sbp->s_last_seq); | |
180 | ||
32502047 | 181 | nilfs->ns_prev_seq = nilfs->ns_last_seq; |
843d63ba RK |
182 | nilfs->ns_seg_seq = nilfs->ns_last_seq; |
183 | nilfs->ns_segnum = | |
184 | nilfs_get_segnum_of_block(nilfs, nilfs->ns_last_pseg); | |
185 | nilfs->ns_cno = nilfs->ns_last_cno + 1; | |
186 | if (nilfs->ns_segnum >= nilfs->ns_nsegments) { | |
a1d0747a | 187 | nilfs_err(nilfs->ns_sb, |
feee880f RK |
188 | "pointed segment number is out of range: segnum=%llu, nsegments=%lu", |
189 | (unsigned long long)nilfs->ns_segnum, | |
190 | nilfs->ns_nsegments); | |
843d63ba RK |
191 | ret = -EINVAL; |
192 | } | |
193 | return ret; | |
194 | } | |
195 | ||
ebeccaae RK |
196 | /** |
197 | * nilfs_get_blocksize - get block size from raw superblock data | |
198 | * @sb: super block instance | |
199 | * @sbp: superblock raw data buffer | |
200 | * @blocksize: place to store block size | |
201 | * | |
202 | * nilfs_get_blocksize() calculates the block size from the block size | |
203 | * exponent information written in @sbp and stores it in @blocksize, | |
204 | * or aborts with an error message if it's too large. | |
205 | * | |
206 | * Return Value: On success, 0 is returned. If the block size is too | |
207 | * large, -EINVAL is returned. | |
208 | */ | |
209 | static int nilfs_get_blocksize(struct super_block *sb, | |
210 | struct nilfs_super_block *sbp, int *blocksize) | |
211 | { | |
212 | unsigned int shift_bits = le32_to_cpu(sbp->s_log_block_size); | |
213 | ||
214 | if (unlikely(shift_bits > | |
215 | ilog2(NILFS_MAX_BLOCK_SIZE) - BLOCK_SIZE_BITS)) { | |
216 | nilfs_err(sb, "too large filesystem blocksize: 2 ^ %u KiB", | |
217 | shift_bits); | |
218 | return -EINVAL; | |
219 | } | |
220 | *blocksize = BLOCK_SIZE << shift_bits; | |
221 | return 0; | |
222 | } | |
223 | ||
8a9d2191 RK |
224 | /** |
225 | * load_nilfs - load and recover the nilfs | |
226 | * @nilfs: the_nilfs structure to be released | |
312f79c4 | 227 | * @sb: super block instance used to recover past segment |
8a9d2191 RK |
228 | * |
229 | * load_nilfs() searches and load the latest super root, | |
230 | * attaches the last segment, and does recovery if needed. | |
231 | * The caller must call this exclusively for simultaneous mounts. | |
232 | */ | |
f7545144 | 233 | int load_nilfs(struct the_nilfs *nilfs, struct super_block *sb) |
8a9d2191 RK |
234 | { |
235 | struct nilfs_recovery_info ri; | |
f7545144 | 236 | unsigned int s_flags = sb->s_flags; |
8a9d2191 | 237 | int really_read_only = bdev_read_only(nilfs->ns_bdev); |
a057d2c0 | 238 | int valid_fs = nilfs_valid_fs(nilfs); |
f50a4c81 | 239 | int err; |
8a9d2191 | 240 | |
f50a4c81 | 241 | if (!valid_fs) { |
a1d0747a | 242 | nilfs_warn(sb, "mounting unchecked fs"); |
1751e8a6 | 243 | if (s_flags & SB_RDONLY) { |
a1d0747a JP |
244 | nilfs_info(sb, |
245 | "recovery required for readonly filesystem"); | |
246 | nilfs_info(sb, | |
247 | "write access will be enabled during recovery"); | |
8a9d2191 | 248 | } |
8a9d2191 RK |
249 | } |
250 | ||
f50a4c81 RK |
251 | nilfs_init_recovery_info(&ri); |
252 | ||
8b94025c | 253 | err = nilfs_search_super_root(nilfs, &ri); |
8a9d2191 | 254 | if (unlikely(err)) { |
6c125160 RK |
255 | struct nilfs_super_block **sbp = nilfs->ns_sbp; |
256 | int blocksize; | |
257 | ||
258 | if (err != -EINVAL) | |
259 | goto scan_error; | |
260 | ||
261 | if (!nilfs_valid_sb(sbp[1])) { | |
a1d0747a JP |
262 | nilfs_warn(sb, |
263 | "unable to fall back to spare super block"); | |
6c125160 RK |
264 | goto scan_error; |
265 | } | |
a1d0747a | 266 | nilfs_info(sb, "trying rollback from an earlier position"); |
6c125160 RK |
267 | |
268 | /* | |
269 | * restore super block with its spare and reconfigure | |
270 | * relevant states of the nilfs object. | |
271 | */ | |
272 | memcpy(sbp[0], sbp[1], nilfs->ns_sbsize); | |
273 | nilfs->ns_crc_seed = le32_to_cpu(sbp[0]->s_crc_seed); | |
274 | nilfs->ns_sbwtime = le64_to_cpu(sbp[0]->s_wtime); | |
275 | ||
276 | /* verify consistency between two super blocks */ | |
ebeccaae RK |
277 | err = nilfs_get_blocksize(sb, sbp[0], &blocksize); |
278 | if (err) | |
279 | goto scan_error; | |
280 | ||
6c125160 | 281 | if (blocksize != nilfs->ns_blocksize) { |
a1d0747a JP |
282 | nilfs_warn(sb, |
283 | "blocksize differs between two super blocks (%d != %d)", | |
284 | blocksize, nilfs->ns_blocksize); | |
ebeccaae | 285 | err = -EINVAL; |
6c125160 RK |
286 | goto scan_error; |
287 | } | |
288 | ||
289 | err = nilfs_store_log_cursor(nilfs, sbp[0]); | |
290 | if (err) | |
291 | goto scan_error; | |
292 | ||
293 | /* drop clean flag to allow roll-forward and recovery */ | |
294 | nilfs->ns_mount_state &= ~NILFS_VALID_FS; | |
295 | valid_fs = 0; | |
296 | ||
297 | err = nilfs_search_super_root(nilfs, &ri); | |
298 | if (err) | |
299 | goto scan_error; | |
8a9d2191 RK |
300 | } |
301 | ||
f7545144 | 302 | err = nilfs_load_super_root(nilfs, sb, ri.ri_super_root); |
8a9d2191 | 303 | if (unlikely(err)) { |
a1d0747a | 304 | nilfs_err(sb, "error %d while loading super root", err); |
8a9d2191 RK |
305 | goto failed; |
306 | } | |
307 | ||
f50a4c81 RK |
308 | if (valid_fs) |
309 | goto skip_recovery; | |
310 | ||
1751e8a6 | 311 | if (s_flags & SB_RDONLY) { |
c5ca48aa RK |
312 | __u64 features; |
313 | ||
3b2ce58b | 314 | if (nilfs_test_opt(nilfs, NORECOVERY)) { |
a1d0747a JP |
315 | nilfs_info(sb, |
316 | "norecovery option specified, skipping roll-forward recovery"); | |
0234576d RK |
317 | goto skip_recovery; |
318 | } | |
c5ca48aa RK |
319 | features = le64_to_cpu(nilfs->ns_sbp[0]->s_feature_compat_ro) & |
320 | ~NILFS_FEATURE_COMPAT_RO_SUPP; | |
321 | if (features) { | |
a1d0747a | 322 | nilfs_err(sb, |
feee880f RK |
323 | "couldn't proceed with recovery because of unsupported optional features (%llx)", |
324 | (unsigned long long)features); | |
c5ca48aa RK |
325 | err = -EROFS; |
326 | goto failed_unload; | |
327 | } | |
f50a4c81 | 328 | if (really_read_only) { |
a1d0747a | 329 | nilfs_err(sb, |
feee880f | 330 | "write access unavailable, cannot proceed"); |
f50a4c81 RK |
331 | err = -EROFS; |
332 | goto failed_unload; | |
8a9d2191 | 333 | } |
1751e8a6 | 334 | sb->s_flags &= ~SB_RDONLY; |
3b2ce58b | 335 | } else if (nilfs_test_opt(nilfs, NORECOVERY)) { |
a1d0747a | 336 | nilfs_err(sb, |
feee880f | 337 | "recovery cancelled because norecovery option was specified for a read/write mount"); |
0234576d RK |
338 | err = -EINVAL; |
339 | goto failed_unload; | |
f50a4c81 RK |
340 | } |
341 | ||
f7545144 | 342 | err = nilfs_salvage_orphan_logs(nilfs, sb, &ri); |
f50a4c81 RK |
343 | if (err) |
344 | goto failed_unload; | |
345 | ||
346 | down_write(&nilfs->ns_sem); | |
7ecaa46c | 347 | nilfs->ns_mount_state |= NILFS_VALID_FS; /* set "clean" flag */ |
f7545144 | 348 | err = nilfs_cleanup_super(sb); |
f50a4c81 RK |
349 | up_write(&nilfs->ns_sem); |
350 | ||
351 | if (err) { | |
a1d0747a | 352 | nilfs_err(sb, |
feee880f RK |
353 | "error %d updating super block. recovery unfinished.", |
354 | err); | |
f50a4c81 | 355 | goto failed_unload; |
8a9d2191 | 356 | } |
a1d0747a | 357 | nilfs_info(sb, "recovery complete"); |
8a9d2191 | 358 | |
f50a4c81 | 359 | skip_recovery: |
f50a4c81 | 360 | nilfs_clear_recovery_info(&ri); |
f7545144 | 361 | sb->s_flags = s_flags; |
f50a4c81 RK |
362 | return 0; |
363 | ||
6c125160 | 364 | scan_error: |
a1d0747a | 365 | nilfs_err(sb, "error %d while searching super root", err); |
6c125160 RK |
366 | goto failed; |
367 | ||
f50a4c81 | 368 | failed_unload: |
f1e89c86 RK |
369 | iput(nilfs->ns_cpfile); |
370 | iput(nilfs->ns_sufile); | |
371 | iput(nilfs->ns_dat); | |
8a9d2191 RK |
372 | |
373 | failed: | |
374 | nilfs_clear_recovery_info(&ri); | |
f7545144 | 375 | sb->s_flags = s_flags; |
8a9d2191 RK |
376 | return err; |
377 | } | |
378 | ||
379 | static unsigned long long nilfs_max_size(unsigned int blkbits) | |
380 | { | |
381 | unsigned int max_bits; | |
382 | unsigned long long res = MAX_LFS_FILESIZE; /* page cache limit */ | |
383 | ||
384 | max_bits = blkbits + NILFS_BMAP_KEY_BIT; /* bmap size limit */ | |
385 | if (max_bits < 64) | |
386 | res = min_t(unsigned long long, res, (1ULL << max_bits) - 1); | |
387 | return res; | |
388 | } | |
389 | ||
4e33f9ea RK |
390 | /** |
391 | * nilfs_nrsvsegs - calculate the number of reserved segments | |
392 | * @nilfs: nilfs object | |
393 | * @nsegs: total number of segments | |
394 | */ | |
395 | unsigned long nilfs_nrsvsegs(struct the_nilfs *nilfs, unsigned long nsegs) | |
396 | { | |
397 | return max_t(unsigned long, NILFS_MIN_NRSVSEGS, | |
398 | DIV_ROUND_UP(nsegs * nilfs->ns_r_segments_percentage, | |
399 | 100)); | |
400 | } | |
401 | ||
402 | void nilfs_set_nsegments(struct the_nilfs *nilfs, unsigned long nsegs) | |
403 | { | |
404 | nilfs->ns_nsegments = nsegs; | |
405 | nilfs->ns_nrsvsegs = nilfs_nrsvsegs(nilfs, nsegs); | |
406 | } | |
407 | ||
e339ad31 RK |
408 | static int nilfs_store_disk_layout(struct the_nilfs *nilfs, |
409 | struct nilfs_super_block *sbp) | |
8a9d2191 | 410 | { |
9566a7a8 | 411 | if (le32_to_cpu(sbp->s_rev_level) < NILFS_MIN_SUPP_REV) { |
a1d0747a | 412 | nilfs_err(nilfs->ns_sb, |
feee880f RK |
413 | "unsupported revision (superblock rev.=%d.%d, current rev.=%d.%d). Please check the version of mkfs.nilfs(2).", |
414 | le32_to_cpu(sbp->s_rev_level), | |
415 | le16_to_cpu(sbp->s_minor_rev_level), | |
416 | NILFS_CURRENT_REV, NILFS_MINOR_REV); | |
8a9d2191 RK |
417 | return -EINVAL; |
418 | } | |
e339ad31 RK |
419 | nilfs->ns_sbsize = le16_to_cpu(sbp->s_bytes); |
420 | if (nilfs->ns_sbsize > BLOCK_SIZE) | |
421 | return -EINVAL; | |
422 | ||
8a9d2191 | 423 | nilfs->ns_inode_size = le16_to_cpu(sbp->s_inode_size); |
0ec060d1 | 424 | if (nilfs->ns_inode_size > nilfs->ns_blocksize) { |
a1d0747a | 425 | nilfs_err(nilfs->ns_sb, "too large inode size: %d bytes", |
feee880f | 426 | nilfs->ns_inode_size); |
0ec060d1 RK |
427 | return -EINVAL; |
428 | } else if (nilfs->ns_inode_size < NILFS_MIN_INODE_SIZE) { | |
a1d0747a | 429 | nilfs_err(nilfs->ns_sb, "too small inode size: %d bytes", |
feee880f | 430 | nilfs->ns_inode_size); |
0ec060d1 RK |
431 | return -EINVAL; |
432 | } | |
433 | ||
8a9d2191 RK |
434 | nilfs->ns_first_ino = le32_to_cpu(sbp->s_first_ino); |
435 | ||
436 | nilfs->ns_blocks_per_segment = le32_to_cpu(sbp->s_blocks_per_segment); | |
437 | if (nilfs->ns_blocks_per_segment < NILFS_SEG_MIN_BLOCKS) { | |
a1d0747a | 438 | nilfs_err(nilfs->ns_sb, "too short segment: %lu blocks", |
feee880f | 439 | nilfs->ns_blocks_per_segment); |
8a9d2191 RK |
440 | return -EINVAL; |
441 | } | |
442 | ||
443 | nilfs->ns_first_data_block = le64_to_cpu(sbp->s_first_data_block); | |
8a9d2191 RK |
444 | nilfs->ns_r_segments_percentage = |
445 | le32_to_cpu(sbp->s_r_segments_percentage); | |
3d777a64 HC |
446 | if (nilfs->ns_r_segments_percentage < 1 || |
447 | nilfs->ns_r_segments_percentage > 99) { | |
a1d0747a | 448 | nilfs_err(nilfs->ns_sb, |
feee880f RK |
449 | "invalid reserved segments percentage: %lu", |
450 | nilfs->ns_r_segments_percentage); | |
3d777a64 HC |
451 | return -EINVAL; |
452 | } | |
453 | ||
4e33f9ea | 454 | nilfs_set_nsegments(nilfs, le64_to_cpu(sbp->s_nsegments)); |
8a9d2191 RK |
455 | nilfs->ns_crc_seed = le32_to_cpu(sbp->s_crc_seed); |
456 | return 0; | |
457 | } | |
458 | ||
e339ad31 RK |
459 | static int nilfs_valid_sb(struct nilfs_super_block *sbp) |
460 | { | |
461 | static unsigned char sum[4]; | |
462 | const int sumoff = offsetof(struct nilfs_super_block, s_sum); | |
463 | size_t bytes; | |
464 | u32 crc; | |
465 | ||
466 | if (!sbp || le16_to_cpu(sbp->s_magic) != NILFS_SUPER_MAGIC) | |
467 | return 0; | |
468 | bytes = le16_to_cpu(sbp->s_bytes); | |
63d2f95d | 469 | if (bytes < sumoff + 4 || bytes > BLOCK_SIZE) |
e339ad31 RK |
470 | return 0; |
471 | crc = crc32_le(le32_to_cpu(sbp->s_crc_seed), (unsigned char *)sbp, | |
472 | sumoff); | |
473 | crc = crc32_le(crc, sum, 4); | |
474 | crc = crc32_le(crc, (unsigned char *)sbp + sumoff + 4, | |
475 | bytes - sumoff - 4); | |
476 | return crc == le32_to_cpu(sbp->s_sum); | |
477 | } | |
478 | ||
610a2a3d RK |
479 | /** |
480 | * nilfs_sb2_bad_offset - check the location of the second superblock | |
481 | * @sbp: superblock raw data buffer | |
482 | * @offset: byte offset of second superblock calculated from device size | |
483 | * | |
484 | * nilfs_sb2_bad_offset() checks if the position on the second | |
485 | * superblock is valid or not based on the filesystem parameters | |
486 | * stored in @sbp. If @offset points to a location within the segment | |
487 | * area, or if the parameters themselves are not normal, it is | |
488 | * determined to be invalid. | |
489 | * | |
490 | * Return Value: true if invalid, false if valid. | |
491 | */ | |
492 | static bool nilfs_sb2_bad_offset(struct nilfs_super_block *sbp, u64 offset) | |
e339ad31 | 493 | { |
610a2a3d RK |
494 | unsigned int shift_bits = le32_to_cpu(sbp->s_log_block_size); |
495 | u32 blocks_per_segment = le32_to_cpu(sbp->s_blocks_per_segment); | |
496 | u64 nsegments = le64_to_cpu(sbp->s_nsegments); | |
497 | u64 index; | |
498 | ||
499 | if (blocks_per_segment < NILFS_SEG_MIN_BLOCKS || | |
500 | shift_bits > ilog2(NILFS_MAX_BLOCK_SIZE) - BLOCK_SIZE_BITS) | |
501 | return true; | |
502 | ||
503 | index = offset >> (shift_bits + BLOCK_SIZE_BITS); | |
504 | do_div(index, blocks_per_segment); | |
505 | return index < nsegments; | |
e339ad31 RK |
506 | } |
507 | ||
508 | static void nilfs_release_super_block(struct the_nilfs *nilfs) | |
509 | { | |
510 | int i; | |
511 | ||
512 | for (i = 0; i < 2; i++) { | |
513 | if (nilfs->ns_sbp[i]) { | |
514 | brelse(nilfs->ns_sbh[i]); | |
515 | nilfs->ns_sbh[i] = NULL; | |
516 | nilfs->ns_sbp[i] = NULL; | |
517 | } | |
518 | } | |
519 | } | |
520 | ||
521 | void nilfs_fall_back_super_block(struct the_nilfs *nilfs) | |
522 | { | |
523 | brelse(nilfs->ns_sbh[0]); | |
524 | nilfs->ns_sbh[0] = nilfs->ns_sbh[1]; | |
525 | nilfs->ns_sbp[0] = nilfs->ns_sbp[1]; | |
526 | nilfs->ns_sbh[1] = NULL; | |
527 | nilfs->ns_sbp[1] = NULL; | |
528 | } | |
529 | ||
530 | void nilfs_swap_super_block(struct the_nilfs *nilfs) | |
531 | { | |
532 | struct buffer_head *tsbh = nilfs->ns_sbh[0]; | |
533 | struct nilfs_super_block *tsbp = nilfs->ns_sbp[0]; | |
534 | ||
535 | nilfs->ns_sbh[0] = nilfs->ns_sbh[1]; | |
536 | nilfs->ns_sbp[0] = nilfs->ns_sbp[1]; | |
537 | nilfs->ns_sbh[1] = tsbh; | |
538 | nilfs->ns_sbp[1] = tsbp; | |
539 | } | |
540 | ||
541 | static int nilfs_load_super_block(struct the_nilfs *nilfs, | |
542 | struct super_block *sb, int blocksize, | |
543 | struct nilfs_super_block **sbpp) | |
544 | { | |
545 | struct nilfs_super_block **sbp = nilfs->ns_sbp; | |
546 | struct buffer_head **sbh = nilfs->ns_sbh; | |
4fcd6979 | 547 | u64 sb2off = NILFS_SB2_OFFSET_BYTES(bdev_nr_bytes(nilfs->ns_bdev)); |
e339ad31 RK |
548 | int valid[2], swp = 0; |
549 | ||
550 | sbp[0] = nilfs_read_super_block(sb, NILFS_SB_OFFSET_BYTES, blocksize, | |
551 | &sbh[0]); | |
552 | sbp[1] = nilfs_read_super_block(sb, sb2off, blocksize, &sbh[1]); | |
553 | ||
554 | if (!sbp[0]) { | |
555 | if (!sbp[1]) { | |
a1d0747a | 556 | nilfs_err(sb, "unable to read superblock"); |
e339ad31 RK |
557 | return -EIO; |
558 | } | |
a1d0747a JP |
559 | nilfs_warn(sb, |
560 | "unable to read primary superblock (blocksize = %d)", | |
561 | blocksize); | |
4138ec23 | 562 | } else if (!sbp[1]) { |
a1d0747a JP |
563 | nilfs_warn(sb, |
564 | "unable to read secondary superblock (blocksize = %d)", | |
565 | blocksize); | |
4138ec23 | 566 | } |
e339ad31 | 567 | |
25294d8c RK |
568 | /* |
569 | * Compare two super blocks and set 1 in swp if the secondary | |
570 | * super block is valid and newer. Otherwise, set 0 in swp. | |
571 | */ | |
e339ad31 RK |
572 | valid[0] = nilfs_valid_sb(sbp[0]); |
573 | valid[1] = nilfs_valid_sb(sbp[1]); | |
25294d8c RK |
574 | swp = valid[1] && (!valid[0] || |
575 | le64_to_cpu(sbp[1]->s_last_cno) > | |
576 | le64_to_cpu(sbp[0]->s_last_cno)); | |
e339ad31 RK |
577 | |
578 | if (valid[swp] && nilfs_sb2_bad_offset(sbp[swp], sb2off)) { | |
579 | brelse(sbh[1]); | |
580 | sbh[1] = NULL; | |
581 | sbp[1] = NULL; | |
d7178c79 | 582 | valid[1] = 0; |
e339ad31 RK |
583 | swp = 0; |
584 | } | |
585 | if (!valid[swp]) { | |
586 | nilfs_release_super_block(nilfs); | |
a1d0747a | 587 | nilfs_err(sb, "couldn't find nilfs on the device"); |
e339ad31 RK |
588 | return -EINVAL; |
589 | } | |
590 | ||
ea1a16f7 | 591 | if (!valid[!swp]) |
a1d0747a JP |
592 | nilfs_warn(sb, |
593 | "broken superblock, retrying with spare superblock (blocksize = %d)", | |
594 | blocksize); | |
ea1a16f7 | 595 | if (swp) |
e339ad31 | 596 | nilfs_swap_super_block(nilfs); |
e339ad31 | 597 | |
b2ac86e1 JS |
598 | nilfs->ns_sbwcount = 0; |
599 | nilfs->ns_sbwtime = le64_to_cpu(sbp[0]->s_wtime); | |
e339ad31 RK |
600 | nilfs->ns_prot_seq = le64_to_cpu(sbp[valid[1] & !swp]->s_last_seq); |
601 | *sbpp = sbp[0]; | |
602 | return 0; | |
603 | } | |
604 | ||
8a9d2191 RK |
605 | /** |
606 | * init_nilfs - initialize a NILFS instance. | |
607 | * @nilfs: the_nilfs structure | |
8a9d2191 RK |
608 | * @sb: super block |
609 | * @data: mount options | |
610 | * | |
611 | * init_nilfs() performs common initialization per block device (e.g. | |
612 | * reading the super block, getting disk layout information, initializing | |
f11459ad | 613 | * shared fields in the_nilfs). |
8a9d2191 RK |
614 | * |
615 | * Return Value: On success, 0 is returned. On error, a negative error | |
616 | * code is returned. | |
617 | */ | |
f7545144 | 618 | int init_nilfs(struct the_nilfs *nilfs, struct super_block *sb, char *data) |
8a9d2191 | 619 | { |
8a9d2191 | 620 | struct nilfs_super_block *sbp; |
8a9d2191 | 621 | int blocksize; |
e339ad31 | 622 | int err; |
8a9d2191 RK |
623 | |
624 | down_write(&nilfs->ns_sem); | |
8a9d2191 | 625 | |
89c0fd01 | 626 | blocksize = sb_min_blocksize(sb, NILFS_MIN_BLOCK_SIZE); |
e339ad31 | 627 | if (!blocksize) { |
a1d0747a | 628 | nilfs_err(sb, "unable to set blocksize"); |
8a9d2191 RK |
629 | err = -EINVAL; |
630 | goto out; | |
631 | } | |
e339ad31 RK |
632 | err = nilfs_load_super_block(nilfs, sb, blocksize, &sbp); |
633 | if (err) | |
634 | goto out; | |
635 | ||
8a9d2191 RK |
636 | err = nilfs_store_magic_and_option(sb, sbp, data); |
637 | if (err) | |
638 | goto failed_sbh; | |
639 | ||
c5ca48aa RK |
640 | err = nilfs_check_feature_compatibility(sb, sbp); |
641 | if (err) | |
642 | goto failed_sbh; | |
643 | ||
ebeccaae RK |
644 | err = nilfs_get_blocksize(sb, sbp, &blocksize); |
645 | if (err) | |
646 | goto failed_sbh; | |
647 | ||
648 | if (blocksize < NILFS_MIN_BLOCK_SIZE) { | |
a1d0747a | 649 | nilfs_err(sb, |
feee880f RK |
650 | "couldn't mount because of unsupported filesystem blocksize %d", |
651 | blocksize); | |
89c0fd01 RK |
652 | err = -EINVAL; |
653 | goto failed_sbh; | |
654 | } | |
8a9d2191 | 655 | if (sb->s_blocksize != blocksize) { |
e1defc4f | 656 | int hw_blocksize = bdev_logical_block_size(sb->s_bdev); |
e339ad31 RK |
657 | |
658 | if (blocksize < hw_blocksize) { | |
a1d0747a | 659 | nilfs_err(sb, |
feee880f RK |
660 | "blocksize %d too small for device (sector-size = %d)", |
661 | blocksize, hw_blocksize); | |
8a9d2191 | 662 | err = -EINVAL; |
e339ad31 RK |
663 | goto failed_sbh; |
664 | } | |
665 | nilfs_release_super_block(nilfs); | |
666 | sb_set_blocksize(sb, blocksize); | |
667 | ||
668 | err = nilfs_load_super_block(nilfs, sb, blocksize, &sbp); | |
669 | if (err) | |
8a9d2191 | 670 | goto out; |
076a378b RK |
671 | /* |
672 | * Not to failed_sbh; sbh is released automatically | |
673 | * when reloading fails. | |
674 | */ | |
8a9d2191 RK |
675 | } |
676 | nilfs->ns_blocksize_bits = sb->s_blocksize_bits; | |
92c60cca | 677 | nilfs->ns_blocksize = blocksize; |
8a9d2191 | 678 | |
9b1fc4e4 RK |
679 | get_random_bytes(&nilfs->ns_next_generation, |
680 | sizeof(nilfs->ns_next_generation)); | |
681 | ||
e339ad31 | 682 | err = nilfs_store_disk_layout(nilfs, sbp); |
8a9d2191 RK |
683 | if (err) |
684 | goto failed_sbh; | |
685 | ||
686 | sb->s_maxbytes = nilfs_max_size(sb->s_blocksize_bits); | |
687 | ||
688 | nilfs->ns_mount_state = le16_to_cpu(sbp->s_state); | |
8a9d2191 | 689 | |
843d63ba RK |
690 | err = nilfs_store_log_cursor(nilfs, sbp); |
691 | if (err) | |
8a9d2191 | 692 | goto failed_sbh; |
8a9d2191 | 693 | |
dd70edbd VD |
694 | err = nilfs_sysfs_create_device_group(sb); |
695 | if (err) | |
696 | goto failed_sbh; | |
697 | ||
8a9d2191 RK |
698 | set_nilfs_init(nilfs); |
699 | err = 0; | |
700 | out: | |
701 | up_write(&nilfs->ns_sem); | |
702 | return err; | |
703 | ||
704 | failed_sbh: | |
e339ad31 | 705 | nilfs_release_super_block(nilfs); |
8a9d2191 RK |
706 | goto out; |
707 | } | |
708 | ||
e902ec99 JS |
709 | int nilfs_discard_segments(struct the_nilfs *nilfs, __u64 *segnump, |
710 | size_t nsegs) | |
711 | { | |
712 | sector_t seg_start, seg_end; | |
713 | sector_t start = 0, nblocks = 0; | |
714 | unsigned int sects_per_block; | |
715 | __u64 *sn; | |
716 | int ret = 0; | |
717 | ||
718 | sects_per_block = (1 << nilfs->ns_blocksize_bits) / | |
719 | bdev_logical_block_size(nilfs->ns_bdev); | |
720 | for (sn = segnump; sn < segnump + nsegs; sn++) { | |
721 | nilfs_get_segment_range(nilfs, *sn, &seg_start, &seg_end); | |
722 | ||
723 | if (!nblocks) { | |
724 | start = seg_start; | |
725 | nblocks = seg_end - seg_start + 1; | |
726 | } else if (start + nblocks == seg_start) { | |
727 | nblocks += seg_end - seg_start + 1; | |
728 | } else { | |
729 | ret = blkdev_issue_discard(nilfs->ns_bdev, | |
730 | start * sects_per_block, | |
731 | nblocks * sects_per_block, | |
44abff2c | 732 | GFP_NOFS); |
e902ec99 JS |
733 | if (ret < 0) |
734 | return ret; | |
735 | nblocks = 0; | |
736 | } | |
737 | } | |
738 | if (nblocks) | |
739 | ret = blkdev_issue_discard(nilfs->ns_bdev, | |
740 | start * sects_per_block, | |
741 | nblocks * sects_per_block, | |
44abff2c | 742 | GFP_NOFS); |
e902ec99 JS |
743 | return ret; |
744 | } | |
745 | ||
8a9d2191 RK |
746 | int nilfs_count_free_blocks(struct the_nilfs *nilfs, sector_t *nblocks) |
747 | { | |
8a9d2191 | 748 | unsigned long ncleansegs; |
8a9d2191 | 749 | |
ef7d4757 | 750 | ncleansegs = nilfs_sufile_get_ncleansegs(nilfs->ns_sufile); |
ef7d4757 RK |
751 | *nblocks = (sector_t)ncleansegs * nilfs->ns_blocks_per_segment; |
752 | return 0; | |
8a9d2191 RK |
753 | } |
754 | ||
8a9d2191 RK |
755 | int nilfs_near_disk_full(struct the_nilfs *nilfs) |
756 | { | |
8a9d2191 | 757 | unsigned long ncleansegs, nincsegs; |
ef7d4757 RK |
758 | |
759 | ncleansegs = nilfs_sufile_get_ncleansegs(nilfs->ns_sufile); | |
760 | nincsegs = atomic_read(&nilfs->ns_ndirtyblks) / | |
761 | nilfs->ns_blocks_per_segment + 1; | |
762 | ||
763 | return ncleansegs <= nilfs->ns_nrsvsegs + nincsegs; | |
8a9d2191 RK |
764 | } |
765 | ||
ba65ae47 | 766 | struct nilfs_root *nilfs_lookup_root(struct the_nilfs *nilfs, __u64 cno) |
6dd47406 | 767 | { |
ba65ae47 RK |
768 | struct rb_node *n; |
769 | struct nilfs_root *root; | |
770 | ||
771 | spin_lock(&nilfs->ns_cptree_lock); | |
772 | n = nilfs->ns_cptree.rb_node; | |
773 | while (n) { | |
774 | root = rb_entry(n, struct nilfs_root, rb_node); | |
775 | ||
776 | if (cno < root->cno) { | |
777 | n = n->rb_left; | |
778 | } else if (cno > root->cno) { | |
779 | n = n->rb_right; | |
780 | } else { | |
d4f0284a | 781 | refcount_inc(&root->count); |
ba65ae47 RK |
782 | spin_unlock(&nilfs->ns_cptree_lock); |
783 | return root; | |
784 | } | |
6dd47406 | 785 | } |
ba65ae47 | 786 | spin_unlock(&nilfs->ns_cptree_lock); |
6dd47406 | 787 | |
6dd47406 | 788 | return NULL; |
6dd47406 RK |
789 | } |
790 | ||
ba65ae47 RK |
791 | struct nilfs_root * |
792 | nilfs_find_or_create_root(struct the_nilfs *nilfs, __u64 cno) | |
8a9d2191 | 793 | { |
ba65ae47 RK |
794 | struct rb_node **p, *parent; |
795 | struct nilfs_root *root, *new; | |
dd70edbd | 796 | int err; |
8a9d2191 | 797 | |
ba65ae47 RK |
798 | root = nilfs_lookup_root(nilfs, cno); |
799 | if (root) | |
800 | return root; | |
8a9d2191 | 801 | |
dd70edbd | 802 | new = kzalloc(sizeof(*root), GFP_KERNEL); |
ba65ae47 RK |
803 | if (!new) |
804 | return NULL; | |
805 | ||
806 | spin_lock(&nilfs->ns_cptree_lock); | |
807 | ||
808 | p = &nilfs->ns_cptree.rb_node; | |
809 | parent = NULL; | |
810 | ||
811 | while (*p) { | |
812 | parent = *p; | |
813 | root = rb_entry(parent, struct nilfs_root, rb_node); | |
814 | ||
815 | if (cno < root->cno) { | |
816 | p = &(*p)->rb_left; | |
817 | } else if (cno > root->cno) { | |
818 | p = &(*p)->rb_right; | |
819 | } else { | |
d4f0284a | 820 | refcount_inc(&root->count); |
ba65ae47 RK |
821 | spin_unlock(&nilfs->ns_cptree_lock); |
822 | kfree(new); | |
823 | return root; | |
8a9d2191 RK |
824 | } |
825 | } | |
8a9d2191 | 826 | |
ba65ae47 RK |
827 | new->cno = cno; |
828 | new->ifile = NULL; | |
829 | new->nilfs = nilfs; | |
d4f0284a | 830 | refcount_set(&new->count, 1); |
e5f7f848 VD |
831 | atomic64_set(&new->inodes_count, 0); |
832 | atomic64_set(&new->blocks_count, 0); | |
ba65ae47 RK |
833 | |
834 | rb_link_node(&new->rb_node, parent, p); | |
835 | rb_insert_color(&new->rb_node, &nilfs->ns_cptree); | |
836 | ||
837 | spin_unlock(&nilfs->ns_cptree_lock); | |
838 | ||
dd70edbd VD |
839 | err = nilfs_sysfs_create_snapshot_group(new); |
840 | if (err) { | |
841 | kfree(new); | |
842 | new = NULL; | |
843 | } | |
844 | ||
ba65ae47 RK |
845 | return new; |
846 | } | |
847 | ||
848 | void nilfs_put_root(struct nilfs_root *root) | |
849 | { | |
98e2e409 | 850 | struct the_nilfs *nilfs = root->nilfs; |
ba65ae47 | 851 | |
98e2e409 | 852 | if (refcount_dec_and_lock(&root->count, &nilfs->ns_cptree_lock)) { |
ba65ae47 RK |
853 | rb_erase(&root->rb_node, &nilfs->ns_cptree); |
854 | spin_unlock(&nilfs->ns_cptree_lock); | |
98e2e409 ZL |
855 | |
856 | nilfs_sysfs_delete_snapshot_group(root); | |
72b9918e | 857 | iput(root->ifile); |
ba65ae47 RK |
858 | |
859 | kfree(root); | |
860 | } | |
8a9d2191 | 861 | } |