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)
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel
