lkml.org 
[lkml]   [2017]   [Sep]   [24]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH 4.13 096/109] bcache: correct cache_dirty_target in __update_writeback_rate()
    Date
    4.13-stable review patch.  If anyone has any objections, please let me know.

    ------------------

    From: Tang Junhui <tang.junhui@zte.com.cn>

    commit a8394090a9129b40f9d90dcb7f4a49d60c727ca6 upstream.

    __update_write_rate() uses a Proportion-Differentiation Controller
    algorithm to control writeback rate. A dirty target number is used in
    this PD controller to control writeback rate. A larger target number
    will make the writeback rate smaller, on the versus, a smaller target
    number will make the writeback rate larger.

    bcache uses the following steps to calculate the target number,
    1) cache_sectors = all-buckets-of-cache-set * buckets-size
    2) cache_dirty_target = cache_sectors * cached-device-writeback_percent
    3) target = cache_dirty_target *
    (sectors-of-cached-device/sectors-of-all-cached-devices-of-this-cache-set)

    The calculation at step 1) for cache_sectors is incorrect, which does
    not consider dirty blocks occupied by flash only volume.

    A flash only volume can be took as a bcache device without cached
    device. All data sectors allocated for it are persistent on cache device
    and marked dirty, they are not touched by bcache writeback and garbage
    collection code. So data blocks of flash only volume should be ignore
    when calculating cache_sectors of cache set.

    Current code does not subtract dirty sectors of flash only volume, which
    results a larger target number from the above 3 steps. And in sequence
    the cache device's writeback rate is smaller then a correct value,
    writeback speed is slower on all cached devices.

    This patch fixes the incorrect slower writeback rate by subtracting
    dirty sectors of flash only volumes in __update_writeback_rate().

    (Commit log composed by Coly Li to pass checkpatch.pl checking)

    Signed-off-by: Tang Junhui <tang.junhui@zte.com.cn>
    Reviewed-by: Coly Li <colyli@suse.de>
    Signed-off-by: Jens Axboe <axboe@kernel.dk>
    Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

    ---
    drivers/md/bcache/writeback.c | 3 ++-
    drivers/md/bcache/writeback.h | 19 +++++++++++++++++++
    2 files changed, 21 insertions(+), 1 deletion(-)

    --- a/drivers/md/bcache/writeback.c
    +++ b/drivers/md/bcache/writeback.c
    @@ -21,7 +21,8 @@
    static void __update_writeback_rate(struct cached_dev *dc)
    {
    struct cache_set *c = dc->disk.c;
    - uint64_t cache_sectors = c->nbuckets * c->sb.bucket_size;
    + uint64_t cache_sectors = c->nbuckets * c->sb.bucket_size -
    + bcache_flash_devs_sectors_dirty(c);
    uint64_t cache_dirty_target =
    div_u64(cache_sectors * dc->writeback_percent, 100);

    --- a/drivers/md/bcache/writeback.h
    +++ b/drivers/md/bcache/writeback.h
    @@ -14,6 +14,25 @@ static inline uint64_t bcache_dev_sector
    return ret;
    }

    +static inline uint64_t bcache_flash_devs_sectors_dirty(struct cache_set *c)
    +{
    + uint64_t i, ret = 0;
    +
    + mutex_lock(&bch_register_lock);
    +
    + for (i = 0; i < c->nr_uuids; i++) {
    + struct bcache_device *d = c->devices[i];
    +
    + if (!d || !UUID_FLASH_ONLY(&c->uuids[i]))
    + continue;
    + ret += bcache_dev_sectors_dirty(d);
    + }
    +
    + mutex_unlock(&bch_register_lock);
    +
    + return ret;
    +}
    +
    static inline unsigned offset_to_stripe(struct bcache_device *d,
    uint64_t offset)
    {

    \
     
     \ /
      Last update: 2017-09-24 22:50    [W:4.126 / U:0.108 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site