lkml.org 
[lkml]   [2022]   [Nov]   [23]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH AUTOSEL 5.10 13/22] zonefs: fix zone report size in __zonefs_io_error()
    Date
    From: Damien Le Moal <damien.lemoal@opensource.wdc.com>

    [ Upstream commit 7dd12d65ac646046a3fe0bbf9a4e86f4514207b3 ]

    When an IO error occurs, the function __zonefs_io_error() is used to
    issue a zone report to obtain the latest zone information from the
    device. This function gets a zone report for all zones used as storage
    for a file, which is always 1 zone except for files representing
    aggregated conventional zones.

    The number of zones of a zone report for a file is calculated in
    __zonefs_io_error() by doing a bit-shift of the inode i_zone_size field,
    which is equal to or larger than the device zone size. However, this
    calculation does not take into account that the last zone of a zoned
    device may be smaller than the zone size reported by bdev_zone_sectors()
    (which is used to set the bit shift size). As a result, if an error
    occurs for an IO targetting such last smaller zone, the zone report will
    ask for 0 zones, leading to an invalid zone report.

    Fix this by using the fact that all files require a 1 zone report,
    except if the inode i_zone_size field indicates a zone size larger than
    the device zone size. This exception case corresponds to a mount with
    aggregated conventional zones.

    A check for this exception is added to the file inode initialization
    during mount. If an invalid setup is detected, emit an error and fail
    the mount (check contributed by Johannes Thumshirn).

    Signed-off-by: Johannes Thumshirn <johannes.thumshirn@wdc.com>
    Signed-off-by: Damien Le Moal <damien.lemoal@opensource.wdc.com>
    Signed-off-by: Sasha Levin <sashal@kernel.org>
    ---
    fs/zonefs/super.c | 37 +++++++++++++++++++++++++++----------
    1 file changed, 27 insertions(+), 10 deletions(-)

    diff --git a/fs/zonefs/super.c b/fs/zonefs/super.c
    index bf5cb6efb8c0..475d23a4f8da 100644
    --- a/fs/zonefs/super.c
    +++ b/fs/zonefs/super.c
    @@ -440,14 +440,22 @@ static void __zonefs_io_error(struct inode *inode, bool write)
    struct super_block *sb = inode->i_sb;
    struct zonefs_sb_info *sbi = ZONEFS_SB(sb);
    unsigned int noio_flag;
    - unsigned int nr_zones =
    - zi->i_zone_size >> (sbi->s_zone_sectors_shift + SECTOR_SHIFT);
    + unsigned int nr_zones = 1;
    struct zonefs_ioerr_data err = {
    .inode = inode,
    .write = write,
    };
    int ret;

    + /*
    + * The only files that have more than one zone are conventional zone
    + * files with aggregated conventional zones, for which the inode zone
    + * size is always larger than the device zone size.
    + */
    + if (zi->i_zone_size > bdev_zone_sectors(sb->s_bdev))
    + nr_zones = zi->i_zone_size >>
    + (sbi->s_zone_sectors_shift + SECTOR_SHIFT);
    +
    /*
    * Memory allocations in blkdev_report_zones() can trigger a memory
    * reclaim which may in turn cause a recursion into zonefs as well as
    @@ -1364,6 +1372,14 @@ static int zonefs_init_file_inode(struct inode *inode, struct blk_zone *zone,
    zi->i_ztype = type;
    zi->i_zsector = zone->start;
    zi->i_zone_size = zone->len << SECTOR_SHIFT;
    + if (zi->i_zone_size > bdev_zone_sectors(sb->s_bdev) << SECTOR_SHIFT &&
    + !(sbi->s_features & ZONEFS_F_AGGRCNV)) {
    + zonefs_err(sb,
    + "zone size %llu doesn't match device's zone sectors %llu\n",
    + zi->i_zone_size,
    + bdev_zone_sectors(sb->s_bdev) << SECTOR_SHIFT);
    + return -EINVAL;
    + }

    zi->i_max_size = min_t(loff_t, MAX_LFS_FILESIZE,
    zone->capacity << SECTOR_SHIFT);
    @@ -1406,11 +1422,11 @@ static struct dentry *zonefs_create_inode(struct dentry *parent,
    struct inode *dir = d_inode(parent);
    struct dentry *dentry;
    struct inode *inode;
    - int ret;
    + int ret = -ENOMEM;

    dentry = d_alloc_name(parent, name);
    if (!dentry)
    - return NULL;
    + return ERR_PTR(ret);

    inode = new_inode(parent->d_sb);
    if (!inode)
    @@ -1435,7 +1451,7 @@ static struct dentry *zonefs_create_inode(struct dentry *parent,
    dput:
    dput(dentry);

    - return NULL;
    + return ERR_PTR(ret);
    }

    struct zonefs_zone_data {
    @@ -1455,7 +1471,7 @@ static int zonefs_create_zgroup(struct zonefs_zone_data *zd,
    struct blk_zone *zone, *next, *end;
    const char *zgroup_name;
    char *file_name;
    - struct dentry *dir;
    + struct dentry *dir, *dent;
    unsigned int n = 0;
    int ret;

    @@ -1473,8 +1489,8 @@ static int zonefs_create_zgroup(struct zonefs_zone_data *zd,
    zgroup_name = "seq";

    dir = zonefs_create_inode(sb->s_root, zgroup_name, NULL, type);
    - if (!dir) {
    - ret = -ENOMEM;
    + if (IS_ERR(dir)) {
    + ret = PTR_ERR(dir);
    goto free;
    }

    @@ -1520,8 +1536,9 @@ static int zonefs_create_zgroup(struct zonefs_zone_data *zd,
    * Use the file number within its group as file name.
    */
    snprintf(file_name, ZONEFS_NAME_MAX - 1, "%u", n);
    - if (!zonefs_create_inode(dir, file_name, zone, type)) {
    - ret = -ENOMEM;
    + dent = zonefs_create_inode(dir, file_name, zone, type);
    + if (IS_ERR(dent)) {
    + ret = PTR_ERR(dent);
    goto free;
    }

    --
    2.35.1
    \
     
     \ /
      Last update: 2022-11-23 13:55    [W:2.399 / U:0.056 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site