blob: 5ada38c99a2c95e49a1abb99a828fa0f860306eb [file] [log] [blame]
David Teiglandb3b94fa2006-01-16 16:50:04 +00001/*
2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
Steven Whitehouse3a8a9a12006-05-18 15:09:15 -04003 * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
David Teiglandb3b94fa2006-01-16 16:50:04 +00004 *
5 * This copyrighted material is made available to anyone wishing to use,
6 * modify, copy, or redistribute it subject to the terms and conditions
Steven Whitehousee9fc2aa2006-09-01 11:05:15 -04007 * of the GNU General Public License version 2.
David Teiglandb3b94fa2006-01-16 16:50:04 +00008 */
9
David Teiglandb3b94fa2006-01-16 16:50:04 +000010#include <linux/slab.h>
11#include <linux/spinlock.h>
12#include <linux/completion.h>
13#include <linux/buffer_head.h>
Steven Whitehouse5c676f62006-02-27 17:23:27 -050014#include <linux/gfs2_ondisk.h>
Steven Whitehouse71b86f52006-03-28 14:14:04 -050015#include <linux/crc32.h>
Fabio Massimo Di Nitto7d308592006-09-19 07:56:29 +020016#include <linux/lm_interface.h>
David Teiglandb3b94fa2006-01-16 16:50:04 +000017
18#include "gfs2.h"
Steven Whitehouse5c676f62006-02-27 17:23:27 -050019#include "incore.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000020#include "bmap.h"
21#include "glock.h"
22#include "glops.h"
23#include "lm.h"
24#include "lops.h"
25#include "meta_io.h"
26#include "recovery.h"
27#include "super.h"
Steven Whitehouse5c676f62006-02-27 17:23:27 -050028#include "util.h"
Steven Whitehouse71b86f52006-03-28 14:14:04 -050029#include "dir.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000030
31int gfs2_replay_read_block(struct gfs2_jdesc *jd, unsigned int blk,
32 struct buffer_head **bh)
33{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -040034 struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
Steven Whitehouse5c676f62006-02-27 17:23:27 -050035 struct gfs2_glock *gl = ip->i_gl;
David Teiglandb3b94fa2006-01-16 16:50:04 +000036 int new = 0;
Steven Whitehousecd915492006-09-04 12:49:07 -040037 u64 dblock;
38 u32 extlen;
David Teiglandb3b94fa2006-01-16 16:50:04 +000039 int error;
40
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -040041 error = gfs2_extent_map(&ip->i_inode, blk, &new, &dblock, &extlen);
David Teiglandb3b94fa2006-01-16 16:50:04 +000042 if (error)
43 return error;
44 if (!dblock) {
Steven Whitehouse5c676f62006-02-27 17:23:27 -050045 gfs2_consist_inode(ip);
David Teiglandb3b94fa2006-01-16 16:50:04 +000046 return -EIO;
47 }
48
Steven Whitehouse7276b3b2006-09-21 17:05:23 -040049 *bh = gfs2_meta_ra(gl, dblock, extlen);
David Teiglandb3b94fa2006-01-16 16:50:04 +000050
51 return error;
52}
53
Steven Whitehousecd915492006-09-04 12:49:07 -040054int gfs2_revoke_add(struct gfs2_sbd *sdp, u64 blkno, unsigned int where)
David Teiglandb3b94fa2006-01-16 16:50:04 +000055{
56 struct list_head *head = &sdp->sd_revoke_list;
57 struct gfs2_revoke_replay *rr;
58 int found = 0;
59
60 list_for_each_entry(rr, head, rr_list) {
61 if (rr->rr_blkno == blkno) {
62 found = 1;
63 break;
64 }
65 }
66
67 if (found) {
68 rr->rr_where = where;
69 return 0;
70 }
71
72 rr = kmalloc(sizeof(struct gfs2_revoke_replay), GFP_KERNEL);
73 if (!rr)
74 return -ENOMEM;
75
76 rr->rr_blkno = blkno;
77 rr->rr_where = where;
78 list_add(&rr->rr_list, head);
79
80 return 1;
81}
82
Steven Whitehousecd915492006-09-04 12:49:07 -040083int gfs2_revoke_check(struct gfs2_sbd *sdp, u64 blkno, unsigned int where)
David Teiglandb3b94fa2006-01-16 16:50:04 +000084{
85 struct gfs2_revoke_replay *rr;
86 int wrap, a, b, revoke;
87 int found = 0;
88
89 list_for_each_entry(rr, &sdp->sd_revoke_list, rr_list) {
90 if (rr->rr_blkno == blkno) {
91 found = 1;
92 break;
93 }
94 }
95
96 if (!found)
97 return 0;
98
99 wrap = (rr->rr_where < sdp->sd_replay_tail);
100 a = (sdp->sd_replay_tail < where);
101 b = (where < rr->rr_where);
102 revoke = (wrap) ? (a || b) : (a && b);
103
104 return revoke;
105}
106
107void gfs2_revoke_clean(struct gfs2_sbd *sdp)
108{
109 struct list_head *head = &sdp->sd_revoke_list;
110 struct gfs2_revoke_replay *rr;
111
112 while (!list_empty(head)) {
113 rr = list_entry(head->next, struct gfs2_revoke_replay, rr_list);
114 list_del(&rr->rr_list);
115 kfree(rr);
116 }
117}
118
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100119static int gfs2_log_header_in(struct gfs2_log_header_host *lh, const void *buf)
120{
121 const struct gfs2_log_header *str = buf;
122
123 if (str->lh_header.mh_magic != cpu_to_be32(GFS2_MAGIC) ||
124 str->lh_header.mh_type != cpu_to_be32(GFS2_METATYPE_LH))
125 return 1;
126
127 lh->lh_sequence = be64_to_cpu(str->lh_sequence);
128 lh->lh_flags = be32_to_cpu(str->lh_flags);
129 lh->lh_tail = be32_to_cpu(str->lh_tail);
130 lh->lh_blkno = be32_to_cpu(str->lh_blkno);
131 lh->lh_hash = be32_to_cpu(str->lh_hash);
132 return 0;
133}
134
David Teiglandb3b94fa2006-01-16 16:50:04 +0000135/**
136 * get_log_header - read the log header for a given segment
137 * @jd: the journal
138 * @blk: the block to look at
139 * @lh: the log header to return
140 *
141 * Read the log header for a given segement in a given journal. Do a few
142 * sanity checks on it.
143 *
144 * Returns: 0 on success,
145 * 1 if the header was invalid or incomplete,
146 * errno on error
147 */
148
149static int get_log_header(struct gfs2_jdesc *jd, unsigned int blk,
Al Viro55167622006-10-13 21:47:13 -0400150 struct gfs2_log_header_host *head)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000151{
152 struct buffer_head *bh;
Al Viro55167622006-10-13 21:47:13 -0400153 struct gfs2_log_header_host lh;
Steven Whitehouse887bc5d2006-12-05 13:34:17 -0500154 const u32 nothing = 0;
Steven Whitehousecd915492006-09-04 12:49:07 -0400155 u32 hash;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000156 int error;
157
158 error = gfs2_replay_read_block(jd, blk, &bh);
159 if (error)
160 return error;
161
Steven Whitehouse2a2c9822006-10-31 14:44:50 -0500162 hash = crc32_le((u32)~0, bh->b_data, sizeof(struct gfs2_log_header) -
163 sizeof(u32));
164 hash = crc32_le(hash, (unsigned char const *)&nothing, sizeof(nothing));
165 hash ^= (u32)~0;
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100166 error = gfs2_log_header_in(&lh, bh->b_data);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000167 brelse(bh);
168
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100169 if (error || lh.lh_blkno != blk || lh.lh_hash != hash)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000170 return 1;
171
172 *head = lh;
173
174 return 0;
175}
176
177/**
178 * find_good_lh - find a good log header
179 * @jd: the journal
180 * @blk: the segment to start searching from
181 * @lh: the log header to fill in
182 * @forward: if true search forward in the log, else search backward
183 *
184 * Call get_log_header() to get a log header for a segment, but if the
185 * segment is bad, either scan forward or backward until we find a good one.
186 *
187 * Returns: errno
188 */
189
190static int find_good_lh(struct gfs2_jdesc *jd, unsigned int *blk,
Al Viro55167622006-10-13 21:47:13 -0400191 struct gfs2_log_header_host *head)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000192{
193 unsigned int orig_blk = *blk;
194 int error;
195
196 for (;;) {
197 error = get_log_header(jd, *blk, head);
198 if (error <= 0)
199 return error;
200
201 if (++*blk == jd->jd_blocks)
202 *blk = 0;
203
204 if (*blk == orig_blk) {
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400205 gfs2_consist_inode(GFS2_I(jd->jd_inode));
David Teiglandb3b94fa2006-01-16 16:50:04 +0000206 return -EIO;
207 }
208 }
209}
210
211/**
212 * jhead_scan - make sure we've found the head of the log
213 * @jd: the journal
214 * @head: this is filled in with the log descriptor of the head
215 *
216 * At this point, seg and lh should be either the head of the log or just
217 * before. Scan forward until we find the head.
218 *
219 * Returns: errno
220 */
221
Al Viro55167622006-10-13 21:47:13 -0400222static int jhead_scan(struct gfs2_jdesc *jd, struct gfs2_log_header_host *head)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000223{
224 unsigned int blk = head->lh_blkno;
Al Viro55167622006-10-13 21:47:13 -0400225 struct gfs2_log_header_host lh;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000226 int error;
227
228 for (;;) {
229 if (++blk == jd->jd_blocks)
230 blk = 0;
231
232 error = get_log_header(jd, blk, &lh);
233 if (error < 0)
234 return error;
235 if (error == 1)
236 continue;
237
238 if (lh.lh_sequence == head->lh_sequence) {
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400239 gfs2_consist_inode(GFS2_I(jd->jd_inode));
David Teiglandb3b94fa2006-01-16 16:50:04 +0000240 return -EIO;
241 }
242 if (lh.lh_sequence < head->lh_sequence)
243 break;
244
245 *head = lh;
246 }
247
248 return 0;
249}
250
251/**
252 * gfs2_find_jhead - find the head of a log
253 * @jd: the journal
254 * @head: the log descriptor for the head of the log is returned here
255 *
256 * Do a binary search of a journal and find the valid log entry with the
257 * highest sequence number. (i.e. the log head)
258 *
259 * Returns: errno
260 */
261
Al Viro55167622006-10-13 21:47:13 -0400262int gfs2_find_jhead(struct gfs2_jdesc *jd, struct gfs2_log_header_host *head)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000263{
Al Viro55167622006-10-13 21:47:13 -0400264 struct gfs2_log_header_host lh_1, lh_m;
Steven Whitehousecd915492006-09-04 12:49:07 -0400265 u32 blk_1, blk_2, blk_m;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000266 int error;
267
268 blk_1 = 0;
269 blk_2 = jd->jd_blocks - 1;
270
271 for (;;) {
272 blk_m = (blk_1 + blk_2) / 2;
273
274 error = find_good_lh(jd, &blk_1, &lh_1);
275 if (error)
276 return error;
277
278 error = find_good_lh(jd, &blk_m, &lh_m);
279 if (error)
280 return error;
281
282 if (blk_1 == blk_m || blk_m == blk_2)
283 break;
284
285 if (lh_1.lh_sequence <= lh_m.lh_sequence)
286 blk_1 = blk_m;
287 else
288 blk_2 = blk_m;
289 }
290
291 error = jhead_scan(jd, &lh_1);
292 if (error)
293 return error;
294
295 *head = lh_1;
296
297 return error;
298}
299
300/**
301 * foreach_descriptor - go through the active part of the log
302 * @jd: the journal
303 * @start: the first log header in the active region
304 * @end: the last log header (don't process the contents of this entry))
305 *
306 * Call a given function once for every log descriptor in the active
307 * portion of the log.
308 *
309 * Returns: errno
310 */
311
312static int foreach_descriptor(struct gfs2_jdesc *jd, unsigned int start,
313 unsigned int end, int pass)
314{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400315 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000316 struct buffer_head *bh;
317 struct gfs2_log_descriptor *ld;
318 int error = 0;
319 u32 length;
320 __be64 *ptr;
321 unsigned int offset = sizeof(struct gfs2_log_descriptor);
Steven Whitehousea67cdbd2006-09-05 14:41:30 -0400322 offset += sizeof(__be64) - 1;
323 offset &= ~(sizeof(__be64) - 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000324
325 while (start != end) {
326 error = gfs2_replay_read_block(jd, start, &bh);
327 if (error)
328 return error;
329 if (gfs2_meta_check(sdp, bh)) {
330 brelse(bh);
331 return -EIO;
332 }
333 ld = (struct gfs2_log_descriptor *)bh->b_data;
334 length = be32_to_cpu(ld->ld_length);
335
Steven Whitehousee3167de2006-03-30 15:46:23 -0500336 if (be32_to_cpu(ld->ld_header.mh_type) == GFS2_METATYPE_LH) {
Al Viro55167622006-10-13 21:47:13 -0400337 struct gfs2_log_header_host lh;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000338 error = get_log_header(jd, start, &lh);
339 if (!error) {
340 gfs2_replay_incr_blk(sdp, &start);
Russell Cattelan88721872006-08-10 11:08:40 -0500341 brelse(bh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000342 continue;
343 }
344 if (error == 1) {
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400345 gfs2_consist_inode(GFS2_I(jd->jd_inode));
David Teiglandb3b94fa2006-01-16 16:50:04 +0000346 error = -EIO;
347 }
348 brelse(bh);
349 return error;
350 } else if (gfs2_metatype_check(sdp, bh, GFS2_METATYPE_LD)) {
351 brelse(bh);
352 return -EIO;
353 }
354 ptr = (__be64 *)(bh->b_data + offset);
355 error = lops_scan_elements(jd, start, ld, ptr, pass);
356 if (error) {
357 brelse(bh);
358 return error;
359 }
360
361 while (length--)
362 gfs2_replay_incr_blk(sdp, &start);
363
364 brelse(bh);
365 }
366
367 return 0;
368}
369
370/**
371 * clean_journal - mark a dirty journal as being clean
372 * @sdp: the filesystem
373 * @jd: the journal
374 * @gl: the journal's glock
375 * @head: the head journal to start from
376 *
377 * Returns: errno
378 */
379
Al Viro55167622006-10-13 21:47:13 -0400380static int clean_journal(struct gfs2_jdesc *jd, struct gfs2_log_header_host *head)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000381{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400382 struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
383 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000384 unsigned int lblock;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000385 struct gfs2_log_header *lh;
Steven Whitehousecd915492006-09-04 12:49:07 -0400386 u32 hash;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000387 struct buffer_head *bh;
388 int error;
Steven Whitehouse23591252006-10-13 17:25:45 -0400389 struct buffer_head bh_map = { .b_state = 0, .b_blocknr = 0 };
Steven Whitehousefd88de562006-05-05 16:59:11 -0400390
David Teiglandb3b94fa2006-01-16 16:50:04 +0000391 lblock = head->lh_blkno;
392 gfs2_replay_incr_blk(sdp, &lblock);
Steven Whitehouse23591252006-10-13 17:25:45 -0400393 bh_map.b_size = 1 << ip->i_inode.i_blkbits;
394 error = gfs2_block_map(&ip->i_inode, lblock, 0, &bh_map);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000395 if (error)
396 return error;
Steven Whitehouse7a6bbac2006-09-18 17:18:23 -0400397 if (!bh_map.b_blocknr) {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000398 gfs2_consist_inode(ip);
399 return -EIO;
400 }
401
Steven Whitehouse7a6bbac2006-09-18 17:18:23 -0400402 bh = sb_getblk(sdp->sd_vfs, bh_map.b_blocknr);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000403 lock_buffer(bh);
404 memset(bh->b_data, 0, bh->b_size);
405 set_buffer_uptodate(bh);
406 clear_buffer_dirty(bh);
407 unlock_buffer(bh);
408
409 lh = (struct gfs2_log_header *)bh->b_data;
410 memset(lh, 0, sizeof(struct gfs2_log_header));
411 lh->lh_header.mh_magic = cpu_to_be32(GFS2_MAGIC);
Russell Cattelan88721872006-08-10 11:08:40 -0500412 lh->lh_header.mh_type = cpu_to_be32(GFS2_METATYPE_LH);
Steven Whitehousee3167de2006-03-30 15:46:23 -0500413 lh->lh_header.mh_format = cpu_to_be32(GFS2_FORMAT_LH);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000414 lh->lh_sequence = cpu_to_be64(head->lh_sequence + 1);
415 lh->lh_flags = cpu_to_be32(GFS2_LOG_HEAD_UNMOUNT);
416 lh->lh_blkno = cpu_to_be32(lblock);
417 hash = gfs2_disk_hash((const char *)lh, sizeof(struct gfs2_log_header));
418 lh->lh_hash = cpu_to_be32(hash);
419
420 set_buffer_dirty(bh);
421 if (sync_dirty_buffer(bh))
422 gfs2_io_error_bh(sdp, bh);
423 brelse(bh);
424
425 return error;
426}
427
428/**
429 * gfs2_recover_journal - recovery a given journal
430 * @jd: the struct gfs2_jdesc describing the journal
David Teiglandb3b94fa2006-01-16 16:50:04 +0000431 *
432 * Acquire the journal's lock, check to see if the journal is clean, and
433 * do recovery if necessary.
434 *
435 * Returns: errno
436 */
437
David Teiglandc63e31c2006-04-20 17:03:48 -0400438int gfs2_recover_journal(struct gfs2_jdesc *jd)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000439{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400440 struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
441 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
Al Viro55167622006-10-13 21:47:13 -0400442 struct gfs2_log_header_host head;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000443 struct gfs2_holder j_gh, ji_gh, t_gh;
444 unsigned long t;
445 int ro = 0;
446 unsigned int pass;
447 int error;
448
Steven Whitehouse5965b1f2006-04-26 13:21:55 -0400449 if (jd->jd_jid != sdp->sd_lockstruct.ls_jid) {
450 fs_info(sdp, "jid=%u: Trying to acquire journal lock...\n",
451 jd->jd_jid);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000452
Steven Whitehouse5965b1f2006-04-26 13:21:55 -0400453 /* Aquire the journal lock so we can do recovery */
David Teiglandb3b94fa2006-01-16 16:50:04 +0000454
Steven Whitehouse5965b1f2006-04-26 13:21:55 -0400455 error = gfs2_glock_nq_num(sdp, jd->jd_jid, &gfs2_journal_glops,
456 LM_ST_EXCLUSIVE,
457 LM_FLAG_NOEXP | LM_FLAG_TRY | GL_NOCACHE,
458 &j_gh);
459 switch (error) {
460 case 0:
461 break;
Steven Whitehouse907b9bc2006-09-25 09:26:04 -0400462
Steven Whitehouse5965b1f2006-04-26 13:21:55 -0400463 case GLR_TRYFAILED:
464 fs_info(sdp, "jid=%u: Busy\n", jd->jd_jid);
465 error = 0;
Steven Whitehouse907b9bc2006-09-25 09:26:04 -0400466
Steven Whitehouse5965b1f2006-04-26 13:21:55 -0400467 default:
468 goto fail;
469 };
David Teiglandb3b94fa2006-01-16 16:50:04 +0000470
Steven Whitehouse5965b1f2006-04-26 13:21:55 -0400471 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED,
472 LM_FLAG_NOEXP, &ji_gh);
473 if (error)
474 goto fail_gunlock_j;
475 } else {
476 fs_info(sdp, "jid=%u, already locked for use\n", jd->jd_jid);
477 }
David Teiglandb3b94fa2006-01-16 16:50:04 +0000478
479 fs_info(sdp, "jid=%u: Looking at journal...\n", jd->jd_jid);
480
481 error = gfs2_jdesc_check(jd);
482 if (error)
483 goto fail_gunlock_ji;
484
485 error = gfs2_find_jhead(jd, &head);
486 if (error)
487 goto fail_gunlock_ji;
488
489 if (!(head.lh_flags & GFS2_LOG_HEAD_UNMOUNT)) {
490 fs_info(sdp, "jid=%u: Acquiring the transaction lock...\n",
491 jd->jd_jid);
492
493 t = jiffies;
494
495 /* Acquire a shared hold on the transaction lock */
496
Steven Whitehouse59a1cc62006-08-04 15:41:22 -0400497 error = gfs2_glock_nq_init(sdp->sd_trans_gl, LM_ST_SHARED,
Steven Whitehouse5965b1f2006-04-26 13:21:55 -0400498 LM_FLAG_NOEXP | LM_FLAG_PRIORITY |
Steven Whitehouse59a1cc62006-08-04 15:41:22 -0400499 GL_NOCANCEL | GL_NOCACHE, &t_gh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000500 if (error)
501 goto fail_gunlock_ji;
502
503 if (test_bit(SDF_JOURNAL_CHECKED, &sdp->sd_flags)) {
504 if (!test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags))
505 ro = 1;
506 } else {
507 if (sdp->sd_vfs->s_flags & MS_RDONLY)
508 ro = 1;
509 }
510
511 if (ro) {
512 fs_warn(sdp, "jid=%u: Can't replay: read-only FS\n",
513 jd->jd_jid);
514 error = -EROFS;
515 goto fail_gunlock_tr;
516 }
517
518 fs_info(sdp, "jid=%u: Replaying journal...\n", jd->jd_jid);
519
520 for (pass = 0; pass < 2; pass++) {
521 lops_before_scan(jd, &head, pass);
522 error = foreach_descriptor(jd, head.lh_tail,
523 head.lh_blkno, pass);
524 lops_after_scan(jd, error, pass);
525 if (error)
526 goto fail_gunlock_tr;
527 }
528
529 error = clean_journal(jd, &head);
530 if (error)
531 goto fail_gunlock_tr;
532
533 gfs2_glock_dq_uninit(&t_gh);
Steven Whitehouse5c676f62006-02-27 17:23:27 -0500534 t = DIV_ROUND_UP(jiffies - t, HZ);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000535 fs_info(sdp, "jid=%u: Journal replayed in %lus\n",
536 jd->jd_jid, t);
537 }
538
Steven Whitehouse5965b1f2006-04-26 13:21:55 -0400539 if (jd->jd_jid != sdp->sd_lockstruct.ls_jid)
540 gfs2_glock_dq_uninit(&ji_gh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000541
542 gfs2_lm_recovery_done(sdp, jd->jd_jid, LM_RD_SUCCESS);
543
Steven Whitehouse5965b1f2006-04-26 13:21:55 -0400544 if (jd->jd_jid != sdp->sd_lockstruct.ls_jid)
545 gfs2_glock_dq_uninit(&j_gh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000546
547 fs_info(sdp, "jid=%u: Done\n", jd->jd_jid);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000548 return 0;
549
Steven Whitehouse5965b1f2006-04-26 13:21:55 -0400550fail_gunlock_tr:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000551 gfs2_glock_dq_uninit(&t_gh);
Steven Whitehouse5965b1f2006-04-26 13:21:55 -0400552fail_gunlock_ji:
553 if (jd->jd_jid != sdp->sd_lockstruct.ls_jid) {
554 gfs2_glock_dq_uninit(&ji_gh);
555fail_gunlock_j:
556 gfs2_glock_dq_uninit(&j_gh);
557 }
David Teiglandb3b94fa2006-01-16 16:50:04 +0000558
559 fs_info(sdp, "jid=%u: %s\n", jd->jd_jid, (error) ? "Failed" : "Done");
560
Steven Whitehouse5965b1f2006-04-26 13:21:55 -0400561fail:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000562 gfs2_lm_recovery_done(sdp, jd->jd_jid, LM_RD_GAVEUP);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000563 return error;
564}
565
566/**
567 * gfs2_check_journals - Recover any dirty journals
568 * @sdp: the filesystem
569 *
570 */
571
572void gfs2_check_journals(struct gfs2_sbd *sdp)
573{
574 struct gfs2_jdesc *jd;
575
576 for (;;) {
577 jd = gfs2_jdesc_find_dirty(sdp);
578 if (!jd)
579 break;
580
581 if (jd != sdp->sd_jdesc)
David Teiglandc63e31c2006-04-20 17:03:48 -0400582 gfs2_recover_journal(jd);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000583 }
584}
585