nilfs2: hide nilfs_mdt_clear calls in nilfs_mdt_destroy

[safe/jmp/linux-2.6] / fs / nilfs2 / recovery.c

diff --git a/fs/nilfs2/recovery.c b/fs/nilfs2/recovery.c
index a4253f3..bcd386d 100644 (file)
--- a/fs/nilfs2/recovery.c
+++ b/fs/nilfs2/recovery.c
@@ -28,7 +28,6 @@
 #include "segment.h"
 #include "sufile.h"
 #include "page.h"
-#include "seglist.h"
 #include "segbuf.h"
 
 /*
@@ -92,9 +91,6 @@ static int nilfs_warn_segment_error(int err)
                printk(KERN_WARNING
                       "NILFS warning: No super root in the last segment\n");
                break;
-       case NILFS_SEG_VALID:
-       default:
-               BUG();
        }
        return -EINVAL;
 }
@@ -398,6 +394,24 @@ static void dispose_recovery_list(struct list_head *head)
        }
 }
 
+struct nilfs_segment_entry {
+       struct list_head        list;
+       __u64                   segnum;
+};
+
+static int nilfs_segment_list_add(struct list_head *head, __u64 segnum)
+{
+       struct nilfs_segment_entry *ent = kmalloc(sizeof(*ent), GFP_NOFS);
+
+       if (unlikely(!ent))
+               return -ENOMEM;
+
+       ent->segnum = segnum;
+       INIT_LIST_HEAD(&ent->list);
+       list_add_tail(&ent->list, head);
+       return 0;
+}
+
 void nilfs_dispose_segment_list(struct list_head *head)
 {
        while (!list_empty(head)) {
@@ -405,18 +419,18 @@ void nilfs_dispose_segment_list(struct list_head *head)
                        = list_entry(head->next,
                                     struct nilfs_segment_entry, list);
                list_del(&ent->list);
-               nilfs_free_segment_entry(ent);
+               kfree(ent);
        }
 }
 
 static int nilfs_prepare_segment_for_recovery(struct the_nilfs *nilfs,
+                                             struct nilfs_sb_info *sbi,
                                              struct nilfs_recovery_info *ri)
 {
        struct list_head *head = &ri->ri_used_segments;
        struct nilfs_segment_entry *ent, *n;
        struct inode *sufile = nilfs->ns_sufile;
        __u64 segnum[4];
-       time_t mtime;
        int err;
        int i;
 
@@ -425,6 +439,7 @@ static int nilfs_prepare_segment_for_recovery(struct the_nilfs *nilfs,
        segnum[2] = ri->ri_segnum;
        segnum[3] = ri->ri_nextnum;
 
+       nilfs_attach_writer(nilfs, sbi);
        /*
         * Releasing the next segment of the latest super root.
         * The next segment is invalidated by this recovery.
@@ -433,49 +448,26 @@ static int nilfs_prepare_segment_for_recovery(struct the_nilfs *nilfs,
        if (unlikely(err))
                goto failed;
 
-       err = -ENOMEM;
        for (i = 1; i < 4; i++) {
-               ent = nilfs_alloc_segment_entry(segnum[i]);
-               if (unlikely(!ent))
+               err = nilfs_segment_list_add(head, segnum[i]);
+               if (unlikely(err))
                        goto failed;
-               list_add_tail(&ent->list, head);
        }
 
        /*
         * Collecting segments written after the latest super root.
         * These are marked dirty to avoid being reallocated in the next write.
         */
