Source of dm-cache-target.c - linux-imx - PHYTEC BitBucket (Stash)

Ignore whitespace
Show whitespace characters
Hide e-diff
Unified diff
Side-by-side diff
Source viewDiff to previous
 
     * origin.  If a write goes to a cached oblock, then the cache
     * block is invalidated.
     */
    CM_IO_PASSTHROUGH
};
​
struct cache_features {
    enum cache_metadata_mode mode;
    enum cache_io_mode io_mode;
    unsigned metadata_version;
    bool discard_passdown:1;
};
​
struct cache_stats {
    atomic_t read_hit;
    atomic_t read_miss;
    atomic_t write_hit;
    atomic_t write_miss;
    atomic_t demotion;
    atomic_t promotion;
    atomic_t writeback;
Show more
​
    // FIXME: do we need to lock the region?  Or can we just assume the
    // user wont be so foolish as to issue discard concurrently with
    // other IO?
    calc_discard_block_range(cache, bio, &b, &e);
    while (b != e) {
        set_discard(cache, b);
        b = to_dblock(from_dblock(b) + 1);
    }
​
    bio_endio(bio);
    if (cache->features.discard_passdown) {
        remap_to_origin(cache, bio);
        generic_make_request(bio);
    } else
        bio_endio(bio);
​
    return false;
}
​
static void process_deferred_bios(struct work_struct *ws)
{
    struct cache *cache = container_of(ws, struct cache, deferred_bio_worker);
​
    unsigned long flags;
    bool commit_needed = false;
Show more
    ca->block_size = block_size;
​
    return 0;
}
​
static void init_features(struct cache_features *cf)
{
    cf->mode = CM_WRITE;
    cf->io_mode = CM_IO_WRITEBACK;
    cf->metadata_version = 1;
    cf->discard_passdown = true;
}
​
static int parse_features(struct cache_args *ca, struct dm_arg_set *as,
              char **error)
{
    static const struct dm_arg _args[] = {
        {0, 2, "Invalid number of cache feature arguments"},
        {0, 3, "Invalid number of cache feature arguments"},
    };
​
    int r, mode_ctr = 0;
    unsigned argc;
    const char *arg;
    struct cache_features *cf = &ca->features;
​
    init_features(cf);
​
    r = dm_read_arg_group(_args, as, &argc, error);
Show more
        }
​
        else if (!strcasecmp(arg, "passthrough")) {
            cf->io_mode = CM_IO_PASSTHROUGH;
            mode_ctr++;
        }
​
        else if (!strcasecmp(arg, "metadata2"))
            cf->metadata_version = 2;
​
        else if (!strcasecmp(arg, "no_discard_passdown"))
            cf->discard_passdown = false;
​
        else {
            *error = "Unrecognised cache feature requested";
            return -EINVAL;
        }
    }
​
    if (mode_ctr > 1) {
        *error = "Duplicate cache io_mode features requested";
        return -EINVAL;
    }
Show more
​
static void cache_resume(struct dm_target *ti)
{
    struct cache *cache = ti->private;
​
    cache->need_tick_bio = true;
    allow_background_work(cache);
    do_waker(&cache->waker.work);
}
​
static void emit_flags(struct cache *cache, char *result,
               unsigned maxlen, ssize_t *sz_ptr)
{
    ssize_t sz = *sz_ptr;
    struct cache_features *cf = &cache->features;
    unsigned count = (cf->metadata_version == 2) + !cf->discard_passdown + 1;
​
    DMEMIT("%u ", count);
​
    if (cf->metadata_version == 2)
        DMEMIT("metadata2 ");
​
    if (writethrough_mode(cache))
        DMEMIT("writethrough ");
​
    else if (passthrough_mode(cache))
        DMEMIT("passthrough ");
​
    else if (writeback_mode(cache))
        DMEMIT("writeback ");
​
    else {
        DMEMIT("unknown ");
        DMERR("%s: internal error: unknown io mode: %d",
              cache_device_name(cache), (int) cf->io_mode);
    }
​
    if (!cf->discard_passdown)
        DMEMIT("no_discard_passdown ");
​
    *sz_ptr = sz;
}
​
/*
 * Status format:
 *
 * <metadata block size> <#used metadata blocks>/<#total metadata blocks>
 * <cache block size> <#used cache blocks>/<#total cache blocks>
 * <#read hits> <#read misses> <#write hits> <#write misses>
 * <#demotions> <#promotions> <#dirty>
 * <#features> <features>*
 * <#core args> <core args>
 * <policy name> <#policy args> <policy args>* <cache metadata mode> <needs_check>
Show more
               (unsigned long long) from_cblock(residency),
               (unsigned long long) from_cblock(cache->cache_size),
               (unsigned) atomic_read(&cache->stats.read_hit),
               (unsigned) atomic_read(&cache->stats.read_miss),
               (unsigned) atomic_read(&cache->stats.write_hit),
               (unsigned) atomic_read(&cache->stats.write_miss),
               (unsigned) atomic_read(&cache->stats.demotion),
               (unsigned) atomic_read(&cache->stats.promotion),
               (unsigned long) atomic_read(&cache->nr_dirty));
​
        if (cache->features.metadata_version == 2)
            DMEMIT("2 metadata2 ");
        else
            DMEMIT("1 ");
​
        if (writethrough_mode(cache))
            DMEMIT("writethrough ");
​
        else if (passthrough_mode(cache))
            DMEMIT("passthrough ");
​
        else if (writeback_mode(cache))
            DMEMIT("writeback ");
​
        else {
            DMERR("%s: internal error: unknown io mode: %d",
                  cache_device_name(cache), (int) cache->features.io_mode);
            goto err;
        }
        emit_flags(cache, result, maxlen, &sz);
​
        DMEMIT("2 migration_threshold %llu ", (unsigned long long) cache->migration_threshold);
​
        DMEMIT("%s ", dm_cache_policy_get_name(cache->policy));
        if (sz < maxlen) {
            r = policy_emit_config_values(cache->policy, result, maxlen, &sz);
            if (r)
                DMERR("%s: policy_emit_config_values returned %d",
                      cache_device_name(cache), r);
        }
Show more
    int r = 0;
    struct cache *cache = ti->private;
​
    r = fn(ti, cache->cache_dev, 0, get_dev_size(cache->cache_dev), data);
    if (!r)
        r = fn(ti, cache->origin_dev, 0, ti->len, data);
​
    return r;
}
​
static bool origin_dev_supports_discard(struct block_device *origin_bdev)
{
    struct request_queue *q = bdev_get_queue(origin_bdev);
​
    return q && blk_queue_discard(q);
}
​
/*
 * If discard_passdown was enabled verify that the origin device
 * supports discards.  Disable discard_passdown if not.
 */
