nilfs2: prevent WARNING in nilfs_sufile_set_segment_usage()

commit 675abf8df1353e0e3bde314993e0796c524cfbf0 upstream.

If nilfs2 reads a disk image with corrupted segment usage metadata, and
its segment usage information is marked as an error for the segment at the
write location, nilfs_sufile_set_segment_usage() can trigger WARN_ONs
during log writing.

Segments newly allocated for writing with nilfs_sufile_alloc() will not
have this error flag set, but this unexpected situation will occur if the
segment indexed by either nilfs->ns_segnum or nilfs->ns_nextnum (active
segment) was marked in error.

Fix this issue by inserting a sanity check to treat it as a file system
corruption.

Since error returns are not allowed during the execution phase where
nilfs_sufile_set_segment_usage() is used, this inserts the sanity check
into nilfs_sufile_mark_dirty() which pre-reads the buffer containing the
segment usage record to be updated and sets it up in a dirty state for
writing.

In addition, nilfs_sufile_set_segment_usage() is also called when
canceling log writing and undoing segment usage update, so in order to
avoid issuing the same kernel warning in that case, in case of
cancellation, avoid checking the error flag in
nilfs_sufile_set_segment_usage().

Link: https://lkml.kernel.org/r/20231205085947.4431-1-konishi.ryusuke@gmail.com
Signed-off-by: Ryusuke Konishi <konishi.ryusuke@gmail.com>
Reported-by: syzbot+14e9f834f6ddecece094@syzkaller.appspotmail.com
Closes: https://syzkaller.appspot.com/bug?extid=14e9f834f6ddecece094
Tested-by: Ryusuke Konishi <konishi.ryusuke@gmail.com>
Cc: <stable@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

diff --git a/fs/nilfs2/sufile.c b/fs/nilfs2/sufile.c
index 2c6078a..58ca7c9 100644 (file)
--- a/fs/nilfs2/sufile.c
+++ b/fs/nilfs2/sufile.c
@@ -501,15 +501,38 @@ int nilfs_sufile_mark_dirty(struct inode *sufile, __u64 segnum)
 
        down_write(&NILFS_MDT(sufile)->mi_sem);
        ret = nilfs_sufile_get_segment_usage_block(sufile, segnum, 0, &bh);
-       if (!ret) {
-               mark_buffer_dirty(bh);
-               nilfs_mdt_mark_dirty(sufile);
-               kaddr = kmap_atomic(bh->b_page);
-               su = nilfs_sufile_block_get_segment_usage(sufile, segnum, bh, kaddr);
+       if (ret)
+               goto out_sem;
+
+       kaddr = kmap_atomic(bh->b_page);
+       su = nilfs_sufile_block_get_segment_usage(sufile, segnum, bh, kaddr);
+       if (unlikely(nilfs_segment_usage_error(su))) {
+               struct the_nilfs *nilfs = sufile->i_sb->s_fs_info;
+
+               kunmap_atomic(kaddr);
+               brelse(bh);
+               if (nilfs_segment_is_active(nilfs, segnum)) {
+                       nilfs_error(sufile->i_sb,
+                                   "active segment %llu is erroneous",
+                                   (unsigned long long)segnum);
+               } else {
+                       /*
+                        * Segments marked erroneous are never allocated by
+                        * nilfs_sufile_alloc(); only active segments, ie,
+                        * the segments indexed by ns_segnum or ns_nextnum,
+                        * can be erroneous here.
+                        */
+                       WARN_ON_ONCE(1);
+               }
+               ret = -EIO;
+       } else {
                nilfs_segment_usage_set_dirty(su);
                kunmap_atomic(kaddr);
+               mark_buffer_dirty(bh);
+               nilfs_mdt_mark_dirty(sufile);
                brelse(bh);
        }
+out_sem:
        up_write(&NILFS_MDT(sufile)->mi_sem);
        return ret;
 }
@@ -536,9 +559,14 @@ int nilfs_sufile_set_segment_usage(struct inode *sufile, __u64 segnum,
 
        kaddr = kmap_atomic(bh->b_page);
        su = nilfs_sufile_block_get_segment_usage(sufile, segnum, bh, kaddr);
-       WARN_ON(nilfs_segment_usage_error(su));
-       if (modtime)
+       if (modtime) {
+               /*
+                * Check segusage error and set su_lastmod only when updating
+                * this entry with a valid timestamp, not for cancellation.
+                */
+               WARN_ON_ONCE(nilfs_segment_usage_error(su));
                su->su_lastmod = cpu_to_le64(modtime);
+       }
        su->su_nblocks = cpu_to_le32(nblocks);
        kunmap_atomic(kaddr);