1 /* 2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. 3 * Copyright (C) 2004-2006 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 version 2. 8 */ 9 10 #include <linux/module.h> 11 #include <linux/slab.h> 12 #include <linux/spinlock.h> 13 #include <linux/completion.h> 14 #include <linux/buffer_head.h> 15 #include <linux/gfs2_ondisk.h> 16 #include <linux/crc32.h> 17 #include <linux/crc32c.h> 18 #include <linux/ktime.h> 19 20 #include "gfs2.h" 21 #include "incore.h" 22 #include "bmap.h" 23 #include "glock.h" 24 #include "glops.h" 25 #include "log.h" 26 #include "lops.h" 27 #include "meta_io.h" 28 #include "recovery.h" 29 #include "super.h" 30 #include "util.h" 31 #include "dir.h" 32 33 struct workqueue_struct *gfs_recovery_wq; 34 35 int gfs2_replay_read_block(struct gfs2_jdesc *jd, unsigned int blk, 36 struct buffer_head **bh) 37 { 38 struct gfs2_inode *ip = GFS2_I(jd->jd_inode); 39 struct gfs2_glock *gl = ip->i_gl; 40 int new = 0; 41 u64 dblock; 42 u32 extlen; 43 int error; 44 45 error = gfs2_extent_map(&ip->i_inode, blk, &new, &dblock, &extlen); 46 if (error) 47 return error; 48 if (!dblock) { 49 gfs2_consist_inode(ip); 50 return -EIO; 51 } 52 53 *bh = gfs2_meta_ra(gl, dblock, extlen); 54 55 return error; 56 } 57 58 int gfs2_revoke_add(struct gfs2_jdesc *jd, u64 blkno, unsigned int where) 59 { 60 struct list_head *head = &jd->jd_revoke_list; 61 struct gfs2_revoke_replay *rr; 62 int found = 0; 63 64 list_for_each_entry(rr, head, rr_list) { 65 if (rr->rr_blkno == blkno) { 66 found = 1; 67 break; 68 } 69 } 70 71 if (found) { 72 rr->rr_where = where; 73 return 0; 74 } 75 76 rr = kmalloc(sizeof(struct gfs2_revoke_replay), GFP_NOFS); 77 if (!rr) 78 return -ENOMEM; 79 80 rr->rr_blkno = blkno; 81 rr->rr_where = where; 82 list_add(&rr->rr_list, head); 83 84 return 1; 85 } 86 87 int gfs2_revoke_check(struct gfs2_jdesc *jd, u64 blkno, unsigned int where) 88 { 89 struct gfs2_revoke_replay *rr; 90 int wrap, a, b, revoke; 91 int found = 0; 92 93 list_for_each_entry(rr, &jd->jd_revoke_list, rr_list) { 94 if (rr->rr_blkno == blkno) { 95 found = 1; 96 break; 97 } 98 } 99 100 if (!found) 101 return 0; 102 103 wrap = (rr->rr_where < jd->jd_replay_tail); 104 a = (jd->jd_replay_tail < where); 105 b = (where < rr->rr_where); 106 revoke = (wrap) ? (a || b) : (a && b); 107 108 return revoke; 109 } 110 111 void gfs2_revoke_clean(struct gfs2_jdesc *jd) 112 { 113 struct list_head *head = &jd->jd_revoke_list; 114 struct gfs2_revoke_replay *rr; 115 116 while (!list_empty(head)) { 117 rr = list_entry(head->next, struct gfs2_revoke_replay, rr_list); 118 list_del(&rr->rr_list); 119 kfree(rr); 120 } 121 } 122 123 int __get_log_header(struct gfs2_sbd *sdp, const struct gfs2_log_header *lh, 124 unsigned int blkno, struct gfs2_log_header_host *head) 125 { 126 u32 hash, crc; 127 128 if (lh->lh_header.mh_magic != cpu_to_be32(GFS2_MAGIC) || 129 lh->lh_header.mh_type != cpu_to_be32(GFS2_METATYPE_LH) || 130 (blkno && be32_to_cpu(lh->lh_blkno) != blkno)) 131 return 1; 132 133 hash = crc32(~0, lh, LH_V1_SIZE - 4); 134 hash = ~crc32_le_shift(hash, 4); /* assume lh_hash is zero */ 135 136 if (be32_to_cpu(lh->lh_hash) != hash) 137 return 1; 138 139 crc = crc32c(~0, (void *)lh + LH_V1_SIZE + 4, 140 sdp->sd_sb.sb_bsize - LH_V1_SIZE - 4); 141 142 if ((lh->lh_crc != 0 && be32_to_cpu(lh->lh_crc) != crc)) 143 return 1; 144 145 head->lh_sequence = be64_to_cpu(lh->lh_sequence); 146 head->lh_flags = be32_to_cpu(lh->lh_flags); 147 head->lh_tail = be32_to_cpu(lh->lh_tail); 148 head->lh_blkno = be32_to_cpu(lh->lh_blkno); 149 150 return 0; 151 } 152 /** 153 * get_log_header - read the log header for a given segment 154 * @jd: the journal 155 * @blk: the block to look at 156 * @lh: the log header to return 157 * 158 * Read the log header for a given segement in a given journal. Do a few 159 * sanity checks on it. 160 * 161 * Returns: 0 on success, 162 * 1 if the header was invalid or incomplete, 163 * errno on error 164 */ 165 166 static int get_log_header(struct gfs2_jdesc *jd, unsigned int blk, 167 struct gfs2_log_header_host *head) 168 { 169 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode); 170 struct buffer_head *bh; 171 int error; 172 173 error = gfs2_replay_read_block(jd, blk, &bh); 174 if (error) 175 return error; 176 177 error = __get_log_header(sdp, (const struct gfs2_log_header *)bh->b_data, 178 blk, head); 179 brelse(bh); 180 181 return error; 182 } 183 184 /** 185 * foreach_descriptor - go through the active part of the log 186 * @jd: the journal 187 * @start: the first log header in the active region 188 * @end: the last log header (don't process the contents of this entry)) 189 * 190 * Call a given function once for every log descriptor in the active 191 * portion of the log. 192 * 193 * Returns: errno 194 */ 195 196 static int foreach_descriptor(struct gfs2_jdesc *jd, u32 start, 197 unsigned int end, int pass) 198 { 199 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode); 200 struct buffer_head *bh; 201 struct gfs2_log_descriptor *ld; 202 int error = 0; 203 u32 length; 204 __be64 *ptr; 205 unsigned int offset = sizeof(struct gfs2_log_descriptor); 206 offset += sizeof(__be64) - 1; 207 offset &= ~(sizeof(__be64) - 1); 208 209 while (start != end) { 210 error = gfs2_replay_read_block(jd, start, &bh); 211 if (error) 212 return error; 213 if (gfs2_meta_check(sdp, bh)) { 214 brelse(bh); 215 return -EIO; 216 } 217 ld = (struct gfs2_log_descriptor *)bh->b_data; 218 length = be32_to_cpu(ld->ld_length); 219 220 if (be32_to_cpu(ld->ld_header.mh_type) == GFS2_METATYPE_LH) { 221 struct gfs2_log_header_host lh; 222 error = get_log_header(jd, start, &lh); 223 if (!error) { 224 gfs2_replay_incr_blk(jd, &start); 225 brelse(bh); 226 continue; 227 } 228 if (error == 1) { 229 gfs2_consist_inode(GFS2_I(jd->jd_inode)); 230 error = -EIO; 231 } 232 brelse(bh); 233 return error; 234 } else if (gfs2_metatype_check(sdp, bh, GFS2_METATYPE_LD)) { 235 brelse(bh); 236 return -EIO; 237 } 238 ptr = (__be64 *)(bh->b_data + offset); 239 error = lops_scan_elements(jd, start, ld, ptr, pass); 240 if (error) { 241 brelse(bh); 242 return error; 243 } 244 245 while (length--) 246 gfs2_replay_incr_blk(jd, &start); 247 248 brelse(bh); 249 } 250 251 return 0; 252 } 253 254 /** 255 * clean_journal - mark a dirty journal as being clean 256 * @jd: the journal 257 * @head: the head journal to start from 258 * 259 * Returns: errno 260 */ 261 262 static void clean_journal(struct gfs2_jdesc *jd, 263 struct gfs2_log_header_host *head) 264 { 265 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode); 266 u32 lblock = head->lh_blkno; 267 268 gfs2_replay_incr_blk(jd, &lblock); 269 if (jd->jd_jid == sdp->sd_lockstruct.ls_jid) 270 sdp->sd_log_flush_head = lblock; 271 gfs2_write_log_header(sdp, jd, head->lh_sequence + 1, 0, lblock, 272 GFS2_LOG_HEAD_UNMOUNT | GFS2_LOG_HEAD_RECOVERY, 273 REQ_PREFLUSH | REQ_FUA | REQ_META | REQ_SYNC); 274 } 275 276 277 static void gfs2_recovery_done(struct gfs2_sbd *sdp, unsigned int jid, 278 unsigned int message) 279 { 280 char env_jid[20]; 281 char env_status[20]; 282 char *envp[] = { env_jid, env_status, NULL }; 283 struct lm_lockstruct *ls = &sdp->sd_lockstruct; 284 285 ls->ls_recover_jid_done = jid; 286 ls->ls_recover_jid_status = message; 287 sprintf(env_jid, "JID=%u", jid); 288 sprintf(env_status, "RECOVERY=%s", 289 message == LM_RD_SUCCESS ? "Done" : "Failed"); 290 kobject_uevent_env(&sdp->sd_kobj, KOBJ_CHANGE, envp); 291 292 if (sdp->sd_lockstruct.ls_ops->lm_recovery_result) 293 sdp->sd_lockstruct.ls_ops->lm_recovery_result(sdp, jid, message); 294 } 295 296 void gfs2_recover_func(struct work_struct *work) 297 { 298 struct gfs2_jdesc *jd = container_of(work, struct gfs2_jdesc, jd_work); 299 struct gfs2_inode *ip = GFS2_I(jd->jd_inode); 300 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode); 301 struct gfs2_log_header_host head; 302 struct gfs2_holder j_gh, ji_gh, thaw_gh; 303 ktime_t t_start, t_jlck, t_jhd, t_tlck, t_rep; 304 int ro = 0; 305 unsigned int pass; 306 int error = 0; 307 int jlocked = 0; 308 309 t_start = ktime_get(); 310 if (sdp->sd_args.ar_spectator) 311 goto fail; 312 if (jd->jd_jid != sdp->sd_lockstruct.ls_jid) { 313 fs_info(sdp, "jid=%u: Trying to acquire journal lock...\n", 314 jd->jd_jid); 315 jlocked = 1; 316 /* Acquire the journal lock so we can do recovery */ 317 318 error = gfs2_glock_nq_num(sdp, jd->jd_jid, &gfs2_journal_glops, 319 LM_ST_EXCLUSIVE, 320 LM_FLAG_NOEXP | LM_FLAG_TRY | GL_NOCACHE, 321 &j_gh); 322 switch (error) { 323 case 0: 324 break; 325 326 case GLR_TRYFAILED: 327 fs_info(sdp, "jid=%u: Busy\n", jd->jd_jid); 328 error = 0; 329 330 default: 331 goto fail; 332 }; 333 334 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 335 LM_FLAG_NOEXP | GL_NOCACHE, &ji_gh); 336 if (error) 337 goto fail_gunlock_j; 338 } else { 339 fs_info(sdp, "jid=%u, already locked for use\n", jd->jd_jid); 340 } 341 342 t_jlck = ktime_get(); 343 fs_info(sdp, "jid=%u: Looking at journal...\n", jd->jd_jid); 344 345 error = gfs2_jdesc_check(jd); 346 if (error) 347 goto fail_gunlock_ji; 348 349 error = gfs2_find_jhead(jd, &head, true); 350 if (error) 351 goto fail_gunlock_ji; 352 t_jhd = ktime_get(); 353 fs_info(sdp, "jid=%u: Journal head lookup took %lldms\n", jd->jd_jid, 354 ktime_ms_delta(t_jhd, t_jlck)); 355 356 if (!(head.lh_flags & GFS2_LOG_HEAD_UNMOUNT)) { 357 fs_info(sdp, "jid=%u: Acquiring the transaction lock...\n", 358 jd->jd_jid); 359 360 /* Acquire a shared hold on the freeze lock */ 361 362 error = gfs2_glock_nq_init(sdp->sd_freeze_gl, LM_ST_SHARED, 363 LM_FLAG_NOEXP | LM_FLAG_PRIORITY, 364 &thaw_gh); 365 if (error) 366 goto fail_gunlock_ji; 367 368 if (test_bit(SDF_RORECOVERY, &sdp->sd_flags)) { 369 ro = 1; 370 } else if (test_bit(SDF_JOURNAL_CHECKED, &sdp->sd_flags)) { 371 if (!test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags)) 372 ro = 1; 373 } else { 374 if (sb_rdonly(sdp->sd_vfs)) { 375 /* check if device itself is read-only */ 376 ro = bdev_read_only(sdp->sd_vfs->s_bdev); 377 if (!ro) { 378 fs_info(sdp, "recovery required on " 379 "read-only filesystem.\n"); 380 fs_info(sdp, "write access will be " 381 "enabled during recovery.\n"); 382 } 383 } 384 } 385 386 if (ro) { 387 fs_warn(sdp, "jid=%u: Can't replay: read-only block " 388 "device\n", jd->jd_jid); 389 error = -EROFS; 390 goto fail_gunlock_thaw; 391 } 392 393 t_tlck = ktime_get(); 394 fs_info(sdp, "jid=%u: Replaying journal...\n", jd->jd_jid); 395 396 for (pass = 0; pass < 2; pass++) { 397 lops_before_scan(jd, &head, pass); 398 error = foreach_descriptor(jd, head.lh_tail, 399 head.lh_blkno, pass); 400 lops_after_scan(jd, error, pass); 401 if (error) 402 goto fail_gunlock_thaw; 403 } 404 405 clean_journal(jd, &head); 406 407 gfs2_glock_dq_uninit(&thaw_gh); 408 t_rep = ktime_get(); 409 fs_info(sdp, "jid=%u: Journal replayed in %lldms [jlck:%lldms, " 410 "jhead:%lldms, tlck:%lldms, replay:%lldms]\n", 411 jd->jd_jid, ktime_ms_delta(t_rep, t_start), 412 ktime_ms_delta(t_jlck, t_start), 413 ktime_ms_delta(t_jhd, t_jlck), 414 ktime_ms_delta(t_tlck, t_jhd), 415 ktime_ms_delta(t_rep, t_tlck)); 416 } 417 418 gfs2_recovery_done(sdp, jd->jd_jid, LM_RD_SUCCESS); 419 420 if (jlocked) { 421 gfs2_glock_dq_uninit(&ji_gh); 422 gfs2_glock_dq_uninit(&j_gh); 423 } 424 425 fs_info(sdp, "jid=%u: Done\n", jd->jd_jid); 426 goto done; 427 428 fail_gunlock_thaw: 429 gfs2_glock_dq_uninit(&thaw_gh); 430 fail_gunlock_ji: 431 if (jlocked) { 432 gfs2_glock_dq_uninit(&ji_gh); 433 fail_gunlock_j: 434 gfs2_glock_dq_uninit(&j_gh); 435 } 436 437 fs_info(sdp, "jid=%u: %s\n", jd->jd_jid, (error) ? "Failed" : "Done"); 438 fail: 439 jd->jd_recover_error = error; 440 gfs2_recovery_done(sdp, jd->jd_jid, LM_RD_GAVEUP); 441 done: 442 clear_bit(JDF_RECOVERY, &jd->jd_flags); 443 smp_mb__after_atomic(); 444 wake_up_bit(&jd->jd_flags, JDF_RECOVERY); 445 } 446 447 int gfs2_recover_journal(struct gfs2_jdesc *jd, bool wait) 448 { 449 int rv; 450 451 if (test_and_set_bit(JDF_RECOVERY, &jd->jd_flags)) 452 return -EBUSY; 453 454 /* we have JDF_RECOVERY, queue should always succeed */ 455 rv = queue_work(gfs_recovery_wq, &jd->jd_work); 456 BUG_ON(!rv); 457 458 if (wait) 459 wait_on_bit(&jd->jd_flags, JDF_RECOVERY, 460 TASK_UNINTERRUPTIBLE); 461 462 return wait ? jd->jd_recover_error : 0; 463 } 464 465