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 BP |
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, | |
c1696fb8 BP |
269 | GFS2_LOG_HEAD_UNMOUNT | GFS2_LOG_HEAD_RECOVERY, |
270 | REQ_PREFLUSH | REQ_FUA | REQ_META | REQ_SYNC); | |
b3b94faa DT |
271 | } |
272 | ||
da755fdb | 273 | |
f057f6cd SW |
274 | static void gfs2_recovery_done(struct gfs2_sbd *sdp, unsigned int jid, |
275 | unsigned int message) | |
da755fdb | 276 | { |
f057f6cd SW |
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; | |
e0c2a9aa | 281 | |
f057f6cd SW |
282 | ls->ls_recover_jid_done = jid; |
283 | ls->ls_recover_jid_status = message; | |
3566c964 | 284 | sprintf(env_jid, "JID=%u", jid); |
f057f6cd SW |
285 | sprintf(env_status, "RECOVERY=%s", |
286 | message == LM_RD_SUCCESS ? "Done" : "Failed"); | |
287 | kobject_uevent_env(&sdp->sd_kobj, KOBJ_CHANGE, envp); | |
e0c2a9aa DT |
288 | |
289 | if (sdp->sd_lockstruct.ls_ops->lm_recovery_result) | |
290 | sdp->sd_lockstruct.ls_ops->lm_recovery_result(sdp, jid, message); | |
da755fdb SW |
291 | } |
292 | ||
6ecd7c2d | 293 | void gfs2_recover_func(struct work_struct *work) |
b3b94faa | 294 | { |
fe64d517 | 295 | struct gfs2_jdesc *jd = container_of(work, struct gfs2_jdesc, jd_work); |
feaa7bba SW |
296 | struct gfs2_inode *ip = GFS2_I(jd->jd_inode); |
297 | struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode); | |
55167622 | 298 | struct gfs2_log_header_host head; |
24972557 | 299 | struct gfs2_holder j_gh, ji_gh, thaw_gh; |
5e86d9d1 | 300 | ktime_t t_start, t_jlck, t_jhd, t_tlck, t_rep; |
b3b94faa DT |
301 | int ro = 0; |
302 | unsigned int pass; | |
4a772772 | 303 | int error = 0; |
c741c455 | 304 | int jlocked = 0; |
b3b94faa | 305 | |
5e86d9d1 | 306 | t_start = ktime_get(); |
4a772772 BP |
307 | if (sdp->sd_args.ar_spectator) |
308 | goto fail; | |
309 | if (jd->jd_jid != sdp->sd_lockstruct.ls_jid) { | |
5965b1f4 SW |
310 | fs_info(sdp, "jid=%u: Trying to acquire journal lock...\n", |
311 | jd->jd_jid); | |
c741c455 | 312 | jlocked = 1; |
c78bad11 | 313 | /* Acquire the journal lock so we can do recovery */ |
b3b94faa | 314 | |
5965b1f4 SW |
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; | |
907b9bce | 322 | |
5965b1f4 SW |
323 | case GLR_TRYFAILED: |
324 | fs_info(sdp, "jid=%u: Busy\n", jd->jd_jid); | |
325 | error = 0; | |
907b9bce | 326 | |
5965b1f4 SW |
327 | default: |
328 | goto fail; | |
329 | }; | |
b3b94faa | 330 | |
5965b1f4 | 331 | error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, |
75be73a8 | 332 | LM_FLAG_NOEXP | GL_NOCACHE, &ji_gh); |
5965b1f4 SW |
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 | } | |
b3b94faa | 338 | |
5e86d9d1 | 339 | t_jlck = ktime_get(); |
b3b94faa DT |
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 | ||
f4686c26 | 346 | error = gfs2_find_jhead(jd, &head, true); |
b3b94faa DT |
347 | if (error) |
348 | goto fail_gunlock_ji; | |
5e86d9d1 | 349 | t_jhd = ktime_get(); |
98583b3e AD |
350 | fs_info(sdp, "jid=%u: Journal head lookup took %lldms\n", jd->jd_jid, |
351 | ktime_ms_delta(t_jhd, t_jlck)); | |
b3b94faa DT |
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 | ||
24972557 | 357 | /* Acquire a shared hold on the freeze lock */ |
b3b94faa | 358 | |
24972557 BM |
359 | error = gfs2_glock_nq_init(sdp->sd_freeze_gl, LM_ST_SHARED, |
360 | LM_FLAG_NOEXP | LM_FLAG_PRIORITY, | |
361 | &thaw_gh); | |
b3b94faa DT |
362 | if (error) |
363 | goto fail_gunlock_ji; | |
364 | ||
e8ca5cc5 DT |
365 | if (test_bit(SDF_RORECOVERY, &sdp->sd_flags)) { |
366 | ro = 1; | |
367 | } else if (test_bit(SDF_JOURNAL_CHECKED, &sdp->sd_flags)) { | |
b3b94faa DT |
368 | if (!test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags)) |
369 | ro = 1; | |
370 | } else { | |
bc98a42c | 371 | if (sb_rdonly(sdp->sd_vfs)) { |
7bc5c414 AD |
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 | } | |
b3b94faa DT |
381 | } |
382 | ||
383 | if (ro) { | |
7bc5c414 AD |
384 | fs_warn(sdp, "jid=%u: Can't replay: read-only block " |
385 | "device\n", jd->jd_jid); | |
b3b94faa | 386 | error = -EROFS; |
24972557 | 387 | goto fail_gunlock_thaw; |
b3b94faa DT |
388 | } |
389 | ||
5e86d9d1 | 390 | t_tlck = ktime_get(); |
49eb776e BP |
391 | fs_info(sdp, "jid=%u: Replaying journal...0x%x to 0x%x\n", |
392 | jd->jd_jid, head.lh_tail, head.lh_blkno); | |
b3b94faa DT |
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) | |
24972557 | 400 | goto fail_gunlock_thaw; |
b3b94faa DT |
401 | } |
402 | ||
588bff95 | 403 | clean_journal(jd, &head); |
b3b94faa | 404 | |
24972557 | 405 | gfs2_glock_dq_uninit(&thaw_gh); |
5e86d9d1 AD |
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)); | |
b3b94faa DT |
414 | } |
415 | ||
f057f6cd | 416 | gfs2_recovery_done(sdp, jd->jd_jid, LM_RD_SUCCESS); |
b3b94faa | 417 | |
c741c455 SW |
418 | if (jlocked) { |
419 | gfs2_glock_dq_uninit(&ji_gh); | |
5965b1f4 | 420 | gfs2_glock_dq_uninit(&j_gh); |
c741c455 | 421 | } |
b3b94faa DT |
422 | |
423 | fs_info(sdp, "jid=%u: Done\n", jd->jd_jid); | |
6ecd7c2d | 424 | goto done; |
b3b94faa | 425 | |
24972557 BM |
426 | fail_gunlock_thaw: |
427 | gfs2_glock_dq_uninit(&thaw_gh); | |
5965b1f4 | 428 | fail_gunlock_ji: |
c741c455 | 429 | if (jlocked) { |
5965b1f4 SW |
430 | gfs2_glock_dq_uninit(&ji_gh); |
431 | fail_gunlock_j: | |
432 | gfs2_glock_dq_uninit(&j_gh); | |
433 | } | |
b3b94faa DT |
434 | |
435 | fs_info(sdp, "jid=%u: %s\n", jd->jd_jid, (error) ? "Failed" : "Done"); | |
5965b1f4 | 436 | fail: |
376d3778 | 437 | jd->jd_recover_error = error; |
f057f6cd | 438 | gfs2_recovery_done(sdp, jd->jd_jid, LM_RD_GAVEUP); |
6ecd7c2d TH |
439 | done: |
440 | clear_bit(JDF_RECOVERY, &jd->jd_flags); | |
4e857c58 | 441 | smp_mb__after_atomic(); |
6ecd7c2d | 442 | wake_up_bit(&jd->jd_flags, JDF_RECOVERY); |
b3b94faa DT |
443 | } |
444 | ||
6ecd7c2d | 445 | int gfs2_recover_journal(struct gfs2_jdesc *jd, bool wait) |
9ac1b4d9 | 446 | { |
fe64d517 | 447 | int rv; |
6ecd7c2d TH |
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) | |
74316201 | 457 | wait_on_bit(&jd->jd_flags, JDF_RECOVERY, |
6ecd7c2d TH |
458 | TASK_UNINTERRUPTIBLE); |
459 | ||
376d3778 | 460 | return wait ? jd->jd_recover_error : 0; |
9ac1b4d9 SW |
461 | } |
462 |