static void disable_passdown_if_not_supported(struct cache *cache)
{
    struct block_device *origin_bdev = cache->origin_dev->bdev;
    struct queue_limits *origin_limits = &bdev_get_queue(origin_bdev)->limits;
    const char *reason = NULL;
    char buf[BDEVNAME_SIZE];
​
    if (!cache->features.discard_passdown)
        return;
​
    if (!origin_dev_supports_discard(origin_bdev))
        reason = "discard unsupported";
​
    else if (origin_limits->max_discard_sectors < cache->sectors_per_block)
        reason = "max discard sectors smaller than a block";
​
    if (reason) {
        DMWARN("Origin device (%s) %s: Disabling discard passdown.",
               bdevname(origin_bdev, buf), reason);
        cache->features.discard_passdown = false;
    }
}
​
static void set_discard_limits(struct cache *cache, struct queue_limits *limits)
{
    struct block_device *origin_bdev = cache->origin_dev->bdev;
    struct queue_limits *origin_limits = &bdev_get_queue(origin_bdev)->limits;
​
    if (!cache->features.discard_passdown) {
        /* No passdown is done so setting own virtual limits */
        limits->max_discard_sectors = min_t(sector_t, cache->discard_block_size * 1024,
                            cache->origin_sectors);
        limits->discard_granularity = cache->discard_block_size << SECTOR_SHIFT;
        return;
    }
​
    /*
     * FIXME: these limits may be incompatible with the cache device
     * cache_iterate_devices() is stacking both origin and fast device limits
     * but discards aren't passed to fast device, so inherit origin's limits.
     */
    limits->max_discard_sectors = min_t(sector_t, cache->discard_block_size * 1024,
                        cache->origin_sectors);
    limits->discard_granularity = cache->discard_block_size << SECTOR_SHIFT;
    limits->max_discard_sectors = origin_limits->max_discard_sectors;
    limits->max_hw_discard_sectors = origin_limits->max_hw_discard_sectors;
    limits->discard_granularity = origin_limits->discard_granularity;
    limits->discard_alignment = origin_limits->discard_alignment;
    limits->discard_misaligned = origin_limits->discard_misaligned;
}
​
static void cache_io_hints(struct dm_target *ti, struct queue_limits *limits)
{
    struct cache *cache = ti->private;
    uint64_t io_opt_sectors = limits->io_opt >> SECTOR_SHIFT;
​
    /*
     * If the system-determined stacked limits are compatible with the
     * cache's blocksize (io_opt is a factor) do not override them.
     */
    if (io_opt_sectors < cache->sectors_per_block ||
        do_div(io_opt_sectors, cache->sectors_per_block)) {
        blk_limits_io_min(limits, cache->sectors_per_block << SECTOR_SHIFT);
        blk_limits_io_opt(limits, cache->sectors_per_block << SECTOR_SHIFT);
    }
​
    disable_passdown_if_not_supported(cache);
    set_discard_limits(cache, limits);
}
​
/*----------------------------------------------------------------*/
​
static struct target_type cache_target = {
    .name = "cache",
    .version = {2, 0, 0},
    .version = {2, 1, 0},
    .module = THIS_MODULE,
    .ctr = cache_ctr,
    .dtr = cache_dtr,
    .map = cache_map,
    .end_io = cache_end_io,
    .postsuspend = cache_postsuspend,
    .preresume = cache_preresume,
    .resume = cache_resume,
    .status = cache_status,
    .message = cache_message,