6c7e2e880e32a8fc1daea90fe4a4039e198e63a7
[linux-3.10.git] / fs / gfs2 / recovery.c
1 /*
2  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
3  * Copyright (C) 2004-2005 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 v.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 <asm/semaphore.h>
18
19 #include "gfs2.h"
20 #include "lm_interface.h"
21 #include "incore.h"
22 #include "bmap.h"
23 #include "glock.h"
24 #include "glops.h"
25 #include "lm.h"
26 #include "lops.h"
27 #include "meta_io.h"
28 #include "recovery.h"
29 #include "super.h"
30 #include "util.h"
31 #include "dir.h"
32
33 int gfs2_replay_read_block(struct gfs2_jdesc *jd, unsigned int blk,
34                            struct buffer_head **bh)
35 {
36         struct gfs2_inode *ip = jd->jd_inode->u.generic_ip;
37         struct gfs2_glock *gl = ip->i_gl;
38         int new = 0;
39         uint64_t dblock;
40         uint32_t extlen;
41         int error;
42
43         error = gfs2_block_map(ip, blk, &new, &dblock,
44                                &extlen);
45         if (error)
46                 return error;
47         if (!dblock) {
48                 gfs2_consist_inode(ip);
49                 return -EIO;
50         }
51
52         gfs2_meta_ra(gl, dblock, extlen);
53         error = gfs2_meta_read(gl, dblock, DIO_START | DIO_WAIT, bh);
54
55         return error;
56 }
57
58 int gfs2_revoke_add(struct gfs2_sbd *sdp, uint64_t blkno, unsigned int where)
59 {
60         struct list_head *head = &sdp->sd_revoke_list;
61         struct gfs2_revoke_replay *rr;
62         int found = 0;
63
64         list_for_each_entry(rr, head, rr_list) {
65                 if (rr->rr_blkno == blkno) {
66                         found = 1;
67                         break;
68                 }
69         }
70
71         if (found) {
72                 rr->rr_where = where;
73                 return 0;
74         }
75
76         rr = kmalloc(sizeof(struct gfs2_revoke_replay), GFP_KERNEL);
77         if (!rr)
78                 return -ENOMEM;
79
80         rr->rr_blkno = blkno;
81         rr->rr_where = where;
82         list_add(&rr->rr_list, head);
83
84         return 1;
85 }
86
87 int gfs2_revoke_check(struct gfs2_sbd *sdp, uint64_t blkno, unsigned int where)
88 {
89         struct gfs2_revoke_replay *rr;
90         int wrap, a, b, revoke;
91         int found = 0;
92
93         list_for_each_entry(rr, &sdp->sd_revoke_list, rr_list) {
94                 if (rr->rr_blkno == blkno) {
95                         found = 1;
96                         break;
97                 }
98         }
99
100         if (!found)
101                 return 0;
102
103         wrap = (rr->rr_where < sdp->sd_replay_tail);
104         a = (sdp->sd_replay_tail < where);
105         b = (where < rr->rr_where);
106         revoke = (wrap) ? (a || b) : (a && b);
107
108         return revoke;
109 }
110
111 void gfs2_revoke_clean(struct gfs2_sbd *sdp)
112 {
113         struct list_head *head = &sdp->sd_revoke_list;
114         struct gfs2_revoke_replay *rr;
115
116         while (!list_empty(head)) {
117                 rr = list_entry(head->next, struct gfs2_revoke_replay, rr_list);
118                 list_del(&rr->rr_list);
119                 kfree(rr);
120         }
121 }
122
123 /**
124  * get_log_header - read the log header for a given segment
125  * @jd: the journal
126  * @blk: the block to look at
127  * @lh: the log header to return
128  *
129  * Read the log header for a given segement in a given journal.  Do a few
130  * sanity checks on it.
131  *
132  * Returns: 0 on success,
133  *          1 if the header was invalid or incomplete,
134  *          errno on error
135  */
136
137 static int get_log_header(struct gfs2_jdesc *jd, unsigned int blk,
138                           struct gfs2_log_header *head)
139 {
140         struct buffer_head *bh;
141         struct gfs2_log_header lh;
142         uint32_t hash;
143         int error;
144
145         error = gfs2_replay_read_block(jd, blk, &bh);
146         if (error)
147                 return error;
148
149         memcpy(&lh, bh->b_data, sizeof(struct gfs2_log_header));
150         lh.lh_hash = 0;
151         hash = gfs2_disk_hash((char *)&lh, sizeof(struct gfs2_log_header));
152         gfs2_log_header_in(&lh, bh->b_data);
153
154         brelse(bh);
155
156         if (lh.lh_header.mh_magic != GFS2_MAGIC ||
157             lh.lh_header.mh_type != GFS2_METATYPE_LH ||
158             lh.lh_blkno != blk ||
159             lh.lh_hash != hash)
160                 return 1;
161
162         *head = lh;
163
164         return 0;
165 }
166
167 /**
168  * find_good_lh - find a good log header
169  * @jd: the journal
170  * @blk: the segment to start searching from
171  * @lh: the log header to fill in
172  * @forward: if true search forward in the log, else search backward
173  *
174  * Call get_log_header() to get a log header for a segment, but if the
175  * segment is bad, either scan forward or backward until we find a good one.
176  *
177  * Returns: errno
178  */
179
180 static int find_good_lh(struct gfs2_jdesc *jd, unsigned int *blk,
181                         struct gfs2_log_header *head)
182 {
183         unsigned int orig_blk = *blk;
184         int error;
185
186         for (;;) {
187                 error = get_log_header(jd, *blk, head);
188                 if (error <= 0)
189                         return error;
190
191                 if (++*blk == jd->jd_blocks)
192                         *blk = 0;
193
194                 if (*blk == orig_blk) {
195                         gfs2_consist_inode(jd->jd_inode->u.generic_ip);
196                         return -EIO;
197                 }
198         }
199 }
200
201 /**
202  * jhead_scan - make sure we've found the head of the log
203  * @jd: the journal
204  * @head: this is filled in with the log descriptor of the head
205  *
206  * At this point, seg and lh should be either the head of the log or just
207  * before.  Scan forward until we find the head.
208  *
209  * Returns: errno
210  */
211
212 static int jhead_scan(struct gfs2_jdesc *jd, struct gfs2_log_header *head)
213 {
214         unsigned int blk = head->lh_blkno;
215         struct gfs2_log_header lh;
216         int error;
217
218         for (;;) {
219                 if (++blk == jd->jd_blocks)
220                         blk = 0;
221
222                 error = get_log_header(jd, blk, &lh);
223                 if (error < 0)
224                         return error;
225                 if (error == 1)
226                         continue;
227
228                 if (lh.lh_sequence == head->lh_sequence) {
229                         gfs2_consist_inode(jd->jd_inode->u.generic_ip);
230                         return -EIO;
231                 }
232                 if (lh.lh_sequence < head->lh_sequence)
233                         break;
234
235                 *head = lh;
236         }
237
238         return 0;
239 }
240
241 /**
242  * gfs2_find_jhead - find the head of a log
243  * @jd: the journal
244  * @head: the log descriptor for the head of the log is returned here
245  *
246  * Do a binary search of a journal and find the valid log entry with the
247  * highest sequence number.  (i.e. the log head)
248  *
249  * Returns: errno
250  */
251
252 int gfs2_find_jhead(struct gfs2_jdesc *jd, struct gfs2_log_header *head)
253 {
254         struct gfs2_log_header lh_1, lh_m;
255         uint32_t blk_1, blk_2, blk_m;
256         int error;
257
258         blk_1 = 0;
259         blk_2 = jd->jd_blocks - 1;
260
261         for (;;) {
262                 blk_m = (blk_1 + blk_2) / 2;
263
264                 error = find_good_lh(jd, &blk_1, &lh_1);
265                 if (error)
266                         return error;
267
268                 error = find_good_lh(jd, &blk_m, &lh_m);
269                 if (error)
270                         return error;
271
272                 if (blk_1 == blk_m || blk_m == blk_2)
273                         break;
274
275                 if (lh_1.lh_sequence <= lh_m.lh_sequence)
276                         blk_1 = blk_m;
277                 else
278                         blk_2 = blk_m;
279         }
280
281         error = jhead_scan(jd, &lh_1);
282         if (error)
283                 return error;
284
285         *head = lh_1;
286
287         return error;
288 }
289
290 /**
291  * foreach_descriptor - go through the active part of the log
292  * @jd: the journal
293  * @start: the first log header in the active region
294  * @end: the last log header (don't process the contents of this entry))
295  *
296  * Call a given function once for every log descriptor in the active
297  * portion of the log.
298  *
299  * Returns: errno
300  */
301
302 static int foreach_descriptor(struct gfs2_jdesc *jd, unsigned int start,
303                               unsigned int end, int pass)
304 {
305         struct gfs2_inode *ip = jd->jd_inode->u.generic_ip;
306         struct gfs2_sbd *sdp = ip->i_sbd;
307         struct buffer_head *bh;
308         struct gfs2_log_descriptor *ld;
309         int error = 0;
310         u32 length;
311         __be64 *ptr;
312         unsigned int offset = sizeof(struct gfs2_log_descriptor);
313         offset += (sizeof(__be64)-1);
314         offset &= ~(sizeof(__be64)-1);
315
316         while (start != end) {
317                 error = gfs2_replay_read_block(jd, start, &bh);
318                 if (error)
319                         return error;
320                 if (gfs2_meta_check(sdp, bh)) {
321                         brelse(bh);
322                         return -EIO;
323                 }
324                 ld = (struct gfs2_log_descriptor *)bh->b_data;
325                 length = be32_to_cpu(ld->ld_length);
326
327                 if (be16_to_cpu(ld->ld_header.mh_type) == GFS2_METATYPE_LH) {
328                         struct gfs2_log_header lh;
329                         error = get_log_header(jd, start, &lh);
330                         if (!error) {
331                                 gfs2_replay_incr_blk(sdp, &start);
332                                 continue;
333                         }
334                         if (error == 1) {
335                                 gfs2_consist_inode(jd->jd_inode->u.generic_ip);
336                                 error = -EIO;
337                         }
338                         brelse(bh);
339                         return error;
340                 } else if (gfs2_metatype_check(sdp, bh, GFS2_METATYPE_LD)) {
341                         brelse(bh);
342                         return -EIO;
343                 }
344                 ptr = (__be64 *)(bh->b_data + offset);
345                 error = lops_scan_elements(jd, start, ld, ptr, pass);
346                 if (error) {
347                         brelse(bh);
348                         return error;
349                 }
350
351                 while (length--)
352                         gfs2_replay_incr_blk(sdp, &start);
353
354                 brelse(bh);
355         }
356
357         return 0;
358 }
359
360 /**
361  * clean_journal - mark a dirty journal as being clean
362  * @sdp: the filesystem
363  * @jd: the journal
364  * @gl: the journal's glock
365  * @head: the head journal to start from
366  *
367  * Returns: errno
368  */
369
370 static int clean_journal(struct gfs2_jdesc *jd, struct gfs2_log_header *head)
371 {
372         struct gfs2_inode *ip = jd->jd_inode->u.generic_ip;
373         struct gfs2_sbd *sdp = ip->i_sbd;
374         unsigned int lblock;
375         int new = 0;
376         uint64_t dblock;
377         struct gfs2_log_header *lh;
378         uint32_t hash;
379         struct buffer_head *bh;
380         int error;
381         
382         lblock = head->lh_blkno;
383         gfs2_replay_incr_blk(sdp, &lblock);
384         error = gfs2_block_map(ip, lblock, &new, &dblock, NULL);
385         if (error)
386                 return error;
387         if (!dblock) {
388                 gfs2_consist_inode(ip);
389                 return -EIO;
390         }
391
392         bh = sb_getblk(sdp->sd_vfs, dblock);
393         lock_buffer(bh);
394         memset(bh->b_data, 0, bh->b_size);
395         set_buffer_uptodate(bh);
396         clear_buffer_dirty(bh);
397         unlock_buffer(bh);
398
399         lh = (struct gfs2_log_header *)bh->b_data;
400         memset(lh, 0, sizeof(struct gfs2_log_header));
401         lh->lh_header.mh_magic = cpu_to_be32(GFS2_MAGIC);
402         lh->lh_header.mh_type = cpu_to_be16(GFS2_METATYPE_LH);
403         lh->lh_header.mh_format = cpu_to_be16(GFS2_FORMAT_LH);
404         lh->lh_sequence = cpu_to_be64(head->lh_sequence + 1);
405         lh->lh_flags = cpu_to_be32(GFS2_LOG_HEAD_UNMOUNT);
406         lh->lh_blkno = cpu_to_be32(lblock);
407         hash = gfs2_disk_hash((const char *)lh, sizeof(struct gfs2_log_header));
408         lh->lh_hash = cpu_to_be32(hash);
409
410         set_buffer_dirty(bh);
411         if (sync_dirty_buffer(bh))
412                 gfs2_io_error_bh(sdp, bh);
413         brelse(bh);
414
415         return error;
416 }
417
418 /**
419  * gfs2_recover_journal - recovery a given journal
420  * @jd: the struct gfs2_jdesc describing the journal
421  * @wait: Don't return until the journal is clean (or an error is encountered)
422  *
423  * Acquire the journal's lock, check to see if the journal is clean, and
424  * do recovery if necessary.
425  *
426  * Returns: errno
427  */
428
429 int gfs2_recover_journal(struct gfs2_jdesc *jd, int wait)
430 {
431         struct gfs2_inode *ip = jd->jd_inode->u.generic_ip;
432         struct gfs2_sbd *sdp = ip->i_sbd;
433         struct gfs2_log_header head;
434         struct gfs2_holder j_gh, ji_gh, t_gh;
435         unsigned long t;
436         int ro = 0;
437         unsigned int pass;
438         int error;
439
440         fs_info(sdp, "jid=%u: Trying to acquire journal lock...\n", jd->jd_jid);
441
442         /* Aquire the journal lock so we can do recovery */
443
444         error = gfs2_glock_nq_num(sdp,
445                                   jd->jd_jid, &gfs2_journal_glops,
446                                   LM_ST_EXCLUSIVE,
447                                   LM_FLAG_NOEXP |
448                                   ((wait) ? 0 : LM_FLAG_TRY) |
449                                   GL_NOCACHE, &j_gh);
450         switch (error) {
451         case 0:
452                 break;
453
454         case GLR_TRYFAILED:
455                 fs_info(sdp, "jid=%u: Busy\n", jd->jd_jid);
456                 error = 0;
457
458         default:
459                 goto fail;
460         };
461
462         error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED,
463                                    LM_FLAG_NOEXP, &ji_gh);
464         if (error)
465                 goto fail_gunlock_j;
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,
486                                            LM_ST_SHARED,
487                                            LM_FLAG_NOEXP |
488                                            LM_FLAG_PRIORITY |
489                                            GL_NEVER_RECURSE |
490                                            GL_NOCANCEL |
491                                            GL_NOCACHE,
492                                            &t_gh);
493                 if (error)
494                         goto fail_gunlock_ji;
495
496                 if (test_bit(SDF_JOURNAL_CHECKED, &sdp->sd_flags)) {
497                         if (!test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags))
498                                 ro = 1;
499                 } else {
500                         if (sdp->sd_vfs->s_flags & MS_RDONLY)
501                                 ro = 1;
502                 }
503
504                 if (ro) {
505                         fs_warn(sdp, "jid=%u: Can't replay: read-only FS\n",
506                                 jd->jd_jid);
507                         error = -EROFS;
508                         goto fail_gunlock_tr;
509                 }
510
511                 fs_info(sdp, "jid=%u: Replaying journal...\n", jd->jd_jid);
512
513                 for (pass = 0; pass < 2; pass++) {
514                         lops_before_scan(jd, &head, pass);
515                         error = foreach_descriptor(jd, head.lh_tail,
516                                                    head.lh_blkno, pass);
517                         lops_after_scan(jd, error, pass);
518                         if (error)
519                                 goto fail_gunlock_tr;
520                 }
521
522                 error = clean_journal(jd, &head);
523                 if (error)
524                         goto fail_gunlock_tr;
525
526                 gfs2_glock_dq_uninit(&t_gh);
527
528                 t = DIV_ROUND_UP(jiffies - t, HZ);
529                 
530                 fs_info(sdp, "jid=%u: Journal replayed in %lus\n",
531                         jd->jd_jid, t);
532         }
533
534         gfs2_glock_dq_uninit(&ji_gh);
535
536         gfs2_lm_recovery_done(sdp, jd->jd_jid, LM_RD_SUCCESS);
537
538         gfs2_glock_dq_uninit(&j_gh);
539
540         fs_info(sdp, "jid=%u: Done\n", jd->jd_jid);
541
542         return 0;
543
544  fail_gunlock_tr:
545         gfs2_glock_dq_uninit(&t_gh);
546
547  fail_gunlock_ji:
548         gfs2_glock_dq_uninit(&ji_gh);
549
550  fail_gunlock_j:
551         gfs2_glock_dq_uninit(&j_gh);
552
553         fs_info(sdp, "jid=%u: %s\n", jd->jd_jid, (error) ? "Failed" : "Done");
554
555  fail:
556         gfs2_lm_recovery_done(sdp, jd->jd_jid, LM_RD_GAVEUP);
557
558         return error;
559 }
560
561 /**
562  * gfs2_check_journals - Recover any dirty journals
563  * @sdp: the filesystem
564  *
565  */
566
567 void gfs2_check_journals(struct gfs2_sbd *sdp)
568 {
569         struct gfs2_jdesc *jd;
570
571         for (;;) {
572                 jd = gfs2_jdesc_find_dirty(sdp);
573                 if (!jd)
574                         break;
575
576                 if (jd != sdp->sd_jdesc)
577                         gfs2_recover_journal(jd, NO_WAIT);
578         }
579 }
580