382 lines
8.0 KiB
C
382 lines
8.0 KiB
C
/*
|
|
* 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 DM_HASH_SIZE 256
|
|
#define DM_HASH_MASK (DM_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[DM_HASH_SIZE];
|
|
};
|
|
|
|
/*----------------------------------------------------------------*/
|
|
|
|
static int is_shadow(struct dm_transaction_manager *tm, dm_block_t b)
|
|
{
|
|
int r = 0;
|
|
unsigned bucket = dm_hash_block(b, DM_HASH_MASK);
|
|
struct shadow_info *si;
|
|
|
|
spin_lock(&tm->lock);
|
|
hlist_for_each_entry(si, 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, DM_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 *tmp;
|
|
struct hlist_head *bucket;
|
|
int i;
|
|
|
|
spin_lock(&tm->lock);
|
|
for (i = 0; i < DM_HASH_SIZE; i++) {
|
|
bucket = tm->buckets + i;
|
|
hlist_for_each_entry_safe(si, 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 < DM_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);
|
|
|
|
/*----------------------------------------------------------------*/
|