dm-region-hash.rar_Dirty

/* * Copyright (C) 2003 Sistina Software Limited. * Copyright (C) 2004-2008 Red Hat, Inc. All rights reserved. * * This file is released under the GPL. */ #include <linux/dm-dirty-log.h> #include <linux/dm-region-hash.h> #include <linux/ctype.h> #include <linux/init.h> #include <linux/module.h> #include <linux/slab.h> #include <linux/vmalloc.h> #include "dm.h" #define DM_MSG_PREFIX "region hash" /*----------------------------------------------------------------- * Region hash * * The mirror splits itself up into discrete regions. Each * region can be in one of three states: clean, dirty, * nosync. There is no need to put clean regions in the hash. * * In addition to being present in the hash table a region _may_ * be present on one of three lists. * * clean_regions: Regions on this list have no io pending to * them, they are in sync, we are no longer interested in them, * they are dull. dm_rh_update_states() will remove them from the * hash table. * * quiesced_regions: These regions have been spun down, ready * for recovery. rh_recovery_start() will remove regions from * this list and hand them to kmirrord, which will schedule the * recovery io with kcopyd. * * recovered_regions: Regions that kcopyd has successfully * recovered. dm_rh_update_states() will now schedule any delayed * io, up the recovery_count, and remove the region from the * hash. * * There are 2 locks: * A rw spin lock 'hash_lock' protects just the hash table, * this is never held in write mode from interrupt context, * which I believe means that we only have to disable irqs when * doing a write lock. * * An ordinary spin lock 'region_lock' that protects the three * lists in the region_hash, with the 'state', 'list' and * 'delayed_bios' fields of the regions. This is used from irq * context, so all other uses will have to suspend local irqs. *---------------------------------------------------------------*/ struct dm_region_hash { uint32_t region_size; unsigned region_shift; /* holds persistent region state */ struct dm_dirty_log *log; /* hash table */ rwlock_t hash_lock; mempool_t *region_pool; unsigned mask; unsigned nr_buckets; unsigned prime; unsigned shift; struct list_head *buckets; unsigned max_recovery; /* Max # of regions to recover in parallel */ spinlock_t region_lock; atomic_t recovery_in_flight; struct semaphore recovery_count; struct list_head clean_regions; struct list_head quiesced_regions; struct list_head recovered_regions; struct list_head failed_recovered_regions; /* * If there was a flush failure no regions can be marked clean. */ int flush_failure; void *context; sector_t target_begin; /* Callback function to schedule bios writes */ void (*dispatch_bios)(void *context, struct bio_list *bios); /* Callback function to wakeup callers worker thread. */ void (*wakeup_workers)(void *context); /* Callback function to wakeup callers recovery waiters. */ void (*wakeup_all_recovery_waiters)(void *context); }; struct dm_region { struct dm_region_hash *rh; /* FIXME: can we get rid of this ? */ region_t key; int state; struct list_head hash_list; struct list_head list; atomic_t pending; struct bio_list delayed_bios; }; /* * Conversion fns */ static region_t dm_rh_sector_to_region(struct dm_region_hash *rh, sector_t sector) { return sector >> rh->region_shift; } sector_t dm_rh_region_to_sector(struct dm_region_hash *rh, region_t region) { return region << rh->region_shift; } EXPORT_SYMBOL_GPL(dm_rh_region_to_sector); region_t dm_rh_bio_to_region(struct dm_region_hash *rh, struct bio *bio) { return dm_rh_sector_to_region(rh, bio->bi_sector - rh->target_begin); } EXPORT_SYMBOL_GPL(dm_rh_bio_to_region); void *dm_rh_region_context(struct dm_region *reg) { return reg->rh->context; } EXPORT_SYMBOL_GPL(dm_rh_region_context); region_t dm_rh_get_region_key(struct dm_region *reg) { return reg->key; } EXPORT_SYMBOL_GPL(dm_rh_get_region_key); sector_t dm_rh_get_region_size(struct dm_region_hash *rh) { return rh->region_size; } EXPORT_SYMBOL_GPL(dm_rh_get_region_size); /* * FIXME: shall we pass in a structure instead of all these args to * dm_region_hash_create()???? */ #define RH_HASH_MULT 2654435387U #define RH_HASH_SHIFT 12 #define MIN_REGIONS 64 struct dm_region_hash *dm_region_hash_create( void *context, void (*dispatch_bios)(void *context, struct bio_list *bios), void (*wakeup_workers)(void *context), void (*wakeup_all_recovery_waiters)(void *context), sector_t target_begin, unsigned max_recovery, struct dm_dirty_log *log, uint32_t region_size, region_t nr_regions) { struct dm_region_hash *rh; unsigned nr_buckets, max_buckets; size_t i; /* * Calculate a suitable number of buckets for our hash * table. */ max_buckets = nr_regions >> 6; for (nr_buckets = 128u; nr_buckets < max_buckets; nr_buckets <<= 1) ; nr_buckets >>= 1; rh = kmalloc(sizeof(*rh), GFP_KERNEL); if (!rh) { DMERR("unable to allocate region hash memory"); return ERR_PTR(-ENOMEM); } rh->context = context; rh->dispatch_bios = dispatch_bios; rh->wakeup_workers = wakeup_workers; rh->wakeup_all_recovery_waiters = wakeup_all_recovery_waiters; rh->target_begin = target_begin; rh->max_recovery = max_recovery; rh->log = log; rh->region_size = region_size; rh->region_shift = ffs(region_size) - 1; rwlock_init(&rh->hash_lock); rh->mask = nr_buckets - 1; rh->nr_buckets = nr_buckets; rh->shift = RH_HASH_SHIFT; rh->prime = RH_HASH_MULT; rh->buckets = vmalloc(nr_buckets * sizeof(*rh->buckets)); if (!rh->buckets) { DMERR("unable to allocate region hash bucket memory"); kfree(rh); return ERR_PTR(-ENOMEM); } for (i = 0; i < nr_buckets; i++) INIT_LIST_HEAD(rh->buckets + i); spin_lock_init(&rh->region_lock); sema_init(&rh->recovery_count, 0); atomic_set(&rh->recovery_in_flight, 0); INIT_LIST_HEAD(&rh->clean_regions); INIT_LIST_HEAD(&rh->quiesced_regions); INIT_LIST_HEAD(&rh->recovered_regions); INIT_LIST_HEAD(&rh->failed_recovered_regions); rh->flush_failure = 0; rh->region_pool = mempool_create_kmalloc_pool(MIN_REGIONS, sizeof(struct dm_region)); if (!rh->region_pool) { vfree(rh->buckets); kfree(rh); rh = ERR_PTR(-ENOMEM); } return rh; } EXPORT_SYMBOL_GPL(dm_region_hash_create); void dm_region_hash_destroy(struct dm_region_hash *rh) { unsigned h; struct dm_region *reg, *nreg; BUG_ON(!list_empty(&rh->quiesced_regions)); for (h = 0; h < rh->nr_buckets; h++) { list_for_each_entry_safe(reg, nreg, rh->buckets + h, hash_list) { BUG_ON(atomic_read(&reg->pending)); mempool_free(reg, rh->region_pool); } } if (rh->log) dm_dirty_log_destroy(rh->log); if (rh->region_pool) mempool_destroy(rh->region_pool); vfree(rh->buckets); kfree(rh); } EXPORT_SYMBOL_GPL(dm_region_hash_destroy); struct dm_dirty_log *dm_rh_dirty_log(struct dm_region_hash *rh) { return rh->log; } EXPORT_SYMBOL_GPL(dm_rh_dirty_log); static unsigned rh_hash(struct dm_region_hash *rh, region_t region) { return (unsigned) ((region * rh->prime) >> rh->shift) & rh->mask; } static struct dm_region *__rh_lookup(struct dm_region_hash *rh, region_t region) { struct dm_region *reg; struct list_head *bucket = rh->buckets + rh_hash(rh, region); list_for_each_entry(reg, bucket, hash_list) if (reg->key == region) return reg; return NULL; } static void __rh_insert(struct dm_region_hash *rh, struct dm_region *reg) { list_add(&reg->hash_list, rh->buckets + rh_hash(rh, reg->key)); } static struct dm_region *__rh_alloc(struct dm_region_hash *rh, region_t region) { struct dm_region *reg, *nreg; nreg = mempool_alloc(rh->region_pool, GFP_ATOMIC); if (unlikely(!nreg)) nreg = kmalloc(sizeof(*nreg), GFP_NOIO | __GFP_NOFAIL); nreg->state = rh->log->type->in_sync(rh->log, region, 1) ? DM_RH_CLEAN : DM_RH_NOSYNC; nreg->rh = rh; nreg->key = region; INIT_LIST_HEAD(&nreg->list);