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 gfs2_write_log_header(sdp, jd, head->lh_sequence + 1, 0, lblock, 267 GFS2_LOG_HEAD_UNMOUNT | GFS2_LOG_HEAD_RECOVERY, 268 REQ_PREFLUSH | REQ_FUA | REQ_META | REQ_SYNC); 269 if (jd->jd_jid == sdp->sd_lockstruct.ls_jid) { 270 sdp->sd_log_flush_head = lblock; 271 gfs2_log_incr_head(sdp); 272 } 273 } 274 275 276 static void gfs2_recovery_done(struct gfs2_sbd *sdp, unsigned int jid, 277 unsigned int message) 278 { 279 char env_jid[20]; 280 char env_status[20]; 281 char *envp[] = { env_jid, env_status, NULL }; 282 struct lm_lockstruct *ls = &sdp->sd_lockstruct; 283 284 ls->ls_recover_jid_done = jid; 285 ls->ls_recover_jid_status = message; 286 sprintf(env_jid, "JID=%u", jid); 287 sprintf(env_status, "RECOVERY=%s", 288 message == LM_RD_SUCCESS ? "Done" : "Failed"); 289 kobject_uevent_env(&sdp->sd_kobj, KOBJ_CHANGE, envp); 290 291 if (sdp->sd_lockstruct.ls_ops->lm_recovery_result) 292 sdp->sd_lockstruct.ls_ops->lm_recovery_result(sdp, jid, message); 293 } 294 295 void gfs2_recover_func(struct work_struct *work) 296 { 297 struct gfs2_jdesc *jd = container_of(work, struct gfs2_jdesc, jd_work); 298 struct gfs2_inode *ip = GFS2_I(jd->jd_inode); 299 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode); 300 struct gfs2_log_header_host head; 301 struct gfs2_holder j_gh, ji_gh, thaw_gh; 302 ktime_t t_start, t_jlck, t_jhd, t_tlck, t_rep; 303 int ro = 0; 304 unsigned int pass; 305 int error = 0; 306 int jlocked = 0; 307 308 t_start = ktime_get(); 309 if (sdp->sd_args.ar_spectator) 310 goto fail; 311 if (jd->jd_jid != sdp->sd_lockstruct.ls_jid) { 312 fs_info(sdp, "jid=%u: Trying to acquire journal lock...\n", 313 jd->jd_jid); 314 jlocked = 1; 315 /* Acquire the journal lock so we can do recovery */ 316 317 error = gfs2_glock_nq_num(sdp, jd->jd_jid, &gfs2_journal_glops, 318 LM_ST_EXCLUSIVE, 319 LM_FLAG_NOEXP | LM_FLAG_TRY | GL_NOCACHE, 320 &j_gh); 321 switch (error) { 322 case 0: 323 break; 324 325 case GLR_TRYFAILED: 326 fs_info(sdp, "jid=%u: Busy\n", jd->jd_jid); 327 error = 0; 328 329 default: 330 goto fail; 331 } 332 333 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 334 LM_FLAG_NOEXP | GL_NOCACHE, &ji_gh); 335 if (error) 336 goto fail_gunlock_j; 337 } else { 338 fs_info(sdp, "jid=%u, already locked for use\n", jd->jd_jid); 339 } 340 341 t_jlck = ktime_get(); 342 fs_info(sdp, "jid=%u: Looking at journal...\n", jd->jd_jid); 343 344 error = gfs2_jdesc_check(jd); 345 if (error) 346 goto fail_gunlock_ji; 347 348 error = gfs2_find_jhead(jd, &head, true); 349 if (error) 350 goto fail_gunlock_ji; 351 t_jhd = ktime_get(); 352 fs_info(sdp, "jid=%u: Journal head lookup took %lldms\n", jd->jd_jid, 353 ktime_ms_delta(t_jhd, t_jlck)); 354 355 if (!(head.lh_flags & GFS2_LOG_HEAD_UNMOUNT)) { 356 fs_info(sdp, "jid=%u: Acquiring the transaction lock...\n", 357 jd->jd_jid); 358 359 /* Acquire a shared hold on the freeze lock */ 360 361 error = gfs2_glock_nq_init(sdp->sd_freeze_gl, LM_ST_SHARED, 362 LM_FLAG_NOEXP | LM_FLAG_PRIORITY, 363 &thaw_gh); 364 if (error) 365 goto fail_gunlock_ji; 366 367 if (test_bit(SDF_RORECOVERY, &sdp->sd_flags)) { 368 ro = 1; 369 } else if (test_bit(SDF_JOURNAL_CHECKED, &sdp->sd_flags)) { 370 if (!test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags)) 371 ro = 1; 372 } else { 373 if (sb_rdonly(sdp->sd_vfs)) { 374 /* check if device itself is read-only */ 375 ro = bdev_read_only(sdp->sd_vfs->s_bdev); 376 if (!ro) { 377 fs_info(sdp, "recovery required on " 378 "read-only filesystem.\n"); 379 fs_info(sdp, "write access will be " 380 "enabled during recovery.\n"); 381 } 382 } 383 } 384 385 if (ro) { 386 fs_warn(sdp, "jid=%u: Can't replay: read-only block " 387 "device\n", jd->jd_jid); 388 error = -EROFS; 389 goto fail_gunlock_thaw; 390 } 391 392 t_tlck = ktime_get(); 393 fs_info(sdp, "jid=%u: Replaying journal...0x%x to 0x%x\n", 394 jd->jd_jid, head.lh_tail, head.lh_blkno); 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