[PATCH] ext2: fsid for statvfs
[linux-2.6.git] / 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 #include <linux/lm_interface.h>
18
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"
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         *bh = gfs2_meta_ra(gl, dblock, extlen);
51
52         return error;
53 }
54
55 int gfs2_revoke_add(struct gfs2_sbd *sdp, u64 blkno, unsigned int where)
56 {
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
84 int gfs2_revoke_check(struct gfs2_sbd *sdp, u64 blkno, unsigned int where)
85 {
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
108 void 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
134 static int get_log_header(struct gfs2_jdesc *jd, unsigned int blk,
135                           struct gfs2_log_header *head)
136 {
137         struct buffer_head *bh;
138         struct gfs2_log_header lh;
139         u32 hash;
140         int error;
141
142         error = gfs2_replay_read_block(jd, blk, &bh);
143         if (error)
144                 return error;
145
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);
150
151         brelse(bh);
152
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;
157
158         *head = lh;
159
160         return 0;
161 }
162
163 /**
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
169  *
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.
172  *
173  * Returns: errno
174  */
175
176 static int find_good_lh(struct gfs2_jdesc *jd, unsigned int *blk,
177                         struct gfs2_log_header *head)
178 {
179         unsigned int orig_blk = *blk;
180         int error;
181
182         for (;;) {
183                 error = get_log_header(jd, *blk, head);
184                 if (error <= 0)
185                         return error;
186
187                 if (++*blk == jd->jd_blocks)
188                         *blk = 0;
189
190                 if (*blk == orig_blk) {
191                         gfs2_consist_inode(GFS2_I(jd->jd_inode));
192                         return -EIO;
193                 }
194         }
195 }
196
197 /**
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
201  *
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.
204  *
205  * Returns: errno
206  */
207
208 static int jhead_scan(struct gfs2_jdesc *jd, struct gfs2_log_header *head)
209 {
210         unsigned int blk = head->lh_blkno;
211         struct gfs2_log_header lh;
212         int error;
213
214         for (;;) {
215                 if (++blk == jd->jd_blocks)
216                         blk = 0;
217
218                 error = get_log_header(jd, blk, &lh);
219                 if (error < 0)
220                         return error;
221                 if (error == 1)
222                         continue;
223
224                 if (lh.lh_sequence == head->lh_sequence) {
225                         gfs2_consist_inode(GFS2_I(jd->jd_inode));
226                         return -EIO;
227                 }
228                 if (lh.lh_sequence < head->lh_sequence)
229                         break;
230
231                 *head = lh;
232         }
233
234         return 0;
235 }
236
237 /**
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
241  *
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)
244  *
245  * Returns: errno
246  */
247
248 int gfs2_find_jhead(struct gfs2_jdesc *jd, struct gfs2_log_header *head)
249 {
250         struct gfs2_log_header lh_1, lh_m;
251         u32 blk_1, blk_2, blk_m;
252         int error;
253
254         blk_1 = 0;
255         blk_2 = jd->jd_blocks - 1;
256
257         for (;;) {
258                 blk_m = (blk_1 + blk_2) / 2;
259
260                 error = find_good_lh(jd, &blk_1, &lh_1);
261                 if (error)
262                         return error;
263
264                 error = find_good_lh(jd, &blk_m, &lh_m);
265                 if (error)
266                         return error;
267
268                 if (blk_1 == blk_m || blk_m == blk_2)
269                         break;
270
271                 if (lh_1.lh_sequence <= lh_m.lh_sequence)
272                         blk_1 = blk_m;
273                 else
274                         blk_2 = blk_m;
275         }
276
277         error = jhead_scan(jd, &lh_1);
278         if (error)
279                 return error;
280
281         *head = lh_1;
282
283         return error;
284 }
285
286 /**
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))
291  *
292  * Call a given function once for every log descriptor in the active
293  * portion of the log.
294  *
295  * Returns: errno
296  */
297
298 static int foreach_descriptor(struct gfs2_jdesc *jd, unsigned int start,
299                               unsigned int end, int pass)
300 {
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);
310
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;
318                 }
319                 ld = (struct gfs2_log_descriptor *)bh->b_data;
320                 length = be32_to_cpu(ld->ld_length);
321
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;
329                         }
330                         if (error == 1) {
331                                 gfs2_consist_inode(GFS2_I(jd->jd_inode));
332                                 error = -EIO;
333                         }
334                         brelse(bh);
335                         return error;
336                 } else if (gfs2_metatype_check(sdp, bh, GFS2_METATYPE_LD)) {
337                         brelse(bh);
338                         return -EIO;
339                 }
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;
345                 }
346
347                 while (length--)
348                         gfs2_replay_incr_blk(sdp, &start);
349
350                 brelse(bh);
351         }
352
353         return 0;
354 }
355
356 /**
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
362  *
363  * Returns: errno
364  */
365
366 static int clean_journal(struct gfs2_jdesc *jd, struct gfs2_log_header *head)
367 {
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 };
376
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;
386         }
387
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);
394
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);
405
406         set_buffer_dirty(bh);
407         if (sync_dirty_buffer(bh))
408                 gfs2_io_error_bh(sdp, bh);
409         brelse(bh);
410
411         return error;
412 }
413
414 /**
415  * gfs2_recover_journal - recovery a given journal
416  * @jd: the struct gfs2_jdesc describing the journal
417  *
418  * Acquire the journal's lock, check to see if the journal is clean, and
419  * do recovery if necessary.
420  *
421  * Returns: errno
422  */
423
424 int gfs2_recover_journal(struct gfs2_jdesc *jd)
425 {
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;
434
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);
438
439                 /* Aquire the journal lock so we can do recovery */
440
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;
448
449                 case GLR_TRYFAILED:
450                         fs_info(sdp, "jid=%u: Busy\n", jd->jd_jid);
451                         error = 0;
452
453                 default:
454                         goto fail;
455                 };
456
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);
463         }
464
465         fs_info(sdp, "jid=%u: Looking at journal...\n", jd->jd_jid);
466
467         error = gfs2_jdesc_check(jd);
468         if (error)
469                 goto fail_gunlock_ji;
470
471         error = gfs2_find_jhead(jd, &head);
472         if (error)
473                 goto fail_gunlock_ji;
474
475         if (!(head.lh_flags & GFS2_LOG_HEAD_UNMOUNT)) {
476                 fs_info(sdp, "jid=%u: Acquiring the transaction lock...\n",
477                         jd->jd_jid);
478
479                 t = jiffies;
480
481                 /* Acquire a shared hold on the transaction lock */
482
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;
488
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;
495                 }
496
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;
502                 }
503
504                 fs_info(sdp, "jid=%u: Replaying journal...\n", jd->jd_jid);
505
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;
513                 }
514
515                 error = clean_journal(jd, &head);
516                 if (error)
517                         goto fail_gunlock_tr;
518
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);
523         }
524
525         if (jd->jd_jid != sdp->sd_lockstruct.ls_jid)
526                 gfs2_glock_dq_uninit(&ji_gh);
527
528         gfs2_lm_recovery_done(sdp, jd->jd_jid, LM_RD_SUCCESS);
529
530         if (jd->jd_jid != sdp->sd_lockstruct.ls_jid)
531                 gfs2_glock_dq_uninit(&j_gh);
532
533         fs_info(sdp, "jid=%u: Done\n", jd->jd_jid);
534         return 0;
535
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);
543         }
544
545         fs_info(sdp, "jid=%u: %s\n", jd->jd_jid, (error) ? "Failed" : "Done");
546
547 fail:
548         gfs2_lm_recovery_done(sdp, jd->jd_jid, LM_RD_GAVEUP);
549         return error;
550 }
551
552 /**
553  * gfs2_check_journals - Recover any dirty journals
554  * @sdp: the filesystem
555  *
556  */
557
558 void gfs2_check_journals(struct gfs2_sbd *sdp)
559 {
560         struct gfs2_jdesc *jd;
561
562         for (;;) {
563                 jd = gfs2_jdesc_find_dirty(sdp);
564                 if (!jd)
565                         break;
566
567                 if (jd != sdp->sd_jdesc)
568                         gfs2_recover_journal(jd);
569         }
570 }
571