blob: bae2a516b4ee0b6d72277d470747ae92cf40b4c5 [file] [log] [blame]
Ryusuke Konishi0f3e1c72009-04-06 19:01:38 -07001/*
2 * recovery.c - NILFS recovery logic
3 *
4 * Copyright (C) 2005-2008 Nippon Telegraph and Telephone Corporation.
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
19 *
20 * Written by Ryusuke Konishi <ryusuke@osrg.net>
21 */
22
23#include <linux/buffer_head.h>
24#include <linux/blkdev.h>
25#include <linux/swap.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090026#include <linux/slab.h>
Ryusuke Konishi0f3e1c72009-04-06 19:01:38 -070027#include <linux/crc32.h>
28#include "nilfs.h"
29#include "segment.h"
30#include "sufile.h"
31#include "page.h"
Ryusuke Konishi0f3e1c72009-04-06 19:01:38 -070032#include "segbuf.h"
33
34/*
35 * Segment check result
36 */
37enum {
38 NILFS_SEG_VALID,
39 NILFS_SEG_NO_SUPER_ROOT,
40 NILFS_SEG_FAIL_IO,
41 NILFS_SEG_FAIL_MAGIC,
42 NILFS_SEG_FAIL_SEQ,
Ryusuke Konishi0f3e1c72009-04-06 19:01:38 -070043 NILFS_SEG_FAIL_CHECKSUM_SUPER_ROOT,
44 NILFS_SEG_FAIL_CHECKSUM_FULL,
45 NILFS_SEG_FAIL_CONSISTENCY,
46};
47
48/* work structure for recovery */
49struct nilfs_recovery_block {
50 ino_t ino; /* Inode number of the file that this block
51 belongs to */
52 sector_t blocknr; /* block number */
53 __u64 vblocknr; /* virtual block number */
54 unsigned long blkoff; /* File offset of the data block (per block) */
55 struct list_head list;
56};
57
58
59static int nilfs_warn_segment_error(int err)
60{
61 switch (err) {
62 case NILFS_SEG_FAIL_IO:
63 printk(KERN_WARNING
64 "NILFS warning: I/O error on loading last segment\n");
65 return -EIO;
66 case NILFS_SEG_FAIL_MAGIC:
67 printk(KERN_WARNING
68 "NILFS warning: Segment magic number invalid\n");
69 break;
70 case NILFS_SEG_FAIL_SEQ:
71 printk(KERN_WARNING
72 "NILFS warning: Sequence number mismatch\n");
73 break;
Ryusuke Konishi0f3e1c72009-04-06 19:01:38 -070074 case NILFS_SEG_FAIL_CHECKSUM_SUPER_ROOT:
75 printk(KERN_WARNING
76 "NILFS warning: Checksum error in super root\n");
77 break;
78 case NILFS_SEG_FAIL_CHECKSUM_FULL:
79 printk(KERN_WARNING
80 "NILFS warning: Checksum error in segment payload\n");
81 break;
82 case NILFS_SEG_FAIL_CONSISTENCY:
83 printk(KERN_WARNING
84 "NILFS warning: Inconsistent segment\n");
85 break;
86 case NILFS_SEG_NO_SUPER_ROOT:
87 printk(KERN_WARNING
88 "NILFS warning: No super root in the last segment\n");
89 break;
Ryusuke Konishi0f3e1c72009-04-06 19:01:38 -070090 }
91 return -EINVAL;
92}
93
94static void store_segsum_info(struct nilfs_segsum_info *ssi,
95 struct nilfs_segment_summary *sum,
96 unsigned int blocksize)
97{
98 ssi->flags = le16_to_cpu(sum->ss_flags);
99 ssi->seg_seq = le64_to_cpu(sum->ss_seq);
100 ssi->ctime = le64_to_cpu(sum->ss_create);
101 ssi->next = le64_to_cpu(sum->ss_next);
102 ssi->nblocks = le32_to_cpu(sum->ss_nblocks);
103 ssi->nfinfo = le32_to_cpu(sum->ss_nfinfo);
104 ssi->sumbytes = le32_to_cpu(sum->ss_sumbytes);
105
106 ssi->nsumblk = DIV_ROUND_UP(ssi->sumbytes, blocksize);
107 ssi->nfileblk = ssi->nblocks - ssi->nsumblk - !!NILFS_SEG_HAS_SR(ssi);
Ryusuke Konishi50614bc2010-04-10 17:59:15 +0900108
109 /* need to verify ->ss_bytes field if read ->ss_cno */
Ryusuke Konishi0f3e1c72009-04-06 19:01:38 -0700110}
111
112/**
113 * calc_crc_cont - check CRC of blocks continuously
114 * @sbi: nilfs_sb_info
115 * @bhs: buffer head of start block
116 * @sum: place to store result
117 * @offset: offset bytes in the first block
118 * @check_bytes: number of bytes to be checked
119 * @start: DBN of start block
120 * @nblock: number of blocks to be checked
121 */
122static int calc_crc_cont(struct nilfs_sb_info *sbi, struct buffer_head *bhs,
123 u32 *sum, unsigned long offset, u64 check_bytes,
124 sector_t start, unsigned long nblock)
125{
126 unsigned long blocksize = sbi->s_super->s_blocksize;
127 unsigned long size;
128 u32 crc;
129
130 BUG_ON(offset >= blocksize);
131 check_bytes -= offset;
132 size = min_t(u64, check_bytes, blocksize - offset);
133 crc = crc32_le(sbi->s_nilfs->ns_crc_seed,
134 (unsigned char *)bhs->b_data + offset, size);
135 if (--nblock > 0) {
136 do {
137 struct buffer_head *bh
138 = sb_bread(sbi->s_super, ++start);
139 if (!bh)
140 return -EIO;
141 check_bytes -= size;
142 size = min_t(u64, check_bytes, blocksize);
143 crc = crc32_le(crc, bh->b_data, size);
144 brelse(bh);
145 } while (--nblock > 0);
146 }
147 *sum = crc;
148 return 0;
149}
150
151/**
152 * nilfs_read_super_root_block - read super root block
153 * @sb: super_block
154 * @sr_block: disk block number of the super root block
155 * @pbh: address of a buffer_head pointer to return super root buffer
156 * @check: CRC check flag
157 */
158int nilfs_read_super_root_block(struct super_block *sb, sector_t sr_block,
159 struct buffer_head **pbh, int check)
160{
161 struct buffer_head *bh_sr;
162 struct nilfs_super_root *sr;
163 u32 crc;
164 int ret;
165
166 *pbh = NULL;
167 bh_sr = sb_bread(sb, sr_block);
168 if (unlikely(!bh_sr)) {
169 ret = NILFS_SEG_FAIL_IO;
170 goto failed;
171 }
172
173 sr = (struct nilfs_super_root *)bh_sr->b_data;
174 if (check) {
175 unsigned bytes = le16_to_cpu(sr->sr_bytes);
176
177 if (bytes == 0 || bytes > sb->s_blocksize) {
178 ret = NILFS_SEG_FAIL_CHECKSUM_SUPER_ROOT;
179 goto failed_bh;
180 }
181 if (calc_crc_cont(NILFS_SB(sb), bh_sr, &crc,
182 sizeof(sr->sr_sum), bytes, sr_block, 1)) {
183 ret = NILFS_SEG_FAIL_IO;
184 goto failed_bh;
185 }
186 if (crc != le32_to_cpu(sr->sr_sum)) {
187 ret = NILFS_SEG_FAIL_CHECKSUM_SUPER_ROOT;
188 goto failed_bh;
189 }
190 }
191 *pbh = bh_sr;
192 return 0;
193
194 failed_bh:
195 brelse(bh_sr);
196
197 failed:
198 return nilfs_warn_segment_error(ret);
199}
200
201/**
202 * load_segment_summary - read segment summary of the specified partial segment
203 * @sbi: nilfs_sb_info
204 * @pseg_start: start disk block number of partial segment
205 * @seg_seq: sequence number requested
206 * @ssi: pointer to nilfs_segsum_info struct to store information
Ryusuke Konishi0f3e1c72009-04-06 19:01:38 -0700207 */
208static int
209load_segment_summary(struct nilfs_sb_info *sbi, sector_t pseg_start,
Jiro SEKIBA03f29362010-02-18 19:11:35 +0900210 u64 seg_seq, struct nilfs_segsum_info *ssi)
Ryusuke Konishi0f3e1c72009-04-06 19:01:38 -0700211{
212 struct buffer_head *bh_sum;
213 struct nilfs_segment_summary *sum;
Jiro SEKIBA03f29362010-02-18 19:11:35 +0900214 unsigned long nblock;
215 u32 crc;
Ryusuke Konishi0f3e1c72009-04-06 19:01:38 -0700216 int ret = NILFS_SEG_FAIL_IO;
217
218 bh_sum = sb_bread(sbi->s_super, pseg_start);
219 if (!bh_sum)
220 goto out;
221
222 sum = (struct nilfs_segment_summary *)bh_sum->b_data;
223
224 /* Check consistency of segment summary */
225 if (le32_to_cpu(sum->ss_magic) != NILFS_SEGSUM_MAGIC) {
226 ret = NILFS_SEG_FAIL_MAGIC;
227 goto failed;
228 }
229 store_segsum_info(ssi, sum, sbi->s_super->s_blocksize);
230 if (seg_seq != ssi->seg_seq) {
231 ret = NILFS_SEG_FAIL_SEQ;
232 goto failed;
233 }
Ryusuke Konishi0f3e1c72009-04-06 19:01:38 -0700234
Jiro SEKIBA03f29362010-02-18 19:11:35 +0900235 nblock = ssi->nblocks;
Ryusuke Konishi0f3e1c72009-04-06 19:01:38 -0700236 if (unlikely(nblock == 0 ||
237 nblock > sbi->s_nilfs->ns_blocks_per_segment)) {
238 /* This limits the number of blocks read in the CRC check */
239 ret = NILFS_SEG_FAIL_CONSISTENCY;
240 goto failed;
241 }
Jiro SEKIBA03f29362010-02-18 19:11:35 +0900242 if (calc_crc_cont(sbi, bh_sum, &crc, sizeof(sum->ss_datasum),
243 ((u64)nblock << sbi->s_super->s_blocksize_bits),
Ryusuke Konishi0f3e1c72009-04-06 19:01:38 -0700244 pseg_start, nblock)) {
245 ret = NILFS_SEG_FAIL_IO;
246 goto failed;
247 }
Jiro SEKIBA03f29362010-02-18 19:11:35 +0900248 if (crc == le32_to_cpu(sum->ss_datasum))
Ryusuke Konishi0f3e1c72009-04-06 19:01:38 -0700249 ret = 0;
Jiro SEKIBA03f29362010-02-18 19:11:35 +0900250 else
251 ret = NILFS_SEG_FAIL_CHECKSUM_FULL;
Ryusuke Konishi0f3e1c72009-04-06 19:01:38 -0700252 failed:
253 brelse(bh_sum);
254 out:
255 return ret;
256}
257
258static void *segsum_get(struct super_block *sb, struct buffer_head **pbh,
259 unsigned int *offset, unsigned int bytes)
260{
261 void *ptr;
262 sector_t blocknr;
263
264 BUG_ON((*pbh)->b_size < *offset);
265 if (bytes > (*pbh)->b_size - *offset) {
266 blocknr = (*pbh)->b_blocknr;
267 brelse(*pbh);
268 *pbh = sb_bread(sb, blocknr + 1);
269 if (unlikely(!*pbh))
270 return NULL;
271 *offset = 0;
272 }
273 ptr = (*pbh)->b_data + *offset;
274 *offset += bytes;
275 return ptr;
276}
277
278static void segsum_skip(struct super_block *sb, struct buffer_head **pbh,
279 unsigned int *offset, unsigned int bytes,
280 unsigned long count)
281{
282 unsigned int rest_item_in_current_block
283 = ((*pbh)->b_size - *offset) / bytes;
284
285 if (count <= rest_item_in_current_block) {
286 *offset += bytes * count;
287 } else {
288 sector_t blocknr = (*pbh)->b_blocknr;
289 unsigned int nitem_per_block = (*pbh)->b_size / bytes;
290 unsigned int bcnt;
291
292 count -= rest_item_in_current_block;
293 bcnt = DIV_ROUND_UP(count, nitem_per_block);
294 *offset = bytes * (count - (bcnt - 1) * nitem_per_block);
295
296 brelse(*pbh);
297 *pbh = sb_bread(sb, blocknr + bcnt);
298 }
299}
300
301static int
302collect_blocks_from_segsum(struct nilfs_sb_info *sbi, sector_t sum_blocknr,
303 struct nilfs_segsum_info *ssi,
304 struct list_head *head)
305{
306 struct buffer_head *bh;
307 unsigned int offset;
308 unsigned long nfinfo = ssi->nfinfo;
309 sector_t blocknr = sum_blocknr + ssi->nsumblk;
310 ino_t ino;
311 int err = -EIO;
312
313 if (!nfinfo)
314 return 0;
315
316 bh = sb_bread(sbi->s_super, sum_blocknr);
317 if (unlikely(!bh))
318 goto out;
319
320 offset = le16_to_cpu(
321 ((struct nilfs_segment_summary *)bh->b_data)->ss_bytes);
322 for (;;) {
323 unsigned long nblocks, ndatablk, nnodeblk;
324 struct nilfs_finfo *finfo;
325
326 finfo = segsum_get(sbi->s_super, &bh, &offset, sizeof(*finfo));
327 if (unlikely(!finfo))
328 goto out;
329
330 ino = le64_to_cpu(finfo->fi_ino);
331 nblocks = le32_to_cpu(finfo->fi_nblocks);
332 ndatablk = le32_to_cpu(finfo->fi_ndatablk);
333 nnodeblk = nblocks - ndatablk;
334
335 while (ndatablk-- > 0) {
336 struct nilfs_recovery_block *rb;
337 struct nilfs_binfo_v *binfo;
338
339 binfo = segsum_get(sbi->s_super, &bh, &offset,
340 sizeof(*binfo));
341 if (unlikely(!binfo))
342 goto out;
343
344 rb = kmalloc(sizeof(*rb), GFP_NOFS);
345 if (unlikely(!rb)) {
346 err = -ENOMEM;
347 goto out;
348 }
349 rb->ino = ino;
350 rb->blocknr = blocknr++;
351 rb->vblocknr = le64_to_cpu(binfo->bi_vblocknr);
352 rb->blkoff = le64_to_cpu(binfo->bi_blkoff);
353 /* INIT_LIST_HEAD(&rb->list); */
354 list_add_tail(&rb->list, head);
355 }
356 if (--nfinfo == 0)
357 break;
358 blocknr += nnodeblk; /* always 0 for the data sync segments */
359 segsum_skip(sbi->s_super, &bh, &offset, sizeof(__le64),
360 nnodeblk);
361 if (unlikely(!bh))
362 goto out;
363 }
364 err = 0;
365 out:
366 brelse(bh); /* brelse(NULL) is just ignored */
367 return err;
368}
369
370static void dispose_recovery_list(struct list_head *head)
371{
372 while (!list_empty(head)) {
373 struct nilfs_recovery_block *rb
374 = list_entry(head->next,
375 struct nilfs_recovery_block, list);
376 list_del(&rb->list);
377 kfree(rb);
378 }
379}
380
Ryusuke Konishi654137d2009-05-17 19:07:21 +0900381struct nilfs_segment_entry {
382 struct list_head list;
383 __u64 segnum;
384};
385
386static int nilfs_segment_list_add(struct list_head *head, __u64 segnum)
387{
388 struct nilfs_segment_entry *ent = kmalloc(sizeof(*ent), GFP_NOFS);
389
390 if (unlikely(!ent))
391 return -ENOMEM;
392
393 ent->segnum = segnum;
394 INIT_LIST_HEAD(&ent->list);
395 list_add_tail(&ent->list, head);
396 return 0;
397}
398
Ryusuke Konishi0f3e1c72009-04-06 19:01:38 -0700399void nilfs_dispose_segment_list(struct list_head *head)
400{
401 while (!list_empty(head)) {
402 struct nilfs_segment_entry *ent
403 = list_entry(head->next,
404 struct nilfs_segment_entry, list);
405 list_del(&ent->list);
Ryusuke Konishi654137d2009-05-17 19:07:21 +0900406 kfree(ent);
Ryusuke Konishi0f3e1c72009-04-06 19:01:38 -0700407 }
408}
409
410static int nilfs_prepare_segment_for_recovery(struct the_nilfs *nilfs,
Ryusuke Konishi85c2a742009-04-28 23:38:46 +0900411 struct nilfs_sb_info *sbi,
Ryusuke Konishi0f3e1c72009-04-06 19:01:38 -0700412 struct nilfs_recovery_info *ri)
413{
414 struct list_head *head = &ri->ri_used_segments;
415 struct nilfs_segment_entry *ent, *n;
416 struct inode *sufile = nilfs->ns_sufile;
417 __u64 segnum[4];
418 int err;
419 int i;
420
421 segnum[0] = nilfs->ns_segnum;
422 segnum[1] = nilfs->ns_nextnum;
423 segnum[2] = ri->ri_segnum;
424 segnum[3] = ri->ri_nextnum;
425
Ryusuke Konishi85c2a742009-04-28 23:38:46 +0900426 nilfs_attach_writer(nilfs, sbi);
Ryusuke Konishi0f3e1c72009-04-06 19:01:38 -0700427 /*
428 * Releasing the next segment of the latest super root.
429 * The next segment is invalidated by this recovery.
430 */
431 err = nilfs_sufile_free(sufile, segnum[1]);
432 if (unlikely(err))
433 goto failed;
434
Ryusuke Konishi0f3e1c72009-04-06 19:01:38 -0700435 for (i = 1; i < 4; i++) {
Ryusuke Konishi654137d2009-05-17 19:07:21 +0900436 err = nilfs_segment_list_add(head, segnum[i]);
437 if (unlikely(err))
Ryusuke Konishi0f3e1c72009-04-06 19:01:38 -0700438 goto failed;
Ryusuke Konishi0f3e1c72009-04-06 19:01:38 -0700439 }
440
441 /*
442 * Collecting segments written after the latest super root.
Ryusuke Konishi2c2e52f2009-04-06 19:01:54 -0700443 * These are marked dirty to avoid being reallocated in the next write.
Ryusuke Konishi0f3e1c72009-04-06 19:01:38 -0700444 */
445 list_for_each_entry_safe(ent, n, head, list) {
Ryusuke Konishic85399c2009-04-05 18:30:58 +0900446 if (ent->segnum != segnum[0]) {
447 err = nilfs_sufile_scrap(sufile, ent->segnum);
448 if (unlikely(err))
449 goto failed;
Ryusuke Konishi0f3e1c72009-04-06 19:01:38 -0700450 }
Ryusuke Konishi2c2e52f2009-04-06 19:01:54 -0700451 list_del(&ent->list);
Ryusuke Konishi654137d2009-05-17 19:07:21 +0900452 kfree(ent);
Ryusuke Konishi0f3e1c72009-04-06 19:01:38 -0700453 }
Ryusuke Konishi0f3e1c72009-04-06 19:01:38 -0700454
Ryusuke Konishi0f3e1c72009-04-06 19:01:38 -0700455 /* Allocate new segments for recovery */
456 err = nilfs_sufile_alloc(sufile, &segnum[0]);
457 if (unlikely(err))
458 goto failed;
459
460 nilfs->ns_pseg_offset = 0;
461 nilfs->ns_seg_seq = ri->ri_seq + 2;
462 nilfs->ns_nextnum = nilfs->ns_segnum = segnum[0];
Ryusuke Konishi0f3e1c72009-04-06 19:01:38 -0700463
464 failed:
465 /* No need to recover sufile because it will be destroyed on error */
Ryusuke Konishi85c2a742009-04-28 23:38:46 +0900466 nilfs_detach_writer(nilfs, sbi);
Ryusuke Konishi0f3e1c72009-04-06 19:01:38 -0700467 return err;
468}
469
470static int nilfs_recovery_copy_block(struct nilfs_sb_info *sbi,
471 struct nilfs_recovery_block *rb,
472 struct page *page)
473{
474 struct buffer_head *bh_org;
475 void *kaddr;
476
477 bh_org = sb_bread(sbi->s_super, rb->blocknr);
478 if (unlikely(!bh_org))
479 return -EIO;
480
481 kaddr = kmap_atomic(page, KM_USER0);
482 memcpy(kaddr + bh_offset(bh_org), bh_org->b_data, bh_org->b_size);
483 kunmap_atomic(kaddr, KM_USER0);
484 brelse(bh_org);
485 return 0;
486}
487
488static int recover_dsync_blocks(struct nilfs_sb_info *sbi,
489 struct list_head *head,
490 unsigned long *nr_salvaged_blocks)
491{
492 struct inode *inode;
493 struct nilfs_recovery_block *rb, *n;
494 unsigned blocksize = sbi->s_super->s_blocksize;
495 struct page *page;
496 loff_t pos;
497 int err = 0, err2 = 0;
498
499 list_for_each_entry_safe(rb, n, head, list) {
500 inode = nilfs_iget(sbi->s_super, rb->ino);
501 if (IS_ERR(inode)) {
502 err = PTR_ERR(inode);
503 inode = NULL;
504 goto failed_inode;
505 }
506
507 pos = rb->blkoff << inode->i_blkbits;
508 page = NULL;
509 err = block_write_begin(NULL, inode->i_mapping, pos, blocksize,
510 0, &page, NULL, nilfs_get_block);
511 if (unlikely(err))
512 goto failed_inode;
513
514 err = nilfs_recovery_copy_block(sbi, rb, page);
515 if (unlikely(err))
516 goto failed_page;
517
518 err = nilfs_set_file_dirty(sbi, inode, 1);
519 if (unlikely(err))
520 goto failed_page;
521
522 block_write_end(NULL, inode->i_mapping, pos, blocksize,
523 blocksize, page, NULL);
524
525 unlock_page(page);
526 page_cache_release(page);
527
528 (*nr_salvaged_blocks)++;
529 goto next;
530
531 failed_page:
532 unlock_page(page);
533 page_cache_release(page);
534
535 failed_inode:
536 printk(KERN_WARNING
537 "NILFS warning: error recovering data block "
538 "(err=%d, ino=%lu, block-offset=%llu)\n",
Heiko Carstensb5696e52009-09-03 17:42:48 +0200539 err, (unsigned long)rb->ino,
540 (unsigned long long)rb->blkoff);
Ryusuke Konishi0f3e1c72009-04-06 19:01:38 -0700541 if (!err2)
542 err2 = err;
543 next:
544 iput(inode); /* iput(NULL) is just ignored */
545 list_del_init(&rb->list);
546 kfree(rb);
547 }
548 return err2;
549}
550
551/**
552 * nilfs_do_roll_forward - salvage logical segments newer than the latest
553 * checkpoint
554 * @sbi: nilfs_sb_info
555 * @nilfs: the_nilfs
556 * @ri: pointer to a nilfs_recovery_info
557 */
558static int nilfs_do_roll_forward(struct the_nilfs *nilfs,
559 struct nilfs_sb_info *sbi,
560 struct nilfs_recovery_info *ri)
561{
562 struct nilfs_segsum_info ssi;
563 sector_t pseg_start;
564 sector_t seg_start, seg_end; /* Starting/ending DBN of full segment */
565 unsigned long nsalvaged_blocks = 0;
566 u64 seg_seq;
567 __u64 segnum, nextnum = 0;
568 int empty_seg = 0;
569 int err = 0, ret;
570 LIST_HEAD(dsync_blocks); /* list of data blocks to be recovered */
571 enum {
572 RF_INIT_ST,
573 RF_DSYNC_ST, /* scanning data-sync segments */
574 };
575 int state = RF_INIT_ST;
576
577 nilfs_attach_writer(nilfs, sbi);
578 pseg_start = ri->ri_lsegs_start;
579 seg_seq = ri->ri_lsegs_start_seq;
580 segnum = nilfs_get_segnum_of_block(nilfs, pseg_start);
581 nilfs_get_segment_range(nilfs, segnum, &seg_start, &seg_end);
582
583 while (segnum != ri->ri_segnum || pseg_start <= ri->ri_pseg_start) {
584
Jiro SEKIBA03f29362010-02-18 19:11:35 +0900585 ret = load_segment_summary(sbi, pseg_start, seg_seq, &ssi);
Ryusuke Konishi0f3e1c72009-04-06 19:01:38 -0700586 if (ret) {
587 if (ret == NILFS_SEG_FAIL_IO) {
588 err = -EIO;
589 goto failed;
590 }
591 goto strayed;
592 }
593 if (unlikely(NILFS_SEG_HAS_SR(&ssi)))
594 goto confused;
595
596 /* Found a valid partial segment; do recovery actions */
597 nextnum = nilfs_get_segnum_of_block(nilfs, ssi.next);
598 empty_seg = 0;
599 nilfs->ns_ctime = ssi.ctime;
600 if (!(ssi.flags & NILFS_SS_GC))
601 nilfs->ns_nongc_ctime = ssi.ctime;
602
603 switch (state) {
604 case RF_INIT_ST:
605 if (!NILFS_SEG_LOGBGN(&ssi) || !NILFS_SEG_DSYNC(&ssi))
606 goto try_next_pseg;
607 state = RF_DSYNC_ST;
608 /* Fall through */
609 case RF_DSYNC_ST:
610 if (!NILFS_SEG_DSYNC(&ssi))
611 goto confused;
612
613 err = collect_blocks_from_segsum(
614 sbi, pseg_start, &ssi, &dsync_blocks);
615 if (unlikely(err))
616 goto failed;
617 if (NILFS_SEG_LOGEND(&ssi)) {
618 err = recover_dsync_blocks(
619 sbi, &dsync_blocks, &nsalvaged_blocks);
620 if (unlikely(err))
621 goto failed;
622 state = RF_INIT_ST;
623 }
624 break; /* Fall through to try_next_pseg */
625 }
626
627 try_next_pseg:
628 if (pseg_start == ri->ri_lsegs_end)
629 break;
630 pseg_start += ssi.nblocks;
631 if (pseg_start < seg_end)
632 continue;
633 goto feed_segment;
634
635 strayed:
636 if (pseg_start == ri->ri_lsegs_end)
637 break;
638
639 feed_segment:
640 /* Looking to the next full segment */
641 if (empty_seg++)
642 break;
643 seg_seq++;
644 segnum = nextnum;
645 nilfs_get_segment_range(nilfs, segnum, &seg_start, &seg_end);
646 pseg_start = seg_start;
647 }
648
649 if (nsalvaged_blocks) {
650 printk(KERN_INFO "NILFS (device %s): salvaged %lu blocks\n",
651 sbi->s_super->s_id, nsalvaged_blocks);
652 ri->ri_need_recovery = NILFS_RECOVERY_ROLLFORWARD_DONE;
653 }
654 out:
655 dispose_recovery_list(&dsync_blocks);
656 nilfs_detach_writer(sbi->s_nilfs, sbi);
657 return err;
658
659 confused:
660 err = -EINVAL;
661 failed:
662 printk(KERN_ERR
663 "NILFS (device %s): Error roll-forwarding "
664 "(err=%d, pseg block=%llu). ",
665 sbi->s_super->s_id, err, (unsigned long long)pseg_start);
666 goto out;
667}
668
669static void nilfs_finish_roll_forward(struct the_nilfs *nilfs,
670 struct nilfs_sb_info *sbi,
671 struct nilfs_recovery_info *ri)
672{
673 struct buffer_head *bh;
674 int err;
675
676 if (nilfs_get_segnum_of_block(nilfs, ri->ri_lsegs_start) !=
677 nilfs_get_segnum_of_block(nilfs, ri->ri_super_root))
678 return;
679
680 bh = sb_getblk(sbi->s_super, ri->ri_lsegs_start);
681 BUG_ON(!bh);
682 memset(bh->b_data, 0, bh->b_size);
683 set_buffer_dirty(bh);
684 err = sync_dirty_buffer(bh);
685 if (unlikely(err))
686 printk(KERN_WARNING
687 "NILFS warning: buffer sync write failed during "
688 "post-cleaning of recovery.\n");
689 brelse(bh);
690}
691
692/**
693 * nilfs_recover_logical_segments - salvage logical segments written after
694 * the latest super root
695 * @nilfs: the_nilfs
696 * @sbi: nilfs_sb_info
697 * @ri: pointer to a nilfs_recovery_info struct to store search results.
698 *
699 * Return Value: On success, 0 is returned. On error, one of the following
700 * negative error code is returned.
701 *
702 * %-EINVAL - Inconsistent filesystem state.
703 *
704 * %-EIO - I/O error
705 *
706 * %-ENOSPC - No space left on device (only in a panic state).
707 *
708 * %-ERESTARTSYS - Interrupted.
709 *
710 * %-ENOMEM - Insufficient memory available.
711 */
712int nilfs_recover_logical_segments(struct the_nilfs *nilfs,
713 struct nilfs_sb_info *sbi,
714 struct nilfs_recovery_info *ri)
715{
716 int err;
717
718 if (ri->ri_lsegs_start == 0 || ri->ri_lsegs_end == 0)
719 return 0;
720
721 err = nilfs_attach_checkpoint(sbi, ri->ri_cno);
722 if (unlikely(err)) {
723 printk(KERN_ERR
724 "NILFS: error loading the latest checkpoint.\n");
725 return err;
726 }
727
728 err = nilfs_do_roll_forward(nilfs, sbi, ri);
729 if (unlikely(err))
730 goto failed;
731
732 if (ri->ri_need_recovery == NILFS_RECOVERY_ROLLFORWARD_DONE) {
Ryusuke Konishi85c2a742009-04-28 23:38:46 +0900733 err = nilfs_prepare_segment_for_recovery(nilfs, sbi, ri);
Ryusuke Konishi0f3e1c72009-04-06 19:01:38 -0700734 if (unlikely(err)) {
735 printk(KERN_ERR "NILFS: Error preparing segments for "
736 "recovery.\n");
737 goto failed;
738 }
739
Ryusuke Konishicece5522009-04-06 19:01:58 -0700740 err = nilfs_attach_segment_constructor(sbi);
Ryusuke Konishi0f3e1c72009-04-06 19:01:38 -0700741 if (unlikely(err))
742 goto failed;
743
744 set_nilfs_discontinued(nilfs);
745 err = nilfs_construct_segment(sbi->s_super);
746 nilfs_detach_segment_constructor(sbi);
747
748 if (unlikely(err)) {
749 printk(KERN_ERR "NILFS: Oops! recovery failed. "
750 "(err=%d)\n", err);
751 goto failed;
752 }
753
754 nilfs_finish_roll_forward(nilfs, sbi, ri);
755 }
756
Ryusuke Konishi0f3e1c72009-04-06 19:01:38 -0700757 failed:
758 nilfs_detach_checkpoint(sbi);
Ryusuke Konishi0f3e1c72009-04-06 19:01:38 -0700759 return err;
760}
761
762/**
763 * nilfs_search_super_root - search the latest valid super root
764 * @nilfs: the_nilfs
765 * @sbi: nilfs_sb_info
766 * @ri: pointer to a nilfs_recovery_info struct to store search results.
767 *
768 * nilfs_search_super_root() looks for the latest super-root from a partial
769 * segment pointed by the superblock. It sets up struct the_nilfs through
770 * this search. It fills nilfs_recovery_info (ri) required for recovery.
771 *
772 * Return Value: On success, 0 is returned. On error, one of the following
773 * negative error code is returned.
774 *
775 * %-EINVAL - No valid segment found
776 *
777 * %-EIO - I/O error
778 */
779int nilfs_search_super_root(struct the_nilfs *nilfs, struct nilfs_sb_info *sbi,
780 struct nilfs_recovery_info *ri)
781{
782 struct nilfs_segsum_info ssi;
783 sector_t pseg_start, pseg_end, sr_pseg_start = 0;
784 sector_t seg_start, seg_end; /* range of full segment (block number) */
Ryusuke Konishi050b4142009-11-19 22:24:48 +0900785 sector_t b, end;
Ryusuke Konishi0f3e1c72009-04-06 19:01:38 -0700786 u64 seg_seq;
787 __u64 segnum, nextnum = 0;
788 __u64 cno;
Ryusuke Konishi0f3e1c72009-04-06 19:01:38 -0700789 LIST_HEAD(segments);
790 int empty_seg = 0, scan_newer = 0;
791 int ret;
792
793 pseg_start = nilfs->ns_last_pseg;
794 seg_seq = nilfs->ns_last_seq;
795 cno = nilfs->ns_last_cno;
796 segnum = nilfs_get_segnum_of_block(nilfs, pseg_start);
797
798 /* Calculate range of segment */
799 nilfs_get_segment_range(nilfs, segnum, &seg_start, &seg_end);
800
Ryusuke Konishi050b4142009-11-19 22:24:48 +0900801 /* Read ahead segment */
802 b = seg_start;
803 while (b <= seg_end)
804 sb_breadahead(sbi->s_super, b++);
805
Ryusuke Konishi0f3e1c72009-04-06 19:01:38 -0700806 for (;;) {
807 /* Load segment summary */
Jiro SEKIBA03f29362010-02-18 19:11:35 +0900808 ret = load_segment_summary(sbi, pseg_start, seg_seq, &ssi);
Ryusuke Konishi0f3e1c72009-04-06 19:01:38 -0700809 if (ret) {
810 if (ret == NILFS_SEG_FAIL_IO)
811 goto failed;
812 goto strayed;
813 }
814 pseg_end = pseg_start + ssi.nblocks - 1;
815 if (unlikely(pseg_end > seg_end)) {
816 ret = NILFS_SEG_FAIL_CONSISTENCY;
817 goto strayed;
818 }
819
820 /* A valid partial segment */
821 ri->ri_pseg_start = pseg_start;
822 ri->ri_seq = seg_seq;
823 ri->ri_segnum = segnum;
824 nextnum = nilfs_get_segnum_of_block(nilfs, ssi.next);
825 ri->ri_nextnum = nextnum;
826 empty_seg = 0;
827
Ryusuke Konishi050b4142009-11-19 22:24:48 +0900828 if (!NILFS_SEG_HAS_SR(&ssi) && !scan_newer) {
829 /* This will never happen because a superblock
830 (last_segment) always points to a pseg
831 having a super root. */
832 ret = NILFS_SEG_FAIL_CONSISTENCY;
833 goto failed;
834 }
835
836 if (pseg_start == seg_start) {
837 nilfs_get_segment_range(nilfs, nextnum, &b, &end);
838 while (b <= end)
839 sb_breadahead(sbi->s_super, b++);
840 }
Ryusuke Konishi0f3e1c72009-04-06 19:01:38 -0700841 if (!NILFS_SEG_HAS_SR(&ssi)) {
Ryusuke Konishi0f3e1c72009-04-06 19:01:38 -0700842 if (!ri->ri_lsegs_start && NILFS_SEG_LOGBGN(&ssi)) {
843 ri->ri_lsegs_start = pseg_start;
844 ri->ri_lsegs_start_seq = seg_seq;
845 }
846 if (NILFS_SEG_LOGEND(&ssi))
847 ri->ri_lsegs_end = pseg_start;
848 goto try_next_pseg;
849 }
850
851 /* A valid super root was found. */
852 ri->ri_cno = cno++;
853 ri->ri_super_root = pseg_end;
854 ri->ri_lsegs_start = ri->ri_lsegs_end = 0;
855
856 nilfs_dispose_segment_list(&segments);
857 nilfs->ns_pseg_offset = (sr_pseg_start = pseg_start)
858 + ssi.nblocks - seg_start;
859 nilfs->ns_seg_seq = seg_seq;
860 nilfs->ns_segnum = segnum;
861 nilfs->ns_cno = cno; /* nilfs->ns_cno = ri->ri_cno + 1 */
862 nilfs->ns_ctime = ssi.ctime;
863 nilfs->ns_nextnum = nextnum;
864
865 if (scan_newer)
866 ri->ri_need_recovery = NILFS_RECOVERY_SR_UPDATED;
Ryusuke Konishi2c2e52f2009-04-06 19:01:54 -0700867 else {
Ryusuke Konishi2c2e52f2009-04-06 19:01:54 -0700868 if (nilfs->ns_mount_state & NILFS_VALID_FS)
869 goto super_root_found;
870 scan_newer = 1;
871 }
Ryusuke Konishi0f3e1c72009-04-06 19:01:38 -0700872
873 /* reset region for roll-forward */
874 pseg_start += ssi.nblocks;
875 if (pseg_start < seg_end)
876 continue;
877 goto feed_segment;
878
879 try_next_pseg:
880 /* Standing on a course, or met an inconsistent state */
881 pseg_start += ssi.nblocks;
882 if (pseg_start < seg_end)
883 continue;
884 goto feed_segment;
885
886 strayed:
887 /* Off the trail */
888 if (!scan_newer)
889 /*
890 * This can happen if a checkpoint was written without
891 * barriers, or as a result of an I/O failure.
892 */
893 goto failed;
894
895 feed_segment:
896 /* Looking to the next full segment */
897 if (empty_seg++)
898 goto super_root_found; /* found a valid super root */
899
Ryusuke Konishi654137d2009-05-17 19:07:21 +0900900 ret = nilfs_segment_list_add(&segments, segnum);
901 if (unlikely(ret))
Ryusuke Konishi0f3e1c72009-04-06 19:01:38 -0700902 goto failed;
Ryusuke Konishi0f3e1c72009-04-06 19:01:38 -0700903
904 seg_seq++;
905 segnum = nextnum;
906 nilfs_get_segment_range(nilfs, segnum, &seg_start, &seg_end);
907 pseg_start = seg_start;
908 }
909
910 super_root_found:
911 /* Updating pointers relating to the latest checkpoint */
Ryusuke Konishi0935db72009-11-29 02:39:11 +0900912 list_splice_tail(&segments, &ri->ri_used_segments);
Ryusuke Konishi0f3e1c72009-04-06 19:01:38 -0700913 nilfs->ns_last_pseg = sr_pseg_start;
914 nilfs->ns_last_seq = nilfs->ns_seg_seq;
915 nilfs->ns_last_cno = ri->ri_cno;
916 return 0;
917
918 failed:
919 nilfs_dispose_segment_list(&segments);
920 return (ret < 0) ? ret : nilfs_warn_segment_error(ret);
921}