[GFS2] More style fixes
[linux-2.6] / fs / gfs2 / recovery.c
1 /*
2  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
3  * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
4  *
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  */
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>
15 #include <linux/gfs2_ondisk.h>
16 #include <linux/crc32.h>
17
18 #include "gfs2.h"
19 #include "lm_interface.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"
31
32 int gfs2_replay_read_block(struct gfs2_jdesc *jd, unsigned int blk,
33                            struct buffer_head **bh)
34 {
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;
41
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;
48         }
49
50         gfs2_meta_ra(gl, dblock, extlen);
51         error = gfs2_meta_read(gl, dblock, DIO_START | DIO_WAIT, bh);
52
53         return error;
54 }
55
56 int gfs2_revoke_add(struct gfs2_sbd *sdp, u64 blkno, unsigned int where)
57 {
58         struct list_head *head = &sdp->sd_revoke_list;
59         struct gfs2_revoke_replay *rr;
60         int found = 0;
61
62         list_for_each_entry(rr, head, rr_list) {
63                 if (rr->rr_blkno == blkno) {
64                         found = 1;
65                         break;
66                 }
67         }
68
69         if (found) {
70                 rr->rr_where = where;
71                 return 0;
72         }
73
74         rr = kmalloc(sizeof(struct gfs2_revoke_replay), GFP_KERNEL);
75         if (!rr)
76                 return -ENOMEM;
77
78         rr->rr_blkno = blkno;
79         rr->rr_where = where;
80         list_add(&rr->rr_list, head);
81
82         return 1;
83 }
84
85 int gfs2_revoke_check(struct gfs2_sbd *sdp, u64 blkno, unsigned int where)
86 {
87         struct gfs2_revoke_replay *rr;
88         int wrap, a, b, revoke;
89         int found = 0;
90
91         list_for_each_entry(rr, &sdp->sd_revoke_list, rr_list) {
92                 if (rr->rr_blkno == blkno) {
93                         found = 1;
94                         break;
95                 }
96         }
97
98         if (!found)
99                 return 0;
100
101         wrap = (rr->rr_where < sdp->sd_replay_tail);
102         a = (sdp->sd_replay_tail < where);
103         b = (where < rr->rr_where);
104         revoke = (wrap) ? (a || b) : (a && b);
105
106         return revoke;
107 }
108
109 void gfs2_revoke_clean(struct gfs2_sbd *sdp)
110 {
111         struct list_head *head = &sdp->sd_revoke_list;
112         struct gfs2_revoke_replay *rr;
113
114         while (!list_empty(head)) {
115                 rr = list_entry(head->next, struct gfs2_revoke_replay, rr_list);
116                 list_del(&rr->rr_list);
117                 kfree(rr);
118         }
119 }
120
121 /**
122  * get_log_header - read the log header for a given segment
123  * @jd: the journal
124  * @blk: the block to look at
125  * @lh: the log header to return
126  *
127  * Read the log header for a given segement in a given journal.  Do a few
128  * sanity checks on it.
129  *
130  * Returns: 0 on success,
131  *          1 if the header was invalid or incomplete,
132  *          errno on error
133  */
134
135 static int get_log_header(struct gfs2_jdesc *jd, unsigned int blk,
136                           struct gfs2_log_header *head)
137 {
138         struct buffer_head *bh;
139         struct gfs2_log_header lh;
140         u32 hash;
141         int error;
142
143         error = gfs2_replay_read_block(jd, blk, &bh);
144         if (error)
145                 return error;
146
147         memcpy(&lh, bh->b_data, sizeof(struct gfs2_log_header));
148         lh.lh_hash = 0;
149         hash = gfs2_disk_hash((char *)&lh, sizeof(struct gfs2_log_header));
150         gfs2_log_header_in(&lh, bh->b_data);
151
152         brelse(bh);
153
154         if (lh.lh_header.mh_magic != GFS2_MAGIC ||
155             lh.lh_header.mh_type != GFS2_METATYPE_LH ||
156             lh.lh_blkno != blk || lh.lh_hash != hash)
157                 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
177 static int find_good_lh(struct gfs2_jdesc *jd, unsigned int *blk,
178                         struct gfs2_log_header *head)
179 {
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) {
192                         gfs2_consist_inode(GFS2_I(jd->jd_inode));
193                         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
209 static int jhead_scan(struct gfs2_jdesc *jd, struct gfs2_log_header *head)
210 {
211         unsigned int blk = head->lh_blkno;
212         struct gfs2_log_header lh;
213         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) {
226                         gfs2_consist_inode(GFS2_I(jd->jd_inode));
227                         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
249 int gfs2_find_jhead(struct gfs2_jdesc *jd, struct gfs2_log_header *head)
250 {
251         struct gfs2_log_header lh_1, lh_m;
252         u32 blk_1, blk_2, blk_m;
253         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
299 static int foreach_descriptor(struct gfs2_jdesc *jd, unsigned int start,
300                               unsigned int end, int pass)
301 {
302         struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
303         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);
309         offset += sizeof(__be64) - 1;
310         offset &= ~(sizeof(__be64) - 1);
311
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
323                 if (be32_to_cpu(ld->ld_header.mh_type) == GFS2_METATYPE_LH) {
324                         struct gfs2_log_header lh;
325                         error = get_log_header(jd, start, &lh);
326                         if (!error) {
327                                 gfs2_replay_incr_blk(sdp, &start);
328                                 brelse(bh);
329                                 continue;
330                         }
331                         if (error == 1) {
332                                 gfs2_consist_inode(GFS2_I(jd->jd_inode));
333                                 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
367 static int clean_journal(struct gfs2_jdesc *jd, struct gfs2_log_header *head)
368 {
369         struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
370         struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
371         unsigned int lblock;
372         int new = 0;
373         u64 dblock;
374         struct gfs2_log_header *lh;
375         u32 hash;
376         struct buffer_head *bh;
377         int error;
378         int boundary;
379
380         lblock = head->lh_blkno;
381         gfs2_replay_incr_blk(sdp, &lblock);
382         error = gfs2_block_map(&ip->i_inode, lblock, &new, &dblock, &boundary);
383         if (error)
384                 return error;
385         if (!dblock) {
386                 gfs2_consist_inode(ip);
387                 return -EIO;
388         }
389
390         bh = sb_getblk(sdp->sd_vfs, dblock);
391         lock_buffer(bh);
392         memset(bh->b_data, 0, bh->b_size);
393         set_buffer_uptodate(bh);
394         clear_buffer_dirty(bh);
395         unlock_buffer(bh);
396
397         lh = (struct gfs2_log_header *)bh->b_data;
398         memset(lh, 0, sizeof(struct gfs2_log_header));
399         lh->lh_header.mh_magic = cpu_to_be32(GFS2_MAGIC);
400         lh->lh_header.mh_type = cpu_to_be32(GFS2_METATYPE_LH);
401         lh->lh_header.mh_format = cpu_to_be32(GFS2_FORMAT_LH);
402         lh->lh_sequence = cpu_to_be64(head->lh_sequence + 1);
403         lh->lh_flags = cpu_to_be32(GFS2_LOG_HEAD_UNMOUNT);
404         lh->lh_blkno = cpu_to_be32(lblock);
405         hash = gfs2_disk_hash((const char *)lh, sizeof(struct gfs2_log_header));
406         lh->lh_hash = cpu_to_be32(hash);
407
408         set_buffer_dirty(bh);
409         if (sync_dirty_buffer(bh))
410                 gfs2_io_error_bh(sdp, bh);
411         brelse(bh);
412
413         return error;
414 }
415
416 /**
417  * gfs2_recover_journal - recovery a given journal
418  * @jd: the struct gfs2_jdesc describing the journal
419  *
420  * Acquire the journal's lock, check to see if the journal is clean, and
421  * do recovery if necessary.
422  *
423  * Returns: errno
424  */
425
426 int gfs2_recover_journal(struct gfs2_jdesc *jd)
427 {
428         struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
429         struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
430         struct gfs2_log_header head;
431         struct gfs2_holder j_gh, ji_gh, t_gh;
432         unsigned long t;
433         int ro = 0;
434         unsigned int pass;
435         int error;
436
437         if (jd->jd_jid != sdp->sd_lockstruct.ls_jid) {
438                 fs_info(sdp, "jid=%u: Trying to acquire journal lock...\n",
439                         jd->jd_jid);
440
441                 /* Aquire the journal lock so we can do recovery */
442
443                 error = gfs2_glock_nq_num(sdp, jd->jd_jid, &gfs2_journal_glops,
444                                           LM_ST_EXCLUSIVE,
445                                           LM_FLAG_NOEXP | LM_FLAG_TRY | GL_NOCACHE,
446                                           &j_gh);
447                 switch (error) {
448                 case 0:
449                         break;
450         
451                 case GLR_TRYFAILED:
452                         fs_info(sdp, "jid=%u: Busy\n", jd->jd_jid);
453                         error = 0;
454         
455                 default:
456                         goto fail;
457                 };
458
459                 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED,
460                                            LM_FLAG_NOEXP, &ji_gh);
461                 if (error)
462                         goto fail_gunlock_j;
463         } else {
464                 fs_info(sdp, "jid=%u, already locked for use\n", jd->jd_jid);
465         }
466
467         fs_info(sdp, "jid=%u: Looking at journal...\n", jd->jd_jid);
468
469         error = gfs2_jdesc_check(jd);
470         if (error)
471                 goto fail_gunlock_ji;
472
473         error = gfs2_find_jhead(jd, &head);
474         if (error)
475                 goto fail_gunlock_ji;
476
477         if (!(head.lh_flags & GFS2_LOG_HEAD_UNMOUNT)) {
478                 fs_info(sdp, "jid=%u: Acquiring the transaction lock...\n",
479                         jd->jd_jid);
480
481                 t = jiffies;
482
483                 /* Acquire a shared hold on the transaction lock */
484
485                 error = gfs2_glock_nq_init(sdp->sd_trans_gl, LM_ST_SHARED,
486                                            LM_FLAG_NOEXP | LM_FLAG_PRIORITY |
487                                            GL_NOCANCEL | GL_NOCACHE, &t_gh);
488                 if (error)
489                         goto fail_gunlock_ji;
490
491                 if (test_bit(SDF_JOURNAL_CHECKED, &sdp->sd_flags)) {
492                         if (!test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags))
493                                 ro = 1;
494                 } else {
495                         if (sdp->sd_vfs->s_flags & MS_RDONLY)
496                                 ro = 1;
497                 }
498
499                 if (ro) {
500                         fs_warn(sdp, "jid=%u: Can't replay: read-only FS\n",
501                                 jd->jd_jid);
502                         error = -EROFS;
503                         goto fail_gunlock_tr;
504                 }
505
506                 fs_info(sdp, "jid=%u: Replaying journal...\n", jd->jd_jid);
507
508                 for (pass = 0; pass < 2; pass++) {
509                         lops_before_scan(jd, &head, pass);
510                         error = foreach_descriptor(jd, head.lh_tail,
511                                                    head.lh_blkno, pass);
512                         lops_after_scan(jd, error, pass);
513                         if (error)
514                                 goto fail_gunlock_tr;
515                 }
516
517                 error = clean_journal(jd, &head);
518                 if (error)
519                         goto fail_gunlock_tr;
520
521                 gfs2_glock_dq_uninit(&t_gh);
522                 t = DIV_ROUND_UP(jiffies - t, HZ);
523                 fs_info(sdp, "jid=%u: Journal replayed in %lus\n",
524                         jd->jd_jid, t);
525         }
526
527         if (jd->jd_jid != sdp->sd_lockstruct.ls_jid)
528                 gfs2_glock_dq_uninit(&ji_gh);
529
530         gfs2_lm_recovery_done(sdp, jd->jd_jid, LM_RD_SUCCESS);
531
532         if (jd->jd_jid != sdp->sd_lockstruct.ls_jid)
533                 gfs2_glock_dq_uninit(&j_gh);
534
535         fs_info(sdp, "jid=%u: Done\n", jd->jd_jid);
536         return 0;
537
538 fail_gunlock_tr:
539         gfs2_glock_dq_uninit(&t_gh);
540 fail_gunlock_ji:
541         if (jd->jd_jid != sdp->sd_lockstruct.ls_jid) {
542                 gfs2_glock_dq_uninit(&ji_gh);
543 fail_gunlock_j:
544                 gfs2_glock_dq_uninit(&j_gh);
545         }
546
547         fs_info(sdp, "jid=%u: %s\n", jd->jd_jid, (error) ? "Failed" : "Done");
548
549 fail:
550         gfs2_lm_recovery_done(sdp, jd->jd_jid, LM_RD_GAVEUP);
551         return error;
552 }
553
554 /**
555  * gfs2_check_journals - Recover any dirty journals
556  * @sdp: the filesystem
557  *
558  */
559
560 void gfs2_check_journals(struct gfs2_sbd *sdp)
561 {
562         struct gfs2_jdesc *jd;
563
564         for (;;) {
565                 jd = gfs2_jdesc_find_dirty(sdp);
566                 if (!jd)
567                         break;
568
569                 if (jd != sdp->sd_jdesc)
570                         gfs2_recover_journal(jd);
571         }
572 }
573