Merge tag 'block-5.6-2020-02-28' of git://git.kernel.dk/linux-block

+1 -1

block/blk-flush.c

··· 412 412 */ 413 413 if ((policy & REQ_FSEQ_DATA) && 414 414 !(policy & (REQ_FSEQ_PREFLUSH | REQ_FSEQ_POSTFLUSH))) { 415 - blk_mq_request_bypass_insert(rq, false); 415 + blk_mq_request_bypass_insert(rq, false, false); 416 416 return; 417 417 } 418 418

+15 -7

block/blk-mq-sched.c

··· 361 361 bool has_sched, 362 362 struct request *rq) 363 363 { 364 - /* dispatch flush rq directly */ 365 - if (rq->rq_flags & RQF_FLUSH_SEQ) { 366 - spin_lock(&hctx->lock); 367 - list_add(&rq->queuelist, &hctx->dispatch); 368 - spin_unlock(&hctx->lock); 364 + /* 365 + * dispatch flush and passthrough rq directly 366 + * 367 + * passthrough request has to be added to hctx->dispatch directly. 368 + * For some reason, device may be in one situation which can't 369 + * handle FS request, so STS_RESOURCE is always returned and the 370 + * FS request will be added to hctx->dispatch. However passthrough 371 + * request may be required at that time for fixing the problem. If 372 + * passthrough request is added to scheduler queue, there isn't any 373 + * chance to dispatch it given we prioritize requests in hctx->dispatch. 374 + */ 375 + if ((rq->rq_flags & RQF_FLUSH_SEQ) || blk_rq_is_passthrough(rq)) 369 376 return true; 370 - } 371 377 372 378 if (has_sched) 373 379 rq->rq_flags |= RQF_SORTED; ··· 397 391 398 392 WARN_ON(e && (rq->tag != -1)); 399 393 400 - if (blk_mq_sched_bypass_insert(hctx, !!e, rq)) 394 + if (blk_mq_sched_bypass_insert(hctx, !!e, rq)) { 395 + blk_mq_request_bypass_insert(rq, at_head, false); 401 396 goto run; 397 + } 402 398 403 399 if (e && e->type->ops.insert_requests) { 404 400 LIST_HEAD(list);

+2 -2

block/blk-mq-tag.c

··· 183 183 return tag + tag_offset; 184 184 } 185 185 186 - void blk_mq_put_tag(struct blk_mq_hw_ctx *hctx, struct blk_mq_tags *tags, 187 - struct blk_mq_ctx *ctx, unsigned int tag) 186 + void blk_mq_put_tag(struct blk_mq_tags *tags, struct blk_mq_ctx *ctx, 187 + unsigned int tag) 188 188 { 189 189 if (!blk_mq_tag_is_reserved(tags, tag)) { 190 190 const int real_tag = tag - tags->nr_reserved_tags;

+2 -2

block/blk-mq-tag.h

··· 26 26 extern void blk_mq_free_tags(struct blk_mq_tags *tags); 27 27 28 28 extern unsigned int blk_mq_get_tag(struct blk_mq_alloc_data *data); 29 - extern void blk_mq_put_tag(struct blk_mq_hw_ctx *hctx, struct blk_mq_tags *tags, 30 - struct blk_mq_ctx *ctx, unsigned int tag); 29 + extern void blk_mq_put_tag(struct blk_mq_tags *tags, struct blk_mq_ctx *ctx, 30 + unsigned int tag); 31 31 extern int blk_mq_tag_update_depth(struct blk_mq_hw_ctx *hctx, 32 32 struct blk_mq_tags **tags, 33 33 unsigned int depth, bool can_grow);

+15 -13

block/blk-mq.c

··· 477 477 blk_pm_mark_last_busy(rq); 478 478 rq->mq_hctx = NULL; 479 479 if (rq->tag != -1) 480 - blk_mq_put_tag(hctx, hctx->tags, ctx, rq->tag); 480 + blk_mq_put_tag(hctx->tags, ctx, rq->tag); 481 481 if (sched_tag != -1) 482 - blk_mq_put_tag(hctx, hctx->sched_tags, ctx, sched_tag); 482 + blk_mq_put_tag(hctx->sched_tags, ctx, sched_tag); 483 483 blk_mq_sched_restart(hctx); 484 484 blk_queue_exit(q); 485 485 } ··· 735 735 * merge. 736 736 */ 737 737 if (rq->rq_flags & RQF_DONTPREP) 738 - blk_mq_request_bypass_insert(rq, false); 738 + blk_mq_request_bypass_insert(rq, false, false); 739 739 else 740 740 blk_mq_sched_insert_request(rq, true, false, false); 741 741 } ··· 1286 1286 q->mq_ops->commit_rqs(hctx); 1287 1287 1288 1288 spin_lock(&hctx->lock); 1289 - list_splice_init(list, &hctx->dispatch); 1289 + list_splice_tail_init(list, &hctx->dispatch); 1290 1290 spin_unlock(&hctx->lock); 1291 1291 1292 1292 /* ··· 1677 1677 * Should only be used carefully, when the caller knows we want to 1678 1678 * bypass a potential IO scheduler on the target device. 1679 1679 */ 1680 - void blk_mq_request_bypass_insert(struct request *rq, bool run_queue) 1680 + void blk_mq_request_bypass_insert(struct request *rq, bool at_head, 1681 + bool run_queue) 1681 1682 { 1682 1683 struct blk_mq_hw_ctx *hctx = rq->mq_hctx; 1683 1684 1684 1685 spin_lock(&hctx->lock); 1685 - list_add_tail(&rq->queuelist, &hctx->dispatch); 1686 + if (at_head) 1687 + list_add(&rq->queuelist, &hctx->dispatch); 1688 + else 1689 + list_add_tail(&rq->queuelist, &hctx->dispatch); 1686 1690 spin_unlock(&hctx->lock); 1687 1691 1688 1692 if (run_queue) ··· 1853 1849 if (bypass_insert) 1854 1850 return BLK_STS_RESOURCE; 1855 1851 1856 - blk_mq_request_bypass_insert(rq, run_queue); 1852 + blk_mq_request_bypass_insert(rq, false, run_queue); 1857 1853 return BLK_STS_OK; 1858 1854 } 1859 1855 ··· 1880 1876 1881 1877 ret = __blk_mq_try_issue_directly(hctx, rq, cookie, false, true); 1882 1878 if (ret == BLK_STS_RESOURCE || ret == BLK_STS_DEV_RESOURCE) 1883 - blk_mq_request_bypass_insert(rq, true); 1879 + blk_mq_request_bypass_insert(rq, false, true); 1884 1880 else if (ret != BLK_STS_OK) 1885 1881 blk_mq_end_request(rq, ret); 1886 1882 ··· 1914 1910 if (ret != BLK_STS_OK) { 1915 1911 if (ret == BLK_STS_RESOURCE || 1916 1912 ret == BLK_STS_DEV_RESOURCE) { 1917 - blk_mq_request_bypass_insert(rq, 1913 + blk_mq_request_bypass_insert(rq, false, 1918 1914 list_empty(list)); 1919 1915 break; 1920 1916 } ··· 3402 3398 } 3403 3399 3404 3400 static unsigned long blk_mq_poll_nsecs(struct request_queue *q, 3405 - struct blk_mq_hw_ctx *hctx, 3406 3401 struct request *rq) 3407 3402 { 3408 3403 unsigned long ret = 0; ··· 3434 3431 } 3435 3432 3436 3433 static bool blk_mq_poll_hybrid_sleep(struct request_queue *q, 3437 - struct blk_mq_hw_ctx *hctx, 3438 3434 struct request *rq) 3439 3435 { 3440 3436 struct hrtimer_sleeper hs; ··· 3453 3451 if (q->poll_nsec > 0) 3454 3452 nsecs = q->poll_nsec; 3455 3453 else 3456 - nsecs = blk_mq_poll_nsecs(q, hctx, rq); 3454 + nsecs = blk_mq_poll_nsecs(q, rq); 3457 3455 3458 3456 if (!nsecs) 3459 3457 return false; ··· 3508 3506 return false; 3509 3507 } 3510 3508 3511 - return blk_mq_poll_hybrid_sleep(q, hctx, rq); 3509 + return blk_mq_poll_hybrid_sleep(q, rq); 3512 3510 } 3513 3511 3514 3512 /**

+3 -2

block/blk-mq.h

··· 66 66 */ 67 67 void __blk_mq_insert_request(struct blk_mq_hw_ctx *hctx, struct request *rq, 68 68 bool at_head); 69 - void blk_mq_request_bypass_insert(struct request *rq, bool run_queue); 69 + void blk_mq_request_bypass_insert(struct request *rq, bool at_head, 70 + bool run_queue); 70 71 void blk_mq_insert_requests(struct blk_mq_hw_ctx *hctx, struct blk_mq_ctx *ctx, 71 72 struct list_head *list); 72 73 ··· 200 199 static inline void __blk_mq_put_driver_tag(struct blk_mq_hw_ctx *hctx, 201 200 struct request *rq) 202 201 { 203 - blk_mq_put_tag(hctx, hctx->tags, rq->mq_ctx, rq->tag); 202 + blk_mq_put_tag(hctx->tags, rq->mq_ctx, rq->tag); 204 203 rq->tag = -1; 205 204 206 205 if (rq->rq_flags & RQF_MQ_INFLIGHT) {

-3

drivers/block/null_blk.h

··· 14 14 #include <linux/fault-inject.h> 15 15 16 16 struct nullb_cmd { 17 - struct list_head list; 18 - struct llist_node ll_list; 19 - struct __call_single_data csd; 20 17 struct request *rq; 21 18 struct bio *bio; 22 19 unsigned int tag;

-2

drivers/block/null_blk_main.c

··· 1518 1518 1519 1519 for (i = 0; i < nq->queue_depth; i++) { 1520 1520 cmd = &nq->cmds[i]; 1521 - INIT_LIST_HEAD(&cmd->list); 1522 - cmd->ll_list.next = NULL; 1523 1521 cmd->tag = -1U; 1524 1522 } 1525 1523

+1 -1

drivers/nvme/host/pci.c

··· 1078 1078 1079 1079 spin_lock(&nvmeq->cq_poll_lock); 1080 1080 found = nvme_process_cq(nvmeq, &start, &end, -1); 1081 + nvme_complete_cqes(nvmeq, start, end); 1081 1082 spin_unlock(&nvmeq->cq_poll_lock); 1082 1083 1083 - nvme_complete_cqes(nvmeq, start, end); 1084 1084 return found; 1085 1085 } 1086 1086

+1 -1

include/linux/blkdev.h

··· 524 524 unsigned int sg_reserved_size; 525 525 int node; 526 526 #ifdef CONFIG_BLK_DEV_IO_TRACE 527 - struct blk_trace *blk_trace; 527 + struct blk_trace __rcu *blk_trace; 528 528 struct mutex blk_trace_mutex; 529 529 #endif 530 530 /*

+13 -5

include/linux/blktrace_api.h

··· 51 51 **/ 52 52 #define blk_add_cgroup_trace_msg(q, cg, fmt, ...) \ 53 53 do { \ 54 - struct blk_trace *bt = (q)->blk_trace; \ 54 + struct blk_trace *bt; \ 55 + \ 56 + rcu_read_lock(); \ 57 + bt = rcu_dereference((q)->blk_trace); \ 55 58 if (unlikely(bt)) \ 56 59 __trace_note_message(bt, cg, fmt, ##__VA_ARGS__);\ 60 + rcu_read_unlock(); \ 57 61 } while (0) 58 62 #define blk_add_trace_msg(q, fmt, ...) \ 59 63 blk_add_cgroup_trace_msg(q, NULL, fmt, ##__VA_ARGS__) ··· 65 61 66 62 static inline bool blk_trace_note_message_enabled(struct request_queue *q) 67 63 { 68 - struct blk_trace *bt = q->blk_trace; 69 - if (likely(!bt)) 70 - return false; 71 - return bt->act_mask & BLK_TC_NOTIFY; 64 + struct blk_trace *bt; 65 + bool ret; 66 + 67 + rcu_read_lock(); 68 + bt = rcu_dereference(q->blk_trace); 69 + ret = bt && (bt->act_mask & BLK_TC_NOTIFY); 70 + rcu_read_unlock(); 71 + return ret; 72 72 } 73 73 74 74 extern void blk_add_driver_data(struct request_queue *q, struct request *rq,

+83 -31

kernel/trace/blktrace.c

··· 335 335 336 336 static void blk_trace_cleanup(struct blk_trace *bt) 337 337 { 338 + synchronize_rcu(); 338 339 blk_trace_free(bt); 339 340 put_probe_ref(); 340 341 } ··· 630 629 static int __blk_trace_startstop(struct request_queue *q, int start) 631 630 { 632 631 int ret; 633 - struct blk_trace *bt = q->blk_trace; 632 + struct blk_trace *bt; 634 633 634 + bt = rcu_dereference_protected(q->blk_trace, 635 + lockdep_is_held(&q->blk_trace_mutex)); 635 636 if (bt == NULL) 636 637 return -EINVAL; 637 638 ··· 743 740 void blk_trace_shutdown(struct request_queue *q) 744 741 { 745 742 mutex_lock(&q->blk_trace_mutex); 746 - 747 - if (q->blk_trace) { 743 + if (rcu_dereference_protected(q->blk_trace, 744 + lockdep_is_held(&q->blk_trace_mutex))) { 748 745 __blk_trace_startstop(q, 0); 749 746 __blk_trace_remove(q); 750 747 } ··· 755 752 #ifdef CONFIG_BLK_CGROUP 756 753 static u64 blk_trace_bio_get_cgid(struct request_queue *q, struct bio *bio) 757 754 { 758 - struct blk_trace *bt = q->blk_trace; 755 + struct blk_trace *bt; 759 756 757 + /* We don't use the 'bt' value here except as an optimization... */ 758 + bt = rcu_dereference_protected(q->blk_trace, 1); 760 759 if (!bt || !(blk_tracer_flags.val & TRACE_BLK_OPT_CGROUP)) 761 760 return 0; 762 761 ··· 801 796 static void blk_add_trace_rq(struct request *rq, int error, 802 797 unsigned int nr_bytes, u32 what, u64 cgid) 803 798 { 804 - struct blk_trace *bt = rq->q->blk_trace; 799 + struct blk_trace *bt; 805 800 806 - if (likely(!bt)) 801 + rcu_read_lock(); 802 + bt = rcu_dereference(rq->q->blk_trace); 803 + if (likely(!bt)) { 804 + rcu_read_unlock(); 807 805 return; 806 + } 808 807 809 808 if (blk_rq_is_passthrough(rq)) 810 809 what |= BLK_TC_ACT(BLK_TC_PC); ··· 817 808 818 809 __blk_add_trace(bt, blk_rq_trace_sector(rq), nr_bytes, req_op(rq), 819 810 rq->cmd_flags, what, error, 0, NULL, cgid); 811 + rcu_read_unlock(); 820 812 } 821 813 822 814 static void blk_add_trace_rq_insert(void *ignore, ··· 863 853 static void blk_add_trace_bio(struct request_queue *q, struct bio *bio, 864 854 u32 what, int error) 865 855 { 866 - struct blk_trace *bt = q->blk_trace; 856 + struct blk_trace *bt; 867 857 868 - if (likely(!bt)) 858 + rcu_read_lock(); 859 + bt = rcu_dereference(q->blk_trace); 860 + if (likely(!bt)) { 861 + rcu_read_unlock(); 869 862 return; 863 + } 870 864 871 865 __blk_add_trace(bt, bio->bi_iter.bi_sector, bio->bi_iter.bi_size, 872 866 bio_op(bio), bio->bi_opf, what, error, 0, NULL, 873 867 blk_trace_bio_get_cgid(q, bio)); 868 + rcu_read_unlock(); 874 869 } 875 870 876 871 static void blk_add_trace_bio_bounce(void *ignore, ··· 920 905 if (bio) 921 906 blk_add_trace_bio(q, bio, BLK_TA_GETRQ, 0); 922 907 else { 923 - struct blk_trace *bt = q->blk_trace; 908 + struct blk_trace *bt; 924 909 910 + rcu_read_lock(); 911 + bt = rcu_dereference(q->blk_trace); 925 912 if (bt) 926 913 __blk_add_trace(bt, 0, 0, rw, 0, BLK_TA_GETRQ, 0, 0, 927 914 NULL, 0); 915 + rcu_read_unlock(); 928 916 } 929 917 } 930 918 ··· 939 921 if (bio) 940 922 blk_add_trace_bio(q, bio, BLK_TA_SLEEPRQ, 0); 941 923 else { 942 - struct blk_trace *bt = q->blk_trace; 924 + struct blk_trace *bt; 943 925 926 + rcu_read_lock(); 927 + bt = rcu_dereference(q->blk_trace); 944 928 if (bt) 945 929 __blk_add_trace(bt, 0, 0, rw, 0, BLK_TA_SLEEPRQ, 946 930 0, 0, NULL, 0); 931 + rcu_read_unlock(); 947 932 } 948 933 } 949 934 950 935 static void blk_add_trace_plug(void *ignore, struct request_queue *q) 951 936 { 952 - struct blk_trace *bt = q->blk_trace; 937 + struct blk_trace *bt; 953 938 939 + rcu_read_lock(); 940 + bt = rcu_dereference(q->blk_trace); 954 941 if (bt) 955 942 __blk_add_trace(bt, 0, 0, 0, 0, BLK_TA_PLUG, 0, 0, NULL, 0); 943 + rcu_read_unlock(); 956 944 } 957 945 958 946 static void blk_add_trace_unplug(void *ignore, struct request_queue *q, 959 947 unsigned int depth, bool explicit) 960 948 { 961 - struct blk_trace *bt = q->blk_trace; 949 + struct blk_trace *bt; 962 950 951 + rcu_read_lock(); 952 + bt = rcu_dereference(q->blk_trace); 963 953 if (bt) { 964 954 __be64 rpdu = cpu_to_be64(depth); 965 955 u32 what; ··· 979 953 980 954 __blk_add_trace(bt, 0, 0, 0, 0, what, 0, sizeof(rpdu), &rpdu, 0); 981 955 } 956 + rcu_read_unlock(); 982 957 } 983 958 984 959 static void blk_add_trace_split(void *ignore, 985 960 struct request_queue *q, struct bio *bio, 986 961 unsigned int pdu) 987 962 { 988 - struct blk_trace *bt = q->blk_trace; 963 + struct blk_trace *bt; 989 964 965 + rcu_read_lock(); 966 + bt = rcu_dereference(q->blk_trace); 990 967 if (bt) { 991 968 __be64 rpdu = cpu_to_be64(pdu); 992 969 ··· 998 969 BLK_TA_SPLIT, bio->bi_status, sizeof(rpdu), 999 970 &rpdu, blk_trace_bio_get_cgid(q, bio)); 1000 971 } 972 + rcu_read_unlock(); 1001 973 } 1002 974 1003 975 /** ··· 1018 988 struct request_queue *q, struct bio *bio, 1019 989 dev_t dev, sector_t from) 1020 990 { 1021 - struct blk_trace *bt = q->blk_trace; 991 + struct blk_trace *bt; 1022 992 struct blk_io_trace_remap r; 1023 993 1024 - if (likely(!bt)) 994 + rcu_read_lock(); 995 + bt = rcu_dereference(q->blk_trace); 996 + if (likely(!bt)) { 997 + rcu_read_unlock(); 1025 998 return; 999 + } 1026 1000 1027 1001 r.device_from = cpu_to_be32(dev); 1028 1002 r.device_to = cpu_to_be32(bio_dev(bio)); ··· 1035 1001 __blk_add_trace(bt, bio->bi_iter.bi_sector, bio->bi_iter.bi_size, 1036 1002 bio_op(bio), bio->bi_opf, BLK_TA_REMAP, bio->bi_status, 1037 1003 sizeof(r), &r, blk_trace_bio_get_cgid(q, bio)); 1004 + rcu_read_unlock(); 1038 1005 } 1039 1006 1040 1007 /** ··· 1056 1021 struct request *rq, dev_t dev, 1057 1022 sector_t from) 1058 1023 { 1059 - struct blk_trace *bt = q->blk_trace; 1024 + struct blk_trace *bt; 1060 1025 struct blk_io_trace_remap r; 1061 1026 1062 - if (likely(!bt)) 1027 + rcu_read_lock(); 1028 + bt = rcu_dereference(q->blk_trace); 1029 + if (likely(!bt)) { 1030 + rcu_read_unlock(); 1063 1031 return; 1032 + } 1064 1033 1065 1034 r.device_from = cpu_to_be32(dev); 1066 1035 r.device_to = cpu_to_be32(disk_devt(rq->rq_disk)); ··· 1073 1034 __blk_add_trace(bt, blk_rq_pos(rq), blk_rq_bytes(rq), 1074 1035 rq_data_dir(rq), 0, BLK_TA_REMAP, 0, 1075 1036 sizeof(r), &r, blk_trace_request_get_cgid(q, rq)); 1037 + rcu_read_unlock(); 1076 1038 } 1077 1039 1078 1040 /** ··· 1091 1051 struct request *rq, 1092 1052 void *data, size_t len) 1093 1053 { 1094 - struct blk_trace *bt = q->blk_trace; 1054 + struct blk_trace *bt; 1095 1055 1096 - if (likely(!bt)) 1056 + rcu_read_lock(); 1057 + bt = rcu_dereference(q->blk_trace); 1058 + if (likely(!bt)) { 1059 + rcu_read_unlock(); 1097 1060 return; 1061 + } 1098 1062 1099 1063 __blk_add_trace(bt, blk_rq_trace_sector(rq), blk_rq_bytes(rq), 0, 0, 1100 1064 BLK_TA_DRV_DATA, 0, len, data, 1101 1065 blk_trace_request_get_cgid(q, rq)); 1066 + rcu_read_unlock(); 1102 1067 } 1103 1068 EXPORT_SYMBOL_GPL(blk_add_driver_data); 1104 1069 ··· 1642 1597 return -EINVAL; 1643 1598 1644 1599 put_probe_ref(); 1600 + synchronize_rcu(); 1645 1601 blk_trace_free(bt); 1646 1602 return 0; 1647 1603 } ··· 1804 1758 struct hd_struct *p = dev_to_part(dev); 1805 1759 struct request_queue *q; 1806 1760 struct block_device *bdev; 1761 + struct blk_trace *bt; 1807 1762 ssize_t ret = -ENXIO; 1808 1763 1809 1764 bdev = bdget(part_devt(p)); ··· 1817 1770 1818 1771 mutex_lock(&q->blk_trace_mutex); 1819 1772 1773 + bt = rcu_dereference_protected(q->blk_trace, 1774 + lockdep_is_held(&q->blk_trace_mutex)); 1820 1775 if (attr == &dev_attr_enable) { 1821 - ret = sprintf(buf, "%u\n", !!q->blk_trace); 1776 + ret = sprintf(buf, "%u\n", !!bt); 1822 1777 goto out_unlock_bdev; 1823 1778 } 1824 1779 1825 - if (q->blk_trace == NULL) 1780 + if (bt == NULL) 1826 1781 ret = sprintf(buf, "disabled\n"); 1827 1782 else if (attr == &dev_attr_act_mask) 1828 - ret = blk_trace_mask2str(buf, q->blk_trace->act_mask); 1783 + ret = blk_trace_mask2str(buf, bt->act_mask); 1829 1784 else if (attr == &dev_attr_pid) 1830 - ret = sprintf(buf, "%u\n", q->blk_trace->pid); 1785 + ret = sprintf(buf, "%u\n", bt->pid); 1831 1786 else if (attr == &dev_attr_start_lba) 1832 - ret = sprintf(buf, "%llu\n", q->blk_trace->start_lba); 1787 + ret = sprintf(buf, "%llu\n", bt->start_lba); 1833 1788 else if (attr == &dev_attr_end_lba) 1834 - ret = sprintf(buf, "%llu\n", q->blk_trace->end_lba); 1789 + ret = sprintf(buf, "%llu\n", bt->end_lba); 1835 1790 1836 1791 out_unlock_bdev: 1837 1792 mutex_unlock(&q->blk_trace_mutex); ··· 1850 1801 struct block_device *bdev; 1851 1802 struct request_queue *q; 1852 1803 struct hd_struct *p; 1804 + struct blk_trace *bt; 1853 1805 u64 value; 1854 1806 ssize_t ret = -EINVAL; 1855 1807 ··· 1881 1831 1882 1832 mutex_lock(&q->blk_trace_mutex); 1883 1833 1834 + bt = rcu_dereference_protected(q->blk_trace, 1835 + lockdep_is_held(&q->blk_trace_mutex)); 1884 1836 if (attr == &dev_attr_enable) { 1885 - if (!!value == !!q->blk_trace) { 1837 + if (!!value == !!bt) { 1886 1838 ret = 0; 1887 1839 goto out_unlock_bdev; 1888 1840 } ··· 1896 1844 } 1897 1845 1898 1846 ret = 0; 1899 - if (q->blk_trace == NULL) 1847 + if (bt == NULL) 1900 1848 ret = blk_trace_setup_queue(q, bdev); 1901 1849 1902 1850 if (ret == 0) { 1903 1851 if (attr == &dev_attr_act_mask) 1904 - q->blk_trace->act_mask = value; 1852 + bt->act_mask = value; 1905 1853 else if (attr == &dev_attr_pid) 1906 - q->blk_trace->pid = value; 1854 + bt->pid = value; 1907 1855 else if (attr == &dev_attr_start_lba) 1908 - q->blk_trace->start_lba = value; 1856 + bt->start_lba = value; 1909 1857 else if (attr == &dev_attr_end_lba) 1910 - q->blk_trace->end_lba = value; 1858 + bt->end_lba = value; 1911 1859 } 1912 1860 1913 1861 out_unlock_bdev:

Configure Feed

Configure Feed