Commit | Line | Data |
---|---|---|
7336d0e6 | 1 | // SPDX-License-Identifier: GPL-2.0-only |
b3b94faa DT |
2 | /* |
3 | * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. | |
3a8a9a10 | 4 | * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved. |
b3b94faa DT |
5 | */ |
6 | ||
1c2ea8a2 | 7 | #include <linux/module.h> |
b3b94faa DT |
8 | #include <linux/slab.h> |
9 | #include <linux/spinlock.h> | |
10 | #include <linux/completion.h> | |
11 | #include <linux/buffer_head.h> | |
5c676f6d | 12 | #include <linux/gfs2_ondisk.h> |
71b86f56 | 13 | #include <linux/crc32.h> |
c1696fb8 | 14 | #include <linux/crc32c.h> |
5e86d9d1 | 15 | #include <linux/ktime.h> |
b3b94faa DT |
16 | |
17 | #include "gfs2.h" | |
5c676f6d | 18 | #include "incore.h" |
b3b94faa DT |
19 | #include "bmap.h" |
20 | #include "glock.h" | |
21 | #include "glops.h" | |
588bff95 | 22 | #include "log.h" |
b3b94faa DT |
23 | #include "lops.h" |
24 | #include "meta_io.h" | |
25 | #include "recovery.h" | |
26 | #include "super.h" | |
5c676f6d | 27 | #include "util.h" |
71b86f56 | 28 | #include "dir.h" |
b3b94faa | 29 | |
6ecd7c2d TH |
30 | struct workqueue_struct *gfs_recovery_wq; |
31 | ||
b3b94faa DT |
32 | int gfs2_replay_read_block(struct gfs2_jdesc *jd, unsigned int blk, |
33 | struct buffer_head **bh) | |
34 | { | |
feaa7bba | 35 | struct gfs2_inode *ip = GFS2_I(jd->jd_inode); |
5c676f6d | 36 | struct gfs2_glock *gl = ip->i_gl; |
b3b94faa | 37 | int new = 0; |
cd915493 SW |
38 | u64 dblock; |
39 | u32 extlen; | |
b3b94faa DT |
40 | int error; |
41 | ||
feaa7bba | 42 | error = gfs2_extent_map(&ip->i_inode, blk, &new, &dblock, &extlen); |
b3b94faa DT |
43 | if (error) |
44 | return error; | |
45 | if (!dblock) { | |
5c676f6d | 46 | gfs2_consist_inode(ip); |
b3b94faa DT |
47 | return -EIO; |
48 | } | |
49 | ||
7276b3b0 | 50 | *bh = gfs2_meta_ra(gl, dblock, extlen); |
b3b94faa DT |
51 | |
52 | return error; | |
53 | } | |
54 | ||
a17d758b | 55 | int gfs2_revoke_add(struct gfs2_jdesc *jd, u64 blkno, unsigned int where) |
b3b94faa | 56 | { |
a17d758b | 57 | struct list_head *head = &jd->jd_revoke_list; |
b3b94faa DT |
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 | ||
16c5f06f | 73 | rr = kmalloc(sizeof(struct gfs2_revoke_replay), GFP_NOFS); |
b3b94faa DT |
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 | ||
a17d758b | 84 | int gfs2_revoke_check(struct gfs2_jdesc *jd, u64 blkno, unsigned int where) |
b3b94faa DT |
85 | { |
86 | struct gfs2_revoke_replay *rr; | |
87 | int wrap, a, b, revoke; | |
88 | int found = 0; | |
89 | ||
a17d758b | 90 | list_for_each_entry(rr, &jd->jd_revoke_list, rr_list) { |
b3b94faa DT |
91 | if (rr->rr_blkno == blkno) { |
92 | found = 1; | |
93 | break; | |
94 | } | |
95 | } | |
96 | ||
97 | if (!found) | |
98 | return 0; | |
99 | ||
a17d758b BP |
100 | wrap = (rr->rr_where < jd->jd_replay_tail); |
101 | a = (jd->jd_replay_tail < where); | |
b3b94faa DT |
102 | b = (where < rr->rr_where); |
103 | revoke = (wrap) ? (a || b) : (a && b); | |
104 | ||
105 | return revoke; | |
106 | } | |
107 | ||
a17d758b | 108 | void gfs2_revoke_clean(struct gfs2_jdesc *jd) |
b3b94faa | 109 | { |
a17d758b | 110 | struct list_head *head = &jd->jd_revoke_list; |
b3b94faa DT |
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 | ||
40e0e61e AD |
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 | } | |
b3b94faa DT |
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, | |
55167622 | 164 | struct gfs2_log_header_host *head) |
b3b94faa | 165 | { |
40e0e61e | 166 | struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode); |
b3b94faa | 167 | struct buffer_head *bh; |
b3b94faa DT |
168 | int error; |
169 | ||
170 | error = gfs2_replay_read_block(jd, blk, &bh); | |
171 | if (error) | |
172 | return error; | |
b3b94faa | 173 | |
40e0e61e AD |
174 | error = __get_log_header(sdp, (const struct gfs2_log_header *)bh->b_data, |
175 | blk, head); | |
0ff5916a | 176 | brelse(bh); |
b3b94faa | 177 | |
0ff5916a | 178 | return error; |
b3b94faa DT |
179 | } |
180 | ||
b3b94faa DT |
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 | ||
7c70b896 | 193 | static int foreach_descriptor(struct gfs2_jdesc *jd, u32 start, |
b3b94faa DT |
194 | unsigned int end, int pass) |
195 | { | |
feaa7bba | 196 | struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode); |
b3b94faa DT |
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); | |
a67cdbd4 SW |
203 | offset += sizeof(__be64) - 1; |
204 | offset &= ~(sizeof(__be64) - 1); | |
b3b94faa DT |
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 | ||
e3167ded | 217 | if (be32_to_cpu(ld->ld_header.mh_type) == GFS2_METATYPE_LH) { |
55167622 | 218 | struct gfs2_log_header_host lh; |
b3b94faa DT |
219 | error = get_log_header(jd, start, &lh); |
220 | if (!error) { | |
e1cb6be9 | 221 | gfs2_replay_incr_blk(jd, &start); |
88721877 | 222 | brelse(bh); |
b3b94faa DT |
223 | continue; |
224 | } | |
225 | if (error == 1) { | |
feaa7bba | 226 | gfs2_consist_inode(GFS2_I(jd->jd_inode)); |
b3b94faa DT |
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--) | |
e1cb6be9 | 243 | gfs2_replay_incr_blk(jd, &start); |
b3b94faa DT |
244 | |
245 | brelse(bh); | |
246 | } | |
247 | ||
248 | return 0; | |
249 | } | |
250 | ||
251 | /** | |
252 | * clean_journal - mark a dirty journal as being clean | |
b3b94faa | 253 | * @jd: the journal |
b3b94faa DT |
254 | * @head: the head journal to start from |
255 | * | |
256 | * Returns: errno | |
257 | */ | |
258 | ||
588bff95 BP |
259 | static void clean_journal(struct gfs2_jdesc *jd, |
260 | struct gfs2_log_header_host *head) | |
b3b94faa | 261 | { |
feaa7bba | 262 | struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode); |
7c70b896 | 263 | u32 lblock = head->lh_blkno; |
b3b94faa | 264 | |
7c70b896 | 265 | gfs2_replay_incr_blk(jd, &lblock); |
7c70b896 | 266 | gfs2_write_log_header(sdp, jd, head->lh_sequence + 1, 0, lblock, |
c1696fb8 BP |
267 | GFS2_LOG_HEAD_UNMOUNT | GFS2_LOG_HEAD_RECOVERY, |
268 | REQ_PREFLUSH | REQ_FUA | REQ_META | REQ_SYNC); | |
19ebc050 AG |
269 | if (jd->jd_jid == sdp->sd_lockstruct.ls_jid) { |
270 | sdp->sd_log_flush_head = lblock; | |
271 | gfs2_log_incr_head(sdp); | |
272 | } | |
b3b94faa DT |
273 | } |
274 | ||
da755fdb | 275 | |
f057f6cd SW |
276 | static void gfs2_recovery_done(struct gfs2_sbd *sdp, unsigned int jid, |
277 | unsigned int message) | |
da755fdb | 278 | { |
f057f6cd SW |
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; | |
e0c2a9aa | 283 | |
f057f6cd SW |
284 | ls->ls_recover_jid_done = jid; |
285 | ls->ls_recover_jid_status = message; | |
3566c964 | 286 | sprintf(env_jid, "JID=%u", jid); |
f057f6cd SW |
287 | sprintf(env_status, "RECOVERY=%s", |
288 | message == LM_RD_SUCCESS ? "Done" : "Failed"); | |
289 | kobject_uevent_env(&sdp->sd_kobj, KOBJ_CHANGE, envp); | |
e0c2a9aa DT |
290 | |
291 | if (sdp->sd_lockstruct.ls_ops->lm_recovery_result) | |
292 | sdp->sd_lockstruct.ls_ops->lm_recovery_result(sdp, jid, message); | |
da755fdb SW |
293 | } |
294 | ||
6ecd7c2d | 295 | void gfs2_recover_func(struct work_struct *work) |
b3b94faa | 296 | { |
fe64d517 | 297 | struct gfs2_jdesc *jd = container_of(work, struct gfs2_jdesc, jd_work); |
feaa7bba SW |
298 | struct gfs2_inode *ip = GFS2_I(jd->jd_inode); |
299 | struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode); | |
55167622 | 300 | struct gfs2_log_header_host head; |
24972557 | 301 | struct gfs2_holder j_gh, ji_gh, thaw_gh; |
5e86d9d1 | 302 | ktime_t t_start, t_jlck, t_jhd, t_tlck, t_rep; |
b3b94faa DT |
303 | int ro = 0; |
304 | unsigned int pass; | |
4a772772 | 305 | int error = 0; |
c741c455 | 306 | int jlocked = 0; |
b3b94faa | 307 | |
5e86d9d1 | 308 | t_start = ktime_get(); |
4a772772 BP |
309 | if (sdp->sd_args.ar_spectator) |
310 | goto fail; | |
311 | if (jd->jd_jid != sdp->sd_lockstruct.ls_jid) { | |
5965b1f4 SW |
312 | fs_info(sdp, "jid=%u: Trying to acquire journal lock...\n", |
313 | jd->jd_jid); | |
c741c455 | 314 | jlocked = 1; |
c78bad11 | 315 | /* Acquire the journal lock so we can do recovery */ |
b3b94faa | 316 | |
5965b1f4 SW |
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; | |
907b9bce | 324 | |
5965b1f4 SW |
325 | case GLR_TRYFAILED: |
326 | fs_info(sdp, "jid=%u: Busy\n", jd->jd_jid); | |
327 | error = 0; | |
907b9bce | 328 | |
5965b1f4 SW |
329 | default: |
330 | goto fail; | |
098b9c14 | 331 | } |
b3b94faa | 332 | |
5965b1f4 | 333 | error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, |
75be73a8 | 334 | LM_FLAG_NOEXP | GL_NOCACHE, &ji_gh); |
5965b1f4 SW |
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 | } | |
b3b94faa | 340 | |
5e86d9d1 | 341 | t_jlck = ktime_get(); |
b3b94faa DT |
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 | ||
f4686c26 | 348 | error = gfs2_find_jhead(jd, &head, true); |
b3b94faa DT |
349 | if (error) |
350 | goto fail_gunlock_ji; | |
5e86d9d1 | 351 | t_jhd = ktime_get(); |
98583b3e AD |
352 | fs_info(sdp, "jid=%u: Journal head lookup took %lldms\n", jd->jd_jid, |
353 | ktime_ms_delta(t_jhd, t_jlck)); | |
b3b94faa DT |
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 | ||
24972557 | 359 | /* Acquire a shared hold on the freeze lock */ |
b3b94faa | 360 | |
24972557 BM |
361 | error = gfs2_glock_nq_init(sdp->sd_freeze_gl, LM_ST_SHARED, |
362 | LM_FLAG_NOEXP | LM_FLAG_PRIORITY, | |
363 | &thaw_gh); | |
b3b94faa DT |
364 | if (error) |
365 | goto fail_gunlock_ji; | |
366 | ||
e8ca5cc5 DT |
367 | if (test_bit(SDF_RORECOVERY, &sdp->sd_flags)) { |
368 | ro = 1; | |
369 | } else if (test_bit(SDF_JOURNAL_CHECKED, &sdp->sd_flags)) { | |
b3b94faa DT |
370 | if (!test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags)) |
371 | ro = 1; | |
372 | } else { | |
bc98a42c | 373 | if (sb_rdonly(sdp->sd_vfs)) { |
7bc5c414 AD |
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 | } | |
b3b94faa DT |
383 | } |
384 | ||
385 | if (ro) { | |
7bc5c414 AD |
386 | fs_warn(sdp, "jid=%u: Can't replay: read-only block " |
387 | "device\n", jd->jd_jid); | |
b3b94faa | 388 | error = -EROFS; |
24972557 | 389 | goto fail_gunlock_thaw; |
b3b94faa DT |
390 | } |
391 | ||
5e86d9d1 | 392 | t_tlck = ktime_get(); |
49eb776e BP |
393 | fs_info(sdp, "jid=%u: Replaying journal...0x%x to 0x%x\n", |
394 | jd->jd_jid, head.lh_tail, head.lh_blkno); | |
b3b94faa DT |
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) | |
24972557 | 402 | goto fail_gunlock_thaw; |
b3b94faa DT |
403 | } |
404 | ||
588bff95 | 405 | clean_journal(jd, &head); |
b3b94faa | 406 | |
24972557 | 407 | gfs2_glock_dq_uninit(&thaw_gh); |
5e86d9d1 AD |
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)); | |
b3b94faa DT |
416 | } |
417 | ||
f057f6cd | 418 | gfs2_recovery_done(sdp, jd->jd_jid, LM_RD_SUCCESS); |
b3b94faa | 419 | |
c741c455 SW |
420 | if (jlocked) { |
421 | gfs2_glock_dq_uninit(&ji_gh); | |
5965b1f4 | 422 | gfs2_glock_dq_uninit(&j_gh); |
c741c455 | 423 | } |
b3b94faa DT |
424 | |
425 | fs_info(sdp, "jid=%u: Done\n", jd->jd_jid); | |
6ecd7c2d | 426 | goto done; |
b3b94faa | 427 | |
24972557 BM |
428 | fail_gunlock_thaw: |
429 | gfs2_glock_dq_uninit(&thaw_gh); | |
5965b1f4 | 430 | fail_gunlock_ji: |
c741c455 | 431 | if (jlocked) { |
5965b1f4 SW |
432 | gfs2_glock_dq_uninit(&ji_gh); |
433 | fail_gunlock_j: | |
434 | gfs2_glock_dq_uninit(&j_gh); | |
435 | } | |
b3b94faa DT |
436 | |
437 | fs_info(sdp, "jid=%u: %s\n", jd->jd_jid, (error) ? "Failed" : "Done"); | |
5965b1f4 | 438 | fail: |
376d3778 | 439 | jd->jd_recover_error = error; |
f057f6cd | 440 | gfs2_recovery_done(sdp, jd->jd_jid, LM_RD_GAVEUP); |
6ecd7c2d TH |
441 | done: |
442 | clear_bit(JDF_RECOVERY, &jd->jd_flags); | |
4e857c58 | 443 | smp_mb__after_atomic(); |
6ecd7c2d | 444 | wake_up_bit(&jd->jd_flags, JDF_RECOVERY); |
b3b94faa DT |
445 | } |
446 | ||
6ecd7c2d | 447 | int gfs2_recover_journal(struct gfs2_jdesc *jd, bool wait) |
9ac1b4d9 | 448 | { |
fe64d517 | 449 | int rv; |
6ecd7c2d TH |
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) | |
74316201 | 459 | wait_on_bit(&jd->jd_flags, JDF_RECOVERY, |
6ecd7c2d TH |
460 | TASK_UNINTERRUPTIBLE); |
461 | ||
376d3778 | 462 | return wait ? jd->jd_recover_error : 0; |
9ac1b4d9 SW |
463 | } |
464 |