Merge tag 'for-7.4/dm-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/device-mapper/linux-dm

Pull device mapper fixes from Mikulas Patocka:
 "dm:
   - fix infinite loop when removing a zoned device
   - fix misbehavior if kobject_init_and_add fails
   - fix refcount underflow if zone reset failed
   - fix misbehavior if we attempt to load a table after previous table
     load failed
   - fix use-after-free if we open a device read-only and then re-open
     it read-write
   - fix error being ignored if flush failed

  dm-pcache:
   - fix misbehavior on flush failure

  dm-raid:
   - validate array_position after it is read from the superblock

  dm-cache:
   - fix a crash if dm_kcopyd_client_create fails
   - fix divide by zero on extremely large device
   - fix NULL pointer dereference on open failure
   - fix misbehavior if dm_bitset_cursor_begin fails

  dm-snapshot:
   - properly advertise discard_granularity in the queue limits
   - fix data corruption on unaligned discards

  dm-crypt:
   - fix a crash on invalid table line
   - fix scheduling in atomic context when using no_write_workqueue and
     asynchronous completion cipher
   - fix misbehavior if percpu_counter_init fails

  dm-thin:
   - fix integer overflow if no_space_timeout is too high
   - fix data corruption if discard races with regular I/O
   - fix leak if __set_snapshot_details fails
   - fix parsing of feature arguments

  dm-mpath:
   - fix buffer overflow when parsing the table string
   - fix integer overflow in queue_if_no_path_timeout_secs

  dm-log-userspace:
   - fix open device leak on initialization error

  dm-zoned:
   - back off when reclaim cannot make progress
   - do not reclaim a random zone into another random zone

  dm-integrity:
   - don't recalculate with HMAC because of a dirty bitmap
   - don't attempt to commit journal on disabled device

  dm-persistent-data:
   - don't ignore the return value of node_copy
   - fix buffer leak if find_leaf fails

  dm-verity:
   - don't restart or panic on errors during system shutdown

  dm-raid:
   - flush a work item in raid_dtr, fix use-after-free"

* tag 'for-7.4/dm-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/device-mapper/linux-dm: (34 commits)
  dm: fail a REQ_PREFLUSH bio with data when its preflush fails
  dm-raid: fix use-after-free in raid_dtr()
  dm-integrity: don't attempt to commit journal on disabled device
  dm-verity: don't restart or panic on errors during system shutdown
  dm crypt: fix use of uninitialized percpu_counter in ctr error path
  dm: fix use-after-free when dm_get_device() widens the open mode
  dm persistent data: don't leak bufio buffer if find_leaf fails
  dm persistent data: don't ignore writeback errors
  dm persistent data: test return value of node_copy
  dm-thin: fix parsing of feature arguments
  dm-thin: fix leak if __set_snapshot_details fails
  dm-thin: fix data corruption if discard races with regular I/O
  dm-cache: fix ending a cursor that never began
  dm-cache: fix NULL pointer dereference on open failure
  dm-crypt: defer async write submission to write thread
  dm mpath: cap queue_if_no_path_timeout_secs
  dm cache: validate the discard block size before narrowing
  dm: Reject table setup after queue or disk teardown
  dm: avoid double-dropping the zone reset submission reference
  dm-sysfs: fix misbehavior if kobject_init_and_add fails
  ...
