lkml.org 
[lkml]   [2021]   [Mar]   [10]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH 5.4 03/24] dm table: fix DAX iterate_devices based device capability checks
    Date
    From: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

    From: Jeffle Xu <jefflexu@linux.alibaba.com>

    commit 5b0fab508992c2e120971da658ce80027acbc405 upstream.

    Fix dm_table_supports_dax() and invert logic of both
    iterate_devices_callout_fn so that all devices' DAX capabilities are
    properly checked.

    Fixes: 545ed20e6df6 ("dm: add infrastructure for DAX support")
    Cc: stable@vger.kernel.org
    Signed-off-by: Jeffle Xu <jefflexu@linux.alibaba.com>
    Signed-off-by: Mike Snitzer <snitzer@redhat.com>
    Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
    ---
    drivers/md/dm-table.c | 37 ++++++++++---------------------------
    drivers/md/dm.c | 2 +-
    drivers/md/dm.h | 2 +-
    3 files changed, 12 insertions(+), 29 deletions(-)

    --- a/drivers/md/dm-table.c
    +++ b/drivers/md/dm-table.c
    @@ -888,24 +888,24 @@ void dm_table_set_type(struct dm_table *
    EXPORT_SYMBOL_GPL(dm_table_set_type);

    /* validate the dax capability of the target device span */
    -int device_supports_dax(struct dm_target *ti, struct dm_dev *dev,
    +int device_not_dax_capable(struct dm_target *ti, struct dm_dev *dev,
    sector_t start, sector_t len, void *data)
    {
    int blocksize = *(int *) data, id;
    bool rc;

    id = dax_read_lock();
    - rc = dax_supported(dev->dax_dev, dev->bdev, blocksize, start, len);
    + rc = !dax_supported(dev->dax_dev, dev->bdev, blocksize, start, len);
    dax_read_unlock(id);

    return rc;
    }

    /* Check devices support synchronous DAX */
    -static int device_dax_synchronous(struct dm_target *ti, struct dm_dev *dev,
    - sector_t start, sector_t len, void *data)
    +static int device_not_dax_synchronous_capable(struct dm_target *ti, struct dm_dev *dev,
    + sector_t start, sector_t len, void *data)
    {
    - return dev->dax_dev && dax_synchronous(dev->dax_dev);
    + return !dev->dax_dev || !dax_synchronous(dev->dax_dev);
    }

    bool dm_table_supports_dax(struct dm_table *t,
    @@ -922,7 +922,7 @@ bool dm_table_supports_dax(struct dm_tab
    return false;

    if (!ti->type->iterate_devices ||
    - !ti->type->iterate_devices(ti, iterate_fn, blocksize))
    + ti->type->iterate_devices(ti, iterate_fn, blocksize))
    return false;
    }

    @@ -996,7 +996,7 @@ static int dm_table_determine_type(struc
    verify_bio_based:
    /* We must use this table as bio-based */
    t->type = DM_TYPE_BIO_BASED;
    - if (dm_table_supports_dax(t, device_supports_dax, &page_size) ||
    + if (dm_table_supports_dax(t, device_not_dax_capable, &page_size) ||
    (list_empty(devices) && live_md_type == DM_TYPE_DAX_BIO_BASED)) {
    t->type = DM_TYPE_DAX_BIO_BASED;
    } else {
    @@ -1715,23 +1715,6 @@ static int device_dax_write_cache_enable
    return false;
    }

    -static int dm_table_supports_dax_write_cache(struct dm_table *t)
    -{
    - struct dm_target *ti;
    - unsigned i;
    -
    - for (i = 0; i < dm_table_get_num_targets(t); i++) {
    - ti = dm_table_get_target(t, i);
    -
    - if (ti->type->iterate_devices &&
    - ti->type->iterate_devices(ti,
    - device_dax_write_cache_enabled, NULL))
    - return true;
    - }
    -
    - return false;
    -}
    -
    static int device_is_rotational(struct dm_target *ti, struct dm_dev *dev,
    sector_t start, sector_t len, void *data)
    {
    @@ -1918,15 +1901,15 @@ void dm_table_set_restrictions(struct dm
    }
    blk_queue_write_cache(q, wc, fua);

    - if (dm_table_supports_dax(t, device_supports_dax, &page_size)) {
    + if (dm_table_supports_dax(t, device_not_dax_capable, &page_size)) {
    blk_queue_flag_set(QUEUE_FLAG_DAX, q);
    - if (dm_table_supports_dax(t, device_dax_synchronous, NULL))
    + if (dm_table_supports_dax(t, device_not_dax_synchronous_capable, NULL))
    set_dax_synchronous(t->md->dax_dev);
    }
    else
    blk_queue_flag_clear(QUEUE_FLAG_DAX, q);

    - if (dm_table_supports_dax_write_cache(t))
    + if (dm_table_any_dev_attr(t, device_dax_write_cache_enabled))
    dax_write_cache(t->md->dax_dev, true);

    /* Ensure that all underlying devices are non-rotational. */
    --- a/drivers/md/dm.c
    +++ b/drivers/md/dm.c
    @@ -1139,7 +1139,7 @@ static bool dm_dax_supported(struct dax_
    if (!map)
    goto out;

    - ret = dm_table_supports_dax(map, device_supports_dax, &blocksize);
    + ret = dm_table_supports_dax(map, device_not_dax_capable, &blocksize);

    out:
    dm_put_live_table(md, srcu_idx);
    --- a/drivers/md/dm.h
    +++ b/drivers/md/dm.h
    @@ -74,7 +74,7 @@ void dm_table_free_md_mempools(struct dm
    struct dm_md_mempools *dm_table_get_md_mempools(struct dm_table *t);
    bool dm_table_supports_dax(struct dm_table *t, iterate_devices_callout_fn fn,
    int *blocksize);
    -int device_supports_dax(struct dm_target *ti, struct dm_dev *dev,
    +int device_not_dax_capable(struct dm_target *ti, struct dm_dev *dev,
    sector_t start, sector_t len, void *data);

    void dm_lock_md_type(struct mapped_device *md);

    \
     
     \ /
      Last update: 2021-03-10 14:40    [W:2.610 / U:0.096 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site