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)) { | |
969183bc | 114 | rr = list_first_entry(head, struct gfs2_revoke_replay, rr_list); |
b3b94faa DT |
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 | ||
73092698 AD |
147 | head->lh_local_total = be64_to_cpu(lh->lh_local_total); |
148 | head->lh_local_free = be64_to_cpu(lh->lh_local_free); | |
149 | head->lh_local_dinodes = be64_to_cpu(lh->lh_local_dinodes); | |
150 | ||
40e0e61e AD |
151 | return 0; |
152 | } | |
b3b94faa DT |
153 | /** |
154 | * get_log_header - read the log header for a given segment | |
155 | * @jd: the journal | |
156 | * @blk: the block to look at | |
157 | * @lh: the log header to return | |
158 | * | |
159 | * Read the log header for a given segement in a given journal. Do a few | |
160 | * sanity checks on it. | |
161 | * | |
162 | * Returns: 0 on success, | |
163 | * 1 if the header was invalid or incomplete, | |
164 | * errno on error | |
165 | */ | |
166 | ||
167 | static int get_log_header(struct gfs2_jdesc *jd, unsigned int blk, | |
55167622 | 168 | struct gfs2_log_header_host *head) |
b3b94faa | 169 | { |
40e0e61e | 170 | struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode); |
b3b94faa | 171 | struct buffer_head *bh; |
b3b94faa DT |
172 | int error; |
173 | ||
174 | error = gfs2_replay_read_block(jd, blk, &bh); | |
175 | if (error) | |
176 | return error; | |
b3b94faa | 177 | |
40e0e61e AD |
178 | error = __get_log_header(sdp, (const struct gfs2_log_header *)bh->b_data, |
179 | blk, head); | |
0ff5916a | 180 | brelse(bh); |
b3b94faa | 181 | |
0ff5916a | 182 | return error; |
b3b94faa DT |
183 | } |
184 | ||
b3b94faa DT |
185 | /** |
186 | * foreach_descriptor - go through the active part of the log | |
187 | * @jd: the journal | |
188 | * @start: the first log header in the active region | |
189 | * @end: the last log header (don't process the contents of this entry)) | |
190 | * | |
191 | * Call a given function once for every log descriptor in the active | |
192 | * portion of the log. | |
193 | * | |
194 | * Returns: errno | |
195 | */ | |
196 | ||
7c70b896 | 197 | static int foreach_descriptor(struct gfs2_jdesc *jd, u32 start, |
b3b94faa DT |
198 | unsigned int end, int pass) |
199 | { | |
feaa7bba | 200 | struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode); |
b3b94faa DT |
201 | struct buffer_head *bh; |
202 | struct gfs2_log_descriptor *ld; | |
203 | int error = 0; | |
204 | u32 length; | |
205 | __be64 *ptr; | |
206 | unsigned int offset = sizeof(struct gfs2_log_descriptor); | |
a67cdbd4 SW |
207 | offset += sizeof(__be64) - 1; |
208 | offset &= ~(sizeof(__be64) - 1); | |
b3b94faa DT |
209 | |
210 | while (start != end) { | |
211 | error = gfs2_replay_read_block(jd, start, &bh); | |
212 | if (error) | |
213 | return error; | |
214 | if (gfs2_meta_check(sdp, bh)) { | |
215 | brelse(bh); | |
216 | return -EIO; | |
217 | } | |
218 | ld = (struct gfs2_log_descriptor *)bh->b_data; | |
219 | length = be32_to_cpu(ld->ld_length); | |
220 | ||
e3167ded | 221 | if (be32_to_cpu(ld->ld_header.mh_type) == GFS2_METATYPE_LH) { |
55167622 | 222 | struct gfs2_log_header_host lh; |
b3b94faa DT |
223 | error = get_log_header(jd, start, &lh); |
224 | if (!error) { | |
e1cb6be9 | 225 | gfs2_replay_incr_blk(jd, &start); |
88721877 | 226 | brelse(bh); |
b3b94faa DT |
227 | continue; |
228 | } | |
229 | if (error == 1) { | |
feaa7bba | 230 | gfs2_consist_inode(GFS2_I(jd->jd_inode)); |
b3b94faa DT |
231 | error = -EIO; |
232 | } | |
233 | brelse(bh); | |
234 | return error; | |
235 | } else if (gfs2_metatype_check(sdp, bh, GFS2_METATYPE_LD)) { | |
236 | brelse(bh); | |
237 | return -EIO; | |
238 | } | |
239 | ptr = (__be64 *)(bh->b_data + offset); | |
240 | error = lops_scan_elements(jd, start, ld, ptr, pass); | |
241 | if (error) { | |
242 | brelse(bh); | |
243 | return error; | |
244 | } | |
245 | ||
246 | while (length--) | |
e1cb6be9 | 247 | gfs2_replay_incr_blk(jd, &start); |
b3b94faa DT |
248 | |
249 | brelse(bh); | |
250 | } | |
251 | ||
252 | return 0; | |
253 | } | |
254 | ||
255 | /** | |
256 | * clean_journal - mark a dirty journal as being clean | |
b3b94faa | 257 | * @jd: the journal |
b3b94faa DT |
258 | * @head: the head journal to start from |
259 | * | |
260 | * Returns: errno | |
261 | */ | |
262 | ||
588bff95 BP |
263 | static void clean_journal(struct gfs2_jdesc *jd, |
264 | struct gfs2_log_header_host *head) | |
b3b94faa | 265 | { |
feaa7bba | 266 | struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode); |
7c70b896 | 267 | u32 lblock = head->lh_blkno; |
b3b94faa | 268 | |
7c70b896 | 269 | gfs2_replay_incr_blk(jd, &lblock); |
7c70b896 | 270 | gfs2_write_log_header(sdp, jd, head->lh_sequence + 1, 0, lblock, |
c1696fb8 BP |
271 | GFS2_LOG_HEAD_UNMOUNT | GFS2_LOG_HEAD_RECOVERY, |
272 | REQ_PREFLUSH | REQ_FUA | REQ_META | REQ_SYNC); | |
19ebc050 AG |
273 | if (jd->jd_jid == sdp->sd_lockstruct.ls_jid) { |
274 | sdp->sd_log_flush_head = lblock; | |
275 | gfs2_log_incr_head(sdp); | |
276 | } | |
b3b94faa DT |
277 | } |
278 | ||
da755fdb | 279 | |
f057f6cd SW |
280 | static void gfs2_recovery_done(struct gfs2_sbd *sdp, unsigned int jid, |
281 | unsigned int message) | |
da755fdb | 282 | { |
f057f6cd SW |
283 | char env_jid[20]; |
284 | char env_status[20]; | |
285 | char *envp[] = { env_jid, env_status, NULL }; | |
286 | struct lm_lockstruct *ls = &sdp->sd_lockstruct; | |
e0c2a9aa | 287 | |
f057f6cd SW |
288 | ls->ls_recover_jid_done = jid; |
289 | ls->ls_recover_jid_status = message; | |
3566c964 | 290 | sprintf(env_jid, "JID=%u", jid); |
f057f6cd SW |
291 | sprintf(env_status, "RECOVERY=%s", |
292 | message == LM_RD_SUCCESS ? "Done" : "Failed"); | |
293 | kobject_uevent_env(&sdp->sd_kobj, KOBJ_CHANGE, envp); | |
e0c2a9aa DT |
294 | |
295 | if (sdp->sd_lockstruct.ls_ops->lm_recovery_result) | |
296 | sdp->sd_lockstruct.ls_ops->lm_recovery_result(sdp, jid, message); | |
da755fdb SW |
297 | } |
298 | ||
bedb0f05 AD |
299 | /** |
300 | * update_statfs_inode - Update the master statfs inode or zero out the local | |
301 | * statfs inode for a given journal. | |
302 | * @jd: The journal | |
303 | * @head: If NULL, @inode is the local statfs inode and we need to zero it out. | |
304 | * Otherwise, it @head contains the statfs change info that needs to be | |
305 | * synced to the master statfs inode (pointed to by @inode). | |
306 | * @inode: statfs inode to update. | |
307 | */ | |
308 | static int update_statfs_inode(struct gfs2_jdesc *jd, | |
309 | struct gfs2_log_header_host *head, | |
310 | struct inode *inode) | |
311 | { | |
312 | struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode); | |
313 | struct gfs2_inode *ip; | |
314 | struct buffer_head *bh; | |
315 | struct gfs2_statfs_change_host sc; | |
316 | int error = 0; | |
317 | ||
318 | BUG_ON(!inode); | |
319 | ip = GFS2_I(inode); | |
320 | ||
321 | error = gfs2_meta_inode_buffer(ip, &bh); | |
322 | if (error) | |
323 | goto out; | |
324 | ||
325 | spin_lock(&sdp->sd_statfs_spin); | |
326 | ||
327 | if (head) { /* Update the master statfs inode */ | |
328 | gfs2_statfs_change_in(&sc, bh->b_data + sizeof(struct gfs2_dinode)); | |
329 | sc.sc_total += head->lh_local_total; | |
330 | sc.sc_free += head->lh_local_free; | |
331 | sc.sc_dinodes += head->lh_local_dinodes; | |
332 | gfs2_statfs_change_out(&sc, bh->b_data + sizeof(struct gfs2_dinode)); | |
333 | ||
334 | fs_info(sdp, "jid=%u: Updated master statfs Total:%lld, " | |
335 | "Free:%lld, Dinodes:%lld after change " | |
336 | "[%+lld,%+lld,%+lld]\n", jd->jd_jid, sc.sc_total, | |
337 | sc.sc_free, sc.sc_dinodes, head->lh_local_total, | |
338 | head->lh_local_free, head->lh_local_dinodes); | |
339 | } else { /* Zero out the local statfs inode */ | |
340 | memset(bh->b_data + sizeof(struct gfs2_dinode), 0, | |
341 | sizeof(struct gfs2_statfs_change)); | |
342 | /* If it's our own journal, reset any in-memory changes too */ | |
343 | if (jd->jd_jid == sdp->sd_lockstruct.ls_jid) { | |
344 | memset(&sdp->sd_statfs_local, 0, | |
345 | sizeof(struct gfs2_statfs_change_host)); | |
346 | } | |
347 | } | |
348 | spin_unlock(&sdp->sd_statfs_spin); | |
349 | ||
350 | mark_buffer_dirty(bh); | |
351 | brelse(bh); | |
4a55752a | 352 | gfs2_inode_metasync(ip->i_gl); |
bedb0f05 AD |
353 | |
354 | out: | |
355 | return error; | |
356 | } | |
357 | ||
358 | /** | |
359 | * recover_local_statfs - Update the master and local statfs changes for this | |
360 | * journal. | |
361 | * | |
362 | * Previously, statfs updates would be read in from the local statfs inode and | |
363 | * synced to the master statfs inode during recovery. | |
364 | * | |
365 | * We now use the statfs updates in the journal head to update the master statfs | |
366 | * inode instead of reading in from the local statfs inode. To preserve backward | |
367 | * compatibility with kernels that can't do this, we still need to keep the | |
368 | * local statfs inode up to date by writing changes to it. At some point in the | |
369 | * future, we can do away with the local statfs inodes altogether and keep the | |
370 | * statfs changes solely in the journal. | |
371 | * | |
372 | * @jd: the journal | |
373 | * @head: the journal head | |
374 | * | |
375 | * Returns: errno | |
376 | */ | |
377 | static void recover_local_statfs(struct gfs2_jdesc *jd, | |
378 | struct gfs2_log_header_host *head) | |
379 | { | |
380 | int error; | |
381 | struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode); | |
382 | ||
383 | if (!head->lh_local_total && !head->lh_local_free | |
384 | && !head->lh_local_dinodes) /* No change */ | |
385 | goto zero_local; | |
386 | ||
387 | /* First update the master statfs inode with the changes we | |
388 | * found in the journal. */ | |
389 | error = update_statfs_inode(jd, head, sdp->sd_statfs_inode); | |
390 | if (error) | |
391 | goto out; | |
392 | ||
393 | zero_local: | |
394 | /* Zero out the local statfs inode so any changes in there | |
395 | * are not re-recovered. */ | |
396 | error = update_statfs_inode(jd, NULL, | |
397 | find_local_statfs_inode(sdp, jd->jd_jid)); | |
398 | out: | |
399 | return; | |
400 | } | |
401 | ||
6ecd7c2d | 402 | void gfs2_recover_func(struct work_struct *work) |
b3b94faa | 403 | { |
fe64d517 | 404 | struct gfs2_jdesc *jd = container_of(work, struct gfs2_jdesc, jd_work); |
feaa7bba SW |
405 | struct gfs2_inode *ip = GFS2_I(jd->jd_inode); |
406 | struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode); | |
55167622 | 407 | struct gfs2_log_header_host head; |
24972557 | 408 | struct gfs2_holder j_gh, ji_gh, thaw_gh; |
5e86d9d1 | 409 | ktime_t t_start, t_jlck, t_jhd, t_tlck, t_rep; |
b3b94faa DT |
410 | int ro = 0; |
411 | unsigned int pass; | |
4a772772 | 412 | int error = 0; |
c741c455 | 413 | int jlocked = 0; |
b3b94faa | 414 | |
03678a99 BP |
415 | if (gfs2_withdrawn(sdp)) { |
416 | fs_err(sdp, "jid=%u: Recovery not attempted due to withdraw.\n", | |
417 | jd->jd_jid); | |
418 | goto fail; | |
419 | } | |
5e86d9d1 | 420 | t_start = ktime_get(); |
4a772772 BP |
421 | if (sdp->sd_args.ar_spectator) |
422 | goto fail; | |
423 | if (jd->jd_jid != sdp->sd_lockstruct.ls_jid) { | |
5965b1f4 SW |
424 | fs_info(sdp, "jid=%u: Trying to acquire journal lock...\n", |
425 | jd->jd_jid); | |
c741c455 | 426 | jlocked = 1; |
c78bad11 | 427 | /* Acquire the journal lock so we can do recovery */ |
b3b94faa | 428 | |
5965b1f4 SW |
429 | error = gfs2_glock_nq_num(sdp, jd->jd_jid, &gfs2_journal_glops, |
430 | LM_ST_EXCLUSIVE, | |
431 | LM_FLAG_NOEXP | LM_FLAG_TRY | GL_NOCACHE, | |
432 | &j_gh); | |
433 | switch (error) { | |
434 | case 0: | |
435 | break; | |
907b9bce | 436 | |
5965b1f4 SW |
437 | case GLR_TRYFAILED: |
438 | fs_info(sdp, "jid=%u: Busy\n", jd->jd_jid); | |
439 | error = 0; | |
907b9bce | 440 | |
5965b1f4 SW |
441 | default: |
442 | goto fail; | |
098b9c14 | 443 | } |
b3b94faa | 444 | |
5965b1f4 | 445 | error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, |
75be73a8 | 446 | LM_FLAG_NOEXP | GL_NOCACHE, &ji_gh); |
5965b1f4 SW |
447 | if (error) |
448 | goto fail_gunlock_j; | |
449 | } else { | |
450 | fs_info(sdp, "jid=%u, already locked for use\n", jd->jd_jid); | |
451 | } | |
b3b94faa | 452 | |
5e86d9d1 | 453 | t_jlck = ktime_get(); |
b3b94faa DT |
454 | fs_info(sdp, "jid=%u: Looking at journal...\n", jd->jd_jid); |
455 | ||
456 | error = gfs2_jdesc_check(jd); | |
457 | if (error) | |
458 | goto fail_gunlock_ji; | |
459 | ||
f4686c26 | 460 | error = gfs2_find_jhead(jd, &head, true); |
b3b94faa DT |
461 | if (error) |
462 | goto fail_gunlock_ji; | |
5e86d9d1 | 463 | t_jhd = ktime_get(); |
98583b3e AD |
464 | fs_info(sdp, "jid=%u: Journal head lookup took %lldms\n", jd->jd_jid, |
465 | ktime_ms_delta(t_jhd, t_jlck)); | |
b3b94faa DT |
466 | |
467 | if (!(head.lh_flags & GFS2_LOG_HEAD_UNMOUNT)) { | |
468 | fs_info(sdp, "jid=%u: Acquiring the transaction lock...\n", | |
469 | jd->jd_jid); | |
470 | ||
24972557 | 471 | /* Acquire a shared hold on the freeze lock */ |
b3b94faa | 472 | |
c77b52c0 | 473 | error = gfs2_freeze_lock(sdp, &thaw_gh, LM_FLAG_PRIORITY); |
b3b94faa DT |
474 | if (error) |
475 | goto fail_gunlock_ji; | |
476 | ||
e8ca5cc5 DT |
477 | if (test_bit(SDF_RORECOVERY, &sdp->sd_flags)) { |
478 | ro = 1; | |
479 | } else if (test_bit(SDF_JOURNAL_CHECKED, &sdp->sd_flags)) { | |
b3b94faa DT |
480 | if (!test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags)) |
481 | ro = 1; | |
482 | } else { | |
bc98a42c | 483 | if (sb_rdonly(sdp->sd_vfs)) { |
7bc5c414 AD |
484 | /* check if device itself is read-only */ |
485 | ro = bdev_read_only(sdp->sd_vfs->s_bdev); | |
486 | if (!ro) { | |
487 | fs_info(sdp, "recovery required on " | |
488 | "read-only filesystem.\n"); | |
489 | fs_info(sdp, "write access will be " | |
490 | "enabled during recovery.\n"); | |
491 | } | |
492 | } | |
b3b94faa DT |
493 | } |
494 | ||
495 | if (ro) { | |
7bc5c414 AD |
496 | fs_warn(sdp, "jid=%u: Can't replay: read-only block " |
497 | "device\n", jd->jd_jid); | |
b3b94faa | 498 | error = -EROFS; |
24972557 | 499 | goto fail_gunlock_thaw; |
b3b94faa DT |
500 | } |
501 | ||
5e86d9d1 | 502 | t_tlck = ktime_get(); |
49eb776e BP |
503 | fs_info(sdp, "jid=%u: Replaying journal...0x%x to 0x%x\n", |
504 | jd->jd_jid, head.lh_tail, head.lh_blkno); | |
b3b94faa | 505 | |
c9ebc4b7 BP |
506 | /* We take the sd_log_flush_lock here primarily to prevent log |
507 | * flushes and simultaneous journal replays from stomping on | |
82218943 | 508 | * each other wrt jd_log_bio. */ |
c953a735 | 509 | down_read(&sdp->sd_log_flush_lock); |
b3b94faa DT |
510 | for (pass = 0; pass < 2; pass++) { |
511 | lops_before_scan(jd, &head, pass); | |
512 | error = foreach_descriptor(jd, head.lh_tail, | |
513 | head.lh_blkno, pass); | |
514 | lops_after_scan(jd, error, pass); | |
834ec3e1 AG |
515 | if (error) { |
516 | up_read(&sdp->sd_log_flush_lock); | |
24972557 | 517 | goto fail_gunlock_thaw; |
834ec3e1 | 518 | } |
b3b94faa DT |
519 | } |
520 | ||
bedb0f05 | 521 | recover_local_statfs(jd, &head); |
588bff95 | 522 | clean_journal(jd, &head); |
c953a735 | 523 | up_read(&sdp->sd_log_flush_lock); |
b3b94faa | 524 | |
c77b52c0 | 525 | gfs2_freeze_unlock(&thaw_gh); |
5e86d9d1 AD |
526 | t_rep = ktime_get(); |
527 | fs_info(sdp, "jid=%u: Journal replayed in %lldms [jlck:%lldms, " | |
528 | "jhead:%lldms, tlck:%lldms, replay:%lldms]\n", | |
529 | jd->jd_jid, ktime_ms_delta(t_rep, t_start), | |
530 | ktime_ms_delta(t_jlck, t_start), | |
531 | ktime_ms_delta(t_jhd, t_jlck), | |
532 | ktime_ms_delta(t_tlck, t_jhd), | |
533 | ktime_ms_delta(t_rep, t_tlck)); | |
b3b94faa DT |
534 | } |
535 | ||
f057f6cd | 536 | gfs2_recovery_done(sdp, jd->jd_jid, LM_RD_SUCCESS); |
b3b94faa | 537 | |
c741c455 SW |
538 | if (jlocked) { |
539 | gfs2_glock_dq_uninit(&ji_gh); | |
5965b1f4 | 540 | gfs2_glock_dq_uninit(&j_gh); |
c741c455 | 541 | } |
b3b94faa DT |
542 | |
543 | fs_info(sdp, "jid=%u: Done\n", jd->jd_jid); | |
6ecd7c2d | 544 | goto done; |
b3b94faa | 545 | |
24972557 | 546 | fail_gunlock_thaw: |
c77b52c0 | 547 | gfs2_freeze_unlock(&thaw_gh); |
5965b1f4 | 548 | fail_gunlock_ji: |
c741c455 | 549 | if (jlocked) { |
5965b1f4 SW |
550 | gfs2_glock_dq_uninit(&ji_gh); |
551 | fail_gunlock_j: | |
552 | gfs2_glock_dq_uninit(&j_gh); | |
553 | } | |
b3b94faa DT |
554 | |
555 | fs_info(sdp, "jid=%u: %s\n", jd->jd_jid, (error) ? "Failed" : "Done"); | |
5965b1f4 | 556 | fail: |
376d3778 | 557 | jd->jd_recover_error = error; |
f057f6cd | 558 | gfs2_recovery_done(sdp, jd->jd_jid, LM_RD_GAVEUP); |
6ecd7c2d TH |
559 | done: |
560 | clear_bit(JDF_RECOVERY, &jd->jd_flags); | |
4e857c58 | 561 | smp_mb__after_atomic(); |
6ecd7c2d | 562 | wake_up_bit(&jd->jd_flags, JDF_RECOVERY); |
b3b94faa DT |
563 | } |
564 | ||
6ecd7c2d | 565 | int gfs2_recover_journal(struct gfs2_jdesc *jd, bool wait) |
9ac1b4d9 | 566 | { |
fe64d517 | 567 | int rv; |
6ecd7c2d TH |
568 | |
569 | if (test_and_set_bit(JDF_RECOVERY, &jd->jd_flags)) | |
570 | return -EBUSY; | |
571 | ||
572 | /* we have JDF_RECOVERY, queue should always succeed */ | |
573 | rv = queue_work(gfs_recovery_wq, &jd->jd_work); | |
574 | BUG_ON(!rv); | |
575 | ||
576 | if (wait) | |
74316201 | 577 | wait_on_bit(&jd->jd_flags, JDF_RECOVERY, |
6ecd7c2d TH |
578 | TASK_UNINTERRUPTIBLE); |
579 | ||
376d3778 | 580 | return wait ? jd->jd_recover_error : 0; |
9ac1b4d9 SW |
581 | } |
582 |