Merge tag 'for-5.19/drivers-2022-06-02' of git://git.kernel.dk/linux-block

+2

block/genhd.c

··· 385 385 386 386 if (disk->flags & (GENHD_FL_NO_PART | GENHD_FL_HIDDEN)) 387 387 return -EINVAL; 388 + if (test_bit(GD_SUPPRESS_PART_SCAN, &disk->state)) 389 + return -EINVAL; 388 390 if (disk->open_partitions) 389 391 return -EBUSY; 390 392

+4 -4

drivers/block/loop.c

··· 1102 1102 lo->lo_flags |= LO_FLAGS_PARTSCAN; 1103 1103 partscan = lo->lo_flags & LO_FLAGS_PARTSCAN; 1104 1104 if (partscan) 1105 - lo->lo_disk->flags &= ~GENHD_FL_NO_PART; 1105 + clear_bit(GD_SUPPRESS_PART_SCAN, &lo->lo_disk->state); 1106 1106 1107 1107 loop_global_unlock(lo, is_loop); 1108 1108 if (partscan) ··· 1198 1198 */ 1199 1199 lo->lo_flags = 0; 1200 1200 if (!part_shift) 1201 - lo->lo_disk->flags |= GENHD_FL_NO_PART; 1201 + set_bit(GD_SUPPRESS_PART_SCAN, &lo->lo_disk->state); 1202 1202 mutex_lock(&lo->lo_mutex); 1203 1203 lo->lo_state = Lo_unbound; 1204 1204 mutex_unlock(&lo->lo_mutex); ··· 1308 1308 1309 1309 if (!err && (lo->lo_flags & LO_FLAGS_PARTSCAN) && 1310 1310 !(prev_lo_flags & LO_FLAGS_PARTSCAN)) { 1311 - lo->lo_disk->flags &= ~GENHD_FL_NO_PART; 1311 + clear_bit(GD_SUPPRESS_PART_SCAN, &lo->lo_disk->state); 1312 1312 partscan = true; 1313 1313 } 1314 1314 out_unlock: ··· 2011 2011 * userspace tools. Parameters like this in general should be avoided. 2012 2012 */ 2013 2013 if (!part_shift) 2014 - disk->flags |= GENHD_FL_NO_PART; 2014 + set_bit(GD_SUPPRESS_PART_SCAN, &disk->state); 2015 2015 mutex_init(&lo->lo_mutex); 2016 2016 lo->lo_number = i; 2017 2017 spin_lock_init(&lo->lo_lock);

+68 -46

drivers/block/nbd.c

··· 403 403 if (!mutex_trylock(&cmd->lock)) 404 404 return BLK_EH_RESET_TIMER; 405 405 406 - if (!__test_and_clear_bit(NBD_CMD_INFLIGHT, &cmd->flags)) { 406 + if (!test_bit(NBD_CMD_INFLIGHT, &cmd->flags)) { 407 407 mutex_unlock(&cmd->lock); 408 408 return BLK_EH_DONE; 409 409 } 410 410 411 411 if (!refcount_inc_not_zero(&nbd->config_refs)) { 412 412 cmd->status = BLK_STS_TIMEOUT; 413 + __clear_bit(NBD_CMD_INFLIGHT, &cmd->flags); 413 414 mutex_unlock(&cmd->lock); 414 415 goto done; 415 416 } ··· 479 478 dev_err_ratelimited(nbd_to_dev(nbd), "Connection timed out\n"); 480 479 set_bit(NBD_RT_TIMEDOUT, &config->runtime_flags); 481 480 cmd->status = BLK_STS_IOERR; 481 + __clear_bit(NBD_CMD_INFLIGHT, &cmd->flags); 482 482 mutex_unlock(&cmd->lock); 483 483 sock_shutdown(nbd); 484 484 nbd_config_put(nbd); ··· 747 745 cmd = blk_mq_rq_to_pdu(req); 748 746 749 747 mutex_lock(&cmd->lock); 750 - if (!__test_and_clear_bit(NBD_CMD_INFLIGHT, &cmd->flags)) { 748 + if (!test_bit(NBD_CMD_INFLIGHT, &cmd->flags)) { 751 749 dev_err(disk_to_dev(nbd->disk), "Suspicious reply %d (status %u flags %lu)", 752 750 tag, cmd->status, cmd->flags); 753 751 ret = -ENOENT; ··· 856 854 } 857 855 858 856 rq = blk_mq_rq_from_pdu(cmd); 859 - if (likely(!blk_should_fake_timeout(rq->q))) 860 - blk_mq_complete_request(rq); 857 + if (likely(!blk_should_fake_timeout(rq->q))) { 858 + bool complete; 859 + 860 + mutex_lock(&cmd->lock); 861 + complete = __test_and_clear_bit(NBD_CMD_INFLIGHT, 862 + &cmd->flags); 863 + mutex_unlock(&cmd->lock); 864 + if (complete) 865 + blk_mq_complete_request(rq); 866 + } 861 867 percpu_ref_put(&q->q_usage_counter); 862 868 } 863 869 ··· 1429 1419 static void nbd_clear_sock_ioctl(struct nbd_device *nbd, 1430 1420 struct block_device *bdev) 1431 1421 { 1432 - sock_shutdown(nbd); 1422 + nbd_clear_sock(nbd); 1433 1423 __invalidate_device(bdev, true); 1434 1424 nbd_bdev_reset(nbd); 1435 1425 if (test_and_clear_bit(NBD_RT_HAS_CONFIG_REF, ··· 1528 1518 { 1529 1519 struct nbd_config *config; 1530 1520 1521 + if (!try_module_get(THIS_MODULE)) 1522 + return ERR_PTR(-ENODEV); 1523 + 1531 1524 config = kzalloc(sizeof(struct nbd_config), GFP_NOFS); 1532 - if (!config) 1533 - return NULL; 1525 + if (!config) { 1526 + module_put(THIS_MODULE); 1527 + return ERR_PTR(-ENOMEM); 1528 + } 1529 + 1534 1530 atomic_set(&config->recv_threads, 0); 1535 1531 init_waitqueue_head(&config->recv_wq); 1536 1532 init_waitqueue_head(&config->conn_wait); 1537 1533 config->blksize_bits = NBD_DEF_BLKSIZE_BITS; 1538 1534 atomic_set(&config->live_connections, 0); 1539 - try_module_get(THIS_MODULE); 1540 1535 return config; 1541 1536 } 1542 1537 ··· 1568 1553 mutex_unlock(&nbd->config_lock); 1569 1554 goto out; 1570 1555 } 1571 - config = nbd->config = nbd_alloc_config(); 1572 - if (!config) { 1573 - ret = -ENOMEM; 1556 + config = nbd_alloc_config(); 1557 + if (IS_ERR(config)) { 1558 + ret = PTR_ERR(config); 1574 1559 mutex_unlock(&nbd->config_lock); 1575 1560 goto out; 1576 1561 } 1562 + nbd->config = config; 1577 1563 refcount_set(&nbd->config_refs, 1); 1578 1564 refcount_inc(&nbd->refs); 1579 1565 mutex_unlock(&nbd->config_lock); ··· 1814 1798 refcount_set(&nbd->refs, 0); 1815 1799 INIT_LIST_HEAD(&nbd->list); 1816 1800 disk->major = NBD_MAJOR; 1817 - 1818 - /* Too big first_minor can cause duplicate creation of 1819 - * sysfs files/links, since index << part_shift might overflow, or 1820 - * MKDEV() expect that the max bits of first_minor is 20. 1821 - */ 1822 1801 disk->first_minor = index << part_shift; 1823 - if (disk->first_minor < index || disk->first_minor > MINORMASK) { 1824 - err = -EINVAL; 1825 - goto out_free_work; 1826 - } 1827 - 1828 1802 disk->minors = 1 << part_shift; 1829 1803 disk->fops = &nbd_fops; 1830 1804 disk->private_data = nbd; ··· 1919 1913 if (!netlink_capable(skb, CAP_SYS_ADMIN)) 1920 1914 return -EPERM; 1921 1915 1922 - if (info->attrs[NBD_ATTR_INDEX]) 1916 + if (info->attrs[NBD_ATTR_INDEX]) { 1923 1917 index = nla_get_u32(info->attrs[NBD_ATTR_INDEX]); 1918 + 1919 + /* 1920 + * Too big first_minor can cause duplicate creation of 1921 + * sysfs files/links, since index << part_shift might overflow, or 1922 + * MKDEV() expect that the max bits of first_minor is 20. 1923 + */ 1924 + if (index < 0 || index > MINORMASK >> part_shift) { 1925 + pr_err("illegal input index %d\n", index); 1926 + return -EINVAL; 1927 + } 1928 + } 1924 1929 if (!info->attrs[NBD_ATTR_SOCKETS]) { 1925 - printk(KERN_ERR "nbd: must specify at least one socket\n"); 1930 + pr_err("must specify at least one socket\n"); 1926 1931 return -EINVAL; 1927 1932 } 1928 1933 if (!info->attrs[NBD_ATTR_SIZE_BYTES]) { 1929 - printk(KERN_ERR "nbd: must specify a size in bytes for the device\n"); 1934 + pr_err("must specify a size in bytes for the device\n"); 1930 1935 return -EINVAL; 1931 1936 } 1932 1937 again: ··· 1973 1956 nbd_put(nbd); 1974 1957 if (index == -1) 1975 1958 goto again; 1976 - printk(KERN_ERR "nbd: nbd%d already in use\n", index); 1959 + pr_err("nbd%d already in use\n", index); 1977 1960 return -EBUSY; 1978 1961 } 1979 1962 if (WARN_ON(nbd->config)) { ··· 1981 1964 nbd_put(nbd); 1982 1965 return -EINVAL; 1983 1966 } 1984 - config = nbd->config = nbd_alloc_config(); 1985 - if (!nbd->config) { 1967 + config = nbd_alloc_config(); 1968 + if (IS_ERR(config)) { 1986 1969 mutex_unlock(&nbd->config_lock); 1987 1970 nbd_put(nbd); 1988 - printk(KERN_ERR "nbd: couldn't allocate config\n"); 1989 - return -ENOMEM; 1971 + pr_err("couldn't allocate config\n"); 1972 + return PTR_ERR(config); 1990 1973 } 1974 + nbd->config = config; 1991 1975 refcount_set(&nbd->config_refs, 1); 1992 1976 set_bit(NBD_RT_BOUND, &config->runtime_flags); 1993 1977 ··· 2041 2023 struct nlattr *socks[NBD_SOCK_MAX+1]; 2042 2024 2043 2025 if (nla_type(attr) != NBD_SOCK_ITEM) { 2044 - printk(KERN_ERR "nbd: socks must be embedded in a SOCK_ITEM attr\n"); 2026 + pr_err("socks must be embedded in a SOCK_ITEM attr\n"); 2045 2027 ret = -EINVAL; 2046 2028 goto out; 2047 2029 } ··· 2050 2032 nbd_sock_policy, 2051 2033 info->extack); 2052 2034 if (ret != 0) { 2053 - printk(KERN_ERR "nbd: error processing sock list\n"); 2035 + pr_err("error processing sock list\n"); 2054 2036 ret = -EINVAL; 2055 2037 goto out; 2056 2038 } ··· 2122 2104 return -EPERM; 2123 2105 2124 2106 if (!info->attrs[NBD_ATTR_INDEX]) { 2125 - printk(KERN_ERR "nbd: must specify an index to disconnect\n"); 2107 + pr_err("must specify an index to disconnect\n"); 2126 2108 return -EINVAL; 2127 2109 } 2128 2110 index = nla_get_u32(info->attrs[NBD_ATTR_INDEX]); ··· 2130 2112 nbd = idr_find(&nbd_index_idr, index); 2131 2113 if (!nbd) { 2132 2114 mutex_unlock(&nbd_index_mutex); 2133 - printk(KERN_ERR "nbd: couldn't find device at index %d\n", 2134 - index); 2115 + pr_err("couldn't find device at index %d\n", index); 2135 2116 return -EINVAL; 2136 2117 } 2137 2118 if (!refcount_inc_not_zero(&nbd->refs)) { 2138 2119 mutex_unlock(&nbd_index_mutex); 2139 - printk(KERN_ERR "nbd: device at index %d is going down\n", 2140 - index); 2120 + pr_err("device at index %d is going down\n", index); 2141 2121 return -EINVAL; 2142 2122 } 2143 2123 mutex_unlock(&nbd_index_mutex); ··· 2160 2144 return -EPERM; 2161 2145 2162 2146 if (!info->attrs[NBD_ATTR_INDEX]) { 2163 - printk(KERN_ERR "nbd: must specify a device to reconfigure\n"); 2147 + pr_err("must specify a device to reconfigure\n"); 2164 2148 return -EINVAL; 2165 2149 } 2166 2150 index = nla_get_u32(info->attrs[NBD_ATTR_INDEX]); ··· 2168 2152 nbd = idr_find(&nbd_index_idr, index); 2169 2153 if (!nbd) { 2170 2154 mutex_unlock(&nbd_index_mutex); 2171 - printk(KERN_ERR "nbd: couldn't find a device at index %d\n", 2172 - index); 2155 + pr_err("couldn't find a device at index %d\n", index); 2173 2156 return -EINVAL; 2174 2157 } 2175 2158 if (nbd->backend) { ··· 2189 2174 } 2190 2175 if (!refcount_inc_not_zero(&nbd->refs)) { 2191 2176 mutex_unlock(&nbd_index_mutex); 2192 - printk(KERN_ERR "nbd: device at index %d is going down\n", 2193 - index); 2177 + pr_err("device at index %d is going down\n", index); 2194 2178 return -EINVAL; 2195 2179 } 2196 2180 mutex_unlock(&nbd_index_mutex); ··· 2253 2239 struct nlattr *socks[NBD_SOCK_MAX+1]; 2254 2240 2255 2241 if (nla_type(attr) != NBD_SOCK_ITEM) { 2256 - printk(KERN_ERR "nbd: socks must be embedded in a SOCK_ITEM attr\n"); 2242 + pr_err("socks must be embedded in a SOCK_ITEM attr\n"); 2257 2243 ret = -EINVAL; 2258 2244 goto out; 2259 2245 } ··· 2262 2248 nbd_sock_policy, 2263 2249 info->extack); 2264 2250 if (ret != 0) { 2265 - printk(KERN_ERR "nbd: error processing sock list\n"); 2251 + pr_err("error processing sock list\n"); 2266 2252 ret = -EINVAL; 2267 2253 goto out; 2268 2254 } ··· 2479 2465 BUILD_BUG_ON(sizeof(struct nbd_request) != 28); 2480 2466 2481 2467 if (max_part < 0) { 2482 - printk(KERN_ERR "nbd: max_part must be >= 0\n"); 2468 + pr_err("max_part must be >= 0\n"); 2483 2469 return -EINVAL; 2484 2470 } 2485 2471 ··· 2542 2528 struct nbd_device *nbd; 2543 2529 LIST_HEAD(del_list); 2544 2530 2531 + /* 2532 + * Unregister netlink interface prior to waiting 2533 + * for the completion of netlink commands. 2534 + */ 2535 + genl_unregister_family(&nbd_genl_family); 2536 + 2545 2537 nbd_dbg_close(); 2546 2538 2547 2539 mutex_lock(&nbd_index_mutex); ··· 2557 2537 while (!list_empty(&del_list)) { 2558 2538 nbd = list_first_entry(&del_list, struct nbd_device, list); 2559 2539 list_del_init(&nbd->list); 2540 + if (refcount_read(&nbd->config_refs)) 2541 + pr_err("possibly leaking nbd_config (ref %d)\n", 2542 + refcount_read(&nbd->config_refs)); 2560 2543 if (refcount_read(&nbd->refs) != 1) 2561 - printk(KERN_ERR "nbd: possibly leaking a device\n"); 2544 + pr_err("possibly leaking a device\n"); 2562 2545 nbd_put(nbd); 2563 2546 } 2564 2547 ··· 2569 2546 destroy_workqueue(nbd_del_wq); 2570 2547 2571 2548 idr_destroy(&nbd_index_idr); 2572 - genl_unregister_family(&nbd_genl_family); 2573 2549 unregister_blkdev(NBD_MAJOR, "nbd"); 2574 2550 } 2575 2551

-6

drivers/block/null_blk/main.c

··· 77 77 NULL_IRQ_TIMER = 2, 78 78 }; 79 79 80 - enum { 81 - NULL_Q_BIO = 0, 82 - NULL_Q_RQ = 1, 83 - NULL_Q_MQ = 2, 84 - }; 85 - 86 80 static bool g_virt_boundary = false; 87 81 module_param_named(virt_boundary, g_virt_boundary, bool, 0444); 88 82 MODULE_PARM_DESC(virt_boundary, "Require a virtual boundary for the device. Default: False");

