Dump of assembler code for function public_key_verify_signature:
crypto/asymmetric_keys/public_key.c:
311	{
   0xffffffff8158cd70 <+0>:	call   0xffffffff810cb580 <__fentry__>
   0xffffffff8158cd75 <+5>:	push   %r15
   0xffffffff8158cd77 <+7>:	mov    $0x8,%ecx
   0xffffffff8158cd7c <+12>:	push   %r14
   0xffffffff8158cd7e <+14>:	push   %r13
   0xffffffff8158cd80 <+16>:	push   %r12
   0xffffffff8158cd82 <+18>:	push   %rbp
   0xffffffff8158cd83 <+19>:	push   %rbx
   0xffffffff8158cd84 <+20>:	mov    %rdi,%rbx
   0xffffffff8158cd87 <+23>:	sub    $0x100,%rsp
   0xffffffff8158cd8e <+30>:	mov    %gs:0x28,%rax
   0xffffffff8158cd97 <+39>:	mov    %rax,0xf8(%rsp)
   0xffffffff8158cd9f <+47>:	xor    %eax,%eax
   0xffffffff8158cda1 <+49>:	lea    0x38(%rsp),%r13

312		struct crypto_wait cwait;
313		struct crypto_akcipher *tfm;
314		struct akcipher_request *req;
315		struct scatterlist src_sg[2];
316		char alg_name[CRYPTO_MAX_ALG_NAME];
317		char *key, *ptr;
318		int ret;
319	
320		pr_devel("==>%s()\n", __func__);
321	
322		BUG_ON(!pkey);
   0xffffffff8158cda6 <+54>:	test   %rbx,%rbx
   0xffffffff8158cda9 <+57>:	movq   $0x0,0x10(%rsp)
   0xffffffff8158cdb2 <+66>:	lea    0x78(%rsp),%r12
   0xffffffff8158cdb7 <+71>:	mov    %r13,%rdi
   0xffffffff8158cdba <+74>:	movq   $0x0,0x18(%rsp)
   0xffffffff8158cdc3 <+83>:	movq   $0x0,0x20(%rsp)
   0xffffffff8158cdcc <+92>:	movq   $0x0,0x28(%rsp)
   0xffffffff8158cdd5 <+101>:	movq   $0x0,0x30(%rsp)
   0xffffffff8158cdde <+110>:	rep stos %rax,%es:(%rdi)
   0xffffffff8158cde1 <+113>:	mov    $0x10,%ecx
   0xffffffff8158cde6 <+118>:	mov    %r12,%rdi
   0xffffffff8158cde9 <+121>:	rep stos %rax,%es:(%rdi)
   0xffffffff8158cdec <+124>:	je     0xffffffff8158d0be <public_key_verify_signature+846>

323		BUG_ON(!sig);
   0xffffffff8158cdf2 <+130>:	test   %rsi,%rsi
   0xffffffff8158cdf5 <+133>:	mov    %rsi,%rbp
   0xffffffff8158cdf8 <+136>:	je     0xffffffff8158d0c0 <public_key_verify_signature+848>

324		BUG_ON(!sig->s);
   0xffffffff8158cdfe <+142>:	cmpq   $0x0,0x10(%rsi)
   0xffffffff8158ce03 <+147>:	je     0xffffffff8158d0c2 <public_key_verify_signature+850>

325	
326		ret = software_key_determine_akcipher(sig->encoding,
   0xffffffff8158ce09 <+153>:	mov    0x38(%rsi),%rsi
   0xffffffff8158ce0d <+157>:	mov    %r12,%rcx
   0xffffffff8158ce10 <+160>:	mov    %rbx,%rdx
   0xffffffff8158ce13 <+163>:	mov    0x40(%rbp),%rdi
   0xffffffff8158ce17 <+167>:	call   0xffffffff8158ca80 <software_key_determine_akcipher>

327						      sig->hash_algo,
328						      pkey, alg_name);
329		if (ret < 0)
   0xffffffff8158ce1c <+172>:	test   %eax,%eax
   0xffffffff8158ce1e <+174>:	js     0xffffffff8158d07e <public_key_verify_signature+782>

330			return ret;
331	
332		tfm = crypto_alloc_akcipher(alg_name, 0, 0);
   0xffffffff8158ce24 <+180>:	xor    %edx,%edx
   0xffffffff8158ce26 <+182>:	xor    %esi,%esi
   0xffffffff8158ce28 <+184>:	mov    %r12,%rdi
   0xffffffff8158ce2b <+187>:	call   0xffffffff8156fa50 <crypto_alloc_akcipher>

333		if (IS_ERR(tfm))
   0xffffffff8158ce30 <+192>:	cmp    $0xfffffffffffff000,%rax

332		tfm = crypto_alloc_akcipher(alg_name, 0, 0);
   0xffffffff8158ce36 <+198>:	mov    %rax,%r12

./include/linux/err.h:
36		return IS_ERR_VALUE((unsigned long)ptr);
   0xffffffff8158ce39 <+201>:	ja     0xffffffff8158d07e <public_key_verify_signature+782>

./include/linux/slab.h:
557		return __kmalloc(size, flags);
   0xffffffff8158ce3f <+207>:	mov    0x10(%rax),%rax
   0xffffffff8158ce43 <+211>:	mov    $0xcc0,%esi

./include/crypto/akcipher.h:
196		req = kmalloc(sizeof(*req) + crypto_akcipher_reqsize(tfm), gfp);
   0xffffffff8158ce48 <+216>:	mov    -0x8(%rax),%edi
   0xffffffff8158ce4b <+219>:	add    $0x48,%rdi

./include/linux/slab.h:
557		return __kmalloc(size, flags);
   0xffffffff8158ce4f <+223>:	call   0xffffffff8133e020 <__kmalloc>

./include/crypto/akcipher.h:
197		if (likely(req))
   0xffffffff8158ce54 <+228>:	test   %rax,%rax

./include/linux/slab.h:
557		return __kmalloc(size, flags);
   0xffffffff8158ce57 <+231>:	mov    %rax,%r14

./include/crypto/akcipher.h:
197		if (likely(req))
   0xffffffff8158ce5a <+234>:	je     0xffffffff8158d0c4 <public_key_verify_signature+852>

136		return &tfm->base;
   0xffffffff8158ce60 <+240>:	mov    0x8(%rbx),%edx

137	}
138	
139	static inline struct akcipher_alg *__crypto_akcipher_alg(struct crypto_alg *alg)
140	{
141		return container_of(alg, struct akcipher_alg, base);
142	}
143	
144	static inline struct crypto_akcipher *__crypto_akcipher_tfm(
145		struct crypto_tfm *tfm)
146	{
147		return container_of(tfm, struct crypto_akcipher, base);
148	}
149	
150	static inline struct akcipher_alg *crypto_akcipher_alg(
151		struct crypto_akcipher *tfm)
152	{
153		return __crypto_akcipher_alg(crypto_akcipher_tfm(tfm)->__crt_alg);
154	}
155	
156	static inline unsigned int crypto_akcipher_reqsize(struct crypto_akcipher *tfm)
157	{
158		return crypto_akcipher_alg(tfm)->reqsize;
159	}
160	
161	static inline void akcipher_request_set_tfm(struct akcipher_request *req,
162						    struct crypto_akcipher *tfm)
163	{
164		req->base.tfm = crypto_akcipher_tfm(tfm);
   0xffffffff8158ce63 <+243>:	mov    %r12,0x20(%rax)

./include/linux/slab.h:
557		return __kmalloc(size, flags);
   0xffffffff8158ce67 <+247>:	mov    $0xcc0,%esi

crypto/asymmetric_keys/public_key.c:
341		key = kmalloc(pkey->keylen + sizeof(u32) * 2 + pkey->paramlen,
   0xffffffff8158ce6c <+252>:	mov    0x18(%rbx),%eax
   0xffffffff8158ce6f <+255>:	lea    0x8(%rdx,%rax,1),%rdi

./include/linux/slab.h:
557		return __kmalloc(size, flags);
   0xffffffff8158ce74 <+260>:	call   0xffffffff8133e020 <__kmalloc>

crypto/asymmetric_keys/public_key.c:
343		if (!key)
   0xffffffff8158ce79 <+265>:	test   %rax,%rax

./include/linux/slab.h:
557		return __kmalloc(size, flags);
   0xffffffff8158ce7c <+268>:	mov    %rax,%r15

crypto/asymmetric_keys/public_key.c:
343		if (!key)
   0xffffffff8158ce7f <+271>:	je     0xffffffff8158d12a <public_key_verify_signature+954>

344			goto error_free_req;
345	
346		memcpy(key, pkey->key, pkey->keylen);
   0xffffffff8158ce85 <+277>:	mov    0x8(%rbx),%edx

./include/linux/string.h:
399		return __underlying_memcpy(p, q, size);
   0xffffffff8158ce88 <+280>:	mov    %rax,%rdi
   0xffffffff8158ce8b <+283>:	mov    (%rbx),%rsi

crypto/asymmetric_keys/public_key.c:
346		memcpy(key, pkey->key, pkey->keylen);
   0xffffffff8158ce8e <+286>:	mov    %edx,0xc(%rsp)

./include/linux/string.h:
399		return __underlying_memcpy(p, q, size);
   0xffffffff8158ce92 <+290>:	mov    %rdx,(%rsp)
   0xffffffff8158ce96 <+294>:	call   0xffffffff81fd7590 <memcpy>

crypto/asymmetric_keys/public_key.c:
347		ptr = key + pkey->keylen;
   0xffffffff8158ce9b <+299>:	mov    (%rsp),%rdx
   0xffffffff8158ce9f <+303>:	mov    0xc(%rbx),%eax

./include/linux/string.h:
399		return __underlying_memcpy(p, q, size);
   0xffffffff8158cea2 <+306>:	mov    0x10(%rbx),%rsi

crypto/asymmetric_keys/public_key.c:
347		ptr = key + pkey->keylen;
   0xffffffff8158cea6 <+310>:	lea    (%r15,%rdx,1),%rdi

./include/linux/string.h:
399		return __underlying_memcpy(p, q, size);
   0xffffffff8158ceaa <+314>:	mov    0x18(%rbx),%edx
   0xffffffff8158cead <+317>:	mov    %eax,(%rdi)
   0xffffffff8158ceaf <+319>:	add    $0x8,%rdi
   0xffffffff8158ceb3 <+323>:	mov    %edx,-0x4(%rdi)
   0xffffffff8158ceb6 <+326>:	call   0xffffffff81fd7590 <memcpy>

crypto/asymmetric_keys/public_key.c:
352		if (pkey->key_is_private)
   0xffffffff8158cebb <+331>:	cmpb   $0x0,0x1c(%rbx)
   0xffffffff8158cebf <+335>:	mov    0xc(%rsp),%r8d

./include/crypto/akcipher.h:
414		return alg->set_priv_key(tfm, key, keylen);
   0xffffffff8158cec4 <+340>:	mov    0x10(%r12),%rax

crypto/asymmetric_keys/public_key.c:
352		if (pkey->key_is_private)
   0xffffffff8158cec9 <+345>:	jne    0xffffffff8158d0a7 <public_key_verify_signature+823>

./include/crypto/akcipher.h:
392		return alg->set_pub_key(tfm, key, keylen);
   0xffffffff8158cecf <+351>:	mov    -0x30(%rax),%rax
   0xffffffff8158ced3 <+355>:	mov    %r8d,%edx
   0xffffffff8158ced6 <+358>:	mov    %r15,%rsi
   0xffffffff8158ced9 <+361>:	mov    %r12,%rdi
   0xffffffff8158cedc <+364>:	call   0xffffffff82204c40 <__x86_indirect_thunk_rax>

crypto/asymmetric_keys/public_key.c:
356		if (ret)
   0xffffffff8158cee1 <+369>:	test   %eax,%eax
   0xffffffff8158cee3 <+371>:	jne    0xffffffff8158d059 <public_key_verify_signature+745>

357			goto error_free_key;
358	    
359	    BUG_ON(!sig->pkey_algo);
   0xffffffff8158cee9 <+377>:	mov    0x30(%rbp),%rsi
   0xffffffff8158ceed <+381>:	test   %rsi,%rsi
   0xffffffff8158cef0 <+384>:	je     0xffffffff8158d11f <public_key_verify_signature+943>

360		if (strcmp(sig->pkey_algo, "sm2") == 0 && sig->data_size) {
   0xffffffff8158cef6 <+390>:	mov    $0xffffffff82c427b0,%rdi
   0xffffffff8158cefd <+397>:	mov    $0x4,%ecx
   0xffffffff8158cf02 <+402>:	repz cmpsb %es:(%rdi),%ds:(%rsi)
   0xffffffff8158cf04 <+404>:	seta   %al
   0xffffffff8158cf07 <+407>:	sbb    $0x0,%al
   0xffffffff8158cf09 <+409>:	test   %al,%al
   0xffffffff8158cf0b <+411>:	jne    0xffffffff8158cf18 <public_key_verify_signature+424>
   0xffffffff8158cf0d <+413>:	mov    0x50(%rbp),%eax
   0xffffffff8158cf10 <+416>:	test   %eax,%eax
   0xffffffff8158cf12 <+418>:	jne    0xffffffff8158d0df <public_key_verify_signature+879>

361			ret = cert_sig_digest_update(sig, tfm);
362			if (ret)
363				goto error_free_key;
364		}
365	
366		sg_init_table(src_sg, 2);
   0xffffffff8158cf18 <+424>:	mov    %r13,%rdi
   0xffffffff8158cf1b <+427>:	mov    $0x2,%esi
   0xffffffff8158cf20 <+432>:	call   0xffffffff815e2980 <sg_init_table>

367		sg_set_buf(&src_sg[0], sig->s, sig->s_size);
   0xffffffff8158cf25 <+437>:	mov    0x10(%rbp),%rax
   0xffffffff8158cf29 <+441>:	mov    $0x80000000,%ecx
   0xffffffff8158cf2e <+446>:	mov    0x18(%rbp),%edx

./include/linux/scatterlist.h:
145		sg_set_page(sg, virt_to_page(buf), buflen, offset_in_page(buf));
   0xffffffff8158cf31 <+449>:	mov    %eax,%edi
   0xffffffff8158cf33 <+451>:	and    $0xfff,%edi

./arch/x86/include/asm/page_64.h:
20		unsigned long y = x - __START_KERNEL_map;
   0xffffffff8158cf39 <+457>:	add    %rcx,%rax
   0xffffffff8158cf3c <+460>:	jb     0xffffffff8158d147 <public_key_verify_signature+983>

21	
22		/* use the carry flag to determine if x was < __START_KERNEL_map */
23		x = y + ((x > y) ? phys_base : (__START_KERNEL_map - PAGE_OFFSET));
   0xffffffff8158cf42 <+466>:	mov    $0xffffffff80000000,%rsi
   0xffffffff8158cf49 <+473>:	sub    0x17c3b00(%rip),%rsi        # 0xffffffff82d50a50 <page_offset_base>

24	
25		return x;
   0xffffffff8158cf50 <+480>:	mov    0x17c3ae9(%rip),%rcx        # 0xffffffff82d50a40 <vmemmap_base>

23		x = y + ((x > y) ? phys_base : (__START_KERNEL_map - PAGE_OFFSET));
   0xffffffff8158cf57 <+487>:	add    %rsi,%rax

./include/linux/scatterlist.h:
145		sg_set_page(sg, virt_to_page(buf), buflen, offset_in_page(buf));
   0xffffffff8158cf5a <+490>:	shr    $0xc,%rax
   0xffffffff8158cf5e <+494>:	shl    $0x6,%rax
   0xffffffff8158cf62 <+498>:	lea    (%rax,%rcx,1),%rsi

89		unsigned long page_link = sg->page_link & (SG_CHAIN | SG_END);
   0xffffffff8158cf66 <+502>:	mov    0x38(%rsp),%rax
   0xffffffff8158cf6b <+507>:	and    $0x3,%eax

90	
91		/*
92		 * In order for the low bit stealing approach to work, pages
93		 * must be aligned at a 32-bit boundary as a minimum.
94		 */
95		BUG_ON((unsigned long) page & (SG_CHAIN | SG_END));
   0xffffffff8158cf6e <+510>:	test   $0x3,%cl
   0xffffffff8158cf71 <+513>:	jne    0xffffffff8158d121 <public_key_verify_signature+945>

96	#ifdef CONFIG_DEBUG_SG
97		BUG_ON(sg_is_chain(sg));
98	#endif
99		sg->page_link = page_link | (unsigned long) page;
   0xffffffff8158cf77 <+519>:	or     %rsi,%rax
   0xffffffff8158cf7a <+522>:	mov    $0x80000000,%esi

100	}
101	
102	/**
103	 * sg_set_page - Set sg entry to point at given page
104	 * @sg:		 SG entry
105	 * @page:	 The page
106	 * @len:	 Length of data
107	 * @offset:	 Offset into page
108	 *
109	 * Description:
110	 *   Use this function to set an sg entry pointing at a page, never assign
111	 *   the page directly. We encode sg table information in the lower bits
112	 *   of the page pointer. See sg_page() for looking up the page belonging
113	 *   to an sg entry.
114	 *
115	 **/
116	static inline void sg_set_page(struct scatterlist *sg, struct page *page,
117				       unsigned int len, unsigned int offset)
118	{
119		sg_assign_page(sg, page);
120		sg->offset = offset;
   0xffffffff8158cf7f <+527>:	mov    %edi,0x40(%rsp)

crypto/asymmetric_keys/public_key.c:
368		sg_set_buf(&src_sg[1], sig->digest, sig->digest_size);
   0xffffffff8158cf83 <+531>:	movzbl 0x28(%rbp),%edi

./include/linux/scatterlist.h:
99		sg->page_link = page_link | (unsigned long) page;
   0xffffffff8158cf87 <+535>:	mov    %rax,0x38(%rsp)

121		sg->length = len;
   0xffffffff8158cf8c <+540>:	mov    0x20(%rbp),%rax
   0xffffffff8158cf90 <+544>:	mov    %edx,0x44(%rsp)

122	}
123	
124	static inline struct page *sg_page(struct scatterlist *sg)
125	{
126	#ifdef CONFIG_DEBUG_SG
127		BUG_ON(sg_is_chain(sg));
128	#endif
129		return (struct page *)((sg)->page_link & ~(SG_CHAIN | SG_END));
130	}
131	
132	/**
133	 * sg_set_buf - Set sg entry to point at given data
134	 * @sg:		 SG entry
135	 * @buf:	 Data
136	 * @buflen:	 Data length
137	 *
138	 **/
139	static inline void sg_set_buf(struct scatterlist *sg, const void *buf,
140				      unsigned int buflen)
141	{
142	#ifdef CONFIG_DEBUG_SG
143		BUG_ON(!virt_addr_valid(buf));
144	#endif
145		sg_set_page(sg, virt_to_page(buf), buflen, offset_in_page(buf));
   0xffffffff8158cf94 <+548>:	mov    %eax,%r8d
   0xffffffff8158cf97 <+551>:	and    $0xfff,%r8d

./arch/x86/include/asm/page_64.h:
20		unsigned long y = x - __START_KERNEL_map;
   0xffffffff8158cf9e <+558>:	add    %rsi,%rax
   0xffffffff8158cfa1 <+561>:	jb     0xffffffff8158d153 <public_key_verify_signature+995>

21	
22		/* use the carry flag to determine if x was < __START_KERNEL_map */
23		x = y + ((x > y) ? phys_base : (__START_KERNEL_map - PAGE_OFFSET));
   0xffffffff8158cfa7 <+567>:	mov    $0xffffffff80000000,%rsi
   0xffffffff8158cfae <+574>:	sub    0x17c3a9b(%rip),%rsi        # 0xffffffff82d50a50 <page_offset_base>

24	
25		return x;
   0xffffffff8158cfb5 <+581>:	add    %rsi,%rax

./include/linux/scatterlist.h:
145		sg_set_page(sg, virt_to_page(buf), buflen, offset_in_page(buf));
   0xffffffff8158cfb8 <+584>:	shr    $0xc,%rax
   0xffffffff8158cfbc <+588>:	shl    $0x6,%rax
   0xffffffff8158cfc0 <+592>:	lea    (%rax,%rcx,1),%rsi

89		unsigned long page_link = sg->page_link & (SG_CHAIN | SG_END);
   0xffffffff8158cfc4 <+596>:	mov    0x58(%rsp),%rax
   0xffffffff8158cfc9 <+601>:	and    $0x3,%eax

90	
91		/*
92		 * In order for the low bit stealing approach to work, pages
93		 * must be aligned at a 32-bit boundary as a minimum.
94		 */
95		BUG_ON((unsigned long) page & (SG_CHAIN | SG_END));
   0xffffffff8158cfcc <+604>:	and    $0x3,%ecx
   0xffffffff8158cfcf <+607>:	jne    0xffffffff8158d123 <public_key_verify_signature+947>

96	#ifdef CONFIG_DEBUG_SG
97		BUG_ON(sg_is_chain(sg));
98	#endif
99		sg->page_link = page_link | (unsigned long) page;
   0xffffffff8158cfd5 <+613>:	or     %rsi,%rax

121		sg->length = len;
   0xffffffff8158cfd8 <+616>:	mov    %edi,0x64(%rsp)

./include/linux/completion.h:
88		init_swait_queue_head(&x->wait);
   0xffffffff8158cfdc <+620>:	mov    $0xffffffff82beaddd,%rsi

./include/crypto/akcipher.h:
254		req->src_len = src_len;
   0xffffffff8158cfe3 <+627>:	mov    %edx,0x40(%r14)

./include/linux/completion.h:
88		init_swait_queue_head(&x->wait);
   0xffffffff8158cfe7 <+631>:	mov    $0xffffffff83ab7a41,%rdx

./include/crypto/akcipher.h:
255		req->dst_len = dst_len;
   0xffffffff8158cfee <+638>:	mov    %edi,0x44(%r14)

./include/linux/completion.h:
88		init_swait_queue_head(&x->wait);
   0xffffffff8158cff2 <+642>:	lea    0x18(%rsp),%rdi

./include/linux/scatterlist.h:
99		sg->page_link = page_link | (unsigned long) page;
   0xffffffff8158cff7 <+647>:	mov    %rax,0x58(%rsp)

100	}
101	
102	/**
103	 * sg_set_page - Set sg entry to point at given page
104	 * @sg:		 SG entry
105	 * @page:	 The page
106	 * @len:	 Length of data
107	 * @offset:	 Offset into page
108	 *
109	 * Description:
110	 *   Use this function to set an sg entry pointing at a page, never assign
111	 *   the page directly. We encode sg table information in the lower bits
112	 *   of the page pointer. See sg_page() for looking up the page belonging
113	 *   to an sg entry.
114	 *
115	 **/
116	static inline void sg_set_page(struct scatterlist *sg, struct page *page,
117				       unsigned int len, unsigned int offset)
118	{
119		sg_assign_page(sg, page);
120		sg->offset = offset;
   0xffffffff8158cffc <+652>:	mov    %r8d,0x60(%rsp)

./include/crypto/akcipher.h:
252		req->src = src;
   0xffffffff8158d001 <+657>:	mov    %r13,0x30(%r14)

253		req->dst = dst;
   0xffffffff8158d005 <+661>:	movq   $0x0,0x38(%r14)

./include/linux/completion.h:
87		x->done = 0;
   0xffffffff8158d00d <+669>:	movl   $0x0,0x10(%rsp)

88		init_swait_queue_head(&x->wait);
   0xffffffff8158d015 <+677>:	call   0xffffffff811923d0 <__init_swait_queue_head>

./include/crypto/akcipher.h:
229		req->base.complete = cmpl;
   0xffffffff8158d01a <+682>:	movq   $0xffffffff81569180,0x10(%r14)

230		req->base.data = data;
   0xffffffff8158d022 <+690>:	mov    %r14,%rdi
   0xffffffff8158d025 <+693>:	lea    0x10(%rsp),%rax

231		req->base.flags = flgs;
   0xffffffff8158d02a <+698>:	movl   $0x600,0x28(%r14)

230		req->base.data = data;
   0xffffffff8158d032 <+706>:	mov    %rax,0x18(%r14)

256	}
257	
258	/**
259	 * crypto_akcipher_maxsize() - Get len for output buffer
260	 *
261	 * Function returns the dest buffer size required for a given key.
262	 * Function assumes that the key is already set in the transformation. If this
263	 * function is called without a setkey or with a failed setkey, you will end up
264	 * in a NULL dereference.
265	 *
266	 * @tfm:	AKCIPHER tfm handle allocated with crypto_alloc_akcipher()
267	 */
268	static inline unsigned int crypto_akcipher_maxsize(struct crypto_akcipher *tfm)
269	{
270		struct akcipher_alg *alg = crypto_akcipher_alg(tfm);
271	
272		return alg->max_size(tfm);
273	}
274	
275	/**
276	 * crypto_akcipher_encrypt() - Invoke public key encrypt operation
277	 *
278	 * Function invokes the specific public key encrypt operation for a given
279	 * public key algorithm
280	 *
281	 * @req:	asymmetric key request
282	 *
283	 * Return: zero on success; error code in case of error
284	 */
285	static inline int crypto_akcipher_encrypt(struct akcipher_request *req)
286	{
287		struct crypto_akcipher *tfm = crypto_akcipher_reqtfm(req);
288		struct akcipher_alg *alg = crypto_akcipher_alg(tfm);
289		struct crypto_alg *calg = tfm->base.__crt_alg;
290		unsigned int src_len = req->src_len;
291		int ret;
292	
293		crypto_stats_get(calg);
294		ret = alg->encrypt(req);
295		crypto_stats_akcipher_encrypt(src_len, ret, calg);
296		return ret;
297	}
298	
299	/**
300	 * crypto_akcipher_decrypt() - Invoke public key decrypt operation
301	 *
302	 * Function invokes the specific public key decrypt operation for a given
303	 * public key algorithm
304	 *
305	 * @req:	asymmetric key request
306	 *
307	 * Return: zero on success; error code in case of error
308	 */
309	static inline int crypto_akcipher_decrypt(struct akcipher_request *req)
310	{
311		struct crypto_akcipher *tfm = crypto_akcipher_reqtfm(req);
312		struct akcipher_alg *alg = crypto_akcipher_alg(tfm);
313		struct crypto_alg *calg = tfm->base.__crt_alg;
314		unsigned int src_len = req->src_len;
315		int ret;
316	
317		crypto_stats_get(calg);
318		ret = alg->decrypt(req);
319		crypto_stats_akcipher_decrypt(src_len, ret, calg);
320		return ret;
321	}
322	
323	/**
324	 * crypto_akcipher_sign() - Invoke public key sign operation
325	 *
326	 * Function invokes the specific public key sign operation for a given
327	 * public key algorithm
328	 *
329	 * @req:	asymmetric key request
330	 *
331	 * Return: zero on success; error code in case of error
332	 */
333	static inline int crypto_akcipher_sign(struct akcipher_request *req)
334	{
335		struct crypto_akcipher *tfm = crypto_akcipher_reqtfm(req);
336		struct akcipher_alg *alg = crypto_akcipher_alg(tfm);
337		struct crypto_alg *calg = tfm->base.__crt_alg;
338		int ret;
339	
340		crypto_stats_get(calg);
341		ret = alg->sign(req);
342		crypto_stats_akcipher_sign(ret, calg);
343		return ret;
344	}
345	
346	/**
347	 * crypto_akcipher_verify() - Invoke public key signature verification
348	 *
349	 * Function invokes the specific public key signature verification operation
350	 * for a given public key algorithm.
351	 *
352	 * @req:	asymmetric key request
353	 *
354	 * Note: req->dst should be NULL, req->src should point to SG of size
355	 * (req->src_size + req->dst_size), containing signature (of req->src_size
356	 * length) with appended digest (of req->dst_size length).
357	 *
358	 * Return: zero on verification success; error code in case of error.
359	 */
360	static inline int crypto_akcipher_verify(struct akcipher_request *req)
361	{
362		struct crypto_akcipher *tfm = crypto_akcipher_reqtfm(req);
363		struct akcipher_alg *alg = crypto_akcipher_alg(tfm);
364		struct crypto_alg *calg = tfm->base.__crt_alg;
365		int ret;
366	
367		crypto_stats_get(calg);
368		ret = alg->verify(req);
   0xffffffff8158d036 <+710>:	mov    0x20(%r14),%rax
   0xffffffff8158d03a <+714>:	mov    0x10(%rax),%rax
   0xffffffff8158d03e <+718>:	mov    -0x48(%rax),%rax
   0xffffffff8158d042 <+722>:	call   0xffffffff82204c40 <__x86_indirect_thunk_rax>

./include/linux/crypto.h:
590		switch (err) {
   0xffffffff8158d047 <+727>:	cmp    $0xffffff8d,%eax
   0xffffffff8158d04a <+730>:	je     0xffffffff8158d104 <public_key_verify_signature+916>
   0xffffffff8158d050 <+736>:	cmp    $0xfffffff0,%eax
   0xffffffff8158d053 <+739>:	je     0xffffffff8158d104 <public_key_verify_signature+916>

crypto/asymmetric_keys/public_key.c:
378		kfree(key);
   0xffffffff8158d059 <+745>:	mov    %r15,%rdi
   0xffffffff8158d05c <+748>:	mov    %eax,(%rsp)
   0xffffffff8158d05f <+751>:	call   0xffffffff8133c9c0 <kfree>

./include/crypto/akcipher.h:
210		kfree_sensitive(req);
   0xffffffff8158d064 <+756>:	mov    %r14,%rdi
   0xffffffff8158d067 <+759>:	call   0xffffffff812f0380 <kfree_sensitive>

136		return &tfm->base;
   0xffffffff8158d06c <+764>:	mov    %r12,%rsi
   0xffffffff8158d06f <+767>:	mov    %r12,%rdi
   0xffffffff8158d072 <+770>:	call   0xffffffff81569610 <crypto_destroy_tfm>

crypto/asymmetric_keys/public_key.c:
384		if (WARN_ON_ONCE(ret > 0))
   0xffffffff8158d077 <+775>:	mov    (%rsp),%eax
   0xffffffff8158d07a <+778>:	test   %eax,%eax
   0xffffffff8158d07c <+780>:	jg     0xffffffff8158d0d6 <public_key_verify_signature+870>

386		return ret;
387	}
   0xffffffff8158d07e <+782>:	mov    0xf8(%rsp),%rbx
   0xffffffff8158d086 <+790>:	sub    %gs:0x28,%rbx
   0xffffffff8158d08f <+799>:	jne    0xffffffff8158d125 <public_key_verify_signature+949>
   0xffffffff8158d095 <+805>:	add    $0x100,%rsp
   0xffffffff8158d09c <+812>:	pop    %rbx
   0xffffffff8158d09d <+813>:	pop    %rbp
   0xffffffff8158d09e <+814>:	pop    %r12
   0xffffffff8158d0a0 <+816>:	pop    %r13
   0xffffffff8158d0a2 <+818>:	pop    %r14
   0xffffffff8158d0a4 <+820>:	pop    %r15
   0xffffffff8158d0a6 <+822>:	ret    

./include/crypto/akcipher.h:
414		return alg->set_priv_key(tfm, key, keylen);
   0xffffffff8158d0a7 <+823>:	mov    %r8d,%edx
   0xffffffff8158d0aa <+826>:	mov    %r15,%rsi
   0xffffffff8158d0ad <+829>:	mov    %r12,%rdi
   0xffffffff8158d0b0 <+832>:	mov    -0x28(%rax),%rax
   0xffffffff8158d0b4 <+836>:	call   0xffffffff82204c40 <__x86_indirect_thunk_rax>
   0xffffffff8158d0b9 <+841>:	jmp    0xffffffff8158cee1 <public_key_verify_signature+369>

crypto/asymmetric_keys/public_key.c:
322		BUG_ON(!pkey);
   0xffffffff8158d0be <+846>:	ud2    

323		BUG_ON(!sig);
   0xffffffff8158d0c0 <+848>:	ud2    

324		BUG_ON(!sig->s);
   0xffffffff8158d0c2 <+850>:	ud2    

./include/crypto/akcipher.h:
136		return &tfm->base;
   0xffffffff8158d0c4 <+852>:	mov    %r12,%rsi
   0xffffffff8158d0c7 <+855>:	mov    %r12,%rdi
   0xffffffff8158d0ca <+858>:	call   0xffffffff81569610 <crypto_destroy_tfm>

crypto/asymmetric_keys/public_key.c:
384		if (WARN_ON_ONCE(ret > 0))
   0xffffffff8158d0cf <+863>:	mov    $0xfffffff4,%eax
   0xffffffff8158d0d4 <+868>:	jmp    0xffffffff8158d07e <public_key_verify_signature+782>
   0xffffffff8158d0d6 <+870>:	ud2    

385			ret = -EINVAL;
   0xffffffff8158d0d8 <+872>:	mov    $0xffffffea,%eax
   0xffffffff8158d0dd <+877>:	jmp    0xffffffff8158d07e <public_key_verify_signature+782>

378		kfree(key);
   0xffffffff8158d0df <+879>:	mov    %r15,%rdi
   0xffffffff8158d0e2 <+882>:	call   0xffffffff8133c9c0 <kfree>

./include/crypto/akcipher.h:
210		kfree_sensitive(req);
   0xffffffff8158d0e7 <+887>:	mov    %r14,%rdi
   0xffffffff8158d0ea <+890>:	call   0xffffffff812f0380 <kfree_sensitive>

136		return &tfm->base;
   0xffffffff8158d0ef <+895>:	mov    %r12,%rsi
   0xffffffff8158d0f2 <+898>:	mov    %r12,%rdi
   0xffffffff8158d0f5 <+901>:	call   0xffffffff81569610 <crypto_destroy_tfm>

crypto/asymmetric_keys/public_key.c:
384		if (WARN_ON_ONCE(ret > 0))
   0xffffffff8158d0fa <+906>:	mov    $0xfffffdf4,%eax
   0xffffffff8158d0ff <+911>:	jmp    0xffffffff8158d07e <public_key_verify_signature+782>

./include/linux/crypto.h:
593			wait_for_completion(&wait->completion);
   0xffffffff8158d104 <+916>:	lea    0x10(%rsp),%rdi
   0xffffffff8158d109 <+921>:	call   0xffffffff81fdb650 <wait_for_completion>

./include/linux/completion.h:
100		x->done = 0;
   0xffffffff8158d10e <+926>:	mov    0x30(%rsp),%eax
   0xffffffff8158d112 <+930>:	movl   $0x0,0x10(%rsp)

./include/linux/crypto.h:
599		return err;
   0xffffffff8158d11a <+938>:	jmp    0xffffffff8158d059 <public_key_verify_signature+745>

crypto/asymmetric_keys/public_key.c:
359	    BUG_ON(!sig->pkey_algo);
   0xffffffff8158d11f <+943>:	ud2    

./include/linux/scatterlist.h:
95		BUG_ON((unsigned long) page & (SG_CHAIN | SG_END));
   0xffffffff8158d121 <+945>:	ud2    
   0xffffffff8158d123 <+947>:	ud2    
   0xffffffff8158d125 <+949>:	call   0xffffffff81fd6eb0 <__stack_chk_fail>

./include/crypto/akcipher.h:
210		kfree_sensitive(req);
   0xffffffff8158d12a <+954>:	mov    %r14,%rdi
   0xffffffff8158d12d <+957>:	call   0xffffffff812f0380 <kfree_sensitive>

136		return &tfm->base;
   0xffffffff8158d132 <+962>:	mov    %r12,%rsi
   0xffffffff8158d135 <+965>:	mov    %r12,%rdi
   0xffffffff8158d138 <+968>:	call   0xffffffff81569610 <crypto_destroy_tfm>

crypto/asymmetric_keys/public_key.c:
384		if (WARN_ON_ONCE(ret > 0))
   0xffffffff8158d13d <+973>:	mov    $0xfffffff4,%eax
   0xffffffff8158d142 <+978>:	jmp    0xffffffff8158d07e <public_key_verify_signature+782>

./arch/x86/include/asm/page_64.h:
23		x = y + ((x > y) ? phys_base : (__START_KERNEL_map - PAGE_OFFSET));
   0xffffffff8158d147 <+983>:	mov    0x1a8bec2(%rip),%rsi        # 0xffffffff83019010 <phys_base>
   0xffffffff8158d14e <+990>:	jmp    0xffffffff8158cf50 <public_key_verify_signature+480>
   0xffffffff8158d153 <+995>:	mov    0x1a8beb6(%rip),%rsi        # 0xffffffff83019010 <phys_base>
   0xffffffff8158d15a <+1002>:	jmp    0xffffffff8158cfb5 <public_key_verify_signature+581>
End of assembler dump.