Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'for-linus-20190608' of git://git.kernel.dk/linux-block
Pull block fixes from Jens Axboe:
- Allow symlink from the bfq.weight cgroup parameter to the general
weight (Angelo)
- Damien is new skd maintainer (Bart)
- NVMe pull request from Sagi, with a few small fixes.
- Ensure we set DMA segment size properly, dma-debug is now tripping on
these (Christoph)
- Remove useless debugfs_create() return check (Greg)
- Remove redundant unlikely() check on IS_ERR() (Kefeng)
- Fixup request freeing on exit (Ming)
* tag 'for-linus-20190608' of git://git.kernel.dk/linux-block:
block, bfq: add weight symlink to the bfq.weight cgroup parameter
cgroup: let a symlink too be created with a cftype file
block: free sched's request pool in blk_cleanup_queue
nvme-rdma: use dynamic dma mapping per command
nvme: Fix u32 overflow in the number of namespace list calculation
mmc: also set max_segment_size in the device
mtip32xx: also set max_segment_size in the device
rsxx: don't call dma_set_max_seg_size
nvme-pci: don't limit DMA segement size
block: Drop unlikely before IS_ERR(_OR_NULL)
block: aoe: no need to check return value of debugfs_create functions
nvmet: fix data_len to 0 for bdev-backed write_zeroes
MAINTAINERS: Hand over skd maintainership
nvme-tcp: fix queue mapping when queue count is limited
nvme-rdma: fix queue mapping when queue count is limited
+251
-92
+1
-1
MAINTAINERS
+1
-1
MAINTAINERS
···
14995
14995
F: drivers/net/ethernet/adaptec/starfire*
14996
14996
14997
14997
STEC S1220 SKD DRIVER
14998
-
M: Bart Van Assche <bart.vanassche@wdc.com>
14998
+
M: Damien Le Moal <Damien.LeMoal@wdc.com>
14999
14999
L: linux-block@vger.kernel.org
15000
15000
S: Maintained
15001
15001
F: drivers/block/skd*[ch]
+4
-2
block/bfq-cgroup.c
+4
-2
block/bfq-cgroup.c
···
1046
1046
struct cftype bfq_blkcg_legacy_files[] = {
1047
1047
{
1048
1048
.name = "bfq.weight",
1049
-
.flags = CFTYPE_NOT_ON_ROOT,
1049
+
.link_name = "weight",
1050
+
.flags = CFTYPE_NOT_ON_ROOT | CFTYPE_SYMLINKED,
1050
1051
.seq_show = bfq_io_show_weight,
1051
1052
.write_u64 = bfq_io_set_weight_legacy,
1052
1053
},
···
1167
1166
struct cftype bfq_blkg_files[] = {
1168
1167
{
1169
1168
.name = "bfq.weight",
1170
-
.flags = CFTYPE_NOT_ON_ROOT,
1169
+
.link_name = "weight",
1170
+
.flags = CFTYPE_NOT_ON_ROOT | CFTYPE_SYMLINKED,
1171
1171
.seq_show = bfq_io_show_weight,
1172
1172
.write = bfq_io_set_weight,
1173
1173
},
+1
-1
block/blk-cgroup.c
+1
-1
block/blk-cgroup.c
+13
block/blk-core.c
+13
block/blk-core.c
···
320
320
if (queue_is_mq(q))
321
321
blk_mq_exit_queue(q);
322
322
323
+
/*
324
+
* In theory, request pool of sched_tags belongs to request queue.
325
+
* However, the current implementation requires tag_set for freeing
326
+
* requests, so free the pool now.
327
+
*
328
+
* Queue has become frozen, there can't be any in-queue requests, so
329
+
* it is safe to free requests now.
330
+
*/
331
+
mutex_lock(&q->sysfs_lock);
332
+
if (q->elevator)
333
+
blk_mq_sched_free_requests(q);
334
+
mutex_unlock(&q->sysfs_lock);
335
+
323
336
percpu_ref_exit(&q->q_usage_counter);
324
337
325
338
/* @q is and will stay empty, shutdown and put */
+27
-3
block/blk-mq-sched.c
+27
-3
block/blk-mq-sched.c
···
475
475
return ret;
476
476
}
477
477
478
+
/* called in queue's release handler, tagset has gone away */
478
479
static void blk_mq_sched_tags_teardown(struct request_queue *q)
479
480
{
480
-
struct blk_mq_tag_set *set = q->tag_set;
481
481
struct blk_mq_hw_ctx *hctx;
482
482
int i;
483
483
484
-
queue_for_each_hw_ctx(q, hctx, i)
485
-
blk_mq_sched_free_tags(set, hctx, i);
484
+
queue_for_each_hw_ctx(q, hctx, i) {
485
+
if (hctx->sched_tags) {
486
+
blk_mq_free_rq_map(hctx->sched_tags);
487
+
hctx->sched_tags = NULL;
488
+
}
489
+
}
486
490
}
487
491
488
492
int blk_mq_init_sched(struct request_queue *q, struct elevator_type *e)
···
527
523
ret = e->ops.init_hctx(hctx, i);
528
524
if (ret) {
529
525
eq = q->elevator;
526
+
blk_mq_sched_free_requests(q);
530
527
blk_mq_exit_sched(q, eq);
531
528
kobject_put(&eq->kobj);
532
529
return ret;
···
539
534
return 0;
540
535
541
536
err:
537
+
blk_mq_sched_free_requests(q);
542
538
blk_mq_sched_tags_teardown(q);
543
539
q->elevator = NULL;
544
540
return ret;
541
+
}
542
+
543
+
/*
544
+
* called in either blk_queue_cleanup or elevator_switch, tagset
545
+
* is required for freeing requests
546
+
*/
547
+
void blk_mq_sched_free_requests(struct request_queue *q)
548
+
{
549
+
struct blk_mq_hw_ctx *hctx;
550
+
int i;
551
+
552
+
lockdep_assert_held(&q->sysfs_lock);
553
+
WARN_ON(!q->elevator);
554
+
555
+
queue_for_each_hw_ctx(q, hctx, i) {
556
+
if (hctx->sched_tags)
557
+
blk_mq_free_rqs(q->tag_set, hctx->sched_tags, i);
558
+
}
545
559
}
546
560
547
561
void blk_mq_exit_sched(struct request_queue *q, struct elevator_queue *e)
+1
block/blk-mq-sched.h
+1
block/blk-mq-sched.h
···
28
28
29
29
int blk_mq_init_sched(struct request_queue *q, struct elevator_type *e);
30
30
void blk_mq_exit_sched(struct request_queue *q, struct elevator_queue *e);
31
+
void blk_mq_sched_free_requests(struct request_queue *q);
31
32
32
33
static inline bool
33
34
blk_mq_sched_bio_merge(struct request_queue *q, struct bio *bio)
+1
-1
block/blk-sysfs.c
+1
-1
block/blk-sysfs.c
+9
-1
block/blk.h
+9
-1
block/blk.h
···
6
6
#include <linux/blk-mq.h>
7
7
#include <xen/xen.h>
8
8
#include "blk-mq.h"
9
+
#include "blk-mq-sched.h"
9
10
10
11
/* Max future timer expiry for timeouts */
11
12
#define BLK_MAX_TIMEOUT (5 * HZ)
···
177
176
int elevator_init_mq(struct request_queue *q);
178
177
int elevator_switch_mq(struct request_queue *q,
179
178
struct elevator_type *new_e);
180
-
void elevator_exit(struct request_queue *, struct elevator_queue *);
179
+
void __elevator_exit(struct request_queue *, struct elevator_queue *);
181
180
int elv_register_queue(struct request_queue *q);
182
181
void elv_unregister_queue(struct request_queue *q);
182
+
183
+
static inline void elevator_exit(struct request_queue *q,
184
+
struct elevator_queue *e)
185
+
{
186
+
blk_mq_sched_free_requests(q);
187
+
__elevator_exit(q, e);
188
+
}
183
189
184
190
struct hd_struct *__disk_get_part(struct gendisk *disk, int partno);
185
191
+1
-1
block/elevator.c
+1
-1
block/elevator.c
+2
-14
drivers/block/aoe/aoeblk.c
+2
-14
drivers/block/aoe/aoeblk.c
···
196
196
static void
197
197
aoedisk_add_debugfs(struct aoedev *d)
198
198
{
199
-
struct dentry *entry;
200
199
char *p;
201
200
202
201
if (aoe_debugfs_dir == NULL)
···
206
207
else
207
208
p++;
208
209
BUG_ON(*p == '\0');
209
-
entry = debugfs_create_file(p, 0444, aoe_debugfs_dir, d,
210
-
&aoe_debugfs_fops);
211
-
if (IS_ERR_OR_NULL(entry)) {
212
-
pr_info("aoe: cannot create debugfs file for %s\n",
213
-
d->gd->disk_name);
214
-
return;
215
-
}
216
-
BUG_ON(d->debugfs);
217
-
d->debugfs = entry;
210
+
d->debugfs = debugfs_create_file(p, 0444, aoe_debugfs_dir, d,
211
+
&aoe_debugfs_fops);
218
212
}
219
213
void
220
214
aoedisk_rm_debugfs(struct aoedev *d)
···
464
472
if (buf_pool_cache == NULL)
465
473
return -ENOMEM;
466
474
aoe_debugfs_dir = debugfs_create_dir("aoe", NULL);
467
-
if (IS_ERR_OR_NULL(aoe_debugfs_dir)) {
468
-
pr_info("aoe: cannot create debugfs directory\n");
469
-
aoe_debugfs_dir = NULL;
470
-
}
471
475
return 0;
472
476
}
473
477
+1
drivers/block/mtip32xx/mtip32xx.c
+1
drivers/block/mtip32xx/mtip32xx.c
···
3676
3676
blk_queue_physical_block_size(dd->queue, 4096);
3677
3677
blk_queue_max_hw_sectors(dd->queue, 0xffff);
3678
3678
blk_queue_max_segment_size(dd->queue, 0x400000);
3679
+
dma_set_max_seg_size(&dd->pdev->dev, 0x400000);
3679
3680
blk_queue_io_min(dd->queue, 4096);
3680
3681
3681
3682
/* Set the capacity of the device in 512 byte sectors. */
-1
drivers/block/rsxx/core.c
-1
drivers/block/rsxx/core.c
+2
drivers/mmc/core/queue.c
+2
drivers/mmc/core/queue.c
···
377
377
blk_queue_max_segment_size(mq->queue,
378
378
round_down(host->max_seg_size, block_size));
379
379
380
+
dma_set_max_seg_size(mmc_dev(host), queue_max_segment_size(mq->queue));
381
+
380
382
INIT_WORK(&mq->recovery_work, mmc_mq_recovery_handler);
381
383
INIT_WORK(&mq->complete_work, mmc_blk_mq_complete_work);
382
384
+2
-1
drivers/nvme/host/core.c
+2
-1
drivers/nvme/host/core.c
···
3400
3400
{
3401
3401
struct nvme_ns *ns;
3402
3402
__le32 *ns_list;
3403
-
unsigned i, j, nsid, prev = 0, num_lists = DIV_ROUND_UP(nn, 1024);
3403
+
unsigned i, j, nsid, prev = 0;
3404
+
unsigned num_lists = DIV_ROUND_UP_ULL((u64)nn, 1024);
3404
3405
int ret = 0;
3405
3406
3406
3407
ns_list = kzalloc(NVME_IDENTIFY_DATA_SIZE, GFP_KERNEL);
+6
drivers/nvme/host/pci.c
+6
drivers/nvme/host/pci.c
···
2513
2513
*/
2514
2514
dev->ctrl.max_hw_sectors = NVME_MAX_KB_SZ << 1;
2515
2515
dev->ctrl.max_segments = NVME_MAX_SEGS;
2516
+
2517
+
/*
2518
+
* Don't limit the IOMMU merged segment size.
2519
+
*/
2520
+
dma_set_max_seg_size(dev->dev, 0xffffffff);
2521
+
2516
2522
mutex_unlock(&dev->shutdown_lock);
2517
2523
2518
2524
/*
+97
-55
drivers/nvme/host/rdma.c
+97
-55
drivers/nvme/host/rdma.c
···
213
213
if (!ring)
214
214
return NULL;
215
215
216
+
/*
217
+
* Bind the CQEs (post recv buffers) DMA mapping to the RDMA queue
218
+
* lifetime. It's safe, since any chage in the underlying RDMA device
219
+
* will issue error recovery and queue re-creation.
220
+
*/
216
221
for (i = 0; i < ib_queue_size; i++) {
217
222
if (nvme_rdma_alloc_qe(ibdev, &ring[i], capsule_size, dir))
218
223
goto out_free_ring;
···
279
274
static void nvme_rdma_exit_request(struct blk_mq_tag_set *set,
280
275
struct request *rq, unsigned int hctx_idx)
281
276
{
282
-
struct nvme_rdma_ctrl *ctrl = set->driver_data;
283
277
struct nvme_rdma_request *req = blk_mq_rq_to_pdu(rq);
284
-
int queue_idx = (set == &ctrl->tag_set) ? hctx_idx + 1 : 0;
285
-
struct nvme_rdma_queue *queue = &ctrl->queues[queue_idx];
286
-
struct nvme_rdma_device *dev = queue->device;
287
278
288
-
nvme_rdma_free_qe(dev->dev, &req->sqe, sizeof(struct nvme_command),
289
-
DMA_TO_DEVICE);
279
+
kfree(req->sqe.data);
290
280
}
291
281
292
282
static int nvme_rdma_init_request(struct blk_mq_tag_set *set,
···
292
292
struct nvme_rdma_request *req = blk_mq_rq_to_pdu(rq);
293
293
int queue_idx = (set == &ctrl->tag_set) ? hctx_idx + 1 : 0;
294
294
struct nvme_rdma_queue *queue = &ctrl->queues[queue_idx];
295
-
struct nvme_rdma_device *dev = queue->device;
296
-
struct ib_device *ibdev = dev->dev;
297
-
int ret;
298
295
299
296
nvme_req(rq)->ctrl = &ctrl->ctrl;
300
-
ret = nvme_rdma_alloc_qe(ibdev, &req->sqe, sizeof(struct nvme_command),
301
-
DMA_TO_DEVICE);
302
-
if (ret)
303
-
return ret;
297
+
req->sqe.data = kzalloc(sizeof(struct nvme_command), GFP_KERNEL);
298
+
if (!req->sqe.data)
299
+
return -ENOMEM;
304
300
305
301
req->queue = queue;
306
302
···
637
641
{
638
642
struct nvmf_ctrl_options *opts = ctrl->ctrl.opts;
639
643
struct ib_device *ibdev = ctrl->device->dev;
640
-
unsigned int nr_io_queues;
644
+
unsigned int nr_io_queues, nr_default_queues;
645
+
unsigned int nr_read_queues, nr_poll_queues;
641
646
int i, ret;
642
647
643
-
nr_io_queues = min(opts->nr_io_queues, num_online_cpus());
644
-
645
-
/*
646
-
* we map queues according to the device irq vectors for
647
-
* optimal locality so we don't need more queues than
648
-
* completion vectors.
649
-
*/
650
-
nr_io_queues = min_t(unsigned int, nr_io_queues,
651
-
ibdev->num_comp_vectors);
652
-
653
-
if (opts->nr_write_queues) {
654
-
ctrl->io_queues[HCTX_TYPE_DEFAULT] =
655
-
min(opts->nr_write_queues, nr_io_queues);
656
-
nr_io_queues += ctrl->io_queues[HCTX_TYPE_DEFAULT];
657
-
} else {
658
-
ctrl->io_queues[HCTX_TYPE_DEFAULT] = nr_io_queues;
659
-
}
660
-
661
-
ctrl->io_queues[HCTX_TYPE_READ] = nr_io_queues;
662
-
663
-
if (opts->nr_poll_queues) {
664
-
ctrl->io_queues[HCTX_TYPE_POLL] =
665
-
min(opts->nr_poll_queues, num_online_cpus());
666
-
nr_io_queues += ctrl->io_queues[HCTX_TYPE_POLL];
667
-
}
648
+
nr_read_queues = min_t(unsigned int, ibdev->num_comp_vectors,
649
+
min(opts->nr_io_queues, num_online_cpus()));
650
+
nr_default_queues = min_t(unsigned int, ibdev->num_comp_vectors,
651
+
min(opts->nr_write_queues, num_online_cpus()));
652
+
nr_poll_queues = min(opts->nr_poll_queues, num_online_cpus());
653
+
nr_io_queues = nr_read_queues + nr_default_queues + nr_poll_queues;
668
654
669
655
ret = nvme_set_queue_count(&ctrl->ctrl, &nr_io_queues);
670
656
if (ret)
···
658
680
659
681
dev_info(ctrl->ctrl.device,
660
682
"creating %d I/O queues.\n", nr_io_queues);
683
+
684
+
if (opts->nr_write_queues && nr_read_queues < nr_io_queues) {
685
+
/*
686
+
* separate read/write queues
687
+
* hand out dedicated default queues only after we have
688
+
* sufficient read queues.
689
+
*/
690
+
ctrl->io_queues[HCTX_TYPE_READ] = nr_read_queues;
691
+
nr_io_queues -= ctrl->io_queues[HCTX_TYPE_READ];
692
+
ctrl->io_queues[HCTX_TYPE_DEFAULT] =
693
+
min(nr_default_queues, nr_io_queues);
694
+
nr_io_queues -= ctrl->io_queues[HCTX_TYPE_DEFAULT];
695
+
} else {
696
+
/*
697
+
* shared read/write queues
698
+
* either no write queues were requested, or we don't have
699
+
* sufficient queue count to have dedicated default queues.
700
+
*/
701
+
ctrl->io_queues[HCTX_TYPE_DEFAULT] =
702
+
min(nr_read_queues, nr_io_queues);
703
+
nr_io_queues -= ctrl->io_queues[HCTX_TYPE_DEFAULT];
704
+
}
705
+
706
+
if (opts->nr_poll_queues && nr_io_queues) {
707
+
/* map dedicated poll queues only if we have queues left */
708
+
ctrl->io_queues[HCTX_TYPE_POLL] =
709
+
min(nr_poll_queues, nr_io_queues);
710
+
}
661
711
662
712
for (i = 1; i < ctrl->ctrl.queue_count; i++) {
663
713
ret = nvme_rdma_alloc_queue(ctrl, i,
···
775
769
776
770
ctrl->max_fr_pages = nvme_rdma_get_max_fr_pages(ctrl->device->dev);
777
771
772
+
/*
773
+
* Bind the async event SQE DMA mapping to the admin queue lifetime.
774
+
* It's safe, since any chage in the underlying RDMA device will issue
775
+
* error recovery and queue re-creation.
776
+
*/
778
777
error = nvme_rdma_alloc_qe(ctrl->device->dev, &ctrl->async_event_sqe,
779
778
sizeof(struct nvme_command), DMA_TO_DEVICE);
780
779
if (error)
···
1720
1709
return nvmf_fail_nonready_command(&queue->ctrl->ctrl, rq);
1721
1710
1722
1711
dev = queue->device->dev;
1712
+
1713
+
req->sqe.dma = ib_dma_map_single(dev, req->sqe.data,
1714
+
sizeof(struct nvme_command),
1715
+
DMA_TO_DEVICE);
1716
+
err = ib_dma_mapping_error(dev, req->sqe.dma);
1717
+
if (unlikely(err))
1718
+
return BLK_STS_RESOURCE;
1719
+
1723
1720
ib_dma_sync_single_for_cpu(dev, sqe->dma,
1724
1721
sizeof(struct nvme_command), DMA_TO_DEVICE);
1725
1722
1726
1723
ret = nvme_setup_cmd(ns, rq, c);
1727
1724
if (ret)
1728
-
return ret;
1725
+
goto unmap_qe;
1729
1726
1730
1727
blk_mq_start_request(rq);
1731
1728
···
1758
1739
}
1759
1740
1760
1741
return BLK_STS_OK;
1742
+
1761
1743
err:
1762
1744
if (err == -ENOMEM || err == -EAGAIN)
1763
-
return BLK_STS_RESOURCE;
1764
-
return BLK_STS_IOERR;
1745
+
ret = BLK_STS_RESOURCE;
1746
+
else
1747
+
ret = BLK_STS_IOERR;
1748
+
unmap_qe:
1749
+
ib_dma_unmap_single(dev, req->sqe.dma, sizeof(struct nvme_command),
1750
+
DMA_TO_DEVICE);
1751
+
return ret;
1765
1752
}
1766
1753
1767
1754
static int nvme_rdma_poll(struct blk_mq_hw_ctx *hctx)
···
1780
1755
static void nvme_rdma_complete_rq(struct request *rq)
1781
1756
{
1782
1757
struct nvme_rdma_request *req = blk_mq_rq_to_pdu(rq);
1758
+
struct nvme_rdma_queue *queue = req->queue;
1759
+
struct ib_device *ibdev = queue->device->dev;
1783
1760
1784
-
nvme_rdma_unmap_data(req->queue, rq);
1761
+
nvme_rdma_unmap_data(queue, rq);
1762
+
ib_dma_unmap_single(ibdev, req->sqe.dma, sizeof(struct nvme_command),
1763
+
DMA_TO_DEVICE);
1785
1764
nvme_complete_rq(rq);
1786
1765
}
1787
1766
1788
1767
static int nvme_rdma_map_queues(struct blk_mq_tag_set *set)
1789
1768
{
1790
1769
struct nvme_rdma_ctrl *ctrl = set->driver_data;
1770
+
struct nvmf_ctrl_options *opts = ctrl->ctrl.opts;
1791
1771
1792
-
set->map[HCTX_TYPE_DEFAULT].queue_offset = 0;
1793
-
set->map[HCTX_TYPE_DEFAULT].nr_queues =
1794
-
ctrl->io_queues[HCTX_TYPE_DEFAULT];
1795
-
set->map[HCTX_TYPE_READ].nr_queues = ctrl->io_queues[HCTX_TYPE_READ];
1796
-
if (ctrl->ctrl.opts->nr_write_queues) {
1772
+
if (opts->nr_write_queues && ctrl->io_queues[HCTX_TYPE_READ]) {
1797
1773
/* separate read/write queues */
1774
+
set->map[HCTX_TYPE_DEFAULT].nr_queues =
1775
+
ctrl->io_queues[HCTX_TYPE_DEFAULT];
1776
+
set->map[HCTX_TYPE_DEFAULT].queue_offset = 0;
1777
+
set->map[HCTX_TYPE_READ].nr_queues =
1778
+
ctrl->io_queues[HCTX_TYPE_READ];
1798
1779
set->map[HCTX_TYPE_READ].queue_offset =
1799
-
ctrl->io_queues[HCTX_TYPE_DEFAULT];
1780
+
ctrl->io_queues[HCTX_TYPE_DEFAULT];
1800
1781
} else {
1801
-
/* mixed read/write queues */
1782
+
/* shared read/write queues */
1783
+
set->map[HCTX_TYPE_DEFAULT].nr_queues =
1784
+
ctrl->io_queues[HCTX_TYPE_DEFAULT];
1785
+
set->map[HCTX_TYPE_DEFAULT].queue_offset = 0;
1786
+
set->map[HCTX_TYPE_READ].nr_queues =
1787
+
ctrl->io_queues[HCTX_TYPE_DEFAULT];
1802
1788
set->map[HCTX_TYPE_READ].queue_offset = 0;
1803
1789
}
1804
1790
blk_mq_rdma_map_queues(&set->map[HCTX_TYPE_DEFAULT],
···
1817
1781
blk_mq_rdma_map_queues(&set->map[HCTX_TYPE_READ],
1818
1782
ctrl->device->dev, 0);
1819
1783
1820
-
if (ctrl->ctrl.opts->nr_poll_queues) {
1784
+
if (opts->nr_poll_queues && ctrl->io_queues[HCTX_TYPE_POLL]) {
1785
+
/* map dedicated poll queues only if we have queues left */
1821
1786
set->map[HCTX_TYPE_POLL].nr_queues =
1822
1787
ctrl->io_queues[HCTX_TYPE_POLL];
1823
1788
set->map[HCTX_TYPE_POLL].queue_offset =
1824
-
ctrl->io_queues[HCTX_TYPE_DEFAULT];
1825
-
if (ctrl->ctrl.opts->nr_write_queues)
1826
-
set->map[HCTX_TYPE_POLL].queue_offset +=
1827
-
ctrl->io_queues[HCTX_TYPE_READ];
1789
+
ctrl->io_queues[HCTX_TYPE_DEFAULT] +
1790
+
ctrl->io_queues[HCTX_TYPE_READ];
1828
1791
blk_mq_map_queues(&set->map[HCTX_TYPE_POLL]);
1829
1792
}
1793
+
1794
+
dev_info(ctrl->ctrl.device,
1795
+
"mapped %d/%d/%d default/read/poll queues.\n",
1796
+
ctrl->io_queues[HCTX_TYPE_DEFAULT],
1797
+
ctrl->io_queues[HCTX_TYPE_READ],
1798
+
ctrl->io_queues[HCTX_TYPE_POLL]);
1799
+
1830
1800
return 0;
1831
1801
}
1832
1802
+50
-7
drivers/nvme/host/tcp.c
+50
-7
drivers/nvme/host/tcp.c
···
111
111
struct work_struct err_work;
112
112
struct delayed_work connect_work;
113
113
struct nvme_tcp_request async_req;
114
+
u32 io_queues[HCTX_MAX_TYPES];
114
115
};
115
116
116
117
static LIST_HEAD(nvme_tcp_ctrl_list);
···
1565
1564
return nr_io_queues;
1566
1565
}
1567
1566
1567
+
static void nvme_tcp_set_io_queues(struct nvme_ctrl *nctrl,
1568
+
unsigned int nr_io_queues)
1569
+
{
1570
+
struct nvme_tcp_ctrl *ctrl = to_tcp_ctrl(nctrl);
1571
+
struct nvmf_ctrl_options *opts = nctrl->opts;
1572
+
1573
+
if (opts->nr_write_queues && opts->nr_io_queues < nr_io_queues) {
1574
+
/*
1575
+
* separate read/write queues
1576
+
* hand out dedicated default queues only after we have
1577
+
* sufficient read queues.
1578
+
*/
1579
+
ctrl->io_queues[HCTX_TYPE_READ] = opts->nr_io_queues;
1580
+
nr_io_queues -= ctrl->io_queues[HCTX_TYPE_READ];
1581
+
ctrl->io_queues[HCTX_TYPE_DEFAULT] =
1582
+
min(opts->nr_write_queues, nr_io_queues);
1583
+
nr_io_queues -= ctrl->io_queues[HCTX_TYPE_DEFAULT];
1584
+
} else {
1585
+
/*
1586
+
* shared read/write queues
1587
+
* either no write queues were requested, or we don't have
1588
+
* sufficient queue count to have dedicated default queues.
1589
+
*/
1590
+
ctrl->io_queues[HCTX_TYPE_DEFAULT] =
1591
+
min(opts->nr_io_queues, nr_io_queues);
1592
+
nr_io_queues -= ctrl->io_queues[HCTX_TYPE_DEFAULT];
1593
+
}
1594
+
}
1595
+
1568
1596
static int nvme_tcp_alloc_io_queues(struct nvme_ctrl *ctrl)
1569
1597
{
1570
1598
unsigned int nr_io_queues;
···
1610
1580
1611
1581
dev_info(ctrl->device,
1612
1582
"creating %d I/O queues.\n", nr_io_queues);
1583
+
1584
+
nvme_tcp_set_io_queues(ctrl, nr_io_queues);
1613
1585
1614
1586
return __nvme_tcp_alloc_io_queues(ctrl);
1615
1587
}
···
2121
2089
static int nvme_tcp_map_queues(struct blk_mq_tag_set *set)
2122
2090
{
2123
2091
struct nvme_tcp_ctrl *ctrl = set->driver_data;
2092
+
struct nvmf_ctrl_options *opts = ctrl->ctrl.opts;
2124
2093
2125
-
set->map[HCTX_TYPE_DEFAULT].queue_offset = 0;
2126
-
set->map[HCTX_TYPE_READ].nr_queues = ctrl->ctrl.opts->nr_io_queues;
2127
-
if (ctrl->ctrl.opts->nr_write_queues) {
2094
+
if (opts->nr_write_queues && ctrl->io_queues[HCTX_TYPE_READ]) {
2128
2095
/* separate read/write queues */
2129
2096
set->map[HCTX_TYPE_DEFAULT].nr_queues =
2130
-
ctrl->ctrl.opts->nr_write_queues;
2097
+
ctrl->io_queues[HCTX_TYPE_DEFAULT];
2098
+
set->map[HCTX_TYPE_DEFAULT].queue_offset = 0;
2099
+
set->map[HCTX_TYPE_READ].nr_queues =
2100
+
ctrl->io_queues[HCTX_TYPE_READ];
2131
2101
set->map[HCTX_TYPE_READ].queue_offset =
2132
-
ctrl->ctrl.opts->nr_write_queues;
2102
+
ctrl->io_queues[HCTX_TYPE_DEFAULT];
2133
2103
} else {
2134
-
/* mixed read/write queues */
2104
+
/* shared read/write queues */
2135
2105
set->map[HCTX_TYPE_DEFAULT].nr_queues =
2136
-
ctrl->ctrl.opts->nr_io_queues;
2106
+
ctrl->io_queues[HCTX_TYPE_DEFAULT];
2107
+
set->map[HCTX_TYPE_DEFAULT].queue_offset = 0;
2108
+
set->map[HCTX_TYPE_READ].nr_queues =
2109
+
ctrl->io_queues[HCTX_TYPE_DEFAULT];
2137
2110
set->map[HCTX_TYPE_READ].queue_offset = 0;
2138
2111
}
2139
2112
blk_mq_map_queues(&set->map[HCTX_TYPE_DEFAULT]);
2140
2113
blk_mq_map_queues(&set->map[HCTX_TYPE_READ]);
2114
+
2115
+
dev_info(ctrl->ctrl.device,
2116
+
"mapped %d/%d default/read queues.\n",
2117
+
ctrl->io_queues[HCTX_TYPE_DEFAULT],
2118
+
ctrl->io_queues[HCTX_TYPE_READ]);
2119
+
2141
2120
return 0;
2142
2121
}
2143
2122
+1
drivers/nvme/target/io-cmd-bdev.c
+1
drivers/nvme/target/io-cmd-bdev.c
+3
include/linux/cgroup-defs.h
+3
include/linux/cgroup-defs.h
···
106
106
CFTYPE_WORLD_WRITABLE = (1 << 4), /* (DON'T USE FOR NEW FILES) S_IWUGO */
107
107
CFTYPE_DEBUG = (1 << 5), /* create when cgroup_debug */
108
108
109
+
CFTYPE_SYMLINKED = (1 << 6), /* pointed to by symlink too */
110
+
109
111
/* internal flags, do not use outside cgroup core proper */
110
112
__CFTYPE_ONLY_ON_DFL = (1 << 16), /* only on default hierarchy */
111
113
__CFTYPE_NOT_ON_DFL = (1 << 17), /* not on default hierarchy */
···
545
543
* end of cftype array.
546
544
*/
547
545
char name[MAX_CFTYPE_NAME];
546
+
char link_name[MAX_CFTYPE_NAME];
548
547
unsigned long private;
549
548
550
549
/*
+29
-4
kernel/cgroup/cgroup.c
+29
-4
kernel/cgroup/cgroup.c
···
1460
1460
1461
1461
static struct kernfs_syscall_ops cgroup_kf_syscall_ops;
1462
1462
1463
-
static char *cgroup_file_name(struct cgroup *cgrp, const struct cftype *cft,
1464
-
char *buf)
1463
+
static char *cgroup_fill_name(struct cgroup *cgrp, const struct cftype *cft,
1464
+
char *buf, bool write_link_name)
1465
1465
{
1466
1466
struct cgroup_subsys *ss = cft->ss;
1467
1467
···
1471
1471
1472
1472
snprintf(buf, CGROUP_FILE_NAME_MAX, "%s%s.%s",
1473
1473
dbg, cgroup_on_dfl(cgrp) ? ss->name : ss->legacy_name,
1474
-
cft->name);
1474
+
write_link_name ? cft->link_name : cft->name);
1475
1475
} else {
1476
-
strscpy(buf, cft->name, CGROUP_FILE_NAME_MAX);
1476
+
strscpy(buf, write_link_name ? cft->link_name : cft->name,
1477
+
CGROUP_FILE_NAME_MAX);
1477
1478
}
1478
1479
return buf;
1480
+
}
1481
+
1482
+
static char *cgroup_file_name(struct cgroup *cgrp, const struct cftype *cft,
1483
+
char *buf)
1484
+
{
1485
+
return cgroup_fill_name(cgrp, cft, buf, false);
1486
+
}
1487
+
1488
+
static char *cgroup_link_name(struct cgroup *cgrp, const struct cftype *cft,
1489
+
char *buf)
1490
+
{
1491
+
return cgroup_fill_name(cgrp, cft, buf, true);
1479
1492
}
1480
1493
1481
1494
/**
···
1649
1636
}
1650
1637
1651
1638
kernfs_remove_by_name(cgrp->kn, cgroup_file_name(cgrp, cft, name));
1639
+
if (cft->flags & CFTYPE_SYMLINKED)
1640
+
kernfs_remove_by_name(cgrp->kn,
1641
+
cgroup_link_name(cgrp, cft, name));
1652
1642
}
1653
1643
1654
1644
/**
···
3837
3821
{
3838
3822
char name[CGROUP_FILE_NAME_MAX];
3839
3823
struct kernfs_node *kn;
3824
+
struct kernfs_node *kn_link;
3840
3825
struct lock_class_key *key = NULL;
3841
3826
int ret;
3842
3827
···
3866
3849
spin_lock_irq(&cgroup_file_kn_lock);
3867
3850
cfile->kn = kn;
3868
3851
spin_unlock_irq(&cgroup_file_kn_lock);
3852
+
}
3853
+
3854
+
if (cft->flags & CFTYPE_SYMLINKED) {
3855
+
kn_link = kernfs_create_link(cgrp->kn,
3856
+
cgroup_link_name(cgrp, cft, name),
3857
+
kn);
3858
+
if (IS_ERR(kn_link))
3859
+
return PTR_ERR(kn_link);
3869
3860
}
3870
3861
3871
3862
return 0;