Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'for-linus-2019-08-17' of git://git.kernel.dk/linux-block
Pull block fixes from Jens Axboe:
"A collection of fixes that should go into this series. This contains:
- Revert of the REQ_NOWAIT_INLINE and associated dio changes. There
were still corner cases there, and even though I had a solution for
it, it's too involved for this stage. (me)
- Set of NVMe fixes (via Sagi)
- io_uring fix for fixed buffers (Anthony)
- io_uring defer issue fix (Jackie)
- Regression fix for queue sync at exit time (zhengbin)
- xen blk-back memory leak fix (Wenwen)"
* tag 'for-linus-2019-08-17' of git://git.kernel.dk/linux-block:
io_uring: fix an issue when IOSQE_IO_LINK is inserted into defer list
block: remove REQ_NOWAIT_INLINE
io_uring: fix manual setup of iov_iter for fixed buffers
xen/blkback: fix memory leaks
blk-mq: move cancel of requeue_work to the front of blk_exit_queue
nvme-pci: Fix async probe remove race
nvme: fix controller removal race with scan work
nvme-rdma: fix possible use-after-free in connect error flow
nvme: fix a possible deadlock when passthru commands sent to a multipath device
nvme-core: Fix extra device_put() call on error path
nvmet-file: fix nvmet_file_flush() always returning an error
nvmet-loop: Flush nvme_delete_wq when removing the port
nvmet: Fix use-after-free bug when a port is removed
nvme-multipath: revalidate nvme_ns_head gendisk in nvme_validate_ns
+167
-84
+2
-8
block/blk-mq.c
+2
-8
block/blk-mq.c
···
1958
1958
rq = blk_mq_get_request(q, bio, &data);
1959
1959
if (unlikely(!rq)) {
1960
1960
rq_qos_cleanup(q, bio);
1961
-
1962
-
cookie = BLK_QC_T_NONE;
1963
-
if (bio->bi_opf & REQ_NOWAIT_INLINE)
1964
-
cookie = BLK_QC_T_EAGAIN;
1965
-
else if (bio->bi_opf & REQ_NOWAIT)
1961
+
if (bio->bi_opf & REQ_NOWAIT)
1966
1962
bio_wouldblock_error(bio);
1967
-
return cookie;
1963
+
return BLK_QC_T_NONE;
1968
1964
}
1969
1965
1970
1966
trace_block_getrq(q, bio, bio->bi_opf);
···
2661
2665
{
2662
2666
struct blk_mq_hw_ctx *hctx, *next;
2663
2667
int i;
2664
-
2665
-
cancel_delayed_work_sync(&q->requeue_work);
2666
2668
2667
2669
queue_for_each_hw_ctx(q, hctx, i)
2668
2670
WARN_ON_ONCE(hctx && list_empty(&hctx->hctx_list));
+3
block/blk-sysfs.c
+3
block/blk-sysfs.c
+3
-3
drivers/block/xen-blkback/xenbus.c
+3
-3
drivers/block/xen-blkback/xenbus.c
···
965
965
}
966
966
}
967
967
968
+
err = -ENOMEM;
968
969
for (i = 0; i < nr_grefs * XEN_BLKIF_REQS_PER_PAGE; i++) {
969
970
req = kzalloc(sizeof(*req), GFP_KERNEL);
970
971
if (!req)
···
988
987
err = xen_blkif_map(ring, ring_ref, nr_grefs, evtchn);
989
988
if (err) {
990
989
xenbus_dev_fatal(dev, err, "mapping ring-ref port %u", evtchn);
991
-
return err;
990
+
goto fail;
992
991
}
993
992
994
993
return 0;
···
1008
1007
}
1009
1008
kfree(req);
1010
1009
}
1011
-
return -ENOMEM;
1012
-
1010
+
return err;
1013
1011
}
1014
1012
1015
1013
static int connect_ring(struct backend_info *be)
+14
-1
drivers/nvme/host/core.c
+14
-1
drivers/nvme/host/core.c
···
1286
1286
*/
1287
1287
if (effects & (NVME_CMD_EFFECTS_LBCC | NVME_CMD_EFFECTS_CSE_MASK)) {
1288
1288
mutex_lock(&ctrl->scan_lock);
1289
+
mutex_lock(&ctrl->subsys->lock);
1290
+
nvme_mpath_start_freeze(ctrl->subsys);
1291
+
nvme_mpath_wait_freeze(ctrl->subsys);
1289
1292
nvme_start_freeze(ctrl);
1290
1293
nvme_wait_freeze(ctrl);
1291
1294
}
···
1319
1316
nvme_update_formats(ctrl);
1320
1317
if (effects & (NVME_CMD_EFFECTS_LBCC | NVME_CMD_EFFECTS_CSE_MASK)) {
1321
1318
nvme_unfreeze(ctrl);
1319
+
nvme_mpath_unfreeze(ctrl->subsys);
1320
+
mutex_unlock(&ctrl->subsys->lock);
1322
1321
mutex_unlock(&ctrl->scan_lock);
1323
1322
}
1324
1323
if (effects & NVME_CMD_EFFECTS_CCC)
···
1720
1715
if (ns->head->disk) {
1721
1716
nvme_update_disk_info(ns->head->disk, ns, id);
1722
1717
blk_queue_stack_limits(ns->head->disk->queue, ns->queue);
1718
+
revalidate_disk(ns->head->disk);
1723
1719
}
1724
1720
#endif
1725
1721
}
···
2493
2487
if (ret) {
2494
2488
dev_err(ctrl->device,
2495
2489
"failed to register subsystem device.\n");
2490
+
put_device(&subsys->dev);
2496
2491
goto out_unlock;
2497
2492
}
2498
2493
ida_init(&subsys->ns_ida);
···
2516
2509
nvme_put_subsystem(subsys);
2517
2510
out_unlock:
2518
2511
mutex_unlock(&nvme_subsystems_lock);
2519
-
put_device(&subsys->dev);
2520
2512
return ret;
2521
2513
}
2522
2514
···
3576
3570
{
3577
3571
struct nvme_ns *ns, *next;
3578
3572
LIST_HEAD(ns_list);
3573
+
3574
+
/*
3575
+
* make sure to requeue I/O to all namespaces as these
3576
+
* might result from the scan itself and must complete
3577
+
* for the scan_work to make progress
3578
+
*/
3579
+
nvme_mpath_clear_ctrl_paths(ctrl);
3579
3580
3580
3581
/* prevent racing with ns scanning */
3581
3582
flush_work(&ctrl->scan_work);
+70
-6
drivers/nvme/host/multipath.c
+70
-6
drivers/nvme/host/multipath.c
···
12
12
MODULE_PARM_DESC(multipath,
13
13
"turn on native support for multiple controllers per subsystem");
14
14
15
+
void nvme_mpath_unfreeze(struct nvme_subsystem *subsys)
16
+
{
17
+
struct nvme_ns_head *h;
18
+
19
+
lockdep_assert_held(&subsys->lock);
20
+
list_for_each_entry(h, &subsys->nsheads, entry)
21
+
if (h->disk)
22
+
blk_mq_unfreeze_queue(h->disk->queue);
23
+
}
24
+
25
+
void nvme_mpath_wait_freeze(struct nvme_subsystem *subsys)
26
+
{
27
+
struct nvme_ns_head *h;
28
+
29
+
lockdep_assert_held(&subsys->lock);
30
+
list_for_each_entry(h, &subsys->nsheads, entry)
31
+
if (h->disk)
32
+
blk_mq_freeze_queue_wait(h->disk->queue);
33
+
}
34
+
35
+
void nvme_mpath_start_freeze(struct nvme_subsystem *subsys)
36
+
{
37
+
struct nvme_ns_head *h;
38
+
39
+
lockdep_assert_held(&subsys->lock);
40
+
list_for_each_entry(h, &subsys->nsheads, entry)
41
+
if (h->disk)
42
+
blk_freeze_queue_start(h->disk->queue);
43
+
}
44
+
15
45
/*
16
46
* If multipathing is enabled we need to always use the subsystem instance
17
47
* number for numbering our devices to avoid conflicts between subsystems that
···
134
104
[NVME_ANA_CHANGE] = "change",
135
105
};
136
106
137
-
void nvme_mpath_clear_current_path(struct nvme_ns *ns)
107
+
bool nvme_mpath_clear_current_path(struct nvme_ns *ns)
138
108
{
139
109
struct nvme_ns_head *head = ns->head;
110
+
bool changed = false;
140
111
int node;
141
112
142
113
if (!head)
143
-
return;
114
+
goto out;
144
115
145
116
for_each_node(node) {
146
-
if (ns == rcu_access_pointer(head->current_path[node]))
117
+
if (ns == rcu_access_pointer(head->current_path[node])) {
147
118
rcu_assign_pointer(head->current_path[node], NULL);
119
+
changed = true;
120
+
}
148
121
}
122
+
out:
123
+
return changed;
124
+
}
125
+
126
+
void nvme_mpath_clear_ctrl_paths(struct nvme_ctrl *ctrl)
127
+
{
128
+
struct nvme_ns *ns;
129
+
130
+
mutex_lock(&ctrl->scan_lock);
131
+
list_for_each_entry(ns, &ctrl->namespaces, list)
132
+
if (nvme_mpath_clear_current_path(ns))
133
+
kblockd_schedule_work(&ns->head->requeue_work);
134
+
mutex_unlock(&ctrl->scan_lock);
149
135
}
150
136
151
137
static bool nvme_path_is_disabled(struct nvme_ns *ns)
···
272
226
return ns;
273
227
}
274
228
229
+
static bool nvme_available_path(struct nvme_ns_head *head)
230
+
{
231
+
struct nvme_ns *ns;
232
+
233
+
list_for_each_entry_rcu(ns, &head->list, siblings) {
234
+
switch (ns->ctrl->state) {
235
+
case NVME_CTRL_LIVE:
236
+
case NVME_CTRL_RESETTING:
237
+
case NVME_CTRL_CONNECTING:
238
+
/* fallthru */
239
+
return true;
240
+
default:
241
+
break;
242
+
}
243
+
}
244
+
return false;
245
+
}
246
+
275
247
static blk_qc_t nvme_ns_head_make_request(struct request_queue *q,
276
248
struct bio *bio)
277
249
{
···
316
252
disk_devt(ns->head->disk),
317
253
bio->bi_iter.bi_sector);
318
254
ret = direct_make_request(bio);
319
-
} else if (!list_empty_careful(&head->list)) {
320
-
dev_warn_ratelimited(dev, "no path available - requeuing I/O\n");
255
+
} else if (nvme_available_path(head)) {
256
+
dev_warn_ratelimited(dev, "no usable path - requeuing I/O\n");
321
257
322
258
spin_lock_irq(&head->requeue_lock);
323
259
bio_list_add(&head->requeue_list, bio);
324
260
spin_unlock_irq(&head->requeue_lock);
325
261
} else {
326
-
dev_warn_ratelimited(dev, "no path - failing I/O\n");
262
+
dev_warn_ratelimited(dev, "no available path - failing I/O\n");
327
263
328
264
bio->bi_status = BLK_STS_IOERR;
329
265
bio_endio(bio);
+19
-2
drivers/nvme/host/nvme.h
+19
-2
drivers/nvme/host/nvme.h
···
490
490
return ctrl->ana_log_buf != NULL;
491
491
}
492
492
493
+
void nvme_mpath_unfreeze(struct nvme_subsystem *subsys);
494
+
void nvme_mpath_wait_freeze(struct nvme_subsystem *subsys);
495
+
void nvme_mpath_start_freeze(struct nvme_subsystem *subsys);
493
496
void nvme_set_disk_name(char *disk_name, struct nvme_ns *ns,
494
497
struct nvme_ctrl *ctrl, int *flags);
495
498
void nvme_failover_req(struct request *req);
···
503
500
int nvme_mpath_init(struct nvme_ctrl *ctrl, struct nvme_id_ctrl *id);
504
501
void nvme_mpath_uninit(struct nvme_ctrl *ctrl);
505
502
void nvme_mpath_stop(struct nvme_ctrl *ctrl);
506
-
void nvme_mpath_clear_current_path(struct nvme_ns *ns);
503
+
bool nvme_mpath_clear_current_path(struct nvme_ns *ns);
504
+
void nvme_mpath_clear_ctrl_paths(struct nvme_ctrl *ctrl);
507
505
struct nvme_ns *nvme_find_path(struct nvme_ns_head *head);
508
506
509
507
static inline void nvme_mpath_check_last_path(struct nvme_ns *ns)
···
552
548
static inline void nvme_mpath_remove_disk(struct nvme_ns_head *head)
553
549
{
554
550
}
555
-
static inline void nvme_mpath_clear_current_path(struct nvme_ns *ns)
551
+
static inline bool nvme_mpath_clear_current_path(struct nvme_ns *ns)
552
+
{
553
+
return false;
554
+
}
555
+
static inline void nvme_mpath_clear_ctrl_paths(struct nvme_ctrl *ctrl)
556
556
{
557
557
}
558
558
static inline void nvme_mpath_check_last_path(struct nvme_ns *ns)
···
574
566
{
575
567
}
576
568
static inline void nvme_mpath_stop(struct nvme_ctrl *ctrl)
569
+
{
570
+
}
571
+
static inline void nvme_mpath_unfreeze(struct nvme_subsystem *subsys)
572
+
{
573
+
}
574
+
static inline void nvme_mpath_wait_freeze(struct nvme_subsystem *subsys)
575
+
{
576
+
}
577
+
static inline void nvme_mpath_start_freeze(struct nvme_subsystem *subsys)
577
578
{
578
579
}
579
580
#endif /* CONFIG_NVME_MULTIPATH */
+2
-1
drivers/nvme/host/pci.c
+2
-1
drivers/nvme/host/pci.c
···
2695
2695
{
2696
2696
struct nvme_dev *dev = data;
2697
2697
2698
-
nvme_reset_ctrl_sync(&dev->ctrl);
2698
+
flush_work(&dev->ctrl.reset_work);
2699
2699
flush_work(&dev->ctrl.scan_work);
2700
2700
nvme_put_ctrl(&dev->ctrl);
2701
2701
}
···
2761
2761
2762
2762
dev_info(dev->ctrl.device, "pci function %s\n", dev_name(&pdev->dev));
2763
2763
2764
+
nvme_reset_ctrl(&dev->ctrl);
2764
2765
nvme_get_ctrl(&dev->ctrl);
2765
2766
async_schedule(nvme_async_probe, dev);
2766
2767
+11
-5
drivers/nvme/host/rdma.c
+11
-5
drivers/nvme/host/rdma.c
···
562
562
return ret;
563
563
}
564
564
565
+
static void __nvme_rdma_stop_queue(struct nvme_rdma_queue *queue)
566
+
{
567
+
rdma_disconnect(queue->cm_id);
568
+
ib_drain_qp(queue->qp);
569
+
}
570
+
565
571
static void nvme_rdma_stop_queue(struct nvme_rdma_queue *queue)
566
572
{
567
573
if (!test_and_clear_bit(NVME_RDMA_Q_LIVE, &queue->flags))
568
574
return;
569
-
570
-
rdma_disconnect(queue->cm_id);
571
-
ib_drain_qp(queue->qp);
575
+
__nvme_rdma_stop_queue(queue);
572
576
}
573
577
574
578
static void nvme_rdma_free_queue(struct nvme_rdma_queue *queue)
···
611
607
else
612
608
ret = nvmf_connect_admin_queue(&ctrl->ctrl);
613
609
614
-
if (!ret)
610
+
if (!ret) {
615
611
set_bit(NVME_RDMA_Q_LIVE, &queue->flags);
616
-
else
612
+
} else {
613
+
__nvme_rdma_stop_queue(queue);
617
614
dev_info(ctrl->ctrl.device,
618
615
"failed to connect queue: %d ret=%d\n", idx, ret);
616
+
}
619
617
return ret;
620
618
}
621
619
+1
drivers/nvme/target/configfs.c
+1
drivers/nvme/target/configfs.c
+15
drivers/nvme/target/core.c
+15
drivers/nvme/target/core.c
···
46
46
u16 status;
47
47
48
48
switch (errno) {
49
+
case 0:
50
+
status = NVME_SC_SUCCESS;
51
+
break;
49
52
case -ENOSPC:
50
53
req->error_loc = offsetof(struct nvme_rw_command, length);
51
54
status = NVME_SC_CAP_EXCEEDED | NVME_SC_DNR;
···
282
279
up_write(&nvmet_config_sem);
283
280
}
284
281
EXPORT_SYMBOL_GPL(nvmet_unregister_transport);
282
+
283
+
void nvmet_port_del_ctrls(struct nvmet_port *port, struct nvmet_subsys *subsys)
284
+
{
285
+
struct nvmet_ctrl *ctrl;
286
+
287
+
mutex_lock(&subsys->lock);
288
+
list_for_each_entry(ctrl, &subsys->ctrls, subsys_entry) {
289
+
if (ctrl->port == port)
290
+
ctrl->ops->delete_ctrl(ctrl);
291
+
}
292
+
mutex_unlock(&subsys->lock);
293
+
}
285
294
286
295
int nvmet_enable_port(struct nvmet_port *port)
287
296
{
+8
drivers/nvme/target/loop.c
+8
drivers/nvme/target/loop.c
···
654
654
mutex_lock(&nvme_loop_ports_mutex);
655
655
list_del_init(&port->entry);
656
656
mutex_unlock(&nvme_loop_ports_mutex);
657
+
658
+
/*
659
+
* Ensure any ctrls that are in the process of being
660
+
* deleted are in fact deleted before we return
661
+
* and free the port. This is to prevent active
662
+
* ctrls from using a port after it's freed.
663
+
*/
664
+
flush_workqueue(nvme_delete_wq);
657
665
}
658
666
659
667
static const struct nvmet_fabrics_ops nvme_loop_ops = {
+3
drivers/nvme/target/nvmet.h
+3
drivers/nvme/target/nvmet.h
···
418
418
int nvmet_register_transport(const struct nvmet_fabrics_ops *ops);
419
419
void nvmet_unregister_transport(const struct nvmet_fabrics_ops *ops);
420
420
421
+
void nvmet_port_del_ctrls(struct nvmet_port *port,
422
+
struct nvmet_subsys *subsys);
423
+
421
424
int nvmet_enable_port(struct nvmet_port *port);
422
425
void nvmet_disable_port(struct nvmet_port *port);
423
426
+5
-44
fs/block_dev.c
+5
-44
fs/block_dev.c
···
345
345
struct bio *bio;
346
346
bool is_poll = (iocb->ki_flags & IOCB_HIPRI) != 0;
347
347
bool is_read = (iov_iter_rw(iter) == READ), is_sync;
348
-
bool nowait = (iocb->ki_flags & IOCB_NOWAIT) != 0;
349
348
loff_t pos = iocb->ki_pos;
350
349
blk_qc_t qc = BLK_QC_T_NONE;
351
-
gfp_t gfp;
352
-
int ret;
350
+
int ret = 0;
353
351
354
352
if ((pos | iov_iter_alignment(iter)) &
355
353
(bdev_logical_block_size(bdev) - 1))
356
354
return -EINVAL;
357
355
358
-
if (nowait)
359
-
gfp = GFP_NOWAIT;
360
-
else
361
-
gfp = GFP_KERNEL;
362
-
363
-
bio = bio_alloc_bioset(gfp, nr_pages, &blkdev_dio_pool);
364
-
if (!bio)
365
-
return -EAGAIN;
356
+
bio = bio_alloc_bioset(GFP_KERNEL, nr_pages, &blkdev_dio_pool);
366
357
367
358
dio = container_of(bio, struct blkdev_dio, bio);
368
359
dio->is_sync = is_sync = is_sync_kiocb(iocb);
···
375
384
if (!is_poll)
376
385
blk_start_plug(&plug);
377
386
378
-
ret = 0;
379
387
for (;;) {
380
388
bio_set_dev(bio, bdev);
381
389
bio->bi_iter.bi_sector = pos >> 9;
···
399
409
task_io_account_write(bio->bi_iter.bi_size);
400
410
}
401
411
402
-
/*
403
-
* Tell underlying layer to not block for resource shortage.
404
-
* And if we would have blocked, return error inline instead
405
-
* of through the bio->bi_end_io() callback.
406
-
*/
407
-
if (nowait)
408
-
bio->bi_opf |= (REQ_NOWAIT | REQ_NOWAIT_INLINE);
409
-
412
+
dio->size += bio->bi_iter.bi_size;
410
413
pos += bio->bi_iter.bi_size;
411
414
412
415
nr_pages = iov_iter_npages(iter, BIO_MAX_PAGES);
···
411
428
polled = true;
412
429
}
413
430
414
-
dio->size += bio->bi_iter.bi_size;
415
431
qc = submit_bio(bio);
416
-
if (qc == BLK_QC_T_EAGAIN) {
417
-
dio->size -= bio->bi_iter.bi_size;
418
-
ret = -EAGAIN;
419
-
goto error;
420
-
}
421
432
422
433
if (polled)
423
434
WRITE_ONCE(iocb->ki_cookie, qc);
···
432
455
atomic_inc(&dio->ref);
433
456
}
434
457
435
-
dio->size += bio->bi_iter.bi_size;
436
-
qc = submit_bio(bio);
437
-
if (qc == BLK_QC_T_EAGAIN) {
438
-
dio->size -= bio->bi_iter.bi_size;
439
-
ret = -EAGAIN;
440
-
goto error;
441
-
}
442
-
443
-
bio = bio_alloc(gfp, nr_pages);
444
-
if (!bio) {
445
-
ret = -EAGAIN;
446
-
goto error;
447
-
}
458
+
submit_bio(bio);
459
+
bio = bio_alloc(GFP_KERNEL, nr_pages);
448
460
}
449
461
450
462
if (!is_poll)
···
453
487
}
454
488
__set_current_state(TASK_RUNNING);
455
489
456
-
out:
457
490
if (!ret)
458
491
ret = blk_status_to_errno(dio->bio.bi_status);
459
492
if (likely(!ret))
···
460
495
461
496
bio_put(&dio->bio);
462
497
return ret;
463
-
error:
464
-
if (!is_poll)
465
-
blk_finish_plug(&plug);
466
-
goto out;
467
498
}
468
499
469
500
static ssize_t
+10
-10
fs/io_uring.c
+10
-10
fs/io_uring.c
···
1097
1097
1098
1098
iter->bvec = bvec + seg_skip;
1099
1099
iter->nr_segs -= seg_skip;
1100
-
iter->count -= (seg_skip << PAGE_SHIFT);
1100
+
iter->count -= bvec->bv_len + offset;
1101
1101
iter->iov_offset = offset & ~PAGE_MASK;
1102
-
if (iter->iov_offset)
1103
-
iter->count -= iter->iov_offset;
1104
1102
}
1105
1103
}
1106
1104
···
2023
2025
{
2024
2026
int ret;
2025
2027
2028
+
ret = io_req_defer(ctx, req, s->sqe);
2029
+
if (ret) {
2030
+
if (ret != -EIOCBQUEUED) {
2031
+
io_free_req(req);
2032
+
io_cqring_add_event(ctx, s->sqe->user_data, ret);
2033
+
}
2034
+
return 0;
2035
+
}
2036
+
2026
2037
ret = __io_submit_sqe(ctx, req, s, true);
2027
2038
if (ret == -EAGAIN && !(req->flags & REQ_F_NOWAIT)) {
2028
2039
struct io_uring_sqe *sqe_copy;
···
2101
2094
io_free_req(req);
2102
2095
err:
2103
2096
io_cqring_add_event(ctx, s->sqe->user_data, ret);
2104
-
return;
2105
-
}
2106
-
2107
-
ret = io_req_defer(ctx, req, s->sqe);
2108
-
if (ret) {
2109
-
if (ret != -EIOCBQUEUED)
2110
-
goto err_req;
2111
2097
return;
2112
2098
}
2113
2099
+1
-4
include/linux/blk_types.h
+1
-4
include/linux/blk_types.h
···
311
311
__REQ_RAHEAD, /* read ahead, can fail anytime */
312
312
__REQ_BACKGROUND, /* background IO */
313
313
__REQ_NOWAIT, /* Don't wait if request will block */
314
-
__REQ_NOWAIT_INLINE, /* Return would-block error inline */
315
314
/*
316
315
* When a shared kthread needs to issue a bio for a cgroup, doing
317
316
* so synchronously can lead to priority inversions as the kthread
···
345
346
#define REQ_RAHEAD (1ULL << __REQ_RAHEAD)
346
347
#define REQ_BACKGROUND (1ULL << __REQ_BACKGROUND)
347
348
#define REQ_NOWAIT (1ULL << __REQ_NOWAIT)
348
-
#define REQ_NOWAIT_INLINE (1ULL << __REQ_NOWAIT_INLINE)
349
349
#define REQ_CGROUP_PUNT (1ULL << __REQ_CGROUP_PUNT)
350
350
351
351
#define REQ_NOUNMAP (1ULL << __REQ_NOUNMAP)
···
418
420
419
421
typedef unsigned int blk_qc_t;
420
422
#define BLK_QC_T_NONE -1U
421
-
#define BLK_QC_T_EAGAIN -2U
422
423
#define BLK_QC_T_SHIFT 16
423
424
#define BLK_QC_T_INTERNAL (1U << 31)
424
425
425
426
static inline bool blk_qc_t_valid(blk_qc_t cookie)
426
427
{
427
-
return cookie != BLK_QC_T_NONE && cookie != BLK_QC_T_EAGAIN;
428
+
return cookie != BLK_QC_T_NONE;
428
429
}
429
430
430
431
static inline unsigned int blk_qc_t_to_queue_num(blk_qc_t cookie)