This commit is contained in:
Linus Torvalds
2026-11-15 13:45:14 -08:00
24 changed files with 300 additions and 133 deletions
+3 -1
View File
@@ -766,6 +766,7 @@ static struct dm_cache_metadata *metadata_open(struct block_device *bdev,
return ERR_PTR(-ENOMEM);
}
INIT_LIST_HEAD(&cmd->list);
cmd->version = metadata_version;
refcount_set(&cmd->ref_count, 1);
init_rwsem(&cmd->root_lock);
@@ -1432,7 +1433,8 @@ static int __load_mappings(struct dm_cache_metadata *cmd,
from_cblock(cmd->cache_blocks),
&cmd->dirty_cursor);
if (r) {
dm_array_cursor_end(&cmd->hint_cursor);
if (hints_valid)
dm_array_cursor_end(&cmd->hint_cursor);
dm_array_cursor_end(&cmd->mapping_cursor);
return r;
}
+11 -4
View File
@@ -17,6 +17,7 @@
#include <linux/jiffies.h>
#include <linux/init.h>
#include <linux/kstrtox.h>
#include <linux/math64.h>
#include <linux/mempool.h>
#include <linux/module.h>
#include <linux/rwsem.h>
@@ -2383,9 +2384,7 @@ static int create_cache_policy(struct cache *cache, struct cache_args *ca,
static bool too_many_discard_blocks(sector_t discard_block_size,
sector_t origin_size)
{
(void) sector_div(origin_size, discard_block_size);
return origin_size > MAX_DISCARD_BLOCKS;
return div64_u64(origin_size, discard_block_size) > MAX_DISCARD_BLOCKS;
}
static sector_t calculate_discard_block_size(sector_t cache_block_size,
@@ -2422,6 +2421,7 @@ static int cache_create(struct cache_args *ca, struct cache **result)
struct cache *cache;
struct dm_target *ti = ca->ti;
dm_block_t origin_blocks;
sector_t discard_block_size;
struct dm_cache_metadata *cmd;
bool may_format = ca->features.mode == CM_WRITE;
@@ -2521,9 +2521,15 @@ static int cache_create(struct cache_args *ca, struct cache **result)
}
clear_bitset(cache->dirty_bitset, from_cblock(cache->cache_size));
cache->discard_block_size =
discard_block_size =
calculate_discard_block_size(cache->sectors_per_block,
cache->origin_sectors);
if (discard_block_size > U32_MAX) {
*error = "Discard block size exceeds 32 bits";
r = -EOVERFLOW;
goto bad;
}
cache->discard_block_size = discard_block_size;
cache->discard_nr_blocks = to_dblock(dm_sector_div_up(cache->origin_sectors,
cache->discard_block_size));
cache->discard_bitset = alloc_bitset(from_dblock(cache->discard_nr_blocks));
@@ -2544,6 +2550,7 @@ static int cache_create(struct cache_args *ca, struct cache **result)
if (IS_ERR(cache->copier)) {
*error = "could not create kcopyd client";
r = PTR_ERR(cache->copier);
cache->copier = NULL;
goto bad;
}
+15 -7
View File
@@ -1982,8 +1982,9 @@ static void kcryptd_crypt_write_io_submit(struct dm_crypt_io *io, int async)
/* crypt_convert should have filled the clone bio */
BUG_ON(io->ctx.iter_out.bi_size);
if ((likely(!async) && test_bit(DM_CRYPT_NO_OFFLOAD, &cc->flags)) ||
test_bit(DM_CRYPT_NO_WRITE_WORKQUEUE, &cc->flags)) {
if (likely(!async) &&
(test_bit(DM_CRYPT_NO_OFFLOAD, &cc->flags) ||
test_bit(DM_CRYPT_NO_WRITE_WORKQUEUE, &cc->flags))) {
dm_submit_bio_remap(io->base_bio, clone);
return;
}
@@ -2847,8 +2848,11 @@ static int crypt_ctr_auth_cipher(struct crypt_config *cc, char *cipher_api)
char *start, *end, *mac_alg = NULL;
struct crypto_ahash *mac;
if (!strstarts(cipher_api, "authenc("))
if (!strstarts(cipher_api, "authenc(")) {
if (test_bit(CRYPT_KEY_MAC_SIZE_SET, &cc->cipher_flags))
return -EINVAL;
return 0;
}
start = strchr(cipher_api, '(');
end = strchr(cipher_api, ',');
@@ -3229,6 +3233,14 @@ static int crypt_ctr(struct dm_target *ti, unsigned int argc, char **argv)
ti->error = "Cannot allocate encryption context";
return -ENOMEM;
}
ret = percpu_counter_init(&cc->n_allocated_pages, 0, GFP_KERNEL);
if (ret < 0) {
ti->error = "Cannot initialize page counter";
kfree_sensitive(cc);
return ret;
}
cc->key_size = key_size;
cc->sector_size = (1 << SECTOR_SHIFT);
cc->sector_shift = 0;
@@ -3240,10 +3252,6 @@ static int crypt_ctr(struct dm_target *ti, unsigned int argc, char **argv)
crypt_calculate_pages_per_client();
spin_unlock(&dm_crypt_clients_lock);
ret = percpu_counter_init(&cc->n_allocated_pages, 0, GFP_KERNEL);
if (ret < 0)
goto bad;
/* Optional parameters need to be read before cipher constructor */
if (argc > 5) {
ret = crypt_ctr_optional(ti, argc - 5, &argv[5]);
+27 -3
View File
@@ -2908,6 +2908,11 @@ static void integrity_commit(struct work_struct *w)
spin_lock_irq(&ic->endio_wait.lock);
flushes = bio_list_get(&ic->flush_bio_list);
if (unlikely(dm_integrity_failed(ic))) {
wake_up_locked(&ic->endio_wait);
spin_unlock_irq(&ic->endio_wait.lock);
goto release_flush_bios;
}
if (unlikely(ic->mode != 'J')) {
spin_unlock_irq(&ic->endio_wait.lock);
dm_integrity_flush_buffers(ic, true);
@@ -3888,6 +3893,24 @@ static bool superblock_changed(struct dm_integrity_c *ic)
memcmp(ic->sb->salt, ic->sb_copy->salt, SALT_SIZE) != 0;
}
/*
* The superblock is authenticated only if fix_hmac and journal_mac are used,
* so SB_FLAG_DIRTY_BITMAP may have been set by someone who doesn't know the
* key. Apply the policy that the constructor applies to SB_FLAG_RECALCULATING.
*/
static bool dm_integrity_may_recalc_dirty_bitmap(struct dm_integrity_c *ic)
{
if (!ic->internal_hash) {
DMERR("Dirty bitmap found, but internal_hash is not used");
return false;
}
if (dm_integrity_disable_recalculate(ic)) {
DMERR("Dirty bitmap found, but HMAC recalculation requires \"legacy_recalculate\"");
return false;
}
return true;
}
static void dm_integrity_resume(struct dm_target *ti)
{
struct dm_integrity_c *ic = ti->private;
@@ -3977,8 +4000,10 @@ static void dm_integrity_resume(struct dm_target *ti)
if (!(ic->sb->log2_blocks_per_bitmap_bit == ic->log2_blocks_per_bitmap_bit &&
block_bitmap_op(ic, ic->journal, 0, ic->provided_data_sectors, BITMAP_OP_TEST_ALL_CLEAR)) ||
ic->reset_recalculate_flag) {
ic->sb->flags |= cpu_to_le32(SB_FLAG_RECALCULATING);
ic->sb->recalc_sector = cpu_to_le64(0);
if (dm_integrity_may_recalc_dirty_bitmap(ic)) {
ic->sb->flags |= cpu_to_le32(SB_FLAG_RECALCULATING);
ic->sb->recalc_sector = cpu_to_le64(0);
}
}
init_journal(ic, 0, ic->journal_sections, 0);
replay_journal(ic);
@@ -5409,7 +5434,6 @@ try_smaller_buffer:
r = create_journal(ic, &ti->error);
if (r)
goto bad;
}
if (ic->mode == 'B') {
+1 -1
View File
@@ -1794,7 +1794,7 @@ static void retrieve_deps(struct dm_table *table,
deps->count = count;
count = 0;
list_for_each_entry(dd, dm_table_get_devices(table), list)
deps->dev[count++] = huge_encode_dev(dd->dm_dev->bdev->bd_dev);
deps->dev[count++] = huge_encode_dev(dd->bdev->bd_dev);
param->data_size = param->data_start + needed;
}
+5 -1
View File
@@ -294,9 +294,11 @@ static int userspace_ctr(struct dm_dirty_log *log, struct dm_target *ti,
}
r = dm_get_device(ti, devices_rdata,
dm_table_get_mode(ti->table), &lc->log_dev);
if (r)
if (r) {
DMERR("Failed to register %s with device-mapper",
devices_rdata);
goto out;
}
}
if (lc->integrated_flush) {
@@ -315,6 +317,8 @@ static int userspace_ctr(struct dm_dirty_log *log, struct dm_target *ti,
out:
kfree(devices_rdata);
if (r) {
if (lc->log_dev)
dm_put_device(lc->ti, lc->log_dev);
mempool_exit(&lc->flush_entry_pool);
kfree(lc);
kfree(ctr_str);
+4 -2
View File
@@ -797,7 +797,8 @@ static void queue_if_no_path_timeout_work(struct timer_list *t)
static void enable_nopath_timeout(struct multipath *m)
{
unsigned long queue_if_no_path_timeout =
READ_ONCE(queue_if_no_path_timeout_secs) * HZ;
min_t(unsigned long, READ_ONCE(queue_if_no_path_timeout_secs),
MAX_JIFFY_OFFSET / HZ) * HZ;
lockdep_assert_held(&m->lock);
@@ -1085,8 +1086,9 @@ static int parse_hw_handler(struct dm_arg_set *as, struct multipath *m)
if (hw_argc > 1) {
char *p;
int i, j, len = 4;
int i, j, len;
len = snprintf(NULL, 0, "%d", hw_argc - 1) + 1;
for (i = 0; i <= hw_argc - 2; i++)
len += strlen(as->argv[i]) + 1;
p = m->hw_handler_params = kzalloc(len, GFP_KERNEL);
+2 -2
View File
@@ -336,9 +336,9 @@ struct pcache_backing_dev_req *backing_dev_req_create(struct pcache_backing_dev
return backing_req;
}
void backing_dev_flush(struct pcache_backing_dev *backing_dev)
int backing_dev_flush(struct pcache_backing_dev *backing_dev)
{
blkdev_issue_flush(backing_dev->dm_dev->bdev);
return blkdev_issue_flush(backing_dev->dm_dev->bdev);
}
int pcache_backing_init(void)
+1 -1
View File
@@ -120,7 +120,7 @@ struct pcache_backing_dev_req *backing_dev_req_alloc(struct pcache_backing_dev *
struct pcache_backing_dev_req_opts *opts);
void backing_dev_req_init(struct pcache_backing_dev_req *backing_req,
struct pcache_backing_dev_req_opts *opts);
void backing_dev_flush(struct pcache_backing_dev *backing_dev);
int backing_dev_flush(struct pcache_backing_dev *backing_dev);
int pcache_backing_init(void);
void pcache_backing_exit(void);
+21 -7
View File
@@ -18,12 +18,18 @@ static void writeback_ctx_end(struct pcache_cache *cache, int ret)
return;
if (!cache->writeback_ctx.ret) {
backing_dev_flush(cache->backing_dev);
mutex_lock(&cache->dirty_tail_lock);
cache_pos_advance(&cache->dirty_tail, cache->writeback_ctx.advance);
cache_encode_dirty_tail(cache);
mutex_unlock(&cache->dirty_tail_lock);
ret = backing_dev_flush(cache->backing_dev);
if (ret) {
pcache_dev_err(CACHE_TO_PCACHE(cache),
"failed to flush backing device: %d", ret);
cache->writeback_ctx.ret = ret;
} else {
mutex_lock(&cache->dirty_tail_lock);
cache_pos_advance(&cache->dirty_tail,
cache->writeback_ctx.advance);
cache_encode_dirty_tail(cache);
mutex_unlock(&cache->dirty_tail_lock);
}
}
queue_delayed_work(cache_get_wq(cache), &cache->writeback_work, 0);
}
@@ -76,8 +82,16 @@ static inline bool is_cache_clean(struct pcache_cache *cache, struct pcache_cach
void cache_writeback_exit(struct pcache_cache *cache)
{
int ret;
cancel_delayed_work_sync(&cache->writeback_work);
backing_dev_flush(cache->backing_dev);
ret = backing_dev_flush(cache->backing_dev);
if (ret)
pcache_dev_err(CACHE_TO_PCACHE(cache),
"failed to flush backing device during exit: %d",
ret);
cache_tree_exit(&cache->writeback_key_tree);
}
+3 -2
View File
@@ -2420,7 +2420,8 @@ static int super_init_validation(struct raid_set *rs, struct md_rdev *rdev)
*/
if (!test_bit(FirstUse, &r->flags) && (r->raid_disk >= 0)) {
role = le32_to_cpu(sb2->array_position);
if (role < 0)
/* Bound @role before it indexes the failed_devices stack bitmap. */
if (role < 0 || role >= rs->raid_disks)
continue;
if (role != r->raid_disk) {
@@ -3333,7 +3334,7 @@ static void raid_dtr(struct dm_target *ti)
rs->md.dm_gendisk = NULL;
mddev_unlock(&rs->md);
if (work_pending(&rs->md.event_work))
if (rs->md.event_work.func)
flush_work(&rs->md.event_work);
raid_set_free(rs);
}
+11 -7
View File
@@ -1358,8 +1358,10 @@ static int snapshot_ctr(struct dm_target *ti, unsigned int argc, char **argv)
ti->private = s;
ti->num_flush_bios = num_flush_bios;
if (s->discard_zeroes_cow)
if (s->discard_zeroes_cow) {
ti->num_discard_bios = (s->discard_passdown_origin ? 2 : 1);
ti->max_discard_granularity = true;
}
ti->per_io_data_size = sizeof(struct dm_snap_tracked_chunk);
/* Add snapshot to the list of snapshots for this origin */
@@ -1946,8 +1948,8 @@ static void zero_exception(struct dm_snapshot *s, struct dm_exception *e,
static bool io_overlaps_chunk(struct dm_snapshot *s, struct bio *bio)
{
return bio->bi_iter.bi_size ==
(s->store->chunk_size << SECTOR_SHIFT);
return bio->bi_iter.bi_size == (s->store->chunk_size << SECTOR_SHIFT) &&
!(bio->bi_iter.bi_sector & s->store->chunk_mask);
}
static int snapshot_map(struct dm_target *ti, struct bio *bio)
@@ -2007,11 +2009,13 @@ static int snapshot_map(struct dm_target *ti, struct bio *bio)
e = dm_lookup_exception(&s->complete, chunk);
if (e) {
remap_exception(s, e, bio, chunk);
if (unlikely(bio_op(bio) == REQ_OP_DISCARD) &&
io_overlaps_chunk(s, bio)) {
if (unlikely(bio_op(bio) == REQ_OP_DISCARD)) {
dm_exception_table_unlock(&lock);
up_read(&s->lock);
zero_exception(s, e, bio, chunk);
if (io_overlaps_chunk(s, bio))
zero_exception(s, e, bio, chunk);
else
bio_endio(bio);
r = DM_MAPIO_SUBMITTED; /* discard is not issued */
goto out;
}
@@ -2414,7 +2418,7 @@ static void snapshot_io_hints(struct dm_target *ti, struct queue_limits *limits)
snap = snap_src;
/* All discards are split on chunk_size boundary */
limits->discard_granularity = snap->store->chunk_size;
limits->discard_granularity = snap->store->chunk_size << SECTOR_SHIFT;
limits->max_hw_discard_sectors = snap->store->chunk_size;
up_read(&_origins_lock);
+14 -3
View File
@@ -128,9 +128,20 @@ static const struct kobj_type dm_ktype = {
*/
int dm_sysfs_init(struct mapped_device *md)
{
return kobject_init_and_add(dm_kobject(md), &dm_ktype,
&disk_to_dev(dm_disk(md))->kobj,
"%s", "dm");
struct kobject *kobj = dm_kobject(md);
int r;
/* The kobject must be zeroed before calling kobject_init */
memset(kobj, 0, sizeof(struct kobject));
r = kobject_init_and_add(kobj, &dm_ktype,
&disk_to_dev(dm_disk(md))->kobj,
"%s", "dm");
if (unlikely(r)) {
/* Weird semantics - we must call kobject_put on failure */
dm_sysfs_exit(md);
return r;
}
return 0;
}
/*
+81 -65
View File
@@ -165,14 +165,16 @@ int dm_table_create(struct dm_table **result, blk_mode_t mode,
static void free_devices(struct list_head *devices, struct mapped_device *md)
{
struct list_head *tmp, *next;
struct dm_dev_internal *dd, *dd_next;
struct dm_dev_ref *ref, *ref_next;
list_for_each_safe(tmp, next, devices) {
struct dm_dev_internal *dd =
list_entry(tmp, struct dm_dev_internal, list);
DMWARN("%s: dm_table_destroy: dm_put_device call missing for %s",
dm_device_name(md), dd->dm_dev->name);
dm_put_table_device(md, dd->dm_dev);
list_for_each_entry_safe(dd, dd_next, devices, list) {
list_for_each_entry_safe(ref, ref_next, &dd->refs, list) {
DMWARN("%s: dm_table_destroy: dm_put_device call missing for %s",
dm_device_name(md), ref->dm_dev->name);
dm_put_table_device(md, ref->dm_dev);
kfree(ref);
}
kfree(dd);
}
}
@@ -218,12 +220,27 @@ static struct dm_dev_internal *find_device(struct list_head *l, dev_t dev)
struct dm_dev_internal *dd;
list_for_each_entry(dd, l, list)
if (dd->dm_dev->bdev->bd_dev == dev)
if (dd->bdev->bd_dev == dev)
return dd;
return NULL;
}
/*
* See if the device is already open with a mode that covers the
* requested one.
*/
static struct dm_dev_ref *find_ref(struct dm_dev_internal *dd, blk_mode_t mode)
{
struct dm_dev_ref *ref;
list_for_each_entry(ref, &dd->refs, list)
if ((ref->dm_dev->mode & mode) == mode)
return ref;
return NULL;
}
/*
* If possible, this checks an area of a destination device is invalid.
*/
@@ -303,31 +320,6 @@ static int device_area_is_invalid(struct dm_target *ti, struct dm_dev *dev,
return 0;
}
/*
* This upgrades the mode on an already open dm_dev, being
* careful to leave things as they were if we fail to reopen the
* device and not to touch the existing bdev field in case
* it is accessed concurrently.
*/
static int upgrade_mode(struct dm_dev_internal *dd, blk_mode_t new_mode,
struct mapped_device *md)
{
int r;
struct dm_dev *old_dev, *new_dev;
old_dev = dd->dm_dev;
r = dm_get_table_device(md, dd->dm_dev->bdev->bd_dev,
dd->dm_dev->mode | new_mode, &new_dev);
if (r)
return r;
dd->dm_dev = new_dev;
dm_put_table_device(md, old_dev);
return 0;
}
/*
* Note: the __ref annotation is because this function can call the __init
* marked early_lookup_bdev when called during early boot code from dm-init.c.
@@ -360,7 +352,9 @@ EXPORT_SYMBOL(dm_devt_from_path);
/*
* Add a device to the list, or just increment the usage count if
* it's already present.
* it's already present with a mode that covers the requested one.
* Otherwise open the device again with the requested mode, so the
* dm_devs returned earlier stay valid.
*/
int dm_get_device(struct dm_target *ti, const char *path, blk_mode_t mode,
struct dm_dev **result)
@@ -368,6 +362,7 @@ int dm_get_device(struct dm_target *ti, const char *path, blk_mode_t mode,
int r;
dev_t dev;
struct dm_dev_internal *dd;
struct dm_dev_ref *ref;
struct dm_table *t = ti->table;
BUG_ON(!t);
@@ -380,30 +375,46 @@ int dm_get_device(struct dm_target *ti, const char *path, blk_mode_t mode,
return -EINVAL;
dd = find_device(&t->devices, dev);
if (!dd) {
if (dd) {
ref = find_ref(dd, mode);
if (ref) {
refcount_inc(&ref->count);
goto out;
}
} else {
dd = kmalloc_obj(*dd);
if (!dd)
return -ENOMEM;
r = dm_get_table_device(t->md, dev, mode, &dd->dm_dev);
if (r) {
kfree(dd);
return r;
}
refcount_set(&dd->count, 1);
list_add(&dd->list, &t->devices);
goto out;
} else if (dd->dm_dev->mode != (mode | dd->dm_dev->mode)) {
r = upgrade_mode(dd, mode, t->md);
if (r)
return r;
INIT_LIST_HEAD(&dd->refs);
}
refcount_inc(&dd->count);
ref = kmalloc_obj(*ref);
if (!ref) {
r = -ENOMEM;
goto bad;
}
r = dm_get_table_device(t->md, dev, mode, &ref->dm_dev);
if (r) {
kfree(ref);
goto bad;
}
refcount_set(&ref->count, 1);
/* A device in the list always has at least one ref */
if (list_empty(&dd->refs)) {
dd->bdev = ref->dm_dev->bdev;
list_add(&dd->list, &t->devices);
}
list_add_tail(&ref->list, &dd->refs);
out:
*result = dd->dm_dev;
*result = ref->dm_dev;
return 0;
bad:
if (list_empty(&dd->refs))
kfree(dd);
return r;
}
EXPORT_SYMBOL(dm_get_device);
@@ -453,23 +464,28 @@ static int dm_set_device_limits(struct dm_target *ti, struct dm_dev *dev,
*/
void dm_put_device(struct dm_target *ti, struct dm_dev *d)
{
int found = 0;
struct list_head *devices = &ti->table->devices;
struct dm_dev_internal *dd;
struct dm_dev_ref *ref;
list_for_each_entry(dd, devices, list) {
if (dd->dm_dev == d) {
found = 1;
break;
}
}
if (!found) {
DMERR("%s: device %s not in table devices list",
dm_device_name(ti->table->md), d->name);
list_for_each_entry(dd, devices, list)
list_for_each_entry(ref, &dd->refs, list)
if (ref->dm_dev == d)
goto found;
DMERR("%s: device %s not in table devices list",
dm_device_name(ti->table->md), d->name);
return;
found:
if (!refcount_dec_and_test(&ref->count))
return;
}
if (refcount_dec_and_test(&dd->count)) {
dm_put_table_device(ti->table->md, d);
dm_put_table_device(ti->table->md, d);
list_del(&ref->list);
kfree(ref);
if (list_empty(&dd->refs)) {
list_del(&dd->list);
kfree(dd);
}
+4 -1
View File
@@ -1225,10 +1225,13 @@ static int __create_snap(struct dm_pool_metadata *pmd,
__close_device(td);
if (r)
goto bad;
goto bad2;
return 0;
bad2:
list_del(&td->list);
kfree(td);
bad:
dm_btree_remove(&pmd->tl_info, pmd->root, &key, &pmd->root);
dm_btree_remove(&pmd->details_info, pmd->details_root,
+5 -2
View File
@@ -1703,6 +1703,7 @@ static void break_up_discard_bio(struct thin_c *tc, dm_block_t begin, dm_block_t
(void) build_key(tc->td, PHYSICAL, data_begin, data_begin + len, &data_key);
if (bio_detain(tc->pool, &data_key, NULL, &data_cell)) {
/* contention, we'll give up with this range */
virt_begin += len;
data_begin += len;
continue;
}
@@ -2542,7 +2543,9 @@ static void set_pool_mode(struct pool *pool, enum pool_mode new_mode)
struct pool_c *pt = pool->ti->private;
bool needs_check = dm_pool_metadata_needs_check(pool->pmd);
enum pool_mode old_mode = get_pool_mode(pool);
unsigned long no_space_timeout = READ_ONCE(no_space_timeout_secs) * HZ;
unsigned long no_space_timeout =
min_t(unsigned long, READ_ONCE(no_space_timeout_secs),
MAX_JIFFY_OFFSET / HZ) * HZ;
/*
* Never allow the pool to transition to PM_WRITE mode if user
@@ -3146,7 +3149,7 @@ static int parse_pool_features(struct dm_arg_set *as, struct pool_features *pf,
const char *arg_name;
static const struct dm_arg _args[] = {
{0, 4, "Invalid number of pool feature arguments"},
{0, 5, "Invalid number of pool feature arguments"},
};
/*
+18 -9
View File
@@ -170,6 +170,15 @@ static void verity_hash_at_level(struct dm_verity *v, sector_t block, int level,
*offset = idx << (v->hash_dev_block_bits - v->hash_per_block_bits);
}
/*
* Skip verity work in response to I/O error when system is shutting down.
*/
static inline bool verity_is_system_shutting_down(void)
{
return system_state == SYSTEM_HALT || system_state == SYSTEM_POWER_OFF
|| system_state == SYSTEM_RESTART;
}
/*
* Handle verification errors.
*/
@@ -219,6 +228,15 @@ out:
if (v->mode == DM_VERITY_MODE_LOGGING)
return 0;
/*
* Devices may already be quiesced (e.g. UFS set offline by its
* shutdown hook), so a failure here does not imply corruption. Fail
* the I/O but do not restart or panic, which would also override the
* reboot reason of the shutdown already in progress.
*/
if (verity_is_system_shutting_down())
return 1;
if (v->mode == DM_VERITY_MODE_RESTART)
kernel_restart("dm-verity device corrupted");
@@ -593,15 +611,6 @@ error:
return r;
}
/*
* Skip verity work in response to I/O error when system is shutting down.
*/
static inline bool verity_is_system_shutting_down(void)
{
return system_state == SYSTEM_HALT || system_state == SYSTEM_POWER_OFF
|| system_state == SYSTEM_RESTART;
}
static void restart_io_error(struct work_struct *w)
{
kernel_restart("dm-verity device has I/O error");
+2
View File
@@ -33,6 +33,8 @@ static int dm_blk_do_report_zones(struct mapped_device *md, struct dm_table *t,
nr_zones - args->zone_idx);
if (ret < 0)
return ret;
if (!ret)
return -EIO;
} while (args->zone_idx < nr_zones &&
args->next_sector < get_capacity(md->disk));
+17 -1
View File
@@ -288,7 +288,13 @@ static int dmz_reclaim_rnd_data(struct dmz_reclaim *zrc, struct dm_zone *dzone)
again:
szone = dmz_alloc_zone(zmd, zrc->dev_idx,
alloc_flags | DMZ_ALLOC_RECLAIM);
if (!szone && alloc_flags == DMZ_ALLOC_SEQ && dmz_nr_cache_zones(zmd)) {
/*
* If no free sequential zone is available, a cache zone can still be
* moved into a free random zone of the zoned device, which frees cache
* space. Do not do this for a random zone: moving it into another
* random zone frees nothing and, on an idle target, repeats forever.
*/
if (!szone && alloc_flags == DMZ_ALLOC_SEQ && dmz_is_cache(dzone)) {
alloc_flags = DMZ_ALLOC_RND;
goto again;
}
@@ -537,6 +543,16 @@ static void dmz_reclaim_work(struct work_struct *work)
dmz_nr_rnd_zones(zmd, zrc->dev_idx));
ret = dmz_do_reclaim(zrc);
if (ret == -ENOSPC || ret == -EBUSY) {
/*
* No zone to copy into (-ENOSPC) or no zone to reclaim
* (-EBUSY): retrying at once cannot make progress and would
* spin. Poll again after the idle period instead, without
* postponing work that an allocation has already queued.
*/
queue_delayed_work(zrc->wq, &zrc->work, DMZ_IDLE_PERIOD);
return;
}
if (ret && ret != -EINTR) {
if (!dmz_check_dev(zmd))
return;
+15 -6
View File
@@ -983,7 +983,7 @@ static void __dm_io_complete(struct dm_io *io, bool first_stage)
if (requeued)
return;
if (unlikely(requeue_flush_with_data)) {
if (unlikely(requeue_flush_with_data) && !io_error) {
/*
* Preflush done for flush with data, reissue
* without REQ_PREFLUSH.
@@ -991,7 +991,7 @@ static void __dm_io_complete(struct dm_io *io, bool first_stage)
bio->bi_opf &= ~REQ_PREFLUSH;
queue_io(md, bio);
} else {
/* done with normal IO or empty flush */
/* done with normal IO, empty flush or failed preflush */
if (io_error)
bio->bi_status = io_error;
bio_endio(bio);
@@ -1588,7 +1588,7 @@ static void __send_empty_flush(struct clone_info *ci)
*/
clone = alloc_tio(ci, NULL, 0, &len, GFP_NOIO);
atomic_add(1, &ci->io->io_count);
bio_set_dev(clone, dd->dm_dev->bdev);
bio_set_dev(clone, dd->bdev);
clone->bi_end_io = clone_endio;
dm_submit_bio_remap(clone, NULL);
}
@@ -1929,8 +1929,13 @@ static blk_status_t __send_zone_reset_all(struct clone_info *ci)
break;
}
/* Release the reference that alloc_io() took for submission. */
atomic_sub(1, &ci->io->io_count);
/*
* Release the reference that alloc_io() took for submission. On error,
* that reference was not consumed: dm_split_and_process_bio() releases
* it on the error path, so do not release it here a second time.
*/
if (sts == BLK_STS_OK)
atomic_dec(&ci->io->io_count);
return sts;
}
@@ -2606,13 +2611,17 @@ int dm_setup_md_queue(struct mapped_device *md, struct dm_table *t)
WARN_ON_ONCE(type == DM_TYPE_NONE);
/* A failed setup may have left the queue initialized or the disk dead. */
if (md->tag_set || test_bit(GD_DEAD, &md->disk->state))
return -ENODEV;
if (type == DM_TYPE_REQUEST_BASED) {
md->disk->fops = &dm_rq_blk_dops;
r = dm_mq_init_request_queue(md, t);
if (r) {
DMERR("Cannot initialize queue for request-based dm mapped device");
return r;
}
md->disk->fops = &dm_rq_blk_dops;
}
r = dm_calculate_queue_limits(t, &limits);
+17 -1
View File
@@ -37,10 +37,26 @@
/*
* List of devices that a metadevice uses and should open/close.
* There is one dm_dev_internal per device. It holds one dm_dev_ref
* for each mode that the targets opened the device with.
*/
struct dm_dev_internal {
struct list_head list;
refcount_t count;
struct block_device *bdev;
struct list_head refs;
};
/*
* One open of a device with one mode, shared by the targets of a table.
* dm_get_device() reuses a dm_dev_ref whose mode covers the requested
* mode, and adds a new one only when none does. So the dm_dev_refs of
* a device have different modes, and a table holds each table_device
* at most once. table_device->count is still the number of tables that
* use the table_device.
*/
struct dm_dev_ref {
struct list_head list;
refcount_t count; /* dm_get_device() calls that returned dm_dev */
struct dm_dev *dm_dev;
};
+10 -3
View File
@@ -253,7 +253,9 @@ static int __rebalance2(struct dm_btree_info *info, struct btree_node *parent,
/*
* Merge
*/
node_copy(left, right, -nr_right);
ret = node_copy(left, right, -nr_right);
if (unlikely(ret))
return ret;
left->header.nr_entries = cpu_to_le32(nr_left + nr_right);
delete_at(parent, r->index);
@@ -315,13 +317,16 @@ static int delete_center_node(struct dm_btree_info *info, struct btree_node *par
{
uint32_t max_entries = le32_to_cpu(left->header.max_entries);
unsigned int shift = min(max_entries - nr_left, nr_center);
int ret;
if (nr_left + shift > max_entries) {
DMERR("node shift out of bounds");
return -EINVAL;
}
node_copy(left, center, -shift);
ret = node_copy(left, center, -shift);
if (unlikely(ret))
return ret;
left->header.nr_entries = cpu_to_le32(nr_left + shift);
if (shift != nr_center) {
@@ -333,7 +338,9 @@ static int delete_center_node(struct dm_btree_info *info, struct btree_node *par
}
node_shift(right, shift);
node_copy(center, right, shift);
ret = node_copy(center, right, shift);
if (unlikely(ret))
return ret;
right->header.nr_entries = cpu_to_le32(nr_right + shift);
}
*key_ptr(parent, r->index) = right->keys[0];
+7 -1
View File
@@ -1582,7 +1582,13 @@ int dm_btree_cursor_begin(struct dm_btree_info *info, dm_block_t root,
if (r)
return r;
return find_leaf(c);
r = find_leaf(c);
if (unlikely(r)) {
dm_btree_cursor_end(c);
return r;
}
return 0;
}
EXPORT_SYMBOL_GPL(dm_btree_cursor_begin);
@@ -1190,17 +1190,20 @@ static dm_block_t disk_ll_max_entries(struct ll_disk *ll)
static int disk_ll_commit(struct ll_disk *ll)
{
int r = 0;
int r;
unsigned int i;
for (i = 0; i < IE_CACHE_SIZE; i++) {
struct ie_cache *iec = ll->ie_cache + i;
if (iec->valid && iec->dirty)
if (iec->valid && iec->dirty) {
r = ie_cache_writeback(ll, iec);
if (unlikely(r))
return r;
}
}
return r;
return 0;
}
int sm_ll_new_disk(struct ll_disk *ll, struct dm_transaction_manager *tm)