* [f2fs-dev] [PATCH v3] fsck.f2fs: write checkpoint with OPU mode
@ 2019-07-17 1:28 Chao Yu
2019-08-05 9:51 ` Chao Yu
0 siblings, 1 reply; 4+ messages in thread
From: Chao Yu @ 2019-07-17 1:28 UTC (permalink / raw)
To: jaegeuk; +Cc: linux-f2fs-devel
This original patch was from Weichao Guo.
We may encounter both checkpoints invalid in such a case:
1. kernel writes CP A;
2. power-cut when kernel writes CP B, then CP B is corrupted;
3. fsck: load CP A, fix meta/data;
4. power-cut when fsck writes CP A in-place, then CP A is corrupted too;
To avoid both checkpoints being invalid, this patch changes to duplicate
valid checkpoint to mirror position first, and then, write fixed checkpoint
to CP #0 position.
This can make sure that, while fsck repairing, even there is sudden
power-cut, last valid checkpoint can be kept in CP #1 position.
Signed-off-by: Weichao Guo <guoweichao@huawei.com>
Signed-off-by: Chao Yu <yuchao0@huawei.com>
---
v3:
- fix wrong size of duplication.
fsck/f2fs.h | 2 ++
fsck/fsck.c | 15 +++++++++++++--
fsck/fsck.h | 2 ++
fsck/mount.c | 53 +++++++++++++++++++++++++++++++++++++++++++++++++++-
4 files changed, 69 insertions(+), 3 deletions(-)
diff --git a/fsck/f2fs.h b/fsck/f2fs.h
index 4dc6698..52e68ec 100644
--- a/fsck/f2fs.h
+++ b/fsck/f2fs.h
@@ -195,6 +195,8 @@ struct f2fs_sb_info {
unsigned int cur_victim_sec; /* current victim section num */
u32 free_segments;
+
+ int cp_backuped; /* backup valid checkpoint */
};
static inline struct f2fs_super_block *F2FS_RAW_SUPER(struct f2fs_sb_info *sbi)
diff --git a/fsck/fsck.c b/fsck/fsck.c
index 8953ca1..49363d3 100644
--- a/fsck/fsck.c
+++ b/fsck/fsck.c
@@ -2127,6 +2127,16 @@ static void fix_checkpoint(struct f2fs_sb_info *sbi)
ASSERT(ret >= 0);
}
+static void fix_checkpoints(struct f2fs_sb_info *sbi)
+{
+ /* copy valid checkpoint to its mirror position */
+ duplicate_checkpoint(sbi);
+
+ /* repair checkpoint at CP #0 position */
+ sbi->cur_cp = 1;
+ fix_checkpoint(sbi);
+}
+
int check_curseg_offset(struct f2fs_sb_info *sbi, int type)
{
struct curseg_info *curseg = CURSEG_I(sbi, type);
@@ -2765,6 +2775,7 @@ int fsck_verify(struct f2fs_sb_info *sbi)
}
}
#endif
+
/* fix global metadata */
if (force || (c.fix_on && f2fs_dev_is_writable())) {
struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
@@ -2777,10 +2788,10 @@ int fsck_verify(struct f2fs_sb_info *sbi)
rewrite_sit_area_bitmap(sbi);
fix_curseg_info(sbi);
fix_checksum(sbi);
- fix_checkpoint(sbi);
+ fix_checkpoints(sbi);
} else if (is_set_ckpt_flags(cp, CP_FSCK_FLAG) ||
is_set_ckpt_flags(cp, CP_QUOTA_NEED_FSCK_FLAG)) {
- write_checkpoint(sbi);
+ write_checkpoints(sbi);
}
}
return ret;
diff --git a/fsck/fsck.h b/fsck/fsck.h
index d38e8de..3699b35 100644
--- a/fsck/fsck.h
+++ b/fsck/fsck.h
@@ -191,7 +191,9 @@ extern void flush_sit_entries(struct f2fs_sb_info *);
extern void move_curseg_info(struct f2fs_sb_info *, u64, int);
extern void write_curseg_info(struct f2fs_sb_info *);
extern int find_next_free_block(struct f2fs_sb_info *, u64 *, int, int);
+extern void duplicate_checkpoint(struct f2fs_sb_info *);
extern void write_checkpoint(struct f2fs_sb_info *);
+extern void write_checkpoints(struct f2fs_sb_info *);
extern void update_superblock(struct f2fs_super_block *, int);
extern void update_data_blkaddr(struct f2fs_sb_info *, nid_t, u16, block_t);
extern void update_nat_blkaddr(struct f2fs_sb_info *, nid_t, nid_t, block_t);
diff --git a/fsck/mount.c b/fsck/mount.c
index 60e0e4a..973c82f 100644
--- a/fsck/mount.c
+++ b/fsck/mount.c
@@ -2229,7 +2229,7 @@ void flush_journal_entries(struct f2fs_sb_info *sbi)
int n_sits = flush_sit_journal_entries(sbi);
if (n_nats || n_sits)
- write_checkpoint(sbi);
+ write_checkpoints(sbi);
}
void flush_sit_entries(struct f2fs_sb_info *sbi)
@@ -2478,6 +2478,47 @@ void nullify_nat_entry(struct f2fs_sb_info *sbi, u32 nid)
free(nat_block);
}
+void duplicate_checkpoint(struct f2fs_sb_info *sbi)
+{
+ struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
+ unsigned long long dst, src;
+ void *buf;
+ unsigned int seg_size = 1 << get_sb(log_blocks_per_seg);
+ int ret;
+
+ if (sbi->cp_backuped)
+ return;
+
+ buf = malloc(F2FS_BLKSIZE * seg_size);
+ ASSERT(buf);
+
+ if (sbi->cur_cp == 1) {
+ src = get_sb(cp_blkaddr);
+ dst = src + seg_size;
+ } else {
+ dst = get_sb(cp_blkaddr);
+ src = dst + seg_size;
+ }
+
+ ret = dev_read(buf, src << F2FS_BLKSIZE_BITS,
+ seg_size << F2FS_BLKSIZE_BITS);
+ ASSERT(ret >= 0);
+
+ ret = dev_write(buf, dst << F2FS_BLKSIZE_BITS,
+ seg_size << F2FS_BLKSIZE_BITS);
+ ASSERT(ret >= 0);
+
+ free(buf);
+
+ ret = f2fs_fsync_device();
+ ASSERT(ret >= 0);
+
+ sbi->cp_backuped = 1;
+
+ MSG(0, "Info: Duplicate valid checkpoint to mirror position "
+ "%llu -> %llu\n", src, dst);
+}
+
void write_checkpoint(struct f2fs_sb_info *sbi)
{
struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
@@ -2557,6 +2598,16 @@ void write_checkpoint(struct f2fs_sb_info *sbi)
ASSERT(ret >= 0);
}
+void write_checkpoints(struct f2fs_sb_info *sbi)
+{
+ /* copy valid checkpoint to its mirror position */
+ duplicate_checkpoint(sbi);
+
+ /* repair checkpoint at CP #0 position */
+ sbi->cur_cp = 1;
+ write_checkpoint(sbi);
+}
+
void build_nat_area_bitmap(struct f2fs_sb_info *sbi)
{
struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_HOT_DATA);
--
2.18.0.rc1
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply related [flat|nested] 4+ messages in thread* Re: [f2fs-dev] [PATCH v3] fsck.f2fs: write checkpoint with OPU mode
2019-07-17 1:28 [f2fs-dev] [PATCH v3] fsck.f2fs: write checkpoint with OPU mode Chao Yu
@ 2019-08-05 9:51 ` Chao Yu
2019-08-06 0:48 ` Jaegeuk Kim
0 siblings, 1 reply; 4+ messages in thread
From: Chao Yu @ 2019-08-05 9:51 UTC (permalink / raw)
To: jaegeuk; +Cc: linux-f2fs-devel
Jaegeuk,
Any test updates on this patch?
Could you update dev/dev-test branch of tools repo, so that I can rebase on them.
On 2019/7/17 9:28, Chao Yu wrote:
> This original patch was from Weichao Guo.
>
> We may encounter both checkpoints invalid in such a case:
> 1. kernel writes CP A;
> 2. power-cut when kernel writes CP B, then CP B is corrupted;
> 3. fsck: load CP A, fix meta/data;
> 4. power-cut when fsck writes CP A in-place, then CP A is corrupted too;
>
> To avoid both checkpoints being invalid, this patch changes to duplicate
> valid checkpoint to mirror position first, and then, write fixed checkpoint
> to CP #0 position.
>
> This can make sure that, while fsck repairing, even there is sudden
> power-cut, last valid checkpoint can be kept in CP #1 position.
>
> Signed-off-by: Weichao Guo <guoweichao@huawei.com>
> Signed-off-by: Chao Yu <yuchao0@huawei.com>
> ---
> v3:
> - fix wrong size of duplication.
> fsck/f2fs.h | 2 ++
> fsck/fsck.c | 15 +++++++++++++--
> fsck/fsck.h | 2 ++
> fsck/mount.c | 53 +++++++++++++++++++++++++++++++++++++++++++++++++++-
> 4 files changed, 69 insertions(+), 3 deletions(-)
>
> diff --git a/fsck/f2fs.h b/fsck/f2fs.h
> index 4dc6698..52e68ec 100644
> --- a/fsck/f2fs.h
> +++ b/fsck/f2fs.h
> @@ -195,6 +195,8 @@ struct f2fs_sb_info {
>
> unsigned int cur_victim_sec; /* current victim section num */
> u32 free_segments;
> +
> + int cp_backuped; /* backup valid checkpoint */
> };
>
> static inline struct f2fs_super_block *F2FS_RAW_SUPER(struct f2fs_sb_info *sbi)
> diff --git a/fsck/fsck.c b/fsck/fsck.c
> index 8953ca1..49363d3 100644
> --- a/fsck/fsck.c
> +++ b/fsck/fsck.c
> @@ -2127,6 +2127,16 @@ static void fix_checkpoint(struct f2fs_sb_info *sbi)
> ASSERT(ret >= 0);
> }
>
> +static void fix_checkpoints(struct f2fs_sb_info *sbi)
> +{
> + /* copy valid checkpoint to its mirror position */
> + duplicate_checkpoint(sbi);
> +
> + /* repair checkpoint at CP #0 position */
> + sbi->cur_cp = 1;
> + fix_checkpoint(sbi);
> +}
> +
> int check_curseg_offset(struct f2fs_sb_info *sbi, int type)
> {
> struct curseg_info *curseg = CURSEG_I(sbi, type);
> @@ -2765,6 +2775,7 @@ int fsck_verify(struct f2fs_sb_info *sbi)
> }
> }
> #endif
> +
> /* fix global metadata */
> if (force || (c.fix_on && f2fs_dev_is_writable())) {
> struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
> @@ -2777,10 +2788,10 @@ int fsck_verify(struct f2fs_sb_info *sbi)
> rewrite_sit_area_bitmap(sbi);
> fix_curseg_info(sbi);
> fix_checksum(sbi);
> - fix_checkpoint(sbi);
> + fix_checkpoints(sbi);
> } else if (is_set_ckpt_flags(cp, CP_FSCK_FLAG) ||
> is_set_ckpt_flags(cp, CP_QUOTA_NEED_FSCK_FLAG)) {
> - write_checkpoint(sbi);
> + write_checkpoints(sbi);
> }
> }
> return ret;
> diff --git a/fsck/fsck.h b/fsck/fsck.h
> index d38e8de..3699b35 100644
> --- a/fsck/fsck.h
> +++ b/fsck/fsck.h
> @@ -191,7 +191,9 @@ extern void flush_sit_entries(struct f2fs_sb_info *);
> extern void move_curseg_info(struct f2fs_sb_info *, u64, int);
> extern void write_curseg_info(struct f2fs_sb_info *);
> extern int find_next_free_block(struct f2fs_sb_info *, u64 *, int, int);
> +extern void duplicate_checkpoint(struct f2fs_sb_info *);
> extern void write_checkpoint(struct f2fs_sb_info *);
> +extern void write_checkpoints(struct f2fs_sb_info *);
> extern void update_superblock(struct f2fs_super_block *, int);
> extern void update_data_blkaddr(struct f2fs_sb_info *, nid_t, u16, block_t);
> extern void update_nat_blkaddr(struct f2fs_sb_info *, nid_t, nid_t, block_t);
> diff --git a/fsck/mount.c b/fsck/mount.c
> index 60e0e4a..973c82f 100644
> --- a/fsck/mount.c
> +++ b/fsck/mount.c
> @@ -2229,7 +2229,7 @@ void flush_journal_entries(struct f2fs_sb_info *sbi)
> int n_sits = flush_sit_journal_entries(sbi);
>
> if (n_nats || n_sits)
> - write_checkpoint(sbi);
> + write_checkpoints(sbi);
> }
>
> void flush_sit_entries(struct f2fs_sb_info *sbi)
> @@ -2478,6 +2478,47 @@ void nullify_nat_entry(struct f2fs_sb_info *sbi, u32 nid)
> free(nat_block);
> }
>
> +void duplicate_checkpoint(struct f2fs_sb_info *sbi)
> +{
> + struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
> + unsigned long long dst, src;
> + void *buf;
> + unsigned int seg_size = 1 << get_sb(log_blocks_per_seg);
> + int ret;
> +
> + if (sbi->cp_backuped)
> + return;
> +
> + buf = malloc(F2FS_BLKSIZE * seg_size);
> + ASSERT(buf);
> +
> + if (sbi->cur_cp == 1) {
> + src = get_sb(cp_blkaddr);
> + dst = src + seg_size;
> + } else {
> + dst = get_sb(cp_blkaddr);
> + src = dst + seg_size;
> + }
> +
> + ret = dev_read(buf, src << F2FS_BLKSIZE_BITS,
> + seg_size << F2FS_BLKSIZE_BITS);
> + ASSERT(ret >= 0);
> +
> + ret = dev_write(buf, dst << F2FS_BLKSIZE_BITS,
> + seg_size << F2FS_BLKSIZE_BITS);
> + ASSERT(ret >= 0);
> +
> + free(buf);
> +
> + ret = f2fs_fsync_device();
> + ASSERT(ret >= 0);
> +
> + sbi->cp_backuped = 1;
> +
> + MSG(0, "Info: Duplicate valid checkpoint to mirror position "
> + "%llu -> %llu\n", src, dst);
> +}
> +
> void write_checkpoint(struct f2fs_sb_info *sbi)
> {
> struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
> @@ -2557,6 +2598,16 @@ void write_checkpoint(struct f2fs_sb_info *sbi)
> ASSERT(ret >= 0);
> }
>
> +void write_checkpoints(struct f2fs_sb_info *sbi)
> +{
> + /* copy valid checkpoint to its mirror position */
> + duplicate_checkpoint(sbi);
> +
> + /* repair checkpoint at CP #0 position */
> + sbi->cur_cp = 1;
> + write_checkpoint(sbi);
> +}
> +
> void build_nat_area_bitmap(struct f2fs_sb_info *sbi)
> {
> struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_HOT_DATA);
>
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply [flat|nested] 4+ messages in thread* Re: [f2fs-dev] [PATCH v3] fsck.f2fs: write checkpoint with OPU mode
2019-08-05 9:51 ` Chao Yu
@ 2019-08-06 0:48 ` Jaegeuk Kim
2019-08-06 1:43 ` Chao Yu
0 siblings, 1 reply; 4+ messages in thread
From: Jaegeuk Kim @ 2019-08-06 0:48 UTC (permalink / raw)
To: Chao Yu; +Cc: linux-f2fs-devel
On 08/05, Chao Yu wrote:
> Jaegeuk,
>
> Any test updates on this patch?
>
> Could you update dev/dev-test branch of tools repo, so that I can rebase on them.
>
I think this seems fine to go. Let me update as soon as possible.
> On 2019/7/17 9:28, Chao Yu wrote:
> > This original patch was from Weichao Guo.
> >
> > We may encounter both checkpoints invalid in such a case:
> > 1. kernel writes CP A;
> > 2. power-cut when kernel writes CP B, then CP B is corrupted;
> > 3. fsck: load CP A, fix meta/data;
> > 4. power-cut when fsck writes CP A in-place, then CP A is corrupted too;
> >
> > To avoid both checkpoints being invalid, this patch changes to duplicate
> > valid checkpoint to mirror position first, and then, write fixed checkpoint
> > to CP #0 position.
> >
> > This can make sure that, while fsck repairing, even there is sudden
> > power-cut, last valid checkpoint can be kept in CP #1 position.
> >
> > Signed-off-by: Weichao Guo <guoweichao@huawei.com>
> > Signed-off-by: Chao Yu <yuchao0@huawei.com>
> > ---
> > v3:
> > - fix wrong size of duplication.
> > fsck/f2fs.h | 2 ++
> > fsck/fsck.c | 15 +++++++++++++--
> > fsck/fsck.h | 2 ++
> > fsck/mount.c | 53 +++++++++++++++++++++++++++++++++++++++++++++++++++-
> > 4 files changed, 69 insertions(+), 3 deletions(-)
> >
> > diff --git a/fsck/f2fs.h b/fsck/f2fs.h
> > index 4dc6698..52e68ec 100644
> > --- a/fsck/f2fs.h
> > +++ b/fsck/f2fs.h
> > @@ -195,6 +195,8 @@ struct f2fs_sb_info {
> >
> > unsigned int cur_victim_sec; /* current victim section num */
> > u32 free_segments;
> > +
> > + int cp_backuped; /* backup valid checkpoint */
> > };
> >
> > static inline struct f2fs_super_block *F2FS_RAW_SUPER(struct f2fs_sb_info *sbi)
> > diff --git a/fsck/fsck.c b/fsck/fsck.c
> > index 8953ca1..49363d3 100644
> > --- a/fsck/fsck.c
> > +++ b/fsck/fsck.c
> > @@ -2127,6 +2127,16 @@ static void fix_checkpoint(struct f2fs_sb_info *sbi)
> > ASSERT(ret >= 0);
> > }
> >
> > +static void fix_checkpoints(struct f2fs_sb_info *sbi)
> > +{
> > + /* copy valid checkpoint to its mirror position */
> > + duplicate_checkpoint(sbi);
> > +
> > + /* repair checkpoint at CP #0 position */
> > + sbi->cur_cp = 1;
> > + fix_checkpoint(sbi);
> > +}
> > +
> > int check_curseg_offset(struct f2fs_sb_info *sbi, int type)
> > {
> > struct curseg_info *curseg = CURSEG_I(sbi, type);
> > @@ -2765,6 +2775,7 @@ int fsck_verify(struct f2fs_sb_info *sbi)
> > }
> > }
> > #endif
> > +
> > /* fix global metadata */
> > if (force || (c.fix_on && f2fs_dev_is_writable())) {
> > struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
> > @@ -2777,10 +2788,10 @@ int fsck_verify(struct f2fs_sb_info *sbi)
> > rewrite_sit_area_bitmap(sbi);
> > fix_curseg_info(sbi);
> > fix_checksum(sbi);
> > - fix_checkpoint(sbi);
> > + fix_checkpoints(sbi);
> > } else if (is_set_ckpt_flags(cp, CP_FSCK_FLAG) ||
> > is_set_ckpt_flags(cp, CP_QUOTA_NEED_FSCK_FLAG)) {
> > - write_checkpoint(sbi);
> > + write_checkpoints(sbi);
> > }
> > }
> > return ret;
> > diff --git a/fsck/fsck.h b/fsck/fsck.h
> > index d38e8de..3699b35 100644
> > --- a/fsck/fsck.h
> > +++ b/fsck/fsck.h
> > @@ -191,7 +191,9 @@ extern void flush_sit_entries(struct f2fs_sb_info *);
> > extern void move_curseg_info(struct f2fs_sb_info *, u64, int);
> > extern void write_curseg_info(struct f2fs_sb_info *);
> > extern int find_next_free_block(struct f2fs_sb_info *, u64 *, int, int);
> > +extern void duplicate_checkpoint(struct f2fs_sb_info *);
> > extern void write_checkpoint(struct f2fs_sb_info *);
> > +extern void write_checkpoints(struct f2fs_sb_info *);
> > extern void update_superblock(struct f2fs_super_block *, int);
> > extern void update_data_blkaddr(struct f2fs_sb_info *, nid_t, u16, block_t);
> > extern void update_nat_blkaddr(struct f2fs_sb_info *, nid_t, nid_t, block_t);
> > diff --git a/fsck/mount.c b/fsck/mount.c
> > index 60e0e4a..973c82f 100644
> > --- a/fsck/mount.c
> > +++ b/fsck/mount.c
> > @@ -2229,7 +2229,7 @@ void flush_journal_entries(struct f2fs_sb_info *sbi)
> > int n_sits = flush_sit_journal_entries(sbi);
> >
> > if (n_nats || n_sits)
> > - write_checkpoint(sbi);
> > + write_checkpoints(sbi);
> > }
> >
> > void flush_sit_entries(struct f2fs_sb_info *sbi)
> > @@ -2478,6 +2478,47 @@ void nullify_nat_entry(struct f2fs_sb_info *sbi, u32 nid)
> > free(nat_block);
> > }
> >
> > +void duplicate_checkpoint(struct f2fs_sb_info *sbi)
> > +{
> > + struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
> > + unsigned long long dst, src;
> > + void *buf;
> > + unsigned int seg_size = 1 << get_sb(log_blocks_per_seg);
> > + int ret;
> > +
> > + if (sbi->cp_backuped)
> > + return;
> > +
> > + buf = malloc(F2FS_BLKSIZE * seg_size);
> > + ASSERT(buf);
> > +
> > + if (sbi->cur_cp == 1) {
> > + src = get_sb(cp_blkaddr);
> > + dst = src + seg_size;
> > + } else {
> > + dst = get_sb(cp_blkaddr);
> > + src = dst + seg_size;
> > + }
> > +
> > + ret = dev_read(buf, src << F2FS_BLKSIZE_BITS,
> > + seg_size << F2FS_BLKSIZE_BITS);
> > + ASSERT(ret >= 0);
> > +
> > + ret = dev_write(buf, dst << F2FS_BLKSIZE_BITS,
> > + seg_size << F2FS_BLKSIZE_BITS);
> > + ASSERT(ret >= 0);
> > +
> > + free(buf);
> > +
> > + ret = f2fs_fsync_device();
> > + ASSERT(ret >= 0);
> > +
> > + sbi->cp_backuped = 1;
> > +
> > + MSG(0, "Info: Duplicate valid checkpoint to mirror position "
> > + "%llu -> %llu\n", src, dst);
> > +}
> > +
> > void write_checkpoint(struct f2fs_sb_info *sbi)
> > {
> > struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
> > @@ -2557,6 +2598,16 @@ void write_checkpoint(struct f2fs_sb_info *sbi)
> > ASSERT(ret >= 0);
> > }
> >
> > +void write_checkpoints(struct f2fs_sb_info *sbi)
> > +{
> > + /* copy valid checkpoint to its mirror position */
> > + duplicate_checkpoint(sbi);
> > +
> > + /* repair checkpoint at CP #0 position */
> > + sbi->cur_cp = 1;
> > + write_checkpoint(sbi);
> > +}
> > +
> > void build_nat_area_bitmap(struct f2fs_sb_info *sbi)
> > {
> > struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_HOT_DATA);
> >
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply [flat|nested] 4+ messages in thread* Re: [f2fs-dev] [PATCH v3] fsck.f2fs: write checkpoint with OPU mode
2019-08-06 0:48 ` Jaegeuk Kim
@ 2019-08-06 1:43 ` Chao Yu
0 siblings, 0 replies; 4+ messages in thread
From: Chao Yu @ 2019-08-06 1:43 UTC (permalink / raw)
To: Jaegeuk Kim; +Cc: linux-f2fs-devel
On 2019/8/6 8:48, Jaegeuk Kim wrote:
> On 08/05, Chao Yu wrote:
>> Jaegeuk,
>>
>> Any test updates on this patch?
>>
>> Could you update dev/dev-test branch of tools repo, so that I can rebase on them.
>>
>
> I think this seems fine to go. Let me update as soon as possible.
Cool, thanks!
Thanks,
>
>> On 2019/7/17 9:28, Chao Yu wrote:
>>> This original patch was from Weichao Guo.
>>>
>>> We may encounter both checkpoints invalid in such a case:
>>> 1. kernel writes CP A;
>>> 2. power-cut when kernel writes CP B, then CP B is corrupted;
>>> 3. fsck: load CP A, fix meta/data;
>>> 4. power-cut when fsck writes CP A in-place, then CP A is corrupted too;
>>>
>>> To avoid both checkpoints being invalid, this patch changes to duplicate
>>> valid checkpoint to mirror position first, and then, write fixed checkpoint
>>> to CP #0 position.
>>>
>>> This can make sure that, while fsck repairing, even there is sudden
>>> power-cut, last valid checkpoint can be kept in CP #1 position.
>>>
>>> Signed-off-by: Weichao Guo <guoweichao@huawei.com>
>>> Signed-off-by: Chao Yu <yuchao0@huawei.com>
>>> ---
>>> v3:
>>> - fix wrong size of duplication.
>>> fsck/f2fs.h | 2 ++
>>> fsck/fsck.c | 15 +++++++++++++--
>>> fsck/fsck.h | 2 ++
>>> fsck/mount.c | 53 +++++++++++++++++++++++++++++++++++++++++++++++++++-
>>> 4 files changed, 69 insertions(+), 3 deletions(-)
>>>
>>> diff --git a/fsck/f2fs.h b/fsck/f2fs.h
>>> index 4dc6698..52e68ec 100644
>>> --- a/fsck/f2fs.h
>>> +++ b/fsck/f2fs.h
>>> @@ -195,6 +195,8 @@ struct f2fs_sb_info {
>>>
>>> unsigned int cur_victim_sec; /* current victim section num */
>>> u32 free_segments;
>>> +
>>> + int cp_backuped; /* backup valid checkpoint */
>>> };
>>>
>>> static inline struct f2fs_super_block *F2FS_RAW_SUPER(struct f2fs_sb_info *sbi)
>>> diff --git a/fsck/fsck.c b/fsck/fsck.c
>>> index 8953ca1..49363d3 100644
>>> --- a/fsck/fsck.c
>>> +++ b/fsck/fsck.c
>>> @@ -2127,6 +2127,16 @@ static void fix_checkpoint(struct f2fs_sb_info *sbi)
>>> ASSERT(ret >= 0);
>>> }
>>>
>>> +static void fix_checkpoints(struct f2fs_sb_info *sbi)
>>> +{
>>> + /* copy valid checkpoint to its mirror position */
>>> + duplicate_checkpoint(sbi);
>>> +
>>> + /* repair checkpoint at CP #0 position */
>>> + sbi->cur_cp = 1;
>>> + fix_checkpoint(sbi);
>>> +}
>>> +
>>> int check_curseg_offset(struct f2fs_sb_info *sbi, int type)
>>> {
>>> struct curseg_info *curseg = CURSEG_I(sbi, type);
>>> @@ -2765,6 +2775,7 @@ int fsck_verify(struct f2fs_sb_info *sbi)
>>> }
>>> }
>>> #endif
>>> +
>>> /* fix global metadata */
>>> if (force || (c.fix_on && f2fs_dev_is_writable())) {
>>> struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
>>> @@ -2777,10 +2788,10 @@ int fsck_verify(struct f2fs_sb_info *sbi)
>>> rewrite_sit_area_bitmap(sbi);
>>> fix_curseg_info(sbi);
>>> fix_checksum(sbi);
>>> - fix_checkpoint(sbi);
>>> + fix_checkpoints(sbi);
>>> } else if (is_set_ckpt_flags(cp, CP_FSCK_FLAG) ||
>>> is_set_ckpt_flags(cp, CP_QUOTA_NEED_FSCK_FLAG)) {
>>> - write_checkpoint(sbi);
>>> + write_checkpoints(sbi);
>>> }
>>> }
>>> return ret;
>>> diff --git a/fsck/fsck.h b/fsck/fsck.h
>>> index d38e8de..3699b35 100644
>>> --- a/fsck/fsck.h
>>> +++ b/fsck/fsck.h
>>> @@ -191,7 +191,9 @@ extern void flush_sit_entries(struct f2fs_sb_info *);
>>> extern void move_curseg_info(struct f2fs_sb_info *, u64, int);
>>> extern void write_curseg_info(struct f2fs_sb_info *);
>>> extern int find_next_free_block(struct f2fs_sb_info *, u64 *, int, int);
>>> +extern void duplicate_checkpoint(struct f2fs_sb_info *);
>>> extern void write_checkpoint(struct f2fs_sb_info *);
>>> +extern void write_checkpoints(struct f2fs_sb_info *);
>>> extern void update_superblock(struct f2fs_super_block *, int);
>>> extern void update_data_blkaddr(struct f2fs_sb_info *, nid_t, u16, block_t);
>>> extern void update_nat_blkaddr(struct f2fs_sb_info *, nid_t, nid_t, block_t);
>>> diff --git a/fsck/mount.c b/fsck/mount.c
>>> index 60e0e4a..973c82f 100644
>>> --- a/fsck/mount.c
>>> +++ b/fsck/mount.c
>>> @@ -2229,7 +2229,7 @@ void flush_journal_entries(struct f2fs_sb_info *sbi)
>>> int n_sits = flush_sit_journal_entries(sbi);
>>>
>>> if (n_nats || n_sits)
>>> - write_checkpoint(sbi);
>>> + write_checkpoints(sbi);
>>> }
>>>
>>> void flush_sit_entries(struct f2fs_sb_info *sbi)
>>> @@ -2478,6 +2478,47 @@ void nullify_nat_entry(struct f2fs_sb_info *sbi, u32 nid)
>>> free(nat_block);
>>> }
>>>
>>> +void duplicate_checkpoint(struct f2fs_sb_info *sbi)
>>> +{
>>> + struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
>>> + unsigned long long dst, src;
>>> + void *buf;
>>> + unsigned int seg_size = 1 << get_sb(log_blocks_per_seg);
>>> + int ret;
>>> +
>>> + if (sbi->cp_backuped)
>>> + return;
>>> +
>>> + buf = malloc(F2FS_BLKSIZE * seg_size);
>>> + ASSERT(buf);
>>> +
>>> + if (sbi->cur_cp == 1) {
>>> + src = get_sb(cp_blkaddr);
>>> + dst = src + seg_size;
>>> + } else {
>>> + dst = get_sb(cp_blkaddr);
>>> + src = dst + seg_size;
>>> + }
>>> +
>>> + ret = dev_read(buf, src << F2FS_BLKSIZE_BITS,
>>> + seg_size << F2FS_BLKSIZE_BITS);
>>> + ASSERT(ret >= 0);
>>> +
>>> + ret = dev_write(buf, dst << F2FS_BLKSIZE_BITS,
>>> + seg_size << F2FS_BLKSIZE_BITS);
>>> + ASSERT(ret >= 0);
>>> +
>>> + free(buf);
>>> +
>>> + ret = f2fs_fsync_device();
>>> + ASSERT(ret >= 0);
>>> +
>>> + sbi->cp_backuped = 1;
>>> +
>>> + MSG(0, "Info: Duplicate valid checkpoint to mirror position "
>>> + "%llu -> %llu\n", src, dst);
>>> +}
>>> +
>>> void write_checkpoint(struct f2fs_sb_info *sbi)
>>> {
>>> struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
>>> @@ -2557,6 +2598,16 @@ void write_checkpoint(struct f2fs_sb_info *sbi)
>>> ASSERT(ret >= 0);
>>> }
>>>
>>> +void write_checkpoints(struct f2fs_sb_info *sbi)
>>> +{
>>> + /* copy valid checkpoint to its mirror position */
>>> + duplicate_checkpoint(sbi);
>>> +
>>> + /* repair checkpoint at CP #0 position */
>>> + sbi->cur_cp = 1;
>>> + write_checkpoint(sbi);
>>> +}
>>> +
>>> void build_nat_area_bitmap(struct f2fs_sb_info *sbi)
>>> {
>>> struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_HOT_DATA);
>>>
> .
>
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply [flat|nested] 4+ messages in thread
end of thread, other threads:[~2019-08-06 1:42 UTC | newest]
Thread overview: 4+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2019-07-17 1:28 [f2fs-dev] [PATCH v3] fsck.f2fs: write checkpoint with OPU mode Chao Yu
2019-08-05 9:51 ` Chao Yu
2019-08-06 0:48 ` Jaegeuk Kim
2019-08-06 1:43 ` Chao Yu
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).