Blame view
fs/gfs2/recovery.c
14 KB
b3b94faa5
|
1 2 |
/* * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. |
3a8a9a103
|
3 |
* Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved. |
b3b94faa5
|
4 5 6 |
* * This copyrighted material is made available to anyone wishing to use, * modify, copy, or redistribute it subject to the terms and conditions |
e9fc2aa09
|
7 |
* of the GNU General Public License version 2. |
b3b94faa5
|
8 |
*/ |
1c2ea8a2c
|
9 |
#include <linux/module.h> |
b3b94faa5
|
10 11 12 13 |
#include <linux/slab.h> #include <linux/spinlock.h> #include <linux/completion.h> #include <linux/buffer_head.h> |
5c676f6d3
|
14 |
#include <linux/gfs2_ondisk.h> |
71b86f562
|
15 |
#include <linux/crc32.h> |
b3b94faa5
|
16 17 |
#include "gfs2.h" |
5c676f6d3
|
18 |
#include "incore.h" |
b3b94faa5
|
19 20 21 |
#include "bmap.h" #include "glock.h" #include "glops.h" |
b3b94faa5
|
22 23 24 25 |
#include "lops.h" #include "meta_io.h" #include "recovery.h" #include "super.h" |
5c676f6d3
|
26 |
#include "util.h" |
71b86f562
|
27 |
#include "dir.h" |
b3b94faa5
|
28 |
|
6ecd7c2dd
|
29 |
struct workqueue_struct *gfs_recovery_wq; |
b3b94faa5
|
30 31 32 |
int gfs2_replay_read_block(struct gfs2_jdesc *jd, unsigned int blk, struct buffer_head **bh) { |
feaa7bba0
|
33 |
struct gfs2_inode *ip = GFS2_I(jd->jd_inode); |
5c676f6d3
|
34 |
struct gfs2_glock *gl = ip->i_gl; |
b3b94faa5
|
35 |
int new = 0; |
cd915493f
|
36 37 |
u64 dblock; u32 extlen; |
b3b94faa5
|
38 |
int error; |
feaa7bba0
|
39 |
error = gfs2_extent_map(&ip->i_inode, blk, &new, &dblock, &extlen); |
b3b94faa5
|
40 41 42 |
if (error) return error; if (!dblock) { |
5c676f6d3
|
43 |
gfs2_consist_inode(ip); |
b3b94faa5
|
44 45 |
return -EIO; } |
7276b3b0c
|
46 |
*bh = gfs2_meta_ra(gl, dblock, extlen); |
b3b94faa5
|
47 48 49 |
return error; } |
cd915493f
|
50 |
int gfs2_revoke_add(struct gfs2_sbd *sdp, u64 blkno, unsigned int where) |
b3b94faa5
|
51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 |
{ struct list_head *head = &sdp->sd_revoke_list; struct gfs2_revoke_replay *rr; int found = 0; list_for_each_entry(rr, head, rr_list) { if (rr->rr_blkno == blkno) { found = 1; break; } } if (found) { rr->rr_where = where; return 0; } |
16c5f06f1
|
67 |
rr = kmalloc(sizeof(struct gfs2_revoke_replay), GFP_NOFS); |
b3b94faa5
|
68 69 70 71 72 73 74 75 76 |
if (!rr) return -ENOMEM; rr->rr_blkno = blkno; rr->rr_where = where; list_add(&rr->rr_list, head); return 1; } |
cd915493f
|
77 |
int gfs2_revoke_check(struct gfs2_sbd *sdp, u64 blkno, unsigned int where) |
b3b94faa5
|
78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 |
{ struct gfs2_revoke_replay *rr; int wrap, a, b, revoke; int found = 0; list_for_each_entry(rr, &sdp->sd_revoke_list, rr_list) { if (rr->rr_blkno == blkno) { found = 1; break; } } if (!found) return 0; wrap = (rr->rr_where < sdp->sd_replay_tail); a = (sdp->sd_replay_tail < where); b = (where < rr->rr_where); revoke = (wrap) ? (a || b) : (a && b); return revoke; } void gfs2_revoke_clean(struct gfs2_sbd *sdp) { struct list_head *head = &sdp->sd_revoke_list; struct gfs2_revoke_replay *rr; while (!list_empty(head)) { rr = list_entry(head->next, struct gfs2_revoke_replay, rr_list); list_del(&rr->rr_list); kfree(rr); } } |
bb8d8a6f5
|
112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 |
static int gfs2_log_header_in(struct gfs2_log_header_host *lh, const void *buf) { const struct gfs2_log_header *str = buf; if (str->lh_header.mh_magic != cpu_to_be32(GFS2_MAGIC) || str->lh_header.mh_type != cpu_to_be32(GFS2_METATYPE_LH)) return 1; lh->lh_sequence = be64_to_cpu(str->lh_sequence); lh->lh_flags = be32_to_cpu(str->lh_flags); lh->lh_tail = be32_to_cpu(str->lh_tail); lh->lh_blkno = be32_to_cpu(str->lh_blkno); lh->lh_hash = be32_to_cpu(str->lh_hash); return 0; } |
b3b94faa5
|
127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 |
/** * get_log_header - read the log header for a given segment * @jd: the journal * @blk: the block to look at * @lh: the log header to return * * Read the log header for a given segement in a given journal. Do a few * sanity checks on it. * * Returns: 0 on success, * 1 if the header was invalid or incomplete, * errno on error */ static int get_log_header(struct gfs2_jdesc *jd, unsigned int blk, |
551676226
|
142 |
struct gfs2_log_header_host *head) |
b3b94faa5
|
143 144 |
{ struct buffer_head *bh; |
f5a8cd020
|
145 |
struct gfs2_log_header_host uninitialized_var(lh); |
887bc5d00
|
146 |
const u32 nothing = 0; |
cd915493f
|
147 |
u32 hash; |
b3b94faa5
|
148 149 150 151 152 |
int error; error = gfs2_replay_read_block(jd, blk, &bh); if (error) return error; |
2a2c98247
|
153 154 155 156 |
hash = crc32_le((u32)~0, bh->b_data, sizeof(struct gfs2_log_header) - sizeof(u32)); hash = crc32_le(hash, (unsigned char const *)¬hing, sizeof(nothing)); hash ^= (u32)~0; |
bb8d8a6f5
|
157 |
error = gfs2_log_header_in(&lh, bh->b_data); |
b3b94faa5
|
158 |
brelse(bh); |
bb8d8a6f5
|
159 |
if (error || lh.lh_blkno != blk || lh.lh_hash != hash) |
b3b94faa5
|
160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 |
return 1; *head = lh; return 0; } /** * find_good_lh - find a good log header * @jd: the journal * @blk: the segment to start searching from * @lh: the log header to fill in * @forward: if true search forward in the log, else search backward * * Call get_log_header() to get a log header for a segment, but if the * segment is bad, either scan forward or backward until we find a good one. * * Returns: errno */ static int find_good_lh(struct gfs2_jdesc *jd, unsigned int *blk, |
551676226
|
181 |
struct gfs2_log_header_host *head) |
b3b94faa5
|
182 183 184 185 186 187 188 189 190 191 192 193 194 |
{ unsigned int orig_blk = *blk; int error; for (;;) { error = get_log_header(jd, *blk, head); if (error <= 0) return error; if (++*blk == jd->jd_blocks) *blk = 0; if (*blk == orig_blk) { |
feaa7bba0
|
195 |
gfs2_consist_inode(GFS2_I(jd->jd_inode)); |
b3b94faa5
|
196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 |
return -EIO; } } } /** * jhead_scan - make sure we've found the head of the log * @jd: the journal * @head: this is filled in with the log descriptor of the head * * At this point, seg and lh should be either the head of the log or just * before. Scan forward until we find the head. * * Returns: errno */ |
551676226
|
211 |
static int jhead_scan(struct gfs2_jdesc *jd, struct gfs2_log_header_host *head) |
b3b94faa5
|
212 213 |
{ unsigned int blk = head->lh_blkno; |
551676226
|
214 |
struct gfs2_log_header_host lh; |
b3b94faa5
|
215 216 217 218 219 220 221 222 223 224 225 226 227 |
int error; for (;;) { if (++blk == jd->jd_blocks) blk = 0; error = get_log_header(jd, blk, &lh); if (error < 0) return error; if (error == 1) continue; if (lh.lh_sequence == head->lh_sequence) { |
feaa7bba0
|
228 |
gfs2_consist_inode(GFS2_I(jd->jd_inode)); |
b3b94faa5
|
229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 |
return -EIO; } if (lh.lh_sequence < head->lh_sequence) break; *head = lh; } return 0; } /** * gfs2_find_jhead - find the head of a log * @jd: the journal * @head: the log descriptor for the head of the log is returned here * * Do a binary search of a journal and find the valid log entry with the * highest sequence number. (i.e. the log head) * * Returns: errno */ |
551676226
|
250 |
int gfs2_find_jhead(struct gfs2_jdesc *jd, struct gfs2_log_header_host *head) |
b3b94faa5
|
251 |
{ |
551676226
|
252 |
struct gfs2_log_header_host lh_1, lh_m; |
cd915493f
|
253 |
u32 blk_1, blk_2, blk_m; |
b3b94faa5
|
254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 |
int error; blk_1 = 0; blk_2 = jd->jd_blocks - 1; for (;;) { blk_m = (blk_1 + blk_2) / 2; error = find_good_lh(jd, &blk_1, &lh_1); if (error) return error; error = find_good_lh(jd, &blk_m, &lh_m); if (error) return error; if (blk_1 == blk_m || blk_m == blk_2) break; if (lh_1.lh_sequence <= lh_m.lh_sequence) blk_1 = blk_m; else blk_2 = blk_m; } error = jhead_scan(jd, &lh_1); if (error) return error; *head = lh_1; return error; } /** * foreach_descriptor - go through the active part of the log * @jd: the journal * @start: the first log header in the active region * @end: the last log header (don't process the contents of this entry)) * * Call a given function once for every log descriptor in the active * portion of the log. * * Returns: errno */ static int foreach_descriptor(struct gfs2_jdesc *jd, unsigned int start, unsigned int end, int pass) { |
feaa7bba0
|
303 |
struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode); |
b3b94faa5
|
304 305 306 307 308 309 |
struct buffer_head *bh; struct gfs2_log_descriptor *ld; int error = 0; u32 length; __be64 *ptr; unsigned int offset = sizeof(struct gfs2_log_descriptor); |
a67cdbd45
|
310 311 |
offset += sizeof(__be64) - 1; offset &= ~(sizeof(__be64) - 1); |
b3b94faa5
|
312 313 314 315 316 317 318 319 320 321 322 |
while (start != end) { error = gfs2_replay_read_block(jd, start, &bh); if (error) return error; if (gfs2_meta_check(sdp, bh)) { brelse(bh); return -EIO; } ld = (struct gfs2_log_descriptor *)bh->b_data; length = be32_to_cpu(ld->ld_length); |
e3167ded1
|
323 |
if (be32_to_cpu(ld->ld_header.mh_type) == GFS2_METATYPE_LH) { |
551676226
|
324 |
struct gfs2_log_header_host lh; |
b3b94faa5
|
325 326 327 |
error = get_log_header(jd, start, &lh); if (!error) { gfs2_replay_incr_blk(sdp, &start); |
887218778
|
328 |
brelse(bh); |
b3b94faa5
|
329 330 331 |
continue; } if (error == 1) { |
feaa7bba0
|
332 |
gfs2_consist_inode(GFS2_I(jd->jd_inode)); |
b3b94faa5
|
333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 |
error = -EIO; } brelse(bh); return error; } else if (gfs2_metatype_check(sdp, bh, GFS2_METATYPE_LD)) { brelse(bh); return -EIO; } ptr = (__be64 *)(bh->b_data + offset); error = lops_scan_elements(jd, start, ld, ptr, pass); if (error) { brelse(bh); return error; } while (length--) gfs2_replay_incr_blk(sdp, &start); brelse(bh); } return 0; } /** * clean_journal - mark a dirty journal as being clean * @sdp: the filesystem * @jd: the journal * @gl: the journal's glock * @head: the head journal to start from * * Returns: errno */ |
551676226
|
366 |
static int clean_journal(struct gfs2_jdesc *jd, struct gfs2_log_header_host *head) |
b3b94faa5
|
367 |
{ |
feaa7bba0
|
368 369 |
struct gfs2_inode *ip = GFS2_I(jd->jd_inode); struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode); |
b3b94faa5
|
370 |
unsigned int lblock; |
b3b94faa5
|
371 |
struct gfs2_log_header *lh; |
cd915493f
|
372 |
u32 hash; |
b3b94faa5
|
373 374 |
struct buffer_head *bh; int error; |
23591256d
|
375 |
struct buffer_head bh_map = { .b_state = 0, .b_blocknr = 0 }; |
fd88de569
|
376 |
|
b3b94faa5
|
377 378 |
lblock = head->lh_blkno; gfs2_replay_incr_blk(sdp, &lblock); |
23591256d
|
379 |
bh_map.b_size = 1 << ip->i_inode.i_blkbits; |
e9e1ef2b6
|
380 |
error = gfs2_block_map(&ip->i_inode, lblock, &bh_map, 0); |
b3b94faa5
|
381 382 |
if (error) return error; |
7a6bbacbb
|
383 |
if (!bh_map.b_blocknr) { |
b3b94faa5
|
384 385 386 |
gfs2_consist_inode(ip); return -EIO; } |
7a6bbacbb
|
387 |
bh = sb_getblk(sdp->sd_vfs, bh_map.b_blocknr); |
b3b94faa5
|
388 389 390 391 392 393 394 395 396 |
lock_buffer(bh); memset(bh->b_data, 0, bh->b_size); set_buffer_uptodate(bh); clear_buffer_dirty(bh); unlock_buffer(bh); lh = (struct gfs2_log_header *)bh->b_data; memset(lh, 0, sizeof(struct gfs2_log_header)); lh->lh_header.mh_magic = cpu_to_be32(GFS2_MAGIC); |
887218778
|
397 |
lh->lh_header.mh_type = cpu_to_be32(GFS2_METATYPE_LH); |
0ab7d13fc
|
398 |
lh->lh_header.__pad0 = cpu_to_be64(0); |
e3167ded1
|
399 |
lh->lh_header.mh_format = cpu_to_be32(GFS2_FORMAT_LH); |
0ab7d13fc
|
400 |
lh->lh_header.mh_jid = cpu_to_be32(sdp->sd_jdesc->jd_jid); |
b3b94faa5
|
401 402 403 404 405 406 407 408 409 410 411 412 413 |
lh->lh_sequence = cpu_to_be64(head->lh_sequence + 1); lh->lh_flags = cpu_to_be32(GFS2_LOG_HEAD_UNMOUNT); lh->lh_blkno = cpu_to_be32(lblock); hash = gfs2_disk_hash((const char *)lh, sizeof(struct gfs2_log_header)); lh->lh_hash = cpu_to_be32(hash); set_buffer_dirty(bh); if (sync_dirty_buffer(bh)) gfs2_io_error_bh(sdp, bh); brelse(bh); return error; } |
da755fdb4
|
414 |
|
f057f6cdf
|
415 416 |
static void gfs2_recovery_done(struct gfs2_sbd *sdp, unsigned int jid, unsigned int message) |
da755fdb4
|
417 |
{ |
f057f6cdf
|
418 419 420 421 422 423 424 425 426 427 |
char env_jid[20]; char env_status[20]; char *envp[] = { env_jid, env_status, NULL }; struct lm_lockstruct *ls = &sdp->sd_lockstruct; ls->ls_recover_jid_done = jid; ls->ls_recover_jid_status = message; sprintf(env_jid, "JID=%d", jid); sprintf(env_status, "RECOVERY=%s", message == LM_RD_SUCCESS ? "Done" : "Failed"); kobject_uevent_env(&sdp->sd_kobj, KOBJ_CHANGE, envp); |
da755fdb4
|
428 |
} |
6ecd7c2dd
|
429 |
void gfs2_recover_func(struct work_struct *work) |
b3b94faa5
|
430 |
{ |
fe64d517d
|
431 |
struct gfs2_jdesc *jd = container_of(work, struct gfs2_jdesc, jd_work); |
feaa7bba0
|
432 433 |
struct gfs2_inode *ip = GFS2_I(jd->jd_inode); struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode); |
551676226
|
434 |
struct gfs2_log_header_host head; |
b3b94faa5
|
435 436 437 438 439 |
struct gfs2_holder j_gh, ji_gh, t_gh; unsigned long t; int ro = 0; unsigned int pass; int error; |
5965b1f47
|
440 441 442 443 |
if (jd->jd_jid != sdp->sd_lockstruct.ls_jid) { fs_info(sdp, "jid=%u: Trying to acquire journal lock... ", jd->jd_jid); |
b3b94faa5
|
444 |
|
c78bad11f
|
445 |
/* Acquire the journal lock so we can do recovery */ |
b3b94faa5
|
446 |
|
5965b1f47
|
447 448 449 450 451 452 453 |
error = gfs2_glock_nq_num(sdp, jd->jd_jid, &gfs2_journal_glops, LM_ST_EXCLUSIVE, LM_FLAG_NOEXP | LM_FLAG_TRY | GL_NOCACHE, &j_gh); switch (error) { case 0: break; |
907b9bceb
|
454 |
|
5965b1f47
|
455 456 457 458 |
case GLR_TRYFAILED: fs_info(sdp, "jid=%u: Busy ", jd->jd_jid); error = 0; |
907b9bceb
|
459 |
|
5965b1f47
|
460 461 462 |
default: goto fail; }; |
b3b94faa5
|
463 |
|
5965b1f47
|
464 |
error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, |
75be73a82
|
465 |
LM_FLAG_NOEXP | GL_NOCACHE, &ji_gh); |
5965b1f47
|
466 467 468 469 470 471 |
if (error) goto fail_gunlock_j; } else { fs_info(sdp, "jid=%u, already locked for use ", jd->jd_jid); } |
b3b94faa5
|
472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 |
fs_info(sdp, "jid=%u: Looking at journal... ", jd->jd_jid); error = gfs2_jdesc_check(jd); if (error) goto fail_gunlock_ji; error = gfs2_find_jhead(jd, &head); if (error) goto fail_gunlock_ji; if (!(head.lh_flags & GFS2_LOG_HEAD_UNMOUNT)) { fs_info(sdp, "jid=%u: Acquiring the transaction lock... ", jd->jd_jid); t = jiffies; /* Acquire a shared hold on the transaction lock */ |
59a1cc6bd
|
492 |
error = gfs2_glock_nq_init(sdp->sd_trans_gl, LM_ST_SHARED, |
5965b1f47
|
493 |
LM_FLAG_NOEXP | LM_FLAG_PRIORITY | |
6802e3400
|
494 |
GL_NOCACHE, &t_gh); |
b3b94faa5
|
495 496 497 498 499 500 501 |
if (error) goto fail_gunlock_ji; if (test_bit(SDF_JOURNAL_CHECKED, &sdp->sd_flags)) { if (!test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags)) ro = 1; } else { |
7bc5c414f
|
502 503 504 505 506 507 508 509 510 511 512 513 |
if (sdp->sd_vfs->s_flags & MS_RDONLY) { /* check if device itself is read-only */ ro = bdev_read_only(sdp->sd_vfs->s_bdev); if (!ro) { fs_info(sdp, "recovery required on " "read-only filesystem. "); fs_info(sdp, "write access will be " "enabled during recovery. "); } } |
b3b94faa5
|
514 515 516 |
} if (ro) { |
7bc5c414f
|
517 518 519 |
fs_warn(sdp, "jid=%u: Can't replay: read-only block " "device ", jd->jd_jid); |
b3b94faa5
|
520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 |
error = -EROFS; goto fail_gunlock_tr; } fs_info(sdp, "jid=%u: Replaying journal... ", jd->jd_jid); for (pass = 0; pass < 2; pass++) { lops_before_scan(jd, &head, pass); error = foreach_descriptor(jd, head.lh_tail, head.lh_blkno, pass); lops_after_scan(jd, error, pass); if (error) goto fail_gunlock_tr; } error = clean_journal(jd, &head); if (error) goto fail_gunlock_tr; gfs2_glock_dq_uninit(&t_gh); |
5c676f6d3
|
541 |
t = DIV_ROUND_UP(jiffies - t, HZ); |
b3b94faa5
|
542 543 544 545 |
fs_info(sdp, "jid=%u: Journal replayed in %lus ", jd->jd_jid, t); } |
5965b1f47
|
546 547 |
if (jd->jd_jid != sdp->sd_lockstruct.ls_jid) gfs2_glock_dq_uninit(&ji_gh); |
b3b94faa5
|
548 |
|
f057f6cdf
|
549 |
gfs2_recovery_done(sdp, jd->jd_jid, LM_RD_SUCCESS); |
b3b94faa5
|
550 |
|
5965b1f47
|
551 552 |
if (jd->jd_jid != sdp->sd_lockstruct.ls_jid) gfs2_glock_dq_uninit(&j_gh); |
b3b94faa5
|
553 554 555 |
fs_info(sdp, "jid=%u: Done ", jd->jd_jid); |
6ecd7c2dd
|
556 |
goto done; |
b3b94faa5
|
557 |
|
5965b1f47
|
558 |
fail_gunlock_tr: |
b3b94faa5
|
559 |
gfs2_glock_dq_uninit(&t_gh); |
5965b1f47
|
560 561 562 563 564 565 |
fail_gunlock_ji: if (jd->jd_jid != sdp->sd_lockstruct.ls_jid) { gfs2_glock_dq_uninit(&ji_gh); fail_gunlock_j: gfs2_glock_dq_uninit(&j_gh); } |
b3b94faa5
|
566 567 568 |
fs_info(sdp, "jid=%u: %s ", jd->jd_jid, (error) ? "Failed" : "Done"); |
5965b1f47
|
569 |
fail: |
f057f6cdf
|
570 |
gfs2_recovery_done(sdp, jd->jd_jid, LM_RD_GAVEUP); |
6ecd7c2dd
|
571 572 573 574 |
done: clear_bit(JDF_RECOVERY, &jd->jd_flags); smp_mb__after_clear_bit(); wake_up_bit(&jd->jd_flags, JDF_RECOVERY); |
b3b94faa5
|
575 |
} |
fe64d517d
|
576 |
static int gfs2_recovery_wait(void *word) |
b3b94faa5
|
577 |
{ |
fe64d517d
|
578 579 |
schedule(); return 0; |
b3b94faa5
|
580 |
} |
6ecd7c2dd
|
581 |
int gfs2_recover_journal(struct gfs2_jdesc *jd, bool wait) |
9ac1b4d9b
|
582 |
{ |
fe64d517d
|
583 |
int rv; |
6ecd7c2dd
|
584 585 586 587 588 589 590 591 592 593 594 |
if (test_and_set_bit(JDF_RECOVERY, &jd->jd_flags)) return -EBUSY; /* we have JDF_RECOVERY, queue should always succeed */ rv = queue_work(gfs_recovery_wq, &jd->jd_work); BUG_ON(!rv); if (wait) wait_on_bit(&jd->jd_flags, JDF_RECOVERY, gfs2_recovery_wait, TASK_UNINTERRUPTIBLE); |
9ac1b4d9b
|
595 596 |
return 0; } |