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