All of lore.kernel.org
 help / color / mirror / Atom feed
* riscv: llvm-compiler: calling convention violation: temporary register $t2 is used to pass the ninth function parameter
@ 2022-05-10  6:53 ` Changbin Du
  0 siblings, 0 replies; 21+ messages in thread
From: Changbin Du @ 2022-05-10  6:53 UTC (permalink / raw)
  To: Paul Walmsley, Palmer Dabbelt, Albert Ou, Steven Rostedt
  Cc: changbin.du, hw.huiwang, linux-riscv, linux-kernel, llvm,
	codegen-riscv, llvmproject

[This is a resent to correct llvm mailist.]

Hello, folks,

Recently I encountered a kernel crash problem when using ftrace with 'perf ftrace'
command on risc-v kernel built with llvm.

This crash only exists on llvm build, not reproducable with GCC. So I hope llvm
guys can take a look :)

The llvm versions I have tried are llvm-13.0.0 and mainline (commit 102bc634cb
("[runtime] Build compiler-rt with --unwindlib=none")).

[  612.947887][  T496] Unable to handle kernel NULL pointer dereference at virtual address 0000000000000001
[  613.050789][  T496] Hardware name: riscv-virtio,qemu (DT)
[  613.087976][  T496] epc : __find_rr_leaf+0x128/0x220
[  613.107493][  T496]  ra : return_to_handler+0x22/0x24
[  613.125322][  T496] epc : ffffffff80a1915a ra : ffffffff80009506 sp : ff20000011e43860
[  613.150124][  T496]  gp : ffffffff81812f40 tp : ff6000008bb01580 t0 : ff600000806cf0f0
[  613.173657][  T496]  t1 : 000000000001b29a t2 : 0000000000000001 s0 : ff20000011e43920
[  613.187311][  T496]  s1 : ff600000848c2a00 a0 : 0000000000000002 a1 : 0000000000000002
[  613.202731][  T496]  a2 : fffffffffffffffd a3 : ff6000009d287000 a4 : 00000000000002c0
[  613.213723][  T496]  a5 : ff6000009d259b40 a6 : ffffffffffffff9c a7 : ffffffffffffffff
[  613.226648][  T496]  s2 : 0000000000000001 s3 : ff20000011e439d8 s4 : ffffffff8160d140
[  613.246571][  T496]  s5 : 0000000000000002 s6 : 0000000000000000 s7 : 0000000000000000
[  613.264681][  T496]  s8 : 0000000000000064 s9 : 0000000000000000 s10: 0000000000400000
[  613.277999][  T496]  s11: ff600000848c2aa8 t3 : 0000000000000290 t4 : 00000000004002c0
[  613.303729][  T496]  t5 : 00000000ffffffff t6 : ff6000009d2872d0
[  613.322145][  T496] status: 0000000200000120 badaddr: 0000000000000001 cause: 000000000000000d
[  613.346228][  T496] [<ffffffff80a12526>] ip6_pol_route+0xb6/0x602
[  613.365722][  T496] [<ffffffff80a1321a>] ip6_pol_route_output+0x2c/0x34
[  613.386374][  T496] [<ffffffff80a1c028>] fib6_rule_lookup+0x36/0xa0
[  613.401865][  T496] [<ffffffff80a131da>] ip6_route_output_flags_noref+0xd6/0xea
[  613.412776][  T496] [<ffffffff80a13274>] ip6_route_output_flags+0x52/0xd4
[  613.432013][  T496] [<ffffffff809ffb3a>] ip6_dst_lookup_tail+0x68/0x23a
[  613.456198][  T496] [<ffffffff809ffec6>] ip6_sk_dst_lookup_flow+0x132/0x1cc
[  613.513174][  T496] [<ffffffff80003cd8>] ret_from_syscall+0x0/0x2
[  613.518973][  T496] [<ffffffff800094e4>] return_to_handler+0x0/0x24
[  613.563961][  T496] Kernel panic - not syncing: Fatal exception
[  613.572278][  T496] SMP: stopping secondary CPUs
[  613.587449][  T496] ---[ end Kernel panic - not syncing: Fatal exception ]---

The crash happened when dereferencing the point 'mpri' at route.c:758.

(gdb) l *__find_rr_leaf+0x128
0xffffffff809da9c4 is in __find_rr_leaf (net/ipv6/route.c:758).
753
754             if (strict & RT6_LOOKUP_F_REACHABLE)
755                     rt6_probe(nh);
756
757             /* note that m can be RT6_NUD_FAIL_PROBE at this point */
758             if (m > *mpri) {
759                     *do_rr = match_do_rr;
760                     *mpri = m;
761                     rc = true;
762             }

Adding some logs, I found the problem. The ninth passed parameter of function
__find_rr_leaf() which is the address of local variable 'mpri', is changed to
value '0x1' when inside the function __find_rr_leaf.
Here is the code snippet and full link
https://github.com/torvalds/linux/blob/9cb7c013420f98fa6fd12fc6a5dc055170c108db/net/ipv6/route.c.

static void find_rr_leaf(struct fib6_node *fn, struct fib6_info *leaf,
			 struct fib6_info *rr_head, int oif, int strict,
			 bool *do_rr, struct fib6_result *res)
{
	u32 metric = rr_head->fib6_metric;
	struct fib6_info *cont = NULL;
	int mpri = -1;

	__find_rr_leaf(rr_head, NULL, metric, res, &cont,
		       oif, strict, do_rr, &mpri);
	...
}

Then debugging with gdb, I found this probably is a compiler bug. We can see the
local function __find_rr_leaf() is not optimized out and the compiler generates
a local symbol for it. The find_rr_leaf() (inlined by fib6_table_lookup) invokes
this function with 'jalr' instruction.

(gdb) disassemble fib6_table_lookup
Dump of assembler code for function fib6_table_lookup:
   [snip]
   0xffffffff80a1240e <+412>:   beqz    a1,0xffffffff80a12436 <fib6_table_lookup+452>
   0xffffffff80a12410 <+414>:   slli    a1,s9,0x20
   0xffffffff80a12414 <+418>:   srli    a1,a1,0x20
   0xffffffff80a12416 <+420>:   sext.w  a2,a1
   0xffffffff80a1241a <+424>:   addi    a7,s0,-125
   0xffffffff80a1241e <+428>:   addi    t2,s0,-124
   0xffffffff80a12422 <+432>:   li      a1,0
   0xffffffff80a12424 <+434>:   mv      a3,s10
   0xffffffff80a12426 <+436>:   li      a4,0
   0xffffffff80a12428 <+438>:   ld      a5,-152(s0)
   0xffffffff80a1242c <+442>:   mv      a6,s8
   0xffffffff80a1242e <+444>:   auipc   ra,0x7
   0xffffffff80a12432 <+448>:   jalr    -686(ra) # 0xffffffff80a19180 <__find_rr_leaf>
   [snip]

And at line route.c:758, the value of point 'mpri' is stored in temporary register
$t2 and $s3 (copied from $t2).

(gdb) info scope __find_rr_leaf
[snip]
Symbol mpri is multi-location:
  Base address 0xffffffff80a10564  Range 0xffffffff80a19190-0xffffffff80a191ae: a variable in $t2
  Range 0xffffffff80a191c0-0xffffffff80a191d6: a variable in $s3
  Range 0xffffffff80a19200-0xffffffff80a19208: a variable in $s3
  Range 0xffffffff80a1921e-0xffffffff80a192fe: a variable in $s3
  Range 0xffffffff80a1930a-0xffffffff80a19356: a variable in $s3

Let's see when register $t2 is corrupted with single-step mode. Obviously, register
$t2 is changed by mcount function ftrace_caller(). This is why the bug happens
to ftrace.

Dump of assembler code for function __find_rr_leaf:
   0xffffffff80a19180 <+0>:     sd      ra,-8(sp)   #  $t2 = 0xff200000120db7b4
   0xffffffff80a19184 <+4>:     auipc   ra,0xff5f1
   0xffffffff80a19188 <+8>:     jalr    -1744(ra) # 0xffffffff80009ab4 <ftrace_caller> #  $t2 = 0xff200000120db7b4
=> 0xffffffff80a1918c <+12>:    ld      ra,-8(sp)    #  $t2 = 0x1, bug, $t2 is corrupted!!
   0xffffffff80a19190 <+16>:    addi    sp,sp,-176
   [snip]

So now we can come to a conclusion. The generated local function __find_rr_leaf()
violates the risc-v calling convention and leads to the panic. It should use stack
but *not* temporary register $t2 to pass the ninth parameter! It's okay if the
callsite can take care of local symbol callees, but the Function Instrumentation
features should be considerated carefully.

For comparison, here is the result from gcc (9.2.0):
(gdb) info scope __find_rr_leaf
[snip]
Symbol mpri is a complex DWARF expression:
     0: DW_OP_fbreg 0, length 8.

I also built a simple test function with 9 parameters by clang and same cflags,
but cannot reproduce it. Maybe it is conditional?

Simple test code:
__attribute__ ((noinline))
void test_func(int *a, int *b, int *c, int *d, int *e, int *f, int *g, int *h, int *i)
{
        printf("__find_rr_leaf: %d\n", *i);
}

int main(void)
{
        int a,b,c,d,e,f,g,h,i = 100;

        test_func(&a,&b,&c,&d,&e,&f,&g,&h,&i);
        return 0;
}

-- 
Cheers,
Changbin Du

^ permalink raw reply	[flat|nested] 21+ messages in thread

* riscv: llvm-compiler: calling convention violation: temporary register $t2 is used to pass the ninth function parameter
@ 2022-05-10  6:53 ` Changbin Du
  0 siblings, 0 replies; 21+ messages in thread
From: Changbin Du @ 2022-05-10  6:53 UTC (permalink / raw)
  To: Paul Walmsley, Palmer Dabbelt, Albert Ou, Steven Rostedt
  Cc: changbin.du, hw.huiwang, linux-riscv, linux-kernel, llvm,
	codegen-riscv, llvmproject

[This is a resent to correct llvm mailist.]

Hello, folks,

Recently I encountered a kernel crash problem when using ftrace with 'perf ftrace'
command on risc-v kernel built with llvm.

This crash only exists on llvm build, not reproducable with GCC. So I hope llvm
guys can take a look :)

The llvm versions I have tried are llvm-13.0.0 and mainline (commit 102bc634cb
("[runtime] Build compiler-rt with --unwindlib=none")).

[  612.947887][  T496] Unable to handle kernel NULL pointer dereference at virtual address 0000000000000001
[  613.050789][  T496] Hardware name: riscv-virtio,qemu (DT)
[  613.087976][  T496] epc : __find_rr_leaf+0x128/0x220
[  613.107493][  T496]  ra : return_to_handler+0x22/0x24
[  613.125322][  T496] epc : ffffffff80a1915a ra : ffffffff80009506 sp : ff20000011e43860
[  613.150124][  T496]  gp : ffffffff81812f40 tp : ff6000008bb01580 t0 : ff600000806cf0f0
[  613.173657][  T496]  t1 : 000000000001b29a t2 : 0000000000000001 s0 : ff20000011e43920
[  613.187311][  T496]  s1 : ff600000848c2a00 a0 : 0000000000000002 a1 : 0000000000000002
[  613.202731][  T496]  a2 : fffffffffffffffd a3 : ff6000009d287000 a4 : 00000000000002c0
[  613.213723][  T496]  a5 : ff6000009d259b40 a6 : ffffffffffffff9c a7 : ffffffffffffffff
[  613.226648][  T496]  s2 : 0000000000000001 s3 : ff20000011e439d8 s4 : ffffffff8160d140
[  613.246571][  T496]  s5 : 0000000000000002 s6 : 0000000000000000 s7 : 0000000000000000
[  613.264681][  T496]  s8 : 0000000000000064 s9 : 0000000000000000 s10: 0000000000400000
[  613.277999][  T496]  s11: ff600000848c2aa8 t3 : 0000000000000290 t4 : 00000000004002c0
[  613.303729][  T496]  t5 : 00000000ffffffff t6 : ff6000009d2872d0
[  613.322145][  T496] status: 0000000200000120 badaddr: 0000000000000001 cause: 000000000000000d
[  613.346228][  T496] [<ffffffff80a12526>] ip6_pol_route+0xb6/0x602
[  613.365722][  T496] [<ffffffff80a1321a>] ip6_pol_route_output+0x2c/0x34
[  613.386374][  T496] [<ffffffff80a1c028>] fib6_rule_lookup+0x36/0xa0
[  613.401865][  T496] [<ffffffff80a131da>] ip6_route_output_flags_noref+0xd6/0xea
[  613.412776][  T496] [<ffffffff80a13274>] ip6_route_output_flags+0x52/0xd4
[  613.432013][  T496] [<ffffffff809ffb3a>] ip6_dst_lookup_tail+0x68/0x23a
[  613.456198][  T496] [<ffffffff809ffec6>] ip6_sk_dst_lookup_flow+0x132/0x1cc
[  613.513174][  T496] [<ffffffff80003cd8>] ret_from_syscall+0x0/0x2
[  613.518973][  T496] [<ffffffff800094e4>] return_to_handler+0x0/0x24
[  613.563961][  T496] Kernel panic - not syncing: Fatal exception
[  613.572278][  T496] SMP: stopping secondary CPUs
[  613.587449][  T496] ---[ end Kernel panic - not syncing: Fatal exception ]---

The crash happened when dereferencing the point 'mpri' at route.c:758.

(gdb) l *__find_rr_leaf+0x128
0xffffffff809da9c4 is in __find_rr_leaf (net/ipv6/route.c:758).
753
754             if (strict & RT6_LOOKUP_F_REACHABLE)
755                     rt6_probe(nh);
756
757             /* note that m can be RT6_NUD_FAIL_PROBE at this point */
758             if (m > *mpri) {
759                     *do_rr = match_do_rr;
760                     *mpri = m;
761                     rc = true;
762             }

Adding some logs, I found the problem. The ninth passed parameter of function
__find_rr_leaf() which is the address of local variable 'mpri', is changed to
value '0x1' when inside the function __find_rr_leaf.
Here is the code snippet and full link
https://github.com/torvalds/linux/blob/9cb7c013420f98fa6fd12fc6a5dc055170c108db/net/ipv6/route.c.

static void find_rr_leaf(struct fib6_node *fn, struct fib6_info *leaf,
			 struct fib6_info *rr_head, int oif, int strict,
			 bool *do_rr, struct fib6_result *res)
{
	u32 metric = rr_head->fib6_metric;
	struct fib6_info *cont = NULL;
	int mpri = -1;

	__find_rr_leaf(rr_head, NULL, metric, res, &cont,
		       oif, strict, do_rr, &mpri);
	...
}

Then debugging with gdb, I found this probably is a compiler bug. We can see the
local function __find_rr_leaf() is not optimized out and the compiler generates
a local symbol for it. The find_rr_leaf() (inlined by fib6_table_lookup) invokes
this function with 'jalr' instruction.

(gdb) disassemble fib6_table_lookup
Dump of assembler code for function fib6_table_lookup:
   [snip]
   0xffffffff80a1240e <+412>:   beqz    a1,0xffffffff80a12436 <fib6_table_lookup+452>
   0xffffffff80a12410 <+414>:   slli    a1,s9,0x20
   0xffffffff80a12414 <+418>:   srli    a1,a1,0x20
   0xffffffff80a12416 <+420>:   sext.w  a2,a1
   0xffffffff80a1241a <+424>:   addi    a7,s0,-125
   0xffffffff80a1241e <+428>:   addi    t2,s0,-124
   0xffffffff80a12422 <+432>:   li      a1,0
   0xffffffff80a12424 <+434>:   mv      a3,s10
   0xffffffff80a12426 <+436>:   li      a4,0
   0xffffffff80a12428 <+438>:   ld      a5,-152(s0)
   0xffffffff80a1242c <+442>:   mv      a6,s8
   0xffffffff80a1242e <+444>:   auipc   ra,0x7
   0xffffffff80a12432 <+448>:   jalr    -686(ra) # 0xffffffff80a19180 <__find_rr_leaf>
   [snip]

And at line route.c:758, the value of point 'mpri' is stored in temporary register
$t2 and $s3 (copied from $t2).

(gdb) info scope __find_rr_leaf
[snip]
Symbol mpri is multi-location:
  Base address 0xffffffff80a10564  Range 0xffffffff80a19190-0xffffffff80a191ae: a variable in $t2
  Range 0xffffffff80a191c0-0xffffffff80a191d6: a variable in $s3
  Range 0xffffffff80a19200-0xffffffff80a19208: a variable in $s3
  Range 0xffffffff80a1921e-0xffffffff80a192fe: a variable in $s3
  Range 0xffffffff80a1930a-0xffffffff80a19356: a variable in $s3

Let's see when register $t2 is corrupted with single-step mode. Obviously, register
$t2 is changed by mcount function ftrace_caller(). This is why the bug happens
to ftrace.

Dump of assembler code for function __find_rr_leaf:
   0xffffffff80a19180 <+0>:     sd      ra,-8(sp)   #  $t2 = 0xff200000120db7b4
   0xffffffff80a19184 <+4>:     auipc   ra,0xff5f1
   0xffffffff80a19188 <+8>:     jalr    -1744(ra) # 0xffffffff80009ab4 <ftrace_caller> #  $t2 = 0xff200000120db7b4
=> 0xffffffff80a1918c <+12>:    ld      ra,-8(sp)    #  $t2 = 0x1, bug, $t2 is corrupted!!
   0xffffffff80a19190 <+16>:    addi    sp,sp,-176
   [snip]

So now we can come to a conclusion. The generated local function __find_rr_leaf()
violates the risc-v calling convention and leads to the panic. It should use stack
but *not* temporary register $t2 to pass the ninth parameter! It's okay if the
callsite can take care of local symbol callees, but the Function Instrumentation
features should be considerated carefully.

For comparison, here is the result from gcc (9.2.0):
(gdb) info scope __find_rr_leaf
[snip]
Symbol mpri is a complex DWARF expression:
     0: DW_OP_fbreg 0, length 8.

I also built a simple test function with 9 parameters by clang and same cflags,
but cannot reproduce it. Maybe it is conditional?

Simple test code:
__attribute__ ((noinline))
void test_func(int *a, int *b, int *c, int *d, int *e, int *f, int *g, int *h, int *i)
{
        printf("__find_rr_leaf: %d\n", *i);
}

int main(void)
{
        int a,b,c,d,e,f,g,h,i = 100;

        test_func(&a,&b,&c,&d,&e,&f,&g,&h,&i);
        return 0;
}

-- 
Cheers,
Changbin Du

_______________________________________________
linux-riscv mailing list
linux-riscv@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-riscv

^ permalink raw reply	[flat|nested] 21+ messages in thread

* Re: riscv: llvm-compiler: calling convention violation: temporary register $t2 is used to pass the ninth function parameter
  2022-05-10  6:53 ` Changbin Du
@ 2022-05-11 18:39   ` Nick Desaulniers
  -1 siblings, 0 replies; 21+ messages in thread
From: Nick Desaulniers @ 2022-05-11 18:39 UTC (permalink / raw)
  To: Changbin Du
  Cc: Paul Walmsley, Palmer Dabbelt, Albert Ou, Steven Rostedt,
	hw.huiwang, linux-riscv, linux-kernel, llvm, codegen-riscv,
	llvmproject, craig.topper, asb

On Mon, May 9, 2022 at 11:54 PM Changbin Du <changbin.du@huawei.com> wrote:
>
> [This is a resent to correct llvm mailist.]
>
> Hello, folks,
>
> Recently I encountered a kernel crash problem when using ftrace with 'perf ftrace'
> command on risc-v kernel built with llvm.
>
> This crash only exists on llvm build, not reproducable with GCC. So I hope llvm
> guys can take a look :)
>
> The llvm versions I have tried are llvm-13.0.0 and mainline (commit 102bc634cb
> ("[runtime] Build compiler-rt with --unwindlib=none")).
>
> [  612.947887][  T496] Unable to handle kernel NULL pointer dereference at virtual address 0000000000000001
> [  613.050789][  T496] Hardware name: riscv-virtio,qemu (DT)
> [  613.087976][  T496] epc : __find_rr_leaf+0x128/0x220
> [  613.107493][  T496]  ra : return_to_handler+0x22/0x24
> [  613.125322][  T496] epc : ffffffff80a1915a ra : ffffffff80009506 sp : ff20000011e43860
> [  613.150124][  T496]  gp : ffffffff81812f40 tp : ff6000008bb01580 t0 : ff600000806cf0f0
> [  613.173657][  T496]  t1 : 000000000001b29a t2 : 0000000000000001 s0 : ff20000011e43920
> [  613.187311][  T496]  s1 : ff600000848c2a00 a0 : 0000000000000002 a1 : 0000000000000002
> [  613.202731][  T496]  a2 : fffffffffffffffd a3 : ff6000009d287000 a4 : 00000000000002c0
> [  613.213723][  T496]  a5 : ff6000009d259b40 a6 : ffffffffffffff9c a7 : ffffffffffffffff
> [  613.226648][  T496]  s2 : 0000000000000001 s3 : ff20000011e439d8 s4 : ffffffff8160d140
> [  613.246571][  T496]  s5 : 0000000000000002 s6 : 0000000000000000 s7 : 0000000000000000
> [  613.264681][  T496]  s8 : 0000000000000064 s9 : 0000000000000000 s10: 0000000000400000
> [  613.277999][  T496]  s11: ff600000848c2aa8 t3 : 0000000000000290 t4 : 00000000004002c0
> [  613.303729][  T496]  t5 : 00000000ffffffff t6 : ff6000009d2872d0
> [  613.322145][  T496] status: 0000000200000120 badaddr: 0000000000000001 cause: 000000000000000d
> [  613.346228][  T496] [<ffffffff80a12526>] ip6_pol_route+0xb6/0x602
> [  613.365722][  T496] [<ffffffff80a1321a>] ip6_pol_route_output+0x2c/0x34
> [  613.386374][  T496] [<ffffffff80a1c028>] fib6_rule_lookup+0x36/0xa0
> [  613.401865][  T496] [<ffffffff80a131da>] ip6_route_output_flags_noref+0xd6/0xea
> [  613.412776][  T496] [<ffffffff80a13274>] ip6_route_output_flags+0x52/0xd4
> [  613.432013][  T496] [<ffffffff809ffb3a>] ip6_dst_lookup_tail+0x68/0x23a
> [  613.456198][  T496] [<ffffffff809ffec6>] ip6_sk_dst_lookup_flow+0x132/0x1cc
> [  613.513174][  T496] [<ffffffff80003cd8>] ret_from_syscall+0x0/0x2
> [  613.518973][  T496] [<ffffffff800094e4>] return_to_handler+0x0/0x24
> [  613.563961][  T496] Kernel panic - not syncing: Fatal exception
> [  613.572278][  T496] SMP: stopping secondary CPUs
> [  613.587449][  T496] ---[ end Kernel panic - not syncing: Fatal exception ]---
>
> The crash happened when dereferencing the point 'mpri' at route.c:758.
>
> (gdb) l *__find_rr_leaf+0x128
> 0xffffffff809da9c4 is in __find_rr_leaf (net/ipv6/route.c:758).
> 753
> 754             if (strict & RT6_LOOKUP_F_REACHABLE)
> 755                     rt6_probe(nh);
> 756
> 757             /* note that m can be RT6_NUD_FAIL_PROBE at this point */
> 758             if (m > *mpri) {
> 759                     *do_rr = match_do_rr;
> 760                     *mpri = m;
> 761                     rc = true;
> 762             }
>
> Adding some logs, I found the problem. The ninth passed parameter of function
> __find_rr_leaf() which is the address of local variable 'mpri', is changed to
> value '0x1' when inside the function __find_rr_leaf.
> Here is the code snippet and full link
> https://github.com/torvalds/linux/blob/9cb7c013420f98fa6fd12fc6a5dc055170c108db/net/ipv6/route.c.
>
> static void find_rr_leaf(struct fib6_node *fn, struct fib6_info *leaf,
>                          struct fib6_info *rr_head, int oif, int strict,
>                          bool *do_rr, struct fib6_result *res)
> {
>         u32 metric = rr_head->fib6_metric;
>         struct fib6_info *cont = NULL;
>         int mpri = -1;
>
>         __find_rr_leaf(rr_head, NULL, metric, res, &cont,
>                        oif, strict, do_rr, &mpri);
>         ...
> }
>
> Then debugging with gdb, I found this probably is a compiler bug. We can see the
> local function __find_rr_leaf() is not optimized out and the compiler generates
> a local symbol for it. The find_rr_leaf() (inlined by fib6_table_lookup) invokes
> this function with 'jalr' instruction.
>
> (gdb) disassemble fib6_table_lookup
> Dump of assembler code for function fib6_table_lookup:
>    [snip]
>    0xffffffff80a1240e <+412>:   beqz    a1,0xffffffff80a12436 <fib6_table_lookup+452>
>    0xffffffff80a12410 <+414>:   slli    a1,s9,0x20
>    0xffffffff80a12414 <+418>:   srli    a1,a1,0x20
>    0xffffffff80a12416 <+420>:   sext.w  a2,a1
>    0xffffffff80a1241a <+424>:   addi    a7,s0,-125
>    0xffffffff80a1241e <+428>:   addi    t2,s0,-124
>    0xffffffff80a12422 <+432>:   li      a1,0
>    0xffffffff80a12424 <+434>:   mv      a3,s10
>    0xffffffff80a12426 <+436>:   li      a4,0
>    0xffffffff80a12428 <+438>:   ld      a5,-152(s0)
>    0xffffffff80a1242c <+442>:   mv      a6,s8
>    0xffffffff80a1242e <+444>:   auipc   ra,0x7
>    0xffffffff80a12432 <+448>:   jalr    -686(ra) # 0xffffffff80a19180 <__find_rr_leaf>
>    [snip]
>
> And at line route.c:758, the value of point 'mpri' is stored in temporary register
> $t2 and $s3 (copied from $t2).
>
> (gdb) info scope __find_rr_leaf
> [snip]
> Symbol mpri is multi-location:
>   Base address 0xffffffff80a10564  Range 0xffffffff80a19190-0xffffffff80a191ae: a variable in $t2
>   Range 0xffffffff80a191c0-0xffffffff80a191d6: a variable in $s3
>   Range 0xffffffff80a19200-0xffffffff80a19208: a variable in $s3
>   Range 0xffffffff80a1921e-0xffffffff80a192fe: a variable in $s3
>   Range 0xffffffff80a1930a-0xffffffff80a19356: a variable in $s3
>
> Let's see when register $t2 is corrupted with single-step mode. Obviously, register
> $t2 is changed by mcount function ftrace_caller(). This is why the bug happens
> to ftrace.
>
> Dump of assembler code for function __find_rr_leaf:
>    0xffffffff80a19180 <+0>:     sd      ra,-8(sp)   #  $t2 = 0xff200000120db7b4
>    0xffffffff80a19184 <+4>:     auipc   ra,0xff5f1
>    0xffffffff80a19188 <+8>:     jalr    -1744(ra) # 0xffffffff80009ab4 <ftrace_caller> #  $t2 = 0xff200000120db7b4
> => 0xffffffff80a1918c <+12>:    ld      ra,-8(sp)    #  $t2 = 0x1, bug, $t2 is corrupted!!
>    0xffffffff80a19190 <+16>:    addi    sp,sp,-176
>    [snip]
>
> So now we can come to a conclusion. The generated local function __find_rr_leaf()
> violates the risc-v calling convention and leads to the panic. It should use stack
> but *not* temporary register $t2 to pass the ninth parameter! It's okay if the
> callsite can take care of local symbol callees, but the Function Instrumentation
> features should be considerated carefully.
>
> For comparison, here is the result from gcc (9.2.0):
> (gdb) info scope __find_rr_leaf
> [snip]
> Symbol mpri is a complex DWARF expression:
>      0: DW_OP_fbreg 0, length 8.
>
> I also built a simple test function with 9 parameters by clang and same cflags,
> but cannot reproduce it. Maybe it is conditional?
>
> Simple test code:
> __attribute__ ((noinline))
> void test_func(int *a, int *b, int *c, int *d, int *e, int *f, int *g, int *h, int *i)
> {
>         printf("__find_rr_leaf: %d\n", *i);
> }
>
> int main(void)
> {
>         int a,b,c,d,e,f,g,h,i = 100;
>
>         test_func(&a,&b,&c,&d,&e,&f,&g,&h,&i);
>         return 0;
> }

Hmm...any chance you could come up with a more concise test case then
using creduce [0] or cvise [1]?
[0] https://embed.cs.utah.edu/creduce/
[1] https://github.com/marxin/cvise


>
> --
> Cheers,
> Changbin Du
>


-- 
Thanks,
~Nick Desaulniers

^ permalink raw reply	[flat|nested] 21+ messages in thread

* Re: riscv: llvm-compiler: calling convention violation: temporary register $t2 is used to pass the ninth function parameter
@ 2022-05-11 18:39   ` Nick Desaulniers
  0 siblings, 0 replies; 21+ messages in thread
From: Nick Desaulniers @ 2022-05-11 18:39 UTC (permalink / raw)
  To: Changbin Du
  Cc: Paul Walmsley, Palmer Dabbelt, Albert Ou, Steven Rostedt,
	hw.huiwang, linux-riscv, linux-kernel, llvm, codegen-riscv,
	llvmproject, craig.topper, asb

On Mon, May 9, 2022 at 11:54 PM Changbin Du <changbin.du@huawei.com> wrote:
>
> [This is a resent to correct llvm mailist.]
>
> Hello, folks,
>
> Recently I encountered a kernel crash problem when using ftrace with 'perf ftrace'
> command on risc-v kernel built with llvm.
>
> This crash only exists on llvm build, not reproducable with GCC. So I hope llvm
> guys can take a look :)
>
> The llvm versions I have tried are llvm-13.0.0 and mainline (commit 102bc634cb
> ("[runtime] Build compiler-rt with --unwindlib=none")).
>
> [  612.947887][  T496] Unable to handle kernel NULL pointer dereference at virtual address 0000000000000001
> [  613.050789][  T496] Hardware name: riscv-virtio,qemu (DT)
> [  613.087976][  T496] epc : __find_rr_leaf+0x128/0x220
> [  613.107493][  T496]  ra : return_to_handler+0x22/0x24
> [  613.125322][  T496] epc : ffffffff80a1915a ra : ffffffff80009506 sp : ff20000011e43860
> [  613.150124][  T496]  gp : ffffffff81812f40 tp : ff6000008bb01580 t0 : ff600000806cf0f0
> [  613.173657][  T496]  t1 : 000000000001b29a t2 : 0000000000000001 s0 : ff20000011e43920
> [  613.187311][  T496]  s1 : ff600000848c2a00 a0 : 0000000000000002 a1 : 0000000000000002
> [  613.202731][  T496]  a2 : fffffffffffffffd a3 : ff6000009d287000 a4 : 00000000000002c0
> [  613.213723][  T496]  a5 : ff6000009d259b40 a6 : ffffffffffffff9c a7 : ffffffffffffffff
> [  613.226648][  T496]  s2 : 0000000000000001 s3 : ff20000011e439d8 s4 : ffffffff8160d140
> [  613.246571][  T496]  s5 : 0000000000000002 s6 : 0000000000000000 s7 : 0000000000000000
> [  613.264681][  T496]  s8 : 0000000000000064 s9 : 0000000000000000 s10: 0000000000400000
> [  613.277999][  T496]  s11: ff600000848c2aa8 t3 : 0000000000000290 t4 : 00000000004002c0
> [  613.303729][  T496]  t5 : 00000000ffffffff t6 : ff6000009d2872d0
> [  613.322145][  T496] status: 0000000200000120 badaddr: 0000000000000001 cause: 000000000000000d
> [  613.346228][  T496] [<ffffffff80a12526>] ip6_pol_route+0xb6/0x602
> [  613.365722][  T496] [<ffffffff80a1321a>] ip6_pol_route_output+0x2c/0x34
> [  613.386374][  T496] [<ffffffff80a1c028>] fib6_rule_lookup+0x36/0xa0
> [  613.401865][  T496] [<ffffffff80a131da>] ip6_route_output_flags_noref+0xd6/0xea
> [  613.412776][  T496] [<ffffffff80a13274>] ip6_route_output_flags+0x52/0xd4
> [  613.432013][  T496] [<ffffffff809ffb3a>] ip6_dst_lookup_tail+0x68/0x23a
> [  613.456198][  T496] [<ffffffff809ffec6>] ip6_sk_dst_lookup_flow+0x132/0x1cc
> [  613.513174][  T496] [<ffffffff80003cd8>] ret_from_syscall+0x0/0x2
> [  613.518973][  T496] [<ffffffff800094e4>] return_to_handler+0x0/0x24
> [  613.563961][  T496] Kernel panic - not syncing: Fatal exception
> [  613.572278][  T496] SMP: stopping secondary CPUs
> [  613.587449][  T496] ---[ end Kernel panic - not syncing: Fatal exception ]---
>
> The crash happened when dereferencing the point 'mpri' at route.c:758.
>
> (gdb) l *__find_rr_leaf+0x128
> 0xffffffff809da9c4 is in __find_rr_leaf (net/ipv6/route.c:758).
> 753
> 754             if (strict & RT6_LOOKUP_F_REACHABLE)
> 755                     rt6_probe(nh);
> 756
> 757             /* note that m can be RT6_NUD_FAIL_PROBE at this point */
> 758             if (m > *mpri) {
> 759                     *do_rr = match_do_rr;
> 760                     *mpri = m;
> 761                     rc = true;
> 762             }
>
> Adding some logs, I found the problem. The ninth passed parameter of function
> __find_rr_leaf() which is the address of local variable 'mpri', is changed to
> value '0x1' when inside the function __find_rr_leaf.
> Here is the code snippet and full link
> https://github.com/torvalds/linux/blob/9cb7c013420f98fa6fd12fc6a5dc055170c108db/net/ipv6/route.c.
>
> static void find_rr_leaf(struct fib6_node *fn, struct fib6_info *leaf,
>                          struct fib6_info *rr_head, int oif, int strict,
>                          bool *do_rr, struct fib6_result *res)
> {
>         u32 metric = rr_head->fib6_metric;
>         struct fib6_info *cont = NULL;
>         int mpri = -1;
>
>         __find_rr_leaf(rr_head, NULL, metric, res, &cont,
>                        oif, strict, do_rr, &mpri);
>         ...
> }
>
> Then debugging with gdb, I found this probably is a compiler bug. We can see the
> local function __find_rr_leaf() is not optimized out and the compiler generates
> a local symbol for it. The find_rr_leaf() (inlined by fib6_table_lookup) invokes
> this function with 'jalr' instruction.
>
> (gdb) disassemble fib6_table_lookup
> Dump of assembler code for function fib6_table_lookup:
>    [snip]
>    0xffffffff80a1240e <+412>:   beqz    a1,0xffffffff80a12436 <fib6_table_lookup+452>
>    0xffffffff80a12410 <+414>:   slli    a1,s9,0x20
>    0xffffffff80a12414 <+418>:   srli    a1,a1,0x20
>    0xffffffff80a12416 <+420>:   sext.w  a2,a1
>    0xffffffff80a1241a <+424>:   addi    a7,s0,-125
>    0xffffffff80a1241e <+428>:   addi    t2,s0,-124
>    0xffffffff80a12422 <+432>:   li      a1,0
>    0xffffffff80a12424 <+434>:   mv      a3,s10
>    0xffffffff80a12426 <+436>:   li      a4,0
>    0xffffffff80a12428 <+438>:   ld      a5,-152(s0)
>    0xffffffff80a1242c <+442>:   mv      a6,s8
>    0xffffffff80a1242e <+444>:   auipc   ra,0x7
>    0xffffffff80a12432 <+448>:   jalr    -686(ra) # 0xffffffff80a19180 <__find_rr_leaf>
>    [snip]
>
> And at line route.c:758, the value of point 'mpri' is stored in temporary register
> $t2 and $s3 (copied from $t2).
>
> (gdb) info scope __find_rr_leaf
> [snip]
> Symbol mpri is multi-location:
>   Base address 0xffffffff80a10564  Range 0xffffffff80a19190-0xffffffff80a191ae: a variable in $t2
>   Range 0xffffffff80a191c0-0xffffffff80a191d6: a variable in $s3
>   Range 0xffffffff80a19200-0xffffffff80a19208: a variable in $s3
>   Range 0xffffffff80a1921e-0xffffffff80a192fe: a variable in $s3
>   Range 0xffffffff80a1930a-0xffffffff80a19356: a variable in $s3
>
> Let's see when register $t2 is corrupted with single-step mode. Obviously, register
> $t2 is changed by mcount function ftrace_caller(). This is why the bug happens
> to ftrace.
>
> Dump of assembler code for function __find_rr_leaf:
>    0xffffffff80a19180 <+0>:     sd      ra,-8(sp)   #  $t2 = 0xff200000120db7b4
>    0xffffffff80a19184 <+4>:     auipc   ra,0xff5f1
>    0xffffffff80a19188 <+8>:     jalr    -1744(ra) # 0xffffffff80009ab4 <ftrace_caller> #  $t2 = 0xff200000120db7b4
> => 0xffffffff80a1918c <+12>:    ld      ra,-8(sp)    #  $t2 = 0x1, bug, $t2 is corrupted!!
>    0xffffffff80a19190 <+16>:    addi    sp,sp,-176
>    [snip]
>
> So now we can come to a conclusion. The generated local function __find_rr_leaf()
> violates the risc-v calling convention and leads to the panic. It should use stack
> but *not* temporary register $t2 to pass the ninth parameter! It's okay if the
> callsite can take care of local symbol callees, but the Function Instrumentation
> features should be considerated carefully.
>
> For comparison, here is the result from gcc (9.2.0):
> (gdb) info scope __find_rr_leaf
> [snip]
> Symbol mpri is a complex DWARF expression:
>      0: DW_OP_fbreg 0, length 8.
>
> I also built a simple test function with 9 parameters by clang and same cflags,
> but cannot reproduce it. Maybe it is conditional?
>
> Simple test code:
> __attribute__ ((noinline))
> void test_func(int *a, int *b, int *c, int *d, int *e, int *f, int *g, int *h, int *i)
> {
>         printf("__find_rr_leaf: %d\n", *i);
> }
>
> int main(void)
> {
>         int a,b,c,d,e,f,g,h,i = 100;
>
>         test_func(&a,&b,&c,&d,&e,&f,&g,&h,&i);
>         return 0;
> }

Hmm...any chance you could come up with a more concise test case then
using creduce [0] or cvise [1]?
[0] https://embed.cs.utah.edu/creduce/
[1] https://github.com/marxin/cvise


>
> --
> Cheers,
> Changbin Du
>


-- 
Thanks,
~Nick Desaulniers

_______________________________________________
linux-riscv mailing list
linux-riscv@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-riscv

^ permalink raw reply	[flat|nested] 21+ messages in thread

* Re: riscv: llvm-compiler: calling convention violation: temporary register $t2 is used to pass the ninth function parameter
  2022-05-11 18:39   ` Nick Desaulniers
@ 2022-05-11 20:07     ` Craig Topper
  -1 siblings, 0 replies; 21+ messages in thread
From: Craig Topper @ 2022-05-11 20:07 UTC (permalink / raw)
  To: Nick Desaulniers
  Cc: Changbin Du, Paul Walmsley, Palmer Dabbelt, Albert Ou,
	Steven Rostedt, hw.huiwang, linux-riscv, linux-kernel, llvm,
	codegen-riscv, llvmproject, asb

I’m guessing that because the function is static, the calling convention was changed to fastcall which allows us to ignore the ABI.

> On May 11, 2022, at 11:39 AM, Nick Desaulniers <ndesaulniers@google.com> wrote:
> 
> On Mon, May 9, 2022 at 11:54 PM Changbin Du <changbin.du@huawei.com> wrote:
>> 
>> [This is a resent to correct llvm mailist.]
>> 
>> Hello, folks,
>> 
>> Recently I encountered a kernel crash problem when using ftrace with 'perf ftrace'
>> command on risc-v kernel built with llvm.
>> 
>> This crash only exists on llvm build, not reproducable with GCC. So I hope llvm
>> guys can take a look :)
>> 
>> The llvm versions I have tried are llvm-13.0.0 and mainline (commit 102bc634cb
>> ("[runtime] Build compiler-rt with --unwindlib=none")).
>> 
>> [  612.947887][  T496] Unable to handle kernel NULL pointer dereference at virtual address 0000000000000001
>> [  613.050789][  T496] Hardware name: riscv-virtio,qemu (DT)
>> [  613.087976][  T496] epc : __find_rr_leaf+0x128/0x220
>> [  613.107493][  T496]  ra : return_to_handler+0x22/0x24
>> [  613.125322][  T496] epc : ffffffff80a1915a ra : ffffffff80009506 sp : ff20000011e43860
>> [  613.150124][  T496]  gp : ffffffff81812f40 tp : ff6000008bb01580 t0 : ff600000806cf0f0
>> [  613.173657][  T496]  t1 : 000000000001b29a t2 : 0000000000000001 s0 : ff20000011e43920
>> [  613.187311][  T496]  s1 : ff600000848c2a00 a0 : 0000000000000002 a1 : 0000000000000002
>> [  613.202731][  T496]  a2 : fffffffffffffffd a3 : ff6000009d287000 a4 : 00000000000002c0
>> [  613.213723][  T496]  a5 : ff6000009d259b40 a6 : ffffffffffffff9c a7 : ffffffffffffffff
>> [  613.226648][  T496]  s2 : 0000000000000001 s3 : ff20000011e439d8 s4 : ffffffff8160d140
>> [  613.246571][  T496]  s5 : 0000000000000002 s6 : 0000000000000000 s7 : 0000000000000000
>> [  613.264681][  T496]  s8 : 0000000000000064 s9 : 0000000000000000 s10: 0000000000400000
>> [  613.277999][  T496]  s11: ff600000848c2aa8 t3 : 0000000000000290 t4 : 00000000004002c0
>> [  613.303729][  T496]  t5 : 00000000ffffffff t6 : ff6000009d2872d0
>> [  613.322145][  T496] status: 0000000200000120 badaddr: 0000000000000001 cause: 000000000000000d
>> [  613.346228][  T496] [<ffffffff80a12526>] ip6_pol_route+0xb6/0x602
>> [  613.365722][  T496] [<ffffffff80a1321a>] ip6_pol_route_output+0x2c/0x34
>> [  613.386374][  T496] [<ffffffff80a1c028>] fib6_rule_lookup+0x36/0xa0
>> [  613.401865][  T496] [<ffffffff80a131da>] ip6_route_output_flags_noref+0xd6/0xea
>> [  613.412776][  T496] [<ffffffff80a13274>] ip6_route_output_flags+0x52/0xd4
>> [  613.432013][  T496] [<ffffffff809ffb3a>] ip6_dst_lookup_tail+0x68/0x23a
>> [  613.456198][  T496] [<ffffffff809ffec6>] ip6_sk_dst_lookup_flow+0x132/0x1cc
>> [  613.513174][  T496] [<ffffffff80003cd8>] ret_from_syscall+0x0/0x2
>> [  613.518973][  T496] [<ffffffff800094e4>] return_to_handler+0x0/0x24
>> [  613.563961][  T496] Kernel panic - not syncing: Fatal exception
>> [  613.572278][  T496] SMP: stopping secondary CPUs
>> [  613.587449][  T496] ---[ end Kernel panic - not syncing: Fatal exception ]---
>> 
>> The crash happened when dereferencing the point 'mpri' at route.c:758.
>> 
>> (gdb) l *__find_rr_leaf+0x128
>> 0xffffffff809da9c4 is in __find_rr_leaf (net/ipv6/route.c:758).
>> 753
>> 754             if (strict & RT6_LOOKUP_F_REACHABLE)
>> 755                     rt6_probe(nh);
>> 756
>> 757             /* note that m can be RT6_NUD_FAIL_PROBE at this point */
>> 758             if (m > *mpri) {
>> 759                     *do_rr = match_do_rr;
>> 760                     *mpri = m;
>> 761                     rc = true;
>> 762             }
>> 
>> Adding some logs, I found the problem. The ninth passed parameter of function
>> __find_rr_leaf() which is the address of local variable 'mpri', is changed to
>> value '0x1' when inside the function __find_rr_leaf.
>> Here is the code snippet and full link
>> https://github.com/torvalds/linux/blob/9cb7c013420f98fa6fd12fc6a5dc055170c108db/net/ipv6/route.c.
>> 
>> static void find_rr_leaf(struct fib6_node *fn, struct fib6_info *leaf,
>>                         struct fib6_info *rr_head, int oif, int strict,
>>                         bool *do_rr, struct fib6_result *res)
>> {
>>        u32 metric = rr_head->fib6_metric;
>>        struct fib6_info *cont = NULL;
>>        int mpri = -1;
>> 
>>        __find_rr_leaf(rr_head, NULL, metric, res, &cont,
>>                       oif, strict, do_rr, &mpri);
>>        ...
>> }
>> 
>> Then debugging with gdb, I found this probably is a compiler bug. We can see the
>> local function __find_rr_leaf() is not optimized out and the compiler generates
>> a local symbol for it. The find_rr_leaf() (inlined by fib6_table_lookup) invokes
>> this function with 'jalr' instruction.
>> 
>> (gdb) disassemble fib6_table_lookup
>> Dump of assembler code for function fib6_table_lookup:
>>   [snip]
>>   0xffffffff80a1240e <+412>:   beqz    a1,0xffffffff80a12436 <fib6_table_lookup+452>
>>   0xffffffff80a12410 <+414>:   slli    a1,s9,0x20
>>   0xffffffff80a12414 <+418>:   srli    a1,a1,0x20
>>   0xffffffff80a12416 <+420>:   sext.w  a2,a1
>>   0xffffffff80a1241a <+424>:   addi    a7,s0,-125
>>   0xffffffff80a1241e <+428>:   addi    t2,s0,-124
>>   0xffffffff80a12422 <+432>:   li      a1,0
>>   0xffffffff80a12424 <+434>:   mv      a3,s10
>>   0xffffffff80a12426 <+436>:   li      a4,0
>>   0xffffffff80a12428 <+438>:   ld      a5,-152(s0)
>>   0xffffffff80a1242c <+442>:   mv      a6,s8
>>   0xffffffff80a1242e <+444>:   auipc   ra,0x7
>>   0xffffffff80a12432 <+448>:   jalr    -686(ra) # 0xffffffff80a19180 <__find_rr_leaf>
>>   [snip]
>> 
>> And at line route.c:758, the value of point 'mpri' is stored in temporary register
>> $t2 and $s3 (copied from $t2).
>> 
>> (gdb) info scope __find_rr_leaf
>> [snip]
>> Symbol mpri is multi-location:
>>  Base address 0xffffffff80a10564  Range 0xffffffff80a19190-0xffffffff80a191ae: a variable in $t2
>>  Range 0xffffffff80a191c0-0xffffffff80a191d6: a variable in $s3
>>  Range 0xffffffff80a19200-0xffffffff80a19208: a variable in $s3
>>  Range 0xffffffff80a1921e-0xffffffff80a192fe: a variable in $s3
>>  Range 0xffffffff80a1930a-0xffffffff80a19356: a variable in $s3
>> 
>> Let's see when register $t2 is corrupted with single-step mode. Obviously, register
>> $t2 is changed by mcount function ftrace_caller(). This is why the bug happens
>> to ftrace.
>> 
>> Dump of assembler code for function __find_rr_leaf:
>>   0xffffffff80a19180 <+0>:     sd      ra,-8(sp)   #  $t2 = 0xff200000120db7b4
>>   0xffffffff80a19184 <+4>:     auipc   ra,0xff5f1
>>   0xffffffff80a19188 <+8>:     jalr    -1744(ra) # 0xffffffff80009ab4 <ftrace_caller> #  $t2 = 0xff200000120db7b4
>> => 0xffffffff80a1918c <+12>:    ld      ra,-8(sp)    #  $t2 = 0x1, bug, $t2 is corrupted!!
>>   0xffffffff80a19190 <+16>:    addi    sp,sp,-176
>>   [snip]
>> 
>> So now we can come to a conclusion. The generated local function __find_rr_leaf()
>> violates the risc-v calling convention and leads to the panic. It should use stack
>> but *not* temporary register $t2 to pass the ninth parameter! It's okay if the
>> callsite can take care of local symbol callees, but the Function Instrumentation
>> features should be considerated carefully.
>> 
>> For comparison, here is the result from gcc (9.2.0):
>> (gdb) info scope __find_rr_leaf
>> [snip]
>> Symbol mpri is a complex DWARF expression:
>>     0: DW_OP_fbreg 0, length 8.
>> 
>> I also built a simple test function with 9 parameters by clang and same cflags,
>> but cannot reproduce it. Maybe it is conditional?
>> 
>> Simple test code:
>> __attribute__ ((noinline))
>> void test_func(int *a, int *b, int *c, int *d, int *e, int *f, int *g, int *h, int *i)
>> {
>>        printf("__find_rr_leaf: %d\n", *i);
>> }
>> 
>> int main(void)
>> {
>>        int a,b,c,d,e,f,g,h,i = 100;
>> 
>>        test_func(&a,&b,&c,&d,&e,&f,&g,&h,&i);
>>        return 0;
>> }
> 
> Hmm...any chance you could come up with a more concise test case then
> using creduce [0] or cvise [1]?
> [0] https://embed.cs.utah.edu/creduce/
> [1] https://github.com/marxin/cvise
> 
> 
>> 
>> --
>> Cheers,
>> Changbin Du
>> 
> 
> 
> -- 
> Thanks,
> ~Nick Desaulniers


^ permalink raw reply	[flat|nested] 21+ messages in thread

* Re: riscv: llvm-compiler: calling convention violation: temporary register $t2 is used to pass the ninth function parameter
@ 2022-05-11 20:07     ` Craig Topper
  0 siblings, 0 replies; 21+ messages in thread
From: Craig Topper @ 2022-05-11 20:07 UTC (permalink / raw)
  To: Nick Desaulniers
  Cc: Changbin Du, Paul Walmsley, Palmer Dabbelt, Albert Ou,
	Steven Rostedt, hw.huiwang, linux-riscv, linux-kernel, llvm,
	codegen-riscv, llvmproject, asb

I’m guessing that because the function is static, the calling convention was changed to fastcall which allows us to ignore the ABI.

> On May 11, 2022, at 11:39 AM, Nick Desaulniers <ndesaulniers@google.com> wrote:
> 
> On Mon, May 9, 2022 at 11:54 PM Changbin Du <changbin.du@huawei.com> wrote:
>> 
>> [This is a resent to correct llvm mailist.]
>> 
>> Hello, folks,
>> 
>> Recently I encountered a kernel crash problem when using ftrace with 'perf ftrace'
>> command on risc-v kernel built with llvm.
>> 
>> This crash only exists on llvm build, not reproducable with GCC. So I hope llvm
>> guys can take a look :)
>> 
>> The llvm versions I have tried are llvm-13.0.0 and mainline (commit 102bc634cb
>> ("[runtime] Build compiler-rt with --unwindlib=none")).
>> 
>> [  612.947887][  T496] Unable to handle kernel NULL pointer dereference at virtual address 0000000000000001
>> [  613.050789][  T496] Hardware name: riscv-virtio,qemu (DT)
>> [  613.087976][  T496] epc : __find_rr_leaf+0x128/0x220
>> [  613.107493][  T496]  ra : return_to_handler+0x22/0x24
>> [  613.125322][  T496] epc : ffffffff80a1915a ra : ffffffff80009506 sp : ff20000011e43860
>> [  613.150124][  T496]  gp : ffffffff81812f40 tp : ff6000008bb01580 t0 : ff600000806cf0f0
>> [  613.173657][  T496]  t1 : 000000000001b29a t2 : 0000000000000001 s0 : ff20000011e43920
>> [  613.187311][  T496]  s1 : ff600000848c2a00 a0 : 0000000000000002 a1 : 0000000000000002
>> [  613.202731][  T496]  a2 : fffffffffffffffd a3 : ff6000009d287000 a4 : 00000000000002c0
>> [  613.213723][  T496]  a5 : ff6000009d259b40 a6 : ffffffffffffff9c a7 : ffffffffffffffff
>> [  613.226648][  T496]  s2 : 0000000000000001 s3 : ff20000011e439d8 s4 : ffffffff8160d140
>> [  613.246571][  T496]  s5 : 0000000000000002 s6 : 0000000000000000 s7 : 0000000000000000
>> [  613.264681][  T496]  s8 : 0000000000000064 s9 : 0000000000000000 s10: 0000000000400000
>> [  613.277999][  T496]  s11: ff600000848c2aa8 t3 : 0000000000000290 t4 : 00000000004002c0
>> [  613.303729][  T496]  t5 : 00000000ffffffff t6 : ff6000009d2872d0
>> [  613.322145][  T496] status: 0000000200000120 badaddr: 0000000000000001 cause: 000000000000000d
>> [  613.346228][  T496] [<ffffffff80a12526>] ip6_pol_route+0xb6/0x602
>> [  613.365722][  T496] [<ffffffff80a1321a>] ip6_pol_route_output+0x2c/0x34
>> [  613.386374][  T496] [<ffffffff80a1c028>] fib6_rule_lookup+0x36/0xa0
>> [  613.401865][  T496] [<ffffffff80a131da>] ip6_route_output_flags_noref+0xd6/0xea
>> [  613.412776][  T496] [<ffffffff80a13274>] ip6_route_output_flags+0x52/0xd4
>> [  613.432013][  T496] [<ffffffff809ffb3a>] ip6_dst_lookup_tail+0x68/0x23a
>> [  613.456198][  T496] [<ffffffff809ffec6>] ip6_sk_dst_lookup_flow+0x132/0x1cc
>> [  613.513174][  T496] [<ffffffff80003cd8>] ret_from_syscall+0x0/0x2
>> [  613.518973][  T496] [<ffffffff800094e4>] return_to_handler+0x0/0x24
>> [  613.563961][  T496] Kernel panic - not syncing: Fatal exception
>> [  613.572278][  T496] SMP: stopping secondary CPUs
>> [  613.587449][  T496] ---[ end Kernel panic - not syncing: Fatal exception ]---
>> 
>> The crash happened when dereferencing the point 'mpri' at route.c:758.
>> 
>> (gdb) l *__find_rr_leaf+0x128
>> 0xffffffff809da9c4 is in __find_rr_leaf (net/ipv6/route.c:758).
>> 753
>> 754             if (strict & RT6_LOOKUP_F_REACHABLE)
>> 755                     rt6_probe(nh);
>> 756
>> 757             /* note that m can be RT6_NUD_FAIL_PROBE at this point */
>> 758             if (m > *mpri) {
>> 759                     *do_rr = match_do_rr;
>> 760                     *mpri = m;
>> 761                     rc = true;
>> 762             }
>> 
>> Adding some logs, I found the problem. The ninth passed parameter of function
>> __find_rr_leaf() which is the address of local variable 'mpri', is changed to
>> value '0x1' when inside the function __find_rr_leaf.
>> Here is the code snippet and full link
>> https://github.com/torvalds/linux/blob/9cb7c013420f98fa6fd12fc6a5dc055170c108db/net/ipv6/route.c.
>> 
>> static void find_rr_leaf(struct fib6_node *fn, struct fib6_info *leaf,
>>                         struct fib6_info *rr_head, int oif, int strict,
>>                         bool *do_rr, struct fib6_result *res)
>> {
>>        u32 metric = rr_head->fib6_metric;
>>        struct fib6_info *cont = NULL;
>>        int mpri = -1;
>> 
>>        __find_rr_leaf(rr_head, NULL, metric, res, &cont,
>>                       oif, strict, do_rr, &mpri);
>>        ...
>> }
>> 
>> Then debugging with gdb, I found this probably is a compiler bug. We can see the
>> local function __find_rr_leaf() is not optimized out and the compiler generates
>> a local symbol for it. The find_rr_leaf() (inlined by fib6_table_lookup) invokes
>> this function with 'jalr' instruction.
>> 
>> (gdb) disassemble fib6_table_lookup
>> Dump of assembler code for function fib6_table_lookup:
>>   [snip]
>>   0xffffffff80a1240e <+412>:   beqz    a1,0xffffffff80a12436 <fib6_table_lookup+452>
>>   0xffffffff80a12410 <+414>:   slli    a1,s9,0x20
>>   0xffffffff80a12414 <+418>:   srli    a1,a1,0x20
>>   0xffffffff80a12416 <+420>:   sext.w  a2,a1
>>   0xffffffff80a1241a <+424>:   addi    a7,s0,-125
>>   0xffffffff80a1241e <+428>:   addi    t2,s0,-124
>>   0xffffffff80a12422 <+432>:   li      a1,0
>>   0xffffffff80a12424 <+434>:   mv      a3,s10
>>   0xffffffff80a12426 <+436>:   li      a4,0
>>   0xffffffff80a12428 <+438>:   ld      a5,-152(s0)
>>   0xffffffff80a1242c <+442>:   mv      a6,s8
>>   0xffffffff80a1242e <+444>:   auipc   ra,0x7
>>   0xffffffff80a12432 <+448>:   jalr    -686(ra) # 0xffffffff80a19180 <__find_rr_leaf>
>>   [snip]
>> 
>> And at line route.c:758, the value of point 'mpri' is stored in temporary register
>> $t2 and $s3 (copied from $t2).
>> 
>> (gdb) info scope __find_rr_leaf
>> [snip]
>> Symbol mpri is multi-location:
>>  Base address 0xffffffff80a10564  Range 0xffffffff80a19190-0xffffffff80a191ae: a variable in $t2
>>  Range 0xffffffff80a191c0-0xffffffff80a191d6: a variable in $s3
>>  Range 0xffffffff80a19200-0xffffffff80a19208: a variable in $s3
>>  Range 0xffffffff80a1921e-0xffffffff80a192fe: a variable in $s3
>>  Range 0xffffffff80a1930a-0xffffffff80a19356: a variable in $s3
>> 
>> Let's see when register $t2 is corrupted with single-step mode. Obviously, register
>> $t2 is changed by mcount function ftrace_caller(). This is why the bug happens
>> to ftrace.
>> 
>> Dump of assembler code for function __find_rr_leaf:
>>   0xffffffff80a19180 <+0>:     sd      ra,-8(sp)   #  $t2 = 0xff200000120db7b4
>>   0xffffffff80a19184 <+4>:     auipc   ra,0xff5f1
>>   0xffffffff80a19188 <+8>:     jalr    -1744(ra) # 0xffffffff80009ab4 <ftrace_caller> #  $t2 = 0xff200000120db7b4
>> => 0xffffffff80a1918c <+12>:    ld      ra,-8(sp)    #  $t2 = 0x1, bug, $t2 is corrupted!!
>>   0xffffffff80a19190 <+16>:    addi    sp,sp,-176
>>   [snip]
>> 
>> So now we can come to a conclusion. The generated local function __find_rr_leaf()
>> violates the risc-v calling convention and leads to the panic. It should use stack
>> but *not* temporary register $t2 to pass the ninth parameter! It's okay if the
>> callsite can take care of local symbol callees, but the Function Instrumentation
>> features should be considerated carefully.
>> 
>> For comparison, here is the result from gcc (9.2.0):
>> (gdb) info scope __find_rr_leaf
>> [snip]
>> Symbol mpri is a complex DWARF expression:
>>     0: DW_OP_fbreg 0, length 8.
>> 
>> I also built a simple test function with 9 parameters by clang and same cflags,
>> but cannot reproduce it. Maybe it is conditional?
>> 
>> Simple test code:
>> __attribute__ ((noinline))
>> void test_func(int *a, int *b, int *c, int *d, int *e, int *f, int *g, int *h, int *i)
>> {
>>        printf("__find_rr_leaf: %d\n", *i);
>> }
>> 
>> int main(void)
>> {
>>        int a,b,c,d,e,f,g,h,i = 100;
>> 
>>        test_func(&a,&b,&c,&d,&e,&f,&g,&h,&i);
>>        return 0;
>> }
> 
> Hmm...any chance you could come up with a more concise test case then
> using creduce [0] or cvise [1]?
> [0] https://embed.cs.utah.edu/creduce/
> [1] https://github.com/marxin/cvise
> 
> 
>> 
>> --
>> Cheers,
>> Changbin Du
>> 
> 
> 
> -- 
> Thanks,
> ~Nick Desaulniers


_______________________________________________
linux-riscv mailing list
linux-riscv@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-riscv

^ permalink raw reply	[flat|nested] 21+ messages in thread

* Re: riscv: llvm-compiler: calling convention violation: temporary register $t2 is used to pass the ninth function parameter
  2022-05-11 18:39   ` Nick Desaulniers
@ 2022-05-12  8:28     ` Changbin Du
  -1 siblings, 0 replies; 21+ messages in thread
From: Changbin Du @ 2022-05-12  8:28 UTC (permalink / raw)
  To: Nick Desaulniers
  Cc: Changbin Du, Paul Walmsley, Palmer Dabbelt, Albert Ou,
	Steven Rostedt, hw.huiwang, linux-riscv, linux-kernel, llvm,
	codegen-riscv, llvmproject, craig.topper, asb

On Wed, May 11, 2022 at 11:39:07AM -0700, Nick Desaulniers wrote:
> On Mon, May 9, 2022 at 11:54 PM Changbin Du <changbin.du@huawei.com> wrote:
> >
[snip]
> > I also built a simple test function with 9 parameters by clang and same cflags,
> > but cannot reproduce it. Maybe it is conditional?
> >
> > Simple test code:
> > __attribute__ ((noinline))
> > void test_func(int *a, int *b, int *c, int *d, int *e, int *f, int *g, int *h, int *i)
> > {
> >         printf("__find_rr_leaf: %d\n", *i);
> > }
> >
> > int main(void)
> > {
> >         int a,b,c,d,e,f,g,h,i = 100;
> >
> >         test_func(&a,&b,&c,&d,&e,&f,&g,&h,&i);
> >         return 0;
> > }
> 
> Hmm...any chance you could come up with a more concise test case then
> using creduce [0] or cvise [1]?
> [0] https://embed.cs.utah.edu/creduce/
> [1] https://github.com/marxin/cvise
> 
>
okay, let me try to reduce the orignal source with creduce.

> 
> 
> -- 
> Thanks,
> ~Nick Desaulniers

-- 
Cheers,
Changbin Du

^ permalink raw reply	[flat|nested] 21+ messages in thread

* Re: riscv: llvm-compiler: calling convention violation: temporary register $t2 is used to pass the ninth function parameter
@ 2022-05-12  8:28     ` Changbin Du
  0 siblings, 0 replies; 21+ messages in thread
From: Changbin Du @ 2022-05-12  8:28 UTC (permalink / raw)
  To: Nick Desaulniers
  Cc: Changbin Du, Paul Walmsley, Palmer Dabbelt, Albert Ou,
	Steven Rostedt, hw.huiwang, linux-riscv, linux-kernel, llvm,
	codegen-riscv, llvmproject, craig.topper, asb

On Wed, May 11, 2022 at 11:39:07AM -0700, Nick Desaulniers wrote:
> On Mon, May 9, 2022 at 11:54 PM Changbin Du <changbin.du@huawei.com> wrote:
> >
[snip]
> > I also built a simple test function with 9 parameters by clang and same cflags,
> > but cannot reproduce it. Maybe it is conditional?
> >
> > Simple test code:
> > __attribute__ ((noinline))
> > void test_func(int *a, int *b, int *c, int *d, int *e, int *f, int *g, int *h, int *i)
> > {
> >         printf("__find_rr_leaf: %d\n", *i);
> > }
> >
> > int main(void)
> > {
> >         int a,b,c,d,e,f,g,h,i = 100;
> >
> >         test_func(&a,&b,&c,&d,&e,&f,&g,&h,&i);
> >         return 0;
> > }
> 
> Hmm...any chance you could come up with a more concise test case then
> using creduce [0] or cvise [1]?
> [0] https://embed.cs.utah.edu/creduce/
> [1] https://github.com/marxin/cvise
> 
>
okay, let me try to reduce the orignal source with creduce.

> 
> 
> -- 
> Thanks,
> ~Nick Desaulniers

-- 
Cheers,
Changbin Du

_______________________________________________
linux-riscv mailing list
linux-riscv@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-riscv

^ permalink raw reply	[flat|nested] 21+ messages in thread

* Re: riscv: llvm-compiler: calling convention violation: temporary register $t2 is used to pass the ninth function parameter
  2022-05-11 20:07     ` Craig Topper
@ 2022-05-12  8:30       ` Changbin Du
  -1 siblings, 0 replies; 21+ messages in thread
From: Changbin Du @ 2022-05-12  8:30 UTC (permalink / raw)
  To: Craig Topper
  Cc: Nick Desaulniers, Changbin Du, Paul Walmsley, Palmer Dabbelt,
	Albert Ou, Steven Rostedt, hw.huiwang, linux-riscv, linux-kernel,
	llvm, codegen-riscv, llvmproject, asb

On Wed, May 11, 2022 at 01:07:14PM -0700, Craig Topper wrote:
> I’m guessing that because the function is static, the calling convention was changed to fastcall which allows us to ignore the ABI.
> 
I think so. But the mcount function assumes the ABI is not changed.

> > On May 11, 2022, at 11:39 AM, Nick Desaulniers <ndesaulniers@google.com> wrote:
> > 
> > On Mon, May 9, 2022 at 11:54 PM Changbin Du <changbin.du@huawei.com> wrote:
> >> 
> >> [This is a resent to correct llvm mailist.]
> >> 
> >> Hello, folks,
> >> 
> >> Recently I encountered a kernel crash problem when using ftrace with 'perf ftrace'
> >> command on risc-v kernel built with llvm.
> >> 
> >> This crash only exists on llvm build, not reproducable with GCC. So I hope llvm
> >> guys can take a look :)
> >> 
> >> The llvm versions I have tried are llvm-13.0.0 and mainline (commit 102bc634cb
> >> ("[runtime] Build compiler-rt with --unwindlib=none")).
> >> 
> >> [  612.947887][  T496] Unable to handle kernel NULL pointer dereference at virtual address 0000000000000001
> >> [  613.050789][  T496] Hardware name: riscv-virtio,qemu (DT)
> >> [  613.087976][  T496] epc : __find_rr_leaf+0x128/0x220
> >> [  613.107493][  T496]  ra : return_to_handler+0x22/0x24
> >> [  613.125322][  T496] epc : ffffffff80a1915a ra : ffffffff80009506 sp : ff20000011e43860
> >> [  613.150124][  T496]  gp : ffffffff81812f40 tp : ff6000008bb01580 t0 : ff600000806cf0f0
> >> [  613.173657][  T496]  t1 : 000000000001b29a t2 : 0000000000000001 s0 : ff20000011e43920
> >> [  613.187311][  T496]  s1 : ff600000848c2a00 a0 : 0000000000000002 a1 : 0000000000000002
> >> [  613.202731][  T496]  a2 : fffffffffffffffd a3 : ff6000009d287000 a4 : 00000000000002c0
> >> [  613.213723][  T496]  a5 : ff6000009d259b40 a6 : ffffffffffffff9c a7 : ffffffffffffffff
> >> [  613.226648][  T496]  s2 : 0000000000000001 s3 : ff20000011e439d8 s4 : ffffffff8160d140
> >> [  613.246571][  T496]  s5 : 0000000000000002 s6 : 0000000000000000 s7 : 0000000000000000
> >> [  613.264681][  T496]  s8 : 0000000000000064 s9 : 0000000000000000 s10: 0000000000400000
> >> [  613.277999][  T496]  s11: ff600000848c2aa8 t3 : 0000000000000290 t4 : 00000000004002c0
> >> [  613.303729][  T496]  t5 : 00000000ffffffff t6 : ff6000009d2872d0
> >> [  613.322145][  T496] status: 0000000200000120 badaddr: 0000000000000001 cause: 000000000000000d
> >> [  613.346228][  T496] [<ffffffff80a12526>] ip6_pol_route+0xb6/0x602
> >> [  613.365722][  T496] [<ffffffff80a1321a>] ip6_pol_route_output+0x2c/0x34
> >> [  613.386374][  T496] [<ffffffff80a1c028>] fib6_rule_lookup+0x36/0xa0
> >> [  613.401865][  T496] [<ffffffff80a131da>] ip6_route_output_flags_noref+0xd6/0xea
> >> [  613.412776][  T496] [<ffffffff80a13274>] ip6_route_output_flags+0x52/0xd4
> >> [  613.432013][  T496] [<ffffffff809ffb3a>] ip6_dst_lookup_tail+0x68/0x23a
> >> [  613.456198][  T496] [<ffffffff809ffec6>] ip6_sk_dst_lookup_flow+0x132/0x1cc
> >> [  613.513174][  T496] [<ffffffff80003cd8>] ret_from_syscall+0x0/0x2
> >> [  613.518973][  T496] [<ffffffff800094e4>] return_to_handler+0x0/0x24
> >> [  613.563961][  T496] Kernel panic - not syncing: Fatal exception
> >> [  613.572278][  T496] SMP: stopping secondary CPUs
> >> [  613.587449][  T496] ---[ end Kernel panic - not syncing: Fatal exception ]---
> >> 
> >> The crash happened when dereferencing the point 'mpri' at route.c:758.
> >> 
> >> (gdb) l *__find_rr_leaf+0x128
> >> 0xffffffff809da9c4 is in __find_rr_leaf (net/ipv6/route.c:758).
> >> 753
> >> 754             if (strict & RT6_LOOKUP_F_REACHABLE)
> >> 755                     rt6_probe(nh);
> >> 756
> >> 757             /* note that m can be RT6_NUD_FAIL_PROBE at this point */
> >> 758             if (m > *mpri) {
> >> 759                     *do_rr = match_do_rr;
> >> 760                     *mpri = m;
> >> 761                     rc = true;
> >> 762             }
> >> 
> >> Adding some logs, I found the problem. The ninth passed parameter of function
> >> __find_rr_leaf() which is the address of local variable 'mpri', is changed to
> >> value '0x1' when inside the function __find_rr_leaf.
> >> Here is the code snippet and full link
> >> https://github.com/torvalds/linux/blob/9cb7c013420f98fa6fd12fc6a5dc055170c108db/net/ipv6/route.c.
> >> 
> >> static void find_rr_leaf(struct fib6_node *fn, struct fib6_info *leaf,
> >>                         struct fib6_info *rr_head, int oif, int strict,
> >>                         bool *do_rr, struct fib6_result *res)
> >> {
> >>        u32 metric = rr_head->fib6_metric;
> >>        struct fib6_info *cont = NULL;
> >>        int mpri = -1;
> >> 
> >>        __find_rr_leaf(rr_head, NULL, metric, res, &cont,
> >>                       oif, strict, do_rr, &mpri);
> >>        ...
> >> }
> >> 
> >> Then debugging with gdb, I found this probably is a compiler bug. We can see the
> >> local function __find_rr_leaf() is not optimized out and the compiler generates
> >> a local symbol for it. The find_rr_leaf() (inlined by fib6_table_lookup) invokes
> >> this function with 'jalr' instruction.
> >> 
> >> (gdb) disassemble fib6_table_lookup
> >> Dump of assembler code for function fib6_table_lookup:
> >>   [snip]
> >>   0xffffffff80a1240e <+412>:   beqz    a1,0xffffffff80a12436 <fib6_table_lookup+452>
> >>   0xffffffff80a12410 <+414>:   slli    a1,s9,0x20
> >>   0xffffffff80a12414 <+418>:   srli    a1,a1,0x20
> >>   0xffffffff80a12416 <+420>:   sext.w  a2,a1
> >>   0xffffffff80a1241a <+424>:   addi    a7,s0,-125
> >>   0xffffffff80a1241e <+428>:   addi    t2,s0,-124
> >>   0xffffffff80a12422 <+432>:   li      a1,0
> >>   0xffffffff80a12424 <+434>:   mv      a3,s10
> >>   0xffffffff80a12426 <+436>:   li      a4,0
> >>   0xffffffff80a12428 <+438>:   ld      a5,-152(s0)
> >>   0xffffffff80a1242c <+442>:   mv      a6,s8
> >>   0xffffffff80a1242e <+444>:   auipc   ra,0x7
> >>   0xffffffff80a12432 <+448>:   jalr    -686(ra) # 0xffffffff80a19180 <__find_rr_leaf>
> >>   [snip]
> >> 
> >> And at line route.c:758, the value of point 'mpri' is stored in temporary register
> >> $t2 and $s3 (copied from $t2).
> >> 
> >> (gdb) info scope __find_rr_leaf
> >> [snip]
> >> Symbol mpri is multi-location:
> >>  Base address 0xffffffff80a10564  Range 0xffffffff80a19190-0xffffffff80a191ae: a variable in $t2
> >>  Range 0xffffffff80a191c0-0xffffffff80a191d6: a variable in $s3
> >>  Range 0xffffffff80a19200-0xffffffff80a19208: a variable in $s3
> >>  Range 0xffffffff80a1921e-0xffffffff80a192fe: a variable in $s3
> >>  Range 0xffffffff80a1930a-0xffffffff80a19356: a variable in $s3
> >> 
> >> Let's see when register $t2 is corrupted with single-step mode. Obviously, register
> >> $t2 is changed by mcount function ftrace_caller(). This is why the bug happens
> >> to ftrace.
> >> 
> >> Dump of assembler code for function __find_rr_leaf:
> >>   0xffffffff80a19180 <+0>:     sd      ra,-8(sp)   #  $t2 = 0xff200000120db7b4
> >>   0xffffffff80a19184 <+4>:     auipc   ra,0xff5f1
> >>   0xffffffff80a19188 <+8>:     jalr    -1744(ra) # 0xffffffff80009ab4 <ftrace_caller> #  $t2 = 0xff200000120db7b4
> >> => 0xffffffff80a1918c <+12>:    ld      ra,-8(sp)    #  $t2 = 0x1, bug, $t2 is corrupted!!
> >>   0xffffffff80a19190 <+16>:    addi    sp,sp,-176
> >>   [snip]
> >> 
> >> So now we can come to a conclusion. The generated local function __find_rr_leaf()
> >> violates the risc-v calling convention and leads to the panic. It should use stack
> >> but *not* temporary register $t2 to pass the ninth parameter! It's okay if the
> >> callsite can take care of local symbol callees, but the Function Instrumentation
> >> features should be considerated carefully.
> >> 
> >> For comparison, here is the result from gcc (9.2.0):
> >> (gdb) info scope __find_rr_leaf
> >> [snip]
> >> Symbol mpri is a complex DWARF expression:
> >>     0: DW_OP_fbreg 0, length 8.
> >> 
> >> I also built a simple test function with 9 parameters by clang and same cflags,
> >> but cannot reproduce it. Maybe it is conditional?
> >> 
> >> Simple test code:
> >> __attribute__ ((noinline))
> >> void test_func(int *a, int *b, int *c, int *d, int *e, int *f, int *g, int *h, int *i)
> >> {
> >>        printf("__find_rr_leaf: %d\n", *i);
> >> }
> >> 
> >> int main(void)
> >> {
> >>        int a,b,c,d,e,f,g,h,i = 100;
> >> 
> >>        test_func(&a,&b,&c,&d,&e,&f,&g,&h,&i);
> >>        return 0;
> >> }
> > 
> > Hmm...any chance you could come up with a more concise test case then
> > using creduce [0] or cvise [1]?
> > [0] https://embed.cs.utah.edu/creduce/
> > [1] https://github.com/marxin/cvise
> > 
> > 
> >> 
> >> --
> >> Cheers,
> >> Changbin Du
> >> 
> > 
> > 
> > -- 
> > Thanks,
> > ~Nick Desaulniers
> 

-- 
Cheers,
Changbin Du

^ permalink raw reply	[flat|nested] 21+ messages in thread

* Re: riscv: llvm-compiler: calling convention violation: temporary register $t2 is used to pass the ninth function parameter
@ 2022-05-12  8:30       ` Changbin Du
  0 siblings, 0 replies; 21+ messages in thread
From: Changbin Du @ 2022-05-12  8:30 UTC (permalink / raw)
  To: Craig Topper
  Cc: Nick Desaulniers, Changbin Du, Paul Walmsley, Palmer Dabbelt,
	Albert Ou, Steven Rostedt, hw.huiwang, linux-riscv, linux-kernel,
	llvm, codegen-riscv, llvmproject, asb

On Wed, May 11, 2022 at 01:07:14PM -0700, Craig Topper wrote:
> I’m guessing that because the function is static, the calling convention was changed to fastcall which allows us to ignore the ABI.
> 
I think so. But the mcount function assumes the ABI is not changed.

> > On May 11, 2022, at 11:39 AM, Nick Desaulniers <ndesaulniers@google.com> wrote:
> > 
> > On Mon, May 9, 2022 at 11:54 PM Changbin Du <changbin.du@huawei.com> wrote:
> >> 
> >> [This is a resent to correct llvm mailist.]
> >> 
> >> Hello, folks,
> >> 
> >> Recently I encountered a kernel crash problem when using ftrace with 'perf ftrace'
> >> command on risc-v kernel built with llvm.
> >> 
> >> This crash only exists on llvm build, not reproducable with GCC. So I hope llvm
> >> guys can take a look :)
> >> 
> >> The llvm versions I have tried are llvm-13.0.0 and mainline (commit 102bc634cb
> >> ("[runtime] Build compiler-rt with --unwindlib=none")).
> >> 
> >> [  612.947887][  T496] Unable to handle kernel NULL pointer dereference at virtual address 0000000000000001
> >> [  613.050789][  T496] Hardware name: riscv-virtio,qemu (DT)
> >> [  613.087976][  T496] epc : __find_rr_leaf+0x128/0x220
> >> [  613.107493][  T496]  ra : return_to_handler+0x22/0x24
> >> [  613.125322][  T496] epc : ffffffff80a1915a ra : ffffffff80009506 sp : ff20000011e43860
> >> [  613.150124][  T496]  gp : ffffffff81812f40 tp : ff6000008bb01580 t0 : ff600000806cf0f0
> >> [  613.173657][  T496]  t1 : 000000000001b29a t2 : 0000000000000001 s0 : ff20000011e43920
> >> [  613.187311][  T496]  s1 : ff600000848c2a00 a0 : 0000000000000002 a1 : 0000000000000002
> >> [  613.202731][  T496]  a2 : fffffffffffffffd a3 : ff6000009d287000 a4 : 00000000000002c0
> >> [  613.213723][  T496]  a5 : ff6000009d259b40 a6 : ffffffffffffff9c a7 : ffffffffffffffff
> >> [  613.226648][  T496]  s2 : 0000000000000001 s3 : ff20000011e439d8 s4 : ffffffff8160d140
> >> [  613.246571][  T496]  s5 : 0000000000000002 s6 : 0000000000000000 s7 : 0000000000000000
> >> [  613.264681][  T496]  s8 : 0000000000000064 s9 : 0000000000000000 s10: 0000000000400000
> >> [  613.277999][  T496]  s11: ff600000848c2aa8 t3 : 0000000000000290 t4 : 00000000004002c0
> >> [  613.303729][  T496]  t5 : 00000000ffffffff t6 : ff6000009d2872d0
> >> [  613.322145][  T496] status: 0000000200000120 badaddr: 0000000000000001 cause: 000000000000000d
> >> [  613.346228][  T496] [<ffffffff80a12526>] ip6_pol_route+0xb6/0x602
> >> [  613.365722][  T496] [<ffffffff80a1321a>] ip6_pol_route_output+0x2c/0x34
> >> [  613.386374][  T496] [<ffffffff80a1c028>] fib6_rule_lookup+0x36/0xa0
> >> [  613.401865][  T496] [<ffffffff80a131da>] ip6_route_output_flags_noref+0xd6/0xea
> >> [  613.412776][  T496] [<ffffffff80a13274>] ip6_route_output_flags+0x52/0xd4
> >> [  613.432013][  T496] [<ffffffff809ffb3a>] ip6_dst_lookup_tail+0x68/0x23a
> >> [  613.456198][  T496] [<ffffffff809ffec6>] ip6_sk_dst_lookup_flow+0x132/0x1cc
> >> [  613.513174][  T496] [<ffffffff80003cd8>] ret_from_syscall+0x0/0x2
> >> [  613.518973][  T496] [<ffffffff800094e4>] return_to_handler+0x0/0x24
> >> [  613.563961][  T496] Kernel panic - not syncing: Fatal exception
> >> [  613.572278][  T496] SMP: stopping secondary CPUs
> >> [  613.587449][  T496] ---[ end Kernel panic - not syncing: Fatal exception ]---
> >> 
> >> The crash happened when dereferencing the point 'mpri' at route.c:758.
> >> 
> >> (gdb) l *__find_rr_leaf+0x128
> >> 0xffffffff809da9c4 is in __find_rr_leaf (net/ipv6/route.c:758).
> >> 753
> >> 754             if (strict & RT6_LOOKUP_F_REACHABLE)
> >> 755                     rt6_probe(nh);
> >> 756
> >> 757             /* note that m can be RT6_NUD_FAIL_PROBE at this point */
> >> 758             if (m > *mpri) {
> >> 759                     *do_rr = match_do_rr;
> >> 760                     *mpri = m;
> >> 761                     rc = true;
> >> 762             }
> >> 
> >> Adding some logs, I found the problem. The ninth passed parameter of function
> >> __find_rr_leaf() which is the address of local variable 'mpri', is changed to
> >> value '0x1' when inside the function __find_rr_leaf.
> >> Here is the code snippet and full link
> >> https://github.com/torvalds/linux/blob/9cb7c013420f98fa6fd12fc6a5dc055170c108db/net/ipv6/route.c.
> >> 
> >> static void find_rr_leaf(struct fib6_node *fn, struct fib6_info *leaf,
> >>                         struct fib6_info *rr_head, int oif, int strict,
> >>                         bool *do_rr, struct fib6_result *res)
> >> {
> >>        u32 metric = rr_head->fib6_metric;
> >>        struct fib6_info *cont = NULL;
> >>        int mpri = -1;
> >> 
> >>        __find_rr_leaf(rr_head, NULL, metric, res, &cont,
> >>                       oif, strict, do_rr, &mpri);
> >>        ...
> >> }
> >> 
> >> Then debugging with gdb, I found this probably is a compiler bug. We can see the
> >> local function __find_rr_leaf() is not optimized out and the compiler generates
> >> a local symbol for it. The find_rr_leaf() (inlined by fib6_table_lookup) invokes
> >> this function with 'jalr' instruction.
> >> 
> >> (gdb) disassemble fib6_table_lookup
> >> Dump of assembler code for function fib6_table_lookup:
> >>   [snip]
> >>   0xffffffff80a1240e <+412>:   beqz    a1,0xffffffff80a12436 <fib6_table_lookup+452>
> >>   0xffffffff80a12410 <+414>:   slli    a1,s9,0x20
> >>   0xffffffff80a12414 <+418>:   srli    a1,a1,0x20
> >>   0xffffffff80a12416 <+420>:   sext.w  a2,a1
> >>   0xffffffff80a1241a <+424>:   addi    a7,s0,-125
> >>   0xffffffff80a1241e <+428>:   addi    t2,s0,-124
> >>   0xffffffff80a12422 <+432>:   li      a1,0
> >>   0xffffffff80a12424 <+434>:   mv      a3,s10
> >>   0xffffffff80a12426 <+436>:   li      a4,0
> >>   0xffffffff80a12428 <+438>:   ld      a5,-152(s0)
> >>   0xffffffff80a1242c <+442>:   mv      a6,s8
> >>   0xffffffff80a1242e <+444>:   auipc   ra,0x7
> >>   0xffffffff80a12432 <+448>:   jalr    -686(ra) # 0xffffffff80a19180 <__find_rr_leaf>
> >>   [snip]
> >> 
> >> And at line route.c:758, the value of point 'mpri' is stored in temporary register
> >> $t2 and $s3 (copied from $t2).
> >> 
> >> (gdb) info scope __find_rr_leaf
> >> [snip]
> >> Symbol mpri is multi-location:
> >>  Base address 0xffffffff80a10564  Range 0xffffffff80a19190-0xffffffff80a191ae: a variable in $t2
> >>  Range 0xffffffff80a191c0-0xffffffff80a191d6: a variable in $s3
> >>  Range 0xffffffff80a19200-0xffffffff80a19208: a variable in $s3
> >>  Range 0xffffffff80a1921e-0xffffffff80a192fe: a variable in $s3
> >>  Range 0xffffffff80a1930a-0xffffffff80a19356: a variable in $s3
> >> 
> >> Let's see when register $t2 is corrupted with single-step mode. Obviously, register
> >> $t2 is changed by mcount function ftrace_caller(). This is why the bug happens
> >> to ftrace.
> >> 
> >> Dump of assembler code for function __find_rr_leaf:
> >>   0xffffffff80a19180 <+0>:     sd      ra,-8(sp)   #  $t2 = 0xff200000120db7b4
> >>   0xffffffff80a19184 <+4>:     auipc   ra,0xff5f1
> >>   0xffffffff80a19188 <+8>:     jalr    -1744(ra) # 0xffffffff80009ab4 <ftrace_caller> #  $t2 = 0xff200000120db7b4
> >> => 0xffffffff80a1918c <+12>:    ld      ra,-8(sp)    #  $t2 = 0x1, bug, $t2 is corrupted!!
> >>   0xffffffff80a19190 <+16>:    addi    sp,sp,-176
> >>   [snip]
> >> 
> >> So now we can come to a conclusion. The generated local function __find_rr_leaf()
> >> violates the risc-v calling convention and leads to the panic. It should use stack
> >> but *not* temporary register $t2 to pass the ninth parameter! It's okay if the
> >> callsite can take care of local symbol callees, but the Function Instrumentation
> >> features should be considerated carefully.
> >> 
> >> For comparison, here is the result from gcc (9.2.0):
> >> (gdb) info scope __find_rr_leaf
> >> [snip]
> >> Symbol mpri is a complex DWARF expression:
> >>     0: DW_OP_fbreg 0, length 8.
> >> 
> >> I also built a simple test function with 9 parameters by clang and same cflags,
> >> but cannot reproduce it. Maybe it is conditional?
> >> 
> >> Simple test code:
> >> __attribute__ ((noinline))
> >> void test_func(int *a, int *b, int *c, int *d, int *e, int *f, int *g, int *h, int *i)
> >> {
> >>        printf("__find_rr_leaf: %d\n", *i);
> >> }
> >> 
> >> int main(void)
> >> {
> >>        int a,b,c,d,e,f,g,h,i = 100;
> >> 
> >>        test_func(&a,&b,&c,&d,&e,&f,&g,&h,&i);
> >>        return 0;
> >> }
> > 
> > Hmm...any chance you could come up with a more concise test case then
> > using creduce [0] or cvise [1]?
> > [0] https://embed.cs.utah.edu/creduce/
> > [1] https://github.com/marxin/cvise
> > 
> > 
> >> 
> >> --
> >> Cheers,
> >> Changbin Du
> >> 
> > 
> > 
> > -- 
> > Thanks,
> > ~Nick Desaulniers
> 

-- 
Cheers,
Changbin Du

_______________________________________________
linux-riscv mailing list
linux-riscv@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-riscv

^ permalink raw reply	[flat|nested] 21+ messages in thread

* Re: riscv: llvm-compiler: calling convention violation: temporary register $t2 is used to pass the ninth function parameter
  2022-05-12  8:30       ` Changbin Du
@ 2022-05-12  8:35         ` Alex Bradbury
  -1 siblings, 0 replies; 21+ messages in thread
From: Alex Bradbury @ 2022-05-12  8:35 UTC (permalink / raw)
  To: Changbin Du
  Cc: Craig Topper, Nick Desaulniers, Paul Walmsley, Palmer Dabbelt,
	Albert Ou, Steven Rostedt, hw.huiwang, linux-riscv, linux-kernel,
	llvm, codegen-riscv, llvmproject

On Thu, 12 May 2022 at 09:30, Changbin Du <changbin.du@huawei.com> wrote:
>
> On Wed, May 11, 2022 at 01:07:14PM -0700, Craig Topper wrote:
> > I’m guessing that because the function is static, the calling convention was changed to fastcall which allows us to ignore the ABI.
> >
> I think so. But the mcount function assumes the ABI is not changed.

It feels like this is a problem that would be encountered on other
architectures with clangbuiltlinux as well, due to dropping the ABI
requirements for local functions. Have you seen something similar
elsewhere Nick?

Best,

Alex

^ permalink raw reply	[flat|nested] 21+ messages in thread

* Re: riscv: llvm-compiler: calling convention violation: temporary register $t2 is used to pass the ninth function parameter
@ 2022-05-12  8:35         ` Alex Bradbury
  0 siblings, 0 replies; 21+ messages in thread
From: Alex Bradbury @ 2022-05-12  8:35 UTC (permalink / raw)
  To: Changbin Du
  Cc: Craig Topper, Nick Desaulniers, Paul Walmsley, Palmer Dabbelt,
	Albert Ou, Steven Rostedt, hw.huiwang, linux-riscv, linux-kernel,
	llvm, codegen-riscv, llvmproject

On Thu, 12 May 2022 at 09:30, Changbin Du <changbin.du@huawei.com> wrote:
>
> On Wed, May 11, 2022 at 01:07:14PM -0700, Craig Topper wrote:
> > I’m guessing that because the function is static, the calling convention was changed to fastcall which allows us to ignore the ABI.
> >
> I think so. But the mcount function assumes the ABI is not changed.

It feels like this is a problem that would be encountered on other
architectures with clangbuiltlinux as well, due to dropping the ABI
requirements for local functions. Have you seen something similar
elsewhere Nick?

Best,

Alex

_______________________________________________
linux-riscv mailing list
linux-riscv@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-riscv

^ permalink raw reply	[flat|nested] 21+ messages in thread

* Re: riscv: llvm-compiler: calling convention violation: temporary register $t2 is used to pass the ninth function parameter
       [not found]         ` <CAL5JJjHYLTskw6YdC9qMj4KUAeY+0rO88Gh-TRaZyxCGJe+dnw@mail.gmail.com>
@ 2022-05-13  3:46             ` Changbin Du
  0 siblings, 0 replies; 21+ messages in thread
From: Changbin Du @ 2022-05-13  3:46 UTC (permalink / raw)
  To: Craig Topper
  Cc: Alex Bradbury, Albert Ou, Changbin Du, Nick Desaulniers,
	Palmer Dabbelt, Paul Walmsley, Steven Rostedt, hw.huiwang,
	linux-kernel, linux-riscv, llvm

[-- Attachment #1: Type: text/plain, Size: 5683 bytes --]

On Thu, May 12, 2022 at 07:49:41AM -0700, Craig Topper wrote:
> Changbin, can you provide a pre-processed source and a command line? I can
> reduce it on the llvm side.
> 

hmm, clang can not build the preprocessed source by itself!

$ /opt/llvm-13.0.0/bin/clang -nostdinc -Qunused-arguments -Wall -Wundef -Werror=strict-prototypes -Wno-trigraphs -fno-strict-aliasing -fno-common -fshort-wchar -fno-PIE -Werror=implicit-function-declaration -Werror=implicit-int -Werror=return-type -Wno-format-security -std=gnu11 --target=riscv64-linux-gnu -fintegrated-as -Werror=unknown-warning-option -Werror=ignored-optimization-argument -mabi=lp64 -mno-relax -march=rv64imac -mno-save-restore -mcmodel=medany -fno-omit-frame-pointer -fno-delete-null-pointer-checks -Wno-frame-address -Wno-address-of-packed-member -O2 -Wframe-larger-than=2048 -fstack-protector-strong -Werror -Wno-gnu -Wno-unused-but-set-variable -Wno-unused-const-variable -fno-omit-frame-pointer -fno-optimize-sibling-calls -fno-stack-clash-protection -fpatchable-function-entry=8 -Wdeclaration-after-statement -Wvla -Wno-pointer-sign -Wcast-function-type -fno-strict-overflow -fno-stack-check -Werror=date-time -Werror=incompatible-pointer-types -Wno-initializer-overrides -Wno-format -Wno-sign-compare -Wno-format-zero-length -Wno-pointer-to-enum-cast -Wno-tautological-constant-out-of-range-compare -g   -c -o route.o route.i
In file included from net/ipv6/route.c:30:
In file included from ./include/linux/socket.h:8:
In file included from ./include/linux/uio.h:9:
In file included from ./include/linux/thread_info.h:14:
In file included from ./include/linux/restart_block.h:10:
In file included from ./include/linux/time64.h:5:
./include/linux/math64.h:278:128: error: expression result unused [-Werror,-Wunused-value]
 ({ uint32_t __base = (divisor); uint32_t __rem; __rem = ((uint64_t)(rl.ll)) % __base; (rl.ll) = ((uint64_t)(rl.ll)) / __base; __rem; });
 ...

I also tried to reduce it using creduce. But the result is still too large and
creduce encounted a bug.

Here is my test script 'llvm-riscv-callconvention-bug.sh':
#!/bin/bash

pushd /home/changbin/work/linux-riscv
/opt/llvm-latest/bin/clang -Wp,-MMD,net/ipv6/.route.o.d  -nostdinc -I./arch/riscv/include -I./arch/riscv/include/generated  -I./include -I./arch/riscv/include/uapi -I./arch/riscv/include/generated/uapi -I./include/uapi -I./include/generated/uapi -include ./include/linux/compiler-version.h -include ./include/linux/kconfig.h -include ./include/linux/compiler_types.h -D__KERNEL__ -DCC_USING_PATCHABLE_FUNCTION_ENTRY -Qunused-arguments -fmacro-prefix-map=./= -Wall -Wundef -Werror=strict-prototypes -Wno-trigraphs -fno-strict-aliasing -fno-common -fshort-wchar -fno-PIE -Werror=implicit-function-declaration -Werror=implicit-int -Werror=return-type -Wno-format-security -std=gnu11 --target=riscv64-linux-gnu -fintegrated-as -Werror=unknown-warning-option -Werror=ignored-optimization-argument -mabi=lp64 -mno-relax -march=rv64imac -mno-save-restore -DCONFIG_PAGE_OFFSET=0xff60000000000000 -mcmodel=medany -fno-omit-frame-pointer -fno-delete-null-pointer-checks -Wno-frame-address -Wno-address-of-packed-member -O2 -Wframe-larger-than=2048 -fstack-protector-strong -Werror -Wno-gnu -Wno-unused-but-set-variable -Wno-unused-const-variable -fno-omit-frame-pointer -fno-optimize-sibling-calls -fno-stack-clash-protection -fpatchable-function-entry=8 -Wdeclaration-after-statement -Wvla -Wno-pointer-sign -Wcast-function-type -fno-strict-overflow -fno-stack-check -Werror=date-time -Werror=incompatible-pointer-types -Wno-initializer-overrides -Wno-format -Wno-sign-compare -Wno-format-zero-length -Wno-pointer-to-enum-cast -Wno-tautological-constant-out-of-range-compare -g    -DKBUILD_MODFILE='"net/ipv6/ipv6"' -DKBUILD_BASENAME='"route"' -DKBUILD_MODNAME='"ipv6"' -D__KBUILD_MODNAME=kmod_ipv6 -c -o net/ipv6/route.o /home/changbin/work/linux-riscv/net/ipv6/route.c || exit 1


mpri_found=false

gdb -q -ex 'info scope __find_rr_leaf' -ex 'quit' net/ipv6/route.o | while read line
do
        if [ "$mpri_found" = true ]; then
                match='\$t2'
                if [[ "$line" =~ $match ]]; then
                        exit 0
                else
                        exit 1
                fi
        fi

        match='Symbol mpri*'
        if [[ "$line" =~ $match ]]; then
                mpri_found=true
                echo $line
        fi
done
popd


$ creduce llvm-riscv-callconvention-bug.sh linux-riscv/net/ipv6/route.c


Here are the steps to reproduce it by buiding linux kernel:
 1. copy attached llvm-bug.kernel.config as .config under kernel souce tree.
   $ cd linux
   $ cp llvm-bug.kernel.config .config
 2. build the kernel.
   $ make ARCH=riscv LLVM=1 LLVM_IAS=1 -j$(nproc) Image
 3. investigate the result.
   $ gdb net/ipv6/route.o
   $ (gdb) info scope __find_rr_leaf



> On Thu, May 12, 2022 at 1:35 AM Alex Bradbury <asb@asbradbury.org> wrote:
> 
> > On Thu, 12 May 2022 at 09:30, Changbin Du <changbin.du@huawei.com> wrote:
> > >
> > > On Wed, May 11, 2022 at 01:07:14PM -0700, Craig Topper wrote:
> > > > I’m guessing that because the function is static, the calling
> > convention was changed to fastcall which allows us to ignore the ABI.
> > > >
> > > I think so. But the mcount function assumes the ABI is not changed.
> >
> > It feels like this is a problem that would be encountered on other
> > architectures with clangbuiltlinux as well, due to dropping the ABI
> > requirements for local functions. Have you seen something similar
> > elsewhere Nick?
> >
> > Best,
> >
> > Alex
> >

-- 
Cheers,
Changbin Du

[-- Attachment #2: llvm-bug.kernel.config --]
[-- Type: text/plain, Size: 97609 bytes --]

#
# Automatically generated file; DO NOT EDIT.
# Linux/riscv 5.18.0-rc6 Kernel Configuration
#
CONFIG_CC_VERSION_TEXT="clang version 13.0.0 (https://github.com/llvm/llvm-project.git d7b669b3a30345cfcdb2fde2af6f48aa4b94845d)"
CONFIG_GCC_VERSION=0
CONFIG_CC_IS_CLANG=y
CONFIG_CLANG_VERSION=130000
CONFIG_AS_IS_LLVM=y
CONFIG_AS_VERSION=130000
CONFIG_LD_VERSION=0
CONFIG_LD_IS_LLD=y
CONFIG_LLD_VERSION=130000
CONFIG_CC_CAN_LINK=y
CONFIG_CC_CAN_LINK_STATIC=y
CONFIG_CC_HAS_ASM_GOTO=y
CONFIG_CC_HAS_ASM_GOTO_OUTPUT=y
CONFIG_TOOLS_SUPPORT_RELR=y
CONFIG_CC_HAS_ASM_INLINE=y
CONFIG_CC_HAS_NO_PROFILE_FN_ATTR=y
CONFIG_PAHOLE_VERSION=0
CONFIG_IRQ_WORK=y
CONFIG_BUILDTIME_TABLE_SORT=y
CONFIG_THREAD_INFO_IN_TASK=y

#
# General setup
#
CONFIG_INIT_ENV_ARG_LIMIT=32
# CONFIG_COMPILE_TEST is not set
CONFIG_WERROR=y
CONFIG_LOCALVERSION=""
CONFIG_LOCALVERSION_AUTO=y
CONFIG_BUILD_SALT=""
CONFIG_DEFAULT_INIT=""
CONFIG_DEFAULT_HOSTNAME="(none)"
CONFIG_SWAP=y
CONFIG_SYSVIPC=y
CONFIG_SYSVIPC_SYSCTL=y
CONFIG_POSIX_MQUEUE=y
CONFIG_POSIX_MQUEUE_SYSCTL=y
# CONFIG_WATCH_QUEUE is not set
CONFIG_CROSS_MEMORY_ATTACH=y
# CONFIG_USELIB is not set
# CONFIG_AUDIT is not set
CONFIG_HAVE_ARCH_AUDITSYSCALL=y

#
# IRQ subsystem
#
CONFIG_GENERIC_IRQ_SHOW=y
CONFIG_GENERIC_IRQ_SHOW_LEVEL=y
CONFIG_GENERIC_IRQ_MIGRATION=y
CONFIG_IRQ_DOMAIN=y
CONFIG_IRQ_DOMAIN_HIERARCHY=y
CONFIG_GENERIC_MSI_IRQ=y
CONFIG_GENERIC_MSI_IRQ_DOMAIN=y
CONFIG_IRQ_FORCED_THREADING=y
CONFIG_SPARSE_IRQ=y
# CONFIG_GENERIC_IRQ_DEBUGFS is not set
# end of IRQ subsystem

CONFIG_GENERIC_IRQ_MULTI_HANDLER=y
CONFIG_ARCH_CLOCKSOURCE_INIT=y
CONFIG_GENERIC_TIME_VSYSCALL=y
CONFIG_GENERIC_CLOCKEVENTS=y
CONFIG_ARCH_HAS_TICK_BROADCAST=y
CONFIG_GENERIC_CLOCKEVENTS_BROADCAST=y

#
# Timers subsystem
#
CONFIG_TICK_ONESHOT=y
CONFIG_NO_HZ_COMMON=y
# CONFIG_HZ_PERIODIC is not set
CONFIG_NO_HZ_IDLE=y
# CONFIG_NO_HZ_FULL is not set
# CONFIG_NO_HZ is not set
CONFIG_HIGH_RES_TIMERS=y
# end of Timers subsystem

CONFIG_BPF=y
CONFIG_HAVE_EBPF_JIT=y

#
# BPF subsystem
#
CONFIG_BPF_SYSCALL=y
# CONFIG_BPF_JIT is not set
# CONFIG_BPF_UNPRIV_DEFAULT_OFF is not set
# CONFIG_BPF_PRELOAD is not set
# end of BPF subsystem

CONFIG_PREEMPT_VOLUNTARY_BUILD=y
# CONFIG_PREEMPT_NONE is not set
CONFIG_PREEMPT_VOLUNTARY=y
# CONFIG_PREEMPT is not set
CONFIG_PREEMPT_COUNT=y

#
# CPU/Task time and stats accounting
#
CONFIG_TICK_CPU_ACCOUNTING=y
# CONFIG_VIRT_CPU_ACCOUNTING_GEN is not set
CONFIG_IRQ_TIME_ACCOUNTING=y
CONFIG_HAVE_SCHED_AVG_IRQ=y
# CONFIG_BSD_PROCESS_ACCT is not set
# CONFIG_TASKSTATS is not set
# CONFIG_PSI is not set
# end of CPU/Task time and stats accounting

CONFIG_CPU_ISOLATION=y

#
# RCU Subsystem
#
CONFIG_TREE_RCU=y
# CONFIG_RCU_EXPERT is not set
CONFIG_SRCU=y
CONFIG_TREE_SRCU=y
CONFIG_TASKS_RCU_GENERIC=y
CONFIG_TASKS_RUDE_RCU=y
CONFIG_TASKS_TRACE_RCU=y
CONFIG_RCU_STALL_COMMON=y
CONFIG_RCU_NEED_SEGCBLIST=y
# end of RCU Subsystem

CONFIG_IKCONFIG=y
CONFIG_IKCONFIG_PROC=y
# CONFIG_IKHEADERS is not set
CONFIG_LOG_BUF_SHIFT=17
CONFIG_LOG_CPU_MAX_BUF_SHIFT=12
CONFIG_PRINTK_SAFE_LOG_BUF_SHIFT=13
# CONFIG_PRINTK_INDEX is not set
CONFIG_GENERIC_SCHED_CLOCK=y

#
# Scheduler features
#
# end of Scheduler features

CONFIG_CC_HAS_INT128=y
CONFIG_ARCH_SUPPORTS_INT128=y
CONFIG_CGROUPS=y
# CONFIG_MEMCG is not set
# CONFIG_BLK_CGROUP is not set
CONFIG_CGROUP_SCHED=y
CONFIG_FAIR_GROUP_SCHED=y
CONFIG_CFS_BANDWIDTH=y
# CONFIG_RT_GROUP_SCHED is not set
# CONFIG_CGROUP_PIDS is not set
# CONFIG_CGROUP_RDMA is not set
# CONFIG_CGROUP_FREEZER is not set
# CONFIG_CPUSETS is not set
# CONFIG_CGROUP_DEVICE is not set
# CONFIG_CGROUP_CPUACCT is not set
# CONFIG_CGROUP_PERF is not set
CONFIG_CGROUP_BPF=y
# CONFIG_CGROUP_MISC is not set
# CONFIG_CGROUP_DEBUG is not set
CONFIG_SOCK_CGROUP_DATA=y
CONFIG_NAMESPACES=y
CONFIG_UTS_NS=y
CONFIG_TIME_NS=y
CONFIG_IPC_NS=y
CONFIG_USER_NS=y
CONFIG_PID_NS=y
CONFIG_NET_NS=y
CONFIG_CHECKPOINT_RESTORE=y
# CONFIG_SCHED_AUTOGROUP is not set
# CONFIG_SYSFS_DEPRECATED is not set
CONFIG_RELAY=y
CONFIG_BLK_DEV_INITRD=y
CONFIG_INITRAMFS_SOURCE=""
CONFIG_RD_GZIP=y
CONFIG_RD_BZIP2=y
CONFIG_RD_LZMA=y
CONFIG_RD_XZ=y
CONFIG_RD_LZO=y
CONFIG_RD_LZ4=y
CONFIG_RD_ZSTD=y
CONFIG_BOOT_CONFIG=y
CONFIG_CC_OPTIMIZE_FOR_PERFORMANCE=y
# CONFIG_CC_OPTIMIZE_FOR_SIZE is not set
CONFIG_SYSCTL=y
CONFIG_SYSCTL_EXCEPTION_TRACE=y
CONFIG_EXPERT=y
CONFIG_MULTIUSER=y
# CONFIG_SGETMASK_SYSCALL is not set
# CONFIG_SYSFS_SYSCALL is not set
CONFIG_FHANDLE=y
CONFIG_POSIX_TIMERS=y
CONFIG_PRINTK=y
CONFIG_BUG=y
CONFIG_ELF_CORE=y
CONFIG_BASE_FULL=y
CONFIG_FUTEX=y
CONFIG_FUTEX_PI=y
CONFIG_EPOLL=y
CONFIG_SIGNALFD=y
CONFIG_TIMERFD=y
CONFIG_EVENTFD=y
CONFIG_SHMEM=y
CONFIG_AIO=y
CONFIG_IO_URING=y
CONFIG_ADVISE_SYSCALLS=y
CONFIG_MEMBARRIER=y
CONFIG_KALLSYMS=y
CONFIG_KALLSYMS_ALL=y
CONFIG_KALLSYMS_BASE_RELATIVE=y
# CONFIG_USERFAULTFD is not set
CONFIG_KCMP=y
CONFIG_RSEQ=y
# CONFIG_DEBUG_RSEQ is not set
# CONFIG_EMBEDDED is not set
CONFIG_HAVE_PERF_EVENTS=y
# CONFIG_PC104 is not set

#
# Kernel Performance Events And Counters
#
CONFIG_PERF_EVENTS=y
# CONFIG_DEBUG_PERF_USE_VMALLOC is not set
# end of Kernel Performance Events And Counters

CONFIG_VM_EVENT_COUNTERS=y
CONFIG_SLUB_DEBUG=y
CONFIG_COMPAT_BRK=y
# CONFIG_SLAB is not set
CONFIG_SLUB=y
# CONFIG_SLOB is not set
CONFIG_SLAB_MERGE_DEFAULT=y
# CONFIG_SLAB_FREELIST_RANDOM is not set
# CONFIG_SLAB_FREELIST_HARDENED is not set
# CONFIG_SHUFFLE_PAGE_ALLOCATOR is not set
CONFIG_SLUB_CPU_PARTIAL=y
# CONFIG_PROFILING is not set
CONFIG_TRACEPOINTS=y
# end of General setup

CONFIG_64BIT=y
CONFIG_RISCV=y
CONFIG_ARCH_MMAP_RND_BITS_MIN=18
CONFIG_ARCH_MMAP_RND_BITS_MAX=24
CONFIG_RISCV_SBI=y
CONFIG_MMU=y
CONFIG_PAGE_OFFSET=0xff60000000000000
CONFIG_ARCH_FLATMEM_ENABLE=y
CONFIG_ARCH_SPARSEMEM_ENABLE=y
CONFIG_ARCH_SELECT_MEMORY_MODEL=y
CONFIG_ARCH_SUPPORTS_UPROBES=y
CONFIG_STACKTRACE_SUPPORT=y
CONFIG_GENERIC_BUG=y
CONFIG_GENERIC_BUG_RELATIVE_POINTERS=y
CONFIG_GENERIC_CALIBRATE_DELAY=y
CONFIG_GENERIC_CSUM=y
CONFIG_GENERIC_HWEIGHT=y
CONFIG_FIX_EARLYCON_MEM=y
CONFIG_PGTABLE_LEVELS=5
CONFIG_LOCKDEP_SUPPORT=y

#
# SoC selection
#
# CONFIG_SOC_MICROCHIP_POLARFIRE is not set
CONFIG_SOC_SIFIVE=y
# CONFIG_SOC_STARFIVE is not set
CONFIG_SOC_VIRT=y
# end of SoC selection

#
# CPU errata selection
#
CONFIG_RISCV_ERRATA_ALTERNATIVE=y
CONFIG_ERRATA_SIFIVE=y
CONFIG_ERRATA_SIFIVE_CIP_453=y
CONFIG_ERRATA_SIFIVE_CIP_1200=y
# end of CPU errata selection

#
# Platform type
#
# CONFIG_ARCH_RV32I is not set
CONFIG_ARCH_RV64I=y
# CONFIG_CMODEL_MEDLOW is not set
CONFIG_CMODEL_MEDANY=y
CONFIG_MODULE_SECTIONS=y
CONFIG_SMP=y
CONFIG_NR_CPUS=32
CONFIG_HOTPLUG_CPU=y
CONFIG_TUNE_GENERIC=y
# CONFIG_NUMA is not set
CONFIG_RISCV_ISA_C=y
CONFIG_FPU=y
# end of Platform type

#
# Kernel features
#
CONFIG_HZ_100=y
# CONFIG_HZ_250 is not set
# CONFIG_HZ_300 is not set
# CONFIG_HZ_1000 is not set
CONFIG_HZ=100
CONFIG_SCHED_HRTICK=y
CONFIG_RISCV_SBI_V01=y
CONFIG_RISCV_BOOT_SPINWAIT=y
CONFIG_KEXEC=y
# CONFIG_CRASH_DUMP is not set
# end of Kernel features

#
# Boot options
#
CONFIG_CMDLINE=""
CONFIG_EFI_STUB=y
CONFIG_EFI=y
# CONFIG_PHYS_RAM_BASE_FIXED is not set
# CONFIG_XIP_KERNEL is not set
# end of Boot options

#
# Power management options
#
CONFIG_PM=y
# CONFIG_PM_DEBUG is not set
CONFIG_PM_CLK=y
CONFIG_PM_GENERIC_DOMAINS=y
# CONFIG_WQ_POWER_EFFICIENT_DEFAULT is not set
CONFIG_PM_GENERIC_DOMAINS_OF=y
# end of Power management options

#
# CPU Power Management
#

#
# CPU Idle
#
# CONFIG_CPU_IDLE is not set
# end of CPU Idle
# end of CPU Power Management

CONFIG_HAVE_KVM_EVENTFD=y
CONFIG_KVM_MMIO=y
CONFIG_KVM_GENERIC_DIRTYLOG_READ_PROTECT=y
CONFIG_HAVE_KVM_VCPU_ASYNC_IOCTL=y
CONFIG_VIRTUALIZATION=y
CONFIG_KVM=y

#
# General architecture-dependent options
#
CONFIG_CRASH_CORE=y
CONFIG_KEXEC_CORE=y
CONFIG_KPROBES=y
# CONFIG_JUMP_LABEL is not set
CONFIG_KPROBES_ON_FTRACE=y
CONFIG_UPROBES=y
CONFIG_HAVE_64BIT_ALIGNED_ACCESS=y
CONFIG_KRETPROBES=y
CONFIG_HAVE_KPROBES=y
CONFIG_HAVE_KRETPROBES=y
CONFIG_HAVE_KPROBES_ON_FTRACE=y
CONFIG_HAVE_FUNCTION_ERROR_INJECTION=y
CONFIG_TRACE_IRQFLAGS_SUPPORT=y
CONFIG_HAVE_ARCH_TRACEHOOK=y
CONFIG_HAVE_DMA_CONTIGUOUS=y
CONFIG_GENERIC_SMP_IDLE_THREAD=y
CONFIG_GENERIC_IDLE_POLL_SETUP=y
CONFIG_ARCH_HAS_FORTIFY_SOURCE=y
CONFIG_ARCH_HAS_SET_MEMORY=y
CONFIG_ARCH_HAS_SET_DIRECT_MAP=y
CONFIG_HAVE_ARCH_THREAD_STRUCT_WHITELIST=y
CONFIG_HAVE_ASM_MODVERSIONS=y
CONFIG_HAVE_REGS_AND_STACK_ACCESS_API=y
CONFIG_HAVE_RSEQ=y
CONFIG_HAVE_FUNCTION_ARG_ACCESS_API=y
CONFIG_HAVE_PERF_REGS=y
CONFIG_HAVE_PERF_USER_STACK_DUMP=y
CONFIG_HAVE_ARCH_JUMP_LABEL=y
CONFIG_HAVE_ARCH_JUMP_LABEL_RELATIVE=y
CONFIG_HAVE_ARCH_SECCOMP=y
CONFIG_HAVE_ARCH_SECCOMP_FILTER=y
# CONFIG_SECCOMP is not set
CONFIG_HAVE_STACKPROTECTOR=y
CONFIG_STACKPROTECTOR=y
CONFIG_STACKPROTECTOR_STRONG=y
CONFIG_LTO_NONE=y
CONFIG_HAVE_CONTEXT_TRACKING=y
CONFIG_HAVE_VIRT_CPU_ACCOUNTING_GEN=y
CONFIG_HAVE_IRQ_TIME_ACCOUNTING=y
CONFIG_HAVE_MOVE_PUD=y
CONFIG_HAVE_MOVE_PMD=y
CONFIG_HAVE_ARCH_TRANSPARENT_HUGEPAGE=y
CONFIG_ARCH_WANT_HUGE_PMD_SHARE=y
CONFIG_HAVE_MOD_ARCH_SPECIFIC=y
CONFIG_MODULES_USE_ELF_RELA=y
CONFIG_ARCH_HAS_ELF_RANDOMIZE=y
CONFIG_HAVE_ARCH_MMAP_RND_BITS=y
CONFIG_ARCH_MMAP_RND_BITS=18
CONFIG_PAGE_SIZE_LESS_THAN_64KB=y
CONFIG_PAGE_SIZE_LESS_THAN_256KB=y
CONFIG_ARCH_WANT_DEFAULT_TOPDOWN_MMAP_LAYOUT=y
CONFIG_CLONE_BACKWARDS=y
# CONFIG_COMPAT_32BIT_TIME is not set
CONFIG_HAVE_ARCH_VMAP_STACK=y
CONFIG_VMAP_STACK=y
CONFIG_ARCH_OPTIONAL_KERNEL_RWX=y
CONFIG_ARCH_OPTIONAL_KERNEL_RWX_DEFAULT=y
CONFIG_ARCH_HAS_STRICT_KERNEL_RWX=y
CONFIG_STRICT_KERNEL_RWX=y
CONFIG_ARCH_HAS_STRICT_MODULE_RWX=y
CONFIG_STRICT_MODULE_RWX=y
CONFIG_ARCH_USE_MEMREMAP_PROT=y
# CONFIG_LOCK_EVENT_COUNTS is not set
CONFIG_ARCH_SUPPORTS_DEBUG_PAGEALLOC=y

#
# GCOV-based kernel profiling
#
# CONFIG_GCOV_KERNEL is not set
CONFIG_ARCH_HAS_GCOV_PROFILE_ALL=y
# end of GCOV-based kernel profiling

CONFIG_HAVE_GCC_PLUGINS=y
# end of General architecture-dependent options

CONFIG_RT_MUTEXES=y
CONFIG_BASE_SMALL=0
CONFIG_MODULES=y
# CONFIG_MODULE_FORCE_LOAD is not set
CONFIG_MODULE_UNLOAD=y
# CONFIG_MODULE_FORCE_UNLOAD is not set
# CONFIG_MODVERSIONS is not set
# CONFIG_MODULE_SRCVERSION_ALL is not set
# CONFIG_MODULE_SIG is not set
CONFIG_MODULE_COMPRESS_NONE=y
# CONFIG_MODULE_COMPRESS_GZIP is not set
# CONFIG_MODULE_COMPRESS_XZ is not set
# CONFIG_MODULE_COMPRESS_ZSTD is not set
# CONFIG_MODULE_ALLOW_MISSING_NAMESPACE_IMPORTS is not set
CONFIG_MODPROBE_PATH="/sbin/modprobe"
# CONFIG_TRIM_UNUSED_KSYMS is not set
CONFIG_MODULES_TREE_LOOKUP=y
CONFIG_BLOCK=y
CONFIG_BLOCK_LEGACY_AUTOLOAD=y
CONFIG_BLK_DEV_BSG_COMMON=y
# CONFIG_BLK_DEV_BSGLIB is not set
# CONFIG_BLK_DEV_INTEGRITY is not set
# CONFIG_BLK_DEV_ZONED is not set
# CONFIG_BLK_WBT is not set
CONFIG_BLK_DEBUG_FS=y
# CONFIG_BLK_SED_OPAL is not set
# CONFIG_BLK_INLINE_ENCRYPTION is not set

#
# Partition Types
#
# CONFIG_PARTITION_ADVANCED is not set
CONFIG_MSDOS_PARTITION=y
CONFIG_EFI_PARTITION=y
# end of Partition Types

CONFIG_BLK_MQ_PCI=y
CONFIG_BLK_MQ_VIRTIO=y
CONFIG_BLK_PM=y

#
# IO Schedulers
#
CONFIG_MQ_IOSCHED_DEADLINE=y
CONFIG_MQ_IOSCHED_KYBER=y
# CONFIG_IOSCHED_BFQ is not set
# end of IO Schedulers

CONFIG_PREEMPT_NOTIFIERS=y
CONFIG_ASN1=y
CONFIG_UNINLINE_SPIN_UNLOCK=y
CONFIG_ARCH_SUPPORTS_ATOMIC_RMW=y
CONFIG_MUTEX_SPIN_ON_OWNER=y
CONFIG_RWSEM_SPIN_ON_OWNER=y
CONFIG_LOCK_SPIN_ON_OWNER=y
CONFIG_ARCH_HAS_MMIOWB=y
CONFIG_MMIOWB=y

#
# Executable file formats
#
CONFIG_BINFMT_ELF=y
CONFIG_ELFCORE=y
CONFIG_CORE_DUMP_DEFAULT_ELF_HEADERS=y
CONFIG_BINFMT_SCRIPT=y
CONFIG_ARCH_HAS_BINFMT_FLAT=y
CONFIG_BINFMT_FLAT=y
# CONFIG_BINFMT_FLAT_OLD is not set
# CONFIG_BINFMT_ZFLAT is not set
# CONFIG_BINFMT_SHARED_FLAT is not set
CONFIG_BINFMT_MISC=y
CONFIG_COREDUMP=y
# end of Executable file formats

#
# Memory Management options
#
CONFIG_SELECT_MEMORY_MODEL=y
# CONFIG_FLATMEM_MANUAL is not set
CONFIG_SPARSEMEM_MANUAL=y
CONFIG_SPARSEMEM=y
CONFIG_SPARSEMEM_EXTREME=y
CONFIG_SPARSEMEM_VMEMMAP_ENABLE=y
CONFIG_SPARSEMEM_VMEMMAP=y
CONFIG_MEMORY_ISOLATION=y
CONFIG_SPLIT_PTLOCK_CPUS=4
CONFIG_ARCH_ENABLE_SPLIT_PMD_PTLOCK=y
CONFIG_MEMORY_BALLOON=y
CONFIG_BALLOON_COMPACTION=y
CONFIG_COMPACTION=y
CONFIG_PAGE_REPORTING=y
CONFIG_MIGRATION=y
CONFIG_ARCH_ENABLE_THP_MIGRATION=y
CONFIG_CONTIG_ALLOC=y
CONFIG_PHYS_ADDR_T_64BIT=y
CONFIG_MMU_NOTIFIER=y
# CONFIG_KSM is not set
CONFIG_DEFAULT_MMAP_MIN_ADDR=4096
CONFIG_TRANSPARENT_HUGEPAGE=y
CONFIG_TRANSPARENT_HUGEPAGE_ALWAYS=y
# CONFIG_TRANSPARENT_HUGEPAGE_MADVISE is not set
CONFIG_ARCH_WANT_GENERAL_HUGETLB=y
CONFIG_FRONTSWAP=y
CONFIG_CMA=y
# CONFIG_CMA_DEBUG is not set
CONFIG_CMA_DEBUGFS=y
CONFIG_CMA_SYSFS=y
CONFIG_CMA_AREAS=7
CONFIG_ZSWAP=y
# CONFIG_ZSWAP_COMPRESSOR_DEFAULT_DEFLATE is not set
CONFIG_ZSWAP_COMPRESSOR_DEFAULT_LZO=y
# CONFIG_ZSWAP_COMPRESSOR_DEFAULT_842 is not set
# CONFIG_ZSWAP_COMPRESSOR_DEFAULT_LZ4 is not set
# CONFIG_ZSWAP_COMPRESSOR_DEFAULT_LZ4HC is not set
# CONFIG_ZSWAP_COMPRESSOR_DEFAULT_ZSTD is not set
CONFIG_ZSWAP_COMPRESSOR_DEFAULT="lzo"
CONFIG_ZSWAP_ZPOOL_DEFAULT_ZBUD=y
# CONFIG_ZSWAP_ZPOOL_DEFAULT_Z3FOLD is not set
# CONFIG_ZSWAP_ZPOOL_DEFAULT_ZSMALLOC is not set
CONFIG_ZSWAP_ZPOOL_DEFAULT="zbud"
# CONFIG_ZSWAP_DEFAULT_ON is not set
CONFIG_ZPOOL=y
CONFIG_ZBUD=y
# CONFIG_Z3FOLD is not set
# CONFIG_ZSMALLOC is not set
CONFIG_GENERIC_EARLY_IOREMAP=y
# CONFIG_DEFERRED_STRUCT_PAGE_INIT is not set
CONFIG_PAGE_IDLE_FLAG=y
CONFIG_IDLE_PAGE_TRACKING=y
CONFIG_ARCH_HAS_CURRENT_STACK_POINTER=y
CONFIG_ZONE_DMA32=y
# CONFIG_PERCPU_STATS is not set
# CONFIG_GUP_TEST is not set
# CONFIG_READ_ONLY_THP_FOR_FS is not set
CONFIG_ARCH_HAS_PTE_SPECIAL=y
CONFIG_SECRETMEM=y
CONFIG_ANON_VMA_NAME=y

#
# Data Access Monitoring
#
CONFIG_DAMON=y
CONFIG_DAMON_VADDR=y
CONFIG_DAMON_PADDR=y
CONFIG_DAMON_SYSFS=y
CONFIG_DAMON_DBGFS=y
CONFIG_DAMON_RECLAIM=y
# end of Data Access Monitoring
# end of Memory Management options

CONFIG_NET=y

#
# Networking options
#
CONFIG_PACKET=y
# CONFIG_PACKET_DIAG is not set
CONFIG_UNIX=y
CONFIG_UNIX_SCM=y
CONFIG_AF_UNIX_OOB=y
# CONFIG_UNIX_DIAG is not set
# CONFIG_TLS is not set
# CONFIG_XFRM_USER is not set
# CONFIG_NET_KEY is not set
# CONFIG_XDP_SOCKETS is not set
CONFIG_INET=y
CONFIG_IP_MULTICAST=y
CONFIG_IP_ADVANCED_ROUTER=y
# CONFIG_IP_FIB_TRIE_STATS is not set
# CONFIG_IP_MULTIPLE_TABLES is not set
# CONFIG_IP_ROUTE_MULTIPATH is not set
# CONFIG_IP_ROUTE_VERBOSE is not set
CONFIG_IP_PNP=y
CONFIG_IP_PNP_DHCP=y
CONFIG_IP_PNP_BOOTP=y
CONFIG_IP_PNP_RARP=y
# CONFIG_NET_IPIP is not set
# CONFIG_NET_IPGRE_DEMUX is not set
CONFIG_NET_IP_TUNNEL=y
# CONFIG_IP_MROUTE is not set
# CONFIG_SYN_COOKIES is not set
# CONFIG_NET_IPVTI is not set
# CONFIG_NET_FOU is not set
# CONFIG_NET_FOU_IP_TUNNELS is not set
# CONFIG_INET_AH is not set
# CONFIG_INET_ESP is not set
# CONFIG_INET_IPCOMP is not set
CONFIG_INET_TUNNEL=y
CONFIG_INET_DIAG=y
CONFIG_INET_TCP_DIAG=y
# CONFIG_INET_UDP_DIAG is not set
# CONFIG_INET_RAW_DIAG is not set
# CONFIG_INET_DIAG_DESTROY is not set
# CONFIG_TCP_CONG_ADVANCED is not set
CONFIG_TCP_CONG_CUBIC=y
CONFIG_DEFAULT_TCP_CONG="cubic"
# CONFIG_TCP_MD5SIG is not set
CONFIG_IPV6=y
# CONFIG_IPV6_ROUTER_PREF is not set
# CONFIG_IPV6_OPTIMISTIC_DAD is not set
# CONFIG_INET6_AH is not set
# CONFIG_INET6_ESP is not set
# CONFIG_INET6_IPCOMP is not set
# CONFIG_IPV6_MIP6 is not set
# CONFIG_IPV6_VTI is not set
CONFIG_IPV6_SIT=y
# CONFIG_IPV6_SIT_6RD is not set
CONFIG_IPV6_NDISC_NODETYPE=y
# CONFIG_IPV6_TUNNEL is not set
# CONFIG_IPV6_MULTIPLE_TABLES is not set
# CONFIG_IPV6_MROUTE is not set
# CONFIG_IPV6_SEG6_LWTUNNEL is not set
# CONFIG_IPV6_SEG6_HMAC is not set
# CONFIG_IPV6_RPL_LWTUNNEL is not set
# CONFIG_IPV6_IOAM6_LWTUNNEL is not set
# CONFIG_MPTCP is not set
# CONFIG_NETWORK_SECMARK is not set
# CONFIG_NETWORK_PHY_TIMESTAMPING is not set
# CONFIG_NETFILTER is not set
# CONFIG_BPFILTER is not set
# CONFIG_IP_DCCP is not set
# CONFIG_IP_SCTP is not set
# CONFIG_RDS is not set
# CONFIG_TIPC is not set
# CONFIG_ATM is not set
# CONFIG_L2TP is not set
# CONFIG_BRIDGE is not set
# CONFIG_NET_DSA is not set
# CONFIG_VLAN_8021Q is not set
# CONFIG_DECNET is not set
# CONFIG_LLC2 is not set
# CONFIG_ATALK is not set
# CONFIG_X25 is not set
# CONFIG_LAPB is not set
# CONFIG_PHONET is not set
# CONFIG_6LOWPAN is not set
# CONFIG_IEEE802154 is not set
# CONFIG_NET_SCHED is not set
# CONFIG_DCB is not set
CONFIG_DNS_RESOLVER=y
# CONFIG_BATMAN_ADV is not set
# CONFIG_OPENVSWITCH is not set
# CONFIG_VSOCKETS is not set
CONFIG_NETLINK_DIAG=y
# CONFIG_MPLS is not set
# CONFIG_NET_NSH is not set
# CONFIG_HSR is not set
# CONFIG_NET_SWITCHDEV is not set
# CONFIG_NET_L3_MASTER_DEV is not set
# CONFIG_QRTR is not set
# CONFIG_NET_NCSI is not set
CONFIG_PCPU_DEV_REFCNT=y
CONFIG_RPS=y
CONFIG_RFS_ACCEL=y
CONFIG_SOCK_RX_QUEUE_MAPPING=y
CONFIG_XPS=y
# CONFIG_CGROUP_NET_PRIO is not set
# CONFIG_CGROUP_NET_CLASSID is not set
CONFIG_NET_RX_BUSY_POLL=y
CONFIG_BQL=y
# CONFIG_BPF_STREAM_PARSER is not set
CONFIG_NET_FLOW_LIMIT=y

#
# Network testing
#
# CONFIG_NET_PKTGEN is not set
# CONFIG_NET_DROP_MONITOR is not set
# end of Network testing
# end of Networking options

# CONFIG_HAMRADIO is not set
# CONFIG_CAN is not set
# CONFIG_BT is not set
# CONFIG_AF_RXRPC is not set
# CONFIG_AF_KCM is not set
# CONFIG_MCTP is not set
CONFIG_WIRELESS=y
# CONFIG_CFG80211 is not set

#
# CFG80211 needs to be enabled for MAC80211
#
CONFIG_MAC80211_STA_HASH_MAX_SIZE=0
# CONFIG_RFKILL is not set
CONFIG_NET_9P=y
CONFIG_NET_9P_FD=y
CONFIG_NET_9P_VIRTIO=y
# CONFIG_NET_9P_DEBUG is not set
# CONFIG_CAIF is not set
# CONFIG_CEPH_LIB is not set
# CONFIG_NFC is not set
# CONFIG_PSAMPLE is not set
# CONFIG_NET_IFE is not set
# CONFIG_LWTUNNEL is not set
CONFIG_DST_CACHE=y
CONFIG_GRO_CELLS=y
CONFIG_NET_SELFTESTS=y
CONFIG_NET_SOCK_MSG=y
CONFIG_PAGE_POOL=y
# CONFIG_PAGE_POOL_STATS is not set
CONFIG_FAILOVER=y
CONFIG_ETHTOOL_NETLINK=y

#
# Device Drivers
#
CONFIG_HAVE_PCI=y
CONFIG_PCI=y
CONFIG_PCI_DOMAINS=y
CONFIG_PCI_DOMAINS_GENERIC=y
CONFIG_PCIEPORTBUS=y
CONFIG_PCIEAER=y
# CONFIG_PCIEAER_INJECT is not set
# CONFIG_PCIE_ECRC is not set
CONFIG_PCIEASPM=y
CONFIG_PCIEASPM_DEFAULT=y
# CONFIG_PCIEASPM_POWERSAVE is not set
# CONFIG_PCIEASPM_POWER_SUPERSAVE is not set
# CONFIG_PCIEASPM_PERFORMANCE is not set
CONFIG_PCIE_PME=y
# CONFIG_PCIE_DPC is not set
# CONFIG_PCIE_PTM is not set
CONFIG_PCI_MSI=y
CONFIG_PCI_MSI_IRQ_DOMAIN=y
CONFIG_PCI_QUIRKS=y
# CONFIG_PCI_DEBUG is not set
# CONFIG_PCI_STUB is not set
CONFIG_PCI_ECAM=y
# CONFIG_PCI_IOV is not set
# CONFIG_PCI_PRI is not set
# CONFIG_PCI_PASID is not set
# CONFIG_PCIE_BUS_TUNE_OFF is not set
CONFIG_PCIE_BUS_DEFAULT=y
# CONFIG_PCIE_BUS_SAFE is not set
# CONFIG_PCIE_BUS_PERFORMANCE is not set
# CONFIG_PCIE_BUS_PEER2PEER is not set
CONFIG_VGA_ARB=y
CONFIG_VGA_ARB_MAX_GPUS=16
# CONFIG_HOTPLUG_PCI is not set

#
# PCI controller drivers
#
# CONFIG_PCI_FTPCI100 is not set
CONFIG_PCI_HOST_COMMON=y
CONFIG_PCI_HOST_GENERIC=y
CONFIG_PCIE_XILINX=y
# CONFIG_PCIE_MICROCHIP_HOST is not set

#
# DesignWare PCI Core Support
#
# CONFIG_PCIE_DW_PLAT_HOST is not set
# CONFIG_PCI_MESON is not set
# CONFIG_PCIE_FU740 is not set
# end of DesignWare PCI Core Support

#
# Mobiveil PCIe Core Support
#
# end of Mobiveil PCIe Core Support

#
# Cadence PCIe controllers support
#
# CONFIG_PCIE_CADENCE_PLAT_HOST is not set
# CONFIG_PCI_J721E_HOST is not set
# end of Cadence PCIe controllers support
# end of PCI controller drivers

#
# PCI Endpoint
#
# CONFIG_PCI_ENDPOINT is not set
# end of PCI Endpoint

#
# PCI switch controller drivers
#
# CONFIG_PCI_SW_SWITCHTEC is not set
# end of PCI switch controller drivers

# CONFIG_CXL_BUS is not set
# CONFIG_PCCARD is not set
# CONFIG_RAPIDIO is not set

#
# Generic Driver Options
#
# CONFIG_UEVENT_HELPER is not set
CONFIG_DEVTMPFS=y
CONFIG_DEVTMPFS_MOUNT=y
# CONFIG_DEVTMPFS_SAFE is not set
CONFIG_STANDALONE=y
CONFIG_PREVENT_FIRMWARE_BUILD=y

#
# Firmware loader
#
CONFIG_FW_LOADER=y
CONFIG_EXTRA_FIRMWARE=""
# CONFIG_FW_LOADER_USER_HELPER is not set
# CONFIG_FW_LOADER_COMPRESS is not set
# end of Firmware loader

CONFIG_ALLOW_DEV_COREDUMP=y
# CONFIG_DEBUG_DRIVER is not set
# CONFIG_DEBUG_DEVRES is not set
# CONFIG_DEBUG_TEST_DRIVER_REMOVE is not set
# CONFIG_TEST_ASYNC_DRIVER_PROBE is not set
CONFIG_REGMAP=y
CONFIG_REGMAP_MMIO=y
CONFIG_DMA_SHARED_BUFFER=y
# CONFIG_DMA_FENCE_TRACE is not set
CONFIG_GENERIC_ARCH_TOPOLOGY=y
# end of Generic Driver Options

#
# Bus devices
#
# CONFIG_MOXTET is not set
# CONFIG_MHI_BUS is not set
# end of Bus devices

# CONFIG_CONNECTOR is not set

#
# Firmware Drivers
#

#
# ARM System Control and Management Interface Protocol
#
# end of ARM System Control and Management Interface Protocol

CONFIG_FIRMWARE_MEMMAP=y
CONFIG_SYSFB=y
# CONFIG_SYSFB_SIMPLEFB is not set
# CONFIG_GOOGLE_FIRMWARE is not set

#
# EFI (Extensible Firmware Interface) Support
#
CONFIG_EFI_ESRT=y
CONFIG_EFI_PARAMS_FROM_FDT=y
CONFIG_EFI_RUNTIME_WRAPPERS=y
CONFIG_EFI_GENERIC_STUB=y
# CONFIG_EFI_BOOTLOADER_CONTROL is not set
# CONFIG_EFI_CAPSULE_LOADER is not set
# CONFIG_EFI_TEST is not set
# CONFIG_RESET_ATTACK_MITIGATION is not set
# CONFIG_EFI_DISABLE_PCI_DMA is not set
# end of EFI (Extensible Firmware Interface) Support

CONFIG_EFI_EARLYCON=y

#
# Tegra firmware driver
#
# end of Tegra firmware driver
# end of Firmware Drivers

# CONFIG_GNSS is not set
# CONFIG_MTD is not set
CONFIG_DTC=y
CONFIG_OF=y
# CONFIG_OF_UNITTEST is not set
CONFIG_OF_FLATTREE=y
CONFIG_OF_EARLY_FLATTREE=y
CONFIG_OF_KOBJ=y
CONFIG_OF_ADDRESS=y
CONFIG_OF_IRQ=y
CONFIG_OF_RESERVED_MEM=y
# CONFIG_OF_OVERLAY is not set
# CONFIG_PARPORT is not set
CONFIG_BLK_DEV=y
# CONFIG_BLK_DEV_NULL_BLK is not set
CONFIG_CDROM=y
# CONFIG_BLK_DEV_PCIESSD_MTIP32XX is not set
CONFIG_BLK_DEV_LOOP=y
CONFIG_BLK_DEV_LOOP_MIN_COUNT=8
# CONFIG_BLK_DEV_DRBD is not set
# CONFIG_BLK_DEV_NBD is not set
# CONFIG_BLK_DEV_SX8 is not set
# CONFIG_BLK_DEV_RAM is not set
# CONFIG_CDROM_PKTCDVD is not set
# CONFIG_ATA_OVER_ETH is not set
CONFIG_VIRTIO_BLK=y
# CONFIG_BLK_DEV_RBD is not set

#
# NVME Support
#
# CONFIG_BLK_DEV_NVME is not set
# CONFIG_NVME_FC is not set
# CONFIG_NVME_TCP is not set
# end of NVME Support

#
# Misc devices
#
# CONFIG_AD525X_DPOT is not set
# CONFIG_DUMMY_IRQ is not set
# CONFIG_PHANTOM is not set
# CONFIG_TIFM_CORE is not set
# CONFIG_ICS932S401 is not set
# CONFIG_ENCLOSURE_SERVICES is not set
# CONFIG_HP_ILO is not set
# CONFIG_APDS9802ALS is not set
# CONFIG_ISL29003 is not set
# CONFIG_ISL29020 is not set
# CONFIG_SENSORS_TSL2550 is not set
# CONFIG_SENSORS_BH1770 is not set
# CONFIG_SENSORS_APDS990X is not set
# CONFIG_HMC6352 is not set
# CONFIG_DS1682 is not set
# CONFIG_LATTICE_ECP3_CONFIG is not set
# CONFIG_SRAM is not set
# CONFIG_DW_XDATA_PCIE is not set
# CONFIG_PCI_ENDPOINT_TEST is not set
# CONFIG_XILINX_SDFEC is not set
# CONFIG_OPEN_DICE is not set
# CONFIG_C2PORT is not set

#
# EEPROM support
#
# CONFIG_EEPROM_AT24 is not set
# CONFIG_EEPROM_AT25 is not set
# CONFIG_EEPROM_LEGACY is not set
# CONFIG_EEPROM_MAX6875 is not set
# CONFIG_EEPROM_93CX6 is not set
# CONFIG_EEPROM_93XX46 is not set
# CONFIG_EEPROM_IDT_89HPESX is not set
# CONFIG_EEPROM_EE1004 is not set
# end of EEPROM support

# CONFIG_CB710_CORE is not set

#
# Texas Instruments shared transport line discipline
#
# end of Texas Instruments shared transport line discipline

# CONFIG_SENSORS_LIS3_SPI is not set
# CONFIG_SENSORS_LIS3_I2C is not set
# CONFIG_ALTERA_STAPL is not set
# CONFIG_GENWQE is not set
# CONFIG_ECHO is not set
# CONFIG_BCM_VK is not set
# CONFIG_MISC_ALCOR_PCI is not set
# CONFIG_MISC_RTSX_PCI is not set
# CONFIG_MISC_RTSX_USB is not set
# CONFIG_HABANA_AI is not set
# CONFIG_PVPANIC is not set
# end of Misc devices

#
# SCSI device support
#
CONFIG_SCSI_MOD=y
# CONFIG_RAID_ATTRS is not set
CONFIG_SCSI_COMMON=y
CONFIG_SCSI=y
CONFIG_SCSI_DMA=y
CONFIG_SCSI_PROC_FS=y

#
# SCSI support type (disk, tape, CD-ROM)
#
CONFIG_BLK_DEV_SD=y
# CONFIG_CHR_DEV_ST is not set
CONFIG_BLK_DEV_SR=y
# CONFIG_CHR_DEV_SG is not set
CONFIG_BLK_DEV_BSG=y
# CONFIG_CHR_DEV_SCH is not set
# CONFIG_SCSI_CONSTANTS is not set
# CONFIG_SCSI_LOGGING is not set
# CONFIG_SCSI_SCAN_ASYNC is not set

#
# SCSI Transports
#
# CONFIG_SCSI_SPI_ATTRS is not set
# CONFIG_SCSI_FC_ATTRS is not set
# CONFIG_SCSI_ISCSI_ATTRS is not set
# CONFIG_SCSI_SAS_ATTRS is not set
# CONFIG_SCSI_SAS_LIBSAS is not set
# CONFIG_SCSI_SRP_ATTRS is not set
# end of SCSI Transports

CONFIG_SCSI_LOWLEVEL=y
# CONFIG_ISCSI_TCP is not set
# CONFIG_ISCSI_BOOT_SYSFS is not set
# CONFIG_SCSI_CXGB3_ISCSI is not set
# CONFIG_SCSI_CXGB4_ISCSI is not set
# CONFIG_SCSI_BNX2_ISCSI is not set
# CONFIG_BE2ISCSI is not set
# CONFIG_BLK_DEV_3W_XXXX_RAID is not set
# CONFIG_SCSI_HPSA is not set
# CONFIG_SCSI_3W_9XXX is not set
# CONFIG_SCSI_3W_SAS is not set
# CONFIG_SCSI_ACARD is not set
# CONFIG_SCSI_AACRAID is not set
# CONFIG_SCSI_AIC7XXX is not set
# CONFIG_SCSI_AIC79XX is not set
# CONFIG_SCSI_AIC94XX is not set
# CONFIG_SCSI_MVSAS is not set
# CONFIG_SCSI_MVUMI is not set
# CONFIG_SCSI_ADVANSYS is not set
# CONFIG_SCSI_ARCMSR is not set
# CONFIG_SCSI_ESAS2R is not set
# CONFIG_MEGARAID_NEWGEN is not set
# CONFIG_MEGARAID_LEGACY is not set
# CONFIG_MEGARAID_SAS is not set
# CONFIG_SCSI_MPT3SAS is not set
# CONFIG_SCSI_MPT2SAS is not set
# CONFIG_SCSI_MPI3MR is not set
# CONFIG_SCSI_SMARTPQI is not set
# CONFIG_SCSI_UFSHCD is not set
# CONFIG_SCSI_HPTIOP is not set
# CONFIG_SCSI_MYRB is not set
# CONFIG_SCSI_MYRS is not set
# CONFIG_SCSI_SNIC is not set
# CONFIG_SCSI_DMX3191D is not set
# CONFIG_SCSI_FDOMAIN_PCI is not set
# CONFIG_SCSI_IPS is not set
# CONFIG_SCSI_INITIO is not set
# CONFIG_SCSI_INIA100 is not set
# CONFIG_SCSI_STEX is not set
# CONFIG_SCSI_SYM53C8XX_2 is not set
# CONFIG_SCSI_IPR is not set
# CONFIG_SCSI_QLOGIC_1280 is not set
# CONFIG_SCSI_QLA_ISCSI is not set
# CONFIG_SCSI_DC395x is not set
# CONFIG_SCSI_AM53C974 is not set
# CONFIG_SCSI_WD719X is not set
# CONFIG_SCSI_DEBUG is not set
# CONFIG_SCSI_PMCRAID is not set
# CONFIG_SCSI_PM8001 is not set
CONFIG_SCSI_VIRTIO=y
# CONFIG_SCSI_DH is not set
# end of SCSI device support

CONFIG_ATA=y
CONFIG_SATA_HOST=y
CONFIG_ATA_VERBOSE_ERROR=y
CONFIG_ATA_FORCE=y
CONFIG_SATA_PMP=y

#
# Controllers with non-SFF native interface
#
CONFIG_SATA_AHCI=y
CONFIG_SATA_MOBILE_LPM_POLICY=0
CONFIG_SATA_AHCI_PLATFORM=y
# CONFIG_AHCI_CEVA is not set
# CONFIG_AHCI_QORIQ is not set
# CONFIG_SATA_INIC162X is not set
# CONFIG_SATA_ACARD_AHCI is not set
# CONFIG_SATA_SIL24 is not set
CONFIG_ATA_SFF=y

#
# SFF controllers with custom DMA interface
#
# CONFIG_PDC_ADMA is not set
# CONFIG_SATA_QSTOR is not set
# CONFIG_SATA_SX4 is not set
CONFIG_ATA_BMDMA=y

#
# SATA SFF controllers with BMDMA
#
# CONFIG_ATA_PIIX is not set
# CONFIG_SATA_MV is not set
# CONFIG_SATA_NV is not set
# CONFIG_SATA_PROMISE is not set
# CONFIG_SATA_SIL is not set
# CONFIG_SATA_SIS is not set
# CONFIG_SATA_SVW is not set
# CONFIG_SATA_ULI is not set
# CONFIG_SATA_VIA is not set
# CONFIG_SATA_VITESSE is not set

#
# PATA SFF controllers with BMDMA
#
# CONFIG_PATA_ALI is not set
# CONFIG_PATA_AMD is not set
# CONFIG_PATA_ARTOP is not set
# CONFIG_PATA_ATIIXP is not set
# CONFIG_PATA_ATP867X is not set
# CONFIG_PATA_CMD64X is not set
# CONFIG_PATA_CYPRESS is not set
# CONFIG_PATA_EFAR is not set
# CONFIG_PATA_HPT366 is not set
# CONFIG_PATA_HPT37X is not set
# CONFIG_PATA_HPT3X2N is not set
# CONFIG_PATA_HPT3X3 is not set
# CONFIG_PATA_IT8213 is not set
# CONFIG_PATA_IT821X is not set
# CONFIG_PATA_JMICRON is not set
# CONFIG_PATA_MARVELL is not set
# CONFIG_PATA_NETCELL is not set
# CONFIG_PATA_NINJA32 is not set
# CONFIG_PATA_NS87415 is not set
# CONFIG_PATA_OLDPIIX is not set
# CONFIG_PATA_OPTIDMA is not set
# CONFIG_PATA_PDC2027X is not set
# CONFIG_PATA_PDC_OLD is not set
# CONFIG_PATA_RADISYS is not set
# CONFIG_PATA_RDC is not set
# CONFIG_PATA_SCH is not set
# CONFIG_PATA_SERVERWORKS is not set
# CONFIG_PATA_SIL680 is not set
# CONFIG_PATA_SIS is not set
# CONFIG_PATA_TOSHIBA is not set
# CONFIG_PATA_TRIFLEX is not set
# CONFIG_PATA_VIA is not set
# CONFIG_PATA_WINBOND is not set

#
# PIO-only SFF controllers
#
# CONFIG_PATA_CMD640_PCI is not set
# CONFIG_PATA_MPIIX is not set
# CONFIG_PATA_NS87410 is not set
# CONFIG_PATA_OPTI is not set
# CONFIG_PATA_PLATFORM is not set
# CONFIG_PATA_RZ1000 is not set

#
# Generic fallback / legacy drivers
#
# CONFIG_ATA_GENERIC is not set
# CONFIG_PATA_LEGACY is not set
# CONFIG_MD is not set
# CONFIG_TARGET_CORE is not set
# CONFIG_FUSION is not set

#
# IEEE 1394 (FireWire) support
#
# CONFIG_FIREWIRE is not set
# CONFIG_FIREWIRE_NOSY is not set
# end of IEEE 1394 (FireWire) support

CONFIG_NETDEVICES=y
CONFIG_NET_CORE=y
# CONFIG_BONDING is not set
# CONFIG_DUMMY is not set
# CONFIG_WIREGUARD is not set
# CONFIG_EQUALIZER is not set
# CONFIG_NET_FC is not set
# CONFIG_NET_TEAM is not set
# CONFIG_MACVLAN is not set
# CONFIG_IPVLAN is not set
# CONFIG_VXLAN is not set
# CONFIG_GENEVE is not set
# CONFIG_BAREUDP is not set
# CONFIG_GTP is not set
# CONFIG_AMT is not set
# CONFIG_MACSEC is not set
# CONFIG_NETCONSOLE is not set
# CONFIG_TUN is not set
# CONFIG_TUN_VNET_CROSS_LE is not set
# CONFIG_VETH is not set
CONFIG_VIRTIO_NET=y
# CONFIG_NLMON is not set
# CONFIG_ARCNET is not set
CONFIG_ETHERNET=y
CONFIG_NET_VENDOR_3COM=y
# CONFIG_VORTEX is not set
# CONFIG_TYPHOON is not set
CONFIG_NET_VENDOR_ADAPTEC=y
# CONFIG_ADAPTEC_STARFIRE is not set
CONFIG_NET_VENDOR_AGERE=y
# CONFIG_ET131X is not set
CONFIG_NET_VENDOR_ALACRITECH=y
# CONFIG_SLICOSS is not set
CONFIG_NET_VENDOR_ALTEON=y
# CONFIG_ACENIC is not set
# CONFIG_ALTERA_TSE is not set
CONFIG_NET_VENDOR_AMAZON=y
# CONFIG_ENA_ETHERNET is not set
CONFIG_NET_VENDOR_AMD=y
# CONFIG_AMD8111_ETH is not set
# CONFIG_PCNET32 is not set
CONFIG_NET_VENDOR_AQUANTIA=y
# CONFIG_AQTION is not set
CONFIG_NET_VENDOR_ARC=y
CONFIG_NET_VENDOR_ASIX=y
CONFIG_NET_VENDOR_ATHEROS=y
# CONFIG_ATL2 is not set
# CONFIG_ATL1 is not set
# CONFIG_ATL1E is not set
# CONFIG_ATL1C is not set
# CONFIG_ALX is not set
CONFIG_NET_VENDOR_BROADCOM=y
# CONFIG_B44 is not set
# CONFIG_BCMGENET is not set
# CONFIG_BNX2 is not set
# CONFIG_CNIC is not set
# CONFIG_TIGON3 is not set
# CONFIG_BNX2X is not set
# CONFIG_SYSTEMPORT is not set
# CONFIG_BNXT is not set
CONFIG_NET_VENDOR_CADENCE=y
CONFIG_MACB=y
# CONFIG_MACB_PCI is not set
CONFIG_NET_VENDOR_CAVIUM=y
# CONFIG_THUNDER_NIC_PF is not set
# CONFIG_THUNDER_NIC_VF is not set
# CONFIG_THUNDER_NIC_BGX is not set
# CONFIG_THUNDER_NIC_RGX is not set
# CONFIG_LIQUIDIO is not set
# CONFIG_LIQUIDIO_VF is not set
CONFIG_NET_VENDOR_CHELSIO=y
# CONFIG_CHELSIO_T1 is not set
# CONFIG_CHELSIO_T3 is not set
# CONFIG_CHELSIO_T4 is not set
# CONFIG_CHELSIO_T4VF is not set
CONFIG_NET_VENDOR_CISCO=y
# CONFIG_ENIC is not set
CONFIG_NET_VENDOR_CORTINA=y
# CONFIG_GEMINI_ETHERNET is not set
CONFIG_NET_VENDOR_DAVICOM=y
# CONFIG_DM9051 is not set
# CONFIG_DNET is not set
CONFIG_NET_VENDOR_DEC=y
# CONFIG_NET_TULIP is not set
CONFIG_NET_VENDOR_DLINK=y
# CONFIG_DL2K is not set
# CONFIG_SUNDANCE is not set
CONFIG_NET_VENDOR_EMULEX=y
# CONFIG_BE2NET is not set
CONFIG_NET_VENDOR_ENGLEDER=y
# CONFIG_TSNEP is not set
CONFIG_NET_VENDOR_EZCHIP=y
# CONFIG_EZCHIP_NPS_MANAGEMENT_ENET is not set
CONFIG_NET_VENDOR_FUNGIBLE=y
# CONFIG_FUN_ETH is not set
CONFIG_NET_VENDOR_GOOGLE=y
CONFIG_NET_VENDOR_HUAWEI=y
CONFIG_NET_VENDOR_I825XX=y
CONFIG_NET_VENDOR_INTEL=y
# CONFIG_E100 is not set
# CONFIG_E1000 is not set
CONFIG_E1000E=y
# CONFIG_IGB is not set
# CONFIG_IGBVF is not set
# CONFIG_IXGB is not set
# CONFIG_IXGBE is not set
# CONFIG_IXGBEVF is not set
# CONFIG_I40E is not set
# CONFIG_I40EVF is not set
# CONFIG_ICE is not set
# CONFIG_FM10K is not set
# CONFIG_IGC is not set
# CONFIG_JME is not set
CONFIG_NET_VENDOR_LITEX=y
# CONFIG_LITEX_LITEETH is not set
CONFIG_NET_VENDOR_MARVELL=y
# CONFIG_MVMDIO is not set
# CONFIG_SKGE is not set
# CONFIG_SKY2 is not set
CONFIG_NET_VENDOR_MELLANOX=y
# CONFIG_MLX4_EN is not set
# CONFIG_MLX5_CORE is not set
# CONFIG_MLXSW_CORE is not set
# CONFIG_MLXFW is not set
CONFIG_NET_VENDOR_MICREL=y
# CONFIG_KS8851 is not set
# CONFIG_KS8851_MLL is not set
# CONFIG_KSZ884X_PCI is not set
CONFIG_NET_VENDOR_MICROCHIP=y
# CONFIG_ENC28J60 is not set
# CONFIG_ENCX24J600 is not set
# CONFIG_LAN743X is not set
CONFIG_NET_VENDOR_MICROSEMI=y
CONFIG_NET_VENDOR_MICROSOFT=y
CONFIG_NET_VENDOR_MYRI=y
# CONFIG_MYRI10GE is not set
# CONFIG_FEALNX is not set
CONFIG_NET_VENDOR_NI=y
# CONFIG_NI_XGE_MANAGEMENT_ENET is not set
CONFIG_NET_VENDOR_NATSEMI=y
# CONFIG_NATSEMI is not set
# CONFIG_NS83820 is not set
CONFIG_NET_VENDOR_NETERION=y
# CONFIG_S2IO is not set
# CONFIG_VXGE is not set
CONFIG_NET_VENDOR_NETRONOME=y
# CONFIG_NFP is not set
CONFIG_NET_VENDOR_8390=y
# CONFIG_NE2K_PCI is not set
CONFIG_NET_VENDOR_NVIDIA=y
# CONFIG_FORCEDETH is not set
CONFIG_NET_VENDOR_OKI=y
# CONFIG_ETHOC is not set
CONFIG_NET_VENDOR_PACKET_ENGINES=y
# CONFIG_HAMACHI is not set
# CONFIG_YELLOWFIN is not set
CONFIG_NET_VENDOR_PENSANDO=y
# CONFIG_IONIC is not set
CONFIG_NET_VENDOR_QLOGIC=y
# CONFIG_QLA3XXX is not set
# CONFIG_QLCNIC is not set
# CONFIG_NETXEN_NIC is not set
# CONFIG_QED is not set
CONFIG_NET_VENDOR_BROCADE=y
# CONFIG_BNA is not set
CONFIG_NET_VENDOR_QUALCOMM=y
# CONFIG_QCA7000_SPI is not set
# CONFIG_QCOM_EMAC is not set
# CONFIG_RMNET is not set
CONFIG_NET_VENDOR_RDC=y
# CONFIG_R6040 is not set
CONFIG_NET_VENDOR_REALTEK=y
# CONFIG_8139CP is not set
# CONFIG_8139TOO is not set
CONFIG_R8169=y
CONFIG_NET_VENDOR_RENESAS=y
CONFIG_NET_VENDOR_ROCKER=y
CONFIG_NET_VENDOR_SAMSUNG=y
# CONFIG_SXGBE_ETH is not set
CONFIG_NET_VENDOR_SEEQ=y
CONFIG_NET_VENDOR_SILAN=y
# CONFIG_SC92031 is not set
CONFIG_NET_VENDOR_SIS=y
# CONFIG_SIS900 is not set
# CONFIG_SIS190 is not set
CONFIG_NET_VENDOR_SOLARFLARE=y
# CONFIG_SFC is not set
# CONFIG_SFC_FALCON is not set
CONFIG_NET_VENDOR_SMSC=y
# CONFIG_EPIC100 is not set
# CONFIG_SMSC911X is not set
# CONFIG_SMSC9420 is not set
CONFIG_NET_VENDOR_SOCIONEXT=y
CONFIG_NET_VENDOR_STMICRO=y
# CONFIG_STMMAC_ETH is not set
CONFIG_NET_VENDOR_SUN=y
# CONFIG_HAPPYMEAL is not set
# CONFIG_SUNGEM is not set
# CONFIG_CASSINI is not set
# CONFIG_NIU is not set
CONFIG_NET_VENDOR_SYNOPSYS=y
# CONFIG_DWC_XLGMAC is not set
CONFIG_NET_VENDOR_TEHUTI=y
# CONFIG_TEHUTI is not set
CONFIG_NET_VENDOR_TI=y
# CONFIG_TI_CPSW_PHY_SEL is not set
# CONFIG_TLAN is not set
# CONFIG_NET_VENDOR_VERTEXCOM is not set
CONFIG_NET_VENDOR_VIA=y
# CONFIG_VIA_RHINE is not set
# CONFIG_VIA_VELOCITY is not set
CONFIG_NET_VENDOR_WIZNET=y
# CONFIG_WIZNET_W5100 is not set
# CONFIG_WIZNET_W5300 is not set
CONFIG_NET_VENDOR_XILINX=y
# CONFIG_XILINX_EMACLITE is not set
# CONFIG_XILINX_AXI_EMAC is not set
# CONFIG_XILINX_LL_TEMAC is not set
# CONFIG_FDDI is not set
# CONFIG_HIPPI is not set
CONFIG_PHYLINK=y
CONFIG_PHYLIB=y
CONFIG_SWPHY=y
CONFIG_FIXED_PHY=y
# CONFIG_SFP is not set

#
# MII PHY device drivers
#
# CONFIG_AMD_PHY is not set
# CONFIG_ADIN_PHY is not set
# CONFIG_AQUANTIA_PHY is not set
# CONFIG_AX88796B_PHY is not set
# CONFIG_BROADCOM_PHY is not set
# CONFIG_BCM54140_PHY is not set
# CONFIG_BCM7XXX_PHY is not set
# CONFIG_BCM84881_PHY is not set
# CONFIG_BCM87XX_PHY is not set
# CONFIG_CICADA_PHY is not set
# CONFIG_CORTINA_PHY is not set
# CONFIG_DAVICOM_PHY is not set
# CONFIG_ICPLUS_PHY is not set
# CONFIG_LXT_PHY is not set
# CONFIG_INTEL_XWAY_PHY is not set
# CONFIG_LSI_ET1011C_PHY is not set
# CONFIG_MARVELL_PHY is not set
# CONFIG_MARVELL_10G_PHY is not set
# CONFIG_MARVELL_88X2222_PHY is not set
# CONFIG_MAXLINEAR_GPHY is not set
# CONFIG_MEDIATEK_GE_PHY is not set
# CONFIG_MICREL_PHY is not set
# CONFIG_MICROCHIP_PHY is not set
# CONFIG_MICROCHIP_T1_PHY is not set
CONFIG_MICROSEMI_PHY=y
# CONFIG_MOTORCOMM_PHY is not set
# CONFIG_NATIONAL_PHY is not set
# CONFIG_NXP_C45_TJA11XX_PHY is not set
# CONFIG_NXP_TJA11XX_PHY is not set
# CONFIG_QSEMI_PHY is not set
CONFIG_REALTEK_PHY=y
# CONFIG_RENESAS_PHY is not set
# CONFIG_ROCKCHIP_PHY is not set
# CONFIG_SMSC_PHY is not set
# CONFIG_STE10XP is not set
# CONFIG_TERANETICS_PHY is not set
# CONFIG_DP83822_PHY is not set
# CONFIG_DP83TC811_PHY is not set
# CONFIG_DP83848_PHY is not set
# CONFIG_DP83867_PHY is not set
# CONFIG_DP83869_PHY is not set
# CONFIG_VITESSE_PHY is not set
# CONFIG_XILINX_GMII2RGMII is not set
# CONFIG_MICREL_KS8995MA is not set
CONFIG_MDIO_DEVICE=y
CONFIG_MDIO_BUS=y
CONFIG_FWNODE_MDIO=y
CONFIG_OF_MDIO=y
CONFIG_MDIO_DEVRES=y
# CONFIG_MDIO_BITBANG is not set
# CONFIG_MDIO_BCM_UNIMAC is not set
# CONFIG_MDIO_HISI_FEMAC is not set
# CONFIG_MDIO_MVUSB is not set
# CONFIG_MDIO_MSCC_MIIM is not set
# CONFIG_MDIO_OCTEON is not set
# CONFIG_MDIO_IPQ4019 is not set
# CONFIG_MDIO_IPQ8064 is not set
# CONFIG_MDIO_THUNDER is not set

#
# MDIO Multiplexers
#
# CONFIG_MDIO_BUS_MUX_MULTIPLEXER is not set
# CONFIG_MDIO_BUS_MUX_MMIOREG is not set

#
# PCS device drivers
#
# CONFIG_PCS_XPCS is not set
# end of PCS device drivers

# CONFIG_PPP is not set
# CONFIG_SLIP is not set
# CONFIG_USB_NET_DRIVERS is not set
# CONFIG_WLAN is not set
# CONFIG_WAN is not set

#
# Wireless WAN
#
# CONFIG_WWAN is not set
# end of Wireless WAN

# CONFIG_VMXNET3 is not set
# CONFIG_NETDEVSIM is not set
CONFIG_NET_FAILOVER=y
# CONFIG_ISDN is not set

#
# Input device support
#
CONFIG_INPUT=y
# CONFIG_INPUT_FF_MEMLESS is not set
# CONFIG_INPUT_SPARSEKMAP is not set
# CONFIG_INPUT_MATRIXKMAP is not set
CONFIG_INPUT_VIVALDIFMAP=y

#
# Userland interfaces
#
CONFIG_INPUT_MOUSEDEV=y
# CONFIG_INPUT_MOUSEDEV_PSAUX is not set
CONFIG_INPUT_MOUSEDEV_SCREEN_X=1024
CONFIG_INPUT_MOUSEDEV_SCREEN_Y=768
# CONFIG_INPUT_JOYDEV is not set
# CONFIG_INPUT_EVDEV is not set
# CONFIG_INPUT_EVBUG is not set

#
# Input Device Drivers
#
CONFIG_INPUT_KEYBOARD=y
# CONFIG_KEYBOARD_ADP5588 is not set
# CONFIG_KEYBOARD_ADP5589 is not set
CONFIG_KEYBOARD_ATKBD=y
# CONFIG_KEYBOARD_QT1050 is not set
# CONFIG_KEYBOARD_QT1070 is not set
# CONFIG_KEYBOARD_QT2160 is not set
# CONFIG_KEYBOARD_DLINK_DIR685 is not set
# CONFIG_KEYBOARD_LKKBD is not set
# CONFIG_KEYBOARD_TCA6416 is not set
# CONFIG_KEYBOARD_TCA8418 is not set
# CONFIG_KEYBOARD_LM8333 is not set
# CONFIG_KEYBOARD_MAX7359 is not set
# CONFIG_KEYBOARD_MCS is not set
# CONFIG_KEYBOARD_MPR121 is not set
# CONFIG_KEYBOARD_NEWTON is not set
# CONFIG_KEYBOARD_OPENCORES is not set
# CONFIG_KEYBOARD_SAMSUNG is not set
# CONFIG_KEYBOARD_GOLDFISH_EVENTS is not set
# CONFIG_KEYBOARD_STOWAWAY is not set
# CONFIG_KEYBOARD_SUNKBD is not set
# CONFIG_KEYBOARD_OMAP4 is not set
# CONFIG_KEYBOARD_XTKBD is not set
# CONFIG_KEYBOARD_CAP11XX is not set
# CONFIG_KEYBOARD_BCM is not set
# CONFIG_KEYBOARD_CYPRESS_SF is not set
CONFIG_INPUT_MOUSE=y
CONFIG_MOUSE_PS2=y
CONFIG_MOUSE_PS2_ALPS=y
CONFIG_MOUSE_PS2_BYD=y
CONFIG_MOUSE_PS2_LOGIPS2PP=y
CONFIG_MOUSE_PS2_SYNAPTICS=y
CONFIG_MOUSE_PS2_SYNAPTICS_SMBUS=y
CONFIG_MOUSE_PS2_CYPRESS=y
CONFIG_MOUSE_PS2_TRACKPOINT=y
# CONFIG_MOUSE_PS2_ELANTECH is not set
# CONFIG_MOUSE_PS2_SENTELIC is not set
# CONFIG_MOUSE_PS2_TOUCHKIT is not set
CONFIG_MOUSE_PS2_FOCALTECH=y
CONFIG_MOUSE_PS2_SMBUS=y
# CONFIG_MOUSE_SERIAL is not set
# CONFIG_MOUSE_APPLETOUCH is not set
# CONFIG_MOUSE_BCM5974 is not set
# CONFIG_MOUSE_CYAPA is not set
# CONFIG_MOUSE_ELAN_I2C is not set
# CONFIG_MOUSE_VSXXXAA is not set
# CONFIG_MOUSE_SYNAPTICS_I2C is not set
# CONFIG_MOUSE_SYNAPTICS_USB is not set
# CONFIG_INPUT_JOYSTICK is not set
# CONFIG_INPUT_TABLET is not set
# CONFIG_INPUT_TOUCHSCREEN is not set
# CONFIG_INPUT_MISC is not set
# CONFIG_RMI4_CORE is not set

#
# Hardware I/O ports
#
CONFIG_SERIO=y
CONFIG_SERIO_SERPORT=y
# CONFIG_SERIO_PCIPS2 is not set
CONFIG_SERIO_LIBPS2=y
# CONFIG_SERIO_RAW is not set
# CONFIG_SERIO_ALTERA_PS2 is not set
# CONFIG_SERIO_PS2MULT is not set
# CONFIG_SERIO_ARC_PS2 is not set
# CONFIG_SERIO_APBPS2 is not set
# CONFIG_USERIO is not set
# CONFIG_GAMEPORT is not set
# end of Hardware I/O ports
# end of Input device support

#
# Character devices
#
CONFIG_TTY=y
CONFIG_VT=y
CONFIG_CONSOLE_TRANSLATIONS=y
CONFIG_VT_CONSOLE=y
CONFIG_HW_CONSOLE=y
CONFIG_VT_HW_CONSOLE_BINDING=y
CONFIG_UNIX98_PTYS=y
CONFIG_LEGACY_PTYS=y
CONFIG_LEGACY_PTY_COUNT=256
CONFIG_LDISC_AUTOLOAD=y

#
# Serial drivers
#
CONFIG_SERIAL_EARLYCON=y
CONFIG_SERIAL_8250=y
CONFIG_SERIAL_8250_DEPRECATED_OPTIONS=y
# CONFIG_SERIAL_8250_16550A_VARIANTS is not set
# CONFIG_SERIAL_8250_FINTEK is not set
CONFIG_SERIAL_8250_CONSOLE=y
CONFIG_SERIAL_8250_PCI=y
CONFIG_SERIAL_8250_EXAR=y
CONFIG_SERIAL_8250_NR_UARTS=4
CONFIG_SERIAL_8250_RUNTIME_UARTS=4
# CONFIG_SERIAL_8250_EXTENDED is not set
# CONFIG_SERIAL_8250_ASPEED_VUART is not set
# CONFIG_SERIAL_8250_DW is not set
# CONFIG_SERIAL_8250_RT288X is not set
CONFIG_SERIAL_8250_PERICOM=y
CONFIG_SERIAL_OF_PLATFORM=y

#
# Non-8250 serial port support
#
CONFIG_SERIAL_EARLYCON_RISCV_SBI=y
# CONFIG_SERIAL_MAX3100 is not set
# CONFIG_SERIAL_MAX310X is not set
# CONFIG_SERIAL_UARTLITE is not set
CONFIG_SERIAL_CORE=y
CONFIG_SERIAL_CORE_CONSOLE=y
# CONFIG_SERIAL_JSM is not set
CONFIG_SERIAL_SIFIVE=y
CONFIG_SERIAL_SIFIVE_CONSOLE=y
# CONFIG_SERIAL_SCCNXP is not set
# CONFIG_SERIAL_SC16IS7XX is not set
# CONFIG_SERIAL_ALTERA_JTAGUART is not set
# CONFIG_SERIAL_ALTERA_UART is not set
# CONFIG_SERIAL_XILINX_PS_UART is not set
# CONFIG_SERIAL_ARC is not set
# CONFIG_SERIAL_RP2 is not set
# CONFIG_SERIAL_FSL_LPUART is not set
# CONFIG_SERIAL_FSL_LINFLEXUART is not set
# CONFIG_SERIAL_CONEXANT_DIGICOLOR is not set
# CONFIG_SERIAL_SPRD is not set
# end of Serial drivers

# CONFIG_SERIAL_NONSTANDARD is not set
# CONFIG_GOLDFISH_TTY is not set
# CONFIG_N_GSM is not set
# CONFIG_NOZOMI is not set
# CONFIG_NULL_TTY is not set
CONFIG_HVC_DRIVER=y
CONFIG_HVC_RISCV_SBI=y
# CONFIG_RPMSG_TTY is not set
# CONFIG_SERIAL_DEV_BUS is not set
# CONFIG_TTY_PRINTK is not set
CONFIG_VIRTIO_CONSOLE=y
# CONFIG_IPMI_HANDLER is not set
CONFIG_HW_RANDOM=y
# CONFIG_HW_RANDOM_TIMERIOMEM is not set
# CONFIG_HW_RANDOM_BA431 is not set
CONFIG_HW_RANDOM_VIRTIO=y
# CONFIG_HW_RANDOM_CCTRNG is not set
# CONFIG_HW_RANDOM_XIPHERA is not set
# CONFIG_APPLICOM is not set
CONFIG_DEVMEM=y
CONFIG_DEVPORT=y
# CONFIG_TCG_TPM is not set
# CONFIG_XILLYBUS is not set
# CONFIG_XILLYUSB is not set
# CONFIG_RANDOM_TRUST_BOOTLOADER is not set
# end of Character devices

#
# I2C support
#
CONFIG_I2C=y
CONFIG_I2C_BOARDINFO=y
CONFIG_I2C_COMPAT=y
# CONFIG_I2C_CHARDEV is not set
# CONFIG_I2C_MUX is not set
CONFIG_I2C_HELPER_AUTO=y
CONFIG_I2C_ALGOBIT=y

#
# I2C Hardware Bus support
#

#
# PC SMBus host controller drivers
#
# CONFIG_I2C_ALI1535 is not set
# CONFIG_I2C_ALI1563 is not set
# CONFIG_I2C_ALI15X3 is not set
# CONFIG_I2C_AMD756 is not set
# CONFIG_I2C_AMD8111 is not set
# CONFIG_I2C_I801 is not set
# CONFIG_I2C_ISCH is not set
# CONFIG_I2C_PIIX4 is not set
# CONFIG_I2C_NFORCE2 is not set
# CONFIG_I2C_NVIDIA_GPU is not set
# CONFIG_I2C_SIS5595 is not set
# CONFIG_I2C_SIS630 is not set
# CONFIG_I2C_SIS96X is not set
# CONFIG_I2C_VIA is not set
# CONFIG_I2C_VIAPRO is not set

#
# I2C system bus drivers (mostly embedded / system-on-chip)
#
# CONFIG_I2C_DESIGNWARE_PLATFORM is not set
# CONFIG_I2C_DESIGNWARE_PCI is not set
# CONFIG_I2C_EMEV2 is not set
# CONFIG_I2C_OCORES is not set
# CONFIG_I2C_PCA_PLATFORM is not set
# CONFIG_I2C_RK3X is not set
# CONFIG_I2C_SIMTEC is not set
# CONFIG_I2C_XILINX is not set

#
# External I2C/SMBus adapter drivers
#
# CONFIG_I2C_DIOLAN_U2C is not set
# CONFIG_I2C_CP2615 is not set
# CONFIG_I2C_ROBOTFUZZ_OSIF is not set
# CONFIG_I2C_TAOS_EVM is not set
# CONFIG_I2C_TINY_USB is not set

#
# Other I2C/SMBus bus drivers
#
# CONFIG_I2C_VIRTIO is not set
# end of I2C Hardware Bus support

# CONFIG_I2C_STUB is not set
# CONFIG_I2C_SLAVE is not set
# CONFIG_I2C_DEBUG_CORE is not set
# CONFIG_I2C_DEBUG_ALGO is not set
# CONFIG_I2C_DEBUG_BUS is not set
# end of I2C support

# CONFIG_I3C is not set
CONFIG_SPI=y
# CONFIG_SPI_DEBUG is not set
CONFIG_SPI_MASTER=y
# CONFIG_SPI_MEM is not set

#
# SPI Master Controller Drivers
#
# CONFIG_SPI_ALTERA is not set
# CONFIG_SPI_AXI_SPI_ENGINE is not set
# CONFIG_SPI_BITBANG is not set
# CONFIG_SPI_CADENCE is not set
# CONFIG_SPI_DESIGNWARE is not set
# CONFIG_SPI_NXP_FLEXSPI is not set
# CONFIG_SPI_FSL_SPI is not set
# CONFIG_SPI_PXA2XX is not set
# CONFIG_SPI_ROCKCHIP is not set
# CONFIG_SPI_SC18IS602 is not set
CONFIG_SPI_SIFIVE=y
# CONFIG_SPI_MXIC is not set
# CONFIG_SPI_XCOMM is not set
# CONFIG_SPI_XILINX is not set
# CONFIG_SPI_ZYNQMP_GQSPI is not set
# CONFIG_SPI_AMD is not set

#
# SPI Multiplexer support
#
# CONFIG_SPI_MUX is not set

#
# SPI Protocol Masters
#
# CONFIG_SPI_SPIDEV is not set
# CONFIG_SPI_LOOPBACK_TEST is not set
# CONFIG_SPI_TLE62X0 is not set
# CONFIG_SPI_SLAVE is not set
# CONFIG_SPMI is not set
# CONFIG_HSI is not set
# CONFIG_PPS is not set

#
# PTP clock support
#
# CONFIG_PTP_1588_CLOCK is not set
CONFIG_PTP_1588_CLOCK_OPTIONAL=y

#
# Enable PHYLIB and NETWORK_PHY_TIMESTAMPING to see the additional clocks.
#
# end of PTP clock support

# CONFIG_PINCTRL is not set
# CONFIG_GPIOLIB is not set
# CONFIG_W1 is not set
CONFIG_POWER_RESET=y
# CONFIG_POWER_RESET_RESTART is not set
CONFIG_POWER_RESET_SYSCON=y
CONFIG_POWER_RESET_SYSCON_POWEROFF=y
# CONFIG_SYSCON_REBOOT_MODE is not set
# CONFIG_NVMEM_REBOOT_MODE is not set
CONFIG_POWER_SUPPLY=y
# CONFIG_POWER_SUPPLY_DEBUG is not set
CONFIG_POWER_SUPPLY_HWMON=y
# CONFIG_PDA_POWER is not set
# CONFIG_IP5XXX_POWER is not set
# CONFIG_TEST_POWER is not set
# CONFIG_CHARGER_ADP5061 is not set
# CONFIG_BATTERY_CW2015 is not set
# CONFIG_BATTERY_DS2780 is not set
# CONFIG_BATTERY_DS2781 is not set
# CONFIG_BATTERY_DS2782 is not set
# CONFIG_BATTERY_SAMSUNG_SDI is not set
# CONFIG_BATTERY_SBS is not set
# CONFIG_CHARGER_SBS is not set
# CONFIG_BATTERY_BQ27XXX is not set
# CONFIG_BATTERY_MAX17040 is not set
# CONFIG_BATTERY_MAX17042 is not set
# CONFIG_CHARGER_MAX8903 is not set
# CONFIG_CHARGER_LP8727 is not set
# CONFIG_CHARGER_LTC4162L is not set
# CONFIG_CHARGER_DETECTOR_MAX14656 is not set
# CONFIG_CHARGER_MAX77976 is not set
# CONFIG_CHARGER_BQ2415X is not set
# CONFIG_BATTERY_GAUGE_LTC2941 is not set
# CONFIG_BATTERY_GOLDFISH is not set
# CONFIG_BATTERY_RT5033 is not set
# CONFIG_CHARGER_BD99954 is not set
# CONFIG_BATTERY_UG3105 is not set
CONFIG_HWMON=y
# CONFIG_HWMON_DEBUG_CHIP is not set

#
# Native drivers
#
# CONFIG_SENSORS_AD7314 is not set
# CONFIG_SENSORS_AD7414 is not set
# CONFIG_SENSORS_AD7418 is not set
# CONFIG_SENSORS_ADM1021 is not set
# CONFIG_SENSORS_ADM1025 is not set
# CONFIG_SENSORS_ADM1026 is not set
# CONFIG_SENSORS_ADM1029 is not set
# CONFIG_SENSORS_ADM1031 is not set
# CONFIG_SENSORS_ADM1177 is not set
# CONFIG_SENSORS_ADM9240 is not set
# CONFIG_SENSORS_ADT7310 is not set
# CONFIG_SENSORS_ADT7410 is not set
# CONFIG_SENSORS_ADT7411 is not set
# CONFIG_SENSORS_ADT7462 is not set
# CONFIG_SENSORS_ADT7470 is not set
# CONFIG_SENSORS_ADT7475 is not set
# CONFIG_SENSORS_AHT10 is not set
# CONFIG_SENSORS_AQUACOMPUTER_D5NEXT is not set
# CONFIG_SENSORS_AS370 is not set
# CONFIG_SENSORS_ASC7621 is not set
# CONFIG_SENSORS_AXI_FAN_CONTROL is not set
# CONFIG_SENSORS_ASPEED is not set
# CONFIG_SENSORS_ATXP1 is not set
# CONFIG_SENSORS_CORSAIR_CPRO is not set
# CONFIG_SENSORS_CORSAIR_PSU is not set
# CONFIG_SENSORS_DRIVETEMP is not set
# CONFIG_SENSORS_DS620 is not set
# CONFIG_SENSORS_DS1621 is not set
# CONFIG_SENSORS_I5K_AMB is not set
# CONFIG_SENSORS_F71805F is not set
# CONFIG_SENSORS_F71882FG is not set
# CONFIG_SENSORS_F75375S is not set
# CONFIG_SENSORS_GL518SM is not set
# CONFIG_SENSORS_GL520SM is not set
# CONFIG_SENSORS_G760A is not set
# CONFIG_SENSORS_G762 is not set
# CONFIG_SENSORS_HIH6130 is not set
# CONFIG_SENSORS_IT87 is not set
# CONFIG_SENSORS_JC42 is not set
# CONFIG_SENSORS_POWR1220 is not set
# CONFIG_SENSORS_LINEAGE is not set
# CONFIG_SENSORS_LTC2945 is not set
# CONFIG_SENSORS_LTC2947_I2C is not set
# CONFIG_SENSORS_LTC2947_SPI is not set
# CONFIG_SENSORS_LTC2990 is not set
# CONFIG_SENSORS_LTC4151 is not set
# CONFIG_SENSORS_LTC4215 is not set
# CONFIG_SENSORS_LTC4222 is not set
# CONFIG_SENSORS_LTC4245 is not set
# CONFIG_SENSORS_LTC4260 is not set
# CONFIG_SENSORS_LTC4261 is not set
# CONFIG_SENSORS_MAX1111 is not set
# CONFIG_SENSORS_MAX127 is not set
# CONFIG_SENSORS_MAX16065 is not set
# CONFIG_SENSORS_MAX1619 is not set
# CONFIG_SENSORS_MAX1668 is not set
# CONFIG_SENSORS_MAX197 is not set
# CONFIG_SENSORS_MAX31722 is not set
# CONFIG_SENSORS_MAX31730 is not set
# CONFIG_SENSORS_MAX6620 is not set
# CONFIG_SENSORS_MAX6621 is not set
# CONFIG_SENSORS_MAX6639 is not set
# CONFIG_SENSORS_MAX6642 is not set
# CONFIG_SENSORS_MAX6650 is not set
# CONFIG_SENSORS_MAX6697 is not set
# CONFIG_SENSORS_MAX31790 is not set
# CONFIG_SENSORS_MCP3021 is not set
# CONFIG_SENSORS_TC654 is not set
# CONFIG_SENSORS_TPS23861 is not set
# CONFIG_SENSORS_MR75203 is not set
# CONFIG_SENSORS_ADCXX is not set
# CONFIG_SENSORS_LM63 is not set
# CONFIG_SENSORS_LM70 is not set
# CONFIG_SENSORS_LM73 is not set
# CONFIG_SENSORS_LM75 is not set
# CONFIG_SENSORS_LM77 is not set
# CONFIG_SENSORS_LM78 is not set
# CONFIG_SENSORS_LM80 is not set
# CONFIG_SENSORS_LM83 is not set
# CONFIG_SENSORS_LM85 is not set
# CONFIG_SENSORS_LM87 is not set
# CONFIG_SENSORS_LM90 is not set
# CONFIG_SENSORS_LM92 is not set
# CONFIG_SENSORS_LM93 is not set
# CONFIG_SENSORS_LM95234 is not set
# CONFIG_SENSORS_LM95241 is not set
# CONFIG_SENSORS_LM95245 is not set
# CONFIG_SENSORS_PC87360 is not set
# CONFIG_SENSORS_PC87427 is not set
# CONFIG_SENSORS_NCT6683 is not set
# CONFIG_SENSORS_NCT6775 is not set
# CONFIG_SENSORS_NCT7802 is not set
# CONFIG_SENSORS_NPCM7XX is not set
# CONFIG_SENSORS_NZXT_KRAKEN2 is not set
# CONFIG_SENSORS_NZXT_SMART2 is not set
# CONFIG_SENSORS_PCF8591 is not set
# CONFIG_PMBUS is not set
# CONFIG_SENSORS_SBTSI is not set
# CONFIG_SENSORS_SBRMI is not set
# CONFIG_SENSORS_SHT21 is not set
# CONFIG_SENSORS_SHT3x is not set
# CONFIG_SENSORS_SHT4x is not set
# CONFIG_SENSORS_SHTC1 is not set
# CONFIG_SENSORS_SIS5595 is not set
# CONFIG_SENSORS_SY7636A is not set
# CONFIG_SENSORS_DME1737 is not set
# CONFIG_SENSORS_EMC1403 is not set
# CONFIG_SENSORS_EMC2103 is not set
# CONFIG_SENSORS_EMC6W201 is not set
# CONFIG_SENSORS_SMSC47M1 is not set
# CONFIG_SENSORS_SMSC47M192 is not set
# CONFIG_SENSORS_SMSC47B397 is not set
# CONFIG_SENSORS_STTS751 is not set
# CONFIG_SENSORS_SMM665 is not set
# CONFIG_SENSORS_ADC128D818 is not set
# CONFIG_SENSORS_ADS7828 is not set
# CONFIG_SENSORS_ADS7871 is not set
# CONFIG_SENSORS_AMC6821 is not set
# CONFIG_SENSORS_INA209 is not set
# CONFIG_SENSORS_INA2XX is not set
# CONFIG_SENSORS_INA238 is not set
# CONFIG_SENSORS_INA3221 is not set
# CONFIG_SENSORS_TC74 is not set
# CONFIG_SENSORS_THMC50 is not set
# CONFIG_SENSORS_TMP102 is not set
# CONFIG_SENSORS_TMP103 is not set
# CONFIG_SENSORS_TMP108 is not set
# CONFIG_SENSORS_TMP401 is not set
# CONFIG_SENSORS_TMP421 is not set
# CONFIG_SENSORS_TMP464 is not set
# CONFIG_SENSORS_TMP513 is not set
# CONFIG_SENSORS_VIA686A is not set
# CONFIG_SENSORS_VT1211 is not set
# CONFIG_SENSORS_VT8231 is not set
# CONFIG_SENSORS_W83773G is not set
# CONFIG_SENSORS_W83781D is not set
# CONFIG_SENSORS_W83791D is not set
# CONFIG_SENSORS_W83792D is not set
# CONFIG_SENSORS_W83793 is not set
# CONFIG_SENSORS_W83795 is not set
# CONFIG_SENSORS_W83L785TS is not set
# CONFIG_SENSORS_W83L786NG is not set
# CONFIG_SENSORS_W83627HF is not set
# CONFIG_SENSORS_W83627EHF is not set
# CONFIG_THERMAL is not set
# CONFIG_WATCHDOG is not set
CONFIG_SSB_POSSIBLE=y
# CONFIG_SSB is not set
CONFIG_BCMA_POSSIBLE=y
# CONFIG_BCMA is not set

#
# Multifunction device drivers
#
# CONFIG_MFD_ACT8945A is not set
# CONFIG_MFD_AS3711 is not set
# CONFIG_MFD_AS3722 is not set
# CONFIG_PMIC_ADP5520 is not set
# CONFIG_MFD_ATMEL_FLEXCOM is not set
# CONFIG_MFD_ATMEL_HLCDC is not set
# CONFIG_MFD_BCM590XX is not set
# CONFIG_MFD_BD9571MWV is not set
# CONFIG_MFD_AXP20X_I2C is not set
# CONFIG_MFD_MADERA is not set
# CONFIG_PMIC_DA903X is not set
# CONFIG_MFD_DA9052_SPI is not set
# CONFIG_MFD_DA9052_I2C is not set
# CONFIG_MFD_DA9055 is not set
# CONFIG_MFD_DA9062 is not set
# CONFIG_MFD_DA9063 is not set
# CONFIG_MFD_DA9150 is not set
# CONFIG_MFD_DLN2 is not set
# CONFIG_MFD_GATEWORKS_GSC is not set
# CONFIG_MFD_MC13XXX_SPI is not set
# CONFIG_MFD_MC13XXX_I2C is not set
# CONFIG_MFD_MP2629 is not set
# CONFIG_MFD_HI6421_PMIC is not set
# CONFIG_HTC_PASIC3 is not set
# CONFIG_LPC_ICH is not set
# CONFIG_LPC_SCH is not set
# CONFIG_MFD_IQS62X is not set
# CONFIG_MFD_JANZ_CMODIO is not set
# CONFIG_MFD_KEMPLD is not set
# CONFIG_MFD_88PM800 is not set
# CONFIG_MFD_88PM805 is not set
# CONFIG_MFD_88PM860X is not set
# CONFIG_MFD_MAX14577 is not set
# CONFIG_MFD_MAX77620 is not set
# CONFIG_MFD_MAX77650 is not set
# CONFIG_MFD_MAX77686 is not set
# CONFIG_MFD_MAX77693 is not set
# CONFIG_MFD_MAX77714 is not set
# CONFIG_MFD_MAX77843 is not set
# CONFIG_MFD_MAX8907 is not set
# CONFIG_MFD_MAX8925 is not set
# CONFIG_MFD_MAX8997 is not set
# CONFIG_MFD_MAX8998 is not set
# CONFIG_MFD_MT6360 is not set
# CONFIG_MFD_MT6397 is not set
# CONFIG_MFD_MENF21BMC is not set
# CONFIG_EZX_PCAP is not set
# CONFIG_MFD_CPCAP is not set
# CONFIG_MFD_VIPERBOARD is not set
# CONFIG_MFD_NTXEC is not set
# CONFIG_MFD_RETU is not set
# CONFIG_MFD_PCF50633 is not set
# CONFIG_MFD_RDC321X is not set
# CONFIG_MFD_RT4831 is not set
# CONFIG_MFD_RT5033 is not set
# CONFIG_MFD_RC5T583 is not set
# CONFIG_MFD_RK808 is not set
# CONFIG_MFD_RN5T618 is not set
# CONFIG_MFD_SEC_CORE is not set
# CONFIG_MFD_SI476X_CORE is not set
# CONFIG_MFD_SIMPLE_MFD_I2C is not set
# CONFIG_MFD_SM501 is not set
# CONFIG_MFD_SKY81452 is not set
# CONFIG_MFD_STMPE is not set
CONFIG_MFD_SYSCON=y
# CONFIG_MFD_TI_AM335X_TSCADC is not set
# CONFIG_MFD_LP3943 is not set
# CONFIG_MFD_LP8788 is not set
# CONFIG_MFD_TI_LMU is not set
# CONFIG_MFD_PALMAS is not set
# CONFIG_TPS6105X is not set
# CONFIG_TPS6507X is not set
# CONFIG_MFD_TPS65086 is not set
# CONFIG_MFD_TPS65090 is not set
# CONFIG_MFD_TPS65217 is not set
# CONFIG_MFD_TI_LP873X is not set
# CONFIG_MFD_TI_LP87565 is not set
# CONFIG_MFD_TPS65218 is not set
# CONFIG_MFD_TPS6586X is not set
# CONFIG_MFD_TPS65912_I2C is not set
# CONFIG_MFD_TPS65912_SPI is not set
# CONFIG_TWL4030_CORE is not set
# CONFIG_TWL6040_CORE is not set
# CONFIG_MFD_WL1273_CORE is not set
# CONFIG_MFD_LM3533 is not set
# CONFIG_MFD_TC3589X is not set
# CONFIG_MFD_TQMX86 is not set
# CONFIG_MFD_VX855 is not set
# CONFIG_MFD_LOCHNAGAR is not set
# CONFIG_MFD_ARIZONA_I2C is not set
# CONFIG_MFD_ARIZONA_SPI is not set
# CONFIG_MFD_WM8400 is not set
# CONFIG_MFD_WM831X_I2C is not set
# CONFIG_MFD_WM831X_SPI is not set
# CONFIG_MFD_WM8350_I2C is not set
# CONFIG_MFD_WM8994 is not set
# CONFIG_MFD_ROHM_BD718XX is not set
# CONFIG_MFD_ROHM_BD71828 is not set
# CONFIG_MFD_ROHM_BD957XMUF is not set
# CONFIG_MFD_STPMIC1 is not set
# CONFIG_MFD_STMFX is not set
# CONFIG_MFD_ATC260X_I2C is not set
# CONFIG_MFD_QCOM_PM8008 is not set
# CONFIG_MFD_INTEL_M10_BMC is not set
# CONFIG_MFD_RSMU_I2C is not set
# CONFIG_MFD_RSMU_SPI is not set
# end of Multifunction device drivers

# CONFIG_REGULATOR is not set
# CONFIG_RC_CORE is not set

#
# CEC support
#
# CONFIG_MEDIA_CEC_SUPPORT is not set
# end of CEC support

# CONFIG_MEDIA_SUPPORT is not set

#
# Graphics support
#
CONFIG_DRM=y
# CONFIG_DRM_DP_AUX_CHARDEV is not set
# CONFIG_DRM_DEBUG_MM is not set
# CONFIG_DRM_DEBUG_SELFTEST is not set
CONFIG_DRM_DP_HELPER=y
CONFIG_DRM_KMS_HELPER=y
# CONFIG_DRM_DEBUG_DP_MST_TOPOLOGY_REFS is not set
CONFIG_DRM_DEBUG_MODESET_LOCK=y
CONFIG_DRM_FBDEV_EMULATION=y
CONFIG_DRM_FBDEV_OVERALLOC=100
# CONFIG_DRM_FBDEV_LEAK_PHYS_SMEM is not set
# CONFIG_DRM_LOAD_EDID_FIRMWARE is not set
# CONFIG_DRM_DP_CEC is not set
CONFIG_DRM_TTM=y
CONFIG_DRM_TTM_HELPER=y
CONFIG_DRM_GEM_SHMEM_HELPER=y

#
# I2C encoder or helper chips
#
# CONFIG_DRM_I2C_CH7006 is not set
# CONFIG_DRM_I2C_SIL164 is not set
# CONFIG_DRM_I2C_NXP_TDA998X is not set
# CONFIG_DRM_I2C_NXP_TDA9950 is not set
# end of I2C encoder or helper chips

#
# ARM devices
#
# CONFIG_DRM_KOMEDA is not set
# end of ARM devices

CONFIG_DRM_RADEON=y
# CONFIG_DRM_RADEON_USERPTR is not set
# CONFIG_DRM_AMDGPU is not set
# CONFIG_DRM_NOUVEAU is not set
# CONFIG_DRM_VGEM is not set
# CONFIG_DRM_VKMS is not set
# CONFIG_DRM_UDL is not set
# CONFIG_DRM_AST is not set
# CONFIG_DRM_MGAG200 is not set
# CONFIG_DRM_RCAR_DW_HDMI is not set
# CONFIG_DRM_RCAR_USE_LVDS is not set
# CONFIG_DRM_RCAR_MIPI_DSI is not set
# CONFIG_DRM_QXL is not set
CONFIG_DRM_VIRTIO_GPU=y
CONFIG_DRM_PANEL=y

#
# Display Panels
#
# CONFIG_DRM_PANEL_ABT_Y030XX067A is not set
# CONFIG_DRM_PANEL_ARM_VERSATILE is not set
# CONFIG_DRM_PANEL_LVDS is not set
# CONFIG_DRM_PANEL_SIMPLE is not set
# CONFIG_DRM_PANEL_EDP is not set
# CONFIG_DRM_PANEL_ILITEK_IL9322 is not set
# CONFIG_DRM_PANEL_INNOLUX_EJ030NA is not set
# CONFIG_DRM_PANEL_SAMSUNG_LD9040 is not set
# CONFIG_DRM_PANEL_LG_LG4573 is not set
# CONFIG_DRM_PANEL_NOVATEK_NT39016 is not set
# CONFIG_DRM_PANEL_OLIMEX_LCD_OLINUXINO is not set
# CONFIG_DRM_PANEL_SAMSUNG_ATNA33XC20 is not set
# CONFIG_DRM_PANEL_SAMSUNG_S6E63M0 is not set
# CONFIG_DRM_PANEL_SAMSUNG_S6E88A0_AMS452EF01 is not set
# CONFIG_DRM_PANEL_SAMSUNG_S6E8AA0 is not set
# CONFIG_DRM_PANEL_SEIKO_43WVF1G is not set
# CONFIG_DRM_PANEL_SITRONIX_ST7789V is not set
# CONFIG_DRM_PANEL_TPO_TD028TTEC1 is not set
# end of Display Panels

CONFIG_DRM_BRIDGE=y
CONFIG_DRM_PANEL_BRIDGE=y

#
# Display Interface Bridges
#
# CONFIG_DRM_CDNS_DSI is not set
# CONFIG_DRM_CHIPONE_ICN6211 is not set
# CONFIG_DRM_CHRONTEL_CH7033 is not set
# CONFIG_DRM_DISPLAY_CONNECTOR is not set
# CONFIG_DRM_ITE_IT6505 is not set
# CONFIG_DRM_LONTIUM_LT8912B is not set
# CONFIG_DRM_LONTIUM_LT9611 is not set
# CONFIG_DRM_LONTIUM_LT9611UXC is not set
# CONFIG_DRM_ITE_IT66121 is not set
# CONFIG_DRM_LVDS_CODEC is not set
# CONFIG_DRM_MEGACHIPS_STDPXXXX_GE_B850V3_FW is not set
# CONFIG_DRM_NWL_MIPI_DSI is not set
# CONFIG_DRM_NXP_PTN3460 is not set
# CONFIG_DRM_PARADE_PS8622 is not set
# CONFIG_DRM_PARADE_PS8640 is not set
# CONFIG_DRM_SIL_SII8620 is not set
# CONFIG_DRM_SII902X is not set
# CONFIG_DRM_SII9234 is not set
# CONFIG_DRM_SIMPLE_BRIDGE is not set
# CONFIG_DRM_THINE_THC63LVD1024 is not set
# CONFIG_DRM_TOSHIBA_TC358762 is not set
# CONFIG_DRM_TOSHIBA_TC358764 is not set
# CONFIG_DRM_TOSHIBA_TC358767 is not set
# CONFIG_DRM_TOSHIBA_TC358768 is not set
# CONFIG_DRM_TOSHIBA_TC358775 is not set
# CONFIG_DRM_TI_TFP410 is not set
# CONFIG_DRM_TI_SN65DSI83 is not set
# CONFIG_DRM_TI_SN65DSI86 is not set
# CONFIG_DRM_TI_TPD12S015 is not set
# CONFIG_DRM_ANALOGIX_ANX6345 is not set
# CONFIG_DRM_ANALOGIX_ANX78XX is not set
# CONFIG_DRM_ANALOGIX_ANX7625 is not set
# CONFIG_DRM_I2C_ADV7511 is not set
# CONFIG_DRM_CDNS_MHDP8546 is not set
# end of Display Interface Bridges

# CONFIG_DRM_ETNAVIV is not set
# CONFIG_DRM_MXSFB is not set
# CONFIG_DRM_ARCPGU is not set
# CONFIG_DRM_BOCHS is not set
# CONFIG_DRM_CIRRUS_QEMU is not set
# CONFIG_DRM_GM12U320 is not set
# CONFIG_DRM_PANEL_MIPI_DBI is not set
# CONFIG_DRM_SIMPLEDRM is not set
# CONFIG_TINYDRM_HX8357D is not set
# CONFIG_TINYDRM_ILI9163 is not set
# CONFIG_TINYDRM_ILI9225 is not set
# CONFIG_TINYDRM_ILI9341 is not set
# CONFIG_TINYDRM_ILI9486 is not set
# CONFIG_TINYDRM_MI0283QT is not set
# CONFIG_TINYDRM_REPAPER is not set
# CONFIG_TINYDRM_ST7586 is not set
# CONFIG_TINYDRM_ST7735R is not set
# CONFIG_DRM_GUD is not set
# CONFIG_DRM_SSD130X is not set
# CONFIG_DRM_LEGACY is not set
CONFIG_DRM_PANEL_ORIENTATION_QUIRKS=y
CONFIG_DRM_NOMODESET=y

#
# Frame buffer Devices
#
CONFIG_FB_CMDLINE=y
CONFIG_FB_NOTIFY=y
CONFIG_FB=y
# CONFIG_FIRMWARE_EDID is not set
CONFIG_FB_CFB_FILLRECT=y
CONFIG_FB_CFB_COPYAREA=y
CONFIG_FB_CFB_IMAGEBLIT=y
CONFIG_FB_SYS_FILLRECT=y
CONFIG_FB_SYS_COPYAREA=y
CONFIG_FB_SYS_IMAGEBLIT=y
# CONFIG_FB_FOREIGN_ENDIAN is not set
CONFIG_FB_SYS_FOPS=y
CONFIG_FB_DEFERRED_IO=y
# CONFIG_FB_MODE_HELPERS is not set
# CONFIG_FB_TILEBLITTING is not set

#
# Frame buffer hardware drivers
#
# CONFIG_FB_CIRRUS is not set
# CONFIG_FB_PM2 is not set
# CONFIG_FB_CYBER2000 is not set
# CONFIG_FB_ASILIANT is not set
# CONFIG_FB_IMSTT is not set
# CONFIG_FB_EFI is not set
# CONFIG_FB_OPENCORES is not set
# CONFIG_FB_S1D13XXX is not set
# CONFIG_FB_NVIDIA is not set
# CONFIG_FB_RIVA is not set
# CONFIG_FB_I740 is not set
# CONFIG_FB_MATROX is not set
# CONFIG_FB_RADEON is not set
# CONFIG_FB_ATY128 is not set
# CONFIG_FB_ATY is not set
# CONFIG_FB_S3 is not set
# CONFIG_FB_SAVAGE is not set
# CONFIG_FB_SIS is not set
# CONFIG_FB_NEOMAGIC is not set
# CONFIG_FB_KYRO is not set
# CONFIG_FB_3DFX is not set
# CONFIG_FB_VOODOO1 is not set
# CONFIG_FB_VT8623 is not set
# CONFIG_FB_TRIDENT is not set
# CONFIG_FB_ARK is not set
# CONFIG_FB_PM3 is not set
# CONFIG_FB_CARMINE is not set
# CONFIG_FB_SMSCUFX is not set
# CONFIG_FB_UDL is not set
# CONFIG_FB_IBM_GXT4500 is not set
# CONFIG_FB_GOLDFISH is not set
# CONFIG_FB_VIRTUAL is not set
# CONFIG_FB_METRONOME is not set
# CONFIG_FB_MB862XX is not set
# CONFIG_FB_SIMPLE is not set
# CONFIG_FB_SM712 is not set
# end of Frame buffer Devices

#
# Backlight & LCD device support
#
# CONFIG_LCD_CLASS_DEVICE is not set
CONFIG_BACKLIGHT_CLASS_DEVICE=y
# CONFIG_BACKLIGHT_QCOM_WLED is not set
# CONFIG_BACKLIGHT_ADP8860 is not set
# CONFIG_BACKLIGHT_ADP8870 is not set
# CONFIG_BACKLIGHT_LM3639 is not set
# CONFIG_BACKLIGHT_LV5207LP is not set
# CONFIG_BACKLIGHT_BD6107 is not set
# CONFIG_BACKLIGHT_ARCXCNN is not set
# end of Backlight & LCD device support

CONFIG_HDMI=y

#
# Console display driver support
#
CONFIG_VGA_CONSOLE=y
CONFIG_DUMMY_CONSOLE=y
CONFIG_DUMMY_CONSOLE_COLUMNS=80
CONFIG_DUMMY_CONSOLE_ROWS=25
CONFIG_FRAMEBUFFER_CONSOLE=y
CONFIG_FRAMEBUFFER_CONSOLE_LEGACY_ACCELERATION=y
CONFIG_FRAMEBUFFER_CONSOLE_DETECT_PRIMARY=y
# CONFIG_FRAMEBUFFER_CONSOLE_ROTATION is not set
# CONFIG_FRAMEBUFFER_CONSOLE_DEFERRED_TAKEOVER is not set
# end of Console display driver support

# CONFIG_LOGO is not set
# end of Graphics support

# CONFIG_SOUND is not set

#
# HID support
#
CONFIG_HID=y
# CONFIG_HID_BATTERY_STRENGTH is not set
# CONFIG_HIDRAW is not set
# CONFIG_UHID is not set
CONFIG_HID_GENERIC=y

#
# Special HID drivers
#
# CONFIG_HID_A4TECH is not set
# CONFIG_HID_ACCUTOUCH is not set
# CONFIG_HID_ACRUX is not set
# CONFIG_HID_APPLEIR is not set
# CONFIG_HID_AUREAL is not set
# CONFIG_HID_BELKIN is not set
# CONFIG_HID_BETOP_FF is not set
# CONFIG_HID_CHERRY is not set
# CONFIG_HID_CHICONY is not set
# CONFIG_HID_COUGAR is not set
# CONFIG_HID_MACALLY is not set
# CONFIG_HID_CMEDIA is not set
# CONFIG_HID_CREATIVE_SB0540 is not set
# CONFIG_HID_CYPRESS is not set
# CONFIG_HID_DRAGONRISE is not set
# CONFIG_HID_EMS_FF is not set
# CONFIG_HID_ELECOM is not set
# CONFIG_HID_ELO is not set
# CONFIG_HID_EZKEY is not set
# CONFIG_HID_GEMBIRD is not set
# CONFIG_HID_GFRM is not set
# CONFIG_HID_GLORIOUS is not set
# CONFIG_HID_HOLTEK is not set
# CONFIG_HID_VIVALDI is not set
# CONFIG_HID_KEYTOUCH is not set
# CONFIG_HID_KYE is not set
# CONFIG_HID_UCLOGIC is not set
# CONFIG_HID_WALTOP is not set
# CONFIG_HID_VIEWSONIC is not set
# CONFIG_HID_XIAOMI is not set
# CONFIG_HID_GYRATION is not set
# CONFIG_HID_ICADE is not set
# CONFIG_HID_ITE is not set
# CONFIG_HID_JABRA is not set
# CONFIG_HID_TWINHAN is not set
# CONFIG_HID_KENSINGTON is not set
# CONFIG_HID_LCPOWER is not set
# CONFIG_HID_LENOVO is not set
# CONFIG_HID_LETSKETCH is not set
# CONFIG_HID_MAGICMOUSE is not set
# CONFIG_HID_MALTRON is not set
# CONFIG_HID_MAYFLASH is not set
# CONFIG_HID_REDRAGON is not set
# CONFIG_HID_MICROSOFT is not set
# CONFIG_HID_MONTEREY is not set
# CONFIG_HID_MULTITOUCH is not set
# CONFIG_HID_NTI is not set
# CONFIG_HID_NTRIG is not set
# CONFIG_HID_ORTEK is not set
# CONFIG_HID_PANTHERLORD is not set
# CONFIG_HID_PENMOUNT is not set
# CONFIG_HID_PETALYNX is not set
# CONFIG_HID_PICOLCD is not set
# CONFIG_HID_PLANTRONICS is not set
# CONFIG_HID_RAZER is not set
# CONFIG_HID_PRIMAX is not set
# CONFIG_HID_RETRODE is not set
# CONFIG_HID_ROCCAT is not set
# CONFIG_HID_SAITEK is not set
# CONFIG_HID_SAMSUNG is not set
# CONFIG_HID_SEMITEK is not set
# CONFIG_HID_SIGMAMICRO is not set
# CONFIG_HID_SPEEDLINK is not set
# CONFIG_HID_STEAM is not set
# CONFIG_HID_STEELSERIES is not set
# CONFIG_HID_SUNPLUS is not set
# CONFIG_HID_RMI is not set
# CONFIG_HID_GREENASIA is not set
# CONFIG_HID_SMARTJOYPLUS is not set
# CONFIG_HID_TIVO is not set
# CONFIG_HID_TOPSEED is not set
# CONFIG_HID_THRUSTMASTER is not set
# CONFIG_HID_UDRAW_PS3 is not set
# CONFIG_HID_WACOM is not set
# CONFIG_HID_XINMO is not set
# CONFIG_HID_ZEROPLUS is not set
# CONFIG_HID_ZYDACRON is not set
# CONFIG_HID_SENSOR_HUB is not set
# CONFIG_HID_ALPS is not set
# end of Special HID drivers

#
# USB HID support
#
CONFIG_USB_HID=y
# CONFIG_HID_PID is not set
# CONFIG_USB_HIDDEV is not set
# end of USB HID support

#
# I2C HID support
#
# CONFIG_I2C_HID_OF is not set
# CONFIG_I2C_HID_OF_GOODIX is not set
# end of I2C HID support
# end of HID support

CONFIG_USB_OHCI_LITTLE_ENDIAN=y
CONFIG_USB_SUPPORT=y
CONFIG_USB_COMMON=y
# CONFIG_USB_ULPI_BUS is not set
CONFIG_USB_ARCH_HAS_HCD=y
CONFIG_USB=y
CONFIG_USB_PCI=y
# CONFIG_USB_ANNOUNCE_NEW_DEVICES is not set

#
# Miscellaneous USB options
#
CONFIG_USB_DEFAULT_PERSIST=y
# CONFIG_USB_FEW_INIT_RETRIES is not set
# CONFIG_USB_DYNAMIC_MINORS is not set
# CONFIG_USB_OTG is not set
# CONFIG_USB_OTG_PRODUCTLIST is not set
# CONFIG_USB_OTG_DISABLE_EXTERNAL_HUB is not set
CONFIG_USB_AUTOSUSPEND_DELAY=2
# CONFIG_USB_MON is not set

#
# USB Host Controller Drivers
#
# CONFIG_USB_C67X00_HCD is not set
CONFIG_USB_XHCI_HCD=y
# CONFIG_USB_XHCI_DBGCAP is not set
CONFIG_USB_XHCI_PCI=y
# CONFIG_USB_XHCI_PCI_RENESAS is not set
CONFIG_USB_XHCI_PLATFORM=y
CONFIG_USB_EHCI_HCD=y
# CONFIG_USB_EHCI_ROOT_HUB_TT is not set
CONFIG_USB_EHCI_TT_NEWSCHED=y
CONFIG_USB_EHCI_PCI=y
# CONFIG_USB_EHCI_FSL is not set
CONFIG_USB_EHCI_HCD_PLATFORM=y
# CONFIG_USB_OXU210HP_HCD is not set
# CONFIG_USB_ISP116X_HCD is not set
# CONFIG_USB_FOTG210_HCD is not set
# CONFIG_USB_MAX3421_HCD is not set
CONFIG_USB_OHCI_HCD=y
CONFIG_USB_OHCI_HCD_PCI=y
CONFIG_USB_OHCI_HCD_PLATFORM=y
# CONFIG_USB_UHCI_HCD is not set
# CONFIG_USB_SL811_HCD is not set
# CONFIG_USB_R8A66597_HCD is not set
# CONFIG_USB_HCD_TEST_MODE is not set

#
# USB Device Class drivers
#
# CONFIG_USB_ACM is not set
# CONFIG_USB_PRINTER is not set
# CONFIG_USB_WDM is not set
# CONFIG_USB_TMC is not set

#
# NOTE: USB_STORAGE depends on SCSI but BLK_DEV_SD may
#

#
# also be needed; see USB_STORAGE Help for more info
#
CONFIG_USB_STORAGE=y
# CONFIG_USB_STORAGE_DEBUG is not set
# CONFIG_USB_STORAGE_REALTEK is not set
# CONFIG_USB_STORAGE_DATAFAB is not set
# CONFIG_USB_STORAGE_FREECOM is not set
# CONFIG_USB_STORAGE_ISD200 is not set
# CONFIG_USB_STORAGE_USBAT is not set
# CONFIG_USB_STORAGE_SDDR09 is not set
# CONFIG_USB_STORAGE_SDDR55 is not set
# CONFIG_USB_STORAGE_JUMPSHOT is not set
# CONFIG_USB_STORAGE_ALAUDA is not set
# CONFIG_USB_STORAGE_ONETOUCH is not set
# CONFIG_USB_STORAGE_KARMA is not set
# CONFIG_USB_STORAGE_CYPRESS_ATACB is not set
# CONFIG_USB_STORAGE_ENE_UB6250 is not set
CONFIG_USB_UAS=y

#
# USB Imaging devices
#
# CONFIG_USB_MDC800 is not set
# CONFIG_USB_MICROTEK is not set
# CONFIG_USBIP_CORE is not set
# CONFIG_USB_CDNS_SUPPORT is not set
# CONFIG_USB_MUSB_HDRC is not set
# CONFIG_USB_DWC3 is not set
# CONFIG_USB_DWC2 is not set
# CONFIG_USB_CHIPIDEA is not set
# CONFIG_USB_ISP1760 is not set

#
# USB port drivers
#
# CONFIG_USB_SERIAL is not set

#
# USB Miscellaneous drivers
#
# CONFIG_USB_EMI62 is not set
# CONFIG_USB_EMI26 is not set
# CONFIG_USB_ADUTUX is not set
# CONFIG_USB_SEVSEG is not set
# CONFIG_USB_LEGOTOWER is not set
# CONFIG_USB_LCD is not set
# CONFIG_USB_CYPRESS_CY7C63 is not set
# CONFIG_USB_CYTHERM is not set
# CONFIG_USB_IDMOUSE is not set
# CONFIG_USB_FTDI_ELAN is not set
# CONFIG_USB_APPLEDISPLAY is not set
# CONFIG_APPLE_MFI_FASTCHARGE is not set
# CONFIG_USB_SISUSBVGA is not set
# CONFIG_USB_LD is not set
# CONFIG_USB_TRANCEVIBRATOR is not set
# CONFIG_USB_IOWARRIOR is not set
# CONFIG_USB_TEST is not set
# CONFIG_USB_EHSET_TEST_FIXTURE is not set
# CONFIG_USB_ISIGHTFW is not set
# CONFIG_USB_YUREX is not set
# CONFIG_USB_EZUSB_FX2 is not set
# CONFIG_USB_HUB_USB251XB is not set
# CONFIG_USB_HSIC_USB3503 is not set
# CONFIG_USB_HSIC_USB4604 is not set
# CONFIG_USB_LINK_LAYER_TEST is not set
# CONFIG_USB_CHAOSKEY is not set

#
# USB Physical Layer drivers
#
# CONFIG_NOP_USB_XCEIV is not set
# CONFIG_USB_ISP1301 is not set
# end of USB Physical Layer drivers

# CONFIG_USB_GADGET is not set
# CONFIG_TYPEC is not set
# CONFIG_USB_ROLE_SWITCH is not set
# CONFIG_MMC is not set
# CONFIG_MEMSTICK is not set
# CONFIG_NEW_LEDS is not set
# CONFIG_ACCESSIBILITY is not set
# CONFIG_INFINIBAND is not set
CONFIG_EDAC_SUPPORT=y
# CONFIG_EDAC is not set
CONFIG_RTC_LIB=y
CONFIG_RTC_CLASS=y
CONFIG_RTC_HCTOSYS=y
CONFIG_RTC_HCTOSYS_DEVICE="rtc0"
CONFIG_RTC_SYSTOHC=y
CONFIG_RTC_SYSTOHC_DEVICE="rtc0"
# CONFIG_RTC_DEBUG is not set
CONFIG_RTC_NVMEM=y

#
# RTC interfaces
#
CONFIG_RTC_INTF_SYSFS=y
CONFIG_RTC_INTF_PROC=y
CONFIG_RTC_INTF_DEV=y
# CONFIG_RTC_INTF_DEV_UIE_EMUL is not set
# CONFIG_RTC_DRV_TEST is not set

#
# I2C RTC drivers
#
# CONFIG_RTC_DRV_ABB5ZES3 is not set
# CONFIG_RTC_DRV_ABEOZ9 is not set
# CONFIG_RTC_DRV_ABX80X is not set
# CONFIG_RTC_DRV_DS1307 is not set
# CONFIG_RTC_DRV_DS1374 is not set
# CONFIG_RTC_DRV_DS1672 is not set
# CONFIG_RTC_DRV_HYM8563 is not set
# CONFIG_RTC_DRV_MAX6900 is not set
# CONFIG_RTC_DRV_RS5C372 is not set
# CONFIG_RTC_DRV_ISL1208 is not set
# CONFIG_RTC_DRV_ISL12022 is not set
# CONFIG_RTC_DRV_ISL12026 is not set
# CONFIG_RTC_DRV_X1205 is not set
# CONFIG_RTC_DRV_PCF8523 is not set
# CONFIG_RTC_DRV_PCF85063 is not set
# CONFIG_RTC_DRV_PCF85363 is not set
# CONFIG_RTC_DRV_PCF8563 is not set
# CONFIG_RTC_DRV_PCF8583 is not set
# CONFIG_RTC_DRV_M41T80 is not set
# CONFIG_RTC_DRV_BQ32K is not set
# CONFIG_RTC_DRV_S35390A is not set
# CONFIG_RTC_DRV_FM3130 is not set
# CONFIG_RTC_DRV_RX8010 is not set
# CONFIG_RTC_DRV_RX8581 is not set
# CONFIG_RTC_DRV_RX8025 is not set
# CONFIG_RTC_DRV_EM3027 is not set
# CONFIG_RTC_DRV_RV3028 is not set
# CONFIG_RTC_DRV_RV3032 is not set
# CONFIG_RTC_DRV_RV8803 is not set
# CONFIG_RTC_DRV_SD3078 is not set

#
# SPI RTC drivers
#
# CONFIG_RTC_DRV_M41T93 is not set
# CONFIG_RTC_DRV_M41T94 is not set
# CONFIG_RTC_DRV_DS1302 is not set
# CONFIG_RTC_DRV_DS1305 is not set
# CONFIG_RTC_DRV_DS1343 is not set
# CONFIG_RTC_DRV_DS1347 is not set
# CONFIG_RTC_DRV_DS1390 is not set
# CONFIG_RTC_DRV_MAX6916 is not set
# CONFIG_RTC_DRV_R9701 is not set
# CONFIG_RTC_DRV_RX4581 is not set
# CONFIG_RTC_DRV_RS5C348 is not set
# CONFIG_RTC_DRV_MAX6902 is not set
# CONFIG_RTC_DRV_PCF2123 is not set
# CONFIG_RTC_DRV_MCP795 is not set
CONFIG_RTC_I2C_AND_SPI=y

#
# SPI and I2C RTC drivers
#
# CONFIG_RTC_DRV_DS3232 is not set
# CONFIG_RTC_DRV_PCF2127 is not set
# CONFIG_RTC_DRV_RV3029C2 is not set
# CONFIG_RTC_DRV_RX6110 is not set

#
# Platform RTC drivers
#
# CONFIG_RTC_DRV_DS1286 is not set
# CONFIG_RTC_DRV_DS1511 is not set
# CONFIG_RTC_DRV_DS1553 is not set
# CONFIG_RTC_DRV_DS1685_FAMILY is not set
# CONFIG_RTC_DRV_DS1742 is not set
# CONFIG_RTC_DRV_DS2404 is not set
# CONFIG_RTC_DRV_EFI is not set
# CONFIG_RTC_DRV_STK17TA8 is not set
# CONFIG_RTC_DRV_M48T86 is not set
# CONFIG_RTC_DRV_M48T35 is not set
# CONFIG_RTC_DRV_M48T59 is not set
# CONFIG_RTC_DRV_MSM6242 is not set
# CONFIG_RTC_DRV_BQ4802 is not set
# CONFIG_RTC_DRV_RP5C01 is not set
# CONFIG_RTC_DRV_V3020 is not set
# CONFIG_RTC_DRV_ZYNQMP is not set

#
# on-CPU RTC drivers
#
# CONFIG_RTC_DRV_CADENCE is not set
# CONFIG_RTC_DRV_FTRTC010 is not set
# CONFIG_RTC_DRV_R7301 is not set

#
# HID Sensor RTC drivers
#
CONFIG_RTC_DRV_GOLDFISH=y
# CONFIG_DMADEVICES is not set

#
# DMABUF options
#
CONFIG_SYNC_FILE=y
# CONFIG_SW_SYNC is not set
# CONFIG_UDMABUF is not set
# CONFIG_DMABUF_MOVE_NOTIFY is not set
# CONFIG_DMABUF_DEBUG is not set
# CONFIG_DMABUF_SELFTESTS is not set
# CONFIG_DMABUF_HEAPS is not set
# CONFIG_DMABUF_SYSFS_STATS is not set
# end of DMABUF options

# CONFIG_AUXDISPLAY is not set
# CONFIG_UIO is not set
# CONFIG_VFIO is not set
# CONFIG_VIRT_DRIVERS is not set
CONFIG_VIRTIO=y
CONFIG_VIRTIO_PCI_LIB=y
CONFIG_VIRTIO_PCI_LIB_LEGACY=y
CONFIG_VIRTIO_MENU=y
CONFIG_VIRTIO_PCI=y
CONFIG_VIRTIO_PCI_LEGACY=y
CONFIG_VIRTIO_BALLOON=y
CONFIG_VIRTIO_INPUT=y
CONFIG_VIRTIO_MMIO=y
CONFIG_VIRTIO_MMIO_CMDLINE_DEVICES=y
CONFIG_VIRTIO_DMA_SHARED_BUFFER=y
# CONFIG_VDPA is not set
CONFIG_VHOST_MENU=y
# CONFIG_VHOST_NET is not set
# CONFIG_VHOST_CROSS_ENDIAN_LEGACY is not set

#
# Microsoft Hyper-V guest support
#
# end of Microsoft Hyper-V guest support

# CONFIG_GREYBUS is not set
# CONFIG_COMEDI is not set
# CONFIG_STAGING is not set
CONFIG_GOLDFISH=y
# CONFIG_GOLDFISH_PIPE is not set
CONFIG_HAVE_CLK=y
CONFIG_HAVE_CLK_PREPARE=y
CONFIG_COMMON_CLK=y
# CONFIG_LMK04832 is not set
# CONFIG_COMMON_CLK_MAX9485 is not set
# CONFIG_COMMON_CLK_SI5341 is not set
# CONFIG_COMMON_CLK_SI5351 is not set
# CONFIG_COMMON_CLK_SI514 is not set
# CONFIG_COMMON_CLK_SI544 is not set
# CONFIG_COMMON_CLK_SI570 is not set
# CONFIG_COMMON_CLK_CDCE706 is not set
# CONFIG_COMMON_CLK_CDCE925 is not set
# CONFIG_COMMON_CLK_CS2000_CP is not set
# CONFIG_COMMON_CLK_AXI_CLKGEN is not set
# CONFIG_COMMON_CLK_RS9_PCIE is not set
# CONFIG_COMMON_CLK_VC5 is not set
# CONFIG_COMMON_CLK_FIXED_MMIO is not set
CONFIG_CLK_ANALOGBITS_WRPLL_CLN28HPC=y
CONFIG_CLK_SIFIVE=y
CONFIG_CLK_SIFIVE_PRCI=y
# CONFIG_XILINX_VCU is not set
# CONFIG_HWSPINLOCK is not set

#
# Clock Source drivers
#
CONFIG_TIMER_OF=y
CONFIG_TIMER_PROBE=y
CONFIG_RISCV_TIMER=y
# CONFIG_MICROCHIP_PIT64B is not set
# end of Clock Source drivers

# CONFIG_MAILBOX is not set
# CONFIG_IOMMU_SUPPORT is not set

#
# Remoteproc drivers
#
# CONFIG_REMOTEPROC is not set
# end of Remoteproc drivers

#
# Rpmsg drivers
#
CONFIG_RPMSG=y
CONFIG_RPMSG_CHAR=y
# CONFIG_RPMSG_CTRL is not set
CONFIG_RPMSG_NS=y
CONFIG_RPMSG_VIRTIO=y
# end of Rpmsg drivers

# CONFIG_SOUNDWIRE is not set

#
# SOC (System On Chip) specific Drivers
#

#
# Amlogic SoC drivers
#
# end of Amlogic SoC drivers

#
# Broadcom SoC drivers
#
# end of Broadcom SoC drivers

#
# NXP/Freescale QorIQ SoC drivers
#
# end of NXP/Freescale QorIQ SoC drivers

#
# i.MX SoC drivers
#
# end of i.MX SoC drivers

#
# Enable LiteX SoC Builder specific drivers
#
# CONFIG_LITEX_SOC_CONTROLLER is not set
# end of Enable LiteX SoC Builder specific drivers

#
# Qualcomm SoC drivers
#
# end of Qualcomm SoC drivers

# CONFIG_SIFIVE_L2 is not set
# CONFIG_SOC_TI is not set

#
# Xilinx SoC drivers
#
# end of Xilinx SoC drivers
# end of SOC (System On Chip) specific Drivers

# CONFIG_PM_DEVFREQ is not set
# CONFIG_EXTCON is not set
# CONFIG_MEMORY is not set
# CONFIG_IIO is not set
# CONFIG_NTB is not set
# CONFIG_VME_BUS is not set
# CONFIG_PWM is not set

#
# IRQ chip support
#
CONFIG_IRQCHIP=y
# CONFIG_AL_FIC is not set
CONFIG_RISCV_INTC=y
CONFIG_SIFIVE_PLIC=y
# end of IRQ chip support

# CONFIG_IPACK_BUS is not set
CONFIG_RESET_CONTROLLER=y
CONFIG_RESET_SIMPLE=y
# CONFIG_RESET_TI_SYSCON is not set

#
# PHY Subsystem
#
# CONFIG_GENERIC_PHY is not set
# CONFIG_PHY_CAN_TRANSCEIVER is not set

#
# PHY drivers for Broadcom platforms
#
# CONFIG_BCM_KONA_USB2_PHY is not set
# end of PHY drivers for Broadcom platforms

# CONFIG_PHY_CADENCE_TORRENT is not set
# CONFIG_PHY_CADENCE_DPHY is not set
# CONFIG_PHY_CADENCE_DPHY_RX is not set
# CONFIG_PHY_CADENCE_SIERRA is not set
# CONFIG_PHY_CADENCE_SALVO is not set
# CONFIG_PHY_PXA_28NM_HSIC is not set
# CONFIG_PHY_PXA_28NM_USB2 is not set
# CONFIG_PHY_LAN966X_SERDES is not set
# CONFIG_PHY_OCELOT_SERDES is not set
# end of PHY Subsystem

# CONFIG_POWERCAP is not set
# CONFIG_MCB is not set

#
# Performance monitor support
#
CONFIG_RISCV_PMU=y
CONFIG_RISCV_PMU_LEGACY=y
CONFIG_RISCV_PMU_SBI=y
# end of Performance monitor support

CONFIG_RAS=y
# CONFIG_USB4 is not set

#
# Android
#
# CONFIG_ANDROID is not set
# end of Android

# CONFIG_LIBNVDIMM is not set
CONFIG_DAX=y
# CONFIG_DEV_DAX is not set
CONFIG_NVMEM=y
CONFIG_NVMEM_SYSFS=y
# CONFIG_NVMEM_RMEM is not set

#
# HW tracing support
#
# CONFIG_STM is not set
# CONFIG_INTEL_TH is not set
# end of HW tracing support

# CONFIG_FPGA is not set
# CONFIG_FSI is not set
# CONFIG_SIOX is not set
# CONFIG_SLIMBUS is not set
# CONFIG_INTERCONNECT is not set
# CONFIG_COUNTER is not set
# CONFIG_PECI is not set
# end of Device Drivers

#
# File systems
#
# CONFIG_VALIDATE_FS_PARSER is not set
CONFIG_FS_IOMAP=y
# CONFIG_EXT2_FS is not set
# CONFIG_EXT3_FS is not set
CONFIG_EXT4_FS=y
CONFIG_EXT4_USE_FOR_EXT2=y
CONFIG_EXT4_FS_POSIX_ACL=y
CONFIG_EXT4_FS_SECURITY=y
CONFIG_EXT4_DEBUG=y
CONFIG_JBD2=y
# CONFIG_JBD2_DEBUG is not set
CONFIG_FS_MBCACHE=y
# CONFIG_REISERFS_FS is not set
# CONFIG_JFS_FS is not set
# CONFIG_XFS_FS is not set
# CONFIG_GFS2_FS is not set
# CONFIG_BTRFS_FS is not set
# CONFIG_NILFS2_FS is not set
# CONFIG_F2FS_FS is not set
CONFIG_FS_POSIX_ACL=y
CONFIG_EXPORTFS=y
CONFIG_EXPORTFS_BLOCK_OPS=y
CONFIG_FILE_LOCKING=y
# CONFIG_FS_ENCRYPTION is not set
# CONFIG_FS_VERITY is not set
CONFIG_FSNOTIFY=y
CONFIG_DNOTIFY=y
CONFIG_INOTIFY_USER=y
# CONFIG_FANOTIFY is not set
# CONFIG_QUOTA is not set
# CONFIG_AUTOFS4_FS is not set
CONFIG_AUTOFS_FS=y
CONFIG_FUSE_FS=y
CONFIG_CUSE=y
# CONFIG_VIRTIO_FS is not set
CONFIG_OVERLAY_FS=y
# CONFIG_OVERLAY_FS_REDIRECT_DIR is not set
CONFIG_OVERLAY_FS_REDIRECT_ALWAYS_FOLLOW=y
# CONFIG_OVERLAY_FS_INDEX is not set
# CONFIG_OVERLAY_FS_XINO_AUTO is not set
# CONFIG_OVERLAY_FS_METACOPY is not set

#
# Caches
#
CONFIG_NETFS_SUPPORT=y
# CONFIG_NETFS_STATS is not set
# CONFIG_FSCACHE is not set
# end of Caches

#
# CD-ROM/DVD Filesystems
#
CONFIG_ISO9660_FS=y
# CONFIG_JOLIET is not set
# CONFIG_ZISOFS is not set
CONFIG_UDF_FS=y
# end of CD-ROM/DVD Filesystems

#
# DOS/FAT/EXFAT/NT Filesystems
#
CONFIG_FAT_FS=y
CONFIG_MSDOS_FS=y
CONFIG_VFAT_FS=y
CONFIG_FAT_DEFAULT_CODEPAGE=437
CONFIG_FAT_DEFAULT_IOCHARSET="iso8859-1"
# CONFIG_FAT_DEFAULT_UTF8 is not set
CONFIG_EXFAT_FS=y
CONFIG_EXFAT_DEFAULT_IOCHARSET="utf8"
CONFIG_NTFS_FS=y
# CONFIG_NTFS_DEBUG is not set
CONFIG_NTFS_RW=y
# CONFIG_NTFS3_FS is not set
# end of DOS/FAT/EXFAT/NT Filesystems

#
# Pseudo filesystems
#
CONFIG_PROC_FS=y
CONFIG_PROC_KCORE=y
CONFIG_PROC_SYSCTL=y
CONFIG_PROC_PAGE_MONITOR=y
CONFIG_PROC_CHILDREN=y
CONFIG_KERNFS=y
CONFIG_SYSFS=y
CONFIG_TMPFS=y
CONFIG_TMPFS_POSIX_ACL=y
CONFIG_TMPFS_XATTR=y
# CONFIG_TMPFS_INODE64 is not set
CONFIG_ARCH_SUPPORTS_HUGETLBFS=y
# CONFIG_HUGETLBFS is not set
CONFIG_MEMFD_CREATE=y
CONFIG_ARCH_HAS_GIGANTIC_PAGE=y
# CONFIG_CONFIGFS_FS is not set
CONFIG_EFIVAR_FS=m
# end of Pseudo filesystems

CONFIG_MISC_FILESYSTEMS=y
# CONFIG_ORANGEFS_FS is not set
# CONFIG_ADFS_FS is not set
# CONFIG_AFFS_FS is not set
# CONFIG_ECRYPT_FS is not set
# CONFIG_HFS_FS is not set
# CONFIG_HFSPLUS_FS is not set
# CONFIG_BEFS_FS is not set
# CONFIG_BFS_FS is not set
# CONFIG_EFS_FS is not set
# CONFIG_CRAMFS is not set
CONFIG_SQUASHFS=y
CONFIG_SQUASHFS_FILE_CACHE=y
# CONFIG_SQUASHFS_FILE_DIRECT is not set
CONFIG_SQUASHFS_DECOMP_SINGLE=y
# CONFIG_SQUASHFS_DECOMP_MULTI is not set
# CONFIG_SQUASHFS_DECOMP_MULTI_PERCPU is not set
CONFIG_SQUASHFS_XATTR=y
CONFIG_SQUASHFS_ZLIB=y
CONFIG_SQUASHFS_LZ4=y
CONFIG_SQUASHFS_LZO=y
CONFIG_SQUASHFS_XZ=y
CONFIG_SQUASHFS_ZSTD=y
# CONFIG_SQUASHFS_4K_DEVBLK_SIZE is not set
# CONFIG_SQUASHFS_EMBEDDED is not set
CONFIG_SQUASHFS_FRAGMENT_CACHE_SIZE=3
# CONFIG_VXFS_FS is not set
# CONFIG_MINIX_FS is not set
# CONFIG_OMFS_FS is not set
# CONFIG_HPFS_FS is not set
# CONFIG_QNX4FS_FS is not set
# CONFIG_QNX6FS_FS is not set
# CONFIG_ROMFS_FS is not set
# CONFIG_PSTORE is not set
# CONFIG_SYSV_FS is not set
# CONFIG_UFS_FS is not set
# CONFIG_EROFS_FS is not set
CONFIG_NETWORK_FILESYSTEMS=y
CONFIG_NFS_FS=y
CONFIG_NFS_V2=y
CONFIG_NFS_V3=y
# CONFIG_NFS_V3_ACL is not set
CONFIG_NFS_V4=y
# CONFIG_NFS_SWAP is not set
CONFIG_NFS_V4_1=y
CONFIG_NFS_V4_2=y
CONFIG_PNFS_FILE_LAYOUT=y
CONFIG_PNFS_FLEXFILE_LAYOUT=y
CONFIG_NFS_V4_1_IMPLEMENTATION_ID_DOMAIN="kernel.org"
# CONFIG_NFS_V4_1_MIGRATION is not set
CONFIG_ROOT_NFS=y
# CONFIG_NFS_USE_LEGACY_DNS is not set
CONFIG_NFS_USE_KERNEL_DNS=y
CONFIG_NFS_DISABLE_UDP_SUPPORT=y
# CONFIG_NFS_V4_2_READ_PLUS is not set
# CONFIG_NFSD is not set
CONFIG_GRACE_PERIOD=y
CONFIG_LOCKD=y
CONFIG_LOCKD_V4=y
CONFIG_NFS_COMMON=y
CONFIG_NFS_V4_2_SSC_HELPER=y
CONFIG_SUNRPC=y
CONFIG_SUNRPC_GSS=y
CONFIG_SUNRPC_BACKCHANNEL=y
# CONFIG_SUNRPC_DEBUG is not set
# CONFIG_CEPH_FS is not set
# CONFIG_CIFS is not set
# CONFIG_SMB_SERVER is not set
# CONFIG_CODA_FS is not set
# CONFIG_AFS_FS is not set
CONFIG_9P_FS=y
CONFIG_9P_FS_POSIX_ACL=y
CONFIG_9P_FS_SECURITY=y
CONFIG_NLS=y
CONFIG_NLS_DEFAULT="iso8859-1"
CONFIG_NLS_CODEPAGE_437=y
# CONFIG_NLS_CODEPAGE_737 is not set
# CONFIG_NLS_CODEPAGE_775 is not set
CONFIG_NLS_CODEPAGE_850=y
# CONFIG_NLS_CODEPAGE_852 is not set
# CONFIG_NLS_CODEPAGE_855 is not set
# CONFIG_NLS_CODEPAGE_857 is not set
# CONFIG_NLS_CODEPAGE_860 is not set
# CONFIG_NLS_CODEPAGE_861 is not set
# CONFIG_NLS_CODEPAGE_862 is not set
# CONFIG_NLS_CODEPAGE_863 is not set
# CONFIG_NLS_CODEPAGE_864 is not set
# CONFIG_NLS_CODEPAGE_865 is not set
# CONFIG_NLS_CODEPAGE_866 is not set
# CONFIG_NLS_CODEPAGE_869 is not set
CONFIG_NLS_CODEPAGE_936=y
CONFIG_NLS_CODEPAGE_950=y
# CONFIG_NLS_CODEPAGE_932 is not set
# CONFIG_NLS_CODEPAGE_949 is not set
# CONFIG_NLS_CODEPAGE_874 is not set
# CONFIG_NLS_ISO8859_8 is not set
# CONFIG_NLS_CODEPAGE_1250 is not set
# CONFIG_NLS_CODEPAGE_1251 is not set
CONFIG_NLS_ASCII=y
CONFIG_NLS_ISO8859_1=y
# CONFIG_NLS_ISO8859_2 is not set
# CONFIG_NLS_ISO8859_3 is not set
# CONFIG_NLS_ISO8859_4 is not set
# CONFIG_NLS_ISO8859_5 is not set
# CONFIG_NLS_ISO8859_6 is not set
# CONFIG_NLS_ISO8859_7 is not set
# CONFIG_NLS_ISO8859_9 is not set
# CONFIG_NLS_ISO8859_13 is not set
# CONFIG_NLS_ISO8859_14 is not set
# CONFIG_NLS_ISO8859_15 is not set
# CONFIG_NLS_KOI8_R is not set
# CONFIG_NLS_KOI8_U is not set
# CONFIG_NLS_MAC_ROMAN is not set
# CONFIG_NLS_MAC_CELTIC is not set
# CONFIG_NLS_MAC_CENTEURO is not set
# CONFIG_NLS_MAC_CROATIAN is not set
# CONFIG_NLS_MAC_CYRILLIC is not set
# CONFIG_NLS_MAC_GAELIC is not set
# CONFIG_NLS_MAC_GREEK is not set
# CONFIG_NLS_MAC_ICELAND is not set
# CONFIG_NLS_MAC_INUIT is not set
# CONFIG_NLS_MAC_ROMANIAN is not set
# CONFIG_NLS_MAC_TURKISH is not set
CONFIG_NLS_UTF8=y
# CONFIG_UNICODE is not set
CONFIG_IO_WQ=y
# end of File systems

#
# Security options
#
CONFIG_KEYS=y
# CONFIG_KEYS_REQUEST_CACHE is not set
# CONFIG_PERSISTENT_KEYRINGS is not set
# CONFIG_ENCRYPTED_KEYS is not set
# CONFIG_KEY_DH_OPERATIONS is not set
# CONFIG_SECURITY_DMESG_RESTRICT is not set
# CONFIG_SECURITY is not set
# CONFIG_SECURITYFS is not set
CONFIG_HAVE_HARDENED_USERCOPY_ALLOCATOR=y
# CONFIG_HARDENED_USERCOPY is not set
# CONFIG_FORTIFY_SOURCE is not set
# CONFIG_STATIC_USERMODEHELPER is not set
CONFIG_DEFAULT_SECURITY_DAC=y
CONFIG_LSM="lockdown,yama,loadpin,safesetid,integrity,bpf"

#
# Kernel hardening options
#

#
# Memory initialization
#
CONFIG_CC_HAS_AUTO_VAR_INIT_PATTERN=y
CONFIG_CC_HAS_AUTO_VAR_INIT_ZERO=y
CONFIG_INIT_STACK_NONE=y
# CONFIG_INIT_STACK_ALL_PATTERN is not set
# CONFIG_INIT_STACK_ALL_ZERO is not set
# CONFIG_INIT_ON_ALLOC_DEFAULT_ON is not set
# CONFIG_INIT_ON_FREE_DEFAULT_ON is not set
# end of Memory initialization
# end of Kernel hardening options
# end of Security options

CONFIG_CRYPTO=y

#
# Crypto core or helper
#
CONFIG_CRYPTO_ALGAPI=y
CONFIG_CRYPTO_ALGAPI2=y
CONFIG_CRYPTO_AEAD=y
CONFIG_CRYPTO_AEAD2=y
CONFIG_CRYPTO_SKCIPHER=y
CONFIG_CRYPTO_SKCIPHER2=y
CONFIG_CRYPTO_HASH=y
CONFIG_CRYPTO_HASH2=y
CONFIG_CRYPTO_RNG2=y
CONFIG_CRYPTO_AKCIPHER2=y
CONFIG_CRYPTO_AKCIPHER=y
CONFIG_CRYPTO_KPP2=y
CONFIG_CRYPTO_ACOMP2=y
CONFIG_CRYPTO_MANAGER=y
CONFIG_CRYPTO_MANAGER2=y
# CONFIG_CRYPTO_USER is not set
CONFIG_CRYPTO_MANAGER_DISABLE_TESTS=y
# CONFIG_CRYPTO_NULL is not set
CONFIG_CRYPTO_NULL2=y
# CONFIG_CRYPTO_PCRYPT is not set
# CONFIG_CRYPTO_CRYPTD is not set
# CONFIG_CRYPTO_AUTHENC is not set
# CONFIG_CRYPTO_TEST is not set
CONFIG_CRYPTO_ENGINE=y

#
# Public-key cryptography
#
CONFIG_CRYPTO_RSA=y
# CONFIG_CRYPTO_DH is not set
# CONFIG_CRYPTO_ECDH is not set
# CONFIG_CRYPTO_ECDSA is not set
# CONFIG_CRYPTO_ECRDSA is not set
# CONFIG_CRYPTO_SM2 is not set
# CONFIG_CRYPTO_CURVE25519 is not set

#
# Authenticated Encryption with Associated Data
#
# CONFIG_CRYPTO_CCM is not set
# CONFIG_CRYPTO_GCM is not set
# CONFIG_CRYPTO_CHACHA20POLY1305 is not set
# CONFIG_CRYPTO_AEGIS128 is not set
# CONFIG_CRYPTO_SEQIV is not set
# CONFIG_CRYPTO_ECHAINIV is not set

#
# Block modes
#
# CONFIG_CRYPTO_CBC is not set
# CONFIG_CRYPTO_CFB is not set
# CONFIG_CRYPTO_CTR is not set
# CONFIG_CRYPTO_CTS is not set
CONFIG_CRYPTO_ECB=y
# CONFIG_CRYPTO_LRW is not set
# CONFIG_CRYPTO_OFB is not set
# CONFIG_CRYPTO_PCBC is not set
# CONFIG_CRYPTO_XTS is not set
# CONFIG_CRYPTO_KEYWRAP is not set
# CONFIG_CRYPTO_ADIANTUM is not set
# CONFIG_CRYPTO_ESSIV is not set

#
# Hash modes
#
# CONFIG_CRYPTO_CMAC is not set
# CONFIG_CRYPTO_HMAC is not set
# CONFIG_CRYPTO_XCBC is not set
# CONFIG_CRYPTO_VMAC is not set

#
# Digest
#
CONFIG_CRYPTO_CRC32C=y
CONFIG_CRYPTO_CRC32=y
CONFIG_CRYPTO_XXHASH=y
CONFIG_CRYPTO_BLAKE2B=y
# CONFIG_CRYPTO_BLAKE2S is not set
# CONFIG_CRYPTO_CRCT10DIF is not set
# CONFIG_CRYPTO_GHASH is not set
# CONFIG_CRYPTO_POLY1305 is not set
# CONFIG_CRYPTO_MD4 is not set
# CONFIG_CRYPTO_MD5 is not set
# CONFIG_CRYPTO_MICHAEL_MIC is not set
# CONFIG_CRYPTO_RMD160 is not set
# CONFIG_CRYPTO_SHA1 is not set
CONFIG_CRYPTO_SHA256=y
# CONFIG_CRYPTO_SHA512 is not set
# CONFIG_CRYPTO_SHA3 is not set
# CONFIG_CRYPTO_SM3 is not set
# CONFIG_CRYPTO_STREEBOG is not set
# CONFIG_CRYPTO_WP512 is not set

#
# Ciphers
#
CONFIG_CRYPTO_AES=y
# CONFIG_CRYPTO_AES_TI is not set
# CONFIG_CRYPTO_ANUBIS is not set
# CONFIG_CRYPTO_ARC4 is not set
# CONFIG_CRYPTO_BLOWFISH is not set
# CONFIG_CRYPTO_CAMELLIA is not set
# CONFIG_CRYPTO_CAST5 is not set
# CONFIG_CRYPTO_CAST6 is not set
# CONFIG_CRYPTO_DES is not set
# CONFIG_CRYPTO_FCRYPT is not set
# CONFIG_CRYPTO_KHAZAD is not set
# CONFIG_CRYPTO_CHACHA20 is not set
# CONFIG_CRYPTO_SEED is not set
# CONFIG_CRYPTO_SERPENT is not set
# CONFIG_CRYPTO_SM4 is not set
# CONFIG_CRYPTO_TEA is not set
# CONFIG_CRYPTO_TWOFISH is not set

#
# Compression
#
# CONFIG_CRYPTO_DEFLATE is not set
CONFIG_CRYPTO_LZO=y
# CONFIG_CRYPTO_842 is not set
# CONFIG_CRYPTO_LZ4 is not set
# CONFIG_CRYPTO_LZ4HC is not set
# CONFIG_CRYPTO_ZSTD is not set

#
# Random Number Generation
#
# CONFIG_CRYPTO_ANSI_CPRNG is not set
# CONFIG_CRYPTO_DRBG_MENU is not set
# CONFIG_CRYPTO_JITTERENTROPY is not set
CONFIG_CRYPTO_USER_API=y
CONFIG_CRYPTO_USER_API_HASH=y
# CONFIG_CRYPTO_USER_API_SKCIPHER is not set
# CONFIG_CRYPTO_USER_API_RNG is not set
# CONFIG_CRYPTO_USER_API_AEAD is not set
CONFIG_CRYPTO_USER_API_ENABLE_OBSOLETE=y
CONFIG_CRYPTO_HW=y
# CONFIG_CRYPTO_DEV_ATMEL_ECC is not set
# CONFIG_CRYPTO_DEV_ATMEL_SHA204A is not set
# CONFIG_CRYPTO_DEV_NITROX_CNN55XX is not set
CONFIG_CRYPTO_DEV_VIRTIO=y
# CONFIG_CRYPTO_DEV_SAFEXCEL is not set
# CONFIG_CRYPTO_DEV_CCREE is not set
# CONFIG_CRYPTO_DEV_AMLOGIC_GXL is not set
# CONFIG_ASYMMETRIC_KEY_TYPE is not set

#
# Certificates for signature checking
#
# CONFIG_SYSTEM_BLACKLIST_KEYRING is not set
# end of Certificates for signature checking

CONFIG_BINARY_PRINTF=y

#
# Library routines
#
# CONFIG_PACKING is not set
CONFIG_BITREVERSE=y
CONFIG_GENERIC_STRNCPY_FROM_USER=y
CONFIG_GENERIC_STRNLEN_USER=y
CONFIG_GENERIC_NET_UTILS=y
# CONFIG_CORDIC is not set
# CONFIG_PRIME_NUMBERS is not set
CONFIG_RATIONAL=y
CONFIG_GENERIC_PCI_IOMAP=y

#
# Crypto library routines
#
CONFIG_CRYPTO_LIB_AES=y
CONFIG_CRYPTO_LIB_BLAKE2S_GENERIC=y
# CONFIG_CRYPTO_LIB_CHACHA is not set
# CONFIG_CRYPTO_LIB_CURVE25519 is not set
CONFIG_CRYPTO_LIB_POLY1305_RSIZE=1
# CONFIG_CRYPTO_LIB_POLY1305 is not set
# CONFIG_CRYPTO_LIB_CHACHA20POLY1305 is not set
CONFIG_CRYPTO_LIB_SHA256=y
# end of Crypto library routines

# CONFIG_CRC_CCITT is not set
CONFIG_CRC16=y
# CONFIG_CRC_T10DIF is not set
# CONFIG_CRC64_ROCKSOFT is not set
CONFIG_CRC_ITU_T=y
CONFIG_CRC32=y
# CONFIG_CRC32_SELFTEST is not set
CONFIG_CRC32_SLICEBY8=y
# CONFIG_CRC32_SLICEBY4 is not set
# CONFIG_CRC32_SARWATE is not set
# CONFIG_CRC32_BIT is not set
# CONFIG_CRC64 is not set
# CONFIG_CRC4 is not set
CONFIG_CRC7=y
CONFIG_LIBCRC32C=y
# CONFIG_CRC8 is not set
CONFIG_XXHASH=y
# CONFIG_RANDOM32_SELFTEST is not set
CONFIG_ZLIB_INFLATE=y
CONFIG_LZO_COMPRESS=y
CONFIG_LZO_DECOMPRESS=y
CONFIG_LZ4_DECOMPRESS=y
CONFIG_ZSTD_DECOMPRESS=y
CONFIG_XZ_DEC=y
CONFIG_XZ_DEC_X86=y
CONFIG_XZ_DEC_POWERPC=y
CONFIG_XZ_DEC_IA64=y
CONFIG_XZ_DEC_ARM=y
CONFIG_XZ_DEC_ARMTHUMB=y
CONFIG_XZ_DEC_SPARC=y
# CONFIG_XZ_DEC_MICROLZMA is not set
CONFIG_XZ_DEC_BCJ=y
# CONFIG_XZ_DEC_TEST is not set
CONFIG_DECOMPRESS_GZIP=y
CONFIG_DECOMPRESS_BZIP2=y
CONFIG_DECOMPRESS_LZMA=y
CONFIG_DECOMPRESS_XZ=y
CONFIG_DECOMPRESS_LZO=y
CONFIG_DECOMPRESS_LZ4=y
CONFIG_DECOMPRESS_ZSTD=y
CONFIG_GENERIC_ALLOCATOR=y
CONFIG_INTERVAL_TREE=y
CONFIG_XARRAY_MULTI=y
CONFIG_ASSOCIATIVE_ARRAY=y
CONFIG_HAS_IOMEM=y
CONFIG_HAS_IOPORT_MAP=y
CONFIG_HAS_DMA=y
CONFIG_NEED_DMA_MAP_STATE=y
CONFIG_ARCH_DMA_ADDR_T_64BIT=y
CONFIG_DMA_DECLARE_COHERENT=y
CONFIG_SWIOTLB=y
# CONFIG_DMA_RESTRICTED_POOL is not set
# CONFIG_DMA_CMA is not set
# CONFIG_DMA_API_DEBUG is not set
# CONFIG_DMA_MAP_BENCHMARK is not set
CONFIG_SGL_ALLOC=y
# CONFIG_CPUMASK_OFFSTACK is not set
CONFIG_CPU_RMAP=y
CONFIG_DQL=y
CONFIG_GLOB=y
# CONFIG_GLOB_SELFTEST is not set
CONFIG_NLATTR=y
CONFIG_CLZ_TAB=y
# CONFIG_IRQ_POLL is not set
CONFIG_MPILIB=y
CONFIG_LIBFDT=y
CONFIG_OID_REGISTRY=y
CONFIG_UCS2_STRING=y
CONFIG_HAVE_GENERIC_VDSO=y
CONFIG_GENERIC_GETTIMEOFDAY=y
CONFIG_GENERIC_VDSO_TIME_NS=y
CONFIG_FONT_SUPPORT=y
# CONFIG_FONTS is not set
CONFIG_FONT_8x8=y
CONFIG_FONT_8x16=y
CONFIG_SG_POOL=y
CONFIG_ARCH_STACKWALK=y
CONFIG_STACKDEPOT=y
CONFIG_STACK_HASH_ORDER=20
CONFIG_SBITMAP=y
# end of Library routines

CONFIG_GENERIC_IOREMAP=y
CONFIG_GENERIC_LIB_DEVMEM_IS_ALLOWED=y

#
# Kernel hacking
#

#
# printk and dmesg options
#
CONFIG_PRINTK_TIME=y
CONFIG_PRINTK_CALLER=y
# CONFIG_STACKTRACE_BUILD_ID is not set
CONFIG_CONSOLE_LOGLEVEL_DEFAULT=7
CONFIG_CONSOLE_LOGLEVEL_QUIET=6
CONFIG_MESSAGE_LOGLEVEL_DEFAULT=7
# CONFIG_BOOT_PRINTK_DELAY is not set
# CONFIG_DYNAMIC_DEBUG is not set
# CONFIG_DYNAMIC_DEBUG_CORE is not set
CONFIG_SYMBOLIC_ERRNAME=y
CONFIG_DEBUG_BUGVERBOSE=y
# end of printk and dmesg options

CONFIG_DEBUG_KERNEL=y
CONFIG_DEBUG_MISC=y

#
# Compile-time checks and compiler options
#
CONFIG_DEBUG_INFO=y
# CONFIG_DEBUG_INFO_NONE is not set
CONFIG_DEBUG_INFO_DWARF_TOOLCHAIN_DEFAULT=y
# CONFIG_DEBUG_INFO_DWARF4 is not set
# CONFIG_DEBUG_INFO_DWARF5 is not set
# CONFIG_DEBUG_INFO_REDUCED is not set
# CONFIG_DEBUG_INFO_COMPRESSED is not set
# CONFIG_DEBUG_INFO_SPLIT is not set
# CONFIG_DEBUG_INFO_BTF is not set
CONFIG_GDB_SCRIPTS=y
CONFIG_FRAME_WARN=2048
# CONFIG_STRIP_ASM_SYMS is not set
# CONFIG_HEADERS_INSTALL is not set
CONFIG_SECTION_MISMATCH_WARN_ONLY=y
CONFIG_ARCH_WANT_FRAME_POINTERS=y
CONFIG_FRAME_POINTER=y
# CONFIG_VMLINUX_MAP is not set
# CONFIG_DEBUG_FORCE_WEAK_PER_CPU is not set
# end of Compile-time checks and compiler options

#
# Generic Kernel Debugging Instruments
#
CONFIG_MAGIC_SYSRQ=y
CONFIG_MAGIC_SYSRQ_DEFAULT_ENABLE=0x1
CONFIG_MAGIC_SYSRQ_SERIAL=y
CONFIG_MAGIC_SYSRQ_SERIAL_SEQUENCE="p"
CONFIG_DEBUG_FS=y
CONFIG_DEBUG_FS_ALLOW_ALL=y
# CONFIG_DEBUG_FS_DISALLOW_MOUNT is not set
# CONFIG_DEBUG_FS_ALLOW_NONE is not set
CONFIG_HAVE_ARCH_KGDB=y
CONFIG_HAVE_ARCH_KGDB_QXFER_PKT=y
# CONFIG_KGDB is not set
CONFIG_ARCH_HAS_UBSAN_SANITIZE_ALL=y
# CONFIG_UBSAN is not set
# end of Generic Kernel Debugging Instruments

#
# Networking Debugging
#
# CONFIG_NET_DEV_REFCNT_TRACKER is not set
# CONFIG_NET_NS_REFCNT_TRACKER is not set
# end of Networking Debugging

#
# Memory Debugging
#
CONFIG_PAGE_EXTENSION=y
CONFIG_DEBUG_PAGEALLOC=y
# CONFIG_DEBUG_PAGEALLOC_ENABLE_DEFAULT is not set
# CONFIG_PAGE_OWNER is not set
# CONFIG_PAGE_POISONING is not set
# CONFIG_DEBUG_PAGE_REF is not set
# CONFIG_DEBUG_RODATA_TEST is not set
CONFIG_ARCH_HAS_DEBUG_WX=y
# CONFIG_DEBUG_WX is not set
CONFIG_GENERIC_PTDUMP=y
CONFIG_PTDUMP_CORE=y
CONFIG_PTDUMP_DEBUGFS=y
# CONFIG_DEBUG_OBJECTS is not set
# CONFIG_SLUB_DEBUG_ON is not set
# CONFIG_SLUB_STATS is not set
CONFIG_HAVE_DEBUG_KMEMLEAK=y
# CONFIG_DEBUG_KMEMLEAK is not set
CONFIG_DEBUG_STACK_USAGE=y
CONFIG_SCHED_STACK_END_CHECK=y
CONFIG_ARCH_HAS_DEBUG_VM_PGTABLE=y
CONFIG_DEBUG_VM=y
# CONFIG_DEBUG_VM_VMACACHE is not set
# CONFIG_DEBUG_VM_RB is not set
CONFIG_DEBUG_VM_PGFLAGS=y
CONFIG_DEBUG_VM_PGTABLE=y
CONFIG_ARCH_HAS_DEBUG_VIRTUAL=y
# CONFIG_DEBUG_VIRTUAL is not set
CONFIG_DEBUG_MEMORY_INIT=y
CONFIG_DEBUG_PER_CPU_MAPS=y
CONFIG_HAVE_ARCH_KASAN=y
CONFIG_HAVE_ARCH_KASAN_VMALLOC=y
CONFIG_CC_HAS_KASAN_GENERIC=y
CONFIG_CC_HAS_WORKING_NOSANITIZE_ADDRESS=y
# CONFIG_KASAN is not set
CONFIG_HAVE_ARCH_KFENCE=y
# CONFIG_KFENCE is not set
# end of Memory Debugging

# CONFIG_DEBUG_SHIRQ is not set

#
# Debug Oops, Lockups and Hangs
#
CONFIG_PANIC_ON_OOPS=y
CONFIG_PANIC_ON_OOPS_VALUE=1
CONFIG_PANIC_TIMEOUT=0
CONFIG_LOCKUP_DETECTOR=y
CONFIG_SOFTLOCKUP_DETECTOR=y
# CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC is not set
CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC_VALUE=0
CONFIG_DETECT_HUNG_TASK=y
CONFIG_DEFAULT_HUNG_TASK_TIMEOUT=120
# CONFIG_BOOTPARAM_HUNG_TASK_PANIC is not set
CONFIG_BOOTPARAM_HUNG_TASK_PANIC_VALUE=0
CONFIG_WQ_WATCHDOG=y
# CONFIG_TEST_LOCKUP is not set
# end of Debug Oops, Lockups and Hangs

#
# Scheduler Debugging
#
CONFIG_SCHED_DEBUG=y
CONFIG_SCHED_INFO=y
CONFIG_SCHEDSTATS=y
# end of Scheduler Debugging

# CONFIG_DEBUG_TIMEKEEPING is not set

#
# Lock Debugging (spinlocks, mutexes, etc...)
#
CONFIG_LOCK_DEBUGGING_SUPPORT=y
# CONFIG_PROVE_LOCKING is not set
# CONFIG_LOCK_STAT is not set
CONFIG_DEBUG_RT_MUTEXES=y
CONFIG_DEBUG_SPINLOCK=y
CONFIG_DEBUG_MUTEXES=y
# CONFIG_DEBUG_WW_MUTEX_SLOWPATH is not set
# CONFIG_DEBUG_RWSEMS is not set
CONFIG_DEBUG_LOCK_ALLOC=y
CONFIG_LOCKDEP=y
CONFIG_LOCKDEP_BITS=15
CONFIG_LOCKDEP_CHAINS_BITS=16
CONFIG_LOCKDEP_STACK_TRACE_BITS=19
CONFIG_LOCKDEP_STACK_TRACE_HASH_BITS=14
CONFIG_LOCKDEP_CIRCULAR_QUEUE_BITS=12
# CONFIG_DEBUG_LOCKDEP is not set
CONFIG_DEBUG_ATOMIC_SLEEP=y
# CONFIG_DEBUG_LOCKING_API_SELFTESTS is not set
# CONFIG_LOCK_TORTURE_TEST is not set
# CONFIG_WW_MUTEX_SELFTEST is not set
# CONFIG_SCF_TORTURE_TEST is not set
# CONFIG_CSD_LOCK_WAIT_DEBUG is not set
# end of Lock Debugging (spinlocks, mutexes, etc...)

CONFIG_TRACE_IRQFLAGS=y
# CONFIG_DEBUG_IRQFLAGS is not set
CONFIG_STACKTRACE=y
# CONFIG_WARN_ALL_UNSEEDED_RANDOM is not set
# CONFIG_DEBUG_KOBJECT is not set

#
# Debug kernel data structures
#
CONFIG_DEBUG_LIST=y
# CONFIG_DEBUG_PLIST is not set
# CONFIG_DEBUG_SG is not set
# CONFIG_DEBUG_NOTIFIERS is not set
CONFIG_BUG_ON_DATA_CORRUPTION=y
# end of Debug kernel data structures

# CONFIG_DEBUG_CREDENTIALS is not set

#
# RCU Debugging
#
# CONFIG_RCU_SCALE_TEST is not set
# CONFIG_RCU_TORTURE_TEST is not set
# CONFIG_RCU_REF_SCALE_TEST is not set
CONFIG_RCU_CPU_STALL_TIMEOUT=21
# CONFIG_RCU_TRACE is not set
CONFIG_RCU_EQS_DEBUG=y
# end of RCU Debugging

# CONFIG_DEBUG_WQ_FORCE_RR_CPU is not set
# CONFIG_CPU_HOTPLUG_STATE_CONTROL is not set
# CONFIG_LATENCYTOP is not set
CONFIG_NOP_TRACER=y
CONFIG_HAVE_FUNCTION_TRACER=y
CONFIG_HAVE_FUNCTION_GRAPH_TRACER=y
CONFIG_HAVE_DYNAMIC_FTRACE=y
CONFIG_HAVE_DYNAMIC_FTRACE_WITH_REGS=y
CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
CONFIG_HAVE_SYSCALL_TRACEPOINTS=y
CONFIG_TRACER_MAX_TRACE=y
CONFIG_TRACE_CLOCK=y
CONFIG_RING_BUFFER=y
CONFIG_EVENT_TRACING=y
CONFIG_CONTEXT_SWITCH_TRACER=y
CONFIG_RING_BUFFER_ALLOW_SWAP=y
CONFIG_PREEMPTIRQ_TRACEPOINTS=y
CONFIG_TRACING=y
CONFIG_GENERIC_TRACER=y
CONFIG_TRACING_SUPPORT=y
CONFIG_FTRACE=y
CONFIG_BOOTTIME_TRACING=y
CONFIG_FUNCTION_TRACER=y
CONFIG_FUNCTION_GRAPH_TRACER=y
CONFIG_DYNAMIC_FTRACE=y
CONFIG_DYNAMIC_FTRACE_WITH_REGS=y
CONFIG_FUNCTION_PROFILER=y
CONFIG_STACK_TRACER=y
CONFIG_IRQSOFF_TRACER=y
CONFIG_SCHED_TRACER=y
# CONFIG_HWLAT_TRACER is not set
CONFIG_OSNOISE_TRACER=y
# CONFIG_TIMERLAT_TRACER is not set
CONFIG_FTRACE_SYSCALLS=y
CONFIG_TRACER_SNAPSHOT=y
CONFIG_TRACER_SNAPSHOT_PER_CPU_SWAP=y
CONFIG_BRANCH_PROFILE_NONE=y
# CONFIG_PROFILE_ANNOTATED_BRANCHES is not set
# CONFIG_PROFILE_ALL_BRANCHES is not set
CONFIG_BLK_DEV_IO_TRACE=y
CONFIG_KPROBE_EVENTS=y
# CONFIG_KPROBE_EVENTS_ON_NOTRACE is not set
CONFIG_UPROBE_EVENTS=y
CONFIG_BPF_EVENTS=y
CONFIG_DYNAMIC_EVENTS=y
CONFIG_PROBE_EVENTS=y
# CONFIG_BPF_KPROBE_OVERRIDE is not set
CONFIG_FTRACE_MCOUNT_RECORD=y
CONFIG_FTRACE_MCOUNT_USE_RECORDMCOUNT=y
# CONFIG_SYNTH_EVENTS is not set
# CONFIG_TRACE_EVENT_INJECT is not set
# CONFIG_TRACEPOINT_BENCHMARK is not set
# CONFIG_RING_BUFFER_BENCHMARK is not set
# CONFIG_TRACE_EVAL_MAP_FILE is not set
CONFIG_FTRACE_RECORD_RECURSION=y
CONFIG_FTRACE_RECORD_RECURSION_SIZE=128
CONFIG_RING_BUFFER_RECORD_RECURSION=y
# CONFIG_FTRACE_STARTUP_TEST is not set
# CONFIG_RING_BUFFER_STARTUP_TEST is not set
# CONFIG_RING_BUFFER_VALIDATE_TIME_DELTAS is not set
# CONFIG_PREEMPTIRQ_DELAY_TEST is not set
# CONFIG_KPROBE_EVENT_GEN_TEST is not set
# CONFIG_SAMPLES is not set
# CONFIG_STRICT_DEVMEM is not set

#
# riscv Debugging
#
# end of riscv Debugging

#
# Kernel Testing and Coverage
#
# CONFIG_KUNIT is not set
# CONFIG_NOTIFIER_ERROR_INJECTION is not set
CONFIG_FUNCTION_ERROR_INJECTION=y
# CONFIG_FAULT_INJECTION is not set
CONFIG_ARCH_HAS_KCOV=y
CONFIG_CC_HAS_SANCOV_TRACE_PC=y
# CONFIG_KCOV is not set
# CONFIG_RUNTIME_TESTING_MENU is not set
CONFIG_ARCH_USE_MEMTEST=y
# CONFIG_MEMTEST is not set
# end of Kernel Testing and Coverage
# end of Kernel hacking

^ permalink raw reply	[flat|nested] 21+ messages in thread

* Re: riscv: llvm-compiler: calling convention violation: temporary register $t2 is used to pass the ninth function parameter
@ 2022-05-13  3:46             ` Changbin Du
  0 siblings, 0 replies; 21+ messages in thread
From: Changbin Du @ 2022-05-13  3:46 UTC (permalink / raw)
  To: Craig Topper
  Cc: Alex Bradbury, Albert Ou, Changbin Du, Nick Desaulniers,
	Palmer Dabbelt, Paul Walmsley, Steven Rostedt, hw.huiwang,
	linux-kernel, linux-riscv, llvm

[-- Attachment #1: Type: text/plain, Size: 5683 bytes --]

On Thu, May 12, 2022 at 07:49:41AM -0700, Craig Topper wrote:
> Changbin, can you provide a pre-processed source and a command line? I can
> reduce it on the llvm side.
> 

hmm, clang can not build the preprocessed source by itself!

$ /opt/llvm-13.0.0/bin/clang -nostdinc -Qunused-arguments -Wall -Wundef -Werror=strict-prototypes -Wno-trigraphs -fno-strict-aliasing -fno-common -fshort-wchar -fno-PIE -Werror=implicit-function-declaration -Werror=implicit-int -Werror=return-type -Wno-format-security -std=gnu11 --target=riscv64-linux-gnu -fintegrated-as -Werror=unknown-warning-option -Werror=ignored-optimization-argument -mabi=lp64 -mno-relax -march=rv64imac -mno-save-restore -mcmodel=medany -fno-omit-frame-pointer -fno-delete-null-pointer-checks -Wno-frame-address -Wno-address-of-packed-member -O2 -Wframe-larger-than=2048 -fstack-protector-strong -Werror -Wno-gnu -Wno-unused-but-set-variable -Wno-unused-const-variable -fno-omit-frame-pointer -fno-optimize-sibling-calls -fno-stack-clash-protection -fpatchable-function-entry=8 -Wdeclaration-after-statement -Wvla -Wno-pointer-sign -Wcast-function-type -fno-strict-overflow -fno-stack-check -Werror=date-time -Werror=incompatible-pointer-types -Wno-initializer-overrides -Wno-format -Wno-sign-compare -Wno-format-zero-length -Wno-pointer-to-enum-cast -Wno-tautological-constant-out-of-range-compare -g   -c -o route.o route.i
In file included from net/ipv6/route.c:30:
In file included from ./include/linux/socket.h:8:
In file included from ./include/linux/uio.h:9:
In file included from ./include/linux/thread_info.h:14:
In file included from ./include/linux/restart_block.h:10:
In file included from ./include/linux/time64.h:5:
./include/linux/math64.h:278:128: error: expression result unused [-Werror,-Wunused-value]
 ({ uint32_t __base = (divisor); uint32_t __rem; __rem = ((uint64_t)(rl.ll)) % __base; (rl.ll) = ((uint64_t)(rl.ll)) / __base; __rem; });
 ...

I also tried to reduce it using creduce. But the result is still too large and
creduce encounted a bug.

Here is my test script 'llvm-riscv-callconvention-bug.sh':
#!/bin/bash

pushd /home/changbin/work/linux-riscv
/opt/llvm-latest/bin/clang -Wp,-MMD,net/ipv6/.route.o.d  -nostdinc -I./arch/riscv/include -I./arch/riscv/include/generated  -I./include -I./arch/riscv/include/uapi -I./arch/riscv/include/generated/uapi -I./include/uapi -I./include/generated/uapi -include ./include/linux/compiler-version.h -include ./include/linux/kconfig.h -include ./include/linux/compiler_types.h -D__KERNEL__ -DCC_USING_PATCHABLE_FUNCTION_ENTRY -Qunused-arguments -fmacro-prefix-map=./= -Wall -Wundef -Werror=strict-prototypes -Wno-trigraphs -fno-strict-aliasing -fno-common -fshort-wchar -fno-PIE -Werror=implicit-function-declaration -Werror=implicit-int -Werror=return-type -Wno-format-security -std=gnu11 --target=riscv64-linux-gnu -fintegrated-as -Werror=unknown-warning-option -Werror=ignored-optimization-argument -mabi=lp64 -mno-relax -march=rv64imac -mno-save-restore -DCONFIG_PAGE_OFFSET=0xff60000000000000 -mcmodel=medany -fno-omit-frame-pointer -fno-delete-null-pointer-checks -Wno-frame-address -Wno-address-of-packed-member -O2 -Wframe-larger-than=2048 -fstack-protector-strong -Werror -Wno-gnu -Wno-unused-but-set-variable -Wno-unused-const-variable -fno-omit-frame-pointer -fno-optimize-sibling-calls -fno-stack-clash-protection -fpatchable-function-entry=8 -Wdeclaration-after-statement -Wvla -Wno-pointer-sign -Wcast-function-type -fno-strict-overflow -fno-stack-check -Werror=date-time -Werror=incompatible-pointer-types -Wno-initializer-overrides -Wno-format -Wno-sign-compare -Wno-format-zero-length -Wno-pointer-to-enum-cast -Wno-tautological-constant-out-of-range-compare -g    -DKBUILD_MODFILE='"net/ipv6/ipv6"' -DKBUILD_BASENAME='"route"' -DKBUILD_MODNAME='"ipv6"' -D__KBUILD_MODNAME=kmod_ipv6 -c -o net/ipv6/route.o /home/changbin/work/linux-riscv/net/ipv6/route.c || exit 1


mpri_found=false

gdb -q -ex 'info scope __find_rr_leaf' -ex 'quit' net/ipv6/route.o | while read line
do
        if [ "$mpri_found" = true ]; then
                match='\$t2'
                if [[ "$line" =~ $match ]]; then
                        exit 0
                else
                        exit 1
                fi
        fi

        match='Symbol mpri*'
        if [[ "$line" =~ $match ]]; then
                mpri_found=true
                echo $line
        fi
done
popd


$ creduce llvm-riscv-callconvention-bug.sh linux-riscv/net/ipv6/route.c


Here are the steps to reproduce it by buiding linux kernel:
 1. copy attached llvm-bug.kernel.config as .config under kernel souce tree.
   $ cd linux
   $ cp llvm-bug.kernel.config .config
 2. build the kernel.
   $ make ARCH=riscv LLVM=1 LLVM_IAS=1 -j$(nproc) Image
 3. investigate the result.
   $ gdb net/ipv6/route.o
   $ (gdb) info scope __find_rr_leaf



> On Thu, May 12, 2022 at 1:35 AM Alex Bradbury <asb@asbradbury.org> wrote:
> 
> > On Thu, 12 May 2022 at 09:30, Changbin Du <changbin.du@huawei.com> wrote:
> > >
> > > On Wed, May 11, 2022 at 01:07:14PM -0700, Craig Topper wrote:
> > > > I’m guessing that because the function is static, the calling
> > convention was changed to fastcall which allows us to ignore the ABI.
> > > >
> > > I think so. But the mcount function assumes the ABI is not changed.
> >
> > It feels like this is a problem that would be encountered on other
> > architectures with clangbuiltlinux as well, due to dropping the ABI
> > requirements for local functions. Have you seen something similar
> > elsewhere Nick?
> >
> > Best,
> >
> > Alex
> >

-- 
Cheers,
Changbin Du

[-- Attachment #2: llvm-bug.kernel.config --]
[-- Type: text/plain, Size: 97609 bytes --]

#
# Automatically generated file; DO NOT EDIT.
# Linux/riscv 5.18.0-rc6 Kernel Configuration
#
CONFIG_CC_VERSION_TEXT="clang version 13.0.0 (https://github.com/llvm/llvm-project.git d7b669b3a30345cfcdb2fde2af6f48aa4b94845d)"
CONFIG_GCC_VERSION=0
CONFIG_CC_IS_CLANG=y
CONFIG_CLANG_VERSION=130000
CONFIG_AS_IS_LLVM=y
CONFIG_AS_VERSION=130000
CONFIG_LD_VERSION=0
CONFIG_LD_IS_LLD=y
CONFIG_LLD_VERSION=130000
CONFIG_CC_CAN_LINK=y
CONFIG_CC_CAN_LINK_STATIC=y
CONFIG_CC_HAS_ASM_GOTO=y
CONFIG_CC_HAS_ASM_GOTO_OUTPUT=y
CONFIG_TOOLS_SUPPORT_RELR=y
CONFIG_CC_HAS_ASM_INLINE=y
CONFIG_CC_HAS_NO_PROFILE_FN_ATTR=y
CONFIG_PAHOLE_VERSION=0
CONFIG_IRQ_WORK=y
CONFIG_BUILDTIME_TABLE_SORT=y
CONFIG_THREAD_INFO_IN_TASK=y

#
# General setup
#
CONFIG_INIT_ENV_ARG_LIMIT=32
# CONFIG_COMPILE_TEST is not set
CONFIG_WERROR=y
CONFIG_LOCALVERSION=""
CONFIG_LOCALVERSION_AUTO=y
CONFIG_BUILD_SALT=""
CONFIG_DEFAULT_INIT=""
CONFIG_DEFAULT_HOSTNAME="(none)"
CONFIG_SWAP=y
CONFIG_SYSVIPC=y
CONFIG_SYSVIPC_SYSCTL=y
CONFIG_POSIX_MQUEUE=y
CONFIG_POSIX_MQUEUE_SYSCTL=y
# CONFIG_WATCH_QUEUE is not set
CONFIG_CROSS_MEMORY_ATTACH=y
# CONFIG_USELIB is not set
# CONFIG_AUDIT is not set
CONFIG_HAVE_ARCH_AUDITSYSCALL=y

#
# IRQ subsystem
#
CONFIG_GENERIC_IRQ_SHOW=y
CONFIG_GENERIC_IRQ_SHOW_LEVEL=y
CONFIG_GENERIC_IRQ_MIGRATION=y
CONFIG_IRQ_DOMAIN=y
CONFIG_IRQ_DOMAIN_HIERARCHY=y
CONFIG_GENERIC_MSI_IRQ=y
CONFIG_GENERIC_MSI_IRQ_DOMAIN=y
CONFIG_IRQ_FORCED_THREADING=y
CONFIG_SPARSE_IRQ=y
# CONFIG_GENERIC_IRQ_DEBUGFS is not set
# end of IRQ subsystem

CONFIG_GENERIC_IRQ_MULTI_HANDLER=y
CONFIG_ARCH_CLOCKSOURCE_INIT=y
CONFIG_GENERIC_TIME_VSYSCALL=y
CONFIG_GENERIC_CLOCKEVENTS=y
CONFIG_ARCH_HAS_TICK_BROADCAST=y
CONFIG_GENERIC_CLOCKEVENTS_BROADCAST=y

#
# Timers subsystem
#
CONFIG_TICK_ONESHOT=y
CONFIG_NO_HZ_COMMON=y
# CONFIG_HZ_PERIODIC is not set
CONFIG_NO_HZ_IDLE=y
# CONFIG_NO_HZ_FULL is not set
# CONFIG_NO_HZ is not set
CONFIG_HIGH_RES_TIMERS=y
# end of Timers subsystem

CONFIG_BPF=y
CONFIG_HAVE_EBPF_JIT=y

#
# BPF subsystem
#
CONFIG_BPF_SYSCALL=y
# CONFIG_BPF_JIT is not set
# CONFIG_BPF_UNPRIV_DEFAULT_OFF is not set
# CONFIG_BPF_PRELOAD is not set
# end of BPF subsystem

CONFIG_PREEMPT_VOLUNTARY_BUILD=y
# CONFIG_PREEMPT_NONE is not set
CONFIG_PREEMPT_VOLUNTARY=y
# CONFIG_PREEMPT is not set
CONFIG_PREEMPT_COUNT=y

#
# CPU/Task time and stats accounting
#
CONFIG_TICK_CPU_ACCOUNTING=y
# CONFIG_VIRT_CPU_ACCOUNTING_GEN is not set
CONFIG_IRQ_TIME_ACCOUNTING=y
CONFIG_HAVE_SCHED_AVG_IRQ=y
# CONFIG_BSD_PROCESS_ACCT is not set
# CONFIG_TASKSTATS is not set
# CONFIG_PSI is not set
# end of CPU/Task time and stats accounting

CONFIG_CPU_ISOLATION=y

#
# RCU Subsystem
#
CONFIG_TREE_RCU=y
# CONFIG_RCU_EXPERT is not set
CONFIG_SRCU=y
CONFIG_TREE_SRCU=y
CONFIG_TASKS_RCU_GENERIC=y
CONFIG_TASKS_RUDE_RCU=y
CONFIG_TASKS_TRACE_RCU=y
CONFIG_RCU_STALL_COMMON=y
CONFIG_RCU_NEED_SEGCBLIST=y
# end of RCU Subsystem

CONFIG_IKCONFIG=y
CONFIG_IKCONFIG_PROC=y
# CONFIG_IKHEADERS is not set
CONFIG_LOG_BUF_SHIFT=17
CONFIG_LOG_CPU_MAX_BUF_SHIFT=12
CONFIG_PRINTK_SAFE_LOG_BUF_SHIFT=13
# CONFIG_PRINTK_INDEX is not set
CONFIG_GENERIC_SCHED_CLOCK=y

#
# Scheduler features
#
# end of Scheduler features

CONFIG_CC_HAS_INT128=y
CONFIG_ARCH_SUPPORTS_INT128=y
CONFIG_CGROUPS=y
# CONFIG_MEMCG is not set
# CONFIG_BLK_CGROUP is not set
CONFIG_CGROUP_SCHED=y
CONFIG_FAIR_GROUP_SCHED=y
CONFIG_CFS_BANDWIDTH=y
# CONFIG_RT_GROUP_SCHED is not set
# CONFIG_CGROUP_PIDS is not set
# CONFIG_CGROUP_RDMA is not set
# CONFIG_CGROUP_FREEZER is not set
# CONFIG_CPUSETS is not set
# CONFIG_CGROUP_DEVICE is not set
# CONFIG_CGROUP_CPUACCT is not set
# CONFIG_CGROUP_PERF is not set
CONFIG_CGROUP_BPF=y
# CONFIG_CGROUP_MISC is not set
# CONFIG_CGROUP_DEBUG is not set
CONFIG_SOCK_CGROUP_DATA=y
CONFIG_NAMESPACES=y
CONFIG_UTS_NS=y
CONFIG_TIME_NS=y
CONFIG_IPC_NS=y
CONFIG_USER_NS=y
CONFIG_PID_NS=y
CONFIG_NET_NS=y
CONFIG_CHECKPOINT_RESTORE=y
# CONFIG_SCHED_AUTOGROUP is not set
# CONFIG_SYSFS_DEPRECATED is not set
CONFIG_RELAY=y
CONFIG_BLK_DEV_INITRD=y
CONFIG_INITRAMFS_SOURCE=""
CONFIG_RD_GZIP=y
CONFIG_RD_BZIP2=y
CONFIG_RD_LZMA=y
CONFIG_RD_XZ=y
CONFIG_RD_LZO=y
CONFIG_RD_LZ4=y
CONFIG_RD_ZSTD=y
CONFIG_BOOT_CONFIG=y
CONFIG_CC_OPTIMIZE_FOR_PERFORMANCE=y
# CONFIG_CC_OPTIMIZE_FOR_SIZE is not set
CONFIG_SYSCTL=y
CONFIG_SYSCTL_EXCEPTION_TRACE=y
CONFIG_EXPERT=y
CONFIG_MULTIUSER=y
# CONFIG_SGETMASK_SYSCALL is not set
# CONFIG_SYSFS_SYSCALL is not set
CONFIG_FHANDLE=y
CONFIG_POSIX_TIMERS=y
CONFIG_PRINTK=y
CONFIG_BUG=y
CONFIG_ELF_CORE=y
CONFIG_BASE_FULL=y
CONFIG_FUTEX=y
CONFIG_FUTEX_PI=y
CONFIG_EPOLL=y
CONFIG_SIGNALFD=y
CONFIG_TIMERFD=y
CONFIG_EVENTFD=y
CONFIG_SHMEM=y
CONFIG_AIO=y
CONFIG_IO_URING=y
CONFIG_ADVISE_SYSCALLS=y
CONFIG_MEMBARRIER=y
CONFIG_KALLSYMS=y
CONFIG_KALLSYMS_ALL=y
CONFIG_KALLSYMS_BASE_RELATIVE=y
# CONFIG_USERFAULTFD is not set
CONFIG_KCMP=y
CONFIG_RSEQ=y
# CONFIG_DEBUG_RSEQ is not set
# CONFIG_EMBEDDED is not set
CONFIG_HAVE_PERF_EVENTS=y
# CONFIG_PC104 is not set

#
# Kernel Performance Events And Counters
#
CONFIG_PERF_EVENTS=y
# CONFIG_DEBUG_PERF_USE_VMALLOC is not set
# end of Kernel Performance Events And Counters

CONFIG_VM_EVENT_COUNTERS=y
CONFIG_SLUB_DEBUG=y
CONFIG_COMPAT_BRK=y
# CONFIG_SLAB is not set
CONFIG_SLUB=y
# CONFIG_SLOB is not set
CONFIG_SLAB_MERGE_DEFAULT=y
# CONFIG_SLAB_FREELIST_RANDOM is not set
# CONFIG_SLAB_FREELIST_HARDENED is not set
# CONFIG_SHUFFLE_PAGE_ALLOCATOR is not set
CONFIG_SLUB_CPU_PARTIAL=y
# CONFIG_PROFILING is not set
CONFIG_TRACEPOINTS=y
# end of General setup

CONFIG_64BIT=y
CONFIG_RISCV=y
CONFIG_ARCH_MMAP_RND_BITS_MIN=18
CONFIG_ARCH_MMAP_RND_BITS_MAX=24
CONFIG_RISCV_SBI=y
CONFIG_MMU=y
CONFIG_PAGE_OFFSET=0xff60000000000000
CONFIG_ARCH_FLATMEM_ENABLE=y
CONFIG_ARCH_SPARSEMEM_ENABLE=y
CONFIG_ARCH_SELECT_MEMORY_MODEL=y
CONFIG_ARCH_SUPPORTS_UPROBES=y
CONFIG_STACKTRACE_SUPPORT=y
CONFIG_GENERIC_BUG=y
CONFIG_GENERIC_BUG_RELATIVE_POINTERS=y
CONFIG_GENERIC_CALIBRATE_DELAY=y
CONFIG_GENERIC_CSUM=y
CONFIG_GENERIC_HWEIGHT=y
CONFIG_FIX_EARLYCON_MEM=y
CONFIG_PGTABLE_LEVELS=5
CONFIG_LOCKDEP_SUPPORT=y

#
# SoC selection
#
# CONFIG_SOC_MICROCHIP_POLARFIRE is not set
CONFIG_SOC_SIFIVE=y
# CONFIG_SOC_STARFIVE is not set
CONFIG_SOC_VIRT=y
# end of SoC selection

#
# CPU errata selection
#
CONFIG_RISCV_ERRATA_ALTERNATIVE=y
CONFIG_ERRATA_SIFIVE=y
CONFIG_ERRATA_SIFIVE_CIP_453=y
CONFIG_ERRATA_SIFIVE_CIP_1200=y
# end of CPU errata selection

#
# Platform type
#
# CONFIG_ARCH_RV32I is not set
CONFIG_ARCH_RV64I=y
# CONFIG_CMODEL_MEDLOW is not set
CONFIG_CMODEL_MEDANY=y
CONFIG_MODULE_SECTIONS=y
CONFIG_SMP=y
CONFIG_NR_CPUS=32
CONFIG_HOTPLUG_CPU=y
CONFIG_TUNE_GENERIC=y
# CONFIG_NUMA is not set
CONFIG_RISCV_ISA_C=y
CONFIG_FPU=y
# end of Platform type

#
# Kernel features
#
CONFIG_HZ_100=y
# CONFIG_HZ_250 is not set
# CONFIG_HZ_300 is not set
# CONFIG_HZ_1000 is not set
CONFIG_HZ=100
CONFIG_SCHED_HRTICK=y
CONFIG_RISCV_SBI_V01=y
CONFIG_RISCV_BOOT_SPINWAIT=y
CONFIG_KEXEC=y
# CONFIG_CRASH_DUMP is not set
# end of Kernel features

#
# Boot options
#
CONFIG_CMDLINE=""
CONFIG_EFI_STUB=y
CONFIG_EFI=y
# CONFIG_PHYS_RAM_BASE_FIXED is not set
# CONFIG_XIP_KERNEL is not set
# end of Boot options

#
# Power management options
#
CONFIG_PM=y
# CONFIG_PM_DEBUG is not set
CONFIG_PM_CLK=y
CONFIG_PM_GENERIC_DOMAINS=y
# CONFIG_WQ_POWER_EFFICIENT_DEFAULT is not set
CONFIG_PM_GENERIC_DOMAINS_OF=y
# end of Power management options

#
# CPU Power Management
#

#
# CPU Idle
#
# CONFIG_CPU_IDLE is not set
# end of CPU Idle
# end of CPU Power Management

CONFIG_HAVE_KVM_EVENTFD=y
CONFIG_KVM_MMIO=y
CONFIG_KVM_GENERIC_DIRTYLOG_READ_PROTECT=y
CONFIG_HAVE_KVM_VCPU_ASYNC_IOCTL=y
CONFIG_VIRTUALIZATION=y
CONFIG_KVM=y

#
# General architecture-dependent options
#
CONFIG_CRASH_CORE=y
CONFIG_KEXEC_CORE=y
CONFIG_KPROBES=y
# CONFIG_JUMP_LABEL is not set
CONFIG_KPROBES_ON_FTRACE=y
CONFIG_UPROBES=y
CONFIG_HAVE_64BIT_ALIGNED_ACCESS=y
CONFIG_KRETPROBES=y
CONFIG_HAVE_KPROBES=y
CONFIG_HAVE_KRETPROBES=y
CONFIG_HAVE_KPROBES_ON_FTRACE=y
CONFIG_HAVE_FUNCTION_ERROR_INJECTION=y
CONFIG_TRACE_IRQFLAGS_SUPPORT=y
CONFIG_HAVE_ARCH_TRACEHOOK=y
CONFIG_HAVE_DMA_CONTIGUOUS=y
CONFIG_GENERIC_SMP_IDLE_THREAD=y
CONFIG_GENERIC_IDLE_POLL_SETUP=y
CONFIG_ARCH_HAS_FORTIFY_SOURCE=y
CONFIG_ARCH_HAS_SET_MEMORY=y
CONFIG_ARCH_HAS_SET_DIRECT_MAP=y
CONFIG_HAVE_ARCH_THREAD_STRUCT_WHITELIST=y
CONFIG_HAVE_ASM_MODVERSIONS=y
CONFIG_HAVE_REGS_AND_STACK_ACCESS_API=y
CONFIG_HAVE_RSEQ=y
CONFIG_HAVE_FUNCTION_ARG_ACCESS_API=y
CONFIG_HAVE_PERF_REGS=y
CONFIG_HAVE_PERF_USER_STACK_DUMP=y
CONFIG_HAVE_ARCH_JUMP_LABEL=y
CONFIG_HAVE_ARCH_JUMP_LABEL_RELATIVE=y
CONFIG_HAVE_ARCH_SECCOMP=y
CONFIG_HAVE_ARCH_SECCOMP_FILTER=y
# CONFIG_SECCOMP is not set
CONFIG_HAVE_STACKPROTECTOR=y
CONFIG_STACKPROTECTOR=y
CONFIG_STACKPROTECTOR_STRONG=y
CONFIG_LTO_NONE=y
CONFIG_HAVE_CONTEXT_TRACKING=y
CONFIG_HAVE_VIRT_CPU_ACCOUNTING_GEN=y
CONFIG_HAVE_IRQ_TIME_ACCOUNTING=y
CONFIG_HAVE_MOVE_PUD=y
CONFIG_HAVE_MOVE_PMD=y
CONFIG_HAVE_ARCH_TRANSPARENT_HUGEPAGE=y
CONFIG_ARCH_WANT_HUGE_PMD_SHARE=y
CONFIG_HAVE_MOD_ARCH_SPECIFIC=y
CONFIG_MODULES_USE_ELF_RELA=y
CONFIG_ARCH_HAS_ELF_RANDOMIZE=y
CONFIG_HAVE_ARCH_MMAP_RND_BITS=y
CONFIG_ARCH_MMAP_RND_BITS=18
CONFIG_PAGE_SIZE_LESS_THAN_64KB=y
CONFIG_PAGE_SIZE_LESS_THAN_256KB=y
CONFIG_ARCH_WANT_DEFAULT_TOPDOWN_MMAP_LAYOUT=y
CONFIG_CLONE_BACKWARDS=y
# CONFIG_COMPAT_32BIT_TIME is not set
CONFIG_HAVE_ARCH_VMAP_STACK=y
CONFIG_VMAP_STACK=y
CONFIG_ARCH_OPTIONAL_KERNEL_RWX=y
CONFIG_ARCH_OPTIONAL_KERNEL_RWX_DEFAULT=y
CONFIG_ARCH_HAS_STRICT_KERNEL_RWX=y
CONFIG_STRICT_KERNEL_RWX=y
CONFIG_ARCH_HAS_STRICT_MODULE_RWX=y
CONFIG_STRICT_MODULE_RWX=y
CONFIG_ARCH_USE_MEMREMAP_PROT=y
# CONFIG_LOCK_EVENT_COUNTS is not set
CONFIG_ARCH_SUPPORTS_DEBUG_PAGEALLOC=y

#
# GCOV-based kernel profiling
#
# CONFIG_GCOV_KERNEL is not set
CONFIG_ARCH_HAS_GCOV_PROFILE_ALL=y
# end of GCOV-based kernel profiling

CONFIG_HAVE_GCC_PLUGINS=y
# end of General architecture-dependent options

CONFIG_RT_MUTEXES=y
CONFIG_BASE_SMALL=0
CONFIG_MODULES=y
# CONFIG_MODULE_FORCE_LOAD is not set
CONFIG_MODULE_UNLOAD=y
# CONFIG_MODULE_FORCE_UNLOAD is not set
# CONFIG_MODVERSIONS is not set
# CONFIG_MODULE_SRCVERSION_ALL is not set
# CONFIG_MODULE_SIG is not set
CONFIG_MODULE_COMPRESS_NONE=y
# CONFIG_MODULE_COMPRESS_GZIP is not set
# CONFIG_MODULE_COMPRESS_XZ is not set
# CONFIG_MODULE_COMPRESS_ZSTD is not set
# CONFIG_MODULE_ALLOW_MISSING_NAMESPACE_IMPORTS is not set
CONFIG_MODPROBE_PATH="/sbin/modprobe"
# CONFIG_TRIM_UNUSED_KSYMS is not set
CONFIG_MODULES_TREE_LOOKUP=y
CONFIG_BLOCK=y
CONFIG_BLOCK_LEGACY_AUTOLOAD=y
CONFIG_BLK_DEV_BSG_COMMON=y
# CONFIG_BLK_DEV_BSGLIB is not set
# CONFIG_BLK_DEV_INTEGRITY is not set
# CONFIG_BLK_DEV_ZONED is not set
# CONFIG_BLK_WBT is not set
CONFIG_BLK_DEBUG_FS=y
# CONFIG_BLK_SED_OPAL is not set
# CONFIG_BLK_INLINE_ENCRYPTION is not set

#
# Partition Types
#
# CONFIG_PARTITION_ADVANCED is not set
CONFIG_MSDOS_PARTITION=y
CONFIG_EFI_PARTITION=y
# end of Partition Types

CONFIG_BLK_MQ_PCI=y
CONFIG_BLK_MQ_VIRTIO=y
CONFIG_BLK_PM=y

#
# IO Schedulers
#
CONFIG_MQ_IOSCHED_DEADLINE=y
CONFIG_MQ_IOSCHED_KYBER=y
# CONFIG_IOSCHED_BFQ is not set
# end of IO Schedulers

CONFIG_PREEMPT_NOTIFIERS=y
CONFIG_ASN1=y
CONFIG_UNINLINE_SPIN_UNLOCK=y
CONFIG_ARCH_SUPPORTS_ATOMIC_RMW=y
CONFIG_MUTEX_SPIN_ON_OWNER=y
CONFIG_RWSEM_SPIN_ON_OWNER=y
CONFIG_LOCK_SPIN_ON_OWNER=y
CONFIG_ARCH_HAS_MMIOWB=y
CONFIG_MMIOWB=y

#
# Executable file formats
#
CONFIG_BINFMT_ELF=y
CONFIG_ELFCORE=y
CONFIG_CORE_DUMP_DEFAULT_ELF_HEADERS=y
CONFIG_BINFMT_SCRIPT=y
CONFIG_ARCH_HAS_BINFMT_FLAT=y
CONFIG_BINFMT_FLAT=y
# CONFIG_BINFMT_FLAT_OLD is not set
# CONFIG_BINFMT_ZFLAT is not set
# CONFIG_BINFMT_SHARED_FLAT is not set
CONFIG_BINFMT_MISC=y
CONFIG_COREDUMP=y
# end of Executable file formats

#
# Memory Management options
#
CONFIG_SELECT_MEMORY_MODEL=y
# CONFIG_FLATMEM_MANUAL is not set
CONFIG_SPARSEMEM_MANUAL=y
CONFIG_SPARSEMEM=y
CONFIG_SPARSEMEM_EXTREME=y
CONFIG_SPARSEMEM_VMEMMAP_ENABLE=y
CONFIG_SPARSEMEM_VMEMMAP=y
CONFIG_MEMORY_ISOLATION=y
CONFIG_SPLIT_PTLOCK_CPUS=4
CONFIG_ARCH_ENABLE_SPLIT_PMD_PTLOCK=y
CONFIG_MEMORY_BALLOON=y
CONFIG_BALLOON_COMPACTION=y
CONFIG_COMPACTION=y
CONFIG_PAGE_REPORTING=y
CONFIG_MIGRATION=y
CONFIG_ARCH_ENABLE_THP_MIGRATION=y
CONFIG_CONTIG_ALLOC=y
CONFIG_PHYS_ADDR_T_64BIT=y
CONFIG_MMU_NOTIFIER=y
# CONFIG_KSM is not set
CONFIG_DEFAULT_MMAP_MIN_ADDR=4096
CONFIG_TRANSPARENT_HUGEPAGE=y
CONFIG_TRANSPARENT_HUGEPAGE_ALWAYS=y
# CONFIG_TRANSPARENT_HUGEPAGE_MADVISE is not set
CONFIG_ARCH_WANT_GENERAL_HUGETLB=y
CONFIG_FRONTSWAP=y
CONFIG_CMA=y
# CONFIG_CMA_DEBUG is not set
CONFIG_CMA_DEBUGFS=y
CONFIG_CMA_SYSFS=y
CONFIG_CMA_AREAS=7
CONFIG_ZSWAP=y
# CONFIG_ZSWAP_COMPRESSOR_DEFAULT_DEFLATE is not set
CONFIG_ZSWAP_COMPRESSOR_DEFAULT_LZO=y
# CONFIG_ZSWAP_COMPRESSOR_DEFAULT_842 is not set
# CONFIG_ZSWAP_COMPRESSOR_DEFAULT_LZ4 is not set
# CONFIG_ZSWAP_COMPRESSOR_DEFAULT_LZ4HC is not set
# CONFIG_ZSWAP_COMPRESSOR_DEFAULT_ZSTD is not set
CONFIG_ZSWAP_COMPRESSOR_DEFAULT="lzo"
CONFIG_ZSWAP_ZPOOL_DEFAULT_ZBUD=y
# CONFIG_ZSWAP_ZPOOL_DEFAULT_Z3FOLD is not set
# CONFIG_ZSWAP_ZPOOL_DEFAULT_ZSMALLOC is not set
CONFIG_ZSWAP_ZPOOL_DEFAULT="zbud"
# CONFIG_ZSWAP_DEFAULT_ON is not set
CONFIG_ZPOOL=y
CONFIG_ZBUD=y
# CONFIG_Z3FOLD is not set
# CONFIG_ZSMALLOC is not set
CONFIG_GENERIC_EARLY_IOREMAP=y
# CONFIG_DEFERRED_STRUCT_PAGE_INIT is not set
CONFIG_PAGE_IDLE_FLAG=y
CONFIG_IDLE_PAGE_TRACKING=y
CONFIG_ARCH_HAS_CURRENT_STACK_POINTER=y
CONFIG_ZONE_DMA32=y
# CONFIG_PERCPU_STATS is not set
# CONFIG_GUP_TEST is not set
# CONFIG_READ_ONLY_THP_FOR_FS is not set
CONFIG_ARCH_HAS_PTE_SPECIAL=y
CONFIG_SECRETMEM=y
CONFIG_ANON_VMA_NAME=y

#
# Data Access Monitoring
#
CONFIG_DAMON=y
CONFIG_DAMON_VADDR=y
CONFIG_DAMON_PADDR=y
CONFIG_DAMON_SYSFS=y
CONFIG_DAMON_DBGFS=y
CONFIG_DAMON_RECLAIM=y
# end of Data Access Monitoring
# end of Memory Management options

CONFIG_NET=y

#
# Networking options
#
CONFIG_PACKET=y
# CONFIG_PACKET_DIAG is not set
CONFIG_UNIX=y
CONFIG_UNIX_SCM=y
CONFIG_AF_UNIX_OOB=y
# CONFIG_UNIX_DIAG is not set
# CONFIG_TLS is not set
# CONFIG_XFRM_USER is not set
# CONFIG_NET_KEY is not set
# CONFIG_XDP_SOCKETS is not set
CONFIG_INET=y
CONFIG_IP_MULTICAST=y
CONFIG_IP_ADVANCED_ROUTER=y
# CONFIG_IP_FIB_TRIE_STATS is not set
# CONFIG_IP_MULTIPLE_TABLES is not set
# CONFIG_IP_ROUTE_MULTIPATH is not set
# CONFIG_IP_ROUTE_VERBOSE is not set
CONFIG_IP_PNP=y
CONFIG_IP_PNP_DHCP=y
CONFIG_IP_PNP_BOOTP=y
CONFIG_IP_PNP_RARP=y
# CONFIG_NET_IPIP is not set
# CONFIG_NET_IPGRE_DEMUX is not set
CONFIG_NET_IP_TUNNEL=y
# CONFIG_IP_MROUTE is not set
# CONFIG_SYN_COOKIES is not set
# CONFIG_NET_IPVTI is not set
# CONFIG_NET_FOU is not set
# CONFIG_NET_FOU_IP_TUNNELS is not set
# CONFIG_INET_AH is not set
# CONFIG_INET_ESP is not set
# CONFIG_INET_IPCOMP is not set
CONFIG_INET_TUNNEL=y
CONFIG_INET_DIAG=y
CONFIG_INET_TCP_DIAG=y
# CONFIG_INET_UDP_DIAG is not set
# CONFIG_INET_RAW_DIAG is not set
# CONFIG_INET_DIAG_DESTROY is not set
# CONFIG_TCP_CONG_ADVANCED is not set
CONFIG_TCP_CONG_CUBIC=y
CONFIG_DEFAULT_TCP_CONG="cubic"
# CONFIG_TCP_MD5SIG is not set
CONFIG_IPV6=y
# CONFIG_IPV6_ROUTER_PREF is not set
# CONFIG_IPV6_OPTIMISTIC_DAD is not set
# CONFIG_INET6_AH is not set
# CONFIG_INET6_ESP is not set
# CONFIG_INET6_IPCOMP is not set
# CONFIG_IPV6_MIP6 is not set
# CONFIG_IPV6_VTI is not set
CONFIG_IPV6_SIT=y
# CONFIG_IPV6_SIT_6RD is not set
CONFIG_IPV6_NDISC_NODETYPE=y
# CONFIG_IPV6_TUNNEL is not set
# CONFIG_IPV6_MULTIPLE_TABLES is not set
# CONFIG_IPV6_MROUTE is not set
# CONFIG_IPV6_SEG6_LWTUNNEL is not set
# CONFIG_IPV6_SEG6_HMAC is not set
# CONFIG_IPV6_RPL_LWTUNNEL is not set
# CONFIG_IPV6_IOAM6_LWTUNNEL is not set
# CONFIG_MPTCP is not set
# CONFIG_NETWORK_SECMARK is not set
# CONFIG_NETWORK_PHY_TIMESTAMPING is not set
# CONFIG_NETFILTER is not set
# CONFIG_BPFILTER is not set
# CONFIG_IP_DCCP is not set
# CONFIG_IP_SCTP is not set
# CONFIG_RDS is not set
# CONFIG_TIPC is not set
# CONFIG_ATM is not set
# CONFIG_L2TP is not set
# CONFIG_BRIDGE is not set
# CONFIG_NET_DSA is not set
# CONFIG_VLAN_8021Q is not set
# CONFIG_DECNET is not set
# CONFIG_LLC2 is not set
# CONFIG_ATALK is not set
# CONFIG_X25 is not set
# CONFIG_LAPB is not set
# CONFIG_PHONET is not set
# CONFIG_6LOWPAN is not set
# CONFIG_IEEE802154 is not set
# CONFIG_NET_SCHED is not set
# CONFIG_DCB is not set
CONFIG_DNS_RESOLVER=y
# CONFIG_BATMAN_ADV is not set
# CONFIG_OPENVSWITCH is not set
# CONFIG_VSOCKETS is not set
CONFIG_NETLINK_DIAG=y
# CONFIG_MPLS is not set
# CONFIG_NET_NSH is not set
# CONFIG_HSR is not set
# CONFIG_NET_SWITCHDEV is not set
# CONFIG_NET_L3_MASTER_DEV is not set
# CONFIG_QRTR is not set
# CONFIG_NET_NCSI is not set
CONFIG_PCPU_DEV_REFCNT=y
CONFIG_RPS=y
CONFIG_RFS_ACCEL=y
CONFIG_SOCK_RX_QUEUE_MAPPING=y
CONFIG_XPS=y
# CONFIG_CGROUP_NET_PRIO is not set
# CONFIG_CGROUP_NET_CLASSID is not set
CONFIG_NET_RX_BUSY_POLL=y
CONFIG_BQL=y
# CONFIG_BPF_STREAM_PARSER is not set
CONFIG_NET_FLOW_LIMIT=y

#
# Network testing
#
# CONFIG_NET_PKTGEN is not set
# CONFIG_NET_DROP_MONITOR is not set
# end of Network testing
# end of Networking options

# CONFIG_HAMRADIO is not set
# CONFIG_CAN is not set
# CONFIG_BT is not set
# CONFIG_AF_RXRPC is not set
# CONFIG_AF_KCM is not set
# CONFIG_MCTP is not set
CONFIG_WIRELESS=y
# CONFIG_CFG80211 is not set

#
# CFG80211 needs to be enabled for MAC80211
#
CONFIG_MAC80211_STA_HASH_MAX_SIZE=0
# CONFIG_RFKILL is not set
CONFIG_NET_9P=y
CONFIG_NET_9P_FD=y
CONFIG_NET_9P_VIRTIO=y
# CONFIG_NET_9P_DEBUG is not set
# CONFIG_CAIF is not set
# CONFIG_CEPH_LIB is not set
# CONFIG_NFC is not set
# CONFIG_PSAMPLE is not set
# CONFIG_NET_IFE is not set
# CONFIG_LWTUNNEL is not set
CONFIG_DST_CACHE=y
CONFIG_GRO_CELLS=y
CONFIG_NET_SELFTESTS=y
CONFIG_NET_SOCK_MSG=y
CONFIG_PAGE_POOL=y
# CONFIG_PAGE_POOL_STATS is not set
CONFIG_FAILOVER=y
CONFIG_ETHTOOL_NETLINK=y

#
# Device Drivers
#
CONFIG_HAVE_PCI=y
CONFIG_PCI=y
CONFIG_PCI_DOMAINS=y
CONFIG_PCI_DOMAINS_GENERIC=y
CONFIG_PCIEPORTBUS=y
CONFIG_PCIEAER=y
# CONFIG_PCIEAER_INJECT is not set
# CONFIG_PCIE_ECRC is not set
CONFIG_PCIEASPM=y
CONFIG_PCIEASPM_DEFAULT=y
# CONFIG_PCIEASPM_POWERSAVE is not set
# CONFIG_PCIEASPM_POWER_SUPERSAVE is not set
# CONFIG_PCIEASPM_PERFORMANCE is not set
CONFIG_PCIE_PME=y
# CONFIG_PCIE_DPC is not set
# CONFIG_PCIE_PTM is not set
CONFIG_PCI_MSI=y
CONFIG_PCI_MSI_IRQ_DOMAIN=y
CONFIG_PCI_QUIRKS=y
# CONFIG_PCI_DEBUG is not set
# CONFIG_PCI_STUB is not set
CONFIG_PCI_ECAM=y
# CONFIG_PCI_IOV is not set
# CONFIG_PCI_PRI is not set
# CONFIG_PCI_PASID is not set
# CONFIG_PCIE_BUS_TUNE_OFF is not set
CONFIG_PCIE_BUS_DEFAULT=y
# CONFIG_PCIE_BUS_SAFE is not set
# CONFIG_PCIE_BUS_PERFORMANCE is not set
# CONFIG_PCIE_BUS_PEER2PEER is not set
CONFIG_VGA_ARB=y
CONFIG_VGA_ARB_MAX_GPUS=16
# CONFIG_HOTPLUG_PCI is not set

#
# PCI controller drivers
#
# CONFIG_PCI_FTPCI100 is not set
CONFIG_PCI_HOST_COMMON=y
CONFIG_PCI_HOST_GENERIC=y
CONFIG_PCIE_XILINX=y
# CONFIG_PCIE_MICROCHIP_HOST is not set

#
# DesignWare PCI Core Support
#
# CONFIG_PCIE_DW_PLAT_HOST is not set
# CONFIG_PCI_MESON is not set
# CONFIG_PCIE_FU740 is not set
# end of DesignWare PCI Core Support

#
# Mobiveil PCIe Core Support
#
# end of Mobiveil PCIe Core Support

#
# Cadence PCIe controllers support
#
# CONFIG_PCIE_CADENCE_PLAT_HOST is not set
# CONFIG_PCI_J721E_HOST is not set
# end of Cadence PCIe controllers support
# end of PCI controller drivers

#
# PCI Endpoint
#
# CONFIG_PCI_ENDPOINT is not set
# end of PCI Endpoint

#
# PCI switch controller drivers
#
# CONFIG_PCI_SW_SWITCHTEC is not set
# end of PCI switch controller drivers

# CONFIG_CXL_BUS is not set
# CONFIG_PCCARD is not set
# CONFIG_RAPIDIO is not set

#
# Generic Driver Options
#
# CONFIG_UEVENT_HELPER is not set
CONFIG_DEVTMPFS=y
CONFIG_DEVTMPFS_MOUNT=y
# CONFIG_DEVTMPFS_SAFE is not set
CONFIG_STANDALONE=y
CONFIG_PREVENT_FIRMWARE_BUILD=y

#
# Firmware loader
#
CONFIG_FW_LOADER=y
CONFIG_EXTRA_FIRMWARE=""
# CONFIG_FW_LOADER_USER_HELPER is not set
# CONFIG_FW_LOADER_COMPRESS is not set
# end of Firmware loader

CONFIG_ALLOW_DEV_COREDUMP=y
# CONFIG_DEBUG_DRIVER is not set
# CONFIG_DEBUG_DEVRES is not set
# CONFIG_DEBUG_TEST_DRIVER_REMOVE is not set
# CONFIG_TEST_ASYNC_DRIVER_PROBE is not set
CONFIG_REGMAP=y
CONFIG_REGMAP_MMIO=y
CONFIG_DMA_SHARED_BUFFER=y
# CONFIG_DMA_FENCE_TRACE is not set
CONFIG_GENERIC_ARCH_TOPOLOGY=y
# end of Generic Driver Options

#
# Bus devices
#
# CONFIG_MOXTET is not set
# CONFIG_MHI_BUS is not set
# end of Bus devices

# CONFIG_CONNECTOR is not set

#
# Firmware Drivers
#

#
# ARM System Control and Management Interface Protocol
#
# end of ARM System Control and Management Interface Protocol

CONFIG_FIRMWARE_MEMMAP=y
CONFIG_SYSFB=y
# CONFIG_SYSFB_SIMPLEFB is not set
# CONFIG_GOOGLE_FIRMWARE is not set

#
# EFI (Extensible Firmware Interface) Support
#
CONFIG_EFI_ESRT=y
CONFIG_EFI_PARAMS_FROM_FDT=y
CONFIG_EFI_RUNTIME_WRAPPERS=y
CONFIG_EFI_GENERIC_STUB=y
# CONFIG_EFI_BOOTLOADER_CONTROL is not set
# CONFIG_EFI_CAPSULE_LOADER is not set
# CONFIG_EFI_TEST is not set
# CONFIG_RESET_ATTACK_MITIGATION is not set
# CONFIG_EFI_DISABLE_PCI_DMA is not set
# end of EFI (Extensible Firmware Interface) Support

CONFIG_EFI_EARLYCON=y

#
# Tegra firmware driver
#
# end of Tegra firmware driver
# end of Firmware Drivers

# CONFIG_GNSS is not set
# CONFIG_MTD is not set
CONFIG_DTC=y
CONFIG_OF=y
# CONFIG_OF_UNITTEST is not set
CONFIG_OF_FLATTREE=y
CONFIG_OF_EARLY_FLATTREE=y
CONFIG_OF_KOBJ=y
CONFIG_OF_ADDRESS=y
CONFIG_OF_IRQ=y
CONFIG_OF_RESERVED_MEM=y
# CONFIG_OF_OVERLAY is not set
# CONFIG_PARPORT is not set
CONFIG_BLK_DEV=y
# CONFIG_BLK_DEV_NULL_BLK is not set
CONFIG_CDROM=y
# CONFIG_BLK_DEV_PCIESSD_MTIP32XX is not set
CONFIG_BLK_DEV_LOOP=y
CONFIG_BLK_DEV_LOOP_MIN_COUNT=8
# CONFIG_BLK_DEV_DRBD is not set
# CONFIG_BLK_DEV_NBD is not set
# CONFIG_BLK_DEV_SX8 is not set
# CONFIG_BLK_DEV_RAM is not set
# CONFIG_CDROM_PKTCDVD is not set
# CONFIG_ATA_OVER_ETH is not set
CONFIG_VIRTIO_BLK=y
# CONFIG_BLK_DEV_RBD is not set

#
# NVME Support
#
# CONFIG_BLK_DEV_NVME is not set
# CONFIG_NVME_FC is not set
# CONFIG_NVME_TCP is not set
# end of NVME Support

#
# Misc devices
#
# CONFIG_AD525X_DPOT is not set
# CONFIG_DUMMY_IRQ is not set
# CONFIG_PHANTOM is not set
# CONFIG_TIFM_CORE is not set
# CONFIG_ICS932S401 is not set
# CONFIG_ENCLOSURE_SERVICES is not set
# CONFIG_HP_ILO is not set
# CONFIG_APDS9802ALS is not set
# CONFIG_ISL29003 is not set
# CONFIG_ISL29020 is not set
# CONFIG_SENSORS_TSL2550 is not set
# CONFIG_SENSORS_BH1770 is not set
# CONFIG_SENSORS_APDS990X is not set
# CONFIG_HMC6352 is not set
# CONFIG_DS1682 is not set
# CONFIG_LATTICE_ECP3_CONFIG is not set
# CONFIG_SRAM is not set
# CONFIG_DW_XDATA_PCIE is not set
# CONFIG_PCI_ENDPOINT_TEST is not set
# CONFIG_XILINX_SDFEC is not set
# CONFIG_OPEN_DICE is not set
# CONFIG_C2PORT is not set

#
# EEPROM support
#
# CONFIG_EEPROM_AT24 is not set
# CONFIG_EEPROM_AT25 is not set
# CONFIG_EEPROM_LEGACY is not set
# CONFIG_EEPROM_MAX6875 is not set
# CONFIG_EEPROM_93CX6 is not set
# CONFIG_EEPROM_93XX46 is not set
# CONFIG_EEPROM_IDT_89HPESX is not set
# CONFIG_EEPROM_EE1004 is not set
# end of EEPROM support

# CONFIG_CB710_CORE is not set

#
# Texas Instruments shared transport line discipline
#
# end of Texas Instruments shared transport line discipline

# CONFIG_SENSORS_LIS3_SPI is not set
# CONFIG_SENSORS_LIS3_I2C is not set
# CONFIG_ALTERA_STAPL is not set
# CONFIG_GENWQE is not set
# CONFIG_ECHO is not set
# CONFIG_BCM_VK is not set
# CONFIG_MISC_ALCOR_PCI is not set
# CONFIG_MISC_RTSX_PCI is not set
# CONFIG_MISC_RTSX_USB is not set
# CONFIG_HABANA_AI is not set
# CONFIG_PVPANIC is not set
# end of Misc devices

#
# SCSI device support
#
CONFIG_SCSI_MOD=y
# CONFIG_RAID_ATTRS is not set
CONFIG_SCSI_COMMON=y
CONFIG_SCSI=y
CONFIG_SCSI_DMA=y
CONFIG_SCSI_PROC_FS=y

#
# SCSI support type (disk, tape, CD-ROM)
#
CONFIG_BLK_DEV_SD=y
# CONFIG_CHR_DEV_ST is not set
CONFIG_BLK_DEV_SR=y
# CONFIG_CHR_DEV_SG is not set
CONFIG_BLK_DEV_BSG=y
# CONFIG_CHR_DEV_SCH is not set
# CONFIG_SCSI_CONSTANTS is not set
# CONFIG_SCSI_LOGGING is not set
# CONFIG_SCSI_SCAN_ASYNC is not set

#
# SCSI Transports
#
# CONFIG_SCSI_SPI_ATTRS is not set
# CONFIG_SCSI_FC_ATTRS is not set
# CONFIG_SCSI_ISCSI_ATTRS is not set
# CONFIG_SCSI_SAS_ATTRS is not set
# CONFIG_SCSI_SAS_LIBSAS is not set
# CONFIG_SCSI_SRP_ATTRS is not set
# end of SCSI Transports

CONFIG_SCSI_LOWLEVEL=y
# CONFIG_ISCSI_TCP is not set
# CONFIG_ISCSI_BOOT_SYSFS is not set
# CONFIG_SCSI_CXGB3_ISCSI is not set
# CONFIG_SCSI_CXGB4_ISCSI is not set
# CONFIG_SCSI_BNX2_ISCSI is not set
# CONFIG_BE2ISCSI is not set
# CONFIG_BLK_DEV_3W_XXXX_RAID is not set
# CONFIG_SCSI_HPSA is not set
# CONFIG_SCSI_3W_9XXX is not set
# CONFIG_SCSI_3W_SAS is not set
# CONFIG_SCSI_ACARD is not set
# CONFIG_SCSI_AACRAID is not set
# CONFIG_SCSI_AIC7XXX is not set
# CONFIG_SCSI_AIC79XX is not set
# CONFIG_SCSI_AIC94XX is not set
# CONFIG_SCSI_MVSAS is not set
# CONFIG_SCSI_MVUMI is not set
# CONFIG_SCSI_ADVANSYS is not set
# CONFIG_SCSI_ARCMSR is not set
# CONFIG_SCSI_ESAS2R is not set
# CONFIG_MEGARAID_NEWGEN is not set
# CONFIG_MEGARAID_LEGACY is not set
# CONFIG_MEGARAID_SAS is not set
# CONFIG_SCSI_MPT3SAS is not set
# CONFIG_SCSI_MPT2SAS is not set
# CONFIG_SCSI_MPI3MR is not set
# CONFIG_SCSI_SMARTPQI is not set
# CONFIG_SCSI_UFSHCD is not set
# CONFIG_SCSI_HPTIOP is not set
# CONFIG_SCSI_MYRB is not set
# CONFIG_SCSI_MYRS is not set
# CONFIG_SCSI_SNIC is not set
# CONFIG_SCSI_DMX3191D is not set
# CONFIG_SCSI_FDOMAIN_PCI is not set
# CONFIG_SCSI_IPS is not set
# CONFIG_SCSI_INITIO is not set
# CONFIG_SCSI_INIA100 is not set
# CONFIG_SCSI_STEX is not set
# CONFIG_SCSI_SYM53C8XX_2 is not set
# CONFIG_SCSI_IPR is not set
# CONFIG_SCSI_QLOGIC_1280 is not set
# CONFIG_SCSI_QLA_ISCSI is not set
# CONFIG_SCSI_DC395x is not set
# CONFIG_SCSI_AM53C974 is not set
# CONFIG_SCSI_WD719X is not set
# CONFIG_SCSI_DEBUG is not set
# CONFIG_SCSI_PMCRAID is not set
# CONFIG_SCSI_PM8001 is not set
CONFIG_SCSI_VIRTIO=y
# CONFIG_SCSI_DH is not set
# end of SCSI device support

CONFIG_ATA=y
CONFIG_SATA_HOST=y
CONFIG_ATA_VERBOSE_ERROR=y
CONFIG_ATA_FORCE=y
CONFIG_SATA_PMP=y

#
# Controllers with non-SFF native interface
#
CONFIG_SATA_AHCI=y
CONFIG_SATA_MOBILE_LPM_POLICY=0
CONFIG_SATA_AHCI_PLATFORM=y
# CONFIG_AHCI_CEVA is not set
# CONFIG_AHCI_QORIQ is not set
# CONFIG_SATA_INIC162X is not set
# CONFIG_SATA_ACARD_AHCI is not set
# CONFIG_SATA_SIL24 is not set
CONFIG_ATA_SFF=y

#
# SFF controllers with custom DMA interface
#
# CONFIG_PDC_ADMA is not set
# CONFIG_SATA_QSTOR is not set
# CONFIG_SATA_SX4 is not set
CONFIG_ATA_BMDMA=y

#
# SATA SFF controllers with BMDMA
#
# CONFIG_ATA_PIIX is not set
# CONFIG_SATA_MV is not set
# CONFIG_SATA_NV is not set
# CONFIG_SATA_PROMISE is not set
# CONFIG_SATA_SIL is not set
# CONFIG_SATA_SIS is not set
# CONFIG_SATA_SVW is not set
# CONFIG_SATA_ULI is not set
# CONFIG_SATA_VIA is not set
# CONFIG_SATA_VITESSE is not set

#
# PATA SFF controllers with BMDMA
#
# CONFIG_PATA_ALI is not set
# CONFIG_PATA_AMD is not set
# CONFIG_PATA_ARTOP is not set
# CONFIG_PATA_ATIIXP is not set
# CONFIG_PATA_ATP867X is not set
# CONFIG_PATA_CMD64X is not set
# CONFIG_PATA_CYPRESS is not set
# CONFIG_PATA_EFAR is not set
# CONFIG_PATA_HPT366 is not set
# CONFIG_PATA_HPT37X is not set
# CONFIG_PATA_HPT3X2N is not set
# CONFIG_PATA_HPT3X3 is not set
# CONFIG_PATA_IT8213 is not set
# CONFIG_PATA_IT821X is not set
# CONFIG_PATA_JMICRON is not set
# CONFIG_PATA_MARVELL is not set
# CONFIG_PATA_NETCELL is not set
# CONFIG_PATA_NINJA32 is not set
# CONFIG_PATA_NS87415 is not set
# CONFIG_PATA_OLDPIIX is not set
# CONFIG_PATA_OPTIDMA is not set
# CONFIG_PATA_PDC2027X is not set
# CONFIG_PATA_PDC_OLD is not set
# CONFIG_PATA_RADISYS is not set
# CONFIG_PATA_RDC is not set
# CONFIG_PATA_SCH is not set
# CONFIG_PATA_SERVERWORKS is not set
# CONFIG_PATA_SIL680 is not set
# CONFIG_PATA_SIS is not set
# CONFIG_PATA_TOSHIBA is not set
# CONFIG_PATA_TRIFLEX is not set
# CONFIG_PATA_VIA is not set
# CONFIG_PATA_WINBOND is not set

#
# PIO-only SFF controllers
#
# CONFIG_PATA_CMD640_PCI is not set
# CONFIG_PATA_MPIIX is not set
# CONFIG_PATA_NS87410 is not set
# CONFIG_PATA_OPTI is not set
# CONFIG_PATA_PLATFORM is not set
# CONFIG_PATA_RZ1000 is not set

#
# Generic fallback / legacy drivers
#
# CONFIG_ATA_GENERIC is not set
# CONFIG_PATA_LEGACY is not set
# CONFIG_MD is not set
# CONFIG_TARGET_CORE is not set
# CONFIG_FUSION is not set

#
# IEEE 1394 (FireWire) support
#
# CONFIG_FIREWIRE is not set
# CONFIG_FIREWIRE_NOSY is not set
# end of IEEE 1394 (FireWire) support

CONFIG_NETDEVICES=y
CONFIG_NET_CORE=y
# CONFIG_BONDING is not set
# CONFIG_DUMMY is not set
# CONFIG_WIREGUARD is not set
# CONFIG_EQUALIZER is not set
# CONFIG_NET_FC is not set
# CONFIG_NET_TEAM is not set
# CONFIG_MACVLAN is not set
# CONFIG_IPVLAN is not set
# CONFIG_VXLAN is not set
# CONFIG_GENEVE is not set
# CONFIG_BAREUDP is not set
# CONFIG_GTP is not set
# CONFIG_AMT is not set
# CONFIG_MACSEC is not set
# CONFIG_NETCONSOLE is not set
# CONFIG_TUN is not set
# CONFIG_TUN_VNET_CROSS_LE is not set
# CONFIG_VETH is not set
CONFIG_VIRTIO_NET=y
# CONFIG_NLMON is not set
# CONFIG_ARCNET is not set
CONFIG_ETHERNET=y
CONFIG_NET_VENDOR_3COM=y
# CONFIG_VORTEX is not set
# CONFIG_TYPHOON is not set
CONFIG_NET_VENDOR_ADAPTEC=y
# CONFIG_ADAPTEC_STARFIRE is not set
CONFIG_NET_VENDOR_AGERE=y
# CONFIG_ET131X is not set
CONFIG_NET_VENDOR_ALACRITECH=y
# CONFIG_SLICOSS is not set
CONFIG_NET_VENDOR_ALTEON=y
# CONFIG_ACENIC is not set
# CONFIG_ALTERA_TSE is not set
CONFIG_NET_VENDOR_AMAZON=y
# CONFIG_ENA_ETHERNET is not set
CONFIG_NET_VENDOR_AMD=y
# CONFIG_AMD8111_ETH is not set
# CONFIG_PCNET32 is not set
CONFIG_NET_VENDOR_AQUANTIA=y
# CONFIG_AQTION is not set
CONFIG_NET_VENDOR_ARC=y
CONFIG_NET_VENDOR_ASIX=y
CONFIG_NET_VENDOR_ATHEROS=y
# CONFIG_ATL2 is not set
# CONFIG_ATL1 is not set
# CONFIG_ATL1E is not set
# CONFIG_ATL1C is not set
# CONFIG_ALX is not set
CONFIG_NET_VENDOR_BROADCOM=y
# CONFIG_B44 is not set
# CONFIG_BCMGENET is not set
# CONFIG_BNX2 is not set
# CONFIG_CNIC is not set
# CONFIG_TIGON3 is not set
# CONFIG_BNX2X is not set
# CONFIG_SYSTEMPORT is not set
# CONFIG_BNXT is not set
CONFIG_NET_VENDOR_CADENCE=y
CONFIG_MACB=y
# CONFIG_MACB_PCI is not set
CONFIG_NET_VENDOR_CAVIUM=y
# CONFIG_THUNDER_NIC_PF is not set
# CONFIG_THUNDER_NIC_VF is not set
# CONFIG_THUNDER_NIC_BGX is not set
# CONFIG_THUNDER_NIC_RGX is not set
# CONFIG_LIQUIDIO is not set
# CONFIG_LIQUIDIO_VF is not set
CONFIG_NET_VENDOR_CHELSIO=y
# CONFIG_CHELSIO_T1 is not set
# CONFIG_CHELSIO_T3 is not set
# CONFIG_CHELSIO_T4 is not set
# CONFIG_CHELSIO_T4VF is not set
CONFIG_NET_VENDOR_CISCO=y
# CONFIG_ENIC is not set
CONFIG_NET_VENDOR_CORTINA=y
# CONFIG_GEMINI_ETHERNET is not set
CONFIG_NET_VENDOR_DAVICOM=y
# CONFIG_DM9051 is not set
# CONFIG_DNET is not set
CONFIG_NET_VENDOR_DEC=y
# CONFIG_NET_TULIP is not set
CONFIG_NET_VENDOR_DLINK=y
# CONFIG_DL2K is not set
# CONFIG_SUNDANCE is not set
CONFIG_NET_VENDOR_EMULEX=y
# CONFIG_BE2NET is not set
CONFIG_NET_VENDOR_ENGLEDER=y
# CONFIG_TSNEP is not set
CONFIG_NET_VENDOR_EZCHIP=y
# CONFIG_EZCHIP_NPS_MANAGEMENT_ENET is not set
CONFIG_NET_VENDOR_FUNGIBLE=y
# CONFIG_FUN_ETH is not set
CONFIG_NET_VENDOR_GOOGLE=y
CONFIG_NET_VENDOR_HUAWEI=y
CONFIG_NET_VENDOR_I825XX=y
CONFIG_NET_VENDOR_INTEL=y
# CONFIG_E100 is not set
# CONFIG_E1000 is not set
CONFIG_E1000E=y
# CONFIG_IGB is not set
# CONFIG_IGBVF is not set
# CONFIG_IXGB is not set
# CONFIG_IXGBE is not set
# CONFIG_IXGBEVF is not set
# CONFIG_I40E is not set
# CONFIG_I40EVF is not set
# CONFIG_ICE is not set
# CONFIG_FM10K is not set
# CONFIG_IGC is not set
# CONFIG_JME is not set
CONFIG_NET_VENDOR_LITEX=y
# CONFIG_LITEX_LITEETH is not set
CONFIG_NET_VENDOR_MARVELL=y
# CONFIG_MVMDIO is not set
# CONFIG_SKGE is not set
# CONFIG_SKY2 is not set
CONFIG_NET_VENDOR_MELLANOX=y
# CONFIG_MLX4_EN is not set
# CONFIG_MLX5_CORE is not set
# CONFIG_MLXSW_CORE is not set
# CONFIG_MLXFW is not set
CONFIG_NET_VENDOR_MICREL=y
# CONFIG_KS8851 is not set
# CONFIG_KS8851_MLL is not set
# CONFIG_KSZ884X_PCI is not set
CONFIG_NET_VENDOR_MICROCHIP=y
# CONFIG_ENC28J60 is not set
# CONFIG_ENCX24J600 is not set
# CONFIG_LAN743X is not set
CONFIG_NET_VENDOR_MICROSEMI=y
CONFIG_NET_VENDOR_MICROSOFT=y
CONFIG_NET_VENDOR_MYRI=y
# CONFIG_MYRI10GE is not set
# CONFIG_FEALNX is not set
CONFIG_NET_VENDOR_NI=y
# CONFIG_NI_XGE_MANAGEMENT_ENET is not set
CONFIG_NET_VENDOR_NATSEMI=y
# CONFIG_NATSEMI is not set
# CONFIG_NS83820 is not set
CONFIG_NET_VENDOR_NETERION=y
# CONFIG_S2IO is not set
# CONFIG_VXGE is not set
CONFIG_NET_VENDOR_NETRONOME=y
# CONFIG_NFP is not set
CONFIG_NET_VENDOR_8390=y
# CONFIG_NE2K_PCI is not set
CONFIG_NET_VENDOR_NVIDIA=y
# CONFIG_FORCEDETH is not set
CONFIG_NET_VENDOR_OKI=y
# CONFIG_ETHOC is not set
CONFIG_NET_VENDOR_PACKET_ENGINES=y
# CONFIG_HAMACHI is not set
# CONFIG_YELLOWFIN is not set
CONFIG_NET_VENDOR_PENSANDO=y
# CONFIG_IONIC is not set
CONFIG_NET_VENDOR_QLOGIC=y
# CONFIG_QLA3XXX is not set
# CONFIG_QLCNIC is not set
# CONFIG_NETXEN_NIC is not set
# CONFIG_QED is not set
CONFIG_NET_VENDOR_BROCADE=y
# CONFIG_BNA is not set
CONFIG_NET_VENDOR_QUALCOMM=y
# CONFIG_QCA7000_SPI is not set
# CONFIG_QCOM_EMAC is not set
# CONFIG_RMNET is not set
CONFIG_NET_VENDOR_RDC=y
# CONFIG_R6040 is not set
CONFIG_NET_VENDOR_REALTEK=y
# CONFIG_8139CP is not set
# CONFIG_8139TOO is not set
CONFIG_R8169=y
CONFIG_NET_VENDOR_RENESAS=y
CONFIG_NET_VENDOR_ROCKER=y
CONFIG_NET_VENDOR_SAMSUNG=y
# CONFIG_SXGBE_ETH is not set
CONFIG_NET_VENDOR_SEEQ=y
CONFIG_NET_VENDOR_SILAN=y
# CONFIG_SC92031 is not set
CONFIG_NET_VENDOR_SIS=y
# CONFIG_SIS900 is not set
# CONFIG_SIS190 is not set
CONFIG_NET_VENDOR_SOLARFLARE=y
# CONFIG_SFC is not set
# CONFIG_SFC_FALCON is not set
CONFIG_NET_VENDOR_SMSC=y
# CONFIG_EPIC100 is not set
# CONFIG_SMSC911X is not set
# CONFIG_SMSC9420 is not set
CONFIG_NET_VENDOR_SOCIONEXT=y
CONFIG_NET_VENDOR_STMICRO=y
# CONFIG_STMMAC_ETH is not set
CONFIG_NET_VENDOR_SUN=y
# CONFIG_HAPPYMEAL is not set
# CONFIG_SUNGEM is not set
# CONFIG_CASSINI is not set
# CONFIG_NIU is not set
CONFIG_NET_VENDOR_SYNOPSYS=y
# CONFIG_DWC_XLGMAC is not set
CONFIG_NET_VENDOR_TEHUTI=y
# CONFIG_TEHUTI is not set
CONFIG_NET_VENDOR_TI=y
# CONFIG_TI_CPSW_PHY_SEL is not set
# CONFIG_TLAN is not set
# CONFIG_NET_VENDOR_VERTEXCOM is not set
CONFIG_NET_VENDOR_VIA=y
# CONFIG_VIA_RHINE is not set
# CONFIG_VIA_VELOCITY is not set
CONFIG_NET_VENDOR_WIZNET=y
# CONFIG_WIZNET_W5100 is not set
# CONFIG_WIZNET_W5300 is not set
CONFIG_NET_VENDOR_XILINX=y
# CONFIG_XILINX_EMACLITE is not set
# CONFIG_XILINX_AXI_EMAC is not set
# CONFIG_XILINX_LL_TEMAC is not set
# CONFIG_FDDI is not set
# CONFIG_HIPPI is not set
CONFIG_PHYLINK=y
CONFIG_PHYLIB=y
CONFIG_SWPHY=y
CONFIG_FIXED_PHY=y
# CONFIG_SFP is not set

#
# MII PHY device drivers
#
# CONFIG_AMD_PHY is not set
# CONFIG_ADIN_PHY is not set
# CONFIG_AQUANTIA_PHY is not set
# CONFIG_AX88796B_PHY is not set
# CONFIG_BROADCOM_PHY is not set
# CONFIG_BCM54140_PHY is not set
# CONFIG_BCM7XXX_PHY is not set
# CONFIG_BCM84881_PHY is not set
# CONFIG_BCM87XX_PHY is not set
# CONFIG_CICADA_PHY is not set
# CONFIG_CORTINA_PHY is not set
# CONFIG_DAVICOM_PHY is not set
# CONFIG_ICPLUS_PHY is not set
# CONFIG_LXT_PHY is not set
# CONFIG_INTEL_XWAY_PHY is not set
# CONFIG_LSI_ET1011C_PHY is not set
# CONFIG_MARVELL_PHY is not set
# CONFIG_MARVELL_10G_PHY is not set
# CONFIG_MARVELL_88X2222_PHY is not set
# CONFIG_MAXLINEAR_GPHY is not set
# CONFIG_MEDIATEK_GE_PHY is not set
# CONFIG_MICREL_PHY is not set
# CONFIG_MICROCHIP_PHY is not set
# CONFIG_MICROCHIP_T1_PHY is not set
CONFIG_MICROSEMI_PHY=y
# CONFIG_MOTORCOMM_PHY is not set
# CONFIG_NATIONAL_PHY is not set
# CONFIG_NXP_C45_TJA11XX_PHY is not set
# CONFIG_NXP_TJA11XX_PHY is not set
# CONFIG_QSEMI_PHY is not set
CONFIG_REALTEK_PHY=y
# CONFIG_RENESAS_PHY is not set
# CONFIG_ROCKCHIP_PHY is not set
# CONFIG_SMSC_PHY is not set
# CONFIG_STE10XP is not set
# CONFIG_TERANETICS_PHY is not set
# CONFIG_DP83822_PHY is not set
# CONFIG_DP83TC811_PHY is not set
# CONFIG_DP83848_PHY is not set
# CONFIG_DP83867_PHY is not set
# CONFIG_DP83869_PHY is not set
# CONFIG_VITESSE_PHY is not set
# CONFIG_XILINX_GMII2RGMII is not set
# CONFIG_MICREL_KS8995MA is not set
CONFIG_MDIO_DEVICE=y
CONFIG_MDIO_BUS=y
CONFIG_FWNODE_MDIO=y
CONFIG_OF_MDIO=y
CONFIG_MDIO_DEVRES=y
# CONFIG_MDIO_BITBANG is not set
# CONFIG_MDIO_BCM_UNIMAC is not set
# CONFIG_MDIO_HISI_FEMAC is not set
# CONFIG_MDIO_MVUSB is not set
# CONFIG_MDIO_MSCC_MIIM is not set
# CONFIG_MDIO_OCTEON is not set
# CONFIG_MDIO_IPQ4019 is not set
# CONFIG_MDIO_IPQ8064 is not set
# CONFIG_MDIO_THUNDER is not set

#
# MDIO Multiplexers
#
# CONFIG_MDIO_BUS_MUX_MULTIPLEXER is not set
# CONFIG_MDIO_BUS_MUX_MMIOREG is not set

#
# PCS device drivers
#
# CONFIG_PCS_XPCS is not set
# end of PCS device drivers

# CONFIG_PPP is not set
# CONFIG_SLIP is not set
# CONFIG_USB_NET_DRIVERS is not set
# CONFIG_WLAN is not set
# CONFIG_WAN is not set

#
# Wireless WAN
#
# CONFIG_WWAN is not set
# end of Wireless WAN

# CONFIG_VMXNET3 is not set
# CONFIG_NETDEVSIM is not set
CONFIG_NET_FAILOVER=y
# CONFIG_ISDN is not set

#
# Input device support
#
CONFIG_INPUT=y
# CONFIG_INPUT_FF_MEMLESS is not set
# CONFIG_INPUT_SPARSEKMAP is not set
# CONFIG_INPUT_MATRIXKMAP is not set
CONFIG_INPUT_VIVALDIFMAP=y

#
# Userland interfaces
#
CONFIG_INPUT_MOUSEDEV=y
# CONFIG_INPUT_MOUSEDEV_PSAUX is not set
CONFIG_INPUT_MOUSEDEV_SCREEN_X=1024
CONFIG_INPUT_MOUSEDEV_SCREEN_Y=768
# CONFIG_INPUT_JOYDEV is not set
# CONFIG_INPUT_EVDEV is not set
# CONFIG_INPUT_EVBUG is not set

#
# Input Device Drivers
#
CONFIG_INPUT_KEYBOARD=y
# CONFIG_KEYBOARD_ADP5588 is not set
# CONFIG_KEYBOARD_ADP5589 is not set
CONFIG_KEYBOARD_ATKBD=y
# CONFIG_KEYBOARD_QT1050 is not set
# CONFIG_KEYBOARD_QT1070 is not set
# CONFIG_KEYBOARD_QT2160 is not set
# CONFIG_KEYBOARD_DLINK_DIR685 is not set
# CONFIG_KEYBOARD_LKKBD is not set
# CONFIG_KEYBOARD_TCA6416 is not set
# CONFIG_KEYBOARD_TCA8418 is not set
# CONFIG_KEYBOARD_LM8333 is not set
# CONFIG_KEYBOARD_MAX7359 is not set
# CONFIG_KEYBOARD_MCS is not set
# CONFIG_KEYBOARD_MPR121 is not set
# CONFIG_KEYBOARD_NEWTON is not set
# CONFIG_KEYBOARD_OPENCORES is not set
# CONFIG_KEYBOARD_SAMSUNG is not set
# CONFIG_KEYBOARD_GOLDFISH_EVENTS is not set
# CONFIG_KEYBOARD_STOWAWAY is not set
# CONFIG_KEYBOARD_SUNKBD is not set
# CONFIG_KEYBOARD_OMAP4 is not set
# CONFIG_KEYBOARD_XTKBD is not set
# CONFIG_KEYBOARD_CAP11XX is not set
# CONFIG_KEYBOARD_BCM is not set
# CONFIG_KEYBOARD_CYPRESS_SF is not set
CONFIG_INPUT_MOUSE=y
CONFIG_MOUSE_PS2=y
CONFIG_MOUSE_PS2_ALPS=y
CONFIG_MOUSE_PS2_BYD=y
CONFIG_MOUSE_PS2_LOGIPS2PP=y
CONFIG_MOUSE_PS2_SYNAPTICS=y
CONFIG_MOUSE_PS2_SYNAPTICS_SMBUS=y
CONFIG_MOUSE_PS2_CYPRESS=y
CONFIG_MOUSE_PS2_TRACKPOINT=y
# CONFIG_MOUSE_PS2_ELANTECH is not set
# CONFIG_MOUSE_PS2_SENTELIC is not set
# CONFIG_MOUSE_PS2_TOUCHKIT is not set
CONFIG_MOUSE_PS2_FOCALTECH=y
CONFIG_MOUSE_PS2_SMBUS=y
# CONFIG_MOUSE_SERIAL is not set
# CONFIG_MOUSE_APPLETOUCH is not set
# CONFIG_MOUSE_BCM5974 is not set
# CONFIG_MOUSE_CYAPA is not set
# CONFIG_MOUSE_ELAN_I2C is not set
# CONFIG_MOUSE_VSXXXAA is not set
# CONFIG_MOUSE_SYNAPTICS_I2C is not set
# CONFIG_MOUSE_SYNAPTICS_USB is not set
# CONFIG_INPUT_JOYSTICK is not set
# CONFIG_INPUT_TABLET is not set
# CONFIG_INPUT_TOUCHSCREEN is not set
# CONFIG_INPUT_MISC is not set
# CONFIG_RMI4_CORE is not set

#
# Hardware I/O ports
#
CONFIG_SERIO=y
CONFIG_SERIO_SERPORT=y
# CONFIG_SERIO_PCIPS2 is not set
CONFIG_SERIO_LIBPS2=y
# CONFIG_SERIO_RAW is not set
# CONFIG_SERIO_ALTERA_PS2 is not set
# CONFIG_SERIO_PS2MULT is not set
# CONFIG_SERIO_ARC_PS2 is not set
# CONFIG_SERIO_APBPS2 is not set
# CONFIG_USERIO is not set
# CONFIG_GAMEPORT is not set
# end of Hardware I/O ports
# end of Input device support

#
# Character devices
#
CONFIG_TTY=y
CONFIG_VT=y
CONFIG_CONSOLE_TRANSLATIONS=y
CONFIG_VT_CONSOLE=y
CONFIG_HW_CONSOLE=y
CONFIG_VT_HW_CONSOLE_BINDING=y
CONFIG_UNIX98_PTYS=y
CONFIG_LEGACY_PTYS=y
CONFIG_LEGACY_PTY_COUNT=256
CONFIG_LDISC_AUTOLOAD=y

#
# Serial drivers
#
CONFIG_SERIAL_EARLYCON=y
CONFIG_SERIAL_8250=y
CONFIG_SERIAL_8250_DEPRECATED_OPTIONS=y
# CONFIG_SERIAL_8250_16550A_VARIANTS is not set
# CONFIG_SERIAL_8250_FINTEK is not set
CONFIG_SERIAL_8250_CONSOLE=y
CONFIG_SERIAL_8250_PCI=y
CONFIG_SERIAL_8250_EXAR=y
CONFIG_SERIAL_8250_NR_UARTS=4
CONFIG_SERIAL_8250_RUNTIME_UARTS=4
# CONFIG_SERIAL_8250_EXTENDED is not set
# CONFIG_SERIAL_8250_ASPEED_VUART is not set
# CONFIG_SERIAL_8250_DW is not set
# CONFIG_SERIAL_8250_RT288X is not set
CONFIG_SERIAL_8250_PERICOM=y
CONFIG_SERIAL_OF_PLATFORM=y

#
# Non-8250 serial port support
#
CONFIG_SERIAL_EARLYCON_RISCV_SBI=y
# CONFIG_SERIAL_MAX3100 is not set
# CONFIG_SERIAL_MAX310X is not set
# CONFIG_SERIAL_UARTLITE is not set
CONFIG_SERIAL_CORE=y
CONFIG_SERIAL_CORE_CONSOLE=y
# CONFIG_SERIAL_JSM is not set
CONFIG_SERIAL_SIFIVE=y
CONFIG_SERIAL_SIFIVE_CONSOLE=y
# CONFIG_SERIAL_SCCNXP is not set
# CONFIG_SERIAL_SC16IS7XX is not set
# CONFIG_SERIAL_ALTERA_JTAGUART is not set
# CONFIG_SERIAL_ALTERA_UART is not set
# CONFIG_SERIAL_XILINX_PS_UART is not set
# CONFIG_SERIAL_ARC is not set
# CONFIG_SERIAL_RP2 is not set
# CONFIG_SERIAL_FSL_LPUART is not set
# CONFIG_SERIAL_FSL_LINFLEXUART is not set
# CONFIG_SERIAL_CONEXANT_DIGICOLOR is not set
# CONFIG_SERIAL_SPRD is not set
# end of Serial drivers

# CONFIG_SERIAL_NONSTANDARD is not set
# CONFIG_GOLDFISH_TTY is not set
# CONFIG_N_GSM is not set
# CONFIG_NOZOMI is not set
# CONFIG_NULL_TTY is not set
CONFIG_HVC_DRIVER=y
CONFIG_HVC_RISCV_SBI=y
# CONFIG_RPMSG_TTY is not set
# CONFIG_SERIAL_DEV_BUS is not set
# CONFIG_TTY_PRINTK is not set
CONFIG_VIRTIO_CONSOLE=y
# CONFIG_IPMI_HANDLER is not set
CONFIG_HW_RANDOM=y
# CONFIG_HW_RANDOM_TIMERIOMEM is not set
# CONFIG_HW_RANDOM_BA431 is not set
CONFIG_HW_RANDOM_VIRTIO=y
# CONFIG_HW_RANDOM_CCTRNG is not set
# CONFIG_HW_RANDOM_XIPHERA is not set
# CONFIG_APPLICOM is not set
CONFIG_DEVMEM=y
CONFIG_DEVPORT=y
# CONFIG_TCG_TPM is not set
# CONFIG_XILLYBUS is not set
# CONFIG_XILLYUSB is not set
# CONFIG_RANDOM_TRUST_BOOTLOADER is not set
# end of Character devices

#
# I2C support
#
CONFIG_I2C=y
CONFIG_I2C_BOARDINFO=y
CONFIG_I2C_COMPAT=y
# CONFIG_I2C_CHARDEV is not set
# CONFIG_I2C_MUX is not set
CONFIG_I2C_HELPER_AUTO=y
CONFIG_I2C_ALGOBIT=y

#
# I2C Hardware Bus support
#

#
# PC SMBus host controller drivers
#
# CONFIG_I2C_ALI1535 is not set
# CONFIG_I2C_ALI1563 is not set
# CONFIG_I2C_ALI15X3 is not set
# CONFIG_I2C_AMD756 is not set
# CONFIG_I2C_AMD8111 is not set
# CONFIG_I2C_I801 is not set
# CONFIG_I2C_ISCH is not set
# CONFIG_I2C_PIIX4 is not set
# CONFIG_I2C_NFORCE2 is not set
# CONFIG_I2C_NVIDIA_GPU is not set
# CONFIG_I2C_SIS5595 is not set
# CONFIG_I2C_SIS630 is not set
# CONFIG_I2C_SIS96X is not set
# CONFIG_I2C_VIA is not set
# CONFIG_I2C_VIAPRO is not set

#
# I2C system bus drivers (mostly embedded / system-on-chip)
#
# CONFIG_I2C_DESIGNWARE_PLATFORM is not set
# CONFIG_I2C_DESIGNWARE_PCI is not set
# CONFIG_I2C_EMEV2 is not set
# CONFIG_I2C_OCORES is not set
# CONFIG_I2C_PCA_PLATFORM is not set
# CONFIG_I2C_RK3X is not set
# CONFIG_I2C_SIMTEC is not set
# CONFIG_I2C_XILINX is not set

#
# External I2C/SMBus adapter drivers
#
# CONFIG_I2C_DIOLAN_U2C is not set
# CONFIG_I2C_CP2615 is not set
# CONFIG_I2C_ROBOTFUZZ_OSIF is not set
# CONFIG_I2C_TAOS_EVM is not set
# CONFIG_I2C_TINY_USB is not set

#
# Other I2C/SMBus bus drivers
#
# CONFIG_I2C_VIRTIO is not set
# end of I2C Hardware Bus support

# CONFIG_I2C_STUB is not set
# CONFIG_I2C_SLAVE is not set
# CONFIG_I2C_DEBUG_CORE is not set
# CONFIG_I2C_DEBUG_ALGO is not set
# CONFIG_I2C_DEBUG_BUS is not set
# end of I2C support

# CONFIG_I3C is not set
CONFIG_SPI=y
# CONFIG_SPI_DEBUG is not set
CONFIG_SPI_MASTER=y
# CONFIG_SPI_MEM is not set

#
# SPI Master Controller Drivers
#
# CONFIG_SPI_ALTERA is not set
# CONFIG_SPI_AXI_SPI_ENGINE is not set
# CONFIG_SPI_BITBANG is not set
# CONFIG_SPI_CADENCE is not set
# CONFIG_SPI_DESIGNWARE is not set
# CONFIG_SPI_NXP_FLEXSPI is not set
# CONFIG_SPI_FSL_SPI is not set
# CONFIG_SPI_PXA2XX is not set
# CONFIG_SPI_ROCKCHIP is not set
# CONFIG_SPI_SC18IS602 is not set
CONFIG_SPI_SIFIVE=y
# CONFIG_SPI_MXIC is not set
# CONFIG_SPI_XCOMM is not set
# CONFIG_SPI_XILINX is not set
# CONFIG_SPI_ZYNQMP_GQSPI is not set
# CONFIG_SPI_AMD is not set

#
# SPI Multiplexer support
#
# CONFIG_SPI_MUX is not set

#
# SPI Protocol Masters
#
# CONFIG_SPI_SPIDEV is not set
# CONFIG_SPI_LOOPBACK_TEST is not set
# CONFIG_SPI_TLE62X0 is not set
# CONFIG_SPI_SLAVE is not set
# CONFIG_SPMI is not set
# CONFIG_HSI is not set
# CONFIG_PPS is not set

#
# PTP clock support
#
# CONFIG_PTP_1588_CLOCK is not set
CONFIG_PTP_1588_CLOCK_OPTIONAL=y

#
# Enable PHYLIB and NETWORK_PHY_TIMESTAMPING to see the additional clocks.
#
# end of PTP clock support

# CONFIG_PINCTRL is not set
# CONFIG_GPIOLIB is not set
# CONFIG_W1 is not set
CONFIG_POWER_RESET=y
# CONFIG_POWER_RESET_RESTART is not set
CONFIG_POWER_RESET_SYSCON=y
CONFIG_POWER_RESET_SYSCON_POWEROFF=y
# CONFIG_SYSCON_REBOOT_MODE is not set
# CONFIG_NVMEM_REBOOT_MODE is not set
CONFIG_POWER_SUPPLY=y
# CONFIG_POWER_SUPPLY_DEBUG is not set
CONFIG_POWER_SUPPLY_HWMON=y
# CONFIG_PDA_POWER is not set
# CONFIG_IP5XXX_POWER is not set
# CONFIG_TEST_POWER is not set
# CONFIG_CHARGER_ADP5061 is not set
# CONFIG_BATTERY_CW2015 is not set
# CONFIG_BATTERY_DS2780 is not set
# CONFIG_BATTERY_DS2781 is not set
# CONFIG_BATTERY_DS2782 is not set
# CONFIG_BATTERY_SAMSUNG_SDI is not set
# CONFIG_BATTERY_SBS is not set
# CONFIG_CHARGER_SBS is not set
# CONFIG_BATTERY_BQ27XXX is not set
# CONFIG_BATTERY_MAX17040 is not set
# CONFIG_BATTERY_MAX17042 is not set
# CONFIG_CHARGER_MAX8903 is not set
# CONFIG_CHARGER_LP8727 is not set
# CONFIG_CHARGER_LTC4162L is not set
# CONFIG_CHARGER_DETECTOR_MAX14656 is not set
# CONFIG_CHARGER_MAX77976 is not set
# CONFIG_CHARGER_BQ2415X is not set
# CONFIG_BATTERY_GAUGE_LTC2941 is not set
# CONFIG_BATTERY_GOLDFISH is not set
# CONFIG_BATTERY_RT5033 is not set
# CONFIG_CHARGER_BD99954 is not set
# CONFIG_BATTERY_UG3105 is not set
CONFIG_HWMON=y
# CONFIG_HWMON_DEBUG_CHIP is not set

#
# Native drivers
#
# CONFIG_SENSORS_AD7314 is not set
# CONFIG_SENSORS_AD7414 is not set
# CONFIG_SENSORS_AD7418 is not set
# CONFIG_SENSORS_ADM1021 is not set
# CONFIG_SENSORS_ADM1025 is not set
# CONFIG_SENSORS_ADM1026 is not set
# CONFIG_SENSORS_ADM1029 is not set
# CONFIG_SENSORS_ADM1031 is not set
# CONFIG_SENSORS_ADM1177 is not set
# CONFIG_SENSORS_ADM9240 is not set
# CONFIG_SENSORS_ADT7310 is not set
# CONFIG_SENSORS_ADT7410 is not set
# CONFIG_SENSORS_ADT7411 is not set
# CONFIG_SENSORS_ADT7462 is not set
# CONFIG_SENSORS_ADT7470 is not set
# CONFIG_SENSORS_ADT7475 is not set
# CONFIG_SENSORS_AHT10 is not set
# CONFIG_SENSORS_AQUACOMPUTER_D5NEXT is not set
# CONFIG_SENSORS_AS370 is not set
# CONFIG_SENSORS_ASC7621 is not set
# CONFIG_SENSORS_AXI_FAN_CONTROL is not set
# CONFIG_SENSORS_ASPEED is not set
# CONFIG_SENSORS_ATXP1 is not set
# CONFIG_SENSORS_CORSAIR_CPRO is not set
# CONFIG_SENSORS_CORSAIR_PSU is not set
# CONFIG_SENSORS_DRIVETEMP is not set
# CONFIG_SENSORS_DS620 is not set
# CONFIG_SENSORS_DS1621 is not set
# CONFIG_SENSORS_I5K_AMB is not set
# CONFIG_SENSORS_F71805F is not set
# CONFIG_SENSORS_F71882FG is not set
# CONFIG_SENSORS_F75375S is not set
# CONFIG_SENSORS_GL518SM is not set
# CONFIG_SENSORS_GL520SM is not set
# CONFIG_SENSORS_G760A is not set
# CONFIG_SENSORS_G762 is not set
# CONFIG_SENSORS_HIH6130 is not set
# CONFIG_SENSORS_IT87 is not set
# CONFIG_SENSORS_JC42 is not set
# CONFIG_SENSORS_POWR1220 is not set
# CONFIG_SENSORS_LINEAGE is not set
# CONFIG_SENSORS_LTC2945 is not set
# CONFIG_SENSORS_LTC2947_I2C is not set
# CONFIG_SENSORS_LTC2947_SPI is not set
# CONFIG_SENSORS_LTC2990 is not set
# CONFIG_SENSORS_LTC4151 is not set
# CONFIG_SENSORS_LTC4215 is not set
# CONFIG_SENSORS_LTC4222 is not set
# CONFIG_SENSORS_LTC4245 is not set
# CONFIG_SENSORS_LTC4260 is not set
# CONFIG_SENSORS_LTC4261 is not set
# CONFIG_SENSORS_MAX1111 is not set
# CONFIG_SENSORS_MAX127 is not set
# CONFIG_SENSORS_MAX16065 is not set
# CONFIG_SENSORS_MAX1619 is not set
# CONFIG_SENSORS_MAX1668 is not set
# CONFIG_SENSORS_MAX197 is not set
# CONFIG_SENSORS_MAX31722 is not set
# CONFIG_SENSORS_MAX31730 is not set
# CONFIG_SENSORS_MAX6620 is not set
# CONFIG_SENSORS_MAX6621 is not set
# CONFIG_SENSORS_MAX6639 is not set
# CONFIG_SENSORS_MAX6642 is not set
# CONFIG_SENSORS_MAX6650 is not set
# CONFIG_SENSORS_MAX6697 is not set
# CONFIG_SENSORS_MAX31790 is not set
# CONFIG_SENSORS_MCP3021 is not set
# CONFIG_SENSORS_TC654 is not set
# CONFIG_SENSORS_TPS23861 is not set
# CONFIG_SENSORS_MR75203 is not set
# CONFIG_SENSORS_ADCXX is not set
# CONFIG_SENSORS_LM63 is not set
# CONFIG_SENSORS_LM70 is not set
# CONFIG_SENSORS_LM73 is not set
# CONFIG_SENSORS_LM75 is not set
# CONFIG_SENSORS_LM77 is not set
# CONFIG_SENSORS_LM78 is not set
# CONFIG_SENSORS_LM80 is not set
# CONFIG_SENSORS_LM83 is not set
# CONFIG_SENSORS_LM85 is not set
# CONFIG_SENSORS_LM87 is not set
# CONFIG_SENSORS_LM90 is not set
# CONFIG_SENSORS_LM92 is not set
# CONFIG_SENSORS_LM93 is not set
# CONFIG_SENSORS_LM95234 is not set
# CONFIG_SENSORS_LM95241 is not set
# CONFIG_SENSORS_LM95245 is not set
# CONFIG_SENSORS_PC87360 is not set
# CONFIG_SENSORS_PC87427 is not set
# CONFIG_SENSORS_NCT6683 is not set
# CONFIG_SENSORS_NCT6775 is not set
# CONFIG_SENSORS_NCT7802 is not set
# CONFIG_SENSORS_NPCM7XX is not set
# CONFIG_SENSORS_NZXT_KRAKEN2 is not set
# CONFIG_SENSORS_NZXT_SMART2 is not set
# CONFIG_SENSORS_PCF8591 is not set
# CONFIG_PMBUS is not set
# CONFIG_SENSORS_SBTSI is not set
# CONFIG_SENSORS_SBRMI is not set
# CONFIG_SENSORS_SHT21 is not set
# CONFIG_SENSORS_SHT3x is not set
# CONFIG_SENSORS_SHT4x is not set
# CONFIG_SENSORS_SHTC1 is not set
# CONFIG_SENSORS_SIS5595 is not set
# CONFIG_SENSORS_SY7636A is not set
# CONFIG_SENSORS_DME1737 is not set
# CONFIG_SENSORS_EMC1403 is not set
# CONFIG_SENSORS_EMC2103 is not set
# CONFIG_SENSORS_EMC6W201 is not set
# CONFIG_SENSORS_SMSC47M1 is not set
# CONFIG_SENSORS_SMSC47M192 is not set
# CONFIG_SENSORS_SMSC47B397 is not set
# CONFIG_SENSORS_STTS751 is not set
# CONFIG_SENSORS_SMM665 is not set
# CONFIG_SENSORS_ADC128D818 is not set
# CONFIG_SENSORS_ADS7828 is not set
# CONFIG_SENSORS_ADS7871 is not set
# CONFIG_SENSORS_AMC6821 is not set
# CONFIG_SENSORS_INA209 is not set
# CONFIG_SENSORS_INA2XX is not set
# CONFIG_SENSORS_INA238 is not set
# CONFIG_SENSORS_INA3221 is not set
# CONFIG_SENSORS_TC74 is not set
# CONFIG_SENSORS_THMC50 is not set
# CONFIG_SENSORS_TMP102 is not set
# CONFIG_SENSORS_TMP103 is not set
# CONFIG_SENSORS_TMP108 is not set
# CONFIG_SENSORS_TMP401 is not set
# CONFIG_SENSORS_TMP421 is not set
# CONFIG_SENSORS_TMP464 is not set
# CONFIG_SENSORS_TMP513 is not set
# CONFIG_SENSORS_VIA686A is not set
# CONFIG_SENSORS_VT1211 is not set
# CONFIG_SENSORS_VT8231 is not set
# CONFIG_SENSORS_W83773G is not set
# CONFIG_SENSORS_W83781D is not set
# CONFIG_SENSORS_W83791D is not set
# CONFIG_SENSORS_W83792D is not set
# CONFIG_SENSORS_W83793 is not set
# CONFIG_SENSORS_W83795 is not set
# CONFIG_SENSORS_W83L785TS is not set
# CONFIG_SENSORS_W83L786NG is not set
# CONFIG_SENSORS_W83627HF is not set
# CONFIG_SENSORS_W83627EHF is not set
# CONFIG_THERMAL is not set
# CONFIG_WATCHDOG is not set
CONFIG_SSB_POSSIBLE=y
# CONFIG_SSB is not set
CONFIG_BCMA_POSSIBLE=y
# CONFIG_BCMA is not set

#
# Multifunction device drivers
#
# CONFIG_MFD_ACT8945A is not set
# CONFIG_MFD_AS3711 is not set
# CONFIG_MFD_AS3722 is not set
# CONFIG_PMIC_ADP5520 is not set
# CONFIG_MFD_ATMEL_FLEXCOM is not set
# CONFIG_MFD_ATMEL_HLCDC is not set
# CONFIG_MFD_BCM590XX is not set
# CONFIG_MFD_BD9571MWV is not set
# CONFIG_MFD_AXP20X_I2C is not set
# CONFIG_MFD_MADERA is not set
# CONFIG_PMIC_DA903X is not set
# CONFIG_MFD_DA9052_SPI is not set
# CONFIG_MFD_DA9052_I2C is not set
# CONFIG_MFD_DA9055 is not set
# CONFIG_MFD_DA9062 is not set
# CONFIG_MFD_DA9063 is not set
# CONFIG_MFD_DA9150 is not set
# CONFIG_MFD_DLN2 is not set
# CONFIG_MFD_GATEWORKS_GSC is not set
# CONFIG_MFD_MC13XXX_SPI is not set
# CONFIG_MFD_MC13XXX_I2C is not set
# CONFIG_MFD_MP2629 is not set
# CONFIG_MFD_HI6421_PMIC is not set
# CONFIG_HTC_PASIC3 is not set
# CONFIG_LPC_ICH is not set
# CONFIG_LPC_SCH is not set
# CONFIG_MFD_IQS62X is not set
# CONFIG_MFD_JANZ_CMODIO is not set
# CONFIG_MFD_KEMPLD is not set
# CONFIG_MFD_88PM800 is not set
# CONFIG_MFD_88PM805 is not set
# CONFIG_MFD_88PM860X is not set
# CONFIG_MFD_MAX14577 is not set
# CONFIG_MFD_MAX77620 is not set
# CONFIG_MFD_MAX77650 is not set
# CONFIG_MFD_MAX77686 is not set
# CONFIG_MFD_MAX77693 is not set
# CONFIG_MFD_MAX77714 is not set
# CONFIG_MFD_MAX77843 is not set
# CONFIG_MFD_MAX8907 is not set
# CONFIG_MFD_MAX8925 is not set
# CONFIG_MFD_MAX8997 is not set
# CONFIG_MFD_MAX8998 is not set
# CONFIG_MFD_MT6360 is not set
# CONFIG_MFD_MT6397 is not set
# CONFIG_MFD_MENF21BMC is not set
# CONFIG_EZX_PCAP is not set
# CONFIG_MFD_CPCAP is not set
# CONFIG_MFD_VIPERBOARD is not set
# CONFIG_MFD_NTXEC is not set
# CONFIG_MFD_RETU is not set
# CONFIG_MFD_PCF50633 is not set
# CONFIG_MFD_RDC321X is not set
# CONFIG_MFD_RT4831 is not set
# CONFIG_MFD_RT5033 is not set
# CONFIG_MFD_RC5T583 is not set
# CONFIG_MFD_RK808 is not set
# CONFIG_MFD_RN5T618 is not set
# CONFIG_MFD_SEC_CORE is not set
# CONFIG_MFD_SI476X_CORE is not set
# CONFIG_MFD_SIMPLE_MFD_I2C is not set
# CONFIG_MFD_SM501 is not set
# CONFIG_MFD_SKY81452 is not set
# CONFIG_MFD_STMPE is not set
CONFIG_MFD_SYSCON=y
# CONFIG_MFD_TI_AM335X_TSCADC is not set
# CONFIG_MFD_LP3943 is not set
# CONFIG_MFD_LP8788 is not set
# CONFIG_MFD_TI_LMU is not set
# CONFIG_MFD_PALMAS is not set
# CONFIG_TPS6105X is not set
# CONFIG_TPS6507X is not set
# CONFIG_MFD_TPS65086 is not set
# CONFIG_MFD_TPS65090 is not set
# CONFIG_MFD_TPS65217 is not set
# CONFIG_MFD_TI_LP873X is not set
# CONFIG_MFD_TI_LP87565 is not set
# CONFIG_MFD_TPS65218 is not set
# CONFIG_MFD_TPS6586X is not set
# CONFIG_MFD_TPS65912_I2C is not set
# CONFIG_MFD_TPS65912_SPI is not set
# CONFIG_TWL4030_CORE is not set
# CONFIG_TWL6040_CORE is not set
# CONFIG_MFD_WL1273_CORE is not set
# CONFIG_MFD_LM3533 is not set
# CONFIG_MFD_TC3589X is not set
# CONFIG_MFD_TQMX86 is not set
# CONFIG_MFD_VX855 is not set
# CONFIG_MFD_LOCHNAGAR is not set
# CONFIG_MFD_ARIZONA_I2C is not set
# CONFIG_MFD_ARIZONA_SPI is not set
# CONFIG_MFD_WM8400 is not set
# CONFIG_MFD_WM831X_I2C is not set
# CONFIG_MFD_WM831X_SPI is not set
# CONFIG_MFD_WM8350_I2C is not set
# CONFIG_MFD_WM8994 is not set
# CONFIG_MFD_ROHM_BD718XX is not set
# CONFIG_MFD_ROHM_BD71828 is not set
# CONFIG_MFD_ROHM_BD957XMUF is not set
# CONFIG_MFD_STPMIC1 is not set
# CONFIG_MFD_STMFX is not set
# CONFIG_MFD_ATC260X_I2C is not set
# CONFIG_MFD_QCOM_PM8008 is not set
# CONFIG_MFD_INTEL_M10_BMC is not set
# CONFIG_MFD_RSMU_I2C is not set
# CONFIG_MFD_RSMU_SPI is not set
# end of Multifunction device drivers

# CONFIG_REGULATOR is not set
# CONFIG_RC_CORE is not set

#
# CEC support
#
# CONFIG_MEDIA_CEC_SUPPORT is not set
# end of CEC support

# CONFIG_MEDIA_SUPPORT is not set

#
# Graphics support
#
CONFIG_DRM=y
# CONFIG_DRM_DP_AUX_CHARDEV is not set
# CONFIG_DRM_DEBUG_MM is not set
# CONFIG_DRM_DEBUG_SELFTEST is not set
CONFIG_DRM_DP_HELPER=y
CONFIG_DRM_KMS_HELPER=y
# CONFIG_DRM_DEBUG_DP_MST_TOPOLOGY_REFS is not set
CONFIG_DRM_DEBUG_MODESET_LOCK=y
CONFIG_DRM_FBDEV_EMULATION=y
CONFIG_DRM_FBDEV_OVERALLOC=100
# CONFIG_DRM_FBDEV_LEAK_PHYS_SMEM is not set
# CONFIG_DRM_LOAD_EDID_FIRMWARE is not set
# CONFIG_DRM_DP_CEC is not set
CONFIG_DRM_TTM=y
CONFIG_DRM_TTM_HELPER=y
CONFIG_DRM_GEM_SHMEM_HELPER=y

#
# I2C encoder or helper chips
#
# CONFIG_DRM_I2C_CH7006 is not set
# CONFIG_DRM_I2C_SIL164 is not set
# CONFIG_DRM_I2C_NXP_TDA998X is not set
# CONFIG_DRM_I2C_NXP_TDA9950 is not set
# end of I2C encoder or helper chips

#
# ARM devices
#
# CONFIG_DRM_KOMEDA is not set
# end of ARM devices

CONFIG_DRM_RADEON=y
# CONFIG_DRM_RADEON_USERPTR is not set
# CONFIG_DRM_AMDGPU is not set
# CONFIG_DRM_NOUVEAU is not set
# CONFIG_DRM_VGEM is not set
# CONFIG_DRM_VKMS is not set
# CONFIG_DRM_UDL is not set
# CONFIG_DRM_AST is not set
# CONFIG_DRM_MGAG200 is not set
# CONFIG_DRM_RCAR_DW_HDMI is not set
# CONFIG_DRM_RCAR_USE_LVDS is not set
# CONFIG_DRM_RCAR_MIPI_DSI is not set
# CONFIG_DRM_QXL is not set
CONFIG_DRM_VIRTIO_GPU=y
CONFIG_DRM_PANEL=y

#
# Display Panels
#
# CONFIG_DRM_PANEL_ABT_Y030XX067A is not set
# CONFIG_DRM_PANEL_ARM_VERSATILE is not set
# CONFIG_DRM_PANEL_LVDS is not set
# CONFIG_DRM_PANEL_SIMPLE is not set
# CONFIG_DRM_PANEL_EDP is not set
# CONFIG_DRM_PANEL_ILITEK_IL9322 is not set
# CONFIG_DRM_PANEL_INNOLUX_EJ030NA is not set
# CONFIG_DRM_PANEL_SAMSUNG_LD9040 is not set
# CONFIG_DRM_PANEL_LG_LG4573 is not set
# CONFIG_DRM_PANEL_NOVATEK_NT39016 is not set
# CONFIG_DRM_PANEL_OLIMEX_LCD_OLINUXINO is not set
# CONFIG_DRM_PANEL_SAMSUNG_ATNA33XC20 is not set
# CONFIG_DRM_PANEL_SAMSUNG_S6E63M0 is not set
# CONFIG_DRM_PANEL_SAMSUNG_S6E88A0_AMS452EF01 is not set
# CONFIG_DRM_PANEL_SAMSUNG_S6E8AA0 is not set
# CONFIG_DRM_PANEL_SEIKO_43WVF1G is not set
# CONFIG_DRM_PANEL_SITRONIX_ST7789V is not set
# CONFIG_DRM_PANEL_TPO_TD028TTEC1 is not set
# end of Display Panels

CONFIG_DRM_BRIDGE=y
CONFIG_DRM_PANEL_BRIDGE=y

#
# Display Interface Bridges
#
# CONFIG_DRM_CDNS_DSI is not set
# CONFIG_DRM_CHIPONE_ICN6211 is not set
# CONFIG_DRM_CHRONTEL_CH7033 is not set
# CONFIG_DRM_DISPLAY_CONNECTOR is not set
# CONFIG_DRM_ITE_IT6505 is not set
# CONFIG_DRM_LONTIUM_LT8912B is not set
# CONFIG_DRM_LONTIUM_LT9611 is not set
# CONFIG_DRM_LONTIUM_LT9611UXC is not set
# CONFIG_DRM_ITE_IT66121 is not set
# CONFIG_DRM_LVDS_CODEC is not set
# CONFIG_DRM_MEGACHIPS_STDPXXXX_GE_B850V3_FW is not set
# CONFIG_DRM_NWL_MIPI_DSI is not set
# CONFIG_DRM_NXP_PTN3460 is not set
# CONFIG_DRM_PARADE_PS8622 is not set
# CONFIG_DRM_PARADE_PS8640 is not set
# CONFIG_DRM_SIL_SII8620 is not set
# CONFIG_DRM_SII902X is not set
# CONFIG_DRM_SII9234 is not set
# CONFIG_DRM_SIMPLE_BRIDGE is not set
# CONFIG_DRM_THINE_THC63LVD1024 is not set
# CONFIG_DRM_TOSHIBA_TC358762 is not set
# CONFIG_DRM_TOSHIBA_TC358764 is not set
# CONFIG_DRM_TOSHIBA_TC358767 is not set
# CONFIG_DRM_TOSHIBA_TC358768 is not set
# CONFIG_DRM_TOSHIBA_TC358775 is not set
# CONFIG_DRM_TI_TFP410 is not set
# CONFIG_DRM_TI_SN65DSI83 is not set
# CONFIG_DRM_TI_SN65DSI86 is not set
# CONFIG_DRM_TI_TPD12S015 is not set
# CONFIG_DRM_ANALOGIX_ANX6345 is not set
# CONFIG_DRM_ANALOGIX_ANX78XX is not set
# CONFIG_DRM_ANALOGIX_ANX7625 is not set
# CONFIG_DRM_I2C_ADV7511 is not set
# CONFIG_DRM_CDNS_MHDP8546 is not set
# end of Display Interface Bridges

# CONFIG_DRM_ETNAVIV is not set
# CONFIG_DRM_MXSFB is not set
# CONFIG_DRM_ARCPGU is not set
# CONFIG_DRM_BOCHS is not set
# CONFIG_DRM_CIRRUS_QEMU is not set
# CONFIG_DRM_GM12U320 is not set
# CONFIG_DRM_PANEL_MIPI_DBI is not set
# CONFIG_DRM_SIMPLEDRM is not set
# CONFIG_TINYDRM_HX8357D is not set
# CONFIG_TINYDRM_ILI9163 is not set
# CONFIG_TINYDRM_ILI9225 is not set
# CONFIG_TINYDRM_ILI9341 is not set
# CONFIG_TINYDRM_ILI9486 is not set
# CONFIG_TINYDRM_MI0283QT is not set
# CONFIG_TINYDRM_REPAPER is not set
# CONFIG_TINYDRM_ST7586 is not set
# CONFIG_TINYDRM_ST7735R is not set
# CONFIG_DRM_GUD is not set
# CONFIG_DRM_SSD130X is not set
# CONFIG_DRM_LEGACY is not set
CONFIG_DRM_PANEL_ORIENTATION_QUIRKS=y
CONFIG_DRM_NOMODESET=y

#
# Frame buffer Devices
#
CONFIG_FB_CMDLINE=y
CONFIG_FB_NOTIFY=y
CONFIG_FB=y
# CONFIG_FIRMWARE_EDID is not set
CONFIG_FB_CFB_FILLRECT=y
CONFIG_FB_CFB_COPYAREA=y
CONFIG_FB_CFB_IMAGEBLIT=y
CONFIG_FB_SYS_FILLRECT=y
CONFIG_FB_SYS_COPYAREA=y
CONFIG_FB_SYS_IMAGEBLIT=y
# CONFIG_FB_FOREIGN_ENDIAN is not set
CONFIG_FB_SYS_FOPS=y
CONFIG_FB_DEFERRED_IO=y
# CONFIG_FB_MODE_HELPERS is not set
# CONFIG_FB_TILEBLITTING is not set

#
# Frame buffer hardware drivers
#
# CONFIG_FB_CIRRUS is not set
# CONFIG_FB_PM2 is not set
# CONFIG_FB_CYBER2000 is not set
# CONFIG_FB_ASILIANT is not set
# CONFIG_FB_IMSTT is not set
# CONFIG_FB_EFI is not set
# CONFIG_FB_OPENCORES is not set
# CONFIG_FB_S1D13XXX is not set
# CONFIG_FB_NVIDIA is not set
# CONFIG_FB_RIVA is not set
# CONFIG_FB_I740 is not set
# CONFIG_FB_MATROX is not set
# CONFIG_FB_RADEON is not set
# CONFIG_FB_ATY128 is not set
# CONFIG_FB_ATY is not set
# CONFIG_FB_S3 is not set
# CONFIG_FB_SAVAGE is not set
# CONFIG_FB_SIS is not set
# CONFIG_FB_NEOMAGIC is not set
# CONFIG_FB_KYRO is not set
# CONFIG_FB_3DFX is not set
# CONFIG_FB_VOODOO1 is not set
# CONFIG_FB_VT8623 is not set
# CONFIG_FB_TRIDENT is not set
# CONFIG_FB_ARK is not set
# CONFIG_FB_PM3 is not set
# CONFIG_FB_CARMINE is not set
# CONFIG_FB_SMSCUFX is not set
# CONFIG_FB_UDL is not set
# CONFIG_FB_IBM_GXT4500 is not set
# CONFIG_FB_GOLDFISH is not set
# CONFIG_FB_VIRTUAL is not set
# CONFIG_FB_METRONOME is not set
# CONFIG_FB_MB862XX is not set
# CONFIG_FB_SIMPLE is not set
# CONFIG_FB_SM712 is not set
# end of Frame buffer Devices

#
# Backlight & LCD device support
#
# CONFIG_LCD_CLASS_DEVICE is not set
CONFIG_BACKLIGHT_CLASS_DEVICE=y
# CONFIG_BACKLIGHT_QCOM_WLED is not set
# CONFIG_BACKLIGHT_ADP8860 is not set
# CONFIG_BACKLIGHT_ADP8870 is not set
# CONFIG_BACKLIGHT_LM3639 is not set
# CONFIG_BACKLIGHT_LV5207LP is not set
# CONFIG_BACKLIGHT_BD6107 is not set
# CONFIG_BACKLIGHT_ARCXCNN is not set
# end of Backlight & LCD device support

CONFIG_HDMI=y

#
# Console display driver support
#
CONFIG_VGA_CONSOLE=y
CONFIG_DUMMY_CONSOLE=y
CONFIG_DUMMY_CONSOLE_COLUMNS=80
CONFIG_DUMMY_CONSOLE_ROWS=25
CONFIG_FRAMEBUFFER_CONSOLE=y
CONFIG_FRAMEBUFFER_CONSOLE_LEGACY_ACCELERATION=y
CONFIG_FRAMEBUFFER_CONSOLE_DETECT_PRIMARY=y
# CONFIG_FRAMEBUFFER_CONSOLE_ROTATION is not set
# CONFIG_FRAMEBUFFER_CONSOLE_DEFERRED_TAKEOVER is not set
# end of Console display driver support

# CONFIG_LOGO is not set
# end of Graphics support

# CONFIG_SOUND is not set

#
# HID support
#
CONFIG_HID=y
# CONFIG_HID_BATTERY_STRENGTH is not set
# CONFIG_HIDRAW is not set
# CONFIG_UHID is not set
CONFIG_HID_GENERIC=y

#
# Special HID drivers
#
# CONFIG_HID_A4TECH is not set
# CONFIG_HID_ACCUTOUCH is not set
# CONFIG_HID_ACRUX is not set
# CONFIG_HID_APPLEIR is not set
# CONFIG_HID_AUREAL is not set
# CONFIG_HID_BELKIN is not set
# CONFIG_HID_BETOP_FF is not set
# CONFIG_HID_CHERRY is not set
# CONFIG_HID_CHICONY is not set
# CONFIG_HID_COUGAR is not set
# CONFIG_HID_MACALLY is not set
# CONFIG_HID_CMEDIA is not set
# CONFIG_HID_CREATIVE_SB0540 is not set
# CONFIG_HID_CYPRESS is not set
# CONFIG_HID_DRAGONRISE is not set
# CONFIG_HID_EMS_FF is not set
# CONFIG_HID_ELECOM is not set
# CONFIG_HID_ELO is not set
# CONFIG_HID_EZKEY is not set
# CONFIG_HID_GEMBIRD is not set
# CONFIG_HID_GFRM is not set
# CONFIG_HID_GLORIOUS is not set
# CONFIG_HID_HOLTEK is not set
# CONFIG_HID_VIVALDI is not set
# CONFIG_HID_KEYTOUCH is not set
# CONFIG_HID_KYE is not set
# CONFIG_HID_UCLOGIC is not set
# CONFIG_HID_WALTOP is not set
# CONFIG_HID_VIEWSONIC is not set
# CONFIG_HID_XIAOMI is not set
# CONFIG_HID_GYRATION is not set
# CONFIG_HID_ICADE is not set
# CONFIG_HID_ITE is not set
# CONFIG_HID_JABRA is not set
# CONFIG_HID_TWINHAN is not set
# CONFIG_HID_KENSINGTON is not set
# CONFIG_HID_LCPOWER is not set
# CONFIG_HID_LENOVO is not set
# CONFIG_HID_LETSKETCH is not set
# CONFIG_HID_MAGICMOUSE is not set
# CONFIG_HID_MALTRON is not set
# CONFIG_HID_MAYFLASH is not set
# CONFIG_HID_REDRAGON is not set
# CONFIG_HID_MICROSOFT is not set
# CONFIG_HID_MONTEREY is not set
# CONFIG_HID_MULTITOUCH is not set
# CONFIG_HID_NTI is not set
# CONFIG_HID_NTRIG is not set
# CONFIG_HID_ORTEK is not set
# CONFIG_HID_PANTHERLORD is not set
# CONFIG_HID_PENMOUNT is not set
# CONFIG_HID_PETALYNX is not set
# CONFIG_HID_PICOLCD is not set
# CONFIG_HID_PLANTRONICS is not set
# CONFIG_HID_RAZER is not set
# CONFIG_HID_PRIMAX is not set
# CONFIG_HID_RETRODE is not set
# CONFIG_HID_ROCCAT is not set
# CONFIG_HID_SAITEK is not set
# CONFIG_HID_SAMSUNG is not set
# CONFIG_HID_SEMITEK is not set
# CONFIG_HID_SIGMAMICRO is not set
# CONFIG_HID_SPEEDLINK is not set
# CONFIG_HID_STEAM is not set
# CONFIG_HID_STEELSERIES is not set
# CONFIG_HID_SUNPLUS is not set
# CONFIG_HID_RMI is not set
# CONFIG_HID_GREENASIA is not set
# CONFIG_HID_SMARTJOYPLUS is not set
# CONFIG_HID_TIVO is not set
# CONFIG_HID_TOPSEED is not set
# CONFIG_HID_THRUSTMASTER is not set
# CONFIG_HID_UDRAW_PS3 is not set
# CONFIG_HID_WACOM is not set
# CONFIG_HID_XINMO is not set
# CONFIG_HID_ZEROPLUS is not set
# CONFIG_HID_ZYDACRON is not set
# CONFIG_HID_SENSOR_HUB is not set
# CONFIG_HID_ALPS is not set
# end of Special HID drivers

#
# USB HID support
#
CONFIG_USB_HID=y
# CONFIG_HID_PID is not set
# CONFIG_USB_HIDDEV is not set
# end of USB HID support

#
# I2C HID support
#
# CONFIG_I2C_HID_OF is not set
# CONFIG_I2C_HID_OF_GOODIX is not set
# end of I2C HID support
# end of HID support

CONFIG_USB_OHCI_LITTLE_ENDIAN=y
CONFIG_USB_SUPPORT=y
CONFIG_USB_COMMON=y
# CONFIG_USB_ULPI_BUS is not set
CONFIG_USB_ARCH_HAS_HCD=y
CONFIG_USB=y
CONFIG_USB_PCI=y
# CONFIG_USB_ANNOUNCE_NEW_DEVICES is not set

#
# Miscellaneous USB options
#
CONFIG_USB_DEFAULT_PERSIST=y
# CONFIG_USB_FEW_INIT_RETRIES is not set
# CONFIG_USB_DYNAMIC_MINORS is not set
# CONFIG_USB_OTG is not set
# CONFIG_USB_OTG_PRODUCTLIST is not set
# CONFIG_USB_OTG_DISABLE_EXTERNAL_HUB is not set
CONFIG_USB_AUTOSUSPEND_DELAY=2
# CONFIG_USB_MON is not set

#
# USB Host Controller Drivers
#
# CONFIG_USB_C67X00_HCD is not set
CONFIG_USB_XHCI_HCD=y
# CONFIG_USB_XHCI_DBGCAP is not set
CONFIG_USB_XHCI_PCI=y
# CONFIG_USB_XHCI_PCI_RENESAS is not set
CONFIG_USB_XHCI_PLATFORM=y
CONFIG_USB_EHCI_HCD=y
# CONFIG_USB_EHCI_ROOT_HUB_TT is not set
CONFIG_USB_EHCI_TT_NEWSCHED=y
CONFIG_USB_EHCI_PCI=y
# CONFIG_USB_EHCI_FSL is not set
CONFIG_USB_EHCI_HCD_PLATFORM=y
# CONFIG_USB_OXU210HP_HCD is not set
# CONFIG_USB_ISP116X_HCD is not set
# CONFIG_USB_FOTG210_HCD is not set
# CONFIG_USB_MAX3421_HCD is not set
CONFIG_USB_OHCI_HCD=y
CONFIG_USB_OHCI_HCD_PCI=y
CONFIG_USB_OHCI_HCD_PLATFORM=y
# CONFIG_USB_UHCI_HCD is not set
# CONFIG_USB_SL811_HCD is not set
# CONFIG_USB_R8A66597_HCD is not set
# CONFIG_USB_HCD_TEST_MODE is not set

#
# USB Device Class drivers
#
# CONFIG_USB_ACM is not set
# CONFIG_USB_PRINTER is not set
# CONFIG_USB_WDM is not set
# CONFIG_USB_TMC is not set

#
# NOTE: USB_STORAGE depends on SCSI but BLK_DEV_SD may
#

#
# also be needed; see USB_STORAGE Help for more info
#
CONFIG_USB_STORAGE=y
# CONFIG_USB_STORAGE_DEBUG is not set
# CONFIG_USB_STORAGE_REALTEK is not set
# CONFIG_USB_STORAGE_DATAFAB is not set
# CONFIG_USB_STORAGE_FREECOM is not set
# CONFIG_USB_STORAGE_ISD200 is not set
# CONFIG_USB_STORAGE_USBAT is not set
# CONFIG_USB_STORAGE_SDDR09 is not set
# CONFIG_USB_STORAGE_SDDR55 is not set
# CONFIG_USB_STORAGE_JUMPSHOT is not set
# CONFIG_USB_STORAGE_ALAUDA is not set
# CONFIG_USB_STORAGE_ONETOUCH is not set
# CONFIG_USB_STORAGE_KARMA is not set
# CONFIG_USB_STORAGE_CYPRESS_ATACB is not set
# CONFIG_USB_STORAGE_ENE_UB6250 is not set
CONFIG_USB_UAS=y

#
# USB Imaging devices
#
# CONFIG_USB_MDC800 is not set
# CONFIG_USB_MICROTEK is not set
# CONFIG_USBIP_CORE is not set
# CONFIG_USB_CDNS_SUPPORT is not set
# CONFIG_USB_MUSB_HDRC is not set
# CONFIG_USB_DWC3 is not set
# CONFIG_USB_DWC2 is not set
# CONFIG_USB_CHIPIDEA is not set
# CONFIG_USB_ISP1760 is not set

#
# USB port drivers
#
# CONFIG_USB_SERIAL is not set

#
# USB Miscellaneous drivers
#
# CONFIG_USB_EMI62 is not set
# CONFIG_USB_EMI26 is not set
# CONFIG_USB_ADUTUX is not set
# CONFIG_USB_SEVSEG is not set
# CONFIG_USB_LEGOTOWER is not set
# CONFIG_USB_LCD is not set
# CONFIG_USB_CYPRESS_CY7C63 is not set
# CONFIG_USB_CYTHERM is not set
# CONFIG_USB_IDMOUSE is not set
# CONFIG_USB_FTDI_ELAN is not set
# CONFIG_USB_APPLEDISPLAY is not set
# CONFIG_APPLE_MFI_FASTCHARGE is not set
# CONFIG_USB_SISUSBVGA is not set
# CONFIG_USB_LD is not set
# CONFIG_USB_TRANCEVIBRATOR is not set
# CONFIG_USB_IOWARRIOR is not set
# CONFIG_USB_TEST is not set
# CONFIG_USB_EHSET_TEST_FIXTURE is not set
# CONFIG_USB_ISIGHTFW is not set
# CONFIG_USB_YUREX is not set
# CONFIG_USB_EZUSB_FX2 is not set
# CONFIG_USB_HUB_USB251XB is not set
# CONFIG_USB_HSIC_USB3503 is not set
# CONFIG_USB_HSIC_USB4604 is not set
# CONFIG_USB_LINK_LAYER_TEST is not set
# CONFIG_USB_CHAOSKEY is not set

#
# USB Physical Layer drivers
#
# CONFIG_NOP_USB_XCEIV is not set
# CONFIG_USB_ISP1301 is not set
# end of USB Physical Layer drivers

# CONFIG_USB_GADGET is not set
# CONFIG_TYPEC is not set
# CONFIG_USB_ROLE_SWITCH is not set
# CONFIG_MMC is not set
# CONFIG_MEMSTICK is not set
# CONFIG_NEW_LEDS is not set
# CONFIG_ACCESSIBILITY is not set
# CONFIG_INFINIBAND is not set
CONFIG_EDAC_SUPPORT=y
# CONFIG_EDAC is not set
CONFIG_RTC_LIB=y
CONFIG_RTC_CLASS=y
CONFIG_RTC_HCTOSYS=y
CONFIG_RTC_HCTOSYS_DEVICE="rtc0"
CONFIG_RTC_SYSTOHC=y
CONFIG_RTC_SYSTOHC_DEVICE="rtc0"
# CONFIG_RTC_DEBUG is not set
CONFIG_RTC_NVMEM=y

#
# RTC interfaces
#
CONFIG_RTC_INTF_SYSFS=y
CONFIG_RTC_INTF_PROC=y
CONFIG_RTC_INTF_DEV=y
# CONFIG_RTC_INTF_DEV_UIE_EMUL is not set
# CONFIG_RTC_DRV_TEST is not set

#
# I2C RTC drivers
#
# CONFIG_RTC_DRV_ABB5ZES3 is not set
# CONFIG_RTC_DRV_ABEOZ9 is not set
# CONFIG_RTC_DRV_ABX80X is not set
# CONFIG_RTC_DRV_DS1307 is not set
# CONFIG_RTC_DRV_DS1374 is not set
# CONFIG_RTC_DRV_DS1672 is not set
# CONFIG_RTC_DRV_HYM8563 is not set
# CONFIG_RTC_DRV_MAX6900 is not set
# CONFIG_RTC_DRV_RS5C372 is not set
# CONFIG_RTC_DRV_ISL1208 is not set
# CONFIG_RTC_DRV_ISL12022 is not set
# CONFIG_RTC_DRV_ISL12026 is not set
# CONFIG_RTC_DRV_X1205 is not set
# CONFIG_RTC_DRV_PCF8523 is not set
# CONFIG_RTC_DRV_PCF85063 is not set
# CONFIG_RTC_DRV_PCF85363 is not set
# CONFIG_RTC_DRV_PCF8563 is not set
# CONFIG_RTC_DRV_PCF8583 is not set
# CONFIG_RTC_DRV_M41T80 is not set
# CONFIG_RTC_DRV_BQ32K is not set
# CONFIG_RTC_DRV_S35390A is not set
# CONFIG_RTC_DRV_FM3130 is not set
# CONFIG_RTC_DRV_RX8010 is not set
# CONFIG_RTC_DRV_RX8581 is not set
# CONFIG_RTC_DRV_RX8025 is not set
# CONFIG_RTC_DRV_EM3027 is not set
# CONFIG_RTC_DRV_RV3028 is not set
# CONFIG_RTC_DRV_RV3032 is not set
# CONFIG_RTC_DRV_RV8803 is not set
# CONFIG_RTC_DRV_SD3078 is not set

#
# SPI RTC drivers
#
# CONFIG_RTC_DRV_M41T93 is not set
# CONFIG_RTC_DRV_M41T94 is not set
# CONFIG_RTC_DRV_DS1302 is not set
# CONFIG_RTC_DRV_DS1305 is not set
# CONFIG_RTC_DRV_DS1343 is not set
# CONFIG_RTC_DRV_DS1347 is not set
# CONFIG_RTC_DRV_DS1390 is not set
# CONFIG_RTC_DRV_MAX6916 is not set
# CONFIG_RTC_DRV_R9701 is not set
# CONFIG_RTC_DRV_RX4581 is not set
# CONFIG_RTC_DRV_RS5C348 is not set
# CONFIG_RTC_DRV_MAX6902 is not set
# CONFIG_RTC_DRV_PCF2123 is not set
# CONFIG_RTC_DRV_MCP795 is not set
CONFIG_RTC_I2C_AND_SPI=y

#
# SPI and I2C RTC drivers
#
# CONFIG_RTC_DRV_DS3232 is not set
# CONFIG_RTC_DRV_PCF2127 is not set
# CONFIG_RTC_DRV_RV3029C2 is not set
# CONFIG_RTC_DRV_RX6110 is not set

#
# Platform RTC drivers
#
# CONFIG_RTC_DRV_DS1286 is not set
# CONFIG_RTC_DRV_DS1511 is not set
# CONFIG_RTC_DRV_DS1553 is not set
# CONFIG_RTC_DRV_DS1685_FAMILY is not set
# CONFIG_RTC_DRV_DS1742 is not set
# CONFIG_RTC_DRV_DS2404 is not set
# CONFIG_RTC_DRV_EFI is not set
# CONFIG_RTC_DRV_STK17TA8 is not set
# CONFIG_RTC_DRV_M48T86 is not set
# CONFIG_RTC_DRV_M48T35 is not set
# CONFIG_RTC_DRV_M48T59 is not set
# CONFIG_RTC_DRV_MSM6242 is not set
# CONFIG_RTC_DRV_BQ4802 is not set
# CONFIG_RTC_DRV_RP5C01 is not set
# CONFIG_RTC_DRV_V3020 is not set
# CONFIG_RTC_DRV_ZYNQMP is not set

#
# on-CPU RTC drivers
#
# CONFIG_RTC_DRV_CADENCE is not set
# CONFIG_RTC_DRV_FTRTC010 is not set
# CONFIG_RTC_DRV_R7301 is not set

#
# HID Sensor RTC drivers
#
CONFIG_RTC_DRV_GOLDFISH=y
# CONFIG_DMADEVICES is not set

#
# DMABUF options
#
CONFIG_SYNC_FILE=y
# CONFIG_SW_SYNC is not set
# CONFIG_UDMABUF is not set
# CONFIG_DMABUF_MOVE_NOTIFY is not set
# CONFIG_DMABUF_DEBUG is not set
# CONFIG_DMABUF_SELFTESTS is not set
# CONFIG_DMABUF_HEAPS is not set
# CONFIG_DMABUF_SYSFS_STATS is not set
# end of DMABUF options

# CONFIG_AUXDISPLAY is not set
# CONFIG_UIO is not set
# CONFIG_VFIO is not set
# CONFIG_VIRT_DRIVERS is not set
CONFIG_VIRTIO=y
CONFIG_VIRTIO_PCI_LIB=y
CONFIG_VIRTIO_PCI_LIB_LEGACY=y
CONFIG_VIRTIO_MENU=y
CONFIG_VIRTIO_PCI=y
CONFIG_VIRTIO_PCI_LEGACY=y
CONFIG_VIRTIO_BALLOON=y
CONFIG_VIRTIO_INPUT=y
CONFIG_VIRTIO_MMIO=y
CONFIG_VIRTIO_MMIO_CMDLINE_DEVICES=y
CONFIG_VIRTIO_DMA_SHARED_BUFFER=y
# CONFIG_VDPA is not set
CONFIG_VHOST_MENU=y
# CONFIG_VHOST_NET is not set
# CONFIG_VHOST_CROSS_ENDIAN_LEGACY is not set

#
# Microsoft Hyper-V guest support
#
# end of Microsoft Hyper-V guest support

# CONFIG_GREYBUS is not set
# CONFIG_COMEDI is not set
# CONFIG_STAGING is not set
CONFIG_GOLDFISH=y
# CONFIG_GOLDFISH_PIPE is not set
CONFIG_HAVE_CLK=y
CONFIG_HAVE_CLK_PREPARE=y
CONFIG_COMMON_CLK=y
# CONFIG_LMK04832 is not set
# CONFIG_COMMON_CLK_MAX9485 is not set
# CONFIG_COMMON_CLK_SI5341 is not set
# CONFIG_COMMON_CLK_SI5351 is not set
# CONFIG_COMMON_CLK_SI514 is not set
# CONFIG_COMMON_CLK_SI544 is not set
# CONFIG_COMMON_CLK_SI570 is not set
# CONFIG_COMMON_CLK_CDCE706 is not set
# CONFIG_COMMON_CLK_CDCE925 is not set
# CONFIG_COMMON_CLK_CS2000_CP is not set
# CONFIG_COMMON_CLK_AXI_CLKGEN is not set
# CONFIG_COMMON_CLK_RS9_PCIE is not set
# CONFIG_COMMON_CLK_VC5 is not set
# CONFIG_COMMON_CLK_FIXED_MMIO is not set
CONFIG_CLK_ANALOGBITS_WRPLL_CLN28HPC=y
CONFIG_CLK_SIFIVE=y
CONFIG_CLK_SIFIVE_PRCI=y
# CONFIG_XILINX_VCU is not set
# CONFIG_HWSPINLOCK is not set

#
# Clock Source drivers
#
CONFIG_TIMER_OF=y
CONFIG_TIMER_PROBE=y
CONFIG_RISCV_TIMER=y
# CONFIG_MICROCHIP_PIT64B is not set
# end of Clock Source drivers

# CONFIG_MAILBOX is not set
# CONFIG_IOMMU_SUPPORT is not set

#
# Remoteproc drivers
#
# CONFIG_REMOTEPROC is not set
# end of Remoteproc drivers

#
# Rpmsg drivers
#
CONFIG_RPMSG=y
CONFIG_RPMSG_CHAR=y
# CONFIG_RPMSG_CTRL is not set
CONFIG_RPMSG_NS=y
CONFIG_RPMSG_VIRTIO=y
# end of Rpmsg drivers

# CONFIG_SOUNDWIRE is not set

#
# SOC (System On Chip) specific Drivers
#

#
# Amlogic SoC drivers
#
# end of Amlogic SoC drivers

#
# Broadcom SoC drivers
#
# end of Broadcom SoC drivers

#
# NXP/Freescale QorIQ SoC drivers
#
# end of NXP/Freescale QorIQ SoC drivers

#
# i.MX SoC drivers
#
# end of i.MX SoC drivers

#
# Enable LiteX SoC Builder specific drivers
#
# CONFIG_LITEX_SOC_CONTROLLER is not set
# end of Enable LiteX SoC Builder specific drivers

#
# Qualcomm SoC drivers
#
# end of Qualcomm SoC drivers

# CONFIG_SIFIVE_L2 is not set
# CONFIG_SOC_TI is not set

#
# Xilinx SoC drivers
#
# end of Xilinx SoC drivers
# end of SOC (System On Chip) specific Drivers

# CONFIG_PM_DEVFREQ is not set
# CONFIG_EXTCON is not set
# CONFIG_MEMORY is not set
# CONFIG_IIO is not set
# CONFIG_NTB is not set
# CONFIG_VME_BUS is not set
# CONFIG_PWM is not set

#
# IRQ chip support
#
CONFIG_IRQCHIP=y
# CONFIG_AL_FIC is not set
CONFIG_RISCV_INTC=y
CONFIG_SIFIVE_PLIC=y
# end of IRQ chip support

# CONFIG_IPACK_BUS is not set
CONFIG_RESET_CONTROLLER=y
CONFIG_RESET_SIMPLE=y
# CONFIG_RESET_TI_SYSCON is not set

#
# PHY Subsystem
#
# CONFIG_GENERIC_PHY is not set
# CONFIG_PHY_CAN_TRANSCEIVER is not set

#
# PHY drivers for Broadcom platforms
#
# CONFIG_BCM_KONA_USB2_PHY is not set
# end of PHY drivers for Broadcom platforms

# CONFIG_PHY_CADENCE_TORRENT is not set
# CONFIG_PHY_CADENCE_DPHY is not set
# CONFIG_PHY_CADENCE_DPHY_RX is not set
# CONFIG_PHY_CADENCE_SIERRA is not set
# CONFIG_PHY_CADENCE_SALVO is not set
# CONFIG_PHY_PXA_28NM_HSIC is not set
# CONFIG_PHY_PXA_28NM_USB2 is not set
# CONFIG_PHY_LAN966X_SERDES is not set
# CONFIG_PHY_OCELOT_SERDES is not set
# end of PHY Subsystem

# CONFIG_POWERCAP is not set
# CONFIG_MCB is not set

#
# Performance monitor support
#
CONFIG_RISCV_PMU=y
CONFIG_RISCV_PMU_LEGACY=y
CONFIG_RISCV_PMU_SBI=y
# end of Performance monitor support

CONFIG_RAS=y
# CONFIG_USB4 is not set

#
# Android
#
# CONFIG_ANDROID is not set
# end of Android

# CONFIG_LIBNVDIMM is not set
CONFIG_DAX=y
# CONFIG_DEV_DAX is not set
CONFIG_NVMEM=y
CONFIG_NVMEM_SYSFS=y
# CONFIG_NVMEM_RMEM is not set

#
# HW tracing support
#
# CONFIG_STM is not set
# CONFIG_INTEL_TH is not set
# end of HW tracing support

# CONFIG_FPGA is not set
# CONFIG_FSI is not set
# CONFIG_SIOX is not set
# CONFIG_SLIMBUS is not set
# CONFIG_INTERCONNECT is not set
# CONFIG_COUNTER is not set
# CONFIG_PECI is not set
# end of Device Drivers

#
# File systems
#
# CONFIG_VALIDATE_FS_PARSER is not set
CONFIG_FS_IOMAP=y
# CONFIG_EXT2_FS is not set
# CONFIG_EXT3_FS is not set
CONFIG_EXT4_FS=y
CONFIG_EXT4_USE_FOR_EXT2=y
CONFIG_EXT4_FS_POSIX_ACL=y
CONFIG_EXT4_FS_SECURITY=y
CONFIG_EXT4_DEBUG=y
CONFIG_JBD2=y
# CONFIG_JBD2_DEBUG is not set
CONFIG_FS_MBCACHE=y
# CONFIG_REISERFS_FS is not set
# CONFIG_JFS_FS is not set
# CONFIG_XFS_FS is not set
# CONFIG_GFS2_FS is not set
# CONFIG_BTRFS_FS is not set
# CONFIG_NILFS2_FS is not set
# CONFIG_F2FS_FS is not set
CONFIG_FS_POSIX_ACL=y
CONFIG_EXPORTFS=y
CONFIG_EXPORTFS_BLOCK_OPS=y
CONFIG_FILE_LOCKING=y
# CONFIG_FS_ENCRYPTION is not set
# CONFIG_FS_VERITY is not set
CONFIG_FSNOTIFY=y
CONFIG_DNOTIFY=y
CONFIG_INOTIFY_USER=y
# CONFIG_FANOTIFY is not set
# CONFIG_QUOTA is not set
# CONFIG_AUTOFS4_FS is not set
CONFIG_AUTOFS_FS=y
CONFIG_FUSE_FS=y
CONFIG_CUSE=y
# CONFIG_VIRTIO_FS is not set
CONFIG_OVERLAY_FS=y
# CONFIG_OVERLAY_FS_REDIRECT_DIR is not set
CONFIG_OVERLAY_FS_REDIRECT_ALWAYS_FOLLOW=y
# CONFIG_OVERLAY_FS_INDEX is not set
# CONFIG_OVERLAY_FS_XINO_AUTO is not set
# CONFIG_OVERLAY_FS_METACOPY is not set

#
# Caches
#
CONFIG_NETFS_SUPPORT=y
# CONFIG_NETFS_STATS is not set
# CONFIG_FSCACHE is not set
# end of Caches

#
# CD-ROM/DVD Filesystems
#
CONFIG_ISO9660_FS=y
# CONFIG_JOLIET is not set
# CONFIG_ZISOFS is not set
CONFIG_UDF_FS=y
# end of CD-ROM/DVD Filesystems

#
# DOS/FAT/EXFAT/NT Filesystems
#
CONFIG_FAT_FS=y
CONFIG_MSDOS_FS=y
CONFIG_VFAT_FS=y
CONFIG_FAT_DEFAULT_CODEPAGE=437
CONFIG_FAT_DEFAULT_IOCHARSET="iso8859-1"
# CONFIG_FAT_DEFAULT_UTF8 is not set
CONFIG_EXFAT_FS=y
CONFIG_EXFAT_DEFAULT_IOCHARSET="utf8"
CONFIG_NTFS_FS=y
# CONFIG_NTFS_DEBUG is not set
CONFIG_NTFS_RW=y
# CONFIG_NTFS3_FS is not set
# end of DOS/FAT/EXFAT/NT Filesystems

#
# Pseudo filesystems
#
CONFIG_PROC_FS=y
CONFIG_PROC_KCORE=y
CONFIG_PROC_SYSCTL=y
CONFIG_PROC_PAGE_MONITOR=y
CONFIG_PROC_CHILDREN=y
CONFIG_KERNFS=y
CONFIG_SYSFS=y
CONFIG_TMPFS=y
CONFIG_TMPFS_POSIX_ACL=y
CONFIG_TMPFS_XATTR=y
# CONFIG_TMPFS_INODE64 is not set
CONFIG_ARCH_SUPPORTS_HUGETLBFS=y
# CONFIG_HUGETLBFS is not set
CONFIG_MEMFD_CREATE=y
CONFIG_ARCH_HAS_GIGANTIC_PAGE=y
# CONFIG_CONFIGFS_FS is not set
CONFIG_EFIVAR_FS=m
# end of Pseudo filesystems

CONFIG_MISC_FILESYSTEMS=y
# CONFIG_ORANGEFS_FS is not set
# CONFIG_ADFS_FS is not set
# CONFIG_AFFS_FS is not set
# CONFIG_ECRYPT_FS is not set
# CONFIG_HFS_FS is not set
# CONFIG_HFSPLUS_FS is not set
# CONFIG_BEFS_FS is not set
# CONFIG_BFS_FS is not set
# CONFIG_EFS_FS is not set
# CONFIG_CRAMFS is not set
CONFIG_SQUASHFS=y
CONFIG_SQUASHFS_FILE_CACHE=y
# CONFIG_SQUASHFS_FILE_DIRECT is not set
CONFIG_SQUASHFS_DECOMP_SINGLE=y
# CONFIG_SQUASHFS_DECOMP_MULTI is not set
# CONFIG_SQUASHFS_DECOMP_MULTI_PERCPU is not set
CONFIG_SQUASHFS_XATTR=y
CONFIG_SQUASHFS_ZLIB=y
CONFIG_SQUASHFS_LZ4=y
CONFIG_SQUASHFS_LZO=y
CONFIG_SQUASHFS_XZ=y
CONFIG_SQUASHFS_ZSTD=y
# CONFIG_SQUASHFS_4K_DEVBLK_SIZE is not set
# CONFIG_SQUASHFS_EMBEDDED is not set
CONFIG_SQUASHFS_FRAGMENT_CACHE_SIZE=3
# CONFIG_VXFS_FS is not set
# CONFIG_MINIX_FS is not set
# CONFIG_OMFS_FS is not set
# CONFIG_HPFS_FS is not set
# CONFIG_QNX4FS_FS is not set
# CONFIG_QNX6FS_FS is not set
# CONFIG_ROMFS_FS is not set
# CONFIG_PSTORE is not set
# CONFIG_SYSV_FS is not set
# CONFIG_UFS_FS is not set
# CONFIG_EROFS_FS is not set
CONFIG_NETWORK_FILESYSTEMS=y
CONFIG_NFS_FS=y
CONFIG_NFS_V2=y
CONFIG_NFS_V3=y
# CONFIG_NFS_V3_ACL is not set
CONFIG_NFS_V4=y
# CONFIG_NFS_SWAP is not set
CONFIG_NFS_V4_1=y
CONFIG_NFS_V4_2=y
CONFIG_PNFS_FILE_LAYOUT=y
CONFIG_PNFS_FLEXFILE_LAYOUT=y
CONFIG_NFS_V4_1_IMPLEMENTATION_ID_DOMAIN="kernel.org"
# CONFIG_NFS_V4_1_MIGRATION is not set
CONFIG_ROOT_NFS=y
# CONFIG_NFS_USE_LEGACY_DNS is not set
CONFIG_NFS_USE_KERNEL_DNS=y
CONFIG_NFS_DISABLE_UDP_SUPPORT=y
# CONFIG_NFS_V4_2_READ_PLUS is not set
# CONFIG_NFSD is not set
CONFIG_GRACE_PERIOD=y
CONFIG_LOCKD=y
CONFIG_LOCKD_V4=y
CONFIG_NFS_COMMON=y
CONFIG_NFS_V4_2_SSC_HELPER=y
CONFIG_SUNRPC=y
CONFIG_SUNRPC_GSS=y
CONFIG_SUNRPC_BACKCHANNEL=y
# CONFIG_SUNRPC_DEBUG is not set
# CONFIG_CEPH_FS is not set
# CONFIG_CIFS is not set
# CONFIG_SMB_SERVER is not set
# CONFIG_CODA_FS is not set
# CONFIG_AFS_FS is not set
CONFIG_9P_FS=y
CONFIG_9P_FS_POSIX_ACL=y
CONFIG_9P_FS_SECURITY=y
CONFIG_NLS=y
CONFIG_NLS_DEFAULT="iso8859-1"
CONFIG_NLS_CODEPAGE_437=y
# CONFIG_NLS_CODEPAGE_737 is not set
# CONFIG_NLS_CODEPAGE_775 is not set
CONFIG_NLS_CODEPAGE_850=y
# CONFIG_NLS_CODEPAGE_852 is not set
# CONFIG_NLS_CODEPAGE_855 is not set
# CONFIG_NLS_CODEPAGE_857 is not set
# CONFIG_NLS_CODEPAGE_860 is not set
# CONFIG_NLS_CODEPAGE_861 is not set
# CONFIG_NLS_CODEPAGE_862 is not set
# CONFIG_NLS_CODEPAGE_863 is not set
# CONFIG_NLS_CODEPAGE_864 is not set
# CONFIG_NLS_CODEPAGE_865 is not set
# CONFIG_NLS_CODEPAGE_866 is not set
# CONFIG_NLS_CODEPAGE_869 is not set
CONFIG_NLS_CODEPAGE_936=y
CONFIG_NLS_CODEPAGE_950=y
# CONFIG_NLS_CODEPAGE_932 is not set
# CONFIG_NLS_CODEPAGE_949 is not set
# CONFIG_NLS_CODEPAGE_874 is not set
# CONFIG_NLS_ISO8859_8 is not set
# CONFIG_NLS_CODEPAGE_1250 is not set
# CONFIG_NLS_CODEPAGE_1251 is not set
CONFIG_NLS_ASCII=y
CONFIG_NLS_ISO8859_1=y
# CONFIG_NLS_ISO8859_2 is not set
# CONFIG_NLS_ISO8859_3 is not set
# CONFIG_NLS_ISO8859_4 is not set
# CONFIG_NLS_ISO8859_5 is not set
# CONFIG_NLS_ISO8859_6 is not set
# CONFIG_NLS_ISO8859_7 is not set
# CONFIG_NLS_ISO8859_9 is not set
# CONFIG_NLS_ISO8859_13 is not set
# CONFIG_NLS_ISO8859_14 is not set
# CONFIG_NLS_ISO8859_15 is not set
# CONFIG_NLS_KOI8_R is not set
# CONFIG_NLS_KOI8_U is not set
# CONFIG_NLS_MAC_ROMAN is not set
# CONFIG_NLS_MAC_CELTIC is not set
# CONFIG_NLS_MAC_CENTEURO is not set
# CONFIG_NLS_MAC_CROATIAN is not set
# CONFIG_NLS_MAC_CYRILLIC is not set
# CONFIG_NLS_MAC_GAELIC is not set
# CONFIG_NLS_MAC_GREEK is not set
# CONFIG_NLS_MAC_ICELAND is not set
# CONFIG_NLS_MAC_INUIT is not set
# CONFIG_NLS_MAC_ROMANIAN is not set
# CONFIG_NLS_MAC_TURKISH is not set
CONFIG_NLS_UTF8=y
# CONFIG_UNICODE is not set
CONFIG_IO_WQ=y
# end of File systems

#
# Security options
#
CONFIG_KEYS=y
# CONFIG_KEYS_REQUEST_CACHE is not set
# CONFIG_PERSISTENT_KEYRINGS is not set
# CONFIG_ENCRYPTED_KEYS is not set
# CONFIG_KEY_DH_OPERATIONS is not set
# CONFIG_SECURITY_DMESG_RESTRICT is not set
# CONFIG_SECURITY is not set
# CONFIG_SECURITYFS is not set
CONFIG_HAVE_HARDENED_USERCOPY_ALLOCATOR=y
# CONFIG_HARDENED_USERCOPY is not set
# CONFIG_FORTIFY_SOURCE is not set
# CONFIG_STATIC_USERMODEHELPER is not set
CONFIG_DEFAULT_SECURITY_DAC=y
CONFIG_LSM="lockdown,yama,loadpin,safesetid,integrity,bpf"

#
# Kernel hardening options
#

#
# Memory initialization
#
CONFIG_CC_HAS_AUTO_VAR_INIT_PATTERN=y
CONFIG_CC_HAS_AUTO_VAR_INIT_ZERO=y
CONFIG_INIT_STACK_NONE=y
# CONFIG_INIT_STACK_ALL_PATTERN is not set
# CONFIG_INIT_STACK_ALL_ZERO is not set
# CONFIG_INIT_ON_ALLOC_DEFAULT_ON is not set
# CONFIG_INIT_ON_FREE_DEFAULT_ON is not set
# end of Memory initialization
# end of Kernel hardening options
# end of Security options

CONFIG_CRYPTO=y

#
# Crypto core or helper
#
CONFIG_CRYPTO_ALGAPI=y
CONFIG_CRYPTO_ALGAPI2=y
CONFIG_CRYPTO_AEAD=y
CONFIG_CRYPTO_AEAD2=y
CONFIG_CRYPTO_SKCIPHER=y
CONFIG_CRYPTO_SKCIPHER2=y
CONFIG_CRYPTO_HASH=y
CONFIG_CRYPTO_HASH2=y
CONFIG_CRYPTO_RNG2=y
CONFIG_CRYPTO_AKCIPHER2=y
CONFIG_CRYPTO_AKCIPHER=y
CONFIG_CRYPTO_KPP2=y
CONFIG_CRYPTO_ACOMP2=y
CONFIG_CRYPTO_MANAGER=y
CONFIG_CRYPTO_MANAGER2=y
# CONFIG_CRYPTO_USER is not set
CONFIG_CRYPTO_MANAGER_DISABLE_TESTS=y
# CONFIG_CRYPTO_NULL is not set
CONFIG_CRYPTO_NULL2=y
# CONFIG_CRYPTO_PCRYPT is not set
# CONFIG_CRYPTO_CRYPTD is not set
# CONFIG_CRYPTO_AUTHENC is not set
# CONFIG_CRYPTO_TEST is not set
CONFIG_CRYPTO_ENGINE=y

#
# Public-key cryptography
#
CONFIG_CRYPTO_RSA=y
# CONFIG_CRYPTO_DH is not set
# CONFIG_CRYPTO_ECDH is not set
# CONFIG_CRYPTO_ECDSA is not set
# CONFIG_CRYPTO_ECRDSA is not set
# CONFIG_CRYPTO_SM2 is not set
# CONFIG_CRYPTO_CURVE25519 is not set

#
# Authenticated Encryption with Associated Data
#
# CONFIG_CRYPTO_CCM is not set
# CONFIG_CRYPTO_GCM is not set
# CONFIG_CRYPTO_CHACHA20POLY1305 is not set
# CONFIG_CRYPTO_AEGIS128 is not set
# CONFIG_CRYPTO_SEQIV is not set
# CONFIG_CRYPTO_ECHAINIV is not set

#
# Block modes
#
# CONFIG_CRYPTO_CBC is not set
# CONFIG_CRYPTO_CFB is not set
# CONFIG_CRYPTO_CTR is not set
# CONFIG_CRYPTO_CTS is not set
CONFIG_CRYPTO_ECB=y
# CONFIG_CRYPTO_LRW is not set
# CONFIG_CRYPTO_OFB is not set
# CONFIG_CRYPTO_PCBC is not set
# CONFIG_CRYPTO_XTS is not set
# CONFIG_CRYPTO_KEYWRAP is not set
# CONFIG_CRYPTO_ADIANTUM is not set
# CONFIG_CRYPTO_ESSIV is not set

#
# Hash modes
#
# CONFIG_CRYPTO_CMAC is not set
# CONFIG_CRYPTO_HMAC is not set
# CONFIG_CRYPTO_XCBC is not set
# CONFIG_CRYPTO_VMAC is not set

#
# Digest
#
CONFIG_CRYPTO_CRC32C=y
CONFIG_CRYPTO_CRC32=y
CONFIG_CRYPTO_XXHASH=y
CONFIG_CRYPTO_BLAKE2B=y
# CONFIG_CRYPTO_BLAKE2S is not set
# CONFIG_CRYPTO_CRCT10DIF is not set
# CONFIG_CRYPTO_GHASH is not set
# CONFIG_CRYPTO_POLY1305 is not set
# CONFIG_CRYPTO_MD4 is not set
# CONFIG_CRYPTO_MD5 is not set
# CONFIG_CRYPTO_MICHAEL_MIC is not set
# CONFIG_CRYPTO_RMD160 is not set
# CONFIG_CRYPTO_SHA1 is not set
CONFIG_CRYPTO_SHA256=y
# CONFIG_CRYPTO_SHA512 is not set
# CONFIG_CRYPTO_SHA3 is not set
# CONFIG_CRYPTO_SM3 is not set
# CONFIG_CRYPTO_STREEBOG is not set
# CONFIG_CRYPTO_WP512 is not set

#
# Ciphers
#
CONFIG_CRYPTO_AES=y
# CONFIG_CRYPTO_AES_TI is not set
# CONFIG_CRYPTO_ANUBIS is not set
# CONFIG_CRYPTO_ARC4 is not set
# CONFIG_CRYPTO_BLOWFISH is not set
# CONFIG_CRYPTO_CAMELLIA is not set
# CONFIG_CRYPTO_CAST5 is not set
# CONFIG_CRYPTO_CAST6 is not set
# CONFIG_CRYPTO_DES is not set
# CONFIG_CRYPTO_FCRYPT is not set
# CONFIG_CRYPTO_KHAZAD is not set
# CONFIG_CRYPTO_CHACHA20 is not set
# CONFIG_CRYPTO_SEED is not set
# CONFIG_CRYPTO_SERPENT is not set
# CONFIG_CRYPTO_SM4 is not set
# CONFIG_CRYPTO_TEA is not set
# CONFIG_CRYPTO_TWOFISH is not set

#
# Compression
#
# CONFIG_CRYPTO_DEFLATE is not set
CONFIG_CRYPTO_LZO=y
# CONFIG_CRYPTO_842 is not set
# CONFIG_CRYPTO_LZ4 is not set
# CONFIG_CRYPTO_LZ4HC is not set
# CONFIG_CRYPTO_ZSTD is not set

#
# Random Number Generation
#
# CONFIG_CRYPTO_ANSI_CPRNG is not set
# CONFIG_CRYPTO_DRBG_MENU is not set
# CONFIG_CRYPTO_JITTERENTROPY is not set
CONFIG_CRYPTO_USER_API=y
CONFIG_CRYPTO_USER_API_HASH=y
# CONFIG_CRYPTO_USER_API_SKCIPHER is not set
# CONFIG_CRYPTO_USER_API_RNG is not set
# CONFIG_CRYPTO_USER_API_AEAD is not set
CONFIG_CRYPTO_USER_API_ENABLE_OBSOLETE=y
CONFIG_CRYPTO_HW=y
# CONFIG_CRYPTO_DEV_ATMEL_ECC is not set
# CONFIG_CRYPTO_DEV_ATMEL_SHA204A is not set
# CONFIG_CRYPTO_DEV_NITROX_CNN55XX is not set
CONFIG_CRYPTO_DEV_VIRTIO=y
# CONFIG_CRYPTO_DEV_SAFEXCEL is not set
# CONFIG_CRYPTO_DEV_CCREE is not set
# CONFIG_CRYPTO_DEV_AMLOGIC_GXL is not set
# CONFIG_ASYMMETRIC_KEY_TYPE is not set

#
# Certificates for signature checking
#
# CONFIG_SYSTEM_BLACKLIST_KEYRING is not set
# end of Certificates for signature checking

CONFIG_BINARY_PRINTF=y

#
# Library routines
#
# CONFIG_PACKING is not set
CONFIG_BITREVERSE=y
CONFIG_GENERIC_STRNCPY_FROM_USER=y
CONFIG_GENERIC_STRNLEN_USER=y
CONFIG_GENERIC_NET_UTILS=y
# CONFIG_CORDIC is not set
# CONFIG_PRIME_NUMBERS is not set
CONFIG_RATIONAL=y
CONFIG_GENERIC_PCI_IOMAP=y

#
# Crypto library routines
#
CONFIG_CRYPTO_LIB_AES=y
CONFIG_CRYPTO_LIB_BLAKE2S_GENERIC=y
# CONFIG_CRYPTO_LIB_CHACHA is not set
# CONFIG_CRYPTO_LIB_CURVE25519 is not set
CONFIG_CRYPTO_LIB_POLY1305_RSIZE=1
# CONFIG_CRYPTO_LIB_POLY1305 is not set
# CONFIG_CRYPTO_LIB_CHACHA20POLY1305 is not set
CONFIG_CRYPTO_LIB_SHA256=y
# end of Crypto library routines

# CONFIG_CRC_CCITT is not set
CONFIG_CRC16=y
# CONFIG_CRC_T10DIF is not set
# CONFIG_CRC64_ROCKSOFT is not set
CONFIG_CRC_ITU_T=y
CONFIG_CRC32=y
# CONFIG_CRC32_SELFTEST is not set
CONFIG_CRC32_SLICEBY8=y
# CONFIG_CRC32_SLICEBY4 is not set
# CONFIG_CRC32_SARWATE is not set
# CONFIG_CRC32_BIT is not set
# CONFIG_CRC64 is not set
# CONFIG_CRC4 is not set
CONFIG_CRC7=y
CONFIG_LIBCRC32C=y
# CONFIG_CRC8 is not set
CONFIG_XXHASH=y
# CONFIG_RANDOM32_SELFTEST is not set
CONFIG_ZLIB_INFLATE=y
CONFIG_LZO_COMPRESS=y
CONFIG_LZO_DECOMPRESS=y
CONFIG_LZ4_DECOMPRESS=y
CONFIG_ZSTD_DECOMPRESS=y
CONFIG_XZ_DEC=y
CONFIG_XZ_DEC_X86=y
CONFIG_XZ_DEC_POWERPC=y
CONFIG_XZ_DEC_IA64=y
CONFIG_XZ_DEC_ARM=y
CONFIG_XZ_DEC_ARMTHUMB=y
CONFIG_XZ_DEC_SPARC=y
# CONFIG_XZ_DEC_MICROLZMA is not set
CONFIG_XZ_DEC_BCJ=y
# CONFIG_XZ_DEC_TEST is not set
CONFIG_DECOMPRESS_GZIP=y
CONFIG_DECOMPRESS_BZIP2=y
CONFIG_DECOMPRESS_LZMA=y
CONFIG_DECOMPRESS_XZ=y
CONFIG_DECOMPRESS_LZO=y
CONFIG_DECOMPRESS_LZ4=y
CONFIG_DECOMPRESS_ZSTD=y
CONFIG_GENERIC_ALLOCATOR=y
CONFIG_INTERVAL_TREE=y
CONFIG_XARRAY_MULTI=y
CONFIG_ASSOCIATIVE_ARRAY=y
CONFIG_HAS_IOMEM=y
CONFIG_HAS_IOPORT_MAP=y
CONFIG_HAS_DMA=y
CONFIG_NEED_DMA_MAP_STATE=y
CONFIG_ARCH_DMA_ADDR_T_64BIT=y
CONFIG_DMA_DECLARE_COHERENT=y
CONFIG_SWIOTLB=y
# CONFIG_DMA_RESTRICTED_POOL is not set
# CONFIG_DMA_CMA is not set
# CONFIG_DMA_API_DEBUG is not set
# CONFIG_DMA_MAP_BENCHMARK is not set
CONFIG_SGL_ALLOC=y
# CONFIG_CPUMASK_OFFSTACK is not set
CONFIG_CPU_RMAP=y
CONFIG_DQL=y
CONFIG_GLOB=y
# CONFIG_GLOB_SELFTEST is not set
CONFIG_NLATTR=y
CONFIG_CLZ_TAB=y
# CONFIG_IRQ_POLL is not set
CONFIG_MPILIB=y
CONFIG_LIBFDT=y
CONFIG_OID_REGISTRY=y
CONFIG_UCS2_STRING=y
CONFIG_HAVE_GENERIC_VDSO=y
CONFIG_GENERIC_GETTIMEOFDAY=y
CONFIG_GENERIC_VDSO_TIME_NS=y
CONFIG_FONT_SUPPORT=y
# CONFIG_FONTS is not set
CONFIG_FONT_8x8=y
CONFIG_FONT_8x16=y
CONFIG_SG_POOL=y
CONFIG_ARCH_STACKWALK=y
CONFIG_STACKDEPOT=y
CONFIG_STACK_HASH_ORDER=20
CONFIG_SBITMAP=y
# end of Library routines

CONFIG_GENERIC_IOREMAP=y
CONFIG_GENERIC_LIB_DEVMEM_IS_ALLOWED=y

#
# Kernel hacking
#

#
# printk and dmesg options
#
CONFIG_PRINTK_TIME=y
CONFIG_PRINTK_CALLER=y
# CONFIG_STACKTRACE_BUILD_ID is not set
CONFIG_CONSOLE_LOGLEVEL_DEFAULT=7
CONFIG_CONSOLE_LOGLEVEL_QUIET=6
CONFIG_MESSAGE_LOGLEVEL_DEFAULT=7
# CONFIG_BOOT_PRINTK_DELAY is not set
# CONFIG_DYNAMIC_DEBUG is not set
# CONFIG_DYNAMIC_DEBUG_CORE is not set
CONFIG_SYMBOLIC_ERRNAME=y
CONFIG_DEBUG_BUGVERBOSE=y
# end of printk and dmesg options

CONFIG_DEBUG_KERNEL=y
CONFIG_DEBUG_MISC=y

#
# Compile-time checks and compiler options
#
CONFIG_DEBUG_INFO=y
# CONFIG_DEBUG_INFO_NONE is not set
CONFIG_DEBUG_INFO_DWARF_TOOLCHAIN_DEFAULT=y
# CONFIG_DEBUG_INFO_DWARF4 is not set
# CONFIG_DEBUG_INFO_DWARF5 is not set
# CONFIG_DEBUG_INFO_REDUCED is not set
# CONFIG_DEBUG_INFO_COMPRESSED is not set
# CONFIG_DEBUG_INFO_SPLIT is not set
# CONFIG_DEBUG_INFO_BTF is not set
CONFIG_GDB_SCRIPTS=y
CONFIG_FRAME_WARN=2048
# CONFIG_STRIP_ASM_SYMS is not set
# CONFIG_HEADERS_INSTALL is not set
CONFIG_SECTION_MISMATCH_WARN_ONLY=y
CONFIG_ARCH_WANT_FRAME_POINTERS=y
CONFIG_FRAME_POINTER=y
# CONFIG_VMLINUX_MAP is not set
# CONFIG_DEBUG_FORCE_WEAK_PER_CPU is not set
# end of Compile-time checks and compiler options

#
# Generic Kernel Debugging Instruments
#
CONFIG_MAGIC_SYSRQ=y
CONFIG_MAGIC_SYSRQ_DEFAULT_ENABLE=0x1
CONFIG_MAGIC_SYSRQ_SERIAL=y
CONFIG_MAGIC_SYSRQ_SERIAL_SEQUENCE="p"
CONFIG_DEBUG_FS=y
CONFIG_DEBUG_FS_ALLOW_ALL=y
# CONFIG_DEBUG_FS_DISALLOW_MOUNT is not set
# CONFIG_DEBUG_FS_ALLOW_NONE is not set
CONFIG_HAVE_ARCH_KGDB=y
CONFIG_HAVE_ARCH_KGDB_QXFER_PKT=y
# CONFIG_KGDB is not set
CONFIG_ARCH_HAS_UBSAN_SANITIZE_ALL=y
# CONFIG_UBSAN is not set
# end of Generic Kernel Debugging Instruments

#
# Networking Debugging
#
# CONFIG_NET_DEV_REFCNT_TRACKER is not set
# CONFIG_NET_NS_REFCNT_TRACKER is not set
# end of Networking Debugging

#
# Memory Debugging
#
CONFIG_PAGE_EXTENSION=y
CONFIG_DEBUG_PAGEALLOC=y
# CONFIG_DEBUG_PAGEALLOC_ENABLE_DEFAULT is not set
# CONFIG_PAGE_OWNER is not set
# CONFIG_PAGE_POISONING is not set
# CONFIG_DEBUG_PAGE_REF is not set
# CONFIG_DEBUG_RODATA_TEST is not set
CONFIG_ARCH_HAS_DEBUG_WX=y
# CONFIG_DEBUG_WX is not set
CONFIG_GENERIC_PTDUMP=y
CONFIG_PTDUMP_CORE=y
CONFIG_PTDUMP_DEBUGFS=y
# CONFIG_DEBUG_OBJECTS is not set
# CONFIG_SLUB_DEBUG_ON is not set
# CONFIG_SLUB_STATS is not set
CONFIG_HAVE_DEBUG_KMEMLEAK=y
# CONFIG_DEBUG_KMEMLEAK is not set
CONFIG_DEBUG_STACK_USAGE=y
CONFIG_SCHED_STACK_END_CHECK=y
CONFIG_ARCH_HAS_DEBUG_VM_PGTABLE=y
CONFIG_DEBUG_VM=y
# CONFIG_DEBUG_VM_VMACACHE is not set
# CONFIG_DEBUG_VM_RB is not set
CONFIG_DEBUG_VM_PGFLAGS=y
CONFIG_DEBUG_VM_PGTABLE=y
CONFIG_ARCH_HAS_DEBUG_VIRTUAL=y
# CONFIG_DEBUG_VIRTUAL is not set
CONFIG_DEBUG_MEMORY_INIT=y
CONFIG_DEBUG_PER_CPU_MAPS=y
CONFIG_HAVE_ARCH_KASAN=y
CONFIG_HAVE_ARCH_KASAN_VMALLOC=y
CONFIG_CC_HAS_KASAN_GENERIC=y
CONFIG_CC_HAS_WORKING_NOSANITIZE_ADDRESS=y
# CONFIG_KASAN is not set
CONFIG_HAVE_ARCH_KFENCE=y
# CONFIG_KFENCE is not set
# end of Memory Debugging

# CONFIG_DEBUG_SHIRQ is not set

#
# Debug Oops, Lockups and Hangs
#
CONFIG_PANIC_ON_OOPS=y
CONFIG_PANIC_ON_OOPS_VALUE=1
CONFIG_PANIC_TIMEOUT=0
CONFIG_LOCKUP_DETECTOR=y
CONFIG_SOFTLOCKUP_DETECTOR=y
# CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC is not set
CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC_VALUE=0
CONFIG_DETECT_HUNG_TASK=y
CONFIG_DEFAULT_HUNG_TASK_TIMEOUT=120
# CONFIG_BOOTPARAM_HUNG_TASK_PANIC is not set
CONFIG_BOOTPARAM_HUNG_TASK_PANIC_VALUE=0
CONFIG_WQ_WATCHDOG=y
# CONFIG_TEST_LOCKUP is not set
# end of Debug Oops, Lockups and Hangs

#
# Scheduler Debugging
#
CONFIG_SCHED_DEBUG=y
CONFIG_SCHED_INFO=y
CONFIG_SCHEDSTATS=y
# end of Scheduler Debugging

# CONFIG_DEBUG_TIMEKEEPING is not set

#
# Lock Debugging (spinlocks, mutexes, etc...)
#
CONFIG_LOCK_DEBUGGING_SUPPORT=y
# CONFIG_PROVE_LOCKING is not set
# CONFIG_LOCK_STAT is not set
CONFIG_DEBUG_RT_MUTEXES=y
CONFIG_DEBUG_SPINLOCK=y
CONFIG_DEBUG_MUTEXES=y
# CONFIG_DEBUG_WW_MUTEX_SLOWPATH is not set
# CONFIG_DEBUG_RWSEMS is not set
CONFIG_DEBUG_LOCK_ALLOC=y
CONFIG_LOCKDEP=y
CONFIG_LOCKDEP_BITS=15
CONFIG_LOCKDEP_CHAINS_BITS=16
CONFIG_LOCKDEP_STACK_TRACE_BITS=19
CONFIG_LOCKDEP_STACK_TRACE_HASH_BITS=14
CONFIG_LOCKDEP_CIRCULAR_QUEUE_BITS=12
# CONFIG_DEBUG_LOCKDEP is not set
CONFIG_DEBUG_ATOMIC_SLEEP=y
# CONFIG_DEBUG_LOCKING_API_SELFTESTS is not set
# CONFIG_LOCK_TORTURE_TEST is not set
# CONFIG_WW_MUTEX_SELFTEST is not set
# CONFIG_SCF_TORTURE_TEST is not set
# CONFIG_CSD_LOCK_WAIT_DEBUG is not set
# end of Lock Debugging (spinlocks, mutexes, etc...)

CONFIG_TRACE_IRQFLAGS=y
# CONFIG_DEBUG_IRQFLAGS is not set
CONFIG_STACKTRACE=y
# CONFIG_WARN_ALL_UNSEEDED_RANDOM is not set
# CONFIG_DEBUG_KOBJECT is not set

#
# Debug kernel data structures
#
CONFIG_DEBUG_LIST=y
# CONFIG_DEBUG_PLIST is not set
# CONFIG_DEBUG_SG is not set
# CONFIG_DEBUG_NOTIFIERS is not set
CONFIG_BUG_ON_DATA_CORRUPTION=y
# end of Debug kernel data structures

# CONFIG_DEBUG_CREDENTIALS is not set

#
# RCU Debugging
#
# CONFIG_RCU_SCALE_TEST is not set
# CONFIG_RCU_TORTURE_TEST is not set
# CONFIG_RCU_REF_SCALE_TEST is not set
CONFIG_RCU_CPU_STALL_TIMEOUT=21
# CONFIG_RCU_TRACE is not set
CONFIG_RCU_EQS_DEBUG=y
# end of RCU Debugging

# CONFIG_DEBUG_WQ_FORCE_RR_CPU is not set
# CONFIG_CPU_HOTPLUG_STATE_CONTROL is not set
# CONFIG_LATENCYTOP is not set
CONFIG_NOP_TRACER=y
CONFIG_HAVE_FUNCTION_TRACER=y
CONFIG_HAVE_FUNCTION_GRAPH_TRACER=y
CONFIG_HAVE_DYNAMIC_FTRACE=y
CONFIG_HAVE_DYNAMIC_FTRACE_WITH_REGS=y
CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
CONFIG_HAVE_SYSCALL_TRACEPOINTS=y
CONFIG_TRACER_MAX_TRACE=y
CONFIG_TRACE_CLOCK=y
CONFIG_RING_BUFFER=y
CONFIG_EVENT_TRACING=y
CONFIG_CONTEXT_SWITCH_TRACER=y
CONFIG_RING_BUFFER_ALLOW_SWAP=y
CONFIG_PREEMPTIRQ_TRACEPOINTS=y
CONFIG_TRACING=y
CONFIG_GENERIC_TRACER=y
CONFIG_TRACING_SUPPORT=y
CONFIG_FTRACE=y
CONFIG_BOOTTIME_TRACING=y
CONFIG_FUNCTION_TRACER=y
CONFIG_FUNCTION_GRAPH_TRACER=y
CONFIG_DYNAMIC_FTRACE=y
CONFIG_DYNAMIC_FTRACE_WITH_REGS=y
CONFIG_FUNCTION_PROFILER=y
CONFIG_STACK_TRACER=y
CONFIG_IRQSOFF_TRACER=y
CONFIG_SCHED_TRACER=y
# CONFIG_HWLAT_TRACER is not set
CONFIG_OSNOISE_TRACER=y
# CONFIG_TIMERLAT_TRACER is not set
CONFIG_FTRACE_SYSCALLS=y
CONFIG_TRACER_SNAPSHOT=y
CONFIG_TRACER_SNAPSHOT_PER_CPU_SWAP=y
CONFIG_BRANCH_PROFILE_NONE=y
# CONFIG_PROFILE_ANNOTATED_BRANCHES is not set
# CONFIG_PROFILE_ALL_BRANCHES is not set
CONFIG_BLK_DEV_IO_TRACE=y
CONFIG_KPROBE_EVENTS=y
# CONFIG_KPROBE_EVENTS_ON_NOTRACE is not set
CONFIG_UPROBE_EVENTS=y
CONFIG_BPF_EVENTS=y
CONFIG_DYNAMIC_EVENTS=y
CONFIG_PROBE_EVENTS=y
# CONFIG_BPF_KPROBE_OVERRIDE is not set
CONFIG_FTRACE_MCOUNT_RECORD=y
CONFIG_FTRACE_MCOUNT_USE_RECORDMCOUNT=y
# CONFIG_SYNTH_EVENTS is not set
# CONFIG_TRACE_EVENT_INJECT is not set
# CONFIG_TRACEPOINT_BENCHMARK is not set
# CONFIG_RING_BUFFER_BENCHMARK is not set
# CONFIG_TRACE_EVAL_MAP_FILE is not set
CONFIG_FTRACE_RECORD_RECURSION=y
CONFIG_FTRACE_RECORD_RECURSION_SIZE=128
CONFIG_RING_BUFFER_RECORD_RECURSION=y
# CONFIG_FTRACE_STARTUP_TEST is not set
# CONFIG_RING_BUFFER_STARTUP_TEST is not set
# CONFIG_RING_BUFFER_VALIDATE_TIME_DELTAS is not set
# CONFIG_PREEMPTIRQ_DELAY_TEST is not set
# CONFIG_KPROBE_EVENT_GEN_TEST is not set
# CONFIG_SAMPLES is not set
# CONFIG_STRICT_DEVMEM is not set

#
# riscv Debugging
#
# end of riscv Debugging

#
# Kernel Testing and Coverage
#
# CONFIG_KUNIT is not set
# CONFIG_NOTIFIER_ERROR_INJECTION is not set
CONFIG_FUNCTION_ERROR_INJECTION=y
# CONFIG_FAULT_INJECTION is not set
CONFIG_ARCH_HAS_KCOV=y
CONFIG_CC_HAS_SANCOV_TRACE_PC=y
# CONFIG_KCOV is not set
# CONFIG_RUNTIME_TESTING_MENU is not set
CONFIG_ARCH_USE_MEMTEST=y
# CONFIG_MEMTEST is not set
# end of Kernel Testing and Coverage
# end of Kernel hacking

[-- Attachment #3: Type: text/plain, Size: 161 bytes --]

_______________________________________________
linux-riscv mailing list
linux-riscv@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-riscv

^ permalink raw reply	[flat|nested] 21+ messages in thread

* Re: riscv: llvm-compiler: calling convention violation: temporary register $t2 is used to pass the ninth function parameter
  2022-05-13  3:46             ` Changbin Du
@ 2022-05-13 19:39               ` Nick Desaulniers
  -1 siblings, 0 replies; 21+ messages in thread
From: Nick Desaulniers @ 2022-05-13 19:39 UTC (permalink / raw)
  To: Changbin Du
  Cc: Craig Topper, Alex Bradbury, Albert Ou, Palmer Dabbelt,
	Paul Walmsley, Steven Rostedt, hw.huiwang, linux-kernel,
	linux-riscv, llvm

On Thu, May 12, 2022 at 8:46 PM Changbin Du <changbin.du@huawei.com> wrote:
>
> On Thu, May 12, 2022 at 07:49:41AM -0700, Craig Topper wrote:
> > Changbin, can you provide a pre-processed source and a command line? I can
> > reduce it on the llvm side.
> >
>
> hmm, clang can not build the preprocessed source by itself!

Sorry, I should have provided more info.

In order to get the preprocessed source, you generally can do:

$ ARCH=riscv make LLVM=1 -j$(nproc) defconfig lib/string.i

replace the final command line parameter with the path to the source
file you care about.

Then, to get the command line invocation, you can do:

$ ARCH=riscv make LLVM=1 -j$(nproc) lib/string.o V=1

Then you can provide the output of those two commands.
-- 
Thanks,
~Nick Desaulniers

^ permalink raw reply	[flat|nested] 21+ messages in thread

* Re: riscv: llvm-compiler: calling convention violation: temporary register $t2 is used to pass the ninth function parameter
@ 2022-05-13 19:39               ` Nick Desaulniers
  0 siblings, 0 replies; 21+ messages in thread
From: Nick Desaulniers @ 2022-05-13 19:39 UTC (permalink / raw)
  To: Changbin Du
  Cc: Craig Topper, Alex Bradbury, Albert Ou, Palmer Dabbelt,
	Paul Walmsley, Steven Rostedt, hw.huiwang, linux-kernel,
	linux-riscv, llvm

On Thu, May 12, 2022 at 8:46 PM Changbin Du <changbin.du@huawei.com> wrote:
>
> On Thu, May 12, 2022 at 07:49:41AM -0700, Craig Topper wrote:
> > Changbin, can you provide a pre-processed source and a command line? I can
> > reduce it on the llvm side.
> >
>
> hmm, clang can not build the preprocessed source by itself!

Sorry, I should have provided more info.

In order to get the preprocessed source, you generally can do:

$ ARCH=riscv make LLVM=1 -j$(nproc) defconfig lib/string.i

replace the final command line parameter with the path to the source
file you care about.

Then, to get the command line invocation, you can do:

$ ARCH=riscv make LLVM=1 -j$(nproc) lib/string.o V=1

Then you can provide the output of those two commands.
-- 
Thanks,
~Nick Desaulniers

_______________________________________________
linux-riscv mailing list
linux-riscv@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-riscv

^ permalink raw reply	[flat|nested] 21+ messages in thread

* Re: riscv: llvm-compiler: calling convention violation: temporary register $t2 is used to pass the ninth function parameter
  2022-05-13 19:39               ` Nick Desaulniers
  (?)
@ 2022-05-16  2:59               ` Changbin Du
  -1 siblings, 0 replies; 21+ messages in thread
From: Changbin Du @ 2022-05-16  2:59 UTC (permalink / raw)
  To: Nick Desaulniers
  Cc: Changbin Du, Craig Topper, Alex Bradbury, Albert Ou,
	Palmer Dabbelt, Paul Walmsley, Steven Rostedt, hw.huiwang,
	linux-kernel, linux-riscv, llvm

[-- Attachment #1: Type: text/plain, Size: 2150 bytes --]

On Fri, May 13, 2022 at 12:39:55PM -0700, Nick Desaulniers wrote:
> On Thu, May 12, 2022 at 8:46 PM Changbin Du <changbin.du@huawei.com> wrote:
> >
> > On Thu, May 12, 2022 at 07:49:41AM -0700, Craig Topper wrote:
> > > Changbin, can you provide a pre-processed source and a command line? I can
> > > reduce it on the llvm side.
> > >
> >
> > hmm, clang can not build the preprocessed source by itself!
> 
> Sorry, I should have provided more info.
> 
> In order to get the preprocessed source, you generally can do:
> 
> $ ARCH=riscv make LLVM=1 -j$(nproc) defconfig lib/string.i
> 
> replace the final command line parameter with the path to the source
> file you care about.
> 
> Then, to get the command line invocation, you can do:
> 
> $ ARCH=riscv make LLVM=1 -j$(nproc) lib/string.o V=1
> 
> Then you can provide the output of those two commands.
> -- 
> Thanks,
> ~Nick Desaulniers

No problem, I know this tricks. Please check attached file, and build it with:
$ /opt/llvm-13.0.0/bin/clang -nostdinc -Qunused-arguments -Wall -Wundef  -Wno-trigraphs -fno-strict-aliasing -fno-common -fshort-wchar -fno-PIE -Werror=implicit-function-declaration -Werror=implicit-int -Werror=return-type -Wno-format-security -std=gnu11 --target=riscv64-linux-gnu -fintegrated-as -Werror=unknown-warning-option -Werror=ignored-optimization-argument -mabi=lp64 -mno-relax -march=rv64imac -mno-save-restore -mcmodel=medany -fno-omit-frame-pointer -fno-delete-null-pointer-checks -Wno-frame-address -Wno-address-of-packed-member -O2 -Wframe-larger-than=2048 -fstack-protector-strong -Wno-gnu -Wno-unused-but-set-variable -Wno-unused-const-variable -fno-omit-frame-pointer -fno-optimize-sibling-calls -fno-stack-clash-protection -fpatchable-function-entry=8 -Wdeclaration-after-statement -Wvla -Wno-pointer-sign -Wcast-function-type -fno-strict-overflow -fno-stack-check -Werror=date-time -Werror=incompatible-pointer-types -Wno-initializer-overrides -Wno-format -Wno-sign-compare -Wno-format-zero-length -Wno-pointer-to-enum-cast -Wno-tautological-constant-out-of-range-compare -g   -c -o route.o route.i

-- 
Cheers,
Changbin Du

[-- Attachment #2: route.i --]
[-- Type: text/plain, Size: 4493865 bytes --]

# 1 "net/ipv6/route.c"\r
# 1 "<built-in>" 1\r
# 1 "<built-in>" 3\r
# 352 "<built-in>" 3\r
# 1 "<command line>" 1\r
# 1 "<built-in>" 2\r
# 1 "././include/linux/compiler-version.h" 1\r
# 2 "<built-in>" 2\r
# 1 "././include/linux/kconfig.h" 1\r
\r
\r
\r
\r
# 1 "./include/generated/autoconf.h" 1\r
# 6 "././include/linux/kconfig.h" 2\r
# 3 "<built-in>" 2\r
# 1 "././include/linux/compiler_types.h" 1\r
# 73 "././include/linux/compiler_types.h"\r
# 1 "./include/linux/compiler_attributes.h" 1\r
# 74 "././include/linux/compiler_types.h" 2\r
# 88 "././include/linux/compiler_types.h"\r
# 1 "./include/linux/compiler-clang.h" 1\r
# 89 "././include/linux/compiler_types.h" 2\r
# 110 "././include/linux/compiler_types.h"\r
struct ftrace_branch_data {\r
 const char *func;\r
 const char *file;\r
 unsigned line;\r
 union {\r
  struct {\r
   unsigned long correct;\r
   unsigned long incorrect;\r
  };\r
  struct {\r
   unsigned long miss;\r
   unsigned long hit;\r
  };\r
  unsigned long miss_hit[2];\r
 };\r
};\r
\r
struct ftrace_likely_data {\r
 struct ftrace_branch_data data;\r
 unsigned long constant;\r
};\r
# 4 "<built-in>" 2\r
# 1 "net/ipv6/route.c" 2\r
# 25 "net/ipv6/route.c"\r
# 1 "./include/linux/capability.h" 1\r
# 16 "./include/linux/capability.h"\r
# 1 "./include/uapi/linux/capability.h" 1\r
# 17 "./include/uapi/linux/capability.h"\r
# 1 "./include/linux/types.h" 1\r
\r
\r
\r
\r
\r
# 1 "./include/uapi/linux/types.h" 1\r
\r
\r
\r
\r
# 1 "./arch/riscv/include/generated/uapi/asm/types.h" 1\r
# 1 "./include/uapi/asm-generic/types.h" 1\r
\r
\r
\r
\r
\r
\r
# 1 "./include/asm-generic/int-ll64.h" 1\r
# 11 "./include/asm-generic/int-ll64.h"\r
# 1 "./include/uapi/asm-generic/int-ll64.h" 1\r
# 12 "./include/uapi/asm-generic/int-ll64.h"\r
# 1 "./arch/riscv/include/uapi/asm/bitsperlong.h" 1\r
# 12 "./arch/riscv/include/uapi/asm/bitsperlong.h"\r
# 1 "./include/asm-generic/bitsperlong.h" 1\r
\r
\r
\r
\r
# 1 "./include/uapi/asm-generic/bitsperlong.h" 1\r
# 6 "./include/asm-generic/bitsperlong.h" 2\r
# 13 "./arch/riscv/include/uapi/asm/bitsperlong.h" 2\r
# 13 "./include/uapi/asm-generic/int-ll64.h" 2\r
\r
\r
\r
\r
\r
\r
\r
typedef __signed__ char __s8;\r
typedef unsigned char __u8;\r
\r
typedef __signed__ short __s16;\r
typedef unsigned short __u16;\r
\r
typedef __signed__ int __s32;\r
typedef unsigned int __u32;\r
\r
\r
__extension__ typedef __signed__ long long __s64;\r
__extension__ typedef unsigned long long __u64;\r
# 12 "./include/asm-generic/int-ll64.h" 2\r
\r
\r
\r
\r
typedef __s8 s8;\r
typedef __u8 u8;\r
typedef __s16 s16;\r
typedef __u16 u16;\r
typedef __s32 s32;\r
typedef __u32 u32;\r
typedef __s64 s64;\r
typedef __u64 u64;\r
# 8 "./include/uapi/asm-generic/types.h" 2\r
# 2 "./arch/riscv/include/generated/uapi/asm/types.h" 2\r
# 6 "./include/uapi/linux/types.h" 2\r
\r
\r
\r
\r
\r
\r
\r
\r
# 1 "./include/uapi/linux/posix_types.h" 1\r
\r
\r
\r
\r
# 1 "./include/linux/stddef.h" 1\r
\r
\r
\r
\r
# 1 "./include/uapi/linux/stddef.h" 1\r
# 6 "./include/linux/stddef.h" 2\r
\r
\r
\r
\r
enum {\r
 false = 0,\r
 true = 1\r
};\r
# 6 "./include/uapi/linux/posix_types.h" 2\r
# 25 "./include/uapi/linux/posix_types.h"\r
typedef struct {\r
 unsigned long fds_bits[1024 / (8 * sizeof(long))];\r
} __kernel_fd_set;\r
\r
\r
typedef void (*__kernel_sighandler_t)(int);\r
\r
\r
typedef int __kernel_key_t;\r
typedef int __kernel_mqd_t;\r
\r
\r
# 1 "./arch/riscv/include/generated/uapi/asm/posix_types.h" 1\r
# 1 "./include/uapi/asm-generic/posix_types.h" 1\r
# 15 "./include/uapi/asm-generic/posix_types.h"\r
typedef long __kernel_long_t;\r
typedef unsigned long __kernel_ulong_t;\r
\r
\r
\r
typedef __kernel_ulong_t __kernel_ino_t;\r
\r
\r
\r
typedef unsigned int __kernel_mode_t;\r
\r
\r
\r
typedef int __kernel_pid_t;\r
\r
\r
\r
typedef int __kernel_ipc_pid_t;\r
\r
\r
\r
typedef unsigned int __kernel_uid_t;\r
typedef unsigned int __kernel_gid_t;\r
\r
\r
\r
typedef __kernel_long_t __kernel_suseconds_t;\r
\r
\r
\r
typedef int __kernel_daddr_t;\r
\r
\r
\r
typedef unsigned int __kernel_uid32_t;\r
typedef unsigned int __kernel_gid32_t;\r
\r
\r
\r
typedef __kernel_uid_t __kernel_old_uid_t;\r
typedef __kernel_gid_t __kernel_old_gid_t;\r
\r
\r
\r
typedef unsigned int __kernel_old_dev_t;\r
# 72 "./include/uapi/asm-generic/posix_types.h"\r
typedef __kernel_ulong_t __kernel_size_t;\r
typedef __kernel_long_t __kernel_ssize_t;\r
typedef __kernel_long_t __kernel_ptrdiff_t;\r
\r
\r
\r
\r
typedef struct {\r
 int val[2];\r
} __kernel_fsid_t;\r
\r
\r
\r
\r
\r
typedef __kernel_long_t __kernel_off_t;\r
typedef long long __kernel_loff_t;\r
typedef __kernel_long_t __kernel_old_time_t;\r
\r
\r
\r
typedef long long __kernel_time64_t;\r
typedef __kernel_long_t __kernel_clock_t;\r
typedef int __kernel_timer_t;\r
typedef int __kernel_clockid_t;\r
typedef char * __kernel_caddr_t;\r
typedef unsigned short __kernel_uid16_t;\r
typedef unsigned short __kernel_gid16_t;\r
# 2 "./arch/riscv/include/generated/uapi/asm/posix_types.h" 2\r
# 37 "./include/uapi/linux/posix_types.h" 2\r
# 15 "./include/uapi/linux/types.h" 2\r
# 29 "./include/uapi/linux/types.h"\r
typedef __u16 __le16;\r
typedef __u16 __be16;\r
typedef __u32 __le32;\r
typedef __u32 __be32;\r
typedef __u64 __le64;\r
typedef __u64 __be64;\r
\r
typedef __u16 __sum16;\r
typedef __u32 __wsum;\r
# 52 "./include/uapi/linux/types.h"\r
typedef unsigned __poll_t;\r
# 7 "./include/linux/types.h" 2\r
\r
\r
\r
\r
\r
\r
typedef u32 __kernel_dev_t;\r
\r
typedef __kernel_fd_set fd_set;\r
typedef __kernel_dev_t dev_t;\r
typedef __kernel_ulong_t ino_t;\r
typedef __kernel_mode_t mode_t;\r
typedef unsigned short umode_t;\r
typedef u32 nlink_t;\r
typedef __kernel_off_t off_t;\r
typedef __kernel_pid_t pid_t;\r
typedef __kernel_daddr_t daddr_t;\r
typedef __kernel_key_t key_t;\r
typedef __kernel_suseconds_t suseconds_t;\r
typedef __kernel_timer_t timer_t;\r
typedef __kernel_clockid_t clockid_t;\r
typedef __kernel_mqd_t mqd_t;\r
\r
typedef _Bool bool;\r
\r
typedef __kernel_uid32_t uid_t;\r
typedef __kernel_gid32_t gid_t;\r
typedef __kernel_uid16_t uid16_t;\r
typedef __kernel_gid16_t gid16_t;\r
\r
typedef unsigned long uintptr_t;\r
# 46 "./include/linux/types.h"\r
typedef __kernel_loff_t loff_t;\r
# 55 "./include/linux/types.h"\r
typedef __kernel_size_t size_t;\r
\r
\r
\r
\r
typedef __kernel_ssize_t ssize_t;\r
\r
\r
\r
\r
typedef __kernel_ptrdiff_t ptrdiff_t;\r
\r
\r
\r
\r
typedef __kernel_clock_t clock_t;\r
\r
\r
\r
\r
typedef __kernel_caddr_t caddr_t;\r
\r
\r
\r
typedef unsigned char u_char;\r
typedef unsigned short u_short;\r
typedef unsigned int u_int;\r
typedef unsigned long u_long;\r
\r
\r
typedef unsigned char unchar;\r
typedef unsigned short ushort;\r
typedef unsigned int uint;\r
typedef unsigned long ulong;\r
\r
\r
\r
\r
typedef u8 u_int8_t;\r
typedef s8 int8_t;\r
typedef u16 u_int16_t;\r
typedef s16 int16_t;\r
typedef u32 u_int32_t;\r
typedef s32 int32_t;\r
\r
\r
\r
typedef u8 uint8_t;\r
typedef u16 uint16_t;\r
typedef u32 uint32_t;\r
\r
\r
typedef u64 uint64_t;\r
typedef u64 u_int64_t;\r
typedef s64 int64_t;\r
# 125 "./include/linux/types.h"\r
typedef u64 sector_t;\r
typedef u64 blkcnt_t;\r
# 143 "./include/linux/types.h"\r
typedef u64 dma_addr_t;\r
\r
\r
\r
\r
typedef unsigned int gfp_t;\r
typedef unsigned int slab_flags_t;\r
typedef unsigned int fmode_t;\r
\r
\r
typedef u64 phys_addr_t;\r
\r
\r
\r
\r
typedef phys_addr_t resource_size_t;\r
\r
\r
\r
\r
\r
typedef unsigned long irq_hw_number_t;\r
\r
typedef struct {\r
 int counter;\r
} atomic_t;\r
\r
\r
\r
\r
typedef struct {\r
 s64 counter;\r
} atomic64_t;\r
\r
\r
struct list_head {\r
 struct list_head *next, *prev;\r
};\r
\r
struct hlist_head {\r
 struct hlist_node *first;\r
};\r
\r
struct hlist_node {\r
 struct hlist_node *next, **pprev;\r
};\r
\r
struct ustat {\r
 __kernel_daddr_t f_tfree;\r
\r
\r
\r
 unsigned long f_tinode;\r
\r
 char f_fname[6];\r
 char f_fpack[6];\r
};\r
# 220 "./include/linux/types.h"\r
struct callback_head {\r
 struct callback_head *next;\r
 void (*func)(struct callback_head *head);\r
} __attribute__((aligned(sizeof(void *))));\r
\r
\r
typedef void (*rcu_callback_t)(struct callback_head *head);\r
typedef void (*call_rcu_func_t)(struct callback_head *head, rcu_callback_t func);\r
\r
typedef void (*swap_r_func_t)(void *a, void *b, int size, const void *priv);\r
typedef void (*swap_func_t)(void *a, void *b, int size);\r
\r
typedef int (*cmp_r_func_t)(const void *a, const void *b, const void *priv);\r
typedef int (*cmp_func_t)(const void *a, const void *b);\r
# 18 "./include/uapi/linux/capability.h" 2\r
# 39 "./include/uapi/linux/capability.h"\r
typedef struct __user_cap_header_struct {\r
 __u32 version;\r
 int pid;\r
} *cap_user_header_t;\r
\r
typedef struct __user_cap_data_struct {\r
        __u32 effective;\r
        __u32 permitted;\r
        __u32 inheritable;\r
} *cap_user_data_t;\r
# 72 "./include/uapi/linux/capability.h"\r
struct vfs_cap_data {\r
 __le32 magic_etc;\r
 struct {\r
  __le32 permitted;\r
  __le32 inheritable;\r
 } data[2];\r
};\r
\r
\r
\r
\r
struct vfs_ns_cap_data {\r
 __le32 magic_etc;\r
 struct {\r
  __le32 permitted;\r
  __le32 inheritable;\r
 } data[2];\r
 __le32 rootid;\r
};\r
# 17 "./include/linux/capability.h" 2\r
# 1 "./include/linux/uidgid.h" 1\r
# 16 "./include/linux/uidgid.h"\r
# 1 "./include/linux/highuid.h" 1\r
# 35 "./include/linux/highuid.h"\r
extern int overflowuid;\r
extern int overflowgid;\r
\r
extern void __bad_uid(void);\r
extern void __bad_gid(void);\r
# 82 "./include/linux/highuid.h"\r
extern int fs_overflowuid;\r
extern int fs_overflowgid;\r
# 17 "./include/linux/uidgid.h" 2\r
\r
struct user_namespace;\r
extern struct user_namespace init_user_ns;\r
\r
typedef struct {\r
 uid_t val;\r
} kuid_t;\r
\r
\r
typedef struct {\r
 gid_t val;\r
} kgid_t;\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) uid_t __kuid_val(kuid_t uid)\r
{\r
 return uid.val;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) gid_t __kgid_val(kgid_t gid)\r
{\r
 return gid.val;\r
}\r
# 61 "./include/linux/uidgid.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool uid_eq(kuid_t left, kuid_t right)\r
{\r
 return __kuid_val(left) == __kuid_val(right);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool gid_eq(kgid_t left, kgid_t right)\r
{\r
 return __kgid_val(left) == __kgid_val(right);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool uid_gt(kuid_t left, kuid_t right)\r
{\r
 return __kuid_val(left) > __kuid_val(right);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool gid_gt(kgid_t left, kgid_t right)\r
{\r
 return __kgid_val(left) > __kgid_val(right);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool uid_gte(kuid_t left, kuid_t right)\r
{\r
 return __kuid_val(left) >= __kuid_val(right);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool gid_gte(kgid_t left, kgid_t right)\r
{\r
 return __kgid_val(left) >= __kgid_val(right);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool uid_lt(kuid_t left, kuid_t right)\r
{\r
 return __kuid_val(left) < __kuid_val(right);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool gid_lt(kgid_t left, kgid_t right)\r
{\r
 return __kgid_val(left) < __kgid_val(right);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool uid_lte(kuid_t left, kuid_t right)\r
{\r
 return __kuid_val(left) <= __kuid_val(right);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool gid_lte(kgid_t left, kgid_t right)\r
{\r
 return __kgid_val(left) <= __kgid_val(right);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool uid_valid(kuid_t uid)\r
{\r
 return __kuid_val(uid) != (uid_t) -1;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool gid_valid(kgid_t gid)\r
{\r
 return __kgid_val(gid) != (gid_t) -1;\r
}\r
\r
\r
\r
extern kuid_t make_kuid(struct user_namespace *from, uid_t uid);\r
extern kgid_t make_kgid(struct user_namespace *from, gid_t gid);\r
\r
extern uid_t from_kuid(struct user_namespace *to, kuid_t uid);\r
extern gid_t from_kgid(struct user_namespace *to, kgid_t gid);\r
extern uid_t from_kuid_munged(struct user_namespace *to, kuid_t uid);\r
extern gid_t from_kgid_munged(struct user_namespace *to, kgid_t gid);\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool kuid_has_mapping(struct user_namespace *ns, kuid_t uid)\r
{\r
 return from_kuid(ns, uid) != (uid_t) -1;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool kgid_has_mapping(struct user_namespace *ns, kgid_t gid)\r
{\r
 return from_kgid(ns, gid) != (gid_t) -1;\r
}\r
# 18 "./include/linux/capability.h" 2\r
\r
\r
\r
\r
extern int file_caps_enabled;\r
\r
typedef struct kernel_cap_struct {\r
 __u32 cap[2];\r
} kernel_cap_t;\r
\r
\r
struct cpu_vfs_cap_data {\r
 __u32 magic_etc;\r
 kernel_cap_t permitted;\r
 kernel_cap_t inheritable;\r
 kuid_t rootid;\r
};\r
\r
\r
\r
\r
\r
struct file;\r
struct inode;\r
struct dentry;\r
struct task_struct;\r
struct user_namespace;\r
\r
extern const kernel_cap_t __cap_empty_set;\r
extern const kernel_cap_t __cap_init_eff_set;\r
# 118 "./include/linux/capability.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) kernel_cap_t cap_combine(const kernel_cap_t a,\r
           const kernel_cap_t b)\r
{\r
 kernel_cap_t dest;\r
 do { unsigned __capi; for (__capi = 0; __capi < 2; ++__capi) { dest.cap[__capi] = a.cap[__capi] | b.cap[__capi]; } } while (0);\r
 return dest;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) kernel_cap_t cap_intersect(const kernel_cap_t a,\r
      const kernel_cap_t b)\r
{\r
 kernel_cap_t dest;\r
 do { unsigned __capi; for (__capi = 0; __capi < 2; ++__capi) { dest.cap[__capi] = a.cap[__capi] & b.cap[__capi]; } } while (0);\r
 return dest;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) kernel_cap_t cap_drop(const kernel_cap_t a,\r
        const kernel_cap_t drop)\r
{\r
 kernel_cap_t dest;\r
 do { unsigned __capi; for (__capi = 0; __capi < 2; ++__capi) { dest.cap[__capi] = a.cap[__capi] &~ drop.cap[__capi]; } } while (0);\r
 return dest;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) kernel_cap_t cap_invert(const kernel_cap_t c)\r
{\r
 kernel_cap_t dest;\r
 do { unsigned __capi; for (__capi = 0; __capi < 2; ++__capi) { dest.cap[__capi] = ~ c.cap[__capi]; } } while (0);\r
 return dest;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool cap_isclear(const kernel_cap_t a)\r
{\r
 unsigned __capi;\r
 for (__capi = 0; __capi < 2; ++__capi) {\r
  if (a.cap[__capi] != 0)\r
   return false;\r
 }\r
 return true;\r
}\r
# 166 "./include/linux/capability.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool cap_issubset(const kernel_cap_t a, const kernel_cap_t set)\r
{\r
 kernel_cap_t dest;\r
 dest = cap_drop(a, set);\r
 return cap_isclear(dest);\r
}\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) kernel_cap_t cap_drop_fs_set(const kernel_cap_t a)\r
{\r
 const kernel_cap_t __cap_fs_set = ((kernel_cap_t){{ ((1 << ((0) & 31)) | (1 << ((27) & 31)) | (1 << ((1) & 31)) | (1 << ((2) & 31)) | (1 << ((3) & 31)) | (1 << ((4) & 31))) | (1 << ((9) & 31)), ((1 << ((32) & 31))) } });\r
 return cap_drop(a, __cap_fs_set);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) kernel_cap_t cap_raise_fs_set(const kernel_cap_t a,\r
         const kernel_cap_t permitted)\r
{\r
 const kernel_cap_t __cap_fs_set = ((kernel_cap_t){{ ((1 << ((0) & 31)) | (1 << ((27) & 31)) | (1 << ((1) & 31)) | (1 << ((2) & 31)) | (1 << ((3) & 31)) | (1 << ((4) & 31))) | (1 << ((9) & 31)), ((1 << ((32) & 31))) } });\r
 return cap_combine(a,\r
      cap_intersect(permitted, __cap_fs_set));\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) kernel_cap_t cap_drop_nfsd_set(const kernel_cap_t a)\r
{\r
 const kernel_cap_t __cap_fs_set = ((kernel_cap_t){{ ((1 << ((0) & 31)) | (1 << ((27) & 31)) | (1 << ((1) & 31)) | (1 << ((2) & 31)) | (1 << ((3) & 31)) | (1 << ((4) & 31))) | (1 << ((24) & 31)), ((1 << ((32) & 31))) } });\r
 return cap_drop(a, __cap_fs_set);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) kernel_cap_t cap_raise_nfsd_set(const kernel_cap_t a,\r
           const kernel_cap_t permitted)\r
{\r
 const kernel_cap_t __cap_nfsd_set = ((kernel_cap_t){{ ((1 << ((0) & 31)) | (1 << ((27) & 31)) | (1 << ((1) & 31)) | (1 << ((2) & 31)) | (1 << ((3) & 31)) | (1 << ((4) & 31))) | (1 << ((24) & 31)), ((1 << ((32) & 31))) } });\r
 return cap_combine(a,\r
      cap_intersect(permitted, __cap_nfsd_set));\r
}\r
\r
\r
extern bool has_capability(struct task_struct *t, int cap);\r
extern bool has_ns_capability(struct task_struct *t,\r
         struct user_namespace *ns, int cap);\r
extern bool has_capability_noaudit(struct task_struct *t, int cap);\r
extern bool has_ns_capability_noaudit(struct task_struct *t,\r
          struct user_namespace *ns, int cap);\r
extern bool capable(int cap);\r
extern bool ns_capable(struct user_namespace *ns, int cap);\r
extern bool ns_capable_noaudit(struct user_namespace *ns, int cap);\r
extern bool ns_capable_setid(struct user_namespace *ns, int cap);\r
# 250 "./include/linux/capability.h"\r
bool privileged_wrt_inode_uidgid(struct user_namespace *ns,\r
     struct user_namespace *mnt_userns,\r
     const struct inode *inode);\r
bool capable_wrt_inode_uidgid(struct user_namespace *mnt_userns,\r
         const struct inode *inode, int cap);\r
extern bool file_ns_capable(const struct file *file, struct user_namespace *ns, int cap);\r
extern bool ptracer_capable(struct task_struct *tsk, struct user_namespace *ns);\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool perfmon_capable(void)\r
{\r
 return capable(38) || capable(21);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool bpf_capable(void)\r
{\r
 return capable(39) || capable(21);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool checkpoint_restore_ns_capable(struct user_namespace *ns)\r
{\r
 return ns_capable(ns, 40) ||\r
  ns_capable(ns, 21);\r
}\r
\r
\r
int get_vfs_caps_from_disk(struct user_namespace *mnt_userns,\r
      const struct dentry *dentry,\r
      struct cpu_vfs_cap_data *cpu_caps);\r
\r
int cap_convert_nscap(struct user_namespace *mnt_userns, struct dentry *dentry,\r
        const void **ivalue, size_t size);\r
# 26 "net/ipv6/route.c" 2\r
# 1 "./include/linux/errno.h" 1\r
\r
\r
\r
\r
# 1 "./include/uapi/linux/errno.h" 1\r
# 1 "./arch/riscv/include/generated/uapi/asm/errno.h" 1\r
# 1 "./include/uapi/asm-generic/errno.h" 1\r
\r
\r
\r
\r
# 1 "./include/uapi/asm-generic/errno-base.h" 1\r
# 6 "./include/uapi/asm-generic/errno.h" 2\r
# 2 "./arch/riscv/include/generated/uapi/asm/errno.h" 2\r
# 2 "./include/uapi/linux/errno.h" 2\r
# 6 "./include/linux/errno.h" 2\r
# 27 "net/ipv6/route.c" 2\r
# 1 "./include/linux/export.h" 1\r
# 72 "./include/linux/export.h"\r
struct kernel_symbol {\r
 unsigned long value;\r
 const char *name;\r
 const char *namespace;\r
};\r
# 28 "net/ipv6/route.c" 2\r
\r
# 1 "./include/uapi/linux/times.h" 1\r
\r
\r
\r
\r
\r
\r
struct tms {\r
 __kernel_clock_t tms_utime;\r
 __kernel_clock_t tms_stime;\r
 __kernel_clock_t tms_cutime;\r
 __kernel_clock_t tms_cstime;\r
};\r
# 30 "net/ipv6/route.c" 2\r
# 1 "./include/linux/socket.h" 1\r
\r
\r
\r
\r
\r
# 1 "./arch/riscv/include/generated/uapi/asm/socket.h" 1\r
# 1 "./include/uapi/asm-generic/socket.h" 1\r
\r
\r
\r
\r
\r
# 1 "./arch/riscv/include/generated/uapi/asm/sockios.h" 1\r
# 1 "./include/uapi/asm-generic/sockios.h" 1\r
# 2 "./arch/riscv/include/generated/uapi/asm/sockios.h" 2\r
# 7 "./include/uapi/asm-generic/socket.h" 2\r
# 2 "./arch/riscv/include/generated/uapi/asm/socket.h" 2\r
# 7 "./include/linux/socket.h" 2\r
# 1 "./include/uapi/linux/sockios.h" 1\r
# 23 "./include/uapi/linux/sockios.h"\r
# 1 "./arch/riscv/include/generated/uapi/asm/sockios.h" 1\r
# 24 "./include/uapi/linux/sockios.h" 2\r
# 8 "./include/linux/socket.h" 2\r
# 1 "./include/linux/uio.h" 1\r
\r
\r
\r
\r
\r
\r
\r
# 1 "./include/linux/kernel.h" 1\r
# 14 "./include/linux/kernel.h"\r
# 1 "./include/linux/stdarg.h" 1\r
\r
\r
\r
\r
typedef __builtin_va_list va_list;\r
# 15 "./include/linux/kernel.h" 2\r
# 1 "./include/linux/align.h" 1\r
\r
\r
\r
\r
# 1 "./include/linux/const.h" 1\r
\r
\r
\r
# 1 "./include/vdso/const.h" 1\r
\r
\r
\r
\r
# 1 "./include/uapi/linux/const.h" 1\r
# 6 "./include/vdso/const.h" 2\r
# 5 "./include/linux/const.h" 2\r
# 6 "./include/linux/align.h" 2\r
# 16 "./include/linux/kernel.h" 2\r
# 1 "./include/linux/limits.h" 1\r
\r
\r
\r
\r
# 1 "./include/uapi/linux/limits.h" 1\r
# 6 "./include/linux/limits.h" 2\r
\r
# 1 "./include/vdso/limits.h" 1\r
# 8 "./include/linux/limits.h" 2\r
# 17 "./include/linux/kernel.h" 2\r
# 1 "./include/linux/linkage.h" 1\r
\r
\r
\r
\r
\r
# 1 "./include/linux/stringify.h" 1\r
# 7 "./include/linux/linkage.h" 2\r
\r
# 1 "./arch/riscv/include/asm/linkage.h" 1\r
# 9 "./include/linux/linkage.h" 2\r
# 18 "./include/linux/kernel.h" 2\r
\r
\r
# 1 "./include/linux/compiler.h" 1\r
# 232 "./include/linux/compiler.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void *offset_to_ptr(const int *off)\r
{\r
 return (void *)((unsigned long)off + *off);\r
}\r
# 248 "./include/linux/compiler.h"\r
# 1 "./arch/riscv/include/generated/asm/rwonce.h" 1\r
# 1 "./include/asm-generic/rwonce.h" 1\r
# 26 "./include/asm-generic/rwonce.h"\r
# 1 "./include/linux/kasan-checks.h" 1\r
# 22 "./include/linux/kasan-checks.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool __kasan_check_read(const volatile void *p, unsigned int size)\r
{\r
 return true;\r
}\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool __kasan_check_write(const volatile void *p, unsigned int size)\r
{\r
 return true;\r
}\r
# 40 "./include/linux/kasan-checks.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool kasan_check_read(const volatile void *p, unsigned int size)\r
{\r
 return true;\r
}\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool kasan_check_write(const volatile void *p, unsigned int size)\r
{\r
 return true;\r
}\r
# 27 "./include/asm-generic/rwonce.h" 2\r
# 1 "./include/linux/kcsan-checks.h" 1\r
# 189 "./include/linux/kcsan-checks.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __kcsan_check_access(const volatile void *ptr, size_t size,\r
     int type) { }\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __kcsan_mb(void) { }\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __kcsan_wmb(void) { }\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __kcsan_rmb(void) { }\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __kcsan_release(void) { }\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void kcsan_disable_current(void) { }\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void kcsan_enable_current(void) { }\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void kcsan_enable_current_nowarn(void) { }\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void kcsan_nestable_atomic_begin(void) { }\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void kcsan_nestable_atomic_end(void) { }\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void kcsan_flat_atomic_begin(void) { }\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void kcsan_flat_atomic_end(void) { }\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void kcsan_atomic_next(int n) { }\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void kcsan_set_access_mask(unsigned long mask) { }\r
\r
struct kcsan_scoped_access { };\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) struct kcsan_scoped_access *\r
kcsan_begin_scoped_access(const volatile void *ptr, size_t size, int type,\r
     struct kcsan_scoped_access *sa) { return sa; }\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void kcsan_end_scoped_access(struct kcsan_scoped_access *sa) { }\r
# 229 "./include/linux/kcsan-checks.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void kcsan_check_access(const volatile void *ptr, size_t size,\r
          int type) { }\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __kcsan_enable_current(void) { }\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __kcsan_disable_current(void) { }\r
# 28 "./include/asm-generic/rwonce.h" 2\r
# 64 "./include/asm-generic/rwonce.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__))\r
unsigned long __read_once_word_nocheck(const void *addr)\r
{\r
 return (*(const volatile typeof( _Generic((*(unsigned long *)addr), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (*(unsigned long *)addr))) *)&(*(unsigned long *)addr));\r
}\r
# 82 "./include/asm-generic/rwonce.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__))\r
unsigned long read_word_at_a_time(const void *addr)\r
{\r
 kasan_check_read(addr, 1);\r
 return *(unsigned long *)addr;\r
}\r
# 2 "./arch/riscv/include/generated/asm/rwonce.h" 2\r
# 249 "./include/linux/compiler.h" 2\r
# 21 "./include/linux/kernel.h" 2\r
# 1 "./include/linux/container_of.h" 1\r
\r
\r
\r
\r
# 1 "./include/linux/build_bug.h" 1\r
# 6 "./include/linux/container_of.h" 2\r
# 1 "./include/linux/err.h" 1\r
\r
\r
\r
\r
\r
\r
\r
# 1 "./arch/riscv/include/generated/uapi/asm/errno.h" 1\r
# 9 "./include/linux/err.h" 2\r
# 24 "./include/linux/err.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void * __attribute__((__warn_unused_result__)) ERR_PTR(long error)\r
{\r
 return (void *) error;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) long __attribute__((__warn_unused_result__)) PTR_ERR( const void *ptr)\r
{\r
 return (long) ptr;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool __attribute__((__warn_unused_result__)) IS_ERR( const void *ptr)\r
{\r
 return __builtin_expect(!!((unsigned long)(void *)((unsigned long)ptr) >= (unsigned long)-4095), 0);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool __attribute__((__warn_unused_result__)) IS_ERR_OR_NULL( const void *ptr)\r
{\r
 return __builtin_expect(!!(!ptr), 0) || __builtin_expect(!!((unsigned long)(void *)((unsigned long)ptr) >= (unsigned long)-4095), 0);\r
}\r
# 51 "./include/linux/err.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void * __attribute__((__warn_unused_result__)) ERR_CAST( const void *ptr)\r
{\r
\r
 return (void *) ptr;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int __attribute__((__warn_unused_result__)) PTR_ERR_OR_ZERO( const void *ptr)\r
{\r
 if (IS_ERR(ptr))\r
  return PTR_ERR(ptr);\r
 else\r
  return 0;\r
}\r
# 7 "./include/linux/container_of.h" 2\r
# 22 "./include/linux/kernel.h" 2\r
# 1 "./include/linux/bitops.h" 1\r
\r
\r
\r
\r
# 1 "./arch/riscv/include/generated/uapi/asm/types.h" 1\r
# 6 "./include/linux/bitops.h" 2\r
# 1 "./include/linux/bits.h" 1\r
\r
\r
\r
\r
\r
# 1 "./include/vdso/bits.h" 1\r
# 7 "./include/linux/bits.h" 2\r
# 7 "./include/linux/bitops.h" 2\r
# 1 "./include/linux/typecheck.h" 1\r
# 8 "./include/linux/bitops.h" 2\r
\r
# 1 "./include/uapi/linux/kernel.h" 1\r
\r
\r
\r
\r
# 1 "./include/uapi/linux/sysinfo.h" 1\r
\r
\r
\r
\r
\r
\r
\r
struct sysinfo {\r
 __kernel_long_t uptime;\r
 __kernel_ulong_t loads[3];\r
 __kernel_ulong_t totalram;\r
 __kernel_ulong_t freeram;\r
 __kernel_ulong_t sharedram;\r
 __kernel_ulong_t bufferram;\r
 __kernel_ulong_t totalswap;\r
 __kernel_ulong_t freeswap;\r
 __u16 procs;\r
 __u16 pad;\r
 __kernel_ulong_t totalhigh;\r
 __kernel_ulong_t freehigh;\r
 __u32 mem_unit;\r
 char _f[20-2*sizeof(__kernel_ulong_t)-sizeof(__u32)];\r
};\r
# 6 "./include/uapi/linux/kernel.h" 2\r
# 10 "./include/linux/bitops.h" 2\r
# 24 "./include/linux/bitops.h"\r
extern unsigned int __sw_hweight8(unsigned int w);\r
extern unsigned int __sw_hweight16(unsigned int w);\r
extern unsigned int __sw_hweight32(unsigned int w);\r
extern unsigned long __sw_hweight64(__u64 w);\r
\r
\r
\r
\r
\r
\r
# 1 "./arch/riscv/include/asm/bitops.h" 1\r
# 14 "./arch/riscv/include/asm/bitops.h"\r
# 1 "./include/linux/irqflags.h" 1\r
# 16 "./include/linux/irqflags.h"\r
# 1 "./arch/riscv/include/asm/irqflags.h" 1\r
# 10 "./arch/riscv/include/asm/irqflags.h"\r
# 1 "./arch/riscv/include/asm/processor.h" 1\r
# 11 "./arch/riscv/include/asm/processor.h"\r
# 1 "./include/vdso/processor.h" 1\r
# 10 "./include/vdso/processor.h"\r
# 1 "./arch/riscv/include/asm/vdso/processor.h" 1\r
\r
\r
\r
\r
\r
\r
# 1 "./arch/riscv/include/asm/barrier.h" 1\r
# 72 "./arch/riscv/include/asm/barrier.h"\r
# 1 "./include/asm-generic/barrier.h" 1\r
# 18 "./include/asm-generic/barrier.h"\r
# 1 "./arch/riscv/include/generated/asm/rwonce.h" 1\r
# 19 "./include/asm-generic/barrier.h" 2\r
# 73 "./arch/riscv/include/asm/barrier.h" 2\r
# 8 "./arch/riscv/include/asm/vdso/processor.h" 2\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void cpu_relax(void)\r
{\r
\r
 int dummy;\r
\r
 __asm__ __volatile__ ("div %0, %0, zero" : "=r" (dummy));\r
\r
 __asm__ __volatile__("": : :"memory");\r
}\r
# 11 "./include/vdso/processor.h" 2\r
# 12 "./arch/riscv/include/asm/processor.h" 2\r
\r
# 1 "./arch/riscv/include/asm/ptrace.h" 1\r
\r
\r
\r
\r
\r
\r
\r
\r
# 1 "./arch/riscv/include/uapi/asm/ptrace.h" 1\r
# 19 "./arch/riscv/include/uapi/asm/ptrace.h"\r
struct user_regs_struct {\r
 unsigned long pc;\r
 unsigned long ra;\r
 unsigned long sp;\r
 unsigned long gp;\r
 unsigned long tp;\r
 unsigned long t0;\r
 unsigned long t1;\r
 unsigned long t2;\r
 unsigned long s0;\r
 unsigned long s1;\r
 unsigned long a0;\r
 unsigned long a1;\r
 unsigned long a2;\r
 unsigned long a3;\r
 unsigned long a4;\r
 unsigned long a5;\r
 unsigned long a6;\r
 unsigned long a7;\r
 unsigned long s2;\r
 unsigned long s3;\r
 unsigned long s4;\r
 unsigned long s5;\r
 unsigned long s6;\r
 unsigned long s7;\r
 unsigned long s8;\r
 unsigned long s9;\r
 unsigned long s10;\r
 unsigned long s11;\r
 unsigned long t3;\r
 unsigned long t4;\r
 unsigned long t5;\r
 unsigned long t6;\r
};\r
\r
struct __riscv_f_ext_state {\r
 __u32 f[32];\r
 __u32 fcsr;\r
};\r
\r
struct __riscv_d_ext_state {\r
 __u64 f[32];\r
 __u32 fcsr;\r
};\r
\r
struct __riscv_q_ext_state {\r
 __u64 f[64] __attribute__((aligned(16)));\r
 __u32 fcsr;\r
\r
\r
\r
\r
 __u32 reserved[3];\r
};\r
\r
union __riscv_fp_state {\r
 struct __riscv_f_ext_state f;\r
 struct __riscv_d_ext_state d;\r
 struct __riscv_q_ext_state q;\r
};\r
# 10 "./arch/riscv/include/asm/ptrace.h" 2\r
# 1 "./arch/riscv/include/asm/csr.h" 1\r
\r
\r
\r
\r
\r
\r
\r
\r
# 1 "./arch/riscv/include/asm/asm.h" 1\r
# 10 "./arch/riscv/include/asm/csr.h" 2\r
# 11 "./arch/riscv/include/asm/ptrace.h" 2\r
\r
\r
\r
\r
struct pt_regs {\r
 unsigned long epc;\r
 unsigned long ra;\r
 unsigned long sp;\r
 unsigned long gp;\r
 unsigned long tp;\r
 unsigned long t0;\r
 unsigned long t1;\r
 unsigned long t2;\r
 unsigned long s0;\r
 unsigned long s1;\r
 unsigned long a0;\r
 unsigned long a1;\r
 unsigned long a2;\r
 unsigned long a3;\r
 unsigned long a4;\r
 unsigned long a5;\r
 unsigned long a6;\r
 unsigned long a7;\r
 unsigned long s2;\r
 unsigned long s3;\r
 unsigned long s4;\r
 unsigned long s5;\r
 unsigned long s6;\r
 unsigned long s7;\r
 unsigned long s8;\r
 unsigned long s9;\r
 unsigned long s10;\r
 unsigned long s11;\r
 unsigned long t3;\r
 unsigned long t4;\r
 unsigned long t5;\r
 unsigned long t6;\r
\r
 unsigned long status;\r
 unsigned long badaddr;\r
 unsigned long cause;\r
\r
 unsigned long orig_a0;\r
};\r
# 67 "./arch/riscv/include/asm/ptrace.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) unsigned long instruction_pointer(struct pt_regs *regs)\r
{\r
 return regs->epc;\r
}\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void instruction_pointer_set(struct pt_regs *regs,\r
        unsigned long val)\r
{\r
 regs->epc = val;\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) unsigned long user_stack_pointer(struct pt_regs *regs)\r
{\r
 return regs->sp;\r
}\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void user_stack_pointer_set(struct pt_regs *regs,\r
       unsigned long val)\r
{\r
 regs->sp = val;\r
}\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) unsigned long kernel_stack_pointer(struct pt_regs *regs)\r
{\r
 return regs->sp;\r
}\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) unsigned long frame_pointer(struct pt_regs *regs)\r
{\r
 return regs->s0;\r
}\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void frame_pointer_set(struct pt_regs *regs,\r
         unsigned long val)\r
{\r
 regs->s0 = val;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) unsigned long regs_return_value(struct pt_regs *regs)\r
{\r
 return regs->a0;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void regs_set_return_value(struct pt_regs *regs,\r
      unsigned long val)\r
{\r
 regs->a0 = val;\r
}\r
\r
extern int regs_query_register_offset(const char *name);\r
extern unsigned long regs_get_kernel_stack_nth(struct pt_regs *regs,\r
            unsigned int n);\r
\r
void prepare_ftrace_return(unsigned long *parent, unsigned long self_addr,\r
      unsigned long frame_pointer);\r
int do_syscall_trace_enter(struct pt_regs *regs);\r
void do_syscall_trace_exit(struct pt_regs *regs);\r
# 136 "./arch/riscv/include/asm/ptrace.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) unsigned long regs_get_register(struct pt_regs *regs,\r
           unsigned int offset)\r
{\r
 if (__builtin_expect(!!(offset > __builtin_offsetof(struct pt_regs, orig_a0)), 0))\r
  return 0;\r
\r
 return *(unsigned long *)((unsigned long)regs + offset);\r
}\r
# 155 "./arch/riscv/include/asm/ptrace.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) unsigned long regs_get_kernel_argument(struct pt_regs *regs,\r
      unsigned int n)\r
{\r
 static const int nr_reg_arguments = 8;\r
 static const unsigned int argument_offs[] = {\r
  __builtin_offsetof(struct pt_regs, a0),\r
  __builtin_offsetof(struct pt_regs, a1),\r
  __builtin_offsetof(struct pt_regs, a2),\r
  __builtin_offsetof(struct pt_regs, a3),\r
  __builtin_offsetof(struct pt_regs, a4),\r
  __builtin_offsetof(struct pt_regs, a5),\r
  __builtin_offsetof(struct pt_regs, a6),\r
  __builtin_offsetof(struct pt_regs, a7),\r
 };\r
\r
 if (n < nr_reg_arguments)\r
  return regs_get_register(regs, argument_offs[n]);\r
 return 0;\r
}\r
# 14 "./arch/riscv/include/asm/processor.h" 2\r
# 27 "./arch/riscv/include/asm/processor.h"\r
struct task_struct;\r
struct pt_regs;\r
\r
\r
struct thread_struct {\r
\r
 unsigned long ra;\r
 unsigned long sp;\r
 unsigned long s[12];\r
 struct __riscv_d_ext_state fstate;\r
 unsigned long bad_cause;\r
};\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void arch_thread_struct_whitelist(unsigned long *offset,\r
      unsigned long *size)\r
{\r
 *offset = __builtin_offsetof(struct thread_struct, fstate);\r
 *size = sizeof((((struct thread_struct *)0)->fstate));\r
}\r
# 61 "./arch/riscv/include/asm/processor.h"\r
extern void start_thread(struct pt_regs *regs,\r
   unsigned long pc, unsigned long sp);\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void release_thread(struct task_struct *dead_task)\r
{\r
}\r
\r
extern unsigned long __get_wchan(struct task_struct *p);\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void wait_for_interrupt(void)\r
{\r
 __asm__ __volatile__ ("wfi");\r
}\r
\r
struct device_node;\r
int riscv_of_processor_hartid(struct device_node *node);\r
int riscv_of_parent_hartid(struct device_node *node);\r
\r
extern void riscv_fill_hwcap(void);\r
extern int arch_dup_task_struct(struct task_struct *dst, struct task_struct *src);\r
# 11 "./arch/riscv/include/asm/irqflags.h" 2\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) unsigned long arch_local_save_flags(void)\r
{\r
 return ({ register unsigned long __v; __asm__ __volatile__ ("csrr %0, " "0x100" : "=r" (__v) : : "memory"); __v; });\r
}\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void arch_local_irq_enable(void)\r
{\r
 ({ unsigned long __v = (unsigned long)((0x00000002UL)); __asm__ __volatile__ ("csrs " "0x100" ", %0" : : "rK" (__v) : "memory"); });\r
}\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void arch_local_irq_disable(void)\r
{\r
 ({ unsigned long __v = (unsigned long)((0x00000002UL)); __asm__ __volatile__ ("csrc " "0x100" ", %0" : : "rK" (__v) : "memory"); });\r
}\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) unsigned long arch_local_irq_save(void)\r
{\r
 return ({ unsigned long __v = (unsigned long)((0x00000002UL)); __asm__ __volatile__ ("csrrc %0, " "0x100" ", %1" : "=r" (__v) : "rK" (__v) : "memory"); __v; });\r
}\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int arch_irqs_disabled_flags(unsigned long flags)\r
{\r
 return !(flags & (0x00000002UL));\r
}\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int arch_irqs_disabled(void)\r
{\r
 return arch_irqs_disabled_flags(arch_local_save_flags());\r
}\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void arch_local_irq_restore(unsigned long flags)\r
{\r
 ({ unsigned long __v = (unsigned long)(flags & (0x00000002UL)); __asm__ __volatile__ ("csrs " "0x100" ", %0" : : "rK" (__v) : "memory"); });\r
}\r
# 17 "./include/linux/irqflags.h" 2\r
# 1 "./arch/riscv/include/generated/asm/percpu.h" 1\r
# 1 "./include/asm-generic/percpu.h" 1\r
\r
\r
\r
\r
\r
# 1 "./include/linux/threads.h" 1\r
# 7 "./include/asm-generic/percpu.h" 2\r
# 1 "./include/linux/percpu-defs.h" 1\r
# 308 "./include/linux/percpu-defs.h"\r
extern void __bad_size_call_parameter(void);\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __this_cpu_preempt_check(const char *op) { }\r
# 8 "./include/asm-generic/percpu.h" 2\r
# 19 "./include/asm-generic/percpu.h"\r
extern unsigned long __per_cpu_offset[32];\r
# 2 "./arch/riscv/include/generated/asm/percpu.h" 2\r
# 18 "./include/linux/irqflags.h" 2\r
# 27 "./include/linux/irqflags.h"\r
  static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void lockdep_softirqs_on(unsigned long ip) { }\r
  static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void lockdep_softirqs_off(unsigned long ip) { }\r
  static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void lockdep_hardirqs_on_prepare(unsigned long ip) { }\r
  static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void lockdep_hardirqs_on(unsigned long ip) { }\r
  static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void lockdep_hardirqs_off(unsigned long ip) { }\r
\r
\r
\r
\r
\r
struct irqtrace_events {\r
 unsigned int irq_events;\r
 unsigned long hardirq_enable_ip;\r
 unsigned long hardirq_disable_ip;\r
 unsigned int hardirq_enable_event;\r
 unsigned int hardirq_disable_event;\r
 unsigned long softirq_disable_ip;\r
 unsigned long softirq_enable_ip;\r
 unsigned int softirq_disable_event;\r
 unsigned int softirq_enable_event;\r
};\r
\r
extern __attribute__((section(".data..percpu" ""))) __typeof__(int) hardirqs_enabled;\r
extern __attribute__((section(".data..percpu" ""))) __typeof__(int) hardirq_context;\r
\r
extern void trace_hardirqs_on_prepare(void);\r
extern void trace_hardirqs_off_finish(void);\r
extern void trace_hardirqs_on(void);\r
extern void trace_hardirqs_off(void);\r
# 152 "./include/linux/irqflags.h"\r
 extern void stop_critical_timings(void);\r
 extern void start_critical_timings(void);\r
# 15 "./arch/riscv/include/asm/bitops.h" 2\r
\r
\r
\r
# 1 "./include/asm-generic/bitops/__ffs.h" 1\r
\r
\r
\r
\r
# 1 "./arch/riscv/include/generated/uapi/asm/types.h" 1\r
# 6 "./include/asm-generic/bitops/__ffs.h" 2\r
\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) unsigned long __ffs(unsigned long word)\r
{\r
 int num = 0;\r
\r
\r
 if ((word & 0xffffffff) == 0) {\r
  num += 32;\r
  word >>= 32;\r
 }\r
\r
 if ((word & 0xffff) == 0) {\r
  num += 16;\r
  word >>= 16;\r
 }\r
 if ((word & 0xff) == 0) {\r
  num += 8;\r
  word >>= 8;\r
 }\r
 if ((word & 0xf) == 0) {\r
  num += 4;\r
  word >>= 4;\r
 }\r
 if ((word & 0x3) == 0) {\r
  num += 2;\r
  word >>= 2;\r
 }\r
 if ((word & 0x1) == 0)\r
  num += 1;\r
 return num;\r
}\r
# 19 "./arch/riscv/include/asm/bitops.h" 2\r
# 1 "./include/asm-generic/bitops/ffz.h" 1\r
# 20 "./arch/riscv/include/asm/bitops.h" 2\r
# 1 "./include/asm-generic/bitops/fls.h" 1\r
# 13 "./include/asm-generic/bitops/fls.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int fls(unsigned int x)\r
{\r
 int r = 32;\r
\r
 if (!x)\r
  return 0;\r
 if (!(x & 0xffff0000u)) {\r
  x <<= 16;\r
  r -= 16;\r
 }\r
 if (!(x & 0xff000000u)) {\r
  x <<= 8;\r
  r -= 8;\r
 }\r
 if (!(x & 0xf0000000u)) {\r
  x <<= 4;\r
  r -= 4;\r
 }\r
 if (!(x & 0xc0000000u)) {\r
  x <<= 2;\r
  r -= 2;\r
 }\r
 if (!(x & 0x80000000u)) {\r
  x <<= 1;\r
  r -= 1;\r
 }\r
 return r;\r
}\r
# 21 "./arch/riscv/include/asm/bitops.h" 2\r
# 1 "./include/asm-generic/bitops/__fls.h" 1\r
\r
\r
\r
\r
# 1 "./arch/riscv/include/generated/uapi/asm/types.h" 1\r
# 6 "./include/asm-generic/bitops/__fls.h" 2\r
\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) unsigned long __fls(unsigned long word)\r
{\r
 int num = 64 - 1;\r
\r
\r
 if (!(word & (~0ul << 32))) {\r
  num -= 32;\r
  word <<= 32;\r
 }\r
\r
 if (!(word & (~0ul << (64 -16)))) {\r
  num -= 16;\r
  word <<= 16;\r
 }\r
 if (!(word & (~0ul << (64 -8)))) {\r
  num -= 8;\r
  word <<= 8;\r
 }\r
 if (!(word & (~0ul << (64 -4)))) {\r
  num -= 4;\r
  word <<= 4;\r
 }\r
 if (!(word & (~0ul << (64 -2)))) {\r
  num -= 2;\r
  word <<= 2;\r
 }\r
 if (!(word & (~0ul << (64 -1))))\r
  num -= 1;\r
 return num;\r
}\r
# 22 "./arch/riscv/include/asm/bitops.h" 2\r
# 1 "./include/asm-generic/bitops/fls64.h" 1\r
\r
\r
\r
\r
# 1 "./arch/riscv/include/generated/uapi/asm/types.h" 1\r
# 6 "./include/asm-generic/bitops/fls64.h" 2\r
# 27 "./include/asm-generic/bitops/fls64.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int fls64(__u64 x)\r
{\r
 if (x == 0)\r
  return 0;\r
 return __fls(x) + 1;\r
}\r
# 23 "./arch/riscv/include/asm/bitops.h" 2\r
# 1 "./include/asm-generic/bitops/sched.h" 1\r
\r
\r
\r
\r
\r
# 1 "./arch/riscv/include/generated/uapi/asm/types.h" 1\r
# 7 "./include/asm-generic/bitops/sched.h" 2\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int sched_find_first_bit(const unsigned long *b)\r
{\r
\r
 if (b[0])\r
  return __ffs(b[0]);\r
 return __ffs(b[1]) + 64;\r
# 30 "./include/asm-generic/bitops/sched.h"\r
}\r
# 24 "./arch/riscv/include/asm/bitops.h" 2\r
# 1 "./include/asm-generic/bitops/ffs.h" 1\r
# 13 "./include/asm-generic/bitops/ffs.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int ffs(int x)\r
{\r
 int r = 1;\r
\r
 if (!x)\r
  return 0;\r
 if (!(x & 0xffff)) {\r
  x >>= 16;\r
  r += 16;\r
 }\r
 if (!(x & 0xff)) {\r
  x >>= 8;\r
  r += 8;\r
 }\r
 if (!(x & 0xf)) {\r
  x >>= 4;\r
  r += 4;\r
 }\r
 if (!(x & 3)) {\r
  x >>= 2;\r
  r += 2;\r
 }\r
 if (!(x & 1)) {\r
  x >>= 1;\r
  r += 1;\r
 }\r
 return r;\r
}\r
# 25 "./arch/riscv/include/asm/bitops.h" 2\r
\r
# 1 "./include/asm-generic/bitops/hweight.h" 1\r
\r
\r
\r
\r
# 1 "./include/asm-generic/bitops/arch_hweight.h" 1\r
\r
\r
\r
\r
# 1 "./arch/riscv/include/generated/uapi/asm/types.h" 1\r
# 6 "./include/asm-generic/bitops/arch_hweight.h" 2\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) unsigned int __arch_hweight32(unsigned int w)\r
{\r
 return __sw_hweight32(w);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) unsigned int __arch_hweight16(unsigned int w)\r
{\r
 return __sw_hweight16(w);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) unsigned int __arch_hweight8(unsigned int w)\r
{\r
 return __sw_hweight8(w);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) unsigned long __arch_hweight64(__u64 w)\r
{\r
 return __sw_hweight64(w);\r
}\r
# 6 "./include/asm-generic/bitops/hweight.h" 2\r
# 1 "./include/asm-generic/bitops/const_hweight.h" 1\r
# 7 "./include/asm-generic/bitops/hweight.h" 2\r
# 27 "./arch/riscv/include/asm/bitops.h" 2\r
# 71 "./arch/riscv/include/asm/bitops.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int test_and_set_bit(int nr, volatile unsigned long *addr)\r
{\r
 return ({ unsigned long __res, __mask; __mask = ((((1UL))) << ((nr) % 64)); __asm__ __volatile__ ( "amo" "or" ".d" ".aqrl" " %0, %2, %1" : "=r" (__res), "+A" (addr[((nr) / 64)]) : "r" ((__mask)) : "memory"); ((__res & __mask) != 0); });\r
}\r
# 83 "./arch/riscv/include/asm/bitops.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int test_and_clear_bit(int nr, volatile unsigned long *addr)\r
{\r
 return ({ unsigned long __res, __mask; __mask = ((((1UL))) << ((nr) % 64)); __asm__ __volatile__ ( "amo" "and" ".d" ".aqrl" " %0, %2, %1" : "=r" (__res), "+A" (addr[((nr) / 64)]) : "r" ((~(__mask))) : "memory"); ((__res & __mask) != 0); });\r
}\r
# 96 "./arch/riscv/include/asm/bitops.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int test_and_change_bit(int nr, volatile unsigned long *addr)\r
{\r
 return ({ unsigned long __res, __mask; __mask = ((((1UL))) << ((nr) % 64)); __asm__ __volatile__ ( "amo" "xor" ".d" ".aqrl" " %0, %2, %1" : "=r" (__res), "+A" (addr[((nr) / 64)]) : "r" ((__mask)) : "memory"); ((__res & __mask) != 0); });\r
}\r
# 113 "./arch/riscv/include/asm/bitops.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void set_bit(int nr, volatile unsigned long *addr)\r
{\r
 __asm__ __volatile__ ( "amo" "or" ".d" "" " zero, %1, %0" : "+A" (addr[((nr) / 64)]) : "r" ((((((1UL))) << ((nr) % 64)))) : "memory");;\r
}\r
# 127 "./arch/riscv/include/asm/bitops.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void clear_bit(int nr, volatile unsigned long *addr)\r
{\r
 __asm__ __volatile__ ( "amo" "and" ".d" "" " zero, %1, %0" : "+A" (addr[((nr) / 64)]) : "r" ((~(((((1UL))) << ((nr) % 64))))) : "memory");;\r
}\r
# 141 "./arch/riscv/include/asm/bitops.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void change_bit(int nr, volatile unsigned long *addr)\r
{\r
 __asm__ __volatile__ ( "amo" "xor" ".d" "" " zero, %1, %0" : "+A" (addr[((nr) / 64)]) : "r" ((((((1UL))) << ((nr) % 64)))) : "memory");;\r
}\r
# 154 "./arch/riscv/include/asm/bitops.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int test_and_set_bit_lock(\r
 unsigned long nr, volatile unsigned long *addr)\r
{\r
 return ({ unsigned long __res, __mask; __mask = ((((1UL))) << ((nr) % 64)); __asm__ __volatile__ ( "amo" "or" ".d" ".aq" " %0, %2, %1" : "=r" (__res), "+A" (addr[((nr) / 64)]) : "r" ((__mask)) : "memory"); ((__res & __mask) != 0); });\r
}\r
# 167 "./arch/riscv/include/asm/bitops.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void clear_bit_unlock(\r
 unsigned long nr, volatile unsigned long *addr)\r
{\r
 __asm__ __volatile__ ( "amo" "and" ".d" ".rl" " zero, %1, %0" : "+A" (addr[((nr) / 64)]) : "r" ((~(((((1UL))) << ((nr) % 64))))) : "memory");;\r
}\r
# 188 "./arch/riscv/include/asm/bitops.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __clear_bit_unlock(\r
 unsigned long nr, volatile unsigned long *addr)\r
{\r
 clear_bit_unlock(nr, addr);\r
}\r
\r
\r
\r
\r
\r
\r
\r
\r
# 1 "./include/asm-generic/bitops/non-atomic.h" 1\r
\r
\r
\r
\r
# 1 "./arch/riscv/include/generated/uapi/asm/types.h" 1\r
# 6 "./include/asm-generic/bitops/non-atomic.h" 2\r
# 16 "./include/asm-generic/bitops/non-atomic.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
arch___set_bit(unsigned int nr, volatile unsigned long *addr)\r
{\r
 unsigned long mask = ((((1UL))) << ((nr) % 64));\r
 unsigned long *p = ((unsigned long *)addr) + ((nr) / 64);\r
\r
 *p |= mask;\r
}\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
arch___clear_bit(unsigned int nr, volatile unsigned long *addr)\r
{\r
 unsigned long mask = ((((1UL))) << ((nr) % 64));\r
 unsigned long *p = ((unsigned long *)addr) + ((nr) / 64);\r
\r
 *p &= ~mask;\r
}\r
# 45 "./include/asm-generic/bitops/non-atomic.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__))\r
void arch___change_bit(unsigned int nr, volatile unsigned long *addr)\r
{\r
 unsigned long mask = ((((1UL))) << ((nr) % 64));\r
 unsigned long *p = ((unsigned long *)addr) + ((nr) / 64);\r
\r
 *p ^= mask;\r
}\r
# 64 "./include/asm-generic/bitops/non-atomic.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
arch___test_and_set_bit(unsigned int nr, volatile unsigned long *addr)\r
{\r
 unsigned long mask = ((((1UL))) << ((nr) % 64));\r
 unsigned long *p = ((unsigned long *)addr) + ((nr) / 64);\r
 unsigned long old = *p;\r
\r
 *p = old | mask;\r
 return (old & mask) != 0;\r
}\r
# 85 "./include/asm-generic/bitops/non-atomic.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
arch___test_and_clear_bit(unsigned int nr, volatile unsigned long *addr)\r
{\r
 unsigned long mask = ((((1UL))) << ((nr) % 64));\r
 unsigned long *p = ((unsigned long *)addr) + ((nr) / 64);\r
 unsigned long old = *p;\r
\r
 *p = old & ~mask;\r
 return (old & mask) != 0;\r
}\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
arch___test_and_change_bit(unsigned int nr, volatile unsigned long *addr)\r
{\r
 unsigned long mask = ((((1UL))) << ((nr) % 64));\r
 unsigned long *p = ((unsigned long *)addr) + ((nr) / 64);\r
 unsigned long old = *p;\r
\r
 *p = old ^ mask;\r
 return (old & mask) != 0;\r
}\r
\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
arch_test_bit(unsigned int nr, const volatile unsigned long *addr)\r
{\r
 return 1UL & (addr[((nr) / 64)] >> (nr & (64 -1)));\r
}\r
# 201 "./arch/riscv/include/asm/bitops.h" 2\r
# 1 "./include/asm-generic/bitops/le.h" 1\r
\r
\r
\r
\r
# 1 "./arch/riscv/include/generated/uapi/asm/types.h" 1\r
# 6 "./include/asm-generic/bitops/le.h" 2\r
# 1 "./arch/riscv/include/uapi/asm/byteorder.h" 1\r
# 10 "./arch/riscv/include/uapi/asm/byteorder.h"\r
# 1 "./include/linux/byteorder/little_endian.h" 1\r
\r
\r
\r
\r
# 1 "./include/uapi/linux/byteorder/little_endian.h" 1\r
# 14 "./include/uapi/linux/byteorder/little_endian.h"\r
# 1 "./include/linux/swab.h" 1\r
\r
\r
\r
\r
# 1 "./include/uapi/linux/swab.h" 1\r
\r
\r
\r
\r
\r
\r
\r
# 1 "./arch/riscv/include/generated/uapi/asm/swab.h" 1\r
# 1 "./include/uapi/asm-generic/swab.h" 1\r
# 2 "./arch/riscv/include/generated/uapi/asm/swab.h" 2\r
# 9 "./include/uapi/linux/swab.h" 2\r
# 48 "./include/uapi/linux/swab.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__const__)) __u16 __fswab16(__u16 val)\r
{\r
\r
\r
\r
 return ((__u16)( (((__u16)(val) & (__u16)0x00ffU) << 8) | (((__u16)(val) & (__u16)0xff00U) >> 8)));\r
\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__const__)) __u32 __fswab32(__u32 val)\r
{\r
\r
\r
\r
 return ((__u32)( (((__u32)(val) & (__u32)0x000000ffUL) << 24) | (((__u32)(val) & (__u32)0x0000ff00UL) << 8) | (((__u32)(val) & (__u32)0x00ff0000UL) >> 8) | (((__u32)(val) & (__u32)0xff000000UL) >> 24)));\r
\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__const__)) __u64 __fswab64(__u64 val)\r
{\r
\r
\r
\r
\r
\r
\r
\r
 return ((__u64)( (((__u64)(val) & (__u64)0x00000000000000ffULL) << 56) | (((__u64)(val) & (__u64)0x000000000000ff00ULL) << 40) | (((__u64)(val) & (__u64)0x0000000000ff0000ULL) << 24) | (((__u64)(val) & (__u64)0x00000000ff000000ULL) << 8) | (((__u64)(val) & (__u64)0x000000ff00000000ULL) >> 8) | (((__u64)(val) & (__u64)0x0000ff0000000000ULL) >> 24) | (((__u64)(val) & (__u64)0x00ff000000000000ULL) >> 40) | (((__u64)(val) & (__u64)0xff00000000000000ULL) >> 56)));\r
\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__const__)) __u32 __fswahw32(__u32 val)\r
{\r
\r
\r
\r
 return ((__u32)( (((__u32)(val) & (__u32)0x0000ffffUL) << 16) | (((__u32)(val) & (__u32)0xffff0000UL) >> 16)));\r
\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__const__)) __u32 __fswahb32(__u32 val)\r
{\r
\r
\r
\r
 return ((__u32)( (((__u32)(val) & (__u32)0x00ff00ffUL) << 8) | (((__u32)(val) & (__u32)0xff00ff00UL) >> 8)));\r
\r
}\r
# 136 "./include/uapi/linux/swab.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) unsigned long __swab(const unsigned long y)\r
{\r
\r
 return (__builtin_constant_p((__u64)(y)) ? ((__u64)( (((__u64)(y) & (__u64)0x00000000000000ffULL) << 56) | (((__u64)(y) & (__u64)0x000000000000ff00ULL) << 40) | (((__u64)(y) & (__u64)0x0000000000ff0000ULL) << 24) | (((__u64)(y) & (__u64)0x00000000ff000000ULL) << 8) | (((__u64)(y) & (__u64)0x000000ff00000000ULL) >> 8) | (((__u64)(y) & (__u64)0x0000ff0000000000ULL) >> 24) | (((__u64)(y) & (__u64)0x00ff000000000000ULL) >> 40) | (((__u64)(y) & (__u64)0xff00000000000000ULL) >> 56))) : __fswab64(y));\r
\r
\r
\r
}\r
# 171 "./include/uapi/linux/swab.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) __u16 __swab16p(const __u16 *p)\r
{\r
\r
\r
\r
 return (__builtin_constant_p((__u16)(*p)) ? ((__u16)( (((__u16)(*p) & (__u16)0x00ffU) << 8) | (((__u16)(*p) & (__u16)0xff00U) >> 8))) : __fswab16(*p));\r
\r
}\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) __u32 __swab32p(const __u32 *p)\r
{\r
\r
\r
\r
 return (__builtin_constant_p((__u32)(*p)) ? ((__u32)( (((__u32)(*p) & (__u32)0x000000ffUL) << 24) | (((__u32)(*p) & (__u32)0x0000ff00UL) << 8) | (((__u32)(*p) & (__u32)0x00ff0000UL) >> 8) | (((__u32)(*p) & (__u32)0xff000000UL) >> 24))) : __fswab32(*p));\r
\r
}\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) __u64 __swab64p(const __u64 *p)\r
{\r
\r
\r
\r
 return (__builtin_constant_p((__u64)(*p)) ? ((__u64)( (((__u64)(*p) & (__u64)0x00000000000000ffULL) << 56) | (((__u64)(*p) & (__u64)0x000000000000ff00ULL) << 40) | (((__u64)(*p) & (__u64)0x0000000000ff0000ULL) << 24) | (((__u64)(*p) & (__u64)0x00000000ff000000ULL) << 8) | (((__u64)(*p) & (__u64)0x000000ff00000000ULL) >> 8) | (((__u64)(*p) & (__u64)0x0000ff0000000000ULL) >> 24) | (((__u64)(*p) & (__u64)0x00ff000000000000ULL) >> 40) | (((__u64)(*p) & (__u64)0xff00000000000000ULL) >> 56))) : __fswab64(*p));\r
\r
}\r
\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __u32 __swahw32p(const __u32 *p)\r
{\r
\r
\r
\r
 return (__builtin_constant_p((__u32)(*p)) ? ((__u32)( (((__u32)(*p) & (__u32)0x0000ffffUL) << 16) | (((__u32)(*p) & (__u32)0xffff0000UL) >> 16))) : __fswahw32(*p));\r
\r
}\r
\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __u32 __swahb32p(const __u32 *p)\r
{\r
\r
\r
\r
 return (__builtin_constant_p((__u32)(*p)) ? ((__u32)( (((__u32)(*p) & (__u32)0x00ff00ffUL) << 8) | (((__u32)(*p) & (__u32)0xff00ff00UL) >> 8))) : __fswahb32(*p));\r
\r
}\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __swab16s(__u16 *p)\r
{\r
\r
\r
\r
 *p = __swab16p(p);\r
\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void __swab32s(__u32 *p)\r
{\r
\r
\r
\r
 *p = __swab32p(p);\r
\r
}\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void __swab64s(__u64 *p)\r
{\r
\r
\r
\r
 *p = __swab64p(p);\r
\r
}\r
\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __swahw32s(__u32 *p)\r
{\r
\r
\r
\r
 *p = __swahw32p(p);\r
\r
}\r
\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __swahb32s(__u32 *p)\r
{\r
\r
\r
\r
 *p = __swahb32p(p);\r
\r
}\r
# 6 "./include/linux/swab.h" 2\r
# 15 "./include/uapi/linux/byteorder/little_endian.h" 2\r
# 45 "./include/uapi/linux/byteorder/little_endian.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) __le64 __cpu_to_le64p(const __u64 *p)\r
{\r
 return ( __le64)*p;\r
}\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) __u64 __le64_to_cpup(const __le64 *p)\r
{\r
 return ( __u64)*p;\r
}\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) __le32 __cpu_to_le32p(const __u32 *p)\r
{\r
 return ( __le32)*p;\r
}\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) __u32 __le32_to_cpup(const __le32 *p)\r
{\r
 return ( __u32)*p;\r
}\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) __le16 __cpu_to_le16p(const __u16 *p)\r
{\r
 return ( __le16)*p;\r
}\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) __u16 __le16_to_cpup(const __le16 *p)\r
{\r
 return ( __u16)*p;\r
}\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) __be64 __cpu_to_be64p(const __u64 *p)\r
{\r
 return ( __be64)__swab64p(p);\r
}\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) __u64 __be64_to_cpup(const __be64 *p)\r
{\r
 return __swab64p((__u64 *)p);\r
}\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) __be32 __cpu_to_be32p(const __u32 *p)\r
{\r
 return ( __be32)__swab32p(p);\r
}\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) __u32 __be32_to_cpup(const __be32 *p)\r
{\r
 return __swab32p((__u32 *)p);\r
}\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) __be16 __cpu_to_be16p(const __u16 *p)\r
{\r
 return ( __be16)__swab16p(p);\r
}\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) __u16 __be16_to_cpup(const __be16 *p)\r
{\r
 return __swab16p((__u16 *)p);\r
}\r
# 6 "./include/linux/byteorder/little_endian.h" 2\r
\r
\r
\r
\r
\r
# 1 "./include/linux/byteorder/generic.h" 1\r
# 144 "./include/linux/byteorder/generic.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void le16_add_cpu(__le16 *var, u16 val)\r
{\r
 *var = (( __le16)(__u16)((( __u16)(__le16)(*var)) + val));\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void le32_add_cpu(__le32 *var, u32 val)\r
{\r
 *var = (( __le32)(__u32)((( __u32)(__le32)(*var)) + val));\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void le64_add_cpu(__le64 *var, u64 val)\r
{\r
 *var = (( __le64)(__u64)((( __u64)(__le64)(*var)) + val));\r
}\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void le32_to_cpu_array(u32 *buf, unsigned int words)\r
{\r
 while (words--) {\r
  do { (void)(buf); } while (0);\r
  buf++;\r
 }\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void cpu_to_le32_array(u32 *buf, unsigned int words)\r
{\r
 while (words--) {\r
  do { (void)(buf); } while (0);\r
  buf++;\r
 }\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void be16_add_cpu(__be16 *var, u16 val)\r
{\r
 *var = (( __be16)(__builtin_constant_p((__u16)(((__builtin_constant_p((__u16)(( __u16)(__be16)(*var))) ? ((__u16)( (((__u16)(( __u16)(__be16)(*var)) & (__u16)0x00ffU) << 8) | (((__u16)(( __u16)(__be16)(*var)) & (__u16)0xff00U) >> 8))) : __fswab16(( __u16)(__be16)(*var))) + val))) ? ((__u16)( (((__u16)(((__builtin_constant_p((__u16)(( __u16)(__be16)(*var))) ? ((__u16)( (((__u16)(( __u16)(__be16)(*var)) & (__u16)0x00ffU) << 8) | (((__u16)(( __u16)(__be16)(*var)) & (__u16)0xff00U) >> 8))) : __fswab16(( __u16)(__be16)(*var))) + val)) & (__u16)0x00ffU) << 8) | (((__u16)(((__builtin_constant_p((__u16)(( __u16)(__be16)(*var))) ? ((__u16)( (((__u16)(( __u16)(__be16)(*var)) & (__u16)0x00ffU) << 8) | (((__u16)(( __u16)(__be16)(*var)) & (__u16)0xff00U) >> 8))) : __fswab16(( __u16)(__be16)(*var))) + val)) & (__u16)0xff00U) >> 8))) : __fswab16(((__builtin_constant_p((__u16)(( __u16)(__be16)(*var))) ? ((__u16)( (((__u16)(( __u16)(__be16)(*var)) & (__u16)0x00ffU) << 8) | (((__u16)(( __u16)(__be16)(*var)) & (__u16)0xff00U) >> 8))) : __fswab16(( __u16)(__be16)(*var))) + val))));\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void be32_add_cpu(__be32 *var, u32 val)\r
{\r
 *var = (( __be32)(__builtin_constant_p((__u32)(((__builtin_constant_p((__u32)(( __u32)(__be32)(*var))) ? ((__u32)( (((__u32)(( __u32)(__be32)(*var)) & (__u32)0x000000ffUL) << 24) | (((__u32)(( __u32)(__be32)(*var)) & (__u32)0x0000ff00UL) << 8) | (((__u32)(( __u32)(__be32)(*var)) & (__u32)0x00ff0000UL) >> 8) | (((__u32)(( __u32)(__be32)(*var)) & (__u32)0xff000000UL) >> 24))) : __fswab32(( __u32)(__be32)(*var))) + val))) ? ((__u32)( (((__u32)(((__builtin_constant_p((__u32)(( __u32)(__be32)(*var))) ? ((__u32)( (((__u32)(( __u32)(__be32)(*var)) & (__u32)0x000000ffUL) << 24) | (((__u32)(( __u32)(__be32)(*var)) & (__u32)0x0000ff00UL) << 8) | (((__u32)(( __u32)(__be32)(*var)) & (__u32)0x00ff0000UL) >> 8) | (((__u32)(( __u32)(__be32)(*var)) & (__u32)0xff000000UL) >> 24))) : __fswab32(( __u32)(__be32)(*var))) + val)) & (__u32)0x000000ffUL) << 24) | (((__u32)(((__builtin_constant_p((__u32)(( __u32)(__be32)(*var))) ? ((__u32)( (((__u32)(( __u32)(__be32)(*var)) & (__u32)0x000000ffUL) << 24) | (((__u32)(( __u32)(__be32)(*var)) & (__u32)0x0000ff00UL) << 8) | (((__u32)(( __u32)(__be32)(*var)) & (__u32)0x00ff0000UL) >> 8) | (((__u32)(( __u32)(__be32)(*var)) & (__u32)0xff000000UL) >> 24))) : __fswab32(( __u32)(__be32)(*var))) + val)) & (__u32)0x0000ff00UL) << 8) | (((__u32)(((__builtin_constant_p((__u32)(( __u32)(__be32)(*var))) ? ((__u32)( (((__u32)(( __u32)(__be32)(*var)) & (__u32)0x000000ffUL) << 24) | (((__u32)(( __u32)(__be32)(*var)) & (__u32)0x0000ff00UL) << 8) | (((__u32)(( __u32)(__be32)(*var)) & (__u32)0x00ff0000UL) >> 8) | (((__u32)(( __u32)(__be32)(*var)) & (__u32)0xff000000UL) >> 24))) : __fswab32(( __u32)(__be32)(*var))) + val)) & (__u32)0x00ff0000UL) >> 8) | (((__u32)(((__builtin_constant_p((__u32)(( __u32)(__be32)(*var))) ? ((__u32)( (((__u32)(( __u32)(__be32)(*var)) & (__u32)0x000000ffUL) << 24) | (((__u32)(( __u32)(__be32)(*var)) & (__u32)0x0000ff00UL) << 8) | (((__u32)(( __u32)(__be32)(*var)) & (__u32)0x00ff0000UL) >> 8) | (((__u32)(( __u32)(__be32)(*var)) & (__u32)0xff000000UL) >> 24))) : __fswab32(( __u32)(__be32)(*var))) + val)) & (__u32)0xff000000UL) >> 24))) : __fswab32(((__builtin_constant_p((__u32)(( __u32)(__be32)(*var))) ? ((__u32)( (((__u32)(( __u32)(__be32)(*var)) & (__u32)0x000000ffUL) << 24) | (((__u32)(( __u32)(__be32)(*var)) & (__u32)0x0000ff00UL) << 8) | (((__u32)(( __u32)(__be32)(*var)) & (__u32)0x00ff0000UL) >> 8) | (((__u32)(( __u32)(__be32)(*var)) & (__u32)0xff000000UL) >> 24))) : __fswab32(( __u32)(__be32)(*var))) + val))));\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void be64_add_cpu(__be64 *var, u64 val)\r
{\r
 *var = (( __be64)(__builtin_constant_p((__u64)(((__builtin_constant_p((__u64)(( __u64)(__be64)(*var))) ? ((__u64)( (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00000000000000ffULL) << 56) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x000000000000ff00ULL) << 40) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x0000000000ff0000ULL) << 24) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00000000ff000000ULL) << 8) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x000000ff00000000ULL) >> 8) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x0000ff0000000000ULL) >> 24) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00ff000000000000ULL) >> 40) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0xff00000000000000ULL) >> 56))) : __fswab64(( __u64)(__be64)(*var))) + val))) ? ((__u64)( (((__u64)(((__builtin_constant_p((__u64)(( __u64)(__be64)(*var))) ? ((__u64)( (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00000000000000ffULL) << 56) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x000000000000ff00ULL) << 40) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x0000000000ff0000ULL) << 24) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00000000ff000000ULL) << 8) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x000000ff00000000ULL) >> 8) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x0000ff0000000000ULL) >> 24) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00ff000000000000ULL) >> 40) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0xff00000000000000ULL) >> 56))) : __fswab64(( __u64)(__be64)(*var))) + val)) & (__u64)0x00000000000000ffULL) << 56) | (((__u64)(((__builtin_constant_p((__u64)(( __u64)(__be64)(*var))) ? ((__u64)( (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00000000000000ffULL) << 56) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x000000000000ff00ULL) << 40) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x0000000000ff0000ULL) << 24) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00000000ff000000ULL) << 8) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x000000ff00000000ULL) >> 8) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x0000ff0000000000ULL) >> 24) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00ff000000000000ULL) >> 40) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0xff00000000000000ULL) >> 56))) : __fswab64(( __u64)(__be64)(*var))) + val)) & (__u64)0x000000000000ff00ULL) << 40) | (((__u64)(((__builtin_constant_p((__u64)(( __u64)(__be64)(*var))) ? ((__u64)( (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00000000000000ffULL) << 56) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x000000000000ff00ULL) << 40) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x0000000000ff0000ULL) << 24) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00000000ff000000ULL) << 8) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x000000ff00000000ULL) >> 8) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x0000ff0000000000ULL) >> 24) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00ff000000000000ULL) >> 40) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0xff00000000000000ULL) >> 56))) : __fswab64(( __u64)(__be64)(*var))) + val)) & (__u64)0x0000000000ff0000ULL) << 24) | (((__u64)(((__builtin_constant_p((__u64)(( __u64)(__be64)(*var))) ? ((__u64)( (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00000000000000ffULL) << 56) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x000000000000ff00ULL) << 40) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x0000000000ff0000ULL) << 24) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00000000ff000000ULL) << 8) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x000000ff00000000ULL) >> 8) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x0000ff0000000000ULL) >> 24) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00ff000000000000ULL) >> 40) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0xff00000000000000ULL) >> 56))) : __fswab64(( __u64)(__be64)(*var))) + val)) & (__u64)0x00000000ff000000ULL) << 8) | (((__u64)(((__builtin_constant_p((__u64)(( __u64)(__be64)(*var))) ? ((__u64)( (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00000000000000ffULL) << 56) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x000000000000ff00ULL) << 40) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x0000000000ff0000ULL) << 24) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00000000ff000000ULL) << 8) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x000000ff00000000ULL) >> 8) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x0000ff0000000000ULL) >> 24) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00ff000000000000ULL) >> 40) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0xff00000000000000ULL) >> 56))) : __fswab64(( __u64)(__be64)(*var))) + val)) & (__u64)0x000000ff00000000ULL) >> 8) | (((__u64)(((__builtin_constant_p((__u64)(( __u64)(__be64)(*var))) ? ((__u64)( (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00000000000000ffULL) << 56) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x000000000000ff00ULL) << 40) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x0000000000ff0000ULL) << 24) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00000000ff000000ULL) << 8) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x000000ff00000000ULL) >> 8) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x0000ff0000000000ULL) >> 24) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00ff000000000000ULL) >> 40) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0xff00000000000000ULL) >> 56))) : __fswab64(( __u64)(__be64)(*var))) + val)) & (__u64)0x0000ff0000000000ULL) >> 24) | (((__u64)(((__builtin_constant_p((__u64)(( __u64)(__be64)(*var))) ? ((__u64)( (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00000000000000ffULL) << 56) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x000000000000ff00ULL) << 40) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x0000000000ff0000ULL) << 24) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00000000ff000000ULL) << 8) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x000000ff00000000ULL) >> 8) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x0000ff0000000000ULL) >> 24) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00ff000000000000ULL) >> 40) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0xff00000000000000ULL) >> 56))) : __fswab64(( __u64)(__be64)(*var))) + val)) & (__u64)0x00ff000000000000ULL) >> 40) | (((__u64)(((__builtin_constant_p((__u64)(( __u64)(__be64)(*var))) ? ((__u64)( (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00000000000000ffULL) << 56) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x000000000000ff00ULL) << 40) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x0000000000ff0000ULL) << 24) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00000000ff000000ULL) << 8) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x000000ff00000000ULL) >> 8) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x0000ff0000000000ULL) >> 24) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00ff000000000000ULL) >> 40) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0xff00000000000000ULL) >> 56))) : __fswab64(( __u64)(__be64)(*var))) + val)) & (__u64)0xff00000000000000ULL) >> 56))) : __fswab64(((__builtin_constant_p((__u64)(( __u64)(__be64)(*var))) ? ((__u64)( (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00000000000000ffULL) << 56) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x000000000000ff00ULL) << 40) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x0000000000ff0000ULL) << 24) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00000000ff000000ULL) << 8) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x000000ff00000000ULL) >> 8) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x0000ff0000000000ULL) >> 24) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0x00ff000000000000ULL) >> 40) | (((__u64)(( __u64)(__be64)(*var)) & (__u64)0xff00000000000000ULL) >> 56))) : __fswab64(( __u64)(__be64)(*var))) + val))));\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void cpu_to_be32_array(__be32 *dst, const u32 *src, size_t len)\r
{\r
 size_t i;\r
\r
 for (i = 0; i < len; i++)\r
  dst[i] = (( __be32)(__builtin_constant_p((__u32)((src[i]))) ? ((__u32)( (((__u32)((src[i])) & (__u32)0x000000ffUL) << 24) | (((__u32)((src[i])) & (__u32)0x0000ff00UL) << 8) | (((__u32)((src[i])) & (__u32)0x00ff0000UL) >> 8) | (((__u32)((src[i])) & (__u32)0xff000000UL) >> 24))) : __fswab32((src[i]))));\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void be32_to_cpu_array(u32 *dst, const __be32 *src, size_t len)\r
{\r
 size_t i;\r
\r
 for (i = 0; i < len; i++)\r
  dst[i] = (__builtin_constant_p((__u32)(( __u32)(__be32)(src[i]))) ? ((__u32)( (((__u32)(( __u32)(__be32)(src[i])) & (__u32)0x000000ffUL) << 24) | (((__u32)(( __u32)(__be32)(src[i])) & (__u32)0x0000ff00UL) << 8) | (((__u32)(( __u32)(__be32)(src[i])) & (__u32)0x00ff0000UL) >> 8) | (((__u32)(( __u32)(__be32)(src[i])) & (__u32)0xff000000UL) >> 24))) : __fswab32(( __u32)(__be32)(src[i])));\r
}\r
# 12 "./include/linux/byteorder/little_endian.h" 2\r
# 11 "./arch/riscv/include/uapi/asm/byteorder.h" 2\r
# 7 "./include/asm-generic/bitops/le.h" 2\r
# 19 "./include/asm-generic/bitops/le.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int test_bit_le(int nr, const void *addr)\r
{\r
 return arch_test_bit(nr ^ 0, addr);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void set_bit_le(int nr, void *addr)\r
{\r
 set_bit(nr ^ 0, addr);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void clear_bit_le(int nr, void *addr)\r
{\r
 clear_bit(nr ^ 0, addr);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __set_bit_le(int nr, void *addr)\r
{\r
 arch___set_bit(nr ^ 0, addr);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __clear_bit_le(int nr, void *addr)\r
{\r
 arch___clear_bit(nr ^ 0, addr);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int test_and_set_bit_le(int nr, void *addr)\r
{\r
 return test_and_set_bit(nr ^ 0, addr);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int test_and_clear_bit_le(int nr, void *addr)\r
{\r
 return test_and_clear_bit(nr ^ 0, addr);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int __test_and_set_bit_le(int nr, void *addr)\r
{\r
 return arch___test_and_set_bit(nr ^ 0, addr);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int __test_and_clear_bit_le(int nr, void *addr)\r
{\r
 return arch___test_and_clear_bit(nr ^ 0, addr);\r
}\r
# 202 "./arch/riscv/include/asm/bitops.h" 2\r
# 1 "./include/asm-generic/bitops/ext2-atomic.h" 1\r
# 203 "./arch/riscv/include/asm/bitops.h" 2\r
# 34 "./include/linux/bitops.h" 2\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int get_bitmask_order(unsigned int count)\r
{\r
 int order;\r
\r
 order = fls(count);\r
 return order;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) unsigned long hweight_long(unsigned long w)\r
{\r
 return sizeof(w) == 4 ? (__builtin_constant_p(w) ? ((((unsigned int) ((!!((w) & (1ULL << 0))) + (!!((w) & (1ULL << 1))) + (!!((w) & (1ULL << 2))) + (!!((w) & (1ULL << 3))) + (!!((w) & (1ULL << 4))) + (!!((w) & (1ULL << 5))) + (!!((w) & (1ULL << 6))) + (!!((w) & (1ULL << 7))))) + ((unsigned int) ((!!(((w) >> 8) & (1ULL << 0))) + (!!(((w) >> 8) & (1ULL << 1))) + (!!(((w) >> 8) & (1ULL << 2))) + (!!(((w) >> 8) & (1ULL << 3))) + (!!(((w) >> 8) & (1ULL << 4))) + (!!(((w) >> 8) & (1ULL << 5))) + (!!(((w) >> 8) & (1ULL << 6))) + (!!(((w) >> 8) & (1ULL << 7)))))) + (((unsigned int) ((!!(((w) >> 16) & (1ULL << 0))) + (!!(((w) >> 16) & (1ULL << 1))) + (!!(((w) >> 16) & (1ULL << 2))) + (!!(((w) >> 16) & (1ULL << 3))) + (!!(((w) >> 16) & (1ULL << 4))) + (!!(((w) >> 16) & (1ULL << 5))) + (!!(((w) >> 16) & (1ULL << 6))) + (!!(((w) >> 16) & (1ULL << 7))))) + ((unsigned int) ((!!((((w) >> 16) >> 8) & (1ULL << 0))) + (!!((((w) >> 16) >> 8) & (1ULL << 1))) + (!!((((w) >> 16) >> 8) & (1ULL << 2))) + (!!((((w) >> 16) >> 8) & (1ULL << 3))) + (!!((((w) >> 16) >> 8) & (1ULL << 4))) + (!!((((w) >> 16) >> 8) & (1ULL << 5))) + (!!((((w) >> 16) >> 8) & (1ULL << 6))) + (!!((((w) >> 16) >> 8) & (1ULL << 7))))))) : __arch_hweight32(w)) : (__builtin_constant_p((__u64)w) ? (((((unsigned int) ((!!(((__u64)w) & (1ULL << 0))) + (!!(((__u64)w) & (1ULL << 1))) + (!!(((__u64)w) & (1ULL << 2))) + (!!(((__u64)w) & (1ULL << 3))) + (!!(((__u64)w) & (1ULL << 4))) + (!!(((__u64)w) & (1ULL << 5))) + (!!(((__u64)w) & (1ULL << 6))) + (!!(((__u64)w) & (1ULL << 7))))) + ((unsigned int) ((!!((((__u64)w) >> 8) & (1ULL << 0))) + (!!((((__u64)w) >> 8) & (1ULL << 1))) + (!!((((__u64)w) >> 8) & (1ULL << 2))) + (!!((((__u64)w) >> 8) & (1ULL << 3))) + (!!((((__u64)w) >> 8) & (1ULL << 4))) + (!!((((__u64)w) >> 8) & (1ULL << 5))) + (!!((((__u64)w) >> 8) & (1ULL << 6))) + (!!((((__u64)w) >> 8) & (1ULL << 7)))))) + (((unsigned int) ((!!((((__u64)w) >> 16) & (1ULL << 0))) + (!!((((__u64)w) >> 16) & (1ULL << 1))) + (!!((((__u64)w) >> 16) & (1ULL << 2))) + (!!((((__u64)w) >> 16) & (1ULL << 3))) + (!!((((__u64)w) >> 16) & (1ULL << 4))) + (!!((((__u64)w) >> 16) & (1ULL << 5))) + (!!((((__u64)w) >> 16) & (1ULL << 6))) + (!!((((__u64)w) >> 16) & (1ULL << 7))))) + ((unsigned int) ((!!(((((__u64)w) >> 16) >> 8) & (1ULL << 0))) + (!!(((((__u64)w) >> 16) >> 8) & (1ULL << 1))) + (!!(((((__u64)w) >> 16) >> 8) & (1ULL << 2))) + (!!(((((__u64)w) >> 16) >> 8) & (1ULL << 3))) + (!!(((((__u64)w) >> 16) >> 8) & (1ULL << 4))) + (!!(((((__u64)w) >> 16) >> 8) & (1ULL << 5))) + (!!(((((__u64)w) >> 16) >> 8) & (1ULL << 6))) + (!!(((((__u64)w) >> 16) >> 8) & (1ULL << 7))))))) + ((((unsigned int) ((!!((((__u64)w) >> 32) & (1ULL << 0))) + (!!((((__u64)w) >> 32) & (1ULL << 1))) + (!!((((__u64)w) >> 32) & (1ULL << 2))) + (!!((((__u64)w) >> 32) & (1ULL << 3))) + (!!((((__u64)w) >> 32) & (1ULL << 4))) + (!!((((__u64)w) >> 32) & (1ULL << 5))) + (!!((((__u64)w) >> 32) & (1ULL << 6))) + (!!((((__u64)w) >> 32) & (1ULL << 7))))) + ((unsigned int) ((!!(((((__u64)w) >> 32) >> 8) & (1ULL << 0))) + (!!(((((__u64)w) >> 32) >> 8) & (1ULL << 1))) + (!!(((((__u64)w) >> 32) >> 8) & (1ULL << 2))) + (!!(((((__u64)w) >> 32) >> 8) & (1ULL << 3))) + (!!(((((__u64)w) >> 32) >> 8) & (1ULL << 4))) + (!!(((((__u64)w) >> 32) >> 8) & (1ULL << 5))) + (!!(((((__u64)w) >> 32) >> 8) & (1ULL << 6))) + (!!(((((__u64)w) >> 32) >> 8) & (1ULL << 7)))))) + (((unsigned int) ((!!(((((__u64)w) >> 32) >> 16) & (1ULL << 0))) + (!!(((((__u64)w) >> 32) >> 16) & (1ULL << 1))) + (!!(((((__u64)w) >> 32) >> 16) & (1ULL << 2))) + (!!(((((__u64)w) >> 32) >> 16) & (1ULL << 3))) + (!!(((((__u64)w) >> 32) >> 16) & (1ULL << 4))) + (!!(((((__u64)w) >> 32) >> 16) & (1ULL << 5))) + (!!(((((__u64)w) >> 32) >> 16) & (1ULL << 6))) + (!!(((((__u64)w) >> 32) >> 16) & (1ULL << 7))))) + ((unsigned int) ((!!((((((__u64)w) >> 32) >> 16) >> 8) & (1ULL << 0))) + (!!((((((__u64)w) >> 32) >> 16) >> 8) & (1ULL << 1))) + (!!((((((__u64)w) >> 32) >> 16) >> 8) & (1ULL << 2))) + (!!((((((__u64)w) >> 32) >> 16) >> 8) & (1ULL << 3))) + (!!((((((__u64)w) >> 32) >> 16) >> 8) & (1ULL << 4))) + (!!((((((__u64)w) >> 32) >> 16) >> 8) & (1ULL << 5))) + (!!((((((__u64)w) >> 32) >> 16) >> 8) & (1ULL << 6))) + (!!((((((__u64)w) >> 32) >> 16) >> 8) & (1ULL << 7)))))))) : __arch_hweight64((__u64)w));\r
}\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __u64 rol64(__u64 word, unsigned int shift)\r
{\r
 return (word << (shift & 63)) | (word >> ((-shift) & 63));\r
}\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __u64 ror64(__u64 word, unsigned int shift)\r
{\r
 return (word >> (shift & 63)) | (word << ((-shift) & 63));\r
}\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __u32 rol32(__u32 word, unsigned int shift)\r
{\r
 return (word << (shift & 31)) | (word >> ((-shift) & 31));\r
}\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __u32 ror32(__u32 word, unsigned int shift)\r
{\r
 return (word >> (shift & 31)) | (word << ((-shift) & 31));\r
}\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __u16 rol16(__u16 word, unsigned int shift)\r
{\r
 return (word << (shift & 15)) | (word >> ((-shift) & 15));\r
}\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __u16 ror16(__u16 word, unsigned int shift)\r
{\r
 return (word >> (shift & 15)) | (word << ((-shift) & 15));\r
}\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __u8 rol8(__u8 word, unsigned int shift)\r
{\r
 return (word << (shift & 7)) | (word >> ((-shift) & 7));\r
}\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __u8 ror8(__u8 word, unsigned int shift)\r
{\r
 return (word >> (shift & 7)) | (word << ((-shift) & 7));\r
}\r
# 135 "./include/linux/bitops.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) __s32 sign_extend32(__u32 value, int index)\r
{\r
 __u8 shift = 31 - index;\r
 return (__s32)(value << shift) >> shift;\r
}\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) __s64 sign_extend64(__u64 value, int index)\r
{\r
 __u8 shift = 63 - index;\r
 return (__s64)(value << shift) >> shift;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) unsigned fls_long(unsigned long l)\r
{\r
 if (sizeof(l) == 4)\r
  return fls(l);\r
 return fls64(l);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int get_count_order(unsigned int count)\r
{\r
 if (count == 0)\r
  return -1;\r
\r
 return fls(--count);\r
}\r
\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int get_count_order_long(unsigned long l)\r
{\r
 if (l == 0UL)\r
  return -1;\r
 return (int)fls_long(--l);\r
}\r
# 188 "./include/linux/bitops.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) unsigned long __ffs64(u64 word)\r
{\r
\r
\r
\r
\r
\r
\r
 return __ffs((unsigned long)word);\r
}\r
\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void assign_bit(long nr, volatile unsigned long *addr,\r
           bool value)\r
{\r
 if (value)\r
  set_bit(nr, addr);\r
 else\r
  clear_bit(nr, addr);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void __assign_bit(long nr, volatile unsigned long *addr,\r
      bool value)\r
{\r
 if (value)\r
  arch___set_bit(nr, addr);\r
 else\r
  arch___clear_bit(nr, addr);\r
}\r
# 23 "./include/linux/kernel.h" 2\r
# 1 "./include/linux/kstrtox.h" 1\r
\r
\r
\r
\r
\r
\r
\r
\r
int __attribute__((__warn_unused_result__)) _kstrtoul(const char *s, unsigned int base, unsigned long *res);\r
int __attribute__((__warn_unused_result__)) _kstrtol(const char *s, unsigned int base, long *res);\r
\r
int __attribute__((__warn_unused_result__)) kstrtoull(const char *s, unsigned int base, unsigned long long *res);\r
int __attribute__((__warn_unused_result__)) kstrtoll(const char *s, unsigned int base, long long *res);\r
# 30 "./include/linux/kstrtox.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int __attribute__((__warn_unused_result__)) kstrtoul(const char *s, unsigned int base, unsigned long *res)\r
{\r
\r
\r
\r
\r
 if (sizeof(unsigned long) == sizeof(unsigned long long) &&\r
     __alignof__(unsigned long) == __alignof__(unsigned long long))\r
  return kstrtoull(s, base, (unsigned long long *)res);\r
 else\r
  return _kstrtoul(s, base, res);\r
}\r
# 58 "./include/linux/kstrtox.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int __attribute__((__warn_unused_result__)) kstrtol(const char *s, unsigned int base, long *res)\r
{\r
\r
\r
\r
\r
 if (sizeof(long) == sizeof(long long) &&\r
     __alignof__(long) == __alignof__(long long))\r
  return kstrtoll(s, base, (long long *)res);\r
 else\r
  return _kstrtol(s, base, res);\r
}\r
\r
int __attribute__((__warn_unused_result__)) kstrtouint(const char *s, unsigned int base, unsigned int *res);\r
int __attribute__((__warn_unused_result__)) kstrtoint(const char *s, unsigned int base, int *res);\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int __attribute__((__warn_unused_result__)) kstrtou64(const char *s, unsigned int base, u64 *res)\r
{\r
 return kstrtoull(s, base, res);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int __attribute__((__warn_unused_result__)) kstrtos64(const char *s, unsigned int base, s64 *res)\r
{\r
 return kstrtoll(s, base, res);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int __attribute__((__warn_unused_result__)) kstrtou32(const char *s, unsigned int base, u32 *res)\r
{\r
 return kstrtouint(s, base, res);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int __attribute__((__warn_unused_result__)) kstrtos32(const char *s, unsigned int base, s32 *res)\r
{\r
 return kstrtoint(s, base, res);\r
}\r
\r
int __attribute__((__warn_unused_result__)) kstrtou16(const char *s, unsigned int base, u16 *res);\r
int __attribute__((__warn_unused_result__)) kstrtos16(const char *s, unsigned int base, s16 *res);\r
int __attribute__((__warn_unused_result__)) kstrtou8(const char *s, unsigned int base, u8 *res);\r
int __attribute__((__warn_unused_result__)) kstrtos8(const char *s, unsigned int base, s8 *res);\r
int __attribute__((__warn_unused_result__)) kstrtobool(const char *s, bool *res);\r
\r
int __attribute__((__warn_unused_result__)) kstrtoull_from_user(const char *s, size_t count, unsigned int base, unsigned long long *res);\r
int __attribute__((__warn_unused_result__)) kstrtoll_from_user(const char *s, size_t count, unsigned int base, long long *res);\r
int __attribute__((__warn_unused_result__)) kstrtoul_from_user(const char *s, size_t count, unsigned int base, unsigned long *res);\r
int __attribute__((__warn_unused_result__)) kstrtol_from_user(const char *s, size_t count, unsigned int base, long *res);\r
int __attribute__((__warn_unused_result__)) kstrtouint_from_user(const char *s, size_t count, unsigned int base, unsigned int *res);\r
int __attribute__((__warn_unused_result__)) kstrtoint_from_user(const char *s, size_t count, unsigned int base, int *res);\r
int __attribute__((__warn_unused_result__)) kstrtou16_from_user(const char *s, size_t count, unsigned int base, u16 *res);\r
int __attribute__((__warn_unused_result__)) kstrtos16_from_user(const char *s, size_t count, unsigned int base, s16 *res);\r
int __attribute__((__warn_unused_result__)) kstrtou8_from_user(const char *s, size_t count, unsigned int base, u8 *res);\r
int __attribute__((__warn_unused_result__)) kstrtos8_from_user(const char *s, size_t count, unsigned int base, s8 *res);\r
int __attribute__((__warn_unused_result__)) kstrtobool_from_user(const char *s, size_t count, bool *res);\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int __attribute__((__warn_unused_result__)) kstrtou64_from_user(const char *s, size_t count, unsigned int base, u64 *res)\r
{\r
 return kstrtoull_from_user(s, count, base, res);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int __attribute__((__warn_unused_result__)) kstrtos64_from_user(const char *s, size_t count, unsigned int base, s64 *res)\r
{\r
 return kstrtoll_from_user(s, count, base, res);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int __attribute__((__warn_unused_result__)) kstrtou32_from_user(const char *s, size_t count, unsigned int base, u32 *res)\r
{\r
 return kstrtouint_from_user(s, count, base, res);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int __attribute__((__warn_unused_result__)) kstrtos32_from_user(const char *s, size_t count, unsigned int base, s32 *res)\r
{\r
 return kstrtoint_from_user(s, count, base, res);\r
}\r
# 145 "./include/linux/kstrtox.h"\r
extern unsigned long simple_strtoul(const char *,char **,unsigned int);\r
extern long simple_strtol(const char *,char **,unsigned int);\r
extern unsigned long long simple_strtoull(const char *,char **,unsigned int);\r
extern long long simple_strtoll(const char *,char **,unsigned int);\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int strtobool(const char *s, bool *res)\r
{\r
 return kstrtobool(s, res);\r
}\r
# 24 "./include/linux/kernel.h" 2\r
# 1 "./include/linux/log2.h" 1\r
# 21 "./include/linux/log2.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) __attribute__((const))\r
int __ilog2_u32(u32 n)\r
{\r
 return fls(n) - 1;\r
}\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) __attribute__((const))\r
int __ilog2_u64(u64 n)\r
{\r
 return fls64(n) - 1;\r
}\r
# 44 "./include/linux/log2.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((const))\r
bool is_power_of_2(unsigned long n)\r
{\r
 return (n != 0 && ((n & (n - 1)) == 0));\r
}\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((const))\r
unsigned long __roundup_pow_of_two(unsigned long n)\r
{\r
 return 1UL << fls_long(n - 1);\r
}\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((const))\r
unsigned long __rounddown_pow_of_two(unsigned long n)\r
{\r
 return 1UL << (fls_long(n) - 1);\r
}\r
# 198 "./include/linux/log2.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__const__))\r
int __order_base_2(unsigned long n)\r
{\r
 return n > 1 ? ( __builtin_constant_p(n - 1) ? ((n - 1) < 2 ? 0 : 63 - __builtin_clzll(n - 1)) : (sizeof(n - 1) <= 4) ? __ilog2_u32(n - 1) : __ilog2_u64(n - 1) ) + 1 : 0;\r
}\r
# 225 "./include/linux/log2.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((const))\r
int __bits_per(unsigned long n)\r
{\r
 if (n < 2)\r
  return 1;\r
 if (is_power_of_2(n))\r
  return ( __builtin_constant_p(n) ? ( ((n) == 0 || (n) == 1) ? 0 : ( __builtin_constant_p((n) - 1) ? (((n) - 1) < 2 ? 0 : 63 - __builtin_clzll((n) - 1)) : (sizeof((n) - 1) <= 4) ? __ilog2_u32((n) - 1) : __ilog2_u64((n) - 1) ) + 1) : __order_base_2(n) ) + 1;\r
 return ( __builtin_constant_p(n) ? ( ((n) == 0 || (n) == 1) ? 0 : ( __builtin_constant_p((n) - 1) ? (((n) - 1) < 2 ? 0 : 63 - __builtin_clzll((n) - 1)) : (sizeof((n) - 1) <= 4) ? __ilog2_u32((n) - 1) : __ilog2_u64((n) - 1) ) + 1) : __order_base_2(n) );\r
}\r
# 25 "./include/linux/kernel.h" 2\r
# 1 "./include/linux/math.h" 1\r
\r
\r
\r
\r
\r
# 1 "./arch/riscv/include/generated/asm/div64.h" 1\r
# 1 "./include/asm-generic/div64.h" 1\r
# 2 "./arch/riscv/include/generated/asm/div64.h" 2\r
# 7 "./include/linux/math.h" 2\r
# 115 "./include/linux/math.h"\r
struct s16_fract { __s16 numerator; __s16 denominator; };\r
struct u16_fract { __u16 numerator; __u16 denominator; };\r
struct s32_fract { __s32 numerator; __s32 denominator; };\r
struct u32_fract { __u32 numerator; __u32 denominator; };\r
# 172 "./include/linux/math.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) u32 reciprocal_scale(u32 val, u32 ep_ro)\r
{\r
 return (u32)(((u64) val * ep_ro) >> 32);\r
}\r
\r
u64 int_pow(u64 base, unsigned int exp);\r
unsigned long int_sqrt(unsigned long);\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) u32 int_sqrt64(u64 x)\r
{\r
 return (u32)int_sqrt(x);\r
}\r
# 26 "./include/linux/kernel.h" 2\r
# 1 "./include/linux/minmax.h" 1\r
# 27 "./include/linux/kernel.h" 2\r
\r
# 1 "./include/linux/panic.h" 1\r
\r
\r
\r
\r
\r
\r
\r
struct pt_regs;\r
\r
extern long (*panic_blink)(int state);\r
__attribute__((__format__(printf, 1, 2)))\r
void panic(const char *fmt, ...) __attribute__((__noreturn__)) __attribute__((__cold__));\r
void nmi_panic(struct pt_regs *regs, const char *msg);\r
extern void oops_enter(void);\r
extern void oops_exit(void);\r
extern bool oops_may_print(void);\r
\r
\r
extern unsigned int sysctl_oops_all_cpu_backtrace;\r
\r
\r
\r
\r
extern int panic_timeout;\r
extern unsigned long panic_print;\r
extern int panic_on_oops;\r
extern int panic_on_unrecovered_nmi;\r
extern int panic_on_io_nmi;\r
extern int panic_on_warn;\r
\r
extern unsigned long panic_on_taint;\r
extern bool panic_on_taint_nousertaint;\r
\r
extern int sysctl_panic_on_rcu_stall;\r
extern int sysctl_max_rcu_stall_to_panic;\r
extern int sysctl_panic_on_stackoverflow;\r
\r
extern bool crash_kexec_post_notifiers;\r
\r
\r
\r
\r
\r
\r
extern atomic_t panic_cpu;\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void set_arch_panic_timeout(int timeout, int arch_default_timeout)\r
{\r
 if (panic_timeout == arch_default_timeout)\r
  panic_timeout = timeout;\r
}\r
# 80 "./include/linux/panic.h"\r
struct taint_flag {\r
 char c_true;\r
 char c_false;\r
 bool module;\r
};\r
\r
extern const struct taint_flag taint_flags[18];\r
\r
enum lockdep_ok {\r
 LOCKDEP_STILL_OK,\r
 LOCKDEP_NOW_UNRELIABLE,\r
};\r
\r
extern const char *print_tainted(void);\r
extern void add_taint(unsigned flag, enum lockdep_ok);\r
extern int test_taint(unsigned flag);\r
extern unsigned long get_taint(void);\r
# 29 "./include/linux/kernel.h" 2\r
# 1 "./include/linux/printk.h" 1\r
\r
\r
\r
\r
\r
# 1 "./include/linux/init.h" 1\r
# 116 "./include/linux/init.h"\r
typedef int (*initcall_t)(void);\r
typedef void (*exitcall_t)(void);\r
# 127 "./include/linux/init.h"\r
typedef initcall_t initcall_entry_t;\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) initcall_t initcall_from_entry(initcall_entry_t *entry)\r
{\r
 return *entry;\r
}\r
\r
\r
extern initcall_entry_t __con_initcall_start[], __con_initcall_end[];\r
\r
\r
typedef void (*ctor_fn_t)(void);\r
\r
struct file_system_type;\r
\r
\r
extern int do_one_initcall(initcall_t fn);\r
extern char __attribute__((__section__(".init.data"))) boot_command_line[];\r
extern char *saved_command_line;\r
extern unsigned int reset_devices;\r
\r
\r
void setup_arch(char **);\r
void prepare_namespace(void);\r
void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((__no_sanitize__("cfi"))) init_rootfs(void);\r
extern struct file_system_type rootfs_fs_type;\r
\r
\r
extern bool rodata_enabled;\r
\r
\r
void mark_rodata_ro(void);\r
\r
\r
extern void (*late_time_init)(void);\r
\r
extern bool initcall_debug;\r
# 303 "./include/linux/init.h"\r
struct obs_kernel_param {\r
 const char *str;\r
 int (*setup_func)(char *);\r
 int early;\r
};\r
# 359 "./include/linux/init.h"\r
void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((__no_sanitize__("cfi"))) parse_early_param(void);\r
void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((__no_sanitize__("cfi"))) parse_early_options(char *cmdline);\r
# 7 "./include/linux/printk.h" 2\r
# 1 "./include/linux/kern_levels.h" 1\r
# 8 "./include/linux/printk.h" 2\r
\r
# 1 "./include/linux/cache.h" 1\r
\r
\r
\r
\r
\r
# 1 "./arch/riscv/include/asm/cache.h" 1\r
# 7 "./include/linux/cache.h" 2\r
# 10 "./include/linux/printk.h" 2\r
# 1 "./include/linux/ratelimit_types.h" 1\r
\r
\r
\r
\r
\r
# 1 "./include/uapi/linux/param.h" 1\r
\r
\r
\r
\r
# 1 "./arch/riscv/include/generated/uapi/asm/param.h" 1\r
# 1 "./include/asm-generic/param.h" 1\r
\r
\r
\r
\r
# 1 "./include/uapi/asm-generic/param.h" 1\r
# 6 "./include/asm-generic/param.h" 2\r
# 2 "./arch/riscv/include/generated/uapi/asm/param.h" 2\r
# 6 "./include/uapi/linux/param.h" 2\r
# 7 "./include/linux/ratelimit_types.h" 2\r
# 1 "./include/linux/spinlock_types_raw.h" 1\r
\r
\r
\r
\r
\r
\r
# 1 "./arch/riscv/include/asm/spinlock_types.h" 1\r
# 13 "./arch/riscv/include/asm/spinlock_types.h"\r
typedef struct {\r
 volatile unsigned int lock;\r
} arch_spinlock_t;\r
\r
\r
\r
typedef struct {\r
 volatile unsigned int lock;\r
} arch_rwlock_t;\r
# 8 "./include/linux/spinlock_types_raw.h" 2\r
\r
\r
\r
\r
# 1 "./include/linux/lockdep_types.h" 1\r
# 17 "./include/linux/lockdep_types.h"\r
enum lockdep_wait_type {\r
 LD_WAIT_INV = 0,\r
\r
 LD_WAIT_FREE,\r
 LD_WAIT_SPIN,\r
\r
\r
\r
\r
 LD_WAIT_CONFIG = LD_WAIT_SPIN,\r
\r
 LD_WAIT_SLEEP,\r
\r
 LD_WAIT_MAX,\r
};\r
\r
enum lockdep_lock_type {\r
 LD_LOCK_NORMAL = 0,\r
 LD_LOCK_PERCPU,\r
 LD_LOCK_MAX,\r
};\r
# 69 "./include/linux/lockdep_types.h"\r
struct lockdep_subclass_key {\r
 char __one_byte;\r
} __attribute__ ((__packed__));\r
\r
\r
struct lock_class_key {\r
 union {\r
  struct hlist_node hash_entry;\r
  struct lockdep_subclass_key subkeys[8UL];\r
 };\r
};\r
\r
extern struct lock_class_key __lockdep_no_validate__;\r
\r
struct lock_trace;\r
\r
\r
\r
\r
\r
\r
\r
struct lock_class {\r
\r
\r
\r
 struct hlist_node hash_entry;\r
\r
\r
\r
\r
\r
\r
 struct list_head lock_entry;\r
\r
\r
\r
\r
\r
\r
 struct list_head locks_after, locks_before;\r
\r
 const struct lockdep_subclass_key *key;\r
 unsigned int subclass;\r
 unsigned int dep_gen_id;\r
\r
\r
\r
\r
 unsigned long usage_mask;\r
 const struct lock_trace *usage_traces[(2*4 + 2)];\r
\r
\r
\r
\r
\r
 int name_version;\r
 const char *name;\r
\r
 u8 wait_type_inner;\r
 u8 wait_type_outer;\r
 u8 lock_type;\r
\r
\r
\r
\r
\r
\r
} ;\r
# 176 "./include/linux/lockdep_types.h"\r
struct lockdep_map {\r
 struct lock_class_key *key;\r
 struct lock_class *class_cache[2];\r
 const char *name;\r
 u8 wait_type_outer;\r
 u8 wait_type_inner;\r
 u8 lock_type;\r
\r
\r
\r
\r
\r
};\r
\r
struct pin_cookie { unsigned int val; };\r
# 13 "./include/linux/spinlock_types_raw.h" 2\r
\r
typedef struct raw_spinlock {\r
 arch_spinlock_t raw_lock;\r
\r
 unsigned int magic, owner_cpu;\r
 void *owner;\r
\r
\r
 struct lockdep_map dep_map;\r
\r
} raw_spinlock_t;\r
# 8 "./include/linux/ratelimit_types.h" 2\r
\r
\r
\r
\r
\r
\r
\r
struct ratelimit_state {\r
 raw_spinlock_t lock;\r
\r
 int interval;\r
 int burst;\r
 int printed;\r
 int missed;\r
 unsigned long begin;\r
 unsigned long flags;\r
};\r
# 40 "./include/linux/ratelimit_types.h"\r
extern int ___ratelimit(struct ratelimit_state *rs, const char *func);\r
# 11 "./include/linux/printk.h" 2\r
# 1 "./include/linux/once_lite.h" 1\r
# 12 "./include/linux/printk.h" 2\r
\r
extern const char linux_banner[];\r
extern const char linux_proc_banner[];\r
\r
extern int oops_in_progress;\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int printk_get_level(const char *buffer)\r
{\r
 if (buffer[0] == '\001' && buffer[1]) {\r
  switch (buffer[1]) {\r
  case '0' ... '7':\r
  case 'c':\r
   return buffer[1];\r
  }\r
 }\r
 return 0;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) const char *printk_skip_level(const char *buffer)\r
{\r
 if (printk_get_level(buffer))\r
  return buffer + 2;\r
\r
 return buffer;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) const char *printk_skip_headers(const char *buffer)\r
{\r
 while (printk_get_level(buffer))\r
  buffer = printk_skip_level(buffer);\r
\r
 return buffer;\r
}\r
# 66 "./include/linux/printk.h"\r
extern int console_printk[];\r
\r
\r
\r
\r
\r
\r
extern void console_verbose(void);\r
\r
\r
\r
extern char devkmsg_log_str[];\r
struct ctl_table;\r
\r
extern int suppress_printk;\r
\r
struct va_format {\r
 const char *fmt;\r
 va_list *va;\r
};\r
# 140 "./include/linux/printk.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__format__(printf, 1, 2))) __attribute__((__cold__))\r
void early_printk(const char *s, ...) { }\r
\r
\r
struct dev_printk_info;\r
\r
\r
           __attribute__((__format__(printf, 4, 0)))\r
int vprintk_emit(int facility, int level,\r
   const struct dev_printk_info *dev_info,\r
   const char *fmt, va_list args);\r
\r
           __attribute__((__format__(printf, 1, 0)))\r
int vprintk(const char *fmt, va_list args);\r
\r
           __attribute__((__format__(printf, 1, 2))) __attribute__((__cold__))\r
int _printk(const char *fmt, ...);\r
\r
\r
\r
\r
__attribute__((__format__(printf, 1, 2))) __attribute__((__cold__)) int _printk_deferred(const char *fmt, ...);\r
\r
extern void __printk_safe_enter(void);\r
extern void __printk_safe_exit(void);\r
# 178 "./include/linux/printk.h"\r
extern int __printk_ratelimit(const char *func);\r
\r
extern bool printk_timed_ratelimit(unsigned long *caller_jiffies,\r
       unsigned int interval_msec);\r
\r
extern int printk_delay_msec;\r
extern int dmesg_restrict;\r
\r
extern void wake_up_klogd(void);\r
\r
char *log_buf_addr_get(void);\r
u32 log_buf_len_get(void);\r
void log_buf_vmcoreinfo_setup(void);\r
void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((__no_sanitize__("cfi"))) setup_log_buf(int early);\r
__attribute__((__format__(printf, 1, 2))) void dump_stack_set_arch_desc(const char *fmt, ...);\r
void dump_stack_print_info(const char *log_lvl);\r
void show_regs_print_info(const char *log_lvl);\r
extern void dump_stack_lvl(const char *log_lvl) __attribute__((__cold__));\r
extern void dump_stack(void) __attribute__((__cold__));\r
void printk_trigger_flush(void);\r
# 280 "./include/linux/printk.h"\r
extern int __printk_cpu_trylock(void);\r
extern void __printk_wait_on_cpu_lock(void);\r
extern void __printk_cpu_unlock(void);\r
# 320 "./include/linux/printk.h"\r
extern int kptr_restrict;\r
# 339 "./include/linux/printk.h"\r
struct module;\r
# 693 "./include/linux/printk.h"\r
extern const struct file_operations kmsg_fops;\r
\r
enum {\r
 DUMP_PREFIX_NONE,\r
 DUMP_PREFIX_ADDRESS,\r
 DUMP_PREFIX_OFFSET\r
};\r
extern int hex_dump_to_buffer(const void *buf, size_t len, int rowsize,\r
         int groupsize, char *linebuf, size_t linebuflen,\r
         bool ascii);\r
\r
extern void print_hex_dump(const char *level, const char *prefix_str,\r
      int prefix_type, int rowsize, int groupsize,\r
      const void *buf, size_t len, bool ascii);\r
# 732 "./include/linux/printk.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void print_hex_dump_debug(const char *prefix_str, int prefix_type,\r
     int rowsize, int groupsize,\r
     const void *buf, size_t len, bool ascii)\r
{\r
}\r
# 30 "./include/linux/kernel.h" 2\r
\r
# 1 "./include/linux/static_call_types.h" 1\r
# 32 "./include/linux/static_call_types.h"\r
struct static_call_site {\r
 s32 addr;\r
 s32 key;\r
};\r
# 94 "./include/linux/static_call_types.h"\r
struct static_call_key {\r
 void *func;\r
};\r
# 32 "./include/linux/kernel.h" 2\r
# 1 "./include/linux/instruction_pointer.h" 1\r
# 33 "./include/linux/kernel.h" 2\r
# 94 "./include/linux/kernel.h"\r
struct completion;\r
struct user;\r
\r
\r
\r
extern int __cond_resched(void);\r
# 125 "./include/linux/kernel.h"\r
extern void __might_resched(const char *file, int line, unsigned int offsets);\r
extern void __might_sleep(const char *file, int line);\r
extern void __cant_sleep(const char *file, int line, int preempt_offset);\r
extern void __cant_migrate(const char *file, int line);\r
# 198 "./include/linux/kernel.h"\r
void __might_fault(const char *file, int line);\r
\r
\r
\r
\r
void do_exit(long error_code) __attribute__((__noreturn__));\r
\r
extern int num_to_str(char *buf, int size,\r
        unsigned long long num, unsigned int width);\r
\r
\r
\r
extern __attribute__((__format__(printf, 2, 3))) int sprintf(char *buf, const char * fmt, ...);\r
extern __attribute__((__format__(printf, 2, 0))) int vsprintf(char *buf, const char *, va_list);\r
extern __attribute__((__format__(printf, 3, 4)))\r
int snprintf(char *buf, size_t size, const char *fmt, ...);\r
extern __attribute__((__format__(printf, 3, 0)))\r
int vsnprintf(char *buf, size_t size, const char *fmt, va_list args);\r
extern __attribute__((__format__(printf, 3, 4)))\r
int scnprintf(char *buf, size_t size, const char *fmt, ...);\r
extern __attribute__((__format__(printf, 3, 0)))\r
int vscnprintf(char *buf, size_t size, const char *fmt, va_list args);\r
extern __attribute__((__format__(printf, 2, 3))) __attribute__((__malloc__))\r
char *kasprintf(gfp_t gfp, const char *fmt, ...);\r
extern __attribute__((__format__(printf, 2, 0))) __attribute__((__malloc__))\r
char *kvasprintf(gfp_t gfp, const char *fmt, va_list args);\r
extern __attribute__((__format__(printf, 2, 0)))\r
const char *kvasprintf_const(gfp_t gfp, const char *fmt, va_list args);\r
\r
extern __attribute__((__format__(scanf, 2, 3)))\r
int sscanf(const char *, const char *, ...);\r
extern __attribute__((__format__(scanf, 2, 0)))\r
int vsscanf(const char *, const char *, va_list);\r
\r
extern int no_hash_pointers_enable(char *str);\r
\r
extern int get_option(char **str, int *pint);\r
extern char *get_options(const char *str, int nints, int *ints);\r
extern unsigned long long memparse(const char *ptr, char **retptr);\r
extern bool parse_option_str(const char *str, const char *option);\r
extern char *next_arg(char *args, char **param, char **val);\r
\r
extern int core_kernel_text(unsigned long addr);\r
extern int __kernel_text_address(unsigned long addr);\r
extern int kernel_text_address(unsigned long addr);\r
extern int func_ptr_is_kernel_text(void *ptr);\r
\r
extern void bust_spinlocks(int yes);\r
\r
extern int root_mountflags;\r
\r
extern bool early_boot_irqs_disabled;\r
\r
\r
\r
\r
\r
extern enum system_states {\r
 SYSTEM_BOOTING,\r
 SYSTEM_SCHEDULING,\r
 SYSTEM_FREEING_INITMEM,\r
 SYSTEM_RUNNING,\r
 SYSTEM_HALT,\r
 SYSTEM_POWER_OFF,\r
 SYSTEM_RESTART,\r
 SYSTEM_SUSPEND,\r
} system_state;\r
\r
extern const char hex_asc[];\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) char *hex_byte_pack(char *buf, u8 byte)\r
{\r
 *buf++ = hex_asc[((byte) & 0xf0) >> 4];\r
 *buf++ = hex_asc[((byte) & 0x0f)];\r
 return buf;\r
}\r
\r
extern const char hex_asc_upper[];\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) char *hex_byte_pack_upper(char *buf, u8 byte)\r
{\r
 *buf++ = hex_asc_upper[((byte) & 0xf0) >> 4];\r
 *buf++ = hex_asc_upper[((byte) & 0x0f)];\r
 return buf;\r
}\r
\r
extern int hex_to_bin(unsigned char ch);\r
extern int __attribute__((__warn_unused_result__)) hex2bin(u8 *dst, const char *src, size_t count);\r
extern char *bin2hex(char *dst, const void *src, size_t count);\r
\r
bool mac_pton(const char *s, u8 *mac);\r
# 314 "./include/linux/kernel.h"\r
enum ftrace_dump_mode {\r
 DUMP_NONE,\r
 DUMP_ALL,\r
 DUMP_ORIG,\r
};\r
\r
\r
void tracing_on(void);\r
void tracing_off(void);\r
int tracing_is_on(void);\r
void tracing_snapshot(void);\r
void tracing_snapshot_alloc(void);\r
\r
extern void tracing_start(void);\r
extern void tracing_stop(void);\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__format__(printf, 1, 2)))\r
void ____trace_printk_check_format(const char *fmt, ...)\r
{\r
}\r
# 393 "./include/linux/kernel.h"\r
extern __attribute__((__format__(printf, 2, 3)))\r
int __trace_bprintk(unsigned long ip, const char *fmt, ...);\r
\r
extern __attribute__((__format__(printf, 2, 3)))\r
int __trace_printk(unsigned long ip, const char *fmt, ...);\r
# 434 "./include/linux/kernel.h"\r
extern int __trace_bputs(unsigned long ip, const char *str);\r
extern int __trace_puts(unsigned long ip, const char *str, int size);\r
\r
extern void trace_dump_stack(int skip);\r
# 456 "./include/linux/kernel.h"\r
extern __attribute__((__format__(printf, 2, 0))) int\r
__ftrace_vbprintk(unsigned long ip, const char *fmt, va_list ap);\r
\r
extern __attribute__((__format__(printf, 2, 0))) int\r
__ftrace_vprintk(unsigned long ip, const char *fmt, va_list ap);\r
\r
extern void ftrace_dump(enum ftrace_dump_mode oops_dump_mode);\r
# 9 "./include/linux/uio.h" 2\r
# 1 "./include/linux/thread_info.h" 1\r
# 13 "./include/linux/thread_info.h"\r
# 1 "./include/linux/bug.h" 1\r
\r
\r
\r
\r
# 1 "./arch/riscv/include/asm/bug.h" 1\r
# 30 "./arch/riscv/include/asm/bug.h"\r
typedef u32 bug_insn_t;\r
# 83 "./arch/riscv/include/asm/bug.h"\r
# 1 "./include/asm-generic/bug.h" 1\r
\r
\r
\r
\r
\r
# 1 "./include/linux/instrumentation.h" 1\r
# 7 "./include/asm-generic/bug.h" 2\r
# 24 "./include/asm-generic/bug.h"\r
struct warn_args;\r
struct pt_regs;\r
\r
void __warn(const char *file, int line, void *caller, unsigned taint,\r
     struct pt_regs *regs, struct warn_args *args);\r
\r
\r
\r
\r
struct bug_entry {\r
\r
\r
\r
 signed int bug_addr_disp;\r
\r
\r
\r
\r
\r
 signed int file_disp;\r
\r
 unsigned short line;\r
\r
 unsigned short flags;\r
};\r
# 101 "./include/asm-generic/bug.h"\r
extern __attribute__((__format__(printf, 1, 2))) void __warn_printk(const char *fmt, ...);\r
# 84 "./arch/riscv/include/asm/bug.h" 2\r
\r
struct pt_regs;\r
struct task_struct;\r
\r
void __show_regs(struct pt_regs *regs);\r
void die(struct pt_regs *regs, const char *str);\r
void do_trap(struct pt_regs *regs, int signo, int code, unsigned long addr);\r
# 6 "./include/linux/bug.h" 2\r
\r
\r
\r
enum bug_trap_type {\r
 BUG_TRAP_TYPE_NONE = 0,\r
 BUG_TRAP_TYPE_WARN = 1,\r
 BUG_TRAP_TYPE_BUG = 2,\r
};\r
\r
struct pt_regs;\r
# 34 "./include/linux/bug.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int is_warning_bug(const struct bug_entry *bug)\r
{\r
 return bug->flags & (1 << 0);\r
}\r
\r
void bug_get_file_line(struct bug_entry *bug, const char **file,\r
         unsigned int *line);\r
\r
struct bug_entry *find_bug(unsigned long bugaddr);\r
\r
enum bug_trap_type report_bug(unsigned long bug_addr, struct pt_regs *regs);\r
\r
\r
int is_valid_bugaddr(unsigned long addr);\r
\r
void generic_bug_clear_once(void);\r
# 80 "./include/linux/bug.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__warn_unused_result__)) bool check_data_corruption(bool v) { return v; }\r
# 14 "./include/linux/thread_info.h" 2\r
# 1 "./include/linux/restart_block.h" 1\r
# 10 "./include/linux/restart_block.h"\r
# 1 "./include/linux/time64.h" 1\r
\r
\r
\r
\r
# 1 "./include/linux/math64.h" 1\r
\r
\r
\r
\r
\r
\r
# 1 "./include/vdso/math64.h" 1\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) u32\r
__iter_div_u64_rem(u64 dividend, u32 divisor, u64 *remainder)\r
{\r
 u32 ret = 0;\r
\r
 while (dividend >= divisor) {\r
\r
\r
  asm("" : "+rm"(dividend));\r
\r
  dividend -= divisor;\r
  ret++;\r
 }\r
\r
 *remainder = dividend;\r
\r
 return ret;\r
}\r
# 8 "./include/linux/math64.h" 2\r
# 1 "./arch/riscv/include/generated/asm/div64.h" 1\r
# 9 "./include/linux/math64.h" 2\r
# 26 "./include/linux/math64.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) u64 div_u64_rem(u64 dividend, u32 divisor, u32 *remainder)\r
{\r
 *remainder = dividend % divisor;\r
 return dividend / divisor;\r
}\r
# 40 "./include/linux/math64.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) s64 div_s64_rem(s64 dividend, s32 divisor, s32 *remainder)\r
{\r
 *remainder = dividend % divisor;\r
 return dividend / divisor;\r
}\r
# 54 "./include/linux/math64.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) u64 div64_u64_rem(u64 dividend, u64 divisor, u64 *remainder)\r
{\r
 *remainder = dividend % divisor;\r
 return dividend / divisor;\r
}\r
# 67 "./include/linux/math64.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) u64 div64_u64(u64 dividend, u64 divisor)\r
{\r
 return dividend / divisor;\r
}\r
# 79 "./include/linux/math64.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) s64 div64_s64(s64 dividend, s64 divisor)\r
{\r
 return dividend / divisor;\r
}\r
# 125 "./include/linux/math64.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) u64 div_u64(u64 dividend, u32 divisor)\r
{\r
 u32 remainder;\r
 return div_u64_rem(dividend, divisor, &remainder);\r
}\r
# 138 "./include/linux/math64.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) s64 div_s64(s64 dividend, s32 divisor)\r
{\r
 s32 remainder;\r
 return div_s64_rem(dividend, divisor, &remainder);\r
}\r
\r
\r
u32 iter_div_u64_rem(u64 dividend, u32 divisor, u64 *remainder);\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) u64 mul_u32_u32(u32 a, u32 b)\r
{\r
 return (u64)a * b;\r
}\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) u64 mul_u64_u32_shr(u64 a, u32 mul, unsigned int shift)\r
{\r
 return (u64)(((unsigned __int128)a * mul) >> shift);\r
}\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) u64 mul_u64_u64_shr(u64 a, u64 mul, unsigned int shift)\r
{\r
 return (u64)(((unsigned __int128)a * mul) >> shift);\r
}\r
# 239 "./include/linux/math64.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) u64 mul_s64_u64_shr(s64 a, u64 b, unsigned int shift)\r
{\r
 u64 ret;\r
\r
\r
\r
\r
\r
 ret = mul_u64_u64_shr(__builtin_choose_expr( __builtin_types_compatible_p(typeof(a), signed long long) || __builtin_types_compatible_p(typeof(a), unsigned long long), ({ signed long long __x = (a); __x < 0 ? -__x : __x; }), __builtin_choose_expr( __builtin_types_compatible_p(typeof(a), signed long) || __builtin_types_compatible_p(typeof(a), unsigned long), ({ signed long __x = (a); __x < 0 ? -__x : __x; }), __builtin_choose_expr( __builtin_types_compatible_p(typeof(a), signed int) || __builtin_types_compatible_p(typeof(a), unsigned int), ({ signed int __x = (a); __x < 0 ? -__x : __x; }), __builtin_choose_expr( __builtin_types_compatible_p(typeof(a), signed short) || __builtin_types_compatible_p(typeof(a), unsigned short), ({ signed short __x = (a); __x < 0 ? -__x : __x; }), __builtin_choose_expr( __builtin_types_compatible_p(typeof(a), signed char) || __builtin_types_compatible_p(typeof(a), unsigned char), ({ signed char __x = (a); __x < 0 ? -__x : __x; }), __builtin_choose_expr( __builtin_types_compatible_p(typeof(a), char), (char)({ signed char __x = (a); __x<0?-__x:__x; }), ((void)0))))))), b, shift);\r
\r
 if (a < 0)\r
  ret = -((s64) ret);\r
\r
 return ret;\r
}\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) u64 mul_u64_u32_div(u64 a, u32 mul, u32 divisor)\r
{\r
 union {\r
  u64 ll;\r
  struct {\r
\r
\r
\r
   u32 low, high;\r
\r
  } l;\r
 } u, rl, rh;\r
\r
 u.ll = a;\r
 rl.ll = mul_u32_u32(u.l.low, mul);\r
 rh.ll = mul_u32_u32(u.l.high, mul) + rl.l.high;\r
\r
\r
 rl.l.high = ({ uint32_t __base = (divisor); uint32_t __rem; __rem = ((uint64_t)(rh.ll)) % __base; (rh.ll) = ((uint64_t)(rh.ll)) / __base; __rem; });\r
\r
\r
 ({ uint32_t __base = (divisor); uint32_t __rem; __rem = ((uint64_t)(rl.ll)) % __base; (rl.ll) = ((uint64_t)(rl.ll)) / __base; __rem; });\r
\r
 rl.l.high = rh.l.low;\r
 return rl.ll;\r
}\r
\r
\r
u64 mul_u64_u64_div_u64(u64 a, u64 mul, u64 div);\r
# 6 "./include/linux/time64.h" 2\r
# 1 "./include/vdso/time64.h" 1\r
# 7 "./include/linux/time64.h" 2\r
\r
typedef __s64 time64_t;\r
typedef __u64 timeu64_t;\r
\r
\r
# 1 "./include/uapi/linux/time.h" 1\r
\r
\r
\r
\r
\r
# 1 "./include/uapi/linux/time_types.h" 1\r
\r
\r
\r
\r
\r
\r
struct __kernel_timespec {\r
 __kernel_time64_t tv_sec;\r
 long long tv_nsec;\r
};\r
\r
struct __kernel_itimerspec {\r
 struct __kernel_timespec it_interval;\r
 struct __kernel_timespec it_value;\r
};\r
# 25 "./include/uapi/linux/time_types.h"\r
struct __kernel_old_timeval {\r
 __kernel_long_t tv_sec;\r
 __kernel_long_t tv_usec;\r
};\r
\r
\r
struct __kernel_old_timespec {\r
 __kernel_old_time_t tv_sec;\r
 long tv_nsec;\r
};\r
\r
struct __kernel_old_itimerval {\r
 struct __kernel_old_timeval it_interval;\r
 struct __kernel_old_timeval it_value;\r
};\r
\r
struct __kernel_sock_timeval {\r
 __s64 tv_sec;\r
 __s64 tv_usec;\r
};\r
# 7 "./include/uapi/linux/time.h" 2\r
# 33 "./include/uapi/linux/time.h"\r
struct timezone {\r
 int tz_minuteswest;\r
 int tz_dsttime;\r
};\r
# 12 "./include/linux/time64.h" 2\r
\r
struct timespec64 {\r
 time64_t tv_sec;\r
 long tv_nsec;\r
};\r
\r
struct itimerspec64 {\r
 struct timespec64 it_interval;\r
 struct timespec64 it_value;\r
};\r
# 43 "./include/linux/time64.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int timespec64_equal(const struct timespec64 *a,\r
       const struct timespec64 *b)\r
{\r
 return (a->tv_sec == b->tv_sec) && (a->tv_nsec == b->tv_nsec);\r
}\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int timespec64_compare(const struct timespec64 *lhs, const struct timespec64 *rhs)\r
{\r
 if (lhs->tv_sec < rhs->tv_sec)\r
  return -1;\r
 if (lhs->tv_sec > rhs->tv_sec)\r
  return 1;\r
 return lhs->tv_nsec - rhs->tv_nsec;\r
}\r
\r
extern void set_normalized_timespec64(struct timespec64 *ts, time64_t sec, s64 nsec);\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) struct timespec64 timespec64_add(struct timespec64 lhs,\r
      struct timespec64 rhs)\r
{\r
 struct timespec64 ts_delta;\r
 set_normalized_timespec64(&ts_delta, lhs.tv_sec + rhs.tv_sec,\r
    lhs.tv_nsec + rhs.tv_nsec);\r
 return ts_delta;\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) struct timespec64 timespec64_sub(struct timespec64 lhs,\r
      struct timespec64 rhs)\r
{\r
 struct timespec64 ts_delta;\r
 set_normalized_timespec64(&ts_delta, lhs.tv_sec - rhs.tv_sec,\r
    lhs.tv_nsec - rhs.tv_nsec);\r
 return ts_delta;\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool timespec64_valid(const struct timespec64 *ts)\r
{\r
\r
 if (ts->tv_sec < 0)\r
  return false;\r
\r
 if ((unsigned long)ts->tv_nsec >= 1000000000L)\r
  return false;\r
 return true;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool timespec64_valid_strict(const struct timespec64 *ts)\r
{\r
 if (!timespec64_valid(ts))\r
  return false;\r
\r
 if ((unsigned long long)ts->tv_sec >= (((s64)~((u64)1 << 63)) / 1000000000L))\r
  return false;\r
 return true;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool timespec64_valid_settod(const struct timespec64 *ts)\r
{\r
 if (!timespec64_valid(ts))\r
  return false;\r
\r
 if ((unsigned long long)ts->tv_sec >= ((((s64)~((u64)1 << 63)) / 1000000000L) - (30LL * 365 * 24 *3600)))\r
  return false;\r
 return true;\r
}\r
# 127 "./include/linux/time64.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) s64 timespec64_to_ns(const struct timespec64 *ts)\r
{\r
\r
 if (ts->tv_sec >= (((s64)~((u64)1 << 63)) / 1000000000L))\r
  return ((s64)~((u64)1 << 63));\r
\r
 if (ts->tv_sec <= ((-((s64)~((u64)1 << 63)) - 1) / 1000000000L))\r
  return (-((s64)~((u64)1 << 63)) - 1);\r
\r
 return ((s64) ts->tv_sec * 1000000000L) + ts->tv_nsec;\r
}\r
\r
\r
\r
\r
\r
\r
\r
extern struct timespec64 ns_to_timespec64(const s64 nsec);\r
# 155 "./include/linux/time64.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void timespec64_add_ns(struct timespec64 *a, u64 ns)\r
{\r
 a->tv_sec += __iter_div_u64_rem(a->tv_nsec + ns, 1000000000L, &ns);\r
 a->tv_nsec = ns;\r
}\r
\r
\r
\r
\r
\r
extern struct timespec64 timespec64_add_safe(const struct timespec64 lhs,\r
      const struct timespec64 rhs);\r
# 11 "./include/linux/restart_block.h" 2\r
\r
struct timespec;\r
struct old_timespec32;\r
struct pollfd;\r
\r
enum timespec_type {\r
 TT_NONE = 0,\r
 TT_NATIVE = 1,\r
 TT_COMPAT = 2,\r
};\r
\r
\r
\r
\r
struct restart_block {\r
 unsigned long arch_data;\r
 long (*fn)(struct restart_block *);\r
 union {\r
\r
  struct {\r
   u32 *uaddr;\r
   u32 val;\r
   u32 flags;\r
   u32 bitset;\r
   u64 time;\r
   u32 *uaddr2;\r
  } futex;\r
\r
  struct {\r
   clockid_t clockid;\r
   enum timespec_type type;\r
   union {\r
    struct __kernel_timespec *rmtp;\r
    struct old_timespec32 *compat_rmtp;\r
   };\r
   u64 expires;\r
  } nanosleep;\r
\r
  struct {\r
   struct pollfd *ufds;\r
   int nfds;\r
   int has_timeout;\r
   unsigned long tv_sec;\r
   unsigned long tv_nsec;\r
  } poll;\r
 };\r
};\r
\r
extern long do_no_restart_syscall(struct restart_block *parm);\r
# 15 "./include/linux/thread_info.h" 2\r
\r
\r
\r
\r
\r
\r
\r
\r
# 1 "./arch/riscv/include/asm/current.h" 1\r
# 18 "./arch/riscv/include/asm/current.h"\r
struct task_struct;\r
\r
register struct task_struct *riscv_current_is_tp __asm__("tp");\r
# 29 "./arch/riscv/include/asm/current.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) struct task_struct *get_current(void)\r
{\r
 return riscv_current_is_tp;\r
}\r
\r
\r
\r
register unsigned long current_stack_pointer __asm__("sp");\r
# 24 "./include/linux/thread_info.h" 2\r
# 33 "./include/linux/thread_info.h"\r
enum {\r
 BAD_STACK = -1,\r
 NOT_STACK = 0,\r
 GOOD_FRAME,\r
 GOOD_STACK,\r
};\r
# 60 "./include/linux/thread_info.h"\r
# 1 "./arch/riscv/include/asm/thread_info.h" 1\r
# 11 "./arch/riscv/include/asm/thread_info.h"\r
# 1 "./arch/riscv/include/asm/page.h" 1\r
# 12 "./arch/riscv/include/asm/page.h"\r
# 1 "./include/linux/pfn.h" 1\r
# 13 "./include/linux/pfn.h"\r
typedef struct {\r
 u64 val;\r
} pfn_t;\r
# 13 "./arch/riscv/include/asm/page.h" 2\r
# 64 "./arch/riscv/include/asm/page.h"\r
typedef struct {\r
 unsigned long pgd;\r
} pgd_t;\r
\r
\r
typedef struct {\r
 unsigned long pte;\r
} pte_t;\r
\r
typedef struct {\r
 unsigned long pgprot;\r
} pgprot_t;\r
\r
typedef struct page *pgtable_t;\r
# 94 "./arch/riscv/include/asm/page.h"\r
extern unsigned long riscv_pfn_base;\r
\r
\r
\r
\r
\r
struct kernel_mapping {\r
 unsigned long page_offset;\r
 unsigned long virt_addr;\r
 uintptr_t phys_addr;\r
 uintptr_t size;\r
\r
 unsigned long va_pa_offset;\r
\r
 unsigned long va_kernel_pa_offset;\r
 unsigned long va_kernel_xip_pa_offset;\r
\r
\r
\r
\r
};\r
\r
extern struct kernel_mapping kernel_map;\r
extern phys_addr_t phys_ram_base;\r
# 189 "./arch/riscv/include/asm/page.h"\r
# 1 "./include/asm-generic/memory_model.h" 1\r
# 190 "./arch/riscv/include/asm/page.h" 2\r
# 1 "./include/asm-generic/getorder.h" 1\r
# 29 "./include/asm-generic/getorder.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) __attribute__((__const__)) int get_order(unsigned long size)\r
{\r
 if (__builtin_constant_p(size)) {\r
  if (!size)\r
   return 64 - (12);\r
\r
  if (size < (1UL << (12)))\r
   return 0;\r
\r
  return ( __builtin_constant_p((size) - 1) ? (((size) - 1) < 2 ? 0 : 63 - __builtin_clzll((size) - 1)) : (sizeof((size) - 1) <= 4) ? __ilog2_u32((size) - 1) : __ilog2_u64((size) - 1) ) - (12) + 1;\r
 }\r
\r
 size--;\r
 size >>= (12);\r
\r
\r
\r
 return fls64(size);\r
\r
}\r
# 191 "./arch/riscv/include/asm/page.h" 2\r
# 12 "./arch/riscv/include/asm/thread_info.h" 2\r
# 56 "./arch/riscv/include/asm/thread_info.h"\r
struct thread_info {\r
 unsigned long flags;\r
 int preempt_count;\r
\r
\r
\r
\r
\r
 long kernel_sp;\r
 long user_sp;\r
 int cpu;\r
};\r
# 61 "./include/linux/thread_info.h" 2\r
\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) long set_restart_fn(struct restart_block *restart,\r
     long (*fn)(struct restart_block *))\r
{\r
 restart->fn = fn;\r
 do { } while (0);\r
 return -516;\r
}\r
# 87 "./include/linux/thread_info.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void set_ti_thread_flag(struct thread_info *ti, int flag)\r
{\r
 set_bit(flag, (unsigned long *)&ti->flags);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void clear_ti_thread_flag(struct thread_info *ti, int flag)\r
{\r
 clear_bit(flag, (unsigned long *)&ti->flags);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void update_ti_thread_flag(struct thread_info *ti, int flag,\r
      bool value)\r
{\r
 if (value)\r
  set_ti_thread_flag(ti, flag);\r
 else\r
  clear_ti_thread_flag(ti, flag);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int test_and_set_ti_thread_flag(struct thread_info *ti, int flag)\r
{\r
 return test_and_set_bit(flag, (unsigned long *)&ti->flags);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int test_and_clear_ti_thread_flag(struct thread_info *ti, int flag)\r
{\r
 return test_and_clear_bit(flag, (unsigned long *)&ti->flags);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int test_ti_thread_flag(struct thread_info *ti, int flag)\r
{\r
 return arch_test_bit(flag, (unsigned long *)&ti->flags);\r
}\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) unsigned long read_ti_thread_flags(struct thread_info *ti)\r
{\r
 return ({ do { __attribute__((__noreturn__)) extern void __compiletime_assert_0(void) ; if (!((sizeof(ti->flags) == sizeof(char) || sizeof(ti->flags) == sizeof(short) || sizeof(ti->flags) == sizeof(int) || sizeof(ti->flags) == sizeof(long)) || sizeof(ti->flags) == sizeof(long long))) __compiletime_assert_0(); } while (0); (*(const volatile typeof( _Generic((ti->flags), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (ti->flags))) *)&(ti->flags)); });\r
}\r
# 183 "./include/linux/thread_info.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int arch_within_stack_frames(const void * const stack,\r
        const void * const stackend,\r
        const void *obj, unsigned long len)\r
{\r
 return 0;\r
}\r
# 202 "./include/linux/thread_info.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void check_object_size(const void *ptr, unsigned long n,\r
         bool to_user)\r
{ }\r
\r
\r
extern void\r
__bad_copy_from(void);\r
extern void\r
__bad_copy_to(void);\r
\r
void __copy_overflow(int size, unsigned long count);\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void copy_overflow(int size, unsigned long count)\r
{\r
 if (1)\r
  __copy_overflow(size, count);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) __attribute__((__warn_unused_result__)) bool\r
check_copy_size(const void *addr, size_t bytes, bool is_source)\r
{\r
 int sz = __builtin_object_size(addr, 0);\r
 if (__builtin_expect(!!(sz >= 0 && sz < bytes), 0)) {\r
  if (!__builtin_constant_p(bytes))\r
   copy_overflow(sz, bytes);\r
  else if (is_source)\r
   __bad_copy_from();\r
  else\r
   __bad_copy_to();\r
  return false;\r
 }\r
 if (({ int __ret_warn_on = !!(bytes > ((int)(~0U >> 1))); if (__builtin_expect(!!(__ret_warn_on), 0)) do { __asm__ __volatile__ ( "1:\n\t" "ebreak\n" ".pushsection __bug_table,\"aw\"\n\t" "2:\n\t" ".word" " 1b - 2b" "\n\t" ".word" " %0 - 2b" "\n\t" ".half" " %1\n\t" ".half" " %2" "\n\t" ".org 2b + %3\n\t" ".popsection" : : "i" ("include/linux/thread_info.h"), "i" (233), "i" ((1 << 0)|((1 << 1) | ((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); __builtin_expect(!!(__ret_warn_on), 0); }))\r
  return false;\r
 check_object_size(addr, bytes, is_source);\r
 return true;\r
}\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void arch_setup_new_exec(void) { }\r
# 10 "./include/linux/uio.h" 2\r
# 1 "./include/linux/mm_types.h" 1\r
\r
\r
\r
\r
# 1 "./include/linux/mm_types_task.h" 1\r
# 13 "./include/linux/mm_types_task.h"\r
# 1 "./include/linux/atomic.h" 1\r
\r
\r
\r
\r
\r
\r
# 1 "./arch/riscv/include/asm/atomic.h" 1\r
# 19 "./arch/riscv/include/asm/atomic.h"\r
# 1 "./arch/riscv/include/asm/cmpxchg.h" 1\r
# 12 "./arch/riscv/include/asm/cmpxchg.h"\r
# 1 "./arch/riscv/include/asm/fence.h" 1\r
# 13 "./arch/riscv/include/asm/cmpxchg.h" 2\r
# 20 "./arch/riscv/include/asm/atomic.h" 2\r
\r
\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int arch_atomic_read(const atomic_t *v)\r
{\r
 return ({ do { __attribute__((__noreturn__)) extern void __compiletime_assert_1(void) ; if (!((sizeof(v->counter) == sizeof(char) || sizeof(v->counter) == sizeof(short) || sizeof(v->counter) == sizeof(int) || sizeof(v->counter) == sizeof(long)) || sizeof(v->counter) == sizeof(long long))) __compiletime_assert_1(); } while (0); (*(const volatile typeof( _Generic((v->counter), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (v->counter))) *)&(v->counter)); });\r
}\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void arch_atomic_set(atomic_t *v, int i)\r
{\r
 do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_2(void) ; if (!((sizeof(v->counter) == sizeof(char) || sizeof(v->counter) == sizeof(short) || sizeof(v->counter) == sizeof(int) || sizeof(v->counter) == sizeof(long)) || sizeof(v->counter) == sizeof(long long))) __compiletime_assert_2(); } while (0); do { *(volatile typeof(v->counter) *)&(v->counter) = (i); } while (0); } while (0);\r
}\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64 arch_atomic64_read(const atomic64_t *v)\r
{\r
 return ({ do { __attribute__((__noreturn__)) extern void __compiletime_assert_3(void) ; if (!((sizeof(v->counter) == sizeof(char) || sizeof(v->counter) == sizeof(short) || sizeof(v->counter) == sizeof(int) || sizeof(v->counter) == sizeof(long)) || sizeof(v->counter) == sizeof(long long))) __compiletime_assert_3(); } while (0); (*(const volatile typeof( _Generic((v->counter), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (v->counter))) *)&(v->counter)); });\r
}\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void arch_atomic64_set(atomic64_t *v, s64 i)\r
{\r
 do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_4(void) ; if (!((sizeof(v->counter) == sizeof(char) || sizeof(v->counter) == sizeof(short) || sizeof(v->counter) == sizeof(int) || sizeof(v->counter) == sizeof(long)) || sizeof(v->counter) == sizeof(long long))) __compiletime_assert_4(); } while (0); do { *(volatile typeof(v->counter) *)&(v->counter) = (i); } while (0); } while (0);\r
}\r
# 74 "./arch/riscv/include/asm/atomic.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void arch_atomic_add(int i, atomic_t *v) { __asm__ __volatile__ ( "	amo" "add" "." "w" " zero, %1, %0" : "+A" (v->counter) : "r" (i) : "memory"); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void arch_atomic64_add(s64 i, atomic64_t *v) { __asm__ __volatile__ ( "	amo" "add" "." "d" " zero, %1, %0" : "+A" (v->counter) : "r" (i) : "memory"); }\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void arch_atomic_sub(int i, atomic_t *v) { __asm__ __volatile__ ( "	amo" "add" "." "w" " zero, %1, %0" : "+A" (v->counter) : "r" (-i) : "memory"); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void arch_atomic64_sub(s64 i, atomic64_t *v) { __asm__ __volatile__ ( "	amo" "add" "." "d" " zero, %1, %0" : "+A" (v->counter) : "r" (-i) : "memory"); }\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void arch_atomic_and(int i, atomic_t *v) { __asm__ __volatile__ ( "	amo" "and" "." "w" " zero, %1, %0" : "+A" (v->counter) : "r" (i) : "memory"); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void arch_atomic64_and(s64 i, atomic64_t *v) { __asm__ __volatile__ ( "	amo" "and" "." "d" " zero, %1, %0" : "+A" (v->counter) : "r" (i) : "memory"); }\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void arch_atomic_or(int i, atomic_t *v) { __asm__ __volatile__ ( "	amo" "or" "." "w" " zero, %1, %0" : "+A" (v->counter) : "r" (i) : "memory"); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void arch_atomic64_or(s64 i, atomic64_t *v) { __asm__ __volatile__ ( "	amo" "or" "." "d" " zero, %1, %0" : "+A" (v->counter) : "r" (i) : "memory"); }\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void arch_atomic_xor(int i, atomic_t *v) { __asm__ __volatile__ ( "	amo" "xor" "." "w" " zero, %1, %0" : "+A" (v->counter) : "r" (i) : "memory"); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void arch_atomic64_xor(s64 i, atomic64_t *v) { __asm__ __volatile__ ( "	amo" "xor" "." "d" " zero, %1, %0" : "+A" (v->counter) : "r" (i) : "memory"); }\r
# 138 "./arch/riscv/include/asm/atomic.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int arch_atomic_fetch_add_relaxed(int i, atomic_t *v) { register int ret; __asm__ __volatile__ ( "	amo" "add" "." "w" " %1, %2, %0" : "+A" (v->counter), "=r" (ret) : "r" (i) : "memory"); return ret; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int arch_atomic_fetch_add(int i, atomic_t *v) { register int ret; __asm__ __volatile__ ( "	amo" "add" "." "w" ".aqrl  %1, %2, %0" : "+A" (v->counter), "=r" (ret) : "r" (i) : "memory"); return ret; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int arch_atomic_add_return_relaxed(int i, atomic_t *v) { return arch_atomic_fetch_add_relaxed(i, v) + i; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int arch_atomic_add_return(int i, atomic_t *v) { return arch_atomic_fetch_add(i, v) + i; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64 arch_atomic64_fetch_add_relaxed(s64 i, atomic64_t *v) { register s64 ret; __asm__ __volatile__ ( "	amo" "add" "." "d" " %1, %2, %0" : "+A" (v->counter), "=r" (ret) : "r" (i) : "memory"); return ret; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64 arch_atomic64_fetch_add(s64 i, atomic64_t *v) { register s64 ret; __asm__ __volatile__ ( "	amo" "add" "." "d" ".aqrl  %1, %2, %0" : "+A" (v->counter), "=r" (ret) : "r" (i) : "memory"); return ret; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64 arch_atomic64_add_return_relaxed(s64 i, atomic64_t *v) { return arch_atomic64_fetch_add_relaxed(i, v) + i; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64 arch_atomic64_add_return(s64 i, atomic64_t *v) { return arch_atomic64_fetch_add(i, v) + i; }\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int arch_atomic_fetch_sub_relaxed(int i, atomic_t *v) { register int ret; __asm__ __volatile__ ( "	amo" "add" "." "w" " %1, %2, %0" : "+A" (v->counter), "=r" (ret) : "r" (-i) : "memory"); return ret; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int arch_atomic_fetch_sub(int i, atomic_t *v) { register int ret; __asm__ __volatile__ ( "	amo" "add" "." "w" ".aqrl  %1, %2, %0" : "+A" (v->counter), "=r" (ret) : "r" (-i) : "memory"); return ret; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int arch_atomic_sub_return_relaxed(int i, atomic_t *v) { return arch_atomic_fetch_sub_relaxed(i, v) + -i; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int arch_atomic_sub_return(int i, atomic_t *v) { return arch_atomic_fetch_sub(i, v) + -i; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64 arch_atomic64_fetch_sub_relaxed(s64 i, atomic64_t *v) { register s64 ret; __asm__ __volatile__ ( "	amo" "add" "." "d" " %1, %2, %0" : "+A" (v->counter), "=r" (ret) : "r" (-i) : "memory"); return ret; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64 arch_atomic64_fetch_sub(s64 i, atomic64_t *v) { register s64 ret; __asm__ __volatile__ ( "	amo" "add" "." "d" ".aqrl  %1, %2, %0" : "+A" (v->counter), "=r" (ret) : "r" (-i) : "memory"); return ret; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64 arch_atomic64_sub_return_relaxed(s64 i, atomic64_t *v) { return arch_atomic64_fetch_sub_relaxed(i, v) + -i; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64 arch_atomic64_sub_return(s64 i, atomic64_t *v) { return arch_atomic64_fetch_sub(i, v) + -i; }\r
# 174 "./arch/riscv/include/asm/atomic.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int arch_atomic_fetch_and_relaxed(int i, atomic_t *v) { register int ret; __asm__ __volatile__ ( "	amo" "and" "." "w" " %1, %2, %0" : "+A" (v->counter), "=r" (ret) : "r" (i) : "memory"); return ret; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int arch_atomic_fetch_and(int i, atomic_t *v) { register int ret; __asm__ __volatile__ ( "	amo" "and" "." "w" ".aqrl  %1, %2, %0" : "+A" (v->counter), "=r" (ret) : "r" (i) : "memory"); return ret; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64 arch_atomic64_fetch_and_relaxed(s64 i, atomic64_t *v) { register s64 ret; __asm__ __volatile__ ( "	amo" "and" "." "d" " %1, %2, %0" : "+A" (v->counter), "=r" (ret) : "r" (i) : "memory"); return ret; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64 arch_atomic64_fetch_and(s64 i, atomic64_t *v) { register s64 ret; __asm__ __volatile__ ( "	amo" "and" "." "d" ".aqrl  %1, %2, %0" : "+A" (v->counter), "=r" (ret) : "r" (i) : "memory"); return ret; }\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int arch_atomic_fetch_or_relaxed(int i, atomic_t *v) { register int ret; __asm__ __volatile__ ( "	amo" "or" "." "w" " %1, %2, %0" : "+A" (v->counter), "=r" (ret) : "r" (i) : "memory"); return ret; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int arch_atomic_fetch_or(int i, atomic_t *v) { register int ret; __asm__ __volatile__ ( "	amo" "or" "." "w" ".aqrl  %1, %2, %0" : "+A" (v->counter), "=r" (ret) : "r" (i) : "memory"); return ret; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64 arch_atomic64_fetch_or_relaxed(s64 i, atomic64_t *v) { register s64 ret; __asm__ __volatile__ ( "	amo" "or" "." "d" " %1, %2, %0" : "+A" (v->counter), "=r" (ret) : "r" (i) : "memory"); return ret; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64 arch_atomic64_fetch_or(s64 i, atomic64_t *v) { register s64 ret; __asm__ __volatile__ ( "	amo" "or" "." "d" ".aqrl  %1, %2, %0" : "+A" (v->counter), "=r" (ret) : "r" (i) : "memory"); return ret; }\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int arch_atomic_fetch_xor_relaxed(int i, atomic_t *v) { register int ret; __asm__ __volatile__ ( "	amo" "xor" "." "w" " %1, %2, %0" : "+A" (v->counter), "=r" (ret) : "r" (i) : "memory"); return ret; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int arch_atomic_fetch_xor(int i, atomic_t *v) { register int ret; __asm__ __volatile__ ( "	amo" "xor" "." "w" ".aqrl  %1, %2, %0" : "+A" (v->counter), "=r" (ret) : "r" (i) : "memory"); return ret; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64 arch_atomic64_fetch_xor_relaxed(s64 i, atomic64_t *v) { register s64 ret; __asm__ __volatile__ ( "	amo" "xor" "." "d" " %1, %2, %0" : "+A" (v->counter), "=r" (ret) : "r" (i) : "memory"); return ret; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64 arch_atomic64_fetch_xor(s64 i, atomic64_t *v) { register s64 ret; __asm__ __volatile__ ( "	amo" "xor" "." "d" ".aqrl  %1, %2, %0" : "+A" (v->counter), "=r" (ret) : "r" (i) : "memory"); return ret; }\r
# 200 "./arch/riscv/include/asm/atomic.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int arch_atomic_fetch_add_unless(atomic_t *v, int a, int u)\r
{\r
       int prev, rc;\r
\r
 __asm__ __volatile__ (\r
  "0:	lr.w     %[p],  %[c]\n"\r
  "	beq      %[p],  %[u], 1f\n"\r
  "	add      %[rc], %[p], %[a]\n"\r
  "	sc.w.rl  %[rc], %[rc], %[c]\n"\r
  "	bnez     %[rc], 0b\n"\r
  "	fence    rw, rw\n"\r
  "1:\n"\r
  : [p]"=&r" (prev), [rc]"=&r" (rc), [c]"+A" (v->counter)\r
  : [a]"r" (a), [u]"r" (u)\r
  : "memory");\r
 return prev;\r
}\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64 arch_atomic64_fetch_add_unless(atomic64_t *v, s64 a, s64 u)\r
{\r
       s64 prev;\r
       long rc;\r
\r
 __asm__ __volatile__ (\r
  "0:	lr.d     %[p],  %[c]\n"\r
  "	beq      %[p],  %[u], 1f\n"\r
  "	add      %[rc], %[p], %[a]\n"\r
  "	sc.d.rl  %[rc], %[rc], %[c]\n"\r
  "	bnez     %[rc], 0b\n"\r
  "	fence    rw, rw\n"\r
  "1:\n"\r
  : [p]"=&r" (prev), [rc]"=&r" (rc), [c]"+A" (v->counter)\r
  : [a]"r" (a), [u]"r" (u)\r
  : "memory");\r
 return prev;\r
}\r
# 299 "./arch/riscv/include/asm/atomic.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int arch_atomic_xchg_relaxed(atomic_t *v, int n) { return ({ __typeof__(&(v->counter)) __ptr = (&(v->counter)); __typeof__(n) __new = (n); __typeof__(*(&(v->counter))) __ret; switch (4) { case 4: __asm__ __volatile__ ( "	amoswap.w %0, %2, %1\n" : "=r" (__ret), "+A" (*__ptr) : "r" (__new) : "memory"); break; case 8: __asm__ __volatile__ ( "	amoswap.d %0, %2, %1\n" : "=r" (__ret), "+A" (*__ptr) : "r" (__new) : "memory"); break; default: do { __attribute__((__noreturn__)) extern void __compiletime_assert_5(void) ; if (!(!(1))) __compiletime_assert_5(); } while (0); } __ret; }); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int arch_atomic_xchg_acquire(atomic_t *v, int n) { return ({ __typeof__(&(v->counter)) __ptr = (&(v->counter)); __typeof__(n) __new = (n); __typeof__(*(&(v->counter))) __ret; switch (4) { case 4: __asm__ __volatile__ ( "	amoswap.w %0, %2, %1\n" "\tfence r , rw\n" : "=r" (__ret), "+A" (*__ptr) : "r" (__new) : "memory"); break; case 8: __asm__ __volatile__ ( "	amoswap.d %0, %2, %1\n" "\tfence r , rw\n" : "=r" (__ret), "+A" (*__ptr) : "r" (__new) : "memory"); break; default: do { __attribute__((__noreturn__)) extern void __compiletime_assert_6(void) ; if (!(!(1))) __compiletime_assert_6(); } while (0); } __ret; }); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int arch_atomic_xchg_release(atomic_t *v, int n) { return ({ __typeof__(&(v->counter)) __ptr = (&(v->counter)); __typeof__(n) __new = (n); __typeof__(*(&(v->counter))) __ret; switch (4) { case 4: __asm__ __volatile__ ( "\tfence rw,  w\n" "	amoswap.w %0, %2, %1\n" : "=r" (__ret), "+A" (*__ptr) : "r" (__new) : "memory"); break; case 8: __asm__ __volatile__ ( "\tfence rw,  w\n" "	amoswap.d %0, %2, %1\n" : "=r" (__ret), "+A" (*__ptr) : "r" (__new) : "memory"); break; default: do { __attribute__((__noreturn__)) extern void __compiletime_assert_7(void) ; if (!(!(1))) __compiletime_assert_7(); } while (0); } __ret; }); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int arch_atomic_xchg(atomic_t *v, int n) { return ({ __typeof__(&(v->counter)) __ptr = (&(v->counter)); __typeof__(n) __new = (n); __typeof__(*(&(v->counter))) __ret; switch (4) { case 4: __asm__ __volatile__ ( "	amoswap.w.aqrl %0, %2, %1\n" : "=r" (__ret), "+A" (*__ptr) : "r" (__new) : "memory"); break; case 8: __asm__ __volatile__ ( "	amoswap.d.aqrl %0, %2, %1\n" : "=r" (__ret), "+A" (*__ptr) : "r" (__new) : "memory"); break; default: do { __attribute__((__noreturn__)) extern void __compiletime_assert_8(void) ; if (!(!(1))) __compiletime_assert_8(); } while (0); } __ret; }); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int arch_atomic_cmpxchg_relaxed(atomic_t *v, int o, int n) { return ({ __typeof__(&(v->counter)) __ptr = (&(v->counter)); __typeof__(*(&(v->counter))) __old = (o); __typeof__(*(&(v->counter))) __new = (n); __typeof__(*(&(v->counter))) __ret; register unsigned int __rc; switch (4) { case 4: __asm__ __volatile__ ( "0:	lr.w %0, %2\n" "	bne  %0, %z3, 1f\n" "	sc.w %1, %z4, %2\n" "	bnez %1, 0b\n" "1:\n" : "=&r" (__ret), "=&r" (__rc), "+A" (*__ptr) : "rJ" ((long)__old), "rJ" (__new) : "memory"); break; case 8: __asm__ __volatile__ ( "0:	lr.d %0, %2\n" "	bne %0, %z3, 1f\n" "	sc.d %1, %z4, %2\n" "	bnez %1, 0b\n" "1:\n" : "=&r" (__ret), "=&r" (__rc), "+A" (*__ptr) : "rJ" (__old), "rJ" (__new) : "memory"); break; default: do { __attribute__((__noreturn__)) extern void __compiletime_assert_9(void) ; if (!(!(1))) __compiletime_assert_9(); } while (0); } __ret; }); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int arch_atomic_cmpxchg_acquire(atomic_t *v, int o, int n) { return ({ __typeof__(&(v->counter)) __ptr = (&(v->counter)); __typeof__(*(&(v->counter))) __old = (o); __typeof__(*(&(v->counter))) __new = (n); __typeof__(*(&(v->counter))) __ret; register unsigned int __rc; switch (4) { case 4: __asm__ __volatile__ ( "0:	lr.w %0, %2\n" "	bne  %0, %z3, 1f\n" "	sc.w %1, %z4, %2\n" "	bnez %1, 0b\n" "\tfence r , rw\n" "1:\n" : "=&r" (__ret), "=&r" (__rc), "+A" (*__ptr) : "rJ" ((long)__old), "rJ" (__new) : "memory"); break; case 8: __asm__ __volatile__ ( "0:	lr.d %0, %2\n" "	bne %0, %z3, 1f\n" "	sc.d %1, %z4, %2\n" "	bnez %1, 0b\n" "\tfence r , rw\n" "1:\n" : "=&r" (__ret), "=&r" (__rc), "+A" (*__ptr) : "rJ" (__old), "rJ" (__new) : "memory"); break; default: do { __attribute__((__noreturn__)) extern void __compiletime_assert_10(void) ; if (!(!(1))) __compiletime_assert_10(); } while (0); } __ret; }); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int arch_atomic_cmpxchg_release(atomic_t *v, int o, int n) { return ({ __typeof__(&(v->counter)) __ptr = (&(v->counter)); __typeof__(*(&(v->counter))) __old = (o); __typeof__(*(&(v->counter))) __new = (n); __typeof__(*(&(v->counter))) __ret; register unsigned int __rc; switch (4) { case 4: __asm__ __volatile__ ( "\tfence rw,  w\n" "0:	lr.w %0, %2\n" "	bne  %0, %z3, 1f\n" "	sc.w %1, %z4, %2\n" "	bnez %1, 0b\n" "1:\n" : "=&r" (__ret), "=&r" (__rc), "+A" (*__ptr) : "rJ" ((long)__old), "rJ" (__new) : "memory"); break; case 8: __asm__ __volatile__ ( "\tfence rw,  w\n" "0:	lr.d %0, %2\n" "	bne %0, %z3, 1f\n" "	sc.d %1, %z4, %2\n" "	bnez %1, 0b\n" "1:\n" : "=&r" (__ret), "=&r" (__rc), "+A" (*__ptr) : "rJ" (__old), "rJ" (__new) : "memory"); break; default: do { __attribute__((__noreturn__)) extern void __compiletime_assert_11(void) ; if (!(!(1))) __compiletime_assert_11(); } while (0); } __ret; }); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int arch_atomic_cmpxchg(atomic_t *v, int o, int n) { return ({ __typeof__(&(v->counter)) __ptr = (&(v->counter)); __typeof__(*(&(v->counter))) __old = (o); __typeof__(*(&(v->counter))) __new = (n); __typeof__(*(&(v->counter))) __ret; register unsigned int __rc; switch (4) { case 4: __asm__ __volatile__ ( "0:	lr.w %0, %2\n" "	bne  %0, %z3, 1f\n" "	sc.w.rl %1, %z4, %2\n" "	bnez %1, 0b\n" "	fence rw, rw\n" "1:\n" : "=&r" (__ret), "=&r" (__rc), "+A" (*__ptr) : "rJ" ((long)__old), "rJ" (__new) : "memory"); break; case 8: __asm__ __volatile__ ( "0:	lr.d %0, %2\n" "	bne %0, %z3, 1f\n" "	sc.d.rl %1, %z4, %2\n" "	bnez %1, 0b\n" "	fence rw, rw\n" "1:\n" : "=&r" (__ret), "=&r" (__rc), "+A" (*__ptr) : "rJ" (__old), "rJ" (__new) : "memory"); break; default: do { __attribute__((__noreturn__)) extern void __compiletime_assert_12(void) ; if (!(!(1))) __compiletime_assert_12(); } while (0); } __ret; }); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64 arch_atomic64_xchg_relaxed(atomic64_t *v, s64 n) { return ({ __typeof__(&(v->counter)) __ptr = (&(v->counter)); __typeof__(n) __new = (n); __typeof__(*(&(v->counter))) __ret; switch (8) { case 4: __asm__ __volatile__ ( "	amoswap.w %0, %2, %1\n" : "=r" (__ret), "+A" (*__ptr) : "r" (__new) : "memory"); break; case 8: __asm__ __volatile__ ( "	amoswap.d %0, %2, %1\n" : "=r" (__ret), "+A" (*__ptr) : "r" (__new) : "memory"); break; default: do { __attribute__((__noreturn__)) extern void __compiletime_assert_13(void) ; if (!(!(1))) __compiletime_assert_13(); } while (0); } __ret; }); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64 arch_atomic64_xchg_acquire(atomic64_t *v, s64 n) { return ({ __typeof__(&(v->counter)) __ptr = (&(v->counter)); __typeof__(n) __new = (n); __typeof__(*(&(v->counter))) __ret; switch (8) { case 4: __asm__ __volatile__ ( "	amoswap.w %0, %2, %1\n" "\tfence r , rw\n" : "=r" (__ret), "+A" (*__ptr) : "r" (__new) : "memory"); break; case 8: __asm__ __volatile__ ( "	amoswap.d %0, %2, %1\n" "\tfence r , rw\n" : "=r" (__ret), "+A" (*__ptr) : "r" (__new) : "memory"); break; default: do { __attribute__((__noreturn__)) extern void __compiletime_assert_14(void) ; if (!(!(1))) __compiletime_assert_14(); } while (0); } __ret; }); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64 arch_atomic64_xchg_release(atomic64_t *v, s64 n) { return ({ __typeof__(&(v->counter)) __ptr = (&(v->counter)); __typeof__(n) __new = (n); __typeof__(*(&(v->counter))) __ret; switch (8) { case 4: __asm__ __volatile__ ( "\tfence rw,  w\n" "	amoswap.w %0, %2, %1\n" : "=r" (__ret), "+A" (*__ptr) : "r" (__new) : "memory"); break; case 8: __asm__ __volatile__ ( "\tfence rw,  w\n" "	amoswap.d %0, %2, %1\n" : "=r" (__ret), "+A" (*__ptr) : "r" (__new) : "memory"); break; default: do { __attribute__((__noreturn__)) extern void __compiletime_assert_15(void) ; if (!(!(1))) __compiletime_assert_15(); } while (0); } __ret; }); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64 arch_atomic64_xchg(atomic64_t *v, s64 n) { return ({ __typeof__(&(v->counter)) __ptr = (&(v->counter)); __typeof__(n) __new = (n); __typeof__(*(&(v->counter))) __ret; switch (8) { case 4: __asm__ __volatile__ ( "	amoswap.w.aqrl %0, %2, %1\n" : "=r" (__ret), "+A" (*__ptr) : "r" (__new) : "memory"); break; case 8: __asm__ __volatile__ ( "	amoswap.d.aqrl %0, %2, %1\n" : "=r" (__ret), "+A" (*__ptr) : "r" (__new) : "memory"); break; default: do { __attribute__((__noreturn__)) extern void __compiletime_assert_16(void) ; if (!(!(1))) __compiletime_assert_16(); } while (0); } __ret; }); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64 arch_atomic64_cmpxchg_relaxed(atomic64_t *v, s64 o, s64 n) { return ({ __typeof__(&(v->counter)) __ptr = (&(v->counter)); __typeof__(*(&(v->counter))) __old = (o); __typeof__(*(&(v->counter))) __new = (n); __typeof__(*(&(v->counter))) __ret; register unsigned int __rc; switch (8) { case 4: __asm__ __volatile__ ( "0:	lr.w %0, %2\n" "	bne  %0, %z3, 1f\n" "	sc.w %1, %z4, %2\n" "	bnez %1, 0b\n" "1:\n" : "=&r" (__ret), "=&r" (__rc), "+A" (*__ptr) : "rJ" ((long)__old), "rJ" (__new) : "memory"); break; case 8: __asm__ __volatile__ ( "0:	lr.d %0, %2\n" "	bne %0, %z3, 1f\n" "	sc.d %1, %z4, %2\n" "	bnez %1, 0b\n" "1:\n" : "=&r" (__ret), "=&r" (__rc), "+A" (*__ptr) : "rJ" (__old), "rJ" (__new) : "memory"); break; default: do { __attribute__((__noreturn__)) extern void __compiletime_assert_17(void) ; if (!(!(1))) __compiletime_assert_17(); } while (0); } __ret; }); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64 arch_atomic64_cmpxchg_acquire(atomic64_t *v, s64 o, s64 n) { return ({ __typeof__(&(v->counter)) __ptr = (&(v->counter)); __typeof__(*(&(v->counter))) __old = (o); __typeof__(*(&(v->counter))) __new = (n); __typeof__(*(&(v->counter))) __ret; register unsigned int __rc; switch (8) { case 4: __asm__ __volatile__ ( "0:	lr.w %0, %2\n" "	bne  %0, %z3, 1f\n" "	sc.w %1, %z4, %2\n" "	bnez %1, 0b\n" "\tfence r , rw\n" "1:\n" : "=&r" (__ret), "=&r" (__rc), "+A" (*__ptr) : "rJ" ((long)__old), "rJ" (__new) : "memory"); break; case 8: __asm__ __volatile__ ( "0:	lr.d %0, %2\n" "	bne %0, %z3, 1f\n" "	sc.d %1, %z4, %2\n" "	bnez %1, 0b\n" "\tfence r , rw\n" "1:\n" : "=&r" (__ret), "=&r" (__rc), "+A" (*__ptr) : "rJ" (__old), "rJ" (__new) : "memory"); break; default: do { __attribute__((__noreturn__)) extern void __compiletime_assert_18(void) ; if (!(!(1))) __compiletime_assert_18(); } while (0); } __ret; }); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64 arch_atomic64_cmpxchg_release(atomic64_t *v, s64 o, s64 n) { return ({ __typeof__(&(v->counter)) __ptr = (&(v->counter)); __typeof__(*(&(v->counter))) __old = (o); __typeof__(*(&(v->counter))) __new = (n); __typeof__(*(&(v->counter))) __ret; register unsigned int __rc; switch (8) { case 4: __asm__ __volatile__ ( "\tfence rw,  w\n" "0:	lr.w %0, %2\n" "	bne  %0, %z3, 1f\n" "	sc.w %1, %z4, %2\n" "	bnez %1, 0b\n" "1:\n" : "=&r" (__ret), "=&r" (__rc), "+A" (*__ptr) : "rJ" ((long)__old), "rJ" (__new) : "memory"); break; case 8: __asm__ __volatile__ ( "\tfence rw,  w\n" "0:	lr.d %0, %2\n" "	bne %0, %z3, 1f\n" "	sc.d %1, %z4, %2\n" "	bnez %1, 0b\n" "1:\n" : "=&r" (__ret), "=&r" (__rc), "+A" (*__ptr) : "rJ" (__old), "rJ" (__new) : "memory"); break; default: do { __attribute__((__noreturn__)) extern void __compiletime_assert_19(void) ; if (!(!(1))) __compiletime_assert_19(); } while (0); } __ret; }); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64 arch_atomic64_cmpxchg(atomic64_t *v, s64 o, s64 n) { return ({ __typeof__(&(v->counter)) __ptr = (&(v->counter)); __typeof__(*(&(v->counter))) __old = (o); __typeof__(*(&(v->counter))) __new = (n); __typeof__(*(&(v->counter))) __ret; register unsigned int __rc; switch (8) { case 4: __asm__ __volatile__ ( "0:	lr.w %0, %2\n" "	bne  %0, %z3, 1f\n" "	sc.w.rl %1, %z4, %2\n" "	bnez %1, 0b\n" "	fence rw, rw\n" "1:\n" : "=&r" (__ret), "=&r" (__rc), "+A" (*__ptr) : "rJ" ((long)__old), "rJ" (__new) : "memory"); break; case 8: __asm__ __volatile__ ( "0:	lr.d %0, %2\n" "	bne %0, %z3, 1f\n" "	sc.d.rl %1, %z4, %2\n" "	bnez %1, 0b\n" "	fence rw, rw\n" "1:\n" : "=&r" (__ret), "=&r" (__rc), "+A" (*__ptr) : "rJ" (__old), "rJ" (__new) : "memory"); break; default: do { __attribute__((__noreturn__)) extern void __compiletime_assert_20(void) ; if (!(!(1))) __compiletime_assert_20(); } while (0); } __ret; }); }\r
# 313 "./arch/riscv/include/asm/atomic.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int arch_atomic_sub_if_positive(atomic_t *v, int offset)\r
{\r
       int prev, rc;\r
\r
 __asm__ __volatile__ (\r
  "0:	lr.w     %[p],  %[c]\n"\r
  "	sub      %[rc], %[p], %[o]\n"\r
  "	bltz     %[rc], 1f\n"\r
  "	sc.w.rl  %[rc], %[rc], %[c]\n"\r
  "	bnez     %[rc], 0b\n"\r
  "	fence    rw, rw\n"\r
  "1:\n"\r
  : [p]"=&r" (prev), [rc]"=&r" (rc), [c]"+A" (v->counter)\r
  : [o]"r" (offset)\r
  : "memory");\r
 return prev - offset;\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64 arch_atomic64_sub_if_positive(atomic64_t *v, s64 offset)\r
{\r
       s64 prev;\r
       long rc;\r
\r
 __asm__ __volatile__ (\r
  "0:	lr.d     %[p],  %[c]\n"\r
  "	sub      %[rc], %[p], %[o]\n"\r
  "	bltz     %[rc], 1f\n"\r
  "	sc.d.rl  %[rc], %[rc], %[c]\n"\r
  "	bnez     %[rc], 0b\n"\r
  "	fence    rw, rw\n"\r
  "1:\n"\r
  : [p]"=&r" (prev), [rc]"=&r" (rc), [c]"+A" (v->counter)\r
  : [o]"r" (offset)\r
  : "memory");\r
 return prev - offset;\r
}\r
# 8 "./include/linux/atomic.h" 2\r
# 80 "./include/linux/atomic.h"\r
# 1 "./include/linux/atomic/atomic-arch-fallback.h" 1\r
# 151 "./include/linux/atomic/atomic-arch-fallback.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
arch_atomic_read_acquire(const atomic_t *v)\r
{\r
 int ret;\r
\r
 if ((sizeof(atomic_t) == sizeof(char) || sizeof(atomic_t) == sizeof(short) || sizeof(atomic_t) == sizeof(int) || sizeof(atomic_t) == sizeof(long))) {\r
  ret = ({ typeof(*&(v)->counter) ___p1 = ({ do { __attribute__((__noreturn__)) extern void __compiletime_assert_21(void) ; if (!((sizeof(*&(v)->counter) == sizeof(char) || sizeof(*&(v)->counter) == sizeof(short) || sizeof(*&(v)->counter) == sizeof(int) || sizeof(*&(v)->counter) == sizeof(long)) || sizeof(*&(v)->counter) == sizeof(long long))) __compiletime_assert_21(); } while (0); (*(const volatile typeof( _Generic((*&(v)->counter), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (*&(v)->counter))) *)&(*&(v)->counter)); }); do { __attribute__((__noreturn__)) extern void __compiletime_assert_22(void) ; if (!((sizeof(*&(v)->counter) == sizeof(char) || sizeof(*&(v)->counter) == sizeof(short) || sizeof(*&(v)->counter) == sizeof(int) || sizeof(*&(v)->counter) == sizeof(long)))) __compiletime_assert_22(); } while (0); __asm__ __volatile__ ("fence " "r" "," "rw" : : : "memory"); ___p1; });\r
 } else {\r
  ret = arch_atomic_read(v);\r
  __asm__ __volatile__("\tfence r , rw\n" "" ::: "memory");\r
 }\r
\r
 return ret;\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
arch_atomic_set_release(atomic_t *v, int i)\r
{\r
 if ((sizeof(atomic_t) == sizeof(char) || sizeof(atomic_t) == sizeof(short) || sizeof(atomic_t) == sizeof(int) || sizeof(atomic_t) == sizeof(long))) {\r
  do { do { } while (0); do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_23(void) ; if (!((sizeof(*&(v)->counter) == sizeof(char) || sizeof(*&(v)->counter) == sizeof(short) || sizeof(*&(v)->counter) == sizeof(int) || sizeof(*&(v)->counter) == sizeof(long)))) __compiletime_assert_23(); } while (0); __asm__ __volatile__ ("fence " "rw" "," "w" : : : "memory"); do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_24(void) ; if (!((sizeof(*&(v)->counter) == sizeof(char) || sizeof(*&(v)->counter) == sizeof(short) || sizeof(*&(v)->counter) == sizeof(int) || sizeof(*&(v)->counter) == sizeof(long)) || sizeof(*&(v)->counter) == sizeof(long long))) __compiletime_assert_24(); } while (0); do { *(volatile typeof(*&(v)->counter) *)&(*&(v)->counter) = (i); } while (0); } while (0); } while (0); } while (0);\r
 } else {\r
  __asm__ __volatile__("\tfence rw,  w\n" "" ::: "memory");;\r
  arch_atomic_set(v, i);\r
 }\r
}\r
# 189 "./include/linux/atomic/atomic-arch-fallback.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
arch_atomic_add_return_acquire(int i, atomic_t *v)\r
{\r
 int ret = arch_atomic_add_return_relaxed(i, v);\r
 __asm__ __volatile__("\tfence r , rw\n" "" ::: "memory");\r
 return ret;\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
arch_atomic_add_return_release(int i, atomic_t *v)\r
{\r
 __asm__ __volatile__("\tfence rw,  w\n" "" ::: "memory");;\r
 return arch_atomic_add_return_relaxed(i, v);\r
}\r
# 231 "./include/linux/atomic/atomic-arch-fallback.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
arch_atomic_fetch_add_acquire(int i, atomic_t *v)\r
{\r
 int ret = arch_atomic_fetch_add_relaxed(i, v);\r
 __asm__ __volatile__("\tfence r , rw\n" "" ::: "memory");\r
 return ret;\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
arch_atomic_fetch_add_release(int i, atomic_t *v)\r
{\r
 __asm__ __volatile__("\tfence rw,  w\n" "" ::: "memory");;\r
 return arch_atomic_fetch_add_relaxed(i, v);\r
}\r
# 273 "./include/linux/atomic/atomic-arch-fallback.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
arch_atomic_sub_return_acquire(int i, atomic_t *v)\r
{\r
 int ret = arch_atomic_sub_return_relaxed(i, v);\r
 __asm__ __volatile__("\tfence r , rw\n" "" ::: "memory");\r
 return ret;\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
arch_atomic_sub_return_release(int i, atomic_t *v)\r
{\r
 __asm__ __volatile__("\tfence rw,  w\n" "" ::: "memory");;\r
 return arch_atomic_sub_return_relaxed(i, v);\r
}\r
# 315 "./include/linux/atomic/atomic-arch-fallback.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
arch_atomic_fetch_sub_acquire(int i, atomic_t *v)\r
{\r
 int ret = arch_atomic_fetch_sub_relaxed(i, v);\r
 __asm__ __volatile__("\tfence r , rw\n" "" ::: "memory");\r
 return ret;\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
arch_atomic_fetch_sub_release(int i, atomic_t *v)\r
{\r
 __asm__ __volatile__("\tfence rw,  w\n" "" ::: "memory");;\r
 return arch_atomic_fetch_sub_relaxed(i, v);\r
}\r
# 351 "./include/linux/atomic/atomic-arch-fallback.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
arch_atomic_inc(atomic_t *v)\r
{\r
 arch_atomic_add(1, v);\r
}\r
# 367 "./include/linux/atomic/atomic-arch-fallback.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
arch_atomic_inc_return(atomic_t *v)\r
{\r
 return arch_atomic_add_return(1, v);\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
arch_atomic_inc_return_acquire(atomic_t *v)\r
{\r
 return arch_atomic_add_return_acquire(1, v);\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
arch_atomic_inc_return_release(atomic_t *v)\r
{\r
 return arch_atomic_add_return_release(1, v);\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
arch_atomic_inc_return_relaxed(atomic_t *v)\r
{\r
 return arch_atomic_add_return_relaxed(1, v);\r
}\r
# 448 "./include/linux/atomic/atomic-arch-fallback.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
arch_atomic_fetch_inc(atomic_t *v)\r
{\r
 return arch_atomic_fetch_add(1, v);\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
arch_atomic_fetch_inc_acquire(atomic_t *v)\r
{\r
 return arch_atomic_fetch_add_acquire(1, v);\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
arch_atomic_fetch_inc_release(atomic_t *v)\r
{\r
 return arch_atomic_fetch_add_release(1, v);\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
arch_atomic_fetch_inc_relaxed(atomic_t *v)\r
{\r
 return arch_atomic_fetch_add_relaxed(1, v);\r
}\r
# 522 "./include/linux/atomic/atomic-arch-fallback.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
arch_atomic_dec(atomic_t *v)\r
{\r
 arch_atomic_sub(1, v);\r
}\r
# 538 "./include/linux/atomic/atomic-arch-fallback.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
arch_atomic_dec_return(atomic_t *v)\r
{\r
 return arch_atomic_sub_return(1, v);\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
arch_atomic_dec_return_acquire(atomic_t *v)\r
{\r
 return arch_atomic_sub_return_acquire(1, v);\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
arch_atomic_dec_return_release(atomic_t *v)\r
{\r
 return arch_atomic_sub_return_release(1, v);\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
arch_atomic_dec_return_relaxed(atomic_t *v)\r
{\r
 return arch_atomic_sub_return_relaxed(1, v);\r
}\r
# 619 "./include/linux/atomic/atomic-arch-fallback.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
arch_atomic_fetch_dec(atomic_t *v)\r
{\r
 return arch_atomic_fetch_sub(1, v);\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
arch_atomic_fetch_dec_acquire(atomic_t *v)\r
{\r
 return arch_atomic_fetch_sub_acquire(1, v);\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
arch_atomic_fetch_dec_release(atomic_t *v)\r
{\r
 return arch_atomic_fetch_sub_release(1, v);\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
arch_atomic_fetch_dec_relaxed(atomic_t *v)\r
{\r
 return arch_atomic_fetch_sub_relaxed(1, v);\r
}\r
# 699 "./include/linux/atomic/atomic-arch-fallback.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
arch_atomic_fetch_and_acquire(int i, atomic_t *v)\r
{\r
 int ret = arch_atomic_fetch_and_relaxed(i, v);\r
 __asm__ __volatile__("\tfence r , rw\n" "" ::: "memory");\r
 return ret;\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
arch_atomic_fetch_and_release(int i, atomic_t *v)\r
{\r
 __asm__ __volatile__("\tfence rw,  w\n" "" ::: "memory");;\r
 return arch_atomic_fetch_and_relaxed(i, v);\r
}\r
# 735 "./include/linux/atomic/atomic-arch-fallback.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
arch_atomic_andnot(int i, atomic_t *v)\r
{\r
 arch_atomic_and(~i, v);\r
}\r
# 751 "./include/linux/atomic/atomic-arch-fallback.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
arch_atomic_fetch_andnot(int i, atomic_t *v)\r
{\r
 return arch_atomic_fetch_and(~i, v);\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
arch_atomic_fetch_andnot_acquire(int i, atomic_t *v)\r
{\r
 return arch_atomic_fetch_and_acquire(~i, v);\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
arch_atomic_fetch_andnot_release(int i, atomic_t *v)\r
{\r
 return arch_atomic_fetch_and_release(~i, v);\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
arch_atomic_fetch_andnot_relaxed(int i, atomic_t *v)\r
{\r
 return arch_atomic_fetch_and_relaxed(~i, v);\r
}\r
# 831 "./include/linux/atomic/atomic-arch-fallback.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
arch_atomic_fetch_or_acquire(int i, atomic_t *v)\r
{\r
 int ret = arch_atomic_fetch_or_relaxed(i, v);\r
 __asm__ __volatile__("\tfence r , rw\n" "" ::: "memory");\r
 return ret;\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
arch_atomic_fetch_or_release(int i, atomic_t *v)\r
{\r
 __asm__ __volatile__("\tfence rw,  w\n" "" ::: "memory");;\r
 return arch_atomic_fetch_or_relaxed(i, v);\r
}\r
# 873 "./include/linux/atomic/atomic-arch-fallback.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
arch_atomic_fetch_xor_acquire(int i, atomic_t *v)\r
{\r
 int ret = arch_atomic_fetch_xor_relaxed(i, v);\r
 __asm__ __volatile__("\tfence r , rw\n" "" ::: "memory");\r
 return ret;\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
arch_atomic_fetch_xor_release(int i, atomic_t *v)\r
{\r
 __asm__ __volatile__("\tfence rw,  w\n" "" ::: "memory");;\r
 return arch_atomic_fetch_xor_relaxed(i, v);\r
}\r
# 1000 "./include/linux/atomic/atomic-arch-fallback.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
arch_atomic_try_cmpxchg(atomic_t *v, int *old, int new)\r
{\r
 int r, o = *old;\r
 r = arch_atomic_cmpxchg(v, o, new);\r
 if (__builtin_expect(!!(r != o), 0))\r
  *old = r;\r
 return __builtin_expect(!!(r == o), 1);\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
arch_atomic_try_cmpxchg_acquire(atomic_t *v, int *old, int new)\r
{\r
 int r, o = *old;\r
 r = arch_atomic_cmpxchg_acquire(v, o, new);\r
 if (__builtin_expect(!!(r != o), 0))\r
  *old = r;\r
 return __builtin_expect(!!(r == o), 1);\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
arch_atomic_try_cmpxchg_release(atomic_t *v, int *old, int new)\r
{\r
 int r, o = *old;\r
 r = arch_atomic_cmpxchg_release(v, o, new);\r
 if (__builtin_expect(!!(r != o), 0))\r
  *old = r;\r
 return __builtin_expect(!!(r == o), 1);\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
arch_atomic_try_cmpxchg_relaxed(atomic_t *v, int *old, int new)\r
{\r
 int r, o = *old;\r
 r = arch_atomic_cmpxchg_relaxed(v, o, new);\r
 if (__builtin_expect(!!(r != o), 0))\r
  *old = r;\r
 return __builtin_expect(!!(r == o), 1);\r
}\r
# 1099 "./include/linux/atomic/atomic-arch-fallback.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
arch_atomic_sub_and_test(int i, atomic_t *v)\r
{\r
 return arch_atomic_sub_return(i, v) == 0;\r
}\r
# 1116 "./include/linux/atomic/atomic-arch-fallback.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
arch_atomic_dec_and_test(atomic_t *v)\r
{\r
 return arch_atomic_dec_return(v) == 0;\r
}\r
# 1133 "./include/linux/atomic/atomic-arch-fallback.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
arch_atomic_inc_and_test(atomic_t *v)\r
{\r
 return arch_atomic_inc_return(v) == 0;\r
}\r
# 1151 "./include/linux/atomic/atomic-arch-fallback.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
arch_atomic_add_negative(int i, atomic_t *v)\r
{\r
 return arch_atomic_add_return(i, v) < 0;\r
}\r
# 1194 "./include/linux/atomic/atomic-arch-fallback.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
arch_atomic_add_unless(atomic_t *v, int a, int u)\r
{\r
 return arch_atomic_fetch_add_unless(v, a, u) != u;\r
}\r
# 1210 "./include/linux/atomic/atomic-arch-fallback.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
arch_atomic_inc_not_zero(atomic_t *v)\r
{\r
 return arch_atomic_add_unless(v, 1, 0);\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
arch_atomic_inc_unless_negative(atomic_t *v)\r
{\r
 int c = arch_atomic_read(v);\r
\r
 do {\r
  if (__builtin_expect(!!(c < 0), 0))\r
   return false;\r
 } while (!arch_atomic_try_cmpxchg(v, &c, c + 1));\r
\r
 return true;\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
arch_atomic_dec_unless_positive(atomic_t *v)\r
{\r
 int c = arch_atomic_read(v);\r
\r
 do {\r
  if (__builtin_expect(!!(c > 0), 0))\r
   return false;\r
 } while (!arch_atomic_try_cmpxchg(v, &c, c - 1));\r
\r
 return true;\r
}\r
# 1272 "./include/linux/atomic/atomic-arch-fallback.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
arch_atomic64_read_acquire(const atomic64_t *v)\r
{\r
 s64 ret;\r
\r
 if ((sizeof(atomic64_t) == sizeof(char) || sizeof(atomic64_t) == sizeof(short) || sizeof(atomic64_t) == sizeof(int) || sizeof(atomic64_t) == sizeof(long))) {\r
  ret = ({ typeof(*&(v)->counter) ___p1 = ({ do { __attribute__((__noreturn__)) extern void __compiletime_assert_25(void) ; if (!((sizeof(*&(v)->counter) == sizeof(char) || sizeof(*&(v)->counter) == sizeof(short) || sizeof(*&(v)->counter) == sizeof(int) || sizeof(*&(v)->counter) == sizeof(long)) || sizeof(*&(v)->counter) == sizeof(long long))) __compiletime_assert_25(); } while (0); (*(const volatile typeof( _Generic((*&(v)->counter), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (*&(v)->counter))) *)&(*&(v)->counter)); }); do { __attribute__((__noreturn__)) extern void __compiletime_assert_26(void) ; if (!((sizeof(*&(v)->counter) == sizeof(char) || sizeof(*&(v)->counter) == sizeof(short) || sizeof(*&(v)->counter) == sizeof(int) || sizeof(*&(v)->counter) == sizeof(long)))) __compiletime_assert_26(); } while (0); __asm__ __volatile__ ("fence " "r" "," "rw" : : : "memory"); ___p1; });\r
 } else {\r
  ret = arch_atomic64_read(v);\r
  __asm__ __volatile__("\tfence r , rw\n" "" ::: "memory");\r
 }\r
\r
 return ret;\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
arch_atomic64_set_release(atomic64_t *v, s64 i)\r
{\r
 if ((sizeof(atomic64_t) == sizeof(char) || sizeof(atomic64_t) == sizeof(short) || sizeof(atomic64_t) == sizeof(int) || sizeof(atomic64_t) == sizeof(long))) {\r
  do { do { } while (0); do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_27(void) ; if (!((sizeof(*&(v)->counter) == sizeof(char) || sizeof(*&(v)->counter) == sizeof(short) || sizeof(*&(v)->counter) == sizeof(int) || sizeof(*&(v)->counter) == sizeof(long)))) __compiletime_assert_27(); } while (0); __asm__ __volatile__ ("fence " "rw" "," "w" : : : "memory"); do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_28(void) ; if (!((sizeof(*&(v)->counter) == sizeof(char) || sizeof(*&(v)->counter) == sizeof(short) || sizeof(*&(v)->counter) == sizeof(int) || sizeof(*&(v)->counter) == sizeof(long)) || sizeof(*&(v)->counter) == sizeof(long long))) __compiletime_assert_28(); } while (0); do { *(volatile typeof(*&(v)->counter) *)&(*&(v)->counter) = (i); } while (0); } while (0); } while (0); } while (0);\r
 } else {\r
  __asm__ __volatile__("\tfence rw,  w\n" "" ::: "memory");;\r
  arch_atomic64_set(v, i);\r
 }\r
}\r
# 1310 "./include/linux/atomic/atomic-arch-fallback.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
arch_atomic64_add_return_acquire(s64 i, atomic64_t *v)\r
{\r
 s64 ret = arch_atomic64_add_return_relaxed(i, v);\r
 __asm__ __volatile__("\tfence r , rw\n" "" ::: "memory");\r
 return ret;\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
arch_atomic64_add_return_release(s64 i, atomic64_t *v)\r
{\r
 __asm__ __volatile__("\tfence rw,  w\n" "" ::: "memory");;\r
 return arch_atomic64_add_return_relaxed(i, v);\r
}\r
# 1352 "./include/linux/atomic/atomic-arch-fallback.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
arch_atomic64_fetch_add_acquire(s64 i, atomic64_t *v)\r
{\r
 s64 ret = arch_atomic64_fetch_add_relaxed(i, v);\r
 __asm__ __volatile__("\tfence r , rw\n" "" ::: "memory");\r
 return ret;\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
arch_atomic64_fetch_add_release(s64 i, atomic64_t *v)\r
{\r
 __asm__ __volatile__("\tfence rw,  w\n" "" ::: "memory");;\r
 return arch_atomic64_fetch_add_relaxed(i, v);\r
}\r
# 1394 "./include/linux/atomic/atomic-arch-fallback.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
arch_atomic64_sub_return_acquire(s64 i, atomic64_t *v)\r
{\r
 s64 ret = arch_atomic64_sub_return_relaxed(i, v);\r
 __asm__ __volatile__("\tfence r , rw\n" "" ::: "memory");\r
 return ret;\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
arch_atomic64_sub_return_release(s64 i, atomic64_t *v)\r
{\r
 __asm__ __volatile__("\tfence rw,  w\n" "" ::: "memory");;\r
 return arch_atomic64_sub_return_relaxed(i, v);\r
}\r
# 1436 "./include/linux/atomic/atomic-arch-fallback.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
arch_atomic64_fetch_sub_acquire(s64 i, atomic64_t *v)\r
{\r
 s64 ret = arch_atomic64_fetch_sub_relaxed(i, v);\r
 __asm__ __volatile__("\tfence r , rw\n" "" ::: "memory");\r
 return ret;\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
arch_atomic64_fetch_sub_release(s64 i, atomic64_t *v)\r
{\r
 __asm__ __volatile__("\tfence rw,  w\n" "" ::: "memory");;\r
 return arch_atomic64_fetch_sub_relaxed(i, v);\r
}\r
# 1472 "./include/linux/atomic/atomic-arch-fallback.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
arch_atomic64_inc(atomic64_t *v)\r
{\r
 arch_atomic64_add(1, v);\r
}\r
# 1488 "./include/linux/atomic/atomic-arch-fallback.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
arch_atomic64_inc_return(atomic64_t *v)\r
{\r
 return arch_atomic64_add_return(1, v);\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
arch_atomic64_inc_return_acquire(atomic64_t *v)\r
{\r
 return arch_atomic64_add_return_acquire(1, v);\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
arch_atomic64_inc_return_release(atomic64_t *v)\r
{\r
 return arch_atomic64_add_return_release(1, v);\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
arch_atomic64_inc_return_relaxed(atomic64_t *v)\r
{\r
 return arch_atomic64_add_return_relaxed(1, v);\r
}\r
# 1569 "./include/linux/atomic/atomic-arch-fallback.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
arch_atomic64_fetch_inc(atomic64_t *v)\r
{\r
 return arch_atomic64_fetch_add(1, v);\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
arch_atomic64_fetch_inc_acquire(atomic64_t *v)\r
{\r
 return arch_atomic64_fetch_add_acquire(1, v);\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
arch_atomic64_fetch_inc_release(atomic64_t *v)\r
{\r
 return arch_atomic64_fetch_add_release(1, v);\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
arch_atomic64_fetch_inc_relaxed(atomic64_t *v)\r
{\r
 return arch_atomic64_fetch_add_relaxed(1, v);\r
}\r
# 1643 "./include/linux/atomic/atomic-arch-fallback.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
arch_atomic64_dec(atomic64_t *v)\r
{\r
 arch_atomic64_sub(1, v);\r
}\r
# 1659 "./include/linux/atomic/atomic-arch-fallback.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
arch_atomic64_dec_return(atomic64_t *v)\r
{\r
 return arch_atomic64_sub_return(1, v);\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
arch_atomic64_dec_return_acquire(atomic64_t *v)\r
{\r
 return arch_atomic64_sub_return_acquire(1, v);\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
arch_atomic64_dec_return_release(atomic64_t *v)\r
{\r
 return arch_atomic64_sub_return_release(1, v);\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
arch_atomic64_dec_return_relaxed(atomic64_t *v)\r
{\r
 return arch_atomic64_sub_return_relaxed(1, v);\r
}\r
# 1740 "./include/linux/atomic/atomic-arch-fallback.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
arch_atomic64_fetch_dec(atomic64_t *v)\r
{\r
 return arch_atomic64_fetch_sub(1, v);\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
arch_atomic64_fetch_dec_acquire(atomic64_t *v)\r
{\r
 return arch_atomic64_fetch_sub_acquire(1, v);\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
arch_atomic64_fetch_dec_release(atomic64_t *v)\r
{\r
 return arch_atomic64_fetch_sub_release(1, v);\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
arch_atomic64_fetch_dec_relaxed(atomic64_t *v)\r
{\r
 return arch_atomic64_fetch_sub_relaxed(1, v);\r
}\r
# 1820 "./include/linux/atomic/atomic-arch-fallback.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
arch_atomic64_fetch_and_acquire(s64 i, atomic64_t *v)\r
{\r
 s64 ret = arch_atomic64_fetch_and_relaxed(i, v);\r
 __asm__ __volatile__("\tfence r , rw\n" "" ::: "memory");\r
 return ret;\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
arch_atomic64_fetch_and_release(s64 i, atomic64_t *v)\r
{\r
 __asm__ __volatile__("\tfence rw,  w\n" "" ::: "memory");;\r
 return arch_atomic64_fetch_and_relaxed(i, v);\r
}\r
# 1856 "./include/linux/atomic/atomic-arch-fallback.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
arch_atomic64_andnot(s64 i, atomic64_t *v)\r
{\r
 arch_atomic64_and(~i, v);\r
}\r
# 1872 "./include/linux/atomic/atomic-arch-fallback.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
arch_atomic64_fetch_andnot(s64 i, atomic64_t *v)\r
{\r
 return arch_atomic64_fetch_and(~i, v);\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
arch_atomic64_fetch_andnot_acquire(s64 i, atomic64_t *v)\r
{\r
 return arch_atomic64_fetch_and_acquire(~i, v);\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
arch_atomic64_fetch_andnot_release(s64 i, atomic64_t *v)\r
{\r
 return arch_atomic64_fetch_and_release(~i, v);\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
arch_atomic64_fetch_andnot_relaxed(s64 i, atomic64_t *v)\r
{\r
 return arch_atomic64_fetch_and_relaxed(~i, v);\r
}\r
# 1952 "./include/linux/atomic/atomic-arch-fallback.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
arch_atomic64_fetch_or_acquire(s64 i, atomic64_t *v)\r
{\r
 s64 ret = arch_atomic64_fetch_or_relaxed(i, v);\r
 __asm__ __volatile__("\tfence r , rw\n" "" ::: "memory");\r
 return ret;\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
arch_atomic64_fetch_or_release(s64 i, atomic64_t *v)\r
{\r
 __asm__ __volatile__("\tfence rw,  w\n" "" ::: "memory");;\r
 return arch_atomic64_fetch_or_relaxed(i, v);\r
}\r
# 1994 "./include/linux/atomic/atomic-arch-fallback.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
arch_atomic64_fetch_xor_acquire(s64 i, atomic64_t *v)\r
{\r
 s64 ret = arch_atomic64_fetch_xor_relaxed(i, v);\r
 __asm__ __volatile__("\tfence r , rw\n" "" ::: "memory");\r
 return ret;\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
arch_atomic64_fetch_xor_release(s64 i, atomic64_t *v)\r
{\r
 __asm__ __volatile__("\tfence rw,  w\n" "" ::: "memory");;\r
 return arch_atomic64_fetch_xor_relaxed(i, v);\r
}\r
# 2121 "./include/linux/atomic/atomic-arch-fallback.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
arch_atomic64_try_cmpxchg(atomic64_t *v, s64 *old, s64 new)\r
{\r
 s64 r, o = *old;\r
 r = arch_atomic64_cmpxchg(v, o, new);\r
 if (__builtin_expect(!!(r != o), 0))\r
  *old = r;\r
 return __builtin_expect(!!(r == o), 1);\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
arch_atomic64_try_cmpxchg_acquire(atomic64_t *v, s64 *old, s64 new)\r
{\r
 s64 r, o = *old;\r
 r = arch_atomic64_cmpxchg(v, o, new);\r
 if (__builtin_expect(!!(r != o), 0))\r
  *old = r;\r
 return __builtin_expect(!!(r == o), 1);\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
arch_atomic64_try_cmpxchg_release(atomic64_t *v, s64 *old, s64 new)\r
{\r
 s64 r, o = *old;\r
 r = arch_atomic64_cmpxchg(v, o, new);\r
 if (__builtin_expect(!!(r != o), 0))\r
  *old = r;\r
 return __builtin_expect(!!(r == o), 1);\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
arch_atomic64_try_cmpxchg_relaxed(atomic64_t *v, s64 *old, s64 new)\r
{\r
 s64 r, o = *old;\r
 r = arch_atomic64_cmpxchg(v, o, new);\r
 if (__builtin_expect(!!(r != o), 0))\r
  *old = r;\r
 return __builtin_expect(!!(r == o), 1);\r
}\r
# 2220 "./include/linux/atomic/atomic-arch-fallback.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
arch_atomic64_sub_and_test(s64 i, atomic64_t *v)\r
{\r
 return arch_atomic64_sub_return(i, v) == 0;\r
}\r
# 2237 "./include/linux/atomic/atomic-arch-fallback.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
arch_atomic64_dec_and_test(atomic64_t *v)\r
{\r
 return arch_atomic64_dec_return(v) == 0;\r
}\r
# 2254 "./include/linux/atomic/atomic-arch-fallback.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
arch_atomic64_inc_and_test(atomic64_t *v)\r
{\r
 return arch_atomic64_inc_return(v) == 0;\r
}\r
# 2272 "./include/linux/atomic/atomic-arch-fallback.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
arch_atomic64_add_negative(s64 i, atomic64_t *v)\r
{\r
 return arch_atomic64_add_return(i, v) < 0;\r
}\r
# 2315 "./include/linux/atomic/atomic-arch-fallback.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
arch_atomic64_add_unless(atomic64_t *v, s64 a, s64 u)\r
{\r
 return arch_atomic64_fetch_add_unless(v, a, u) != u;\r
}\r
# 2331 "./include/linux/atomic/atomic-arch-fallback.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
arch_atomic64_inc_not_zero(atomic64_t *v)\r
{\r
 return arch_atomic64_add_unless(v, 1, 0);\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
arch_atomic64_inc_unless_negative(atomic64_t *v)\r
{\r
 s64 c = arch_atomic64_read(v);\r
\r
 do {\r
  if (__builtin_expect(!!(c < 0), 0))\r
   return false;\r
 } while (!arch_atomic64_try_cmpxchg(v, &c, c + 1));\r
\r
 return true;\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
arch_atomic64_dec_unless_positive(atomic64_t *v)\r
{\r
 s64 c = arch_atomic64_read(v);\r
\r
 do {\r
  if (__builtin_expect(!!(c > 0), 0))\r
   return false;\r
 } while (!arch_atomic64_try_cmpxchg(v, &c, c - 1));\r
\r
 return true;\r
}\r
# 81 "./include/linux/atomic.h" 2\r
# 1 "./include/linux/atomic/atomic-long.h" 1\r
# 10 "./include/linux/atomic/atomic-long.h"\r
# 1 "./arch/riscv/include/generated/uapi/asm/types.h" 1\r
# 11 "./include/linux/atomic/atomic-long.h" 2\r
\r
\r
typedef atomic64_t atomic_long_t;\r
# 26 "./include/linux/atomic/atomic-long.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_read(const atomic_long_t *v)\r
{\r
 return arch_atomic64_read(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_read_acquire(const atomic_long_t *v)\r
{\r
 return arch_atomic64_read_acquire(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
arch_atomic_long_set(atomic_long_t *v, long i)\r
{\r
 arch_atomic64_set(v, i);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
arch_atomic_long_set_release(atomic_long_t *v, long i)\r
{\r
 arch_atomic64_set_release(v, i);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
arch_atomic_long_add(long i, atomic_long_t *v)\r
{\r
 arch_atomic64_add(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_add_return(long i, atomic_long_t *v)\r
{\r
 return arch_atomic64_add_return(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_add_return_acquire(long i, atomic_long_t *v)\r
{\r
 return arch_atomic64_add_return_acquire(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_add_return_release(long i, atomic_long_t *v)\r
{\r
 return arch_atomic64_add_return_release(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_add_return_relaxed(long i, atomic_long_t *v)\r
{\r
 return arch_atomic64_add_return_relaxed(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_fetch_add(long i, atomic_long_t *v)\r
{\r
 return arch_atomic64_fetch_add(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_fetch_add_acquire(long i, atomic_long_t *v)\r
{\r
 return arch_atomic64_fetch_add_acquire(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_fetch_add_release(long i, atomic_long_t *v)\r
{\r
 return arch_atomic64_fetch_add_release(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_fetch_add_relaxed(long i, atomic_long_t *v)\r
{\r
 return arch_atomic64_fetch_add_relaxed(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
arch_atomic_long_sub(long i, atomic_long_t *v)\r
{\r
 arch_atomic64_sub(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_sub_return(long i, atomic_long_t *v)\r
{\r
 return arch_atomic64_sub_return(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_sub_return_acquire(long i, atomic_long_t *v)\r
{\r
 return arch_atomic64_sub_return_acquire(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_sub_return_release(long i, atomic_long_t *v)\r
{\r
 return arch_atomic64_sub_return_release(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_sub_return_relaxed(long i, atomic_long_t *v)\r
{\r
 return arch_atomic64_sub_return_relaxed(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_fetch_sub(long i, atomic_long_t *v)\r
{\r
 return arch_atomic64_fetch_sub(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_fetch_sub_acquire(long i, atomic_long_t *v)\r
{\r
 return arch_atomic64_fetch_sub_acquire(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_fetch_sub_release(long i, atomic_long_t *v)\r
{\r
 return arch_atomic64_fetch_sub_release(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_fetch_sub_relaxed(long i, atomic_long_t *v)\r
{\r
 return arch_atomic64_fetch_sub_relaxed(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
arch_atomic_long_inc(atomic_long_t *v)\r
{\r
 arch_atomic64_inc(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_inc_return(atomic_long_t *v)\r
{\r
 return arch_atomic64_inc_return(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_inc_return_acquire(atomic_long_t *v)\r
{\r
 return arch_atomic64_inc_return_acquire(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_inc_return_release(atomic_long_t *v)\r
{\r
 return arch_atomic64_inc_return_release(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_inc_return_relaxed(atomic_long_t *v)\r
{\r
 return arch_atomic64_inc_return_relaxed(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_fetch_inc(atomic_long_t *v)\r
{\r
 return arch_atomic64_fetch_inc(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_fetch_inc_acquire(atomic_long_t *v)\r
{\r
 return arch_atomic64_fetch_inc_acquire(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_fetch_inc_release(atomic_long_t *v)\r
{\r
 return arch_atomic64_fetch_inc_release(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_fetch_inc_relaxed(atomic_long_t *v)\r
{\r
 return arch_atomic64_fetch_inc_relaxed(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
arch_atomic_long_dec(atomic_long_t *v)\r
{\r
 arch_atomic64_dec(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_dec_return(atomic_long_t *v)\r
{\r
 return arch_atomic64_dec_return(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_dec_return_acquire(atomic_long_t *v)\r
{\r
 return arch_atomic64_dec_return_acquire(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_dec_return_release(atomic_long_t *v)\r
{\r
 return arch_atomic64_dec_return_release(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_dec_return_relaxed(atomic_long_t *v)\r
{\r
 return arch_atomic64_dec_return_relaxed(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_fetch_dec(atomic_long_t *v)\r
{\r
 return arch_atomic64_fetch_dec(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_fetch_dec_acquire(atomic_long_t *v)\r
{\r
 return arch_atomic64_fetch_dec_acquire(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_fetch_dec_release(atomic_long_t *v)\r
{\r
 return arch_atomic64_fetch_dec_release(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_fetch_dec_relaxed(atomic_long_t *v)\r
{\r
 return arch_atomic64_fetch_dec_relaxed(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
arch_atomic_long_and(long i, atomic_long_t *v)\r
{\r
 arch_atomic64_and(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_fetch_and(long i, atomic_long_t *v)\r
{\r
 return arch_atomic64_fetch_and(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_fetch_and_acquire(long i, atomic_long_t *v)\r
{\r
 return arch_atomic64_fetch_and_acquire(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_fetch_and_release(long i, atomic_long_t *v)\r
{\r
 return arch_atomic64_fetch_and_release(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_fetch_and_relaxed(long i, atomic_long_t *v)\r
{\r
 return arch_atomic64_fetch_and_relaxed(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
arch_atomic_long_andnot(long i, atomic_long_t *v)\r
{\r
 arch_atomic64_andnot(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_fetch_andnot(long i, atomic_long_t *v)\r
{\r
 return arch_atomic64_fetch_andnot(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_fetch_andnot_acquire(long i, atomic_long_t *v)\r
{\r
 return arch_atomic64_fetch_andnot_acquire(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_fetch_andnot_release(long i, atomic_long_t *v)\r
{\r
 return arch_atomic64_fetch_andnot_release(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_fetch_andnot_relaxed(long i, atomic_long_t *v)\r
{\r
 return arch_atomic64_fetch_andnot_relaxed(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
arch_atomic_long_or(long i, atomic_long_t *v)\r
{\r
 arch_atomic64_or(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_fetch_or(long i, atomic_long_t *v)\r
{\r
 return arch_atomic64_fetch_or(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_fetch_or_acquire(long i, atomic_long_t *v)\r
{\r
 return arch_atomic64_fetch_or_acquire(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_fetch_or_release(long i, atomic_long_t *v)\r
{\r
 return arch_atomic64_fetch_or_release(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_fetch_or_relaxed(long i, atomic_long_t *v)\r
{\r
 return arch_atomic64_fetch_or_relaxed(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
arch_atomic_long_xor(long i, atomic_long_t *v)\r
{\r
 arch_atomic64_xor(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_fetch_xor(long i, atomic_long_t *v)\r
{\r
 return arch_atomic64_fetch_xor(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_fetch_xor_acquire(long i, atomic_long_t *v)\r
{\r
 return arch_atomic64_fetch_xor_acquire(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_fetch_xor_release(long i, atomic_long_t *v)\r
{\r
 return arch_atomic64_fetch_xor_release(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_fetch_xor_relaxed(long i, atomic_long_t *v)\r
{\r
 return arch_atomic64_fetch_xor_relaxed(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_xchg(atomic_long_t *v, long i)\r
{\r
 return arch_atomic64_xchg(v, i);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_xchg_acquire(atomic_long_t *v, long i)\r
{\r
 return arch_atomic64_xchg(v, i);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_xchg_release(atomic_long_t *v, long i)\r
{\r
 return arch_atomic64_xchg(v, i);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_xchg_relaxed(atomic_long_t *v, long i)\r
{\r
 return arch_atomic64_xchg(v, i);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_cmpxchg(atomic_long_t *v, long old, long new)\r
{\r
 return arch_atomic64_cmpxchg(v, old, new);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_cmpxchg_acquire(atomic_long_t *v, long old, long new)\r
{\r
 return arch_atomic64_cmpxchg(v, old, new);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_cmpxchg_release(atomic_long_t *v, long old, long new)\r
{\r
 return arch_atomic64_cmpxchg(v, old, new);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_cmpxchg_relaxed(atomic_long_t *v, long old, long new)\r
{\r
 return arch_atomic64_cmpxchg(v, old, new);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
arch_atomic_long_try_cmpxchg(atomic_long_t *v, long *old, long new)\r
{\r
 return arch_atomic64_try_cmpxchg(v, (s64 *)old, new);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
arch_atomic_long_try_cmpxchg_acquire(atomic_long_t *v, long *old, long new)\r
{\r
 return arch_atomic64_try_cmpxchg_acquire(v, (s64 *)old, new);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
arch_atomic_long_try_cmpxchg_release(atomic_long_t *v, long *old, long new)\r
{\r
 return arch_atomic64_try_cmpxchg_release(v, (s64 *)old, new);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
arch_atomic_long_try_cmpxchg_relaxed(atomic_long_t *v, long *old, long new)\r
{\r
 return arch_atomic64_try_cmpxchg_relaxed(v, (s64 *)old, new);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
arch_atomic_long_sub_and_test(long i, atomic_long_t *v)\r
{\r
 return arch_atomic64_sub_and_test(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
arch_atomic_long_dec_and_test(atomic_long_t *v)\r
{\r
 return arch_atomic64_dec_and_test(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
arch_atomic_long_inc_and_test(atomic_long_t *v)\r
{\r
 return arch_atomic64_inc_and_test(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
arch_atomic_long_add_negative(long i, atomic_long_t *v)\r
{\r
 return arch_atomic64_add_negative(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_fetch_add_unless(atomic_long_t *v, long a, long u)\r
{\r
 return arch_atomic64_fetch_add_unless(v, a, u);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
arch_atomic_long_add_unless(atomic_long_t *v, long a, long u)\r
{\r
 return arch_atomic64_add_unless(v, a, u);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
arch_atomic_long_inc_not_zero(atomic_long_t *v)\r
{\r
 return arch_atomic64_inc_not_zero(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
arch_atomic_long_inc_unless_negative(atomic_long_t *v)\r
{\r
 return arch_atomic64_inc_unless_negative(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
arch_atomic_long_dec_unless_positive(atomic_long_t *v)\r
{\r
 return arch_atomic64_dec_unless_positive(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
arch_atomic_long_dec_if_positive(atomic_long_t *v)\r
{\r
 return arch_atomic64_sub_if_positive(v, 1);\r
}\r
# 82 "./include/linux/atomic.h" 2\r
# 1 "./include/linux/atomic/atomic-instrumented.h" 1\r
# 22 "./include/linux/atomic/atomic-instrumented.h"\r
# 1 "./include/linux/instrumented.h" 1\r
# 24 "./include/linux/instrumented.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void instrument_read(const volatile void *v, size_t size)\r
{\r
 kasan_check_read(v, size);\r
 kcsan_check_access(v, size, 0);\r
}\r
# 39 "./include/linux/instrumented.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void instrument_write(const volatile void *v, size_t size)\r
{\r
 kasan_check_write(v, size);\r
 kcsan_check_access(v, size, (1 << 0));\r
}\r
# 54 "./include/linux/instrumented.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void instrument_read_write(const volatile void *v, size_t size)\r
{\r
 kasan_check_write(v, size);\r
 kcsan_check_access(v, size, (1 << 1) | (1 << 0));\r
}\r
# 69 "./include/linux/instrumented.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void instrument_atomic_read(const volatile void *v, size_t size)\r
{\r
 kasan_check_read(v, size);\r
 kcsan_check_access(v, size, (1 << 2));\r
}\r
# 84 "./include/linux/instrumented.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void instrument_atomic_write(const volatile void *v, size_t size)\r
{\r
 kasan_check_write(v, size);\r
 kcsan_check_access(v, size, (1 << 2) | (1 << 0));\r
}\r
# 99 "./include/linux/instrumented.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void instrument_atomic_read_write(const volatile void *v, size_t size)\r
{\r
 kasan_check_write(v, size);\r
 kcsan_check_access(v, size, (1 << 2) | (1 << 0) | (1 << 1));\r
}\r
# 115 "./include/linux/instrumented.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
instrument_copy_to_user(void *to, const void *from, unsigned long n)\r
{\r
 kasan_check_read(from, n);\r
 kcsan_check_access(from, n, 0);\r
}\r
# 132 "./include/linux/instrumented.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
instrument_copy_from_user(const void *to, const void *from, unsigned long n)\r
{\r
 kasan_check_write(to, n);\r
 kcsan_check_access(to, n, (1 << 0));\r
}\r
# 23 "./include/linux/atomic/atomic-instrumented.h" 2\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_read(const atomic_t *v)\r
{\r
 instrument_atomic_read(v, sizeof(*v));\r
 return arch_atomic_read(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_read_acquire(const atomic_t *v)\r
{\r
 instrument_atomic_read(v, sizeof(*v));\r
 return arch_atomic_read_acquire(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
atomic_set(atomic_t *v, int i)\r
{\r
 instrument_atomic_write(v, sizeof(*v));\r
 arch_atomic_set(v, i);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
atomic_set_release(atomic_t *v, int i)\r
{\r
 do { } while (0);\r
 instrument_atomic_write(v, sizeof(*v));\r
 arch_atomic_set_release(v, i);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
atomic_add(int i, atomic_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 arch_atomic_add(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_add_return(int i, atomic_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_add_return(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_add_return_acquire(int i, atomic_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_add_return_acquire(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_add_return_release(int i, atomic_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_add_return_release(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_add_return_relaxed(int i, atomic_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_add_return_relaxed(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_fetch_add(int i, atomic_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_fetch_add(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_fetch_add_acquire(int i, atomic_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_fetch_add_acquire(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_fetch_add_release(int i, atomic_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_fetch_add_release(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_fetch_add_relaxed(int i, atomic_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_fetch_add_relaxed(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
atomic_sub(int i, atomic_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 arch_atomic_sub(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_sub_return(int i, atomic_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_sub_return(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_sub_return_acquire(int i, atomic_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_sub_return_acquire(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_sub_return_release(int i, atomic_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_sub_return_release(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_sub_return_relaxed(int i, atomic_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_sub_return_relaxed(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_fetch_sub(int i, atomic_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_fetch_sub(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_fetch_sub_acquire(int i, atomic_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_fetch_sub_acquire(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_fetch_sub_release(int i, atomic_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_fetch_sub_release(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_fetch_sub_relaxed(int i, atomic_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_fetch_sub_relaxed(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
atomic_inc(atomic_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 arch_atomic_inc(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_inc_return(atomic_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_inc_return(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_inc_return_acquire(atomic_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_inc_return_acquire(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_inc_return_release(atomic_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_inc_return_release(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_inc_return_relaxed(atomic_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_inc_return_relaxed(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_fetch_inc(atomic_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_fetch_inc(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_fetch_inc_acquire(atomic_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_fetch_inc_acquire(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_fetch_inc_release(atomic_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_fetch_inc_release(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_fetch_inc_relaxed(atomic_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_fetch_inc_relaxed(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
atomic_dec(atomic_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 arch_atomic_dec(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_dec_return(atomic_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_dec_return(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_dec_return_acquire(atomic_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_dec_return_acquire(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_dec_return_release(atomic_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_dec_return_release(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_dec_return_relaxed(atomic_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_dec_return_relaxed(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_fetch_dec(atomic_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_fetch_dec(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_fetch_dec_acquire(atomic_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_fetch_dec_acquire(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_fetch_dec_release(atomic_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_fetch_dec_release(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_fetch_dec_relaxed(atomic_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_fetch_dec_relaxed(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
atomic_and(int i, atomic_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 arch_atomic_and(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_fetch_and(int i, atomic_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_fetch_and(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_fetch_and_acquire(int i, atomic_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_fetch_and_acquire(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_fetch_and_release(int i, atomic_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_fetch_and_release(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_fetch_and_relaxed(int i, atomic_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_fetch_and_relaxed(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
atomic_andnot(int i, atomic_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 arch_atomic_andnot(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_fetch_andnot(int i, atomic_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_fetch_andnot(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_fetch_andnot_acquire(int i, atomic_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_fetch_andnot_acquire(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_fetch_andnot_release(int i, atomic_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_fetch_andnot_release(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_fetch_andnot_relaxed(int i, atomic_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_fetch_andnot_relaxed(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
atomic_or(int i, atomic_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 arch_atomic_or(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_fetch_or(int i, atomic_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_fetch_or(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_fetch_or_acquire(int i, atomic_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_fetch_or_acquire(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_fetch_or_release(int i, atomic_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_fetch_or_release(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_fetch_or_relaxed(int i, atomic_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_fetch_or_relaxed(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
atomic_xor(int i, atomic_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 arch_atomic_xor(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_fetch_xor(int i, atomic_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_fetch_xor(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_fetch_xor_acquire(int i, atomic_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_fetch_xor_acquire(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_fetch_xor_release(int i, atomic_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_fetch_xor_release(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_fetch_xor_relaxed(int i, atomic_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_fetch_xor_relaxed(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_xchg(atomic_t *v, int i)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_xchg(v, i);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_xchg_acquire(atomic_t *v, int i)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_xchg_acquire(v, i);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_xchg_release(atomic_t *v, int i)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_xchg_release(v, i);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_xchg_relaxed(atomic_t *v, int i)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_xchg_relaxed(v, i);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_cmpxchg(atomic_t *v, int old, int new)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_cmpxchg(v, old, new);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_cmpxchg_acquire(atomic_t *v, int old, int new)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_cmpxchg_acquire(v, old, new);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_cmpxchg_release(atomic_t *v, int old, int new)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_cmpxchg_release(v, old, new);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_cmpxchg_relaxed(atomic_t *v, int old, int new)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_cmpxchg_relaxed(v, old, new);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
atomic_try_cmpxchg(atomic_t *v, int *old, int new)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 instrument_atomic_read_write(old, sizeof(*old));\r
 return arch_atomic_try_cmpxchg(v, old, new);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
atomic_try_cmpxchg_acquire(atomic_t *v, int *old, int new)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 instrument_atomic_read_write(old, sizeof(*old));\r
 return arch_atomic_try_cmpxchg_acquire(v, old, new);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
atomic_try_cmpxchg_release(atomic_t *v, int *old, int new)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 instrument_atomic_read_write(old, sizeof(*old));\r
 return arch_atomic_try_cmpxchg_release(v, old, new);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
atomic_try_cmpxchg_relaxed(atomic_t *v, int *old, int new)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 instrument_atomic_read_write(old, sizeof(*old));\r
 return arch_atomic_try_cmpxchg_relaxed(v, old, new);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
atomic_sub_and_test(int i, atomic_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_sub_and_test(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
atomic_dec_and_test(atomic_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_dec_and_test(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
atomic_inc_and_test(atomic_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_inc_and_test(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
atomic_add_negative(int i, atomic_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_add_negative(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_fetch_add_unless(atomic_t *v, int a, int u)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_fetch_add_unless(v, a, u);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
atomic_add_unless(atomic_t *v, int a, int u)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_add_unless(v, a, u);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
atomic_inc_not_zero(atomic_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_inc_not_zero(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
atomic_inc_unless_negative(atomic_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_inc_unless_negative(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
atomic_dec_unless_positive(atomic_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_dec_unless_positive(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int\r
atomic_dec_if_positive(atomic_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_sub_if_positive(v, 1);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_read(const atomic64_t *v)\r
{\r
 instrument_atomic_read(v, sizeof(*v));\r
 return arch_atomic64_read(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_read_acquire(const atomic64_t *v)\r
{\r
 instrument_atomic_read(v, sizeof(*v));\r
 return arch_atomic64_read_acquire(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
atomic64_set(atomic64_t *v, s64 i)\r
{\r
 instrument_atomic_write(v, sizeof(*v));\r
 arch_atomic64_set(v, i);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
atomic64_set_release(atomic64_t *v, s64 i)\r
{\r
 do { } while (0);\r
 instrument_atomic_write(v, sizeof(*v));\r
 arch_atomic64_set_release(v, i);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
atomic64_add(s64 i, atomic64_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 arch_atomic64_add(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_add_return(s64 i, atomic64_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_add_return(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_add_return_acquire(s64 i, atomic64_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_add_return_acquire(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_add_return_release(s64 i, atomic64_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_add_return_release(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_add_return_relaxed(s64 i, atomic64_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_add_return_relaxed(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_fetch_add(s64 i, atomic64_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_fetch_add(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_fetch_add_acquire(s64 i, atomic64_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_fetch_add_acquire(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_fetch_add_release(s64 i, atomic64_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_fetch_add_release(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_fetch_add_relaxed(s64 i, atomic64_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_fetch_add_relaxed(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
atomic64_sub(s64 i, atomic64_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 arch_atomic64_sub(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_sub_return(s64 i, atomic64_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_sub_return(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_sub_return_acquire(s64 i, atomic64_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_sub_return_acquire(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_sub_return_release(s64 i, atomic64_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_sub_return_release(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_sub_return_relaxed(s64 i, atomic64_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_sub_return_relaxed(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_fetch_sub(s64 i, atomic64_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_fetch_sub(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_fetch_sub_acquire(s64 i, atomic64_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_fetch_sub_acquire(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_fetch_sub_release(s64 i, atomic64_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_fetch_sub_release(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_fetch_sub_relaxed(s64 i, atomic64_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_fetch_sub_relaxed(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
atomic64_inc(atomic64_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 arch_atomic64_inc(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_inc_return(atomic64_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_inc_return(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_inc_return_acquire(atomic64_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_inc_return_acquire(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_inc_return_release(atomic64_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_inc_return_release(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_inc_return_relaxed(atomic64_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_inc_return_relaxed(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_fetch_inc(atomic64_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_fetch_inc(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_fetch_inc_acquire(atomic64_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_fetch_inc_acquire(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_fetch_inc_release(atomic64_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_fetch_inc_release(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_fetch_inc_relaxed(atomic64_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_fetch_inc_relaxed(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
atomic64_dec(atomic64_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 arch_atomic64_dec(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_dec_return(atomic64_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_dec_return(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_dec_return_acquire(atomic64_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_dec_return_acquire(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_dec_return_release(atomic64_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_dec_return_release(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_dec_return_relaxed(atomic64_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_dec_return_relaxed(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_fetch_dec(atomic64_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_fetch_dec(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_fetch_dec_acquire(atomic64_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_fetch_dec_acquire(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_fetch_dec_release(atomic64_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_fetch_dec_release(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_fetch_dec_relaxed(atomic64_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_fetch_dec_relaxed(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
atomic64_and(s64 i, atomic64_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 arch_atomic64_and(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_fetch_and(s64 i, atomic64_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_fetch_and(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_fetch_and_acquire(s64 i, atomic64_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_fetch_and_acquire(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_fetch_and_release(s64 i, atomic64_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_fetch_and_release(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_fetch_and_relaxed(s64 i, atomic64_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_fetch_and_relaxed(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
atomic64_andnot(s64 i, atomic64_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 arch_atomic64_andnot(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_fetch_andnot(s64 i, atomic64_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_fetch_andnot(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_fetch_andnot_acquire(s64 i, atomic64_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_fetch_andnot_acquire(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_fetch_andnot_release(s64 i, atomic64_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_fetch_andnot_release(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_fetch_andnot_relaxed(s64 i, atomic64_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_fetch_andnot_relaxed(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
atomic64_or(s64 i, atomic64_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 arch_atomic64_or(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_fetch_or(s64 i, atomic64_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_fetch_or(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_fetch_or_acquire(s64 i, atomic64_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_fetch_or_acquire(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_fetch_or_release(s64 i, atomic64_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_fetch_or_release(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_fetch_or_relaxed(s64 i, atomic64_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_fetch_or_relaxed(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
atomic64_xor(s64 i, atomic64_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 arch_atomic64_xor(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_fetch_xor(s64 i, atomic64_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_fetch_xor(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_fetch_xor_acquire(s64 i, atomic64_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_fetch_xor_acquire(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_fetch_xor_release(s64 i, atomic64_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_fetch_xor_release(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_fetch_xor_relaxed(s64 i, atomic64_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_fetch_xor_relaxed(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_xchg(atomic64_t *v, s64 i)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_xchg(v, i);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_xchg_acquire(atomic64_t *v, s64 i)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_xchg(v, i);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_xchg_release(atomic64_t *v, s64 i)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_xchg(v, i);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_xchg_relaxed(atomic64_t *v, s64 i)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_xchg(v, i);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_cmpxchg(atomic64_t *v, s64 old, s64 new)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_cmpxchg(v, old, new);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_cmpxchg_acquire(atomic64_t *v, s64 old, s64 new)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_cmpxchg(v, old, new);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_cmpxchg_release(atomic64_t *v, s64 old, s64 new)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_cmpxchg(v, old, new);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_cmpxchg_relaxed(atomic64_t *v, s64 old, s64 new)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_cmpxchg(v, old, new);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
atomic64_try_cmpxchg(atomic64_t *v, s64 *old, s64 new)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 instrument_atomic_read_write(old, sizeof(*old));\r
 return arch_atomic64_try_cmpxchg(v, old, new);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
atomic64_try_cmpxchg_acquire(atomic64_t *v, s64 *old, s64 new)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 instrument_atomic_read_write(old, sizeof(*old));\r
 return arch_atomic64_try_cmpxchg_acquire(v, old, new);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
atomic64_try_cmpxchg_release(atomic64_t *v, s64 *old, s64 new)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 instrument_atomic_read_write(old, sizeof(*old));\r
 return arch_atomic64_try_cmpxchg_release(v, old, new);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
atomic64_try_cmpxchg_relaxed(atomic64_t *v, s64 *old, s64 new)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 instrument_atomic_read_write(old, sizeof(*old));\r
 return arch_atomic64_try_cmpxchg_relaxed(v, old, new);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
atomic64_sub_and_test(s64 i, atomic64_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_sub_and_test(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
atomic64_dec_and_test(atomic64_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_dec_and_test(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
atomic64_inc_and_test(atomic64_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_inc_and_test(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
atomic64_add_negative(s64 i, atomic64_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_add_negative(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_fetch_add_unless(atomic64_t *v, s64 a, s64 u)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_fetch_add_unless(v, a, u);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
atomic64_add_unless(atomic64_t *v, s64 a, s64 u)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_add_unless(v, a, u);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
atomic64_inc_not_zero(atomic64_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_inc_not_zero(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
atomic64_inc_unless_negative(atomic64_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_inc_unless_negative(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
atomic64_dec_unless_positive(atomic64_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_dec_unless_positive(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) s64\r
atomic64_dec_if_positive(atomic64_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic64_sub_if_positive(v, 1);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_read(const atomic_long_t *v)\r
{\r
 instrument_atomic_read(v, sizeof(*v));\r
 return arch_atomic_long_read(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_read_acquire(const atomic_long_t *v)\r
{\r
 instrument_atomic_read(v, sizeof(*v));\r
 return arch_atomic_long_read_acquire(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
atomic_long_set(atomic_long_t *v, long i)\r
{\r
 instrument_atomic_write(v, sizeof(*v));\r
 arch_atomic_long_set(v, i);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
atomic_long_set_release(atomic_long_t *v, long i)\r
{\r
 do { } while (0);\r
 instrument_atomic_write(v, sizeof(*v));\r
 arch_atomic_long_set_release(v, i);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
atomic_long_add(long i, atomic_long_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 arch_atomic_long_add(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_add_return(long i, atomic_long_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_add_return(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_add_return_acquire(long i, atomic_long_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_add_return_acquire(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_add_return_release(long i, atomic_long_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_add_return_release(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_add_return_relaxed(long i, atomic_long_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_add_return_relaxed(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_fetch_add(long i, atomic_long_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_fetch_add(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_fetch_add_acquire(long i, atomic_long_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_fetch_add_acquire(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_fetch_add_release(long i, atomic_long_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_fetch_add_release(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_fetch_add_relaxed(long i, atomic_long_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_fetch_add_relaxed(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
atomic_long_sub(long i, atomic_long_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 arch_atomic_long_sub(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_sub_return(long i, atomic_long_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_sub_return(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_sub_return_acquire(long i, atomic_long_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_sub_return_acquire(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_sub_return_release(long i, atomic_long_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_sub_return_release(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_sub_return_relaxed(long i, atomic_long_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_sub_return_relaxed(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_fetch_sub(long i, atomic_long_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_fetch_sub(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_fetch_sub_acquire(long i, atomic_long_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_fetch_sub_acquire(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_fetch_sub_release(long i, atomic_long_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_fetch_sub_release(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_fetch_sub_relaxed(long i, atomic_long_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_fetch_sub_relaxed(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
atomic_long_inc(atomic_long_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 arch_atomic_long_inc(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_inc_return(atomic_long_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_inc_return(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_inc_return_acquire(atomic_long_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_inc_return_acquire(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_inc_return_release(atomic_long_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_inc_return_release(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_inc_return_relaxed(atomic_long_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_inc_return_relaxed(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_fetch_inc(atomic_long_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_fetch_inc(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_fetch_inc_acquire(atomic_long_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_fetch_inc_acquire(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_fetch_inc_release(atomic_long_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_fetch_inc_release(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_fetch_inc_relaxed(atomic_long_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_fetch_inc_relaxed(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
atomic_long_dec(atomic_long_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 arch_atomic_long_dec(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_dec_return(atomic_long_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_dec_return(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_dec_return_acquire(atomic_long_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_dec_return_acquire(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_dec_return_release(atomic_long_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_dec_return_release(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_dec_return_relaxed(atomic_long_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_dec_return_relaxed(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_fetch_dec(atomic_long_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_fetch_dec(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_fetch_dec_acquire(atomic_long_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_fetch_dec_acquire(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_fetch_dec_release(atomic_long_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_fetch_dec_release(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_fetch_dec_relaxed(atomic_long_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_fetch_dec_relaxed(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
atomic_long_and(long i, atomic_long_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 arch_atomic_long_and(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_fetch_and(long i, atomic_long_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_fetch_and(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_fetch_and_acquire(long i, atomic_long_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_fetch_and_acquire(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_fetch_and_release(long i, atomic_long_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_fetch_and_release(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_fetch_and_relaxed(long i, atomic_long_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_fetch_and_relaxed(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
atomic_long_andnot(long i, atomic_long_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 arch_atomic_long_andnot(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_fetch_andnot(long i, atomic_long_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_fetch_andnot(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_fetch_andnot_acquire(long i, atomic_long_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_fetch_andnot_acquire(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_fetch_andnot_release(long i, atomic_long_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_fetch_andnot_release(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_fetch_andnot_relaxed(long i, atomic_long_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_fetch_andnot_relaxed(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
atomic_long_or(long i, atomic_long_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 arch_atomic_long_or(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_fetch_or(long i, atomic_long_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_fetch_or(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_fetch_or_acquire(long i, atomic_long_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_fetch_or_acquire(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_fetch_or_release(long i, atomic_long_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_fetch_or_release(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_fetch_or_relaxed(long i, atomic_long_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_fetch_or_relaxed(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
atomic_long_xor(long i, atomic_long_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 arch_atomic_long_xor(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_fetch_xor(long i, atomic_long_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_fetch_xor(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_fetch_xor_acquire(long i, atomic_long_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_fetch_xor_acquire(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_fetch_xor_release(long i, atomic_long_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_fetch_xor_release(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_fetch_xor_relaxed(long i, atomic_long_t *v)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_fetch_xor_relaxed(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_xchg(atomic_long_t *v, long i)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_xchg(v, i);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_xchg_acquire(atomic_long_t *v, long i)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_xchg_acquire(v, i);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_xchg_release(atomic_long_t *v, long i)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_xchg_release(v, i);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_xchg_relaxed(atomic_long_t *v, long i)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_xchg_relaxed(v, i);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_cmpxchg(atomic_long_t *v, long old, long new)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_cmpxchg(v, old, new);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_cmpxchg_acquire(atomic_long_t *v, long old, long new)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_cmpxchg_acquire(v, old, new);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_cmpxchg_release(atomic_long_t *v, long old, long new)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_cmpxchg_release(v, old, new);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_cmpxchg_relaxed(atomic_long_t *v, long old, long new)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_cmpxchg_relaxed(v, old, new);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
atomic_long_try_cmpxchg(atomic_long_t *v, long *old, long new)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 instrument_atomic_read_write(old, sizeof(*old));\r
 return arch_atomic_long_try_cmpxchg(v, old, new);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
atomic_long_try_cmpxchg_acquire(atomic_long_t *v, long *old, long new)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 instrument_atomic_read_write(old, sizeof(*old));\r
 return arch_atomic_long_try_cmpxchg_acquire(v, old, new);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
atomic_long_try_cmpxchg_release(atomic_long_t *v, long *old, long new)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 instrument_atomic_read_write(old, sizeof(*old));\r
 return arch_atomic_long_try_cmpxchg_release(v, old, new);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
atomic_long_try_cmpxchg_relaxed(atomic_long_t *v, long *old, long new)\r
{\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 instrument_atomic_read_write(old, sizeof(*old));\r
 return arch_atomic_long_try_cmpxchg_relaxed(v, old, new);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
atomic_long_sub_and_test(long i, atomic_long_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_sub_and_test(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
atomic_long_dec_and_test(atomic_long_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_dec_and_test(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
atomic_long_inc_and_test(atomic_long_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_inc_and_test(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
atomic_long_add_negative(long i, atomic_long_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_add_negative(i, v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_fetch_add_unless(atomic_long_t *v, long a, long u)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_fetch_add_unless(v, a, u);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
atomic_long_add_unless(atomic_long_t *v, long a, long u)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_add_unless(v, a, u);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
atomic_long_inc_not_zero(atomic_long_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_inc_not_zero(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
atomic_long_inc_unless_negative(atomic_long_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_inc_unless_negative(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool\r
atomic_long_dec_unless_positive(atomic_long_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_dec_unless_positive(v);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) long\r
atomic_long_dec_if_positive(atomic_long_t *v)\r
{\r
 do { } while (0);\r
 instrument_atomic_read_write(v, sizeof(*v));\r
 return arch_atomic_long_dec_if_positive(v);\r
}\r
# 83 "./include/linux/atomic.h" 2\r
# 14 "./include/linux/mm_types_task.h" 2\r
# 1 "./include/linux/cpumask.h" 1\r
# 12 "./include/linux/cpumask.h"\r
# 1 "./include/linux/bitmap.h" 1\r
\r
\r
\r
\r
\r
\r
\r
\r
# 1 "./include/linux/find.h" 1\r
# 11 "./include/linux/find.h"\r
extern unsigned long _find_next_bit(const unsigned long *addr1,\r
  const unsigned long *addr2, unsigned long nbits,\r
  unsigned long start, unsigned long invert, unsigned long le);\r
extern unsigned long _find_first_bit(const unsigned long *addr, unsigned long size);\r
extern unsigned long _find_first_and_bit(const unsigned long *addr1,\r
      const unsigned long *addr2, unsigned long size);\r
extern unsigned long _find_first_zero_bit(const unsigned long *addr, unsigned long size);\r
extern unsigned long _find_last_bit(const unsigned long *addr, unsigned long size);\r
# 30 "./include/linux/find.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0)))\r
unsigned long find_next_bit(const unsigned long *addr, unsigned long size,\r
       unsigned long offset)\r
{\r
 if ((__builtin_constant_p(size) && (size) <= 64 && (size) > 0)) {\r
  unsigned long val;\r
\r
  if (__builtin_expect(!!(offset >= size), 0))\r
   return size;\r
\r
  val = *addr & ((((int)(sizeof(struct { int:(-!!(__builtin_choose_expr( (sizeof(int) == sizeof(*(8 ? ((void *)((long)((offset) > (size - 1)) * 0l)) : (int *)8))), (offset) > (size - 1), 0))); })))) + (((~(((0UL)))) - ((((1UL))) << (offset)) + 1) & (~(((0UL))) >> (64 - 1 - (size - 1)))));\r
  return val ? __ffs(val) : size;\r
 }\r
\r
 return _find_next_bit(addr, ((void *)0), size, offset, 0UL, 0);\r
}\r
# 59 "./include/linux/find.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0)))\r
unsigned long find_next_and_bit(const unsigned long *addr1,\r
  const unsigned long *addr2, unsigned long size,\r
  unsigned long offset)\r
{\r
 if ((__builtin_constant_p(size) && (size) <= 64 && (size) > 0)) {\r
  unsigned long val;\r
\r
  if (__builtin_expect(!!(offset >= size), 0))\r
   return size;\r
\r
  val = *addr1 & *addr2 & ((((int)(sizeof(struct { int:(-!!(__builtin_choose_expr( (sizeof(int) == sizeof(*(8 ? ((void *)((long)((offset) > (size - 1)) * 0l)) : (int *)8))), (offset) > (size - 1), 0))); })))) + (((~(((0UL)))) - ((((1UL))) << (offset)) + 1) & (~(((0UL))) >> (64 - 1 - (size - 1)))));\r
  return val ? __ffs(val) : size;\r
 }\r
\r
 return _find_next_bit(addr1, addr2, size, offset, 0UL, 0);\r
}\r
# 88 "./include/linux/find.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0)))\r
unsigned long find_next_zero_bit(const unsigned long *addr, unsigned long size,\r
     unsigned long offset)\r
{\r
 if ((__builtin_constant_p(size) && (size) <= 64 && (size) > 0)) {\r
  unsigned long val;\r
\r
  if (__builtin_expect(!!(offset >= size), 0))\r
   return size;\r
\r
  val = *addr | ~((((int)(sizeof(struct { int:(-!!(__builtin_choose_expr( (sizeof(int) == sizeof(*(8 ? ((void *)((long)((offset) > (size - 1)) * 0l)) : (int *)8))), (offset) > (size - 1), 0))); })))) + (((~(((0UL)))) - ((((1UL))) << (offset)) + 1) & (~(((0UL))) >> (64 - 1 - (size - 1)))));\r
  return val == ~0UL ? size : __ffs(~(val));\r
 }\r
\r
 return _find_next_bit(addr, ((void *)0), size, offset, ~0UL, 0);\r
}\r
# 115 "./include/linux/find.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0)))\r
unsigned long find_first_bit(const unsigned long *addr, unsigned long size)\r
{\r
 if ((__builtin_constant_p(size) && (size) <= 64 && (size) > 0)) {\r
  unsigned long val = *addr & ((((int)(sizeof(struct { int:(-!!(__builtin_choose_expr( (sizeof(int) == sizeof(*(8 ? ((void *)((long)((0) > (size - 1)) * 0l)) : (int *)8))), (0) > (size - 1), 0))); })))) + (((~(((0UL)))) - ((((1UL))) << (0)) + 1) & (~(((0UL))) >> (64 - 1 - (size - 1)))));\r
\r
  return val ? __ffs(val) : size;\r
 }\r
\r
 return _find_first_bit(addr, size);\r
}\r
# 138 "./include/linux/find.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0)))\r
unsigned long find_first_and_bit(const unsigned long *addr1,\r
     const unsigned long *addr2,\r
     unsigned long size)\r
{\r
 if ((__builtin_constant_p(size) && (size) <= 64 && (size) > 0)) {\r
  unsigned long val = *addr1 & *addr2 & ((((int)(sizeof(struct { int:(-!!(__builtin_choose_expr( (sizeof(int) == sizeof(*(8 ? ((void *)((long)((0) > (size - 1)) * 0l)) : (int *)8))), (0) > (size - 1), 0))); })))) + (((~(((0UL)))) - ((((1UL))) << (0)) + 1) & (~(((0UL))) >> (64 - 1 - (size - 1)))));\r
\r
  return val ? __ffs(val) : size;\r
 }\r
\r
 return _find_first_and_bit(addr1, addr2, size);\r
}\r
# 162 "./include/linux/find.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0)))\r
unsigned long find_first_zero_bit(const unsigned long *addr, unsigned long size)\r
{\r
 if ((__builtin_constant_p(size) && (size) <= 64 && (size) > 0)) {\r
  unsigned long val = *addr | ~((((int)(sizeof(struct { int:(-!!(__builtin_choose_expr( (sizeof(int) == sizeof(*(8 ? ((void *)((long)((0) > (size - 1)) * 0l)) : (int *)8))), (0) > (size - 1), 0))); })))) + (((~(((0UL)))) - ((((1UL))) << (0)) + 1) & (~(((0UL))) >> (64 - 1 - (size - 1)))));\r
\r
  return val == ~0UL ? size : __ffs(~(val));\r
 }\r
\r
 return _find_first_zero_bit(addr, size);\r
}\r
# 183 "./include/linux/find.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0)))\r
unsigned long find_last_bit(const unsigned long *addr, unsigned long size)\r
{\r
 if ((__builtin_constant_p(size) && (size) <= 64 && (size) > 0)) {\r
  unsigned long val = *addr & ((((int)(sizeof(struct { int:(-!!(__builtin_choose_expr( (sizeof(int) == sizeof(*(8 ? ((void *)((long)((0) > (size - 1)) * 0l)) : (int *)8))), (0) > (size - 1), 0))); })))) + (((~(((0UL)))) - ((((1UL))) << (0)) + 1) & (~(((0UL))) >> (64 - 1 - (size - 1)))));\r
\r
  return val ? __fls(val) : size;\r
 }\r
\r
 return _find_last_bit(addr, size);\r
}\r
# 206 "./include/linux/find.h"\r
extern unsigned long find_next_clump8(unsigned long *clump,\r
          const unsigned long *addr,\r
          unsigned long size, unsigned long offset);\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) unsigned long find_next_zero_bit_le(const void *addr,\r
  unsigned long size, unsigned long offset)\r
{\r
 return find_next_zero_bit(addr, size, offset);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) unsigned long find_next_bit_le(const void *addr,\r
  unsigned long size, unsigned long offset)\r
{\r
 return find_next_bit(addr, size, offset);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) unsigned long find_first_zero_bit_le(const void *addr,\r
  unsigned long size)\r
{\r
 return find_first_zero_bit(addr, size);\r
}\r
# 10 "./include/linux/bitmap.h" 2\r
\r
# 1 "./include/linux/string.h" 1\r
# 10 "./include/linux/string.h"\r
# 1 "./include/uapi/linux/string.h" 1\r
# 11 "./include/linux/string.h" 2\r
\r
extern char *strndup_user(const char *, long);\r
extern void *memdup_user(const void *, size_t);\r
extern void *vmemdup_user(const void *, size_t);\r
extern void *memdup_user_nul(const void *, size_t);\r
\r
\r
\r
\r
\r
# 1 "./arch/riscv/include/asm/string.h" 1\r
# 13 "./arch/riscv/include/asm/string.h"\r
extern void *memset(void *, int, size_t);\r
extern void *__memset(void *, int, size_t);\r
\r
extern void *memcpy(void *, const void *, size_t);\r
extern void *__memcpy(void *, const void *, size_t);\r
\r
extern void *memmove(void *, const void *, size_t);\r
extern void *__memmove(void *, const void *, size_t);\r
# 21 "./include/linux/string.h" 2\r
\r
\r
extern char * strcpy(char *,const char *);\r
\r
\r
extern char * strncpy(char *,const char *, __kernel_size_t);\r
\r
\r
size_t strlcpy(char *, const char *, size_t);\r
\r
\r
ssize_t strscpy(char *, const char *, size_t);\r
\r
\r
\r
ssize_t strscpy_pad(char *dest, const char *src, size_t count);\r
\r
\r
extern char * strcat(char *, const char *);\r
\r
\r
extern char * strncat(char *, const char *, __kernel_size_t);\r
\r
\r
extern size_t strlcat(char *, const char *, __kernel_size_t);\r
\r
\r
extern int strcmp(const char *,const char *);\r
\r
\r
extern int strncmp(const char *,const char *,__kernel_size_t);\r
\r
\r
extern int strcasecmp(const char *s1, const char *s2);\r
\r
\r
extern int strncasecmp(const char *s1, const char *s2, size_t n);\r
\r
\r
extern char * strchr(const char *,int);\r
\r
\r
extern char * strchrnul(const char *,int);\r
\r
extern char * strnchrnul(const char *, size_t, int);\r
\r
extern char * strnchr(const char *, size_t, int);\r
\r
\r
extern char * strrchr(const char *,int);\r
\r
extern char * __attribute__((__warn_unused_result__)) skip_spaces(const char *);\r
\r
extern char *strim(char *);\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__warn_unused_result__)) char *strstrip(char *str)\r
{\r
 return strim(str);\r
}\r
\r
\r
extern char * strstr(const char *, const char *);\r
\r
\r
extern char * strnstr(const char *, const char *, size_t);\r
\r
\r
extern __kernel_size_t strlen(const char *);\r
\r
\r
extern __kernel_size_t strnlen(const char *,__kernel_size_t);\r
\r
\r
extern char * strpbrk(const char *,const char *);\r
\r
\r
extern char * strsep(char **,const char *);\r
\r
\r
extern __kernel_size_t strspn(const char *,const char *);\r
\r
\r
extern __kernel_size_t strcspn(const char *,const char *);\r
\r
\r
\r
\r
\r
\r
\r
extern void *memset16(uint16_t *, uint16_t, __kernel_size_t);\r
\r
\r
\r
extern void *memset32(uint32_t *, uint32_t, __kernel_size_t);\r
\r
\r
\r
extern void *memset64(uint64_t *, uint64_t, __kernel_size_t);\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void *memset_l(unsigned long *p, unsigned long v,\r
  __kernel_size_t n)\r
{\r
 if (64 == 32)\r
  return memset32((uint32_t *)p, v, n);\r
 else\r
  return memset64((uint64_t *)p, v, n);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void *memset_p(void **p, void *v, __kernel_size_t n)\r
{\r
 if (64 == 32)\r
  return memset32((uint32_t *)p, (uintptr_t)v, n);\r
 else\r
  return memset64((uint64_t *)p, (uintptr_t)v, n);\r
}\r
\r
extern void **__memcat_p(void **a, void **b);\r
# 153 "./include/linux/string.h"\r
extern void * memscan(void *,int,__kernel_size_t);\r
\r
\r
extern int memcmp(const void *,const void *,__kernel_size_t);\r
\r
\r
extern int bcmp(const void *,const void *,__kernel_size_t);\r
\r
\r
extern void * memchr(const void *,int,__kernel_size_t);\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void memcpy_flushcache(void *dst, const void *src, size_t cnt)\r
{\r
 memcpy(dst, src, cnt);\r
}\r
\r
\r
void *memchr_inv(const void *s, int c, size_t n);\r
char *strreplace(char *s, char old, char new);\r
\r
extern void kfree_const(const void *x);\r
\r
extern char *kstrdup(const char *s, gfp_t gfp) __attribute__((__malloc__));\r
extern const char *kstrdup_const(const char *s, gfp_t gfp);\r
extern char *kstrndup(const char *s, size_t len, gfp_t gfp);\r
extern void *kmemdup(const void *src, size_t len, gfp_t gfp);\r
extern char *kmemdup_nul(const char *s, size_t len, gfp_t gfp);\r
\r
extern char **argv_split(gfp_t gfp, const char *str, int *argcp);\r
extern void argv_free(char **argv);\r
\r
extern bool sysfs_streq(const char *s1, const char *s2);\r
int match_string(const char * const *array, size_t n, const char *string);\r
int __sysfs_match_string(const char * const *array, size_t n, const char *s);\r
# 199 "./include/linux/string.h"\r
int vbin_printf(u32 *bin_buf, size_t size, const char *fmt, va_list args);\r
int bstr_printf(char *buf, size_t size, const char *fmt, const u32 *bin_buf);\r
int bprintf(u32 *bin_buf, size_t size, const char *fmt, ...) __attribute__((__format__(printf, 3, 4)));\r
\r
\r
extern ssize_t memory_read_from_buffer(void *to, size_t count, loff_t *ppos,\r
           const void *from, size_t available);\r
\r
int ptr_to_hashval(const void *ptr, unsigned long *hashval_out);\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool strstarts(const char *str, const char *prefix)\r
{\r
 return strncmp(str, prefix, strlen(prefix)) == 0;\r
}\r
\r
size_t memweight(const void *ptr, size_t bytes);\r
# 235 "./include/linux/string.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void memzero_explicit(void *s, size_t count)\r
{\r
 memset(s, 0, count);\r
 __asm__ __volatile__("": :"r"(s) :"memory");\r
}\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) const char *kbasename(const char *path)\r
{\r
 const char *tail = strrchr(path, '/');\r
 return tail ? tail + 1 : path;\r
}\r
\r
\r
\r
\r
\r
void memcpy_and_pad(void *dest, size_t dest_len, const void *src, size_t count,\r
      int pad);\r
# 309 "./include/linux/string.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) size_t str_has_prefix(const char *str, const char *prefix)\r
{\r
 size_t len = strlen(prefix);\r
 return strncmp(str, prefix, len) == 0 ? len : 0;\r
}\r
# 12 "./include/linux/bitmap.h" 2\r
\r
\r
struct device;\r
# 119 "./include/linux/bitmap.h"\r
unsigned long *bitmap_alloc(unsigned int nbits, gfp_t flags);\r
unsigned long *bitmap_zalloc(unsigned int nbits, gfp_t flags);\r
unsigned long *bitmap_alloc_node(unsigned int nbits, gfp_t flags, int node);\r
unsigned long *bitmap_zalloc_node(unsigned int nbits, gfp_t flags, int node);\r
void bitmap_free(const unsigned long *bitmap);\r
\r
\r
unsigned long *devm_bitmap_alloc(struct device *dev,\r
     unsigned int nbits, gfp_t flags);\r
unsigned long *devm_bitmap_zalloc(struct device *dev,\r
      unsigned int nbits, gfp_t flags);\r
\r
\r
\r
\r
\r
int __bitmap_equal(const unsigned long *bitmap1,\r
     const unsigned long *bitmap2, unsigned int nbits);\r
bool __attribute__((__pure__)) __bitmap_or_equal(const unsigned long *src1,\r
         const unsigned long *src2,\r
         const unsigned long *src3,\r
         unsigned int nbits);\r
void __bitmap_complement(unsigned long *dst, const unsigned long *src,\r
    unsigned int nbits);\r
void __bitmap_shift_right(unsigned long *dst, const unsigned long *src,\r
     unsigned int shift, unsigned int nbits);\r
void __bitmap_shift_left(unsigned long *dst, const unsigned long *src,\r
    unsigned int shift, unsigned int nbits);\r
void bitmap_cut(unsigned long *dst, const unsigned long *src,\r
  unsigned int first, unsigned int cut, unsigned int nbits);\r
int __bitmap_and(unsigned long *dst, const unsigned long *bitmap1,\r
   const unsigned long *bitmap2, unsigned int nbits);\r
void __bitmap_or(unsigned long *dst, const unsigned long *bitmap1,\r
   const unsigned long *bitmap2, unsigned int nbits);\r
void __bitmap_xor(unsigned long *dst, const unsigned long *bitmap1,\r
    const unsigned long *bitmap2, unsigned int nbits);\r
int __bitmap_andnot(unsigned long *dst, const unsigned long *bitmap1,\r
      const unsigned long *bitmap2, unsigned int nbits);\r
void __bitmap_replace(unsigned long *dst,\r
        const unsigned long *old, const unsigned long *new,\r
        const unsigned long *mask, unsigned int nbits);\r
int __bitmap_intersects(const unsigned long *bitmap1,\r
   const unsigned long *bitmap2, unsigned int nbits);\r
int __bitmap_subset(const unsigned long *bitmap1,\r
      const unsigned long *bitmap2, unsigned int nbits);\r
int __bitmap_weight(const unsigned long *bitmap, unsigned int nbits);\r
void __bitmap_set(unsigned long *map, unsigned int start, int len);\r
void __bitmap_clear(unsigned long *map, unsigned int start, int len);\r
\r
unsigned long bitmap_find_next_zero_area_off(unsigned long *map,\r
          unsigned long size,\r
          unsigned long start,\r
          unsigned int nr,\r
          unsigned long align_mask,\r
          unsigned long align_offset);\r
# 187 "./include/linux/bitmap.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) unsigned long\r
bitmap_find_next_zero_area(unsigned long *map,\r
      unsigned long size,\r
      unsigned long start,\r
      unsigned int nr,\r
      unsigned long align_mask)\r
{\r
 return bitmap_find_next_zero_area_off(map, size, start, nr,\r
           align_mask, 0);\r
}\r
\r
int bitmap_parse(const char *buf, unsigned int buflen,\r
   unsigned long *dst, int nbits);\r
int bitmap_parse_user(const char *ubuf, unsigned int ulen,\r
   unsigned long *dst, int nbits);\r
int bitmap_parselist(const char *buf, unsigned long *maskp,\r
   int nmaskbits);\r
int bitmap_parselist_user(const char *ubuf, unsigned int ulen,\r
   unsigned long *dst, int nbits);\r
void bitmap_remap(unsigned long *dst, const unsigned long *src,\r
  const unsigned long *old, const unsigned long *new, unsigned int nbits);\r
int bitmap_bitremap(int oldbit,\r
  const unsigned long *old, const unsigned long *new, int bits);\r
void bitmap_onto(unsigned long *dst, const unsigned long *orig,\r
  const unsigned long *relmap, unsigned int bits);\r
void bitmap_fold(unsigned long *dst, const unsigned long *orig,\r
  unsigned int sz, unsigned int nbits);\r
int bitmap_find_free_region(unsigned long *bitmap, unsigned int bits, int order);\r
void bitmap_release_region(unsigned long *bitmap, unsigned int pos, int order);\r
int bitmap_allocate_region(unsigned long *bitmap, unsigned int pos, int order);\r
\r
\r
\r
\r
\r
\r
unsigned int bitmap_ord_to_pos(const unsigned long *bitmap, unsigned int ord, unsigned int nbits);\r
int bitmap_print_to_pagebuf(bool list, char *buf,\r
       const unsigned long *maskp, int nmaskbits);\r
\r
extern int bitmap_print_bitmask_to_buf(char *buf, const unsigned long *maskp,\r
          int nmaskbits, loff_t off, size_t count);\r
\r
extern int bitmap_print_list_to_buf(char *buf, const unsigned long *maskp,\r
          int nmaskbits, loff_t off, size_t count);\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void bitmap_zero(unsigned long *dst, unsigned int nbits)\r
{\r
 unsigned int len = (((nbits) + ((sizeof(long) * 8)) - 1) / ((sizeof(long) * 8))) * sizeof(unsigned long);\r
 memset(dst, 0, len);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void bitmap_fill(unsigned long *dst, unsigned int nbits)\r
{\r
 unsigned int len = (((nbits) + ((sizeof(long) * 8)) - 1) / ((sizeof(long) * 8))) * sizeof(unsigned long);\r
 memset(dst, 0xff, len);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void bitmap_copy(unsigned long *dst, const unsigned long *src,\r
   unsigned int nbits)\r
{\r
 unsigned int len = (((nbits) + ((sizeof(long) * 8)) - 1) / ((sizeof(long) * 8))) * sizeof(unsigned long);\r
 memcpy(dst, src, len);\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void bitmap_copy_clear_tail(unsigned long *dst,\r
  const unsigned long *src, unsigned int nbits)\r
{\r
 bitmap_copy(dst, src, nbits);\r
 if (nbits % 64)\r
  dst[nbits / 64] &= (~0UL >> (-(nbits) & (64 - 1)));\r
}\r
\r
\r
\r
\r
\r
\r
void bitmap_from_arr32(unsigned long *bitmap, const u32 *buf,\r
       unsigned int nbits);\r
void bitmap_to_arr32(u32 *buf, const unsigned long *bitmap,\r
       unsigned int nbits);\r
# 284 "./include/linux/bitmap.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int bitmap_and(unsigned long *dst, const unsigned long *src1,\r
   const unsigned long *src2, unsigned int nbits)\r
{\r
 if ((__builtin_constant_p(nbits) && (nbits) <= 64 && (nbits) > 0))\r
  return (*dst = *src1 & *src2 & (~0UL >> (-(nbits) & (64 - 1)))) != 0;\r
 return __bitmap_and(dst, src1, src2, nbits);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void bitmap_or(unsigned long *dst, const unsigned long *src1,\r
   const unsigned long *src2, unsigned int nbits)\r
{\r
 if ((__builtin_constant_p(nbits) && (nbits) <= 64 && (nbits) > 0))\r
  *dst = *src1 | *src2;\r
 else\r
  __bitmap_or(dst, src1, src2, nbits);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void bitmap_xor(unsigned long *dst, const unsigned long *src1,\r
   const unsigned long *src2, unsigned int nbits)\r
{\r
 if ((__builtin_constant_p(nbits) && (nbits) <= 64 && (nbits) > 0))\r
  *dst = *src1 ^ *src2;\r
 else\r
  __bitmap_xor(dst, src1, src2, nbits);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int bitmap_andnot(unsigned long *dst, const unsigned long *src1,\r
   const unsigned long *src2, unsigned int nbits)\r
{\r
 if ((__builtin_constant_p(nbits) && (nbits) <= 64 && (nbits) > 0))\r
  return (*dst = *src1 & ~(*src2) & (~0UL >> (-(nbits) & (64 - 1)))) != 0;\r
 return __bitmap_andnot(dst, src1, src2, nbits);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void bitmap_complement(unsigned long *dst, const unsigned long *src,\r
   unsigned int nbits)\r
{\r
 if ((__builtin_constant_p(nbits) && (nbits) <= 64 && (nbits) > 0))\r
  *dst = ~(*src);\r
 else\r
  __bitmap_complement(dst, src, nbits);\r
}\r
# 334 "./include/linux/bitmap.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int bitmap_equal(const unsigned long *src1,\r
   const unsigned long *src2, unsigned int nbits)\r
{\r
 if ((__builtin_constant_p(nbits) && (nbits) <= 64 && (nbits) > 0))\r
  return !((*src1 ^ *src2) & (~0UL >> (-(nbits) & (64 - 1))));\r
 if (__builtin_constant_p(nbits & (8 - 1)) &&\r
     (((nbits) & ((typeof(nbits))(8) - 1)) == 0))\r
  return !memcmp(src1, src2, nbits / 8);\r
 return __bitmap_equal(src1, src2, nbits);\r
}\r
# 354 "./include/linux/bitmap.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool bitmap_or_equal(const unsigned long *src1,\r
       const unsigned long *src2,\r
       const unsigned long *src3,\r
       unsigned int nbits)\r
{\r
 if (!(__builtin_constant_p(nbits) && (nbits) <= 64 && (nbits) > 0))\r
  return __bitmap_or_equal(src1, src2, src3, nbits);\r
\r
 return !(((*src1 | *src2) ^ *src3) & (~0UL >> (-(nbits) & (64 - 1))));\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int bitmap_intersects(const unsigned long *src1,\r
   const unsigned long *src2, unsigned int nbits)\r
{\r
 if ((__builtin_constant_p(nbits) && (nbits) <= 64 && (nbits) > 0))\r
  return ((*src1 & *src2) & (~0UL >> (-(nbits) & (64 - 1)))) != 0;\r
 else\r
  return __bitmap_intersects(src1, src2, nbits);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int bitmap_subset(const unsigned long *src1,\r
   const unsigned long *src2, unsigned int nbits)\r
{\r
 if ((__builtin_constant_p(nbits) && (nbits) <= 64 && (nbits) > 0))\r
  return ! ((*src1 & ~(*src2)) & (~0UL >> (-(nbits) & (64 - 1))));\r
 else\r
  return __bitmap_subset(src1, src2, nbits);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool bitmap_empty(const unsigned long *src, unsigned nbits)\r
{\r
 if ((__builtin_constant_p(nbits) && (nbits) <= 64 && (nbits) > 0))\r
  return ! (*src & (~0UL >> (-(nbits) & (64 - 1))));\r
\r
 return find_first_bit(src, nbits) == nbits;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool bitmap_full(const unsigned long *src, unsigned int nbits)\r
{\r
 if ((__builtin_constant_p(nbits) && (nbits) <= 64 && (nbits) > 0))\r
  return ! (~(*src) & (~0UL >> (-(nbits) & (64 - 1))));\r
\r
 return find_first_zero_bit(src, nbits) == nbits;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int bitmap_weight(const unsigned long *src, unsigned int nbits)\r
{\r
 if ((__builtin_constant_p(nbits) && (nbits) <= 64 && (nbits) > 0))\r
  return hweight_long(*src & (~0UL >> (-(nbits) & (64 - 1))));\r
 return __bitmap_weight(src, nbits);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void bitmap_set(unsigned long *map, unsigned int start,\r
  unsigned int nbits)\r
{\r
 if (__builtin_constant_p(nbits) && nbits == 1)\r
  arch___set_bit(start, map);\r
 else if (__builtin_constant_p(start & (8 - 1)) &&\r
   (((start) & ((typeof(start))(8) - 1)) == 0) &&\r
   __builtin_constant_p(nbits & (8 - 1)) &&\r
   (((nbits) & ((typeof(nbits))(8) - 1)) == 0))\r
  memset((char *)map + start / 8, 0xff, nbits / 8);\r
 else\r
  __bitmap_set(map, start, nbits);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void bitmap_clear(unsigned long *map, unsigned int start,\r
  unsigned int nbits)\r
{\r
 if (__builtin_constant_p(nbits) && nbits == 1)\r
  arch___clear_bit(start, map);\r
 else if (__builtin_constant_p(start & (8 - 1)) &&\r
   (((start) & ((typeof(start))(8) - 1)) == 0) &&\r
   __builtin_constant_p(nbits & (8 - 1)) &&\r
   (((nbits) & ((typeof(nbits))(8) - 1)) == 0))\r
  memset((char *)map + start / 8, 0, nbits / 8);\r
 else\r
  __bitmap_clear(map, start, nbits);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void bitmap_shift_right(unsigned long *dst, const unsigned long *src,\r
    unsigned int shift, unsigned int nbits)\r
{\r
 if ((__builtin_constant_p(nbits) && (nbits) <= 64 && (nbits) > 0))\r
  *dst = (*src & (~0UL >> (-(nbits) & (64 - 1)))) >> shift;\r
 else\r
  __bitmap_shift_right(dst, src, shift, nbits);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void bitmap_shift_left(unsigned long *dst, const unsigned long *src,\r
    unsigned int shift, unsigned int nbits)\r
{\r
 if ((__builtin_constant_p(nbits) && (nbits) <= 64 && (nbits) > 0))\r
  *dst = (*src << shift) & (~0UL >> (-(nbits) & (64 - 1)));\r
 else\r
  __bitmap_shift_left(dst, src, shift, nbits);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void bitmap_replace(unsigned long *dst,\r
      const unsigned long *old,\r
      const unsigned long *new,\r
      const unsigned long *mask,\r
      unsigned int nbits)\r
{\r
 if ((__builtin_constant_p(nbits) && (nbits) <= 64 && (nbits) > 0))\r
  *dst = (*old & ~(*mask)) | (*new & *mask);\r
 else\r
  __bitmap_replace(dst, old, new, mask, nbits);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void bitmap_next_set_region(unsigned long *bitmap,\r
       unsigned int *rs, unsigned int *re,\r
       unsigned int end)\r
{\r
 *rs = find_next_bit(bitmap, end, *rs);\r
 *re = find_next_zero_bit(bitmap, end, *rs + 1);\r
}\r
# 515 "./include/linux/bitmap.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void bitmap_from_u64(unsigned long *dst, u64 mask)\r
{\r
 dst[0] = mask & (~0UL);\r
\r
 if (sizeof(mask) > sizeof(unsigned long))\r
  dst[1] = mask >> 32;\r
}\r
# 531 "./include/linux/bitmap.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) unsigned long bitmap_get_value8(const unsigned long *map,\r
           unsigned long start)\r
{\r
 const size_t index = ((start) / 64);\r
 const unsigned long offset = start % 64;\r
\r
 return (map[index] >> offset) & 0xFF;\r
}\r
\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void bitmap_set_value8(unsigned long *map, unsigned long value,\r
         unsigned long start)\r
{\r
 const size_t index = ((start) / 64);\r
 const unsigned long offset = start % 64;\r
\r
 map[index] &= ~(0xFFUL << offset);\r
 map[index] |= value << offset;\r
}\r
# 13 "./include/linux/cpumask.h" 2\r
\r
\r
\r
\r
typedef struct cpumask { unsigned long bits[(((32) + ((sizeof(long) * 8)) - 1) / ((sizeof(long) * 8)))]; } cpumask_t;\r
# 39 "./include/linux/cpumask.h"\r
extern unsigned int nr_cpu_ids;\r
# 90 "./include/linux/cpumask.h"\r
extern struct cpumask __cpu_possible_mask;\r
extern struct cpumask __cpu_online_mask;\r
extern struct cpumask __cpu_present_mask;\r
extern struct cpumask __cpu_active_mask;\r
extern struct cpumask __cpu_dying_mask;\r
\r
\r
\r
\r
\r
\r
extern atomic_t __num_online_cpus;\r
\r
extern cpumask_t cpus_booted_once_mask;\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void cpu_max_bits_warn(unsigned int cpu, unsigned int bits)\r
{\r
\r
 ({ int __ret_warn_on = !!(cpu >= bits); if (__builtin_expect(!!(__ret_warn_on), 0)) do { __asm__ __volatile__ ( "1:\n\t" "ebreak\n" ".pushsection __bug_table,\"aw\"\n\t" "2:\n\t" ".word" " 1b - 2b" "\n\t" ".word" " %0 - 2b" "\n\t" ".half" " %1\n\t" ".half" " %2" "\n\t" ".org 2b + %3\n\t" ".popsection" : : "i" ("include/linux/cpumask.h"), "i" (108), "i" ((1 << 0)|((1 << 1) | ((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); __builtin_expect(!!(__ret_warn_on), 0); });\r
\r
}\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) unsigned int cpumask_check(unsigned int cpu)\r
{\r
 cpu_max_bits_warn(cpu, ((unsigned int)32));\r
 return cpu;\r
}\r
# 204 "./include/linux/cpumask.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) unsigned int cpumask_first(const struct cpumask *srcp)\r
{\r
 return find_first_bit(((srcp)->bits), ((unsigned int)32));\r
}\r
\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) unsigned int cpumask_first_zero(const struct cpumask *srcp)\r
{\r
 return find_first_zero_bit(((srcp)->bits), ((unsigned int)32));\r
}\r
# 227 "./include/linux/cpumask.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0)))\r
unsigned int cpumask_first_and(const struct cpumask *srcp1, const struct cpumask *srcp2)\r
{\r
 return find_first_and_bit(((srcp1)->bits), ((srcp2)->bits), ((unsigned int)32));\r
}\r
\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) unsigned int cpumask_last(const struct cpumask *srcp)\r
{\r
 return find_last_bit(((srcp)->bits), ((unsigned int)32));\r
}\r
\r
unsigned int __attribute__((__pure__)) cpumask_next(int n, const struct cpumask *srcp);\r
# 253 "./include/linux/cpumask.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) unsigned int cpumask_next_zero(int n, const struct cpumask *srcp)\r
{\r
\r
 if (n != -1)\r
  cpumask_check(n);\r
 return find_next_zero_bit(((srcp)->bits), ((unsigned int)32), n+1);\r
}\r
\r
int __attribute__((__pure__)) cpumask_next_and(int n, const struct cpumask *, const struct cpumask *);\r
int __attribute__((__pure__)) cpumask_any_but(const struct cpumask *mask, unsigned int cpu);\r
unsigned int cpumask_local_spread(unsigned int i, int node);\r
int cpumask_any_and_distribute(const struct cpumask *src1p,\r
          const struct cpumask *src2p);\r
int cpumask_any_distribute(const struct cpumask *srcp);\r
# 292 "./include/linux/cpumask.h"\r
extern int cpumask_next_wrap(int n, const struct cpumask *mask, int start, bool wrap);\r
# 344 "./include/linux/cpumask.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void cpumask_set_cpu(unsigned int cpu, struct cpumask *dstp)\r
{\r
 set_bit(cpumask_check(cpu), ((dstp)->bits));\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void __cpumask_set_cpu(unsigned int cpu, struct cpumask *dstp)\r
{\r
 arch___set_bit(cpumask_check(cpu), ((dstp)->bits));\r
}\r
\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void cpumask_clear_cpu(int cpu, struct cpumask *dstp)\r
{\r
 clear_bit(cpumask_check(cpu), ((dstp)->bits));\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void __cpumask_clear_cpu(int cpu, struct cpumask *dstp)\r
{\r
 arch___clear_bit(cpumask_check(cpu), ((dstp)->bits));\r
}\r
# 377 "./include/linux/cpumask.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int cpumask_test_cpu(int cpu, const struct cpumask *cpumask)\r
{\r
 return arch_test_bit(cpumask_check(cpu), (((cpumask))->bits));\r
}\r
# 391 "./include/linux/cpumask.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int cpumask_test_and_set_cpu(int cpu, struct cpumask *cpumask)\r
{\r
 return test_and_set_bit(cpumask_check(cpu), ((cpumask)->bits));\r
}\r
# 405 "./include/linux/cpumask.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int cpumask_test_and_clear_cpu(int cpu, struct cpumask *cpumask)\r
{\r
 return test_and_clear_bit(cpumask_check(cpu), ((cpumask)->bits));\r
}\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void cpumask_setall(struct cpumask *dstp)\r
{\r
 bitmap_fill(((dstp)->bits), ((unsigned int)32));\r
}\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void cpumask_clear(struct cpumask *dstp)\r
{\r
 bitmap_zero(((dstp)->bits), ((unsigned int)32));\r
}\r
# 436 "./include/linux/cpumask.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int cpumask_and(struct cpumask *dstp,\r
          const struct cpumask *src1p,\r
          const struct cpumask *src2p)\r
{\r
 return bitmap_and(((dstp)->bits), ((src1p)->bits),\r
           ((src2p)->bits), ((unsigned int)32));\r
}\r
\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void cpumask_or(struct cpumask *dstp, const struct cpumask *src1p,\r
         const struct cpumask *src2p)\r
{\r
 bitmap_or(((dstp)->bits), ((src1p)->bits),\r
          ((src2p)->bits), ((unsigned int)32));\r
}\r
\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void cpumask_xor(struct cpumask *dstp,\r
          const struct cpumask *src1p,\r
          const struct cpumask *src2p)\r
{\r
 bitmap_xor(((dstp)->bits), ((src1p)->bits),\r
           ((src2p)->bits), ((unsigned int)32));\r
}\r
# 479 "./include/linux/cpumask.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int cpumask_andnot(struct cpumask *dstp,\r
      const struct cpumask *src1p,\r
      const struct cpumask *src2p)\r
{\r
 return bitmap_andnot(((dstp)->bits), ((src1p)->bits),\r
       ((src2p)->bits), ((unsigned int)32));\r
}\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void cpumask_complement(struct cpumask *dstp,\r
          const struct cpumask *srcp)\r
{\r
 bitmap_complement(((dstp)->bits), ((srcp)->bits),\r
           ((unsigned int)32));\r
}\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool cpumask_equal(const struct cpumask *src1p,\r
    const struct cpumask *src2p)\r
{\r
 return bitmap_equal(((src1p)->bits), ((src2p)->bits),\r
       ((unsigned int)32));\r
}\r
\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool cpumask_or_equal(const struct cpumask *src1p,\r
        const struct cpumask *src2p,\r
        const struct cpumask *src3p)\r
{\r
 return bitmap_or_equal(((src1p)->bits), ((src2p)->bits),\r
          ((src3p)->bits), ((unsigned int)32));\r
}\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool cpumask_intersects(const struct cpumask *src1p,\r
         const struct cpumask *src2p)\r
{\r
 return bitmap_intersects(((src1p)->bits), ((src2p)->bits),\r
            ((unsigned int)32));\r
}\r
# 544 "./include/linux/cpumask.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int cpumask_subset(const struct cpumask *src1p,\r
     const struct cpumask *src2p)\r
{\r
 return bitmap_subset(((src1p)->bits), ((src2p)->bits),\r
        ((unsigned int)32));\r
}\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool cpumask_empty(const struct cpumask *srcp)\r
{\r
 return bitmap_empty(((srcp)->bits), ((unsigned int)32));\r
}\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool cpumask_full(const struct cpumask *srcp)\r
{\r
 return bitmap_full(((srcp)->bits), ((unsigned int)32));\r
}\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) unsigned int cpumask_weight(const struct cpumask *srcp)\r
{\r
 return bitmap_weight(((srcp)->bits), ((unsigned int)32));\r
}\r
\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void cpumask_shift_right(struct cpumask *dstp,\r
           const struct cpumask *srcp, int n)\r
{\r
 bitmap_shift_right(((dstp)->bits), ((srcp)->bits), n,\r
            ((unsigned int)32));\r
}\r
\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void cpumask_shift_left(struct cpumask *dstp,\r
          const struct cpumask *srcp, int n)\r
{\r
 bitmap_shift_left(((dstp)->bits), ((srcp)->bits), n,\r
           ((unsigned int)32));\r
}\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void cpumask_copy(struct cpumask *dstp,\r
    const struct cpumask *srcp)\r
{\r
 bitmap_copy(((dstp)->bits), ((srcp)->bits), ((unsigned int)32));\r
}\r
# 646 "./include/linux/cpumask.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int cpumask_parse_user(const char *buf, int len,\r
         struct cpumask *dstp)\r
{\r
 return bitmap_parse_user(buf, len, ((dstp)->bits), ((unsigned int)32));\r
}\r
# 660 "./include/linux/cpumask.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int cpumask_parselist_user(const char *buf, int len,\r
         struct cpumask *dstp)\r
{\r
 return bitmap_parselist_user(buf, len, ((dstp)->bits),\r
         ((unsigned int)32));\r
}\r
# 674 "./include/linux/cpumask.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int cpumask_parse(const char *buf, struct cpumask *dstp)\r
{\r
 return bitmap_parse(buf, (~0U), ((dstp)->bits), ((unsigned int)32));\r
}\r
# 686 "./include/linux/cpumask.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int cpulist_parse(const char *buf, struct cpumask *dstp)\r
{\r
 return bitmap_parselist(buf, ((dstp)->bits), ((unsigned int)32));\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) unsigned int cpumask_size(void)\r
{\r
 return (((((unsigned int)32)) + ((sizeof(long) * 8)) - 1) / ((sizeof(long) * 8))) * sizeof(long);\r
}\r
# 759 "./include/linux/cpumask.h"\r
typedef struct cpumask cpumask_var_t[1];\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool alloc_cpumask_var(cpumask_var_t *mask, gfp_t flags)\r
{\r
 return true;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool alloc_cpumask_var_node(cpumask_var_t *mask, gfp_t flags,\r
       int node)\r
{\r
 return true;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool zalloc_cpumask_var(cpumask_var_t *mask, gfp_t flags)\r
{\r
 cpumask_clear(*mask);\r
 return true;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool zalloc_cpumask_var_node(cpumask_var_t *mask, gfp_t flags,\r
       int node)\r
{\r
 cpumask_clear(*mask);\r
 return true;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void alloc_bootmem_cpumask_var(cpumask_var_t *mask)\r
{\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void free_cpumask_var(cpumask_var_t mask)\r
{\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void free_bootmem_cpumask_var(cpumask_var_t mask)\r
{\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool cpumask_available(cpumask_var_t mask)\r
{\r
 return true;\r
}\r
\r
\r
\r
\r
extern const unsigned long cpu_all_bits[(((32) + ((sizeof(long) * 8)) - 1) / ((sizeof(long) * 8)))];\r
# 819 "./include/linux/cpumask.h"\r
void init_cpu_present(const struct cpumask *src);\r
void init_cpu_possible(const struct cpumask *src);\r
void init_cpu_online(const struct cpumask *src);\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void reset_cpu_possible_mask(void)\r
{\r
 bitmap_zero(((&__cpu_possible_mask)->bits), 32);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void\r
set_cpu_possible(unsigned int cpu, bool possible)\r
{\r
 if (possible)\r
  cpumask_set_cpu(cpu, &__cpu_possible_mask);\r
 else\r
  cpumask_clear_cpu(cpu, &__cpu_possible_mask);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void\r
set_cpu_present(unsigned int cpu, bool present)\r
{\r
 if (present)\r
  cpumask_set_cpu(cpu, &__cpu_present_mask);\r
 else\r
  cpumask_clear_cpu(cpu, &__cpu_present_mask);\r
}\r
\r
void set_cpu_online(unsigned int cpu, bool online);\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void\r
set_cpu_active(unsigned int cpu, bool active)\r
{\r
 if (active)\r
  cpumask_set_cpu(cpu, &__cpu_active_mask);\r
 else\r
  cpumask_clear_cpu(cpu, &__cpu_active_mask);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void\r
set_cpu_dying(unsigned int cpu, bool dying)\r
{\r
 if (dying)\r
  cpumask_set_cpu(cpu, &__cpu_dying_mask);\r
 else\r
  cpumask_clear_cpu(cpu, &__cpu_dying_mask);\r
}\r
# 880 "./include/linux/cpumask.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int __check_is_bitmap(const unsigned long *bitmap)\r
{\r
 return 1;\r
}\r
# 892 "./include/linux/cpumask.h"\r
extern const unsigned long\r
 cpu_bit_bitmap[64 +1][(((32) + ((sizeof(long) * 8)) - 1) / ((sizeof(long) * 8)))];\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) const struct cpumask *get_cpu_mask(unsigned int cpu)\r
{\r
 const unsigned long *p = cpu_bit_bitmap[1 + cpu % 64];\r
 p -= cpu / 64;\r
 return ((struct cpumask *)(1 ? (p) : (void *)sizeof(__check_is_bitmap(p))));\r
}\r
# 911 "./include/linux/cpumask.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) unsigned int num_online_cpus(void)\r
{\r
 return atomic_read(&__num_online_cpus);\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool cpu_online(unsigned int cpu)\r
{\r
 return cpumask_test_cpu(cpu, ((const struct cpumask *)&__cpu_online_mask));\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool cpu_possible(unsigned int cpu)\r
{\r
 return cpumask_test_cpu(cpu, ((const struct cpumask *)&__cpu_possible_mask));\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool cpu_present(unsigned int cpu)\r
{\r
 return cpumask_test_cpu(cpu, ((const struct cpumask *)&__cpu_present_mask));\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool cpu_active(unsigned int cpu)\r
{\r
 return cpumask_test_cpu(cpu, ((const struct cpumask *)&__cpu_active_mask));\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool cpu_dying(unsigned int cpu)\r
{\r
 return cpumask_test_cpu(cpu, ((const struct cpumask *)&__cpu_dying_mask));\r
}\r
# 1005 "./include/linux/cpumask.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) ssize_t\r
cpumap_print_to_pagebuf(bool list, char *buf, const struct cpumask *mask)\r
{\r
 return bitmap_print_to_pagebuf(list, buf, ((mask)->bits),\r
          nr_cpu_ids);\r
}\r
# 1028 "./include/linux/cpumask.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) ssize_t\r
cpumap_print_bitmask_to_buf(char *buf, const struct cpumask *mask,\r
  loff_t off, size_t count)\r
{\r
 return bitmap_print_bitmask_to_buf(buf, ((mask)->bits),\r
       nr_cpu_ids, off, count) - 1;\r
}\r
# 1043 "./include/linux/cpumask.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) ssize_t\r
cpumap_print_list_to_buf(char *buf, const struct cpumask *mask,\r
  loff_t off, size_t count)\r
{\r
 return bitmap_print_list_to_buf(buf, ((mask)->bits),\r
       nr_cpu_ids, off, count) - 1;\r
}\r
# 15 "./include/linux/mm_types_task.h" 2\r
# 34 "./include/linux/mm_types_task.h"\r
struct vmacache {\r
 u64 seqnum;\r
 struct vm_area_struct *vmas[(1U << 2)];\r
};\r
\r
\r
\r
\r
\r
enum {\r
 MM_FILEPAGES,\r
 MM_ANONPAGES,\r
 MM_SWAPENTS,\r
 MM_SHMEMPAGES,\r
 NR_MM_COUNTERS\r
};\r
\r
\r
\r
\r
struct task_rss_stat {\r
 int events;\r
 int count[NR_MM_COUNTERS];\r
};\r
\r
\r
struct mm_rss_stat {\r
 atomic_long_t count[NR_MM_COUNTERS];\r
};\r
\r
struct page_frag {\r
 struct page *page;\r
\r
 __u32 offset;\r
 __u32 size;\r
\r
\r
\r
\r
};\r
\r
\r
struct tlbflush_unmap_batch {\r
# 97 "./include/linux/mm_types_task.h"\r
};\r
# 6 "./include/linux/mm_types.h" 2\r
\r
# 1 "./include/linux/auxvec.h" 1\r
\r
\r
\r
\r
# 1 "./include/uapi/linux/auxvec.h" 1\r
\r
\r
\r
\r
# 1 "./arch/riscv/include/uapi/asm/auxvec.h" 1\r
# 6 "./include/uapi/linux/auxvec.h" 2\r
# 6 "./include/linux/auxvec.h" 2\r
# 8 "./include/linux/mm_types.h" 2\r
# 1 "./include/linux/kref.h" 1\r
# 16 "./include/linux/kref.h"\r
# 1 "./include/linux/spinlock.h" 1\r
# 55 "./include/linux/spinlock.h"\r
# 1 "./include/linux/preempt.h" 1\r
# 11 "./include/linux/preempt.h"\r
# 1 "./include/linux/list.h" 1\r
\r
\r
\r
\r
\r
\r
\r
# 1 "./include/linux/poison.h" 1\r
# 9 "./include/linux/list.h" 2\r
# 35 "./include/linux/list.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void INIT_LIST_HEAD(struct list_head *list)\r
{\r
 do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_29(void) ; if (!((sizeof(list->next) == sizeof(char) || sizeof(list->next) == sizeof(short) || sizeof(list->next) == sizeof(int) || sizeof(list->next) == sizeof(long)) || sizeof(list->next) == sizeof(long long))) __compiletime_assert_29(); } while (0); do { *(volatile typeof(list->next) *)&(list->next) = (list); } while (0); } while (0);\r
 list->prev = list;\r
}\r
\r
\r
extern bool __list_add_valid(struct list_head *new,\r
         struct list_head *prev,\r
         struct list_head *next);\r
extern bool __list_del_entry_valid(struct list_head *entry);\r
# 65 "./include/linux/list.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __list_add(struct list_head *new,\r
         struct list_head *prev,\r
         struct list_head *next)\r
{\r
 if (!__list_add_valid(new, prev, next))\r
  return;\r
\r
 next->prev = new;\r
 new->next = next;\r
 new->prev = prev;\r
 do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_30(void) ; if (!((sizeof(prev->next) == sizeof(char) || sizeof(prev->next) == sizeof(short) || sizeof(prev->next) == sizeof(int) || sizeof(prev->next) == sizeof(long)) || sizeof(prev->next) == sizeof(long long))) __compiletime_assert_30(); } while (0); do { *(volatile typeof(prev->next) *)&(prev->next) = (new); } while (0); } while (0);\r
}\r
# 86 "./include/linux/list.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void list_add(struct list_head *new, struct list_head *head)\r
{\r
 __list_add(new, head, head->next);\r
}\r
# 100 "./include/linux/list.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void list_add_tail(struct list_head *new, struct list_head *head)\r
{\r
 __list_add(new, head->prev, head);\r
}\r
# 112 "./include/linux/list.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __list_del(struct list_head * prev, struct list_head * next)\r
{\r
 next->prev = prev;\r
 do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_31(void) ; if (!((sizeof(prev->next) == sizeof(char) || sizeof(prev->next) == sizeof(short) || sizeof(prev->next) == sizeof(int) || sizeof(prev->next) == sizeof(long)) || sizeof(prev->next) == sizeof(long long))) __compiletime_assert_31(); } while (0); do { *(volatile typeof(prev->next) *)&(prev->next) = (next); } while (0); } while (0);\r
}\r
# 126 "./include/linux/list.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __list_del_clearprev(struct list_head *entry)\r
{\r
 __list_del(entry->prev, entry->next);\r
 entry->prev = ((void *)0);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __list_del_entry(struct list_head *entry)\r
{\r
 if (!__list_del_entry_valid(entry))\r
  return;\r
\r
 __list_del(entry->prev, entry->next);\r
}\r
\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void list_del(struct list_head *entry)\r
{\r
 __list_del_entry(entry);\r
 entry->next = ((void *) 0x100 + 0);\r
 entry->prev = ((void *) 0x122 + 0);\r
}\r
# 160 "./include/linux/list.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void list_replace(struct list_head *old,\r
    struct list_head *new)\r
{\r
 new->next = old->next;\r
 new->next->prev = new;\r
 new->prev = old->prev;\r
 new->prev->next = new;\r
}\r
# 176 "./include/linux/list.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void list_replace_init(struct list_head *old,\r
         struct list_head *new)\r
{\r
 list_replace(old, new);\r
 INIT_LIST_HEAD(old);\r
}\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void list_swap(struct list_head *entry1,\r
        struct list_head *entry2)\r
{\r
 struct list_head *pos = entry2->prev;\r
\r
 list_del(entry2);\r
 list_replace(entry1, entry2);\r
 if (pos == entry1)\r
  pos = entry2;\r
 list_add(entry1, pos);\r
}\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void list_del_init(struct list_head *entry)\r
{\r
 __list_del_entry(entry);\r
 INIT_LIST_HEAD(entry);\r
}\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void list_move(struct list_head *list, struct list_head *head)\r
{\r
 __list_del_entry(list);\r
 list_add(list, head);\r
}\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void list_move_tail(struct list_head *list,\r
      struct list_head *head)\r
{\r
 __list_del_entry(list);\r
 list_add_tail(list, head);\r
}\r
# 242 "./include/linux/list.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void list_bulk_move_tail(struct list_head *head,\r
           struct list_head *first,\r
           struct list_head *last)\r
{\r
 first->prev->next = last->next;\r
 last->next->prev = first->prev;\r
\r
 head->prev->next = first;\r
 first->prev = head->prev;\r
\r
 last->next = head;\r
 head->prev = last;\r
}\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int list_is_first(const struct list_head *list, const struct list_head *head)\r
{\r
 return list->prev == head;\r
}\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int list_is_last(const struct list_head *list, const struct list_head *head)\r
{\r
 return list->next == head;\r
}\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int list_is_head(const struct list_head *list, const struct list_head *head)\r
{\r
 return list == head;\r
}\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int list_empty(const struct list_head *head)\r
{\r
 return ({ do { __attribute__((__noreturn__)) extern void __compiletime_assert_32(void) ; if (!((sizeof(head->next) == sizeof(char) || sizeof(head->next) == sizeof(short) || sizeof(head->next) == sizeof(int) || sizeof(head->next) == sizeof(long)) || sizeof(head->next) == sizeof(long long))) __compiletime_assert_32(); } while (0); (*(const volatile typeof( _Generic((head->next), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (head->next))) *)&(head->next)); }) == head;\r
}\r
# 306 "./include/linux/list.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void list_del_init_careful(struct list_head *entry)\r
{\r
 __list_del_entry(entry);\r
 entry->prev = entry;\r
 do { do { } while (0); do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_33(void) ; if (!((sizeof(*&entry->next) == sizeof(char) || sizeof(*&entry->next) == sizeof(short) || sizeof(*&entry->next) == sizeof(int) || sizeof(*&entry->next) == sizeof(long)))) __compiletime_assert_33(); } while (0); __asm__ __volatile__ ("fence " "rw" "," "w" : : : "memory"); do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_34(void) ; if (!((sizeof(*&entry->next) == sizeof(char) || sizeof(*&entry->next) == sizeof(short) || sizeof(*&entry->next) == sizeof(int) || sizeof(*&entry->next) == sizeof(long)) || sizeof(*&entry->next) == sizeof(long long))) __compiletime_assert_34(); } while (0); do { *(volatile typeof(*&entry->next) *)&(*&entry->next) = (entry); } while (0); } while (0); } while (0); } while (0);\r
}\r
# 326 "./include/linux/list.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int list_empty_careful(const struct list_head *head)\r
{\r
 struct list_head *next = ({ typeof(*&head->next) ___p1 = ({ do { __attribute__((__noreturn__)) extern void __compiletime_assert_35(void) ; if (!((sizeof(*&head->next) == sizeof(char) || sizeof(*&head->next) == sizeof(short) || sizeof(*&head->next) == sizeof(int) || sizeof(*&head->next) == sizeof(long)) || sizeof(*&head->next) == sizeof(long long))) __compiletime_assert_35(); } while (0); (*(const volatile typeof( _Generic((*&head->next), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (*&head->next))) *)&(*&head->next)); }); do { __attribute__((__noreturn__)) extern void __compiletime_assert_36(void) ; if (!((sizeof(*&head->next) == sizeof(char) || sizeof(*&head->next) == sizeof(short) || sizeof(*&head->next) == sizeof(int) || sizeof(*&head->next) == sizeof(long)))) __compiletime_assert_36(); } while (0); __asm__ __volatile__ ("fence " "r" "," "rw" : : : "memory"); ___p1; });\r
 return list_is_head(next, head) && (next == head->prev);\r
}\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void list_rotate_left(struct list_head *head)\r
{\r
 struct list_head *first;\r
\r
 if (!list_empty(head)) {\r
  first = head->next;\r
  list_move_tail(first, head);\r
 }\r
}\r
# 353 "./include/linux/list.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void list_rotate_to_front(struct list_head *list,\r
     struct list_head *head)\r
{\r
\r
\r
\r
\r
\r
 list_move_tail(head, list);\r
}\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int list_is_singular(const struct list_head *head)\r
{\r
 return !list_empty(head) && (head->next == head->prev);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __list_cut_position(struct list_head *list,\r
  struct list_head *head, struct list_head *entry)\r
{\r
 struct list_head *new_first = entry->next;\r
 list->next = head->next;\r
 list->next->prev = list;\r
 list->prev = entry;\r
 entry->next = list;\r
 head->next = new_first;\r
 new_first->prev = head;\r
}\r
# 399 "./include/linux/list.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void list_cut_position(struct list_head *list,\r
  struct list_head *head, struct list_head *entry)\r
{\r
 if (list_empty(head))\r
  return;\r
 if (list_is_singular(head) && !list_is_head(entry, head) && (entry != head->next))\r
  return;\r
 if (list_is_head(entry, head))\r
  INIT_LIST_HEAD(list);\r
 else\r
  __list_cut_position(list, head, entry);\r
}\r
# 426 "./include/linux/list.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void list_cut_before(struct list_head *list,\r
       struct list_head *head,\r
       struct list_head *entry)\r
{\r
 if (head->next == entry) {\r
  INIT_LIST_HEAD(list);\r
  return;\r
 }\r
 list->next = head->next;\r
 list->next->prev = list;\r
 list->prev = entry->prev;\r
 list->prev->next = list;\r
 head->next = entry;\r
 entry->prev = head;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __list_splice(const struct list_head *list,\r
     struct list_head *prev,\r
     struct list_head *next)\r
{\r
 struct list_head *first = list->next;\r
 struct list_head *last = list->prev;\r
\r
 first->prev = prev;\r
 prev->next = first;\r
\r
 last->next = next;\r
 next->prev = last;\r
}\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void list_splice(const struct list_head *list,\r
    struct list_head *head)\r
{\r
 if (!list_empty(list))\r
  __list_splice(list, head, head->next);\r
}\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void list_splice_tail(struct list_head *list,\r
    struct list_head *head)\r
{\r
 if (!list_empty(list))\r
  __list_splice(list, head->prev, head);\r
}\r
# 487 "./include/linux/list.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void list_splice_init(struct list_head *list,\r
        struct list_head *head)\r
{\r
 if (!list_empty(list)) {\r
  __list_splice(list, head, head->next);\r
  INIT_LIST_HEAD(list);\r
 }\r
}\r
# 504 "./include/linux/list.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void list_splice_tail_init(struct list_head *list,\r
      struct list_head *head)\r
{\r
 if (!list_empty(list)) {\r
  __list_splice(list, head->prev, head);\r
  INIT_LIST_HEAD(list);\r
 }\r
}\r
# 802 "./include/linux/list.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void INIT_HLIST_NODE(struct hlist_node *h)\r
{\r
 h->next = ((void *)0);\r
 h->pprev = ((void *)0);\r
}\r
# 816 "./include/linux/list.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int hlist_unhashed(const struct hlist_node *h)\r
{\r
 return !h->pprev;\r
}\r
# 829 "./include/linux/list.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int hlist_unhashed_lockless(const struct hlist_node *h)\r
{\r
 return !({ do { __attribute__((__noreturn__)) extern void __compiletime_assert_37(void) ; if (!((sizeof(h->pprev) == sizeof(char) || sizeof(h->pprev) == sizeof(short) || sizeof(h->pprev) == sizeof(int) || sizeof(h->pprev) == sizeof(long)) || sizeof(h->pprev) == sizeof(long long))) __compiletime_assert_37(); } while (0); (*(const volatile typeof( _Generic((h->pprev), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (h->pprev))) *)&(h->pprev)); });\r
}\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int hlist_empty(const struct hlist_head *h)\r
{\r
 return !({ do { __attribute__((__noreturn__)) extern void __compiletime_assert_38(void) ; if (!((sizeof(h->first) == sizeof(char) || sizeof(h->first) == sizeof(short) || sizeof(h->first) == sizeof(int) || sizeof(h->first) == sizeof(long)) || sizeof(h->first) == sizeof(long long))) __compiletime_assert_38(); } while (0); (*(const volatile typeof( _Generic((h->first), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (h->first))) *)&(h->first)); });\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __hlist_del(struct hlist_node *n)\r
{\r
 struct hlist_node *next = n->next;\r
 struct hlist_node **pprev = n->pprev;\r
\r
 do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_39(void) ; if (!((sizeof(*pprev) == sizeof(char) || sizeof(*pprev) == sizeof(short) || sizeof(*pprev) == sizeof(int) || sizeof(*pprev) == sizeof(long)) || sizeof(*pprev) == sizeof(long long))) __compiletime_assert_39(); } while (0); do { *(volatile typeof(*pprev) *)&(*pprev) = (next); } while (0); } while (0);\r
 if (next)\r
  do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_40(void) ; if (!((sizeof(next->pprev) == sizeof(char) || sizeof(next->pprev) == sizeof(short) || sizeof(next->pprev) == sizeof(int) || sizeof(next->pprev) == sizeof(long)) || sizeof(next->pprev) == sizeof(long long))) __compiletime_assert_40(); } while (0); do { *(volatile typeof(next->pprev) *)&(next->pprev) = (pprev); } while (0); } while (0);\r
}\r
# 860 "./include/linux/list.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void hlist_del(struct hlist_node *n)\r
{\r
 __hlist_del(n);\r
 n->next = ((void *) 0x100 + 0);\r
 n->pprev = ((void *) 0x122 + 0);\r
}\r
\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void hlist_del_init(struct hlist_node *n)\r
{\r
 if (!hlist_unhashed(n)) {\r
  __hlist_del(n);\r
  INIT_HLIST_NODE(n);\r
 }\r
}\r
# 889 "./include/linux/list.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void hlist_add_head(struct hlist_node *n, struct hlist_head *h)\r
{\r
 struct hlist_node *first = h->first;\r
 do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_41(void) ; if (!((sizeof(n->next) == sizeof(char) || sizeof(n->next) == sizeof(short) || sizeof(n->next) == sizeof(int) || sizeof(n->next) == sizeof(long)) || sizeof(n->next) == sizeof(long long))) __compiletime_assert_41(); } while (0); do { *(volatile typeof(n->next) *)&(n->next) = (first); } while (0); } while (0);\r
 if (first)\r
  do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_42(void) ; if (!((sizeof(first->pprev) == sizeof(char) || sizeof(first->pprev) == sizeof(short) || sizeof(first->pprev) == sizeof(int) || sizeof(first->pprev) == sizeof(long)) || sizeof(first->pprev) == sizeof(long long))) __compiletime_assert_42(); } while (0); do { *(volatile typeof(first->pprev) *)&(first->pprev) = (&n->next); } while (0); } while (0);\r
 do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_43(void) ; if (!((sizeof(h->first) == sizeof(char) || sizeof(h->first) == sizeof(short) || sizeof(h->first) == sizeof(int) || sizeof(h->first) == sizeof(long)) || sizeof(h->first) == sizeof(long long))) __compiletime_assert_43(); } while (0); do { *(volatile typeof(h->first) *)&(h->first) = (n); } while (0); } while (0);\r
 do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_44(void) ; if (!((sizeof(n->pprev) == sizeof(char) || sizeof(n->pprev) == sizeof(short) || sizeof(n->pprev) == sizeof(int) || sizeof(n->pprev) == sizeof(long)) || sizeof(n->pprev) == sizeof(long long))) __compiletime_assert_44(); } while (0); do { *(volatile typeof(n->pprev) *)&(n->pprev) = (&h->first); } while (0); } while (0);\r
}\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void hlist_add_before(struct hlist_node *n,\r
        struct hlist_node *next)\r
{\r
 do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_45(void) ; if (!((sizeof(n->pprev) == sizeof(char) || sizeof(n->pprev) == sizeof(short) || sizeof(n->pprev) == sizeof(int) || sizeof(n->pprev) == sizeof(long)) || sizeof(n->pprev) == sizeof(long long))) __compiletime_assert_45(); } while (0); do { *(volatile typeof(n->pprev) *)&(n->pprev) = (next->pprev); } while (0); } while (0);\r
 do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_46(void) ; if (!((sizeof(n->next) == sizeof(char) || sizeof(n->next) == sizeof(short) || sizeof(n->next) == sizeof(int) || sizeof(n->next) == sizeof(long)) || sizeof(n->next) == sizeof(long long))) __compiletime_assert_46(); } while (0); do { *(volatile typeof(n->next) *)&(n->next) = (next); } while (0); } while (0);\r
 do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_47(void) ; if (!((sizeof(next->pprev) == sizeof(char) || sizeof(next->pprev) == sizeof(short) || sizeof(next->pprev) == sizeof(int) || sizeof(next->pprev) == sizeof(long)) || sizeof(next->pprev) == sizeof(long long))) __compiletime_assert_47(); } while (0); do { *(volatile typeof(next->pprev) *)&(next->pprev) = (&n->next); } while (0); } while (0);\r
 do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_48(void) ; if (!((sizeof(*(n->pprev)) == sizeof(char) || sizeof(*(n->pprev)) == sizeof(short) || sizeof(*(n->pprev)) == sizeof(int) || sizeof(*(n->pprev)) == sizeof(long)) || sizeof(*(n->pprev)) == sizeof(long long))) __compiletime_assert_48(); } while (0); do { *(volatile typeof(*(n->pprev)) *)&(*(n->pprev)) = (n); } while (0); } while (0);\r
}\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void hlist_add_behind(struct hlist_node *n,\r
        struct hlist_node *prev)\r
{\r
 do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_49(void) ; if (!((sizeof(n->next) == sizeof(char) || sizeof(n->next) == sizeof(short) || sizeof(n->next) == sizeof(int) || sizeof(n->next) == sizeof(long)) || sizeof(n->next) == sizeof(long long))) __compiletime_assert_49(); } while (0); do { *(volatile typeof(n->next) *)&(n->next) = (prev->next); } while (0); } while (0);\r
 do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_50(void) ; if (!((sizeof(prev->next) == sizeof(char) || sizeof(prev->next) == sizeof(short) || sizeof(prev->next) == sizeof(int) || sizeof(prev->next) == sizeof(long)) || sizeof(prev->next) == sizeof(long long))) __compiletime_assert_50(); } while (0); do { *(volatile typeof(prev->next) *)&(prev->next) = (n); } while (0); } while (0);\r
 do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_51(void) ; if (!((sizeof(n->pprev) == sizeof(char) || sizeof(n->pprev) == sizeof(short) || sizeof(n->pprev) == sizeof(int) || sizeof(n->pprev) == sizeof(long)) || sizeof(n->pprev) == sizeof(long long))) __compiletime_assert_51(); } while (0); do { *(volatile typeof(n->pprev) *)&(n->pprev) = (&prev->next); } while (0); } while (0);\r
\r
 if (n->next)\r
  do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_52(void) ; if (!((sizeof(n->next->pprev) == sizeof(char) || sizeof(n->next->pprev) == sizeof(short) || sizeof(n->next->pprev) == sizeof(int) || sizeof(n->next->pprev) == sizeof(long)) || sizeof(n->next->pprev) == sizeof(long long))) __compiletime_assert_52(); } while (0); do { *(volatile typeof(n->next->pprev) *)&(n->next->pprev) = (&n->next); } while (0); } while (0);\r
}\r
# 937 "./include/linux/list.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void hlist_add_fake(struct hlist_node *n)\r
{\r
 n->pprev = &n->next;\r
}\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool hlist_fake(struct hlist_node *h)\r
{\r
 return h->pprev == &h->next;\r
}\r
# 959 "./include/linux/list.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool\r
hlist_is_singular_node(struct hlist_node *n, struct hlist_head *h)\r
{\r
 return !n->next && n->pprev == &h->first;\r
}\r
# 973 "./include/linux/list.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void hlist_move_list(struct hlist_head *old,\r
       struct hlist_head *new)\r
{\r
 new->first = old->first;\r
 if (new->first)\r
  new->first->pprev = &new->first;\r
 old->first = ((void *)0);\r
}\r
# 12 "./include/linux/preempt.h" 2\r
# 78 "./include/linux/preempt.h"\r
# 1 "./arch/riscv/include/generated/asm/preempt.h" 1\r
# 1 "./include/asm-generic/preempt.h" 1\r
\r
\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int preempt_count(void)\r
{\r
 return ({ do { __attribute__((__noreturn__)) extern void __compiletime_assert_53(void) ; if (!((sizeof(((struct thread_info *)get_current())->preempt_count) == sizeof(char) || sizeof(((struct thread_info *)get_current())->preempt_count) == sizeof(short) || sizeof(((struct thread_info *)get_current())->preempt_count) == sizeof(int) || sizeof(((struct thread_info *)get_current())->preempt_count) == sizeof(long)) || sizeof(((struct thread_info *)get_current())->preempt_count) == sizeof(long long))) __compiletime_assert_53(); } while (0); (*(const volatile typeof( _Generic((((struct thread_info *)get_current())->preempt_count), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (((struct thread_info *)get_current())->preempt_count))) *)&(((struct thread_info *)get_current())->preempt_count)); });\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) volatile int *preempt_count_ptr(void)\r
{\r
 return &((struct thread_info *)get_current())->preempt_count;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void preempt_count_set(int pc)\r
{\r
 *preempt_count_ptr() = pc;\r
}\r
# 35 "./include/asm-generic/preempt.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void set_preempt_need_resched(void)\r
{\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void clear_preempt_need_resched(void)\r
{\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool test_preempt_need_resched(void)\r
{\r
 return false;\r
}\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void __preempt_count_add(int val)\r
{\r
 *preempt_count_ptr() += val;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void __preempt_count_sub(int val)\r
{\r
 *preempt_count_ptr() -= val;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool __preempt_count_dec_and_test(void)\r
{\r
\r
\r
\r
\r
\r
 return !--*preempt_count_ptr() && test_ti_thread_flag(((struct thread_info *)get_current()), 3);\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool should_resched(int preempt_offset)\r
{\r
 return __builtin_expect(!!(preempt_count() == preempt_offset && test_ti_thread_flag(((struct thread_info *)get_current()), 3)), 0);\r
\r
}\r
# 2 "./arch/riscv/include/generated/asm/preempt.h" 2\r
# 79 "./include/linux/preempt.h" 2\r
# 89 "./include/linux/preempt.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) unsigned char interrupt_context_level(void)\r
{\r
 unsigned long pc = preempt_count();\r
 unsigned char level = 0;\r
\r
 level += !!(pc & ((((1UL << (4))-1) << (((0 + 8) + 8) + 4))));\r
 level += !!(pc & ((((1UL << (4))-1) << (((0 + 8) + 8) + 4)) | (((1UL << (4))-1) << ((0 + 8) + 8))));\r
 level += !!(pc & ((((1UL << (4))-1) << (((0 + 8) + 8) + 4)) | (((1UL << (4))-1) << ((0 + 8) + 8)) | (1UL << (0 + 8))));\r
\r
 return level;\r
}\r
# 309 "./include/linux/preempt.h"\r
struct preempt_notifier;\r
# 325 "./include/linux/preempt.h"\r
struct preempt_ops {\r
 void (*sched_in)(struct preempt_notifier *notifier, int cpu);\r
 void (*sched_out)(struct preempt_notifier *notifier,\r
     struct task_struct *next);\r
};\r
# 338 "./include/linux/preempt.h"\r
struct preempt_notifier {\r
 struct hlist_node link;\r
 struct preempt_ops *ops;\r
};\r
\r
void preempt_notifier_inc(void);\r
void preempt_notifier_dec(void);\r
void preempt_notifier_register(struct preempt_notifier *notifier);\r
void preempt_notifier_unregister(struct preempt_notifier *notifier);\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void preempt_notifier_init(struct preempt_notifier *notifier,\r
         struct preempt_ops *ops)\r
{\r
 INIT_HLIST_NODE(&notifier->link);\r
 notifier->ops = ops;\r
}\r
# 414 "./include/linux/preempt.h"\r
extern void migrate_disable(void);\r
extern void migrate_enable(void);\r
# 56 "./include/linux/spinlock.h" 2\r
\r
\r
\r
\r
\r
# 1 "./include/linux/bottom_half.h" 1\r
\r
\r
\r
\r
\r
\r
\r
\r
extern void __local_bh_disable_ip(unsigned long ip, unsigned int cnt);\r
# 18 "./include/linux/bottom_half.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void local_bh_disable(void)\r
{\r
 __local_bh_disable_ip(({ __label__ __here; __here: (unsigned long)&&__here; }), (2 * (1UL << (0 + 8))));\r
}\r
\r
extern void _local_bh_enable(void);\r
extern void __local_bh_enable_ip(unsigned long ip, unsigned int cnt);\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void local_bh_enable_ip(unsigned long ip)\r
{\r
 __local_bh_enable_ip(ip, (2 * (1UL << (0 + 8))));\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void local_bh_enable(void)\r
{\r
 __local_bh_enable_ip(({ __label__ __here; __here: (unsigned long)&&__here; }), (2 * (1UL << (0 + 8))));\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool local_bh_blocked(void) { return false; }\r
# 62 "./include/linux/spinlock.h" 2\r
# 1 "./include/linux/lockdep.h" 1\r
# 14 "./include/linux/lockdep.h"\r
# 1 "./include/linux/smp.h" 1\r
# 15 "./include/linux/smp.h"\r
# 1 "./include/linux/smp_types.h" 1\r
\r
\r
\r
\r
# 1 "./include/linux/llist.h" 1\r
# 56 "./include/linux/llist.h"\r
struct llist_head {\r
 struct llist_node *first;\r
};\r
\r
struct llist_node {\r
 struct llist_node *next;\r
};\r
# 71 "./include/linux/llist.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void init_llist_head(struct llist_head *list)\r
{\r
 list->first = ((void *)0);\r
}\r
# 189 "./include/linux/llist.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool llist_empty(const struct llist_head *head)\r
{\r
 return ({ do { __attribute__((__noreturn__)) extern void __compiletime_assert_54(void) ; if (!((sizeof(head->first) == sizeof(char) || sizeof(head->first) == sizeof(short) || sizeof(head->first) == sizeof(int) || sizeof(head->first) == sizeof(long)) || sizeof(head->first) == sizeof(long long))) __compiletime_assert_54(); } while (0); (*(const volatile typeof( _Generic((head->first), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (head->first))) *)&(head->first)); }) == ((void *)0);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) struct llist_node *llist_next(struct llist_node *node)\r
{\r
 return node->next;\r
}\r
\r
extern bool llist_add_batch(struct llist_node *new_first,\r
       struct llist_node *new_last,\r
       struct llist_head *head);\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool __llist_add_batch(struct llist_node *new_first,\r
         struct llist_node *new_last,\r
         struct llist_head *head)\r
{\r
 new_last->next = head->first;\r
 head->first = new_first;\r
 return new_last->next == ((void *)0);\r
}\r
# 219 "./include/linux/llist.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool llist_add(struct llist_node *new, struct llist_head *head)\r
{\r
 return llist_add_batch(new, new, head);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool __llist_add(struct llist_node *new, struct llist_head *head)\r
{\r
 return __llist_add_batch(new, new, head);\r
}\r
# 237 "./include/linux/llist.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) struct llist_node *llist_del_all(struct llist_head *head)\r
{\r
 return ({ typeof(&head->first) __ai_ptr = (&head->first); do { } while (0); instrument_atomic_write(__ai_ptr, sizeof(*__ai_ptr)); ({ __typeof__(*(__ai_ptr)) _x_ = (((void *)0)); (__typeof__(*(__ai_ptr))) ({ __typeof__((__ai_ptr)) __ptr = ((__ai_ptr)); __typeof__(_x_) __new = (_x_); __typeof__(*((__ai_ptr))) __ret; switch (sizeof(*(__ai_ptr))) { case 4: __asm__ __volatile__ ( "	amoswap.w.aqrl %0, %2, %1\n" : "=r" (__ret), "+A" (*__ptr) : "r" (__new) : "memory"); break; case 8: __asm__ __volatile__ ( "	amoswap.d.aqrl %0, %2, %1\n" : "=r" (__ret), "+A" (*__ptr) : "r" (__new) : "memory"); break; default: do { __attribute__((__noreturn__)) extern void __compiletime_assert_55(void) ; if (!(!(1))) __compiletime_assert_55(); } while (0); } __ret; }); }); });\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) struct llist_node *__llist_del_all(struct llist_head *head)\r
{\r
 struct llist_node *first = head->first;\r
\r
 head->first = ((void *)0);\r
 return first;\r
}\r
\r
extern struct llist_node *llist_del_first(struct llist_head *head);\r
\r
struct llist_node *llist_reverse_order(struct llist_node *head);\r
# 6 "./include/linux/smp_types.h" 2\r
\r
enum {\r
 CSD_FLAG_LOCK = 0x01,\r
\r
 IRQ_WORK_PENDING = 0x01,\r
 IRQ_WORK_BUSY = 0x02,\r
 IRQ_WORK_LAZY = 0x04,\r
 IRQ_WORK_HARD_IRQ = 0x08,\r
\r
 IRQ_WORK_CLAIMED = (IRQ_WORK_PENDING | IRQ_WORK_BUSY),\r
\r
 CSD_TYPE_ASYNC = 0x00,\r
 CSD_TYPE_SYNC = 0x10,\r
 CSD_TYPE_IRQ_WORK = 0x20,\r
 CSD_TYPE_TTWU = 0x30,\r
\r
 CSD_FLAG_TYPE_MASK = 0xF0,\r
};\r
# 58 "./include/linux/smp_types.h"\r
struct __call_single_node {\r
 struct llist_node llist;\r
 union {\r
  unsigned int u_flags;\r
  atomic_t a_flags;\r
 };\r
\r
 u16 src, dst;\r
\r
};\r
# 16 "./include/linux/smp.h" 2\r
\r
typedef void (*smp_call_func_t)(void *info);\r
typedef bool (*smp_cond_func_t)(int cpu, void *info);\r
\r
\r
\r
\r
struct __call_single_data {\r
 struct __call_single_node node;\r
 smp_call_func_t func;\r
 void *info;\r
};\r
\r
\r
\r
\r
\r
typedef struct __call_single_data call_single_data_t\r
 __attribute__((__aligned__(sizeof(struct __call_single_data))));\r
# 45 "./include/linux/smp.h"\r
extern void __smp_call_single_queue(int cpu, struct llist_node *node);\r
\r
\r
extern unsigned int total_cpus;\r
\r
int smp_call_function_single(int cpuid, smp_call_func_t func, void *info,\r
        int wait);\r
\r
void on_each_cpu_cond_mask(smp_cond_func_t cond_func, smp_call_func_t func,\r
      void *info, bool wait, const struct cpumask *mask);\r
\r
int smp_call_function_single_async(int cpu, struct __call_single_data *csd);\r
\r
\r
\r
\r
\r
void panic_smp_self_stop(void);\r
void nmi_panic_self_stop(struct pt_regs *regs);\r
void crash_smp_send_stop(void);\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void on_each_cpu(smp_call_func_t func, void *info, int wait)\r
{\r
 on_each_cpu_cond_mask(((void *)0), func, info, wait, ((const struct cpumask *)&__cpu_online_mask));\r
}\r
# 90 "./include/linux/smp.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void on_each_cpu_mask(const struct cpumask *mask,\r
        smp_call_func_t func, void *info, bool wait)\r
{\r
 on_each_cpu_cond_mask(((void *)0), func, info, wait, mask);\r
}\r
\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void on_each_cpu_cond(smp_cond_func_t cond_func,\r
        smp_call_func_t func, void *info, bool wait)\r
{\r
 on_each_cpu_cond_mask(cond_func, func, info, wait, ((const struct cpumask *)&__cpu_online_mask));\r
}\r
\r
\r
\r
\r
\r
\r
\r
# 1 "./arch/riscv/include/asm/smp.h" 1\r
# 10 "./arch/riscv/include/asm/smp.h"\r
# 1 "./include/linux/irqreturn.h" 1\r
# 11 "./include/linux/irqreturn.h"\r
enum irqreturn {\r
 IRQ_NONE = (0 << 0),\r
 IRQ_HANDLED = (1 << 0),\r
 IRQ_WAKE_THREAD = (1 << 1),\r
};\r
\r
typedef enum irqreturn irqreturn_t;\r
# 11 "./arch/riscv/include/asm/smp.h" 2\r
\r
\r
\r
\r
struct seq_file;\r
extern unsigned long boot_cpu_hartid;\r
\r
struct riscv_ipi_ops {\r
 void (*ipi_inject)(const struct cpumask *target);\r
 void (*ipi_clear)(void);\r
};\r
\r
\r
\r
\r
\r
extern unsigned long __cpuid_to_hartid_map[32];\r
\r
\r
\r
void show_ipi_stats(struct seq_file *p, int prec);\r
\r
\r
void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((__no_sanitize__("cfi"))) setup_smp(void);\r
\r
\r
void handle_IPI(struct pt_regs *regs);\r
\r
\r
void arch_send_call_function_ipi_mask(struct cpumask *mask);\r
\r
\r
void arch_send_call_function_single_ipi(int cpu);\r
\r
int riscv_hartid_to_cpuid(int hartid);\r
\r
\r
void riscv_set_ipi_ops(const struct riscv_ipi_ops *ops);\r
\r
\r
void riscv_clear_ipi(void);\r
\r
\r
           void smp_callin(void);\r
# 63 "./arch/riscv/include/asm/smp.h"\r
int __cpu_disable(void);\r
void __cpu_die(unsigned int cpu);\r
# 96 "./arch/riscv/include/asm/smp.h"\r
bool cpu_has_hotplug(unsigned int cpu);\r
# 114 "./include/linux/smp.h" 2\r
# 123 "./include/linux/smp.h"\r
extern void smp_send_stop(void);\r
\r
\r
\r
\r
extern void smp_send_reschedule(int cpu);\r
\r
\r
\r
\r
\r
extern void smp_prepare_cpus(unsigned int max_cpus);\r
\r
\r
\r
\r
extern int __cpu_up(unsigned int cpunum, struct task_struct *tidle);\r
\r
\r
\r
\r
extern void smp_cpus_done(unsigned int max_cpus);\r
\r
\r
\r
\r
void smp_call_function(smp_call_func_t func, void *info, int wait);\r
void smp_call_function_many(const struct cpumask *mask,\r
       smp_call_func_t func, void *info, bool wait);\r
\r
int smp_call_function_any(const struct cpumask *mask,\r
     smp_call_func_t func, void *info, int wait);\r
\r
void kick_all_cpus_sync(void);\r
void wake_up_all_idle_cpus(void);\r
\r
\r
\r
\r
void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((__no_sanitize__("cfi"))) call_function_init(void);\r
void generic_smp_call_function_single_interrupt(void);\r
\r
\r
\r
\r
\r
\r
\r
void smp_prepare_boot_cpu(void);\r
\r
extern unsigned int setup_max_cpus;\r
extern void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((__no_sanitize__("cfi"))) setup_nr_cpu_ids(void);\r
extern void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((__no_sanitize__("cfi"))) smp_init(void);\r
\r
extern int __boot_cpu_id;\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int get_boot_cpu_id(void)\r
{\r
 return __boot_cpu_id;\r
}\r
# 274 "./include/linux/smp.h"\r
extern void arch_disable_smp_support(void);\r
\r
extern void arch_thaw_secondary_cpus_begin(void);\r
extern void arch_thaw_secondary_cpus_end(void);\r
\r
void smp_setup_processor_id(void);\r
\r
int smp_call_on_cpu(unsigned int cpu, int (*func)(void *), void *par,\r
      bool phys);\r
\r
\r
int smpcfd_prepare_cpu(unsigned int cpu);\r
int smpcfd_dead_cpu(unsigned int cpu);\r
int smpcfd_dying_cpu(unsigned int cpu);\r
# 15 "./include/linux/lockdep.h" 2\r
# 1 "./arch/riscv/include/generated/asm/percpu.h" 1\r
# 16 "./include/linux/lockdep.h" 2\r
\r
struct task_struct;\r
\r
\r
extern int prove_locking;\r
extern int lock_stat;\r
\r
\r
\r
\r
\r
\r
# 1 "./include/linux/debug_locks.h" 1\r
\r
\r
\r
\r
\r
\r
\r
struct task_struct;\r
\r
extern int debug_locks ;\r
extern int debug_locks_silent ;\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int __debug_locks_off(void)\r
{\r
 return ({ typeof(&debug_locks) __ai_ptr = (&debug_locks); do { } while (0); instrument_atomic_write(__ai_ptr, sizeof(*__ai_ptr)); ({ __typeof__(*(__ai_ptr)) _x_ = (0); (__typeof__(*(__ai_ptr))) ({ __typeof__((__ai_ptr)) __ptr = ((__ai_ptr)); __typeof__(_x_) __new = (_x_); __typeof__(*((__ai_ptr))) __ret; switch (sizeof(*(__ai_ptr))) { case 4: __asm__ __volatile__ ( "	amoswap.w.aqrl %0, %2, %1\n" : "=r" (__ret), "+A" (*__ptr) : "r" (__new) : "memory"); break; case 8: __asm__ __volatile__ ( "	amoswap.d.aqrl %0, %2, %1\n" : "=r" (__ret), "+A" (*__ptr) : "r" (__new) : "memory"); break; default: do { __attribute__((__noreturn__)) extern void __compiletime_assert_56(void) ; if (!(!(1))) __compiletime_assert_56(); } while (0); } __ret; }); }); });\r
}\r
\r
\r
\r
\r
extern int debug_locks_off(void);\r
# 51 "./include/linux/debug_locks.h"\r
extern void debug_show_all_locks(void);\r
extern void debug_show_held_locks(struct task_struct *task);\r
extern void debug_check_no_locks_freed(const void *from, unsigned long len);\r
extern void debug_check_no_locks_held(void);\r
# 28 "./include/linux/lockdep.h" 2\r
# 1 "./include/linux/stacktrace.h" 1\r
\r
\r
\r
\r
\r
# 1 "./arch/riscv/include/generated/uapi/asm/errno.h" 1\r
# 7 "./include/linux/stacktrace.h" 2\r
\r
struct task_struct;\r
struct pt_regs;\r
# 21 "./include/linux/stacktrace.h"\r
typedef bool (*stack_trace_consume_fn)(void *cookie, unsigned long addr);\r
# 38 "./include/linux/stacktrace.h"\r
void arch_stack_walk(stack_trace_consume_fn consume_entry, void *cookie,\r
       struct task_struct *task, struct pt_regs *regs);\r
# 58 "./include/linux/stacktrace.h"\r
int arch_stack_walk_reliable(stack_trace_consume_fn consume_entry, void *cookie,\r
        struct task_struct *task);\r
\r
void arch_stack_walk_user(stack_trace_consume_fn consume_entry, void *cookie,\r
     const struct pt_regs *regs);\r
\r
\r
\r
void stack_trace_print(const unsigned long *trace, unsigned int nr_entries,\r
         int spaces);\r
int stack_trace_snprint(char *buf, size_t size, const unsigned long *entries,\r
   unsigned int nr_entries, int spaces);\r
unsigned int stack_trace_save(unsigned long *store, unsigned int size,\r
         unsigned int skipnr);\r
unsigned int stack_trace_save_tsk(struct task_struct *task,\r
      unsigned long *store, unsigned int size,\r
      unsigned int skipnr);\r
unsigned int stack_trace_save_regs(struct pt_regs *regs, unsigned long *store,\r
       unsigned int size, unsigned int skipnr);\r
unsigned int stack_trace_save_user(unsigned long *store, unsigned int size);\r
unsigned int filter_irq_stacks(unsigned long *entries, unsigned int nr_entries);\r
# 103 "./include/linux/stacktrace.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int stack_trace_save_tsk_reliable(struct task_struct *tsk,\r
      unsigned long *store,\r
      unsigned int size)\r
{\r
 return -38;\r
}\r
# 29 "./include/linux/lockdep.h" 2\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void lockdep_copy_map(struct lockdep_map *to,\r
        struct lockdep_map *from)\r
{\r
 int i;\r
\r
 *to = *from;\r
# 44 "./include/linux/lockdep.h"\r
 for (i = 0; i < 2; i++)\r
  to->class_cache[i] = ((void *)0);\r
}\r
\r
\r
\r
\r
\r
struct lock_list {\r
 struct list_head entry;\r
 struct lock_class *class;\r
 struct lock_class *links_to;\r
 const struct lock_trace *trace;\r
 u16 distance;\r
\r
 u8 dep;\r
\r
 u8 only_xr;\r
\r
\r
\r
\r
\r
 struct lock_list *parent;\r
};\r
# 79 "./include/linux/lockdep.h"\r
struct lock_chain {\r
\r
 unsigned int irq_context : 2,\r
     depth : 6,\r
     base : 24;\r
\r
 struct hlist_node entry;\r
 u64 chain_key;\r
};\r
\r
\r
\r
\r
\r
struct held_lock {\r
# 108 "./include/linux/lockdep.h"\r
 u64 prev_chain_key;\r
 unsigned long acquire_ip;\r
 struct lockdep_map *instance;\r
 struct lockdep_map *nest_lock;\r
# 121 "./include/linux/lockdep.h"\r
 unsigned int class_idx:13;\r
# 135 "./include/linux/lockdep.h"\r
 unsigned int irq_context:2;\r
 unsigned int trylock:1;\r
\r
 unsigned int read:2;\r
 unsigned int check:1;\r
 unsigned int hardirqs_off:1;\r
 unsigned int references:12;\r
 unsigned int pin_count;\r
};\r
\r
\r
\r
\r
extern void lockdep_init(void);\r
extern void lockdep_reset(void);\r
extern void lockdep_reset_lock(struct lockdep_map *lock);\r
extern void lockdep_free_key_range(void *start, unsigned long size);\r
extern void lockdep_sys_exit(void);\r
extern void lockdep_set_selftest_task(struct task_struct *task);\r
\r
extern void lockdep_init_task(struct task_struct *task);\r
# 179 "./include/linux/lockdep.h"\r
extern void lockdep_register_key(struct lock_class_key *key);\r
extern void lockdep_unregister_key(struct lock_class_key *key);\r
\r
\r
\r
\r
\r
\r
\r
extern void lockdep_init_map_type(struct lockdep_map *lock, const char *name,\r
 struct lock_class_key *key, int subclass, u8 inner, u8 outer, u8 lock_type);\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void\r
lockdep_init_map_waits(struct lockdep_map *lock, const char *name,\r
         struct lock_class_key *key, int subclass, u8 inner, u8 outer)\r
{\r
 lockdep_init_map_type(lock, name, key, subclass, inner, LD_WAIT_INV, LD_LOCK_NORMAL);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void\r
lockdep_init_map_wait(struct lockdep_map *lock, const char *name,\r
        struct lock_class_key *key, int subclass, u8 inner)\r
{\r
 lockdep_init_map_waits(lock, name, key, subclass, inner, LD_WAIT_INV);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void lockdep_init_map(struct lockdep_map *lock, const char *name,\r
        struct lock_class_key *key, int subclass)\r
{\r
 lockdep_init_map_wait(lock, name, key, subclass, LD_WAIT_INV);\r
}\r
# 245 "./include/linux/lockdep.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int lockdep_match_key(struct lockdep_map *lock,\r
        struct lock_class_key *key)\r
{\r
 return lock->key == key;\r
}\r
# 265 "./include/linux/lockdep.h"\r
extern void lock_acquire(struct lockdep_map *lock, unsigned int subclass,\r
    int trylock, int read, int check,\r
    struct lockdep_map *nest_lock, unsigned long ip);\r
\r
extern void lock_release(struct lockdep_map *lock, unsigned long ip);\r
# 279 "./include/linux/lockdep.h"\r
extern int lock_is_held_type(const struct lockdep_map *lock, int read);\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int lock_is_held(const struct lockdep_map *lock)\r
{\r
 return lock_is_held_type(lock, -1);\r
}\r
\r
\r
\r
\r
extern void lock_set_class(struct lockdep_map *lock, const char *name,\r
      struct lock_class_key *key, unsigned int subclass,\r
      unsigned long ip);\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void lock_set_subclass(struct lockdep_map *lock,\r
  unsigned int subclass, unsigned long ip)\r
{\r
 lock_set_class(lock, lock->name, lock->key, subclass, ip);\r
}\r
\r
extern void lock_downgrade(struct lockdep_map *lock, unsigned long ip);\r
\r
\r
\r
extern struct pin_cookie lock_pin_lock(struct lockdep_map *lock);\r
extern void lock_repin_lock(struct lockdep_map *lock, struct pin_cookie);\r
extern void lock_unpin_lock(struct lockdep_map *lock, struct pin_cookie);\r
# 428 "./include/linux/lockdep.h"\r
enum xhlock_context_t {\r
 XHLOCK_HARD,\r
 XHLOCK_SOFT,\r
 XHLOCK_CTX_NR,\r
};\r
# 442 "./include/linux/lockdep.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void lockdep_invariant_state(bool force) {}\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void lockdep_free_task(struct task_struct *task) {}\r
# 487 "./include/linux/lockdep.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void print_irqtrace_events(struct task_struct *curr)\r
{\r
}\r
# 500 "./include/linux/lockdep.h"\r
extern bool read_lock_is_recursive(void);\r
# 653 "./include/linux/lockdep.h"\r
void lockdep_rcu_suspicious(const char *file, const int line, const char *s);\r
# 63 "./include/linux/spinlock.h" 2\r
\r
# 1 "./arch/riscv/include/asm/mmiowb.h" 1\r
# 13 "./arch/riscv/include/asm/mmiowb.h"\r
# 1 "./include/asm-generic/mmiowb.h" 1\r
# 23 "./include/asm-generic/mmiowb.h"\r
# 1 "./include/asm-generic/mmiowb_types.h" 1\r
\r
\r
\r
\r
\r
\r
struct mmiowb_state {\r
 u16 nesting_count;\r
 u16 mmiowb_pending;\r
};\r
# 24 "./include/asm-generic/mmiowb.h" 2\r
\r
\r
# 1 "./arch/riscv/include/generated/asm/percpu.h" 1\r
# 27 "./include/asm-generic/mmiowb.h" 2\r
\r
\r
extern __attribute__((section(".data..percpu" ""))) __typeof__(struct mmiowb_state) __mmiowb_state;\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void mmiowb_set_pending(void)\r
{\r
 struct mmiowb_state *ms = ({ do { const void *__vpp_verify = (typeof((&__mmiowb_state) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __ptr = (unsigned long) ((typeof(*(&__mmiowb_state)) *)(&__mmiowb_state)); (typeof((typeof(*(&__mmiowb_state)) *)(&__mmiowb_state))) (__ptr + (((__per_cpu_offset[(((struct thread_info *)get_current())->cpu)])))); }); });\r
\r
 if (__builtin_expect(!!(ms->nesting_count), 1))\r
  ms->mmiowb_pending = ms->nesting_count;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void mmiowb_spin_lock(void)\r
{\r
 struct mmiowb_state *ms = ({ do { const void *__vpp_verify = (typeof((&__mmiowb_state) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __ptr = (unsigned long) ((typeof(*(&__mmiowb_state)) *)(&__mmiowb_state)); (typeof((typeof(*(&__mmiowb_state)) *)(&__mmiowb_state))) (__ptr + (((__per_cpu_offset[(((struct thread_info *)get_current())->cpu)])))); }); });\r
 ms->nesting_count++;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void mmiowb_spin_unlock(void)\r
{\r
 struct mmiowb_state *ms = ({ do { const void *__vpp_verify = (typeof((&__mmiowb_state) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __ptr = (unsigned long) ((typeof(*(&__mmiowb_state)) *)(&__mmiowb_state)); (typeof((typeof(*(&__mmiowb_state)) *)(&__mmiowb_state))) (__ptr + (((__per_cpu_offset[(((struct thread_info *)get_current())->cpu)])))); }); });\r
\r
 if (__builtin_expect(!!(ms->mmiowb_pending), 0)) {\r
  ms->mmiowb_pending = 0;\r
  __asm__ __volatile__ ("fence o,w" : : : "memory");;\r
 }\r
\r
 ms->nesting_count--;\r
}\r
# 14 "./arch/riscv/include/asm/mmiowb.h" 2\r
# 65 "./include/linux/spinlock.h" 2\r
# 87 "./include/linux/spinlock.h"\r
# 1 "./include/linux/spinlock_types.h" 1\r
# 17 "./include/linux/spinlock_types.h"\r
typedef struct spinlock {\r
 union {\r
  struct raw_spinlock rlock;\r
\r
\r
\r
  struct {\r
   u8 __padding[(__builtin_offsetof(struct raw_spinlock, dep_map))];\r
   struct lockdep_map dep_map;\r
  };\r
\r
 };\r
} spinlock_t;\r
# 74 "./include/linux/spinlock_types.h"\r
# 1 "./include/linux/rwlock_types.h" 1\r
# 25 "./include/linux/rwlock_types.h"\r
typedef struct {\r
 arch_rwlock_t raw_lock;\r
\r
 unsigned int magic, owner_cpu;\r
 void *owner;\r
\r
\r
 struct lockdep_map dep_map;\r
\r
} rwlock_t;\r
# 75 "./include/linux/spinlock_types.h" 2\r
# 88 "./include/linux/spinlock.h" 2\r
\r
\r
\r
\r
\r
# 1 "./arch/riscv/include/asm/spinlock.h" 1\r
# 22 "./arch/riscv/include/asm/spinlock.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void arch_spin_unlock(arch_spinlock_t *lock)\r
{\r
 do { do { } while (0); do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_57(void) ; if (!((sizeof(*&lock->lock) == sizeof(char) || sizeof(*&lock->lock) == sizeof(short) || sizeof(*&lock->lock) == sizeof(int) || sizeof(*&lock->lock) == sizeof(long)))) __compiletime_assert_57(); } while (0); __asm__ __volatile__ ("fence " "rw" "," "w" : : : "memory"); do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_58(void) ; if (!((sizeof(*&lock->lock) == sizeof(char) || sizeof(*&lock->lock) == sizeof(short) || sizeof(*&lock->lock) == sizeof(int) || sizeof(*&lock->lock) == sizeof(long)) || sizeof(*&lock->lock) == sizeof(long long))) __compiletime_assert_58(); } while (0); do { *(volatile typeof(*&lock->lock) *)&(*&lock->lock) = (0); } while (0); } while (0); } while (0); } while (0);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int arch_spin_trylock(arch_spinlock_t *lock)\r
{\r
 int tmp = 1, busy;\r
\r
 __asm__ __volatile__ (\r
  "	amoswap.w %0, %2, %1\n"\r
  "\tfence r , rw\n"\r
  : "=r" (busy), "+A" (lock->lock)\r
  : "r" (tmp)\r
  : "memory");\r
\r
 return !busy;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void arch_spin_lock(arch_spinlock_t *lock)\r
{\r
 while (1) {\r
  if ((({ do { __attribute__((__noreturn__)) extern void __compiletime_assert_59(void) ; if (!((sizeof((lock)->lock) == sizeof(char) || sizeof((lock)->lock) == sizeof(short) || sizeof((lock)->lock) == sizeof(int) || sizeof((lock)->lock) == sizeof(long)) || sizeof((lock)->lock) == sizeof(long long))) __compiletime_assert_59(); } while (0); (*(const volatile typeof( _Generic(((lock)->lock), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: ((lock)->lock))) *)&((lock)->lock)); }) != 0))\r
   continue;\r
\r
  if (arch_spin_trylock(lock))\r
   break;\r
 }\r
}\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void arch_read_lock(arch_rwlock_t *lock)\r
{\r
 int tmp;\r
\r
 __asm__ __volatile__(\r
  "1:	lr.w	%1, %0\n"\r
  "	bltz	%1, 1b\n"\r
  "	addi	%1, %1, 1\n"\r
  "	sc.w	%1, %1, %0\n"\r
  "	bnez	%1, 1b\n"\r
  "\tfence r , rw\n"\r
  : "+A" (lock->lock), "=&r" (tmp)\r
  :: "memory");\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void arch_write_lock(arch_rwlock_t *lock)\r
{\r
 int tmp;\r
\r
 __asm__ __volatile__(\r
  "1:	lr.w	%1, %0\n"\r
  "	bnez	%1, 1b\n"\r
  "	li	%1, -1\n"\r
  "	sc.w	%1, %1, %0\n"\r
  "	bnez	%1, 1b\n"\r
  "\tfence r , rw\n"\r
  : "+A" (lock->lock), "=&r" (tmp)\r
  :: "memory");\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int arch_read_trylock(arch_rwlock_t *lock)\r
{\r
 int busy;\r
\r
 __asm__ __volatile__(\r
  "1:	lr.w	%1, %0\n"\r
  "	bltz	%1, 1f\n"\r
  "	addi	%1, %1, 1\n"\r
  "	sc.w	%1, %1, %0\n"\r
  "	bnez	%1, 1b\n"\r
  "\tfence r , rw\n"\r
  "1:\n"\r
  : "+A" (lock->lock), "=&r" (busy)\r
  :: "memory");\r
\r
 return !busy;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int arch_write_trylock(arch_rwlock_t *lock)\r
{\r
 int busy;\r
\r
 __asm__ __volatile__(\r
  "1:	lr.w	%1, %0\n"\r
  "	bnez	%1, 1f\n"\r
  "	li	%1, -1\n"\r
  "	sc.w	%1, %1, %0\n"\r
  "	bnez	%1, 1b\n"\r
  "\tfence r , rw\n"\r
  "1:\n"\r
  : "+A" (lock->lock), "=&r" (busy)\r
  :: "memory");\r
\r
 return !busy;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void arch_read_unlock(arch_rwlock_t *lock)\r
{\r
 __asm__ __volatile__(\r
  "\tfence rw,  w\n"\r
  "	amoadd.w x0, %1, %0\n"\r
  : "+A" (lock->lock)\r
  : "r" (-1)\r
  : "memory");\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void arch_write_unlock(arch_rwlock_t *lock)\r
{\r
 do { do { } while (0); do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_60(void) ; if (!((sizeof(*&lock->lock) == sizeof(char) || sizeof(*&lock->lock) == sizeof(short) || sizeof(*&lock->lock) == sizeof(int) || sizeof(*&lock->lock) == sizeof(long)))) __compiletime_assert_60(); } while (0); __asm__ __volatile__ ("fence " "rw" "," "w" : : : "memory"); do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_61(void) ; if (!((sizeof(*&lock->lock) == sizeof(char) || sizeof(*&lock->lock) == sizeof(short) || sizeof(*&lock->lock) == sizeof(int) || sizeof(*&lock->lock) == sizeof(long)) || sizeof(*&lock->lock) == sizeof(long long))) __compiletime_assert_61(); } while (0); do { *(volatile typeof(*&lock->lock) *)&(*&lock->lock) = (0); } while (0); } while (0); } while (0); } while (0);\r
}\r
# 94 "./include/linux/spinlock.h" 2\r
\r
\r
\r
\r
\r
  extern void __raw_spin_lock_init(raw_spinlock_t *lock, const char *name,\r
       struct lock_class_key *key, short inner);\r
# 178 "./include/linux/spinlock.h"\r
 extern void do_raw_spin_lock(raw_spinlock_t *lock) ;\r
 extern int do_raw_spin_trylock(raw_spinlock_t *lock);\r
 extern void do_raw_spin_unlock(raw_spinlock_t *lock) ;\r
# 303 "./include/linux/spinlock.h"\r
# 1 "./include/linux/rwlock.h" 1\r
# 18 "./include/linux/rwlock.h"\r
  extern void __rwlock_init(rwlock_t *lock, const char *name,\r
       struct lock_class_key *key);\r
# 32 "./include/linux/rwlock.h"\r
 extern void do_raw_read_lock(rwlock_t *lock) ;\r
 extern int do_raw_read_trylock(rwlock_t *lock);\r
 extern void do_raw_read_unlock(rwlock_t *lock) ;\r
 extern void do_raw_write_lock(rwlock_t *lock) ;\r
 extern int do_raw_write_trylock(rwlock_t *lock);\r
 extern void do_raw_write_unlock(rwlock_t *lock) ;\r
# 304 "./include/linux/spinlock.h" 2\r
\r
\r
\r
\r
\r
\r
# 1 "./include/linux/spinlock_api_smp.h" 1\r
# 18 "./include/linux/spinlock_api_smp.h"\r
int in_lock_functions(unsigned long addr);\r
\r
\r
\r
void __attribute__((__section__(".spinlock.text"))) _raw_spin_lock(raw_spinlock_t *lock) ;\r
void __attribute__((__section__(".spinlock.text"))) _raw_spin_lock_nested(raw_spinlock_t *lock, int subclass)\r
                        ;\r
void __attribute__((__section__(".spinlock.text")))\r
_raw_spin_lock_nest_lock(raw_spinlock_t *lock, struct lockdep_map *map)\r
                        ;\r
void __attribute__((__section__(".spinlock.text"))) _raw_spin_lock_bh(raw_spinlock_t *lock) ;\r
void __attribute__((__section__(".spinlock.text"))) _raw_spin_lock_irq(raw_spinlock_t *lock)\r
                        ;\r
\r
unsigned long __attribute__((__section__(".spinlock.text"))) _raw_spin_lock_irqsave(raw_spinlock_t *lock)\r
                        ;\r
unsigned long __attribute__((__section__(".spinlock.text")))\r
_raw_spin_lock_irqsave_nested(raw_spinlock_t *lock, int subclass)\r
                        ;\r
int __attribute__((__section__(".spinlock.text"))) _raw_spin_trylock(raw_spinlock_t *lock);\r
int __attribute__((__section__(".spinlock.text"))) _raw_spin_trylock_bh(raw_spinlock_t *lock);\r
void __attribute__((__section__(".spinlock.text"))) _raw_spin_unlock(raw_spinlock_t *lock) ;\r
void __attribute__((__section__(".spinlock.text"))) _raw_spin_unlock_bh(raw_spinlock_t *lock) ;\r
void __attribute__((__section__(".spinlock.text"))) _raw_spin_unlock_irq(raw_spinlock_t *lock) ;\r
void __attribute__((__section__(".spinlock.text")))\r
_raw_spin_unlock_irqrestore(raw_spinlock_t *lock, unsigned long flags)\r
                        ;\r
# 86 "./include/linux/spinlock_api_smp.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int __raw_spin_trylock(raw_spinlock_t *lock)\r
{\r
 do { __preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);\r
 if (do_raw_spin_trylock(lock)) {\r
  lock_acquire(&lock->dep_map, 0, 1, 0, 1, ((void *)0), (unsigned long)__builtin_return_address(0));\r
  return 1;\r
 }\r
 do { __asm__ __volatile__("": : :"memory"); __preempt_count_sub(1); } while (0);\r
 return 0;\r
}\r
# 104 "./include/linux/spinlock_api_smp.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) unsigned long __raw_spin_lock_irqsave(raw_spinlock_t *lock)\r
{\r
 unsigned long flags;\r
\r
 do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); flags = arch_local_irq_save(); } while (0); if (!({ ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_irqs_disabled_flags(flags); })) trace_hardirqs_off(); } while (0);\r
 do { __preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);\r
 lock_acquire(&lock->dep_map, 0, 0, 0, 1, ((void *)0), (unsigned long)__builtin_return_address(0));\r
 do_raw_spin_lock(lock);\r
 return flags;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __raw_spin_lock_irq(raw_spinlock_t *lock)\r
{\r
 do { bool was_disabled = (arch_irqs_disabled()); arch_local_irq_disable(); if (!was_disabled) trace_hardirqs_off(); } while (0);\r
 do { __preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);\r
 lock_acquire(&lock->dep_map, 0, 0, 0, 1, ((void *)0), (unsigned long)__builtin_return_address(0));\r
 do_raw_spin_lock(lock);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __raw_spin_lock_bh(raw_spinlock_t *lock)\r
{\r
 __local_bh_disable_ip((unsigned long)__builtin_return_address(0), ((2 * (1UL << (0 + 8))) + (1UL << 0)));\r
 lock_acquire(&lock->dep_map, 0, 0, 0, 1, ((void *)0), (unsigned long)__builtin_return_address(0));\r
 do_raw_spin_lock(lock);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __raw_spin_lock(raw_spinlock_t *lock)\r
{\r
 do { __preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);\r
 lock_acquire(&lock->dep_map, 0, 0, 0, 1, ((void *)0), (unsigned long)__builtin_return_address(0));\r
 do_raw_spin_lock(lock);\r
}\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __raw_spin_unlock(raw_spinlock_t *lock)\r
{\r
 lock_release(&lock->dep_map, (unsigned long)__builtin_return_address(0));\r
 do_raw_spin_unlock(lock);\r
 do { __asm__ __volatile__("": : :"memory"); __preempt_count_sub(1); } while (0);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __raw_spin_unlock_irqrestore(raw_spinlock_t *lock,\r
         unsigned long flags)\r
{\r
 lock_release(&lock->dep_map, (unsigned long)__builtin_return_address(0));\r
 do_raw_spin_unlock(lock);\r
 do { if (!({ ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_irqs_disabled_flags(flags); })) trace_hardirqs_on(); do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); do { } while (0); arch_local_irq_restore(flags); } while (0); } while (0);\r
 do { __asm__ __volatile__("": : :"memory"); __preempt_count_sub(1); } while (0);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __raw_spin_unlock_irq(raw_spinlock_t *lock)\r
{\r
 lock_release(&lock->dep_map, (unsigned long)__builtin_return_address(0));\r
 do_raw_spin_unlock(lock);\r
 do { trace_hardirqs_on(); arch_local_irq_enable(); } while (0);\r
 do { __asm__ __volatile__("": : :"memory"); __preempt_count_sub(1); } while (0);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __raw_spin_unlock_bh(raw_spinlock_t *lock)\r
{\r
 lock_release(&lock->dep_map, (unsigned long)__builtin_return_address(0));\r
 do_raw_spin_unlock(lock);\r
 __local_bh_enable_ip((unsigned long)__builtin_return_address(0), ((2 * (1UL << (0 + 8))) + (1UL << 0)));\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int __raw_spin_trylock_bh(raw_spinlock_t *lock)\r
{\r
 __local_bh_disable_ip((unsigned long)__builtin_return_address(0), ((2 * (1UL << (0 + 8))) + (1UL << 0)));\r
 if (do_raw_spin_trylock(lock)) {\r
  lock_acquire(&lock->dep_map, 0, 1, 0, 1, ((void *)0), (unsigned long)__builtin_return_address(0));\r
  return 1;\r
 }\r
 __local_bh_enable_ip((unsigned long)__builtin_return_address(0), ((2 * (1UL << (0 + 8))) + (1UL << 0)));\r
 return 0;\r
}\r
\r
\r
\r
\r
# 1 "./include/linux/rwlock_api_smp.h" 1\r
# 18 "./include/linux/rwlock_api_smp.h"\r
void __attribute__((__section__(".spinlock.text"))) _raw_read_lock(rwlock_t *lock) ;\r
void __attribute__((__section__(".spinlock.text"))) _raw_write_lock(rwlock_t *lock) ;\r
void __attribute__((__section__(".spinlock.text"))) _raw_write_lock_nested(rwlock_t *lock, int subclass) ;\r
void __attribute__((__section__(".spinlock.text"))) _raw_read_lock_bh(rwlock_t *lock) ;\r
void __attribute__((__section__(".spinlock.text"))) _raw_write_lock_bh(rwlock_t *lock) ;\r
void __attribute__((__section__(".spinlock.text"))) _raw_read_lock_irq(rwlock_t *lock) ;\r
void __attribute__((__section__(".spinlock.text"))) _raw_write_lock_irq(rwlock_t *lock) ;\r
unsigned long __attribute__((__section__(".spinlock.text"))) _raw_read_lock_irqsave(rwlock_t *lock)\r
                       ;\r
unsigned long __attribute__((__section__(".spinlock.text"))) _raw_write_lock_irqsave(rwlock_t *lock)\r
                       ;\r
int __attribute__((__section__(".spinlock.text"))) _raw_read_trylock(rwlock_t *lock);\r
int __attribute__((__section__(".spinlock.text"))) _raw_write_trylock(rwlock_t *lock);\r
void __attribute__((__section__(".spinlock.text"))) _raw_read_unlock(rwlock_t *lock) ;\r
void __attribute__((__section__(".spinlock.text"))) _raw_write_unlock(rwlock_t *lock) ;\r
void __attribute__((__section__(".spinlock.text"))) _raw_read_unlock_bh(rwlock_t *lock) ;\r
void __attribute__((__section__(".spinlock.text"))) _raw_write_unlock_bh(rwlock_t *lock) ;\r
void __attribute__((__section__(".spinlock.text"))) _raw_read_unlock_irq(rwlock_t *lock) ;\r
void __attribute__((__section__(".spinlock.text"))) _raw_write_unlock_irq(rwlock_t *lock) ;\r
void __attribute__((__section__(".spinlock.text")))\r
_raw_read_unlock_irqrestore(rwlock_t *lock, unsigned long flags)\r
                       ;\r
void __attribute__((__section__(".spinlock.text")))\r
_raw_write_unlock_irqrestore(rwlock_t *lock, unsigned long flags)\r
                       ;\r
# 118 "./include/linux/rwlock_api_smp.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int __raw_read_trylock(rwlock_t *lock)\r
{\r
 do { __preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);\r
 if (do_raw_read_trylock(lock)) {\r
  do { if (read_lock_is_recursive()) lock_acquire(&lock->dep_map, 0, 1, 2, 1, ((void *)0), (unsigned long)__builtin_return_address(0)); else lock_acquire(&lock->dep_map, 0, 1, 1, 1, ((void *)0), (unsigned long)__builtin_return_address(0)); } while (0);\r
  return 1;\r
 }\r
 do { __asm__ __volatile__("": : :"memory"); __preempt_count_sub(1); } while (0);\r
 return 0;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int __raw_write_trylock(rwlock_t *lock)\r
{\r
 do { __preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);\r
 if (do_raw_write_trylock(lock)) {\r
  lock_acquire(&lock->dep_map, 0, 1, 0, 1, ((void *)0), (unsigned long)__builtin_return_address(0));\r
  return 1;\r
 }\r
 do { __asm__ __volatile__("": : :"memory"); __preempt_count_sub(1); } while (0);\r
 return 0;\r
}\r
# 147 "./include/linux/rwlock_api_smp.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __raw_read_lock(rwlock_t *lock)\r
{\r
 do { __preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);\r
 do { if (read_lock_is_recursive()) lock_acquire(&lock->dep_map, 0, 0, 2, 1, ((void *)0), (unsigned long)__builtin_return_address(0)); else lock_acquire(&lock->dep_map, 0, 0, 1, 1, ((void *)0), (unsigned long)__builtin_return_address(0)); } while (0);\r
 do_raw_read_lock(lock);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) unsigned long __raw_read_lock_irqsave(rwlock_t *lock)\r
{\r
 unsigned long flags;\r
\r
 do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); flags = arch_local_irq_save(); } while (0); if (!({ ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_irqs_disabled_flags(flags); })) trace_hardirqs_off(); } while (0);\r
 do { __preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);\r
 do { if (read_lock_is_recursive()) lock_acquire(&lock->dep_map, 0, 0, 2, 1, ((void *)0), (unsigned long)__builtin_return_address(0)); else lock_acquire(&lock->dep_map, 0, 0, 1, 1, ((void *)0), (unsigned long)__builtin_return_address(0)); } while (0);\r
 do_raw_read_lock(lock);\r
 return flags;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __raw_read_lock_irq(rwlock_t *lock)\r
{\r
 do { bool was_disabled = (arch_irqs_disabled()); arch_local_irq_disable(); if (!was_disabled) trace_hardirqs_off(); } while (0);\r
 do { __preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);\r
 do { if (read_lock_is_recursive()) lock_acquire(&lock->dep_map, 0, 0, 2, 1, ((void *)0), (unsigned long)__builtin_return_address(0)); else lock_acquire(&lock->dep_map, 0, 0, 1, 1, ((void *)0), (unsigned long)__builtin_return_address(0)); } while (0);\r
 do_raw_read_lock(lock);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __raw_read_lock_bh(rwlock_t *lock)\r
{\r
 __local_bh_disable_ip((unsigned long)__builtin_return_address(0), ((2 * (1UL << (0 + 8))) + (1UL << 0)));\r
 do { if (read_lock_is_recursive()) lock_acquire(&lock->dep_map, 0, 0, 2, 1, ((void *)0), (unsigned long)__builtin_return_address(0)); else lock_acquire(&lock->dep_map, 0, 0, 1, 1, ((void *)0), (unsigned long)__builtin_return_address(0)); } while (0);\r
 do_raw_read_lock(lock);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) unsigned long __raw_write_lock_irqsave(rwlock_t *lock)\r
{\r
 unsigned long flags;\r
\r
 do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); flags = arch_local_irq_save(); } while (0); if (!({ ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_irqs_disabled_flags(flags); })) trace_hardirqs_off(); } while (0);\r
 do { __preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);\r
 lock_acquire(&lock->dep_map, 0, 0, 0, 1, ((void *)0), (unsigned long)__builtin_return_address(0));\r
 do_raw_write_lock(lock);\r
 return flags;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __raw_write_lock_irq(rwlock_t *lock)\r
{\r
 do { bool was_disabled = (arch_irqs_disabled()); arch_local_irq_disable(); if (!was_disabled) trace_hardirqs_off(); } while (0);\r
 do { __preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);\r
 lock_acquire(&lock->dep_map, 0, 0, 0, 1, ((void *)0), (unsigned long)__builtin_return_address(0));\r
 do_raw_write_lock(lock);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __raw_write_lock_bh(rwlock_t *lock)\r
{\r
 __local_bh_disable_ip((unsigned long)__builtin_return_address(0), ((2 * (1UL << (0 + 8))) + (1UL << 0)));\r
 lock_acquire(&lock->dep_map, 0, 0, 0, 1, ((void *)0), (unsigned long)__builtin_return_address(0));\r
 do_raw_write_lock(lock);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __raw_write_lock(rwlock_t *lock)\r
{\r
 do { __preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);\r
 lock_acquire(&lock->dep_map, 0, 0, 0, 1, ((void *)0), (unsigned long)__builtin_return_address(0));\r
 do_raw_write_lock(lock);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __raw_write_lock_nested(rwlock_t *lock, int subclass)\r
{\r
 do { __preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);\r
 lock_acquire(&lock->dep_map, subclass, 0, 0, 1, ((void *)0), (unsigned long)__builtin_return_address(0));\r
 do_raw_write_lock(lock);\r
}\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __raw_write_unlock(rwlock_t *lock)\r
{\r
 lock_release(&lock->dep_map, (unsigned long)__builtin_return_address(0));\r
 do_raw_write_unlock(lock);\r
 do { __asm__ __volatile__("": : :"memory"); __preempt_count_sub(1); } while (0);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __raw_read_unlock(rwlock_t *lock)\r
{\r
 lock_release(&lock->dep_map, (unsigned long)__builtin_return_address(0));\r
 do_raw_read_unlock(lock);\r
 do { __asm__ __volatile__("": : :"memory"); __preempt_count_sub(1); } while (0);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void\r
__raw_read_unlock_irqrestore(rwlock_t *lock, unsigned long flags)\r
{\r
 lock_release(&lock->dep_map, (unsigned long)__builtin_return_address(0));\r
 do_raw_read_unlock(lock);\r
 do { if (!({ ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_irqs_disabled_flags(flags); })) trace_hardirqs_on(); do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); do { } while (0); arch_local_irq_restore(flags); } while (0); } while (0);\r
 do { __asm__ __volatile__("": : :"memory"); __preempt_count_sub(1); } while (0);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __raw_read_unlock_irq(rwlock_t *lock)\r
{\r
 lock_release(&lock->dep_map, (unsigned long)__builtin_return_address(0));\r
 do_raw_read_unlock(lock);\r
 do { trace_hardirqs_on(); arch_local_irq_enable(); } while (0);\r
 do { __asm__ __volatile__("": : :"memory"); __preempt_count_sub(1); } while (0);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __raw_read_unlock_bh(rwlock_t *lock)\r
{\r
 lock_release(&lock->dep_map, (unsigned long)__builtin_return_address(0));\r
 do_raw_read_unlock(lock);\r
 __local_bh_enable_ip((unsigned long)__builtin_return_address(0), ((2 * (1UL << (0 + 8))) + (1UL << 0)));\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __raw_write_unlock_irqrestore(rwlock_t *lock,\r
          unsigned long flags)\r
{\r
 lock_release(&lock->dep_map, (unsigned long)__builtin_return_address(0));\r
 do_raw_write_unlock(lock);\r
 do { if (!({ ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_irqs_disabled_flags(flags); })) trace_hardirqs_on(); do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); do { } while (0); arch_local_irq_restore(flags); } while (0); } while (0);\r
 do { __asm__ __volatile__("": : :"memory"); __preempt_count_sub(1); } while (0);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __raw_write_unlock_irq(rwlock_t *lock)\r
{\r
 lock_release(&lock->dep_map, (unsigned long)__builtin_return_address(0));\r
 do_raw_write_unlock(lock);\r
 do { trace_hardirqs_on(); arch_local_irq_enable(); } while (0);\r
 do { __asm__ __volatile__("": : :"memory"); __preempt_count_sub(1); } while (0);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __raw_write_unlock_bh(rwlock_t *lock)\r
{\r
 lock_release(&lock->dep_map, (unsigned long)__builtin_return_address(0));\r
 do_raw_write_unlock(lock);\r
 __local_bh_enable_ip((unsigned long)__builtin_return_address(0), ((2 * (1UL << (0 + 8))) + (1UL << 0)));\r
}\r
# 184 "./include/linux/spinlock_api_smp.h" 2\r
# 311 "./include/linux/spinlock.h" 2\r
# 322 "./include/linux/spinlock.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) raw_spinlock_t *spinlock_check(spinlock_t *lock)\r
{\r
 return &lock->rlock;\r
}\r
# 347 "./include/linux/spinlock.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void spin_lock(spinlock_t *lock)\r
{\r
 _raw_spin_lock(&lock->rlock);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void spin_lock_bh(spinlock_t *lock)\r
{\r
 _raw_spin_lock_bh(&lock->rlock);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int spin_trylock(spinlock_t *lock)\r
{\r
 return (_raw_spin_trylock(&lock->rlock));\r
}\r
# 372 "./include/linux/spinlock.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void spin_lock_irq(spinlock_t *lock)\r
{\r
 _raw_spin_lock_irq(&lock->rlock);\r
}\r
# 387 "./include/linux/spinlock.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void spin_unlock(spinlock_t *lock)\r
{\r
 _raw_spin_unlock(&lock->rlock);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void spin_unlock_bh(spinlock_t *lock)\r
{\r
 _raw_spin_unlock_bh(&lock->rlock);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void spin_unlock_irq(spinlock_t *lock)\r
{\r
 _raw_spin_unlock_irq(&lock->rlock);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void spin_unlock_irqrestore(spinlock_t *lock, unsigned long flags)\r
{\r
 do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); _raw_spin_unlock_irqrestore(&lock->rlock, flags); } while (0);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int spin_trylock_bh(spinlock_t *lock)\r
{\r
 return (_raw_spin_trylock_bh(&lock->rlock));\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int spin_trylock_irq(spinlock_t *lock)\r
{\r
 return ({ do { bool was_disabled = (arch_irqs_disabled()); arch_local_irq_disable(); if (!was_disabled) trace_hardirqs_off(); } while (0); (_raw_spin_trylock(&lock->rlock)) ? 1 : ({ do { trace_hardirqs_on(); arch_local_irq_enable(); } while (0); 0; }); });\r
}\r
# 440 "./include/linux/spinlock.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int spin_is_locked(spinlock_t *lock)\r
{\r
 return (({ do { __attribute__((__noreturn__)) extern void __compiletime_assert_62(void) ; if (!((sizeof((&(&lock->rlock)->raw_lock)->lock) == sizeof(char) || sizeof((&(&lock->rlock)->raw_lock)->lock) == sizeof(short) || sizeof((&(&lock->rlock)->raw_lock)->lock) == sizeof(int) || sizeof((&(&lock->rlock)->raw_lock)->lock) == sizeof(long)) || sizeof((&(&lock->rlock)->raw_lock)->lock) == sizeof(long long))) __compiletime_assert_62(); } while (0); (*(const volatile typeof( _Generic(((&(&lock->rlock)->raw_lock)->lock), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: ((&(&lock->rlock)->raw_lock)->lock))) *)&((&(&lock->rlock)->raw_lock)->lock)); }) != 0);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int spin_is_contended(spinlock_t *lock)\r
{\r
 return (((void)(&lock->rlock), 0));\r
}\r
# 469 "./include/linux/spinlock.h"\r
extern int _atomic_dec_and_lock(atomic_t *atomic, spinlock_t *lock);\r
\r
\r
\r
extern int _atomic_dec_and_lock_irqsave(atomic_t *atomic, spinlock_t *lock,\r
     unsigned long *flags);\r
\r
\r
\r
int __alloc_bucket_spinlocks(spinlock_t **locks, unsigned int *lock_mask,\r
        size_t max_size, unsigned int cpu_mult,\r
        gfp_t gfp, const char *name,\r
        struct lock_class_key *key);\r
# 493 "./include/linux/spinlock.h"\r
void free_bucket_spinlocks(spinlock_t *locks);\r
# 17 "./include/linux/kref.h" 2\r
# 1 "./include/linux/refcount.h" 1\r
# 101 "./include/linux/refcount.h"\r
struct mutex;\r
# 111 "./include/linux/refcount.h"\r
typedef struct refcount_struct {\r
 atomic_t refs;\r
} refcount_t;\r
\r
\r
\r
\r
\r
enum refcount_saturation_type {\r
 REFCOUNT_ADD_NOT_ZERO_OVF,\r
 REFCOUNT_ADD_OVF,\r
 REFCOUNT_ADD_UAF,\r
 REFCOUNT_SUB_UAF,\r
 REFCOUNT_DEC_LEAK,\r
};\r
\r
void refcount_warn_saturate(refcount_t *r, enum refcount_saturation_type t);\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void refcount_set(refcount_t *r, int n)\r
{\r
 atomic_set(&r->refs, n);\r
}\r
\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) unsigned int refcount_read(const refcount_t *r)\r
{\r
 return atomic_read(&r->refs);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__warn_unused_result__)) bool __refcount_add_not_zero(int i, refcount_t *r, int *oldp)\r
{\r
 int old = refcount_read(r);\r
\r
 do {\r
  if (!old)\r
   break;\r
 } while (!atomic_try_cmpxchg_relaxed(&r->refs, &old, old + i));\r
\r
 if (oldp)\r
  *oldp = old;\r
\r
 if (__builtin_expect(!!(old < 0 || old + i < 0), 0))\r
  refcount_warn_saturate(r, REFCOUNT_ADD_NOT_ZERO_OVF);\r
\r
 return old;\r
}\r
# 186 "./include/linux/refcount.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__warn_unused_result__)) bool refcount_add_not_zero(int i, refcount_t *r)\r
{\r
 return __refcount_add_not_zero(i, r, ((void *)0));\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __refcount_add(int i, refcount_t *r, int *oldp)\r
{\r
 int old = atomic_fetch_add_relaxed(i, &r->refs);\r
\r
 if (oldp)\r
  *oldp = old;\r
\r
 if (__builtin_expect(!!(!old), 0))\r
  refcount_warn_saturate(r, REFCOUNT_ADD_UAF);\r
 else if (__builtin_expect(!!(old < 0 || old + i < 0), 0))\r
  refcount_warn_saturate(r, REFCOUNT_ADD_OVF);\r
}\r
# 220 "./include/linux/refcount.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void refcount_add(int i, refcount_t *r)\r
{\r
 __refcount_add(i, r, ((void *)0));\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__warn_unused_result__)) bool __refcount_inc_not_zero(refcount_t *r, int *oldp)\r
{\r
 return __refcount_add_not_zero(1, r, oldp);\r
}\r
# 243 "./include/linux/refcount.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__warn_unused_result__)) bool refcount_inc_not_zero(refcount_t *r)\r
{\r
 return __refcount_inc_not_zero(r, ((void *)0));\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __refcount_inc(refcount_t *r, int *oldp)\r
{\r
 __refcount_add(1, r, oldp);\r
}\r
# 265 "./include/linux/refcount.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void refcount_inc(refcount_t *r)\r
{\r
 __refcount_inc(r, ((void *)0));\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__warn_unused_result__)) bool __refcount_sub_and_test(int i, refcount_t *r, int *oldp)\r
{\r
 int old = atomic_fetch_sub_release(i, &r->refs);\r
\r
 if (oldp)\r
  *oldp = old;\r
\r
 if (old == i) {\r
  do { do { } while (0); __asm__ __volatile__ ("fence " "r" "," "r" : : : "memory"); } while (0);\r
  return true;\r
 }\r
\r
 if (__builtin_expect(!!(old < 0 || old - i < 0), 0))\r
  refcount_warn_saturate(r, REFCOUNT_SUB_UAF);\r
\r
 return false;\r
}\r
# 308 "./include/linux/refcount.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__warn_unused_result__)) bool refcount_sub_and_test(int i, refcount_t *r)\r
{\r
 return __refcount_sub_and_test(i, r, ((void *)0));\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__warn_unused_result__)) bool __refcount_dec_and_test(refcount_t *r, int *oldp)\r
{\r
 return __refcount_sub_and_test(1, r, oldp);\r
}\r
# 331 "./include/linux/refcount.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__warn_unused_result__)) bool refcount_dec_and_test(refcount_t *r)\r
{\r
 return __refcount_dec_and_test(r, ((void *)0));\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __refcount_dec(refcount_t *r, int *oldp)\r
{\r
 int old = atomic_fetch_sub_release(1, &r->refs);\r
\r
 if (oldp)\r
  *oldp = old;\r
\r
 if (__builtin_expect(!!(old <= 1), 0))\r
  refcount_warn_saturate(r, REFCOUNT_DEC_LEAK);\r
}\r
# 357 "./include/linux/refcount.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void refcount_dec(refcount_t *r)\r
{\r
 __refcount_dec(r, ((void *)0));\r
}\r
\r
extern __attribute__((__warn_unused_result__)) bool refcount_dec_if_one(refcount_t *r);\r
extern __attribute__((__warn_unused_result__)) bool refcount_dec_not_one(refcount_t *r);\r
extern __attribute__((__warn_unused_result__)) bool refcount_dec_and_mutex_lock(refcount_t *r, struct mutex *lock);\r
extern __attribute__((__warn_unused_result__)) bool refcount_dec_and_lock(refcount_t *r, spinlock_t *lock);\r
extern __attribute__((__warn_unused_result__)) bool refcount_dec_and_lock_irqsave(refcount_t *r,\r
             spinlock_t *lock,\r
             unsigned long *flags);\r
# 18 "./include/linux/kref.h" 2\r
\r
struct kref {\r
 refcount_t refcount;\r
};\r
\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void kref_init(struct kref *kref)\r
{\r
 refcount_set(&kref->refcount, 1);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) unsigned int kref_read(const struct kref *kref)\r
{\r
 return refcount_read(&kref->refcount);\r
}\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void kref_get(struct kref *kref)\r
{\r
 refcount_inc(&kref->refcount);\r
}\r
# 62 "./include/linux/kref.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int kref_put(struct kref *kref, void (*release)(struct kref *kref))\r
{\r
 if (refcount_dec_and_test(&kref->refcount)) {\r
  release(kref);\r
  return 1;\r
 }\r
 return 0;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int kref_put_mutex(struct kref *kref,\r
     void (*release)(struct kref *kref),\r
     struct mutex *lock)\r
{\r
 if (refcount_dec_and_mutex_lock(&kref->refcount, lock)) {\r
  release(kref);\r
  return 1;\r
 }\r
 return 0;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int kref_put_lock(struct kref *kref,\r
    void (*release)(struct kref *kref),\r
    spinlock_t *lock)\r
{\r
 if (refcount_dec_and_lock(&kref->refcount, lock)) {\r
  release(kref);\r
  return 1;\r
 }\r
 return 0;\r
}\r
# 109 "./include/linux/kref.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int __attribute__((__warn_unused_result__)) kref_get_unless_zero(struct kref *kref)\r
{\r
 return refcount_inc_not_zero(&kref->refcount);\r
}\r
# 9 "./include/linux/mm_types.h" 2\r
\r
\r
# 1 "./include/linux/rbtree.h" 1\r
# 20 "./include/linux/rbtree.h"\r
# 1 "./include/linux/rbtree_types.h" 1\r
\r
\r
\r
\r
struct rb_node {\r
 unsigned long __rb_parent_color;\r
 struct rb_node *rb_right;\r
 struct rb_node *rb_left;\r
} __attribute__((aligned(sizeof(long))));\r
\r
\r
struct rb_root {\r
 struct rb_node *rb_node;\r
};\r
# 26 "./include/linux/rbtree_types.h"\r
struct rb_root_cached {\r
 struct rb_root rb_root;\r
 struct rb_node *rb_leftmost;\r
};\r
# 21 "./include/linux/rbtree.h" 2\r
\r
\r
\r
# 1 "./include/linux/rcupdate.h" 1\r
# 40 "./include/linux/rcupdate.h"\r
void call_rcu(struct callback_head *head, rcu_callback_t func);\r
void rcu_barrier_tasks(void);\r
void rcu_barrier_tasks_rude(void);\r
void synchronize_rcu(void);\r
# 63 "./include/linux/rcupdate.h"\r
void rcu_read_unlock_strict(void);\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __rcu_read_lock(void)\r
{\r
 do { __preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __rcu_read_unlock(void)\r
{\r
 do { __asm__ __volatile__("": : :"memory"); __preempt_count_sub(1); } while (0);\r
 if (0)\r
  rcu_read_unlock_strict();\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int rcu_preempt_depth(void)\r
{\r
 return 0;\r
}\r
\r
\r
\r
\r
void rcu_init(void);\r
extern int rcu_scheduler_active;\r
void rcu_sched_clock_irq(int user);\r
void rcu_report_dead(unsigned int cpu);\r
void rcutree_migrate_callbacks(int cpu);\r
\r
\r
void rcu_init_tasks_generic(void);\r
\r
\r
\r
\r
\r
void rcu_sysrq_start(void);\r
void rcu_sysrq_end(void);\r
# 110 "./include/linux/rcupdate.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void rcu_user_enter(void) { }\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void rcu_user_exit(void) { }\r
# 120 "./include/linux/rcupdate.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void rcu_init_nohz(void) { }\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int rcu_nocb_cpu_offload(int cpu) { return -22; }\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int rcu_nocb_cpu_deoffload(int cpu) { return 0; }\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void rcu_nocb_flush_deferred_wakeup(void) { }\r
# 191 "./include/linux/rcupdate.h"\r
void call_rcu_tasks_rude(struct callback_head *head, rcu_callback_t func);\r
void synchronize_rcu_tasks_rude(void);\r
\r
\r
\r
void exit_tasks_rcu_start(void);\r
void exit_tasks_rcu_finish(void);\r
# 226 "./include/linux/rcupdate.h"\r
# 1 "./include/linux/rcutree.h" 1\r
# 20 "./include/linux/rcutree.h"\r
void rcu_softirq_qs(void);\r
void rcu_note_context_switch(bool preempt);\r
int rcu_needs_cpu(void);\r
void rcu_cpu_stall_reset(void);\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void rcu_virt_note_context_switch(int cpu)\r
{\r
 rcu_note_context_switch(false);\r
}\r
\r
void synchronize_rcu_expedited(void);\r
void kvfree_call_rcu(struct callback_head *head, rcu_callback_t func);\r
\r
void rcu_barrier(void);\r
bool rcu_eqs_special_set(int cpu);\r
void rcu_momentary_dyntick_idle(void);\r
void kfree_rcu_scheduler_running(void);\r
bool rcu_gp_might_be_stalled(void);\r
unsigned long get_state_synchronize_rcu(void);\r
unsigned long start_poll_synchronize_rcu(void);\r
bool poll_state_synchronize_rcu(unsigned long oldstate);\r
void cond_synchronize_rcu(unsigned long oldstate);\r
\r
void rcu_idle_enter(void);\r
void rcu_idle_exit(void);\r
void rcu_irq_enter(void);\r
void rcu_irq_exit(void);\r
void rcu_irq_enter_irqson(void);\r
void rcu_irq_exit_irqson(void);\r
bool rcu_is_idle_cpu(int cpu);\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void rcu_irq_exit_check_preempt(void) { }\r
\r
\r
void exit_rcu(void);\r
\r
void rcu_scheduler_starting(void);\r
extern int rcu_scheduler_active;\r
void rcu_end_inkernel_boot(void);\r
bool rcu_inkernel_boot_has_ended(void);\r
bool rcu_is_watching(void);\r
\r
void rcu_all_qs(void);\r
\r
\r
\r
int rcutree_prepare_cpu(unsigned int cpu);\r
int rcutree_online_cpu(unsigned int cpu);\r
int rcutree_offline_cpu(unsigned int cpu);\r
int rcutree_dead_cpu(unsigned int cpu);\r
int rcutree_dying_cpu(unsigned int cpu);\r
void rcu_cpu_starting(unsigned int cpu);\r
# 227 "./include/linux/rcupdate.h" 2\r
# 247 "./include/linux/rcupdate.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void init_rcu_head(struct callback_head *head) { }\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void destroy_rcu_head(struct callback_head *head) { }\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void init_rcu_head_on_stack(struct callback_head *head) { }\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void destroy_rcu_head_on_stack(struct callback_head *head) { }\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool rcu_lockdep_current_cpu_online(void) { return true; }\r
\r
\r
extern struct lockdep_map rcu_lock_map;\r
extern struct lockdep_map rcu_bh_lock_map;\r
extern struct lockdep_map rcu_sched_lock_map;\r
extern struct lockdep_map rcu_callback_map;\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void rcu_lock_acquire(struct lockdep_map *map)\r
{\r
 lock_acquire(map, 0, 0, 2, 0, ((void *)0), ({ __label__ __here; __here: (unsigned long)&&__here; }));\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void rcu_lock_release(struct lockdep_map *map)\r
{\r
 lock_release(map, ({ __label__ __here; __here: (unsigned long)&&__here; }));\r
}\r
\r
int debug_lockdep_rcu_enabled(void);\r
int rcu_read_lock_held(void);\r
int rcu_read_lock_bh_held(void);\r
int rcu_read_lock_sched_held(void);\r
int rcu_read_lock_any_held(void);\r
# 690 "./include/linux/rcupdate.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void rcu_read_lock(void)\r
{\r
 __rcu_read_lock();\r
 (void)0;\r
 rcu_lock_acquire(&rcu_lock_map);\r
 do { } while (0 && (!rcu_is_watching()));\r
\r
}\r
# 721 "./include/linux/rcupdate.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void rcu_read_unlock(void)\r
{\r
 do { } while (0 && (!rcu_is_watching()));\r
\r
 (void)0;\r
 __rcu_read_unlock();\r
 rcu_lock_release(&rcu_lock_map);\r
}\r
# 744 "./include/linux/rcupdate.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void rcu_read_lock_bh(void)\r
{\r
 local_bh_disable();\r
 (void)0;\r
 rcu_lock_acquire(&rcu_bh_lock_map);\r
 do { } while (0 && (!rcu_is_watching()));\r
\r
}\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void rcu_read_unlock_bh(void)\r
{\r
 do { } while (0 && (!rcu_is_watching()));\r
\r
 rcu_lock_release(&rcu_bh_lock_map);\r
 (void)0;\r
 local_bh_enable();\r
}\r
# 782 "./include/linux/rcupdate.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void rcu_read_lock_sched(void)\r
{\r
 do { __preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);\r
 (void)0;\r
 rcu_lock_acquire(&rcu_sched_lock_map);\r
 do { } while (0 && (!rcu_is_watching()));\r
\r
}\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((patchable_function_entry(0, 0))) void rcu_read_lock_sched_notrace(void)\r
{\r
 do { __preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);\r
 (void)0;\r
}\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void rcu_read_unlock_sched(void)\r
{\r
 do { } while (0 && (!rcu_is_watching()));\r
\r
 rcu_lock_release(&rcu_sched_lock_map);\r
 (void)0;\r
 do { __asm__ __volatile__("": : :"memory"); __preempt_count_sub(1); } while (0);\r
}\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((patchable_function_entry(0, 0))) void rcu_read_unlock_sched_notrace(void)\r
{\r
 (void)0;\r
 do { __asm__ __volatile__("": : :"memory"); __preempt_count_sub(1); } while (0);\r
}\r
# 982 "./include/linux/rcupdate.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void rcu_head_init(struct callback_head *rhp)\r
{\r
 rhp->func = (rcu_callback_t)~0L;\r
}\r
# 1000 "./include/linux/rcupdate.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool\r
rcu_head_after_call_rcu(struct callback_head *rhp, rcu_callback_t f)\r
{\r
 rcu_callback_t func = ({ do { __attribute__((__noreturn__)) extern void __compiletime_assert_63(void) ; if (!((sizeof(rhp->func) == sizeof(char) || sizeof(rhp->func) == sizeof(short) || sizeof(rhp->func) == sizeof(int) || sizeof(rhp->func) == sizeof(long)) || sizeof(rhp->func) == sizeof(long long))) __compiletime_assert_63(); } while (0); (*(const volatile typeof( _Generic((rhp->func), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (rhp->func))) *)&(rhp->func)); });\r
\r
 if (func == f)\r
  return true;\r
 ({ int __ret_warn_on = !!(func != (rcu_callback_t)~0L); if (__builtin_expect(!!(__ret_warn_on), 0)) do { __asm__ __volatile__ ( "1:\n\t" "ebreak\n" ".pushsection __bug_table,\"aw\"\n\t" "2:\n\t" ".word" " 1b - 2b" "\n\t" ".word" " %0 - 2b" "\n\t" ".half" " %1\n\t" ".half" " %2" "\n\t" ".org 2b + %3\n\t" ".popsection" : : "i" ("include/linux/rcupdate.h"), "i" (1007), "i" ((1 << 0)|((1 << 1) | ((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); __builtin_expect(!!(__ret_warn_on), 0); });\r
 return false;\r
}\r
\r
\r
extern int rcu_expedited;\r
extern int rcu_normal;\r
# 25 "./include/linux/rbtree.h" 2\r
# 39 "./include/linux/rbtree.h"\r
extern void rb_insert_color(struct rb_node *, struct rb_root *);\r
extern void rb_erase(struct rb_node *, struct rb_root *);\r
\r
\r
\r
extern struct rb_node *rb_next(const struct rb_node *);\r
extern struct rb_node *rb_prev(const struct rb_node *);\r
extern struct rb_node *rb_first(const struct rb_root *);\r
extern struct rb_node *rb_last(const struct rb_root *);\r
\r
\r
extern struct rb_node *rb_first_postorder(const struct rb_root *);\r
extern struct rb_node *rb_next_postorder(const struct rb_node *);\r
\r
\r
extern void rb_replace_node(struct rb_node *victim, struct rb_node *new,\r
       struct rb_root *root);\r
extern void rb_replace_node_rcu(struct rb_node *victim, struct rb_node *new,\r
    struct rb_root *root);\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void rb_link_node(struct rb_node *node, struct rb_node *parent,\r
    struct rb_node **rb_link)\r
{\r
 node->__rb_parent_color = (unsigned long)parent;\r
 node->rb_left = node->rb_right = ((void *)0);\r
\r
 *rb_link = node;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void rb_link_node_rcu(struct rb_node *node, struct rb_node *parent,\r
        struct rb_node **rb_link)\r
{\r
 node->__rb_parent_color = (unsigned long)parent;\r
 node->rb_left = node->rb_right = ((void *)0);\r
\r
 do { uintptr_t _r_a_p__v = (uintptr_t)(node); ; if (__builtin_constant_p(node) && (_r_a_p__v) == (uintptr_t)((void *)0)) do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_64(void) ; if (!((sizeof((*rb_link)) == sizeof(char) || sizeof((*rb_link)) == sizeof(short) || sizeof((*rb_link)) == sizeof(int) || sizeof((*rb_link)) == sizeof(long)) || sizeof((*rb_link)) == sizeof(long long))) __compiletime_assert_64(); } while (0); do { *(volatile typeof((*rb_link)) *)&((*rb_link)) = ((typeof(*rb_link))(_r_a_p__v)); } while (0); } while (0); else do { do { } while (0); do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_65(void) ; if (!((sizeof(*&*rb_link) == sizeof(char) || sizeof(*&*rb_link) == sizeof(short) || sizeof(*&*rb_link) == sizeof(int) || sizeof(*&*rb_link) == sizeof(long)))) __compiletime_assert_65(); } while (0); __asm__ __volatile__ ("fence " "rw" "," "w" : : : "memory"); do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_66(void) ; if (!((sizeof(*&*rb_link) == sizeof(char) || sizeof(*&*rb_link) == sizeof(short) || sizeof(*&*rb_link) == sizeof(int) || sizeof(*&*rb_link) == sizeof(long)) || sizeof(*&*rb_link) == sizeof(long long))) __compiletime_assert_66(); } while (0); do { *(volatile typeof(*&*rb_link) *)&(*&*rb_link) = ((typeof(*((typeof(*rb_link))_r_a_p__v)) *)((typeof(*rb_link))_r_a_p__v)); } while (0); } while (0); } while (0); } while (0); } while (0);\r
}\r
# 108 "./include/linux/rbtree.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void rb_insert_color_cached(struct rb_node *node,\r
       struct rb_root_cached *root,\r
       bool leftmost)\r
{\r
 if (leftmost)\r
  root->rb_leftmost = node;\r
 rb_insert_color(node, &root->rb_root);\r
}\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) struct rb_node *\r
rb_erase_cached(struct rb_node *node, struct rb_root_cached *root)\r
{\r
 struct rb_node *leftmost = ((void *)0);\r
\r
 if (root->rb_leftmost == node)\r
  leftmost = root->rb_leftmost = rb_next(node);\r
\r
 rb_erase(node, &root->rb_root);\r
\r
 return leftmost;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void rb_replace_node_cached(struct rb_node *victim,\r
       struct rb_node *new,\r
       struct rb_root_cached *root)\r
{\r
 if (root->rb_leftmost == victim)\r
  root->rb_leftmost = new;\r
 rb_replace_node(victim, new, &root->rb_root);\r
}\r
# 164 "./include/linux/rbtree.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) struct rb_node *\r
rb_add_cached(struct rb_node *node, struct rb_root_cached *tree,\r
       bool (*less)(struct rb_node *, const struct rb_node *))\r
{\r
 struct rb_node **link = &tree->rb_root.rb_node;\r
 struct rb_node *parent = ((void *)0);\r
 bool leftmost = true;\r
\r
 while (*link) {\r
  parent = *link;\r
  if (less(node, parent)) {\r
   link = &parent->rb_left;\r
  } else {\r
   link = &parent->rb_right;\r
   leftmost = false;\r
  }\r
 }\r
\r
 rb_link_node(node, parent, link);\r
 rb_insert_color_cached(node, tree, leftmost);\r
\r
 return leftmost ? node : ((void *)0);\r
}\r
\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void\r
rb_add(struct rb_node *node, struct rb_root *tree,\r
       bool (*less)(struct rb_node *, const struct rb_node *))\r
{\r
 struct rb_node **link = &tree->rb_node;\r
 struct rb_node *parent = ((void *)0);\r
\r
 while (*link) {\r
  parent = *link;\r
  if (less(node, parent))\r
   link = &parent->rb_left;\r
  else\r
   link = &parent->rb_right;\r
 }\r
\r
 rb_link_node(node, parent, link);\r
 rb_insert_color(node, tree);\r
}\r
# 222 "./include/linux/rbtree.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) struct rb_node *\r
rb_find_add(struct rb_node *node, struct rb_root *tree,\r
     int (*cmp)(struct rb_node *, const struct rb_node *))\r
{\r
 struct rb_node **link = &tree->rb_node;\r
 struct rb_node *parent = ((void *)0);\r
 int c;\r
\r
 while (*link) {\r
  parent = *link;\r
  c = cmp(node, parent);\r
\r
  if (c < 0)\r
   link = &parent->rb_left;\r
  else if (c > 0)\r
   link = &parent->rb_right;\r
  else\r
   return parent;\r
 }\r
\r
 rb_link_node(node, parent, link);\r
 rb_insert_color(node, tree);\r
 return ((void *)0);\r
}\r
# 255 "./include/linux/rbtree.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) struct rb_node *\r
rb_find(const void *key, const struct rb_root *tree,\r
 int (*cmp)(const void *key, const struct rb_node *))\r
{\r
 struct rb_node *node = tree->rb_node;\r
\r
 while (node) {\r
  int c = cmp(key, node);\r
\r
  if (c < 0)\r
   node = node->rb_left;\r
  else if (c > 0)\r
   node = node->rb_right;\r
  else\r
   return node;\r
 }\r
\r
 return ((void *)0);\r
}\r
# 283 "./include/linux/rbtree.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) struct rb_node *\r
rb_find_first(const void *key, const struct rb_root *tree,\r
       int (*cmp)(const void *key, const struct rb_node *))\r
{\r
 struct rb_node *node = tree->rb_node;\r
 struct rb_node *match = ((void *)0);\r
\r
 while (node) {\r
  int c = cmp(key, node);\r
\r
  if (c <= 0) {\r
   if (!c)\r
    match = node;\r
   node = node->rb_left;\r
  } else if (c > 0) {\r
   node = node->rb_right;\r
  }\r
 }\r
\r
 return match;\r
}\r
# 313 "./include/linux/rbtree.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) struct rb_node *\r
rb_next_match(const void *key, struct rb_node *node,\r
       int (*cmp)(const void *key, const struct rb_node *))\r
{\r
 node = rb_next(node);\r
 if (node && cmp(key, node))\r
  node = ((void *)0);\r
 return node;\r
}\r
# 12 "./include/linux/mm_types.h" 2\r
# 1 "./include/linux/rwsem.h" 1\r
# 32 "./include/linux/rwsem.h"\r
# 1 "./include/linux/osq_lock.h" 1\r
\r
\r
\r
\r
\r
\r
\r
\r
struct optimistic_spin_node {\r
 struct optimistic_spin_node *next, *prev;\r
 int locked;\r
 int cpu;\r
};\r
\r
struct optimistic_spin_queue {\r
\r
\r
\r
\r
 atomic_t tail;\r
};\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void osq_lock_init(struct optimistic_spin_queue *lock)\r
{\r
 atomic_set(&lock->tail, (0));\r
}\r
\r
extern bool osq_lock(struct optimistic_spin_queue *lock);\r
extern void osq_unlock(struct optimistic_spin_queue *lock);\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool osq_is_locked(struct optimistic_spin_queue *lock)\r
{\r
 return atomic_read(&lock->tail) != (0);\r
}\r
# 33 "./include/linux/rwsem.h" 2\r
# 47 "./include/linux/rwsem.h"\r
struct rw_semaphore {\r
 atomic_long_t count;\r
\r
\r
\r
\r
\r
 atomic_long_t owner;\r
\r
 struct optimistic_spin_queue osq;\r
\r
 raw_spinlock_t wait_lock;\r
 struct list_head wait_list;\r
\r
\r
\r
\r
 struct lockdep_map dep_map;\r
\r
};\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int rwsem_is_locked(struct rw_semaphore *sem)\r
{\r
 return atomic_long_read(&sem->count) != 0;\r
}\r
# 103 "./include/linux/rwsem.h"\r
extern void __init_rwsem(struct rw_semaphore *sem, const char *name,\r
    struct lock_class_key *key);\r
# 119 "./include/linux/rwsem.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int rwsem_is_contended(struct rw_semaphore *sem)\r
{\r
 return !list_empty(&sem->wait_list);\r
}\r
# 174 "./include/linux/rwsem.h"\r
extern void down_read(struct rw_semaphore *sem);\r
extern int __attribute__((__warn_unused_result__)) down_read_interruptible(struct rw_semaphore *sem);\r
extern int __attribute__((__warn_unused_result__)) down_read_killable(struct rw_semaphore *sem);\r
\r
\r
\r
\r
extern int down_read_trylock(struct rw_semaphore *sem);\r
\r
\r
\r
\r
extern void down_write(struct rw_semaphore *sem);\r
extern int __attribute__((__warn_unused_result__)) down_write_killable(struct rw_semaphore *sem);\r
\r
\r
\r
\r
extern int down_write_trylock(struct rw_semaphore *sem);\r
\r
\r
\r
\r
extern void up_read(struct rw_semaphore *sem);\r
\r
\r
\r
\r
extern void up_write(struct rw_semaphore *sem);\r
\r
\r
\r
\r
extern void downgrade_write(struct rw_semaphore *sem);\r
# 223 "./include/linux/rwsem.h"\r
extern void down_read_nested(struct rw_semaphore *sem, int subclass);\r
extern int __attribute__((__warn_unused_result__)) down_read_killable_nested(struct rw_semaphore *sem, int subclass);\r
extern void down_write_nested(struct rw_semaphore *sem, int subclass);\r
extern int down_write_killable_nested(struct rw_semaphore *sem, int subclass);\r
extern void _down_write_nest_lock(struct rw_semaphore *sem, struct lockdep_map *nest_lock);\r
# 241 "./include/linux/rwsem.h"\r
extern void down_read_non_owner(struct rw_semaphore *sem);\r
extern void up_read_non_owner(struct rw_semaphore *sem);\r
# 13 "./include/linux/mm_types.h" 2\r
# 1 "./include/linux/completion.h" 1\r
# 12 "./include/linux/completion.h"\r
# 1 "./include/linux/swait.h" 1\r
\r
\r
\r
\r
\r
\r
\r
# 1 "./include/linux/wait.h" 1\r
# 12 "./include/linux/wait.h"\r
# 1 "./include/uapi/linux/wait.h" 1\r
# 13 "./include/linux/wait.h" 2\r
\r
typedef struct wait_queue_entry wait_queue_entry_t;\r
\r
typedef int (*wait_queue_func_t)(struct wait_queue_entry *wq_entry, unsigned mode, int flags, void *key);\r
int default_wake_function(struct wait_queue_entry *wq_entry, unsigned mode, int flags, void *key);\r
# 30 "./include/linux/wait.h"\r
struct wait_queue_entry {\r
 unsigned int flags;\r
 void *private;\r
 wait_queue_func_t func;\r
 struct list_head entry;\r
};\r
\r
struct wait_queue_head {\r
 spinlock_t lock;\r
 struct list_head head;\r
};\r
typedef struct wait_queue_head wait_queue_head_t;\r
\r
struct task_struct;\r
# 64 "./include/linux/wait.h"\r
extern void __init_waitqueue_head(struct wait_queue_head *wq_head, const char *name, struct lock_class_key *);\r
# 82 "./include/linux/wait.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void init_waitqueue_entry(struct wait_queue_entry *wq_entry, struct task_struct *p)\r
{\r
 wq_entry->flags = 0;\r
 wq_entry->private = p;\r
 wq_entry->func = default_wake_function;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void\r
init_waitqueue_func_entry(struct wait_queue_entry *wq_entry, wait_queue_func_t func)\r
{\r
 wq_entry->flags = 0;\r
 wq_entry->private = ((void *)0);\r
 wq_entry->func = func;\r
}\r
# 127 "./include/linux/wait.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int waitqueue_active(struct wait_queue_head *wq_head)\r
{\r
 return !list_empty(&wq_head->head);\r
}\r
# 140 "./include/linux/wait.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool wq_has_single_sleeper(struct wait_queue_head *wq_head)\r
{\r
 return list_is_singular(&wq_head->head);\r
}\r
# 153 "./include/linux/wait.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool wq_has_sleeper(struct wait_queue_head *wq_head)\r
{\r
\r
\r
\r
\r
\r
\r
\r
 do { do { } while (0); __asm__ __volatile__ ("fence " "rw" "," "rw" : : : "memory"); } while (0);\r
 return waitqueue_active(wq_head);\r
}\r
\r
extern void add_wait_queue(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry);\r
extern void add_wait_queue_exclusive(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry);\r
extern void add_wait_queue_priority(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry);\r
extern void remove_wait_queue(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry);\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __add_wait_queue(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry)\r
{\r
 struct list_head *head = &wq_head->head;\r
 struct wait_queue_entry *wq;\r
\r
 for (wq = ({ void *__mptr = (void *)((&wq_head->head)->next); _Static_assert(__builtin_types_compatible_p(typeof(*((&wq_head->head)->next)), typeof(((typeof(*wq) *)0)->entry)) || __builtin_types_compatible_p(typeof(*((&wq_head->head)->next)), typeof(void)), "pointer type mismatch in container_of()"); ((typeof(*wq) *)(__mptr - __builtin_offsetof(typeof(*wq), entry))); }); !(&wq->entry == (&wq_head->head)); wq = ({ void *__mptr = (void *)((wq)->entry.next); _Static_assert(__builtin_types_compatible_p(typeof(*((wq)->entry.next)), typeof(((typeof(*(wq)) *)0)->entry)) || __builtin_types_compatible_p(typeof(*((wq)->entry.next)), typeof(void)), "pointer type mismatch in container_of()"); ((typeof(*(wq)) *)(__mptr - __builtin_offsetof(typeof(*(wq)), entry))); })) {\r
  if (!(wq->flags & 0x20))\r
   break;\r
  head = &wq->entry;\r
 }\r
 list_add(&wq_entry->entry, head);\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void\r
__add_wait_queue_exclusive(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry)\r
{\r
 wq_entry->flags |= 0x01;\r
 __add_wait_queue(wq_head, wq_entry);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __add_wait_queue_entry_tail(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry)\r
{\r
 list_add_tail(&wq_entry->entry, &wq_head->head);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void\r
__add_wait_queue_entry_tail_exclusive(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry)\r
{\r
 wq_entry->flags |= 0x01;\r
 __add_wait_queue_entry_tail(wq_head, wq_entry);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void\r
__remove_wait_queue(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry)\r
{\r
 list_del(&wq_entry->entry);\r
}\r
\r
void __wake_up(struct wait_queue_head *wq_head, unsigned int mode, int nr, void *key);\r
void __wake_up_locked_key(struct wait_queue_head *wq_head, unsigned int mode, void *key);\r
void __wake_up_locked_key_bookmark(struct wait_queue_head *wq_head,\r
  unsigned int mode, void *key, wait_queue_entry_t *bookmark);\r
void __wake_up_sync_key(struct wait_queue_head *wq_head, unsigned int mode, void *key);\r
void __wake_up_locked_sync_key(struct wait_queue_head *wq_head, unsigned int mode, void *key);\r
void __wake_up_locked(struct wait_queue_head *wq_head, unsigned int mode, int nr);\r
void __wake_up_sync(struct wait_queue_head *wq_head, unsigned int mode);\r
void __wake_up_pollfree(struct wait_queue_head *wq_head);\r
# 261 "./include/linux/wait.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void wake_up_pollfree(struct wait_queue_head *wq_head)\r
{\r
\r
\r
\r
\r
\r
\r
\r
 if (waitqueue_active(wq_head))\r
  __wake_up_pollfree(wq_head);\r
}\r
# 286 "./include/linux/wait.h"\r
extern void init_wait_entry(struct wait_queue_entry *wq_entry, int flags);\r
# 770 "./include/linux/wait.h"\r
extern int do_wait_intr(wait_queue_head_t *, wait_queue_entry_t *);\r
extern int do_wait_intr_irq(wait_queue_head_t *, wait_queue_entry_t *);\r
# 1164 "./include/linux/wait.h"\r
void prepare_to_wait(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry, int state);\r
bool prepare_to_wait_exclusive(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry, int state);\r
long prepare_to_wait_event(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry, int state);\r
void finish_wait(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry);\r
long wait_woken(struct wait_queue_entry *wq_entry, unsigned mode, long timeout);\r
int woken_wake_function(struct wait_queue_entry *wq_entry, unsigned mode, int sync, void *key);\r
int autoremove_wake_function(struct wait_queue_entry *wq_entry, unsigned mode, int sync, void *key);\r
# 1189 "./include/linux/wait.h"\r
typedef int (*task_call_f)(struct task_struct *p, void *arg);\r
extern int task_call_func(struct task_struct *p, task_call_f func, void *arg);\r
# 9 "./include/linux/swait.h" 2\r
# 41 "./include/linux/swait.h"\r
struct task_struct;\r
\r
struct swait_queue_head {\r
 raw_spinlock_t lock;\r
 struct list_head task_list;\r
};\r
\r
struct swait_queue {\r
 struct task_struct *task;\r
 struct list_head task_list;\r
};\r
# 69 "./include/linux/swait.h"\r
extern void __init_swait_queue_head(struct swait_queue_head *q, const char *name,\r
        struct lock_class_key *key);\r
# 121 "./include/linux/swait.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int swait_active(struct swait_queue_head *wq)\r
{\r
 return !list_empty(&wq->task_list);\r
}\r
# 134 "./include/linux/swait.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool swq_has_sleeper(struct swait_queue_head *wq)\r
{\r
\r
\r
\r
\r
\r
\r
\r
 do { do { } while (0); __asm__ __volatile__ ("fence " "rw" "," "rw" : : : "memory"); } while (0);\r
 return swait_active(wq);\r
}\r
\r
extern void swake_up_one(struct swait_queue_head *q);\r
extern void swake_up_all(struct swait_queue_head *q);\r
extern void swake_up_locked(struct swait_queue_head *q);\r
\r
extern void prepare_to_swait_exclusive(struct swait_queue_head *q, struct swait_queue *wait, int state);\r
extern long prepare_to_swait_event(struct swait_queue_head *q, struct swait_queue *wait, int state);\r
\r
extern void __finish_swait(struct swait_queue_head *q, struct swait_queue *wait);\r
extern void finish_swait(struct swait_queue_head *q, struct swait_queue *wait);\r
# 13 "./include/linux/completion.h" 2\r
# 26 "./include/linux/completion.h"\r
struct completion {\r
 unsigned int done;\r
 struct swait_queue_head wait;\r
};\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void complete_acquire(struct completion *x) {}\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void complete_release(struct completion *x) {}\r
# 84 "./include/linux/completion.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void init_completion(struct completion *x)\r
{\r
 x->done = 0;\r
 do { static struct lock_class_key __key; __init_swait_queue_head((&x->wait), "&x->wait", &__key); } while (0);\r
}\r
# 97 "./include/linux/completion.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void reinit_completion(struct completion *x)\r
{\r
 x->done = 0;\r
}\r
\r
extern void wait_for_completion(struct completion *);\r
extern void wait_for_completion_io(struct completion *);\r
extern int wait_for_completion_interruptible(struct completion *x);\r
extern int wait_for_completion_killable(struct completion *x);\r
extern unsigned long wait_for_completion_timeout(struct completion *x,\r
         unsigned long timeout);\r
extern unsigned long wait_for_completion_io_timeout(struct completion *x,\r
          unsigned long timeout);\r
extern long wait_for_completion_interruptible_timeout(\r
 struct completion *x, unsigned long timeout);\r
extern long wait_for_completion_killable_timeout(\r
 struct completion *x, unsigned long timeout);\r
extern bool try_wait_for_completion(struct completion *x);\r
extern bool completion_done(struct completion *x);\r
\r
extern void complete(struct completion *);\r
extern void complete_all(struct completion *);\r
# 14 "./include/linux/mm_types.h" 2\r
\r
# 1 "./include/linux/uprobes.h" 1\r
# 19 "./include/linux/uprobes.h"\r
struct vm_area_struct;\r
struct mm_struct;\r
struct inode;\r
struct notifier_block;\r
struct page;\r
\r
\r
\r
\r
\r
\r
enum uprobe_filter_ctx {\r
 UPROBE_FILTER_REGISTER,\r
 UPROBE_FILTER_UNREGISTER,\r
 UPROBE_FILTER_MMAP,\r
};\r
\r
struct uprobe_consumer {\r
 int (*handler)(struct uprobe_consumer *self, struct pt_regs *regs);\r
 int (*ret_handler)(struct uprobe_consumer *self,\r
    unsigned long func,\r
    struct pt_regs *regs);\r
 bool (*filter)(struct uprobe_consumer *self,\r
    enum uprobe_filter_ctx ctx,\r
    struct mm_struct *mm);\r
\r
 struct uprobe_consumer *next;\r
};\r
\r
\r
\r
# 1 "./arch/riscv/include/asm/uprobes.h" 1\r
\r
\r
\r
\r
\r
# 1 "./arch/riscv/include/asm/probes.h" 1\r
\r
\r
\r
\r
\r
typedef u32 probe_opcode_t;\r
typedef bool (probes_handler_t) (u32 opcode, unsigned long addr, struct pt_regs *);\r
\r
\r
struct arch_probe_insn {\r
 probe_opcode_t *insn;\r
 probes_handler_t *handler;\r
\r
 unsigned long restore;\r
};\r
\r
\r
typedef u32 kprobe_opcode_t;\r
struct arch_specific_insn {\r
 struct arch_probe_insn api;\r
};\r
# 7 "./arch/riscv/include/asm/uprobes.h" 2\r
# 1 "./arch/riscv/include/asm/patch.h" 1\r
\r
\r
\r
\r
\r
\r
\r
\r
int patch_text_nosync(void *addr, const void *insns, size_t len);\r
int patch_text(void *addr, u32 insn);\r
# 8 "./arch/riscv/include/asm/uprobes.h" 2\r
# 21 "./arch/riscv/include/asm/uprobes.h"\r
typedef u32 uprobe_opcode_t;\r
\r
struct arch_uprobe_task {\r
 unsigned long saved_cause;\r
};\r
\r
struct arch_uprobe {\r
 union {\r
  u8 insn[8];\r
  u8 ixol[8];\r
 };\r
 struct arch_probe_insn api;\r
 unsigned long insn_size;\r
 bool simulate;\r
};\r
\r
bool uprobe_breakpoint_handler(struct pt_regs *regs);\r
bool uprobe_single_step_handler(struct pt_regs *regs);\r
# 50 "./include/linux/uprobes.h" 2\r
\r
enum uprobe_task_state {\r
 UTASK_RUNNING,\r
 UTASK_SSTEP,\r
 UTASK_SSTEP_ACK,\r
 UTASK_SSTEP_TRAPPED,\r
};\r
\r
\r
\r
\r
struct uprobe_task {\r
 enum uprobe_task_state state;\r
\r
 union {\r
  struct {\r
   struct arch_uprobe_task autask;\r
   unsigned long vaddr;\r
  };\r
\r
  struct {\r
   struct callback_head dup_xol_work;\r
   unsigned long dup_xol_addr;\r
  };\r
 };\r
\r
 struct uprobe *active_uprobe;\r
 unsigned long xol_vaddr;\r
\r
 struct return_instance *return_instances;\r
 unsigned int depth;\r
};\r
\r
struct return_instance {\r
 struct uprobe *uprobe;\r
 unsigned long func;\r
 unsigned long stack;\r
 unsigned long orig_ret_vaddr;\r
 bool chained;\r
\r
 struct return_instance *next;\r
};\r
\r
enum rp_check {\r
 RP_CHECK_CALL,\r
 RP_CHECK_CHAIN_CALL,\r
 RP_CHECK_RET,\r
};\r
\r
struct xol_area;\r
\r
struct uprobes_state {\r
 struct xol_area *xol_area;\r
};\r
\r
extern void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((__no_sanitize__("cfi"))) uprobes_init(void);\r
extern int set_swbp(struct arch_uprobe *aup, struct mm_struct *mm, unsigned long vaddr);\r
extern int set_orig_insn(struct arch_uprobe *aup, struct mm_struct *mm, unsigned long vaddr);\r
extern bool is_swbp_insn(uprobe_opcode_t *insn);\r
extern bool is_trap_insn(uprobe_opcode_t *insn);\r
extern unsigned long uprobe_get_swbp_addr(struct pt_regs *regs);\r
extern unsigned long uprobe_get_trap_addr(struct pt_regs *regs);\r
extern int uprobe_write_opcode(struct arch_uprobe *auprobe, struct mm_struct *mm, unsigned long vaddr, uprobe_opcode_t);\r
extern int uprobe_register(struct inode *inode, loff_t offset, struct uprobe_consumer *uc);\r
extern int uprobe_register_refctr(struct inode *inode, loff_t offset, loff_t ref_ctr_offset, struct uprobe_consumer *uc);\r
extern int uprobe_apply(struct inode *inode, loff_t offset, struct uprobe_consumer *uc, bool);\r
extern void uprobe_unregister(struct inode *inode, loff_t offset, struct uprobe_consumer *uc);\r
extern int uprobe_mmap(struct vm_area_struct *vma);\r
extern void uprobe_munmap(struct vm_area_struct *vma, unsigned long start, unsigned long end);\r
extern void uprobe_start_dup_mmap(void);\r
extern void uprobe_end_dup_mmap(void);\r
extern void uprobe_dup_mmap(struct mm_struct *oldmm, struct mm_struct *newmm);\r
extern void uprobe_free_utask(struct task_struct *t);\r
extern void uprobe_copy_process(struct task_struct *t, unsigned long flags);\r
extern int uprobe_post_sstep_notifier(struct pt_regs *regs);\r
extern int uprobe_pre_sstep_notifier(struct pt_regs *regs);\r
extern void uprobe_notify_resume(struct pt_regs *regs);\r
extern bool uprobe_deny_signal(void);\r
extern bool arch_uprobe_skip_sstep(struct arch_uprobe *aup, struct pt_regs *regs);\r
extern void uprobe_clear_state(struct mm_struct *mm);\r
extern int arch_uprobe_analyze_insn(struct arch_uprobe *aup, struct mm_struct *mm, unsigned long addr);\r
extern int arch_uprobe_pre_xol(struct arch_uprobe *aup, struct pt_regs *regs);\r
extern int arch_uprobe_post_xol(struct arch_uprobe *aup, struct pt_regs *regs);\r
extern bool arch_uprobe_xol_was_trapped(struct task_struct *tsk);\r
extern int arch_uprobe_exception_notify(struct notifier_block *self, unsigned long val, void *data);\r
extern void arch_uprobe_abort_xol(struct arch_uprobe *aup, struct pt_regs *regs);\r
extern unsigned long arch_uretprobe_hijack_return_addr(unsigned long trampoline_vaddr, struct pt_regs *regs);\r
extern bool arch_uretprobe_is_alive(struct return_instance *ret, enum rp_check ctx, struct pt_regs *regs);\r
extern bool arch_uprobe_ignore(struct arch_uprobe *aup, struct pt_regs *regs);\r
extern void arch_uprobe_copy_ixol(struct page *page, unsigned long vaddr,\r
      void *src, unsigned long len);\r
# 16 "./include/linux/mm_types.h" 2\r
\r
# 1 "./include/linux/page-flags-layout.h" 1\r
\r
\r
\r
\r
# 1 "./include/linux/numa.h" 1\r
# 47 "./include/linux/numa.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int numa_map_to_online_node(int node)\r
{\r
 return (-1);\r
}\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int memory_add_physaddr_to_nid(u64 start)\r
{\r
 return 0;\r
}\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int phys_to_target_node(u64 start)\r
{\r
 return 0;\r
}\r
# 6 "./include/linux/page-flags-layout.h" 2\r
# 1 "./include/generated/bounds.h" 1\r
# 7 "./include/linux/page-flags-layout.h" 2\r
# 30 "./include/linux/page-flags-layout.h"\r
# 1 "./arch/riscv/include/asm/sparsemem.h" 1\r
# 31 "./include/linux/page-flags-layout.h" 2\r
# 18 "./include/linux/mm_types.h" 2\r
# 1 "./include/linux/workqueue.h" 1\r
\r
\r
\r
\r
\r
\r
\r
\r
# 1 "./include/linux/timer.h" 1\r
\r
\r
\r
\r
\r
# 1 "./include/linux/ktime.h" 1\r
# 24 "./include/linux/ktime.h"\r
# 1 "./include/linux/time.h" 1\r
\r
\r
\r
\r
\r
\r
\r
\r
extern struct timezone sys_tz;\r
\r
int get_timespec64(struct timespec64 *ts,\r
  const struct __kernel_timespec *uts);\r
int put_timespec64(const struct timespec64 *ts,\r
  struct __kernel_timespec *uts);\r
int get_itimerspec64(struct itimerspec64 *it,\r
   const struct __kernel_itimerspec *uit);\r
int put_itimerspec64(const struct itimerspec64 *it,\r
   struct __kernel_itimerspec *uit);\r
\r
extern time64_t mktime64(const unsigned int year, const unsigned int mon,\r
   const unsigned int day, const unsigned int hour,\r
   const unsigned int min, const unsigned int sec);\r
\r
\r
extern void clear_itimer(void);\r
\r
\r
\r
\r
extern long do_utimes(int dfd, const char *filename, struct timespec64 *times, int flags);\r
\r
\r
\r
\r
\r
struct tm {\r
\r
\r
\r
\r
 int tm_sec;\r
\r
 int tm_min;\r
\r
 int tm_hour;\r
\r
 int tm_mday;\r
\r
 int tm_mon;\r
\r
 long tm_year;\r
\r
 int tm_wday;\r
\r
 int tm_yday;\r
};\r
\r
void time64_to_tm(time64_t totalsecs, int offset, struct tm *result);\r
\r
\r
# 1 "./include/linux/time32.h" 1\r
# 13 "./include/linux/time32.h"\r
# 1 "./include/linux/timex.h" 1\r
# 56 "./include/linux/timex.h"\r
# 1 "./include/uapi/linux/timex.h" 1\r
# 56 "./include/uapi/linux/timex.h"\r
# 1 "./include/linux/time.h" 1\r
# 57 "./include/uapi/linux/timex.h" 2\r
# 97 "./include/uapi/linux/timex.h"\r
struct __kernel_timex_timeval {\r
 __kernel_time64_t tv_sec;\r
 long long tv_usec;\r
};\r
\r
struct __kernel_timex {\r
 unsigned int modes;\r
 int :32;\r
 long long offset;\r
 long long freq;\r
 long long maxerror;\r
 long long esterror;\r
 int status;\r
 int :32;\r
 long long constant;\r
 long long precision;\r
 long long tolerance;\r
\r
\r
 struct __kernel_timex_timeval time;\r
 long long tick;\r
\r
 long long ppsfreq;\r
 long long jitter;\r
 int shift;\r
 int :32;\r
 long long stabil;\r
 long long jitcnt;\r
 long long calcnt;\r
 long long errcnt;\r
 long long stbcnt;\r
\r
 int tai;\r
\r
 int :32; int :32; int :32; int :32;\r
 int :32; int :32; int :32; int :32;\r
 int :32; int :32; int :32;\r
};\r
# 57 "./include/linux/timex.h" 2\r
\r
\r
\r
\r
\r
\r
\r
\r
# 1 "./arch/riscv/include/asm/timex.h" 1\r
# 11 "./arch/riscv/include/asm/timex.h"\r
typedef unsigned long cycles_t;\r
# 51 "./arch/riscv/include/asm/timex.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) cycles_t get_cycles(void)\r
{\r
 return ({ register unsigned long __v; __asm__ __volatile__ ("csrr %0, " "0xc01" : "=r" (__v) : : "memory"); __v; });\r
}\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) u32 get_cycles_hi(void)\r
{\r
 return ({ register unsigned long __v; __asm__ __volatile__ ("csrr %0, " "0xc81" : "=r" (__v) : : "memory"); __v; });\r
}\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) u64 get_cycles64(void)\r
{\r
 return get_cycles();\r
}\r
# 85 "./arch/riscv/include/asm/timex.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int read_current_timer(unsigned long *timer_val)\r
{\r
 *timer_val = get_cycles();\r
 return 0;\r
}\r
\r
extern void time_init(void);\r
# 66 "./include/linux/timex.h" 2\r
# 139 "./include/linux/timex.h"\r
extern unsigned long tick_usec;\r
extern unsigned long tick_nsec;\r
# 154 "./include/linux/timex.h"\r
extern int do_adjtimex(struct __kernel_timex *);\r
extern int do_clock_adjtime(const clockid_t which_clock, struct __kernel_timex * ktx);\r
\r
extern void hardpps(const struct timespec64 *, const struct timespec64 *);\r
\r
int read_current_timer(unsigned long *timer_val);\r
# 14 "./include/linux/time32.h" 2\r
\r
# 1 "./include/vdso/time32.h" 1\r
\r
\r
\r
\r
typedef s32 old_time32_t;\r
\r
struct old_timespec32 {\r
 old_time32_t tv_sec;\r
 s32 tv_nsec;\r
};\r
\r
struct old_timeval32 {\r
 old_time32_t tv_sec;\r
 s32 tv_usec;\r
};\r
# 16 "./include/linux/time32.h" 2\r
\r
struct old_itimerspec32 {\r
 struct old_timespec32 it_interval;\r
 struct old_timespec32 it_value;\r
};\r
\r
struct old_utimbuf32 {\r
 old_time32_t actime;\r
 old_time32_t modtime;\r
};\r
\r
struct old_timex32 {\r
 u32 modes;\r
 s32 offset;\r
 s32 freq;\r
 s32 maxerror;\r
 s32 esterror;\r
 s32 status;\r
 s32 constant;\r
 s32 precision;\r
 s32 tolerance;\r
 struct old_timeval32 time;\r
 s32 tick;\r
 s32 ppsfreq;\r
 s32 jitter;\r
 s32 shift;\r
 s32 stabil;\r
 s32 jitcnt;\r
 s32 calcnt;\r
 s32 errcnt;\r
 s32 stbcnt;\r
 s32 tai;\r
\r
 s32:32; s32:32; s32:32; s32:32;\r
 s32:32; s32:32; s32:32; s32:32;\r
 s32:32; s32:32; s32:32;\r
};\r
\r
extern int get_old_timespec32(struct timespec64 *, const void *);\r
extern int put_old_timespec32(const struct timespec64 *, void *);\r
extern int get_old_itimerspec32(struct itimerspec64 *its,\r
   const struct old_itimerspec32 *uits);\r
extern int put_old_itimerspec32(const struct itimerspec64 *its,\r
   struct old_itimerspec32 *uits);\r
struct __kernel_timex;\r
int get_old_timex32(struct __kernel_timex *, const struct old_timex32 *);\r
int put_old_timex32(struct old_timex32 *, const struct __kernel_timex *);\r
\r
\r
\r
\r
\r
\r
\r
extern struct __kernel_old_timeval ns_to_kernel_old_timeval(s64 nsec);\r
# 61 "./include/linux/time.h" 2\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool itimerspec64_valid(const struct itimerspec64 *its)\r
{\r
 if (!timespec64_valid(&(its->it_interval)) ||\r
  !timespec64_valid(&(its->it_value)))\r
  return false;\r
\r
 return true;\r
}\r
# 100 "./include/linux/time.h"\r
# 1 "./include/vdso/time.h" 1\r
\r
\r
\r
\r
\r
\r
struct timens_offset {\r
 s64 sec;\r
 u64 nsec;\r
};\r
# 101 "./include/linux/time.h" 2\r
# 25 "./include/linux/ktime.h" 2\r
# 1 "./include/linux/jiffies.h" 1\r
# 12 "./include/linux/jiffies.h"\r
# 1 "./include/vdso/jiffies.h" 1\r
\r
\r
\r
\r
# 1 "./arch/riscv/include/generated/uapi/asm/param.h" 1\r
# 6 "./include/vdso/jiffies.h" 2\r
# 13 "./include/linux/jiffies.h" 2\r
# 1 "./arch/riscv/include/generated/uapi/asm/param.h" 1\r
# 14 "./include/linux/jiffies.h" 2\r
# 1 "./include/generated/timeconst.h" 1\r
# 15 "./include/linux/jiffies.h" 2\r
# 62 "./include/linux/jiffies.h"\r
extern int register_refined_jiffies(long clock_tick_rate);\r
# 79 "./include/linux/jiffies.h"\r
extern u64 __attribute__((__aligned__((1 << 6)), __section__(".data..cacheline_aligned"))) jiffies_64;\r
extern unsigned long volatile __attribute__((__aligned__((1 << 6)), __section__(".data..cacheline_aligned"))) jiffies;\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) u64 get_jiffies_64(void)\r
{\r
 return (u64)jiffies;\r
}\r
# 189 "./include/linux/jiffies.h"\r
extern unsigned long preset_lpj;\r
# 290 "./include/linux/jiffies.h"\r
extern unsigned int jiffies_to_msecs(const unsigned long j);\r
extern unsigned int jiffies_to_usecs(const unsigned long j);\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) u64 jiffies_to_nsecs(const unsigned long j)\r
{\r
 return (u64)jiffies_to_usecs(j) * 1000L;\r
}\r
\r
extern u64 jiffies64_to_nsecs(u64 j);\r
extern u64 jiffies64_to_msecs(u64 j);\r
\r
extern unsigned long __msecs_to_jiffies(const unsigned int m);\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) unsigned long _msecs_to_jiffies(const unsigned int m)\r
{\r
 return (m + (1000L / 100) - 1) / (1000L / 100);\r
}\r
# 363 "./include/linux/jiffies.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) unsigned long msecs_to_jiffies(const unsigned int m)\r
{\r
 if (__builtin_constant_p(m)) {\r
  if ((int)m < 0)\r
   return ((((long)(~0UL >> 1)) >> 1)-1);\r
  return _msecs_to_jiffies(m);\r
 } else {\r
  return __msecs_to_jiffies(m);\r
 }\r
}\r
\r
extern unsigned long __usecs_to_jiffies(const unsigned int u);\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) unsigned long _usecs_to_jiffies(const unsigned int u)\r
{\r
 return (u + (1000000L / 100) - 1) / (1000000L / 100);\r
}\r
# 410 "./include/linux/jiffies.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) unsigned long usecs_to_jiffies(const unsigned int u)\r
{\r
 if (__builtin_constant_p(u)) {\r
  if (u > jiffies_to_usecs(((((long)(~0UL >> 1)) >> 1)-1)))\r
   return ((((long)(~0UL >> 1)) >> 1)-1);\r
  return _usecs_to_jiffies(u);\r
 } else {\r
  return __usecs_to_jiffies(u);\r
 }\r
}\r
\r
extern unsigned long timespec64_to_jiffies(const struct timespec64 *value);\r
extern void jiffies_to_timespec64(const unsigned long jiffies,\r
      struct timespec64 *value);\r
extern clock_t jiffies_to_clock_t(unsigned long x);\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) clock_t jiffies_delta_to_clock_t(long delta)\r
{\r
 return jiffies_to_clock_t(__builtin_choose_expr(((!!(sizeof((typeof(0L) *)1 == (typeof(delta) *)1))) && ((sizeof(int) == sizeof(*(8 ? ((void *)((long)(0L) * 0l)) : (int *)8))) && (sizeof(int) == sizeof(*(8 ? ((void *)((long)(delta) * 0l)) : (int *)8))))), ((0L) > (delta) ? (0L) : (delta)), ({ typeof(0L) __UNIQUE_ID___x67 = (0L); typeof(delta) __UNIQUE_ID___y68 = (delta); ((__UNIQUE_ID___x67) > (__UNIQUE_ID___y68) ? (__UNIQUE_ID___x67) : (__UNIQUE_ID___y68)); })));\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) unsigned int jiffies_delta_to_msecs(long delta)\r
{\r
 return jiffies_to_msecs(__builtin_choose_expr(((!!(sizeof((typeof(0L) *)1 == (typeof(delta) *)1))) && ((sizeof(int) == sizeof(*(8 ? ((void *)((long)(0L) * 0l)) : (int *)8))) && (sizeof(int) == sizeof(*(8 ? ((void *)((long)(delta) * 0l)) : (int *)8))))), ((0L) > (delta) ? (0L) : (delta)), ({ typeof(0L) __UNIQUE_ID___x69 = (0L); typeof(delta) __UNIQUE_ID___y70 = (delta); ((__UNIQUE_ID___x69) > (__UNIQUE_ID___y70) ? (__UNIQUE_ID___x69) : (__UNIQUE_ID___y70)); })));\r
}\r
\r
extern unsigned long clock_t_to_jiffies(unsigned long x);\r
extern u64 jiffies_64_to_clock_t(u64 x);\r
extern u64 nsec_to_clock_t(u64 x);\r
extern u64 nsecs_to_jiffies64(u64 n);\r
extern unsigned long nsecs_to_jiffies(u64 n);\r
# 26 "./include/linux/ktime.h" 2\r
\r
\r
\r
typedef s64 ktime_t;\r
# 38 "./include/linux/ktime.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) ktime_t ktime_set(const s64 secs, const unsigned long nsecs)\r
{\r
 if (__builtin_expect(!!(secs >= (((s64)~((u64)1 << 63)) / 1000000000L)), 0))\r
  return ((s64)~((u64)1 << 63));\r
\r
 return secs * 1000000000L + (s64)nsecs;\r
}\r
# 71 "./include/linux/ktime.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) ktime_t timespec64_to_ktime(struct timespec64 ts)\r
{\r
 return ktime_set(ts.tv_sec, ts.tv_nsec);\r
}\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) s64 ktime_to_ns(const ktime_t kt)\r
{\r
 return kt;\r
}\r
# 95 "./include/linux/ktime.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int ktime_compare(const ktime_t cmp1, const ktime_t cmp2)\r
{\r
 if (cmp1 < cmp2)\r
  return -1;\r
 if (cmp1 > cmp2)\r
  return 1;\r
 return 0;\r
}\r
# 111 "./include/linux/ktime.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool ktime_after(const ktime_t cmp1, const ktime_t cmp2)\r
{\r
 return ktime_compare(cmp1, cmp2) > 0;\r
}\r
# 123 "./include/linux/ktime.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool ktime_before(const ktime_t cmp1, const ktime_t cmp2)\r
{\r
 return ktime_compare(cmp1, cmp2) < 0;\r
}\r
# 148 "./include/linux/ktime.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) s64 ktime_divns(const ktime_t kt, s64 div)\r
{\r
\r
\r
\r
\r
 ({ int __ret_warn_on = !!(div < 0); if (__builtin_expect(!!(__ret_warn_on), 0)) do { __asm__ __volatile__ ( "1:\n\t" "ebreak\n" ".pushsection __bug_table,\"aw\"\n\t" "2:\n\t" ".word" " 1b - 2b" "\n\t" ".word" " %0 - 2b" "\n\t" ".half" " %1\n\t" ".half" " %2" "\n\t" ".org 2b + %3\n\t" ".popsection" : : "i" ("include/linux/ktime.h"), "i" (154), "i" ((1 << 0)|(((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); __builtin_expect(!!(__ret_warn_on), 0); });\r
 return kt / div;\r
}\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) s64 ktime_to_us(const ktime_t kt)\r
{\r
 return ktime_divns(kt, 1000L);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) s64 ktime_to_ms(const ktime_t kt)\r
{\r
 return ktime_divns(kt, 1000000L);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) s64 ktime_us_delta(const ktime_t later, const ktime_t earlier)\r
{\r
       return ktime_to_us(((later) - (earlier)));\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) s64 ktime_ms_delta(const ktime_t later, const ktime_t earlier)\r
{\r
 return ktime_to_ms(((later) - (earlier)));\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) ktime_t ktime_add_us(const ktime_t kt, const u64 usec)\r
{\r
 return ((kt) + (usec * 1000L));\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) ktime_t ktime_add_ms(const ktime_t kt, const u64 msec)\r
{\r
 return ((kt) + (msec * 1000000L));\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) ktime_t ktime_sub_us(const ktime_t kt, const u64 usec)\r
{\r
 return ((kt) - (usec * 1000L));\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) ktime_t ktime_sub_ms(const ktime_t kt, const u64 msec)\r
{\r
 return ((kt) - (msec * 1000000L));\r
}\r
\r
extern ktime_t ktime_add_safe(const ktime_t lhs, const ktime_t rhs);\r
# 209 "./include/linux/ktime.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__warn_unused_result__)) bool ktime_to_timespec64_cond(const ktime_t kt,\r
             struct timespec64 *ts)\r
{\r
 if (kt) {\r
  *ts = ns_to_timespec64((kt));\r
  return true;\r
 } else {\r
  return false;\r
 }\r
}\r
\r
\r
# 1 "./include/vdso/ktime.h" 1\r
# 221 "./include/linux/ktime.h" 2\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) ktime_t ns_to_ktime(u64 ns)\r
{\r
 return ns;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) ktime_t ms_to_ktime(u64 ms)\r
{\r
 return ms * 1000000L;\r
}\r
\r
\r
# 1 "./include/linux/timekeeping.h" 1\r
\r
\r
\r
\r
\r
# 1 "./include/linux/clocksource_ids.h" 1\r
\r
\r
\r
\r
\r
enum clocksource_ids {\r
 CSID_GENERIC = 0,\r
 CSID_ARM_ARCH_COUNTER,\r
 CSID_MAX,\r
};\r
# 7 "./include/linux/timekeeping.h" 2\r
\r
\r
\r
void timekeeping_init(void);\r
extern int timekeeping_suspended;\r
\r
\r
extern void legacy_timer_tick(unsigned long ticks);\r
\r
\r
\r
\r
extern int do_settimeofday64(const struct timespec64 *ts);\r
extern int do_sys_settimeofday64(const struct timespec64 *tv,\r
     const struct timezone *tz);\r
# 41 "./include/linux/timekeeping.h"\r
extern void ktime_get_raw_ts64(struct timespec64 *ts);\r
extern void ktime_get_ts64(struct timespec64 *ts);\r
extern void ktime_get_real_ts64(struct timespec64 *tv);\r
extern void ktime_get_coarse_ts64(struct timespec64 *ts);\r
extern void ktime_get_coarse_real_ts64(struct timespec64 *ts);\r
\r
void getboottime64(struct timespec64 *ts);\r
\r
\r
\r
\r
extern time64_t ktime_get_seconds(void);\r
extern time64_t __ktime_get_real_seconds(void);\r
extern time64_t ktime_get_real_seconds(void);\r
\r
\r
\r
\r
\r
enum tk_offsets {\r
 TK_OFFS_REAL,\r
 TK_OFFS_BOOT,\r
 TK_OFFS_TAI,\r
 TK_OFFS_MAX,\r
};\r
\r
extern ktime_t ktime_get(void);\r
extern ktime_t ktime_get_with_offset(enum tk_offsets offs);\r
extern ktime_t ktime_get_coarse_with_offset(enum tk_offsets offs);\r
extern ktime_t ktime_mono_to_any(ktime_t tmono, enum tk_offsets offs);\r
extern ktime_t ktime_get_raw(void);\r
extern u32 ktime_get_resolution_ns(void);\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) ktime_t ktime_get_real(void)\r
{\r
 return ktime_get_with_offset(TK_OFFS_REAL);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) ktime_t ktime_get_coarse_real(void)\r
{\r
 return ktime_get_coarse_with_offset(TK_OFFS_REAL);\r
}\r
\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) ktime_t ktime_get_boottime(void)\r
{\r
 return ktime_get_with_offset(TK_OFFS_BOOT);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) ktime_t ktime_get_coarse_boottime(void)\r
{\r
 return ktime_get_coarse_with_offset(TK_OFFS_BOOT);\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) ktime_t ktime_get_clocktai(void)\r
{\r
 return ktime_get_with_offset(TK_OFFS_TAI);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) ktime_t ktime_get_coarse_clocktai(void)\r
{\r
 return ktime_get_coarse_with_offset(TK_OFFS_TAI);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) ktime_t ktime_get_coarse(void)\r
{\r
 struct timespec64 ts;\r
\r
 ktime_get_coarse_ts64(&ts);\r
 return timespec64_to_ktime(ts);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) u64 ktime_get_coarse_ns(void)\r
{\r
 return ktime_to_ns(ktime_get_coarse());\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) u64 ktime_get_coarse_real_ns(void)\r
{\r
 return ktime_to_ns(ktime_get_coarse_real());\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) u64 ktime_get_coarse_boottime_ns(void)\r
{\r
 return ktime_to_ns(ktime_get_coarse_boottime());\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) u64 ktime_get_coarse_clocktai_ns(void)\r
{\r
 return ktime_to_ns(ktime_get_coarse_clocktai());\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) ktime_t ktime_mono_to_real(ktime_t mono)\r
{\r
 return ktime_mono_to_any(mono, TK_OFFS_REAL);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) u64 ktime_get_ns(void)\r
{\r
 return ktime_to_ns(ktime_get());\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) u64 ktime_get_real_ns(void)\r
{\r
 return ktime_to_ns(ktime_get_real());\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) u64 ktime_get_boottime_ns(void)\r
{\r
 return ktime_to_ns(ktime_get_boottime());\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) u64 ktime_get_clocktai_ns(void)\r
{\r
 return ktime_to_ns(ktime_get_clocktai());\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) u64 ktime_get_raw_ns(void)\r
{\r
 return ktime_to_ns(ktime_get_raw());\r
}\r
\r
extern u64 ktime_get_mono_fast_ns(void);\r
extern u64 ktime_get_raw_fast_ns(void);\r
extern u64 ktime_get_boot_fast_ns(void);\r
extern u64 ktime_get_real_fast_ns(void);\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void ktime_get_boottime_ts64(struct timespec64 *ts)\r
{\r
 *ts = ns_to_timespec64((ktime_get_boottime()));\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void ktime_get_coarse_boottime_ts64(struct timespec64 *ts)\r
{\r
 *ts = ns_to_timespec64((ktime_get_coarse_boottime()));\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) time64_t ktime_get_boottime_seconds(void)\r
{\r
 return ktime_divns(ktime_get_coarse_boottime(), 1000000000L);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void ktime_get_clocktai_ts64(struct timespec64 *ts)\r
{\r
 *ts = ns_to_timespec64((ktime_get_clocktai()));\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void ktime_get_coarse_clocktai_ts64(struct timespec64 *ts)\r
{\r
 *ts = ns_to_timespec64((ktime_get_coarse_clocktai()));\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) time64_t ktime_get_clocktai_seconds(void)\r
{\r
 return ktime_divns(ktime_get_coarse_clocktai(), 1000000000L);\r
}\r
\r
\r
\r
\r
extern bool timekeeping_rtc_skipsuspend(void);\r
extern bool timekeeping_rtc_skipresume(void);\r
\r
extern void timekeeping_inject_sleeptime64(const struct timespec64 *delta);\r
\r
\r
\r
\r
\r
\r
\r
struct ktime_timestamps {\r
 u64 mono;\r
 u64 boot;\r
 u64 real;\r
};\r
# 246 "./include/linux/timekeeping.h"\r
struct system_time_snapshot {\r
 u64 cycles;\r
 ktime_t real;\r
 ktime_t raw;\r
 enum clocksource_ids cs_id;\r
 unsigned int clock_was_set_seq;\r
 u8 cs_was_changed_seq;\r
};\r
# 262 "./include/linux/timekeeping.h"\r
struct system_device_crosststamp {\r
 ktime_t device;\r
 ktime_t sys_realtime;\r
 ktime_t sys_monoraw;\r
};\r
# 275 "./include/linux/timekeeping.h"\r
struct system_counterval_t {\r
 u64 cycles;\r
 struct clocksource *cs;\r
};\r
\r
\r
\r
\r
extern int get_device_system_crosststamp(\r
   int (*get_time_fn)(ktime_t *device_time,\r
    struct system_counterval_t *system_counterval,\r
    void *ctx),\r
   void *ctx,\r
   struct system_time_snapshot *history,\r
   struct system_device_crosststamp *xtstamp);\r
\r
\r
\r
\r
extern void ktime_get_snapshot(struct system_time_snapshot *systime_snapshot);\r
\r
\r
extern void ktime_get_fast_timestamps(struct ktime_timestamps *snap);\r
\r
\r
\r
\r
extern int persistent_clock_is_local;\r
\r
extern void read_persistent_clock64(struct timespec64 *ts);\r
void read_persistent_wall_and_boot_offset(struct timespec64 *wall_clock,\r
       struct timespec64 *boot_offset);\r
# 233 "./include/linux/ktime.h" 2\r
# 7 "./include/linux/timer.h" 2\r
\r
# 1 "./include/linux/debugobjects.h" 1\r
\r
\r
\r
\r
\r
\r
\r
enum debug_obj_state {\r
 ODEBUG_STATE_NONE,\r
 ODEBUG_STATE_INIT,\r
 ODEBUG_STATE_INACTIVE,\r
 ODEBUG_STATE_ACTIVE,\r
 ODEBUG_STATE_DESTROYED,\r
 ODEBUG_STATE_NOTAVAILABLE,\r
 ODEBUG_STATE_MAX,\r
};\r
\r
struct debug_obj_descr;\r
# 28 "./include/linux/debugobjects.h"\r
struct debug_obj {\r
 struct hlist_node node;\r
 enum debug_obj_state state;\r
 unsigned int astate;\r
 void *object;\r
 const struct debug_obj_descr *descr;\r
};\r
# 55 "./include/linux/debugobjects.h"\r
struct debug_obj_descr {\r
 const char *name;\r
 void *(*debug_hint)(void *addr);\r
 bool (*is_static_object)(void *addr);\r
 bool (*fixup_init)(void *addr, enum debug_obj_state state);\r
 bool (*fixup_activate)(void *addr, enum debug_obj_state state);\r
 bool (*fixup_destroy)(void *addr, enum debug_obj_state state);\r
 bool (*fixup_free)(void *addr, enum debug_obj_state state);\r
 bool (*fixup_assert_init)(void *addr, enum debug_obj_state state);\r
};\r
# 88 "./include/linux/debugobjects.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void\r
debug_object_init (void *addr, const struct debug_obj_descr *descr) { }\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void\r
debug_object_init_on_stack(void *addr, const struct debug_obj_descr *descr) { }\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int\r
debug_object_activate (void *addr, const struct debug_obj_descr *descr) { return 0; }\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void\r
debug_object_deactivate(void *addr, const struct debug_obj_descr *descr) { }\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void\r
debug_object_destroy (void *addr, const struct debug_obj_descr *descr) { }\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void\r
debug_object_free (void *addr, const struct debug_obj_descr *descr) { }\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void\r
debug_object_assert_init(void *addr, const struct debug_obj_descr *descr) { }\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void debug_objects_early_init(void) { }\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void debug_objects_mem_init(void) { }\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void\r
debug_check_no_obj_freed(const void *address, unsigned long size) { }\r
# 9 "./include/linux/timer.h" 2\r
\r
\r
struct timer_list {\r
\r
\r
\r
\r
 struct hlist_node entry;\r
 unsigned long expires;\r
 void (*function)(struct timer_list *);\r
 u32 flags;\r
\r
\r
 struct lockdep_map lockdep_map;\r
\r
};\r
# 91 "./include/linux/timer.h"\r
void init_timer_key(struct timer_list *timer,\r
      void (*func)(struct timer_list *), unsigned int flags,\r
      const char *name, struct lock_class_key *key);\r
\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void init_timer_on_stack_key(struct timer_list *timer,\r
        void (*func)(struct timer_list *),\r
        unsigned int flags,\r
        const char *name,\r
        struct lock_class_key *key)\r
{\r
 init_timer_key(timer, func, flags, name, key);\r
}\r
# 150 "./include/linux/timer.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void destroy_timer_on_stack(struct timer_list *timer) { }\r
# 166 "./include/linux/timer.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int timer_pending(const struct timer_list * timer)\r
{\r
 return !hlist_unhashed_lockless(&timer->entry);\r
}\r
\r
extern void add_timer_on(struct timer_list *timer, int cpu);\r
extern int del_timer(struct timer_list * timer);\r
extern int mod_timer(struct timer_list *timer, unsigned long expires);\r
extern int mod_timer_pending(struct timer_list *timer, unsigned long expires);\r
extern int timer_reduce(struct timer_list *timer, unsigned long expires);\r
\r
\r
\r
\r
\r
\r
\r
extern void add_timer(struct timer_list *timer);\r
\r
extern int try_to_del_timer_sync(struct timer_list *timer);\r
\r
\r
  extern int del_timer_sync(struct timer_list *timer);\r
\r
\r
\r
\r
\r
\r
extern void init_timers(void);\r
struct hrtimer;\r
extern enum hrtimer_restart it_real_fn(struct hrtimer *);\r
\r
\r
struct ctl_table;\r
\r
extern unsigned int sysctl_timer_migration;\r
int timer_migration_handler(struct ctl_table *table, int write,\r
       void *buffer, size_t *lenp, loff_t *ppos);\r
\r
\r
unsigned long __round_jiffies(unsigned long j, int cpu);\r
unsigned long __round_jiffies_relative(unsigned long j, int cpu);\r
unsigned long round_jiffies(unsigned long j);\r
unsigned long round_jiffies_relative(unsigned long j);\r
\r
unsigned long __round_jiffies_up(unsigned long j, int cpu);\r
unsigned long __round_jiffies_up_relative(unsigned long j, int cpu);\r
unsigned long round_jiffies_up(unsigned long j);\r
unsigned long round_jiffies_up_relative(unsigned long j);\r
\r
\r
int timers_prepare_cpu(unsigned int cpu);\r
int timers_dead_cpu(unsigned int cpu);\r
# 10 "./include/linux/workqueue.h" 2\r
\r
\r
\r
\r
\r
\r
\r
\r
struct workqueue_struct;\r
\r
struct work_struct;\r
typedef void (*work_func_t)(struct work_struct *work);\r
void delayed_work_timer_fn(struct timer_list *t);\r
\r
\r
\r
\r
\r
\r
\r
enum {\r
 WORK_STRUCT_PENDING_BIT = 0,\r
 WORK_STRUCT_INACTIVE_BIT= 1,\r
 WORK_STRUCT_PWQ_BIT = 2,\r
 WORK_STRUCT_LINKED_BIT = 3,\r
\r
\r
\r
\r
 WORK_STRUCT_COLOR_SHIFT = 4,\r
\r
\r
 WORK_STRUCT_COLOR_BITS = 4,\r
\r
 WORK_STRUCT_PENDING = 1 << WORK_STRUCT_PENDING_BIT,\r
 WORK_STRUCT_INACTIVE = 1 << WORK_STRUCT_INACTIVE_BIT,\r
 WORK_STRUCT_PWQ = 1 << WORK_STRUCT_PWQ_BIT,\r
 WORK_STRUCT_LINKED = 1 << WORK_STRUCT_LINKED_BIT,\r
\r
\r
\r
 WORK_STRUCT_STATIC = 0,\r
\r
\r
 WORK_NR_COLORS = (1 << WORK_STRUCT_COLOR_BITS),\r
\r
\r
 WORK_CPU_UNBOUND = 32,\r
\r
\r
\r
\r
\r
\r
 WORK_STRUCT_FLAG_BITS = WORK_STRUCT_COLOR_SHIFT +\r
      WORK_STRUCT_COLOR_BITS,\r
\r
\r
 WORK_OFFQ_FLAG_BASE = WORK_STRUCT_COLOR_SHIFT,\r
\r
 __WORK_OFFQ_CANCELING = WORK_OFFQ_FLAG_BASE,\r
 WORK_OFFQ_CANCELING = (1 << __WORK_OFFQ_CANCELING),\r
\r
\r
\r
\r
\r
\r
 WORK_OFFQ_FLAG_BITS = 1,\r
 WORK_OFFQ_POOL_SHIFT = WORK_OFFQ_FLAG_BASE + WORK_OFFQ_FLAG_BITS,\r
 WORK_OFFQ_LEFT = 64 - WORK_OFFQ_POOL_SHIFT,\r
 WORK_OFFQ_POOL_BITS = WORK_OFFQ_LEFT <= 31 ? WORK_OFFQ_LEFT : 31,\r
 WORK_OFFQ_POOL_NONE = (1LU << WORK_OFFQ_POOL_BITS) - 1,\r
\r
\r
 WORK_STRUCT_FLAG_MASK = (1UL << WORK_STRUCT_FLAG_BITS) - 1,\r
 WORK_STRUCT_WQ_DATA_MASK = ~WORK_STRUCT_FLAG_MASK,\r
 WORK_STRUCT_NO_POOL = (unsigned long)WORK_OFFQ_POOL_NONE << WORK_OFFQ_POOL_SHIFT,\r
\r
\r
 WORK_BUSY_PENDING = 1 << 0,\r
 WORK_BUSY_RUNNING = 1 << 1,\r
\r
\r
 WORKER_DESC_LEN = 24,\r
};\r
\r
struct work_struct {\r
 atomic_long_t data;\r
 struct list_head entry;\r
 work_func_t func;\r
\r
 struct lockdep_map lockdep_map;\r
\r
};\r
\r
\r
\r
\r
\r
struct delayed_work {\r
 struct work_struct work;\r
 struct timer_list timer;\r
\r
\r
 struct workqueue_struct *wq;\r
 int cpu;\r
};\r
\r
struct rcu_work {\r
 struct work_struct work;\r
 struct callback_head rcu;\r
\r
\r
 struct workqueue_struct *wq;\r
};\r
\r
\r
\r
\r
\r
\r
struct workqueue_attrs {\r
\r
\r
\r
 int nice;\r
\r
\r
\r
\r
 cpumask_var_t cpumask;\r
# 150 "./include/linux/workqueue.h"\r
 bool no_numa;\r
};\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) struct delayed_work *to_delayed_work(struct work_struct *work)\r
{\r
 return ({ void *__mptr = (void *)(work); _Static_assert(__builtin_types_compatible_p(typeof(*(work)), typeof(((struct delayed_work *)0)->work)) || __builtin_types_compatible_p(typeof(*(work)), typeof(void)), "pointer type mismatch in container_of()"); ((struct delayed_work *)(__mptr - __builtin_offsetof(struct delayed_work, work))); });\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) struct rcu_work *to_rcu_work(struct work_struct *work)\r
{\r
 return ({ void *__mptr = (void *)(work); _Static_assert(__builtin_types_compatible_p(typeof(*(work)), typeof(((struct rcu_work *)0)->work)) || __builtin_types_compatible_p(typeof(*(work)), typeof(void)), "pointer type mismatch in container_of()"); ((struct rcu_work *)(__mptr - __builtin_offsetof(struct rcu_work, work))); });\r
}\r
\r
struct execute_work {\r
 struct work_struct work;\r
};\r
# 210 "./include/linux/workqueue.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __init_work(struct work_struct *work, int onstack) { }\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void destroy_work_on_stack(struct work_struct *work) { }\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void destroy_delayed_work_on_stack(struct delayed_work *work) { }\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) unsigned int work_static(struct work_struct *work) { return 0; }\r
# 303 "./include/linux/workqueue.h"\r
enum {\r
 WQ_UNBOUND = 1 << 1,\r
 WQ_FREEZABLE = 1 << 2,\r
 WQ_MEM_RECLAIM = 1 << 3,\r
 WQ_HIGHPRI = 1 << 4,\r
 WQ_CPU_INTENSIVE = 1 << 5,\r
 WQ_SYSFS = 1 << 6,\r
# 336 "./include/linux/workqueue.h"\r
 WQ_POWER_EFFICIENT = 1 << 7,\r
\r
 __WQ_DRAINING = 1 << 16,\r
 __WQ_ORDERED = 1 << 17,\r
 __WQ_LEGACY = 1 << 18,\r
 __WQ_ORDERED_EXPLICIT = 1 << 19,\r
\r
 WQ_MAX_ACTIVE = 512,\r
 WQ_MAX_UNBOUND_PER_CPU = 4,\r
 WQ_DFL_ACTIVE = WQ_MAX_ACTIVE / 2,\r
};\r
# 380 "./include/linux/workqueue.h"\r
extern struct workqueue_struct *system_wq;\r
extern struct workqueue_struct *system_highpri_wq;\r
extern struct workqueue_struct *system_long_wq;\r
extern struct workqueue_struct *system_unbound_wq;\r
extern struct workqueue_struct *system_freezable_wq;\r
extern struct workqueue_struct *system_power_efficient_wq;\r
extern struct workqueue_struct *system_freezable_power_efficient_wq;\r
# 402 "./include/linux/workqueue.h"\r
__attribute__((__format__(printf, 1, 4))) struct workqueue_struct *\r
alloc_workqueue(const char *fmt, unsigned int flags, int max_active, ...);\r
# 430 "./include/linux/workqueue.h"\r
extern void destroy_workqueue(struct workqueue_struct *wq);\r
\r
struct workqueue_attrs *alloc_workqueue_attrs(void);\r
void free_workqueue_attrs(struct workqueue_attrs *attrs);\r
int apply_workqueue_attrs(struct workqueue_struct *wq,\r
     const struct workqueue_attrs *attrs);\r
int workqueue_set_unbound_cpumask(cpumask_var_t cpumask);\r
\r
extern bool queue_work_on(int cpu, struct workqueue_struct *wq,\r
   struct work_struct *work);\r
extern bool queue_work_node(int node, struct workqueue_struct *wq,\r
       struct work_struct *work);\r
extern bool queue_delayed_work_on(int cpu, struct workqueue_struct *wq,\r
   struct delayed_work *work, unsigned long delay);\r
extern bool mod_delayed_work_on(int cpu, struct workqueue_struct *wq,\r
   struct delayed_work *dwork, unsigned long delay);\r
extern bool queue_rcu_work(struct workqueue_struct *wq, struct rcu_work *rwork);\r
\r
extern void flush_workqueue(struct workqueue_struct *wq);\r
extern void drain_workqueue(struct workqueue_struct *wq);\r
\r
extern int schedule_on_each_cpu(work_func_t func);\r
\r
int execute_in_process_context(work_func_t fn, struct execute_work *);\r
\r
extern bool flush_work(struct work_struct *work);\r
extern bool cancel_work_sync(struct work_struct *work);\r
\r
extern bool flush_delayed_work(struct delayed_work *dwork);\r
extern bool cancel_delayed_work(struct delayed_work *dwork);\r
extern bool cancel_delayed_work_sync(struct delayed_work *dwork);\r
\r
extern bool flush_rcu_work(struct rcu_work *rwork);\r
\r
extern void workqueue_set_max_active(struct workqueue_struct *wq,\r
         int max_active);\r
extern struct work_struct *current_work(void);\r
extern bool current_is_workqueue_rescuer(void);\r
extern bool workqueue_congested(int cpu, struct workqueue_struct *wq);\r
extern unsigned int work_busy(struct work_struct *work);\r
extern __attribute__((__format__(printf, 1, 2))) void set_worker_desc(const char *fmt, ...);\r
extern void print_worker_info(const char *log_lvl, struct task_struct *task);\r
extern void show_all_workqueues(void);\r
extern void show_one_workqueue(struct workqueue_struct *wq);\r
extern void wq_worker_comm(char *buf, size_t size, struct task_struct *task);\r
# 499 "./include/linux/workqueue.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool queue_work(struct workqueue_struct *wq,\r
         struct work_struct *work)\r
{\r
 return queue_work_on(WORK_CPU_UNBOUND, wq, work);\r
}\r
# 513 "./include/linux/workqueue.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool queue_delayed_work(struct workqueue_struct *wq,\r
          struct delayed_work *dwork,\r
          unsigned long delay)\r
{\r
 return queue_delayed_work_on(WORK_CPU_UNBOUND, wq, dwork, delay);\r
}\r
# 528 "./include/linux/workqueue.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool mod_delayed_work(struct workqueue_struct *wq,\r
        struct delayed_work *dwork,\r
        unsigned long delay)\r
{\r
 return mod_delayed_work_on(WORK_CPU_UNBOUND, wq, dwork, delay);\r
}\r
# 542 "./include/linux/workqueue.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool schedule_work_on(int cpu, struct work_struct *work)\r
{\r
 return queue_work_on(cpu, system_wq, work);\r
}\r
# 561 "./include/linux/workqueue.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool schedule_work(struct work_struct *work)\r
{\r
 return queue_work(system_wq, work);\r
}\r
# 590 "./include/linux/workqueue.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void flush_scheduled_work(void)\r
{\r
 flush_workqueue(system_wq);\r
}\r
# 604 "./include/linux/workqueue.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool schedule_delayed_work_on(int cpu, struct delayed_work *dwork,\r
         unsigned long delay)\r
{\r
 return queue_delayed_work_on(cpu, system_wq, dwork, delay);\r
}\r
# 618 "./include/linux/workqueue.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool schedule_delayed_work(struct delayed_work *dwork,\r
      unsigned long delay)\r
{\r
 return queue_delayed_work(system_wq, dwork, delay);\r
}\r
# 634 "./include/linux/workqueue.h"\r
long work_on_cpu(int cpu, long (*fn)(void *), void *arg);\r
long work_on_cpu_safe(int cpu, long (*fn)(void *), void *arg);\r
# 645 "./include/linux/workqueue.h"\r
int workqueue_sysfs_register(struct workqueue_struct *wq);\r
\r
\r
\r
\r
\r
\r
void wq_watchdog_touch(int cpu);\r
\r
\r
\r
\r
\r
int workqueue_prepare_cpu(unsigned int cpu);\r
int workqueue_online_cpu(unsigned int cpu);\r
int workqueue_offline_cpu(unsigned int cpu);\r
\r
\r
void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((__no_sanitize__("cfi"))) workqueue_init_early(void);\r
void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((__no_sanitize__("cfi"))) workqueue_init(void);\r
# 19 "./include/linux/mm_types.h" 2\r
# 1 "./include/linux/seqlock.h" 1\r
# 19 "./include/linux/seqlock.h"\r
# 1 "./include/linux/mutex.h" 1\r
# 63 "./include/linux/mutex.h"\r
struct mutex {\r
 atomic_long_t owner;\r
 raw_spinlock_t wait_lock;\r
\r
 struct optimistic_spin_queue osq;\r
\r
 struct list_head wait_list;\r
\r
 void *magic;\r
\r
\r
 struct lockdep_map dep_map;\r
\r
};\r
\r
\r
\r
\r
\r
\r
extern void mutex_destroy(struct mutex *lock);\r
# 118 "./include/linux/mutex.h"\r
extern void __mutex_init(struct mutex *lock, const char *name,\r
    struct lock_class_key *key);\r
\r
\r
\r
\r
\r
\r
\r
extern bool mutex_is_locked(struct mutex *lock);\r
# 178 "./include/linux/mutex.h"\r
extern void mutex_lock_nested(struct mutex *lock, unsigned int subclass);\r
extern void _mutex_lock_nest_lock(struct mutex *lock, struct lockdep_map *nest_lock);\r
\r
extern int __attribute__((__warn_unused_result__)) mutex_lock_interruptible_nested(struct mutex *lock,\r
     unsigned int subclass);\r
extern int __attribute__((__warn_unused_result__)) mutex_lock_killable_nested(struct mutex *lock,\r
     unsigned int subclass);\r
extern void mutex_lock_io_nested(struct mutex *lock, unsigned int subclass);\r
# 217 "./include/linux/mutex.h"\r
extern int mutex_trylock(struct mutex *lock);\r
extern void mutex_unlock(struct mutex *lock);\r
\r
extern int atomic_dec_and_mutex_lock(atomic_t *cnt, struct mutex *lock);\r
# 20 "./include/linux/seqlock.h" 2\r
# 1 "./include/linux/ww_mutex.h" 1\r
# 21 "./include/linux/ww_mutex.h"\r
# 1 "./include/linux/rtmutex.h" 1\r
# 21 "./include/linux/rtmutex.h"\r
extern int max_lock_depth;\r
\r
struct rt_mutex_base {\r
 raw_spinlock_t wait_lock;\r
 struct rb_root_cached waiters;\r
 struct task_struct *owner;\r
};\r
# 42 "./include/linux/rtmutex.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool rt_mutex_base_is_locked(struct rt_mutex_base *lock)\r
{\r
 return ({ do { __attribute__((__noreturn__)) extern void __compiletime_assert_71(void) ; if (!((sizeof(lock->owner) == sizeof(char) || sizeof(lock->owner) == sizeof(short) || sizeof(lock->owner) == sizeof(int) || sizeof(lock->owner) == sizeof(long)) || sizeof(lock->owner) == sizeof(long long))) __compiletime_assert_71(); } while (0); (*(const volatile typeof( _Generic((lock->owner), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (lock->owner))) *)&(lock->owner)); }) != ((void *)0);\r
}\r
\r
extern void rt_mutex_base_init(struct rt_mutex_base *rtb);\r
# 57 "./include/linux/rtmutex.h"\r
struct rt_mutex {\r
 struct rt_mutex_base rtmutex;\r
\r
 struct lockdep_map dep_map;\r
\r
};\r
\r
struct rt_mutex_waiter;\r
struct hrtimer_sleeper;\r
\r
\r
extern void rt_mutex_debug_task_free(struct task_struct *tsk);\r
# 98 "./include/linux/rtmutex.h"\r
extern void __rt_mutex_init(struct rt_mutex *lock, const char *name, struct lock_class_key *key);\r
\r
\r
extern void rt_mutex_lock_nested(struct rt_mutex *lock, unsigned int subclass);\r
extern void _rt_mutex_lock_nest_lock(struct rt_mutex *lock, struct lockdep_map *nest_lock);\r
# 116 "./include/linux/rtmutex.h"\r
extern int rt_mutex_lock_interruptible(struct rt_mutex *lock);\r
extern int rt_mutex_lock_killable(struct rt_mutex *lock);\r
extern int rt_mutex_trylock(struct rt_mutex *lock);\r
\r
extern void rt_mutex_unlock(struct rt_mutex *lock);\r
# 22 "./include/linux/ww_mutex.h" 2\r
# 38 "./include/linux/ww_mutex.h"\r
struct ww_class {\r
 atomic_long_t stamp;\r
 struct lock_class_key acquire_key;\r
 struct lock_class_key mutex_key;\r
 const char *acquire_name;\r
 const char *mutex_name;\r
 unsigned int is_wait_die;\r
};\r
\r
struct ww_mutex {\r
 struct mutex base;\r
 struct ww_acquire_ctx *ctx;\r
\r
 struct ww_class *ww_class;\r
\r
};\r
\r
struct ww_acquire_ctx {\r
 struct task_struct *task;\r
 unsigned long stamp;\r
 unsigned int acquired;\r
 unsigned short wounded;\r
 unsigned short is_wait_die;\r
\r
 unsigned int done_acquire;\r
 struct ww_class *ww_class;\r
 void *contending_lock;\r
\r
\r
 struct lockdep_map dep_map;\r
\r
\r
\r
\r
\r
};\r
# 98 "./include/linux/ww_mutex.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void ww_mutex_init(struct ww_mutex *lock,\r
     struct ww_class *ww_class)\r
{\r
 __mutex_init(&lock->base,ww_class->mutex_name,&ww_class->mutex_key);\r
 lock->ctx = ((void *)0);\r
\r
 lock->ww_class = ww_class;\r
\r
}\r
# 132 "./include/linux/ww_mutex.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void ww_acquire_init(struct ww_acquire_ctx *ctx,\r
       struct ww_class *ww_class)\r
{\r
 ctx->task = get_current();\r
 ctx->stamp = atomic_long_inc_return_relaxed(&ww_class->stamp);\r
 ctx->acquired = 0;\r
 ctx->wounded = false;\r
 ctx->is_wait_die = ww_class->is_wait_die;\r
\r
 ctx->ww_class = ww_class;\r
 ctx->done_acquire = 0;\r
 ctx->contending_lock = ((void *)0);\r
\r
\r
 debug_check_no_locks_freed((void *)ctx, sizeof(*ctx));\r
 lockdep_init_map(&ctx->dep_map, ww_class->acquire_name,\r
    &ww_class->acquire_key, 0);\r
 lock_acquire(&ctx->dep_map, 0, 0, 0, 1, ((void *)0), (unsigned long)__builtin_return_address(0));\r
\r
\r
\r
\r
\r
}\r
# 168 "./include/linux/ww_mutex.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void ww_acquire_done(struct ww_acquire_ctx *ctx)\r
{\r
\r
 do { ({ int __ret_warn_on = !!(debug_locks && !(lock_is_held(&(ctx)->dep_map) != 0)); if (__builtin_expect(!!(__ret_warn_on), 0)) do { __asm__ __volatile__ ( "1:\n\t" "ebreak\n" ".pushsection __bug_table,\"aw\"\n\t" "2:\n\t" ".word" " 1b - 2b" "\n\t" ".word" " %0 - 2b" "\n\t" ".half" " %1\n\t" ".half" " %2" "\n\t" ".org 2b + %3\n\t" ".popsection" : : "i" ("include/linux/ww_mutex.h"), "i" (171), "i" ((1 << 0)|(((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); __builtin_expect(!!(__ret_warn_on), 0); }); } while (0);\r
\r
 ({ int __ret = 0; if (!oops_in_progress && __builtin_expect(!!(ctx->done_acquire), 0)) { do { } while(0); if (debug_locks_off() && !debug_locks_silent) ({ int __ret_warn_on = !!(1); if (__builtin_expect(!!(__ret_warn_on), 0)) do { do { } while(0); __warn_printk("DEBUG_LOCKS_WARN_ON(%s)", "ctx->done_acquire"); do { __asm__ __volatile__ ( "1:\n\t" "ebreak\n" ".pushsection __bug_table,\"aw\"\n\t" "2:\n\t" ".word" " 1b - 2b" "\n\t" ".word" " %0 - 2b" "\n\t" ".half" " %1\n\t" ".half" " %2" "\n\t" ".org 2b + %3\n\t" ".popsection" : : "i" ("include/linux/ww_mutex.h"), "i" (173), "i" ((1 << 0)|((1 << 3) | ((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); do { } while(0); } while (0); __builtin_expect(!!(__ret_warn_on), 0); }); do { } while(0); __ret = 1; } __ret; });\r
 ctx->done_acquire = 1;\r
\r
}\r
# 185 "./include/linux/ww_mutex.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void ww_acquire_fini(struct ww_acquire_ctx *ctx)\r
{\r
\r
 lock_release(&ctx->dep_map, ({ __label__ __here; __here: (unsigned long)&&__here; }));\r
\r
\r
 ({ int __ret = 0; if (!oops_in_progress && __builtin_expect(!!(ctx->acquired), 0)) { do { } while(0); if (debug_locks_off() && !debug_locks_silent) ({ int __ret_warn_on = !!(1); if (__builtin_expect(!!(__ret_warn_on), 0)) do { do { } while(0); __warn_printk("DEBUG_LOCKS_WARN_ON(%s)", "ctx->acquired"); do { __asm__ __volatile__ ( "1:\n\t" "ebreak\n" ".pushsection __bug_table,\"aw\"\n\t" "2:\n\t" ".word" " 1b - 2b" "\n\t" ".word" " %0 - 2b" "\n\t" ".half" " %1\n\t" ".half" " %2" "\n\t" ".org 2b + %3\n\t" ".popsection" : : "i" ("include/linux/ww_mutex.h"), "i" (191), "i" ((1 << 0)|((1 << 3) | ((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); do { } while(0); } while (0); __builtin_expect(!!(__ret_warn_on), 0); }); do { } while(0); __ret = 1; } __ret; });\r
 if (!0)\r
\r
\r
\r
\r
  ctx->done_acquire = 1;\r
\r
 if (!1)\r
\r
  ctx->acquired = ~0U;\r
\r
}\r
# 234 "./include/linux/ww_mutex.h"\r
extern int ww_mutex_lock(struct ww_mutex *lock, struct ww_acquire_ctx *ctx);\r
# 266 "./include/linux/ww_mutex.h"\r
extern int __attribute__((__warn_unused_result__)) ww_mutex_lock_interruptible(struct ww_mutex *lock,\r
          struct ww_acquire_ctx *ctx);\r
# 292 "./include/linux/ww_mutex.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void\r
ww_mutex_lock_slow(struct ww_mutex *lock, struct ww_acquire_ctx *ctx)\r
{\r
 int ret;\r
\r
 ({ int __ret = 0; if (!oops_in_progress && __builtin_expect(!!(!ctx->contending_lock), 0)) { do { } while(0); if (debug_locks_off() && !debug_locks_silent) ({ int __ret_warn_on = !!(1); if (__builtin_expect(!!(__ret_warn_on), 0)) do { do { } while(0); __warn_printk("DEBUG_LOCKS_WARN_ON(%s)", "!ctx->contending_lock"); do { __asm__ __volatile__ ( "1:\n\t" "ebreak\n" ".pushsection __bug_table,\"aw\"\n\t" "2:\n\t" ".word" " 1b - 2b" "\n\t" ".word" " %0 - 2b" "\n\t" ".half" " %1\n\t" ".half" " %2" "\n\t" ".org 2b + %3\n\t" ".popsection" : : "i" ("include/linux/ww_mutex.h"), "i" (297), "i" ((1 << 0)|((1 << 3) | ((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); do { } while(0); } while (0); __builtin_expect(!!(__ret_warn_on), 0); }); do { } while(0); __ret = 1; } __ret; });\r
\r
 ret = ww_mutex_lock(lock, ctx);\r
 (void)ret;\r
}\r
# 328 "./include/linux/ww_mutex.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int __attribute__((__warn_unused_result__))\r
ww_mutex_lock_slow_interruptible(struct ww_mutex *lock,\r
     struct ww_acquire_ctx *ctx)\r
{\r
\r
 ({ int __ret = 0; if (!oops_in_progress && __builtin_expect(!!(!ctx->contending_lock), 0)) { do { } while(0); if (debug_locks_off() && !debug_locks_silent) ({ int __ret_warn_on = !!(1); if (__builtin_expect(!!(__ret_warn_on), 0)) do { do { } while(0); __warn_printk("DEBUG_LOCKS_WARN_ON(%s)", "!ctx->contending_lock"); do { __asm__ __volatile__ ( "1:\n\t" "ebreak\n" ".pushsection __bug_table,\"aw\"\n\t" "2:\n\t" ".word" " 1b - 2b" "\n\t" ".word" " %0 - 2b" "\n\t" ".half" " %1\n\t" ".half" " %2" "\n\t" ".org 2b + %3\n\t" ".popsection" : : "i" ("include/linux/ww_mutex.h"), "i" (333), "i" ((1 << 0)|((1 << 3) | ((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); do { } while(0); } while (0); __builtin_expect(!!(__ret_warn_on), 0); }); do { } while(0); __ret = 1; } __ret; });\r
\r
 return ww_mutex_lock_interruptible(lock, ctx);\r
}\r
\r
extern void ww_mutex_unlock(struct ww_mutex *lock);\r
\r
extern int __attribute__((__warn_unused_result__)) ww_mutex_trylock(struct ww_mutex *lock,\r
      struct ww_acquire_ctx *ctx);\r
# 351 "./include/linux/ww_mutex.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void ww_mutex_destroy(struct ww_mutex *lock)\r
{\r
\r
 mutex_destroy(&lock->base);\r
\r
}\r
\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool ww_mutex_is_locked(struct ww_mutex *lock)\r
{\r
 return mutex_is_locked((&lock->base));\r
}\r
# 21 "./include/linux/seqlock.h" 2\r
# 65 "./include/linux/seqlock.h"\r
typedef struct seqcount {\r
 unsigned sequence;\r
\r
 struct lockdep_map dep_map;\r
\r
} seqcount_t;\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __seqcount_init(seqcount_t *s, const char *name,\r
       struct lock_class_key *key)\r
{\r
\r
\r
\r
 lockdep_init_map(&s->dep_map, name, key, 0);\r
 s->sequence = 0;\r
}\r
# 97 "./include/linux/seqlock.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void seqcount_lockdep_reader_access(const seqcount_t *s)\r
{\r
 seqcount_t *l = (seqcount_t *)s;\r
 unsigned long flags;\r
\r
 do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); flags = arch_local_irq_save(); } while (0); if (!({ ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_irqs_disabled_flags(flags); })) trace_hardirqs_off(); } while (0);\r
 lock_acquire(&l->dep_map, 0, 0, 2, 1, ((void *)0), (unsigned long)__builtin_return_address(0));\r
 lock_release(&l->dep_map, (unsigned long)__builtin_return_address(0));\r
 do { if (!({ ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_irqs_disabled_flags(flags); })) trace_hardirqs_on(); do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); do { } while (0); arch_local_irq_restore(flags); } while (0); } while (0);\r
}\r
# 254 "./include/linux/seqlock.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) seqcount_t *__seqprop_ptr(seqcount_t *s)\r
{\r
 return s;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) unsigned __seqprop_sequence(const seqcount_t *s)\r
{\r
 return ({ do { __attribute__((__noreturn__)) extern void __compiletime_assert_72(void) ; if (!((sizeof(s->sequence) == sizeof(char) || sizeof(s->sequence) == sizeof(short) || sizeof(s->sequence) == sizeof(int) || sizeof(s->sequence) == sizeof(long)) || sizeof(s->sequence) == sizeof(long long))) __compiletime_assert_72(); } while (0); (*(const volatile typeof( _Generic((s->sequence), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (s->sequence))) *)&(s->sequence)); });\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool __seqprop_preemptible(const seqcount_t *s)\r
{\r
 return false;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __seqprop_assert(const seqcount_t *s)\r
{\r
 do { } while (0);\r
}\r
\r
\r
\r
typedef struct seqcount_raw_spinlock { seqcount_t seqcount; raw_spinlock_t *lock; } seqcount_raw_spinlock_t; static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) seqcount_t * __seqprop_raw_spinlock_ptr(seqcount_raw_spinlock_t *s) { return &s->seqcount; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) unsigned __seqprop_raw_spinlock_sequence(const seqcount_raw_spinlock_t *s) { unsigned seq = ({ do { __attribute__((__noreturn__)) extern void __compiletime_assert_73(void) ; if (!((sizeof(s->seqcount.sequence) == sizeof(char) || sizeof(s->seqcount.sequence) == sizeof(short) || sizeof(s->seqcount.sequence) == sizeof(int) || sizeof(s->seqcount.sequence) == sizeof(long)) || sizeof(s->seqcount.sequence) == sizeof(long long))) __compiletime_assert_73(); } while (0); (*(const volatile typeof( _Generic((s->seqcount.sequence), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (s->seqcount.sequence))) *)&(s->seqcount.sequence)); }); if (!0) return seq; if (false && __builtin_expect(!!(seq & 1), 0)) { _raw_spin_lock(s->lock); _raw_spin_unlock(s->lock); seq = ({ do { __attribute__((__noreturn__)) extern void __compiletime_assert_74(void) ; if (!((sizeof(s->seqcount.sequence) == sizeof(char) || sizeof(s->seqcount.sequence) == sizeof(short) || sizeof(s->seqcount.sequence) == sizeof(int) || sizeof(s->seqcount.sequence) == sizeof(long)) || sizeof(s->seqcount.sequence) == sizeof(long long))) __compiletime_assert_74(); } while (0); (*(const volatile typeof( _Generic((s->seqcount.sequence), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (s->seqcount.sequence))) *)&(s->seqcount.sequence)); }); } return seq; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool __seqprop_raw_spinlock_preemptible(const seqcount_raw_spinlock_t *s) { if (!0) return false; return false; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void __seqprop_raw_spinlock_assert(const seqcount_raw_spinlock_t *s) { do { ({ int __ret_warn_on = !!(debug_locks && !(lock_is_held(&(s->lock)->dep_map) != 0)); if (__builtin_expect(!!(__ret_warn_on), 0)) do { __asm__ __volatile__ ( "1:\n\t" "ebreak\n" ".pushsection __bug_table,\"aw\"\n\t" "2:\n\t" ".word" " 1b - 2b" "\n\t" ".word" " %0 - 2b" "\n\t" ".half" " %1\n\t" ".half" " %2" "\n\t" ".org 2b + %3\n\t" ".popsection" : : "i" ("include/linux/seqlock.h"), "i" (276), "i" ((1 << 0)|(((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); __builtin_expect(!!(__ret_warn_on), 0); }); } while (0); }\r
typedef struct seqcount_spinlock { seqcount_t seqcount; spinlock_t *lock; } seqcount_spinlock_t; static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) seqcount_t * __seqprop_spinlock_ptr(seqcount_spinlock_t *s) { return &s->seqcount; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) unsigned __seqprop_spinlock_sequence(const seqcount_spinlock_t *s) { unsigned seq = ({ do { __attribute__((__noreturn__)) extern void __compiletime_assert_75(void) ; if (!((sizeof(s->seqcount.sequence) == sizeof(char) || sizeof(s->seqcount.sequence) == sizeof(short) || sizeof(s->seqcount.sequence) == sizeof(int) || sizeof(s->seqcount.sequence) == sizeof(long)) || sizeof(s->seqcount.sequence) == sizeof(long long))) __compiletime_assert_75(); } while (0); (*(const volatile typeof( _Generic((s->seqcount.sequence), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (s->seqcount.sequence))) *)&(s->seqcount.sequence)); }); if (!0) return seq; if (0 && __builtin_expect(!!(seq & 1), 0)) { spin_lock(s->lock); spin_unlock(s->lock); seq = ({ do { __attribute__((__noreturn__)) extern void __compiletime_assert_76(void) ; if (!((sizeof(s->seqcount.sequence) == sizeof(char) || sizeof(s->seqcount.sequence) == sizeof(short) || sizeof(s->seqcount.sequence) == sizeof(int) || sizeof(s->seqcount.sequence) == sizeof(long)) || sizeof(s->seqcount.sequence) == sizeof(long long))) __compiletime_assert_76(); } while (0); (*(const volatile typeof( _Generic((s->seqcount.sequence), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (s->seqcount.sequence))) *)&(s->seqcount.sequence)); }); } return seq; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool __seqprop_spinlock_preemptible(const seqcount_spinlock_t *s) { if (!0) return 0; return false; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void __seqprop_spinlock_assert(const seqcount_spinlock_t *s) { do { ({ int __ret_warn_on = !!(debug_locks && !(lock_is_held(&(s->lock)->dep_map) != 0)); if (__builtin_expect(!!(__ret_warn_on), 0)) do { __asm__ __volatile__ ( "1:\n\t" "ebreak\n" ".pushsection __bug_table,\"aw\"\n\t" "2:\n\t" ".word" " 1b - 2b" "\n\t" ".word" " %0 - 2b" "\n\t" ".half" " %1\n\t" ".half" " %2" "\n\t" ".org 2b + %3\n\t" ".popsection" : : "i" ("include/linux/seqlock.h"), "i" (277), "i" ((1 << 0)|(((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); __builtin_expect(!!(__ret_warn_on), 0); }); } while (0); }\r
typedef struct seqcount_rwlock { seqcount_t seqcount; rwlock_t *lock; } seqcount_rwlock_t; static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) seqcount_t * __seqprop_rwlock_ptr(seqcount_rwlock_t *s) { return &s->seqcount; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) unsigned __seqprop_rwlock_sequence(const seqcount_rwlock_t *s) { unsigned seq = ({ do { __attribute__((__noreturn__)) extern void __compiletime_assert_77(void) ; if (!((sizeof(s->seqcount.sequence) == sizeof(char) || sizeof(s->seqcount.sequence) == sizeof(short) || sizeof(s->seqcount.sequence) == sizeof(int) || sizeof(s->seqcount.sequence) == sizeof(long)) || sizeof(s->seqcount.sequence) == sizeof(long long))) __compiletime_assert_77(); } while (0); (*(const volatile typeof( _Generic((s->seqcount.sequence), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (s->seqcount.sequence))) *)&(s->seqcount.sequence)); }); if (!0) return seq; if (0 && __builtin_expect(!!(seq & 1), 0)) { _raw_read_lock(s->lock); _raw_read_unlock(s->lock); seq = ({ do { __attribute__((__noreturn__)) extern void __compiletime_assert_78(void) ; if (!((sizeof(s->seqcount.sequence) == sizeof(char) || sizeof(s->seqcount.sequence) == sizeof(short) || sizeof(s->seqcount.sequence) == sizeof(int) || sizeof(s->seqcount.sequence) == sizeof(long)) || sizeof(s->seqcount.sequence) == sizeof(long long))) __compiletime_assert_78(); } while (0); (*(const volatile typeof( _Generic((s->seqcount.sequence), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (s->seqcount.sequence))) *)&(s->seqcount.sequence)); }); } return seq; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool __seqprop_rwlock_preemptible(const seqcount_rwlock_t *s) { if (!0) return 0; return false; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void __seqprop_rwlock_assert(const seqcount_rwlock_t *s) { do { ({ int __ret_warn_on = !!(debug_locks && !(lock_is_held(&(s->lock)->dep_map) != 0)); if (__builtin_expect(!!(__ret_warn_on), 0)) do { __asm__ __volatile__ ( "1:\n\t" "ebreak\n" ".pushsection __bug_table,\"aw\"\n\t" "2:\n\t" ".word" " 1b - 2b" "\n\t" ".word" " %0 - 2b" "\n\t" ".half" " %1\n\t" ".half" " %2" "\n\t" ".org 2b + %3\n\t" ".popsection" : : "i" ("include/linux/seqlock.h"), "i" (278), "i" ((1 << 0)|(((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); __builtin_expect(!!(__ret_warn_on), 0); }); } while (0); }\r
typedef struct seqcount_mutex { seqcount_t seqcount; struct mutex *lock; } seqcount_mutex_t; static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) seqcount_t * __seqprop_mutex_ptr(seqcount_mutex_t *s) { return &s->seqcount; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) unsigned __seqprop_mutex_sequence(const seqcount_mutex_t *s) { unsigned seq = ({ do { __attribute__((__noreturn__)) extern void __compiletime_assert_79(void) ; if (!((sizeof(s->seqcount.sequence) == sizeof(char) || sizeof(s->seqcount.sequence) == sizeof(short) || sizeof(s->seqcount.sequence) == sizeof(int) || sizeof(s->seqcount.sequence) == sizeof(long)) || sizeof(s->seqcount.sequence) == sizeof(long long))) __compiletime_assert_79(); } while (0); (*(const volatile typeof( _Generic((s->seqcount.sequence), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (s->seqcount.sequence))) *)&(s->seqcount.sequence)); }); if (!0) return seq; if (true && __builtin_expect(!!(seq & 1), 0)) { mutex_lock_nested(s->lock, 0); mutex_unlock(s->lock); seq = ({ do { __attribute__((__noreturn__)) extern void __compiletime_assert_80(void) ; if (!((sizeof(s->seqcount.sequence) == sizeof(char) || sizeof(s->seqcount.sequence) == sizeof(short) || sizeof(s->seqcount.sequence) == sizeof(int) || sizeof(s->seqcount.sequence) == sizeof(long)) || sizeof(s->seqcount.sequence) == sizeof(long long))) __compiletime_assert_80(); } while (0); (*(const volatile typeof( _Generic((s->seqcount.sequence), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (s->seqcount.sequence))) *)&(s->seqcount.sequence)); }); } return seq; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool __seqprop_mutex_preemptible(const seqcount_mutex_t *s) { if (!0) return true; return false; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void __seqprop_mutex_assert(const seqcount_mutex_t *s) { do { ({ int __ret_warn_on = !!(debug_locks && !(lock_is_held(&(s->lock)->dep_map) != 0)); if (__builtin_expect(!!(__ret_warn_on), 0)) do { __asm__ __volatile__ ( "1:\n\t" "ebreak\n" ".pushsection __bug_table,\"aw\"\n\t" "2:\n\t" ".word" " 1b - 2b" "\n\t" ".word" " %0 - 2b" "\n\t" ".half" " %1\n\t" ".half" " %2" "\n\t" ".org 2b + %3\n\t" ".popsection" : : "i" ("include/linux/seqlock.h"), "i" (279), "i" ((1 << 0)|(((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); __builtin_expect(!!(__ret_warn_on), 0); }); } while (0); }\r
typedef struct seqcount_ww_mutex { seqcount_t seqcount; struct ww_mutex *lock; } seqcount_ww_mutex_t; static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) seqcount_t * __seqprop_ww_mutex_ptr(seqcount_ww_mutex_t *s) { return &s->seqcount; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) unsigned __seqprop_ww_mutex_sequence(const seqcount_ww_mutex_t *s) { unsigned seq = ({ do { __attribute__((__noreturn__)) extern void __compiletime_assert_81(void) ; if (!((sizeof(s->seqcount.sequence) == sizeof(char) || sizeof(s->seqcount.sequence) == sizeof(short) || sizeof(s->seqcount.sequence) == sizeof(int) || sizeof(s->seqcount.sequence) == sizeof(long)) || sizeof(s->seqcount.sequence) == sizeof(long long))) __compiletime_assert_81(); } while (0); (*(const volatile typeof( _Generic((s->seqcount.sequence), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (s->seqcount.sequence))) *)&(s->seqcount.sequence)); }); if (!0) return seq; if (true && __builtin_expect(!!(seq & 1), 0)) { ww_mutex_lock(s->lock, ((void *)0)); ww_mutex_unlock(s->lock); seq = ({ do { __attribute__((__noreturn__)) extern void __compiletime_assert_82(void) ; if (!((sizeof(s->seqcount.sequence) == sizeof(char) || sizeof(s->seqcount.sequence) == sizeof(short) || sizeof(s->seqcount.sequence) == sizeof(int) || sizeof(s->seqcount.sequence) == sizeof(long)) || sizeof(s->seqcount.sequence) == sizeof(long long))) __compiletime_assert_82(); } while (0); (*(const volatile typeof( _Generic((s->seqcount.sequence), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (s->seqcount.sequence))) *)&(s->seqcount.sequence)); }); } return seq; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool __seqprop_ww_mutex_preemptible(const seqcount_ww_mutex_t *s) { if (!0) return true; return false; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void __seqprop_ww_mutex_assert(const seqcount_ww_mutex_t *s) { do { ({ int __ret_warn_on = !!(debug_locks && !(lock_is_held(&(&s->lock->base)->dep_map) != 0)); if (__builtin_expect(!!(__ret_warn_on), 0)) do { __asm__ __volatile__ ( "1:\n\t" "ebreak\n" ".pushsection __bug_table,\"aw\"\n\t" "2:\n\t" ".word" " 1b - 2b" "\n\t" ".word" " %0 - 2b" "\n\t" ".half" " %1\n\t" ".half" " %2" "\n\t" ".org 2b + %3\n\t" ".popsection" : : "i" ("include/linux/seqlock.h"), "i" (280), "i" ((1 << 0)|(((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); __builtin_expect(!!(__ret_warn_on), 0); }); } while (0); }\r
# 430 "./include/linux/seqlock.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int do___read_seqcount_retry(const seqcount_t *s, unsigned start)\r
{\r
 kcsan_atomic_next(0);\r
 return __builtin_expect(!!(({ do { __attribute__((__noreturn__)) extern void __compiletime_assert_83(void) ; if (!((sizeof(s->sequence) == sizeof(char) || sizeof(s->sequence) == sizeof(short) || sizeof(s->sequence) == sizeof(int) || sizeof(s->sequence) == sizeof(long)) || sizeof(s->sequence) == sizeof(long long))) __compiletime_assert_83(); } while (0); (*(const volatile typeof( _Generic((s->sequence), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (s->sequence))) *)&(s->sequence)); }) != start), 0);\r
}\r
# 450 "./include/linux/seqlock.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int do_read_seqcount_retry(const seqcount_t *s, unsigned start)\r
{\r
 do { do { } while (0); __asm__ __volatile__ ("fence " "r" "," "r" : : : "memory"); } while (0);\r
 return do___read_seqcount_retry(s, start);\r
}\r
# 470 "./include/linux/seqlock.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void do_raw_write_seqcount_begin(seqcount_t *s)\r
{\r
 kcsan_nestable_atomic_begin();\r
 s->sequence++;\r
 do { do { } while (0); __asm__ __volatile__ ("fence " "w" "," "w" : : : "memory"); } while (0);\r
}\r
# 491 "./include/linux/seqlock.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void do_raw_write_seqcount_end(seqcount_t *s)\r
{\r
 do { do { } while (0); __asm__ __volatile__ ("fence " "w" "," "w" : : : "memory"); } while (0);\r
 s->sequence++;\r
 kcsan_nestable_atomic_end();\r
}\r
# 517 "./include/linux/seqlock.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void do_write_seqcount_begin_nested(seqcount_t *s, int subclass)\r
{\r
 do_raw_write_seqcount_begin(s);\r
 lock_acquire(&s->dep_map, subclass, 0, 0, 1, ((void *)0), (unsigned long)__builtin_return_address(0));\r
}\r
# 543 "./include/linux/seqlock.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void do_write_seqcount_begin(seqcount_t *s)\r
{\r
 do_write_seqcount_begin_nested(s, 0);\r
}\r
# 563 "./include/linux/seqlock.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void do_write_seqcount_end(seqcount_t *s)\r
{\r
 lock_release(&s->dep_map, (unsigned long)__builtin_return_address(0));\r
 do_raw_write_seqcount_end(s);\r
}\r
# 613 "./include/linux/seqlock.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void do_raw_write_seqcount_barrier(seqcount_t *s)\r
{\r
 kcsan_nestable_atomic_begin();\r
 s->sequence++;\r
 do { do { } while (0); __asm__ __volatile__ ("fence " "w" "," "w" : : : "memory"); } while (0);\r
 s->sequence++;\r
 kcsan_nestable_atomic_end();\r
}\r
# 633 "./include/linux/seqlock.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void do_write_seqcount_invalidate(seqcount_t *s)\r
{\r
 do { do { } while (0); __asm__ __volatile__ ("fence " "w" "," "w" : : : "memory"); } while (0);\r
 kcsan_nestable_atomic_begin();\r
 s->sequence+=2;\r
 kcsan_nestable_atomic_end();\r
}\r
# 651 "./include/linux/seqlock.h"\r
typedef struct {\r
 seqcount_t seqcount;\r
} seqcount_latch_t;\r
# 680 "./include/linux/seqlock.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) unsigned raw_read_seqcount_latch(const seqcount_latch_t *s)\r
{\r
\r
\r
\r
\r
 return ({ do { __attribute__((__noreturn__)) extern void __compiletime_assert_84(void) ; if (!((sizeof(s->seqcount.sequence) == sizeof(char) || sizeof(s->seqcount.sequence) == sizeof(short) || sizeof(s->seqcount.sequence) == sizeof(int) || sizeof(s->seqcount.sequence) == sizeof(long)) || sizeof(s->seqcount.sequence) == sizeof(long long))) __compiletime_assert_84(); } while (0); (*(const volatile typeof( _Generic((s->seqcount.sequence), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (s->seqcount.sequence))) *)&(s->seqcount.sequence)); });\r
}\r
# 696 "./include/linux/seqlock.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int\r
read_seqcount_latch_retry(const seqcount_latch_t *s, unsigned start)\r
{\r
 return do_read_seqcount_retry(_Generic(*(&s->seqcount), seqcount_t: __seqprop_ptr((void *)(&s->seqcount)), seqcount_raw_spinlock_t: __seqprop_raw_spinlock_ptr((void *)((&s->seqcount))), seqcount_spinlock_t: __seqprop_spinlock_ptr((void *)((&s->seqcount))), seqcount_rwlock_t: __seqprop_rwlock_ptr((void *)((&s->seqcount))), seqcount_mutex_t: __seqprop_mutex_ptr((void *)((&s->seqcount))), seqcount_ww_mutex_t: __seqprop_ww_mutex_ptr((void *)((&s->seqcount)))), start);\r
}\r
# 783 "./include/linux/seqlock.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void raw_write_seqcount_latch(seqcount_latch_t *s)\r
{\r
 do { do { } while (0); __asm__ __volatile__ ("fence " "w" "," "w" : : : "memory"); } while (0);\r
 s->seqcount.sequence++;\r
 do { do { } while (0); __asm__ __volatile__ ("fence " "w" "," "w" : : : "memory"); } while (0);\r
}\r
# 800 "./include/linux/seqlock.h"\r
typedef struct {\r
\r
\r
\r
\r
 seqcount_spinlock_t seqcount;\r
 spinlock_t lock;\r
} seqlock_t;\r
# 838 "./include/linux/seqlock.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) unsigned read_seqbegin(const seqlock_t *sl)\r
{\r
 unsigned ret = ({ seqcount_lockdep_reader_access(_Generic(*(&sl->seqcount), seqcount_t: __seqprop_ptr((void *)(&sl->seqcount)), seqcount_raw_spinlock_t: __seqprop_raw_spinlock_ptr((void *)((&sl->seqcount))), seqcount_spinlock_t: __seqprop_spinlock_ptr((void *)((&sl->seqcount))), seqcount_rwlock_t: __seqprop_rwlock_ptr((void *)((&sl->seqcount))), seqcount_mutex_t: __seqprop_mutex_ptr((void *)((&sl->seqcount))), seqcount_ww_mutex_t: __seqprop_ww_mutex_ptr((void *)((&sl->seqcount))))); ({ unsigned _seq = ({ unsigned __seq; while ((__seq = _Generic(*(&sl->seqcount), seqcount_t: __seqprop_sequence((void *)(&sl->seqcount)), seqcount_raw_spinlock_t: __seqprop_raw_spinlock_sequence((void *)((&sl->seqcount))), seqcount_spinlock_t: __seqprop_spinlock_sequence((void *)((&sl->seqcount))), seqcount_rwlock_t: __seqprop_rwlock_sequence((void *)((&sl->seqcount))), seqcount_mutex_t: __seqprop_mutex_sequence((void *)((&sl->seqcount))), seqcount_ww_mutex_t: __seqprop_ww_mutex_sequence((void *)((&sl->seqcount))))) & 1) cpu_relax(); kcsan_atomic_next(1000); __seq; }); do { do { } while (0); __asm__ __volatile__ ("fence " "r" "," "r" : : : "memory"); } while (0); _seq; }); });\r
\r
 kcsan_atomic_next(0);\r
 kcsan_flat_atomic_begin();\r
 return ret;\r
}\r
# 858 "./include/linux/seqlock.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) unsigned read_seqretry(const seqlock_t *sl, unsigned start)\r
{\r
\r
\r
\r
\r
 kcsan_flat_atomic_end();\r
\r
 return do_read_seqcount_retry(_Generic(*(&sl->seqcount), seqcount_t: __seqprop_ptr((void *)(&sl->seqcount)), seqcount_raw_spinlock_t: __seqprop_raw_spinlock_ptr((void *)((&sl->seqcount))), seqcount_spinlock_t: __seqprop_spinlock_ptr((void *)((&sl->seqcount))), seqcount_rwlock_t: __seqprop_rwlock_ptr((void *)((&sl->seqcount))), seqcount_mutex_t: __seqprop_mutex_ptr((void *)((&sl->seqcount))), seqcount_ww_mutex_t: __seqprop_ww_mutex_ptr((void *)((&sl->seqcount)))), start);\r
}\r
# 888 "./include/linux/seqlock.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void write_seqlock(seqlock_t *sl)\r
{\r
 spin_lock(&sl->lock);\r
 do_write_seqcount_begin(&sl->seqcount.seqcount);\r
}\r
# 901 "./include/linux/seqlock.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void write_sequnlock(seqlock_t *sl)\r
{\r
 do_write_seqcount_end(&sl->seqcount.seqcount);\r
 spin_unlock(&sl->lock);\r
}\r
# 914 "./include/linux/seqlock.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void write_seqlock_bh(seqlock_t *sl)\r
{\r
 spin_lock_bh(&sl->lock);\r
 do_write_seqcount_begin(&sl->seqcount.seqcount);\r
}\r
# 928 "./include/linux/seqlock.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void write_sequnlock_bh(seqlock_t *sl)\r
{\r
 do_write_seqcount_end(&sl->seqcount.seqcount);\r
 spin_unlock_bh(&sl->lock);\r
}\r
# 941 "./include/linux/seqlock.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void write_seqlock_irq(seqlock_t *sl)\r
{\r
 spin_lock_irq(&sl->lock);\r
 do_write_seqcount_begin(&sl->seqcount.seqcount);\r
}\r
# 954 "./include/linux/seqlock.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void write_sequnlock_irq(seqlock_t *sl)\r
{\r
 do_write_seqcount_end(&sl->seqcount.seqcount);\r
 spin_unlock_irq(&sl->lock);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) unsigned long __write_seqlock_irqsave(seqlock_t *sl)\r
{\r
 unsigned long flags;\r
\r
 do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); flags = _raw_spin_lock_irqsave(spinlock_check(&sl->lock)); } while (0); } while (0);\r
 do_write_seqcount_begin(&sl->seqcount.seqcount);\r
 return flags;\r
}\r
# 991 "./include/linux/seqlock.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void\r
write_sequnlock_irqrestore(seqlock_t *sl, unsigned long flags)\r
{\r
 do_write_seqcount_end(&sl->seqcount.seqcount);\r
 spin_unlock_irqrestore(&sl->lock, flags);\r
}\r
# 1014 "./include/linux/seqlock.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void read_seqlock_excl(seqlock_t *sl)\r
{\r
 spin_lock(&sl->lock);\r
}\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void read_sequnlock_excl(seqlock_t *sl)\r
{\r
 spin_unlock(&sl->lock);\r
}\r
# 1037 "./include/linux/seqlock.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void read_seqlock_excl_bh(seqlock_t *sl)\r
{\r
 spin_lock_bh(&sl->lock);\r
}\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void read_sequnlock_excl_bh(seqlock_t *sl)\r
{\r
 spin_unlock_bh(&sl->lock);\r
}\r
# 1061 "./include/linux/seqlock.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void read_seqlock_excl_irq(seqlock_t *sl)\r
{\r
 spin_lock_irq(&sl->lock);\r
}\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void read_sequnlock_excl_irq(seqlock_t *sl)\r
{\r
 spin_unlock_irq(&sl->lock);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) unsigned long __read_seqlock_excl_irqsave(seqlock_t *sl)\r
{\r
 unsigned long flags;\r
\r
 do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); flags = _raw_spin_lock_irqsave(spinlock_check(&sl->lock)); } while (0); } while (0);\r
 return flags;\r
}\r
# 1104 "./include/linux/seqlock.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void\r
read_sequnlock_excl_irqrestore(seqlock_t *sl, unsigned long flags)\r
{\r
 spin_unlock_irqrestore(&sl->lock, flags);\r
}\r
# 1141 "./include/linux/seqlock.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void read_seqbegin_or_lock(seqlock_t *lock, int *seq)\r
{\r
 if (!(*seq & 1))\r
  *seq = read_seqbegin(lock);\r
 else\r
  read_seqlock_excl(lock);\r
}\r
# 1156 "./include/linux/seqlock.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int need_seqretry(seqlock_t *lock, int seq)\r
{\r
 return !(seq & 1) && read_seqretry(lock, seq);\r
}\r
# 1169 "./include/linux/seqlock.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void done_seqretry(seqlock_t *lock, int seq)\r
{\r
 if (seq & 1)\r
  read_sequnlock_excl(lock);\r
}\r
# 1195 "./include/linux/seqlock.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) unsigned long\r
read_seqbegin_or_lock_irqsave(seqlock_t *lock, int *seq)\r
{\r
 unsigned long flags = 0;\r
\r
 if (!(*seq & 1))\r
  *seq = read_seqbegin(lock);\r
 else\r
  do { flags = __read_seqlock_excl_irqsave(lock); } while (0);\r
\r
 return flags;\r
}\r
# 1220 "./include/linux/seqlock.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void\r
done_seqretry_irqrestore(seqlock_t *lock, int seq, unsigned long flags)\r
{\r
 if (seq & 1)\r
  read_sequnlock_excl_irqrestore(lock, flags);\r
}\r
# 20 "./include/linux/mm_types.h" 2\r
\r
# 1 "./arch/riscv/include/asm/mmu.h" 1\r
# 12 "./arch/riscv/include/asm/mmu.h"\r
typedef struct {\r
\r
\r
\r
 atomic_long_t id;\r
\r
 void *vdso;\r
\r
\r
 cpumask_t icache_stale_mask;\r
\r
} mm_context_t;\r
\r
void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((__no_sanitize__("cfi"))) create_pgd_mapping(pgd_t *pgdp, uintptr_t va, phys_addr_t pa,\r
          phys_addr_t sz, pgprot_t prot);\r
# 22 "./include/linux/mm_types.h" 2\r
\r
\r
\r
\r
\r
\r
\r
\r
struct address_space;\r
struct mem_cgroup;\r
# 72 "./include/linux/mm_types.h"\r
struct page {\r
 unsigned long flags;\r
\r
\r
\r
\r
\r
\r
\r
 union {\r
  struct {\r
\r
\r
\r
\r
\r
   union {\r
    struct list_head lru;\r
\r
    struct {\r
\r
     void *__filler;\r
\r
     unsigned int mlock_count;\r
    };\r
   };\r
\r
   struct address_space *mapping;\r
   unsigned long index;\r
\r
\r
\r
\r
\r
\r
   unsigned long private;\r
  };\r
  struct {\r
\r
\r
\r
\r
   unsigned long pp_magic;\r
   struct page_pool *pp;\r
   unsigned long _pp_mapping_pad;\r
   unsigned long dma_addr;\r
   union {\r
\r
\r
\r
\r
    unsigned long dma_addr_upper;\r
\r
\r
\r
\r
    atomic_long_t pp_frag_count;\r
   };\r
  };\r
  struct {\r
   unsigned long compound_head;\r
\r
\r
   unsigned char compound_dtor;\r
   unsigned char compound_order;\r
   atomic_t compound_mapcount;\r
   atomic_t compound_pincount;\r
\r
   unsigned int compound_nr;\r
\r
  };\r
  struct {\r
   unsigned long _compound_pad_1;\r
   unsigned long _compound_pad_2;\r
\r
   struct list_head deferred_list;\r
  };\r
  struct {\r
   unsigned long _pt_pad_1;\r
   pgtable_t pmd_huge_pte;\r
   unsigned long _pt_pad_2;\r
   union {\r
    struct mm_struct *pt_mm;\r
    atomic_t pt_frag_refcount;\r
   };\r
\r
   spinlock_t *ptl;\r
\r
\r
\r
  };\r
  struct {\r
\r
   struct dev_pagemap *pgmap;\r
   void *zone_device_data;\r
# 177 "./include/linux/mm_types.h"\r
  };\r
\r
\r
  struct callback_head callback_head;\r
 };\r
\r
 union {\r
\r
\r
\r
\r
  atomic_t _mapcount;\r
\r
\r
\r
\r
\r
\r
\r
  unsigned int page_type;\r
 };\r
\r
\r
 atomic_t _refcount;\r
# 224 "./include/linux/mm_types.h"\r
} ;\r
# 250 "./include/linux/mm_types.h"\r
struct folio {\r
\r
 union {\r
  struct {\r
\r
   unsigned long flags;\r
   union {\r
    struct list_head lru;\r
    struct {\r
     void *__filler;\r
     unsigned int mlock_count;\r
    };\r
   };\r
   struct address_space *mapping;\r
   unsigned long index;\r
   void *private;\r
   atomic_t _mapcount;\r
   atomic_t _refcount;\r
\r
\r
\r
\r
  };\r
  struct page page;\r
 };\r
};\r
\r
_Static_assert(sizeof(struct page) == sizeof(struct folio), "sizeof(struct page) == sizeof(struct folio)");\r
\r
\r
_Static_assert(__builtin_offsetof(struct page, flags) == __builtin_offsetof(struct folio, flags), "offsetof(struct page, flags) == offsetof(struct folio, flags)");\r
_Static_assert(__builtin_offsetof(struct page, lru) == __builtin_offsetof(struct folio, lru), "offsetof(struct page, lru) == offsetof(struct folio, lru)");\r
_Static_assert(__builtin_offsetof(struct page, mapping) == __builtin_offsetof(struct folio, mapping), "offsetof(struct page, mapping) == offsetof(struct folio, mapping)");\r
_Static_assert(__builtin_offsetof(struct page, compound_head) == __builtin_offsetof(struct folio, lru), "offsetof(struct page, compound_head) == offsetof(struct folio, lru)");\r
_Static_assert(__builtin_offsetof(struct page, index) == __builtin_offsetof(struct folio, index), "offsetof(struct page, index) == offsetof(struct folio, index)");\r
_Static_assert(__builtin_offsetof(struct page, private) == __builtin_offsetof(struct folio, private), "offsetof(struct page, private) == offsetof(struct folio, private)");\r
_Static_assert(__builtin_offsetof(struct page, _mapcount) == __builtin_offsetof(struct folio, _mapcount), "offsetof(struct page, _mapcount) == offsetof(struct folio, _mapcount)");\r
_Static_assert(__builtin_offsetof(struct page, _refcount) == __builtin_offsetof(struct folio, _refcount), "offsetof(struct page, _refcount) == offsetof(struct folio, _refcount)");\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) atomic_t *folio_mapcount_ptr(struct folio *folio)\r
{\r
 struct page *tail = &folio->page + 1;\r
 return &tail->compound_mapcount;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) atomic_t *compound_mapcount_ptr(struct page *page)\r
{\r
 return &page[1].compound_mapcount;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) atomic_t *compound_pincount_ptr(struct page *page)\r
{\r
 return &page[1].compound_pincount;\r
}\r
# 325 "./include/linux/mm_types.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void set_page_private(struct page *page, unsigned long private)\r
{\r
 page->private = private;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void *folio_get_private(struct folio *folio)\r
{\r
 return folio->private;\r
}\r
\r
struct page_frag_cache {\r
 void * va;\r
\r
 __u16 offset;\r
 __u16 size;\r
\r
\r
\r
\r
\r
\r
 unsigned int pagecnt_bias;\r
 bool pfmemalloc;\r
};\r
\r
typedef unsigned long vm_flags_t;\r
\r
\r
\r
\r
\r
\r
struct vm_region {\r
 struct rb_node vm_rb;\r
 vm_flags_t vm_flags;\r
 unsigned long vm_start;\r
 unsigned long vm_end;\r
 unsigned long vm_top;\r
 unsigned long vm_pgoff;\r
 struct file *vm_file;\r
\r
 int vm_usage;\r
 bool vm_icache_flushed : 1;\r
\r
};\r
# 378 "./include/linux/mm_types.h"\r
struct vm_userfaultfd_ctx {};\r
\r
\r
struct anon_vma_name {\r
 struct kref kref;\r
\r
 char name[];\r
};\r
\r
\r
\r
\r
\r
\r
\r
struct vm_area_struct {\r
\r
\r
 unsigned long vm_start;\r
 unsigned long vm_end;\r
\r
\r
\r
 struct vm_area_struct *vm_next, *vm_prev;\r
\r
 struct rb_node vm_rb;\r
\r
\r
\r
\r
\r
\r
\r
 unsigned long rb_subtree_gap;\r
\r
\r
\r
 struct mm_struct *vm_mm;\r
\r
\r
\r
\r
\r
 pgprot_t vm_page_prot;\r
 unsigned long vm_flags;\r
# 432 "./include/linux/mm_types.h"\r
 union {\r
  struct {\r
   struct rb_node rb;\r
   unsigned long rb_subtree_last;\r
  } shared;\r
\r
\r
\r
\r
  struct anon_vma_name *anon_name;\r
 };\r
\r
\r
\r
\r
\r
\r
\r
 struct list_head anon_vma_chain;\r
\r
 struct anon_vma *anon_vma;\r
\r
\r
 const struct vm_operations_struct *vm_ops;\r
\r
\r
 unsigned long vm_pgoff;\r
\r
 struct file * vm_file;\r
 void * vm_private_data;\r
\r
\r
 atomic_long_t swap_readahead_info;\r
\r
\r
\r
\r
\r
\r
\r
 struct vm_userfaultfd_ctx vm_userfaultfd_ctx;\r
} ;\r
\r
struct kioctx_table;\r
struct mm_struct {\r
 struct {\r
  struct vm_area_struct *mmap;\r
  struct rb_root mm_rb;\r
  u64 vmacache_seqnum;\r
\r
  unsigned long (*get_unmapped_area) (struct file *filp,\r
    unsigned long addr, unsigned long len,\r
    unsigned long pgoff, unsigned long flags);\r
\r
  unsigned long mmap_base;\r
  unsigned long mmap_legacy_base;\r
\r
\r
\r
\r
\r
  unsigned long task_size;\r
  unsigned long highest_vm_end;\r
  pgd_t * pgd;\r
# 504 "./include/linux/mm_types.h"\r
  atomic_t membarrier_state;\r
# 516 "./include/linux/mm_types.h"\r
  atomic_t mm_users;\r
# 525 "./include/linux/mm_types.h"\r
  atomic_t mm_count;\r
\r
\r
  atomic_long_t pgtables_bytes;\r
\r
  int map_count;\r
\r
  spinlock_t page_table_lock;\r
# 547 "./include/linux/mm_types.h"\r
  struct rw_semaphore mmap_lock;\r
\r
  struct list_head mmlist;\r
\r
\r
\r
\r
\r
\r
  unsigned long hiwater_rss;\r
  unsigned long hiwater_vm;\r
\r
  unsigned long total_vm;\r
  unsigned long locked_vm;\r
  atomic64_t pinned_vm;\r
  unsigned long data_vm;\r
  unsigned long exec_vm;\r
  unsigned long stack_vm;\r
  unsigned long def_flags;\r
\r
\r
\r
\r
\r
\r
  seqcount_t write_protect_seq;\r
\r
  spinlock_t arg_lock;\r
\r
  unsigned long start_code, end_code, start_data, end_data;\r
  unsigned long start_brk, brk, start_stack;\r
  unsigned long arg_start, arg_end, env_start, env_end;\r
\r
  unsigned long saved_auxv[(2*(7 + 20 + 1))];\r
\r
\r
\r
\r
\r
  struct mm_rss_stat rss_stat;\r
\r
  struct linux_binfmt *binfmt;\r
\r
\r
  mm_context_t context;\r
\r
  unsigned long flags;\r
\r
\r
  spinlock_t ioctx_lock;\r
  struct kioctx_table *ioctx_table;\r
# 612 "./include/linux/mm_types.h"\r
  struct user_namespace *user_ns;\r
\r
\r
  struct file *exe_file;\r
\r
  struct mmu_notifier_subscriptions *notifier_subscriptions;\r
# 641 "./include/linux/mm_types.h"\r
  atomic_t tlb_flush_pending;\r
\r
\r
\r
\r
  struct uprobes_state uprobes_state;\r
\r
\r
\r
\r
\r
\r
  struct work_struct async_put_work;\r
\r
\r
\r
\r
 } ;\r
\r
\r
\r
\r
\r
 unsigned long cpu_bitmap[];\r
};\r
\r
extern struct mm_struct init_mm;\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void mm_init_cpumask(struct mm_struct *mm)\r
{\r
 unsigned long cpu_bitmap = (unsigned long)mm;\r
\r
 cpu_bitmap += __builtin_offsetof(struct mm_struct, cpu_bitmap);\r
 cpumask_clear((struct cpumask *)cpu_bitmap);\r
}\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) cpumask_t *mm_cpumask(struct mm_struct *mm)\r
{\r
 return (struct cpumask *)&mm->cpu_bitmap;\r
}\r
\r
struct mmu_gather;\r
extern void tlb_gather_mmu(struct mmu_gather *tlb, struct mm_struct *mm);\r
extern void tlb_gather_mmu_fullmm(struct mmu_gather *tlb, struct mm_struct *mm);\r
extern void tlb_finish_mmu(struct mmu_gather *tlb);\r
\r
struct vm_fault;\r
\r
\r
\r
\r
\r
\r
typedef unsigned int vm_fault_t;\r
# 723 "./include/linux/mm_types.h"\r
enum vm_fault_reason {\r
 VM_FAULT_OOM = ( vm_fault_t)0x000001,\r
 VM_FAULT_SIGBUS = ( vm_fault_t)0x000002,\r
 VM_FAULT_MAJOR = ( vm_fault_t)0x000004,\r
 VM_FAULT_WRITE = ( vm_fault_t)0x000008,\r
 VM_FAULT_HWPOISON = ( vm_fault_t)0x000010,\r
 VM_FAULT_HWPOISON_LARGE = ( vm_fault_t)0x000020,\r
 VM_FAULT_SIGSEGV = ( vm_fault_t)0x000040,\r
 VM_FAULT_NOPAGE = ( vm_fault_t)0x000100,\r
 VM_FAULT_LOCKED = ( vm_fault_t)0x000200,\r
 VM_FAULT_RETRY = ( vm_fault_t)0x000400,\r
 VM_FAULT_FALLBACK = ( vm_fault_t)0x000800,\r
 VM_FAULT_DONE_COW = ( vm_fault_t)0x001000,\r
 VM_FAULT_NEEDDSYNC = ( vm_fault_t)0x002000,\r
 VM_FAULT_HINDEX_MASK = ( vm_fault_t)0x0f0000,\r
};\r
# 763 "./include/linux/mm_types.h"\r
struct vm_special_mapping {\r
 const char *name;\r
\r
\r
\r
\r
\r
\r
\r
 struct page **pages;\r
\r
\r
\r
\r
\r
 vm_fault_t (*fault)(const struct vm_special_mapping *sm,\r
    struct vm_area_struct *vma,\r
    struct vm_fault *vmf);\r
\r
 int (*mremap)(const struct vm_special_mapping *sm,\r
       struct vm_area_struct *new_vma);\r
};\r
\r
enum tlb_flush_reason {\r
 TLB_FLUSH_ON_TASK_SWITCH,\r
 TLB_REMOTE_SHOOTDOWN,\r
 TLB_LOCAL_SHOOTDOWN,\r
 TLB_LOCAL_MM_SHOOTDOWN,\r
 TLB_REMOTE_SEND_IPI,\r
 NR_TLB_FLUSH_REASONS,\r
};\r
\r
\r
\r
\r
\r
typedef struct {\r
 unsigned long val;\r
} swp_entry_t;\r
# 835 "./include/linux/mm_types.h"\r
enum fault_flag {\r
 FAULT_FLAG_WRITE = 1 << 0,\r
 FAULT_FLAG_MKWRITE = 1 << 1,\r
 FAULT_FLAG_ALLOW_RETRY = 1 << 2,\r
 FAULT_FLAG_RETRY_NOWAIT = 1 << 3,\r
 FAULT_FLAG_KILLABLE = 1 << 4,\r
 FAULT_FLAG_TRIED = 1 << 5,\r
 FAULT_FLAG_USER = 1 << 6,\r
 FAULT_FLAG_REMOTE = 1 << 7,\r
 FAULT_FLAG_INSTRUCTION = 1 << 8,\r
 FAULT_FLAG_INTERRUPTIBLE = 1 << 9,\r
};\r
# 11 "./include/linux/uio.h" 2\r
# 1 "./include/uapi/linux/uio.h" 1\r
# 17 "./include/uapi/linux/uio.h"\r
struct iovec\r
{\r
 void *iov_base;\r
 __kernel_size_t iov_len;\r
};\r
# 12 "./include/linux/uio.h" 2\r
\r
struct page;\r
struct pipe_inode_info;\r
\r
struct kvec {\r
 void *iov_base;\r
 size_t iov_len;\r
};\r
\r
enum iter_type {\r
\r
 ITER_IOVEC,\r
 ITER_KVEC,\r
 ITER_BVEC,\r
 ITER_PIPE,\r
 ITER_XARRAY,\r
 ITER_DISCARD,\r
};\r
\r
struct iov_iter_state {\r
 size_t iov_offset;\r
 size_t count;\r
 unsigned long nr_segs;\r
};\r
\r
struct iov_iter {\r
 u8 iter_type;\r
 bool nofault;\r
 bool data_source;\r
 size_t iov_offset;\r
 size_t count;\r
 union {\r
  const struct iovec *iov;\r
  const struct kvec *kvec;\r
  const struct bio_vec *bvec;\r
  struct xarray *xarray;\r
  struct pipe_inode_info *pipe;\r
 };\r
 union {\r
  unsigned long nr_segs;\r
  struct {\r
   unsigned int head;\r
   unsigned int start_head;\r
  };\r
  loff_t xarray_start;\r
 };\r
};\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) enum iter_type iov_iter_type(const struct iov_iter *i)\r
{\r
 return i->iter_type;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void iov_iter_save_state(struct iov_iter *iter,\r
           struct iov_iter_state *state)\r
{\r
 state->iov_offset = iter->iov_offset;\r
 state->count = iter->count;\r
 state->nr_segs = iter->nr_segs;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool iter_is_iovec(const struct iov_iter *i)\r
{\r
 return iov_iter_type(i) == ITER_IOVEC;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool iov_iter_is_kvec(const struct iov_iter *i)\r
{\r
 return iov_iter_type(i) == ITER_KVEC;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool iov_iter_is_bvec(const struct iov_iter *i)\r
{\r
 return iov_iter_type(i) == ITER_BVEC;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool iov_iter_is_pipe(const struct iov_iter *i)\r
{\r
 return iov_iter_type(i) == ITER_PIPE;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool iov_iter_is_discard(const struct iov_iter *i)\r
{\r
 return iov_iter_type(i) == ITER_DISCARD;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool iov_iter_is_xarray(const struct iov_iter *i)\r
{\r
 return iov_iter_type(i) == ITER_XARRAY;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) unsigned char iov_iter_rw(const struct iov_iter *i)\r
{\r
 return i->data_source ? 1 : 0;\r
}\r
# 115 "./include/linux/uio.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) size_t iov_length(const struct iovec *iov, unsigned long nr_segs)\r
{\r
 unsigned long seg;\r
 size_t ret = 0;\r
\r
 for (seg = 0; seg < nr_segs; seg++)\r
  ret += iov[seg].iov_len;\r
 return ret;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) struct iovec iov_iter_iovec(const struct iov_iter *iter)\r
{\r
 return (struct iovec) {\r
  .iov_base = iter->iov->iov_base + iter->iov_offset,\r
  .iov_len = __builtin_choose_expr(((!!(sizeof((typeof(iter->count) *)1 == (typeof(iter->iov->iov_len - iter->iov_offset) *)1))) && ((sizeof(int) == sizeof(*(8 ? ((void *)((long)(iter->count) * 0l)) : (int *)8))) && (sizeof(int) == sizeof(*(8 ? ((void *)((long)(iter->iov->iov_len - iter->iov_offset) * 0l)) : (int *)8))))), ((iter->count) < (iter->iov->iov_len - iter->iov_offset) ? (iter->count) : (iter->iov->iov_len - iter->iov_offset)), ({ typeof(iter->count) __UNIQUE_ID___x85 = (iter->count); typeof(iter->iov->iov_len - iter->iov_offset) __UNIQUE_ID___y86 = (iter->iov->iov_len - iter->iov_offset); ((__UNIQUE_ID___x85) < (__UNIQUE_ID___y86) ? (__UNIQUE_ID___x85) : (__UNIQUE_ID___y86)); })),\r
\r
 };\r
}\r
\r
size_t copy_page_from_iter_atomic(struct page *page, unsigned offset,\r
      size_t bytes, struct iov_iter *i);\r
void iov_iter_advance(struct iov_iter *i, size_t bytes);\r
void iov_iter_revert(struct iov_iter *i, size_t bytes);\r
size_t fault_in_iov_iter_readable(const struct iov_iter *i, size_t bytes);\r
size_t fault_in_iov_iter_writeable(const struct iov_iter *i, size_t bytes);\r
size_t iov_iter_single_seg_count(const struct iov_iter *i);\r
size_t copy_page_to_iter(struct page *page, size_t offset, size_t bytes,\r
    struct iov_iter *i);\r
size_t copy_page_from_iter(struct page *page, size_t offset, size_t bytes,\r
    struct iov_iter *i);\r
\r
size_t _copy_to_iter(const void *addr, size_t bytes, struct iov_iter *i);\r
size_t _copy_from_iter(void *addr, size_t bytes, struct iov_iter *i);\r
size_t _copy_from_iter_nocache(void *addr, size_t bytes, struct iov_iter *i);\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) size_t copy_folio_to_iter(struct folio *folio, size_t offset,\r
  size_t bytes, struct iov_iter *i)\r
{\r
 return copy_page_to_iter(&folio->page, offset, bytes, i);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) __attribute__((__warn_unused_result__))\r
size_t copy_to_iter(const void *addr, size_t bytes, struct iov_iter *i)\r
{\r
 if (__builtin_expect(!!(!check_copy_size(addr, bytes, true)), 0))\r
  return 0;\r
 else\r
  return _copy_to_iter(addr, bytes, i);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) __attribute__((__warn_unused_result__))\r
size_t copy_from_iter(void *addr, size_t bytes, struct iov_iter *i)\r
{\r
 if (__builtin_expect(!!(!check_copy_size(addr, bytes, false)), 0))\r
  return 0;\r
 else\r
  return _copy_from_iter(addr, bytes, i);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) __attribute__((__warn_unused_result__))\r
bool copy_from_iter_full(void *addr, size_t bytes, struct iov_iter *i)\r
{\r
 size_t copied = copy_from_iter(addr, bytes, i);\r
 if (__builtin_expect(!!(copied == bytes), 1))\r
  return true;\r
 iov_iter_revert(i, copied);\r
 return false;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) __attribute__((__warn_unused_result__))\r
size_t copy_from_iter_nocache(void *addr, size_t bytes, struct iov_iter *i)\r
{\r
 if (__builtin_expect(!!(!check_copy_size(addr, bytes, false)), 0))\r
  return 0;\r
 else\r
  return _copy_from_iter_nocache(addr, bytes, i);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) __attribute__((__warn_unused_result__))\r
bool copy_from_iter_full_nocache(void *addr, size_t bytes, struct iov_iter *i)\r
{\r
 size_t copied = copy_from_iter_nocache(addr, bytes, i);\r
 if (__builtin_expect(!!(copied == bytes), 1))\r
  return true;\r
 iov_iter_revert(i, copied);\r
 return false;\r
}\r
# 221 "./include/linux/uio.h"\r
size_t iov_iter_zero(size_t bytes, struct iov_iter *);\r
unsigned long iov_iter_alignment(const struct iov_iter *i);\r
unsigned long iov_iter_gap_alignment(const struct iov_iter *i);\r
void iov_iter_init(struct iov_iter *i, unsigned int direction, const struct iovec *iov,\r
   unsigned long nr_segs, size_t count);\r
void iov_iter_kvec(struct iov_iter *i, unsigned int direction, const struct kvec *kvec,\r
   unsigned long nr_segs, size_t count);\r
void iov_iter_bvec(struct iov_iter *i, unsigned int direction, const struct bio_vec *bvec,\r
   unsigned long nr_segs, size_t count);\r
void iov_iter_pipe(struct iov_iter *i, unsigned int direction, struct pipe_inode_info *pipe,\r
   size_t count);\r
void iov_iter_discard(struct iov_iter *i, unsigned int direction, size_t count);\r
void iov_iter_xarray(struct iov_iter *i, unsigned int direction, struct xarray *xarray,\r
       loff_t start, size_t count);\r
ssize_t iov_iter_get_pages(struct iov_iter *i, struct page **pages,\r
   size_t maxsize, unsigned maxpages, size_t *start);\r
ssize_t iov_iter_get_pages_alloc(struct iov_iter *i, struct page ***pages,\r
   size_t maxsize, size_t *start);\r
int iov_iter_npages(const struct iov_iter *i, int maxpages);\r
void iov_iter_restore(struct iov_iter *i, struct iov_iter_state *state);\r
\r
const void *dup_iter(struct iov_iter *new, struct iov_iter *old, gfp_t flags);\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) size_t iov_iter_count(const struct iov_iter *i)\r
{\r
 return i->count;\r
}\r
\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void iov_iter_truncate(struct iov_iter *i, u64 count)\r
{\r
\r
\r
\r
\r
\r
\r
 if (i->count > count)\r
  i->count = count;\r
}\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void iov_iter_reexpand(struct iov_iter *i, size_t count)\r
{\r
 i->count = count;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int\r
iov_iter_npages_cap(struct iov_iter *i, int maxpages, size_t max_bytes)\r
{\r
 size_t shorted = 0;\r
 int npages;\r
\r
 if (iov_iter_count(i) > max_bytes) {\r
  shorted = iov_iter_count(i) - max_bytes;\r
  iov_iter_truncate(i, max_bytes);\r
 }\r
 npages = iov_iter_npages(i, ((int)(~0U >> 1)));\r
 if (shorted)\r
  iov_iter_reexpand(i, iov_iter_count(i) + shorted);\r
\r
 return npages;\r
}\r
\r
struct csum_state {\r
 __wsum csum;\r
 size_t off;\r
};\r
\r
size_t csum_and_copy_to_iter(const void *addr, size_t bytes, void *csstate, struct iov_iter *i);\r
size_t csum_and_copy_from_iter(void *addr, size_t bytes, __wsum *csum, struct iov_iter *i);\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) __attribute__((__warn_unused_result__))\r
bool csum_and_copy_from_iter_full(void *addr, size_t bytes,\r
      __wsum *csum, struct iov_iter *i)\r
{\r
 size_t copied = csum_and_copy_from_iter(addr, bytes, csum, i);\r
 if (__builtin_expect(!!(copied == bytes), 1))\r
  return true;\r
 iov_iter_revert(i, copied);\r
 return false;\r
}\r
size_t hash_and_copy_to_iter(const void *addr, size_t bytes, void *hashp,\r
  struct iov_iter *i);\r
\r
struct iovec *iovec_from_user(const struct iovec *uvector,\r
  unsigned long nr_segs, unsigned long fast_segs,\r
  struct iovec *fast_iov, bool compat);\r
ssize_t import_iovec(int type, const struct iovec *uvec,\r
   unsigned nr_segs, unsigned fast_segs, struct iovec **iovp,\r
   struct iov_iter *i);\r
ssize_t __import_iovec(int type, const struct iovec *uvec,\r
   unsigned nr_segs, unsigned fast_segs, struct iovec **iovp,\r
   struct iov_iter *i, bool compat);\r
int import_single_range(int type, void *buf, size_t len,\r
   struct iovec *iov, struct iov_iter *i);\r
# 9 "./include/linux/socket.h" 2\r
\r
\r
# 1 "./include/uapi/linux/socket.h" 1\r
# 10 "./include/uapi/linux/socket.h"\r
typedef unsigned short __kernel_sa_family_t;\r
\r
\r
\r
\r
\r
struct __kernel_sockaddr_storage {\r
 union {\r
  struct {\r
   __kernel_sa_family_t ss_family;\r
\r
   char __data[128 - sizeof(unsigned short)];\r
\r
\r
  };\r
  void *__align;\r
 };\r
};\r
# 12 "./include/linux/socket.h" 2\r
\r
struct file;\r
struct pid;\r
struct cred;\r
struct socket;\r
\r
\r
\r
\r
\r
struct seq_file;\r
extern void socket_seq_show(struct seq_file *seq);\r
\r
\r
typedef __kernel_sa_family_t sa_family_t;\r
\r
\r
\r
\r
\r
struct sockaddr {\r
 sa_family_t sa_family;\r
 char sa_data[14];\r
};\r
\r
struct linger {\r
 int l_onoff;\r
 int l_linger;\r
};\r
# 50 "./include/linux/socket.h"\r
struct msghdr {\r
 void *msg_name;\r
 int msg_namelen;\r
 struct iov_iter msg_iter;\r
\r
\r
\r
\r
\r
\r
 union {\r
  void *msg_control;\r
  void *msg_control_user;\r
 };\r
 bool msg_control_is_user : 1;\r
 __kernel_size_t msg_controllen;\r
 unsigned int msg_flags;\r
 struct kiocb *msg_iocb;\r
};\r
\r
struct user_msghdr {\r
 void *msg_name;\r
 int msg_namelen;\r
 struct iovec *msg_iov;\r
 __kernel_size_t msg_iovlen;\r
 void *msg_control;\r
 __kernel_size_t msg_controllen;\r
 unsigned int msg_flags;\r
};\r
\r
\r
struct mmsghdr {\r
 struct user_msghdr msg_hdr;\r
 unsigned int msg_len;\r
};\r
\r
\r
\r
\r
\r
\r
\r
struct cmsghdr {\r
 __kernel_size_t cmsg_len;\r
        int cmsg_level;\r
        int cmsg_type;\r
};\r
# 141 "./include/linux/socket.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) struct cmsghdr * __cmsg_nxthdr(void *__ctl, __kernel_size_t __size,\r
            struct cmsghdr *__cmsg)\r
{\r
 struct cmsghdr * __ptr;\r
\r
 __ptr = (struct cmsghdr*)(((unsigned char *) __cmsg) + ( ((__cmsg->cmsg_len)+sizeof(long)-1) & ~(sizeof(long)-1) ));\r
 if ((unsigned long)((char*)(__ptr+1) - (char *) __ctl) > __size)\r
  return (struct cmsghdr *)0;\r
\r
 return __ptr;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) struct cmsghdr * cmsg_nxthdr (struct msghdr *__msg, struct cmsghdr *__cmsg)\r
{\r
 return __cmsg_nxthdr(__msg->msg_control, __msg->msg_controllen, __cmsg);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) size_t msg_data_left(struct msghdr *msg)\r
{\r
 return iov_iter_count(&msg->msg_iter);\r
}\r
\r
\r
\r
\r
\r
\r
\r
struct ucred {\r
 __u32 pid;\r
 __u32 uid;\r
 __u32 gid;\r
};\r
# 374 "./include/linux/socket.h"\r
extern int move_addr_to_kernel(void *uaddr, int ulen, struct __kernel_sockaddr_storage *kaddr);\r
extern int put_cmsg(struct msghdr*, int level, int type, int len, void *data);\r
\r
struct timespec64;\r
struct __kernel_timespec;\r
struct old_timespec32;\r
\r
struct scm_timestamping_internal {\r
 struct timespec64 ts[3];\r
};\r
\r
extern void put_cmsg_scm_timestamping64(struct msghdr *msg, struct scm_timestamping_internal *tss);\r
extern void put_cmsg_scm_timestamping(struct msghdr *msg, struct scm_timestamping_internal *tss);\r
\r
\r
\r
\r
extern long __sys_recvmsg(int fd, struct user_msghdr *msg,\r
     unsigned int flags, bool forbid_cmsg_compat);\r
extern long __sys_sendmsg(int fd, struct user_msghdr *msg,\r
     unsigned int flags, bool forbid_cmsg_compat);\r
extern int __sys_recvmmsg(int fd, struct mmsghdr *mmsg,\r
     unsigned int vlen, unsigned int flags,\r
     struct __kernel_timespec *timeout,\r
     struct old_timespec32 *timeout32);\r
extern int __sys_sendmmsg(int fd, struct mmsghdr *mmsg,\r
     unsigned int vlen, unsigned int flags,\r
     bool forbid_cmsg_compat);\r
extern long __sys_sendmsg_sock(struct socket *sock, struct msghdr *msg,\r
          unsigned int flags);\r
extern long __sys_recvmsg_sock(struct socket *sock, struct msghdr *msg,\r
          struct user_msghdr *umsg,\r
          struct sockaddr *uaddr,\r
          unsigned int flags);\r
extern int sendmsg_copy_msghdr(struct msghdr *msg,\r
          struct user_msghdr *umsg, unsigned flags,\r
          struct iovec **iov);\r
extern int recvmsg_copy_msghdr(struct msghdr *msg,\r
          struct user_msghdr *umsg, unsigned flags,\r
          struct sockaddr **uaddr,\r
          struct iovec **iov);\r
extern int __copy_msghdr_from_user(struct msghdr *kmsg,\r
       struct user_msghdr *umsg,\r
       struct sockaddr **save_addr,\r
       struct iovec **uiov, size_t *nsegs);\r
\r
\r
extern int __sys_recvfrom(int fd, void *ubuf, size_t size,\r
     unsigned int flags, struct sockaddr *addr,\r
     int *addr_len);\r
extern int __sys_sendto(int fd, void *buff, size_t len,\r
   unsigned int flags, struct sockaddr *addr,\r
   int addr_len);\r
extern int __sys_accept4_file(struct file *file, unsigned file_flags,\r
   struct sockaddr *upeer_sockaddr,\r
    int *upeer_addrlen, int flags,\r
    unsigned long nofile);\r
extern struct file *do_accept(struct file *file, unsigned file_flags,\r
         struct sockaddr *upeer_sockaddr,\r
         int *upeer_addrlen, int flags);\r
extern int __sys_accept4(int fd, struct sockaddr *upeer_sockaddr,\r
    int *upeer_addrlen, int flags);\r
extern int __sys_socket(int family, int type, int protocol);\r
extern int __sys_bind(int fd, struct sockaddr *umyaddr, int addrlen);\r
extern int __sys_connect_file(struct file *file, struct __kernel_sockaddr_storage *addr,\r
         int addrlen, int file_flags);\r
extern int __sys_connect(int fd, struct sockaddr *uservaddr,\r
    int addrlen);\r
extern int __sys_listen(int fd, int backlog);\r
extern int __sys_getsockname(int fd, struct sockaddr *usockaddr,\r
        int *usockaddr_len);\r
extern int __sys_getpeername(int fd, struct sockaddr *usockaddr,\r
        int *usockaddr_len);\r
extern int __sys_socketpair(int family, int type, int protocol,\r
       int *usockvec);\r
extern int __sys_shutdown_sock(struct socket *sock, int how);\r
extern int __sys_shutdown(int fd, int how);\r
# 31 "net/ipv6/route.c" 2\r
\r
# 1 "./include/linux/net.h" 1\r
# 18 "./include/linux/net.h"\r
# 1 "./include/linux/random.h" 1\r
\r
\r
\r
\r
\r
\r
\r
\r
# 1 "./include/linux/once.h" 1\r
\r
\r
\r
\r
\r
# 1 "./include/linux/jump_label.h" 1\r
# 79 "./include/linux/jump_label.h"\r
extern bool static_key_initialized;\r
\r
\r
\r
\r
\r
struct static_key {\r
 atomic_t enabled;\r
# 107 "./include/linux/jump_label.h"\r
};\r
# 191 "./include/linux/jump_label.h"\r
enum jump_label_type {\r
 JUMP_LABEL_NOP = 0,\r
 JUMP_LABEL_JMP,\r
};\r
\r
struct module;\r
# 259 "./include/linux/jump_label.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int static_key_count(struct static_key *key)\r
{\r
 return atomic_read(&key->enabled);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) void jump_label_init(void)\r
{\r
 static_key_initialized = true;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool static_key_false(struct static_key *key)\r
{\r
 if (__builtin_expect(!!(static_key_count(key) > 0), 0))\r
  return true;\r
 return false;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool static_key_true(struct static_key *key)\r
{\r
 if (__builtin_expect(!!(static_key_count(key) > 0), 1))\r
  return true;\r
 return false;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void static_key_slow_inc(struct static_key *key)\r
{\r
 ({ int __ret_warn_on = !!(!static_key_initialized); if (__builtin_expect(!!(__ret_warn_on), 0)) do { do { } while(0); __warn_printk("%s(): static key '%pS' used before call to jump_label_init()", __func__, (key)); do { __asm__ __volatile__ ( "1:\n\t" "ebreak\n" ".pushsection __bug_table,\"aw\"\n\t" "2:\n\t" ".word" " 1b - 2b" "\n\t" ".word" " %0 - 2b" "\n\t" ".half" " %1\n\t" ".half" " %2" "\n\t" ".org 2b + %3\n\t" ".popsection" : : "i" ("include/linux/jump_label.h"), "i" (285), "i" ((1 << 0)|((1 << 3) | ((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); do { } while(0); } while (0); __builtin_expect(!!(__ret_warn_on), 0); });\r
 atomic_inc(&key->enabled);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void static_key_slow_dec(struct static_key *key)\r
{\r
 ({ int __ret_warn_on = !!(!static_key_initialized); if (__builtin_expect(!!(__ret_warn_on), 0)) do { do { } while(0); __warn_printk("%s(): static key '%pS' used before call to jump_label_init()", __func__, (key)); do { __asm__ __volatile__ ( "1:\n\t" "ebreak\n" ".pushsection __bug_table,\"aw\"\n\t" "2:\n\t" ".word" " 1b - 2b" "\n\t" ".word" " %0 - 2b" "\n\t" ".half" " %1\n\t" ".half" " %2" "\n\t" ".org 2b + %3\n\t" ".popsection" : : "i" ("include/linux/jump_label.h"), "i" (291), "i" ((1 << 0)|((1 << 3) | ((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); do { } while(0); } while (0); __builtin_expect(!!(__ret_warn_on), 0); });\r
 atomic_dec(&key->enabled);\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int jump_label_text_reserved(void *start, void *end)\r
{\r
 return 0;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void jump_label_lock(void) {}\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void jump_label_unlock(void) {}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int jump_label_apply_nops(struct module *mod)\r
{\r
 return 0;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void static_key_enable(struct static_key *key)\r
{\r
 ({ int __ret_warn_on = !!(!static_key_initialized); if (__builtin_expect(!!(__ret_warn_on), 0)) do { do { } while(0); __warn_printk("%s(): static key '%pS' used before call to jump_label_init()", __func__, (key)); do { __asm__ __volatile__ ( "1:\n\t" "ebreak\n" ".pushsection __bug_table,\"aw\"\n\t" "2:\n\t" ".word" " 1b - 2b" "\n\t" ".word" " %0 - 2b" "\n\t" ".half" " %1\n\t" ".half" " %2" "\n\t" ".org 2b + %3\n\t" ".popsection" : : "i" ("include/linux/jump_label.h"), "i" (313), "i" ((1 << 0)|((1 << 3) | ((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); do { } while(0); } while (0); __builtin_expect(!!(__ret_warn_on), 0); });\r
\r
 if (atomic_read(&key->enabled) != 0) {\r
  ({ int __ret_warn_on = !!(atomic_read(&key->enabled) != 1); if (__builtin_expect(!!(__ret_warn_on), 0)) do { __asm__ __volatile__ ( "1:\n\t" "ebreak\n" ".pushsection __bug_table,\"aw\"\n\t" "2:\n\t" ".word" " 1b - 2b" "\n\t" ".word" " %0 - 2b" "\n\t" ".half" " %1\n\t" ".half" " %2" "\n\t" ".org 2b + %3\n\t" ".popsection" : : "i" ("include/linux/jump_label.h"), "i" (316), "i" ((1 << 0)|((1 << 1) | ((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); __builtin_expect(!!(__ret_warn_on), 0); });\r
  return;\r
 }\r
 atomic_set(&key->enabled, 1);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void static_key_disable(struct static_key *key)\r
{\r
 ({ int __ret_warn_on = !!(!static_key_initialized); if (__builtin_expect(!!(__ret_warn_on), 0)) do { do { } while(0); __warn_printk("%s(): static key '%pS' used before call to jump_label_init()", __func__, (key)); do { __asm__ __volatile__ ( "1:\n\t" "ebreak\n" ".pushsection __bug_table,\"aw\"\n\t" "2:\n\t" ".word" " 1b - 2b" "\n\t" ".word" " %0 - 2b" "\n\t" ".half" " %1\n\t" ".half" " %2" "\n\t" ".org 2b + %3\n\t" ".popsection" : : "i" ("include/linux/jump_label.h"), "i" (324), "i" ((1 << 0)|((1 << 3) | ((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); do { } while(0); } while (0); __builtin_expect(!!(__ret_warn_on), 0); });\r
\r
 if (atomic_read(&key->enabled) != 1) {\r
  ({ int __ret_warn_on = !!(atomic_read(&key->enabled) != 0); if (__builtin_expect(!!(__ret_warn_on), 0)) do { __asm__ __volatile__ ( "1:\n\t" "ebreak\n" ".pushsection __bug_table,\"aw\"\n\t" "2:\n\t" ".word" " 1b - 2b" "\n\t" ".word" " %0 - 2b" "\n\t" ".half" " %1\n\t" ".half" " %2" "\n\t" ".org 2b + %3\n\t" ".popsection" : : "i" ("include/linux/jump_label.h"), "i" (327), "i" ((1 << 0)|((1 << 1) | ((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); __builtin_expect(!!(__ret_warn_on), 0); });\r
  return;\r
 }\r
 atomic_set(&key->enabled, 0);\r
}\r
# 353 "./include/linux/jump_label.h"\r
struct static_key_true {\r
 struct static_key key;\r
};\r
\r
struct static_key_false {\r
 struct static_key key;\r
};\r
# 407 "./include/linux/jump_label.h"\r
extern bool ____wrong_branch_error(void);\r
# 7 "./include/linux/once.h" 2\r
\r
bool __do_once_start(bool *done, unsigned long *flags);\r
void __do_once_done(bool *done, struct static_key_true *once_key,\r
      unsigned long *flags, struct module *mod);\r
# 10 "./include/linux/random.h" 2\r
\r
# 1 "./include/uapi/linux/random.h" 1\r
# 12 "./include/uapi/linux/random.h"\r
# 1 "./include/uapi/linux/ioctl.h" 1\r
\r
\r
\r
\r
# 1 "./arch/riscv/include/generated/uapi/asm/ioctl.h" 1\r
# 1 "./include/asm-generic/ioctl.h" 1\r
\r
\r
\r
\r
# 1 "./include/uapi/asm-generic/ioctl.h" 1\r
# 6 "./include/asm-generic/ioctl.h" 2\r
\r
\r
\r
\r
\r
extern unsigned int __invalid_size_argument_for_IOC;\r
# 2 "./arch/riscv/include/generated/uapi/asm/ioctl.h" 2\r
# 6 "./include/uapi/linux/ioctl.h" 2\r
# 13 "./include/uapi/linux/random.h" 2\r
# 1 "./include/linux/irqnr.h" 1\r
\r
\r
\r
\r
# 1 "./include/uapi/linux/irqnr.h" 1\r
# 6 "./include/linux/irqnr.h" 2\r
\r
\r
extern int nr_irqs;\r
extern struct irq_desc *irq_to_desc(unsigned int irq);\r
unsigned int irq_get_next_irq(unsigned int offset);\r
# 14 "./include/uapi/linux/random.h" 2\r
# 41 "./include/uapi/linux/random.h"\r
struct rand_pool_info {\r
 int entropy_count;\r
 int buf_size;\r
 __u32 buf[0];\r
};\r
# 12 "./include/linux/random.h" 2\r
\r
struct notifier_block;\r
\r
extern void add_device_randomness(const void *, size_t);\r
extern void add_bootloader_randomness(const void *, size_t);\r
# 25 "./include/linux/random.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void add_latent_entropy(void) {}\r
\r
\r
extern void add_input_randomness(unsigned int type, unsigned int code,\r
     unsigned int value) ;\r
extern void add_interrupt_randomness(int irq) ;\r
extern void add_hwgenerator_randomness(const void *buffer, size_t count,\r
           size_t entropy);\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int register_random_vmfork_notifier(struct notifier_block *nb) { return 0; }\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int unregister_random_vmfork_notifier(struct notifier_block *nb) { return 0; }\r
\r
\r
extern void get_random_bytes(void *buf, size_t nbytes);\r
extern int wait_for_random_bytes(void);\r
extern int __attribute__((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((__no_sanitize__("cfi"))) rand_initialize(void);\r
extern bool rng_is_initialized(void);\r
extern int register_random_ready_notifier(struct notifier_block *nb);\r
extern int unregister_random_ready_notifier(struct notifier_block *nb);\r
extern size_t __attribute__((__warn_unused_result__)) get_random_bytes_arch(void *buf, size_t nbytes);\r
\r
\r
extern const struct file_operations random_fops, urandom_fops;\r
\r
\r
u32 get_random_u32(void);\r
u64 get_random_u64(void);\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) unsigned int get_random_int(void)\r
{\r
 return get_random_u32();\r
}\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) unsigned long get_random_long(void)\r
{\r
\r
 return get_random_u64();\r
\r
\r
\r
}\r
# 83 "./include/linux/random.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) unsigned long get_random_canary(void)\r
{\r
 unsigned long val = get_random_long();\r
\r
 return val & 0xffffffffffffff00UL;\r
}\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int get_random_bytes_wait(void *buf, size_t nbytes)\r
{\r
 int ret = wait_for_random_bytes();\r
 get_random_bytes(buf, nbytes);\r
 return ret;\r
}\r
# 107 "./include/linux/random.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int get_random_u32_wait(u32 *out) { int ret = wait_for_random_bytes(); if (__builtin_expect(!!(ret), 0)) return ret; *out = get_random_u32(); return 0; }\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int get_random_u64_wait(u64 *out) { int ret = wait_for_random_bytes(); if (__builtin_expect(!!(ret), 0)) return ret; *out = get_random_u64(); return 0; }\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int get_random_int_wait(int *out) { int ret = wait_for_random_bytes(); if (__builtin_expect(!!(ret), 0)) return ret; *out = get_random_int(); return 0; }\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int get_random_long_wait(long *out) { int ret = wait_for_random_bytes(); if (__builtin_expect(!!(ret), 0)) return ret; *out = get_random_long(); return 0; }\r
\r
\r
unsigned long randomize_page(unsigned long start, unsigned long range);\r
\r
\r
\r
\r
\r
\r
\r
# 1 "./include/linux/prandom.h" 1\r
# 12 "./include/linux/prandom.h"\r
# 1 "./include/linux/percpu.h" 1\r
\r
\r
\r
\r
# 1 "./include/linux/mmdebug.h" 1\r
\r
\r
\r
\r
\r
\r
\r
struct page;\r
struct vm_area_struct;\r
struct mm_struct;\r
\r
void dump_page(struct page *page, const char *reason);\r
void dump_vma(const struct vm_area_struct *vma);\r
void dump_mm(const struct mm_struct *mm);\r
# 6 "./include/linux/percpu.h" 2\r
\r
\r
\r
\r
\r
\r
# 1 "./arch/riscv/include/generated/asm/percpu.h" 1\r
# 13 "./include/linux/percpu.h" 2\r
# 64 "./include/linux/percpu.h"\r
extern void *pcpu_base_addr;\r
extern const unsigned long *pcpu_unit_offsets;\r
\r
struct pcpu_group_info {\r
 int nr_units;\r
 unsigned long base_offset;\r
 unsigned int *cpu_map;\r
\r
};\r
\r
struct pcpu_alloc_info {\r
 size_t static_size;\r
 size_t reserved_size;\r
 size_t dyn_size;\r
 size_t unit_size;\r
 size_t atom_size;\r
 size_t alloc_size;\r
 size_t __ai_size;\r
 int nr_groups;\r
 struct pcpu_group_info groups[];\r
};\r
\r
enum pcpu_fc {\r
 PCPU_FC_AUTO,\r
 PCPU_FC_EMBED,\r
 PCPU_FC_PAGE,\r
\r
 PCPU_FC_NR,\r
};\r
extern const char * const pcpu_fc_names[PCPU_FC_NR];\r
\r
extern enum pcpu_fc pcpu_chosen_fc;\r
\r
typedef int (pcpu_fc_cpu_to_node_fn_t)(int cpu);\r
typedef int (pcpu_fc_cpu_distance_fn_t)(unsigned int from, unsigned int to);\r
\r
extern struct pcpu_alloc_info * __attribute__((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((__no_sanitize__("cfi"))) pcpu_alloc_alloc_info(int nr_groups,\r
            int nr_units);\r
extern void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((__no_sanitize__("cfi"))) pcpu_free_alloc_info(struct pcpu_alloc_info *ai);\r
\r
extern void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((__no_sanitize__("cfi"))) pcpu_setup_first_chunk(const struct pcpu_alloc_info *ai,\r
      void *base_addr);\r
# 120 "./include/linux/percpu.h"\r
extern void *__alloc_reserved_percpu(size_t size, size_t align) __attribute__((__alloc_size__(1))) __attribute__((__malloc__));\r
extern bool __is_kernel_percpu_address(unsigned long addr, unsigned long *can_addr);\r
extern bool is_kernel_percpu_address(unsigned long addr);\r
\r
\r
extern void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((__no_sanitize__("cfi"))) setup_per_cpu_areas(void);\r
\r
\r
extern void *__alloc_percpu_gfp(size_t size, size_t align, gfp_t gfp) __attribute__((__alloc_size__(1))) __attribute__((__malloc__));\r
extern void *__alloc_percpu(size_t size, size_t align) __attribute__((__alloc_size__(1))) __attribute__((__malloc__));\r
extern void free_percpu(void *__pdata);\r
extern phys_addr_t per_cpu_ptr_to_phys(void *addr);\r
# 140 "./include/linux/percpu.h"\r
extern unsigned long pcpu_nr_pages(void);\r
# 13 "./include/linux/prandom.h" 2\r
\r
u32 prandom_u32(void);\r
void prandom_bytes(void *buf, size_t nbytes);\r
void prandom_seed(u32 seed);\r
void prandom_reseed_late(void);\r
\r
extern __attribute__((section(".data..percpu" ""))) __typeof__(unsigned long) net_rand_noise;\r
# 59 "./include/linux/prandom.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void prandom_u32_add_noise(unsigned long a, unsigned long b,\r
      unsigned long c, unsigned long d)\r
{\r
\r
\r
\r
\r
 a ^= ({ typeof(net_rand_noise) pscr_ret__; do { const void *__vpp_verify = (typeof((&(net_rand_noise)) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(net_rand_noise)) { case 1: pscr_ret__ = ({ *({ do { const void *__vpp_verify = (typeof((&(net_rand_noise)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __ptr = (unsigned long) ((typeof(*(&(net_rand_noise))) *)(&(net_rand_noise))); (typeof((typeof(*(&(net_rand_noise))) *)(&(net_rand_noise)))) (__ptr + (((__per_cpu_offset[(((struct thread_info *)get_current())->cpu)])))); }); }); }); break; case 2: pscr_ret__ = ({ *({ do { const void *__vpp_verify = (typeof((&(net_rand_noise)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __ptr = (unsigned long) ((typeof(*(&(net_rand_noise))) *)(&(net_rand_noise))); (typeof((typeof(*(&(net_rand_noise))) *)(&(net_rand_noise)))) (__ptr + (((__per_cpu_offset[(((struct thread_info *)get_current())->cpu)])))); }); }); }); break; case 4: pscr_ret__ = ({ *({ do { const void *__vpp_verify = (typeof((&(net_rand_noise)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __ptr = (unsigned long) ((typeof(*(&(net_rand_noise))) *)(&(net_rand_noise))); (typeof((typeof(*(&(net_rand_noise))) *)(&(net_rand_noise)))) (__ptr + (((__per_cpu_offset[(((struct thread_info *)get_current())->cpu)])))); }); }); }); break; case 8: pscr_ret__ = ({ *({ do { const void *__vpp_verify = (typeof((&(net_rand_noise)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __ptr = (unsigned long) ((typeof(*(&(net_rand_noise))) *)(&(net_rand_noise))); (typeof((typeof(*(&(net_rand_noise))) *)(&(net_rand_noise)))) (__ptr + (((__per_cpu_offset[(((struct thread_info *)get_current())->cpu)])))); }); }); }); break; default: __bad_size_call_parameter(); break; } pscr_ret__; });\r
 ( a += b, b = rol64(b, 13), c += d, d = rol64(d, 16), b ^= a, a = rol64(a, 32), d ^= c, a += d, d = rol64(d, 21), c += b, b = rol64(b, 17), d ^= a, b ^= c, c = rol64(c, 32) );\r
 do { do { const void *__vpp_verify = (typeof((&(net_rand_noise)) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(net_rand_noise)) { case 1: do { *({ do { const void *__vpp_verify = (typeof((&(net_rand_noise)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __ptr = (unsigned long) ((typeof(*(&(net_rand_noise))) *)(&(net_rand_noise))); (typeof((typeof(*(&(net_rand_noise))) *)(&(net_rand_noise)))) (__ptr + (((__per_cpu_offset[(((struct thread_info *)get_current())->cpu)])))); }); }) = d; } while (0);break; case 2: do { *({ do { const void *__vpp_verify = (typeof((&(net_rand_noise)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __ptr = (unsigned long) ((typeof(*(&(net_rand_noise))) *)(&(net_rand_noise))); (typeof((typeof(*(&(net_rand_noise))) *)(&(net_rand_noise)))) (__ptr + (((__per_cpu_offset[(((struct thread_info *)get_current())->cpu)])))); }); }) = d; } while (0);break; case 4: do { *({ do { const void *__vpp_verify = (typeof((&(net_rand_noise)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __ptr = (unsigned long) ((typeof(*(&(net_rand_noise))) *)(&(net_rand_noise))); (typeof((typeof(*(&(net_rand_noise))) *)(&(net_rand_noise)))) (__ptr + (((__per_cpu_offset[(((struct thread_info *)get_current())->cpu)])))); }); }) = d; } while (0);break; case 8: do { *({ do { const void *__vpp_verify = (typeof((&(net_rand_noise)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __ptr = (unsigned long) ((typeof(*(&(net_rand_noise))) *)(&(net_rand_noise))); (typeof((typeof(*(&(net_rand_noise))) *)(&(net_rand_noise)))) (__ptr + (((__per_cpu_offset[(((struct thread_info *)get_current())->cpu)])))); }); }) = d; } while (0);break; default: __bad_size_call_parameter();break; } } while (0);\r
}\r
\r
struct rnd_state {\r
 __u32 s1, s2, s3, s4;\r
};\r
\r
u32 prandom_u32_state(struct rnd_state *state);\r
void prandom_bytes_state(struct rnd_state *state, void *buf, size_t nbytes);\r
void prandom_seed_full_state(struct rnd_state *pcpu_state);\r
# 94 "./include/linux/prandom.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) u32 prandom_u32_max(u32 ep_ro)\r
{\r
 return (u32)(((u64) prandom_u32() * ep_ro) >> 32);\r
}\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) u32 __seed(u32 x, u32 m)\r
{\r
 return (x < m) ? x + m : x;\r
}\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void prandom_seed_state(struct rnd_state *state, u64 seed)\r
{\r
 u32 i = ((seed >> 32) ^ (seed << 10) ^ seed) & 0xffffffffUL;\r
\r
 state->s1 = __seed(i, 2U);\r
 state->s2 = __seed(i, 8U);\r
 state->s3 = __seed(i, 16U);\r
 state->s4 = __seed(i, 128U);\r
 prandom_u32_add_noise((unsigned long)(state), (unsigned long)(i), (unsigned long)(0), (unsigned long)(0));\r
}\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) u32 next_pseudo_random32(u32 seed)\r
{\r
 return seed * 1664525 + 1013904223;\r
}\r
# 121 "./include/linux/random.h" 2\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool __attribute__((__warn_unused_result__)) arch_get_random_long(unsigned long *v)\r
{\r
 return false;\r
}\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool __attribute__((__warn_unused_result__)) arch_get_random_int(unsigned int *v)\r
{\r
 return false;\r
}\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool __attribute__((__warn_unused_result__)) arch_get_random_seed_long(unsigned long *v)\r
{\r
 return false;\r
}\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool __attribute__((__warn_unused_result__)) arch_get_random_seed_int(unsigned int *v)\r
{\r
 return false;\r
}\r
\r
\r
\r
\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool __attribute__((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((__no_sanitize__("cfi"))) arch_get_random_seed_long_early(unsigned long *v)\r
{\r
 ({ int __ret_warn_on = !!(system_state != SYSTEM_BOOTING); if (__builtin_expect(!!(__ret_warn_on), 0)) do { __asm__ __volatile__ ( "1:\n\t" "ebreak\n" ".pushsection __bug_table,\"aw\"\n\t" "2:\n\t" ".word" " 1b - 2b" "\n\t" ".word" " %0 - 2b" "\n\t" ".half" " %1\n\t" ".half" " %2" "\n\t" ".org 2b + %3\n\t" ".popsection" : : "i" ("include/linux/random.h"), "i" (150), "i" ((1 << 0)|(((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); __builtin_expect(!!(__ret_warn_on), 0); });\r
 return arch_get_random_seed_long(v);\r
}\r
\r
\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) bool __attribute__((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((__no_sanitize__("cfi"))) arch_get_random_long_early(unsigned long *v)\r
{\r
 ({ int __ret_warn_on = !!(system_state != SYSTEM_BOOTING); if (__builtin_expect(!!(__ret_warn_on), 0)) do { __asm__ __volatile__ ( "1:\n\t" "ebreak\n" ".pushsection __bug_table,\"aw\"\n\t" "2:\n\t" ".word" " 1b - 2b" "\n\t" ".word" " %0 - 2b" "\n\t" ".half" " %1\n\t" ".half" " %2" "\n\t" ".org 2b + %3\n\t" ".popsection" : : "i" ("include/linux/random.h"), "i" (158), "i" ((1 << 0)|(((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); __builtin_expect(!!(__ret_warn_on), 0); });\r
 return arch_get_random_long(v);\r
}\r
\r
\r
\r
extern int random_prepare_cpu(unsigned int cpu);\r
extern int random_online_cpu(unsigned int cpu);\r
# 19 "./include/linux/net.h" 2\r
\r
# 1 "./include/linux/fcntl.h" 1\r
\r
\r
\r
\r
# 1 "./include/linux/stat.h" 1\r
\r
\r
\r
\r
\r
# 1 "./arch/riscv/include/generated/uapi/asm/stat.h" 1\r
# 1 "./include/uapi/asm-generic/stat.h" 1\r
# 24 "./include/uapi/asm-generic/stat.h"\r
struct stat {\r
 unsigned long st_dev;\r
 unsigned long st_ino;\r
 unsigned int st_mode;\r
 unsigned int st_nlink;\r
 unsigned int st_uid;\r
 unsigned int st_gid;\r
 unsigned long st_rdev;\r
 unsigned long __pad1;\r
 long st_size;\r
 int st_blksize;\r
 int __pad2;\r
 long st_blocks;\r
 long st_atime;\r
 unsigned long st_atime_nsec;\r
 long st_mtime;\r
 unsigned long st_mtime_nsec;\r
 long st_ctime;\r
 unsigned long st_ctime_nsec;\r
 unsigned int __unused4;\r
 unsigned int __unused5;\r
};\r
# 2 "./arch/riscv/include/generated/uapi/asm/stat.h" 2\r
# 7 "./include/linux/stat.h" 2\r
# 1 "./include/uapi/linux/stat.h" 1\r
# 56 "./include/uapi/linux/stat.h"\r
struct statx_timestamp {\r
 __s64 tv_sec;\r
 __u32 tv_nsec;\r
 __s32 __reserved;\r
};\r
# 99 "./include/uapi/linux/stat.h"\r
struct statx {\r
\r
 __u32 stx_mask;\r
 __u32 stx_blksize;\r
 __u64 stx_attributes;\r
\r
 __u32 stx_nlink;\r
 __u32 stx_uid;\r
 __u32 stx_gid;\r
 __u16 stx_mode;\r
 __u16 __spare0[1];\r
\r
 __u64 stx_ino;\r
 __u64 stx_size;\r
 __u64 stx_blocks;\r
 __u64 stx_attributes_mask;\r
\r
 struct statx_timestamp stx_atime;\r
 struct statx_timestamp stx_btime;\r
 struct statx_timestamp stx_ctime;\r
 struct statx_timestamp stx_mtime;\r
\r
 __u32 stx_rdev_major;\r
 __u32 stx_rdev_minor;\r
 __u32 stx_dev_major;\r
 __u32 stx_dev_minor;\r
\r
 __u64 stx_mnt_id;\r
 __u64 __spare2;\r
\r
 __u64 __spare3[12];\r
\r
};\r
# 8 "./include/linux/stat.h" 2\r
# 22 "./include/linux/stat.h"\r
struct kstat {\r
 u32 result_mask;\r
 umode_t mode;\r
 unsigned int nlink;\r
 uint32_t blksize;\r
 u64 attributes;\r
 u64 attributes_mask;\r
# 41 "./include/linux/stat.h"\r
 u64 ino;\r
 dev_t dev;\r
 dev_t rdev;\r
 kuid_t uid;\r
 kgid_t gid;\r
 loff_t size;\r
 struct timespec64 atime;\r
 struct timespec64 mtime;\r
 struct timespec64 ctime;\r
 struct timespec64 btime;\r
 u64 blocks;\r
 u64 mnt_id;\r
};\r
# 6 "./include/linux/fcntl.h" 2\r
# 1 "./include/uapi/linux/fcntl.h" 1\r
\r
\r
\r
\r
# 1 "./arch/riscv/include/generated/uapi/asm/fcntl.h" 1\r
# 1 "./include/uapi/asm-generic/fcntl.h" 1\r
# 156 "./include/uapi/asm-generic/fcntl.h"\r
struct f_owner_ex {\r
 int type;\r
 __kernel_pid_t pid;\r
};\r
# 200 "./include/uapi/asm-generic/fcntl.h"\r
struct flock {\r
 short l_type;\r
 short l_whence;\r
 __kernel_off_t l_start;\r
 __kernel_off_t l_len;\r
 __kernel_pid_t l_pid;\r
\r
};\r
\r
\r
\r
\r
\r
\r
\r
struct flock64 {\r
 short l_type;\r
 short l_whence;\r
 __kernel_loff_t l_start;\r
 __kernel_loff_t l_len;\r
 __kernel_pid_t l_pid;\r
\r
};\r
# 2 "./arch/riscv/include/generated/uapi/asm/fcntl.h" 2\r
# 6 "./include/uapi/linux/fcntl.h" 2\r
# 1 "./include/uapi/linux/openat2.h" 1\r
# 19 "./include/uapi/linux/openat2.h"\r
struct open_how {\r
 __u64 flags;\r
 __u64 mode;\r
 __u64 resolve;\r
};\r
# 7 "./include/uapi/linux/fcntl.h" 2\r
# 7 "./include/linux/fcntl.h" 2\r
# 21 "./include/linux/net.h" 2\r
\r
\r
# 1 "./include/linux/fs.h" 1\r
\r
\r
\r
\r
\r
# 1 "./include/linux/wait_bit.h" 1\r
# 10 "./include/linux/wait_bit.h"\r
struct wait_bit_key {\r
 void *flags;\r
 int bit_nr;\r
 unsigned long timeout;\r
};\r
\r
struct wait_bit_queue_entry {\r
 struct wait_bit_key key;\r
 struct wait_queue_entry wq_entry;\r
};\r
\r
\r
\r
\r
typedef int wait_bit_action_f(struct wait_bit_key *key, int mode);\r
\r
void __wake_up_bit(struct wait_queue_head *wq_head, void *word, int bit);\r
int __wait_on_bit(struct wait_queue_head *wq_head, struct wait_bit_queue_entry *wbq_entry, wait_bit_action_f *action, unsigned int mode);\r
int __wait_on_bit_lock(struct wait_queue_head *wq_head, struct wait_bit_queue_entry *wbq_entry, wait_bit_action_f *action, unsigned int mode);\r
void wake_up_bit(void *word, int bit);\r
int out_of_line_wait_on_bit(void *word, int, wait_bit_action_f *action, unsigned int mode);\r
int out_of_line_wait_on_bit_timeout(void *word, int, wait_bit_action_f *action, unsigned int mode, unsigned long timeout);\r
int out_of_line_wait_on_bit_lock(void *word, int, wait_bit_action_f *action, unsigned int mode);\r
struct wait_queue_head *bit_waitqueue(void *word, int bit);\r
extern void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) __attribute__((__no_sanitize__("cfi"))) wait_bit_init(void);\r
\r
int wake_bit_function(struct wait_queue_entry *wq_entry, unsigned mode, int sync, void *key);\r
# 49 "./include/linux/wait_bit.h"\r
extern int bit_wait(struct wait_bit_key *key, int mode);\r
extern int bit_wait_io(struct wait_bit_key *key, int mode);\r
extern int bit_wait_timeout(struct wait_bit_key *key, int mode);\r
extern int bit_wait_io_timeout(struct wait_bit_key *key, int mode);\r
# 70 "./include/linux/wait_bit.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int\r
wait_on_bit(unsigned long *word, int bit, unsigned mode)\r
{\r
 do { __might_sleep("include/linux/wait_bit.h", 73); __cond_resched(); } while (0);\r
 if (!arch_test_bit(bit, word))\r
  return 0;\r
 return out_of_line_wait_on_bit(word, bit,\r
           bit_wait,\r
           mode);\r
}\r
# 95 "./include/linux/wait_bit.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int\r
wait_on_bit_io(unsigned long *word, int bit, unsigned mode)\r
{\r
 do { __might_sleep("include/linux/wait_bit.h", 98); __cond_resched(); } while (0);\r
 if (!arch_test_bit(bit, word))\r
  return 0;\r
 return out_of_line_wait_on_bit(word, bit,\r
           bit_wait_io,\r
           mode);\r
}\r
# 121 "./include/linux/wait_bit.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int\r
wait_on_bit_timeout(unsigned long *word, int bit, unsigned mode,\r
      unsigned long timeout)\r
{\r
 do { __might_sleep("include/linux/wait_bit.h", 125); __cond_resched(); } while (0);\r
 if (!arch_test_bit(bit, word))\r
  return 0;\r
 return out_of_line_wait_on_bit_timeout(word, bit,\r
            bit_wait_timeout,\r
            mode, timeout);\r
}\r
# 149 "./include/linux/wait_bit.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int\r
wait_on_bit_action(unsigned long *word, int bit, wait_bit_action_f *action,\r
     unsigned mode)\r
{\r
 do { __might_sleep("include/linux/wait_bit.h", 153); __cond_resched(); } while (0);\r
 if (!arch_test_bit(bit, word))\r
  return 0;\r
 return out_of_line_wait_on_bit(word, bit, action, mode);\r
}\r
# 178 "./include/linux/wait_bit.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int\r
wait_on_bit_lock(unsigned long *word, int bit, unsigned mode)\r
{\r
 do { __might_sleep("include/linux/wait_bit.h", 181); __cond_resched(); } while (0);\r
 if (!test_and_set_bit(bit, word))\r
  return 0;\r
 return out_of_line_wait_on_bit_lock(word, bit, bit_wait, mode);\r
}\r
# 202 "./include/linux/wait_bit.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int\r
wait_on_bit_lock_io(unsigned long *word, int bit, unsigned mode)\r
{\r
 do { __might_sleep("include/linux/wait_bit.h", 205); __cond_resched(); } while (0);\r
 if (!test_and_set_bit(bit, word))\r
  return 0;\r
 return out_of_line_wait_on_bit_lock(word, bit, bit_wait_io, mode);\r
}\r
# 228 "./include/linux/wait_bit.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) int\r
wait_on_bit_lock_action(unsigned long *word, int bit, wait_bit_action_f *action,\r
   unsigned mode)\r
{\r
 do { __might_sleep("include/linux/wait_bit.h", 232); __cond_resched(); } while (0);\r
 if (!test_and_set_bit(bit, word))\r
  return 0;\r
 return out_of_line_wait_on_bit_lock(word, bit, action, mode);\r
}\r
\r
extern void init_wait_var_entry(struct wait_bit_queue_entry *wbq_entry, void *var, int flags);\r
extern void wake_up_var(void *var);\r
extern wait_queue_head_t *__var_waitqueue(void *p);\r
# 330 "./include/linux/wait_bit.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void clear_and_wake_up_bit(int bit, void *word)\r
{\r
 clear_bit_unlock(bit, word);\r
\r
 do { do { } while (0); __asm__ __volatile__ ("fence " "rw" "," "rw" : : : "memory"); } while (0);\r
 wake_up_bit(word, bit);\r
}\r
# 7 "./include/linux/fs.h" 2\r
# 1 "./include/linux/kdev_t.h" 1\r
\r
\r
\r
\r
# 1 "./include/uapi/linux/kdev_t.h" 1\r
# 6 "./include/linux/kdev_t.h" 2\r
# 24 "./include/linux/kdev_t.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) bool old_valid_dev(dev_t dev)\r
{\r
 return ((unsigned int) ((dev) >> 20)) < 256 && ((unsigned int) ((dev) & ((1U << 20) - 1))) < 256;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) u16 old_encode_dev(dev_t dev)\r
{\r
 return (((unsigned int) ((dev) >> 20)) << 8) | ((unsigned int) ((dev) & ((1U << 20) - 1)));\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) dev_t old_decode_dev(u16 val)\r
{\r
 return ((((val >> 8) & 255) << 20) | (val & 255));\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) u32 new_encode_dev(dev_t dev)\r
{\r
 unsigned major = ((unsigned int) ((dev) >> 20));\r
 unsigned minor = ((unsigned int) ((dev) & ((1U << 20) - 1)));\r
 return (minor & 0xff) | (major << 8) | ((minor & ~0xff) << 12);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) dev_t new_decode_dev(u32 dev)\r
{\r
 unsigned major = (dev & 0xfff00) >> 8;\r
 unsigned minor = (dev & 0xff) | ((dev >> 12) & 0xfff00);\r
 return (((major) << 20) | (minor));\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) u64 huge_encode_dev(dev_t dev)\r
{\r
 return new_encode_dev(dev);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) dev_t huge_decode_dev(u64 dev)\r
{\r
 return new_decode_dev(dev);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) int sysv_valid_dev(dev_t dev)\r
{\r
 return ((unsigned int) ((dev) >> 20)) < (1<<14) && ((unsigned int) ((dev) & ((1U << 20) - 1))) < (1<<18);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) u32 sysv_encode_dev(dev_t dev)\r
{\r
 return ((unsigned int) ((dev) & ((1U << 20) - 1))) | (((unsigned int) ((dev) >> 20)) << 18);\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) unsigned sysv_major(u32 dev)\r
{\r
 return (dev >> 18) & 0x3fff;\r
}\r
\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) __attribute__((__always_inline__)) unsigned sysv_minor(u32 dev)\r
{\r
 return dev & 0x3ffff;\r
}\r
# 8 "./include/linux/fs.h" 2\r
# 1 "./include/linux/dcache.h" 1\r
\r
\r
\r
\r
\r
\r
\r
# 1 "./include/linux/rculist.h" 1\r
# 22 "./include/linux/rculist.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void INIT_LIST_HEAD_RCU(struct list_head *list)\r
{\r
 do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_87(void) ; if (!((sizeof(list->next) == sizeof(char) || sizeof(list->next) == sizeof(short) || sizeof(list->next) == sizeof(int) || sizeof(list->next) == sizeof(long)) || sizeof(list->next) == sizeof(long long))) __compiletime_assert_87(); } while (0); do { *(volatile typeof(list->next) *)&(list->next) = (list); } while (0); } while (0);\r
 do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_88(void) ; if (!((sizeof(list->prev) == sizeof(char) || sizeof(list->prev) == sizeof(short) || sizeof(list->prev) == sizeof(int) || sizeof(list->prev) == sizeof(long)) || sizeof(list->prev) == sizeof(long long))) __compiletime_assert_88(); } while (0); do { *(volatile typeof(list->prev) *)&(list->prev) = (list); } while (0); } while (0);\r
}\r
# 76 "./include/linux/rculist.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __list_add_rcu(struct list_head *new,\r
  struct list_head *prev, struct list_head *next)\r
{\r
 if (!__list_add_valid(new, prev, next))\r
  return;\r
\r
 new->next = next;\r
 new->prev = prev;\r
 do { uintptr_t _r_a_p__v = (uintptr_t)(new); ; if (__builtin_constant_p(new) && (_r_a_p__v) == (uintptr_t)((void *)0)) do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_89(void) ; if (!((sizeof(((*((struct list_head **)(&(prev)->next))))) == sizeof(char) || sizeof(((*((struct list_head **)(&(prev)->next))))) == sizeof(short) || sizeof(((*((struct list_head **)(&(prev)->next))))) == sizeof(int) || sizeof(((*((struct list_head **)(&(prev)->next))))) == sizeof(long)) || sizeof(((*((struct list_head **)(&(prev)->next))))) == sizeof(long long))) __compiletime_assert_89(); } while (0); do { *(volatile typeof(((*((struct list_head **)(&(prev)->next))))) *)&(((*((struct list_head **)(&(prev)->next))))) = ((typeof((*((struct list_head **)(&(prev)->next)))))(_r_a_p__v)); } while (0); } while (0); else do { do { } while (0); do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_90(void) ; if (!((sizeof(*&(*((struct list_head **)(&(prev)->next)))) == sizeof(char) || sizeof(*&(*((struct list_head **)(&(prev)->next)))) == sizeof(short) || sizeof(*&(*((struct list_head **)(&(prev)->next)))) == sizeof(int) || sizeof(*&(*((struct list_head **)(&(prev)->next)))) == sizeof(long)))) __compiletime_assert_90(); } while (0); __asm__ __volatile__ ("fence " "rw" "," "w" : : : "memory"); do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_91(void) ; if (!((sizeof(*&(*((struct list_head **)(&(prev)->next)))) == sizeof(char) || sizeof(*&(*((struct list_head **)(&(prev)->next)))) == sizeof(short) || sizeof(*&(*((struct list_head **)(&(prev)->next)))) == sizeof(int) || sizeof(*&(*((struct list_head **)(&(prev)->next)))) == sizeof(long)) || sizeof(*&(*((struct list_head **)(&(prev)->next)))) == sizeof(long long))) __compiletime_assert_91(); } while (0); do { *(volatile typeof(*&(*((struct list_head **)(&(prev)->next)))) *)&(*&(*((struct list_head **)(&(prev)->next)))) = ((typeof(*((typeof((*((struct list_head **)(&(prev)->next)))))_r_a_p__v)) *)((typeof((*((struct list_head **)(&(prev)->next)))))_r_a_p__v)); } while (0); } while (0); } while (0); } while (0); } while (0);\r
 next->prev = new;\r
}\r
# 104 "./include/linux/rculist.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void list_add_rcu(struct list_head *new, struct list_head *head)\r
{\r
 __list_add_rcu(new, head, head->next);\r
}\r
# 125 "./include/linux/rculist.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void list_add_tail_rcu(struct list_head *new,\r
     struct list_head *head)\r
{\r
 __list_add_rcu(new, head->prev, head);\r
}\r
# 155 "./include/linux/rculist.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void list_del_rcu(struct list_head *entry)\r
{\r
 __list_del_entry(entry);\r
 entry->prev = ((void *) 0x122 + 0);\r
}\r
# 181 "./include/linux/rculist.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void hlist_del_init_rcu(struct hlist_node *n)\r
{\r
 if (!hlist_unhashed(n)) {\r
  __hlist_del(n);\r
  do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_92(void) ; if (!((sizeof(n->pprev) == sizeof(char) || sizeof(n->pprev) == sizeof(short) || sizeof(n->pprev) == sizeof(int) || sizeof(n->pprev) == sizeof(long)) || sizeof(n->pprev) == sizeof(long long))) __compiletime_assert_92(); } while (0); do { *(volatile typeof(n->pprev) *)&(n->pprev) = (((void *)0)); } while (0); } while (0);\r
 }\r
}\r
# 197 "./include/linux/rculist.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void list_replace_rcu(struct list_head *old,\r
    struct list_head *new)\r
{\r
 new->next = old->next;\r
 new->prev = old->prev;\r
 do { uintptr_t _r_a_p__v = (uintptr_t)(new); ; if (__builtin_constant_p(new) && (_r_a_p__v) == (uintptr_t)((void *)0)) do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_93(void) ; if (!((sizeof(((*((struct list_head **)(&(new->prev)->next))))) == sizeof(char) || sizeof(((*((struct list_head **)(&(new->prev)->next))))) == sizeof(short) || sizeof(((*((struct list_head **)(&(new->prev)->next))))) == sizeof(int) || sizeof(((*((struct list_head **)(&(new->prev)->next))))) == sizeof(long)) || sizeof(((*((struct list_head **)(&(new->prev)->next))))) == sizeof(long long))) __compiletime_assert_93(); } while (0); do { *(volatile typeof(((*((struct list_head **)(&(new->prev)->next))))) *)&(((*((struct list_head **)(&(new->prev)->next))))) = ((typeof((*((struct list_head **)(&(new->prev)->next)))))(_r_a_p__v)); } while (0); } while (0); else do { do { } while (0); do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_94(void) ; if (!((sizeof(*&(*((struct list_head **)(&(new->prev)->next)))) == sizeof(char) || sizeof(*&(*((struct list_head **)(&(new->prev)->next)))) == sizeof(short) || sizeof(*&(*((struct list_head **)(&(new->prev)->next)))) == sizeof(int) || sizeof(*&(*((struct list_head **)(&(new->prev)->next)))) == sizeof(long)))) __compiletime_assert_94(); } while (0); __asm__ __volatile__ ("fence " "rw" "," "w" : : : "memory"); do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_95(void) ; if (!((sizeof(*&(*((struct list_head **)(&(new->prev)->next)))) == sizeof(char) || sizeof(*&(*((struct list_head **)(&(new->prev)->next)))) == sizeof(short) || sizeof(*&(*((struct list_head **)(&(new->prev)->next)))) == sizeof(int) || sizeof(*&(*((struct list_head **)(&(new->prev)->next)))) == sizeof(long)) || sizeof(*&(*((struct list_head **)(&(new->prev)->next)))) == sizeof(long long))) __compiletime_assert_95(); } while (0); do { *(volatile typeof(*&(*((struct list_head **)(&(new->prev)->next)))) *)&(*&(*((struct list_head **)(&(new->prev)->next)))) = ((typeof(*((typeof((*((struct list_head **)(&(new->prev)->next)))))_r_a_p__v)) *)((typeof((*((struct list_head **)(&(new->prev)->next)))))_r_a_p__v)); } while (0); } while (0); } while (0); } while (0); } while (0);\r
 new->next->prev = new;\r
 old->prev = ((void *) 0x122 + 0);\r
}\r
# 226 "./include/linux/rculist.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void __list_splice_init_rcu(struct list_head *list,\r
       struct list_head *prev,\r
       struct list_head *next,\r
       void (*sync)(void))\r
{\r
 struct list_head *first = list->next;\r
 struct list_head *last = list->prev;\r
\r
\r
\r
\r
\r
\r
\r
 INIT_LIST_HEAD_RCU(list);\r
# 249 "./include/linux/rculist.h"\r
 sync();\r
 __kcsan_check_access(&(*first), sizeof(*first), (1 << 0) | (1 << 3));\r
 __kcsan_check_access(&(*last), sizeof(*last), (1 << 0) | (1 << 3));\r
# 261 "./include/linux/rculist.h"\r
 last->next = next;\r
 do { uintptr_t _r_a_p__v = (uintptr_t)(first); ; if (__builtin_constant_p(first) && (_r_a_p__v) == (uintptr_t)((void *)0)) do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_96(void) ; if (!((sizeof(((*((struct list_head **)(&(prev)->next))))) == sizeof(char) || sizeof(((*((struct list_head **)(&(prev)->next))))) == sizeof(short) || sizeof(((*((struct list_head **)(&(prev)->next))))) == sizeof(int) || sizeof(((*((struct list_head **)(&(prev)->next))))) == sizeof(long)) || sizeof(((*((struct list_head **)(&(prev)->next))))) == sizeof(long long))) __compiletime_assert_96(); } while (0); do { *(volatile typeof(((*((struct list_head **)(&(prev)->next))))) *)&(((*((struct list_head **)(&(prev)->next))))) = ((typeof((*((struct list_head **)(&(prev)->next)))))(_r_a_p__v)); } while (0); } while (0); else do { do { } while (0); do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_97(void) ; if (!((sizeof(*&(*((struct list_head **)(&(prev)->next)))) == sizeof(char) || sizeof(*&(*((struct list_head **)(&(prev)->next)))) == sizeof(short) || sizeof(*&(*((struct list_head **)(&(prev)->next)))) == sizeof(int) || sizeof(*&(*((struct list_head **)(&(prev)->next)))) == sizeof(long)))) __compiletime_assert_97(); } while (0); __asm__ __volatile__ ("fence " "rw" "," "w" : : : "memory"); do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_98(void) ; if (!((sizeof(*&(*((struct list_head **)(&(prev)->next)))) == sizeof(char) || sizeof(*&(*((struct list_head **)(&(prev)->next)))) == sizeof(short) || sizeof(*&(*((struct list_head **)(&(prev)->next)))) == sizeof(int) || sizeof(*&(*((struct list_head **)(&(prev)->next)))) == sizeof(long)) || sizeof(*&(*((struct list_head **)(&(prev)->next)))) == sizeof(long long))) __compiletime_assert_98(); } while (0); do { *(volatile typeof(*&(*((struct list_head **)(&(prev)->next)))) *)&(*&(*((struct list_head **)(&(prev)->next)))) = ((typeof(*((typeof((*((struct list_head **)(&(prev)->next)))))_r_a_p__v)) *)((typeof((*((struct list_head **)(&(prev)->next)))))_r_a_p__v)); } while (0); } while (0); } while (0); } while (0); } while (0);\r
 first->prev = prev;\r
 next->prev = last;\r
}\r
# 274 "./include/linux/rculist.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void list_splice_init_rcu(struct list_head *list,\r
     struct list_head *head,\r
     void (*sync)(void))\r
{\r
 if (!list_empty(list))\r
  __list_splice_init_rcu(list, head, head->next, sync);\r
}\r
# 289 "./include/linux/rculist.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void list_splice_tail_init_rcu(struct list_head *list,\r
          struct list_head *head,\r
          void (*sync)(void))\r
{\r
 if (!list_empty(list))\r
  __list_splice_init_rcu(list, head->prev, head, sync);\r
}\r
# 511 "./include/linux/rculist.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void hlist_del_rcu(struct hlist_node *n)\r
{\r
 __hlist_del(n);\r
 do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_99(void) ; if (!((sizeof(n->pprev) == sizeof(char) || sizeof(n->pprev) == sizeof(short) || sizeof(n->pprev) == sizeof(int) || sizeof(n->pprev) == sizeof(long)) || sizeof(n->pprev) == sizeof(long long))) __compiletime_assert_99(); } while (0); do { *(volatile typeof(n->pprev) *)&(n->pprev) = (((void *) 0x122 + 0)); } while (0); } while (0);\r
}\r
# 524 "./include/linux/rculist.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void hlist_replace_rcu(struct hlist_node *old,\r
     struct hlist_node *new)\r
{\r
 struct hlist_node *next = old->next;\r
\r
 new->next = next;\r
 do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_100(void) ; if (!((sizeof(new->pprev) == sizeof(char) || sizeof(new->pprev) == sizeof(short) || sizeof(new->pprev) == sizeof(int) || sizeof(new->pprev) == sizeof(long)) || sizeof(new->pprev) == sizeof(long long))) __compiletime_assert_100(); } while (0); do { *(volatile typeof(new->pprev) *)&(new->pprev) = (old->pprev); } while (0); } while (0);\r
 do { uintptr_t _r_a_p__v = (uintptr_t)(new); ; if (__builtin_constant_p(new) && (_r_a_p__v) == (uintptr_t)((void *)0)) do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_101(void) ; if (!((sizeof((*(struct hlist_node **)new->pprev)) == sizeof(char) || sizeof((*(struct hlist_node **)new->pprev)) == sizeof(short) || sizeof((*(struct hlist_node **)new->pprev)) == sizeof(int) || sizeof((*(struct hlist_node **)new->pprev)) == sizeof(long)) || sizeof((*(struct hlist_node **)new->pprev)) == sizeof(long long))) __compiletime_assert_101(); } while (0); do { *(volatile typeof((*(struct hlist_node **)new->pprev)) *)&((*(struct hlist_node **)new->pprev)) = ((typeof(*(struct hlist_node **)new->pprev))(_r_a_p__v)); } while (0); } while (0); else do { do { } while (0); do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_102(void) ; if (!((sizeof(*&*(struct hlist_node **)new->pprev) == sizeof(char) || sizeof(*&*(struct hlist_node **)new->pprev) == sizeof(short) || sizeof(*&*(struct hlist_node **)new->pprev) == sizeof(int) || sizeof(*&*(struct hlist_node **)new->pprev) == sizeof(long)))) __compiletime_assert_102(); } while (0); __asm__ __volatile__ ("fence " "rw" "," "w" : : : "memory"); do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_103(void) ; if (!((sizeof(*&*(struct hlist_node **)new->pprev) == sizeof(char) || sizeof(*&*(struct hlist_node **)new->pprev) == sizeof(short) || sizeof(*&*(struct hlist_node **)new->pprev) == sizeof(int) || sizeof(*&*(struct hlist_node **)new->pprev) == sizeof(long)) || sizeof(*&*(struct hlist_node **)new->pprev) == sizeof(long long))) __compiletime_assert_103(); } while (0); do { *(volatile typeof(*&*(struct hlist_node **)new->pprev) *)&(*&*(struct hlist_node **)new->pprev) = ((typeof(*((typeof(*(struct hlist_node **)new->pprev))_r_a_p__v)) *)((typeof(*(struct hlist_node **)new->pprev))_r_a_p__v)); } while (0); } while (0); } while (0); } while (0); } while (0);\r
 if (next)\r
  do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_104(void) ; if (!((sizeof(new->next->pprev) == sizeof(char) || sizeof(new->next->pprev) == sizeof(short) || sizeof(new->next->pprev) == sizeof(int) || sizeof(new->next->pprev) == sizeof(long)) || sizeof(new->next->pprev) == sizeof(long long))) __compiletime_assert_104(); } while (0); do { *(volatile typeof(new->next->pprev) *)&(new->next->pprev) = (&new->next); } while (0); } while (0);\r
 do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_105(void) ; if (!((sizeof(old->pprev) == sizeof(char) || sizeof(old->pprev) == sizeof(short) || sizeof(old->pprev) == sizeof(int) || sizeof(old->pprev) == sizeof(long)) || sizeof(old->pprev) == sizeof(long long))) __compiletime_assert_105(); } while (0); do { *(volatile typeof(old->pprev) *)&(old->pprev) = (((void *) 0x122 + 0)); } while (0); } while (0);\r
}\r
# 547 "./include/linux/rculist.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void hlists_swap_heads_rcu(struct hlist_head *left, struct hlist_head *right)\r
{\r
 struct hlist_node *node1 = left->first;\r
 struct hlist_node *node2 = right->first;\r
\r
 do { uintptr_t _r_a_p__v = (uintptr_t)(node2); ; if (__builtin_constant_p(node2) && (_r_a_p__v) == (uintptr_t)((void *)0)) do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_106(void) ; if (!((sizeof((left->first)) == sizeof(char) || sizeof((left->first)) == sizeof(short) || sizeof((left->first)) == sizeof(int) || sizeof((left->first)) == sizeof(long)) || sizeof((left->first)) == sizeof(long long))) __compiletime_assert_106(); } while (0); do { *(volatile typeof((left->first)) *)&((left->first)) = ((typeof(left->first))(_r_a_p__v)); } while (0); } while (0); else do { do { } while (0); do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_107(void) ; if (!((sizeof(*&left->first) == sizeof(char) || sizeof(*&left->first) == sizeof(short) || sizeof(*&left->first) == sizeof(int) || sizeof(*&left->first) == sizeof(long)))) __compiletime_assert_107(); } while (0); __asm__ __volatile__ ("fence " "rw" "," "w" : : : "memory"); do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_108(void) ; if (!((sizeof(*&left->first) == sizeof(char) || sizeof(*&left->first) == sizeof(short) || sizeof(*&left->first) == sizeof(int) || sizeof(*&left->first) == sizeof(long)) || sizeof(*&left->first) == sizeof(long long))) __compiletime_assert_108(); } while (0); do { *(volatile typeof(*&left->first) *)&(*&left->first) = ((typeof(*((typeof(left->first))_r_a_p__v)) *)((typeof(left->first))_r_a_p__v)); } while (0); } while (0); } while (0); } while (0); } while (0);\r
 do { uintptr_t _r_a_p__v = (uintptr_t)(node1); ; if (__builtin_constant_p(node1) && (_r_a_p__v) == (uintptr_t)((void *)0)) do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_109(void) ; if (!((sizeof((right->first)) == sizeof(char) || sizeof((right->first)) == sizeof(short) || sizeof((right->first)) == sizeof(int) || sizeof((right->first)) == sizeof(long)) || sizeof((right->first)) == sizeof(long long))) __compiletime_assert_109(); } while (0); do { *(volatile typeof((right->first)) *)&((right->first)) = ((typeof(right->first))(_r_a_p__v)); } while (0); } while (0); else do { do { } while (0); do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_110(void) ; if (!((sizeof(*&right->first) == sizeof(char) || sizeof(*&right->first) == sizeof(short) || sizeof(*&right->first) == sizeof(int) || sizeof(*&right->first) == sizeof(long)))) __compiletime_assert_110(); } while (0); __asm__ __volatile__ ("fence " "rw" "," "w" : : : "memory"); do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_111(void) ; if (!((sizeof(*&right->first) == sizeof(char) || sizeof(*&right->first) == sizeof(short) || sizeof(*&right->first) == sizeof(int) || sizeof(*&right->first) == sizeof(long)) || sizeof(*&right->first) == sizeof(long long))) __compiletime_assert_111(); } while (0); do { *(volatile typeof(*&right->first) *)&(*&right->first) = ((typeof(*((typeof(right->first))_r_a_p__v)) *)((typeof(right->first))_r_a_p__v)); } while (0); } while (0); } while (0); } while (0); } while (0);\r
 do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_112(void) ; if (!((sizeof(node2->pprev) == sizeof(char) || sizeof(node2->pprev) == sizeof(short) || sizeof(node2->pprev) == sizeof(int) || sizeof(node2->pprev) == sizeof(long)) || sizeof(node2->pprev) == sizeof(long long))) __compiletime_assert_112(); } while (0); do { *(volatile typeof(node2->pprev) *)&(node2->pprev) = (&left->first); } while (0); } while (0);\r
 do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_113(void) ; if (!((sizeof(node1->pprev) == sizeof(char) || sizeof(node1->pprev) == sizeof(short) || sizeof(node1->pprev) == sizeof(int) || sizeof(node1->pprev) == sizeof(long)) || sizeof(node1->pprev) == sizeof(long long))) __compiletime_assert_113(); } while (0); do { *(volatile typeof(node1->pprev) *)&(node1->pprev) = (&right->first); } while (0); } while (0);\r
}\r
# 584 "./include/linux/rculist.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void hlist_add_head_rcu(struct hlist_node *n,\r
     struct hlist_head *h)\r
{\r
 struct hlist_node *first = h->first;\r
\r
 n->next = first;\r
 do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_114(void) ; if (!((sizeof(n->pprev) == sizeof(char) || sizeof(n->pprev) == sizeof(short) || sizeof(n->pprev) == sizeof(int) || sizeof(n->pprev) == sizeof(long)) || sizeof(n->pprev) == sizeof(long long))) __compiletime_assert_114(); } while (0); do { *(volatile typeof(n->pprev) *)&(n->pprev) = (&h->first); } while (0); } while (0);\r
 do { uintptr_t _r_a_p__v = (uintptr_t)(n); ; if (__builtin_constant_p(n) && (_r_a_p__v) == (uintptr_t)((void *)0)) do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_115(void) ; if (!((sizeof(((*((struct hlist_node **)(&(h)->first))))) == sizeof(char) || sizeof(((*((struct hlist_node **)(&(h)->first))))) == sizeof(short) || sizeof(((*((struct hlist_node **)(&(h)->first))))) == sizeof(int) || sizeof(((*((struct hlist_node **)(&(h)->first))))) == sizeof(long)) || sizeof(((*((struct hlist_node **)(&(h)->first))))) == sizeof(long long))) __compiletime_assert_115(); } while (0); do { *(volatile typeof(((*((struct hlist_node **)(&(h)->first))))) *)&(((*((struct hlist_node **)(&(h)->first))))) = ((typeof((*((struct hlist_node **)(&(h)->first)))))(_r_a_p__v)); } while (0); } while (0); else do { do { } while (0); do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_116(void) ; if (!((sizeof(*&(*((struct hlist_node **)(&(h)->first)))) == sizeof(char) || sizeof(*&(*((struct hlist_node **)(&(h)->first)))) == sizeof(short) || sizeof(*&(*((struct hlist_node **)(&(h)->first)))) == sizeof(int) || sizeof(*&(*((struct hlist_node **)(&(h)->first)))) == sizeof(long)))) __compiletime_assert_116(); } while (0); __asm__ __volatile__ ("fence " "rw" "," "w" : : : "memory"); do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_117(void) ; if (!((sizeof(*&(*((struct hlist_node **)(&(h)->first)))) == sizeof(char) || sizeof(*&(*((struct hlist_node **)(&(h)->first)))) == sizeof(short) || sizeof(*&(*((struct hlist_node **)(&(h)->first)))) == sizeof(int) || sizeof(*&(*((struct hlist_node **)(&(h)->first)))) == sizeof(long)) || sizeof(*&(*((struct hlist_node **)(&(h)->first)))) == sizeof(long long))) __compiletime_assert_117(); } while (0); do { *(volatile typeof(*&(*((struct hlist_node **)(&(h)->first)))) *)&(*&(*((struct hlist_node **)(&(h)->first)))) = ((typeof(*((typeof((*((struct hlist_node **)(&(h)->first)))))_r_a_p__v)) *)((typeof((*((struct hlist_node **)(&(h)->first)))))_r_a_p__v)); } while (0); } while (0); } while (0); } while (0); } while (0);\r
 if (first)\r
  do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_118(void) ; if (!((sizeof(first->pprev) == sizeof(char) || sizeof(first->pprev) == sizeof(short) || sizeof(first->pprev) == sizeof(int) || sizeof(first->pprev) == sizeof(long)) || sizeof(first->pprev) == sizeof(long long))) __compiletime_assert_118(); } while (0); do { *(volatile typeof(first->pprev) *)&(first->pprev) = (&n->next); } while (0); } while (0);\r
}\r
# 615 "./include/linux/rculist.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void hlist_add_tail_rcu(struct hlist_node *n,\r
          struct hlist_head *h)\r
{\r
 struct hlist_node *i, *last = ((void *)0);\r
\r
\r
 for (i = h->first; i; i = i->next)\r
  last = i;\r
\r
 if (last) {\r
  n->next = last->next;\r
  do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_119(void) ; if (!((sizeof(n->pprev) == sizeof(char) || sizeof(n->pprev) == sizeof(short) || sizeof(n->pprev) == sizeof(int) || sizeof(n->pprev) == sizeof(long)) || sizeof(n->pprev) == sizeof(long long))) __compiletime_assert_119(); } while (0); do { *(volatile typeof(n->pprev) *)&(n->pprev) = (&last->next); } while (0); } while (0);\r
  do { uintptr_t _r_a_p__v = (uintptr_t)(n); ; if (__builtin_constant_p(n) && (_r_a_p__v) == (uintptr_t)((void *)0)) do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_120(void) ; if (!((sizeof(((*((struct hlist_node **)(&(last)->next))))) == sizeof(char) || sizeof(((*((struct hlist_node **)(&(last)->next))))) == sizeof(short) || sizeof(((*((struct hlist_node **)(&(last)->next))))) == sizeof(int) || sizeof(((*((struct hlist_node **)(&(last)->next))))) == sizeof(long)) || sizeof(((*((struct hlist_node **)(&(last)->next))))) == sizeof(long long))) __compiletime_assert_120(); } while (0); do { *(volatile typeof(((*((struct hlist_node **)(&(last)->next))))) *)&(((*((struct hlist_node **)(&(last)->next))))) = ((typeof((*((struct hlist_node **)(&(last)->next)))))(_r_a_p__v)); } while (0); } while (0); else do { do { } while (0); do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_121(void) ; if (!((sizeof(*&(*((struct hlist_node **)(&(last)->next)))) == sizeof(char) || sizeof(*&(*((struct hlist_node **)(&(last)->next)))) == sizeof(short) || sizeof(*&(*((struct hlist_node **)(&(last)->next)))) == sizeof(int) || sizeof(*&(*((struct hlist_node **)(&(last)->next)))) == sizeof(long)))) __compiletime_assert_121(); } while (0); __asm__ __volatile__ ("fence " "rw" "," "w" : : : "memory"); do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_122(void) ; if (!((sizeof(*&(*((struct hlist_node **)(&(last)->next)))) == sizeof(char) || sizeof(*&(*((struct hlist_node **)(&(last)->next)))) == sizeof(short) || sizeof(*&(*((struct hlist_node **)(&(last)->next)))) == sizeof(int) || sizeof(*&(*((struct hlist_node **)(&(last)->next)))) == sizeof(long)) || sizeof(*&(*((struct hlist_node **)(&(last)->next)))) == sizeof(long long))) __compiletime_assert_122(); } while (0); do { *(volatile typeof(*&(*((struct hlist_node **)(&(last)->next)))) *)&(*&(*((struct hlist_node **)(&(last)->next)))) = ((typeof(*((typeof((*((struct hlist_node **)(&(last)->next)))))_r_a_p__v)) *)((typeof((*((struct hlist_node **)(&(last)->next)))))_r_a_p__v)); } while (0); } while (0); } while (0); } while (0); } while (0);\r
 } else {\r
  hlist_add_head_rcu(n, h);\r
 }\r
}\r
# 651 "./include/linux/rculist.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void hlist_add_before_rcu(struct hlist_node *n,\r
     struct hlist_node *next)\r
{\r
 do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_123(void) ; if (!((sizeof(n->pprev) == sizeof(char) || sizeof(n->pprev) == sizeof(short) || sizeof(n->pprev) == sizeof(int) || sizeof(n->pprev) == sizeof(long)) || sizeof(n->pprev) == sizeof(long long))) __compiletime_assert_123(); } while (0); do { *(volatile typeof(n->pprev) *)&(n->pprev) = (next->pprev); } while (0); } while (0);\r
 n->next = next;\r
 do { uintptr_t _r_a_p__v = (uintptr_t)(n); ; if (__builtin_constant_p(n) && (_r_a_p__v) == (uintptr_t)((void *)0)) do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_124(void) ; if (!((sizeof(((*((struct hlist_node **)((n)->pprev))))) == sizeof(char) || sizeof(((*((struct hlist_node **)((n)->pprev))))) == sizeof(short) || sizeof(((*((struct hlist_node **)((n)->pprev))))) == sizeof(int) || sizeof(((*((struct hlist_node **)((n)->pprev))))) == sizeof(long)) || sizeof(((*((struct hlist_node **)((n)->pprev))))) == sizeof(long long))) __compiletime_assert_124(); } while (0); do { *(volatile typeof(((*((struct hlist_node **)((n)->pprev))))) *)&(((*((struct hlist_node **)((n)->pprev))))) = ((typeof((*((struct hlist_node **)((n)->pprev)))))(_r_a_p__v)); } while (0); } while (0); else do { do { } while (0); do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_125(void) ; if (!((sizeof(*&(*((struct hlist_node **)((n)->pprev)))) == sizeof(char) || sizeof(*&(*((struct hlist_node **)((n)->pprev)))) == sizeof(short) || sizeof(*&(*((struct hlist_node **)((n)->pprev)))) == sizeof(int) || sizeof(*&(*((struct hlist_node **)((n)->pprev)))) == sizeof(long)))) __compiletime_assert_125(); } while (0); __asm__ __volatile__ ("fence " "rw" "," "w" : : : "memory"); do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_126(void) ; if (!((sizeof(*&(*((struct hlist_node **)((n)->pprev)))) == sizeof(char) || sizeof(*&(*((struct hlist_node **)((n)->pprev)))) == sizeof(short) || sizeof(*&(*((struct hlist_node **)((n)->pprev)))) == sizeof(int) || sizeof(*&(*((struct hlist_node **)((n)->pprev)))) == sizeof(long)) || sizeof(*&(*((struct hlist_node **)((n)->pprev)))) == sizeof(long long))) __compiletime_assert_126(); } while (0); do { *(volatile typeof(*&(*((struct hlist_node **)((n)->pprev)))) *)&(*&(*((struct hlist_node **)((n)->pprev)))) = ((typeof(*((typeof((*((struct hlist_node **)((n)->pprev)))))_r_a_p__v)) *)((typeof((*((struct hlist_node **)((n)->pprev)))))_r_a_p__v)); } while (0); } while (0); } while (0); } while (0); } while (0);\r
 do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_127(void) ; if (!((sizeof(next->pprev) == sizeof(char) || sizeof(next->pprev) == sizeof(short) || sizeof(next->pprev) == sizeof(int) || sizeof(next->pprev) == sizeof(long)) || sizeof(next->pprev) == sizeof(long long))) __compiletime_assert_127(); } while (0); do { *(volatile typeof(next->pprev) *)&(next->pprev) = (&n->next); } while (0); } while (0);\r
}\r
# 678 "./include/linux/rculist.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void hlist_add_behind_rcu(struct hlist_node *n,\r
     struct hlist_node *prev)\r
{\r
 n->next = prev->next;\r
 do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_128(void) ; if (!((sizeof(n->pprev) == sizeof(char) || sizeof(n->pprev) == sizeof(short) || sizeof(n->pprev) == sizeof(int) || sizeof(n->pprev) == sizeof(long)) || sizeof(n->pprev) == sizeof(long long))) __compiletime_assert_128(); } while (0); do { *(volatile typeof(n->pprev) *)&(n->pprev) = (&prev->next); } while (0); } while (0);\r
 do { uintptr_t _r_a_p__v = (uintptr_t)(n); ; if (__builtin_constant_p(n) && (_r_a_p__v) == (uintptr_t)((void *)0)) do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_129(void) ; if (!((sizeof(((*((struct hlist_node **)(&(prev)->next))))) == sizeof(char) || sizeof(((*((struct hlist_node **)(&(prev)->next))))) == sizeof(short) || sizeof(((*((struct hlist_node **)(&(prev)->next))))) == sizeof(int) || sizeof(((*((struct hlist_node **)(&(prev)->next))))) == sizeof(long)) || sizeof(((*((struct hlist_node **)(&(prev)->next))))) == sizeof(long long))) __compiletime_assert_129(); } while (0); do { *(volatile typeof(((*((struct hlist_node **)(&(prev)->next))))) *)&(((*((struct hlist_node **)(&(prev)->next))))) = ((typeof((*((struct hlist_node **)(&(prev)->next)))))(_r_a_p__v)); } while (0); } while (0); else do { do { } while (0); do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_130(void) ; if (!((sizeof(*&(*((struct hlist_node **)(&(prev)->next)))) == sizeof(char) || sizeof(*&(*((struct hlist_node **)(&(prev)->next)))) == sizeof(short) || sizeof(*&(*((struct hlist_node **)(&(prev)->next)))) == sizeof(int) || sizeof(*&(*((struct hlist_node **)(&(prev)->next)))) == sizeof(long)))) __compiletime_assert_130(); } while (0); __asm__ __volatile__ ("fence " "rw" "," "w" : : : "memory"); do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_131(void) ; if (!((sizeof(*&(*((struct hlist_node **)(&(prev)->next)))) == sizeof(char) || sizeof(*&(*((struct hlist_node **)(&(prev)->next)))) == sizeof(short) || sizeof(*&(*((struct hlist_node **)(&(prev)->next)))) == sizeof(int) || sizeof(*&(*((struct hlist_node **)(&(prev)->next)))) == sizeof(long)) || sizeof(*&(*((struct hlist_node **)(&(prev)->next)))) == sizeof(long long))) __compiletime_assert_131(); } while (0); do { *(volatile typeof(*&(*((struct hlist_node **)(&(prev)->next)))) *)&(*&(*((struct hlist_node **)(&(prev)->next)))) = ((typeof(*((typeof((*((struct hlist_node **)(&(prev)->next)))))_r_a_p__v)) *)((typeof((*((struct hlist_node **)(&(prev)->next)))))_r_a_p__v)); } while (0); } while (0); } while (0); } while (0); } while (0);\r
 if (n->next)\r
  do { do { __attribute__((__noreturn__)) extern void __compiletime_assert_132(void) ; if (!((sizeof(n->next->pprev) == sizeof(char) || sizeof(n->next->pprev) == sizeof(short) || sizeof(n->next->pprev) == sizeof(int) || sizeof(n->next->pprev) == sizeof(long)) || sizeof(n->next->pprev) == sizeof(long long))) __compiletime_assert_132(); } while (0); do { *(volatile typeof(n->next->pprev) *)&(n->next->pprev) = (&n->next); } while (0); } while (0);\r
}\r
# 9 "./include/linux/dcache.h" 2\r
# 1 "./include/linux/rculist_bl.h" 1\r
\r
\r
\r
\r
\r
\r
\r
# 1 "./include/linux/list_bl.h" 1\r
\r
\r
\r
\r
\r
# 1 "./include/linux/bit_spinlock.h" 1\r
# 16 "./include/linux/bit_spinlock.h"\r
static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((patchable_function_entry(0, 0))) void bit_spin_lock(int bitnum, unsigned long *addr)\r
{\r
\r
\r
\r
\r
\r
\r
\r
 do { __preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);\r
\r
 while (__builtin_expect(!!(test_