11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * dm-snapshot.c 31da177e4SLinus Torvalds * 41da177e4SLinus Torvalds * Copyright (C) 2001-2002 Sistina Software (UK) Limited. 51da177e4SLinus Torvalds * 61da177e4SLinus Torvalds * This file is released under the GPL. 71da177e4SLinus Torvalds */ 81da177e4SLinus Torvalds 91da177e4SLinus Torvalds #include <linux/blkdev.h> 101da177e4SLinus Torvalds #include <linux/ctype.h> 111da177e4SLinus Torvalds #include <linux/device-mapper.h> 121da177e4SLinus Torvalds #include <linux/fs.h> 131da177e4SLinus Torvalds #include <linux/init.h> 141da177e4SLinus Torvalds #include <linux/kdev_t.h> 151da177e4SLinus Torvalds #include <linux/list.h> 161da177e4SLinus Torvalds #include <linux/mempool.h> 171da177e4SLinus Torvalds #include <linux/module.h> 181da177e4SLinus Torvalds #include <linux/slab.h> 191da177e4SLinus Torvalds #include <linux/vmalloc.h> 206f3c3f0aSvignesh babu #include <linux/log2.h> 211da177e4SLinus Torvalds 221da177e4SLinus Torvalds #include "dm-snap.h" 231da177e4SLinus Torvalds #include "dm-bio-list.h" 241da177e4SLinus Torvalds #include "kcopyd.h" 251da177e4SLinus Torvalds 2672d94861SAlasdair G Kergon #define DM_MSG_PREFIX "snapshots" 2772d94861SAlasdair G Kergon 281da177e4SLinus Torvalds /* 291da177e4SLinus Torvalds * The percentage increment we will wake up users at 301da177e4SLinus Torvalds */ 311da177e4SLinus Torvalds #define WAKE_UP_PERCENT 5 321da177e4SLinus Torvalds 331da177e4SLinus Torvalds /* 341da177e4SLinus Torvalds * kcopyd priority of snapshot operations 351da177e4SLinus Torvalds */ 361da177e4SLinus Torvalds #define SNAPSHOT_COPY_PRIORITY 2 371da177e4SLinus Torvalds 381da177e4SLinus Torvalds /* 398ee2767aSMilan Broz * Reserve 1MB for each snapshot initially (with minimum of 1 page). 401da177e4SLinus Torvalds */ 418ee2767aSMilan Broz #define SNAPSHOT_PAGES (((1UL << 20) >> PAGE_SHIFT) ? : 1) 421da177e4SLinus Torvalds 43c642f9e0SAdrian Bunk static struct workqueue_struct *ksnapd; 44c4028958SDavid Howells static void flush_queued_bios(struct work_struct *work); 45ca3a931fSAlasdair G Kergon 46028867acSAlasdair G Kergon struct dm_snap_pending_exception { 47028867acSAlasdair G Kergon struct dm_snap_exception e; 481da177e4SLinus Torvalds 491da177e4SLinus Torvalds /* 501da177e4SLinus Torvalds * Origin buffers waiting for this to complete are held 511da177e4SLinus Torvalds * in a bio list 521da177e4SLinus Torvalds */ 531da177e4SLinus Torvalds struct bio_list origin_bios; 541da177e4SLinus Torvalds struct bio_list snapshot_bios; 551da177e4SLinus Torvalds 561da177e4SLinus Torvalds /* 57eccf0817SAlasdair G Kergon * Short-term queue of pending exceptions prior to submission. 58eccf0817SAlasdair G Kergon */ 59eccf0817SAlasdair G Kergon struct list_head list; 60eccf0817SAlasdair G Kergon 61eccf0817SAlasdair G Kergon /* 62b4b610f6SAlasdair G Kergon * The primary pending_exception is the one that holds 634b832e8dSAlasdair G Kergon * the ref_count and the list of origin_bios for a 64b4b610f6SAlasdair G Kergon * group of pending_exceptions. It is always last to get freed. 65b4b610f6SAlasdair G Kergon * These fields get set up when writing to the origin. 661da177e4SLinus Torvalds */ 67028867acSAlasdair G Kergon struct dm_snap_pending_exception *primary_pe; 68b4b610f6SAlasdair G Kergon 69b4b610f6SAlasdair G Kergon /* 70b4b610f6SAlasdair G Kergon * Number of pending_exceptions processing this chunk. 71b4b610f6SAlasdair G Kergon * When this drops to zero we must complete the origin bios. 72b4b610f6SAlasdair G Kergon * If incrementing or decrementing this, hold pe->snap->lock for 73b4b610f6SAlasdair G Kergon * the sibling concerned and not pe->primary_pe->snap->lock unless 74b4b610f6SAlasdair G Kergon * they are the same. 75b4b610f6SAlasdair G Kergon */ 764b832e8dSAlasdair G Kergon atomic_t ref_count; 771da177e4SLinus Torvalds 781da177e4SLinus Torvalds /* Pointer back to snapshot context */ 791da177e4SLinus Torvalds struct dm_snapshot *snap; 801da177e4SLinus Torvalds 811da177e4SLinus Torvalds /* 821da177e4SLinus Torvalds * 1 indicates the exception has already been sent to 831da177e4SLinus Torvalds * kcopyd. 841da177e4SLinus Torvalds */ 851da177e4SLinus Torvalds int started; 861da177e4SLinus Torvalds }; 871da177e4SLinus Torvalds 881da177e4SLinus Torvalds /* 891da177e4SLinus Torvalds * Hash table mapping origin volumes to lists of snapshots and 901da177e4SLinus Torvalds * a lock to protect it 911da177e4SLinus Torvalds */ 92e18b890bSChristoph Lameter static struct kmem_cache *exception_cache; 93e18b890bSChristoph Lameter static struct kmem_cache *pending_cache; 941da177e4SLinus Torvalds static mempool_t *pending_pool; 951da177e4SLinus Torvalds 961da177e4SLinus Torvalds /* 971da177e4SLinus Torvalds * One of these per registered origin, held in the snapshot_origins hash 981da177e4SLinus Torvalds */ 991da177e4SLinus Torvalds struct origin { 1001da177e4SLinus Torvalds /* The origin device */ 1011da177e4SLinus Torvalds struct block_device *bdev; 1021da177e4SLinus Torvalds 1031da177e4SLinus Torvalds struct list_head hash_list; 1041da177e4SLinus Torvalds 1051da177e4SLinus Torvalds /* List of snapshots for this origin */ 1061da177e4SLinus Torvalds struct list_head snapshots; 1071da177e4SLinus Torvalds }; 1081da177e4SLinus Torvalds 1091da177e4SLinus Torvalds /* 1101da177e4SLinus Torvalds * Size of the hash table for origin volumes. If we make this 1111da177e4SLinus Torvalds * the size of the minors list then it should be nearly perfect 1121da177e4SLinus Torvalds */ 1131da177e4SLinus Torvalds #define ORIGIN_HASH_SIZE 256 1141da177e4SLinus Torvalds #define ORIGIN_MASK 0xFF 1151da177e4SLinus Torvalds static struct list_head *_origins; 1161da177e4SLinus Torvalds static struct rw_semaphore _origins_lock; 1171da177e4SLinus Torvalds 1181da177e4SLinus Torvalds static int init_origin_hash(void) 1191da177e4SLinus Torvalds { 1201da177e4SLinus Torvalds int i; 1211da177e4SLinus Torvalds 1221da177e4SLinus Torvalds _origins = kmalloc(ORIGIN_HASH_SIZE * sizeof(struct list_head), 1231da177e4SLinus Torvalds GFP_KERNEL); 1241da177e4SLinus Torvalds if (!_origins) { 12572d94861SAlasdair G Kergon DMERR("unable to allocate memory"); 1261da177e4SLinus Torvalds return -ENOMEM; 1271da177e4SLinus Torvalds } 1281da177e4SLinus Torvalds 1291da177e4SLinus Torvalds for (i = 0; i < ORIGIN_HASH_SIZE; i++) 1301da177e4SLinus Torvalds INIT_LIST_HEAD(_origins + i); 1311da177e4SLinus Torvalds init_rwsem(&_origins_lock); 1321da177e4SLinus Torvalds 1331da177e4SLinus Torvalds return 0; 1341da177e4SLinus Torvalds } 1351da177e4SLinus Torvalds 1361da177e4SLinus Torvalds static void exit_origin_hash(void) 1371da177e4SLinus Torvalds { 1381da177e4SLinus Torvalds kfree(_origins); 1391da177e4SLinus Torvalds } 1401da177e4SLinus Torvalds 141028867acSAlasdair G Kergon static unsigned origin_hash(struct block_device *bdev) 1421da177e4SLinus Torvalds { 1431da177e4SLinus Torvalds return bdev->bd_dev & ORIGIN_MASK; 1441da177e4SLinus Torvalds } 1451da177e4SLinus Torvalds 1461da177e4SLinus Torvalds static struct origin *__lookup_origin(struct block_device *origin) 1471da177e4SLinus Torvalds { 1481da177e4SLinus Torvalds struct list_head *ol; 1491da177e4SLinus Torvalds struct origin *o; 1501da177e4SLinus Torvalds 1511da177e4SLinus Torvalds ol = &_origins[origin_hash(origin)]; 1521da177e4SLinus Torvalds list_for_each_entry (o, ol, hash_list) 1531da177e4SLinus Torvalds if (bdev_equal(o->bdev, origin)) 1541da177e4SLinus Torvalds return o; 1551da177e4SLinus Torvalds 1561da177e4SLinus Torvalds return NULL; 1571da177e4SLinus Torvalds } 1581da177e4SLinus Torvalds 1591da177e4SLinus Torvalds static void __insert_origin(struct origin *o) 1601da177e4SLinus Torvalds { 1611da177e4SLinus Torvalds struct list_head *sl = &_origins[origin_hash(o->bdev)]; 1621da177e4SLinus Torvalds list_add_tail(&o->hash_list, sl); 1631da177e4SLinus Torvalds } 1641da177e4SLinus Torvalds 1651da177e4SLinus Torvalds /* 1661da177e4SLinus Torvalds * Make a note of the snapshot and its origin so we can look it 1671da177e4SLinus Torvalds * up when the origin has a write on it. 1681da177e4SLinus Torvalds */ 1691da177e4SLinus Torvalds static int register_snapshot(struct dm_snapshot *snap) 1701da177e4SLinus Torvalds { 1711da177e4SLinus Torvalds struct origin *o; 1721da177e4SLinus Torvalds struct block_device *bdev = snap->origin->bdev; 1731da177e4SLinus Torvalds 1741da177e4SLinus Torvalds down_write(&_origins_lock); 1751da177e4SLinus Torvalds o = __lookup_origin(bdev); 1761da177e4SLinus Torvalds 1771da177e4SLinus Torvalds if (!o) { 1781da177e4SLinus Torvalds /* New origin */ 1791da177e4SLinus Torvalds o = kmalloc(sizeof(*o), GFP_KERNEL); 1801da177e4SLinus Torvalds if (!o) { 1811da177e4SLinus Torvalds up_write(&_origins_lock); 1821da177e4SLinus Torvalds return -ENOMEM; 1831da177e4SLinus Torvalds } 1841da177e4SLinus Torvalds 1851da177e4SLinus Torvalds /* Initialise the struct */ 1861da177e4SLinus Torvalds INIT_LIST_HEAD(&o->snapshots); 1871da177e4SLinus Torvalds o->bdev = bdev; 1881da177e4SLinus Torvalds 1891da177e4SLinus Torvalds __insert_origin(o); 1901da177e4SLinus Torvalds } 1911da177e4SLinus Torvalds 1921da177e4SLinus Torvalds list_add_tail(&snap->list, &o->snapshots); 1931da177e4SLinus Torvalds 1941da177e4SLinus Torvalds up_write(&_origins_lock); 1951da177e4SLinus Torvalds return 0; 1961da177e4SLinus Torvalds } 1971da177e4SLinus Torvalds 1981da177e4SLinus Torvalds static void unregister_snapshot(struct dm_snapshot *s) 1991da177e4SLinus Torvalds { 2001da177e4SLinus Torvalds struct origin *o; 2011da177e4SLinus Torvalds 2021da177e4SLinus Torvalds down_write(&_origins_lock); 2031da177e4SLinus Torvalds o = __lookup_origin(s->origin->bdev); 2041da177e4SLinus Torvalds 2051da177e4SLinus Torvalds list_del(&s->list); 2061da177e4SLinus Torvalds if (list_empty(&o->snapshots)) { 2071da177e4SLinus Torvalds list_del(&o->hash_list); 2081da177e4SLinus Torvalds kfree(o); 2091da177e4SLinus Torvalds } 2101da177e4SLinus Torvalds 2111da177e4SLinus Torvalds up_write(&_origins_lock); 2121da177e4SLinus Torvalds } 2131da177e4SLinus Torvalds 2141da177e4SLinus Torvalds /* 2151da177e4SLinus Torvalds * Implementation of the exception hash tables. 216d74f81f8SMilan Broz * The lowest hash_shift bits of the chunk number are ignored, allowing 217d74f81f8SMilan Broz * some consecutive chunks to be grouped together. 2181da177e4SLinus Torvalds */ 219d74f81f8SMilan Broz static int init_exception_table(struct exception_table *et, uint32_t size, 220d74f81f8SMilan Broz unsigned hash_shift) 2211da177e4SLinus Torvalds { 2221da177e4SLinus Torvalds unsigned int i; 2231da177e4SLinus Torvalds 224d74f81f8SMilan Broz et->hash_shift = hash_shift; 2251da177e4SLinus Torvalds et->hash_mask = size - 1; 2261da177e4SLinus Torvalds et->table = dm_vcalloc(size, sizeof(struct list_head)); 2271da177e4SLinus Torvalds if (!et->table) 2281da177e4SLinus Torvalds return -ENOMEM; 2291da177e4SLinus Torvalds 2301da177e4SLinus Torvalds for (i = 0; i < size; i++) 2311da177e4SLinus Torvalds INIT_LIST_HEAD(et->table + i); 2321da177e4SLinus Torvalds 2331da177e4SLinus Torvalds return 0; 2341da177e4SLinus Torvalds } 2351da177e4SLinus Torvalds 236e18b890bSChristoph Lameter static void exit_exception_table(struct exception_table *et, struct kmem_cache *mem) 2371da177e4SLinus Torvalds { 2381da177e4SLinus Torvalds struct list_head *slot; 239028867acSAlasdair G Kergon struct dm_snap_exception *ex, *next; 2401da177e4SLinus Torvalds int i, size; 2411da177e4SLinus Torvalds 2421da177e4SLinus Torvalds size = et->hash_mask + 1; 2431da177e4SLinus Torvalds for (i = 0; i < size; i++) { 2441da177e4SLinus Torvalds slot = et->table + i; 2451da177e4SLinus Torvalds 2461da177e4SLinus Torvalds list_for_each_entry_safe (ex, next, slot, hash_list) 2471da177e4SLinus Torvalds kmem_cache_free(mem, ex); 2481da177e4SLinus Torvalds } 2491da177e4SLinus Torvalds 2501da177e4SLinus Torvalds vfree(et->table); 2511da177e4SLinus Torvalds } 2521da177e4SLinus Torvalds 253028867acSAlasdair G Kergon static uint32_t exception_hash(struct exception_table *et, chunk_t chunk) 2541da177e4SLinus Torvalds { 255d74f81f8SMilan Broz return (chunk >> et->hash_shift) & et->hash_mask; 2561da177e4SLinus Torvalds } 2571da177e4SLinus Torvalds 258028867acSAlasdair G Kergon static void insert_exception(struct exception_table *eh, 259028867acSAlasdair G Kergon struct dm_snap_exception *e) 2601da177e4SLinus Torvalds { 2611da177e4SLinus Torvalds struct list_head *l = &eh->table[exception_hash(eh, e->old_chunk)]; 2621da177e4SLinus Torvalds list_add(&e->hash_list, l); 2631da177e4SLinus Torvalds } 2641da177e4SLinus Torvalds 265028867acSAlasdair G Kergon static void remove_exception(struct dm_snap_exception *e) 2661da177e4SLinus Torvalds { 2671da177e4SLinus Torvalds list_del(&e->hash_list); 2681da177e4SLinus Torvalds } 2691da177e4SLinus Torvalds 2701da177e4SLinus Torvalds /* 2711da177e4SLinus Torvalds * Return the exception data for a sector, or NULL if not 2721da177e4SLinus Torvalds * remapped. 2731da177e4SLinus Torvalds */ 274028867acSAlasdair G Kergon static struct dm_snap_exception *lookup_exception(struct exception_table *et, 2751da177e4SLinus Torvalds chunk_t chunk) 2761da177e4SLinus Torvalds { 2771da177e4SLinus Torvalds struct list_head *slot; 278028867acSAlasdair G Kergon struct dm_snap_exception *e; 2791da177e4SLinus Torvalds 2801da177e4SLinus Torvalds slot = &et->table[exception_hash(et, chunk)]; 2811da177e4SLinus Torvalds list_for_each_entry (e, slot, hash_list) 282d74f81f8SMilan Broz if (chunk >= e->old_chunk && 283d74f81f8SMilan Broz chunk <= e->old_chunk + dm_consecutive_chunk_count(e)) 2841da177e4SLinus Torvalds return e; 2851da177e4SLinus Torvalds 2861da177e4SLinus Torvalds return NULL; 2871da177e4SLinus Torvalds } 2881da177e4SLinus Torvalds 289028867acSAlasdair G Kergon static struct dm_snap_exception *alloc_exception(void) 2901da177e4SLinus Torvalds { 291028867acSAlasdair G Kergon struct dm_snap_exception *e; 2921da177e4SLinus Torvalds 2931da177e4SLinus Torvalds e = kmem_cache_alloc(exception_cache, GFP_NOIO); 2941da177e4SLinus Torvalds if (!e) 2951da177e4SLinus Torvalds e = kmem_cache_alloc(exception_cache, GFP_ATOMIC); 2961da177e4SLinus Torvalds 2971da177e4SLinus Torvalds return e; 2981da177e4SLinus Torvalds } 2991da177e4SLinus Torvalds 300028867acSAlasdair G Kergon static void free_exception(struct dm_snap_exception *e) 3011da177e4SLinus Torvalds { 3021da177e4SLinus Torvalds kmem_cache_free(exception_cache, e); 3031da177e4SLinus Torvalds } 3041da177e4SLinus Torvalds 305028867acSAlasdair G Kergon static struct dm_snap_pending_exception *alloc_pending_exception(void) 3061da177e4SLinus Torvalds { 3071da177e4SLinus Torvalds return mempool_alloc(pending_pool, GFP_NOIO); 3081da177e4SLinus Torvalds } 3091da177e4SLinus Torvalds 310028867acSAlasdair G Kergon static void free_pending_exception(struct dm_snap_pending_exception *pe) 3111da177e4SLinus Torvalds { 3121da177e4SLinus Torvalds mempool_free(pe, pending_pool); 3131da177e4SLinus Torvalds } 3141da177e4SLinus Torvalds 315d74f81f8SMilan Broz static void insert_completed_exception(struct dm_snapshot *s, 316d74f81f8SMilan Broz struct dm_snap_exception *new_e) 317d74f81f8SMilan Broz { 318d74f81f8SMilan Broz struct exception_table *eh = &s->complete; 319d74f81f8SMilan Broz struct list_head *l; 320d74f81f8SMilan Broz struct dm_snap_exception *e = NULL; 321d74f81f8SMilan Broz 322d74f81f8SMilan Broz l = &eh->table[exception_hash(eh, new_e->old_chunk)]; 323d74f81f8SMilan Broz 324d74f81f8SMilan Broz /* Add immediately if this table doesn't support consecutive chunks */ 325d74f81f8SMilan Broz if (!eh->hash_shift) 326d74f81f8SMilan Broz goto out; 327d74f81f8SMilan Broz 328d74f81f8SMilan Broz /* List is ordered by old_chunk */ 329d74f81f8SMilan Broz list_for_each_entry_reverse(e, l, hash_list) { 330d74f81f8SMilan Broz /* Insert after an existing chunk? */ 331d74f81f8SMilan Broz if (new_e->old_chunk == (e->old_chunk + 332d74f81f8SMilan Broz dm_consecutive_chunk_count(e) + 1) && 333d74f81f8SMilan Broz new_e->new_chunk == (dm_chunk_number(e->new_chunk) + 334d74f81f8SMilan Broz dm_consecutive_chunk_count(e) + 1)) { 335d74f81f8SMilan Broz dm_consecutive_chunk_count_inc(e); 336d74f81f8SMilan Broz free_exception(new_e); 337d74f81f8SMilan Broz return; 338d74f81f8SMilan Broz } 339d74f81f8SMilan Broz 340d74f81f8SMilan Broz /* Insert before an existing chunk? */ 341d74f81f8SMilan Broz if (new_e->old_chunk == (e->old_chunk - 1) && 342d74f81f8SMilan Broz new_e->new_chunk == (dm_chunk_number(e->new_chunk) - 1)) { 343d74f81f8SMilan Broz dm_consecutive_chunk_count_inc(e); 344d74f81f8SMilan Broz e->old_chunk--; 345d74f81f8SMilan Broz e->new_chunk--; 346d74f81f8SMilan Broz free_exception(new_e); 347d74f81f8SMilan Broz return; 348d74f81f8SMilan Broz } 349d74f81f8SMilan Broz 350d74f81f8SMilan Broz if (new_e->old_chunk > e->old_chunk) 351d74f81f8SMilan Broz break; 352d74f81f8SMilan Broz } 353d74f81f8SMilan Broz 354d74f81f8SMilan Broz out: 355d74f81f8SMilan Broz list_add(&new_e->hash_list, e ? &e->hash_list : l); 356d74f81f8SMilan Broz } 357d74f81f8SMilan Broz 3581da177e4SLinus Torvalds int dm_add_exception(struct dm_snapshot *s, chunk_t old, chunk_t new) 3591da177e4SLinus Torvalds { 360028867acSAlasdair G Kergon struct dm_snap_exception *e; 3611da177e4SLinus Torvalds 3621da177e4SLinus Torvalds e = alloc_exception(); 3631da177e4SLinus Torvalds if (!e) 3641da177e4SLinus Torvalds return -ENOMEM; 3651da177e4SLinus Torvalds 3661da177e4SLinus Torvalds e->old_chunk = old; 367d74f81f8SMilan Broz 368d74f81f8SMilan Broz /* Consecutive_count is implicitly initialised to zero */ 3691da177e4SLinus Torvalds e->new_chunk = new; 370d74f81f8SMilan Broz 371d74f81f8SMilan Broz insert_completed_exception(s, e); 372d74f81f8SMilan Broz 3731da177e4SLinus Torvalds return 0; 3741da177e4SLinus Torvalds } 3751da177e4SLinus Torvalds 3761da177e4SLinus Torvalds /* 3771da177e4SLinus Torvalds * Hard coded magic. 3781da177e4SLinus Torvalds */ 3791da177e4SLinus Torvalds static int calc_max_buckets(void) 3801da177e4SLinus Torvalds { 3811da177e4SLinus Torvalds /* use a fixed size of 2MB */ 3821da177e4SLinus Torvalds unsigned long mem = 2 * 1024 * 1024; 3831da177e4SLinus Torvalds mem /= sizeof(struct list_head); 3841da177e4SLinus Torvalds 3851da177e4SLinus Torvalds return mem; 3861da177e4SLinus Torvalds } 3871da177e4SLinus Torvalds 3881da177e4SLinus Torvalds /* 3891da177e4SLinus Torvalds * Allocate room for a suitable hash table. 3901da177e4SLinus Torvalds */ 3911da177e4SLinus Torvalds static int init_hash_tables(struct dm_snapshot *s) 3921da177e4SLinus Torvalds { 3931da177e4SLinus Torvalds sector_t hash_size, cow_dev_size, origin_dev_size, max_buckets; 3941da177e4SLinus Torvalds 3951da177e4SLinus Torvalds /* 3961da177e4SLinus Torvalds * Calculate based on the size of the original volume or 3971da177e4SLinus Torvalds * the COW volume... 3981da177e4SLinus Torvalds */ 3991da177e4SLinus Torvalds cow_dev_size = get_dev_size(s->cow->bdev); 4001da177e4SLinus Torvalds origin_dev_size = get_dev_size(s->origin->bdev); 4011da177e4SLinus Torvalds max_buckets = calc_max_buckets(); 4021da177e4SLinus Torvalds 4031da177e4SLinus Torvalds hash_size = min(origin_dev_size, cow_dev_size) >> s->chunk_shift; 4041da177e4SLinus Torvalds hash_size = min(hash_size, max_buckets); 4051da177e4SLinus Torvalds 4068defd830SRobert P. J. Day hash_size = rounddown_pow_of_two(hash_size); 407d74f81f8SMilan Broz if (init_exception_table(&s->complete, hash_size, 408d74f81f8SMilan Broz DM_CHUNK_CONSECUTIVE_BITS)) 4091da177e4SLinus Torvalds return -ENOMEM; 4101da177e4SLinus Torvalds 4111da177e4SLinus Torvalds /* 4121da177e4SLinus Torvalds * Allocate hash table for in-flight exceptions 4131da177e4SLinus Torvalds * Make this smaller than the real hash table 4141da177e4SLinus Torvalds */ 4151da177e4SLinus Torvalds hash_size >>= 3; 4161da177e4SLinus Torvalds if (hash_size < 64) 4171da177e4SLinus Torvalds hash_size = 64; 4181da177e4SLinus Torvalds 419d74f81f8SMilan Broz if (init_exception_table(&s->pending, hash_size, 0)) { 4201da177e4SLinus Torvalds exit_exception_table(&s->complete, exception_cache); 4211da177e4SLinus Torvalds return -ENOMEM; 4221da177e4SLinus Torvalds } 4231da177e4SLinus Torvalds 4241da177e4SLinus Torvalds return 0; 4251da177e4SLinus Torvalds } 4261da177e4SLinus Torvalds 4271da177e4SLinus Torvalds /* 4281da177e4SLinus Torvalds * Round a number up to the nearest 'size' boundary. size must 4291da177e4SLinus Torvalds * be a power of 2. 4301da177e4SLinus Torvalds */ 431028867acSAlasdair G Kergon static ulong round_up(ulong n, ulong size) 4321da177e4SLinus Torvalds { 4331da177e4SLinus Torvalds size--; 4341da177e4SLinus Torvalds return (n + size) & ~size; 4351da177e4SLinus Torvalds } 4361da177e4SLinus Torvalds 4374c7e3bf4SMark McLoughlin static int set_chunk_size(struct dm_snapshot *s, const char *chunk_size_arg, 4384c7e3bf4SMark McLoughlin char **error) 4394c7e3bf4SMark McLoughlin { 4404c7e3bf4SMark McLoughlin unsigned long chunk_size; 4414c7e3bf4SMark McLoughlin char *value; 4424c7e3bf4SMark McLoughlin 4434c7e3bf4SMark McLoughlin chunk_size = simple_strtoul(chunk_size_arg, &value, 10); 4444c7e3bf4SMark McLoughlin if (*chunk_size_arg == '\0' || *value != '\0') { 4454c7e3bf4SMark McLoughlin *error = "Invalid chunk size"; 4464c7e3bf4SMark McLoughlin return -EINVAL; 4474c7e3bf4SMark McLoughlin } 4484c7e3bf4SMark McLoughlin 4494c7e3bf4SMark McLoughlin if (!chunk_size) { 4504c7e3bf4SMark McLoughlin s->chunk_size = s->chunk_mask = s->chunk_shift = 0; 4514c7e3bf4SMark McLoughlin return 0; 4524c7e3bf4SMark McLoughlin } 4534c7e3bf4SMark McLoughlin 4544c7e3bf4SMark McLoughlin /* 4554c7e3bf4SMark McLoughlin * Chunk size must be multiple of page size. Silently 4564c7e3bf4SMark McLoughlin * round up if it's not. 4574c7e3bf4SMark McLoughlin */ 4584c7e3bf4SMark McLoughlin chunk_size = round_up(chunk_size, PAGE_SIZE >> 9); 4594c7e3bf4SMark McLoughlin 4604c7e3bf4SMark McLoughlin /* Check chunk_size is a power of 2 */ 4616f3c3f0aSvignesh babu if (!is_power_of_2(chunk_size)) { 4624c7e3bf4SMark McLoughlin *error = "Chunk size is not a power of 2"; 4634c7e3bf4SMark McLoughlin return -EINVAL; 4644c7e3bf4SMark McLoughlin } 4654c7e3bf4SMark McLoughlin 4664c7e3bf4SMark McLoughlin /* Validate the chunk size against the device block size */ 4674c7e3bf4SMark McLoughlin if (chunk_size % (bdev_hardsect_size(s->cow->bdev) >> 9)) { 4684c7e3bf4SMark McLoughlin *error = "Chunk size is not a multiple of device blocksize"; 4694c7e3bf4SMark McLoughlin return -EINVAL; 4704c7e3bf4SMark McLoughlin } 4714c7e3bf4SMark McLoughlin 4724c7e3bf4SMark McLoughlin s->chunk_size = chunk_size; 4734c7e3bf4SMark McLoughlin s->chunk_mask = chunk_size - 1; 4744c7e3bf4SMark McLoughlin s->chunk_shift = ffs(chunk_size) - 1; 4754c7e3bf4SMark McLoughlin 4764c7e3bf4SMark McLoughlin return 0; 4774c7e3bf4SMark McLoughlin } 4784c7e3bf4SMark McLoughlin 4791da177e4SLinus Torvalds /* 4801da177e4SLinus Torvalds * Construct a snapshot mapping: <origin_dev> <COW-dev> <p/n> <chunk-size> 4811da177e4SLinus Torvalds */ 4821da177e4SLinus Torvalds static int snapshot_ctr(struct dm_target *ti, unsigned int argc, char **argv) 4831da177e4SLinus Torvalds { 4841da177e4SLinus Torvalds struct dm_snapshot *s; 4851da177e4SLinus Torvalds int r = -EINVAL; 4861da177e4SLinus Torvalds char persistent; 4871da177e4SLinus Torvalds char *origin_path; 4881da177e4SLinus Torvalds char *cow_path; 4891da177e4SLinus Torvalds 4904c7e3bf4SMark McLoughlin if (argc != 4) { 49172d94861SAlasdair G Kergon ti->error = "requires exactly 4 arguments"; 4921da177e4SLinus Torvalds r = -EINVAL; 4931da177e4SLinus Torvalds goto bad1; 4941da177e4SLinus Torvalds } 4951da177e4SLinus Torvalds 4961da177e4SLinus Torvalds origin_path = argv[0]; 4971da177e4SLinus Torvalds cow_path = argv[1]; 4981da177e4SLinus Torvalds persistent = toupper(*argv[2]); 4991da177e4SLinus Torvalds 5001da177e4SLinus Torvalds if (persistent != 'P' && persistent != 'N') { 5011da177e4SLinus Torvalds ti->error = "Persistent flag is not P or N"; 5021da177e4SLinus Torvalds r = -EINVAL; 5031da177e4SLinus Torvalds goto bad1; 5041da177e4SLinus Torvalds } 5051da177e4SLinus Torvalds 5061da177e4SLinus Torvalds s = kmalloc(sizeof(*s), GFP_KERNEL); 5071da177e4SLinus Torvalds if (s == NULL) { 5081da177e4SLinus Torvalds ti->error = "Cannot allocate snapshot context private " 5091da177e4SLinus Torvalds "structure"; 5101da177e4SLinus Torvalds r = -ENOMEM; 5111da177e4SLinus Torvalds goto bad1; 5121da177e4SLinus Torvalds } 5131da177e4SLinus Torvalds 5141da177e4SLinus Torvalds r = dm_get_device(ti, origin_path, 0, ti->len, FMODE_READ, &s->origin); 5151da177e4SLinus Torvalds if (r) { 5161da177e4SLinus Torvalds ti->error = "Cannot get origin device"; 5171da177e4SLinus Torvalds goto bad2; 5181da177e4SLinus Torvalds } 5191da177e4SLinus Torvalds 5201da177e4SLinus Torvalds r = dm_get_device(ti, cow_path, 0, 0, 5211da177e4SLinus Torvalds FMODE_READ | FMODE_WRITE, &s->cow); 5221da177e4SLinus Torvalds if (r) { 5231da177e4SLinus Torvalds dm_put_device(ti, s->origin); 5241da177e4SLinus Torvalds ti->error = "Cannot get COW device"; 5251da177e4SLinus Torvalds goto bad2; 5261da177e4SLinus Torvalds } 5271da177e4SLinus Torvalds 5284c7e3bf4SMark McLoughlin r = set_chunk_size(s, argv[3], &ti->error); 5294c7e3bf4SMark McLoughlin if (r) 5301da177e4SLinus Torvalds goto bad3; 5311da177e4SLinus Torvalds 5321da177e4SLinus Torvalds s->type = persistent; 5331da177e4SLinus Torvalds 5341da177e4SLinus Torvalds s->valid = 1; 535aa14edebSAlasdair G Kergon s->active = 0; 5361da177e4SLinus Torvalds s->last_percent = 0; 5371da177e4SLinus Torvalds init_rwsem(&s->lock); 538ca3a931fSAlasdair G Kergon spin_lock_init(&s->pe_lock); 53972727badSMikulas Patocka s->ti = ti; 5401da177e4SLinus Torvalds 5411da177e4SLinus Torvalds /* Allocate hash table for COW data */ 5421da177e4SLinus Torvalds if (init_hash_tables(s)) { 5431da177e4SLinus Torvalds ti->error = "Unable to allocate hash table space"; 5441da177e4SLinus Torvalds r = -ENOMEM; 5451da177e4SLinus Torvalds goto bad3; 5461da177e4SLinus Torvalds } 5471da177e4SLinus Torvalds 5481da177e4SLinus Torvalds s->store.snap = s; 5491da177e4SLinus Torvalds 5501da177e4SLinus Torvalds if (persistent == 'P') 5514c7e3bf4SMark McLoughlin r = dm_create_persistent(&s->store); 5521da177e4SLinus Torvalds else 5534c7e3bf4SMark McLoughlin r = dm_create_transient(&s->store); 5541da177e4SLinus Torvalds 5551da177e4SLinus Torvalds if (r) { 5561da177e4SLinus Torvalds ti->error = "Couldn't create exception store"; 5571da177e4SLinus Torvalds r = -EINVAL; 5581da177e4SLinus Torvalds goto bad4; 5591da177e4SLinus Torvalds } 5601da177e4SLinus Torvalds 5611da177e4SLinus Torvalds r = kcopyd_client_create(SNAPSHOT_PAGES, &s->kcopyd_client); 5621da177e4SLinus Torvalds if (r) { 5631da177e4SLinus Torvalds ti->error = "Could not create kcopyd client"; 5641da177e4SLinus Torvalds goto bad5; 5651da177e4SLinus Torvalds } 5661da177e4SLinus Torvalds 567aa14edebSAlasdair G Kergon /* Metadata must only be loaded into one table at once */ 568f9cea4f7SMark McLoughlin r = s->store.read_metadata(&s->store); 5690764147bSMilan Broz if (r < 0) { 570f9cea4f7SMark McLoughlin ti->error = "Failed to read snapshot metadata"; 571f9cea4f7SMark McLoughlin goto bad6; 5720764147bSMilan Broz } else if (r > 0) { 5730764147bSMilan Broz s->valid = 0; 5740764147bSMilan Broz DMWARN("Snapshot is marked invalid."); 575f9cea4f7SMark McLoughlin } 576aa14edebSAlasdair G Kergon 577ca3a931fSAlasdair G Kergon bio_list_init(&s->queued_bios); 578c4028958SDavid Howells INIT_WORK(&s->queued_bios_work, flush_queued_bios); 579ca3a931fSAlasdair G Kergon 5801da177e4SLinus Torvalds /* Add snapshot to the list of snapshots for this origin */ 581aa14edebSAlasdair G Kergon /* Exceptions aren't triggered till snapshot_resume() is called */ 5821da177e4SLinus Torvalds if (register_snapshot(s)) { 5831da177e4SLinus Torvalds r = -EINVAL; 5841da177e4SLinus Torvalds ti->error = "Cannot register snapshot origin"; 5851da177e4SLinus Torvalds goto bad6; 5861da177e4SLinus Torvalds } 5871da177e4SLinus Torvalds 5881da177e4SLinus Torvalds ti->private = s; 589c51c2752SAlasdair G Kergon ti->split_io = s->chunk_size; 5901da177e4SLinus Torvalds 5911da177e4SLinus Torvalds return 0; 5921da177e4SLinus Torvalds 5931da177e4SLinus Torvalds bad6: 5941da177e4SLinus Torvalds kcopyd_client_destroy(s->kcopyd_client); 5951da177e4SLinus Torvalds 5961da177e4SLinus Torvalds bad5: 5971da177e4SLinus Torvalds s->store.destroy(&s->store); 5981da177e4SLinus Torvalds 5991da177e4SLinus Torvalds bad4: 6001da177e4SLinus Torvalds exit_exception_table(&s->pending, pending_cache); 6011da177e4SLinus Torvalds exit_exception_table(&s->complete, exception_cache); 6021da177e4SLinus Torvalds 6031da177e4SLinus Torvalds bad3: 6041da177e4SLinus Torvalds dm_put_device(ti, s->cow); 6051da177e4SLinus Torvalds dm_put_device(ti, s->origin); 6061da177e4SLinus Torvalds 6071da177e4SLinus Torvalds bad2: 6081da177e4SLinus Torvalds kfree(s); 6091da177e4SLinus Torvalds 6101da177e4SLinus Torvalds bad1: 6111da177e4SLinus Torvalds return r; 6121da177e4SLinus Torvalds } 6131da177e4SLinus Torvalds 61431c93a0cSMilan Broz static void __free_exceptions(struct dm_snapshot *s) 61531c93a0cSMilan Broz { 61631c93a0cSMilan Broz kcopyd_client_destroy(s->kcopyd_client); 61731c93a0cSMilan Broz s->kcopyd_client = NULL; 61831c93a0cSMilan Broz 61931c93a0cSMilan Broz exit_exception_table(&s->pending, pending_cache); 62031c93a0cSMilan Broz exit_exception_table(&s->complete, exception_cache); 62131c93a0cSMilan Broz 62231c93a0cSMilan Broz s->store.destroy(&s->store); 62331c93a0cSMilan Broz } 62431c93a0cSMilan Broz 6251da177e4SLinus Torvalds static void snapshot_dtr(struct dm_target *ti) 6261da177e4SLinus Torvalds { 627028867acSAlasdair G Kergon struct dm_snapshot *s = ti->private; 6281da177e4SLinus Torvalds 629ca3a931fSAlasdair G Kergon flush_workqueue(ksnapd); 630ca3a931fSAlasdair G Kergon 631138728dcSAlasdair G Kergon /* Prevent further origin writes from using this snapshot. */ 632138728dcSAlasdair G Kergon /* After this returns there can be no new kcopyd jobs. */ 6331da177e4SLinus Torvalds unregister_snapshot(s); 6341da177e4SLinus Torvalds 63531c93a0cSMilan Broz __free_exceptions(s); 6361da177e4SLinus Torvalds 6371da177e4SLinus Torvalds dm_put_device(ti, s->origin); 6381da177e4SLinus Torvalds dm_put_device(ti, s->cow); 639138728dcSAlasdair G Kergon 6401da177e4SLinus Torvalds kfree(s); 6411da177e4SLinus Torvalds } 6421da177e4SLinus Torvalds 6431da177e4SLinus Torvalds /* 6441da177e4SLinus Torvalds * Flush a list of buffers. 6451da177e4SLinus Torvalds */ 6461da177e4SLinus Torvalds static void flush_bios(struct bio *bio) 6471da177e4SLinus Torvalds { 6481da177e4SLinus Torvalds struct bio *n; 6491da177e4SLinus Torvalds 6501da177e4SLinus Torvalds while (bio) { 6511da177e4SLinus Torvalds n = bio->bi_next; 6521da177e4SLinus Torvalds bio->bi_next = NULL; 6531da177e4SLinus Torvalds generic_make_request(bio); 6541da177e4SLinus Torvalds bio = n; 6551da177e4SLinus Torvalds } 6561da177e4SLinus Torvalds } 6571da177e4SLinus Torvalds 658c4028958SDavid Howells static void flush_queued_bios(struct work_struct *work) 659ca3a931fSAlasdair G Kergon { 660c4028958SDavid Howells struct dm_snapshot *s = 661c4028958SDavid Howells container_of(work, struct dm_snapshot, queued_bios_work); 662ca3a931fSAlasdair G Kergon struct bio *queued_bios; 663ca3a931fSAlasdair G Kergon unsigned long flags; 664ca3a931fSAlasdair G Kergon 665ca3a931fSAlasdair G Kergon spin_lock_irqsave(&s->pe_lock, flags); 666ca3a931fSAlasdair G Kergon queued_bios = bio_list_get(&s->queued_bios); 667ca3a931fSAlasdair G Kergon spin_unlock_irqrestore(&s->pe_lock, flags); 668ca3a931fSAlasdair G Kergon 669ca3a931fSAlasdair G Kergon flush_bios(queued_bios); 670ca3a931fSAlasdair G Kergon } 671ca3a931fSAlasdair G Kergon 6721da177e4SLinus Torvalds /* 6731da177e4SLinus Torvalds * Error a list of buffers. 6741da177e4SLinus Torvalds */ 6751da177e4SLinus Torvalds static void error_bios(struct bio *bio) 6761da177e4SLinus Torvalds { 6771da177e4SLinus Torvalds struct bio *n; 6781da177e4SLinus Torvalds 6791da177e4SLinus Torvalds while (bio) { 6801da177e4SLinus Torvalds n = bio->bi_next; 6811da177e4SLinus Torvalds bio->bi_next = NULL; 6826712ecf8SNeilBrown bio_io_error(bio); 6831da177e4SLinus Torvalds bio = n; 6841da177e4SLinus Torvalds } 6851da177e4SLinus Torvalds } 6861da177e4SLinus Torvalds 687695368acSAlasdair G Kergon static void __invalidate_snapshot(struct dm_snapshot *s, int err) 68876df1c65SAlasdair G Kergon { 68976df1c65SAlasdair G Kergon if (!s->valid) 69076df1c65SAlasdair G Kergon return; 69176df1c65SAlasdair G Kergon 69276df1c65SAlasdair G Kergon if (err == -EIO) 69376df1c65SAlasdair G Kergon DMERR("Invalidating snapshot: Error reading/writing."); 69476df1c65SAlasdair G Kergon else if (err == -ENOMEM) 69576df1c65SAlasdair G Kergon DMERR("Invalidating snapshot: Unable to allocate exception."); 69676df1c65SAlasdair G Kergon 69776df1c65SAlasdair G Kergon if (s->store.drop_snapshot) 69876df1c65SAlasdair G Kergon s->store.drop_snapshot(&s->store); 69976df1c65SAlasdair G Kergon 70076df1c65SAlasdair G Kergon s->valid = 0; 70176df1c65SAlasdair G Kergon 70272727badSMikulas Patocka dm_table_event(s->ti->table); 70376df1c65SAlasdair G Kergon } 70476df1c65SAlasdair G Kergon 705028867acSAlasdair G Kergon static void get_pending_exception(struct dm_snap_pending_exception *pe) 7064b832e8dSAlasdair G Kergon { 7074b832e8dSAlasdair G Kergon atomic_inc(&pe->ref_count); 7084b832e8dSAlasdair G Kergon } 7094b832e8dSAlasdair G Kergon 710028867acSAlasdair G Kergon static struct bio *put_pending_exception(struct dm_snap_pending_exception *pe) 7114b832e8dSAlasdair G Kergon { 712028867acSAlasdair G Kergon struct dm_snap_pending_exception *primary_pe; 7134b832e8dSAlasdair G Kergon struct bio *origin_bios = NULL; 7144b832e8dSAlasdair G Kergon 7154b832e8dSAlasdair G Kergon primary_pe = pe->primary_pe; 7164b832e8dSAlasdair G Kergon 7174b832e8dSAlasdair G Kergon /* 7184b832e8dSAlasdair G Kergon * If this pe is involved in a write to the origin and 7194b832e8dSAlasdair G Kergon * it is the last sibling to complete then release 7204b832e8dSAlasdair G Kergon * the bios for the original write to the origin. 7214b832e8dSAlasdair G Kergon */ 7224b832e8dSAlasdair G Kergon if (primary_pe && 7234b832e8dSAlasdair G Kergon atomic_dec_and_test(&primary_pe->ref_count)) 7244b832e8dSAlasdair G Kergon origin_bios = bio_list_get(&primary_pe->origin_bios); 7254b832e8dSAlasdair G Kergon 7264b832e8dSAlasdair G Kergon /* 7274b832e8dSAlasdair G Kergon * Free the pe if it's not linked to an origin write or if 7284b832e8dSAlasdair G Kergon * it's not itself a primary pe. 7294b832e8dSAlasdair G Kergon */ 7304b832e8dSAlasdair G Kergon if (!primary_pe || primary_pe != pe) 7314b832e8dSAlasdair G Kergon free_pending_exception(pe); 7324b832e8dSAlasdair G Kergon 7334b832e8dSAlasdair G Kergon /* 7344b832e8dSAlasdair G Kergon * Free the primary pe if nothing references it. 7354b832e8dSAlasdair G Kergon */ 7364b832e8dSAlasdair G Kergon if (primary_pe && !atomic_read(&primary_pe->ref_count)) 7374b832e8dSAlasdair G Kergon free_pending_exception(primary_pe); 7384b832e8dSAlasdair G Kergon 7394b832e8dSAlasdair G Kergon return origin_bios; 7404b832e8dSAlasdair G Kergon } 7414b832e8dSAlasdair G Kergon 742028867acSAlasdair G Kergon static void pending_complete(struct dm_snap_pending_exception *pe, int success) 7431da177e4SLinus Torvalds { 744028867acSAlasdair G Kergon struct dm_snap_exception *e; 7451da177e4SLinus Torvalds struct dm_snapshot *s = pe->snap; 7469d493fa8SAlasdair G Kergon struct bio *origin_bios = NULL; 7479d493fa8SAlasdair G Kergon struct bio *snapshot_bios = NULL; 7489d493fa8SAlasdair G Kergon int error = 0; 7491da177e4SLinus Torvalds 75076df1c65SAlasdair G Kergon if (!success) { 75176df1c65SAlasdair G Kergon /* Read/write error - snapshot is unusable */ 7521da177e4SLinus Torvalds down_write(&s->lock); 753695368acSAlasdair G Kergon __invalidate_snapshot(s, -EIO); 7549d493fa8SAlasdair G Kergon error = 1; 75576df1c65SAlasdair G Kergon goto out; 75676df1c65SAlasdair G Kergon } 75776df1c65SAlasdair G Kergon 75876df1c65SAlasdair G Kergon e = alloc_exception(); 75976df1c65SAlasdair G Kergon if (!e) { 76076df1c65SAlasdair G Kergon down_write(&s->lock); 761695368acSAlasdair G Kergon __invalidate_snapshot(s, -ENOMEM); 7629d493fa8SAlasdair G Kergon error = 1; 7631da177e4SLinus Torvalds goto out; 7641da177e4SLinus Torvalds } 7651da177e4SLinus Torvalds *e = pe->e; 7661da177e4SLinus Torvalds 7679d493fa8SAlasdair G Kergon down_write(&s->lock); 7689d493fa8SAlasdair G Kergon if (!s->valid) { 7699d493fa8SAlasdair G Kergon free_exception(e); 7709d493fa8SAlasdair G Kergon error = 1; 7719d493fa8SAlasdair G Kergon goto out; 7729d493fa8SAlasdair G Kergon } 7739d493fa8SAlasdair G Kergon 7741da177e4SLinus Torvalds /* 7751da177e4SLinus Torvalds * Add a proper exception, and remove the 7761da177e4SLinus Torvalds * in-flight exception from the list. 7771da177e4SLinus Torvalds */ 778d74f81f8SMilan Broz insert_completed_exception(s, e); 7791da177e4SLinus Torvalds 7801da177e4SLinus Torvalds out: 781695368acSAlasdair G Kergon remove_exception(&pe->e); 7829d493fa8SAlasdair G Kergon snapshot_bios = bio_list_get(&pe->snapshot_bios); 7834b832e8dSAlasdair G Kergon origin_bios = put_pending_exception(pe); 784b4b610f6SAlasdair G Kergon 7859d493fa8SAlasdair G Kergon up_write(&s->lock); 7869d493fa8SAlasdair G Kergon 7879d493fa8SAlasdair G Kergon /* Submit any pending write bios */ 7889d493fa8SAlasdair G Kergon if (error) 7899d493fa8SAlasdair G Kergon error_bios(snapshot_bios); 7909d493fa8SAlasdair G Kergon else 7919d493fa8SAlasdair G Kergon flush_bios(snapshot_bios); 7929d493fa8SAlasdair G Kergon 7939d493fa8SAlasdair G Kergon flush_bios(origin_bios); 7941da177e4SLinus Torvalds } 7951da177e4SLinus Torvalds 7961da177e4SLinus Torvalds static void commit_callback(void *context, int success) 7971da177e4SLinus Torvalds { 798028867acSAlasdair G Kergon struct dm_snap_pending_exception *pe = context; 799028867acSAlasdair G Kergon 8001da177e4SLinus Torvalds pending_complete(pe, success); 8011da177e4SLinus Torvalds } 8021da177e4SLinus Torvalds 8031da177e4SLinus Torvalds /* 8041da177e4SLinus Torvalds * Called when the copy I/O has finished. kcopyd actually runs 8051da177e4SLinus Torvalds * this code so don't block. 8061da177e4SLinus Torvalds */ 8074cdc1d1fSAlasdair G Kergon static void copy_callback(int read_err, unsigned long write_err, void *context) 8081da177e4SLinus Torvalds { 809028867acSAlasdair G Kergon struct dm_snap_pending_exception *pe = context; 8101da177e4SLinus Torvalds struct dm_snapshot *s = pe->snap; 8111da177e4SLinus Torvalds 8121da177e4SLinus Torvalds if (read_err || write_err) 8131da177e4SLinus Torvalds pending_complete(pe, 0); 8141da177e4SLinus Torvalds 8151da177e4SLinus Torvalds else 8161da177e4SLinus Torvalds /* Update the metadata if we are persistent */ 8171da177e4SLinus Torvalds s->store.commit_exception(&s->store, &pe->e, commit_callback, 8181da177e4SLinus Torvalds pe); 8191da177e4SLinus Torvalds } 8201da177e4SLinus Torvalds 8211da177e4SLinus Torvalds /* 8221da177e4SLinus Torvalds * Dispatches the copy operation to kcopyd. 8231da177e4SLinus Torvalds */ 824028867acSAlasdair G Kergon static void start_copy(struct dm_snap_pending_exception *pe) 8251da177e4SLinus Torvalds { 8261da177e4SLinus Torvalds struct dm_snapshot *s = pe->snap; 82722a1ceb1SHeinz Mauelshagen struct dm_io_region src, dest; 8281da177e4SLinus Torvalds struct block_device *bdev = s->origin->bdev; 8291da177e4SLinus Torvalds sector_t dev_size; 8301da177e4SLinus Torvalds 8311da177e4SLinus Torvalds dev_size = get_dev_size(bdev); 8321da177e4SLinus Torvalds 8331da177e4SLinus Torvalds src.bdev = bdev; 8341da177e4SLinus Torvalds src.sector = chunk_to_sector(s, pe->e.old_chunk); 8351da177e4SLinus Torvalds src.count = min(s->chunk_size, dev_size - src.sector); 8361da177e4SLinus Torvalds 8371da177e4SLinus Torvalds dest.bdev = s->cow->bdev; 8381da177e4SLinus Torvalds dest.sector = chunk_to_sector(s, pe->e.new_chunk); 8391da177e4SLinus Torvalds dest.count = src.count; 8401da177e4SLinus Torvalds 8411da177e4SLinus Torvalds /* Hand over to kcopyd */ 8421da177e4SLinus Torvalds kcopyd_copy(s->kcopyd_client, 8431da177e4SLinus Torvalds &src, 1, &dest, 0, copy_callback, pe); 8441da177e4SLinus Torvalds } 8451da177e4SLinus Torvalds 8461da177e4SLinus Torvalds /* 8471da177e4SLinus Torvalds * Looks to see if this snapshot already has a pending exception 8481da177e4SLinus Torvalds * for this chunk, otherwise it allocates a new one and inserts 8491da177e4SLinus Torvalds * it into the pending table. 8501da177e4SLinus Torvalds * 8511da177e4SLinus Torvalds * NOTE: a write lock must be held on snap->lock before calling 8521da177e4SLinus Torvalds * this. 8531da177e4SLinus Torvalds */ 854028867acSAlasdair G Kergon static struct dm_snap_pending_exception * 8551da177e4SLinus Torvalds __find_pending_exception(struct dm_snapshot *s, struct bio *bio) 8561da177e4SLinus Torvalds { 857028867acSAlasdair G Kergon struct dm_snap_exception *e; 858028867acSAlasdair G Kergon struct dm_snap_pending_exception *pe; 8591da177e4SLinus Torvalds chunk_t chunk = sector_to_chunk(s, bio->bi_sector); 8601da177e4SLinus Torvalds 8611da177e4SLinus Torvalds /* 8621da177e4SLinus Torvalds * Is there a pending exception for this already ? 8631da177e4SLinus Torvalds */ 8641da177e4SLinus Torvalds e = lookup_exception(&s->pending, chunk); 8651da177e4SLinus Torvalds if (e) { 8661da177e4SLinus Torvalds /* cast the exception to a pending exception */ 867028867acSAlasdair G Kergon pe = container_of(e, struct dm_snap_pending_exception, e); 86876df1c65SAlasdair G Kergon goto out; 86976df1c65SAlasdair G Kergon } 8701da177e4SLinus Torvalds 8711da177e4SLinus Torvalds /* 8721da177e4SLinus Torvalds * Create a new pending exception, we don't want 8731da177e4SLinus Torvalds * to hold the lock while we do this. 8741da177e4SLinus Torvalds */ 8751da177e4SLinus Torvalds up_write(&s->lock); 8761da177e4SLinus Torvalds pe = alloc_pending_exception(); 8771da177e4SLinus Torvalds down_write(&s->lock); 8781da177e4SLinus Torvalds 87976df1c65SAlasdair G Kergon if (!s->valid) { 88076df1c65SAlasdair G Kergon free_pending_exception(pe); 88176df1c65SAlasdair G Kergon return NULL; 88276df1c65SAlasdair G Kergon } 88376df1c65SAlasdair G Kergon 8841da177e4SLinus Torvalds e = lookup_exception(&s->pending, chunk); 8851da177e4SLinus Torvalds if (e) { 8861da177e4SLinus Torvalds free_pending_exception(pe); 887028867acSAlasdair G Kergon pe = container_of(e, struct dm_snap_pending_exception, e); 88876df1c65SAlasdair G Kergon goto out; 88976df1c65SAlasdair G Kergon } 89076df1c65SAlasdair G Kergon 8911da177e4SLinus Torvalds pe->e.old_chunk = chunk; 8921da177e4SLinus Torvalds bio_list_init(&pe->origin_bios); 8931da177e4SLinus Torvalds bio_list_init(&pe->snapshot_bios); 894b4b610f6SAlasdair G Kergon pe->primary_pe = NULL; 8954b832e8dSAlasdair G Kergon atomic_set(&pe->ref_count, 0); 8961da177e4SLinus Torvalds pe->snap = s; 8971da177e4SLinus Torvalds pe->started = 0; 8981da177e4SLinus Torvalds 8991da177e4SLinus Torvalds if (s->store.prepare_exception(&s->store, &pe->e)) { 9001da177e4SLinus Torvalds free_pending_exception(pe); 9011da177e4SLinus Torvalds return NULL; 9021da177e4SLinus Torvalds } 9031da177e4SLinus Torvalds 9044b832e8dSAlasdair G Kergon get_pending_exception(pe); 9051da177e4SLinus Torvalds insert_exception(&s->pending, &pe->e); 9061da177e4SLinus Torvalds 90776df1c65SAlasdair G Kergon out: 9081da177e4SLinus Torvalds return pe; 9091da177e4SLinus Torvalds } 9101da177e4SLinus Torvalds 911028867acSAlasdair G Kergon static void remap_exception(struct dm_snapshot *s, struct dm_snap_exception *e, 912d74f81f8SMilan Broz struct bio *bio, chunk_t chunk) 9131da177e4SLinus Torvalds { 9141da177e4SLinus Torvalds bio->bi_bdev = s->cow->bdev; 915d74f81f8SMilan Broz bio->bi_sector = chunk_to_sector(s, dm_chunk_number(e->new_chunk) + 916d74f81f8SMilan Broz (chunk - e->old_chunk)) + 9171da177e4SLinus Torvalds (bio->bi_sector & s->chunk_mask); 9181da177e4SLinus Torvalds } 9191da177e4SLinus Torvalds 9201da177e4SLinus Torvalds static int snapshot_map(struct dm_target *ti, struct bio *bio, 9211da177e4SLinus Torvalds union map_info *map_context) 9221da177e4SLinus Torvalds { 923028867acSAlasdair G Kergon struct dm_snap_exception *e; 924028867acSAlasdair G Kergon struct dm_snapshot *s = ti->private; 925d2a7ad29SKiyoshi Ueda int r = DM_MAPIO_REMAPPED; 9261da177e4SLinus Torvalds chunk_t chunk; 927028867acSAlasdair G Kergon struct dm_snap_pending_exception *pe = NULL; 9281da177e4SLinus Torvalds 9291da177e4SLinus Torvalds chunk = sector_to_chunk(s, bio->bi_sector); 9301da177e4SLinus Torvalds 9311da177e4SLinus Torvalds /* Full snapshots are not usable */ 93276df1c65SAlasdair G Kergon /* To get here the table must be live so s->active is always set. */ 9331da177e4SLinus Torvalds if (!s->valid) 934f6a80ea8SAlasdair G Kergon return -EIO; 9351da177e4SLinus Torvalds 9361da177e4SLinus Torvalds /* FIXME: should only take write lock if we need 9371da177e4SLinus Torvalds * to copy an exception */ 9381da177e4SLinus Torvalds down_write(&s->lock); 9391da177e4SLinus Torvalds 94076df1c65SAlasdair G Kergon if (!s->valid) { 94176df1c65SAlasdair G Kergon r = -EIO; 94276df1c65SAlasdair G Kergon goto out_unlock; 94376df1c65SAlasdair G Kergon } 94476df1c65SAlasdair G Kergon 9451da177e4SLinus Torvalds /* If the block is already remapped - use that, else remap it */ 9461da177e4SLinus Torvalds e = lookup_exception(&s->complete, chunk); 9471da177e4SLinus Torvalds if (e) { 948d74f81f8SMilan Broz remap_exception(s, e, bio, chunk); 94976df1c65SAlasdair G Kergon goto out_unlock; 95076df1c65SAlasdair G Kergon } 9511da177e4SLinus Torvalds 952ba40a2aaSAlasdair G Kergon /* 953ba40a2aaSAlasdair G Kergon * Write to snapshot - higher level takes care of RW/RO 954ba40a2aaSAlasdair G Kergon * flags so we should only get this if we are 955ba40a2aaSAlasdair G Kergon * writeable. 956ba40a2aaSAlasdair G Kergon */ 957ba40a2aaSAlasdair G Kergon if (bio_rw(bio) == WRITE) { 9581da177e4SLinus Torvalds pe = __find_pending_exception(s, bio); 9591da177e4SLinus Torvalds if (!pe) { 960695368acSAlasdair G Kergon __invalidate_snapshot(s, -ENOMEM); 9611da177e4SLinus Torvalds r = -EIO; 96276df1c65SAlasdair G Kergon goto out_unlock; 96376df1c65SAlasdair G Kergon } 96476df1c65SAlasdair G Kergon 965d74f81f8SMilan Broz remap_exception(s, &pe->e, bio, chunk); 9661da177e4SLinus Torvalds bio_list_add(&pe->snapshot_bios, bio); 9671da177e4SLinus Torvalds 968d2a7ad29SKiyoshi Ueda r = DM_MAPIO_SUBMITTED; 969ba40a2aaSAlasdair G Kergon 9701da177e4SLinus Torvalds if (!pe->started) { 9711da177e4SLinus Torvalds /* this is protected by snap->lock */ 9721da177e4SLinus Torvalds pe->started = 1; 97376df1c65SAlasdair G Kergon up_write(&s->lock); 97476df1c65SAlasdair G Kergon start_copy(pe); 975ba40a2aaSAlasdair G Kergon goto out; 976ba40a2aaSAlasdair G Kergon } 977ba40a2aaSAlasdair G Kergon } else 9781da177e4SLinus Torvalds /* 9791da177e4SLinus Torvalds * FIXME: this read path scares me because we 9801da177e4SLinus Torvalds * always use the origin when we have a pending 9811da177e4SLinus Torvalds * exception. However I can't think of a 9821da177e4SLinus Torvalds * situation where this is wrong - ejt. 9831da177e4SLinus Torvalds */ 9841da177e4SLinus Torvalds bio->bi_bdev = s->origin->bdev; 9851da177e4SLinus Torvalds 986ba40a2aaSAlasdair G Kergon out_unlock: 987ba40a2aaSAlasdair G Kergon up_write(&s->lock); 988ba40a2aaSAlasdair G Kergon out: 9891da177e4SLinus Torvalds return r; 9901da177e4SLinus Torvalds } 9911da177e4SLinus Torvalds 9921da177e4SLinus Torvalds static void snapshot_resume(struct dm_target *ti) 9931da177e4SLinus Torvalds { 994028867acSAlasdair G Kergon struct dm_snapshot *s = ti->private; 9951da177e4SLinus Torvalds 996aa14edebSAlasdair G Kergon down_write(&s->lock); 997aa14edebSAlasdair G Kergon s->active = 1; 998aa14edebSAlasdair G Kergon up_write(&s->lock); 9991da177e4SLinus Torvalds } 10001da177e4SLinus Torvalds 10011da177e4SLinus Torvalds static int snapshot_status(struct dm_target *ti, status_type_t type, 10021da177e4SLinus Torvalds char *result, unsigned int maxlen) 10031da177e4SLinus Torvalds { 1004028867acSAlasdair G Kergon struct dm_snapshot *snap = ti->private; 10051da177e4SLinus Torvalds 10061da177e4SLinus Torvalds switch (type) { 10071da177e4SLinus Torvalds case STATUSTYPE_INFO: 10081da177e4SLinus Torvalds if (!snap->valid) 10091da177e4SLinus Torvalds snprintf(result, maxlen, "Invalid"); 10101da177e4SLinus Torvalds else { 10111da177e4SLinus Torvalds if (snap->store.fraction_full) { 10121da177e4SLinus Torvalds sector_t numerator, denominator; 10131da177e4SLinus Torvalds snap->store.fraction_full(&snap->store, 10141da177e4SLinus Torvalds &numerator, 10151da177e4SLinus Torvalds &denominator); 10164ee218cdSAndrew Morton snprintf(result, maxlen, "%llu/%llu", 10174ee218cdSAndrew Morton (unsigned long long)numerator, 10184ee218cdSAndrew Morton (unsigned long long)denominator); 10191da177e4SLinus Torvalds } 10201da177e4SLinus Torvalds else 10211da177e4SLinus Torvalds snprintf(result, maxlen, "Unknown"); 10221da177e4SLinus Torvalds } 10231da177e4SLinus Torvalds break; 10241da177e4SLinus Torvalds 10251da177e4SLinus Torvalds case STATUSTYPE_TABLE: 10261da177e4SLinus Torvalds /* 10271da177e4SLinus Torvalds * kdevname returns a static pointer so we need 10281da177e4SLinus Torvalds * to make private copies if the output is to 10291da177e4SLinus Torvalds * make sense. 10301da177e4SLinus Torvalds */ 10314ee218cdSAndrew Morton snprintf(result, maxlen, "%s %s %c %llu", 10321da177e4SLinus Torvalds snap->origin->name, snap->cow->name, 10334ee218cdSAndrew Morton snap->type, 10344ee218cdSAndrew Morton (unsigned long long)snap->chunk_size); 10351da177e4SLinus Torvalds break; 10361da177e4SLinus Torvalds } 10371da177e4SLinus Torvalds 10381da177e4SLinus Torvalds return 0; 10391da177e4SLinus Torvalds } 10401da177e4SLinus Torvalds 10411da177e4SLinus Torvalds /*----------------------------------------------------------------- 10421da177e4SLinus Torvalds * Origin methods 10431da177e4SLinus Torvalds *---------------------------------------------------------------*/ 10441da177e4SLinus Torvalds static int __origin_write(struct list_head *snapshots, struct bio *bio) 10451da177e4SLinus Torvalds { 1046d2a7ad29SKiyoshi Ueda int r = DM_MAPIO_REMAPPED, first = 0; 10471da177e4SLinus Torvalds struct dm_snapshot *snap; 1048028867acSAlasdair G Kergon struct dm_snap_exception *e; 1049028867acSAlasdair G Kergon struct dm_snap_pending_exception *pe, *next_pe, *primary_pe = NULL; 10501da177e4SLinus Torvalds chunk_t chunk; 1051eccf0817SAlasdair G Kergon LIST_HEAD(pe_queue); 10521da177e4SLinus Torvalds 10531da177e4SLinus Torvalds /* Do all the snapshots on this origin */ 10541da177e4SLinus Torvalds list_for_each_entry (snap, snapshots, list) { 10551da177e4SLinus Torvalds 105676df1c65SAlasdair G Kergon down_write(&snap->lock); 105776df1c65SAlasdair G Kergon 1058aa14edebSAlasdair G Kergon /* Only deal with valid and active snapshots */ 1059aa14edebSAlasdair G Kergon if (!snap->valid || !snap->active) 106076df1c65SAlasdair G Kergon goto next_snapshot; 10611da177e4SLinus Torvalds 1062d5e404c1SAlasdair G Kergon /* Nothing to do if writing beyond end of snapshot */ 106372727badSMikulas Patocka if (bio->bi_sector >= dm_table_get_size(snap->ti->table)) 106476df1c65SAlasdair G Kergon goto next_snapshot; 10651da177e4SLinus Torvalds 10661da177e4SLinus Torvalds /* 10671da177e4SLinus Torvalds * Remember, different snapshots can have 10681da177e4SLinus Torvalds * different chunk sizes. 10691da177e4SLinus Torvalds */ 10701da177e4SLinus Torvalds chunk = sector_to_chunk(snap, bio->bi_sector); 10711da177e4SLinus Torvalds 10721da177e4SLinus Torvalds /* 10731da177e4SLinus Torvalds * Check exception table to see if block 10741da177e4SLinus Torvalds * is already remapped in this snapshot 10751da177e4SLinus Torvalds * and trigger an exception if not. 1076b4b610f6SAlasdair G Kergon * 10774b832e8dSAlasdair G Kergon * ref_count is initialised to 1 so pending_complete() 1078b4b610f6SAlasdair G Kergon * won't destroy the primary_pe while we're inside this loop. 10791da177e4SLinus Torvalds */ 10801da177e4SLinus Torvalds e = lookup_exception(&snap->complete, chunk); 108176df1c65SAlasdair G Kergon if (e) 108276df1c65SAlasdair G Kergon goto next_snapshot; 108376df1c65SAlasdair G Kergon 10841da177e4SLinus Torvalds pe = __find_pending_exception(snap, bio); 10851da177e4SLinus Torvalds if (!pe) { 1086695368acSAlasdair G Kergon __invalidate_snapshot(snap, -ENOMEM); 108776df1c65SAlasdair G Kergon goto next_snapshot; 108876df1c65SAlasdair G Kergon } 10891da177e4SLinus Torvalds 1090b4b610f6SAlasdair G Kergon if (!primary_pe) { 1091b4b610f6SAlasdair G Kergon /* 1092b4b610f6SAlasdair G Kergon * Either every pe here has same 1093b4b610f6SAlasdair G Kergon * primary_pe or none has one yet. 1094b4b610f6SAlasdair G Kergon */ 1095b4b610f6SAlasdair G Kergon if (pe->primary_pe) 1096b4b610f6SAlasdair G Kergon primary_pe = pe->primary_pe; 1097b4b610f6SAlasdair G Kergon else { 1098b4b610f6SAlasdair G Kergon primary_pe = pe; 1099b4b610f6SAlasdair G Kergon first = 1; 1100eccf0817SAlasdair G Kergon } 1101b4b610f6SAlasdair G Kergon 110276df1c65SAlasdair G Kergon bio_list_add(&primary_pe->origin_bios, bio); 110376df1c65SAlasdair G Kergon 1104d2a7ad29SKiyoshi Ueda r = DM_MAPIO_SUBMITTED; 1105b4b610f6SAlasdair G Kergon } 110676df1c65SAlasdair G Kergon 1107b4b610f6SAlasdair G Kergon if (!pe->primary_pe) { 1108b4b610f6SAlasdair G Kergon pe->primary_pe = primary_pe; 11094b832e8dSAlasdair G Kergon get_pending_exception(primary_pe); 1110b4b610f6SAlasdair G Kergon } 111176df1c65SAlasdair G Kergon 1112eccf0817SAlasdair G Kergon if (!pe->started) { 1113eccf0817SAlasdair G Kergon pe->started = 1; 1114eccf0817SAlasdair G Kergon list_add_tail(&pe->list, &pe_queue); 1115eccf0817SAlasdair G Kergon } 11161da177e4SLinus Torvalds 111776df1c65SAlasdair G Kergon next_snapshot: 11181da177e4SLinus Torvalds up_write(&snap->lock); 11191da177e4SLinus Torvalds } 11201da177e4SLinus Torvalds 1121b4b610f6SAlasdair G Kergon if (!primary_pe) 11224b832e8dSAlasdair G Kergon return r; 1123b4b610f6SAlasdair G Kergon 1124b4b610f6SAlasdair G Kergon /* 1125b4b610f6SAlasdair G Kergon * If this is the first time we're processing this chunk and 11264b832e8dSAlasdair G Kergon * ref_count is now 1 it means all the pending exceptions 1127b4b610f6SAlasdair G Kergon * got completed while we were in the loop above, so it falls to 1128b4b610f6SAlasdair G Kergon * us here to remove the primary_pe and submit any origin_bios. 1129b4b610f6SAlasdair G Kergon */ 1130b4b610f6SAlasdair G Kergon 11314b832e8dSAlasdair G Kergon if (first && atomic_dec_and_test(&primary_pe->ref_count)) { 1132b4b610f6SAlasdair G Kergon flush_bios(bio_list_get(&primary_pe->origin_bios)); 1133b4b610f6SAlasdair G Kergon free_pending_exception(primary_pe); 1134b4b610f6SAlasdair G Kergon /* If we got here, pe_queue is necessarily empty. */ 11354b832e8dSAlasdair G Kergon return r; 1136b4b610f6SAlasdair G Kergon } 1137b4b610f6SAlasdair G Kergon 11381da177e4SLinus Torvalds /* 11391da177e4SLinus Torvalds * Now that we have a complete pe list we can start the copying. 11401da177e4SLinus Torvalds */ 1141eccf0817SAlasdair G Kergon list_for_each_entry_safe(pe, next_pe, &pe_queue, list) 11421da177e4SLinus Torvalds start_copy(pe); 11431da177e4SLinus Torvalds 11441da177e4SLinus Torvalds return r; 11451da177e4SLinus Torvalds } 11461da177e4SLinus Torvalds 11471da177e4SLinus Torvalds /* 11481da177e4SLinus Torvalds * Called on a write from the origin driver. 11491da177e4SLinus Torvalds */ 11501da177e4SLinus Torvalds static int do_origin(struct dm_dev *origin, struct bio *bio) 11511da177e4SLinus Torvalds { 11521da177e4SLinus Torvalds struct origin *o; 1153d2a7ad29SKiyoshi Ueda int r = DM_MAPIO_REMAPPED; 11541da177e4SLinus Torvalds 11551da177e4SLinus Torvalds down_read(&_origins_lock); 11561da177e4SLinus Torvalds o = __lookup_origin(origin->bdev); 11571da177e4SLinus Torvalds if (o) 11581da177e4SLinus Torvalds r = __origin_write(&o->snapshots, bio); 11591da177e4SLinus Torvalds up_read(&_origins_lock); 11601da177e4SLinus Torvalds 11611da177e4SLinus Torvalds return r; 11621da177e4SLinus Torvalds } 11631da177e4SLinus Torvalds 11641da177e4SLinus Torvalds /* 11651da177e4SLinus Torvalds * Origin: maps a linear range of a device, with hooks for snapshotting. 11661da177e4SLinus Torvalds */ 11671da177e4SLinus Torvalds 11681da177e4SLinus Torvalds /* 11691da177e4SLinus Torvalds * Construct an origin mapping: <dev_path> 11701da177e4SLinus Torvalds * The context for an origin is merely a 'struct dm_dev *' 11711da177e4SLinus Torvalds * pointing to the real device. 11721da177e4SLinus Torvalds */ 11731da177e4SLinus Torvalds static int origin_ctr(struct dm_target *ti, unsigned int argc, char **argv) 11741da177e4SLinus Torvalds { 11751da177e4SLinus Torvalds int r; 11761da177e4SLinus Torvalds struct dm_dev *dev; 11771da177e4SLinus Torvalds 11781da177e4SLinus Torvalds if (argc != 1) { 117972d94861SAlasdair G Kergon ti->error = "origin: incorrect number of arguments"; 11801da177e4SLinus Torvalds return -EINVAL; 11811da177e4SLinus Torvalds } 11821da177e4SLinus Torvalds 11831da177e4SLinus Torvalds r = dm_get_device(ti, argv[0], 0, ti->len, 11841da177e4SLinus Torvalds dm_table_get_mode(ti->table), &dev); 11851da177e4SLinus Torvalds if (r) { 11861da177e4SLinus Torvalds ti->error = "Cannot get target device"; 11871da177e4SLinus Torvalds return r; 11881da177e4SLinus Torvalds } 11891da177e4SLinus Torvalds 11901da177e4SLinus Torvalds ti->private = dev; 11911da177e4SLinus Torvalds return 0; 11921da177e4SLinus Torvalds } 11931da177e4SLinus Torvalds 11941da177e4SLinus Torvalds static void origin_dtr(struct dm_target *ti) 11951da177e4SLinus Torvalds { 1196028867acSAlasdair G Kergon struct dm_dev *dev = ti->private; 11971da177e4SLinus Torvalds dm_put_device(ti, dev); 11981da177e4SLinus Torvalds } 11991da177e4SLinus Torvalds 12001da177e4SLinus Torvalds static int origin_map(struct dm_target *ti, struct bio *bio, 12011da177e4SLinus Torvalds union map_info *map_context) 12021da177e4SLinus Torvalds { 1203028867acSAlasdair G Kergon struct dm_dev *dev = ti->private; 12041da177e4SLinus Torvalds bio->bi_bdev = dev->bdev; 12051da177e4SLinus Torvalds 12061da177e4SLinus Torvalds /* Only tell snapshots if this is a write */ 1207d2a7ad29SKiyoshi Ueda return (bio_rw(bio) == WRITE) ? do_origin(dev, bio) : DM_MAPIO_REMAPPED; 12081da177e4SLinus Torvalds } 12091da177e4SLinus Torvalds 12101da177e4SLinus Torvalds #define min_not_zero(l, r) (l == 0) ? r : ((r == 0) ? l : min(l, r)) 12111da177e4SLinus Torvalds 12121da177e4SLinus Torvalds /* 12131da177e4SLinus Torvalds * Set the target "split_io" field to the minimum of all the snapshots' 12141da177e4SLinus Torvalds * chunk sizes. 12151da177e4SLinus Torvalds */ 12161da177e4SLinus Torvalds static void origin_resume(struct dm_target *ti) 12171da177e4SLinus Torvalds { 1218028867acSAlasdair G Kergon struct dm_dev *dev = ti->private; 12191da177e4SLinus Torvalds struct dm_snapshot *snap; 12201da177e4SLinus Torvalds struct origin *o; 12211da177e4SLinus Torvalds chunk_t chunk_size = 0; 12221da177e4SLinus Torvalds 12231da177e4SLinus Torvalds down_read(&_origins_lock); 12241da177e4SLinus Torvalds o = __lookup_origin(dev->bdev); 12251da177e4SLinus Torvalds if (o) 12261da177e4SLinus Torvalds list_for_each_entry (snap, &o->snapshots, list) 12271da177e4SLinus Torvalds chunk_size = min_not_zero(chunk_size, snap->chunk_size); 12281da177e4SLinus Torvalds up_read(&_origins_lock); 12291da177e4SLinus Torvalds 12301da177e4SLinus Torvalds ti->split_io = chunk_size; 12311da177e4SLinus Torvalds } 12321da177e4SLinus Torvalds 12331da177e4SLinus Torvalds static int origin_status(struct dm_target *ti, status_type_t type, char *result, 12341da177e4SLinus Torvalds unsigned int maxlen) 12351da177e4SLinus Torvalds { 1236028867acSAlasdair G Kergon struct dm_dev *dev = ti->private; 12371da177e4SLinus Torvalds 12381da177e4SLinus Torvalds switch (type) { 12391da177e4SLinus Torvalds case STATUSTYPE_INFO: 12401da177e4SLinus Torvalds result[0] = '\0'; 12411da177e4SLinus Torvalds break; 12421da177e4SLinus Torvalds 12431da177e4SLinus Torvalds case STATUSTYPE_TABLE: 12441da177e4SLinus Torvalds snprintf(result, maxlen, "%s", dev->name); 12451da177e4SLinus Torvalds break; 12461da177e4SLinus Torvalds } 12471da177e4SLinus Torvalds 12481da177e4SLinus Torvalds return 0; 12491da177e4SLinus Torvalds } 12501da177e4SLinus Torvalds 12511da177e4SLinus Torvalds static struct target_type origin_target = { 12521da177e4SLinus Torvalds .name = "snapshot-origin", 1253d74f81f8SMilan Broz .version = {1, 6, 0}, 12541da177e4SLinus Torvalds .module = THIS_MODULE, 12551da177e4SLinus Torvalds .ctr = origin_ctr, 12561da177e4SLinus Torvalds .dtr = origin_dtr, 12571da177e4SLinus Torvalds .map = origin_map, 12581da177e4SLinus Torvalds .resume = origin_resume, 12591da177e4SLinus Torvalds .status = origin_status, 12601da177e4SLinus Torvalds }; 12611da177e4SLinus Torvalds 12621da177e4SLinus Torvalds static struct target_type snapshot_target = { 12631da177e4SLinus Torvalds .name = "snapshot", 1264d74f81f8SMilan Broz .version = {1, 6, 0}, 12651da177e4SLinus Torvalds .module = THIS_MODULE, 12661da177e4SLinus Torvalds .ctr = snapshot_ctr, 12671da177e4SLinus Torvalds .dtr = snapshot_dtr, 12681da177e4SLinus Torvalds .map = snapshot_map, 12691da177e4SLinus Torvalds .resume = snapshot_resume, 12701da177e4SLinus Torvalds .status = snapshot_status, 12711da177e4SLinus Torvalds }; 12721da177e4SLinus Torvalds 12731da177e4SLinus Torvalds static int __init dm_snapshot_init(void) 12741da177e4SLinus Torvalds { 12751da177e4SLinus Torvalds int r; 12761da177e4SLinus Torvalds 12771da177e4SLinus Torvalds r = dm_register_target(&snapshot_target); 12781da177e4SLinus Torvalds if (r) { 12791da177e4SLinus Torvalds DMERR("snapshot target register failed %d", r); 12801da177e4SLinus Torvalds return r; 12811da177e4SLinus Torvalds } 12821da177e4SLinus Torvalds 12831da177e4SLinus Torvalds r = dm_register_target(&origin_target); 12841da177e4SLinus Torvalds if (r < 0) { 128572d94861SAlasdair G Kergon DMERR("Origin target register failed %d", r); 12861da177e4SLinus Torvalds goto bad1; 12871da177e4SLinus Torvalds } 12881da177e4SLinus Torvalds 12891da177e4SLinus Torvalds r = init_origin_hash(); 12901da177e4SLinus Torvalds if (r) { 12911da177e4SLinus Torvalds DMERR("init_origin_hash failed."); 12921da177e4SLinus Torvalds goto bad2; 12931da177e4SLinus Torvalds } 12941da177e4SLinus Torvalds 1295028867acSAlasdair G Kergon exception_cache = KMEM_CACHE(dm_snap_exception, 0); 12961da177e4SLinus Torvalds if (!exception_cache) { 12971da177e4SLinus Torvalds DMERR("Couldn't create exception cache."); 12981da177e4SLinus Torvalds r = -ENOMEM; 12991da177e4SLinus Torvalds goto bad3; 13001da177e4SLinus Torvalds } 13011da177e4SLinus Torvalds 1302028867acSAlasdair G Kergon pending_cache = KMEM_CACHE(dm_snap_pending_exception, 0); 13031da177e4SLinus Torvalds if (!pending_cache) { 13041da177e4SLinus Torvalds DMERR("Couldn't create pending cache."); 13051da177e4SLinus Torvalds r = -ENOMEM; 13061da177e4SLinus Torvalds goto bad4; 13071da177e4SLinus Torvalds } 13081da177e4SLinus Torvalds 130993d2341cSMatthew Dobson pending_pool = mempool_create_slab_pool(128, pending_cache); 13101da177e4SLinus Torvalds if (!pending_pool) { 13111da177e4SLinus Torvalds DMERR("Couldn't create pending pool."); 13121da177e4SLinus Torvalds r = -ENOMEM; 13131da177e4SLinus Torvalds goto bad5; 13141da177e4SLinus Torvalds } 13151da177e4SLinus Torvalds 1316ca3a931fSAlasdair G Kergon ksnapd = create_singlethread_workqueue("ksnapd"); 1317ca3a931fSAlasdair G Kergon if (!ksnapd) { 1318ca3a931fSAlasdair G Kergon DMERR("Failed to create ksnapd workqueue."); 1319ca3a931fSAlasdair G Kergon r = -ENOMEM; 1320ca3a931fSAlasdair G Kergon goto bad6; 1321ca3a931fSAlasdair G Kergon } 1322ca3a931fSAlasdair G Kergon 13231da177e4SLinus Torvalds return 0; 13241da177e4SLinus Torvalds 1325ca3a931fSAlasdair G Kergon bad6: 1326ca3a931fSAlasdair G Kergon mempool_destroy(pending_pool); 13271da177e4SLinus Torvalds bad5: 13281da177e4SLinus Torvalds kmem_cache_destroy(pending_cache); 13291da177e4SLinus Torvalds bad4: 13301da177e4SLinus Torvalds kmem_cache_destroy(exception_cache); 13311da177e4SLinus Torvalds bad3: 13321da177e4SLinus Torvalds exit_origin_hash(); 13331da177e4SLinus Torvalds bad2: 13341da177e4SLinus Torvalds dm_unregister_target(&origin_target); 13351da177e4SLinus Torvalds bad1: 13361da177e4SLinus Torvalds dm_unregister_target(&snapshot_target); 13371da177e4SLinus Torvalds return r; 13381da177e4SLinus Torvalds } 13391da177e4SLinus Torvalds 13401da177e4SLinus Torvalds static void __exit dm_snapshot_exit(void) 13411da177e4SLinus Torvalds { 13421da177e4SLinus Torvalds int r; 13431da177e4SLinus Torvalds 1344ca3a931fSAlasdair G Kergon destroy_workqueue(ksnapd); 1345ca3a931fSAlasdair G Kergon 13461da177e4SLinus Torvalds r = dm_unregister_target(&snapshot_target); 13471da177e4SLinus Torvalds if (r) 13481da177e4SLinus Torvalds DMERR("snapshot unregister failed %d", r); 13491da177e4SLinus Torvalds 13501da177e4SLinus Torvalds r = dm_unregister_target(&origin_target); 13511da177e4SLinus Torvalds if (r) 13521da177e4SLinus Torvalds DMERR("origin unregister failed %d", r); 13531da177e4SLinus Torvalds 13541da177e4SLinus Torvalds exit_origin_hash(); 13551da177e4SLinus Torvalds mempool_destroy(pending_pool); 13561da177e4SLinus Torvalds kmem_cache_destroy(pending_cache); 13571da177e4SLinus Torvalds kmem_cache_destroy(exception_cache); 13581da177e4SLinus Torvalds } 13591da177e4SLinus Torvalds 13601da177e4SLinus Torvalds /* Module hooks */ 13611da177e4SLinus Torvalds module_init(dm_snapshot_init); 13621da177e4SLinus Torvalds module_exit(dm_snapshot_exit); 13631da177e4SLinus Torvalds 13641da177e4SLinus Torvalds MODULE_DESCRIPTION(DM_NAME " snapshot target"); 13651da177e4SLinus Torvalds MODULE_AUTHOR("Joe Thornber"); 13661da177e4SLinus Torvalds MODULE_LICENSE("GPL"); 1367