blob: d5e91f4f6a0b7aa88f36e5ce666c8781d31a5103 [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"
David Teiglandb3b94fa2006-01-16 16:50:04 +000023#include "lops.h"
24#include "meta_io.h"
25#include "recovery.h"
26#include "super.h"
Steven Whitehouse5c676f62006-02-27 17:23:27 -050027#include "util.h"
Steven Whitehouse71b86f52006-03-28 14:14:04 -050028#include "dir.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000029
30int gfs2_replay_read_block(struct gfs2_jdesc *jd, unsigned int blk,
31 struct buffer_head **bh)
32{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -040033 struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
Steven Whitehouse5c676f62006-02-27 17:23:27 -050034 struct gfs2_glock *gl = ip->i_gl;
David Teiglandb3b94fa2006-01-16 16:50:04 +000035 int new = 0;
Steven Whitehousecd915492006-09-04 12:49:07 -040036 u64 dblock;
37 u32 extlen;
David Teiglandb3b94fa2006-01-16 16:50:04 +000038 int error;
39
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -040040 error = gfs2_extent_map(&ip->i_inode, blk, &new, &dblock, &extlen);
David Teiglandb3b94fa2006-01-16 16:50:04 +000041 if (error)
42 return error;
43 if (!dblock) {
Steven Whitehouse5c676f62006-02-27 17:23:27 -050044 gfs2_consist_inode(ip);
David Teiglandb3b94fa2006-01-16 16:50:04 +000045 return -EIO;
46 }
47
Steven Whitehouse7276b3b2006-09-21 17:05:23 -040048 *bh = gfs2_meta_ra(gl, dblock, extlen);
David Teiglandb3b94fa2006-01-16 16:50:04 +000049
50 return error;
51}
52
Steven Whitehousecd915492006-09-04 12:49:07 -040053int gfs2_revoke_add(struct gfs2_sbd *sdp, u64 blkno, unsigned int where)
David Teiglandb3b94fa2006-01-16 16:50:04 +000054{
55 struct list_head *head = &sdp->sd_revoke_list;
56 struct gfs2_revoke_replay *rr;
57 int found = 0;
58
59 list_for_each_entry(rr, head, rr_list) {
60 if (rr->rr_blkno == blkno) {
61 found = 1;
62 break;
63 }
64 }
65
66 if (found) {
67 rr->rr_where = where;
68 return 0;
69 }
70
Josef Bacik16c5f062008-04-09 09:33:41 -040071 rr = kmalloc(sizeof(struct gfs2_revoke_replay), GFP_NOFS);
David Teiglandb3b94fa2006-01-16 16:50:04 +000072 if (!rr)
73 return -ENOMEM;
74
75 rr->rr_blkno = blkno;
76 rr->rr_where = where;
77 list_add(&rr->rr_list, head);
78
79 return 1;
80}
81
Steven Whitehousecd915492006-09-04 12:49:07 -040082int gfs2_revoke_check(struct gfs2_sbd *sdp, u64 blkno, unsigned int where)
David Teiglandb3b94fa2006-01-16 16:50:04 +000083{
84 struct gfs2_revoke_replay *rr;
85 int wrap, a, b, revoke;
86 int found = 0;
87
88 list_for_each_entry(rr, &sdp->sd_revoke_list, rr_list) {
89 if (rr->rr_blkno == blkno) {
90 found = 1;
91 break;
92 }
93 }
94
95 if (!found)
96 return 0;
97
98 wrap = (rr->rr_where < sdp->sd_replay_tail);
99 a = (sdp->sd_replay_tail < where);
100 b = (where < rr->rr_where);
101 revoke = (wrap) ? (a || b) : (a && b);
102
103 return revoke;
104}
105
106void gfs2_revoke_clean(struct gfs2_sbd *sdp)
107{
108 struct list_head *head = &sdp->sd_revoke_list;
109 struct gfs2_revoke_replay *rr;
110
111 while (!list_empty(head)) {
112 rr = list_entry(head->next, struct gfs2_revoke_replay, rr_list);
113 list_del(&rr->rr_list);
114 kfree(rr);
115 }
116}
117
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100118static int gfs2_log_header_in(struct gfs2_log_header_host *lh, const void *buf)
119{
120 const struct gfs2_log_header *str = buf;
121
122 if (str->lh_header.mh_magic != cpu_to_be32(GFS2_MAGIC) ||
123 str->lh_header.mh_type != cpu_to_be32(GFS2_METATYPE_LH))
124 return 1;
125
126 lh->lh_sequence = be64_to_cpu(str->lh_sequence);
127 lh->lh_flags = be32_to_cpu(str->lh_flags);
128 lh->lh_tail = be32_to_cpu(str->lh_tail);
129 lh->lh_blkno = be32_to_cpu(str->lh_blkno);
130 lh->lh_hash = be32_to_cpu(str->lh_hash);
131 return 0;
132}
133
David Teiglandb3b94fa2006-01-16 16:50:04 +0000134/**
135 * get_log_header - read the log header for a given segment
136 * @jd: the journal
137 * @blk: the block to look at
138 * @lh: the log header to return
139 *
140 * Read the log header for a given segement in a given journal. Do a few
141 * sanity checks on it.
142 *
143 * Returns: 0 on success,
144 * 1 if the header was invalid or incomplete,
145 * errno on error
146 */
147
148static int get_log_header(struct gfs2_jdesc *jd, unsigned int blk,
Al Viro55167622006-10-13 21:47:13 -0400149 struct gfs2_log_header_host *head)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000150{
151 struct buffer_head *bh;
akpm@linux-foundation.orgf5a8cd02008-03-12 14:01:29 -0700152 struct gfs2_log_header_host uninitialized_var(lh);
Steven Whitehouse887bc5d2006-12-05 13:34:17 -0500153 const u32 nothing = 0;
Steven Whitehousecd915492006-09-04 12:49:07 -0400154 u32 hash;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000155 int error;
156
157 error = gfs2_replay_read_block(jd, blk, &bh);
158 if (error)
159 return error;
160
Steven Whitehouse2a2c9822006-10-31 14:44:50 -0500161 hash = crc32_le((u32)~0, bh->b_data, sizeof(struct gfs2_log_header) -
162 sizeof(u32));
163 hash = crc32_le(hash, (unsigned char const *)&nothing, sizeof(nothing));
164 hash ^= (u32)~0;
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100165 error = gfs2_log_header_in(&lh, bh->b_data);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000166 brelse(bh);
167
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100168 if (error || lh.lh_blkno != blk || lh.lh_hash != hash)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000169 return 1;
170
171 *head = lh;
172
173 return 0;
174}
175
176/**
177 * find_good_lh - find a good log header
178 * @jd: the journal
179 * @blk: the segment to start searching from
180 * @lh: the log header to fill in
181 * @forward: if true search forward in the log, else search backward
182 *
183 * Call get_log_header() to get a log header for a segment, but if the
184 * segment is bad, either scan forward or backward until we find a good one.
185 *
186 * Returns: errno
187 */
188
189static int find_good_lh(struct gfs2_jdesc *jd, unsigned int *blk,
Al Viro55167622006-10-13 21:47:13 -0400190 struct gfs2_log_header_host *head)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000191{
192 unsigned int orig_blk = *blk;
193 int error;
194
195 for (;;) {
196 error = get_log_header(jd, *blk, head);
197 if (error <= 0)
198 return error;
199
200 if (++*blk == jd->jd_blocks)
201 *blk = 0;
202
203 if (*blk == orig_blk) {
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400204 gfs2_consist_inode(GFS2_I(jd->jd_inode));
David Teiglandb3b94fa2006-01-16 16:50:04 +0000205 return -EIO;
206 }
207 }
208}
209
210/**
211 * jhead_scan - make sure we've found the head of the log
212 * @jd: the journal
213 * @head: this is filled in with the log descriptor of the head
214 *
215 * At this point, seg and lh should be either the head of the log or just
216 * before. Scan forward until we find the head.
217 *
218 * Returns: errno
219 */
220
Al Viro55167622006-10-13 21:47:13 -0400221static int jhead_scan(struct gfs2_jdesc *jd, struct gfs2_log_header_host *head)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000222{
223 unsigned int blk = head->lh_blkno;
Al Viro55167622006-10-13 21:47:13 -0400224 struct gfs2_log_header_host lh;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000225 int error;
226
227 for (;;) {
228 if (++blk == jd->jd_blocks)
229 blk = 0;
230
231 error = get_log_header(jd, blk, &lh);
232 if (error < 0)
233 return error;
234 if (error == 1)
235 continue;
236
237 if (lh.lh_sequence == head->lh_sequence) {
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400238 gfs2_consist_inode(GFS2_I(jd->jd_inode));
David Teiglandb3b94fa2006-01-16 16:50:04 +0000239 return -EIO;
240 }
241 if (lh.lh_sequence < head->lh_sequence)
242 break;
243
244 *head = lh;
245 }
246
247 return 0;
248}
249
250/**
251 * gfs2_find_jhead - find the head of a log
252 * @jd: the journal
253 * @head: the log descriptor for the head of the log is returned here
254 *
255 * Do a binary search of a journal and find the valid log entry with the
256 * highest sequence number. (i.e. the log head)
257 *
258 * Returns: errno
259 */
260
Al Viro55167622006-10-13 21:47:13 -0400261int gfs2_find_jhead(struct gfs2_jdesc *jd, struct gfs2_log_header_host *head)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000262{
Al Viro55167622006-10-13 21:47:13 -0400263 struct gfs2_log_header_host lh_1, lh_m;
Steven Whitehousecd915492006-09-04 12:49:07 -0400264 u32 blk_1, blk_2, blk_m;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000265 int error;
266
267 blk_1 = 0;
268 blk_2 = jd->jd_blocks - 1;
269
270 for (;;) {
271 blk_m = (blk_1 + blk_2) / 2;
272
273 error = find_good_lh(jd, &blk_1, &lh_1);
274 if (error)
275 return error;
276
277 error = find_good_lh(jd, &blk_m, &lh_m);
278 if (error)
279 return error;
280
281 if (blk_1 == blk_m || blk_m == blk_2)
282 break;
283
284 if (lh_1.lh_sequence <= lh_m.lh_sequence)
285 blk_1 = blk_m;
286 else
287 blk_2 = blk_m;
288 }
289
290 error = jhead_scan(jd, &lh_1);
291 if (error)
292 return error;
293
294 *head = lh_1;
295
296 return error;
297}
298
299/**
300 * foreach_descriptor - go through the active part of the log
301 * @jd: the journal
302 * @start: the first log header in the active region
303 * @end: the last log header (don't process the contents of this entry))
304 *
305 * Call a given function once for every log descriptor in the active
306 * portion of the log.
307 *
308 * Returns: errno
309 */
310
311static int foreach_descriptor(struct gfs2_jdesc *jd, unsigned int start,
312 unsigned int end, int pass)
313{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400314 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000315 struct buffer_head *bh;
316 struct gfs2_log_descriptor *ld;
317 int error = 0;
318 u32 length;
319 __be64 *ptr;
320 unsigned int offset = sizeof(struct gfs2_log_descriptor);
Steven Whitehousea67cdbd2006-09-05 14:41:30 -0400321 offset += sizeof(__be64) - 1;
322 offset &= ~(sizeof(__be64) - 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000323
324 while (start != end) {
325 error = gfs2_replay_read_block(jd, start, &bh);
326 if (error)
327 return error;
328 if (gfs2_meta_check(sdp, bh)) {
329 brelse(bh);
330 return -EIO;
331 }
332 ld = (struct gfs2_log_descriptor *)bh->b_data;
333 length = be32_to_cpu(ld->ld_length);
334
Steven Whitehousee3167de2006-03-30 15:46:23 -0500335 if (be32_to_cpu(ld->ld_header.mh_type) == GFS2_METATYPE_LH) {
Al Viro55167622006-10-13 21:47:13 -0400336 struct gfs2_log_header_host lh;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000337 error = get_log_header(jd, start, &lh);
338 if (!error) {
339 gfs2_replay_incr_blk(sdp, &start);
Russell Cattelan88721872006-08-10 11:08:40 -0500340 brelse(bh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000341 continue;
342 }
343 if (error == 1) {
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400344 gfs2_consist_inode(GFS2_I(jd->jd_inode));
David Teiglandb3b94fa2006-01-16 16:50:04 +0000345 error = -EIO;
346 }
347 brelse(bh);
348 return error;
349 } else if (gfs2_metatype_check(sdp, bh, GFS2_METATYPE_LD)) {
350 brelse(bh);
351 return -EIO;
352 }
353 ptr = (__be64 *)(bh->b_data + offset);
354 error = lops_scan_elements(jd, start, ld, ptr, pass);
355 if (error) {
356 brelse(bh);
357 return error;
358 }
359
360 while (length--)
361 gfs2_replay_incr_blk(sdp, &start);
362
363 brelse(bh);
364 }
365
366 return 0;
367}
368
369/**
370 * clean_journal - mark a dirty journal as being clean
371 * @sdp: the filesystem
372 * @jd: the journal
373 * @gl: the journal's glock
374 * @head: the head journal to start from
375 *
376 * Returns: errno
377 */
378
Al Viro55167622006-10-13 21:47:13 -0400379static int clean_journal(struct gfs2_jdesc *jd, struct gfs2_log_header_host *head)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000380{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400381 struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
382 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000383 unsigned int lblock;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000384 struct gfs2_log_header *lh;
Steven Whitehousecd915492006-09-04 12:49:07 -0400385 u32 hash;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000386 struct buffer_head *bh;
387 int error;
Steven Whitehouse23591252006-10-13 17:25:45 -0400388 struct buffer_head bh_map = { .b_state = 0, .b_blocknr = 0 };
Steven Whitehousefd88de562006-05-05 16:59:11 -0400389
David Teiglandb3b94fa2006-01-16 16:50:04 +0000390 lblock = head->lh_blkno;
391 gfs2_replay_incr_blk(sdp, &lblock);
Steven Whitehouse23591252006-10-13 17:25:45 -0400392 bh_map.b_size = 1 << ip->i_inode.i_blkbits;
Bob Petersone9e1ef22007-12-10 14:13:27 -0600393 error = gfs2_block_map(&ip->i_inode, lblock, &bh_map, 0);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000394 if (error)
395 return error;
Steven Whitehouse7a6bbac2006-09-18 17:18:23 -0400396 if (!bh_map.b_blocknr) {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000397 gfs2_consist_inode(ip);
398 return -EIO;
399 }
400
Steven Whitehouse7a6bbac2006-09-18 17:18:23 -0400401 bh = sb_getblk(sdp->sd_vfs, bh_map.b_blocknr);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000402 lock_buffer(bh);
403 memset(bh->b_data, 0, bh->b_size);
404 set_buffer_uptodate(bh);
405 clear_buffer_dirty(bh);
406 unlock_buffer(bh);
407
408 lh = (struct gfs2_log_header *)bh->b_data;
409 memset(lh, 0, sizeof(struct gfs2_log_header));
410 lh->lh_header.mh_magic = cpu_to_be32(GFS2_MAGIC);
Russell Cattelan88721872006-08-10 11:08:40 -0500411 lh->lh_header.mh_type = cpu_to_be32(GFS2_METATYPE_LH);
Steven Whitehousee3167de2006-03-30 15:46:23 -0500412 lh->lh_header.mh_format = cpu_to_be32(GFS2_FORMAT_LH);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000413 lh->lh_sequence = cpu_to_be64(head->lh_sequence + 1);
414 lh->lh_flags = cpu_to_be32(GFS2_LOG_HEAD_UNMOUNT);
415 lh->lh_blkno = cpu_to_be32(lblock);
416 hash = gfs2_disk_hash((const char *)lh, sizeof(struct gfs2_log_header));
417 lh->lh_hash = cpu_to_be32(hash);
418
419 set_buffer_dirty(bh);
420 if (sync_dirty_buffer(bh))
421 gfs2_io_error_bh(sdp, bh);
422 brelse(bh);
423
424 return error;
425}
426
Steven Whitehouseda755fd2008-01-30 15:34:04 +0000427
428static void gfs2_lm_recovery_done(struct gfs2_sbd *sdp, unsigned int jid,
429 unsigned int message)
430{
Steven Whitehouse048bca22008-05-23 14:46:04 +0100431 if (!sdp->sd_lockstruct.ls_ops->lm_recovery_done)
432 return;
433
Steven Whitehouseda755fd2008-01-30 15:34:04 +0000434 if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
435 sdp->sd_lockstruct.ls_ops->lm_recovery_done(
436 sdp->sd_lockstruct.ls_lockspace, jid, message);
437}
438
439
David Teiglandb3b94fa2006-01-16 16:50:04 +0000440/**
441 * gfs2_recover_journal - recovery a given journal
442 * @jd: the struct gfs2_jdesc describing the journal
David Teiglandb3b94fa2006-01-16 16:50:04 +0000443 *
444 * Acquire the journal's lock, check to see if the journal is clean, and
445 * do recovery if necessary.
446 *
447 * Returns: errno
448 */
449
David Teiglandc63e31c2006-04-20 17:03:48 -0400450int gfs2_recover_journal(struct gfs2_jdesc *jd)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000451{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400452 struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
453 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
Al Viro55167622006-10-13 21:47:13 -0400454 struct gfs2_log_header_host head;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000455 struct gfs2_holder j_gh, ji_gh, t_gh;
456 unsigned long t;
457 int ro = 0;
458 unsigned int pass;
459 int error;
460
Steven Whitehouse5965b1f2006-04-26 13:21:55 -0400461 if (jd->jd_jid != sdp->sd_lockstruct.ls_jid) {
462 fs_info(sdp, "jid=%u: Trying to acquire journal lock...\n",
463 jd->jd_jid);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000464
Joe Perchesc78bad12008-02-03 17:33:42 +0200465 /* Acquire the journal lock so we can do recovery */
David Teiglandb3b94fa2006-01-16 16:50:04 +0000466
Steven Whitehouse5965b1f2006-04-26 13:21:55 -0400467 error = gfs2_glock_nq_num(sdp, jd->jd_jid, &gfs2_journal_glops,
468 LM_ST_EXCLUSIVE,
469 LM_FLAG_NOEXP | LM_FLAG_TRY | GL_NOCACHE,
470 &j_gh);
471 switch (error) {
472 case 0:
473 break;
Steven Whitehouse907b9bc2006-09-25 09:26:04 -0400474
Steven Whitehouse5965b1f2006-04-26 13:21:55 -0400475 case GLR_TRYFAILED:
476 fs_info(sdp, "jid=%u: Busy\n", jd->jd_jid);
477 error = 0;
Steven Whitehouse907b9bc2006-09-25 09:26:04 -0400478
Steven Whitehouse5965b1f2006-04-26 13:21:55 -0400479 default:
480 goto fail;
481 };
David Teiglandb3b94fa2006-01-16 16:50:04 +0000482
Steven Whitehouse5965b1f2006-04-26 13:21:55 -0400483 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED,
Bob Peterson75be73a2007-08-08 17:08:14 -0500484 LM_FLAG_NOEXP | GL_NOCACHE, &ji_gh);
Steven Whitehouse5965b1f2006-04-26 13:21:55 -0400485 if (error)
486 goto fail_gunlock_j;
487 } else {
488 fs_info(sdp, "jid=%u, already locked for use\n", jd->jd_jid);
489 }
David Teiglandb3b94fa2006-01-16 16:50:04 +0000490
491 fs_info(sdp, "jid=%u: Looking at journal...\n", jd->jd_jid);
492
493 error = gfs2_jdesc_check(jd);
494 if (error)
495 goto fail_gunlock_ji;
496
497 error = gfs2_find_jhead(jd, &head);
498 if (error)
499 goto fail_gunlock_ji;
500
501 if (!(head.lh_flags & GFS2_LOG_HEAD_UNMOUNT)) {
502 fs_info(sdp, "jid=%u: Acquiring the transaction lock...\n",
503 jd->jd_jid);
504
505 t = jiffies;
506
507 /* Acquire a shared hold on the transaction lock */
508
Steven Whitehouse59a1cc62006-08-04 15:41:22 -0400509 error = gfs2_glock_nq_init(sdp->sd_trans_gl, LM_ST_SHARED,
Steven Whitehouse5965b1f2006-04-26 13:21:55 -0400510 LM_FLAG_NOEXP | LM_FLAG_PRIORITY |
Steven Whitehouse6802e342008-05-21 17:03:22 +0100511 GL_NOCACHE, &t_gh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000512 if (error)
513 goto fail_gunlock_ji;
514
515 if (test_bit(SDF_JOURNAL_CHECKED, &sdp->sd_flags)) {
516 if (!test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags))
517 ro = 1;
518 } else {
Abhijith Das7bc5c412008-01-18 14:06:37 -0600519 if (sdp->sd_vfs->s_flags & MS_RDONLY) {
520 /* check if device itself is read-only */
521 ro = bdev_read_only(sdp->sd_vfs->s_bdev);
522 if (!ro) {
523 fs_info(sdp, "recovery required on "
524 "read-only filesystem.\n");
525 fs_info(sdp, "write access will be "
526 "enabled during recovery.\n");
527 }
528 }
David Teiglandb3b94fa2006-01-16 16:50:04 +0000529 }
530
531 if (ro) {
Abhijith Das7bc5c412008-01-18 14:06:37 -0600532 fs_warn(sdp, "jid=%u: Can't replay: read-only block "
533 "device\n", jd->jd_jid);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000534 error = -EROFS;
535 goto fail_gunlock_tr;
536 }
537
538 fs_info(sdp, "jid=%u: Replaying journal...\n", jd->jd_jid);
539
540 for (pass = 0; pass < 2; pass++) {
541 lops_before_scan(jd, &head, pass);
542 error = foreach_descriptor(jd, head.lh_tail,
543 head.lh_blkno, pass);
544 lops_after_scan(jd, error, pass);
545 if (error)
546 goto fail_gunlock_tr;
547 }
548
549 error = clean_journal(jd, &head);
550 if (error)
551 goto fail_gunlock_tr;
552
553 gfs2_glock_dq_uninit(&t_gh);
Steven Whitehouse5c676f62006-02-27 17:23:27 -0500554 t = DIV_ROUND_UP(jiffies - t, HZ);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000555 fs_info(sdp, "jid=%u: Journal replayed in %lus\n",
556 jd->jd_jid, t);
557 }
558
Steven Whitehouse5965b1f2006-04-26 13:21:55 -0400559 if (jd->jd_jid != sdp->sd_lockstruct.ls_jid)
560 gfs2_glock_dq_uninit(&ji_gh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000561
562 gfs2_lm_recovery_done(sdp, jd->jd_jid, LM_RD_SUCCESS);
563
Steven Whitehouse5965b1f2006-04-26 13:21:55 -0400564 if (jd->jd_jid != sdp->sd_lockstruct.ls_jid)
565 gfs2_glock_dq_uninit(&j_gh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000566
567 fs_info(sdp, "jid=%u: Done\n", jd->jd_jid);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000568 return 0;
569
Steven Whitehouse5965b1f2006-04-26 13:21:55 -0400570fail_gunlock_tr:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000571 gfs2_glock_dq_uninit(&t_gh);
Steven Whitehouse5965b1f2006-04-26 13:21:55 -0400572fail_gunlock_ji:
573 if (jd->jd_jid != sdp->sd_lockstruct.ls_jid) {
574 gfs2_glock_dq_uninit(&ji_gh);
575fail_gunlock_j:
576 gfs2_glock_dq_uninit(&j_gh);
577 }
David Teiglandb3b94fa2006-01-16 16:50:04 +0000578
579 fs_info(sdp, "jid=%u: %s\n", jd->jd_jid, (error) ? "Failed" : "Done");
580
Steven Whitehouse5965b1f2006-04-26 13:21:55 -0400581fail:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000582 gfs2_lm_recovery_done(sdp, jd->jd_jid, LM_RD_GAVEUP);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000583 return error;
584}
585
586/**
587 * gfs2_check_journals - Recover any dirty journals
588 * @sdp: the filesystem
589 *
590 */
591
592void gfs2_check_journals(struct gfs2_sbd *sdp)
593{
594 struct gfs2_jdesc *jd;
595
596 for (;;) {
597 jd = gfs2_jdesc_find_dirty(sdp);
598 if (!jd)
599 break;
600
601 if (jd != sdp->sd_jdesc)
David Teiglandc63e31c2006-04-20 17:03:48 -0400602 gfs2_recover_journal(jd);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000603 }
604}
605