ACPI: ibm-acpi: cleanup fan_write
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / fs / gfs2 / recovery.c
blob62cd223819b7aa4536335ef460ed9382ac90eb12
1 /*
2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
3 * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
5 * This copyrighted material is made available to anyone wishing to use,
6 * modify, copy, or redistribute it subject to the terms and conditions
7 * of the GNU General Public License version 2.
8 */
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>
15 #include <linux/gfs2_ondisk.h>
16 #include <linux/crc32.h>
17 #include <linux/lm_interface.h>
19 #include "gfs2.h"
20 #include "incore.h"
21 #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"
29 #include "util.h"
30 #include "dir.h"
32 int gfs2_replay_read_block(struct gfs2_jdesc *jd, unsigned int blk,
33 struct buffer_head **bh)
35 struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
36 struct gfs2_glock *gl = ip->i_gl;
37 int new = 0;
38 u64 dblock;
39 u32 extlen;
40 int error;
42 error = gfs2_extent_map(&ip->i_inode, blk, &new, &dblock, &extlen);
43 if (error)
44 return error;
45 if (!dblock) {
46 gfs2_consist_inode(ip);
47 return -EIO;
50 *bh = gfs2_meta_ra(gl, dblock, extlen);
52 return error;
55 int gfs2_revoke_add(struct gfs2_sbd *sdp, u64 blkno, unsigned int where)
57 struct list_head *head = &sdp->sd_revoke_list;
58 struct gfs2_revoke_replay *rr;
59 int found = 0;
61 list_for_each_entry(rr, head, rr_list) {
62 if (rr->rr_blkno == blkno) {
63 found = 1;
64 break;
68 if (found) {
69 rr->rr_where = where;
70 return 0;
73 rr = kmalloc(sizeof(struct gfs2_revoke_replay), GFP_KERNEL);
74 if (!rr)
75 return -ENOMEM;
77 rr->rr_blkno = blkno;
78 rr->rr_where = where;
79 list_add(&rr->rr_list, head);
81 return 1;
84 int gfs2_revoke_check(struct gfs2_sbd *sdp, u64 blkno, unsigned int where)
86 struct gfs2_revoke_replay *rr;
87 int wrap, a, b, revoke;
88 int found = 0;
90 list_for_each_entry(rr, &sdp->sd_revoke_list, rr_list) {
91 if (rr->rr_blkno == blkno) {
92 found = 1;
93 break;
97 if (!found)
98 return 0;
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);
105 return revoke;
108 void gfs2_revoke_clean(struct gfs2_sbd *sdp)
110 struct list_head *head = &sdp->sd_revoke_list;
111 struct gfs2_revoke_replay *rr;
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);
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
126 * Read the log header for a given segement in a given journal. Do a few
127 * sanity checks on it.
129 * Returns: 0 on success,
130 * 1 if the header was invalid or incomplete,
131 * errno on error
134 static int get_log_header(struct gfs2_jdesc *jd, unsigned int blk,
135 struct gfs2_log_header *head)
137 struct buffer_head *bh;
138 struct gfs2_log_header lh;
139 u32 hash;
140 int error;
142 error = gfs2_replay_read_block(jd, blk, &bh);
143 if (error)
144 return error;
146 memcpy(&lh, bh->b_data, sizeof(struct gfs2_log_header));
147 lh.lh_hash = 0;
148 hash = gfs2_disk_hash((char *)&lh, sizeof(struct gfs2_log_header));
149 gfs2_log_header_in(&lh, bh->b_data);
151 brelse(bh);
153 if (lh.lh_header.mh_magic != GFS2_MAGIC ||
154 lh.lh_header.mh_type != GFS2_METATYPE_LH ||
155 lh.lh_blkno != blk || lh.lh_hash != hash)
156 return 1;
158 *head = lh;
160 return 0;
164 * find_good_lh - find a good log header
165 * @jd: the journal
166 * @blk: the segment to start searching from
167 * @lh: the log header to fill in
168 * @forward: if true search forward in the log, else search backward
170 * Call get_log_header() to get a log header for a segment, but if the
171 * segment is bad, either scan forward or backward until we find a good one.
173 * Returns: errno
176 static int find_good_lh(struct gfs2_jdesc *jd, unsigned int *blk,
177 struct gfs2_log_header *head)
179 unsigned int orig_blk = *blk;
180 int error;
182 for (;;) {
183 error = get_log_header(jd, *blk, head);
184 if (error <= 0)
185 return error;
187 if (++*blk == jd->jd_blocks)
188 *blk = 0;
190 if (*blk == orig_blk) {
191 gfs2_consist_inode(GFS2_I(jd->jd_inode));
192 return -EIO;
198 * jhead_scan - make sure we've found the head of the log
199 * @jd: the journal
200 * @head: this is filled in with the log descriptor of the head
202 * At this point, seg and lh should be either the head of the log or just
203 * before. Scan forward until we find the head.
205 * Returns: errno
208 static int jhead_scan(struct gfs2_jdesc *jd, struct gfs2_log_header *head)
210 unsigned int blk = head->lh_blkno;
211 struct gfs2_log_header lh;
212 int error;
214 for (;;) {
215 if (++blk == jd->jd_blocks)
216 blk = 0;
218 error = get_log_header(jd, blk, &lh);
219 if (error < 0)
220 return error;
221 if (error == 1)
222 continue;
224 if (lh.lh_sequence == head->lh_sequence) {
225 gfs2_consist_inode(GFS2_I(jd->jd_inode));
226 return -EIO;
228 if (lh.lh_sequence < head->lh_sequence)
229 break;
231 *head = lh;
234 return 0;
238 * gfs2_find_jhead - find the head of a log
239 * @jd: the journal
240 * @head: the log descriptor for the head of the log is returned here
242 * Do a binary search of a journal and find the valid log entry with the
243 * highest sequence number. (i.e. the log head)
245 * Returns: errno
248 int gfs2_find_jhead(struct gfs2_jdesc *jd, struct gfs2_log_header *head)
250 struct gfs2_log_header lh_1, lh_m;
251 u32 blk_1, blk_2, blk_m;
252 int error;
254 blk_1 = 0;
255 blk_2 = jd->jd_blocks - 1;
257 for (;;) {
258 blk_m = (blk_1 + blk_2) / 2;
260 error = find_good_lh(jd, &blk_1, &lh_1);
261 if (error)
262 return error;
264 error = find_good_lh(jd, &blk_m, &lh_m);
265 if (error)
266 return error;
268 if (blk_1 == blk_m || blk_m == blk_2)
269 break;
271 if (lh_1.lh_sequence <= lh_m.lh_sequence)
272 blk_1 = blk_m;
273 else
274 blk_2 = blk_m;
277 error = jhead_scan(jd, &lh_1);
278 if (error)
279 return error;
281 *head = lh_1;
283 return error;
287 * foreach_descriptor - go through the active part of the log
288 * @jd: the journal
289 * @start: the first log header in the active region
290 * @end: the last log header (don't process the contents of this entry))
292 * Call a given function once for every log descriptor in the active
293 * portion of the log.
295 * Returns: errno
298 static int foreach_descriptor(struct gfs2_jdesc *jd, unsigned int start,
299 unsigned int end, int pass)
301 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
302 struct buffer_head *bh;
303 struct gfs2_log_descriptor *ld;
304 int error = 0;
305 u32 length;
306 __be64 *ptr;
307 unsigned int offset = sizeof(struct gfs2_log_descriptor);
308 offset += sizeof(__be64) - 1;
309 offset &= ~(sizeof(__be64) - 1);
311 while (start != end) {
312 error = gfs2_replay_read_block(jd, start, &bh);
313 if (error)
314 return error;
315 if (gfs2_meta_check(sdp, bh)) {
316 brelse(bh);
317 return -EIO;
319 ld = (struct gfs2_log_descriptor *)bh->b_data;
320 length = be32_to_cpu(ld->ld_length);
322 if (be32_to_cpu(ld->ld_header.mh_type) == GFS2_METATYPE_LH) {
323 struct gfs2_log_header lh;
324 error = get_log_header(jd, start, &lh);
325 if (!error) {
326 gfs2_replay_incr_blk(sdp, &start);
327 brelse(bh);
328 continue;
330 if (error == 1) {
331 gfs2_consist_inode(GFS2_I(jd->jd_inode));
332 error = -EIO;
334 brelse(bh);
335 return error;
336 } else if (gfs2_metatype_check(sdp, bh, GFS2_METATYPE_LD)) {
337 brelse(bh);
338 return -EIO;
340 ptr = (__be64 *)(bh->b_data + offset);
341 error = lops_scan_elements(jd, start, ld, ptr, pass);
342 if (error) {
343 brelse(bh);
344 return error;
347 while (length--)
348 gfs2_replay_incr_blk(sdp, &start);
350 brelse(bh);
353 return 0;
357 * clean_journal - mark a dirty journal as being clean
358 * @sdp: the filesystem
359 * @jd: the journal
360 * @gl: the journal's glock
361 * @head: the head journal to start from
363 * Returns: errno
366 static int clean_journal(struct gfs2_jdesc *jd, struct gfs2_log_header *head)
368 struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
369 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
370 unsigned int lblock;
371 struct gfs2_log_header *lh;
372 u32 hash;
373 struct buffer_head *bh;
374 int error;
375 struct buffer_head bh_map = { .b_state = 0, .b_blocknr = 0 };
377 lblock = head->lh_blkno;
378 gfs2_replay_incr_blk(sdp, &lblock);
379 bh_map.b_size = 1 << ip->i_inode.i_blkbits;
380 error = gfs2_block_map(&ip->i_inode, lblock, 0, &bh_map);
381 if (error)
382 return error;
383 if (!bh_map.b_blocknr) {
384 gfs2_consist_inode(ip);
385 return -EIO;
388 bh = sb_getblk(sdp->sd_vfs, bh_map.b_blocknr);
389 lock_buffer(bh);
390 memset(bh->b_data, 0, bh->b_size);
391 set_buffer_uptodate(bh);
392 clear_buffer_dirty(bh);
393 unlock_buffer(bh);
395 lh = (struct gfs2_log_header *)bh->b_data;
396 memset(lh, 0, sizeof(struct gfs2_log_header));
397 lh->lh_header.mh_magic = cpu_to_be32(GFS2_MAGIC);
398 lh->lh_header.mh_type = cpu_to_be32(GFS2_METATYPE_LH);
399 lh->lh_header.mh_format = cpu_to_be32(GFS2_FORMAT_LH);
400 lh->lh_sequence = cpu_to_be64(head->lh_sequence + 1);
401 lh->lh_flags = cpu_to_be32(GFS2_LOG_HEAD_UNMOUNT);
402 lh->lh_blkno = cpu_to_be32(lblock);
403 hash = gfs2_disk_hash((const char *)lh, sizeof(struct gfs2_log_header));
404 lh->lh_hash = cpu_to_be32(hash);
406 set_buffer_dirty(bh);
407 if (sync_dirty_buffer(bh))
408 gfs2_io_error_bh(sdp, bh);
409 brelse(bh);
411 return error;
415 * gfs2_recover_journal - recovery a given journal
416 * @jd: the struct gfs2_jdesc describing the journal
418 * Acquire the journal's lock, check to see if the journal is clean, and
419 * do recovery if necessary.
421 * Returns: errno
424 int gfs2_recover_journal(struct gfs2_jdesc *jd)
426 struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
427 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
428 struct gfs2_log_header head;
429 struct gfs2_holder j_gh, ji_gh, t_gh;
430 unsigned long t;
431 int ro = 0;
432 unsigned int pass;
433 int error;
435 if (jd->jd_jid != sdp->sd_lockstruct.ls_jid) {
436 fs_info(sdp, "jid=%u: Trying to acquire journal lock...\n",
437 jd->jd_jid);
439 /* Aquire the journal lock so we can do recovery */
441 error = gfs2_glock_nq_num(sdp, jd->jd_jid, &gfs2_journal_glops,
442 LM_ST_EXCLUSIVE,
443 LM_FLAG_NOEXP | LM_FLAG_TRY | GL_NOCACHE,
444 &j_gh);
445 switch (error) {
446 case 0:
447 break;
449 case GLR_TRYFAILED:
450 fs_info(sdp, "jid=%u: Busy\n", jd->jd_jid);
451 error = 0;
453 default:
454 goto fail;
457 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED,
458 LM_FLAG_NOEXP, &ji_gh);
459 if (error)
460 goto fail_gunlock_j;
461 } else {
462 fs_info(sdp, "jid=%u, already locked for use\n", jd->jd_jid);
465 fs_info(sdp, "jid=%u: Looking at journal...\n", jd->jd_jid);
467 error = gfs2_jdesc_check(jd);
468 if (error)
469 goto fail_gunlock_ji;
471 error = gfs2_find_jhead(jd, &head);
472 if (error)
473 goto fail_gunlock_ji;
475 if (!(head.lh_flags & GFS2_LOG_HEAD_UNMOUNT)) {
476 fs_info(sdp, "jid=%u: Acquiring the transaction lock...\n",
477 jd->jd_jid);
479 t = jiffies;
481 /* Acquire a shared hold on the transaction lock */
483 error = gfs2_glock_nq_init(sdp->sd_trans_gl, LM_ST_SHARED,
484 LM_FLAG_NOEXP | LM_FLAG_PRIORITY |
485 GL_NOCANCEL | GL_NOCACHE, &t_gh);
486 if (error)
487 goto fail_gunlock_ji;
489 if (test_bit(SDF_JOURNAL_CHECKED, &sdp->sd_flags)) {
490 if (!test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags))
491 ro = 1;
492 } else {
493 if (sdp->sd_vfs->s_flags & MS_RDONLY)
494 ro = 1;
497 if (ro) {
498 fs_warn(sdp, "jid=%u: Can't replay: read-only FS\n",
499 jd->jd_jid);
500 error = -EROFS;
501 goto fail_gunlock_tr;
504 fs_info(sdp, "jid=%u: Replaying journal...\n", jd->jd_jid);
506 for (pass = 0; pass < 2; pass++) {
507 lops_before_scan(jd, &head, pass);
508 error = foreach_descriptor(jd, head.lh_tail,
509 head.lh_blkno, pass);
510 lops_after_scan(jd, error, pass);
511 if (error)
512 goto fail_gunlock_tr;
515 error = clean_journal(jd, &head);
516 if (error)
517 goto fail_gunlock_tr;
519 gfs2_glock_dq_uninit(&t_gh);
520 t = DIV_ROUND_UP(jiffies - t, HZ);
521 fs_info(sdp, "jid=%u: Journal replayed in %lus\n",
522 jd->jd_jid, t);
525 if (jd->jd_jid != sdp->sd_lockstruct.ls_jid)
526 gfs2_glock_dq_uninit(&ji_gh);
528 gfs2_lm_recovery_done(sdp, jd->jd_jid, LM_RD_SUCCESS);
530 if (jd->jd_jid != sdp->sd_lockstruct.ls_jid)
531 gfs2_glock_dq_uninit(&j_gh);
533 fs_info(sdp, "jid=%u: Done\n", jd->jd_jid);
534 return 0;
536 fail_gunlock_tr:
537 gfs2_glock_dq_uninit(&t_gh);
538 fail_gunlock_ji:
539 if (jd->jd_jid != sdp->sd_lockstruct.ls_jid) {
540 gfs2_glock_dq_uninit(&ji_gh);
541 fail_gunlock_j:
542 gfs2_glock_dq_uninit(&j_gh);
545 fs_info(sdp, "jid=%u: %s\n", jd->jd_jid, (error) ? "Failed" : "Done");
547 fail:
548 gfs2_lm_recovery_done(sdp, jd->jd_jid, LM_RD_GAVEUP);
549 return error;
553 * gfs2_check_journals - Recover any dirty journals
554 * @sdp: the filesystem
558 void gfs2_check_journals(struct gfs2_sbd *sdp)
560 struct gfs2_jdesc *jd;
562 for (;;) {
563 jd = gfs2_jdesc_find_dirty(sdp);
564 if (!jd)
565 break;
567 if (jd != sdp->sd_jdesc)
568 gfs2_recover_journal(jd);