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-4.18/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 core to use more efficient bio_split() instead of
bio_clone_bioset(). Also fixes splitting bio that has integrity
payload.

- Three fixes related to properly validating DAX capabilities of a
stacked DM device that will advertise DAX support.

- Update DM writecache target to use 2-factor allocator arguments. Kees
says this is the last related change for 4.18.

- Fix DM zoned target to use GFP_NOIO to avoid triggering reclaim
during IO submission (caught by lockdep).

- Fix DM thinp to gracefully recover from running out of data space
while a previous async discard completes (whereby freeing space).

- Fix DM thinp's metadata transaction commit to avoid needless work.

* tag 'for-4.18/dm-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/device-mapper/linux-dm:
dm: prevent DAX mounts if not supported
dax: check for QUEUE_FLAG_DAX in bdev_dax_supported()
pmem: only set QUEUE_FLAG_DAX for fsdax mode
dm thin: handle running out of data space vs concurrent discard
dm raid: don't use 'const' in function return
dm zoned: avoid triggering reclaim from inside dmz_map()
dm writecache: use 2-factor allocator arguments
dm thin metadata: remove needless work from __commit_transaction
dm: use bio_split() when splitting out the already processed bio

Linus Torvalds ff23908b 2cd3ae21

+33 -27
+8
drivers/dax/super.c
··· 86 86 { 87 87 struct dax_device *dax_dev; 88 88 bool dax_enabled = false; 89 + struct request_queue *q; 89 90 pgoff_t pgoff; 90 91 int err, id; 91 92 void *kaddr; ··· 96 95 97 96 if (blocksize != PAGE_SIZE) { 98 97 pr_debug("%s: error: unsupported blocksize for dax\n", 98 + bdevname(bdev, buf)); 99 + return false; 100 + } 101 + 102 + q = bdev_get_queue(bdev); 103 + if (!q || !blk_queue_dax(q)) { 104 + pr_debug("%s: error: request queue doesn't support dax\n", 99 105 bdevname(bdev, buf)); 100 106 return false; 101 107 }
+1 -1
drivers/md/dm-raid.c
··· 588 588 } 589 589 590 590 /* Return md raid10 algorithm for @name */ 591 - static const int raid10_name_to_format(const char *name) 591 + static int raid10_name_to_format(const char *name) 592 592 { 593 593 if (!strcasecmp(name, "near")) 594 594 return ALGORITHM_RAID10_NEAR;
+4 -3
drivers/md/dm-table.c
··· 885 885 static int device_supports_dax(struct dm_target *ti, struct dm_dev *dev, 886 886 sector_t start, sector_t len, void *data) 887 887 { 888 - struct request_queue *q = bdev_get_queue(dev->bdev); 889 - 890 - return q && blk_queue_dax(q); 888 + return bdev_dax_supported(dev->bdev, PAGE_SIZE); 891 889 } 892 890 893 891 static bool dm_table_supports_dax(struct dm_table *t) ··· 1905 1907 1906 1908 if (dm_table_supports_dax(t)) 1907 1909 blk_queue_flag_set(QUEUE_FLAG_DAX, q); 1910 + else 1911 + blk_queue_flag_clear(QUEUE_FLAG_DAX, q); 1912 + 1908 1913 if (dm_table_supports_dax_write_cache(t)) 1909 1914 dax_write_cache(t->md->dax_dev, true); 1910 1915
-9
drivers/md/dm-thin-metadata.c
··· 776 776 static int __commit_transaction(struct dm_pool_metadata *pmd) 777 777 { 778 778 int r; 779 - size_t metadata_len, data_len; 780 779 struct thin_disk_superblock *disk_super; 781 780 struct dm_block *sblock; 782 781 ··· 793 794 return r; 794 795 795 796 r = dm_tm_pre_commit(pmd->tm); 796 - if (r < 0) 797 - return r; 798 - 799 - r = dm_sm_root_size(pmd->metadata_sm, &metadata_len); 800 - if (r < 0) 801 - return r; 802 - 803 - r = dm_sm_root_size(pmd->data_sm, &data_len); 804 797 if (r < 0) 805 798 return r; 806 799
+9 -2
drivers/md/dm-thin.c
··· 1386 1386 1387 1387 static void set_pool_mode(struct pool *pool, enum pool_mode new_mode); 1388 1388 1389 + static void requeue_bios(struct pool *pool); 1390 + 1389 1391 static void check_for_space(struct pool *pool) 1390 1392 { 1391 1393 int r; ··· 1400 1398 if (r) 1401 1399 return; 1402 1400 1403 - if (nr_free) 1401 + if (nr_free) { 1404 1402 set_pool_mode(pool, PM_WRITE); 1403 + requeue_bios(pool); 1404 + } 1405 1405 } 1406 1406 1407 1407 /* ··· 1480 1476 1481 1477 r = dm_pool_alloc_data_block(pool->pmd, result); 1482 1478 if (r) { 1483 - metadata_operation_failed(pool, "dm_pool_alloc_data_block", r); 1479 + if (r == -ENOSPC) 1480 + set_pool_mode(pool, PM_OUT_OF_DATA_SPACE); 1481 + else 1482 + metadata_operation_failed(pool, "dm_pool_alloc_data_block", r); 1484 1483 return r; 1485 1484 } 1486 1485
+5 -5
drivers/md/dm-writecache.c
··· 259 259 if (da != p) { 260 260 long i; 261 261 wc->memory_map = NULL; 262 - pages = kvmalloc(p * sizeof(struct page *), GFP_KERNEL); 262 + pages = kvmalloc_array(p, sizeof(struct page *), GFP_KERNEL); 263 263 if (!pages) { 264 264 r = -ENOMEM; 265 265 goto err2; ··· 859 859 860 860 if (wc->entries) 861 861 return 0; 862 - wc->entries = vmalloc(sizeof(struct wc_entry) * wc->n_blocks); 862 + wc->entries = vmalloc(array_size(sizeof(struct wc_entry), wc->n_blocks)); 863 863 if (!wc->entries) 864 864 return -ENOMEM; 865 865 for (b = 0; b < wc->n_blocks; b++) { ··· 1481 1481 wb->bio.bi_iter.bi_sector = read_original_sector(wc, e); 1482 1482 wb->page_offset = PAGE_SIZE; 1483 1483 if (max_pages <= WB_LIST_INLINE || 1484 - unlikely(!(wb->wc_list = kmalloc(max_pages * sizeof(struct wc_entry *), 1485 - GFP_NOIO | __GFP_NORETRY | 1486 - __GFP_NOMEMALLOC | __GFP_NOWARN)))) { 1484 + unlikely(!(wb->wc_list = kmalloc_array(max_pages, sizeof(struct wc_entry *), 1485 + GFP_NOIO | __GFP_NORETRY | 1486 + __GFP_NOMEMALLOC | __GFP_NOWARN)))) { 1487 1487 wb->wc_list = wb->wc_list_inline; 1488 1488 max_pages = WB_LIST_INLINE; 1489 1489 }
+1 -1
drivers/md/dm-zoned-target.c
··· 787 787 788 788 /* Chunk BIO work */ 789 789 mutex_init(&dmz->chunk_lock); 790 - INIT_RADIX_TREE(&dmz->chunk_rxtree, GFP_KERNEL); 790 + INIT_RADIX_TREE(&dmz->chunk_rxtree, GFP_NOIO); 791 791 dmz->chunk_wq = alloc_workqueue("dmz_cwq_%s", WQ_MEM_RECLAIM | WQ_UNBOUND, 792 792 0, dev->name); 793 793 if (!dmz->chunk_wq) {
+3 -5
drivers/md/dm.c
··· 1056 1056 if (len < 1) 1057 1057 goto out; 1058 1058 nr_pages = min(len, nr_pages); 1059 - if (ti->type->direct_access) 1060 - ret = ti->type->direct_access(ti, pgoff, nr_pages, kaddr, pfn); 1059 + ret = ti->type->direct_access(ti, pgoff, nr_pages, kaddr, pfn); 1061 1060 1062 1061 out: 1063 1062 dm_put_live_table(md, srcu_idx); ··· 1605 1606 * the usage of io->orig_bio in dm_remap_zone_report() 1606 1607 * won't be affected by this reassignment. 1607 1608 */ 1608 - struct bio *b = bio_clone_bioset(bio, GFP_NOIO, 1609 - &md->queue->bio_split); 1609 + struct bio *b = bio_split(bio, bio_sectors(bio) - ci.sector_count, 1610 + GFP_NOIO, &md->queue->bio_split); 1610 1611 ci.io->orig_bio = b; 1611 - bio_advance(bio, (bio_sectors(bio) - ci.sector_count) << 9); 1612 1612 bio_chain(b, bio); 1613 1613 ret = generic_make_request(bio); 1614 1614 break;
+2 -1
drivers/nvdimm/pmem.c
··· 414 414 blk_queue_logical_block_size(q, pmem_sector_size(ndns)); 415 415 blk_queue_max_hw_sectors(q, UINT_MAX); 416 416 blk_queue_flag_set(QUEUE_FLAG_NONROT, q); 417 - blk_queue_flag_set(QUEUE_FLAG_DAX, q); 417 + if (pmem->pfn_flags & PFN_MAP) 418 + blk_queue_flag_set(QUEUE_FLAG_DAX, q); 418 419 q->queuedata = pmem; 419 420 420 421 disk = alloc_disk_node(0, nid);