err.no Git - linux-2.6/blob - fs/gfs2/recovery.c

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