~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/gfs2/recovery.c

Version: ~ [ linux-5.7 ] ~ [ linux-5.6.15 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.43 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.125 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.182 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.225 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.225 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.84 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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/module.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/crc32c.h>
 18 #include <linux/ktime.h>
 19 
 20 #include "gfs2.h"
 21 #include "incore.h"
 22 #include "bmap.h"
 23 #include "glock.h"
 24 #include "glops.h"
 25 #include "log.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 struct workqueue_struct *gfs_recovery_wq;
 34 
 35 int gfs2_replay_read_block(struct gfs2_jdesc *jd, unsigned int blk,
 36                            struct buffer_head **bh)
 37 {
 38         struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
 39         struct gfs2_glock *gl = ip->i_gl;
 40         int new = 0;
 41         u64 dblock;
 42         u32 extlen;
 43         int error;
 44 
 45         error = gfs2_extent_map(&ip->i_inode, blk, &new, &dblock, &extlen);
 46         if (error)
 47                 return error;
 48         if (!dblock) {
 49                 gfs2_consist_inode(ip);
 50                 return -EIO;
 51         }
 52 
 53         *bh = gfs2_meta_ra(gl, dblock, extlen);
 54 
 55         return error;
 56 }
 57 
 58 int gfs2_revoke_add(struct gfs2_jdesc *jd, u64 blkno, unsigned int where)
 59 {
 60         struct list_head *head = &jd->jd_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_NOFS);
 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_jdesc *jd, u64 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, &jd->jd_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 < jd->jd_replay_tail);
