dm-transaction-manager.c

Go to the documentation of this file.

/*
 * Copyright (C) 2011 Red Hat, Inc.
 *
 * This file is released under the GPL.
 */
#include "dm-transaction-manager.h"
#include "dm-space-map.h"
#include "dm-space-map-disk.h"
#include "dm-space-map-metadata.h"
#include "dm-persistent-data-internal.h"

#include <linux/export.h>
#include <linux/slab.h>
#include <linux/device-mapper.h>

#define DM_MSG_PREFIX "transaction manager"

/*----------------------------------------------------------------*/

struct shadow_info {
    struct hlist_node hlist;
    dm_block_t where;
};

/*
 * It would be nice if we scaled with the size of transaction.
 */
#define HASH_SIZE 256
#define HASH_MASK (HASH_SIZE - 1)

struct dm_transaction_manager {
    int is_clone;
    struct dm_transaction_manager *real;

    struct dm_block_manager *bm;
    struct dm_space_map *sm;

    spinlock_t lock;
    struct hlist_head buckets[HASH_SIZE];
};

/*----------------------------------------------------------------*/

static int is_shadow(struct dm_transaction_manager *tm, dm_block_t b)
{
    int r = 0;
    unsigned bucket = dm_hash_block(b, HASH_MASK);
    struct shadow_info *si;
    struct hlist_node *n;

    spin_lock(&tm->lock);
    hlist_for_each_entry(si, n, tm->buckets + bucket, hlist)
        if (si->where == b) {
            r = 1;
            break;
        }
    spin_unlock(&tm->lock);

    return r;
}

/*
 * This can silently fail if there's no memory.  We're ok with this since
 * creating redundant shadows causes no harm.
 */
static void insert_shadow(struct dm_transaction_manager *tm, dm_block_t b)
{
    unsigned bucket;
    struct shadow_info *si;

    si = kmalloc(sizeof(*si), GFP_NOIO);
    if (si) {
        si->where = b;
        bucket = dm_hash_block(b, HASH_MASK);
        spin_lock(&tm->lock);
        hlist_add_head(&si->hlist, tm->buckets + bucket);
        spin_unlock(&tm->lock);
    }
}

static void wipe_shadow_table(struct dm_transaction_manager *tm)
{
    struct shadow_info *si;
    struct hlist_node *n, *tmp;
    struct hlist_head *bucket;
    int i;

    spin_lock(&tm->lock);
    for (i = 0; i < HASH_SIZE; i++) {
        bucket = tm->buckets + i;
        hlist_for_each_entry_safe(si, n, tmp, bucket, hlist)
            kfree(si);

        INIT_HLIST_HEAD(bucket);
    }

    spin_unlock(&tm->lock);
}

/*----------------------------------------------------------------*/

static struct dm_transaction_manager *dm_tm_create(struct dm_block_manager *bm,
                           struct dm_space_map *sm)
{
    int i;
    struct dm_transaction_manager *tm;

    tm = kmalloc(sizeof(*tm), GFP_KERNEL);
    if (!tm)
        return ERR_PTR(-ENOMEM);

    tm->is_clone = 0;
    tm->real = NULL;
    tm->bm = bm;
    tm->sm = sm;

    spin_lock_init(&tm->lock);
    for (i = 0; i < HASH_SIZE; i++)
        INIT_HLIST_HEAD(tm->buckets + i);

    return tm;
}

struct dm_transaction_manager *dm_tm_create_non_blocking_clone(struct dm_transaction_manager *real)
{
    struct dm_transaction_manager *tm;

    tm = kmalloc(sizeof(*tm), GFP_KERNEL);
    if (tm) {
        tm->is_clone = 1;
        tm->real = real;
    }

    return tm;
}
EXPORT_SYMBOL_GPL(dm_tm_create_non_blocking_clone);

void dm_tm_destroy(struct dm_transaction_manager *tm)
{
    if (!tm->is_clone)
        wipe_shadow_table(tm);

    kfree(tm);
}
EXPORT_SYMBOL_GPL(dm_tm_destroy);

int dm_tm_pre_commit(struct dm_transaction_manager *tm)
{
    int r;

    if (tm->is_clone)
        return -EWOULDBLOCK;

    r = dm_sm_commit(tm->sm);
    if (r < 0)
        return r;

    return 0;
}
EXPORT_SYMBOL_GPL(dm_tm_pre_commit);

int dm_tm_commit(struct dm_transaction_manager *tm, struct dm_block *root)
{
    if (tm->is_clone)
        return -EWOULDBLOCK;

    wipe_shadow_table(tm);

    return dm_bm_flush_and_unlock(tm->bm, root);
}
EXPORT_SYMBOL_GPL(dm_tm_commit);

int dm_tm_new_block(struct dm_transaction_manager *tm,
            struct dm_block_validator *v,
            struct dm_block **result)
{
    int r;
    dm_block_t new_block;

    if (tm->is_clone)
        return -EWOULDBLOCK;

    r = dm_sm_new_block(tm->sm, &new_block);
    if (r < 0)
        return r;

    r = dm_bm_write_lock_zero(tm->bm, new_block, v, result);
    if (r < 0) {
        dm_sm_dec_block(tm->sm, new_block);
        return r;
    }

    /*
     * New blocks count as shadows in that they don't need to be
     * shadowed again.
     */
    insert_shadow(tm, new_block);

    return 0;
}

