Hello Ankur, Am 05.10.2017 um 19:59 schrieb Ankur Arora: > On 2017-10-05 06:20 AM, Konrad Rzeszutek Wilk wrote: >> On Wed, Oct 04, 2017 at 08:26:27PM +0200, Philipp Hahn wrote: ... >> Adding Ankur to this as I think he saw something similar. >> >> But in the meantime - do you see this with the latest version of Linux? >>> with linux-4.9.52 running on Debian-Wheezy with Xen-4.1 I observed >>> several stuck processes: Here is one (truncated) dump of the Linux >>> kernel messages: >>> >>>> [<ffffffff8160db6d>] ? __schedule+0x23d/0x6d0 >>>> [<ffffffff8160e8a0>] ? bit_wait_timeout+0x90/0x90 >>>> [<ffffffff8160e032>] ? schedule+0x32/0x80 >>>> [<ffffffff8161150c>] ? schedule_timeout+0x1ec/0x360 >>>> [<ffffffff8130f277>] ? __blk_mq_run_hw_queue+0x327/0x3e0* see below >>>> [<ffffffff8101b7f1>] ? xen_clocksource_get_cycles+0x11/0x20 >>>> [<ffffffff8160e8a0>] ? bit_wait_timeout+0x90/0x90 >>>> [<ffffffff8160d8b4>] ? io_schedule_timeout+0xb4/0x130 >>>> [<ffffffff810bb6f7>] ? prepare_to_wait+0x57/0x80 >>>> [<ffffffff8160e8b7>] ? bit_wait_io+0x17/0x60 >>>> [<ffffffff8160e3ac>] ? __wait_on_bit+0x5c/0x90 >>>> [<ffffffff8160e8a0>] ? bit_wait_timeout+0x90/0x90 >>>> [<ffffffff8160e50e>] ? out_of_line_wait_on_bit+0x7e/0xa0 >>>> [<ffffffff810bba20>] ? autoremove_wake_function+0x40/0x40 >>>> [<ffffffffc00abd18>] ? >>>> jbd2_journal_commit_transaction+0xd48/0x17e0 [jbd2] >>>> [<ffffffff810247d9>] ? __switch_to+0x2c9/0x720 >>>> [<ffffffff810e67fd>] ? try_to_del_timer_sync+0x4d/0x80 >>>> [<ffffffffc00b099d>] ? kjournald2+0xdd/0x280 [jbd2] >>>> [<ffffffff810bb9e0>] ? wake_up_atomic_t+0x30/0x30 >>>> [<ffffffffc00b08c0>] ? commit_timeout+0x10/0x10 [jbd2] >>>> [<ffffffff81097660>] ? kthread+0xf0/0x110 >>>> [<ffffffff810247d9>] ? __switch_to+0x2c9/0x720 >>>> [<ffffffff81097570>] ? kthread_park+0x60/0x60 >>>> [<ffffffff81612bb5>] ? ret_from_fork+0x25/0x30 > This looks like this race: https://patchwork.kernel.org/patch/9853443/
I built a new kernel, for which I picked that patch on top of 4.9.56. We are currently testing that, but it crashed again yesterday evening. Here is the dmesg output: > INFO: task systemd:1 blocked for more than 120 seconds. > Not tainted 4.9.0-ucs105-amd64 #1 Debian 4.9.30-2A~4.2.0.201710161640 > "echo 0 > /proc/sys/kernel/hung_task_timeout_secs" disables this message. > systemd D 0 1 0 0x00000000 > ffff8801f1797c00 0000000000000000 ffffffff81c0e540 ffff8801f4956040 > ffff8801f5a187c0 ffffc90040c4f880 ffffffff8160ebbd ffffffff81186295 > ffffffff81350b39 0000000002cebf80 ffffffff811863c8 ffff8801f4956040 > Call Trace: > [<ffffffff8160ebbd>] ? __schedule+0x23d/0x6d0 > [<ffffffff81186295>] ? move_freepages+0x95/0xd0 > [<ffffffff81350b39>] ? list_del+0x9/0x20 > [<ffffffff811863c8>] ? __rmqueue+0x88/0x3e0 > [<ffffffff8160f082>] ? schedule+0x32/0x80 > [<ffffffff8161255c>] ? schedule_timeout+0x1ec/0x360 > [<ffffffff81187530>] ? get_page_from_freelist+0x350/0xad0 > [<ffffffff8160e904>] ? io_schedule_timeout+0xb4/0x130 > [<ffffffff81364fd4>] ? __sbitmap_queue_get+0x24/0x90 > [<ffffffff813114f9>] ? bt_get.isra.6+0x129/0x1c0 > [<ffffffff81350b39>] ? list_del+0x9/0x20 > [<ffffffff810bba00>] ? wake_up_atomic_t+0x30/0x30 > [<ffffffff81311843>] ? blk_mq_get_tag+0x23/0x90 > [<ffffffff8130d1aa>] ? __blk_mq_alloc_request+0x1a/0x220 > [<ffffffff8130dffd>] ? blk_mq_map_request+0xcd/0x170 > [<ffffffff8131016a>] ? blk_sq_make_request+0xca/0x4c0 > [<ffffffff81303e1a>] ? generic_make_request_checks+0x22a/0x4f0 > [<ffffffff81304761>] ? generic_make_request+0x121/0x2c0 > [<ffffffff8117e823>] ? __add_to_page_cache_locked+0x183/0x230 > [<ffffffff81304976>] ? submit_bio+0x76/0x150 > [<ffffffff8117e964>] ? add_to_page_cache_lru+0x84/0xe0 > [<ffffffffc017b9d9>] ? ext4_mpage_readpages+0x2b9/0x8b0 [ext4] > [<ffffffff811d94fa>] ? alloc_pages_current+0x8a/0x110 > [<ffffffff8118e745>] ? __do_page_cache_readahead+0x195/0x240 > [<ffffffff8117f627>] ? pagecache_get_page+0x27/0x2b0 > [<ffffffff811818e6>] ? filemap_fault+0x276/0x590 > [<ffffffffc0138491>] ? ext4_filemap_fault+0x31/0x50 [ext4] > [<ffffffff811b23a4>] ? __do_fault+0x84/0x190 > [<ffffffff811b783e>] ? handle_mm_fault+0xede/0x1680 > [<ffffffff8124d25e>] ? ep_poll+0x13e/0x360 > [<ffffffff8105feda>] ? __do_page_fault+0x26a/0x500 > [<ffffffff81205ba2>] ? SyS_read+0x52/0xc0 > [<ffffffff81614d58>] ? page_fault+0x28/0x30 I haven't been able to get the address of the queue object yet to get its state. (timeout for today) > Can you dump the output of: cat /sys/block/$xen-frontend-device/mq/*/tags > > If you've hit this bug, one or more of the MQs would be wedged and > the nr_free in one or more of the queues would be 0 and will not > change. As soon as the bug occurs, we can no longer access the VM via ssh or the Xen (serial) console: the connection stalls after entering 2-3 characters. I have a Xen crash-dump file of one such crash, but following /sys/block/xvd?/mq/*/tags manually to get the kobject address using "crash" (gdb) is very time consuming. So far I only did it once for xvda, but I have to to that for the other 15 block devices as well to find one culprit. Philipp Hahn -- Philipp Hahn Open Source Software Engineer Univention GmbH be open. Mary-Somerville-Str. 1 D-28359 Bremen Tel.: +49 421 22232-0 Fax : +49 421 22232-99 h...@univention.de http://www.univention.de/ Geschäftsführer: Peter H. Ganten HRB 20755 Amtsgericht Bremen Steuer-Nr.: 71-597-0287
PID: 1 TASK: ffff8801f4956040 CPU: 0 COMMAND: "systemd" #0 [ffffc90040c4f800] __schedule at ffffffff8160ebbd kernel/sched/core.c: 2902 ffffc90040c4f808: 0000000000000000 init_task ffffc90040c4f818: [ffff8801f4956040:task_struct] ffff8801f5a187c0 ffffc90040c4f828: ffffc90040c4f880 __schedule+573 ffffc90040c4f838: move_freepages+149 list_del+9 ffffc90040c4f848: 0000000002cebf80 __rmqueue+136 ffffc90040c4f858: [ffff8801f4956040:task_struct] 7fffffffffffffff ffffc90040c4f868: [ffff8801f129a850:kmalloc-192] 7fffffffffffffff ffffc90040c4f878: [ffff8801f0a9c040:request_queue] ffffc90040c4f918 ffffc90040c4f888: schedule+50 #1 [ffffc90040c4f888] schedule at ffffffff8160f082 arch/x86/include/asm/bitops.h: 311 ffffc90040c4f890: 0000000000000000 schedule_timeout+492 #2 [ffffc90040c4f898] schedule_timeout at ffffffff8161255c kernel/time/timer.c: 1771 ffffc90040c4f8a0: 0000000000000001 ffffea0004f18880 ffffc90040c4f8b0: ffffea0004f18840 ffff8801ff01bb80 ffffc90040c4f8c0: get_page_from_freelist+848 ffffc90040c4f8c8 ffffc90040c4f8d0: ffffc90040c4f8c8 000059bd97399f43 ffffc90040c4f8e0: 0000000000000000 78bd7181eeb35a00 ffffc90040c4f8f0: 0000000000000000 7fffffffffffffff ffffc90040c4f900: [ffff8801f129a850:kmalloc-192] [ffff8801f16e4300:kmalloc-256] ffffc90040c4f910: [ffff8801f0a9c040:request_queue] ffff8801f5a187c0 ffffc90040c4f920: io_schedule_timeout+180 #3 [ffffc90040c4f920] io_schedule_timeout at ffffffff8160e904 arch/x86/include/asm/current.h: 14 ffffc90040c4f928: __sbitmap_queue_get+36 [ffff8801f120e988:kmalloc-512] ffffc90040c4f938: [ffff8801f1037000:kmalloc-1024] ffffc90040c4fa00 ffffc90040c4f948: bt_get+297 #4 [ffffc90040c4f948] bt_get at ffffffff813114f9 block/blk-mq-tag.c: 143 ffffc90040c4f950: list_del+9 0000000000000000 ffffc90040c4f960: [ffff8801f4956040:task_struct] autoremove_wake_function ffffc90040c4f970: [ffff8801f120e990:kmalloc-512] [ffff8801f120e990:kmalloc-512] ffffc90040c4f980: 78bd7181eeb35a00 ffffc90040c4fa00 ffffc90040c4f990: 0000000000000008 0000000000000000 ffffc90040c4f9a0: ffffc90040c4fa00 blk_mq_get_tag+35 #5 [ffffc90040c4f9a8] blk_mq_get_tag at ffffffff81311843 block/blk-mq-tag.c: 165 ffffc90040c4f9b0: 0000000000000001 __blk_mq_alloc_request+26 #6 [ffffc90040c4f9b8] __blk_mq_alloc_request at ffffffff8130d1aa block/blk-mq.c: 197 ffffc90040c4f9c0: 0000000000000001 ffffe8ffffc0a140 ffffc90040c4f9d0: 0000000000000000 0000000000000008 ffffc90040c4f9e0: [ffff8801f16e4300:kmalloc-256] blk_mq_map_request+205 #7 [ffffc90040c4f9e8] blk_mq_map_request at ffffffff8130dffd block/blk-mq.c: 1209 ffffc90040c4f9f0: [ffff8801f1037000:kmalloc-1024] ffffc90040c4fa90 ffffc90040c4fa00: [ffff8801f0a9c040:request_queue] 0000000000000000 ffffc90040c4fa10: ffffe8ffffc0a140 [ffff8801f1037000:kmalloc-1024] ffffc90040c4fa20: 78bd7181eeb35a00 0000000000000001 ffffc90040c4fa30: 0000000000000000 00000000ffffffff ffffc90040c4fa40: [ffff8801f0a9c040:request_queue] 0000000000000001 ffffc90040c4fa50: 0000000000000001 blk_sq_make_request+202 #8 [ffffc90040c4fa58] blk_sq_make_request at ffffffff8131016a block/blk-mq.c: 1375 ffffc90040c4fa60: [ffff8801f10379e0:kmalloc-1024] [ffff8801f0a9c040:request_queue] ffffc90040c4fa70: generic_make_request_checks+554 ffffc90040c4fad0 ffffc90040c4fa80: [ffff8801f16e4300:kmalloc-256] 0000000088000102 ffffc90040c4fa90: 78bd7181eeb35a00 [ffff8801f3fa6890:ext4_inode_cache] ffffc90040c4faa0: 78bd7181eeb35a00 [ffff8801f16e4300:kmalloc-256] ffffc90040c4fab0: ffffc90040c4fb30 00000000ffffffff ffffc90040c4fac0: [ffff8801f0a9c040:request_queue] 0000000000000001 ffffc90040c4fad0: 0000000000000001 generic_make_request+289 #9 [ffffc90040c4fad8] generic_make_request at ffffffff81304761 block/blk-core.c: 2051 ffffc90040c4fae0: 0000000000000000 0000000000000000 ffffc90040c4faf0: 0000000000000000 0000000000000000 ffffc90040c4fb00: __add_to_page_cache_locked+387 78bd7181eeb35a00 ffffc90040c4fb10: 00000000028e2388 [ffff8801f16e4300:kmalloc-256] ffffc90040c4fb20: ffffea0004a376c0 0000000000000001 ffffc90040c4fb30: 0000000000000020 submit_bio+118 #10 [ffffc90040c4fb38] submit_bio at ffffffff81304976 block/blk-core.c: 2123 ffffc90040c4fb40: ffffea0004a376c0 0000000000000000 ffffc90040c4fb50: add_to_page_cache_lru+132 00028e2388000102 ffffc90040c4fb60: 78bd7181eeb35a00 78bd7181eeb35a00 ffffc90040c4fb70: 00000000000000f0 0000000000000013 ffffc90040c4fb80: ext4_mpage_readpages+697 #11 [ffffc90040c4fb80] ext4_mpage_readpages at ffffffffc017b9d9 [ext4] ffffc90040c4fb88: 024200caffffffff [ffff8801f3fa6718:ext4_inode_cache] ffffc90040c4fb98: ffffea0006bd4400 ffffc90040c4fcd0 ffffc90040c4fba8: [ffff8801f16e4300:kmalloc-256] 0000001500000015 ffffc90040c4fbb8: [ffff8801f3fa6890:ext4_inode_cache] 000010000000000c ffffc90040c4fbc8: 0000000001652086 [ffff8801f4956040:task_struct] ffffc90040c4fbd8: [ffff8801f3eaaa40:bdev_cache] [ffff8801f4956040:task_struct] ffffc90040c4fbe8: [ffff8801f4956040:task_struct] [ffff8801f4956040:task_struct] ffffc90040c4fbf8: 0000000001652083 00000019000000e9 ffffc90040c4fc08: 0000000000000020 0000000001652089 ffffc90040c4fc18: preferred_node_policy 00000000024213ca ffffc90040c4fc28: 0000000000000000 0000000000000000 ffffc90040c4fc38: [ffff8801f4956040:task_struct] [ffff8801f4956040:task_struct] ffffc90040c4fc48: alloc_pages_current+138 78bd7181eeb35a00 ffffc90040c4fc58: 0000000000000020 ffffc90040c4fd50 ffffc90040c4fc68: 0000000000000108 0000000000000020 ffffc90040c4fc78: 0000000000000019 00000000000000e9 ffffc90040c4fc88: __do_page_cache_readahead+405 #12 [ffffc90040c4fc88] __do_page_cache_readahead at ffffffff8118e745 mm/readahead.c: 123 ffffc90040c4fc90: [ffff8801f179d300:kmalloc-256] [ffff8801f3fa6890:ext4_inode_cache] ffffc90040c4fca0: 0000000000000018 024213ca81337a06 ffffc90040c4fcb0: 0000000000000140 ffffea0006b34c80 ffffc90040c4fcc0: [ffff8801f3fa6898:ext4_inode_cache] 0000000000000020 ffffc90040c4fcd0: ffffea0006b34ca0 ffffea00069b9a60 ffffc90040c4fce0: ffffc90040c4fce0 ffffc90040c4fce0 ffffc90040c4fcf0: ffffc90040c4fcf0 ffffc90040c4fcf0 ffffc90040c4fd00: ffffc90040c4fd00 ffffc90040c4fd00 ffffc90040c4fd10: 0000000000000000 78bd7181eeb35a00 ffffc90040c4fd20: pagecache_get_page+39 00000000000000f9 ffffc90040c4fd30: [ffff8801f179d300:kmalloc-256] 0000000000000000 ffffc90040c4fd40: ffffc90040c4fde8 [ffff8801f3fa6718:ext4_inode_cache] ffffc90040c4fd50: [ffff8801f179d3a0:kmalloc-256] filemap_fault+630 #13 [ffffc90040c4fd58] filemap_fault at ffffffff811818e6 mm/filemap.c: 2133 ffffc90040c4fd60: 0000000000000101 [ffff8801f3fa6890:ext4_inode_cache] ffffc90040c4fd70: ffffc90040c4fde8 [ffff8801f1794af0:vm_area_struct] ffffc90040c4fd80: [ffff8801f1794af0:vm_area_struct] [ffff8801f3fa66f0:ext4_inode_cache] ffffc90040c4fd90: [ffff8801f1794af0:vm_area_struct] ffffc90040c4fde8 ffffc90040c4fda0: 0000564c1f3b7223 0000000000000000 ffffc90040c4fdb0: 0000000000000000 ext4_filemap_fault+49 #14 [ffffc90040c4fdb8] ext4_filemap_fault at ffffffffc0138491 [ext4] ffffc90040c4fdc0: [ffff8801f1794af0:vm_area_struct] ffffc90040c4fe68 ffffc90040c4fdd0: 0000000000000000 __do_fault+132 #15 [ffffc90040c4fdd8] __do_fault at ffffffff811b23a4 mm/memory.c: 2828 ffffc90040c4fde0: 0000000000000040 024200ca00000054 ffffc90040c4fdf0: 00000000000000f9 0000564c1f3b7000 ffffc90040c4fe00: 0000000000000000 0000000000000000 ffffc90040c4fe10: ffff880000000d88 78bd7181eeb35a00 ffffc90040c4fe20: [ffff8801f1794af0:vm_area_struct] 0000000000000040 ffffc90040c4fe30: 00000000000000f9 handle_mm_fault+3806 #16 [ffffc90040c4fe38] handle_mm_fault at ffffffff811b783e mm/memory.c: 3155 ffffc90040c4fe40: ffffc90040c4fe70 0000000000000000 ffffc90040c4fe50: [ffff8801f4956040:task_struct] 00007ffca20e0e00 ffffc90040c4fe60: ep_poll+318 [ffff8801f3d09db0:inode_cache] ffffc90040c4fe70: [ffff8801f1794af0:vm_area_struct] 0000564c1f3b7223 ffffc90040c4fe80: 0000000000000054 ffff8801f17627c8 ffffc90040c4fe90: 0000000000000000 ffffea0007cd03b0 ffffc90040c4fea0: 0000000000000000 78bd7181eeb35a00 ffffc90040c4feb0: 0000000000000004 0000564c1f3b7223 ffffc90040c4fec0: [ffff8801f1797c00:mm_struct] ffffc90040c4ff58 ffffc90040c4fed0: 0000000000000054 [ffff8801f4956040:task_struct] ffffc90040c4fee0: __do_page_fault+618 #17 [ffffc90040c4fee0] __do_page_fault at ffffffff8105feda arch/x86/mm/fault.c: 1398 ffffc90040c4fee8: [ffff8801f1797c68:mm_struct] 00000000f1275c00 ffffc90040c4fef8: [ffff8801f1794af0:vm_area_struct] 0000000000000000 ffffc90040c4ff08: 0000000000000000 sys_read+82 ffffc90040c4ff18: 78bd7181eeb35a00 0000000000000000 ffffc90040c4ff28: 00007ffca20e0ab0 0000564c1f39dc13 ffffc90040c4ff38: 0000000000000000 0000000000000000 ffffc90040c4ff48: 00007ffca20e0c38 page_fault+40 #18 [ffffc90040c4ff50] page_fault at ffffffff81614d58 arch/x86/entry/entry_64.S: 1026 RIP: 00007fdaa3eb9dcc RSP: 00007ffca20e04e0 RFLAGS: 00010286 RAX: 0000000000000000 RBX: 00007ffca20e0ac0 RCX: ffffffffffffffff RDX: 0000000000000030 RSI: 0000564c1f39dc13 RDI: 0000564c1f3b7223 RBP: 00007ffca20e0ab0 R8: 0000564c1f3b7223 R9: 00007fdaa3eba99a R10: 0000564c21226180 R11: 0000000000000001 R12: 0000564c1f39dc13 R13: 0000000000000000 R14: 0000000000000000 R15: 00007ffca20e0c38 ORIG_RAX: ffffffffffffffff CS: e033 SS: e02b
/* * Single hardware queue variant. This will attempt to use any per-process * plug for merging and IO deferral. */ static blk_qc_t blk_sq_make_request(struct request_queue *q, struct bio *bio) { <blk_sq_make_request> callq 0000000000002fe5 <blk_sq_make_request+0x5> <blk_sq_make_request+0x5> push %r15 <blk_sq_make_request+0x7> push %r14 <blk_sq_make_request+0x9> push %r13 <blk_sq_make_request+0xb> push %r12 <blk_sq_make_request+0xd> mov %rdi,%r13 <blk_sq_make_request+0x10> push %rbp <blk_sq_make_request+0x11> push %rbx <blk_sq_make_request+0x12> mov $0x1,%ebx <blk_sq_make_request+0x17> sub $0x48,%rsp const int is_sync = rw_is_sync(bio_op(bio), bio->bi_opf); <blk_sq_make_request+0x1b> mov 0x14(%rsi),%eax /* * Single hardware queue variant. This will attempt to use any per-process * plug for merging and IO deferral. */ static blk_qc_t blk_sq_make_request(struct request_queue *q, struct bio *bio) { <blk_sq_make_request+0x1e> mov %gs:0x28,%rcx <blk_sq_make_request+0x27> mov %rcx,0x40(%rsp) <blk_sq_make_request+0x2c> xor %ecx,%ecx <blk_sq_make_request+0x2e> mov %rsi,0x20(%rsp) const int is_sync = rw_is_sync(bio_op(bio), bio->bi_opf); <blk_sq_make_request+0x33> mov %eax,%edx <blk_sq_make_request+0x35> shr $0x1d,%edx <blk_sq_make_request+0x38> test %edx,%edx <blk_sq_make_request+0x3a> je 0000000000003024 <blk_sq_make_request+0x44> <blk_sq_make_request+0x3c> mov %eax,%ebx <blk_sq_make_request+0x3e> shr $0x3,%ebx <blk_sq_make_request+0x41> and $0x1,%ebx unsigned int request_count = 0; struct blk_map_ctx data; struct request *rq; blk_qc_t cookie; blk_queue_bounce(q, &bio); <blk_sq_make_request+0x44> lea 0x20(%rsp),%rsi * plug for merging and IO deferral. */ static blk_qc_t blk_sq_make_request(struct request_queue *q, struct bio *bio) { const int is_sync = rw_is_sync(bio_op(bio), bio->bi_opf); const int is_flush_fua = bio->bi_opf & (REQ_PREFLUSH | REQ_FUA); <blk_sq_make_request+0x49> and $0x300,%eax unsigned int request_count = 0; struct blk_map_ctx data; struct request *rq; blk_qc_t cookie; blk_queue_bounce(q, &bio); <blk_sq_make_request+0x4e> mov %r13,%rdi * plug for merging and IO deferral. */ static blk_qc_t blk_sq_make_request(struct request_queue *q, struct bio *bio) { const int is_sync = rw_is_sync(bio_op(bio), bio->bi_opf); const int is_flush_fua = bio->bi_opf & (REQ_PREFLUSH | REQ_FUA); <blk_sq_make_request+0x51> mov %eax,%ebp struct blk_plug *plug; unsigned int request_count = 0; <blk_sq_make_request+0x53> movl $0x0,0x2c(%rsp) struct blk_map_ctx data; struct request *rq; blk_qc_t cookie; blk_queue_bounce(q, &bio); <blk_sq_make_request+0x5b> callq 0000000000003040 <blk_sq_make_request+0x60> if (bio_integrity_enabled(bio) && bio_integrity_prep(bio)) { <blk_sq_make_request+0x60> mov 0x20(%rsp),%rdi <blk_sq_make_request+0x65> callq 000000000000304a <blk_sq_make_request+0x6a> <blk_sq_make_request+0x6a> test %al,%al <blk_sq_make_request+0x6c> je 0000000000003060 <blk_sq_make_request+0x80> <blk_sq_make_request+0x6e> mov 0x20(%rsp),%rdi <blk_sq_make_request+0x73> callq 0000000000003058 <blk_sq_make_request+0x78> <blk_sq_make_request+0x78> test %eax,%eax <blk_sq_make_request+0x7a> jne 0000000000003133 <blk_sq_make_request+0x153> bio_io_error(bio); return BLK_QC_T_NONE; } blk_queue_split(q, &bio, q->bio_split); <blk_sq_make_request+0x80> mov 0x8b0(%r13),%rdx <blk_sq_make_request+0x87> lea 0x20(%rsp),%rsi <blk_sq_make_request+0x8c> mov %r13,%rdi <blk_sq_make_request+0x8f> callq 0000000000003074 <blk_sq_make_request+0x94> if (!is_flush_fua && !blk_queue_nomerges(q)) { <blk_sq_make_request+0x94> test %ebp,%ebp <blk_sq_make_request+0x96> jne 0000000000003170 <blk_sq_make_request+0x190> } static __always_inline bool constant_test_bit(long nr, const volatile unsigned long *addr) { return ((1UL << (nr & (BITS_PER_LONG-1))) & (addr[nr >> _BITOPS_LONG_SHIFT])) != 0; <blk_sq_make_request+0x9c> mov 0x510(%r13),%rax <blk_sq_make_request+0xa3> test $0x1,%ah <blk_sq_make_request+0xa6> je 00000000000031f4 <blk_sq_make_request+0x214> if (blk_attempt_plug_merge(q, bio, &request_count, NULL)) return BLK_QC_T_NONE; } else request_count = blk_plug_queued_count(q); <blk_sq_make_request+0xac> mov %r13,%rdi <blk_sq_make_request+0xaf> callq 0000000000003094 <blk_sq_make_request+0xb4> <blk_sq_make_request+0xb4> mov %eax,0x2c(%rsp) rq = blk_mq_map_request(q, bio, &data); <blk_sq_make_request+0xb8> mov 0x20(%rsp),%rsi <blk_sq_make_request+0xbd> lea 0x30(%rsp),%rdx <blk_sq_make_request+0xc2> mov %r13,%rdi <blk_sq_make_request+0xc5> callq 0000000000000e70 <blk_mq_map_request> if (unlikely(!rq)) <blk_sq_make_request+0xca> test %rax,%rax if (blk_attempt_plug_merge(q, bio, &request_count, NULL)) return BLK_QC_T_NONE; } else request_count = blk_plug_queued_count(q); rq = blk_mq_map_request(q, bio, &data); <blk_sq_make_request+0xcd> mov %rax,%rbp if (unlikely(!rq)) <blk_sq_make_request+0xd0> je 0000000000003210 <blk_sq_make_request+0x230> return BLK_QC_T_NONE; cookie = blk_tag_to_qc_t(rq->tag, data.hctx->queue_num); <blk_sq_make_request+0xd6> mov 0x30(%rsp),%rax <blk_sq_make_request+0xdb> mov %rax,(%rsp) return cookie != BLK_QC_T_NONE; } static inline blk_qc_t blk_tag_to_qc_t(unsigned int tag, unsigned int queue_num) { return tag | (queue_num << BLK_QC_T_SHIFT); <blk_sq_make_request+0xdf> mov 0x144(%rax),%eax <blk_sq_make_request+0xe5> mov %eax,0x8(%rsp) <blk_sq_make_request+0xe9> mov %eax,%r12d DECLARE_PER_CPU(struct task_struct *, current_task); static __always_inline struct task_struct *get_current(void) { return this_cpu_read_stable(current_task); <blk_sq_make_request+0xec> mov %gs:0x0,%rax /* * A task plug currently exists. Since this is completely lockless, * utilize that to temporarily store requests until the task is * either done or scheduled away. */ plug = current->plug; <blk_sq_make_request+0xf5> mov 0x750(%rax),%r14 <blk_sq_make_request+0xfc> shl $0x10,%r12d <blk_sq_make_request+0x100> or 0x100(%rbp),%r12d if (plug) { <blk_sq_make_request+0x107> test %r14,%r14 <blk_sq_make_request+0x10a> je 000000000000327e <blk_sq_make_request+0x29e> } } static void blk_mq_bio_to_request(struct request *rq, struct bio *bio) { init_request_from_bio(rq, bio); <blk_sq_make_request+0x110> mov 0x20(%rsp),%rsi <blk_sq_make_request+0x115> mov %rbp,%rdi <blk_sq_make_request+0x118> callq 00000000000030fd <blk_sq_make_request+0x11d> blk_account_io_start(rq, 1); <blk_sq_make_request+0x11d> mov $0x1,%esi <blk_sq_make_request+0x122> mov %rbp,%rdi <blk_sq_make_request+0x125> callq 000000000000310a <blk_sq_make_request+0x12a> * either done or scheduled away. */ plug = current->plug; if (plug) { blk_mq_bio_to_request(rq, bio); if (!request_count) <blk_sq_make_request+0x12a> mov 0x2c(%rsp),%eax <blk_sq_make_request+0x12e> test %eax,%eax <blk_sq_make_request+0x130> je 000000000000322f <blk_sq_make_request+0x24f> trace_block_plug(q); blk_mq_put_ctx(data.ctx); if (request_count >= BLK_MAX_REQUEST_COUNT) { <blk_sq_make_request+0x136> cmpl $0xf,0x2c(%rsp) <blk_sq_make_request+0x13b> ja 000000000000321b <blk_sq_make_request+0x23b> <blk_sq_make_request+0x141> mov 0x18(%r14),%rsi blk_flush_plug_list(plug, false); trace_block_plug(q); } list_add_tail(&rq->queuelist, &plug->mq_list); <blk_sq_make_request+0x145> lea 0x10(%r14),%rdx <blk_sq_make_request+0x149> mov %rbp,%rdi <blk_sq_make_request+0x14c> callq 0000000000003131 <blk_sq_make_request+0x151> return cookie; <blk_sq_make_request+0x151> jmp 000000000000314a <blk_sq_make_request+0x16a> blk_qc_t cookie; blk_queue_bounce(q, &bio); if (bio_integrity_enabled(bio) && bio_integrity_prep(bio)) { bio_io_error(bio); <blk_sq_make_request+0x153> mov 0x20(%rsp),%rdi return BLK_QC_T_NONE; <blk_sq_make_request+0x158> mov $0xffffffff,%r12d extern void bio_endio(struct bio *); static inline void bio_io_error(struct bio *bio) { bio->bi_error = -EIO; <blk_sq_make_request+0x15e> movl $0xfffffffb,0x10(%rdi) bio_endio(bio); <blk_sq_make_request+0x165> callq 000000000000314a <blk_sq_make_request+0x16a> blk_mq_run_hw_queue(data.hctx, !is_sync || is_flush_fua); } blk_mq_put_ctx(data.ctx); return cookie; } <blk_sq_make_request+0x16a> mov 0x40(%rsp),%rcx <blk_sq_make_request+0x16f> xor %gs:0x28,%rcx <blk_sq_make_request+0x178> mov %r12d,%eax <blk_sq_make_request+0x17b> jne 000000000000348e <blk_sq_make_request+0x4ae> <blk_sq_make_request+0x181> add $0x48,%rsp <blk_sq_make_request+0x185> pop %rbx <blk_sq_make_request+0x186> pop %rbp <blk_sq_make_request+0x187> pop %r12 <blk_sq_make_request+0x189> pop %r13 <blk_sq_make_request+0x18b> pop %r14 <blk_sq_make_request+0x18d> pop %r15 <blk_sq_make_request+0x18f> retq if (!is_flush_fua && !blk_queue_nomerges(q)) { if (blk_attempt_plug_merge(q, bio, &request_count, NULL)) return BLK_QC_T_NONE; } else request_count = blk_plug_queued_count(q); <blk_sq_make_request+0x190> mov %r13,%rdi <blk_sq_make_request+0x193> callq 0000000000003178 <blk_sq_make_request+0x198> rq = blk_mq_map_request(q, bio, &data); <blk_sq_make_request+0x198> mov 0x20(%rsp),%rsi <blk_sq_make_request+0x19d> lea 0x30(%rsp),%rdx <blk_sq_make_request+0x1a2> mov %r13,%rdi if (!is_flush_fua && !blk_queue_nomerges(q)) { if (blk_attempt_plug_merge(q, bio, &request_count, NULL)) return BLK_QC_T_NONE; } else request_count = blk_plug_queued_count(q); <blk_sq_make_request+0x1a5> mov %eax,0x2c(%rsp) rq = blk_mq_map_request(q, bio, &data); <blk_sq_make_request+0x1a9> callq 0000000000000e70 <blk_mq_map_request> if (unlikely(!rq)) <blk_sq_make_request+0x1ae> test %rax,%rax <blk_sq_make_request+0x1b1> je 0000000000003210 <blk_sq_make_request+0x230> return BLK_QC_T_NONE; cookie = blk_tag_to_qc_t(rq->tag, data.hctx->queue_num); <blk_sq_make_request+0x1b3> mov 0x30(%rsp),%rdx } } static void blk_mq_bio_to_request(struct request *rq, struct bio *bio) { init_request_from_bio(rq, bio); <blk_sq_make_request+0x1b8> mov 0x20(%rsp),%rsi <blk_sq_make_request+0x1bd> mov %rax,%rdi <blk_sq_make_request+0x1c0> mov %rax,(%rsp) <blk_sq_make_request+0x1c4> mov 0x144(%rdx),%r12d <blk_sq_make_request+0x1cb> shl $0x10,%r12d <blk_sq_make_request+0x1cf> or 0x100(%rax),%r12d <blk_sq_make_request+0x1d6> callq 00000000000031bb <blk_sq_make_request+0x1db> blk_account_io_start(rq, 1); <blk_sq_make_request+0x1db> mov (%rsp),%rax <blk_sq_make_request+0x1df> mov $0x1,%esi <blk_sq_make_request+0x1e4> mov %rax,%rdi <blk_sq_make_request+0x1e7> callq 00000000000031cc <blk_sq_make_request+0x1ec> cookie = blk_tag_to_qc_t(rq->tag, data.hctx->queue_num); if (unlikely(is_flush_fua)) { blk_mq_bio_to_request(rq, bio); blk_insert_flush(rq); <blk_sq_make_request+0x1ec> mov (%rsp),%rax <blk_sq_make_request+0x1f0> mov %rax,%rdi <blk_sq_make_request+0x1f3> callq 00000000000031d8 <blk_sq_make_request+0x1f8> if (unlikely(!rq)) return BLK_QC_T_NONE; cookie = blk_tag_to_qc_t(rq->tag, data.hctx->queue_num); if (unlikely(is_flush_fua)) { <blk_sq_make_request+0x1f8> mov $0x1,%esi * an ASYNC request, just ensure that we run it later on. The * latter allows for merging opportunities and more efficient * dispatching. */ run_queue: blk_mq_run_hw_queue(data.hctx, !is_sync || is_flush_fua); <blk_sq_make_request+0x1fd> xor $0x1,%ebx <blk_sq_make_request+0x200> mov 0x30(%rsp),%rdi <blk_sq_make_request+0x205> or %esi,%ebx <blk_sq_make_request+0x207> movzbl %bl,%esi <blk_sq_make_request+0x20a> callq 00000000000031ef <blk_sq_make_request+0x20f> } blk_mq_put_ctx(data.ctx); return cookie; <blk_sq_make_request+0x20f> jmpq 000000000000314a <blk_sq_make_request+0x16a> } blk_queue_split(q, &bio, q->bio_split); if (!is_flush_fua && !blk_queue_nomerges(q)) { if (blk_attempt_plug_merge(q, bio, &request_count, NULL)) <blk_sq_make_request+0x214> mov 0x20(%rsp),%rsi <blk_sq_make_request+0x219> lea 0x2c(%rsp),%rdx <blk_sq_make_request+0x21e> xor %ecx,%ecx <blk_sq_make_request+0x220> mov %r13,%rdi <blk_sq_make_request+0x223> callq 0000000000003208 <blk_sq_make_request+0x228> <blk_sq_make_request+0x228> test %al,%al <blk_sq_make_request+0x22a> je 0000000000003098 <blk_sq_make_request+0xb8> return BLK_QC_T_NONE; <blk_sq_make_request+0x230> mov $0xffffffff,%r12d <blk_sq_make_request+0x236> jmpq 000000000000314a <blk_sq_make_request+0x16a> trace_block_plug(q); blk_mq_put_ctx(data.ctx); if (request_count >= BLK_MAX_REQUEST_COUNT) { blk_flush_plug_list(plug, false); <blk_sq_make_request+0x23b> xor %esi,%esi <blk_sq_make_request+0x23d> mov %r14,%rdi <blk_sq_make_request+0x240> callq 0000000000003225 <blk_sq_make_request+0x245> <blk_sq_make_request+0x245> nopl 0x0(%rax,%rax,1) #include <linux/stringify.h> #include <linux/types.h> static __always_inline bool arch_static_branch(struct static_key *key, bool branch) { asm_volatile_goto("1:" <blk_sq_make_request+0x24a> jmpq 0000000000003121 <blk_sq_make_request+0x141> <blk_sq_make_request+0x24f> nopl 0x0(%rax,%rax,1) <blk_sq_make_request+0x254> jmpq 0000000000003116 <blk_sq_make_request+0x136> * * Plug the request queue @q. Do not allow block operation requests * to be sent to the device driver. Instead, accumulate requests in * the queue to improve throughput performance of the block device. */ TRACE_EVENT(block_plug, <blk_sq_make_request+0x259> mov %gs:0x0(%rip),%eax # 0000000000003240 <blk_sq_make_request+0x260> <blk_sq_make_request+0x260> mov %eax,%eax static __always_inline bool variable_test_bit(long nr, volatile const unsigned long *addr) { bool oldbit; asm volatile("bt %2,%1\n\t" <blk_sq_make_request+0x262> bt %rax,0x0(%rip) # 000000000000324a <blk_sq_make_request+0x26a> <blk_sq_make_request+0x26a> setb %al <blk_sq_make_request+0x26d> test %al,%al <blk_sq_make_request+0x26f> je 0000000000003121 <blk_sq_make_request+0x141> <blk_sq_make_request+0x275> mov 0x0(%rip),%rbx # 000000000000325c <blk_sq_make_request+0x27c> <blk_sq_make_request+0x27c> test %rbx,%rbx <blk_sq_make_request+0x27f> je 0000000000003279 <blk_sq_make_request+0x299> <blk_sq_make_request+0x281> mov (%rbx),%rax <blk_sq_make_request+0x284> mov 0x8(%rbx),%rdi <blk_sq_make_request+0x288> add $0x18,%rbx <blk_sq_make_request+0x28c> mov %r13,%rsi <blk_sq_make_request+0x28f> callq *%rax <blk_sq_make_request+0x291> mov (%rbx),%rax <blk_sq_make_request+0x294> test %rax,%rax <blk_sq_make_request+0x297> jne 0000000000003264 <blk_sq_make_request+0x284> <blk_sq_make_request+0x299> jmpq 0000000000003121 <blk_sq_make_request+0x141> list_add_tail(&rq->queuelist, &plug->mq_list); return cookie; } if (!blk_mq_merge_queue_io(data.hctx, data.ctx, rq, bio)) { <blk_sq_make_request+0x29e> mov 0x38(%rsp),%rax <blk_sq_make_request+0x2a3> mov 0x20(%rsp),%r13 <blk_sq_make_request+0x2a8> mov %rax,0x8(%rsp) blk_account_io_start(rq, 1); } static inline bool hctx_allow_merges(struct blk_mq_hw_ctx *hctx) { return (hctx->flags & BLK_MQ_F_SHOULD_MERGE) && <blk_sq_make_request+0x2ad> mov (%rsp),%rax <blk_sq_make_request+0x2b1> testb $0x1,0xa8(%rax) <blk_sq_make_request+0x2b8> je 0000000000003326 <blk_sq_make_request+0x346> !blk_queue_nomerges(hctx->queue); <blk_sq_make_request+0x2be> mov 0xb0(%rax),%rax <blk_sq_make_request+0x2c5> mov %rax,0x18(%rsp) } static __always_inline bool constant_test_bit(long nr, const volatile unsigned long *addr) { return ((1UL << (nr & (BITS_PER_LONG-1))) & (addr[nr >> _BITOPS_LONG_SHIFT])) != 0; <blk_sq_make_request+0x2ca> mov 0x510(%rax),%rax blk_account_io_start(rq, 1); } static inline bool hctx_allow_merges(struct blk_mq_hw_ctx *hctx) { return (hctx->flags & BLK_MQ_F_SHOULD_MERGE) && <blk_sq_make_request+0x2d1> test $0x1,%ah <blk_sq_make_request+0x2d4> jne 0000000000003326 <blk_sq_make_request+0x346> return true; } static inline bool bio_mergeable(struct bio *bio) { if (bio->bi_opf & REQ_NOMERGE_FLAGS) <blk_sq_make_request+0x2d6> testl $0x100e300,0x14(%r13) <blk_sq_make_request+0x2de> jne 0000000000003326 <blk_sq_make_request+0x346> <blk_sq_make_request+0x2e0> mov 0x8(%rsp),%r15 <blk_sq_make_request+0x2e5> mov %r15,%rdi <blk_sq_make_request+0x2e8> callq 00000000000032cd <blk_sq_make_request+0x2ed> struct blk_mq_ctx *ctx, struct bio *bio) { struct request *rq; int checked = 8; list_for_each_entry_reverse(rq, &ctx->rq_list, queuelist) { <blk_sq_make_request+0x2ed> mov 0x10(%r15),%r14 <blk_sq_make_request+0x2f1> mov %r15,%rax <blk_sq_make_request+0x2f4> mov $0x8,%r15d <blk_sq_make_request+0x2fa> add $0x8,%rax <blk_sq_make_request+0x2fe> mov %rax,0x10(%rsp) <blk_sq_make_request+0x303> cmp %rax,%r14 <blk_sq_make_request+0x306> je 000000000000330c <blk_sq_make_request+0x32c> int el_ret; if (!checked--) break; if (!blk_rq_merge_ok(rq, bio)) <blk_sq_make_request+0x308> mov %r13,%rsi <blk_sq_make_request+0x30b> mov %r14,%rdi <blk_sq_make_request+0x30e> callq 00000000000032f3 <blk_sq_make_request+0x313> <blk_sq_make_request+0x313> test %al,%al <blk_sq_make_request+0x315> jne 0000000000003419 <blk_sq_make_request+0x439> struct blk_mq_ctx *ctx, struct bio *bio) { struct request *rq; int checked = 8; list_for_each_entry_reverse(rq, &ctx->rq_list, queuelist) { <blk_sq_make_request+0x31b> mov 0x8(%r14),%r14 <blk_sq_make_request+0x31f> cmp 0x10(%rsp),%r14 <blk_sq_make_request+0x324> je 000000000000330c <blk_sq_make_request+0x32c> int el_ret; if (!checked--) <blk_sq_make_request+0x326> sub $0x1,%r15d <blk_sq_make_request+0x32a> jne 00000000000032e8 <blk_sq_make_request+0x308> } } static void blk_mq_bio_to_request(struct request *rq, struct bio *bio) { init_request_from_bio(rq, bio); <blk_sq_make_request+0x32c> mov %r13,%rsi <blk_sq_make_request+0x32f> mov %rbp,%rdi <blk_sq_make_request+0x332> callq 0000000000003317 <blk_sq_make_request+0x337> blk_account_io_start(rq, 1); <blk_sq_make_request+0x337> mov $0x1,%esi <blk_sq_make_request+0x33c> mov %rbp,%rdi <blk_sq_make_request+0x33f> callq 0000000000003324 <blk_sq_make_request+0x344> <blk_sq_make_request+0x344> jmp 0000000000003348 <blk_sq_make_request+0x368> } } static void blk_mq_bio_to_request(struct request *rq, struct bio *bio) { init_request_from_bio(rq, bio); <blk_sq_make_request+0x346> mov %r13,%rsi <blk_sq_make_request+0x349> mov %rbp,%rdi <blk_sq_make_request+0x34c> callq 0000000000003331 <blk_sq_make_request+0x351> blk_account_io_start(rq, 1); <blk_sq_make_request+0x351> mov %rbp,%rdi <blk_sq_make_request+0x354> mov $0x1,%esi <blk_sq_make_request+0x359> callq 000000000000333e <blk_sq_make_request+0x35e> <blk_sq_make_request+0x35e> mov 0x8(%rsp),%rdi <blk_sq_make_request+0x363> callq 0000000000003348 <blk_sq_make_request+0x368> struct request *rq, bool at_head) { struct blk_mq_ctx *ctx = rq->mq_ctx; trace_block_rq_insert(hctx->queue, rq); <blk_sq_make_request+0x368> mov (%rsp),%rax } static void __blk_mq_insert_request(struct blk_mq_hw_ctx *hctx, struct request *rq, bool at_head) { struct blk_mq_ctx *ctx = rq->mq_ctx; <blk_sq_make_request+0x36c> mov 0x38(%rbp),%r13 struct request *rq, bool at_head) { struct blk_mq_ctx *ctx = rq->mq_ctx; trace_block_rq_insert(hctx->queue, rq); <blk_sq_make_request+0x370> mov 0xb0(%rax),%r14 <blk_sq_make_request+0x377> nopl 0x0(%rax,%rax,1) <blk_sq_make_request+0x37c> mov 0x10(%r13),%rsi if (at_head) list_add(&rq->queuelist, &ctx->rq_list); else list_add_tail(&rq->queuelist, &ctx->rq_list); <blk_sq_make_request+0x380> lea 0x8(%r13),%rdx <blk_sq_make_request+0x384> mov %rbp,%rdi <blk_sq_make_request+0x387> callq 000000000000336c <blk_sq_make_request+0x38c> struct request *rq, bool at_head) { struct blk_mq_ctx *ctx = rq->mq_ctx; __blk_mq_insert_req_list(hctx, rq, at_head); blk_mq_hctx_mark_pending(hctx, ctx); <blk_sq_make_request+0x38c> mov (%rsp),%rdi <blk_sq_make_request+0x390> lea 0x44(%r13),%rsi <blk_sq_make_request+0x394> callq 0000000000000ab0 <blk_mq_hctx_mark_pending.isra.25> <blk_sq_make_request+0x399> mov 0x8(%rsp),%rdi <blk_sq_make_request+0x39e> callq *0x0 static inline void __raw_spin_unlock(raw_spinlock_t *lock) { spin_release(&lock->dep_map, 1, _RET_IP_); do_raw_spin_unlock(lock); preempt_enable(); <blk_sq_make_request+0x3a5> xor %esi,%esi <blk_sq_make_request+0x3a7> jmpq 00000000000031dd <blk_sq_make_request+0x1fd> <blk_sq_make_request+0x3ac> mov %gs:0x0(%rip),%eax # 0000000000003393 <blk_sq_make_request+0x3b3> <blk_sq_make_request+0x3b3> mov %eax,%eax static __always_inline bool variable_test_bit(long nr, volatile const unsigned long *addr) { bool oldbit; asm volatile("bt %2,%1\n\t" <blk_sq_make_request+0x3b5> bt %rax,0x0(%rip) # 000000000000339d <blk_sq_make_request+0x3bd> <blk_sq_make_request+0x3bd> setb %al <blk_sq_make_request+0x3c0> test %al,%al <blk_sq_make_request+0x3c2> je 0000000000003116 <blk_sq_make_request+0x136> <blk_sq_make_request+0x3c8> mov 0x0(%rip),%rbx # 00000000000033af <blk_sq_make_request+0x3cf> <blk_sq_make_request+0x3cf> test %rbx,%rbx <blk_sq_make_request+0x3d2> je 00000000000033cc <blk_sq_make_request+0x3ec> <blk_sq_make_request+0x3d4> mov (%rbx),%rax <blk_sq_make_request+0x3d7> mov 0x8(%rbx),%rdi <blk_sq_make_request+0x3db> add $0x18,%rbx <blk_sq_make_request+0x3df> mov %r13,%rsi <blk_sq_make_request+0x3e2> callq *%rax <blk_sq_make_request+0x3e4> mov (%rbx),%rax <blk_sq_make_request+0x3e7> test %rax,%rax <blk_sq_make_request+0x3ea> jne 00000000000033b7 <blk_sq_make_request+0x3d7> <blk_sq_make_request+0x3ec> jmpq 0000000000003116 <blk_sq_make_request+0x136> * Called immediately before block operation request @rq is inserted * into queue @q. The fields in the operation request @rq struct can * be examined to determine which device and sectors the pending * operation would access. */ DEFINE_EVENT(block_rq, block_rq_insert, <blk_sq_make_request+0x3f1> mov %gs:0x0(%rip),%eax # 00000000000033d8 <blk_sq_make_request+0x3f8> <blk_sq_make_request+0x3f8> mov %eax,%eax <blk_sq_make_request+0x3fa> bt %rax,0x0(%rip) # 00000000000033e2 <blk_sq_make_request+0x402> <blk_sq_make_request+0x402> setb %al <blk_sq_make_request+0x405> test %al,%al <blk_sq_make_request+0x407> je 000000000000335c <blk_sq_make_request+0x37c> <blk_sq_make_request+0x40d> mov 0x0(%rip),%r15 # 00000000000033f4 <blk_sq_make_request+0x414> <blk_sq_make_request+0x414> test %r15,%r15 <blk_sq_make_request+0x417> je 0000000000003414 <blk_sq_make_request+0x434> <blk_sq_make_request+0x419> mov (%r15),%rcx <blk_sq_make_request+0x41c> mov 0x8(%r15),%rdi <blk_sq_make_request+0x420> add $0x18,%r15 <blk_sq_make_request+0x424> mov %rbp,%rdx <blk_sq_make_request+0x427> mov %r14,%rsi <blk_sq_make_request+0x42a> callq *%rcx <blk_sq_make_request+0x42c> mov (%r15),%rcx <blk_sq_make_request+0x42f> test %rcx,%rcx <blk_sq_make_request+0x432> jne 00000000000033fc <blk_sq_make_request+0x41c> <blk_sq_make_request+0x434> jmpq 000000000000335c <blk_sq_make_request+0x37c> break; if (!blk_rq_merge_ok(rq, bio)) continue; el_ret = blk_try_merge(rq, bio); <blk_sq_make_request+0x439> mov %r13,%rsi <blk_sq_make_request+0x43c> mov %r14,%rdi <blk_sq_make_request+0x43f> callq 0000000000003424 <blk_sq_make_request+0x444> if (el_ret == ELEVATOR_BACK_MERGE) { <blk_sq_make_request+0x444> cmp $0x2,%eax <blk_sq_make_request+0x447> je 0000000000003474 <blk_sq_make_request+0x494> if (bio_attempt_back_merge(q, rq, bio)) { ctx->rq_merged++; return true; } break; } else if (el_ret == ELEVATOR_FRONT_MERGE) { <blk_sq_make_request+0x449> cmp $0x1,%eax <blk_sq_make_request+0x44c> jne 00000000000032fb <blk_sq_make_request+0x31b> if (bio_attempt_front_merge(q, rq, bio)) { <blk_sq_make_request+0x452> mov 0x18(%rsp),%rdi <blk_sq_make_request+0x457> mov %r13,%rdx <blk_sq_make_request+0x45a> mov %r14,%rsi <blk_sq_make_request+0x45d> callq 0000000000003442 <blk_sq_make_request+0x462> <blk_sq_make_request+0x462> test %al,%al <blk_sq_make_request+0x464> je 000000000000330c <blk_sq_make_request+0x32c> ctx->rq_merged++; <blk_sq_make_request+0x46a> mov 0x8(%rsp),%rax <blk_sq_make_request+0x46f> mov 0x8(%rsp),%rdi <blk_sq_make_request+0x474> addq $0x1,0x58(%rax) <blk_sq_make_request+0x479> callq *0x0 blk_mq_bio_to_request(rq, bio); goto insert_rq; } spin_unlock(&ctx->lock); __blk_mq_free_request(hctx, ctx, rq); <blk_sq_make_request+0x480> mov %rdi,%rsi <blk_sq_make_request+0x483> mov (%rsp),%rdi <blk_sq_make_request+0x487> mov %rbp,%rdx <blk_sq_make_request+0x48a> callq 00000000000002f0 <__blk_mq_free_request> return __blk_mq_get_ctx(q, get_cpu()); } static inline void blk_mq_put_ctx(struct blk_mq_ctx *ctx) { put_cpu(); <blk_sq_make_request+0x48f> jmpq 000000000000314a <blk_sq_make_request+0x16a> if (!blk_rq_merge_ok(rq, bio)) continue; el_ret = blk_try_merge(rq, bio); if (el_ret == ELEVATOR_BACK_MERGE) { if (bio_attempt_back_merge(q, rq, bio)) { <blk_sq_make_request+0x494> mov 0x18(%rsp),%rdi <blk_sq_make_request+0x499> mov %r13,%rdx <blk_sq_make_request+0x49c> mov %r14,%rsi <blk_sq_make_request+0x49f> callq 0000000000003484 <blk_sq_make_request+0x4a4> <blk_sq_make_request+0x4a4> test %al,%al <blk_sq_make_request+0x4a6> je 000000000000330c <blk_sq_make_request+0x32c> <blk_sq_make_request+0x4ac> jmp 000000000000344a <blk_sq_make_request+0x46a> blk_mq_run_hw_queue(data.hctx, !is_sync || is_flush_fua); } blk_mq_put_ctx(data.ctx); return cookie; } <blk_sq_make_request+0x4ae> callq 0000000000003493 <blk_sq_make_request+0x4b3> <blk_sq_make_request+0x4b3> data16 data16 data16 nopw %cs:0x0(%rax,%rax,1)