1 | // SPDX-License-Identifier: GPL-2.0+ |
2 | /* |
3 | * NILFS recovery logic |
4 | * |
5 | * Copyright (C) 2005-2008 Nippon Telegraph and Telephone Corporation. |
6 | * |
7 | * Written by Ryusuke Konishi. |
8 | */ |
9 | |
10 | #include <linux/buffer_head.h> |
11 | #include <linux/blkdev.h> |
12 | #include <linux/swap.h> |
13 | #include <linux/slab.h> |
14 | #include <linux/crc32.h> |
15 | #include "nilfs.h" |
16 | #include "segment.h" |
17 | #include "sufile.h" |
18 | #include "page.h" |
19 | #include "segbuf.h" |
20 | |
21 | /* |
22 | * Segment check result |
23 | */ |
24 | enum { |
25 | NILFS_SEG_VALID, |
26 | NILFS_SEG_NO_SUPER_ROOT, |
27 | NILFS_SEG_FAIL_IO, |
28 | NILFS_SEG_FAIL_MAGIC, |
29 | NILFS_SEG_FAIL_SEQ, |
30 | NILFS_SEG_FAIL_CHECKSUM_SUPER_ROOT, |
31 | NILFS_SEG_FAIL_CHECKSUM_FULL, |
32 | NILFS_SEG_FAIL_CONSISTENCY, |
33 | }; |
34 | |
35 | /* work structure for recovery */ |
36 | struct nilfs_recovery_block { |
37 | ino_t ino; /* |
38 | * Inode number of the file that this block |
39 | * belongs to |
40 | */ |
41 | sector_t blocknr; /* block number */ |
42 | __u64 vblocknr; /* virtual block number */ |
43 | unsigned long blkoff; /* File offset of the data block (per block) */ |
44 | struct list_head list; |
45 | }; |
46 | |
47 | |
48 | static int nilfs_warn_segment_error(struct super_block *sb, int err) |
49 | { |
50 | const char *msg = NULL; |
51 | |
52 | switch (err) { |
53 | case NILFS_SEG_FAIL_IO: |
54 | nilfs_err(sb, "I/O error reading segment" ); |
55 | return -EIO; |
56 | case NILFS_SEG_FAIL_MAGIC: |
57 | msg = "Magic number mismatch" ; |
58 | break; |
59 | case NILFS_SEG_FAIL_SEQ: |
60 | msg = "Sequence number mismatch" ; |
61 | break; |
62 | case NILFS_SEG_FAIL_CHECKSUM_SUPER_ROOT: |
63 | msg = "Checksum error in super root" ; |
64 | break; |
65 | case NILFS_SEG_FAIL_CHECKSUM_FULL: |
66 | msg = "Checksum error in segment payload" ; |
67 | break; |
68 | case NILFS_SEG_FAIL_CONSISTENCY: |
69 | msg = "Inconsistency found" ; |
70 | break; |
71 | case NILFS_SEG_NO_SUPER_ROOT: |
72 | msg = "No super root in the last segment" ; |
73 | break; |
74 | default: |
75 | nilfs_err(sb, "unrecognized segment error %d" , err); |
76 | return -EINVAL; |
77 | } |
78 | nilfs_warn(sb, "invalid segment: %s" , msg); |
79 | return -EINVAL; |
80 | } |
81 | |
82 | /** |
83 | * nilfs_compute_checksum - compute checksum of blocks continuously |
84 | * @nilfs: nilfs object |
85 | * @bhs: buffer head of start block |
86 | * @sum: place to store result |
87 | * @offset: offset bytes in the first block |
88 | * @check_bytes: number of bytes to be checked |
89 | * @start: DBN of start block |
90 | * @nblock: number of blocks to be checked |
91 | */ |
92 | static int nilfs_compute_checksum(struct the_nilfs *nilfs, |
93 | struct buffer_head *bhs, u32 *sum, |
94 | unsigned long offset, u64 check_bytes, |
95 | sector_t start, unsigned long nblock) |
96 | { |
97 | unsigned int blocksize = nilfs->ns_blocksize; |
98 | unsigned long size; |
99 | u32 crc; |
100 | |
101 | BUG_ON(offset >= blocksize); |
102 | check_bytes -= offset; |
103 | size = min_t(u64, check_bytes, blocksize - offset); |
104 | crc = crc32_le(crc: nilfs->ns_crc_seed, |
105 | p: (unsigned char *)bhs->b_data + offset, len: size); |
106 | if (--nblock > 0) { |
107 | do { |
108 | struct buffer_head *bh; |
109 | |
110 | bh = __bread(bdev: nilfs->ns_bdev, block: ++start, size: blocksize); |
111 | if (!bh) |
112 | return -EIO; |
113 | check_bytes -= size; |
114 | size = min_t(u64, check_bytes, blocksize); |
115 | crc = crc32_le(crc, p: bh->b_data, len: size); |
116 | brelse(bh); |
117 | } while (--nblock > 0); |
118 | } |
119 | *sum = crc; |
120 | return 0; |
121 | } |
122 | |
123 | /** |
124 | * nilfs_read_super_root_block - read super root block |
125 | * @nilfs: nilfs object |
126 | * @sr_block: disk block number of the super root block |
127 | * @pbh: address of a buffer_head pointer to return super root buffer |
128 | * @check: CRC check flag |
129 | */ |
130 | int nilfs_read_super_root_block(struct the_nilfs *nilfs, sector_t sr_block, |
131 | struct buffer_head **pbh, int check) |
132 | { |
133 | struct buffer_head *bh_sr; |
134 | struct nilfs_super_root *sr; |
135 | u32 crc; |
136 | int ret; |
137 | |
138 | *pbh = NULL; |
139 | bh_sr = __bread(bdev: nilfs->ns_bdev, block: sr_block, size: nilfs->ns_blocksize); |
140 | if (unlikely(!bh_sr)) { |
141 | ret = NILFS_SEG_FAIL_IO; |
142 | goto failed; |
143 | } |
144 | |
145 | sr = (struct nilfs_super_root *)bh_sr->b_data; |
146 | if (check) { |
147 | unsigned int bytes = le16_to_cpu(sr->sr_bytes); |
148 | |
149 | if (bytes == 0 || bytes > nilfs->ns_blocksize) { |
150 | ret = NILFS_SEG_FAIL_CHECKSUM_SUPER_ROOT; |
151 | goto failed_bh; |
152 | } |
153 | if (nilfs_compute_checksum( |
154 | nilfs, bhs: bh_sr, sum: &crc, offset: sizeof(sr->sr_sum), check_bytes: bytes, |
155 | start: sr_block, nblock: 1)) { |
156 | ret = NILFS_SEG_FAIL_IO; |
157 | goto failed_bh; |
158 | } |
159 | if (crc != le32_to_cpu(sr->sr_sum)) { |
160 | ret = NILFS_SEG_FAIL_CHECKSUM_SUPER_ROOT; |
161 | goto failed_bh; |
162 | } |
163 | } |
164 | *pbh = bh_sr; |
165 | return 0; |
166 | |
167 | failed_bh: |
168 | brelse(bh: bh_sr); |
169 | |
170 | failed: |
171 | return nilfs_warn_segment_error(sb: nilfs->ns_sb, err: ret); |
172 | } |
173 | |
174 | /** |
175 | * nilfs_read_log_header - read summary header of the specified log |
176 | * @nilfs: nilfs object |
177 | * @start_blocknr: start block number of the log |
178 | * @sum: pointer to return segment summary structure |
179 | */ |
180 | static struct buffer_head * |
181 | (struct the_nilfs *nilfs, sector_t start_blocknr, |
182 | struct nilfs_segment_summary **sum) |
183 | { |
184 | struct buffer_head *bh_sum; |
185 | |
186 | bh_sum = __bread(bdev: nilfs->ns_bdev, block: start_blocknr, size: nilfs->ns_blocksize); |
187 | if (bh_sum) |
188 | *sum = (struct nilfs_segment_summary *)bh_sum->b_data; |
189 | return bh_sum; |
190 | } |
191 | |
192 | /** |
193 | * nilfs_validate_log - verify consistency of log |
194 | * @nilfs: nilfs object |
195 | * @seg_seq: sequence number of segment |
196 | * @bh_sum: buffer head of summary block |
197 | * @sum: segment summary struct |
198 | */ |
199 | static int nilfs_validate_log(struct the_nilfs *nilfs, u64 seg_seq, |
200 | struct buffer_head *bh_sum, |
201 | struct nilfs_segment_summary *sum) |
202 | { |
203 | unsigned long nblock; |
204 | u32 crc; |
205 | int ret; |
206 | |
207 | ret = NILFS_SEG_FAIL_MAGIC; |
208 | if (le32_to_cpu(sum->ss_magic) != NILFS_SEGSUM_MAGIC) |
209 | goto out; |
210 | |
211 | ret = NILFS_SEG_FAIL_SEQ; |
212 | if (le64_to_cpu(sum->ss_seq) != seg_seq) |
213 | goto out; |
214 | |
215 | nblock = le32_to_cpu(sum->ss_nblocks); |
216 | ret = NILFS_SEG_FAIL_CONSISTENCY; |
217 | if (unlikely(nblock == 0 || nblock > nilfs->ns_blocks_per_segment)) |
218 | /* This limits the number of blocks read in the CRC check */ |
219 | goto out; |
220 | |
221 | ret = NILFS_SEG_FAIL_IO; |
222 | if (nilfs_compute_checksum(nilfs, bhs: bh_sum, sum: &crc, offset: sizeof(sum->ss_datasum), |
223 | check_bytes: ((u64)nblock << nilfs->ns_blocksize_bits), |
224 | start: bh_sum->b_blocknr, nblock)) |
225 | goto out; |
226 | |
227 | ret = NILFS_SEG_FAIL_CHECKSUM_FULL; |
228 | if (crc != le32_to_cpu(sum->ss_datasum)) |
229 | goto out; |
230 | ret = 0; |
231 | out: |
232 | return ret; |
233 | } |
234 | |
235 | /** |
236 | * nilfs_read_summary_info - read an item on summary blocks of a log |
237 | * @nilfs: nilfs object |
238 | * @pbh: the current buffer head on summary blocks [in, out] |
239 | * @offset: the current byte offset on summary blocks [in, out] |
240 | * @bytes: byte size of the item to be read |
241 | */ |
242 | static void *nilfs_read_summary_info(struct the_nilfs *nilfs, |
243 | struct buffer_head **pbh, |
244 | unsigned int *offset, unsigned int bytes) |
245 | { |
246 | void *ptr; |
247 | sector_t blocknr; |
248 | |
249 | BUG_ON((*pbh)->b_size < *offset); |
250 | if (bytes > (*pbh)->b_size - *offset) { |
251 | blocknr = (*pbh)->b_blocknr; |
252 | brelse(bh: *pbh); |
253 | *pbh = __bread(bdev: nilfs->ns_bdev, block: blocknr + 1, |
254 | size: nilfs->ns_blocksize); |
255 | if (unlikely(!*pbh)) |
256 | return NULL; |
257 | *offset = 0; |
258 | } |
259 | ptr = (*pbh)->b_data + *offset; |
260 | *offset += bytes; |
261 | return ptr; |
262 | } |
263 | |
264 | /** |
265 | * nilfs_skip_summary_info - skip items on summary blocks of a log |
266 | * @nilfs: nilfs object |
267 | * @pbh: the current buffer head on summary blocks [in, out] |
268 | * @offset: the current byte offset on summary blocks [in, out] |
269 | * @bytes: byte size of the item to be skipped |
270 | * @count: number of items to be skipped |
271 | */ |
272 | static void nilfs_skip_summary_info(struct the_nilfs *nilfs, |
273 | struct buffer_head **pbh, |
274 | unsigned int *offset, unsigned int bytes, |
275 | unsigned long count) |
276 | { |
277 | unsigned int rest_item_in_current_block |
278 | = ((*pbh)->b_size - *offset) / bytes; |
279 | |
280 | if (count <= rest_item_in_current_block) { |
281 | *offset += bytes * count; |
282 | } else { |
283 | sector_t blocknr = (*pbh)->b_blocknr; |
284 | unsigned int nitem_per_block = (*pbh)->b_size / bytes; |
285 | unsigned int bcnt; |
286 | |
287 | count -= rest_item_in_current_block; |
288 | bcnt = DIV_ROUND_UP(count, nitem_per_block); |
289 | *offset = bytes * (count - (bcnt - 1) * nitem_per_block); |
290 | |
291 | brelse(bh: *pbh); |
292 | *pbh = __bread(bdev: nilfs->ns_bdev, block: blocknr + bcnt, |
293 | size: nilfs->ns_blocksize); |
294 | } |
295 | } |
296 | |
297 | /** |
298 | * nilfs_scan_dsync_log - get block information of a log written for data sync |
299 | * @nilfs: nilfs object |
300 | * @start_blocknr: start block number of the log |
301 | * @sum: log summary information |
302 | * @head: list head to add nilfs_recovery_block struct |
303 | */ |
304 | static int nilfs_scan_dsync_log(struct the_nilfs *nilfs, sector_t start_blocknr, |
305 | struct nilfs_segment_summary *sum, |
306 | struct list_head *head) |
307 | { |
308 | struct buffer_head *bh; |
309 | unsigned int offset; |
310 | u32 nfinfo, sumbytes; |
311 | sector_t blocknr; |
312 | ino_t ino; |
313 | int err = -EIO; |
314 | |
315 | nfinfo = le32_to_cpu(sum->ss_nfinfo); |
316 | if (!nfinfo) |
317 | return 0; |
318 | |
319 | sumbytes = le32_to_cpu(sum->ss_sumbytes); |
320 | blocknr = start_blocknr + DIV_ROUND_UP(sumbytes, nilfs->ns_blocksize); |
321 | bh = __bread(bdev: nilfs->ns_bdev, block: start_blocknr, size: nilfs->ns_blocksize); |
322 | if (unlikely(!bh)) |
323 | goto out; |
324 | |
325 | offset = le16_to_cpu(sum->ss_bytes); |
326 | for (;;) { |
327 | unsigned long nblocks, ndatablk, nnodeblk; |
328 | struct nilfs_finfo *finfo; |
329 | |
330 | finfo = nilfs_read_summary_info(nilfs, pbh: &bh, offset: &offset, |
331 | bytes: sizeof(*finfo)); |
332 | if (unlikely(!finfo)) |
333 | goto out; |
334 | |
335 | ino = le64_to_cpu(finfo->fi_ino); |
336 | nblocks = le32_to_cpu(finfo->fi_nblocks); |
337 | ndatablk = le32_to_cpu(finfo->fi_ndatablk); |
338 | nnodeblk = nblocks - ndatablk; |
339 | |
340 | while (ndatablk-- > 0) { |
341 | struct nilfs_recovery_block *rb; |
342 | struct nilfs_binfo_v *binfo; |
343 | |
344 | binfo = nilfs_read_summary_info(nilfs, pbh: &bh, offset: &offset, |
345 | bytes: sizeof(*binfo)); |
346 | if (unlikely(!binfo)) |
347 | goto out; |
348 | |
349 | rb = kmalloc(size: sizeof(*rb), GFP_NOFS); |
350 | if (unlikely(!rb)) { |
351 | err = -ENOMEM; |
352 | goto out; |
353 | } |
354 | rb->ino = ino; |
355 | rb->blocknr = blocknr++; |
356 | rb->vblocknr = le64_to_cpu(binfo->bi_vblocknr); |
357 | rb->blkoff = le64_to_cpu(binfo->bi_blkoff); |
358 | /* INIT_LIST_HEAD(&rb->list); */ |
359 | list_add_tail(new: &rb->list, head); |
360 | } |
361 | if (--nfinfo == 0) |
362 | break; |
363 | blocknr += nnodeblk; /* always 0 for data sync logs */ |
364 | nilfs_skip_summary_info(nilfs, pbh: &bh, offset: &offset, bytes: sizeof(__le64), |
365 | count: nnodeblk); |
366 | if (unlikely(!bh)) |
367 | goto out; |
368 | } |
369 | err = 0; |
370 | out: |
371 | brelse(bh); /* brelse(NULL) is just ignored */ |
372 | return err; |
373 | } |
374 | |
375 | static void dispose_recovery_list(struct list_head *head) |
376 | { |
377 | while (!list_empty(head)) { |
378 | struct nilfs_recovery_block *rb; |
379 | |
380 | rb = list_first_entry(head, struct nilfs_recovery_block, list); |
381 | list_del(entry: &rb->list); |
382 | kfree(objp: rb); |
383 | } |
384 | } |
385 | |
386 | struct nilfs_segment_entry { |
387 | struct list_head list; |
388 | __u64 segnum; |
389 | }; |
390 | |
391 | static int nilfs_segment_list_add(struct list_head *head, __u64 segnum) |
392 | { |
393 | struct nilfs_segment_entry *ent = kmalloc(size: sizeof(*ent), GFP_NOFS); |
394 | |
395 | if (unlikely(!ent)) |
396 | return -ENOMEM; |
397 | |
398 | ent->segnum = segnum; |
399 | INIT_LIST_HEAD(list: &ent->list); |
400 | list_add_tail(new: &ent->list, head); |
401 | return 0; |
402 | } |
403 | |
404 | void nilfs_dispose_segment_list(struct list_head *head) |
405 | { |
406 | while (!list_empty(head)) { |
407 | struct nilfs_segment_entry *ent; |
408 | |
409 | ent = list_first_entry(head, struct nilfs_segment_entry, list); |
410 | list_del(entry: &ent->list); |
411 | kfree(objp: ent); |
412 | } |
413 | } |
414 | |
415 | static int nilfs_prepare_segment_for_recovery(struct the_nilfs *nilfs, |
416 | struct super_block *sb, |
417 | struct nilfs_recovery_info *ri) |
418 | { |
419 | struct list_head *head = &ri->ri_used_segments; |
420 | struct nilfs_segment_entry *ent, *n; |
421 | struct inode *sufile = nilfs->ns_sufile; |
422 | __u64 segnum[4]; |
423 | int err; |
424 | int i; |
425 | |
426 | segnum[0] = nilfs->ns_segnum; |
427 | segnum[1] = nilfs->ns_nextnum; |
428 | segnum[2] = ri->ri_segnum; |
429 | segnum[3] = ri->ri_nextnum; |
430 | |
431 | /* |
432 | * Releasing the next segment of the latest super root. |
433 | * The next segment is invalidated by this recovery. |
434 | */ |
435 | err = nilfs_sufile_free(sufile, segnum: segnum[1]); |
436 | if (unlikely(err)) |
437 | goto failed; |
438 | |
439 | for (i = 1; i < 4; i++) { |
440 | err = nilfs_segment_list_add(head, segnum: segnum[i]); |
441 | if (unlikely(err)) |
442 | goto failed; |
443 | } |
444 | |
445 | /* |
446 | * Collecting segments written after the latest super root. |
447 | * These are marked dirty to avoid being reallocated in the next write. |
448 | */ |
449 | list_for_each_entry_safe(ent, n, head, list) { |
450 | if (ent->segnum != segnum[0]) { |
451 | err = nilfs_sufile_scrap(sufile, segnum: ent->segnum); |
452 | if (unlikely(err)) |
453 | goto failed; |
454 | } |
455 | list_del(entry: &ent->list); |
456 | kfree(objp: ent); |
457 | } |
458 | |
459 | /* Allocate new segments for recovery */ |
460 | err = nilfs_sufile_alloc(sufile, &segnum[0]); |
461 | if (unlikely(err)) |
462 | goto failed; |
463 | |
464 | nilfs->ns_pseg_offset = 0; |
465 | nilfs->ns_seg_seq = ri->ri_seq + 2; |
466 | nilfs->ns_nextnum = nilfs->ns_segnum = segnum[0]; |
467 | |
468 | failed: |
469 | /* No need to recover sufile because it will be destroyed on error */ |
470 | return err; |
471 | } |
472 | |
473 | static int nilfs_recovery_copy_block(struct the_nilfs *nilfs, |
474 | struct nilfs_recovery_block *rb, |
475 | loff_t pos, struct page *page) |
476 | { |
477 | struct buffer_head *bh_org; |
478 | size_t from = pos & ~PAGE_MASK; |
479 | void *kaddr; |
480 | |
481 | bh_org = __bread(bdev: nilfs->ns_bdev, block: rb->blocknr, size: nilfs->ns_blocksize); |
482 | if (unlikely(!bh_org)) |
483 | return -EIO; |
484 | |
485 | kaddr = kmap_local_page(page); |
486 | memcpy(kaddr + from, bh_org->b_data, bh_org->b_size); |
487 | kunmap_local(kaddr); |
488 | brelse(bh: bh_org); |
489 | return 0; |
490 | } |
491 | |
492 | static int nilfs_recover_dsync_blocks(struct the_nilfs *nilfs, |
493 | struct super_block *sb, |
494 | struct nilfs_root *root, |
495 | struct list_head *head, |
496 | unsigned long *nr_salvaged_blocks) |
497 | { |
498 | struct inode *inode; |
499 | struct nilfs_recovery_block *rb, *n; |
500 | unsigned int blocksize = nilfs->ns_blocksize; |
501 | struct page *page; |
502 | loff_t pos; |
503 | int err = 0, err2 = 0; |
504 | |
505 | list_for_each_entry_safe(rb, n, head, list) { |
506 | inode = nilfs_iget(sb, root, ino: rb->ino); |
507 | if (IS_ERR(ptr: inode)) { |
508 | err = PTR_ERR(ptr: inode); |
509 | inode = NULL; |
510 | goto failed_inode; |
511 | } |
512 | |
513 | pos = rb->blkoff << inode->i_blkbits; |
514 | err = block_write_begin(mapping: inode->i_mapping, pos, len: blocksize, |
515 | pagep: &page, get_block: nilfs_get_block); |
516 | if (unlikely(err)) { |
517 | loff_t isize = inode->i_size; |
518 | |
519 | if (pos + blocksize > isize) |
520 | nilfs_write_failed(mapping: inode->i_mapping, |
521 | to: pos + blocksize); |
522 | goto failed_inode; |
523 | } |
524 | |
525 | err = nilfs_recovery_copy_block(nilfs, rb, pos, page); |
526 | if (unlikely(err)) |
527 | goto failed_page; |
528 | |
529 | err = nilfs_set_file_dirty(inode, nr_dirty: 1); |
530 | if (unlikely(err)) |
531 | goto failed_page; |
532 | |
533 | block_write_end(NULL, inode->i_mapping, pos, blocksize, |
534 | blocksize, page, NULL); |
535 | |
536 | unlock_page(page); |
537 | put_page(page); |
538 | |
539 | (*nr_salvaged_blocks)++; |
540 | goto next; |
541 | |
542 | failed_page: |
543 | unlock_page(page); |
544 | put_page(page); |
545 | |
546 | failed_inode: |
547 | nilfs_warn(sb, |
548 | "error %d recovering data block (ino=%lu, block-offset=%llu)" , |
549 | err, (unsigned long)rb->ino, |
550 | (unsigned long long)rb->blkoff); |
551 | if (!err2) |
552 | err2 = err; |
553 | next: |
554 | iput(inode); /* iput(NULL) is just ignored */ |
555 | list_del_init(entry: &rb->list); |
556 | kfree(objp: rb); |
557 | } |
558 | return err2; |
559 | } |
560 | |
561 | /** |
562 | * nilfs_do_roll_forward - salvage logical segments newer than the latest |
563 | * checkpoint |
564 | * @nilfs: nilfs object |
565 | * @sb: super block instance |
566 | * @ri: pointer to a nilfs_recovery_info |
567 | */ |
568 | static int nilfs_do_roll_forward(struct the_nilfs *nilfs, |
569 | struct super_block *sb, |
570 | struct nilfs_root *root, |
571 | struct nilfs_recovery_info *ri) |
572 | { |
573 | struct buffer_head *bh_sum = NULL; |
574 | struct nilfs_segment_summary *sum = NULL; |
575 | sector_t pseg_start; |
576 | sector_t seg_start, seg_end; /* Starting/ending DBN of full segment */ |
577 | unsigned long nsalvaged_blocks = 0; |
578 | unsigned int flags; |
579 | u64 seg_seq; |
580 | __u64 segnum, nextnum = 0; |
581 | int empty_seg = 0; |
582 | int err = 0, ret; |
583 | LIST_HEAD(dsync_blocks); /* list of data blocks to be recovered */ |
584 | enum { |
585 | RF_INIT_ST, |
586 | RF_DSYNC_ST, /* scanning data-sync segments */ |
587 | }; |
588 | int state = RF_INIT_ST; |
589 | |
590 | pseg_start = ri->ri_lsegs_start; |
591 | seg_seq = ri->ri_lsegs_start_seq; |
592 | segnum = nilfs_get_segnum_of_block(nilfs, blocknr: pseg_start); |
593 | nilfs_get_segment_range(nilfs, segnum, seg_start: &seg_start, seg_end: &seg_end); |
594 | |
595 | while (segnum != ri->ri_segnum || pseg_start <= ri->ri_pseg_start) { |
596 | brelse(bh: bh_sum); |
597 | bh_sum = nilfs_read_log_header(nilfs, start_blocknr: pseg_start, sum: &sum); |
598 | if (!bh_sum) { |
599 | err = -EIO; |
600 | goto failed; |
601 | } |
602 | |
603 | ret = nilfs_validate_log(nilfs, seg_seq, bh_sum, sum); |
604 | if (ret) { |
605 | if (ret == NILFS_SEG_FAIL_IO) { |
606 | err = -EIO; |
607 | goto failed; |
608 | } |
609 | goto strayed; |
610 | } |
611 | |
612 | flags = le16_to_cpu(sum->ss_flags); |
613 | if (flags & NILFS_SS_SR) |
614 | goto confused; |
615 | |
616 | /* Found a valid partial segment; do recovery actions */ |
617 | nextnum = nilfs_get_segnum_of_block(nilfs, |
618 | le64_to_cpu(sum->ss_next)); |
619 | empty_seg = 0; |
620 | nilfs->ns_ctime = le64_to_cpu(sum->ss_create); |
621 | if (!(flags & NILFS_SS_GC)) |
622 | nilfs->ns_nongc_ctime = nilfs->ns_ctime; |
623 | |
624 | switch (state) { |
625 | case RF_INIT_ST: |
626 | if (!(flags & NILFS_SS_LOGBGN) || |
627 | !(flags & NILFS_SS_SYNDT)) |
628 | goto try_next_pseg; |
629 | state = RF_DSYNC_ST; |
630 | fallthrough; |
631 | case RF_DSYNC_ST: |
632 | if (!(flags & NILFS_SS_SYNDT)) |
633 | goto confused; |
634 | |
635 | err = nilfs_scan_dsync_log(nilfs, start_blocknr: pseg_start, sum, |
636 | head: &dsync_blocks); |
637 | if (unlikely(err)) |
638 | goto failed; |
639 | if (flags & NILFS_SS_LOGEND) { |
640 | err = nilfs_recover_dsync_blocks( |
641 | nilfs, sb, root, head: &dsync_blocks, |
642 | nr_salvaged_blocks: &nsalvaged_blocks); |
643 | if (unlikely(err)) |
644 | goto failed; |
645 | state = RF_INIT_ST; |
646 | } |
647 | break; /* Fall through to try_next_pseg */ |
648 | } |
649 | |
650 | try_next_pseg: |
651 | if (pseg_start == ri->ri_lsegs_end) |
652 | break; |
653 | pseg_start += le32_to_cpu(sum->ss_nblocks); |
654 | if (pseg_start < seg_end) |
655 | continue; |
656 | goto feed_segment; |
657 | |
658 | strayed: |
659 | if (pseg_start == ri->ri_lsegs_end) |
660 | break; |
661 | |
662 | feed_segment: |
663 | /* Looking to the next full segment */ |
664 | if (empty_seg++) |
665 | break; |
666 | seg_seq++; |
667 | segnum = nextnum; |
668 | nilfs_get_segment_range(nilfs, segnum, seg_start: &seg_start, seg_end: &seg_end); |
669 | pseg_start = seg_start; |
670 | } |
671 | |
672 | if (nsalvaged_blocks) { |
673 | nilfs_info(sb, "salvaged %lu blocks" , nsalvaged_blocks); |
674 | ri->ri_need_recovery = NILFS_RECOVERY_ROLLFORWARD_DONE; |
675 | } |
676 | out: |
677 | brelse(bh: bh_sum); |
678 | dispose_recovery_list(head: &dsync_blocks); |
679 | return err; |
680 | |
681 | confused: |
682 | err = -EINVAL; |
683 | failed: |
684 | nilfs_err(sb, |
685 | "error %d roll-forwarding partial segment at blocknr = %llu" , |
686 | err, (unsigned long long)pseg_start); |
687 | goto out; |
688 | } |
689 | |
690 | static void nilfs_finish_roll_forward(struct the_nilfs *nilfs, |
691 | struct nilfs_recovery_info *ri) |
692 | { |
693 | struct buffer_head *bh; |
694 | int err; |
695 | |
696 | if (nilfs_get_segnum_of_block(nilfs, blocknr: ri->ri_lsegs_start) != |
697 | nilfs_get_segnum_of_block(nilfs, blocknr: ri->ri_super_root)) |
698 | return; |
699 | |
700 | bh = __getblk(bdev: nilfs->ns_bdev, block: ri->ri_lsegs_start, size: nilfs->ns_blocksize); |
701 | BUG_ON(!bh); |
702 | memset(bh->b_data, 0, bh->b_size); |
703 | set_buffer_dirty(bh); |
704 | err = sync_dirty_buffer(bh); |
705 | if (unlikely(err)) |
706 | nilfs_warn(nilfs->ns_sb, |
707 | "buffer sync write failed during post-cleaning of recovery." ); |
708 | brelse(bh); |
709 | } |
710 | |
711 | /** |
712 | * nilfs_salvage_orphan_logs - salvage logs written after the latest checkpoint |
713 | * @nilfs: nilfs object |
714 | * @sb: super block instance |
715 | * @ri: pointer to a nilfs_recovery_info struct to store search results. |
716 | * |
717 | * Return Value: On success, 0 is returned. On error, one of the following |
718 | * negative error code is returned. |
719 | * |
720 | * %-EINVAL - Inconsistent filesystem state. |
721 | * |
722 | * %-EIO - I/O error |
723 | * |
724 | * %-ENOSPC - No space left on device (only in a panic state). |
725 | * |
726 | * %-ERESTARTSYS - Interrupted. |
727 | * |
728 | * %-ENOMEM - Insufficient memory available. |
729 | */ |
730 | int nilfs_salvage_orphan_logs(struct the_nilfs *nilfs, |
731 | struct super_block *sb, |
732 | struct nilfs_recovery_info *ri) |
733 | { |
734 | struct nilfs_root *root; |
735 | int err; |
736 | |
737 | if (ri->ri_lsegs_start == 0 || ri->ri_lsegs_end == 0) |
738 | return 0; |
739 | |
740 | err = nilfs_attach_checkpoint(sb, cno: ri->ri_cno, curr_mnt: true, root: &root); |
741 | if (unlikely(err)) { |
742 | nilfs_err(sb, "error %d loading the latest checkpoint" , err); |
743 | return err; |
744 | } |
745 | |
746 | err = nilfs_do_roll_forward(nilfs, sb, root, ri); |
747 | if (unlikely(err)) |
748 | goto failed; |
749 | |
750 | if (ri->ri_need_recovery == NILFS_RECOVERY_ROLLFORWARD_DONE) { |
751 | err = nilfs_prepare_segment_for_recovery(nilfs, sb, ri); |
752 | if (unlikely(err)) { |
753 | nilfs_err(sb, "error %d preparing segment for recovery" , |
754 | err); |
755 | goto failed; |
756 | } |
757 | |
758 | err = nilfs_attach_log_writer(sb, root); |
759 | if (unlikely(err)) |
760 | goto failed; |
761 | |
762 | set_nilfs_discontinued(nilfs); |
763 | err = nilfs_construct_segment(sb); |
764 | nilfs_detach_log_writer(sb); |
765 | |
766 | if (unlikely(err)) { |
767 | nilfs_err(sb, "error %d writing segment for recovery" , |
768 | err); |
769 | goto failed; |
770 | } |
771 | |
772 | nilfs_finish_roll_forward(nilfs, ri); |
773 | } |
774 | |
775 | failed: |
776 | nilfs_put_root(root); |
777 | return err; |
778 | } |
779 | |
780 | /** |
781 | * nilfs_search_super_root - search the latest valid super root |
782 | * @nilfs: the_nilfs |
783 | * @ri: pointer to a nilfs_recovery_info struct to store search results. |
784 | * |
785 | * nilfs_search_super_root() looks for the latest super-root from a partial |
786 | * segment pointed by the superblock. It sets up struct the_nilfs through |
787 | * this search. It fills nilfs_recovery_info (ri) required for recovery. |
788 | * |
789 | * Return Value: On success, 0 is returned. On error, one of the following |
790 | * negative error code is returned. |
791 | * |
792 | * %-EINVAL - No valid segment found |
793 | * |
794 | * %-EIO - I/O error |
795 | * |
796 | * %-ENOMEM - Insufficient memory available. |
797 | */ |
798 | int nilfs_search_super_root(struct the_nilfs *nilfs, |
799 | struct nilfs_recovery_info *ri) |
800 | { |
801 | struct buffer_head *bh_sum = NULL; |
802 | struct nilfs_segment_summary *sum = NULL; |
803 | sector_t pseg_start, pseg_end, sr_pseg_start = 0; |
804 | sector_t seg_start, seg_end; /* range of full segment (block number) */ |
805 | sector_t b, end; |
806 | unsigned long nblocks; |
807 | unsigned int flags; |
808 | u64 seg_seq; |
809 | __u64 segnum, nextnum = 0; |
810 | __u64 cno; |
811 | LIST_HEAD(segments); |
812 | int empty_seg = 0, scan_newer = 0; |
813 | int ret; |
814 | |
815 | pseg_start = nilfs->ns_last_pseg; |
816 | seg_seq = nilfs->ns_last_seq; |
817 | cno = nilfs->ns_last_cno; |
818 | segnum = nilfs_get_segnum_of_block(nilfs, blocknr: pseg_start); |
819 | |
820 | /* Calculate range of segment */ |
821 | nilfs_get_segment_range(nilfs, segnum, seg_start: &seg_start, seg_end: &seg_end); |
822 | |
823 | /* Read ahead segment */ |
824 | b = seg_start; |
825 | while (b <= seg_end) |
826 | __breadahead(nilfs->ns_bdev, block: b++, size: nilfs->ns_blocksize); |
827 | |
828 | for (;;) { |
829 | brelse(bh: bh_sum); |
830 | ret = NILFS_SEG_FAIL_IO; |
831 | bh_sum = nilfs_read_log_header(nilfs, start_blocknr: pseg_start, sum: &sum); |
832 | if (!bh_sum) |
833 | goto failed; |
834 | |
835 | ret = nilfs_validate_log(nilfs, seg_seq, bh_sum, sum); |
836 | if (ret) { |
837 | if (ret == NILFS_SEG_FAIL_IO) |
838 | goto failed; |
839 | goto strayed; |
840 | } |
841 | |
842 | nblocks = le32_to_cpu(sum->ss_nblocks); |
843 | pseg_end = pseg_start + nblocks - 1; |
844 | if (unlikely(pseg_end > seg_end)) { |
845 | ret = NILFS_SEG_FAIL_CONSISTENCY; |
846 | goto strayed; |
847 | } |
848 | |
849 | /* A valid partial segment */ |
850 | ri->ri_pseg_start = pseg_start; |
851 | ri->ri_seq = seg_seq; |
852 | ri->ri_segnum = segnum; |
853 | nextnum = nilfs_get_segnum_of_block(nilfs, |
854 | le64_to_cpu(sum->ss_next)); |
855 | ri->ri_nextnum = nextnum; |
856 | empty_seg = 0; |
857 | |
858 | flags = le16_to_cpu(sum->ss_flags); |
859 | if (!(flags & NILFS_SS_SR) && !scan_newer) { |
860 | /* |
861 | * This will never happen because a superblock |
862 | * (last_segment) always points to a pseg with |
863 | * a super root. |
864 | */ |
865 | ret = NILFS_SEG_FAIL_CONSISTENCY; |
866 | goto failed; |
867 | } |
868 | |
869 | if (pseg_start == seg_start) { |
870 | nilfs_get_segment_range(nilfs, segnum: nextnum, seg_start: &b, seg_end: &end); |
871 | while (b <= end) |
872 | __breadahead(nilfs->ns_bdev, block: b++, |
873 | size: nilfs->ns_blocksize); |
874 | } |
875 | if (!(flags & NILFS_SS_SR)) { |
876 | if (!ri->ri_lsegs_start && (flags & NILFS_SS_LOGBGN)) { |
877 | ri->ri_lsegs_start = pseg_start; |
878 | ri->ri_lsegs_start_seq = seg_seq; |
879 | } |
880 | if (flags & NILFS_SS_LOGEND) |
881 | ri->ri_lsegs_end = pseg_start; |
882 | goto try_next_pseg; |
883 | } |
884 | |
885 | /* A valid super root was found. */ |
886 | ri->ri_cno = cno++; |
887 | ri->ri_super_root = pseg_end; |
888 | ri->ri_lsegs_start = ri->ri_lsegs_end = 0; |
889 | |
890 | nilfs_dispose_segment_list(head: &segments); |
891 | sr_pseg_start = pseg_start; |
892 | nilfs->ns_pseg_offset = pseg_start + nblocks - seg_start; |
893 | nilfs->ns_seg_seq = seg_seq; |
894 | nilfs->ns_segnum = segnum; |
895 | nilfs->ns_cno = cno; /* nilfs->ns_cno = ri->ri_cno + 1 */ |
896 | nilfs->ns_ctime = le64_to_cpu(sum->ss_create); |
897 | nilfs->ns_nextnum = nextnum; |
898 | |
899 | if (scan_newer) |
900 | ri->ri_need_recovery = NILFS_RECOVERY_SR_UPDATED; |
901 | else { |
902 | if (nilfs->ns_mount_state & NILFS_VALID_FS) |
903 | goto super_root_found; |
904 | scan_newer = 1; |
905 | } |
906 | |
907 | try_next_pseg: |
908 | /* Standing on a course, or met an inconsistent state */ |
909 | pseg_start += nblocks; |
910 | if (pseg_start < seg_end) |
911 | continue; |
912 | goto feed_segment; |
913 | |
914 | strayed: |
915 | /* Off the trail */ |
916 | if (!scan_newer) |
917 | /* |
918 | * This can happen if a checkpoint was written without |
919 | * barriers, or as a result of an I/O failure. |
920 | */ |
921 | goto failed; |
922 | |
923 | feed_segment: |
924 | /* Looking to the next full segment */ |
925 | if (empty_seg++) |
926 | goto super_root_found; /* found a valid super root */ |
927 | |
928 | ret = nilfs_segment_list_add(head: &segments, segnum); |
929 | if (unlikely(ret)) |
930 | goto failed; |
931 | |
932 | seg_seq++; |
933 | segnum = nextnum; |
934 | nilfs_get_segment_range(nilfs, segnum, seg_start: &seg_start, seg_end: &seg_end); |
935 | pseg_start = seg_start; |
936 | } |
937 | |
938 | super_root_found: |
939 | /* Updating pointers relating to the latest checkpoint */ |
940 | brelse(bh: bh_sum); |
941 | list_splice_tail(list: &segments, head: &ri->ri_used_segments); |
942 | nilfs->ns_last_pseg = sr_pseg_start; |
943 | nilfs->ns_last_seq = nilfs->ns_seg_seq; |
944 | nilfs->ns_last_cno = ri->ri_cno; |
945 | return 0; |
946 | |
947 | failed: |
948 | brelse(bh: bh_sum); |
949 | nilfs_dispose_segment_list(head: &segments); |
950 | return ret < 0 ? ret : nilfs_warn_segment_error(sb: nilfs->ns_sb, err: ret); |
951 | } |
952 | |