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