/* * Copyright (C) 2011 Red Hat UK. * * This file is released under the GPL. */ #include "dm-thin-metadata.h" #include <linux/device-mapper.h>#include <linux/dm-io.h>#include <linux/dm-kcopyd.h>#include <linux/list.h>#include <linux/init.h>#include <linux/module.h>#include <linux/slab.h> #define DM_MSG_PREFIX "thin" /* * Tunable constants */#define ENDIO_HOOK_POOL_SIZE 10240#define DEFERRED_SET_SIZE 64#define MAPPING_POOL_SIZE 1024#define PRISON_CELLS 1024#define COMMIT_PERIOD HZ /* * The block size of the device holding pool data must be * between 64KB and 1GB. */#define DATA_DEV_BLOCK_SIZE_MIN_SECTORS (64 * 1024 >> SECTOR_SHIFT)#define DATA_DEV_BLOCK_SIZE_MAX_SECTORS (1024 * 1024 * 1024 >> SECTOR_SHIFT) /* * Device id is restricted to 24 bits. */#define MAX_DEV_ID ((1 << 24) - 1) /* * How do we handle breaking sharing of data blocks? * ================================================= * * We use a standard copy-on-write btree to store the mappings for the * devices (note I'm talking about copy-on-write of the metadata here, not * the data). When you take an internal snapshot you clone the root node * of the origin btree. After this there is no concept of an origin or a * snapshot. They are just two device trees that happen to point to the * same data blocks. * * When we get a write in we decide if it's to a shared data block using * some timestamp magic. If it is, we have to break sharing. * * Let's say we write to a shared block in what was the origin. The * steps are: * * i) plug io further to this physical block. (see bio_prison code). * * ii) quiesce any read io to that shared data block. Obviously * including all devices that share this block. (see deferred_set code) * * iii) copy the data block to a newly allocate block. This step can be * missed out if the io covers the block. (schedule_copy). * * iv) insert the new mapping into the origin's btree * (process_prepared_mapping). This act of inserting breaks some * sharing of btree nodes between the two devices. Breaking sharing only * effects the btree of that specific device. Btrees for the other * devices that share the block never change. The btree for the origin * device as it was after the last commit is untouched, ie. we're using * persistent data structures in the functional programming sense. * * v) unplug io to this physical block, including the io that triggered * the breaking of sharing. * * Steps (ii) and (iii) occur in parallel. * * The metadata _doesn't_ need to be committed before the io continues. We * get away with this because the io is always written to a _new_ block. * If there's a crash, then: * * - The origin mapping will point to the old origin block (the shared * one). This will contain the data as it was before the io that triggered * the breaking of sharing came in. * * - The snap mapping still points to the old block. As it would after * the commit. * * The downside of this scheme is the timestamp magic isn't perfect, and * will continue to think that data block in the snapshot device is shared * even after the write to the origin has broken sharing. I suspect data * blocks will typically be shared by many different devices, so we're * breaking sharing n + 1 times, rather than n, where n is the number of * devices that reference this data block. At the moment I think the * benefits far, far outweigh the disadvantages. */ /*----------------------------------------------------------------*/ /* * Sometimes we can't deal with a bio straight away. We put them in prison * where they can't cause any mischief. Bios are put in a cell identified * by a key, multiple bios can be in the same cell. When the cell is * subsequently unlocked the bios become available. */struct bio_prison; struct cell_key { int virtual; dm_thin_id dev; dm_block_t block;}; struct dm_bio_prison_cell { struct hlist_node list; struct bio_prison *prison; struct cell_key key; struct bio *holder; struct bio_list bios;}; struct bio_prison { spinlock_t lock; mempool_t *cell_pool; unsigned nr_buckets; unsigned hash_mask; struct hlist_head *cells;}; static uint32_t calc_nr_buckets(unsigned nr_cells){ uint32_t n = 128; nr_cells /= 4; nr_cells = min(nr_cells, 8192u); while (n < nr_cells) n <<= 1; return n;} static struct kmem_cache *_cell_cache; /* * @nr_cells should be the number of cells you want in use _concurrently_. * Don't confuse it with the number of distinct keys. */static struct bio_prison *prison_create(unsigned nr_cells){ unsigned i; uint32_t nr_buckets = calc_nr_buckets(nr_cells); size_t len = sizeof(struct bio_prison) + (sizeof(struct hlist_head) * nr_buckets); struct bio_prison *prison = kmalloc(len, GFP_KERNEL); if (!prison) return NULL; spin_lock_init(&prison->lock); prison->cell_pool = mempool_create_slab_pool(nr_cells, _cell_cache); if (!prison->cell_pool) { kfree(prison); return NULL; } prison->nr_buckets = nr_buckets; prison->hash_mask = nr_buckets - 1; prison->cells = (struct hlist_head *) (prison + 1); for (i = 0; i < nr_buckets; i++) INIT_HLIST_HEAD(prison->cells + i); return prison;} static void prison_destroy(struct bio_prison *prison){ mempool_destroy(prison->cell_pool); kfree(prison);} static uint32_t hash_key(struct bio_prison *prison, struct cell_key *key){ const unsigned long BIG_PRIME = 4294967291UL; uint64_t hash = key->block * BIG_PRIME; return (uint32_t) (hash & prison->hash_mask);} static int keys_equal(struct cell_key *lhs, struct cell_key *rhs){ return (lhs->virtual == rhs->virtual) && (lhs->dev == rhs->dev) && (lhs->block == rhs->block);} static struct dm_bio_prison_cell *__search_bucket(struct hlist_head *bucket, struct cell_key *key){ struct dm_bio_prison_cell *cell; struct hlist_node *tmp; hlist_for_each_entry(cell, tmp, bucket, list) if (keys_equal(&cell->key, key)) return cell; return NULL;} /* * This may block if a new cell needs allocating. You must ensure that * cells will be unlocked even if the calling thread is blocked. * * Returns 1 if the cell was already held, 0 if @inmate is the new holder. */static int bio_detain(struct bio_prison *prison, struct cell_key *key, struct bio *inmate, struct dm_bio_prison_cell **ref){ int r = 1; unsigned long flags; uint32_t hash = hash_key(prison, key); struct dm_bio_prison_cell *cell, *cell2; BUG_ON(hash > prison->nr_buckets); spin_lock_irqsave(&prison->lock, flags); cell = __search_bucket(prison->cells + hash, key); if (cell) { bio_list_add(&cell->bios, inmate); goto out; } /* * Allocate a new cell */ spin_unlock_irqrestore(&prison->lock, flags); cell2 = mempool_alloc(prison->cell_pool, GFP_NOIO); spin_lock_irqsave(&prison->lock, flags); /* * We've been unlocked, so we have to double check that * nobody else has inserted this cell in the meantime. */ cell = __search_bucket(prison->cells + hash, key); if (cell) { mempool_free(cell2, prison->cell_pool); bio_list_add(&cell->bios, inmate); goto out; } /* * Use new cell. */ cell = cell2; cell->prison = prison; memcpy(&cell->key, key, sizeof(cell->key)); cell->holder = inmate; bio_list_init(&cell->bios); hlist_add_head(&cell->list, prison->cells + hash); r = 0; out: spin_unlock_irqrestore(&prison->lock, flags); *ref = cell; return r;} /* * @inmates must have been initialised prior to this call */static void __cell_release(struct dm_bio_prison_cell *cell, struct bio_list *inmates){ struct bio_prison *prison = cell->prison; hlist_del(&cell->list); if (inmates) { bio_list_add(inmates, cell->holder); bio_list_merge(inmates, &cell->bios); } mempool_free(cell, prison->cell_pool);} static void cell_release(struct dm_bio_prison_cell *cell, struct bio_list *bios){ unsigned long flags; struct bio_prison *prison = cell->prison; spin_lock_irqsave(&prison->lock, flags); __cell_release(cell, bios); spin_unlock_irqrestore(&prison->lock, flags);} /* * There are a couple of places where we put a bio into a cell briefly * before taking it out again. In these situations we know that no other * bio may be in the cell. This function releases the cell, and also does * a sanity check. */static void __cell_release_singleton(struct dm_bio_prison_cell *cell, struct bio *bio){ BUG_ON(cell->holder != bio); BUG_ON(!bio_list_empty(&cell->bios)); __cell_release(cell, NULL);} static void cell_release_singleton(struct dm_bio_prison_cell *cell, struct bio *bio){ unsigned long flags; struct bio_prison *prison = cell->prison; spin_lock_irqsave(&prison->lock, flags); __cell_release_singleton(cell, bio); spin_unlock_irqrestore(&prison->lock, flags);} /* * Sometimes we don't want the holder, just the additional bios. */static void __cell_release_no_holder(struct dm_bio_prison_cell *cell, struct bio_list *inmates){ struct bio_prison *prison = cell->prison; hlist_del(&cell->list); bio_list_merge(inmates, &cell->bios); mempool_free(cell, prison->cell_pool);} static void cell_release_no_holder(struct dm_bio_prison_cell *cell, struct bio_list *inmates){ unsigned long flags; struct bio_prison *prison = cell->prison; spin_lock_irqsave(&prison->lock, flags); __cell_release_no_holder(cell, inmates); spin_unlock_irqrestore(&prison->lock, flags);} static void cell_error(struct dm_bio_prison_cell *cell){ struct bio_prison *prison = cell->prison; struct bio_list bios; struct bio *bio; unsigned long flags; bio_list_init(&bios); spin_lock_irqsave(&prison->lock, flags); __cell_release(cell, &bios); spin_unlock_irqrestore(&prison->lock, flags); while ((bio = bio_list_pop(&bios))) bio_io_error(bio);} /*----------------------------------------------------------------*/ /* * We use the deferred set to keep track of pending reads to shared blocks. * We do this to ensure the new mapping caused by a write isn't performed * until these prior reads have completed. Otherwise the insertion of the * new mapping could free the old block that the read bios are mapped to. */ struct deferred_set;struct deferred_entry { struct deferred_set *ds; unsigned count; struct list_head work_items;}; struct deferred_set { spinlock_t lock; unsigned current_entry; unsigned sweeper; struct deferred_entry entries[DEFERRED_SET_SIZE];}; static void ds_init(struct deferred_set *ds){ int i; spin_lock_init(&ds->lock); ds->current_entry = 0; ds->sweeper = 0; for (i = 0; i < DEFERRED_SET_SIZE; i++) { ds->entries[i].ds = ds; ds->entries[i].count = 0; INIT_LIST_HEAD(&ds->entries[i].work_items); }} static struct deferred_entry *ds_inc(struct deferred_set *ds){ unsigned long flags; struct deferred_entry *entry; spin_lock_irqsave(&ds->lock, flags); entry = ds->entries + ds->current_entry; entry->count++; spin_unlock_irqrestore(&ds->lock, flags); return entry;} static unsigned ds_next(unsigned index){ return (index + 1) % DEFERRED_SET_SIZE;} static void __sweep(struct deferred_set *ds, struct list_head *head){ while ((ds->sweeper != ds->current_entry) && !ds->entries[ds->sweeper].count) { list_splice_init(&ds->entries[ds->sweeper].work_items, head); ds->sweeper = ds_next(ds->sweeper); } if ((ds->sweeper == ds->current_entry) && !ds->entries[ds->sweeper].count) list_splice_init(&ds->entries[ds->sweeper].work_items, head);} static void ds_dec(struct deferred_entry *entry, struct list_head *head){ unsigned long flags; spin_lock_irqsave(&entry->ds->lock, flags); BUG_ON(!entry->count); --entry->count; __sweep(entry->ds, head); spin_unlock_irqrestore(&entry->ds->lock, flags);} /* * Returns 1 if deferred or 0 if no pending items to delay job. */static int ds_add_work(struct deferred_set *ds, struct list_head *work){ int r = 1; unsigned long flags; unsigned next_entry; spin_lock_irqsave(&ds->lock, flags); if ((ds->sweeper == ds->current_entry) && !ds->entries[ds->current_entry].count) r = 0; else { list_add(work, &ds->entries[ds->current_entry].work_items); next_entry = ds_next(ds->current_entry); if (!ds->entries[next_entry].count) ds->current_entry = next_entry; } spin_unlock_irqrestore(&ds->lock, flags); return r;} /*----------------------------------------------------------------*/ /* * Key building. */static void build_data_key(struct dm_thin_device *td, dm_block_t b, struct cell_key *key){ key->virtual = 0; key->dev = dm_thin_dev_id(td); key->block = b;} static void build_virtual_key(struct dm_thin_device *td, dm_block_t b, struct cell_key *key){ key->virtual = 1; key->dev = dm_thin_dev_id(td); key->block = b;} /*----------------------------------------------------------------*/ /* * A pool device ties together a metadata device and a data device. It * also provides the interface for creating and destroying internal * devices. */struct dm_thin_new_mapping; struct pool_features { unsigned zero_new_blocks:1;Lines 1–500 of 2849. Load more
/* * Copyright (C) 2011 Red Hat UK. * * This file is released under the GPL. */ #include "dm-thin-metadata.h" #include <linux/device-mapper.h> #include <linux/dm-io.h> #include <linux/dm-kcopyd.h> #include <linux/list.h> #include <linux/init.h> #include <linux/module.h> #include <linux/slab.h> #define DM_MSG_PREFIX "thin" /* * Tunable constants */ #define ENDIO_HOOK_POOL_SIZE 10240 #define DEFERRED_SET_SIZE 64 #define MAPPING_POOL_SIZE 1024 #define PRISON_CELLS 1024 #define COMMIT_PERIOD HZ /* * The block size of the device holding pool data must be * between 64KB and 1GB. */ #define DATA_DEV_BLOCK_SIZE_MIN_SECTORS (64 * 1024 >> SECTOR_SHIFT) #define DATA_DEV_BLOCK_SIZE_MAX_SECTORS (1024 * 1024 * 1024 >> SECTOR_SHIFT) /* * Device id is restricted to 24 bits. */ #define MAX_DEV_ID ((1 << 24) - 1) /* * How do we handle breaking sharing of data blocks? * ================================================= * * We use a standard copy-on-write btree to store the mappings for the * devices (note I'm talking about copy-on-write of the metadata here, not * the data). When you take an internal snapshot you clone the root node * of the origin btree. After this there is no concept of an origin or a * snapshot. They are just two device trees that happen to point to the * same data blocks. * * When we get a write in we decide if it's to a shared data block using * some timestamp magic. If it is, we have to break sharing. * * Let's say we write to a shared block in what was the origin. The * steps are: * * i) plug io further to this physical block. (see bio_prison code). * * ii) quiesce any read io to that shared data block. Obviously * including all devices that share this block. (see deferred_set code) * * iii) copy the data block to a newly allocate block. This step can be * missed out if the io covers the block. (schedule_copy). * * iv) insert the new mapping into the origin's btree * (process_prepared_mapping). This act of inserting breaks some * sharing of btree nodes between the two devices. Breaking sharing only * effects the btree of that specific device. Btrees for the other * devices that share the block never change. The btree for the origin * device as it was after the last commit is untouched, ie. we're using * persistent data structures in the functional programming sense. * * v) unplug io to this physical block, including the io that triggered * the breaking of sharing. * * Steps (ii) and (iii) occur in parallel. * * The metadata _doesn't_ need to be committed before the io continues. We * get away with this because the io is always written to a _new_ block. * If there's a crash, then: * * - The origin mapping will point to the old origin block (the shared * one). This will contain the data as it was before the io that triggered * the breaking of sharing came in. * * - The snap mapping still points to the old block. As it would after * the commit. * * The downside of this scheme is the timestamp magic isn't perfect, and * will continue to think that data block in the snapshot device is shared * even after the write to the origin has broken sharing. I suspect data * blocks will typically be shared by many different devices, so we're * breaking sharing n + 1 times, rather than n, where n is the number of * devices that reference this data block. At the moment I think the * benefits far, far outweigh the disadvantages. */ /*----------------------------------------------------------------*/ /* * Sometimes we can't deal with a bio straight away. We put them in prison * where they can't cause any mischief. Bios are put in a cell identified * by a key, multiple bios can be in the same cell. When the cell is * subsequently unlocked the bios become available. */ struct bio_prison; struct cell_key { int virtual; dm_thin_id dev; dm_block_t block; }; struct dm_bio_prison_cell { struct hlist_node list; struct bio_prison *prison; struct cell_key key; struct bio *holder; struct bio_list bios; }; struct bio_prison { spinlock_t lock; mempool_t *cell_pool; unsigned nr_buckets; unsigned hash_mask; struct hlist_head *cells; }; static uint32_t calc_nr_buckets(unsigned nr_cells) { uint32_t n = 128; nr_cells /= 4; nr_cells = min(nr_cells, 8192u); while (n < nr_cells) n <<= 1; return n; } static struct kmem_cache *_cell_cache; /* * @nr_cells should be the number of cells you want in use _concurrently_. * Don't confuse it with the number of distinct keys. */ static struct bio_prison *prison_create(unsigned nr_cells) { unsigned i; uint32_t nr_buckets = calc_nr_buckets(nr_cells); size_t len = sizeof(struct bio_prison) + (sizeof(struct hlist_head) * nr_buckets); struct bio_prison *prison = kmalloc(len, GFP_KERNEL); if (!prison) return NULL; spin_lock_init(&prison->lock); prison->cell_pool = mempool_create_slab_pool(nr_cells, _cell_cache); if (!prison->cell_pool) { kfree(prison); return NULL; } prison->nr_buckets = nr_buckets; prison->hash_mask = nr_buckets - 1; prison->cells = (struct hlist_head *) (prison + 1); for (i = 0; i < nr_buckets; i++) INIT_HLIST_HEAD(prison->cells + i); return prison; } static void prison_destroy(struct bio_prison *prison) { mempool_destroy(prison->cell_pool); kfree(prison); } static uint32_t hash_key(struct bio_prison *prison, struct cell_key *key) { const unsigned long BIG_PRIME = 4294967291UL; uint64_t hash = key->block * BIG_PRIME; return (uint32_t) (hash & prison->hash_mask); } static int keys_equal(struct cell_key *lhs, struct cell_key *rhs) { return (lhs->virtual == rhs->virtual) && (lhs->dev == rhs->dev) && (lhs->block == rhs->block); } static struct dm_bio_prison_cell *__search_bucket(struct hlist_head *bucket, struct cell_key *key) { struct dm_bio_prison_cell *cell; struct hlist_node *tmp; hlist_for_each_entry(cell, tmp, bucket, list) if (keys_equal(&cell->key, key)) return cell; return NULL; } /* * This may block if a new cell needs allocating. You must ensure that * cells will be unlocked even if the calling thread is blocked. * * Returns 1 if the cell was already held, 0 if @inmate is the new holder. */ static int bio_detain(struct bio_prison *prison, struct cell_key *key, struct bio *inmate, struct dm_bio_prison_cell **ref) { int r = 1; unsigned long flags; uint32_t hash = hash_key(prison, key); struct dm_bio_prison_cell *cell, *cell2; BUG_ON(hash > prison->nr_buckets); spin_lock_irqsave(&prison->lock, flags); cell = __search_bucket(prison->cells + hash, key); if (cell) { bio_list_add(&cell->bios, inmate); goto out; } /* * Allocate a new cell */ spin_unlock_irqrestore(&prison->lock, flags); cell2 = mempool_alloc(prison->cell_pool, GFP_NOIO); spin_lock_irqsave(&prison->lock, flags); /* * We've been unlocked, so we have to double check that * nobody else has inserted this cell in the meantime. */ cell = __search_bucket(prison->cells + hash, key); if (cell) { mempool_free(cell2, prison->cell_pool); bio_list_add(&cell->bios, inmate); goto out; } /* * Use new cell. */ cell = cell2; cell->prison = prison; memcpy(&cell->key, key, sizeof(cell->key)); cell->holder = inmate; bio_list_init(&cell->bios); hlist_add_head(&cell->list, prison->cells + hash); r = 0; out: spin_unlock_irqrestore(&prison->lock, flags); *ref = cell; return r; } /* * @inmates must have been initialised prior to this call */ static void __cell_release(struct dm_bio_prison_cell *cell, struct bio_list *inmates) { struct bio_prison *prison = cell->prison; hlist_del(&cell->list); if (inmates) { bio_list_add(inmates, cell->holder); bio_list_merge(inmates, &cell->bios); } mempool_free(cell, prison->cell_pool); } static void cell_release(struct dm_bio_prison_cell *cell, struct bio_list *bios) { unsigned long flags; struct bio_prison *prison = cell->prison; spin_lock_irqsave(&prison->lock, flags); __cell_release(cell, bios); spin_unlock_irqrestore(&prison->lock, flags); } /* * There are a couple of places where we put a bio into a cell briefly * before taking it out again. In these situations we know that no other * bio may be in the cell. This function releases the cell, and also does * a sanity check. */ static void __cell_release_singleton(struct dm_bio_prison_cell *cell, struct bio *bio) { BUG_ON(cell->holder != bio); BUG_ON(!bio_list_empty(&cell->bios)); __cell_release(cell, NULL); } static void cell_release_singleton(struct dm_bio_prison_cell *cell, struct bio *bio) { unsigned long flags; struct bio_prison *prison = cell->prison; spin_lock_irqsave(&prison->lock, flags); __cell_release_singleton(cell, bio); spin_unlock_irqrestore(&prison->lock, flags); } /* * Sometimes we don't want the holder, just the additional bios. */ static void __cell_release_no_holder(struct dm_bio_prison_cell *cell, struct bio_list *inmates) { struct bio_prison *prison = cell->prison; hlist_del(&cell->list); bio_list_merge(inmates, &cell->bios); mempool_free(cell, prison->cell_pool); } static void cell_release_no_holder(struct dm_bio_prison_cell *cell, struct bio_list *inmates) { unsigned long flags; struct bio_prison *prison = cell->prison; spin_lock_irqsave(&prison->lock, flags); __cell_release_no_holder(cell, inmates); spin_unlock_irqrestore(&prison->lock, flags); } static void cell_error(struct dm_bio_prison_cell *cell) { struct bio_prison *prison = cell->prison; struct bio_list bios; struct bio *bio; unsigned long flags; bio_list_init(&bios); spin_lock_irqsave(&prison->lock, flags); __cell_release(cell, &bios); spin_unlock_irqrestore(&prison->lock, flags); while ((bio = bio_list_pop(&bios))) bio_io_error(bio); } /*----------------------------------------------------------------*/ /* * We use the deferred set to keep track of pending reads to shared blocks. * We do this to ensure the new mapping caused by a write isn't performed * until these prior reads have completed. Otherwise the insertion of the * new mapping could free the old block that the read bios are mapped to. */ struct deferred_set; struct deferred_entry { struct deferred_set *ds; unsigned count; struct list_head work_items; }; struct deferred_set { spinlock_t lock; unsigned current_entry; unsigned sweeper; struct deferred_entry entries[DEFERRED_SET_SIZE]; }; static void ds_init(struct deferred_set *ds) { int i; spin_lock_init(&ds->lock); ds->current_entry = 0; ds->sweeper = 0; for (i = 0; i < DEFERRED_SET_SIZE; i++) { ds->entries[i].ds = ds; ds->entries[i].count = 0; INIT_LIST_HEAD(&ds->entries[i].work_items); } } static struct deferred_entry *ds_inc(struct deferred_set *ds) { unsigned long flags; struct deferred_entry *entry; spin_lock_irqsave(&ds->lock, flags); entry = ds->entries + ds->current_entry; entry->count++; spin_unlock_irqrestore(&ds->lock, flags); return entry; } static unsigned ds_next(unsigned index) { return (index + 1) % DEFERRED_SET_SIZE; } static void __sweep(struct deferred_set *ds, struct list_head *head) { while ((ds->sweeper != ds->current_entry) && !ds->entries[ds->sweeper].count) { list_splice_init(&ds->entries[ds->sweeper].work_items, head); ds->sweeper = ds_next(ds->sweeper); } if ((ds->sweeper == ds->current_entry) && !ds->entries[ds->sweeper].count) list_splice_init(&ds->entries[ds->sweeper].work_items, head); } static void ds_dec(struct deferred_entry *entry, struct list_head *head) { unsigned long flags; spin_lock_irqsave(&entry->ds->lock, flags); BUG_ON(!entry->count); --entry->count; __sweep(entry->ds, head); spin_unlock_irqrestore(&entry->ds->lock, flags); } /* * Returns 1 if deferred or 0 if no pending items to delay job. */ static int ds_add_work(struct deferred_set *ds, struct list_head *work) { int r = 1; unsigned long flags; unsigned next_entry; spin_lock_irqsave(&ds->lock, flags); if ((ds->sweeper == ds->current_entry) && !ds->entries[ds->current_entry].count) r = 0; else { list_add(work, &ds->entries[ds->current_entry].work_items); next_entry = ds_next(ds->current_entry); if (!ds->entries[next_entry].count) ds->current_entry = next_entry; } spin_unlock_irqrestore(&ds->lock, flags); return r; } /*----------------------------------------------------------------*/ /* * Key building. */ static void build_data_key(struct dm_thin_device *td, dm_block_t b, struct cell_key *key) { key->virtual = 0; key->dev = dm_thin_dev_id(td); key->block = b; } static void build_virtual_key(struct dm_thin_device *td, dm_block_t b, struct cell_key *key) { key->virtual = 1; key->dev = dm_thin_dev_id(td); key->block = b; } /*----------------------------------------------------------------*/ /* * A pool device ties together a metadata device and a data device. It * also provides the interface for creating and destroying internal * devices. */ struct dm_thin_new_mapping; struct pool_features { unsigned zero_new_blocks:1;