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, unsigned int 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 267 sdp->sd_log_flush_head = head->lh_blkno; 268 gfs2_replay_incr_blk(jd, &sdp->sd_log_flush_head); 269 gfs2_write_log_header(sdp, jd, head->lh_sequence + 1, 0, 270 GFS2_LOG_HEAD_UNMOUNT | GFS2_LOG_HEAD_RECOVERY, 271 REQ_PREFLUSH | REQ_FUA | REQ_META | REQ_SYNC); 272 } 273 274 275 static void gfs2_recovery_done(struct gfs2_sbd *sdp, unsigned int jid, 276 unsigned int message) 277 { 278 char env_jid[20]; 279 char env_status[20]; 280 char *envp[] = { env_jid, env_status, NULL }; 281 struct lm_lockstruct *ls = &sdp->sd_lockstruct; 282 283 ls->ls_recover_jid_done = jid; 284 ls->ls_recover_jid_status = message; 285 sprintf(env_jid, "JID=%u", jid); 286 sprintf(env_status, "RECOVERY=%s", 287 message == LM_RD_SUCCESS ? "Done" : "Failed"); 288 kobject_uevent_env(&sdp->sd_kobj, KOBJ_CHANGE, envp); 289 290 if (sdp->sd_lockstruct.ls_ops->lm_recovery_result) 291 sdp->sd_lockstruct.ls_ops->lm_recovery_result(sdp, jid, message); 292 } 293 294 void gfs2_recover_func(struct work_struct *work) 295 { 296 struct gfs2_jdesc *jd = container_of(work, struct gfs2_jdesc, jd_work); 297 struct gfs2_inode *ip = GFS2_I(jd->jd_inode); 298 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode); 299 struct gfs2_log_header_host head; 300 struct gfs2_holder j_gh, ji_gh, thaw_gh; 301 ktime_t t_start, t_jlck, t_jhd, t_tlck, t_rep; 302 int ro = 0; 303 unsigned int pass; 304 int error = 0; 305 int jlocked = 0; 306 307 t_start = ktime_get(); 308 if (sdp->sd_args.ar_spectator) 309 goto fail; 310 if (jd->jd_jid != sdp->sd_lockstruct.ls_jid) { 311 fs_info(sdp, "jid=%u: Trying to acquire journal lock...\n", 312 jd->jd_jid); 313 jlocked = 1; 314 /* Acquire the journal lock so we can do recovery */ 315 316 error = gfs2_glock_nq_num(sdp, jd->jd_jid, &gfs2_journal_glops, 317 LM_ST_EXCLUSIVE, 318 LM_FLAG_NOEXP | LM_FLAG_TRY | GL_NOCACHE, 319 &j_gh); 320 switch (error) { 321 case 0: 322 break; 323 324 case GLR_TRYFAILED: 325 fs_info(sdp, "jid=%u: Busy\n", jd->jd_jid); 326 error = 0; 327 328 default: 329 goto fail; 330 }; 331 332 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 333 LM_FLAG_NOEXP | GL_NOCACHE, &ji_gh); 334 if (error) 335 goto fail_gunlock_j; 336 } else { 337 fs_info(sdp, "jid=%u, already locked for use\n", jd->jd_jid); 338 } 339 340 t_jlck = ktime_get(); 341 fs_info(sdp, "jid=%u: Looking at journal...\n", jd->jd_jid); 342 343 error = gfs2_jdesc_check(jd); 344 if (error) 345 goto fail_gunlock_ji; 346 347 error = gfs2_find_jhead(jd, &head); 348 if (error) 349 goto fail_gunlock_ji; 350 t_jhd = ktime_get(); 351 fs_info(sdp, "jid=%u: Journal head lookup took %lldms\n", jd->jd_jid, 352 ktime_ms_delta(t_jhd, t_jlck)); 353 354 if (!(head.lh_flags & GFS2_LOG_HEAD_UNMOUNT)) { 355 fs_info(sdp, "jid=%u: Acquiring the transaction lock...\n", 356 jd->jd_jid); 357 358 /* Acquire a shared hold on the freeze lock */ 359 360 error = gfs2_glock_nq_init(sdp->sd_freeze_gl, LM_ST_SHARED, 361 LM_FLAG_NOEXP | LM_FLAG_PRIORITY, 362 &thaw_gh); 363 if (error) 364 goto fail_gunlock_ji; 365 366 if (test_bit(SDF_RORECOVERY, &sdp->sd_flags)) { 367 ro = 1; 368 } else if (test_bit(SDF_JOURNAL_CHECKED, &sdp->sd_flags)) { 369 if (!test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags)) 370 ro = 1; 371 } else { 372 if (sb_rdonly(sdp->sd_vfs)) { 373 /* check if device itself is read-only */ 374 ro = bdev_read_only(sdp->sd_vfs->s_bdev); 375 if (!ro) { 376 fs_info(sdp, "recovery required on " 377 "read-only filesystem.\n"); 378 fs_info(sdp, "write access will be " 379 "enabled during recovery.\n"); 380 } 381 } 382 } 383 384 if (ro) { 385 fs_warn(sdp, "jid=%u: Can't replay: read-only block " 386 "device\n", jd->jd_jid); 387 error = -EROFS; 388 goto fail_gunlock_thaw; 389 } 390 391 t_tlck = ktime_get(); 392 fs_info(sdp, "jid=%u: Replaying journal...\n", jd->jd_jid); 393 394 for (pass = 0; pass < 2; pass++) { 395 lops_before_scan(jd, &head, pass); 396 error = foreach_descriptor(jd, head.lh_tail, 397 head.lh_blkno, pass); 398 lops_after_scan(jd, error, pass); 399 if (error) 400 goto fail_gunlock_thaw; 401 } 402 403 clean_journal(jd, &head); 404 405 gfs2_glock_dq_uninit(&thaw_gh); 406 t_rep = ktime_get(); 407 fs_info(sdp, "jid=%u: Journal replayed in %lldms [jlck:%lldms, " 408 "jhead:%lldms, tlck:%lldms, replay:%lldms]\n", 409 jd->jd_jid, ktime_ms_delta(t_rep, t_start), 410 ktime_ms_delta(t_jlck, t_start), 411 ktime_ms_delta(t_jhd, t_jlck), 412 ktime_ms_delta(t_tlck, t_jhd), 413 ktime_ms_delta(t_rep, t_tlck)); 414 } 415 416 gfs2_recovery_done(sdp, jd->jd_jid, LM_RD_SUCCESS); 417 418 if (jlocked) { 419 gfs2_glock_dq_uninit(&ji_gh); 420 gfs2_glock_dq_uninit(&j_gh); 421 } 422 423 fs_info(sdp, "jid=%u: Done\n", jd->jd_jid); 424 goto done; 425 426 fail_gunlock_thaw: 427 gfs2_glock_dq_uninit(&thaw_gh); 428 fail_gunlock_ji: 429 if (jlocked) { 430 gfs2_glock_dq_uninit(&ji_gh); 431 fail_gunlock_j: 432 gfs2_glock_dq_uninit(&j_gh); 433 } 434 435 fs_info(sdp, "jid=%u: %s\n", jd->jd_jid, (error) ? "Failed" : "Done"); 436 fail: 437 jd->jd_recover_error = error; 438 gfs2_recovery_done(sdp, jd->jd_jid, LM_RD_GAVEUP); 439 done: 440 clear_bit(JDF_RECOVERY, &jd->jd_flags); 441 smp_mb__after_atomic(); 442 wake_up_bit(&jd->jd_flags, JDF_RECOVERY); 443 } 444 445 int gfs2_recover_journal(struct gfs2_jdesc *jd, bool wait) 446 { 447 int rv; 448 449 if (test_and_set_bit(JDF_RECOVERY, &jd->jd_flags)) 450 return -EBUSY; 451 452 /* we have JDF_RECOVERY, queue should always succeed */ 453 rv = queue_work(gfs_recovery_wq, &jd->jd_work); 454 BUG_ON(!rv); 455 456 if (wait) 457 wait_on_bit(&jd->jd_flags, JDF_RECOVERY, 458 TASK_UNINTERRUPTIBLE); 459 460 return wait ? jd->jd_recover_error : 0; 461 } 462 463