+7

drivers/block/null_blk/null_blk.h

··· 60 60 unsigned int capacity; 61 61 }; 62 62 63 + /* Queue modes */ 64 + enum { 65 + NULL_Q_BIO = 0, 66 + NULL_Q_RQ = 1, 67 + NULL_Q_MQ = 2, 68 + }; 69 + 63 70 struct nullb_device { 64 71 struct nullb *nullb; 65 72 struct config_item item;

+3 -3

drivers/block/null_blk/zoned.c

··· 398 398 */ 399 399 if (append) { 400 400 sector = zone->wp; 401 - if (cmd->bio) 402 - cmd->bio->bi_iter.bi_sector = sector; 403 - else 401 + if (dev->queue_mode == NULL_Q_MQ) 404 402 cmd->rq->__sector = sector; 403 + else 404 + cmd->bio->bi_iter.bi_sector = sector; 405 405 } else if (sector != zone->wp) { 406 406 ret = BLK_STS_IOERR; 407 407 goto unlock;

+7

drivers/md/bcache/bcache.h

··· 395 395 atomic_t io_errors; 396 396 unsigned int error_limit; 397 397 unsigned int offline_seconds; 398 + 399 + /* 400 + * Retry to update writeback_rate if contention happens for 401 + * down_read(dc->writeback_lock) in update_writeback_rate() 402 + */ 403 + #define BCH_WBRATE_UPDATE_MAX_SKIPS 15 404 + unsigned int rate_update_retry; 398 405 }; 399 406 400 407 enum alloc_reserve {

+27 -32

drivers/md/bcache/btree.c

··· 2006 2006 int i; 2007 2007 struct bkey *k = NULL; 2008 2008 struct btree_iter iter; 2009 - struct btree_check_state *check_state; 2010 - char name[32]; 2009 + struct btree_check_state check_state; 2011 2010 2012 2011 /* check and mark root node keys */ 2013 2012 for_each_key_filter(&c->root->keys, k, &iter, bch_ptr_invalid) ··· 2017 2018 if (c->root->level == 0) 2018 2019 return 0; 2019 2020 2020 - check_state = kzalloc(sizeof(struct btree_check_state), GFP_KERNEL); 2021 - if (!check_state) 2022 - return -ENOMEM; 2021 + memset(&check_state, 0, sizeof(struct btree_check_state)); 2022 + check_state.c = c; 2023 + check_state.total_threads = bch_btree_chkthread_nr(); 2024 + check_state.key_idx = 0; 2025 + spin_lock_init(&check_state.idx_lock); 2026 + atomic_set(&check_state.started, 0); 2027 + atomic_set(&check_state.enough, 0); 2028 + init_waitqueue_head(&check_state.wait); 2023 2029 2024 - check_state->c = c; 2025 - check_state->total_threads = bch_btree_chkthread_nr(); 2026 - check_state->key_idx = 0; 2027 - spin_lock_init(&check_state->idx_lock); 2028 - atomic_set(&check_state->started, 0); 2029 - atomic_set(&check_state->enough, 0); 2030 - init_waitqueue_head(&check_state->wait); 2031 - 2030 + rw_lock(0, c->root, c->root->level); 2032 2031 /* 2033 2032 * Run multiple threads to check btree nodes in parallel, 2034 - * if check_state->enough is non-zero, it means current 2033 + * if check_state.enough is non-zero, it means current 2035 2034 * running check threads are enough, unncessary to create 2036 2035 * more. 2037 2036 */ 2038 - for (i = 0; i < check_state->total_threads; i++) { 2039 - /* fetch latest check_state->enough earlier */ 2037 + for (i = 0; i < check_state.total_threads; i++) { 2038 + /* fetch latest check_state.enough earlier */ 2040 2039 smp_mb__before_atomic(); 2041 - if (atomic_read(&check_state->enough)) 2040 + if (atomic_read(&check_state.enough)) 2042 2041 break; 2043 2042 2044 - check_state->infos[i].result = 0; 2045 - check_state->infos[i].state = check_state; 2046 - snprintf(name, sizeof(name), "bch_btrchk[%u]", i); 2047 - atomic_inc(&check_state->started); 2043 + check_state.infos[i].result = 0; 2044 + check_state.infos[i].state = &check_state; 2048 2045 2049 - check_state->infos[i].thread = 2046 + check_state.infos[i].thread = 2050 2047 kthread_run(bch_btree_check_thread, 2051 - &check_state->infos[i], 2052 - name); 2053 - if (IS_ERR(check_state->infos[i].thread)) { 2048 + &check_state.infos[i], 2049 + "bch_btrchk[%d]", i); 2050 + if (IS_ERR(check_state.infos[i].thread)) { 2054 2051 pr_err("fails to run thread bch_btrchk[%d]\n", i); 2055 2052 for (--i; i >= 0; i--) 2056 - kthread_stop(check_state->infos[i].thread); 2053 + kthread_stop(check_state.infos[i].thread); 2057 2054 ret = -ENOMEM; 2058 2055 goto out; 2059 2056 } 2057 + atomic_inc(&check_state.started); 2060 2058 } 2061 2059 2062 2060 /* 2063 2061 * Must wait for all threads to stop. 2064 2062 */ 2065 - wait_event_interruptible(check_state->wait, 2066 - atomic_read(&check_state->started) == 0); 2063 + wait_event(check_state.wait, atomic_read(&check_state.started) == 0); 2067 2064 2068 - for (i = 0; i < check_state->total_threads; i++) { 2069 - if (check_state->infos[i].result) { 2070 - ret = check_state->infos[i].result; 2065 + for (i = 0; i < check_state.total_threads; i++) { 2066 + if (check_state.infos[i].result) { 2067 + ret = check_state.infos[i].result; 2071 2068 goto out; 2072 2069 } 2073 2070 } 2074 2071 2075 2072 out: 2076 - kfree(check_state); 2073 + rw_unlock(0, c->root); 2077 2074 return ret; 2078 2075 } 2079 2076

+1 -1

drivers/md/bcache/btree.h

··· 226 226 int result; 227 227 }; 228 228 229 - #define BCH_BTR_CHKTHREAD_MAX 64 229 + #define BCH_BTR_CHKTHREAD_MAX 12 230 230 struct btree_check_state { 231 231 struct cache_set *c; 232 232 int total_threads;

+26 -5

drivers/md/bcache/journal.c

··· 405 405 return ret; 406 406 } 407 407 408 + void bch_journal_space_reserve(struct journal *j) 409 + { 410 + j->do_reserve = true; 411 + } 412 + 408 413 /* Journalling */ 409 414 410 415 static void btree_flush_write(struct cache_set *c) ··· 626 621 } 627 622 } 628 623 624 + static unsigned int free_journal_buckets(struct cache_set *c) 625 + { 626 + struct journal *j = &c->journal; 627 + struct cache *ca = c->cache; 628 + struct journal_device *ja = &c->cache->journal; 629 + unsigned int n; 630 + 631 + /* In case njournal_buckets is not power of 2 */ 632 + if (ja->cur_idx >= ja->discard_idx) 633 + n = ca->sb.njournal_buckets + ja->discard_idx - ja->cur_idx; 634 + else 635 + n = ja->discard_idx - ja->cur_idx; 636 + 637 + if (n > (1 + j->do_reserve)) 638 + return n - (1 + j->do_reserve); 639 + 640 + return 0; 641 + } 642 + 629 643 static void journal_reclaim(struct cache_set *c) 630 644 { 631 645 struct bkey *k = &c->journal.key; 632 646 struct cache *ca = c->cache; 633 647 uint64_t last_seq; 634 - unsigned int next; 635 648 struct journal_device *ja = &ca->journal; 636 649 atomic_t p __maybe_unused; 637 650 ··· 672 649 if (c->journal.blocks_free) 673 650 goto out; 674 651 675 - next = (ja->cur_idx + 1) % ca->sb.njournal_buckets; 676 - /* No space available on this device */ 677 - if (next == ja->discard_idx) 652 + if (!free_journal_buckets(c)) 678 653 goto out; 679 654 680 - ja->cur_idx = next; 655 + ja->cur_idx = (ja->cur_idx + 1) % ca->sb.njournal_buckets; 681 656 k->ptr[0] = MAKE_PTR(0, 682 657 bucket_to_sector(c, ca->sb.d[ja->cur_idx]), 683 658 ca->sb.nr_this_dev);

+2

drivers/md/bcache/journal.h

··· 105 105 spinlock_t lock; 106 106 spinlock_t flush_write_lock; 107 107 bool btree_flushing; 108 + bool do_reserve; 108 109 /* used when waiting because the journal was full */ 109 110 struct closure_waitlist wait; 110 111 struct closure io; ··· 183 182 184 183 void bch_journal_free(struct cache_set *c); 185 184 int bch_journal_alloc(struct cache_set *c); 185 + void bch_journal_space_reserve(struct journal *j); 186 186 187 187 #endif /* _BCACHE_JOURNAL_H */

+6

drivers/md/bcache/request.c

··· 1105 1105 * which would call closure_get(&dc->disk.cl) 1106 1106 */ 1107 1107 ddip = kzalloc(sizeof(struct detached_dev_io_private), GFP_NOIO); 1108 + if (!ddip) { 1109 + bio->bi_status = BLK_STS_RESOURCE; 1110 + bio->bi_end_io(bio); 1111 + return; 1112 + } 1113 + 1108 1114 ddip->d = d; 1109 1115 /* Count on the bcache device */ 1110 1116 ddip->orig_bdev = orig_bdev;

+1

drivers/md/bcache/super.c

··· 2127 2127 2128 2128 flash_devs_run(c); 2129 2129 2130 + bch_journal_space_reserve(&c->journal); 2130 2131 set_bit(CACHE_SET_RUNNING, &c->flags); 2131 2132 return 0; 2132 2133 err:

+58 -73

drivers/md/bcache/writeback.c

··· 235 235 return; 236 236 } 237 237 238 - if (atomic_read(&dc->has_dirty) && dc->writeback_percent) { 239 - /* 240 - * If the whole cache set is idle, set_at_max_writeback_rate() 241 - * will set writeback rate to a max number. Then it is 242 - * unncessary to update writeback rate for an idle cache set 243 - * in maximum writeback rate number(s). 244 - */ 245 - if (!set_at_max_writeback_rate(c, dc)) { 246 - down_read(&dc->writeback_lock); 238 + /* 239 + * If the whole cache set is idle, set_at_max_writeback_rate() 240 + * will set writeback rate to a max number. Then it is 241 + * unncessary to update writeback rate for an idle cache set 242 + * in maximum writeback rate number(s). 243 + */ 244 + if (atomic_read(&dc->has_dirty) && dc->writeback_percent && 245 + !set_at_max_writeback_rate(c, dc)) { 246 + do { 247 + if (!down_read_trylock((&dc->writeback_lock))) { 248 + dc->rate_update_retry++; 249 + if (dc->rate_update_retry <= 250 + BCH_WBRATE_UPDATE_MAX_SKIPS) 251 + break; 252 + down_read(&dc->writeback_lock); 253 + dc->rate_update_retry = 0; 254 + } 247 255 __update_writeback_rate(dc); 248 256 update_gc_after_writeback(c); 249 257 up_read(&dc->writeback_lock); 250 - } 258 + } while (0); 251 259 } 252 260 253 261 ··· 813 805 814 806 /* Init */ 815 807 #define INIT_KEYS_EACH_TIME 500000 816 - #define INIT_KEYS_SLEEP_MS 100 817 808 818 809 struct sectors_dirty_init { 819 810 struct btree_op op; 820 811 unsigned int inode; 821 812 size_t count; 822 - struct bkey start; 823 813 }; 824 814 825 815 static int sectors_dirty_init_fn(struct btree_op *_op, struct btree *b, ··· 833 827 KEY_START(k), KEY_SIZE(k)); 834 828 835 829 op->count++; 836 - if (atomic_read(&b->c->search_inflight) && 837 - !(op->count % INIT_KEYS_EACH_TIME)) { 838 - bkey_copy_key(&op->start, k); 839 - return -EAGAIN; 840 - } 830 + if (!(op->count % INIT_KEYS_EACH_TIME)) 831 + cond_resched(); 841 832 842 833 return MAP_CONTINUE; 843 834 } ··· 849 846 bch_btree_op_init(&op.op, -1); 850 847 op.inode = d->id; 851 848 op.count = 0; 852 - op.start = KEY(op.inode, 0, 0); 853 849 854 - do { 855 - ret = bcache_btree(map_keys_recurse, 856 - k, 857 - c->root, 858 - &op.op, 859 - &op.start, 860 - sectors_dirty_init_fn, 861 - 0); 862 - if (ret == -EAGAIN) 863 - schedule_timeout_interruptible( 864 - msecs_to_jiffies(INIT_KEYS_SLEEP_MS)); 865 - else if (ret < 0) { 866 - pr_warn("sectors dirty init failed, ret=%d!\n", ret); 867 - break; 868 - } 869 - } while (ret == -EAGAIN); 850 + ret = bcache_btree(map_keys_recurse, 851 + k, 852 + c->root, 853 + &op.op, 854 + &KEY(op.inode, 0, 0), 855 + sectors_dirty_init_fn, 856 + 0); 857 + if (ret < 0) 858 + pr_warn("sectors dirty init failed, ret=%d!\n", ret); 870 859 871 860 return ret; 872 861 } ··· 902 907 goto out; 903 908 } 904 909 skip_nr--; 905 - cond_resched(); 906 910 } 907 911 908 912 if (p) { ··· 911 917 912 918 p = NULL; 913 919 prev_idx = cur_idx; 914 - cond_resched(); 915 920 } 916 921 917 922 out: ··· 941 948 struct btree_iter iter; 942 949 struct sectors_dirty_init op; 943 950 struct cache_set *c = d->c; 944 - struct bch_dirty_init_state *state; 945 - char name[32]; 951 + struct bch_dirty_init_state state; 946 952 947 953 /* Just count root keys if no leaf node */ 954 + rw_lock(0, c->root, c->root->level); 948 955 if (c->root->level == 0) { 949 956 bch_btree_op_init(&op.op, -1); 950 957 op.inode = d->id; 951 958 op.count = 0; 952 - op.start = KEY(op.inode, 0, 0); 953 959 954 960 for_each_key_filter(&c->root->keys, 955 961 k, &iter, bch_ptr_invalid) 956 962 sectors_dirty_init_fn(&op.op, c->root, k); 963 + 964 + rw_unlock(0, c->root); 957 965 return; 958 966 } 959 967 960 - state = kzalloc(sizeof(struct bch_dirty_init_state), GFP_KERNEL); 961 - if (!state) { 962 - pr_warn("sectors dirty init failed: cannot allocate memory\n"); 963 - return; 964 - } 968 + memset(&state, 0, sizeof(struct bch_dirty_init_state)); 969 + state.c = c; 970 + state.d = d; 971 + state.total_threads = bch_btre_dirty_init_thread_nr(); 972 + state.key_idx = 0; 973 + spin_lock_init(&state.idx_lock); 974 + atomic_set(&state.started, 0); 975 + atomic_set(&state.enough, 0); 976 + init_waitqueue_head(&state.wait); 965 977 966 - state->c = c; 967 - state->d = d; 968 - state->total_threads = bch_btre_dirty_init_thread_nr(); 969 - state->key_idx = 0; 970 - spin_lock_init(&state->idx_lock); 971 - atomic_set(&state->started, 0); 972 - atomic_set(&state->enough, 0); 973 - init_waitqueue_head(&state->wait); 974 - 975 - for (i = 0; i < state->total_threads; i++) { 976 - /* Fetch latest state->enough earlier */ 978 + for (i = 0; i < state.total_threads; i++) { 979 + /* Fetch latest state.enough earlier */ 977 980 smp_mb__before_atomic(); 978 - if (atomic_read(&state->enough)) 981 + if (atomic_read(&state.enough)) 979 982 break; 980 983 981 - state->infos[i].state = state; 982 - atomic_inc(&state->started); 983 - snprintf(name, sizeof(name), "bch_dirty_init[%d]", i); 984 - 985 - state->infos[i].thread = 986 - kthread_run(bch_dirty_init_thread, 987 - &state->infos[i], 988 - name); 989 - if (IS_ERR(state->infos[i].thread)) { 984 + state.infos[i].state = &state; 985 + state.infos[i].thread = 986 + kthread_run(bch_dirty_init_thread, &state.infos[i], 987 + "bch_dirtcnt[%d]", i); 988 + if (IS_ERR(state.infos[i].thread)) { 990 989 pr_err("fails to run thread bch_dirty_init[%d]\n", i); 991 990 for (--i; i >= 0; i--) 992 - kthread_stop(state->infos[i].thread); 991 + kthread_stop(state.infos[i].thread); 993 992 goto out; 994 993 } 994 + atomic_inc(&state.started); 995 995 } 996 996 997 - /* 998 - * Must wait for all threads to stop. 999 - */ 1000 - wait_event_interruptible(state->wait, 1001 - atomic_read(&state->started) == 0); 1002 - 1003 997 out: 1004 - kfree(state); 998 + /* Must wait for all threads to stop. */ 999 + wait_event(state.wait, atomic_read(&state.started) == 0); 1000 + rw_unlock(0, c->root); 1005 1001 } 1006 1002 1007 1003 void bch_cached_dev_writeback_init(struct cached_dev *dc) ··· 1013 1031 dc->writeback_rate_fp_term_mid = 10; 1014 1032 dc->writeback_rate_fp_term_high = 1000; 1015 1033 dc->writeback_rate_i_term_inverse = 10000; 1034 + 1035 + /* For dc->writeback_lock contention in update_writeback_rate() */ 1036 + dc->rate_update_retry = 0; 1016 1037 1017 1038 WARN_ON(test_and_clear_bit(BCACHE_DEV_WB_RUNNING, &dc->disk.flags)); 1018 1039 INIT_DELAYED_WORK(&dc->writeback_rate_update, update_writeback_rate);

+1 -1

drivers/md/bcache/writeback.h

··· 20 20 #define BCH_WRITEBACK_FRAGMENT_THRESHOLD_MID 57 21 21 #define BCH_WRITEBACK_FRAGMENT_THRESHOLD_HIGH 64 22 22 23 - #define BCH_DIRTY_INIT_THRD_MAX 64 23 + #define BCH_DIRTY_INIT_THRD_MAX 12 24 24 /* 25 25 * 14 (16384ths) is chosen here as something that each backing device 26 26 * should be a reasonable fraction of the share, and not to blow up

+1 -1

drivers/md/dm-raid.c

··· 3725 3725 if (!strcasecmp(argv[0], "idle") || !strcasecmp(argv[0], "frozen")) { 3726 3726 if (mddev->sync_thread) { 3727 3727 set_bit(MD_RECOVERY_INTR, &mddev->recovery); 3728 - md_reap_sync_thread(mddev); 3728 + md_reap_sync_thread(mddev, false); 3729 3729 } 3730 3730 } else if (decipher_sync_action(mddev, mddev->recovery) != st_idle) 3731 3731 return -EBUSY;

+2 -3

drivers/md/md-linear.c

··· 206 206 207 207 static bool linear_make_request(struct mddev *mddev, struct bio *bio) 208 208 { 209 - char b[BDEVNAME_SIZE]; 210 209 struct dev_info *tmp_dev; 211 210 sector_t start_sector, end_sector, data_offset; 212 211 sector_t bio_sector = bio->bi_iter.bi_sector; ··· 255 256 return true; 256 257 257 258 out_of_bounds: 258 - pr_err("md/linear:%s: make_request: Sector %llu out of bounds on dev %s: %llu sectors, offset %llu\n", 259 + pr_err("md/linear:%s: make_request: Sector %llu out of bounds on dev %pg: %llu sectors, offset %llu\n", 259 260 mdname(mddev), 260 261 (unsigned long long)bio->bi_iter.bi_sector, 261 - bdevname(tmp_dev->rdev->bdev, b), 262 + tmp_dev->rdev->bdev, 262 263 (unsigned long long)tmp_dev->rdev->sectors, 263 264 (unsigned long long)start_sector); 264 265 bio_io_error(bio);

+6 -9

drivers/md/md-multipath.c

··· 87 87 /* 88 88 * oops, IO error: 89 89 */ 90 - char b[BDEVNAME_SIZE]; 91 90 md_error (mp_bh->mddev, rdev); 92 - pr_info("multipath: %s: rescheduling sector %llu\n", 93 - bdevname(rdev->bdev,b), 91 + pr_info("multipath: %pg: rescheduling sector %llu\n", 92 + rdev->bdev, 94 93 (unsigned long long)bio->bi_iter.bi_sector); 95 94 multipath_reschedule_retry(mp_bh); 96 95 } else ··· 153 154 static void multipath_error (struct mddev *mddev, struct md_rdev *rdev) 154 155 { 155 156 struct mpconf *conf = mddev->private; 156 - char b[BDEVNAME_SIZE]; 157 157 158 158 if (conf->raid_disks - mddev->degraded <= 1) { 159 159 /* ··· 175 177 } 176 178 set_bit(Faulty, &rdev->flags); 177 179 set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags); 178 - pr_err("multipath: IO failure on %s, disabling IO path.\n" 180 + pr_err("multipath: IO failure on %pg, disabling IO path.\n" 179 181 "multipath: Operation continuing on %d IO paths.\n", 180 - bdevname(rdev->bdev, b), 182 + rdev->bdev, 181 183 conf->raid_disks - mddev->degraded); 182 184 } 183 185 ··· 195 197 conf->raid_disks); 196 198 197 199 for (i = 0; i < conf->raid_disks; i++) { 198 - char b[BDEVNAME_SIZE]; 199 200 tmp = conf->multipaths + i; 200 201 if (tmp->rdev) 201 - pr_debug(" disk%d, o:%d, dev:%s\n", 202 + pr_debug(" disk%d, o:%d, dev:%pg\n", 202 203 i,!test_bit(Faulty, &tmp->rdev->flags), 203 - bdevname(tmp->rdev->bdev,b)); 204 + tmp->rdev->bdev); 204 205 } 205 206 } 206 207

+84 -101

drivers/md/md.c

··· 1021 1021 1022 1022 static int read_disk_sb(struct md_rdev *rdev, int size) 1023 1023 { 1024 - char b[BDEVNAME_SIZE]; 1025 - 1026 1024 if (rdev->sb_loaded) 1027 1025 return 0; 1028 1026 ··· 1030 1032 return 0; 1031 1033 1032 1034 fail: 1033 - pr_err("md: disabled device %s, could not read superblock.\n", 1034 - bdevname(rdev->bdev,b)); 1035 + pr_err("md: disabled device %pg, could not read superblock.\n", 1036 + rdev->bdev); 1035 1037 return -EINVAL; 1036 1038 } 1037 1039 ··· 1177 1179 */ 1178 1180 static int super_90_load(struct md_rdev *rdev, struct md_rdev *refdev, int minor_version) 1179 1181 { 1180 - char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE]; 1181 1182 mdp_super_t *sb; 1182 1183 int ret; 1183 1184 bool spare_disk = true; ··· 1195 1198 1196 1199 ret = -EINVAL; 1197 1200 1198 - bdevname(rdev->bdev, b); 1199 1201 sb = page_address(rdev->sb_page); 1200 1202 1201 1203 if (sb->md_magic != MD_SB_MAGIC) { 1202 - pr_warn("md: invalid raid superblock magic on %s\n", b); 1204 + pr_warn("md: invalid raid superblock magic on %pg\n", 1205 + rdev->bdev); 1203 1206 goto abort; 1204 1207 } 1205 1208 1206 1209 if (sb->major_version != 0 || 1207 1210 sb->minor_version < 90 || 1208 1211 sb->minor_version > 91) { 1209 - pr_warn("Bad version number %d.%d on %s\n", 1210 - sb->major_version, sb->minor_version, b); 1212 + pr_warn("Bad version number %d.%d on %pg\n", 1213 + sb->major_version, sb->minor_version, rdev->bdev); 1211 1214 goto abort; 1212 1215 } 1213 1216 ··· 1215 1218 goto abort; 1216 1219 1217 1220 if (md_csum_fold(calc_sb_csum(sb)) != md_csum_fold(sb->sb_csum)) { 1218 - pr_warn("md: invalid superblock checksum on %s\n", b); 1221 + pr_warn("md: invalid superblock checksum on %pg\n", rdev->bdev); 1219 1222 goto abort; 1220 1223 } 1221 1224 ··· 1247 1250 __u64 ev1, ev2; 1248 1251 mdp_super_t *refsb = page_address(refdev->sb_page); 1249 1252 if (!md_uuid_equal(refsb, sb)) { 1250 - pr_warn("md: %s has different UUID to %s\n", 1251 - b, bdevname(refdev->bdev,b2)); 1253 + pr_warn("md: %pg has different UUID to %pg\n", 1254 + rdev->bdev, refdev->bdev); 1252 1255 goto abort; 1253 1256 } 1254 1257 if (!md_sb_equal(refsb, sb)) { 1255 - pr_warn("md: %s has same UUID but different superblock to %s\n", 1256 - b, bdevname(refdev->bdev, b2)); 1258 + pr_warn("md: %pg has same UUID but different superblock to %pg\n", 1259 + rdev->bdev, refdev->bdev); 1257 1260 goto abort; 1258 1261 } 1259 1262 ev1 = md_event(sb); ··· 1617 1620 int ret; 1618 1621 sector_t sb_start; 1619 1622 sector_t sectors; 1620 - char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE]; 1621 1623 int bmask; 1622 1624 bool spare_disk = true; 1623 1625 ··· 1660 1664 return -EINVAL; 1661 1665 1662 1666 if (calc_sb_1_csum(sb) != sb->sb_csum) { 1663 - pr_warn("md: invalid superblock checksum on %s\n", 1664 - bdevname(rdev->bdev,b)); 1667 + pr_warn("md: invalid superblock checksum on %pg\n", 1668 + rdev->bdev); 1665 1669 return -EINVAL; 1666 1670 } 1667 1671 if (le64_to_cpu(sb->data_size) < 10) { 1668 - pr_warn("md: data_size too small on %s\n", 1669 - bdevname(rdev->bdev,b)); 1672 + pr_warn("md: data_size too small on %pg\n", 1673 + rdev->bdev); 1670 1674 return -EINVAL; 1671 1675 } 1672 1676 if (sb->pad0 || ··· 1772 1776 sb->level != refsb->level || 1773 1777 sb->layout != refsb->layout || 1774 1778 sb->chunksize != refsb->chunksize) { 1775 - pr_warn("md: %s has strangely different superblock to %s\n", 1776 - bdevname(rdev->bdev,b), 1777 - bdevname(refdev->bdev,b2)); 1779 + pr_warn("md: %pg has strangely different superblock to %pg\n", 1780 + rdev->bdev, 1781 + refdev->bdev); 1778 1782 return -EINVAL; 1779 1783 } 1780 1784 ev1 = le64_to_cpu(sb->events); ··· 2361 2365 int md_integrity_add_rdev(struct md_rdev *rdev, struct mddev *mddev) 2362 2366 { 2363 2367 struct blk_integrity *bi_mddev; 2364 - char name[BDEVNAME_SIZE]; 2365 2368 2366 2369 if (!mddev->gendisk) 2367 2370 return 0; ··· 2371 2376 return 0; 2372 2377 2373 2378 if (blk_integrity_compare(mddev->gendisk, rdev->bdev->bd_disk) != 0) { 2374 - pr_err("%s: incompatible integrity profile for %s\n", 2375 - mdname(mddev), bdevname(rdev->bdev, name)); 2379 + pr_err("%s: incompatible integrity profile for %pg\n", 2380 + mdname(mddev), rdev->bdev); 2376 2381 return -ENXIO; 2377 2382 } 2378 2383 ··· 2481 2486 2482 2487 static void unbind_rdev_from_array(struct md_rdev *rdev) 2483 2488 { 2484 - char b[BDEVNAME_SIZE]; 2485 - 2486 2489 bd_unlink_disk_holder(rdev->bdev, rdev->mddev->gendisk); 2487 2490 list_del_rcu(&rdev->same_set); 2488 - pr_debug("md: unbind<%s>\n", bdevname(rdev->bdev,b)); 2491 + pr_debug("md: unbind<%pg>\n", rdev->bdev); 2489 2492 mddev_destroy_serial_pool(rdev->mddev, rdev, false); 2490 2493 rdev->mddev = NULL; 2491 2494 sysfs_remove_link(&rdev->kobj, "block"); ··· 2536 2543 2537 2544 static void export_rdev(struct md_rdev *rdev) 2538 2545 { 2539 - char b[BDEVNAME_SIZE]; 2540 - 2541 - pr_debug("md: export_rdev(%s)\n", bdevname(rdev->bdev,b)); 2546 + pr_debug("md: export_rdev(%pg)\n", rdev->bdev); 2542 2547 md_rdev_clear(rdev); 2543 2548 #ifndef MODULE 2544 2549 if (test_bit(AutoDetected, &rdev->flags)) ··· 2794 2803 rewrite: 2795 2804 md_bitmap_update_sb(mddev->bitmap); 2796 2805 rdev_for_each(rdev, mddev) { 2797 - char b[BDEVNAME_SIZE]; 2798 - 2799 2806 if (rdev->sb_loaded != 1) 2800 2807 continue; /* no noise on spare devices */ 2801 2808 ··· 2801 2812 md_super_write(mddev,rdev, 2802 2813 rdev->sb_start, rdev->sb_size, 2803 2814 rdev->sb_page); 2804 - pr_debug("md: (write) %s's sb offset: %llu\n", 2805 - bdevname(rdev->bdev, b), 2815 + pr_debug("md: (write) %pg's sb offset: %llu\n", 2816 + rdev->bdev, 2806 2817 (unsigned long long)rdev->sb_start); 2807 2818 rdev->sb_events = mddev->events; 2808 2819 if (rdev->badblocks.size) { ··· 2814 2825 } 2815 2826 2816 2827 } else 2817 - pr_debug("md: %s (skipping faulty)\n", 2818 - bdevname(rdev->bdev, b)); 2828 + pr_debug("md: %pg (skipping faulty)\n", 2829 + rdev->bdev); 2819 2830 2820 2831 if (mddev->level == LEVEL_MULTIPATH) 2821 2832 /* only need to write one superblock... */ ··· 3690 3701 */ 3691 3702 static struct md_rdev *md_import_device(dev_t newdev, int super_format, int super_minor) 3692 3703 { 3693 - char b[BDEVNAME_SIZE]; 3694 3704 int err; 3695 3705 struct md_rdev *rdev; 3696 3706 sector_t size; ··· 3713 3725 3714 3726 size = bdev_nr_bytes(rdev->bdev) >> BLOCK_SIZE_BITS; 3715 3727 if (!size) { 3716 - pr_warn("md: %s has zero or unknown size, marking faulty!\n", 3717 - bdevname(rdev->bdev,b)); 3728 + pr_warn("md: %pg has zero or unknown size, marking faulty!\n", 3729 + rdev->bdev); 3718 3730 err = -EINVAL; 3719 3731 goto abort_free; 3720 3732 } ··· 3723 3735 err = super_types[super_format]. 3724 3736 load_super(rdev, NULL, super_minor); 3725 3737 if (err == -EINVAL) { 3726 - pr_warn("md: %s does not have a valid v%d.%d superblock, not importing!\n", 3727 - bdevname(rdev->bdev,b), 3738 + pr_warn("md: %pg does not have a valid v%d.%d superblock, not importing!\n", 3739 + rdev->bdev, 3728 3740 super_format, super_minor); 3729 3741 goto abort_free; 3730 3742 } 3731 3743 if (err < 0) { 3732 - pr_warn("md: could not read %s's sb, not importing!\n", 3733 - bdevname(rdev->bdev,b)); 3744 + pr_warn("md: could not read %pg's sb, not importing!\n", 3745 + rdev->bdev); 3734 3746 goto abort_free; 3735 3747 } 3736 3748 } ··· 3753 3765 { 3754 3766 int i; 3755 3767 struct md_rdev *rdev, *freshest, *tmp; 3756 - char b[BDEVNAME_SIZE]; 3757 3768 3758 3769 freshest = NULL; 3759 3770 rdev_for_each_safe(rdev, tmp, mddev) ··· 3764 3777 case 0: 3765 3778 break; 3766 3779 default: 3767 - pr_warn("md: fatal superblock inconsistency in %s -- removing from array\n", 3768 - bdevname(rdev->bdev,b)); 3780 + pr_warn("md: fatal superblock inconsistency in %pg -- removing from array\n", 3781 + rdev->bdev); 3769 3782 md_kick_rdev_from_array(rdev); 3770 3783 } 3771 3784 ··· 3783 3796 if (mddev->max_disks && 3784 3797 (rdev->desc_nr >= mddev->max_disks || 3785 3798 i > mddev->max_disks)) { 3786 - pr_warn("md: %s: %s: only %d devices permitted\n", 3787 - mdname(mddev), bdevname(rdev->bdev, b), 3799 + pr_warn("md: %s: %pg: only %d devices permitted\n", 3800 + mdname(mddev), rdev->bdev, 3788 3801 mddev->max_disks); 3789 3802 md_kick_rdev_from_array(rdev); 3790 3803 continue; ··· 3792 3805 if (rdev != freshest) { 3793 3806 if (super_types[mddev->major_version]. 3794 3807 validate_super(mddev, rdev)) { 3795 - pr_warn("md: kicking non-fresh %s from array!\n", 3796 - bdevname(rdev->bdev,b)); 3808 + pr_warn("md: kicking non-fresh %pg from array!\n", 3809 + rdev->bdev); 3797 3810 md_kick_rdev_from_array(rdev); 3798 3811 continue; 3799 3812 } ··· 4831 4844 flush_workqueue(md_misc_wq); 4832 4845 if (mddev->sync_thread) { 4833 4846 set_bit(MD_RECOVERY_INTR, &mddev->recovery); 4834 - md_reap_sync_thread(mddev); 4847 + md_reap_sync_thread(mddev, true); 4835 4848 } 4836 4849 mddev_unlock(mddev); 4837 4850 } ··· 5585 5598 5586 5599 bioset_exit(&mddev->bio_set); 5587 5600 bioset_exit(&mddev->sync_set); 5588 - if (mddev->level != 1 && mddev->level != 10) 5589 - bioset_exit(&mddev->io_acct_set); 5590 5601 kfree(mddev); 5591 5602 } 5592 5603 ··· 5897 5912 /* Warn if this is a potentially silly 5898 5913 * configuration. 5899 5914 */ 5900 - char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE]; 5901 5915 struct md_rdev *rdev2; 5902 5916 int warned = 0; 5903 5917 ··· 5905 5921 if (rdev < rdev2 && 5906 5922 rdev->bdev->bd_disk == 5907 5923 rdev2->bdev->bd_disk) { 5908 - pr_warn("%s: WARNING: %s appears to be on the same physical disk as %s.\n", 5924 + pr_warn("%s: WARNING: %pg appears to be on the same physical disk as %pg.\n", 5909 5925 mdname(mddev), 5910 - bdevname(rdev->bdev,b), 5911 - bdevname(rdev2->bdev,b2)); 5926 + rdev->bdev, 5927 + rdev2->bdev); 5912 5928 warned = 1; 5913 5929 } 5914 5930 } ··· 6197 6213 flush_workqueue(md_misc_wq); 6198 6214 if (mddev->sync_thread) { 6199 6215 set_bit(MD_RECOVERY_INTR, &mddev->recovery); 6200 - md_reap_sync_thread(mddev); 6216 + md_reap_sync_thread(mddev, true); 6201 6217 } 6202 6218 6203 6219 del_timer_sync(&mddev->safemode_timer); ··· 6269 6285 __md_stop(mddev); 6270 6286 bioset_exit(&mddev->bio_set); 6271 6287 bioset_exit(&mddev->sync_set); 6272 - if (mddev->level != 1 && mddev->level != 10) 6273 - bioset_exit(&mddev->io_acct_set); 6274 6288 } 6275 6289 6276 6290 EXPORT_SYMBOL_GPL(md_stop); ··· 6434 6452 pr_info("md: running: "); 6435 6453 6436 6454 rdev_for_each(rdev, mddev) { 6437 - char b[BDEVNAME_SIZE]; 6438 - pr_cont("<%s>", bdevname(rdev->bdev,b)); 6455 + pr_cont("<%pg>", rdev->bdev); 6439 6456 } 6440 6457 pr_cont("\n"); 6441 6458 ··· 6461 6480 { 6462 6481 struct md_rdev *rdev0, *rdev, *tmp; 6463 6482 struct mddev *mddev; 6464 - char b[BDEVNAME_SIZE]; 6465 6483 6466 6484 pr_info("md: autorun ...\n"); 6467 6485 while (!list_empty(&pending_raid_disks)) { ··· 6470 6490 rdev0 = list_entry(pending_raid_disks.next, 6471 6491 struct md_rdev, same_set); 6472 6492 6473 - pr_debug("md: considering %s ...\n", bdevname(rdev0->bdev,b)); 6493 + pr_debug("md: considering %pg ...\n", rdev0->bdev); 6474 6494 INIT_LIST_HEAD(&candidates); 6475 6495 rdev_for_each_list(rdev, tmp, &pending_raid_disks) 6476 6496 if (super_90_load(rdev, rdev0, 0) >= 0) { 6477 - pr_debug("md: adding %s ...\n", 6478 - bdevname(rdev->bdev,b)); 6497 + pr_debug("md: adding %pg ...\n", 6498 + rdev->bdev); 6479 6499 list_move(&rdev->same_set, &candidates); 6480 6500 } 6481 6501 /* ··· 6492 6512 unit = MINOR(dev); 6493 6513 } 6494 6514 if (rdev0->preferred_minor != unit) { 6495 - pr_warn("md: unit number in %s is bad: %d\n", 6496 - bdevname(rdev0->bdev, b), rdev0->preferred_minor); 6515 + pr_warn("md: unit number in %pg is bad: %d\n", 6516 + rdev0->bdev, rdev0->preferred_minor); 6497 6517 break; 6498 6518 } 6499 6519 ··· 6506 6526 pr_warn("md: %s locked, cannot run\n", mdname(mddev)); 6507 6527 else if (mddev->raid_disks || mddev->major_version 6508 6528 || !list_empty(&mddev->disks)) { 6509 - pr_warn("md: %s already running, cannot run %s\n", 6510 - mdname(mddev), bdevname(rdev0->bdev,b)); 6529 + pr_warn("md: %s already running, cannot run %pg\n", 6530 + mdname(mddev), rdev0->bdev); 6511 6531 mddev_unlock(mddev); 6512 6532 } else { 6513 6533 pr_debug("md: created %s\n", mdname(mddev)); ··· 6681 6701 6682 6702 int md_add_new_disk(struct mddev *mddev, struct mdu_disk_info_s *info) 6683 6703 { 6684 - char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE]; 6685 6704 struct md_rdev *rdev; 6686 6705 dev_t dev = MKDEV(info->major,info->minor); 6687 6706 ··· 6710 6731 err = super_types[mddev->major_version] 6711 6732 .load_super(rdev, rdev0, mddev->minor_version); 6712 6733 if (err < 0) { 6713 - pr_warn("md: %s has different UUID to %s\n", 6714 - bdevname(rdev->bdev,b), 6715 - bdevname(rdev0->bdev,b2)); 6734 + pr_warn("md: %pg has different UUID to %pg\n", 6735 + rdev->bdev, 6736 + rdev0->bdev); 6716 6737 export_rdev(rdev); 6717 6738 return -EINVAL; 6718 6739 } ··· 6887 6908 6888 6909 static int hot_remove_disk(struct mddev *mddev, dev_t dev) 6889 6910 { 6890 - char b[BDEVNAME_SIZE]; 6891 6911 struct md_rdev *rdev; 6892 6912 6893 6913 if (!mddev->pers) ··· 6921 6943 6922 6944 return 0; 6923 6945 busy: 6924 - pr_debug("md: cannot remove active disk %s from %s ...\n", 6925 - bdevname(rdev->bdev,b), mdname(mddev)); 6946 + pr_debug("md: cannot remove active disk %pg from %s ...\n", 6947 + rdev->bdev, mdname(mddev)); 6926 6948 return -EBUSY; 6927 6949 } 6928 6950 6929 6951 static int hot_add_disk(struct mddev *mddev, dev_t dev) 6930 6952 { 6931 - char b[BDEVNAME_SIZE]; 6932 6953 int err; 6933 6954 struct md_rdev *rdev; 6934 6955 ··· 6960 6983 rdev->sectors = rdev->sb_start; 6961 6984 6962 6985 if (test_bit(Faulty, &rdev->flags)) { 6963 - pr_warn("md: can not hot-add faulty %s disk to %s!\n", 6964 - bdevname(rdev->bdev,b), mdname(mddev)); 6986 + pr_warn("md: can not hot-add faulty %pg disk to %s!\n", 6987 + rdev->bdev, mdname(mddev)); 6965 6988 err = -EINVAL; 6966 6989 goto abort_export; 6967 6990 } ··· 6988 7011 * disable on the whole MD. 6989 7012 */ 6990 7013 if (!blk_queue_nowait(bdev_get_queue(rdev->bdev))) { 6991 - pr_info("%s: Disabling nowait because %s does not support nowait\n", 6992 - mdname(mddev), bdevname(rdev->bdev, b)); 7014 + pr_info("%s: Disabling nowait because %pg does not support nowait\n", 7015 + mdname(mddev), rdev->bdev); 6993 7016 blk_queue_flag_clear(QUEUE_FLAG_NOWAIT, mddev->queue); 6994 7017 } 6995 7018 /* ··· 7940 7963 7941 7964 void md_unregister_thread(struct md_thread **threadp) 7942 7965 { 7943 - struct md_thread *thread = *threadp; 7944 - if (!thread) 7945 - return; 7946 - pr_debug("interrupting MD-thread pid %d\n", task_pid_nr(thread->tsk)); 7947 - /* Locking ensures that mddev_unlock does not wake_up a 7966 + struct md_thread *thread; 7967 + 7968 + /* 7969 + * Locking ensures that mddev_unlock does not wake_up a 7948 7970 * non-existent thread 7949 7971 */ 7950 7972 spin_lock(&pers_lock); 7973 + thread = *threadp; 7974 + if (!thread) { 7975 + spin_unlock(&pers_lock); 7976 + return; 7977 + } 7951 7978 *threadp = NULL; 7952 7979 spin_unlock(&pers_lock); 7953 7980 7981 + pr_debug("interrupting MD-thread pid %d\n", task_pid_nr(thread->tsk)); 7954 7982 kthread_stop(thread->tsk); 7955 7983 kfree(thread); 7956 7984 } ··· 7994 8012 seq_printf(seq, "unused devices: "); 7995 8013 7996 8014 list_for_each_entry(rdev, &pending_raid_disks, same_set) { 7997 - char b[BDEVNAME_SIZE]; 7998 8015 i++; 7999 - seq_printf(seq, "%s ", 8000 - bdevname(rdev->bdev,b)); 8016 + seq_printf(seq, "%pg ", rdev->bdev); 8001 8017 } 8002 8018 if (!i) 8003 8019 seq_printf(seq, "<none>"); ··· 8235 8255 sectors = 0; 8236 8256 rcu_read_lock(); 8237 8257 rdev_for_each_rcu(rdev, mddev) { 8238 - char b[BDEVNAME_SIZE]; 8239 - seq_printf(seq, " %s[%d]", 8240 - bdevname(rdev->bdev,b), rdev->desc_nr); 8258 + seq_printf(seq, " %pg[%d]", rdev->bdev, rdev->desc_nr); 8259 + 8241 8260 if (test_bit(WriteMostly, &rdev->flags)) 8242 8261 seq_printf(seq, "(W)"); 8243 8262 if (test_bit(Journal, &rdev->flags)) ··· 9303 9324 * ->spare_active and clear saved_raid_disk 9304 9325 */ 9305 9326 set_bit(MD_RECOVERY_INTR, &mddev->recovery); 9306 - md_reap_sync_thread(mddev); 9327 + md_reap_sync_thread(mddev, true); 9307 9328 clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery); 9308 9329 clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery); 9309 9330 clear_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags); ··· 9338 9359 goto unlock; 9339 9360 } 9340 9361 if (mddev->sync_thread) { 9341 - md_reap_sync_thread(mddev); 9362 + md_reap_sync_thread(mddev, true); 9342 9363 goto unlock; 9343 9364 } 9344 9365 /* Set RUNNING before clearing NEEDED to avoid ··· 9411 9432 } 9412 9433 EXPORT_SYMBOL(md_check_recovery); 9413 9434 9414 - void md_reap_sync_thread(struct mddev *mddev) 9435 + void md_reap_sync_thread(struct mddev *mddev, bool reconfig_mutex_held) 9415 9436 { 9416 9437 struct md_rdev *rdev; 9417 9438 sector_t old_dev_sectors = mddev->dev_sectors; 9418 9439 bool is_reshaped = false; 9419 9440 9441 + if (reconfig_mutex_held) 9442 + mddev_unlock(mddev); 9420 9443 /* resync has finished, collect result */ 9421 9444 md_unregister_thread(&mddev->sync_thread); 9445 + if (reconfig_mutex_held) 9446 + mddev_lock_nointr(mddev); 9422 9447 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery) && 9423 9448 !test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery) && 9424 9449 mddev->degraded != mddev->raid_disks) { ··· 9635 9652 struct mdp_superblock_1 *sb = page_address(rdev->sb_page); 9636 9653 struct md_rdev *rdev2, *tmp; 9637 9654 int role, ret; 9638 - char b[BDEVNAME_SIZE]; 9639 9655 9640 9656 /* 9641 9657 * If size is changed in another node then we need to ··· 9658 9676 9659 9677 if (test_bit(Candidate, &rdev2->flags)) { 9660 9678 if (role == MD_DISK_ROLE_FAULTY) { 9661 - pr_info("md: Removing Candidate device %s because add failed\n", bdevname(rdev2->bdev,b)); 9679 + pr_info("md: Removing Candidate device %pg because add failed\n", 9680 + rdev2->bdev); 9662 9681 md_kick_rdev_from_array(rdev2); 9663 9682 continue; 9664 9683 } ··· 9676 9693 MD_FEATURE_RESHAPE_ACTIVE)) { 9677 9694 rdev2->saved_raid_disk = role; 9678 9695 ret = remove_and_add_spares(mddev, rdev2); 9679 - pr_info("Activated spare: %s\n", 9680 - bdevname(rdev2->bdev,b)); 9696 + pr_info("Activated spare: %pg\n", 9697 + rdev2->bdev); 9681 9698 /* wakeup mddev->thread here, so array could 9682 9699 * perform resync with the new activated disk */ 9683 9700 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

+1 -1

drivers/md/md.h

··· 719 719 extern void md_unregister_thread(struct md_thread **threadp); 720 720 extern void md_wakeup_thread(struct md_thread *thread); 721 721 extern void md_check_recovery(struct mddev *mddev); 722 - extern void md_reap_sync_thread(struct mddev *mddev); 722 + extern void md_reap_sync_thread(struct mddev *mddev, bool reconfig_mutex_held); 723 723 extern int mddev_init_writes_pending(struct mddev *mddev); 724 724 extern bool md_write_start(struct mddev *mddev, struct bio *bi); 725 725 extern void md_write_inc(struct mddev *mddev, struct bio *bi);

+12 -17

drivers/md/raid0.c

··· 37 37 int j, k; 38 38 sector_t zone_size = 0; 39 39 sector_t zone_start = 0; 40 - char b[BDEVNAME_SIZE]; 41 40 struct r0conf *conf = mddev->private; 42 41 int raid_disks = conf->strip_zone[0].nb_dev; 43 42 pr_debug("md: RAID0 configuration for %s - %d zone%s\n", ··· 47 48 int len = 0; 48 49 49 50 for (k = 0; k < conf->strip_zone[j].nb_dev; k++) 50 - len += snprintf(line+len, 200-len, "%s%s", k?"/":"", 51 - bdevname(conf->devlist[j*raid_disks 52 - + k]->bdev, b)); 51 + len += snprintf(line+len, 200-len, "%s%pg", k?"/":"", 52 + conf->devlist[j * raid_disks + k]->bdev); 53 53 pr_debug("md: zone%d=[%s]\n", j, line); 54 54 55 55 zone_size = conf->strip_zone[j].zone_end - zone_start; ··· 67 69 struct md_rdev *smallest, *rdev1, *rdev2, *rdev, **dev; 68 70 struct strip_zone *zone; 69 71 int cnt; 70 - char b[BDEVNAME_SIZE]; 71 - char b2[BDEVNAME_SIZE]; 72 72 struct r0conf *conf = kzalloc(sizeof(*conf), GFP_KERNEL); 73 73 unsigned blksize = 512; 74 74 ··· 74 78 if (!conf) 75 79 return -ENOMEM; 76 80 rdev_for_each(rdev1, mddev) { 77 - pr_debug("md/raid0:%s: looking at %s\n", 81 + pr_debug("md/raid0:%s: looking at %pg\n", 78 82 mdname(mddev), 79 - bdevname(rdev1->bdev, b)); 83 + rdev1->bdev); 80 84 c = 0; 81 85 82 86 /* round size to chunk_size */ ··· 88 92 rdev1->bdev->bd_disk->queue)); 89 93 90 94 rdev_for_each(rdev2, mddev) { 91 - pr_debug("md/raid0:%s: comparing %s(%llu)" 92 - " with %s(%llu)\n", 95 + pr_debug("md/raid0:%s: comparing %pg(%llu)" 96 + " with %pg(%llu)\n", 93 97 mdname(mddev), 94 - bdevname(rdev1->bdev,b), 98 + rdev1->bdev, 95 99 (unsigned long long)rdev1->sectors, 96 - bdevname(rdev2->bdev,b2), 100 + rdev2->bdev, 97 101 (unsigned long long)rdev2->sectors); 98 102 if (rdev2 == rdev1) { 99 103 pr_debug("md/raid0:%s: END\n", ··· 221 225 for (j=0; j<cnt; j++) { 222 226 rdev = conf->devlist[j]; 223 227 if (rdev->sectors <= zone->dev_start) { 224 - pr_debug("md/raid0:%s: checking %s ... nope\n", 228 + pr_debug("md/raid0:%s: checking %pg ... nope\n", 225 229 mdname(mddev), 226 - bdevname(rdev->bdev, b)); 230 + rdev->bdev); 227 231 continue; 228 232 } 229 - pr_debug("md/raid0:%s: checking %s ..." 233 + pr_debug("md/raid0:%s: checking %pg ..." 230 234 " contained as device %d\n", 231 235 mdname(mddev), 232 - bdevname(rdev->bdev, b), c); 236 + rdev->bdev, c); 233 237 dev[c] = rdev; 234 238 c++; 235 239 if (!smallest || rdev->sectors < smallest->sectors) { ··· 358 362 kfree(conf->strip_zone); 359 363 kfree(conf->devlist); 360 364 kfree(conf); 361 - mddev->private = NULL; 362 365 } 363 366 364 367 static void raid0_free(struct mddev *mddev, void *priv)

+10 -14

drivers/md/raid1.c

··· 402 402 /* 403 403 * oops, read error: 404 404 */ 405 - char b[BDEVNAME_SIZE]; 406 - pr_err_ratelimited("md/raid1:%s: %s: rescheduling sector %llu\n", 405 + pr_err_ratelimited("md/raid1:%s: %pg: rescheduling sector %llu\n", 407 406 mdname(conf->mddev), 408 - bdevname(rdev->bdev, b), 407 + rdev->bdev, 409 408 (unsigned long long)r1_bio->sector); 410 409 set_bit(R1BIO_ReadError, &r1_bio->state); 411 410 reschedule_retry(r1_bio); ··· 1282 1283 mirror = conf->mirrors + rdisk; 1283 1284 1284 1285 if (r1bio_existed) 1285 - pr_info_ratelimited("md/raid1:%s: redirecting sector %llu to other mirror: %s\n", 1286 + pr_info_ratelimited("md/raid1:%s: redirecting sector %llu to other mirror: %pg\n", 1286 1287 mdname(mddev), 1287 1288 (unsigned long long)r1_bio->sector, 1288 - bdevname(mirror->rdev->bdev, b)); 1289 + mirror->rdev->bdev); 1289 1290 1290 1291 if (test_bit(WriteMostly, &mirror->rdev->flags) && 1291 1292 bitmap) { ··· 1658 1659 */ 1659 1660 static void raid1_error(struct mddev *mddev, struct md_rdev *rdev) 1660 1661 { 1661 - char b[BDEVNAME_SIZE]; 1662 1662 struct r1conf *conf = mddev->private; 1663 1663 unsigned long flags; 1664 1664 ··· 1684 1686 set_bit(MD_RECOVERY_INTR, &mddev->recovery); 1685 1687 set_mask_bits(&mddev->sb_flags, 0, 1686 1688 BIT(MD_SB_CHANGE_DEVS) | BIT(MD_SB_CHANGE_PENDING)); 1687 - pr_crit("md/raid1:%s: Disk failure on %s, disabling device.\n" 1689 + pr_crit("md/raid1:%s: Disk failure on %pg, disabling device.\n" 1688 1690 "md/raid1:%s: Operation continuing on %d devices.\n", 1689 - mdname(mddev), bdevname(rdev->bdev, b), 1691 + mdname(mddev), rdev->bdev, 1690 1692 mdname(mddev), conf->raid_disks - mddev->degraded); 1691 1693 } 1692 1694 ··· 1704 1706 1705 1707 rcu_read_lock(); 1706 1708 for (i = 0; i < conf->raid_disks; i++) { 1707 - char b[BDEVNAME_SIZE]; 1708 1709 struct md_rdev *rdev = rcu_dereference(conf->mirrors[i].rdev); 1709 1710 if (rdev) 1710 - pr_debug(" disk %d, wo:%d, o:%d, dev:%s\n", 1711 + pr_debug(" disk %d, wo:%d, o:%d, dev:%pg\n", 1711 1712 i, !test_bit(In_sync, &rdev->flags), 1712 1713 !test_bit(Faulty, &rdev->flags), 1713 - bdevname(rdev->bdev,b)); 1714 + rdev->bdev); 1714 1715 } 1715 1716 rcu_read_unlock(); 1716 1717 } ··· 2344 2347 } 2345 2348 d = start; 2346 2349 while (d != read_disk) { 2347 - char b[BDEVNAME_SIZE]; 2348 2350 if (d==0) 2349 2351 d = conf->raid_disks * 2; 2350 2352 d--; ··· 2356 2360 if (r1_sync_page_io(rdev, sect, s, 2357 2361 conf->tmppage, READ)) { 2358 2362 atomic_add(s, &rdev->corrected_errors); 2359 - pr_info("md/raid1:%s: read error corrected (%d sectors at %llu on %s)\n", 2363 + pr_info("md/raid1:%s: read error corrected (%d sectors at %llu on %pg)\n", 2360 2364 mdname(mddev), s, 2361 2365 (unsigned long long)(sect + 2362 2366 rdev->data_offset), 2363 - bdevname(rdev->bdev, b)); 2367 + rdev->bdev); 2364 2368 } 2365 2369 rdev_dec_pending(rdev, mddev); 2366 2370 } else

+22 -32

drivers/md/raid10.c

··· 397 397 /* 398 398 * oops, read error - keep the refcount on the rdev 399 399 */ 400 - char b[BDEVNAME_SIZE]; 401 - pr_err_ratelimited("md/raid10:%s: %s: rescheduling sector %llu\n", 400 + pr_err_ratelimited("md/raid10:%s: %pg: rescheduling sector %llu\n", 402 401 mdname(conf->mddev), 403 - bdevname(rdev->bdev, b), 402 + rdev->bdev, 404 403 (unsigned long long)r10_bio->sector); 405 404 set_bit(R10BIO_ReadError, &r10_bio->state); 406 405 reschedule_retry(r10_bio); ··· 1186 1187 return; 1187 1188 } 1188 1189 if (err_rdev) 1189 - pr_err_ratelimited("md/raid10:%s: %s: redirecting sector %llu to another mirror\n", 1190 + pr_err_ratelimited("md/raid10:%s: %pg: redirecting sector %llu to another mirror\n", 1190 1191 mdname(mddev), 1191 - bdevname(rdev->bdev, b), 1192 + rdev->bdev, 1192 1193 (unsigned long long)r10_bio->sector); 1193 1194 if (max_sectors < bio_sectors(bio)) { 1194 1195 struct bio *split = bio_split(bio, max_sectors, ··· 1986 1987 */ 1987 1988 static void raid10_error(struct mddev *mddev, struct md_rdev *rdev) 1988 1989 { 1989 - char b[BDEVNAME_SIZE]; 1990 1990 struct r10conf *conf = mddev->private; 1991 1991 unsigned long flags; 1992 1992 ··· 2008 2010 set_mask_bits(&mddev->sb_flags, 0, 2009 2011 BIT(MD_SB_CHANGE_DEVS) | BIT(MD_SB_CHANGE_PENDING)); 2010 2012 spin_unlock_irqrestore(&conf->device_lock, flags); 2011 - pr_crit("md/raid10:%s: Disk failure on %s, disabling device.\n" 2013 + pr_crit("md/raid10:%s: Disk failure on %pg, disabling device.\n" 2012 2014 "md/raid10:%s: Operation continuing on %d devices.\n", 2013 - mdname(mddev), bdevname(rdev->bdev, b), 2015 + mdname(mddev), rdev->bdev, 2014 2016 mdname(mddev), conf->geo.raid_disks - mddev->degraded); 2015 2017 } 2016 2018 ··· 2030 2032 /* This is only called with ->reconfix_mutex held, so 2031 2033 * rcu protection of rdev is not needed */ 2032 2034 for (i = 0; i < conf->geo.raid_disks; i++) { 2033 - char b[BDEVNAME_SIZE]; 2034 2035 rdev = conf->mirrors[i].rdev; 2035 2036 if (rdev) 2036 - pr_debug(" disk %d, wo:%d, o:%d, dev:%s\n", 2037 + pr_debug(" disk %d, wo:%d, o:%d, dev:%pg\n", 2037 2038 i, !test_bit(In_sync, &rdev->flags), 2038 2039 !test_bit(Faulty, &rdev->flags), 2039 - bdevname(rdev->bdev,b)); 2040 + rdev->bdev); 2040 2041 } 2041 2042 } 2042 2043 ··· 2688 2691 check_decay_read_errors(mddev, rdev); 2689 2692 atomic_inc(&rdev->read_errors); 2690 2693 if (atomic_read(&rdev->read_errors) > max_read_errors) { 2691 - char b[BDEVNAME_SIZE]; 2692 - bdevname(rdev->bdev, b); 2693 - 2694 - pr_notice("md/raid10:%s: %s: Raid device exceeded read_error threshold [cur %d:max %d]\n", 2695 - mdname(mddev), b, 2694 + pr_notice("md/raid10:%s: %pg: Raid device exceeded read_error threshold [cur %d:max %d]\n", 2695 + mdname(mddev), rdev->bdev, 2696 2696 atomic_read(&rdev->read_errors), max_read_errors); 2697 - pr_notice("md/raid10:%s: %s: Failing raid device\n", 2698 - mdname(mddev), b); 2697 + pr_notice("md/raid10:%s: %pg: Failing raid device\n", 2698 + mdname(mddev), rdev->bdev); 2699 2699 md_error(mddev, rdev); 2700 2700 r10_bio->devs[r10_bio->read_slot].bio = IO_BLOCKED; 2701 2701 return; ··· 2762 2768 /* write it back and re-read */ 2763 2769 rcu_read_lock(); 2764 2770 while (sl != r10_bio->read_slot) { 2765 - char b[BDEVNAME_SIZE]; 2766 - 2767 2771 if (sl==0) 2768 2772 sl = conf->copies; 2769 2773 sl--; ··· 2780 2788 s, conf->tmppage, WRITE) 2781 2789 == 0) { 2782 2790 /* Well, this device is dead */ 2783 - pr_notice("md/raid10:%s: read correction write failed (%d sectors at %llu on %s)\n", 2791 + pr_notice("md/raid10:%s: read correction write failed (%d sectors at %llu on %pg)\n", 2784 2792 mdname(mddev), s, 2785 2793 (unsigned long long)( 2786 2794 sect + 2787 2795 choose_data_offset(r10_bio, 2788 2796 rdev)), 2789 - bdevname(rdev->bdev, b)); 2790 - pr_notice("md/raid10:%s: %s: failing drive\n", 2797 + rdev->bdev); 2798 + pr_notice("md/raid10:%s: %pg: failing drive\n", 2791 2799 mdname(mddev), 2792 - bdevname(rdev->bdev, b)); 2800 + rdev->bdev); 2793 2801 } 2794 2802 rdev_dec_pending(rdev, mddev); 2795 2803 rcu_read_lock(); 2796 2804 } 2797 2805 sl = start; 2798 2806 while (sl != r10_bio->read_slot) { 2799 - char b[BDEVNAME_SIZE]; 2800 - 2801 2807 if (sl==0) 2802 2808 sl = conf->copies; 2803 2809 sl--; ··· 2815 2825 READ)) { 2816 2826 case 0: 2817 2827 /* Well, this device is dead */ 2818 - pr_notice("md/raid10:%s: unable to read back corrected sectors (%d sectors at %llu on %s)\n", 2828 + pr_notice("md/raid10:%s: unable to read back corrected sectors (%d sectors at %llu on %pg)\n", 2819 2829 mdname(mddev), s, 2820 2830 (unsigned long long)( 2821 2831 sect + 2822 2832 choose_data_offset(r10_bio, rdev)), 2823 - bdevname(rdev->bdev, b)); 2824 - pr_notice("md/raid10:%s: %s: failing drive\n", 2833 + rdev->bdev); 2834 + pr_notice("md/raid10:%s: %pg: failing drive\n", 2825 2835 mdname(mddev), 2826 - bdevname(rdev->bdev, b)); 2836 + rdev->bdev); 2827 2837 break; 2828 2838 case 1: 2829 - pr_info("md/raid10:%s: read error corrected (%d sectors at %llu on %s)\n", 2839 + pr_info("md/raid10:%s: read error corrected (%d sectors at %llu on %pg)\n", 2830 2840 mdname(mddev), s, 2831 2841 (unsigned long long)( 2832 2842 sect + 2833 2843 choose_data_offset(r10_bio, rdev)), 2834 - bdevname(rdev->bdev, b)); 2844 + rdev->bdev); 2835 2845 atomic_add(s, &rdev->corrected_errors); 2836 2846 } 2837 2847

+2 -3

drivers/md/raid5-cache.c

··· 3064 3064 { 3065 3065 struct request_queue *q = bdev_get_queue(rdev->bdev); 3066 3066 struct r5l_log *log; 3067 - char b[BDEVNAME_SIZE]; 3068 3067 int ret; 3069 3068 3070 - pr_debug("md/raid:%s: using device %s as journal\n", 3071 - mdname(conf->mddev), bdevname(rdev->bdev, b)); 3069 + pr_debug("md/raid:%s: using device %pg as journal\n", 3070 + mdname(conf->mddev), rdev->bdev); 3072 3071 3073 3072 if (PAGE_SIZE != 4096) 3074 3073 return -EINVAL;

+12 -15

drivers/md/raid5-ppl.c

··· 798 798 int data_disks; 799 799 int i; 800 800 int ret = 0; 801 - char b[BDEVNAME_SIZE]; 802 801 unsigned int pp_size = le32_to_cpu(e->pp_size); 803 802 unsigned int data_size = le32_to_cpu(e->data_size); 804 803 ··· 893 894 break; 894 895 } 895 896 896 - pr_debug("%s:%*s reading data member disk %s sector %llu\n", 897 - __func__, indent, "", bdevname(rdev->bdev, b), 897 + pr_debug("%s:%*s reading data member disk %pg sector %llu\n", 898 + __func__, indent, "", rdev->bdev, 898 899 (unsigned long long)sector); 899 900 if (!sync_page_io(rdev, sector, block_size, page2, 900 901 REQ_OP_READ, 0, false)) { ··· 941 942 conf->disks[sh.pd_idx].rdev, 1); 942 943 943 944 BUG_ON(parity_rdev->bdev->bd_dev != log->rdev->bdev->bd_dev); 944 - pr_debug("%s:%*s write parity at sector %llu, disk %s\n", 945 + pr_debug("%s:%*s write parity at sector %llu, disk %pg\n", 945 946 __func__, indent, "", 946 947 (unsigned long long)parity_sector, 947 - bdevname(parity_rdev->bdev, b)); 948 + parity_rdev->bdev); 948 949 if (!sync_page_io(parity_rdev, parity_sector, block_size, 949 950 page1, REQ_OP_WRITE, 0, false)) { 950 951 pr_debug("%s:%*s parity write error!\n", __func__, ··· 1254 1255 1255 1256 static int ppl_validate_rdev(struct md_rdev *rdev) 1256 1257 { 1257 - char b[BDEVNAME_SIZE]; 1258 1258 int ppl_data_sectors; 1259 1259 int ppl_size_new; 1260 1260 ··· 1270 1272 RAID5_STRIPE_SECTORS((struct r5conf *)rdev->mddev->private)); 1271 1273 1272 1274 if (ppl_data_sectors <= 0) { 1273 - pr_warn("md/raid:%s: PPL space too small on %s\n", 1274 - mdname(rdev->mddev), bdevname(rdev->bdev, b)); 1275 + pr_warn("md/raid:%s: PPL space too small on %pg\n", 1276 + mdname(rdev->mddev), rdev->bdev); 1275 1277 return -ENOSPC; 1276 1278 } 1277 1279 ··· 1281 1283 rdev->ppl.sector + ppl_size_new > rdev->data_offset) || 1282 1284 (rdev->ppl.sector >= rdev->data_offset && 1283 1285 rdev->data_offset + rdev->sectors > rdev->ppl.sector)) { 1284 - pr_warn("md/raid:%s: PPL space overlaps with data on %s\n", 1285 - mdname(rdev->mddev), bdevname(rdev->bdev, b)); 1286 + pr_warn("md/raid:%s: PPL space overlaps with data on %pg\n", 1287 + mdname(rdev->mddev), rdev->bdev); 1286 1288 return -EINVAL; 1287 1289 } 1288 1290 1289 1291 if (!rdev->mddev->external && 1290 1292 ((rdev->ppl.offset > 0 && rdev->ppl.offset < (rdev->sb_size >> 9)) || 1291 1293 (rdev->ppl.offset <= 0 && rdev->ppl.offset + ppl_size_new > 0))) { 1292 - pr_warn("md/raid:%s: PPL space overlaps with superblock on %s\n", 1293 - mdname(rdev->mddev), bdevname(rdev->bdev, b)); 1294 + pr_warn("md/raid:%s: PPL space overlaps with superblock on %pg\n", 1295 + mdname(rdev->mddev), rdev->bdev); 1294 1296 return -EINVAL; 1295 1297 } 1296 1298 ··· 1461 1463 struct ppl_conf *ppl_conf = conf->log_private; 1462 1464 struct ppl_log *log; 1463 1465 int ret = 0; 1464 - char b[BDEVNAME_SIZE]; 1465 1466 1466 1467 if (!rdev) 1467 1468 return -EINVAL; 1468 1469 1469 - pr_debug("%s: disk: %d operation: %s dev: %s\n", 1470 + pr_debug("%s: disk: %d operation: %s dev: %pg\n", 1470 1471 __func__, rdev->raid_disk, add ? "add" : "remove", 1471 - bdevname(rdev->bdev, b)); 1472 + rdev->bdev); 1472 1473 1473 1474 if (rdev->raid_disk < 0) 1474 1475 return 0;

+16 -21

drivers/md/raid5.c

··· 2686 2686 struct stripe_head *sh = bi->bi_private; 2687 2687 struct r5conf *conf = sh->raid_conf; 2688 2688 int disks = sh->disks, i; 2689 - char b[BDEVNAME_SIZE]; 2690 2689 struct md_rdev *rdev = NULL; 2691 2690 sector_t s; 2692 2691 ··· 2722 2723 * any error 2723 2724 */ 2724 2725 pr_info_ratelimited( 2725 - "md/raid:%s: read error corrected (%lu sectors at %llu on %s)\n", 2726 + "md/raid:%s: read error corrected (%lu sectors at %llu on %pg)\n", 2726 2727 mdname(conf->mddev), RAID5_STRIPE_SECTORS(conf), 2727 2728 (unsigned long long)s, 2728 - bdevname(rdev->bdev, b)); 2729 + rdev->bdev); 2729 2730 atomic_add(RAID5_STRIPE_SECTORS(conf), &rdev->corrected_errors); 2730 2731 clear_bit(R5_ReadError, &sh->dev[i].flags); 2731 2732 clear_bit(R5_ReWrite, &sh->dev[i].flags); ··· 2742 2743 if (atomic_read(&rdev->read_errors)) 2743 2744 atomic_set(&rdev->read_errors, 0); 2744 2745 } else { 2745 - const char *bdn = bdevname(rdev->bdev, b); 2746 2746 int retry = 0; 2747 2747 int set_bad = 0; 2748 2748 ··· 2750 2752 atomic_inc(&rdev->read_errors); 2751 2753 if (test_bit(R5_ReadRepl, &sh->dev[i].flags)) 2752 2754 pr_warn_ratelimited( 2753 - "md/raid:%s: read error on replacement device (sector %llu on %s).\n", 2755 + "md/raid:%s: read error on replacement device (sector %llu on %pg).\n", 2754 2756 mdname(conf->mddev), 2755 2757 (unsigned long long)s, 2756 - bdn); 2758 + rdev->bdev); 2757 2759 else if (conf->mddev->degraded >= conf->max_degraded) { 2758 2760 set_bad = 1; 2759 2761 pr_warn_ratelimited( 2760 - "md/raid:%s: read error not correctable (sector %llu on %s).\n", 2762 + "md/raid:%s: read error not correctable (sector %llu on %pg).\n", 2761 2763 mdname(conf->mddev), 2762 2764 (unsigned long long)s, 2763 - bdn); 2765 + rdev->bdev); 2764 2766 } else if (test_bit(R5_ReWrite, &sh->dev[i].flags)) { 2765 2767 /* Oh, no!!! */ 2766 2768 set_bad = 1; 2767 2769 pr_warn_ratelimited( 2768 - "md/raid:%s: read error NOT corrected!! (sector %llu on %s).\n", 2770 + "md/raid:%s: read error NOT corrected!! (sector %llu on %pg).\n", 2769 2771 mdname(conf->mddev), 2770 2772 (unsigned long long)s, 2771 - bdn); 2773 + rdev->bdev); 2772 2774 } else if (atomic_read(&rdev->read_errors) 2773 2775 > conf->max_nr_stripes) { 2774 2776 if (!test_bit(Faulty, &rdev->flags)) { ··· 2776 2778 mdname(conf->mddev), 2777 2779 atomic_read(&rdev->read_errors), 2778 2780 conf->max_nr_stripes); 2779 - pr_warn("md/raid:%s: Too many read errors, failing device %s.\n", 2780 - mdname(conf->mddev), bdn); 2781 + pr_warn("md/raid:%s: Too many read errors, failing device %pg.\n", 2782 + mdname(conf->mddev), rdev->bdev); 2781 2783 } 2782 2784 } else 2783 2785 retry = 1; ··· 2889 2891 2890 2892 static void raid5_error(struct mddev *mddev, struct md_rdev *rdev) 2891 2893 { 2892 - char b[BDEVNAME_SIZE]; 2893 2894 struct r5conf *conf = mddev->private; 2894 2895 unsigned long flags; 2895 2896 pr_debug("raid456: error called\n"); 2896 2897 2897 - pr_crit("md/raid:%s: Disk failure on %s, disabling device.\n", 2898 - mdname(mddev), bdevname(rdev->bdev, b)); 2898 + pr_crit("md/raid:%s: Disk failure on %pg, disabling device.\n", 2899 + mdname(mddev), rdev->bdev); 2899 2900 2900 2901 spin_lock_irqsave(&conf->device_lock, flags); 2901 2902 set_bit(Faulty, &rdev->flags); ··· 7356 7359 } 7357 7360 7358 7361 if (test_bit(In_sync, &rdev->flags)) { 7359 - char b[BDEVNAME_SIZE]; 7360 - pr_info("md/raid:%s: device %s operational as raid disk %d\n", 7361 - mdname(mddev), bdevname(rdev->bdev, b), raid_disk); 7362 + pr_info("md/raid:%s: device %pg operational as raid disk %d\n", 7363 + mdname(mddev), rdev->bdev, raid_disk); 7362 7364 } else if (rdev->saved_raid_disk != raid_disk) 7363 7365 /* Cannot rely on bitmap to complete recovery */ 7364 7366 conf->fullsync = 1; ··· 7873 7877 7874 7878 rcu_read_lock(); 7875 7879 for (i = 0; i < conf->raid_disks; i++) { 7876 - char b[BDEVNAME_SIZE]; 7877 7880 rdev = rcu_dereference(conf->disks[i].rdev); 7878 7881 if (rdev) 7879 - pr_debug(" disk %d, o:%d, dev:%s\n", 7882 + pr_debug(" disk %d, o:%d, dev:%pg\n", 7880 7883 i, !test_bit(Faulty, &rdev->flags), 7881 - bdevname(rdev->bdev, b)); 7884 + rdev->bdev); 7882 7885 } 7883 7886 rcu_read_unlock(); 7884 7887 }

+9 -1

drivers/nvme/host/core.c

··· 2228 2228 ctrl->ctrl_config |= (NVME_CTRL_PAGE_SHIFT - 12) << NVME_CC_MPS_SHIFT; 2229 2229 ctrl->ctrl_config |= NVME_CC_AMS_RR | NVME_CC_SHN_NONE; 2230 2230 ctrl->ctrl_config |= NVME_CC_IOSQES | NVME_CC_IOCQES; 2231 - ctrl->ctrl_config |= NVME_CC_ENABLE; 2231 + ret = ctrl->ops->reg_write32(ctrl, NVME_REG_CC, ctrl->ctrl_config); 2232 + if (ret) 2233 + return ret; 2232 2234 2235 + /* Flush write to device (required if transport is PCI) */ 2236 + ret = ctrl->ops->reg_read32(ctrl, NVME_REG_CC, &ctrl->ctrl_config); 2237 + if (ret) 2238 + return ret; 2239 + 2240 + ctrl->ctrl_config |= NVME_CC_ENABLE; 2233 2241 ret = ctrl->ops->reg_write32(ctrl, NVME_REG_CC, ctrl->ctrl_config); 2234 2242 if (ret) 2235 2243 return ret;

+2

drivers/nvme/host/pci.c

··· 3457 3457 .driver_data = NVME_QUIRK_NO_DEEPEST_PS, }, 3458 3458 { PCI_DEVICE(0x2646, 0x2263), /* KINGSTON A2000 NVMe SSD */ 3459 3459 .driver_data = NVME_QUIRK_NO_DEEPEST_PS, }, 3460 + { PCI_DEVICE(0x1e4B, 0x1001), /* MAXIO MAP1001 */ 3461 + .driver_data = NVME_QUIRK_BOGUS_NID, }, 3460 3462 { PCI_DEVICE(0x1e4B, 0x1002), /* MAXIO MAP1002 */ 3461 3463 .driver_data = NVME_QUIRK_BOGUS_NID, }, 3462 3464 { PCI_DEVICE(0x1e4B, 0x1202), /* MAXIO MAP1202 */

+1 -1

drivers/nvme/target/passthru.c

··· 97 97 id->sgls |= cpu_to_le32(1 << 20); 98 98 99 99 /* 100 - * When passsthru controller is setup using nvme-loop transport it will 100 + * When passthru controller is setup using nvme-loop transport it will 101 101 * export the passthru ctrl subsysnqn (PCIe NVMe ctrl) and will fail in 102 102 * the nvme/host/core.c in the nvme_init_subsystem()->nvme_active_ctrl() 103 103 * code path with duplicate ctr subsynqn. In order to prevent that we

+1

include/linux/blkdev.h

··· 147 147 #define GD_DEAD 2 148 148 #define GD_NATIVE_CAPACITY 3 149 149 #define GD_ADDED 4 150 + #define GD_SUPPRESS_PART_SCAN 5 150 151 151 152 struct mutex open_mutex; /* open/close mutex */ 152 153 unsigned open_partitions; /* number of open partitions */

Configure Feed

Configure Feed