blob: d0c806b85c864387cffec4a7a82a9dd8d5deb329 [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
10#include <linux/sched.h>
11#include <linux/slab.h>
12#include <linux/spinlock.h>
13#include <linux/completion.h>
14#include <linux/buffer_head.h>
Steven Whitehouse5c676f62006-02-27 17:23:27 -050015#include <linux/gfs2_ondisk.h>
Steven Whitehouse71b86f52006-03-28 14:14:04 -050016#include <linux/crc32.h>
Fabio Massimo Di Nitto7d308592006-09-19 07:56:29 +020017#include <linux/lm_interface.h>
David Teiglandb3b94fa2006-01-16 16:50:04 +000018
19#include "gfs2.h"
Steven Whitehouse5c676f62006-02-27 17:23:27 -050020#include "incore.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000021#include "bmap.h"
22#include "glock.h"
23#include "glops.h"
24#include "lm.h"
25#include "lops.h"
26#include "meta_io.h"
27#include "recovery.h"
28#include "super.h"
Steven Whitehouse5c676f62006-02-27 17:23:27 -050029#include "util.h"
Steven Whitehouse71b86f52006-03-28 14:14:04 -050030#include "dir.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000031
32int gfs2_replay_read_block(struct gfs2_jdesc *jd, unsigned int blk,
33 struct buffer_head **bh)
34{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -040035 struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
Steven Whitehouse5c676f62006-02-27 17:23:27 -050036 struct gfs2_glock *gl = ip->i_gl;
David Teiglandb3b94fa2006-01-16 16:50:04 +000037 int new = 0;
Steven Whitehousecd915492006-09-04 12:49:07 -040038 u64 dblock;
39 u32 extlen;
David Teiglandb3b94fa2006-01-16 16:50:04 +000040 int error;
41
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -040042 error = gfs2_extent_map(&ip->i_inode, blk, &new, &dblock, &extlen);
David Teiglandb3b94fa2006-01-16 16:50:04 +000043 if (error)
44 return error;
45 if (!dblock) {
Steven Whitehouse5c676f62006-02-27 17:23:27 -050046 gfs2_consist_inode(ip);
David Teiglandb3b94fa2006-01-16 16:50:04 +000047 return -EIO;
48 }
49
Steven Whitehouse7276b3b2006-09-21 17:05:23 -040050 *bh = gfs2_meta_ra(gl, dblock, extlen);
David Teiglandb3b94fa2006-01-16 16:50:04 +000051
52 return error;
53}
54
Steven Whitehousecd915492006-09-04 12:49:07 -040055int gfs2_revoke_add(struct gfs2_sbd *sdp, u64 blkno, unsigned int where)
David Teiglandb3b94fa2006-01-16 16:50:04 +000056{
57 struct list_head *head = &sdp->sd_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_KERNEL);
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
Steven Whitehousecd915492006-09-04 12:49:07 -040084int gfs2_revoke_check(struct gfs2_sbd *sdp, u64 blkno, unsigned int where)
David Teiglandb3b94fa2006-01-16 16:50:04 +000085{
86 struct gfs2_revoke_replay *rr;
87 int wrap, a, b, revoke;
88 int found = 0;
89
90 list_for_each_entry(rr, &sdp->sd_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 < sdp->sd_replay_tail);
101 a = (sdp->sd_replay_tail < where);
102 b = (where < rr->rr_where);
103 revoke = (wrap) ? (a || b) : (a && b);
104
105 return revoke;
106}
107
108void gfs2_revoke_clean(struct gfs2_sbd *sdp)
109{
110 struct list_head *head = &sdp->sd_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/**
121 * get_log_header - read the log header for a given segment
122 * @jd: the journal
123 * @blk: the block to look at
124 * @lh: the log header to return
125 *
126 * Read the log header for a given segement in a given journal. Do a few
127 * sanity checks on it.
128 *
129 * Returns: 0 on success,
130 * 1 if the header was invalid or incomplete,
131 * errno on error
132 */
133
134static int get_log_header(struct gfs2_jdesc *jd, unsigned int blk,
Al Viro55167622006-10-13 21:47:13 -0400135 struct gfs2_log_header_host *head)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000136{
137 struct buffer_head *bh;
Al Viro55167622006-10-13 21:47:13 -0400138 struct gfs2_log_header_host lh;
Steven Whitehouse887bc5d2006-12-05 13:34:17 -0500139 const u32 nothing = 0;
Steven Whitehousecd915492006-09-04 12:49:07 -0400140 u32 hash;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000141 int error;
142
143 error = gfs2_replay_read_block(jd, blk, &bh);
144 if (error)
145 return error;
146
Steven Whitehouse2a2c9822006-10-31 14:44:50 -0500147 hash = crc32_le((u32)~0, bh->b_data, sizeof(struct gfs2_log_header) -
148 sizeof(u32));
149 hash = crc32_le(hash, (unsigned char const *)&nothing, sizeof(nothing));
150 hash ^= (u32)~0;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000151 gfs2_log_header_in(&lh, bh->b_data);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000152 brelse(bh);
153
154 if (lh.lh_header.mh_magic != GFS2_MAGIC ||
155 lh.lh_header.mh_type != GFS2_METATYPE_LH ||
Steven Whitehouse59a1cc62006-08-04 15:41:22 -0400156 lh.lh_blkno != blk || lh.lh_hash != hash)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000157 return 1;
158
159 *head = lh;
160
161 return 0;
162}
163
164/**
165 * find_good_lh - find a good log header
166 * @jd: the journal
167 * @blk: the segment to start searching from
168 * @lh: the log header to fill in
169 * @forward: if true search forward in the log, else search backward
170 *
171 * Call get_log_header() to get a log header for a segment, but if the
172 * segment is bad, either scan forward or backward until we find a good one.
173 *
174 * Returns: errno
175 */
176
177static int find_good_lh(struct gfs2_jdesc *jd, unsigned int *blk,
Al Viro55167622006-10-13 21:47:13 -0400178 struct gfs2_log_header_host *head)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000179{
180 unsigned int orig_blk = *blk;
181 int error;
182
183 for (;;) {
184 error = get_log_header(jd, *blk, head);
185 if (error <= 0)
186 return error;
187
188 if (++*blk == jd->jd_blocks)
189 *blk = 0;
190
191 if (*blk == orig_blk) {
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400192 gfs2_consist_inode(GFS2_I(jd->jd_inode));
David Teiglandb3b94fa2006-01-16 16:50:04 +0000193 return -EIO;
194 }
195 }
196}
197
198/**
199 * jhead_scan - make sure we've found the head of the log
200 * @jd: the journal
201 * @head: this is filled in with the log descriptor of the head
202 *
203 * At this point, seg and lh should be either the head of the log or just
204 * before. Scan forward until we find the head.
205 *
206 * Returns: errno
207 */
208
Al Viro55167622006-10-13 21:47:13 -0400209static int jhead_scan(struct gfs2_jdesc *jd, struct gfs2_log_header_host *head)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000210{
211 unsigned int blk = head->lh_blkno;
Al Viro55167622006-10-13 21:47:13 -0400212 struct gfs2_log_header_host lh;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000213 int error;
214
215 for (;;) {
216 if (++blk == jd->jd_blocks)
217 blk = 0;
218
219 error = get_log_header(jd, blk, &lh);
220 if (error < 0)
221 return error;
222 if (error == 1)
223 continue;
224
225 if (lh.lh_sequence == head->lh_sequence) {
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400226 gfs2_consist_inode(GFS2_I(jd->jd_inode));
David Teiglandb3b94fa2006-01-16 16:50:04 +0000227 return -EIO;
228 }
229 if (lh.lh_sequence < head->lh_sequence)
230 break;
231
232 *head = lh;
233 }
234
235 return 0;
236}
237
238/**
239 * gfs2_find_jhead - find the head of a log
240 * @jd: the journal
241 * @head: the log descriptor for the head of the log is returned here
242 *
243 * Do a binary search of a journal and find the valid log entry with the
244 * highest sequence number. (i.e. the log head)
245 *
246 * Returns: errno
247 */
248
Al Viro55167622006-10-13 21:47:13 -0400249int gfs2_find_jhead(struct gfs2_jdesc *jd, struct gfs2_log_header_host *head)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000250{
Al Viro55167622006-10-13 21:47:13 -0400251 struct gfs2_log_header_host lh_1, lh_m;
Steven Whitehousecd915492006-09-04 12:49:07 -0400252 u32 blk_1, blk_2, blk_m;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000253 int error;
254
255 blk_1 = 0;
256 blk_2 = jd->jd_blocks - 1;
257
258 for (;;) {
259 blk_m = (blk_1 + blk_2) / 2;
260
261 error = find_good_lh(jd, &blk_1, &lh_1);
262 if (error)
263 return error;
264
265 error = find_good_lh(jd, &blk_m, &lh_m);
266 if (error)
267 return error;
268
269 if (blk_1 == blk_m || blk_m == blk_2)
270 break;
271
272 if (lh_1.lh_sequence <= lh_m.lh_sequence)
273 blk_1 = blk_m;
274 else
275 blk_2 = blk_m;
276 }
277
278 error = jhead_scan(jd, &lh_1);
279 if (error)
280 return error;
281
282 *head = lh_1;
283
284 return error;
285}
286
287/**
288 * foreach_descriptor - go through the active part of the log
289 * @jd: the journal
290 * @start: the first log header in the active region
291 * @end: the last log header (don't process the contents of this entry))
292 *
293 * Call a given function once for every log descriptor in the active
294 * portion of the log.
295 *
296 * Returns: errno
297 */
298
299static int foreach_descriptor(struct gfs2_jdesc *jd, unsigned int start,
300 unsigned int end, int pass)
301{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400302 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000303 struct buffer_head *bh;
304 struct gfs2_log_descriptor *ld;
305 int error = 0;
306 u32 length;
307 __be64 *ptr;
308 unsigned int offset = sizeof(struct gfs2_log_descriptor);
Steven Whitehousea67cdbd2006-09-05 14:41:30 -0400309 offset += sizeof(__be64) - 1;
310 offset &= ~(sizeof(__be64) - 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000311
312 while (start != end) {
313 error = gfs2_replay_read_block(jd, start, &bh);
314 if (error)
315 return error;
316 if (gfs2_meta_check(sdp, bh)) {
317 brelse(bh);
318 return -EIO;
319 }
320 ld = (struct gfs2_log_descriptor *)bh->b_data;
321 length = be32_to_cpu(ld->ld_length);
322
Steven Whitehousee3167de2006-03-30 15:46:23 -0500323 if (be32_to_cpu(ld->ld_header.mh_type) == GFS2_METATYPE_LH) {
Al Viro55167622006-10-13 21:47:13 -0400324 struct gfs2_log_header_host lh;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000325 error = get_log_header(jd, start, &lh);
326 if (!error) {
327 gfs2_replay_incr_blk(sdp, &start);
Russell Cattelan88721872006-08-10 11:08:40 -0500328 brelse(bh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000329 continue;
330 }
331 if (error == 1) {
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400332 gfs2_consist_inode(GFS2_I(jd->jd_inode));
David Teiglandb3b94fa2006-01-16 16:50:04 +0000333 error = -EIO;
334 }
335 brelse(bh);
336 return error;
337 } else if (gfs2_metatype_check(sdp, bh, GFS2_METATYPE_LD)) {
338 brelse(bh);
339 return -EIO;
340 }
341 ptr = (__be64 *)(bh->b_data + offset);
342 error = lops_scan_elements(jd, start, ld, ptr, pass);
343 if (error) {
344 brelse(bh);
345 return error;
346 }
347
348 while (length--)
349 gfs2_replay_incr_blk(sdp, &start);
350
351 brelse(bh);
352 }
353
354 return 0;
355}
356
357/**
358 * clean_journal - mark a dirty journal as being clean
359 * @sdp: the filesystem
360 * @jd: the journal
361 * @gl: the journal's glock
362 * @head: the head journal to start from
363 *
364 * Returns: errno
365 */
366
Al Viro55167622006-10-13 21:47:13 -0400367static int clean_journal(struct gfs2_jdesc *jd, struct gfs2_log_header_host *head)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000368{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400369 struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
370 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000371 unsigned int lblock;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000372 struct gfs2_log_header *lh;
Steven Whitehousecd915492006-09-04 12:49:07 -0400373 u32 hash;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000374 struct buffer_head *bh;
375 int error;
Steven Whitehouse23591252006-10-13 17:25:45 -0400376 struct buffer_head bh_map = { .b_state = 0, .b_blocknr = 0 };
Steven Whitehousefd88de562006-05-05 16:59:11 -0400377
David Teiglandb3b94fa2006-01-16 16:50:04 +0000378 lblock = head->lh_blkno;
379 gfs2_replay_incr_blk(sdp, &lblock);
Steven Whitehouse23591252006-10-13 17:25:45 -0400380 bh_map.b_size = 1 << ip->i_inode.i_blkbits;
381 error = gfs2_block_map(&ip->i_inode, lblock, 0, &bh_map);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000382 if (error)
383 return error;
Steven Whitehouse7a6bbac2006-09-18 17:18:23 -0400384 if (!bh_map.b_blocknr) {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000385 gfs2_consist_inode(ip);
386 return -EIO;
387 }
388
Steven Whitehouse7a6bbac2006-09-18 17:18:23 -0400389 bh = sb_getblk(sdp->sd_vfs, bh_map.b_blocknr);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000390 lock_buffer(bh);
391 memset(bh->b_data, 0, bh->b_size);
392 set_buffer_uptodate(bh);
393 clear_buffer_dirty(bh);
394 unlock_buffer(bh);
395
396 lh = (struct gfs2_log_header *)bh->b_data;
397 memset(lh, 0, sizeof(struct gfs2_log_header));
398 lh->lh_header.mh_magic = cpu_to_be32(GFS2_MAGIC);
Russell Cattelan88721872006-08-10 11:08:40 -0500399 lh->lh_header.mh_type = cpu_to_be32(GFS2_METATYPE_LH);
Steven Whitehousee3167de2006-03-30 15:46:23 -0500400 lh->lh_header.mh_format = cpu_to_be32(GFS2_FORMAT_LH);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000401 lh->lh_sequence = cpu_to_be64(head->lh_sequence + 1);
402 lh->lh_flags = cpu_to_be32(GFS2_LOG_HEAD_UNMOUNT);
403 lh->lh_blkno = cpu_to_be32(lblock);
404 hash = gfs2_disk_hash((const char *)lh, sizeof(struct gfs2_log_header));
405 lh->lh_hash = cpu_to_be32(hash);
406
407 set_buffer_dirty(bh);
408 if (sync_dirty_buffer(bh))
409 gfs2_io_error_bh(sdp, bh);
410 brelse(bh);
411
412 return error;
413}
414
415/**
416 * gfs2_recover_journal - recovery a given journal
417 * @jd: the struct gfs2_jdesc describing the journal
David Teiglandb3b94fa2006-01-16 16:50:04 +0000418 *
419 * Acquire the journal's lock, check to see if the journal is clean, and
420 * do recovery if necessary.
421 *
422 * Returns: errno
423 */
424
David Teiglandc63e31c2006-04-20 17:03:48 -0400425int gfs2_recover_journal(struct gfs2_jdesc *jd)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000426{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400427 struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
428 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
Al Viro55167622006-10-13 21:47:13 -0400429 struct gfs2_log_header_host head;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000430 struct gfs2_holder j_gh, ji_gh, t_gh;
431 unsigned long t;
432 int ro = 0;
433 unsigned int pass;
434 int error;
435
Steven Whitehouse5965b1f2006-04-26 13:21:55 -0400436 if (jd->jd_jid != sdp->sd_lockstruct.ls_jid) {
437 fs_info(sdp, "jid=%u: Trying to acquire journal lock...\n",
438 jd->jd_jid);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000439
Steven Whitehouse5965b1f2006-04-26 13:21:55 -0400440 /* Aquire the journal lock so we can do recovery */
David Teiglandb3b94fa2006-01-16 16:50:04 +0000441
Steven Whitehouse5965b1f2006-04-26 13:21:55 -0400442 error = gfs2_glock_nq_num(sdp, jd->jd_jid, &gfs2_journal_glops,
443 LM_ST_EXCLUSIVE,
444 LM_FLAG_NOEXP | LM_FLAG_TRY | GL_NOCACHE,
445 &j_gh);
446 switch (error) {
447 case 0:
448 break;
Steven Whitehouse907b9bc2006-09-25 09:26:04 -0400449
Steven Whitehouse5965b1f2006-04-26 13:21:55 -0400450 case GLR_TRYFAILED:
451 fs_info(sdp, "jid=%u: Busy\n", jd->jd_jid);
452 error = 0;
Steven Whitehouse907b9bc2006-09-25 09:26:04 -0400453
Steven Whitehouse5965b1f2006-04-26 13:21:55 -0400454 default:
455 goto fail;
456 };
David Teiglandb3b94fa2006-01-16 16:50:04 +0000457
Steven Whitehouse5965b1f2006-04-26 13:21:55 -0400458 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED,
459 LM_FLAG_NOEXP, &ji_gh);
460 if (error)
461 goto fail_gunlock_j;
462 } else {
463 fs_info(sdp, "jid=%u, already locked for use\n", jd->jd_jid);
464 }
David Teiglandb3b94fa2006-01-16 16:50:04 +0000465
466 fs_info(sdp, "jid=%u: Looking at journal...\n", jd->jd_jid);
467
468 error = gfs2_jdesc_check(jd);
469 if (error)
470 goto fail_gunlock_ji;
471
472 error = gfs2_find_jhead(jd, &head);
473 if (error)
474 goto fail_gunlock_ji;
475
476 if (!(head.lh_flags & GFS2_LOG_HEAD_UNMOUNT)) {
477 fs_info(sdp, "jid=%u: Acquiring the transaction lock...\n",
478 jd->jd_jid);
479
480 t = jiffies;
481
482 /* Acquire a shared hold on the transaction lock */
483
Steven Whitehouse59a1cc62006-08-04 15:41:22 -0400484 error = gfs2_glock_nq_init(sdp->sd_trans_gl, LM_ST_SHARED,
Steven Whitehouse5965b1f2006-04-26 13:21:55 -0400485 LM_FLAG_NOEXP | LM_FLAG_PRIORITY |
Steven Whitehouse59a1cc62006-08-04 15:41:22 -0400486 GL_NOCANCEL | GL_NOCACHE, &t_gh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000487 if (error)
488 goto fail_gunlock_ji;
489
490 if (test_bit(SDF_JOURNAL_CHECKED, &sdp->sd_flags)) {
491 if (!test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags))
492 ro = 1;
493 } else {
494 if (sdp->sd_vfs->s_flags & MS_RDONLY)
495 ro = 1;
496 }
497
498 if (ro) {
499 fs_warn(sdp, "jid=%u: Can't replay: read-only FS\n",
500 jd->jd_jid);
501 error = -EROFS;
502 goto fail_gunlock_tr;
503 }
504
505 fs_info(sdp, "jid=%u: Replaying journal...\n", jd->jd_jid);
506
507 for (pass = 0; pass < 2; pass++) {
508 lops_before_scan(jd, &head, pass);
509 error = foreach_descriptor(jd, head.lh_tail,
510 head.lh_blkno, pass);
511 lops_after_scan(jd, error, pass);
512 if (error)
513 goto fail_gunlock_tr;
514 }
515
516 error = clean_journal(jd, &head);
517 if (error)
518 goto fail_gunlock_tr;
519
520 gfs2_glock_dq_uninit(&t_gh);
Steven Whitehouse5c676f62006-02-27 17:23:27 -0500521 t = DIV_ROUND_UP(jiffies - t, HZ);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000522 fs_info(sdp, "jid=%u: Journal replayed in %lus\n",
523 jd->jd_jid, t);
524 }
525
Steven Whitehouse5965b1f2006-04-26 13:21:55 -0400526 if (jd->jd_jid != sdp->sd_lockstruct.ls_jid)
527 gfs2_glock_dq_uninit(&ji_gh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000528
529 gfs2_lm_recovery_done(sdp, jd->jd_jid, LM_RD_SUCCESS);
530
Steven Whitehouse5965b1f2006-04-26 13:21:55 -0400531 if (jd->jd_jid != sdp->sd_lockstruct.ls_jid)
532 gfs2_glock_dq_uninit(&j_gh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000533
534 fs_info(sdp, "jid=%u: Done\n", jd->jd_jid);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000535 return 0;
536
Steven Whitehouse5965b1f2006-04-26 13:21:55 -0400537fail_gunlock_tr:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000538 gfs2_glock_dq_uninit(&t_gh);
Steven Whitehouse5965b1f2006-04-26 13:21:55 -0400539fail_gunlock_ji:
540 if (jd->jd_jid != sdp->sd_lockstruct.ls_jid) {
541 gfs2_glock_dq_uninit(&ji_gh);
542fail_gunlock_j:
543 gfs2_glock_dq_uninit(&j_gh);
544 }
David Teiglandb3b94fa2006-01-16 16:50:04 +0000545
546 fs_info(sdp, "jid=%u: %s\n", jd->jd_jid, (error) ? "Failed" : "Done");
547
Steven Whitehouse5965b1f2006-04-26 13:21:55 -0400548fail:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000549 gfs2_lm_recovery_done(sdp, jd->jd_jid, LM_RD_GAVEUP);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000550 return error;
551}
552
553/**
554 * gfs2_check_journals - Recover any dirty journals
555 * @sdp: the filesystem
556 *
557 */
558
559void gfs2_check_journals(struct gfs2_sbd *sdp)
560{
561 struct gfs2_jdesc *jd;
562
563 for (;;) {
564 jd = gfs2_jdesc_find_dirty(sdp);
565 if (!jd)
566 break;
567
568 if (jd != sdp->sd_jdesc)
David Teiglandc63e31c2006-04-20 17:03:48 -0400569 gfs2_recover_journal(jd);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000570 }
571}
572