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 | struct page *page) |
476 | { |
477 | struct buffer_head *bh_org; |
478 | void *kaddr; |
479 | |
480 | bh_org = __bread(bdev: nilfs->ns_bdev, block: rb->blocknr, size: nilfs->ns_blocksize); |
481 | if (unlikely(!bh_org)) |
482 | return -EIO; |
483 | |
484 | kaddr = kmap_atomic(page); |
485 | memcpy(kaddr + bh_offset(bh_org), bh_org->b_data, bh_org->b_size); |
486 | kunmap_atomic(kaddr); |
487 | brelse(bh: bh_org); |
488 | return 0; |
489 | } |
490 | |
491 | static int nilfs_recover_dsync_blocks(struct the_nilfs *nilfs, |
492 | struct super_block *sb, |
493 | struct nilfs_root *root, |
494 | struct list_head *head, |
495 | unsigned long *nr_salvaged_blocks) |
496 | { |
497 | struct inode *inode; |
498 | struct nilfs_recovery_block *rb, *n; |
499 | unsigned int blocksize = nilfs->ns_blocksize; |
500 | struct page *page; |
501 | loff_t pos; |
502 | int err = 0, err2 = 0; |
503 | |
504 | list_for_each_entry_safe(rb, n, head, list) { |
505 | inode = nilfs_iget(sb, root, ino: rb->ino); |
506 | if (IS_ERR(ptr: inode)) { |
507 | err = PTR_ERR(ptr: inode); |
508 | inode = NULL; |
509 | goto failed_inode; |
510 | } |
511 | |
512 | pos = rb->blkoff << inode->i_blkbits; |
513 | err = block_write_begin(mapping: inode->i_mapping, pos, len: blocksize, |
514 | pagep: &page, get_block: nilfs_get_block); |
515 | if (unlikely(err)) { |
516 | loff_t isize = inode->i_size; |
517 | |
518 | if (pos + blocksize > isize) |
519 | nilfs_write_failed(mapping: inode->i_mapping, |
520 | to: pos + blocksize); |
521 | goto failed_inode; |
522 | } |
523 | |
524 | err = nilfs_recovery_copy_block(nilfs, rb, page); |
525 | if (unlikely(err)) |
526 | goto failed_page; |
527 | |
528 | err = nilfs_set_file_dirty(inode, nr_dirty: 1); |
529 | if (unlikely(err)) |
530 | goto failed_page; |
531 | |
532 | block_write_end(NULL, inode->i_mapping, pos, blocksize, |
533 | blocksize, page, NULL); |
534 | |
535 | unlock_page(page); |
536 | put_page(page); |
537 | |
538 | (*nr_salvaged_blocks)++; |
539 | goto next; |
540 | |
541 | failed_page: |
542 | unlock_page(page); |
543 | put_page(page); |
544 | |
545 | failed_inode: |
546 | nilfs_warn(sb, |
547 | "error %d recovering data block (ino=%lu, block-offset=%llu)" , |
548 | err, (unsigned long)rb->ino, |
549 | (unsigned long long)rb->blkoff); |
550 | if (!err2) |
551 | err2 = err; |
552 | next: |
553 | iput(inode); /* iput(NULL) is just ignored */ |
554 | list_del_init(entry: &rb->list); |
555 | kfree(objp: rb); |
556 | } |
557 | return err2; |
558 | } |
559 | |
560 | /** |
561 | * nilfs_do_roll_forward - salvage logical segments newer than the latest |
562 | * checkpoint |
563 | * @nilfs: nilfs object |
564 | * @sb: super block instance |
565 | * @ri: pointer to a nilfs_recovery_info |
566 | */ |
567 | static int nilfs_do_roll_forward(struct the_nilfs *nilfs, |
568 | struct super_block *sb, |
569 | struct nilfs_root *root, |
570 | struct nilfs_recovery_info *ri) |
571 | { |
572 | struct buffer_head *bh_sum = NULL; |
573 | struct nilfs_segment_summary *sum = NULL; |
574 | sector_t pseg_start; |
575 | sector_t seg_start, seg_end; /* Starting/ending DBN of full segment */ |
576 | unsigned long nsalvaged_blocks = 0; |
577 | unsigned int flags; |
578 | u64 seg_seq; |
579 | __u64 segnum, nextnum = 0; |
580 | int empty_seg = 0; |
581 | int err = 0, ret; |
582 | LIST_HEAD(dsync_blocks); /* list of data blocks to be recovered */ |
583 | enum { |
584 | RF_INIT_ST, |
585 | RF_DSYNC_ST, /* scanning data-sync segments */ |
586 | }; |
587 | int state = RF_INIT_ST; |
588 | |
589 | pseg_start = ri->ri_lsegs_start; |
590 | seg_seq = ri->ri_lsegs_start_seq; |
591 | segnum = nilfs_get_segnum_of_block(nilfs, blocknr: pseg_start); |
592 | nilfs_get_segment_range(nilfs, segnum, seg_start: &seg_start, seg_end: &seg_end); |
593 | |
594 | while (segnum != ri->ri_segnum || pseg_start <= ri->ri_pseg_start) { |
595 | brelse(bh: bh_sum); |
596 | bh_sum = nilfs_read_log_header(nilfs, start_blocknr: pseg_start, sum: &sum); |
597 | if (!bh_sum) { |
598 | err = -EIO; |
599 | goto failed; |
600 | } |
601 | |
602 | ret = nilfs_validate_log(nilfs, seg_seq, bh_sum, sum); |
603 | if (ret) { |
604 | if (ret == NILFS_SEG_FAIL_IO) { |
605 | err = -EIO; |
606 | goto failed; |
607 | } |
608 | goto strayed; |
609 | } |
610 | |
611 | flags = le16_to_cpu(sum->ss_flags); |
612 | if (flags & NILFS_SS_SR) |
613 | goto confused; |
614 | |
615 | /* Found a valid partial segment; do recovery actions */ |
616 | nextnum = nilfs_get_segnum_of_block(nilfs, |
617 | le64_to_cpu(sum->ss_next)); |
618 | empty_seg = 0; |
619 | nilfs->ns_ctime = le64_to_cpu(sum->ss_create); |
620 | if (!(flags & NILFS_SS_GC)) |
621 | nilfs->ns_nongc_ctime = nilfs->ns_ctime; |
622 | |
623 | switch (state) { |
624 | case RF_INIT_ST: |
625 | if (!(flags & NILFS_SS_LOGBGN) || |
626 | !(flags & NILFS_SS_SYNDT)) |
627 | goto try_next_pseg; |
628 | state = RF_DSYNC_ST; |
629 | fallthrough; |
630 | case RF_DSYNC_ST: |
631 | if (!(flags & NILFS_SS_SYNDT)) |
632 | goto confused; |
633 | |
634 | err = nilfs_scan_dsync_log(nilfs, start_blocknr: pseg_start, sum, |
635 | head: &dsync_blocks); |
636 | if (unlikely(err)) |
637 | goto failed; |
638 | if (flags & NILFS_SS_LOGEND) { |
639 | err = nilfs_recover_dsync_blocks( |
640 | nilfs, sb, root, head: &dsync_blocks, |
641 | nr_salvaged_blocks: &nsalvaged_blocks); |
642 | if (unlikely(err)) |
643 | goto failed; |
644 | state = RF_INIT_ST; |
645 | } |
646 | break; /* Fall through to try_next_pseg */ |
647 | } |
648 | |
649 | try_next_pseg: |
650 | if (pseg_start == ri->ri_lsegs_end) |
651 | break; |
652 | pseg_start += le32_to_cpu(sum->ss_nblocks); |
653 | if (pseg_start < seg_end) |
654 | continue; |
655 | goto feed_segment; |
656 | |
657 | strayed: |
658 | if (pseg_start == ri->ri_lsegs_end) |
659 | break; |
660 | |
661 | feed_segment: |
662 | /* Looking to the next full segment */ |
663 | if (empty_seg++) |
664 | break; |
665 | seg_seq++; |
666 | segnum = nextnum; |
667 | nilfs_get_segment_range(nilfs, segnum, seg_start: &seg_start, seg_end: &seg_end); |
668 | pseg_start = seg_start; |
669 | } |
670 | |
671 | if (nsalvaged_blocks) { |
672 | nilfs_info(sb, "salvaged %lu blocks" , nsalvaged_blocks); |
673 | ri->ri_need_recovery = NILFS_RECOVERY_ROLLFORWARD_DONE; |
674 | } |
675 | out: |
676 | brelse(bh: bh_sum); |
677 | dispose_recovery_list(head: &dsync_blocks); |
678 | return err; |
679 | |
680 | confused: |
681 | err = -EINVAL; |
682 | failed: |
683 | nilfs_err(sb, |
684 | "error %d roll-forwarding partial segment at blocknr = %llu" , |
685 | err, (unsigned long long)pseg_start); |
686 | goto out; |
687 | } |
688 | |
689 | static void nilfs_finish_roll_forward(struct the_nilfs *nilfs, |
690 | struct nilfs_recovery_info *ri) |
691 | { |
692 | struct buffer_head *bh; |
693 | int err; |
694 | |
695 | if (nilfs_get_segnum_of_block(nilfs, blocknr: ri->ri_lsegs_start) != |
696 | nilfs_get_segnum_of_block(nilfs, blocknr: ri->ri_super_root)) |
697 | return; |
698 | |
699 | bh = __getblk(bdev: nilfs->ns_bdev, block: ri->ri_lsegs_start, size: nilfs->ns_blocksize); |
700 | BUG_ON(!bh); |
701 | memset(bh->b_data, 0, bh->b_size); |
702 | set_buffer_dirty(bh); |
703 | err = sync_dirty_buffer(bh); |
704 | if (unlikely(err)) |
705 | nilfs_warn(nilfs->ns_sb, |
706 | "buffer sync write failed during post-cleaning of recovery." ); |
707 | brelse(bh); |
708 | } |
709 | |
710 | /** |
711 | * nilfs_salvage_orphan_logs - salvage logs written after the latest checkpoint |
712 | * @nilfs: nilfs object |
713 | * @sb: super block instance |
714 | * @ri: pointer to a nilfs_recovery_info struct to store search results. |
715 | * |
716 | * Return Value: On success, 0 is returned. On error, one of the following |
717 | * negative error code is returned. |
718 | * |
719 | * %-EINVAL - Inconsistent filesystem state. |
720 | * |
721 | * %-EIO - I/O error |
722 | * |
723 | * %-ENOSPC - No space left on device (only in a panic state). |
724 | * |
725 | * %-ERESTARTSYS - Interrupted. |
726 | * |
727 | * %-ENOMEM - Insufficient memory available. |
728 | */ |
729 | int nilfs_salvage_orphan_logs(struct the_nilfs *nilfs, |
730 | struct super_block *sb, |
731 | struct nilfs_recovery_info *ri) |
732 | { |
733 | struct nilfs_root *root; |
734 | int err; |
735 | |
736 | if (ri->ri_lsegs_start == 0 || ri->ri_lsegs_end == 0) |
737 | return 0; |
738 | |
739 | err = nilfs_attach_checkpoint(sb, cno: ri->ri_cno, curr_mnt: true, root: &root); |
740 | if (unlikely(err)) { |
741 | nilfs_err(sb, "error %d loading the latest checkpoint" , err); |
742 | return err; |
743 | } |
744 | |
745 | err = nilfs_do_roll_forward(nilfs, sb, root, ri); |
746 | if (unlikely(err)) |
747 | goto failed; |
748 | |
749 | if (ri->ri_need_recovery == NILFS_RECOVERY_ROLLFORWARD_DONE) { |
750 | err = nilfs_prepare_segment_for_recovery(nilfs, sb, ri); |
751 | if (unlikely(err)) { |
752 | nilfs_err(sb, "error %d preparing segment for recovery" , |
753 | err); |
754 | goto failed; |
755 | } |
756 | |
757 | err = nilfs_attach_log_writer(sb, root); |
758 | if (unlikely(err)) |
759 | goto failed; |
760 | |
761 | set_nilfs_discontinued(nilfs); |
762 | err = nilfs_construct_segment(sb); |
763 | nilfs_detach_log_writer(sb); |
764 | |
765 | if (unlikely(err)) { |
766 | nilfs_err(sb, "error %d writing segment for recovery" , |
767 | err); |
768 | goto failed; |
769 | } |
770 | |
771 | nilfs_finish_roll_forward(nilfs, ri); |
772 | } |
773 | |
774 | failed: |
775 | nilfs_put_root(root); |
776 | return err; |
777 | } |
778 | |
779 | /** |
780 | * nilfs_search_super_root - search the latest valid super root |
781 | * @nilfs: the_nilfs |
782 | * @ri: pointer to a nilfs_recovery_info struct to store search results. |
783 | * |
784 | * nilfs_search_super_root() looks for the latest super-root from a partial |
785 | * segment pointed by the superblock. It sets up struct the_nilfs through |
786 | * this search. It fills nilfs_recovery_info (ri) required for recovery. |
787 | * |
788 | * Return Value: On success, 0 is returned. On error, one of the following |
789 | * negative error code is returned. |
790 | * |
791 | * %-EINVAL - No valid segment found |
792 | * |
793 | * %-EIO - I/O error |
794 | * |
795 | * %-ENOMEM - Insufficient memory available. |
796 | */ |
797 | int nilfs_search_super_root(struct the_nilfs *nilfs, |
798 | struct nilfs_recovery_info *ri) |
799 | { |
800 | struct buffer_head *bh_sum = NULL; |
801 | struct nilfs_segment_summary *sum = NULL; |
802 | sector_t pseg_start, pseg_end, sr_pseg_start = 0; |
803 | sector_t seg_start, seg_end; /* range of full segment (block number) */ |
804 | sector_t b, end; |
805 | unsigned long nblocks; |
806 | unsigned int flags; |
807 | u64 seg_seq; |
808 | __u64 segnum, nextnum = 0; |
809 | __u64 cno; |
810 | LIST_HEAD(segments); |
811 | int empty_seg = 0, scan_newer = 0; |
812 | int ret; |
813 | |
814 | pseg_start = nilfs->ns_last_pseg; |
815 | seg_seq = nilfs->ns_last_seq; |
816 | cno = nilfs->ns_last_cno; |
817 | segnum = nilfs_get_segnum_of_block(nilfs, blocknr: pseg_start); |
818 | |
819 | /* Calculate range of segment */ |
820 | nilfs_get_segment_range(nilfs, segnum, seg_start: &seg_start, seg_end: &seg_end); |
821 | |
822 | /* Read ahead segment */ |
823 | b = seg_start; |
824 | while (b <= seg_end) |
825 | __breadahead(nilfs->ns_bdev, block: b++, size: nilfs->ns_blocksize); |
826 | |
827 | for (;;) { |
828 | brelse(bh: bh_sum); |
829 | ret = NILFS_SEG_FAIL_IO; |
830 | bh_sum = nilfs_read_log_header(nilfs, start_blocknr: pseg_start, sum: &sum); |
831 | if (!bh_sum) |
832 | goto failed; |
833 | |
834 | ret = nilfs_validate_log(nilfs, seg_seq, bh_sum, sum); |
835 | if (ret) { |
836 | if (ret == NILFS_SEG_FAIL_IO) |
837 | goto failed; |
838 | goto strayed; |
839 | } |
840 | |
841 | nblocks = le32_to_cpu(sum->ss_nblocks); |
842 | pseg_end = pseg_start + nblocks - 1; |
843 | if (unlikely(pseg_end > seg_end)) { |
844 | ret = NILFS_SEG_FAIL_CONSISTENCY; |
845 | goto strayed; |
846 | } |
847 | |
848 | /* A valid partial segment */ |
849 | ri->ri_pseg_start = pseg_start; |
850 | ri->ri_seq = seg_seq; |
851 | ri->ri_segnum = segnum; |
852 | nextnum = nilfs_get_segnum_of_block(nilfs, |
853 | le64_to_cpu(sum->ss_next)); |
854 | ri->ri_nextnum = nextnum; |
855 | empty_seg = 0; |
856 | |
857 | flags = le16_to_cpu(sum->ss_flags); |
858 | if (!(flags & NILFS_SS_SR) && !scan_newer) { |
859 | /* |
860 | * This will never happen because a superblock |
861 | * (last_segment) always points to a pseg with |
862 | * a super root. |
863 | */ |
864 | ret = NILFS_SEG_FAIL_CONSISTENCY; |
865 | goto failed; |
866 | } |
867 | |
868 | if (pseg_start == seg_start) { |
869 | nilfs_get_segment_range(nilfs, segnum: nextnum, seg_start: &b, seg_end: &end); |
870 | while (b <= end) |
871 | __breadahead(nilfs->ns_bdev, block: b++, |
872 | size: nilfs->ns_blocksize); |
873 | } |
874 | if (!(flags & NILFS_SS_SR)) { |
875 | if (!ri->ri_lsegs_start && (flags & NILFS_SS_LOGBGN)) { |
876 | ri->ri_lsegs_start = pseg_start; |
877 | ri->ri_lsegs_start_seq = seg_seq; |
878 | } |
879 | if (flags & NILFS_SS_LOGEND) |
880 | ri->ri_lsegs_end = pseg_start; |
881 | goto try_next_pseg; |
882 | } |
883 | |
884 | /* A valid super root was found. */ |
885 | ri->ri_cno = cno++; |
886 | ri->ri_super_root = pseg_end; |
887 | ri->ri_lsegs_start = ri->ri_lsegs_end = 0; |
888 | |
889 | nilfs_dispose_segment_list(head: &segments); |
890 | sr_pseg_start = pseg_start; |
891 | nilfs->ns_pseg_offset = pseg_start + nblocks - seg_start; |
892 | nilfs->ns_seg_seq = seg_seq; |
893 | nilfs->ns_segnum = segnum; |
894 | nilfs->ns_cno = cno; /* nilfs->ns_cno = ri->ri_cno + 1 */ |
895 | nilfs->ns_ctime = le64_to_cpu(sum->ss_create); |
896 | nilfs->ns_nextnum = nextnum; |
897 | |
898 | if (scan_newer) |
899 | ri->ri_need_recovery = NILFS_RECOVERY_SR_UPDATED; |
900 | else { |
901 | if (nilfs->ns_mount_state & NILFS_VALID_FS) |
902 | goto super_root_found; |
903 | scan_newer = 1; |
904 | } |
905 | |
906 | try_next_pseg: |
907 | /* Standing on a course, or met an inconsistent state */ |
908 | pseg_start += nblocks; |
909 | if (pseg_start < seg_end) |
910 | continue; |
911 | goto feed_segment; |
912 | |
913 | strayed: |
914 | /* Off the trail */ |
915 | if (!scan_newer) |
916 | /* |
917 | * This can happen if a checkpoint was written without |
918 | * barriers, or as a result of an I/O failure. |
919 | */ |
920 | goto failed; |
921 | |
922 | feed_segment: |
923 | /* Looking to the next full segment */ |
924 | if (empty_seg++) |
925 | goto super_root_found; /* found a valid super root */ |
926 | |
927 | ret = nilfs_segment_list_add(head: &segments, segnum); |
928 | if (unlikely(ret)) |
929 | goto failed; |
930 | |
931 | seg_seq++; |
932 | segnum = nextnum; |
933 | nilfs_get_segment_range(nilfs, segnum, seg_start: &seg_start, seg_end: &seg_end); |
934 | pseg_start = seg_start; |
935 | } |
936 | |
937 | super_root_found: |
938 | /* Updating pointers relating to the latest checkpoint */ |
939 | brelse(bh: bh_sum); |
940 | list_splice_tail(list: &segments, head: &ri->ri_used_segments); |
941 | nilfs->ns_last_pseg = sr_pseg_start; |
942 | nilfs->ns_last_seq = nilfs->ns_seg_seq; |
943 | nilfs->ns_last_cno = ri->ri_cno; |
944 | return 0; |
945 | |
946 | failed: |
947 | brelse(bh: bh_sum); |
948 | nilfs_dispose_segment_list(head: &segments); |
949 | return ret < 0 ? ret : nilfs_warn_segment_error(sb: nilfs->ns_sb, err: ret); |
950 | } |
951 | |