104         a = (jd->jd_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_jdesc *jd)
112 {
113         struct list_head *head = &jd->jd_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 int __get_log_header(struct gfs2_sbd *sdp, const struct gfs2_log_header *lh,
124                      unsigned int blkno, struct gfs2_log_header_host *head)
125 {
126         u32 hash, crc;
127 
128         if (lh->lh_header.mh_magic != cpu_to_be32(GFS2_MAGIC) ||
129             lh->lh_header.mh_type != cpu_to_be32(GFS2_METATYPE_LH) ||
130             (blkno && be32_to_cpu(lh->lh_blkno) != blkno))
131                 return 1;
132 
133         hash = crc32(~0, lh, LH_V1_SIZE - 4);
134         hash = ~crc32_le_shift(hash, 4); /* assume lh_hash is zero */
135 
136         if (be32_to_cpu(lh->lh_hash) != hash)
137                 return 1;
138 
139         crc = crc32c(~0, (void *)lh + LH_V1_SIZE + 4,
140                      sdp->sd_sb.sb_bsize - LH_V1_SIZE - 4);
141 
142         if ((lh->lh_crc != 0 && be32_to_cpu(lh->lh_crc) != crc))
143                 return 1;
144 
145         head->lh_sequence = be64_to_cpu(lh->lh_sequence);
146         head->lh_flags = be32_to_cpu(lh->lh_flags);
147         head->lh_tail = be32_to_cpu(lh->lh_tail);
148         head->lh_blkno = be32_to_cpu(lh->lh_blkno);
149 
150         return 0;
151 }
152 /**
153  * get_log_header - read the log header for a given segment
154  * @jd: the journal
155  * @blk: the block to look at
156  * @lh: the log header to return
157  *
158  * Read the log header for a given segement in a given journal.  Do a few
159  * sanity checks on it.
160  *
161  * Returns: 0 on success,
162  *          1 if the header was invalid or incomplete,
163  *          errno on error
164  */
165 
166 static int get_log_header(struct gfs2_jdesc *jd, unsigned int blk,
167                           struct gfs2_log_header_host *head)
168 {
169         struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
170         struct buffer_head *bh;
171         int error;
172 
173         error = gfs2_replay_read_block(jd, blk, &bh);
174         if (error)
175                 return error;
176 
177         error = __get_log_header(sdp, (const struct gfs2_log_header *)bh->b_data,
178                                  blk, head);
179         brelse(bh);
180 
181         return error;
182 }
183 
184 /**
185  * find_good_lh - find a good log header
186  * @jd: the journal
187  * @blk: the segment to start searching from
188  * @lh: the log header to fill in
189  * @forward: if true search forward in the log, else search backward
190  *
191  * Call get_log_header() to get a log header for a segment, but if the
192  * segment is bad, either scan forward or backward until we find a good one.
193  *
194  * Returns: errno
195  */
196 
197 static int find_good_lh(struct gfs2_jdesc *jd, unsigned int *blk,
198                         struct gfs2_log_header_host *head)
199 {
200         unsigned int orig_blk = *blk;
201         int error;
202 
203         for (;;) {
204                 error = get_log_header(jd, *blk, head);
205                 if (error <= 0)
206                         return error;
207 
208                 if (++*blk == jd->jd_blocks)
209                         *blk = 0;
210 
211                 if (*blk == orig_blk) {
212                         gfs2_consist_inode(GFS2_I(jd->jd_inode));
213                         return -EIO;
214                 }
215         }
216 }
217 
218 /**
219  * jhead_scan - make sure we've found the head of the log
220  * @jd: the journal
221  * @head: this is filled in with the log descriptor of the head
222  *
223  * At this point, seg and lh should be either the head of the log or just
224  * before.  Scan forward until we find the head.
225  *
226  * Returns: errno
227  */
228 
229 static int jhead_scan(struct gfs2_jdesc *jd, struct gfs2_log_header_host *head)
230 {
231         unsigned int blk = head->lh_blkno;
232         struct gfs2_log_header_host lh;
233         int error;
234 
235         for (;;) {
236                 if (++blk == jd->jd_blocks)
237                         blk = 0;
238 
239                 error = get_log_header(jd, blk, &lh);
240                 if (error < 0)
241                         return error;
242                 if (error == 1)
243                         continue;
244 
245                 if (lh.lh_sequence == head->lh_sequence) {
246                         gfs2_consist_inode(GFS2_I(jd->jd_inode));
247                         return -EIO;
248                 }
249                 if (lh.lh_sequence < head->lh_sequence)
250                         break;
251 
252                 *head = lh;
253         }
254 
255         return 0;
256 }
257 
258 /**
259  * gfs2_find_jhead - find the head of a log
260  * @jd: the journal
261  * @head: the log descriptor for the head of the log is returned here
262  *
263  * Do a binary search of a journal and find the valid log entry with the
264  * highest sequence number.  (i.e. the log head)
265  *
266  * Returns: errno
267  */
268 
269 int gfs2_find_jhead(struct gfs2_jdesc *jd, struct gfs2_log_header_host *head)
270 {
271         struct gfs2_log_header_host lh_1, lh_m;
272         u32 blk_1, blk_2, blk_m;
273         int error;
274 
275         blk_1 = 0;
276         blk_2 = jd->jd_blocks - 1;
277 
278         for (;;) {
279                 blk_m = (blk_1 + blk_2) / 2;
280 
281                 error = find_good_lh(jd, &blk_1, &lh_1);
282                 if (error)
283                         return error;
284 
285                 error = find_good_lh(jd, &blk_m, &lh_m);
286                 if (error)
287                         return error;
288 
289                 if (blk_1 == blk_m || blk_m == blk_2)
290                         break;
291 
292                 if (lh_1.lh_sequence <= lh_m.lh_sequence)
293                         blk_1 = blk_m;
294                 else
295                         blk_2 = blk_m;
296         }
297 
298         error = jhead_scan(jd, &lh_1);
299         if (error)
300                 return error;
301 
302         *head = lh_1;
303 
304         return error;
305 }
306 
307 /**
308  * foreach_descriptor - go through the active part of the log
309  * @jd: the journal
310  * @start: the first log header in the active region
311  * @end: the last log header (don't process the contents of this entry))
312  *
313  * Call a given function once for every log descriptor in the active
314  * portion of the log.
315  *
316  * Returns: errno
317  */
318 
319 static int foreach_descriptor(struct gfs2_jdesc *jd, unsigned int start,
320                               unsigned int end, int pass)
321 {
322         struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
323         struct buffer_head *bh;
324         struct gfs2_log_descriptor *ld;
325         int error = 0;
326         u32 length;
327         __be64 *ptr;
328         unsigned int offset = sizeof(struct gfs2_log_descriptor);
329         offset += sizeof(__be64) - 1;
330         offset &= ~(sizeof(__be64) - 1);
331 
332         while (start != end) {
333                 error = gfs2_replay_read_block(jd, start, &bh);
334                 if (error)
335                         return error;
336                 if (gfs2_meta_check(sdp, bh)) {
337                         brelse(bh);
338                         return -EIO;
339                 }
340                 ld = (struct gfs2_log_descriptor *)bh->b_data;
341                 length = be32_to_cpu(ld->ld_length);
342 
343                 if (be32_to_cpu(ld->ld_header.mh_type) == GFS2_METATYPE_LH) {
344                         struct gfs2_log_header_host lh;
345                         error = get_log_header(jd, start, &lh);
346                         if (!error) {
347                                 gfs2_replay_incr_blk(jd, &start);
348                                 brelse(bh);
349                                 continue;
350                         }
351                         if (error == 1) {
352                                 gfs2_consist_inode(GFS2_I(jd->jd_inode));
353                                 error = -EIO;
354                         }
355                         brelse(bh);
356                         return error;
357                 } else if (gfs2_metatype_check(sdp, bh, GFS2_METATYPE_LD)) {
358                         brelse(bh);
359                         return -EIO;
360                 }
361                 ptr = (__be64 *)(bh->b_data + offset);
362                 error = lops_scan_elements(jd, start, ld, ptr, pass);
363                 if (error) {
364                         brelse(bh);
365                         return error;
366                 }
367 
368                 while (length--)
369                         gfs2_replay_incr_blk(jd, &start);
370 
371                 brelse(bh);
372         }
373 
374         return 0;
375 }
376 
377 /**
378  * clean_journal - mark a dirty journal as being clean
379  * @jd: the journal
380  * @head: the head journal to start from
381  *
382  * Returns: errno
383  */
384 
385 static void clean_journal(struct gfs2_jdesc *jd,
386                           struct gfs2_log_header_host *head)
387 {
388         struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
389 
390         sdp->sd_log_flush_head = head->lh_blkno;
391         gfs2_replay_incr_blk(jd, &sdp->sd_log_flush_head);
392         gfs2_write_log_header(sdp, jd, head->lh_sequence + 1, 0,
393                               GFS2_LOG_HEAD_UNMOUNT | GFS2_LOG_HEAD_RECOVERY,
394                               REQ_PREFLUSH | REQ_FUA | REQ_META | REQ_SYNC);
395 }
396 
397 
398 static void gfs2_recovery_done(struct gfs2_sbd *sdp, unsigned int jid,
399                                unsigned int message)
400 {
401         char env_jid[20];
402         char env_status[20];
403         char *envp[] = { env_jid, env_status, NULL };
404         struct lm_lockstruct *ls = &sdp->sd_lockstruct;
405 
406         ls->ls_recover_jid_done = jid;
407         ls->ls_recover_jid_status = message;
408         sprintf(env_jid, "JID=%u", jid);
409         sprintf(env_status, "RECOVERY=%s",
410                 message == LM_RD_SUCCESS ? "Done" : "Failed");
411         kobject_uevent_env(&sdp->sd_kobj, KOBJ_CHANGE, envp);
412 
413         if (sdp->sd_lockstruct.ls_ops->lm_recovery_result)
414                 sdp->sd_lockstruct.ls_ops->lm_recovery_result(sdp, jid, message);
415 }
416 
417 void gfs2_recover_func(struct work_struct *work)
418 {
419         struct gfs2_jdesc *jd = container_of(work, struct gfs2_jdesc, jd_work);
420         struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
421         struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
422         struct gfs2_log_header_host head;
423         struct gfs2_holder j_gh, ji_gh, thaw_gh;
424         ktime_t t_start, t_jlck, t_jhd, t_tlck, t_rep;
425         int ro = 0;
426         unsigned int pass;
427         int error = 0;
428         int jlocked = 0;
429 
430         t_start = ktime_get();
431         if (sdp->sd_args.ar_spectator)
432                 goto fail;
433         if (jd->jd_jid != sdp->sd_lockstruct.ls_jid) {
434                 fs_info(sdp, "jid=%u: Trying to acquire journal lock...\n",
435                         jd->jd_jid);
436                 jlocked = 1;
437                 /* Acquire the journal lock so we can do recovery */
438 
439                 error = gfs2_glock_nq_num(sdp, jd->jd_jid, &gfs2_journal_glops,
440                                           LM_ST_EXCLUSIVE,
441                                           LM_FLAG_NOEXP | LM_FLAG_TRY | GL_NOCACHE,
442                                           &j_gh);
443                 switch (error) {
444                 case 0:
445                         break;
446 
447                 case GLR_TRYFAILED:
448                         fs_info(sdp, "jid=%u: Busy\n", jd->jd_jid);
449                         error = 0;
450 
451                 default:
452                         goto fail;
453                 };
454 
455                 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED,
456                                            LM_FLAG_NOEXP | GL_NOCACHE, &ji_gh);
457                 if (error)
458                         goto fail_gunlock_j;
459         } else {
460                 fs_info(sdp, "jid=%u, already locked for use\n", jd->jd_jid);
461         }
462 
463         t_jlck = ktime_get();
464         fs_info(sdp, "jid=%u: Looking at journal...\n", jd->jd_jid);
465 
466         error = gfs2_jdesc_check(jd);
467         if (error)
468                 goto fail_gunlock_ji;
469 
470         error = gfs2_find_jhead(jd, &head);
471         if (error)
472                 goto fail_gunlock_ji;
473         t_jhd = ktime_get();
474         fs_info(sdp, "jid=%u: Journal head lookup took %lldms\n", jd->jd_jid,
475                 ktime_ms_delta(t_jhd, t_jlck));
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                 /* Acquire a shared hold on the freeze lock */
482 
483                 error = gfs2_glock_nq_init(sdp->sd_freeze_gl, LM_ST_SHARED,
484                                            LM_FLAG_NOEXP | LM_FLAG_PRIORITY,
485                                            &thaw_gh);
486                 if (error)
487                         goto fail_gunlock_ji;
488 
489                 if (test_bit(SDF_RORECOVERY, &sdp->sd_flags)) {
490                         ro = 1;
491                 } else 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 (sb_rdonly(sdp->sd_vfs)) {
496                                 /* check if device itself is read-only */
497                                 ro = bdev_read_only(sdp->sd_vfs->s_bdev);
498                                 if (!ro) {
499                                         fs_info(sdp, "recovery required on "
500                                                 "read-only filesystem.\n");
501                                         fs_info(sdp, "write access will be "
502                                                 "enabled during recovery.\n");
503                                 }
504                         }
505                 }
506 
507                 if (ro) {
508                         fs_warn(sdp, "jid=%u: Can't replay: read-only block "
509                                 "device\n", jd->jd_jid);
510                         error = -EROFS;
511                         goto fail_gunlock_thaw;
512                 }
513 
514                 t_tlck = ktime_get();
515                 fs_info(sdp, "jid=%u: Replaying journal...\n", jd->jd_jid);
516 
517                 for (pass = 0; pass < 2; pass++) {
518                         lops_before_scan(jd, &head, pass);
519                         error = foreach_descriptor(jd, head.lh_tail,
520                                                    head.lh_blkno, pass);
521                         lops_after_scan(jd, error, pass);
522                         if (error)
523                                 goto fail_gunlock_thaw;
524                 }
525 
526                 clean_journal(jd, &head);
527 
528                 gfs2_glock_dq_uninit(&thaw_gh);
529                 t_rep = ktime_get();
530                 fs_info(sdp, "jid=%u: Journal replayed in %lldms [jlck:%lldms, "
531                         "jhead:%lldms, tlck:%lldms, replay:%lldms]\n",
532                         jd->jd_jid, ktime_ms_delta(t_rep, t_start),
533                         ktime_ms_delta(t_jlck, t_start),
534                         ktime_ms_delta(t_jhd, t_jlck),
535                         ktime_ms_delta(t_tlck, t_jhd),
536                         ktime_ms_delta(t_rep, t_tlck));
537         }
538 
539         gfs2_recovery_done(sdp, jd->jd_jid, LM_RD_SUCCESS);
540 
541         if (jlocked) {
542                 gfs2_glock_dq_uninit(&ji_gh);
543                 gfs2_glock_dq_uninit(&j_gh);
544         }
545 
546         fs_info(sdp, "jid=%u: Done\n", jd->jd_jid);
547         goto done;
548 
549 fail_gunlock_thaw:
550         gfs2_glock_dq_uninit(&thaw_gh);
551 fail_gunlock_ji:
552         if (jlocked) {
553                 gfs2_glock_dq_uninit(&ji_gh);
554 fail_gunlock_j:
555                 gfs2_glock_dq_uninit(&j_gh);
556         }
557 
558         fs_info(sdp, "jid=%u: %s\n", jd->jd_jid, (error) ? "Failed" : "Done");
559 fail:
560         jd->jd_recover_error = error;
561         gfs2_recovery_done(sdp, jd->jd_jid, LM_RD_GAVEUP);
562 done:
563         clear_bit(JDF_RECOVERY, &jd->jd_flags);
564         smp_mb__after_atomic();
565         wake_up_bit(&jd->jd_flags, JDF_RECOVERY);
566 }
567 
568 int gfs2_recover_journal(struct gfs2_jdesc *jd, bool wait)
569 {
570         int rv;
571 
572         if (test_and_set_bit(JDF_RECOVERY, &jd->jd_flags))
573                 return -EBUSY;
574 
575         /* we have JDF_RECOVERY, queue should always succeed */
576         rv = queue_work(gfs_recovery_wq, &jd->jd_work);
577         BUG_ON(!rv);
578 
579         if (wait)
580                 wait_on_bit(&jd->jd_flags, JDF_RECOVERY,
581                             TASK_UNINTERRUPTIBLE);
582 
583         return wait ? jd->jd_recover_error : 0;
584 }
585 
586 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp