tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

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

Pull device mapper fixes from Mike Snitzer:

- Fix DM discard regressions due to DM core switching over to using
queue_limits_set() without DM core and targets first being updated to
set (and stack) discard limits in terms of max_hw_discard_sectors and
not max_discard_sectors

- Fix stable@ DM integrity discard support to set device's
discard_granularity limit to the device's logical block size

* tag 'for-6.10/dm-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/device-mapper/linux-dm:
dm: always manage discard support in terms of max_hw_discard_sectors
dm-integrity: set discard_granularity to logical block size

Linus Torvalds 85672639 98f312bc

+10 -13
+2 -3
drivers/md/dm-cache-target.c
··· 3390 3390 3391 3391 if (!cache->features.discard_passdown) { 3392 3392 /* No passdown is done so setting own virtual limits */ 3393 - limits->max_discard_sectors = min_t(sector_t, cache->discard_block_size * 1024, 3394 - cache->origin_sectors); 3393 + limits->max_hw_discard_sectors = min_t(sector_t, cache->discard_block_size * 1024, 3394 + cache->origin_sectors); 3395 3395 limits->discard_granularity = cache->discard_block_size << SECTOR_SHIFT; 3396 3396 return; 3397 3397 } ··· 3400 3400 * cache_iterate_devices() is stacking both origin and fast device limits 3401 3401 * but discards aren't passed to fast device, so inherit origin's limits. 3402 3402 */ 3403 - limits->max_discard_sectors = origin_limits->max_discard_sectors; 3404 3403 limits->max_hw_discard_sectors = origin_limits->max_hw_discard_sectors; 3405 3404 limits->discard_granularity = origin_limits->discard_granularity; 3406 3405 limits->discard_alignment = origin_limits->discard_alignment;
+2 -2
drivers/md/dm-clone-target.c
··· 2046 2046 if (!test_bit(DM_CLONE_DISCARD_PASSDOWN, &clone->flags)) { 2047 2047 /* No passdown is done so we set our own virtual limits */ 2048 2048 limits->discard_granularity = clone->region_size << SECTOR_SHIFT; 2049 - limits->max_discard_sectors = round_down(UINT_MAX >> SECTOR_SHIFT, clone->region_size); 2049 + limits->max_hw_discard_sectors = round_down(UINT_MAX >> SECTOR_SHIFT, 2050 + clone->region_size); 2050 2051 return; 2051 2052 } 2052 2053 ··· 2056 2055 * device limits but discards aren't passed to the source device, so 2057 2056 * inherit destination's limits. 2058 2057 */ 2059 - limits->max_discard_sectors = dest_limits->max_discard_sectors; 2060 2058 limits->max_hw_discard_sectors = dest_limits->max_hw_discard_sectors; 2061 2059 limits->discard_granularity = dest_limits->discard_granularity; 2062 2060 limits->discard_alignment = dest_limits->discard_alignment;
+1
drivers/md/dm-integrity.c
··· 3492 3492 limits->physical_block_size = ic->sectors_per_block << SECTOR_SHIFT; 3493 3493 blk_limits_io_min(limits, ic->sectors_per_block << SECTOR_SHIFT); 3494 3494 limits->dma_alignment = limits->logical_block_size - 1; 3495 + limits->discard_granularity = ic->sectors_per_block << SECTOR_SHIFT; 3495 3496 } 3496 3497 limits->max_integrity_segments = USHRT_MAX; 3497 3498 }
+1 -1
drivers/md/dm-log-writes.c
··· 871 871 if (!bdev_max_discard_sectors(lc->dev->bdev)) { 872 872 lc->device_supports_discard = false; 873 873 limits->discard_granularity = lc->sectorsize; 874 - limits->max_discard_sectors = (UINT_MAX >> SECTOR_SHIFT); 874 + limits->max_hw_discard_sectors = (UINT_MAX >> SECTOR_SHIFT); 875 875 } 876 876 limits->logical_block_size = bdev_logical_block_size(lc->dev->bdev); 877 877 limits->physical_block_size = bdev_physical_block_size(lc->dev->bdev);
+1 -1
drivers/md/dm-snap.c
··· 2410 2410 2411 2411 /* All discards are split on chunk_size boundary */ 2412 2412 limits->discard_granularity = snap->store->chunk_size; 2413 - limits->max_discard_sectors = snap->store->chunk_size; 2413 + limits->max_hw_discard_sectors = snap->store->chunk_size; 2414 2414 2415 2415 up_read(&_origins_lock); 2416 2416 }
-1
drivers/md/dm-target.c
··· 249 249 250 250 static void io_err_io_hints(struct dm_target *ti, struct queue_limits *limits) 251 251 { 252 - limits->max_discard_sectors = UINT_MAX; 253 252 limits->max_hw_discard_sectors = UINT_MAX; 254 253 limits->discard_granularity = 512; 255 254 }
+2 -2
drivers/md/dm-thin.c
··· 4094 4094 if (pt->adjusted_pf.discard_enabled) { 4095 4095 disable_discard_passdown_if_not_supported(pt); 4096 4096 if (!pt->adjusted_pf.discard_passdown) 4097 - limits->max_discard_sectors = 0; 4097 + limits->max_hw_discard_sectors = 0; 4098 4098 /* 4099 4099 * The pool uses the same discard limits as the underlying data 4100 4100 * device. DM core has already set this up. ··· 4491 4491 4492 4492 if (pool->pf.discard_enabled) { 4493 4493 limits->discard_granularity = pool->sectors_per_block << SECTOR_SHIFT; 4494 - limits->max_discard_sectors = pool->sectors_per_block * BIO_PRISON_MAX_RANGE; 4494 + limits->max_hw_discard_sectors = pool->sectors_per_block * BIO_PRISON_MAX_RANGE; 4495 4495 } 4496 4496 } 4497 4497
-1
drivers/md/dm-zero.c
··· 61 61 62 62 static void zero_io_hints(struct dm_target *ti, struct queue_limits *limits) 63 63 { 64 - limits->max_discard_sectors = UINT_MAX; 65 64 limits->max_hw_discard_sectors = UINT_MAX; 66 65 limits->discard_granularity = 512; 67 66 }
-1
drivers/md/dm-zoned-target.c
··· 1001 1001 1002 1002 limits->discard_alignment = 0; 1003 1003 limits->discard_granularity = DMZ_BLOCK_SIZE; 1004 - limits->max_discard_sectors = chunk_sectors; 1005 1004 limits->max_hw_discard_sectors = chunk_sectors; 1006 1005 limits->max_write_zeroes_sectors = chunk_sectors; 1007 1006
+1 -1
drivers/md/dm.c
··· 1086 1086 struct queue_limits *limits = dm_get_queue_limits(md); 1087 1087 1088 1088 /* device doesn't really support DISCARD, disable it */ 1089 - limits->max_discard_sectors = 0; 1089 + limits->max_hw_discard_sectors = 0; 1090 1090 } 1091 1091 1092 1092 void disable_write_zeroes(struct mapped_device *md)