-       mtime = get_seconds();
        list_for_each_entry_safe(ent, n, head, list) {
-               if (ent->segnum == segnum[0]) {
-                       list_del(&ent->list);
-                       nilfs_free_segment_entry(ent);
-                       continue;
-               }
-               err = nilfs_open_segment_entry(ent, sufile);
-               if (unlikely(err))
-                       goto failed;
-               if (!nilfs_segment_usage_dirty(ent->raw_su)) {
-                       /* make the segment garbage */
-                       ent->raw_su->su_nblocks = cpu_to_le32(0);
-                       ent->raw_su->su_lastmod = cpu_to_le32(mtime);
-                       nilfs_segment_usage_set_dirty(ent->raw_su);
+               if (ent->segnum != segnum[0]) {
+                       err = nilfs_sufile_scrap(sufile, ent->segnum);
+                       if (unlikely(err))
+                               goto failed;
                }
                list_del(&ent->list);
-               nilfs_close_segment_entry(ent, sufile);
-               nilfs_free_segment_entry(ent);
+               kfree(ent);
        }
 
-       /*
-        * The segment having the latest super root is active, and
-        * should be deactivated on the next construction for recovery.
-        */
-       err = -ENOMEM;
-       ent = nilfs_alloc_segment_entry(segnum[0]);
-       if (unlikely(!ent))
-               goto failed;
-       list_add_tail(&ent->list, &ri->ri_used_segments);
-
        /* Allocate new segments for recovery */
        err = nilfs_sufile_alloc(sufile, &segnum[0]);
        if (unlikely(err))
@@ -484,10 +476,10 @@ static int nilfs_prepare_segment_for_recovery(struct the_nilfs *nilfs,
        nilfs->ns_pseg_offset = 0;
        nilfs->ns_seg_seq = ri->ri_seq + 2;
        nilfs->ns_nextnum = nilfs->ns_segnum = segnum[0];
-       return 0;
 
  failed:
        /* No need to recover sufile because it will be destroyed on error */
+       nilfs_detach_writer(nilfs, sbi);
        return err;
 }
 
@@ -560,7 +552,8 @@ static int recover_dsync_blocks(struct nilfs_sb_info *sbi,
                printk(KERN_WARNING
                       "NILFS warning: error recovering data block "
                       "(err=%d, ino=%lu, block-offset=%llu)\n",
-                      err, rb->ino, (unsigned long long)rb->blkoff);
+                      err, (unsigned long)rb->ino,
+                      (unsigned long long)rb->blkoff);
                if (!err2)
                        err2 = err;
  next:
@@ -753,14 +746,14 @@ int nilfs_recover_logical_segments(struct the_nilfs *nilfs,
                goto failed;
 
        if (ri->ri_need_recovery == NILFS_RECOVERY_ROLLFORWARD_DONE) {
-               err = nilfs_prepare_segment_for_recovery(nilfs, ri);
+               err = nilfs_prepare_segment_for_recovery(nilfs, sbi, ri);
                if (unlikely(err)) {
                        printk(KERN_ERR "NILFS: Error preparing segments for "
                               "recovery.\n");
                        goto failed;
                }
 
-               err = nilfs_attach_segment_constructor(sbi, ri);
+               err = nilfs_attach_segment_constructor(sbi);
                if (unlikely(err))
                        goto failed;
 
@@ -777,14 +770,8 @@ int nilfs_recover_logical_segments(struct the_nilfs *nilfs,
                nilfs_finish_roll_forward(nilfs, sbi, ri);
        }
 
-       nilfs_detach_checkpoint(sbi);
-       return 0;
-
  failed:
        nilfs_detach_checkpoint(sbi);
-       nilfs_mdt_clear(nilfs->ns_cpfile);
-       nilfs_mdt_clear(nilfs->ns_sufile);
-       nilfs_mdt_clear(nilfs->ns_dat);
        return err;
 }
 
@@ -814,7 +801,6 @@ int nilfs_search_super_root(struct the_nilfs *nilfs, struct nilfs_sb_info *sbi,
        u64 seg_seq;
        __u64 segnum, nextnum = 0;
        __u64 cno;
-       struct nilfs_segment_entry *ent;
        LIST_HEAD(segments);
        int empty_seg = 0, scan_newer = 0;
        int ret;
@@ -883,7 +869,6 @@ int nilfs_search_super_root(struct the_nilfs *nilfs, struct nilfs_sb_info *sbi,
                if (scan_newer)
                        ri->ri_need_recovery = NILFS_RECOVERY_SR_UPDATED;
                else {
-                       nilfs->ns_prot_seq = ssi.seg_seq;
                        if (nilfs->ns_mount_state & NILFS_VALID_FS)
                                goto super_root_found;
                        scan_newer = 1;
@@ -916,12 +901,9 @@ int nilfs_search_super_root(struct the_nilfs *nilfs, struct nilfs_sb_info *sbi,
                if (empty_seg++)
                        goto super_root_found; /* found a valid super root */
 
-               ent = nilfs_alloc_segment_entry(segnum);
-               if (unlikely(!ent)) {
-                       ret = -ENOMEM;
+               ret = nilfs_segment_list_add(&segments, segnum);
+               if (unlikely(ret))
                        goto failed;
-               }
-               list_add_tail(&ent->list, &segments);
 
                seg_seq++;
                segnum = nextnum;