static int __shadow_block(struct dm_transaction_manager *tm, dm_block_t orig,
              struct dm_block_validator *v,
              struct dm_block **result)
{
    int r;
    dm_block_t new;
    struct dm_block *orig_block;

    r = dm_sm_new_block(tm->sm, &new);
    if (r < 0)
        return r;

    r = dm_sm_dec_block(tm->sm, orig);
    if (r < 0)
        return r;

    r = dm_bm_read_lock(tm->bm, orig, v, &orig_block);
    if (r < 0)
        return r;

    /*
     * It would be tempting to use dm_bm_unlock_move here, but some
     * code, such as the space maps, keeps using the old data structures
     * secure in the knowledge they won't be changed until the next
     * transaction.  Using unlock_move would force a synchronous read
     * since the old block would no longer be in the cache.
     */
    r = dm_bm_write_lock_zero(tm->bm, new, v, result);
    if (r) {
        dm_bm_unlock(orig_block);
        return r;
    }

    memcpy(dm_block_data(*result), dm_block_data(orig_block),
           dm_bm_block_size(tm->bm));

    dm_bm_unlock(orig_block);
    return r;
}

int dm_tm_shadow_block(struct dm_transaction_manager *tm, dm_block_t orig,
               struct dm_block_validator *v, struct dm_block **result,
               int *inc_children)
{
    int r;

    if (tm->is_clone)
        return -EWOULDBLOCK;

    r = dm_sm_count_is_more_than_one(tm->sm, orig, inc_children);
    if (r < 0)
        return r;

    if (is_shadow(tm, orig) && !*inc_children)
        return dm_bm_write_lock(tm->bm, orig, v, result);

    r = __shadow_block(tm, orig, v, result);
    if (r < 0)
        return r;
    insert_shadow(tm, dm_block_location(*result));

    return r;
}
EXPORT_SYMBOL_GPL(dm_tm_shadow_block);

int dm_tm_read_lock(struct dm_transaction_manager *tm, dm_block_t b,
            struct dm_block_validator *v,
            struct dm_block **blk)
{
    if (tm->is_clone)
        return dm_bm_read_try_lock(tm->real->bm, b, v, blk);

    return dm_bm_read_lock(tm->bm, b, v, blk);
}
EXPORT_SYMBOL_GPL(dm_tm_read_lock);

int dm_tm_unlock(struct dm_transaction_manager *tm, struct dm_block *b)
{
    return dm_bm_unlock(b);
}
EXPORT_SYMBOL_GPL(dm_tm_unlock);

void dm_tm_inc(struct dm_transaction_manager *tm, dm_block_t b)
{
    /*
     * The non-blocking clone doesn't support this.
     */
    BUG_ON(tm->is_clone);

    dm_sm_inc_block(tm->sm, b);
}
EXPORT_SYMBOL_GPL(dm_tm_inc);

void dm_tm_dec(struct dm_transaction_manager *tm, dm_block_t b)
{
    /*
     * The non-blocking clone doesn't support this.
     */
    BUG_ON(tm->is_clone);

    dm_sm_dec_block(tm->sm, b);
}
EXPORT_SYMBOL_GPL(dm_tm_dec);

int dm_tm_ref(struct dm_transaction_manager *tm, dm_block_t b,
          uint32_t *result)
{
    if (tm->is_clone)
        return -EWOULDBLOCK;

    return dm_sm_get_count(tm->sm, b, result);
}

struct dm_block_manager *dm_tm_get_bm(struct dm_transaction_manager *tm)
{
    return tm->bm;
}

/*----------------------------------------------------------------*/

static int dm_tm_create_internal(struct dm_block_manager *bm,
                 dm_block_t sb_location,
                 struct dm_transaction_manager **tm,
                 struct dm_space_map **sm,
                 int create,
                 void *sm_root, size_t sm_len)
{
    int r;

    *sm = dm_sm_metadata_init();
    if (IS_ERR(*sm))
        return PTR_ERR(*sm);

    *tm = dm_tm_create(bm, *sm);
    if (IS_ERR(*tm)) {
        dm_sm_destroy(*sm);
        return PTR_ERR(*tm);
    }

    if (create) {
        r = dm_sm_metadata_create(*sm, *tm, dm_bm_nr_blocks(bm),
                      sb_location);
        if (r) {
            DMERR("couldn't create metadata space map");
            goto bad;
        }

    } else {
        r = dm_sm_metadata_open(*sm, *tm, sm_root, sm_len);
        if (r) {
            DMERR("couldn't open metadata space map");
            goto bad;
        }
    }

    return 0;

bad:
    dm_tm_destroy(*tm);
    dm_sm_destroy(*sm);
    return r;
}

int dm_tm_create_with_sm(struct dm_block_manager *bm, dm_block_t sb_location,
             struct dm_transaction_manager **tm,
             struct dm_space_map **sm)
{
    return dm_tm_create_internal(bm, sb_location, tm, sm, 1, NULL, 0);
}
EXPORT_SYMBOL_GPL(dm_tm_create_with_sm);

int dm_tm_open_with_sm(struct dm_block_manager *bm, dm_block_t sb_location,
               void *sm_root, size_t root_len,
               struct dm_transaction_manager **tm,
               struct dm_space_map **sm)
{
    return dm_tm_create_internal(bm, sb_location, tm, sm, 0, sm_root, root_len);
}
EXPORT_SYMBOL_GPL(dm_tm_open_with_sm);

/*----------------------------------------------------------------*/