Skip to content

Instantly share code, notes, and snippets.

@hellow554

hellow554/Kernel Oops

Last active August 2, 2018 13:47
Show Gist options
  • Save hellow554/6b11c6c0827d5db80a7e66f71f5636ff to your computer and use it in GitHub Desktop.
Save hellow554/6b11c6c0827d5db80a7e66f71f5636ff to your computer and use it in GitHub Desktop.
Download ZIP
Kernel Panic
Raw
Kernel Oops
[ 1125.090000] Unable to handle kernel paging request at virtual address c14fe63a
[ 1125.100000] pgd = c14d8000
[ 1125.100000] [c14fe63a] *pgd=8140041e(bad)
[ 1125.100000] Internal error: Oops: 1 [#1] PREEMPT ARM
[ 1125.100000] Modules linked in:
[ 1125.100000] CPU: 0 Not tainted (3.4.113 #1)
[ 1125.100000] PC is at udp_recvmsg+0x284/0x33c
[ 1125.100000] LR is at 0x0
[ 1125.100000] pc : [<c0228adc>] lr : [<00000000>] psr: a0000013
[ 1125.100000] sp : c1e67d10 ip : 00000000 fp : 0000004a
[ 1125.100000] r10: c1e67d34 r9 : 0000004a r8 : 00000000
[ 1125.100000] r7 : 000005c0 r6 : c1e10220 r5 : c1e67f7c r4 : c14f4640
[ 1125.100000] r3 : c14fe62e r2 : c1e67ec0 r1 : 00000008 r0 : c1e67ec8
[ 1125.100000] Flags: NzCv IRQs on FIQs on Mode SVC_32 ISA ARM Segment user
[ 1125.100000] Control: 0005317f Table: 814d8000 DAC: 00000015
[ 1125.100000] Process trdp.release (pid: 132, stack limit = 0xc1e66270)
[ 1125.100000] Stack: (0xc1e67d10 to 0xc1e68000)
[ 1125.100000] 7d00: c1e67d34 00004348 00000001 0000004a
[ 1125.100000] 7d20: 00000000 c1e67ec0 c1e10220 00000000 00000000 00000000 c022aea4 c1e67f7c
[ 1125.100000] 7d40: 00000000 00000000 00000000 000005c0 00000000 c1e67f7c c1e67ec0 c02306e0
[ 1125.100000] 7d60: 00000000 00000000 c1e67d74 00000000 c1e10220 00000000 c1e67d90 00000000
[ 1125.100000] 7d80: c3483000 c01d2c38 00000000 00000001 00000001 00000000 00000000 000005c0
[ 1125.100000] 7da0: c3483000 c005c5d4 00000000 c1e67f7c 00000000 c03482b8 c1e66000 c1e67ee0
[ 1125.100000] 7dc0: c1e67e4c 0001424f c0345ba0 c035fca0 c035fca8 c005c6a8 00000000 00000001
[ 1125.100000] 7de0: ffffffff 00000000 00000000 00000000 00000000 00000000 c3887700 c0022608
[ 1125.100000] 7e00: 00000000 00000000 c01e59b4 00000001 c1e67d90 00000000 00000000 beca3b78
[ 1125.100000] 7e20: 00000004 00000000 00000004 c00b05b0 c1e67e48 c1e67e4c c1e67e50 00000001
[ 1125.100000] 7e40: c1e67f7c c3483000 beca35bc c1e67e80 c1e67f7c c1e67e80 c01d2b90 c3483000
[ 1125.100000] 7e60: beca35bc 00000000 c1e67e80 c01d3fac beca35d8 00000008 beca35c0 beca359c
[ 1125.100000] 7e80: b6ab34aa 00000576 00000001 c0022128 c025ce20 c1e49a80 00000009 0001424e
[ 1125.100000] 7ea0: 40008000 c1e66008 0000001d 00000000 c1e67f14 c3887700 c1e66008 0000001d
[ 1125.100000] 7ec0: b0040002 1714010a 00000000 00000000 c00189a8 00000013 f4008000 c000dbf4
[ 1125.100000] 7ee0: 81e68000 c1e49180 00000000 00000000 c1e1e000 c003c2f8 c1e1e000 00000002
[ 1125.100000] 7f00: c036092c c0346700 00000000 00000000 ffffffff 00000000 ffffffff 00000000
[ 1125.100000] 7f20: c1e67f78 c1e66000 c1e67f78 beca3cc0 00000001 beca3cc0 00000008 beca35bc
[ 1125.100000] 7f40: 00000000 c3483000 beca35bc 00000000 00000129 c000e188 c1e66000 00000000
[ 1125.100000] 7f60: beca37e0 c01d4fbc 00000000 beca3860 beca3938 00000000 fffffff7 c1e67ec0
[ 1125.100000] 7f80: 00000000 c1e67e80 00000001 beca359c 00000020 00000000 beca359c b6ab3460
[ 1125.100000] 7fa0: 00000000 c000dfe0 beca359c b6ab3460 00000004 beca35bc 00000000 00000020
[ 1125.100000] 7fc0: beca359c b6ab3460 00000000 00000129 beca37f4 00000000 00056178 beca37e0
[ 1125.100000] 7fe0: 00000004 beca33d0 0001a904 b6f6d8dc 60000010 00000004 83ffe831 83ffec31
[ 1125.100000] [<c0228adc>] (udp_recvmsg+0x284/0x33c) from [<c02306e0>] (inet_recvmsg+0x38/0x4c)
[ 1125.100000] [<c02306e0>] (inet_recvmsg+0x38/0x4c) from [<c01d2c38>] (sock_recvmsg+0xa8/0xcc)
[ 1125.100000] [<c01d2c38>] (sock_recvmsg+0xa8/0xcc) from [<c01d3fac>] (___sys_recvmsg.part.4+0xe0/0x1bc)
[ 1125.100000] [<c01d3fac>] (___sys_recvmsg.part.4+0xe0/0x1bc) from [<c01d4fbc>] (__sys_recvmsg+0x50/0x80)
[ 1125.100000] [<c01d4fbc>] (__sys_recvmsg+0x50/0x80) from [<c000dfe0>] (ret_fast_syscall+0x0/0x2c)
[ 1125.100000] Code: e1d330b0 e3a01008 e1c230b2 e5943080 (e593300c)
[ 1125.430000] ---[ end trace f0b7642b14562089 ]---
[ 1125.440000] ------------[ cut here ]------------
[ 1125.450000] WARNING: at net/ipv4/af_inet.c:153 inet_sock_destruct+0x188/0x1a8()
[ 1125.460000] Modules linked in:
[ 1125.460000] [<c0013ac8>] (unwind_backtrace+0x0/0xec) from [<c001c588>] (warn_slowpath_common+0x4c/0x64)
[ 1125.470000] [<c001c588>] (warn_slowpath_common+0x4c/0x64) from [<c001c63c>] (warn_slowpath_null+0x1c/0x24)
[ 1125.480000] [<c001c63c>] (warn_slowpath_null+0x1c/0x24) from [<c0230888>] (inet_sock_destruct+0x188/0x1a8)
[ 1125.490000] [<c0230888>] (inet_sock_destruct+0x188/0x1a8) from [<c01d75f4>] (__sk_free+0x18/0x154)
[ 1125.500000] [<c01d75f4>] (__sk_free+0x18/0x154) from [<c0230aa0>] (inet_release+0x44/0x70)
[ 1125.510000] [<c0230aa0>] (inet_release+0x44/0x70) from [<c01d3714>] (sock_release+0x20/0xc8)
[ 1125.510000] [<c01d3714>] (sock_release+0x20/0xc8) from [<c01d37d0>] (sock_close+0x14/0x2c)
[ 1125.520000] [<c01d37d0>] (sock_close+0x14/0x2c) from [<c00a0044>] (fput+0xb4/0x27c)
[ 1125.530000] [<c00a0044>] (fput+0xb4/0x27c) from [<c009d64c>] (filp_close+0x64/0x88)
[ 1125.540000] [<c009d64c>] (filp_close+0x64/0x88) from [<c001fb28>] (put_files_struct+0x80/0xe0)
[ 1125.550000] [<c001fb28>] (put_files_struct+0x80/0xe0) from [<c0020388>] (do_exit+0x4c8/0x748)
[ 1125.560000] [<c0020388>] (do_exit+0x4c8/0x748) from [<c0011894>] (die+0x214/0x240)
[ 1125.560000] [<c0011894>] (die+0x214/0x240) from [<c0256160>] (__do_kernel_fault.part.0+0x54/0x74)
[ 1125.570000] [<c0256160>] (__do_kernel_fault.part.0+0x54/0x74) from [<c0015188>] (do_bad_area+0x88/0x8c)
[ 1125.580000] [<c0015188>] (do_bad_area+0x88/0x8c) from [<c00173dc>] (do_alignment+0xf0/0x938)
[ 1125.590000] [<c00173dc>] (do_alignment+0xf0/0x938) from [<c000862c>] (do_DataAbort+0x34/0x98)
[ 1125.600000] [<c000862c>] (do_DataAbort+0x34/0x98) from [<c000db98>] (__dabt_svc+0x38/0x60)
[ 1125.610000] Exception stack(0xc1e67cc8 to 0xc1e67d10)
[ 1125.610000] 7cc0: c1e67ec8 00000008 c1e67ec0 c14fe62e c14f4640 c1e67f7c
[ 1125.620000] 7ce0: c1e10220 000005c0 00000000 0000004a c1e67d34 0000004a 00000000 c1e67d10
[ 1125.630000] 7d00: 00000000 c0228adc a0000013 ffffffff
[ 1125.640000] [<c000db98>] (__dabt_svc+0x38/0x60) from [<c0228adc>] (udp_recvmsg+0x284/0x33c)
[ 1125.650000] [<c0228adc>] (udp_recvmsg+0x284/0x33c) from [<c02306e0>] (inet_recvmsg+0x38/0x4c)
[ 1125.650000] [<c02306e0>] (inet_recvmsg+0x38/0x4c) from [<c01d2c38>] (sock_recvmsg+0xa8/0xcc)
[ 1125.660000] [<c01d2c38>] (sock_recvmsg+0xa8/0xcc) from [<c01d3fac>] (___sys_recvmsg.part.4+0xe0/0x1bc)
[ 1125.670000] [<c01d3fac>] (___sys_recvmsg.part.4+0xe0/0x1bc) from [<c01d4fbc>] (__sys_recvmsg+0x50/0x80)
[ 1125.680000] [<c01d4fbc>] (__sys_recvmsg+0x50/0x80) from [<c000dfe0>] (ret_fast_syscall+0x0/0x2c)
[ 1125.690000] ---[ end trace f0b7642b1456208a ]---
[ 1125.700000] ------------[ cut here ]------------
[ 1125.700000] WARNING: at net/ipv4/af_inet.c:156 inet_sock_destruct+0x158/0x1a8()
[ 1125.710000] Modules linked in:
[ 1125.710000] [<c0013ac8>] (unwind_backtrace+0x0/0xec) from [<c001c588>] (warn_slowpath_common+0x4c/0x64)
[ 1125.720000] [<c001c588>] (warn_slowpath_common+0x4c/0x64) from [<c001c63c>] (warn_slowpath_null+0x1c/0x24)
[ 1125.730000] [<c001c63c>] (warn_slowpath_null+0x1c/0x24) from [<c0230858>] (inet_sock_destruct+0x158/0x1a8)
[ 1125.740000] [<c0230858>] (inet_sock_destruct+0x158/0x1a8) from [<c01d75f4>] (__sk_free+0x18/0x154)
[ 1125.750000] [<c01d75f4>] (__sk_free+0x18/0x154) from [<c0230aa0>] (inet_release+0x44/0x70)
[ 1125.760000] [<c0230aa0>] (inet_release+0x44/0x70) from [<c01d3714>] (sock_release+0x20/0xc8)
[ 1125.770000] [<c01d3714>] (sock_release+0x20/0xc8) from [<c01d37d0>] (sock_close+0x14/0x2c)
[ 1125.780000] [<c01d37d0>] (sock_close+0x14/0x2c) from [<c00a0044>] (fput+0xb4/0x27c)
[ 1125.780000] [<c00a0044>] (fput+0xb4/0x27c) from [<c009d64c>] (filp_close+0x64/0x88)
[ 1125.790000] [<c009d64c>] (filp_close+0x64/0x88) from [<c001fb28>] (put_files_struct+0x80/0xe0)
[ 1125.800000] [<c001fb28>] (put_files_struct+0x80/0xe0) from [<c0020388>] (do_exit+0x4c8/0x748)
[ 1125.810000] [<c0020388>] (do_exit+0x4c8/0x748) from [<c0011894>] (die+0x214/0x240)
[ 1125.820000] [<c0011894>] (die+0x214/0x240) from [<c0256160>] (__do_kernel_fault.part.0+0x54/0x74)
[ 1125.830000] [<c0256160>] (__do_kernel_fault.part.0+0x54/0x74) from [<c0015188>] (do_bad_area+0x88/0x8c)
[ 1125.840000] [<c0015188>] (do_bad_area+0x88/0x8c) from [<c00173dc>] (do_alignment+0xf0/0x938)
[ 1125.850000] [<c00173dc>] (do_alignment+0xf0/0x938) from [<c000862c>] (do_DataAbort+0x34/0x98)
[ 1125.850000] [<c000862c>] (do_DataAbort+0x34/0x98) from [<c000db98>] (__dabt_svc+0x38/0x60)
[ 1125.860000] Exception stack(0xc1e67cc8 to 0xc1e67d10)
[ 1125.870000] 7cc0: c1e67ec8 00000008 c1e67ec0 c14fe62e c14f4640 c1e67f7c
[ 1125.880000] 7ce0: c1e10220 000005c0 00000000 0000004a c1e67d34 0000004a 00000000 c1e67d10
[ 1125.880000] 7d00: 00000000 c0228adc a0000013 ffffffff
[ 1125.890000] [<c000db98>] (__dabt_svc+0x38/0x60) from [<c0228adc>] (udp_recvmsg+0x284/0x33c)
[ 1125.900000] [<c0228adc>] (udp_recvmsg+0x284/0x33c) from [<c02306e0>] (inet_recvmsg+0x38/0x4c)
[ 1125.910000] [<c02306e0>] (inet_recvmsg+0x38/0x4c) from [<c01d2c38>] (sock_recvmsg+0xa8/0xcc)
[ 1125.920000] [<c01d2c38>] (sock_recvmsg+0xa8/0xcc) from [<c01d3fac>] (___sys_recvmsg.part.4+0xe0/0x1bc)
[ 1125.930000] [<c01d3fac>] (___sys_recvmsg.part.4+0xe0/0x1bc) from [<c01d4fbc>] (__sys_recvmsg+0x50/0x80)
[ 1125.940000] [<c01d4fbc>] (__sys_recvmsg+0x50/0x80) from [<c000dfe0>] (ret_fast_syscall+0x0/0x2c)
[ 1125.940000] ---[ end trace f0b7642b1456208b ]---
Raw
mlc3250.dts
/dts-v1/;
/include/ "lpc32xx.dtsi"
/ {
model = "m-u-t MLC3250 board based on NXP LPC3250";
compatible = "mut,mlc3250", "nxp,lpc3250";
#address-cells = <1>;
#size-cells = <1>;
memory {
device_type = "memory";
reg = <0x80000000 0x4000000>;
};
aliases {
serial0 = &uart5;
};
chosen {
bootargs = "debug console=ttyS0,115200 root=/dev/ram0 ";
};
};
&mac {
phy-mode = "rmii";
use-iram;
};
&uart4 {
status = "okay";
};
&uart5 {
status = "okay";
};
Raw
net_uipv4_udp.lst
udp.o: file format elf32-littlearm
Disassembly of section .text:
c0227a30 <xfrm4_udp_encap_rcv>:
}
static inline int xfrm4_udp_encap_rcv(struct sock *sk, struct sk_buff *skb)
{
/* should not happen */
kfree_skb(skb);
c0227a30: e1a00001 mov r0, r1
{
c0227a34: e92d4008 push {r3, lr}
kfree_skb(skb);
c0227a38: ebfffffe bl 0 <kfree_skb>
c0227a38: R_ARM_CALL kfree_skb
return 0;
}
c0227a3c: e3a00000 mov r0, #0
c0227a40: e8bd8008 pop {r3, pc}
c0227a44 <udp_lib_hash>:
return csum;
}
/* hash routines shared between UDPv4/6 and UDP-Litev4/6 */
static inline void udp_lib_hash(struct sock *sk)
{
c0227a44: e7f001f2 .word 0xe7f001f2
c0227a48 <udp_lib_close>:
extern void udp_lib_unhash(struct sock *sk);
extern void udp_lib_rehash(struct sock *sk, u16 new_hash);
static inline void udp_lib_close(struct sock *sk, long timeout)
{
sk_common_release(sk);
c0227a48: eafffffe b 0 <sk_common_release>
c0227a48: R_ARM_JUMP24 sk_common_release
c0227a4c <udplite_getfrag>:
/*
* Checksum computation is all in software, hence simpler getfrag.
*/
static __inline__ int udplite_getfrag(void *from, char *to, int offset,
int len, int odd, struct sk_buff *skb)
{
c0227a4c: e1a0c000 mov ip, r0
return memcpy_fromiovecend(to, (struct iovec *) from, offset, len);
c0227a50: e1a00001 mov r0, r1
c0227a54: e1a0100c mov r1, ip
c0227a58: eafffffe b 0 <memcpy_fromiovecend>
c0227a58: R_ARM_JUMP24 memcpy_fromiovecend
c0227a5c <ipv4_rcv_saddr_equal>:
static int ipv4_rcv_saddr_equal(const struct sock *sk1, const struct sock *sk2)
{
struct inet_sock *inet1 = inet_sk(sk1), *inet2 = inet_sk(sk2);
return (!ipv6_only_sock(sk2) &&
(!inet1->inet_rcv_saddr || !inet2->inet_rcv_saddr ||
c0227a5c: e5903004 ldr r3, [r0, #4]
return (!ipv6_only_sock(sk2) &&
c0227a60: e3530000 cmp r3, #0
c0227a64: 0a000005 beq c0227a80 <ipv4_rcv_saddr_equal+0x24>
(!inet1->inet_rcv_saddr || !inet2->inet_rcv_saddr ||
c0227a68: e5910004 ldr r0, [r1, #4]
return (!ipv6_only_sock(sk2) &&
c0227a6c: e1530000 cmp r3, r0
c0227a70: 13500000 cmpne r0, #0
c0227a74: 03a00001 moveq r0, #1
c0227a78: 13a00000 movne r0, #0
c0227a7c: e12fff1e bx lr
c0227a80: e3a00001 mov r0, #1
inet1->inet_rcv_saddr == inet2->inet_rcv_saddr));
}
c0227a84: e12fff1e bx lr
c0227a88 <udp4_portaddr_hash>:
/* __jhash_nwords - hash exactly 3, 2 or 1 word(s) */
static inline u32 __jhash_nwords(u32 a, u32 b, u32 c, u32 initval)
{
a += initval;
c0227a88: e59f3040 ldr r3, [pc, #64] ; c0227ad0 <udp4_portaddr_hash+0x48>
b += initval;
c += initval;
__jhash_final(a, b, c);
c0227a8c: e59f0040 ldr r0, [pc, #64] ; c0227ad4 <udp4_portaddr_hash+0x4c>
a += initval;
c0227a90: e0811003 add r1, r1, r3
__jhash_final(a, b, c);
c0227a94: e59fc03c ldr ip, [pc, #60] ; c0227ad8 <udp4_portaddr_hash+0x50>
c0227a98: e0211000 eor r1, r1, r0
c0227a9c: e081c00c add ip, r1, ip
c0227aa0: e023300c eor r3, r3, ip
c0227aa4: e04333ec sub r3, r3, ip, ror #7
c0227aa8: e0231000 eor r1, r3, r0
c0227aac: e0411863 sub r1, r1, r3, ror #16
c0227ab0: e02cc001 eor ip, ip, r1
c0227ab4: e04c0e61 sub r0, ip, r1, ror #28
c0227ab8: e0233000 eor r3, r3, r0
c0227abc: e0433960 sub r3, r3, r0, ror #18
c0227ac0: e0211003 eor r1, r1, r3
c0227ac4: e0410463 sub r0, r1, r3, ror #8
static unsigned int udp4_portaddr_hash(struct net *net, __be32 saddr,
unsigned int port)
{
return jhash_1word((__force u32)saddr, net_hash_mix(net)) ^ port;
}
c0227ac8: e0200002 eor r0, r0, r2
c0227acc: e12fff1e bx lr
c0227ad0: deadbef3 .word 0xdeadbef3
c0227ad4: 90430855 .word 0x90430855
c0227ad8: e7bd537e .word 0xe7bd537e
c0227adc <udp_lib_rehash>:
/*
* inet_rcv_saddr was changed, we must rehash secondary hash
*/
void udp_lib_rehash(struct sock *sk, u16 newhash)
{
c0227adc: e92d43f8 push {r3, r4, r5, r6, r7, r8, r9, lr}
if (sk_hashed(sk)) {
c0227ae0: e5903024 ldr r3, [r0, #36] ; 0x24
{
c0227ae4: e1a04000 mov r4, r0
if (sk_hashed(sk)) {
c0227ae8: e3530000 cmp r3, #0
c0227aec: 08bd83f8 popeq {r3, r4, r5, r6, r7, r8, r9, pc}
struct udp_table *udptable = sk->sk_prot->h.udp_table;
c0227af0: e590301c ldr r3, [r0, #28]
struct udp_hslot *hslot, *hslot2, *nhslot2;
hslot2 = udp_hashslot2(udptable, udp_sk(sk)->udp_portaddr_hash);
c0227af4: e1d050ba ldrh r5, [r0, #10]
struct udp_table *udptable = sk->sk_prot->h.udp_table;
c0227af8: e5933090 ldr r3, [r3, #144] ; 0x90
return &table->hash2[hash & table->mask];
c0227afc: e5937008 ldr r7, [r3, #8]
c0227b00: e5938004 ldr r8, [r3, #4]
c0227b04: e0055007 and r5, r5, r7
c0227b08: e0077001 and r7, r7, r1
c0227b0c: e0885185 add r5, r8, r5, lsl #3
c0227b10: e0889187 add r9, r8, r7, lsl #3
nhslot2 = udp_hashslot2(udptable, newhash);
udp_sk(sk)->udp_portaddr_hash = newhash;
if (hslot2 != nhslot2) {
c0227b14: e1550009 cmp r5, r9
udp_sk(sk)->udp_portaddr_hash = newhash;
c0227b18: e1c010ba strh r1, [r0, #10]
if (hslot2 != nhslot2) {
c0227b1c: 08bd83f8 popeq {r3, r4, r5, r6, r7, r8, r9, pc}
static inline struct thread_info *current_thread_info(void) __attribute_const__;
static inline struct thread_info *current_thread_info(void)
{
register unsigned long sp asm ("sp");
return (struct thread_info *)(sp & ~(THREAD_SIZE - 1));
c0227b20: e1a0300d mov r3, sp
c0227b24: e3c36d7f bic r6, r3, #8128 ; 0x1fc0
raw_spin_lock(&lock->rlock);
}
static inline void spin_lock_bh(spinlock_t *lock)
{
raw_spin_lock_bh(&lock->rlock);
c0227b28: ebfffffe bl 0 <local_bh_disable>
c0227b28: R_ARM_CALL local_bh_disable
c0227b2c: e3c6303f bic r3, r6, #63 ; 0x3f
c0227b30: e5932004 ldr r2, [r3, #4]
c0227b34: e2822001 add r2, r2, #1
c0227b38: e5832004 str r2, [r3, #4]
raw_spin_lock(&lock->rlock);
c0227b3c: e5932004 ldr r2, [r3, #4]
c0227b40: e2822001 add r2, r2, #1
c0227b44: e5832004 str r2, [r3, #4]
return ((unsigned long)ptr) >> 1;
}
static inline int hlist_nulls_unhashed(const struct hlist_nulls_node *h)
{
return !h->pprev;
c0227b48: e5943018 ldr r3, [r4, #24]
* perfectly legal to run concurrently with the _rcu list-traversal
* primitives, such as hlist_nulls_for_each_entry_rcu().
*/
static inline void hlist_nulls_del_init_rcu(struct hlist_nulls_node *n)
{
if (!hlist_nulls_unhashed(n)) {
c0227b4c: e3530000 cmp r3, #0
c0227b50: 0a000005 beq c0227b6c <udp_lib_rehash+0x90>
first->pprev = &n->next;
}
static inline void __hlist_nulls_del(struct hlist_nulls_node *n)
{
struct hlist_nulls_node *next = n->next;
c0227b54: e5942014 ldr r2, [r4, #20]
struct hlist_nulls_node **pprev = n->pprev;
*pprev = next;
if (!is_a_nulls(next))
c0227b58: e3120001 tst r2, #1
*pprev = next;
c0227b5c: e5832000 str r2, [r3]
next->pprev = pprev;
c0227b60: 05823004 streq r3, [r2, #4]
__hlist_nulls_del(n);
n->pprev = NULL;
c0227b64: e3a03000 mov r3, #0
c0227b68: e5843018 str r3, [r4, #24]
/* we must lock primary chain too */
spin_lock_bh(&hslot->lock);
spin_lock(&hslot2->lock);
hlist_nulls_del_init_rcu(&udp_sk(sk)->udp_portaddr_node);
hslot2->count--;
c0227b6c: e5953004 ldr r3, [r5, #4]
c0227b70: e2433001 sub r3, r3, #1
c0227b74: e5853004 str r3, [r5, #4]
c0227b78: e3c6303f bic r3, r6, #63 ; 0x3f
raw_spin_lock_irqsave_nested(spinlock_check(lock), flags, subclass); \
} while (0)
static inline void spin_unlock(spinlock_t *lock)
{
raw_spin_unlock(&lock->rlock);
c0227b7c: e5932004 ldr r2, [r3, #4]
c0227b80: e2422001 sub r2, r2, #1
c0227b84: e5832004 str r2, [r3, #4]
* @nr: bit number to test
* @addr: Address to start counting from
*/
static inline int test_bit(int nr, const volatile unsigned long *addr)
{
return 1UL & (addr[BIT_WORD(nr)] >> (nr & (BITS_PER_LONG-1)));
c0227b88: e5933000 ldr r3, [r3]
c0227b8c: e3130002 tst r3, #2
c0227b90: 1a00001a bne c0227c00 <udp_lib_rehash+0x124>
c0227b94: e3c6203f bic r2, r6, #63 ; 0x3f
raw_spin_lock(&lock->rlock);
c0227b98: e5923004 ldr r3, [r2, #4]
c0227b9c: e2833001 add r3, r3, #1
c0227ba0: e5823004 str r3, [r2, #4]
* list-traversal primitive must be guarded by rcu_read_lock().
*/
static inline void hlist_nulls_add_head_rcu(struct hlist_nulls_node *n,
struct hlist_nulls_head *h)
{
struct hlist_nulls_node *first = h->first;
c0227ba4: e7983187 ldr r3, [r8, r7, lsl #3]
spin_unlock(&hslot2->lock);
spin_lock(&nhslot2->lock);
hlist_nulls_add_head_rcu(&udp_sk(sk)->udp_portaddr_node,
c0227ba8: e2842014 add r2, r4, #20
n->next = first;
c0227bac: e5843014 str r3, [r4, #20]
n->pprev = &h->first;
c0227bb0: e5849018 str r9, [r4, #24]
rcu_assign_pointer(hlist_nulls_first_rcu(h), n);
if (!is_a_nulls(first))
c0227bb4: e3130001 tst r3, #1
rcu_assign_pointer(hlist_nulls_first_rcu(h), n);
c0227bb8: e7882187 str r2, [r8, r7, lsl #3]
first->pprev = &n->next;
c0227bbc: 05832004 streq r2, [r3, #4]
&nhslot2->head);
nhslot2->count++;
c0227bc0: e5993004 ldr r3, [r9, #4]
c0227bc4: e2833001 add r3, r3, #1
c0227bc8: e5893004 str r3, [r9, #4]
c0227bcc: e3c6303f bic r3, r6, #63 ; 0x3f
raw_spin_unlock(&lock->rlock);
c0227bd0: e5932004 ldr r2, [r3, #4]
c0227bd4: e2422001 sub r2, r2, #1
c0227bd8: e5832004 str r2, [r3, #4]
c0227bdc: e5933000 ldr r3, [r3]
c0227be0: e3130002 tst r3, #2
c0227be4: 1a000007 bne c0227c08 <udp_lib_rehash+0x12c>
c0227be8: e3c6303f bic r3, r6, #63 ; 0x3f
}
static inline void spin_unlock_bh(spinlock_t *lock)
{
raw_spin_unlock_bh(&lock->rlock);
c0227bec: e5932004 ldr r2, [r3, #4]
c0227bf0: e2422001 sub r2, r2, #1
c0227bf4: e5832004 str r2, [r3, #4]
spin_unlock(&nhslot2->lock);
spin_unlock_bh(&hslot->lock);
}
}
}
c0227bf8: e8bd43f8 pop {r3, r4, r5, r6, r7, r8, r9, lr}
c0227bfc: eafffffe b 0 <local_bh_enable>
c0227bfc: R_ARM_JUMP24 local_bh_enable
raw_spin_unlock(&lock->rlock);
c0227c00: ebfffffe bl 0 <preempt_schedule>
c0227c00: R_ARM_CALL preempt_schedule
c0227c04: eaffffe2 b c0227b94 <udp_lib_rehash+0xb8>
c0227c08: ebfffffe bl 0 <preempt_schedule>
c0227c08: R_ARM_CALL preempt_schedule
c0227c0c: eafffff5 b c0227be8 <udp_lib_rehash+0x10c>
c0227c10 <udp_v4_rehash>:
EXPORT_SYMBOL(udp_lib_rehash);
static void udp_v4_rehash(struct sock *sk)
{
c0227c10: e92d4010 push {r4, lr}
u16 new_hash = udp4_portaddr_hash(sock_net(sk),
inet_sk(sk)->inet_rcv_saddr,
inet_sk(sk)->inet_num);
c0227c14: e2803f56 add r3, r0, #344 ; 0x158
{
c0227c18: e1a04000 mov r4, r0
u16 new_hash = udp4_portaddr_hash(sock_net(sk),
c0227c1c: e5901004 ldr r1, [r0, #4]
c0227c20: e1d320b2 ldrh r2, [r3, #2]
c0227c24: e59f0014 ldr r0, [pc, #20] ; c0227c40 <udp_v4_rehash+0x30>
c0227c28: ebffff96 bl c0227a88 <udp4_portaddr_hash>
udp_lib_rehash(sk, new_hash);
c0227c2c: e1a01800 lsl r1, r0, #16
c0227c30: e1a01821 lsr r1, r1, #16
c0227c34: e1a00004 mov r0, r4
}
c0227c38: e8bd4010 pop {r4, lr}
udp_lib_rehash(sk, new_hash);
c0227c3c: eafffffe b c0227adc <udp_lib_rehash>
c0227c3c: R_ARM_JUMP24 udp_lib_rehash
c0227c40: 00000000 .word 0x00000000
c0227c40: R_ARM_ABS32 init_net
c0227c44 <udp_get_first>:
/* ------------------------------------------------------------------------ */
#ifdef CONFIG_PROC_FS
static struct sock *udp_get_first(struct seq_file *seq, int start)
{
c0227c44: e92d40f8 push {r3, r4, r5, r6, r7, lr}
struct sock *sk;
struct udp_iter_state *state = seq->private;
c0227c48: e590503c ldr r5, [r0, #60] ; 0x3c
struct net *net = seq_file_net(seq);
for (state->bucket = start; state->bucket <= state->udp_table->mask;
c0227c4c: e1a04001 mov r4, r1
c0227c50: e5952008 ldr r2, [r5, #8]
c0227c54: e5851004 str r1, [r5, #4]
c0227c58: e5923008 ldr r3, [r2, #8]
c0227c5c: e1510003 cmp r1, r3
c0227c60: 91a0300d movls r3, sp
c0227c64: 93c37d7f bicls r7, r3, #8128 ; 0x1fc0
c0227c68: 93c7703f bicls r7, r7, #63 ; 0x3f
c0227c6c: 9a000007 bls c0227c90 <udp_get_first+0x4c>
c0227c70: ea000024 b c0227d08 <udp_get_first+0xc4>
++state->bucket) {
c0227c74: e5953004 ldr r3, [r5, #4]
c0227c78: e2833001 add r3, r3, #1
for (state->bucket = start; state->bucket <= state->udp_table->mask;
c0227c7c: e1a04003 mov r4, r3
++state->bucket) {
c0227c80: e5853004 str r3, [r5, #4]
for (state->bucket = start; state->bucket <= state->udp_table->mask;
c0227c84: e5923008 ldr r3, [r2, #8]
c0227c88: e1540003 cmp r4, r3
c0227c8c: 8a00001d bhi c0227d08 <udp_get_first+0xc4>
struct hlist_nulls_node *node;
struct udp_hslot *hslot = &state->udp_table->hash[state->bucket];
c0227c90: e5926000 ldr r6, [r2]
return ((unsigned long)ptr & 1);
c0227c94: e7963184 ldr r3, [r6, r4, lsl #3]
if (hlist_nulls_empty(&hslot->head))
c0227c98: e3130001 tst r3, #1
c0227c9c: 1afffff4 bne c0227c74 <udp_get_first+0x30>
raw_spin_lock_bh(&lock->rlock);
c0227ca0: ebfffffe bl 0 <local_bh_disable>
c0227ca0: R_ARM_CALL local_bh_disable
c0227ca4: e5973004 ldr r3, [r7, #4]
c0227ca8: e2833001 add r3, r3, #1
c0227cac: e5873004 str r3, [r7, #4]
continue;
spin_lock_bh(&hslot->lock);
sk_nulls_for_each(sk, node, &hslot->head) {
c0227cb0: e7960184 ldr r0, [r6, r4, lsl #3]
c0227cb4: e3100001 tst r0, #1
c0227cb8: 1a00000a bne c0227ce8 <udp_get_first+0xa4>
if (!net_eq(sock_net(sk), net))
continue;
if (sk->sk_family == state->family)
c0227cbc: e1d520b0 ldrh r2, [r5]
c0227cc0: e15031b4 ldrh r3, [r0, #-20] ; 0xffffffec
c0227cc4: e1530002 cmp r3, r2
c0227cc8: 1a000003 bne c0227cdc <udp_get_first+0x98>
c0227ccc: ea00000b b c0227d00 <udp_get_first+0xbc>
c0227cd0: e15031b4 ldrh r3, [r0, #-20] ; 0xffffffec
c0227cd4: e1530002 cmp r3, r2
c0227cd8: 0a000008 beq c0227d00 <udp_get_first+0xbc>
sk_nulls_for_each(sk, node, &hslot->head) {
c0227cdc: e5900000 ldr r0, [r0]
c0227ce0: e3100001 tst r0, #1
c0227ce4: 0afffff9 beq c0227cd0 <udp_get_first+0x8c>
raw_spin_unlock_bh(&lock->rlock);
c0227ce8: e5973004 ldr r3, [r7, #4]
c0227cec: e2433001 sub r3, r3, #1
c0227cf0: e5873004 str r3, [r7, #4]
c0227cf4: ebfffffe bl 0 <local_bh_enable>
c0227cf4: R_ARM_CALL local_bh_enable
c0227cf8: e5952008 ldr r2, [r5, #8]
c0227cfc: eaffffdc b c0227c74 <udp_get_first+0x30>
c0227d00: e2400020 sub r0, r0, #32
c0227d04: e8bd80f8 pop {r3, r4, r5, r6, r7, pc}
goto found;
}
spin_unlock_bh(&hslot->lock);
}
sk = NULL;
c0227d08: e3a00000 mov r0, #0
c0227d0c: e8bd80f8 pop {r3, r4, r5, r6, r7, pc}
c0227d10 <udp_get_next>:
found:
return sk;
}
static struct sock *udp_get_next(struct seq_file *seq, struct sock *sk)
{
c0227d10: e92d4010 push {r4, lr}
c0227d14: e24dd008 sub sp, sp, #8
struct udp_iter_state *state = seq->private;
c0227d18: e590403c ldr r4, [r0, #60] ; 0x3c
c0227d1c: ea000005 b c0227d38 <udp_get_next+0x28>
struct net *net = seq_file_net(seq);
do {
sk = sk_nulls_next(sk);
} while (sk && (!net_eq(sock_net(sk), net) || sk->sk_family != state->family));
c0227d20: e2531020 subs r1, r3, #32
c0227d24: 0a000006 beq c0227d44 <udp_get_next+0x34>
c0227d28: e15321b4 ldrh r2, [r3, #-20] ; 0xffffffec
c0227d2c: e1d430b0 ldrh r3, [r4]
c0227d30: e1520003 cmp r2, r3
c0227d34: 0a00000a beq c0227d64 <udp_get_next+0x54>
hlist_entry(sk->sk_node.next, struct sock, sk_node) : NULL;
}
static inline struct sock *sk_nulls_next(const struct sock *sk)
{
return (!is_a_nulls(sk->sk_nulls_node.next)) ?
c0227d38: e5913020 ldr r3, [r1, #32]
hlist_nulls_entry(sk->sk_nulls_node.next,
struct sock, sk_nulls_node) :
c0227d3c: e3130001 tst r3, #1
c0227d40: 0afffff6 beq c0227d20 <udp_get_next+0x10>
if (!sk) {
if (state->bucket <= state->udp_table->mask)
c0227d44: e994000a ldmib r4, {r1, r3}
c0227d48: e5933008 ldr r3, [r3, #8]
c0227d4c: e1510003 cmp r1, r3
c0227d50: 9a000006 bls c0227d70 <udp_get_next+0x60>
spin_unlock_bh(&state->udp_table->hash[state->bucket].lock);
return udp_get_first(seq, state->bucket + 1);
c0227d54: e2811001 add r1, r1, #1
}
return sk;
}
c0227d58: e28dd008 add sp, sp, #8
c0227d5c: e8bd4010 pop {r4, lr}
return udp_get_first(seq, state->bucket + 1);
c0227d60: eaffffb7 b c0227c44 <udp_get_first>
}
c0227d64: e1a00001 mov r0, r1
c0227d68: e28dd008 add sp, sp, #8
c0227d6c: e8bd8010 pop {r4, pc}
c0227d70: e58d0004 str r0, [sp, #4]
c0227d74: e1a0300d mov r3, sp
c0227d78: e3c33d7f bic r3, r3, #8128 ; 0x1fc0
c0227d7c: e3c3303f bic r3, r3, #63 ; 0x3f
c0227d80: e5932004 ldr r2, [r3, #4]
c0227d84: e2422001 sub r2, r2, #1
c0227d88: e5832004 str r2, [r3, #4]
c0227d8c: ebfffffe bl 0 <local_bh_enable>
c0227d8c: R_ARM_CALL local_bh_enable
c0227d90: e5941004 ldr r1, [r4, #4]
c0227d94: e59d0004 ldr r0, [sp, #4]
c0227d98: eaffffed b c0227d54 <udp_get_next+0x44>
c0227d9c <udp_get_idx>:
static struct sock *udp_get_idx(struct seq_file *seq, loff_t pos)
{
c0227d9c: e92d4070 push {r4, r5, r6, lr}
struct sock *sk = udp_get_first(seq, 0);
c0227da0: e3a01000 mov r1, #0
{
c0227da4: e1a04002 mov r4, r2
c0227da8: e1a05003 mov r5, r3
c0227dac: e1a06000 mov r6, r0
struct sock *sk = udp_get_first(seq, 0);
c0227db0: ebffffa3 bl c0227c44 <udp_get_first>
if (sk)
c0227db4: e2501000 subs r1, r0, #0
c0227db8: 1a000006 bne c0227dd8 <udp_get_idx+0x3c>
c0227dbc: ea000009 b c0227de8 <udp_get_idx+0x4c>
while (pos && (sk = udp_get_next(seq, sk)) != NULL)
c0227dc0: e1a00006 mov r0, r6
c0227dc4: ebffffd1 bl c0227d10 <udp_get_next>
c0227dc8: e2501000 subs r1, r0, #0
c0227dcc: 0a000005 beq c0227de8 <udp_get_idx+0x4c>
--pos;
c0227dd0: e2544001 subs r4, r4, #1
c0227dd4: e2c55000 sbc r5, r5, #0
while (pos && (sk = udp_get_next(seq, sk)) != NULL)
c0227dd8: e1943005 orrs r3, r4, r5
c0227ddc: 1afffff7 bne c0227dc0 <udp_get_idx+0x24>
{
c0227de0: e1a00001 mov r0, r1
return pos ? NULL : sk;
}
c0227de4: e8bd8070 pop {r4, r5, r6, pc}
return pos ? NULL : sk;
c0227de8: e3a00000 mov r0, #0
c0227dec: e8bd8070 pop {r4, r5, r6, pc}
c0227df0 <udp_seq_start>:
static void *udp_seq_start(struct seq_file *seq, loff_t *pos)
{
struct udp_iter_state *state = seq->private;
state->bucket = MAX_UDP_PORTS;
c0227df0: e3a02801 mov r2, #65536 ; 0x10000
struct udp_iter_state *state = seq->private;
c0227df4: e590303c ldr r3, [r0, #60] ; 0x3c
state->bucket = MAX_UDP_PORTS;
c0227df8: e5832004 str r2, [r3, #4]
return *pos ? udp_get_idx(seq, *pos-1) : SEQ_START_TOKEN;
c0227dfc: e1c120d0 ldrd r2, [r1]
c0227e00: e1921003 orrs r1, r2, r3
c0227e04: 1a000001 bne c0227e10 <udp_seq_start+0x20>
}
c0227e08: e3a00001 mov r0, #1
c0227e0c: e12fff1e bx lr
return *pos ? udp_get_idx(seq, *pos-1) : SEQ_START_TOKEN;
c0227e10: e2522001 subs r2, r2, #1
c0227e14: e2c33000 sbc r3, r3, #0
c0227e18: eaffffdf b c0227d9c <udp_get_idx>
c0227e1c <udp_seq_next>:
static void *udp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
{
struct sock *sk;
if (v == SEQ_START_TOKEN)
c0227e1c: e3510001 cmp r1, #1
{
c0227e20: e92d4070 push {r4, r5, r6, lr}
c0227e24: e1a06002 mov r6, r2
if (v == SEQ_START_TOKEN)
c0227e28: 0a000005 beq c0227e44 <udp_seq_next+0x28>
sk = udp_get_idx(seq, 0);
else
sk = udp_get_next(seq, v);
c0227e2c: ebffffb7 bl c0227d10 <udp_get_next>
++*pos;
c0227e30: e1c640d0 ldrd r4, [r6]
c0227e34: e2944001 adds r4, r4, #1
c0227e38: e2a55000 adc r5, r5, #0
c0227e3c: e1c640f0 strd r4, [r6]
return sk;
}
c0227e40: e8bd8070 pop {r4, r5, r6, pc}
sk = udp_get_idx(seq, 0);
c0227e44: e3a02000 mov r2, #0
c0227e48: e3a03000 mov r3, #0
c0227e4c: ebffffd2 bl c0227d9c <udp_get_idx>
c0227e50: eafffff6 b c0227e30 <udp_seq_next+0x14>
c0227e54 <udp4_lib_lookup2>:
{
c0227e54: e92d43f0 push {r4, r5, r6, r7, r8, r9, lr}
c0227e58: e24dd014 sub sp, sp, #20
c0227e5c: e59d5030 ldr r5, [sp, #48] ; 0x30
c0227e60: e59d6038 ldr r6, [sp, #56] ; 0x38
udp_portaddr_for_each_entry_rcu(sk, node, &hslot2->head) {
c0227e64: e596c000 ldr ip, [r6]
c0227e68: e21c8001 ands r8, ip, #1
c0227e6c: 03e07000 mvneq r7, #0
c0227e70: 0a000007 beq c0227e94 <udp4_lib_lookup2+0x40>
c0227e74: ea00004b b c0227fa8 <udp4_lib_lookup2+0x154>
return -1;
c0227e78: e3e0e000 mvn lr, #0
if (score > badness) {
c0227e7c: e15e0007 cmp lr, r7
c0227e80: c1a0700e movgt r7, lr
udp_portaddr_for_each_entry_rcu(sk, node, &hslot2->head) {
c0227e84: c1a08000 movgt r8, r0
c0227e88: e59cc000 ldr ip, [ip]
c0227e8c: e31c0001 tst ip, #1
c0227e90: 1a000027 bne c0227f34 <udp4_lib_lookup2+0xe0>
if (inet->inet_rcv_saddr != daddr)
c0227e94: e51ce010 ldr lr, [ip, #-16]
udp_portaddr_for_each_entry_rcu(sk, node, &hslot2->head) {
c0227e98: e24c0014 sub r0, ip, #20
if (inet->inet_rcv_saddr != daddr)
c0227e9c: e153000e cmp r3, lr
c0227ea0: 1afffff4 bne c0227e78 <udp4_lib_lookup2+0x24>
if (inet->inet_num != hnum)
c0227ea4: e28c4f51 add r4, ip, #324 ; 0x144
c0227ea8: e1d4e0b2 ldrh lr, [r4, #2]
c0227eac: e155000e cmp r5, lr
c0227eb0: 1afffff0 bne c0227e78 <udp4_lib_lookup2+0x24>
score = (sk->sk_family == PF_INET ? 1 : 0);
c0227eb4: e15ce0b8 ldrh lr, [ip, #-8]
if (inet->inet_daddr) {
c0227eb8: e51c9014 ldr r9, [ip, #-20] ; 0xffffffec
score = (sk->sk_family == PF_INET ? 1 : 0);
c0227ebc: e24ee002 sub lr, lr, #2
c0227ec0: e16fef1e clz lr, lr
if (inet->inet_daddr) {
c0227ec4: e3590000 cmp r9, #0
score = (sk->sk_family == PF_INET ? 1 : 0);
c0227ec8: e1a0e2ae lsr lr, lr, #5
if (inet->inet_daddr) {
c0227ecc: 0a000002 beq c0227edc <udp4_lib_lookup2+0x88>
if (inet->inet_daddr != saddr)
c0227ed0: e1510009 cmp r1, r9
c0227ed4: 1affffe7 bne c0227e78 <udp4_lib_lookup2+0x24>
score += 2;
c0227ed8: e28ee002 add lr, lr, #2
if (inet->inet_dport) {
c0227edc: e1d440b0 ldrh r4, [r4]
c0227ee0: e3540000 cmp r4, #0
c0227ee4: 0a000002 beq c0227ef4 <udp4_lib_lookup2+0xa0>
if (inet->inet_dport != sport)
c0227ee8: e1520004 cmp r2, r4
c0227eec: 1affffe1 bne c0227e78 <udp4_lib_lookup2+0x24>
score += 2;
c0227ef0: e28ee002 add lr, lr, #2
if (sk->sk_bound_dev_if) {
c0227ef4: e51c4004 ldr r4, [ip, #-4]
c0227ef8: e3540000 cmp r4, #0
c0227efc: 0affffde beq c0227e7c <udp4_lib_lookup2+0x28>
if (sk->sk_bound_dev_if != dif)
c0227f00: e59d9034 ldr r9, [sp, #52] ; 0x34
c0227f04: e1590004 cmp r9, r4
c0227f08: 1affffda bne c0227e78 <udp4_lib_lookup2+0x24>
score += 2;
c0227f0c: e28e4002 add r4, lr, #2
if (score > badness) {
c0227f10: e1540007 cmp r4, r7
c0227f14: daffffdb ble c0227e88 <udp4_lib_lookup2+0x34>
if (score == SCORE2_MAX)
c0227f18: e3540007 cmp r4, #7
c0227f1c: 0a00000b beq c0227f50 <udp4_lib_lookup2+0xfc>
udp_portaddr_for_each_entry_rcu(sk, node, &hslot2->head) {
c0227f20: e59cc000 ldr ip, [ip]
c0227f24: e1a07004 mov r7, r4
c0227f28: e31c0001 tst ip, #1
c0227f2c: e1a08000 mov r8, r0
c0227f30: 0affffd7 beq c0227e94 <udp4_lib_lookup2+0x40>
if (get_nulls_value(node) != slot2)
c0227f34: e59d003c ldr r0, [sp, #60] ; 0x3c
c0227f38: e1a04007 mov r4, r7
c0227f3c: e15000ac cmp r0, ip, lsr #1
c0227f40: e1a00008 mov r0, r8
c0227f44: 1affffc6 bne c0227e64 <udp4_lib_lookup2+0x10>
if (result) {
c0227f48: e3580000 cmp r8, #0
c0227f4c: 0a000018 beq c0227fb4 <udp4_lib_lookup2+0x160>
c0227f50: e3a0e002 mov lr, #2
c0227f54: ea000001 b c0227f60 <udp4_lib_lookup2+0x10c>
do {
val = atomic_cmpxchg(v, c, c + 1);
if (val == c)
return 1;
c = val;
} while (c);
c0227f58: e25ce000 subs lr, ip, #0
c0227f5c: 0a000014 beq c0227fb4 <udp4_lib_lookup2+0x160>
val = atomic_cmpxchg(v, c, c + 1);
c0227f60: e28e8001 add r8, lr, #1
*/
static inline unsigned long arch_local_irq_save(void)
{
unsigned long flags, temp;
asm volatile(
c0227f64: e10f7000 mrs r7, CPSR
c0227f68: e387c080 orr ip, r7, #128 ; 0x80
c0227f6c: e121f00c msr CPSR_c, ip
{
int ret;
unsigned long flags;
raw_local_irq_save(flags);
ret = v->counter;
c0227f70: e590c02c ldr ip, [r0, #44] ; 0x2c
if (likely(ret == old))
c0227f74: e15e000c cmp lr, ip
v->counter = new;
c0227f78: 0580802c streq r8, [r0, #44] ; 0x2c
/*
* restore saved IRQ & FIQ state
*/
static inline void arch_local_irq_restore(unsigned long flags)
{
asm volatile(
c0227f7c: e121f007 msr CPSR_c, r7
if (val == c)
c0227f80: e15e000c cmp lr, ip
c0227f84: 1afffff3 bne c0227f58 <udp4_lib_lookup2+0x104>
if (inet->inet_rcv_saddr != daddr)
c0227f88: e590c004 ldr ip, [r0, #4]
c0227f8c: e153000c cmp r3, ip
c0227f90: 0a00000a beq c0227fc0 <udp4_lib_lookup2+0x16c>
return -1;
c0227f94: e3e0c000 mvn ip, #0
else if (unlikely(compute_score2(result, net, saddr, sport,
c0227f98: e154000c cmp r4, ip
c0227f9c: ca000023 bgt c0228030 <udp4_lib_lookup2+0x1dc>
}
c0227fa0: e28dd014 add sp, sp, #20
c0227fa4: e8bd83f0 pop {r4, r5, r6, r7, r8, r9, pc}
if (get_nulls_value(node) != slot2)
c0227fa8: e59d003c ldr r0, [sp, #60] ; 0x3c
c0227fac: e15000ac cmp r0, ip, lsr #1
c0227fb0: 1affffab bne c0227e64 <udp4_lib_lookup2+0x10>
return -1;
c0227fb4: e3a00000 mov r0, #0
}
c0227fb8: e28dd014 add sp, sp, #20
c0227fbc: e8bd83f0 pop {r4, r5, r6, r7, r8, r9, pc}
if (inet->inet_num != hnum)
c0227fc0: e280ef56 add lr, r0, #344 ; 0x158
c0227fc4: e1dec0b2 ldrh ip, [lr, #2]
c0227fc8: e155000c cmp r5, ip
c0227fcc: 1afffff0 bne c0227f94 <udp4_lib_lookup2+0x140>
score = (sk->sk_family == PF_INET ? 1 : 0);
c0227fd0: e1d0c0bc ldrh ip, [r0, #12]
if (inet->inet_daddr) {
c0227fd4: e5907000 ldr r7, [r0]
score = (sk->sk_family == PF_INET ? 1 : 0);
c0227fd8: e24cc002 sub ip, ip, #2
c0227fdc: e16fcf1c clz ip, ip
if (inet->inet_daddr) {
c0227fe0: e3570000 cmp r7, #0
score = (sk->sk_family == PF_INET ? 1 : 0);
c0227fe4: e1a0c2ac lsr ip, ip, #5
if (inet->inet_daddr) {
c0227fe8: 0a000002 beq c0227ff8 <udp4_lib_lookup2+0x1a4>
if (inet->inet_daddr != saddr)
c0227fec: e1510007 cmp r1, r7
c0227ff0: 1affffe7 bne c0227f94 <udp4_lib_lookup2+0x140>
score += 2;
c0227ff4: e28cc002 add ip, ip, #2
if (inet->inet_dport) {
c0227ff8: e1dee0b0 ldrh lr, [lr]
c0227ffc: e35e0000 cmp lr, #0
c0228000: 0a000002 beq c0228010 <udp4_lib_lookup2+0x1bc>
if (inet->inet_dport != sport)
c0228004: e152000e cmp r2, lr
c0228008: 1affffe1 bne c0227f94 <udp4_lib_lookup2+0x140>
score += 2;
c022800c: e28cc002 add ip, ip, #2
if (sk->sk_bound_dev_if) {
c0228010: e590e010 ldr lr, [r0, #16]
c0228014: e35e0000 cmp lr, #0
c0228018: 0affffde beq c0227f98 <udp4_lib_lookup2+0x144>
if (sk->sk_bound_dev_if != dif)
c022801c: e59d7034 ldr r7, [sp, #52] ; 0x34
c0228020: e157000e cmp r7, lr
score += 2;
c0228024: 028cc002 addeq ip, ip, #2
if (sk->sk_bound_dev_if != dif)
c0228028: 1affffd9 bne c0227f94 <udp4_lib_lookup2+0x140>
c022802c: eaffffd9 b c0227f98 <udp4_lib_lookup2+0x144>
asm volatile(
c0228030: e10fe000 mrs lr, CPSR
c0228034: e38ec080 orr ip, lr, #128 ; 0x80
c0228038: e121f00c msr CPSR_c, ip
val = v->counter;
c022803c: e590c02c ldr ip, [r0, #44] ; 0x2c
v->counter = val -= i;
c0228040: e24cc001 sub ip, ip, #1
c0228044: e580c02c str ip, [r0, #44] ; 0x2c
asm volatile(
c0228048: e121f00e msr CPSR_c, lr
*/
/* Ungrab socket and destroy it, if it was the last reference. */
static inline void sock_put(struct sock *sk)
{
if (atomic_dec_and_test(&sk->sk_refcnt))
c022804c: e35c0000 cmp ip, #0
c0228050: 1affff83 bne c0227e64 <udp4_lib_lookup2+0x10>
c0228054: e98d000e stmib sp, {r1, r2, r3}
sk_free(sk);
c0228058: ebfffffe bl 0 <sk_free>
c0228058: R_ARM_CALL sk_free
c022805c: e99d000e ldmib sp, {r1, r2, r3}
c0228060: eaffff7f b c0227e64 <udp4_lib_lookup2+0x10>
c0228064 <udp_send_skb>:
{
c0228064: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
c0228068: e1a04000 mov r4, r0
c022806c: e1a07001 mov r7, r1
uh->check = 0;
c0228070: e3a01000 mov r1, #0
struct sock *sk = skb->sk;
c0228074: e5906010 ldr r6, [r0, #16]
#else /* NET_SKBUFF_DATA_USES_OFFSET */
static inline unsigned char *skb_transport_header(const struct sk_buff *skb)
{
return skb->transport_header;
c0228078: e590507c ldr r5, [r0, #124] ; 0x7c
return skb->csum_start - skb_headroom(skb);
}
static inline int skb_transport_offset(const struct sk_buff *skb)
{
return skb_transport_header(skb) - skb->data;
c022807c: e5903094 ldr r3, [r0, #148] ; 0x94
int len = skb->len - offset;
c0228080: e594204c ldr r2, [r4, #76] ; 0x4c
uh->source = inet->inet_sport;
c0228084: e2860f59 add r0, r6, #356 ; 0x164
c0228088: e1d000b0 ldrh r0, [r0]
c022808c: e0633005 rsb r3, r3, r5
int len = skb->len - offset;
c0228090: e0633002 rsb r3, r3, r2
int is_udplite = IS_UDPLITE(sk);
c0228094: e5d681f8 ldrb r8, [r6, #504] ; 0x1f8
uh->len = htons(len);
c0228098: e1a03803 lsl r3, r3, #16
uh->source = inet->inet_sport;
c022809c: e1c500b0 strh r0, [r5]
uh->dest = fl4->fl4_dport;
c02280a0: e1d721bc ldrh r2, [r7, #28]
uh->len = htons(len);
c02280a4: e1a09823 lsr r9, r3, #16
static inline __attribute_const__ __u16 __fswab16(__u16 val)
{
#ifdef __arch_swab16
return __arch_swab16(val);
#else
return ___constant_swab16(val);
c02280a8: e1a03c23 lsr r3, r3, #24
c02280ac: e1833409 orr r3, r3, r9, lsl #8
if (is_udplite) /* UDP-Lite */
c02280b0: e1580001 cmp r8, r1
uh->dest = fl4->fl4_dport;
c02280b4: e1c520b2 strh r2, [r5, #2]
uh->len = htons(len);
c02280b8: e1c530b4 strh r3, [r5, #4]
uh->check = 0;
c02280bc: e1c510b6 strh r1, [r5, #6]
if (is_udplite) /* UDP-Lite */
c02280c0: 0a000040 beq c02281c8 <udp_send_skb+0x164>
}
/* Fast-path computation of checksum. Socket may not be locked. */
static inline __wsum udplite_csum(struct sk_buff *skb)
{
const struct udp_sock *up = udp_sk(skb->sk);
c02280c4: e5943010 ldr r3, [r4, #16]
return skb->transport_header;
c02280c8: e594007c ldr r0, [r4, #124] ; 0x7c
const int off = skb_transport_offset(skb);
int len = skb->len - off;
if ((up->pcflag & UDPLITE_SEND_CC) && up->pcslen < len) {
c02280cc: e5d3c1f8 ldrb ip, [r3, #504] ; 0x1f8
return skb_transport_header(skb) - skb->data;
c02280d0: e5941094 ldr r1, [r4, #148] ; 0x94
int len = skb->len - off;
c02280d4: e594204c ldr r2, [r4, #76] ; 0x4c
c02280d8: e0611000 rsb r1, r1, r0
if ((up->pcflag & UDPLITE_SEND_CC) && up->pcslen < len) {
c02280dc: e31c0002 tst ip, #2
int len = skb->len - off;
c02280e0: e0612002 rsb r2, r1, r2
if ((up->pcflag & UDPLITE_SEND_CC) && up->pcslen < len) {
c02280e4: 1a000053 bne c0228238 <udp_send_skb+0x1d4>
if (0 < up->pcslen)
len = up->pcslen;
udp_hdr(skb)->len = htons(up->pcslen);
}
skb->ip_summed = CHECKSUM_NONE; /* no HW support for checksumming */
c02280e8: e5d43060 ldrb r3, [r4, #96] ; 0x60
return skb_checksum(skb, off, len, 0);
c02280ec: e1a00004 mov r0, r4
skb->ip_summed = CHECKSUM_NONE; /* no HW support for checksumming */
c02280f0: e3c3300c bic r3, r3, #12
c02280f4: e5c43060 strb r3, [r4, #96] ; 0x60
return skb_checksum(skb, off, len, 0);
c02280f8: e3a03000 mov r3, #0
c02280fc: ebfffffe bl 0 <skb_checksum>
c02280fc: R_ARM_CALL skb_checksum
c0228100: e1a03000 mov r3, r0
"adcs %0, %0, %4, lsl #8 \n"
#endif
"adcs %0, %0, %5 \n\
adc %0, %0, #0"
: "=&r"(sum)
: "r" (sum), "r" (daddr), "r" (saddr), "r" (len), "Ir" (htons(proto))
c0228104: e5d6108d ldrb r1, [r6, #141] ; 0x8d
__asm__(
c0228108: e5970018 ldr r0, [r7, #24]
c022810c: e597c014 ldr ip, [r7, #20]
c0228110: e1a01401 lsl r1, r1, #8
c0228114: e0932000 adds r2, r3, r0
c0228118: e0b2200c adcs r2, r2, ip
c022811c: e0b22409 adcs r2, r2, r9, lsl #8
c0228120: e0b22001 adcs r2, r2, r1
c0228124: e2a22000 adc r2, r2, #0
__asm__(
c0228128: e0823862 add r3, r2, r2, ror #16
return (__force __sum16)(~(__force u32)sum >> 16);
c022812c: e1e03003 mvn r3, r3
if (uh->check == 0)
c0228130: e1b03823 lsrs r3, r3, #16
uh->check = CSUM_MANGLED_0;
c0228134: 03e03000 mvneq r3, #0
err = ip_send_skb(skb);
c0228138: e1a00004 mov r0, r4
uh->check = CSUM_MANGLED_0;
c022813c: e1c530b6 strh r3, [r5, #6]
err = ip_send_skb(skb);
c0228140: ebfffffe bl 0 <ip_send_skb>
c0228140: R_ARM_CALL ip_send_skb
if (err) {
c0228144: e3500000 cmp r0, #0
c0228148: 0a000011 beq c0228194 <udp_send_skb+0x130>
if (err == -ENOBUFS && !inet->recverr) {
c022814c: e3700069 cmn r0, #105 ; 0x69
c0228150: 18bd87f0 popne {r4, r5, r6, r7, r8, r9, sl, pc}
c0228154: e5d63170 ldrb r3, [r6, #368] ; 0x170
c0228158: e2133001 ands r3, r3, #1
c022815c: 18bd87f0 popne {r4, r5, r6, r7, r8, r9, sl, pc}
UDP_INC_STATS_USER(sock_net(sk),
c0228160: e3580000 cmp r8, #0
c0228164: 0a000075 beq c0228340 <udp_send_skb+0x2dc>
asm volatile(
c0228168: e10f0000 mrs r0, CPSR
c022816c: e3802080 orr r2, r0, #128 ; 0x80
c0228170: e121f002 msr CPSR_c, r2
c0228174: e59f2228 ldr r2, [pc, #552] ; c02283a4 <udp_send_skb+0x340>
c0228178: e592109c ldr r1, [r2, #156] ; 0x9c
c022817c: e5912018 ldr r2, [r1, #24]
c0228180: e2822001 add r2, r2, #1
c0228184: e5812018 str r2, [r1, #24]
asm volatile(
c0228188: e121f000 msr CPSR_c, r0
err = 0;
c022818c: e1a00003 mov r0, r3
c0228190: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
UDP_INC_STATS_USER(sock_net(sk),
c0228194: e3580000 cmp r8, #0
c0228198: 1a00005e bne c0228318 <udp_send_skb+0x2b4>
asm volatile(
c022819c: e10f1000 mrs r1, CPSR
c02281a0: e3813080 orr r3, r1, #128 ; 0x80
c02281a4: e121f003 msr CPSR_c, r3
c02281a8: e59f31f4 ldr r3, [pc, #500] ; c02283a4 <udp_send_skb+0x340>
c02281ac: e5932098 ldr r2, [r3, #152] ; 0x98
c02281b0: e5923010 ldr r3, [r2, #16]
c02281b4: e2833001 add r3, r3, #1
c02281b8: e5823010 str r3, [r2, #16]
asm volatile(
c02281bc: e121f001 msr CPSR_c, r1
c02281c0: e3a00000 mov r0, #0
c02281c4: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
else if (sk->sk_no_check == UDP_CSUM_NOXMIT) { /* UDP csum disabled */
c02281c8: e5d6308c ldrb r3, [r6, #140] ; 0x8c
c02281cc: e203300c and r3, r3, #12
c02281d0: e3530004 cmp r3, #4
skb->ip_summed = CHECKSUM_NONE;
c02281d4: e5d43060 ldrb r3, [r4, #96] ; 0x60
c02281d8: 03c3300c biceq r3, r3, #12
c02281dc: 05c43060 strbeq r3, [r4, #96] ; 0x60
else if (sk->sk_no_check == UDP_CSUM_NOXMIT) { /* UDP csum disabled */
c02281e0: 0a000045 beq c02282fc <udp_send_skb+0x298>
} else if (skb->ip_summed == CHECKSUM_PARTIAL) { /* UDP hardware csum */
c02281e4: e203300c and r3, r3, #12
c02281e8: e353000c cmp r3, #12
c02281ec: 0a00001b beq c0228260 <udp_send_skb+0x1fc>
__wsum csum = csum_partial(skb_transport_header(skb),
c02281f0: e3a01008 mov r1, #8
c02281f4: e5942058 ldr r2, [r4, #88] ; 0x58
c02281f8: e594007c ldr r0, [r4, #124] ; 0x7c
c02281fc: ebfffffe bl 0 <csum_partial>
c02281fc: R_ARM_CALL csum_partial
for (skb = skb_shinfo(skb)->frag_list; skb; skb = skb->next) {
c0228200: e594208c ldr r2, [r4, #140] ; 0x8c
__wsum csum = csum_partial(skb_transport_header(skb),
c0228204: e1a03000 mov r3, r0
for (skb = skb_shinfo(skb)->frag_list; skb; skb = skb->next) {
c0228208: e5921008 ldr r1, [r2, #8]
c022820c: e3510000 cmp r1, #0
c0228210: 0affffbb beq c0228104 <udp_send_skb+0xa0>
csum = csum_add(csum, skb->csum);
c0228214: e5912058 ldr r2, [r1, #88] ; 0x58
for (skb = skb_shinfo(skb)->frag_list; skb; skb = skb->next) {
c0228218: e5911000 ldr r1, [r1]
static inline __wsum csum_add(__wsum csum, __wsum addend)
{
u32 res = (__force u32)csum;
res += (__force u32)addend;
return (__force __wsum)(res + (res < (__force u32)addend));
c022821c: e0933002 adds r3, r3, r2
c0228220: 23a00001 movcs r0, #1
c0228224: 33a00000 movcc r0, #0
c0228228: e3510000 cmp r1, #0
c022822c: e0803003 add r3, r0, r3
c0228230: 1afffff7 bne c0228214 <udp_send_skb+0x1b0>
c0228234: eaffffb2 b c0228104 <udp_send_skb+0xa0>
if ((up->pcflag & UDPLITE_SEND_CC) && up->pcslen < len) {
c0228238: e2833f7d add r3, r3, #500 ; 0x1f4
c022823c: e1d330b0 ldrh r3, [r3]
c0228240: e1520003 cmp r2, r3
c0228244: daffffa7 ble c02280e8 <udp_send_skb+0x84>
if (0 < up->pcslen)
c0228248: e3530000 cmp r3, #0
c022824c: e1a0c423 lsr ip, r3, #8
c0228250: 11a02003 movne r2, r3
c0228254: e18c3403 orr r3, ip, r3, lsl #8
udp_hdr(skb)->len = htons(up->pcslen);
c0228258: e1c030b4 strh r3, [r0, #4]
c022825c: eaffffa1 b c02280e8 <udp_send_skb+0x84>
struct sk_buff *frags = skb_shinfo(skb)->frag_list;
c0228260: e594308c ldr r3, [r4, #140] ; 0x8c
return skb->transport_header;
c0228264: e594907c ldr r9, [r4, #124] ; 0x7c
return skb_transport_header(skb) - skb->data;
c0228268: e5941094 ldr r1, [r4, #148] ; 0x94
c022826c: e5930008 ldr r0, [r3, #8]
int len = skb->len - offset;
c0228270: e594504c ldr r5, [r4, #76] ; 0x4c
c0228274: e0611009 rsb r1, r1, r9
c0228278: e0615005 rsb r5, r1, r5
if (!frags) {
c022827c: e3500000 cmp r0, #0
udp4_hwcsum(skb, fl4->saddr, fl4->daddr);
c0228280: e597a014 ldr sl, [r7, #20]
int len = skb->len - offset;
c0228284: e1a02005 mov r2, r5
udp4_hwcsum(skb, fl4->saddr, fl4->daddr);
c0228288: e5977018 ldr r7, [r7, #24]
if (!frags) {
c022828c: 11a03008 movne r3, r8
c0228290: 0a000035 beq c022836c <udp_send_skb+0x308>
csum = csum_add(csum, frags->csum);
c0228294: e590c058 ldr ip, [r0, #88] ; 0x58
hlen -= frags->len;
c0228298: e590e04c ldr lr, [r0, #76] ; 0x4c
c022829c: e093300c adds r3, r3, ip
c02282a0: 23a0c001 movcs ip, #1
c02282a4: 33a0c000 movcc ip, #0
} while ((frags = frags->next));
c02282a8: e5900000 ldr r0, [r0]
c02282ac: e08c3003 add r3, ip, r3
c02282b0: e3500000 cmp r0, #0
hlen -= frags->len;
c02282b4: e06e2002 rsb r2, lr, r2
} while ((frags = frags->next));
c02282b8: 1afffff5 bne c0228294 <udp_send_skb+0x230>
csum = skb_checksum(skb, offset, hlen, csum);
c02282bc: e1a00004 mov r0, r4
c02282c0: ebfffffe bl 0 <skb_checksum>
c02282c0: R_ARM_CALL skb_checksum
__asm__(
c02282c4: e0903007 adds r3, r0, r7
c02282c8: e0b3300a adcs r3, r3, sl
c02282cc: e0b33405 adcs r3, r3, r5, lsl #8
c02282d0: e2b33c11 adcs r3, r3, #4352 ; 0x1100
c02282d4: e2a33000 adc r3, r3, #0
__asm__(
c02282d8: e0833863 add r3, r3, r3, ror #16
return (__force __sum16)(~(__force u32)sum >> 16);
c02282dc: e1e03003 mvn r3, r3
if (uh->check == 0)
c02282e0: e1b03823 lsrs r3, r3, #16
uh->check = CSUM_MANGLED_0;
c02282e4: 03e03000 mvneq r3, #0
skb->ip_summed = CHECKSUM_NONE;
c02282e8: e5d42060 ldrb r2, [r4, #96] ; 0x60
c02282ec: e3c2200c bic r2, r2, #12
c02282f0: e5c42060 strb r2, [r4, #96] ; 0x60
uh->check = CSUM_MANGLED_0;
c02282f4: 01c930b6 strheq r3, [r9, #6]
c02282f8: 11c930b6 strhne r3, [r9, #6]
err = ip_send_skb(skb);
c02282fc: e1a00004 mov r0, r4
c0228300: ebfffffe bl 0 <ip_send_skb>
c0228300: R_ARM_CALL ip_send_skb
if (err) {
c0228304: e3500000 cmp r0, #0
c0228308: 0affffa3 beq c022819c <udp_send_skb+0x138>
if (err == -ENOBUFS && !inet->recverr) {
c022830c: e3700069 cmn r0, #105 ; 0x69
c0228310: 18bd87f0 popne {r4, r5, r6, r7, r8, r9, sl, pc}
c0228314: eaffff8e b c0228154 <udp_send_skb+0xf0>
asm volatile(
c0228318: e10f1000 mrs r1, CPSR
c022831c: e3813080 orr r3, r1, #128 ; 0x80
c0228320: e121f003 msr CPSR_c, r3
UDP_INC_STATS_USER(sock_net(sk),
c0228324: e59f3078 ldr r3, [pc, #120] ; c02283a4 <udp_send_skb+0x340>
c0228328: e593209c ldr r2, [r3, #156] ; 0x9c
c022832c: e5923010 ldr r3, [r2, #16]
c0228330: e2833001 add r3, r3, #1
c0228334: e5823010 str r3, [r2, #16]
asm volatile(
c0228338: e121f001 msr CPSR_c, r1
c022833c: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
asm volatile(
c0228340: e10f1000 mrs r1, CPSR
c0228344: e3813080 orr r3, r1, #128 ; 0x80
c0228348: e121f003 msr CPSR_c, r3
UDP_INC_STATS_USER(sock_net(sk),
c022834c: e59f3050 ldr r3, [pc, #80] ; c02283a4 <udp_send_skb+0x340>
c0228350: e5932098 ldr r2, [r3, #152] ; 0x98
c0228354: e5923018 ldr r3, [r2, #24]
c0228358: e2833001 add r3, r3, #1
c022835c: e5823018 str r3, [r2, #24]
asm volatile(
c0228360: e121f001 msr CPSR_c, r1
err = 0;
c0228364: e1a00008 mov r0, r8
c0228368: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
skb->csum_offset = offsetof(struct udphdr, check);
c022836c: e3a01006 mov r1, #6
__asm__(
c0228370: e0983007 adds r3, r8, r7
c0228374: e0b3300a adcs r3, r3, sl
c0228378: e0b33405 adcs r3, r3, r5, lsl #8
c022837c: e2b33c11 adcs r3, r3, #4352 ; 0x1100
c0228380: e2a33000 adc r3, r3, #0
__asm__(
c0228384: e0833863 add r3, r3, r3, ror #16
skb->csum_start = skb_transport_header(skb) - skb->head;
c0228388: e5942090 ldr r2, [r4, #144] ; 0x90
uh->check = ~csum_tcpudp_magic(src, dst, len,
c022838c: e1a03823 lsr r3, r3, #16
skb->csum_start = skb_transport_header(skb) - skb->head;
c0228390: e0622009 rsb r2, r2, r9
c0228394: e1c425b8 strh r2, [r4, #88] ; 0x58
skb->csum_offset = offsetof(struct udphdr, check);
c0228398: e1c415ba strh r1, [r4, #90] ; 0x5a
uh->check = ~csum_tcpudp_magic(src, dst, len,
c022839c: e1c930b6 strh r3, [r9, #6]
c02283a0: eaffffd5 b c02282fc <udp_send_skb+0x298>
c02283a4: 00000000 .word 0x00000000
c02283a4: R_ARM_ABS32 init_net
c02283a8 <udp_push_pending_frames>:
{
c02283a8: e92d4038 push {r3, r4, r5, lr}
struct flowi4 *fl4 = &inet->cork.fl.u.ip4;
c02283ac: e2805f6a add r5, r0, #424 ; 0x1a8
struct rtable **rtp,
unsigned int flags);
static inline struct sk_buff *ip_finish_skb(struct sock *sk, struct flowi4 *fl4)
{
return __ip_make_skb(sk, fl4, &sk->sk_write_queue, &inet_sk(sk)->cork.base);
c02283b0: e2803f61 add r3, r0, #388 ; 0x184
c02283b4: e1a01005 mov r1, r5
c02283b8: e2802080 add r2, r0, #128 ; 0x80
{
c02283bc: e1a04000 mov r4, r0
c02283c0: ebfffffe bl 0 <__ip_make_skb>
c02283c0: R_ARM_CALL __ip_make_skb
if (!skb)
c02283c4: e2503000 subs r3, r0, #0
int err = 0;
c02283c8: 01a00003 moveq r0, r3
if (!skb)
c02283cc: 0a000001 beq c02283d8 <udp_push_pending_frames+0x30>
err = udp_send_skb(skb, fl4);
c02283d0: e1a01005 mov r1, r5
c02283d4: ebffff22 bl c0228064 <udp_send_skb>
up->len = 0;
c02283d8: e3a03000 mov r3, #0
c02283dc: e2842e1f add r2, r4, #496 ; 0x1f0
c02283e0: e1c230b2 strh r3, [r2, #2]
up->pending = 0;
c02283e4: e58431e8 str r3, [r4, #488] ; 0x1e8
}
c02283e8: e8bd8038 pop {r3, r4, r5, pc}
c02283ec <udp_disconnect>:
{
c02283ec: e92d4038 push {r3, r4, r5, lr}
inet->inet_daddr = 0;
c02283f0: e3a02000 mov r2, #0
c02283f4: e1a03000 mov r3, r0
sk->sk_state = TCP_CLOSE;
c02283f8: e3a01007 mov r1, #7
c02283fc: e5c0100e strb r1, [r0, #14]
inet->inet_daddr = 0;
c0228400: e4832158 str r2, [r3], #344 ; 0x158
inet->inet_dport = 0;
c0228404: e1c320b0 strh r2, [r3]
if (!(sk->sk_userlocks & SOCK_BINDADDR_LOCK))
c0228408: e5d0308c ldrb r3, [r0, #140] ; 0x8c
sk->sk_bound_dev_if = 0;
c022840c: e5802010 str r2, [r0, #16]
if (!(sk->sk_userlocks & SOCK_BINDADDR_LOCK))
c0228410: e1a03223 lsr r3, r3, #4
c0228414: e2132004 ands r2, r3, #4
c0228418: e20330ff and r3, r3, #255 ; 0xff
#include <linux/ipv6.h>
#endif
static __inline__ void inet_reset_saddr(struct sock *sk)
{
inet_sk(sk)->inet_rcv_saddr = inet_sk(sk)->inet_saddr = 0;
c022841c: 0580215c streq r2, [r0, #348] ; 0x15c
c0228420: 05802004 streq r2, [r0, #4]
if (!(sk->sk_userlocks & SOCK_BINDPORT_LOCK)) {
c0228424: e2134008 ands r4, r3, #8
{
c0228428: e1a05000 mov r5, r0
if (!(sk->sk_userlocks & SOCK_BINDPORT_LOCK)) {
c022842c: 0a000013 beq c0228480 <udp_disconnect+0x94>
c0228430: e1a0300d mov r3, sp
c0228434: e3c34d7f bic r4, r3, #8128 ; 0x1fc0
c0228438: e3c4403f bic r4, r4, #63 ; 0x3f
raw_spin_lock(&lock->rlock);
c022843c: e5943004 ldr r3, [r4, #4]
c0228440: e2833001 add r3, r3, #1
c0228444: e5843004 str r3, [r4, #4]
sk->sk_tx_queue_mapping = tx_queue;
}
static inline void sk_tx_queue_clear(struct sock *sk)
{
sk->sk_tx_queue_mapping = -1;
c0228448: e3e03000 mvn r3, #0
sk_tx_queue_clear(sk);
/*
* This can be called while sk is owned by the caller only,
* with no state that can be checked in a rcu_dereference_check() cond
*/
old_dst = rcu_dereference_raw(sk->sk_dst_cache);
c022844c: e5950070 ldr r0, [r5, #112] ; 0x70
sk->sk_tx_queue_mapping = -1;
c0228450: e5853028 str r3, [r5, #40] ; 0x28
rcu_assign_pointer(sk->sk_dst_cache, dst);
c0228454: e3a03000 mov r3, #0
c0228458: e5853070 str r3, [r5, #112] ; 0x70
dst_release(old_dst);
c022845c: ebfffffe bl 0 <dst_release>
c022845c: R_ARM_CALL dst_release
raw_spin_unlock(&lock->rlock);
c0228460: e5943004 ldr r3, [r4, #4]
c0228464: e2433001 sub r3, r3, #1
c0228468: e5843004 str r3, [r4, #4]
c022846c: e5943000 ldr r3, [r4]
c0228470: e3130002 tst r3, #2
c0228474: 1a000007 bne c0228498 <udp_disconnect+0xac>
}
c0228478: e3a00000 mov r0, #0
c022847c: e8bd8038 pop {r3, r4, r5, pc}
sk->sk_prot->unhash(sk);
c0228480: e590301c ldr r3, [r0, #28]
c0228484: e5933040 ldr r3, [r3, #64] ; 0x40
c0228488: e12fff33 blx r3
inet->inet_sport = 0;
c022848c: e2853f59 add r3, r5, #356 ; 0x164
c0228490: e1c340b0 strh r4, [r3]
c0228494: eaffffe5 b c0228430 <udp_disconnect+0x44>
c0228498: ebfffffe bl 0 <preempt_schedule>
c0228498: R_ARM_CALL preempt_schedule
}
c022849c: e3a00000 mov r0, #0
c02284a0: e8bd8038 pop {r3, r4, r5, pc}
c02284a4 <udp_lib_setsockopt>:
{
c02284a4: e92d4070 push {r4, r5, r6, lr}
c02284a8: e59d1010 ldr r1, [sp, #16]
c02284ac: e1a0c000 mov ip, r0
if (optlen < sizeof(int))
c02284b0: e3510003 cmp r1, #3
int is_udplite = IS_UDPLITE(sk);
c02284b4: e5d061f8 ldrb r6, [r0, #504] ; 0x1f8
if (optlen < sizeof(int))
c02284b8: 9a00005d bls c0228634 <udp_lib_setsockopt+0x190>
c02284bc: e1a04002 mov r4, r2
c02284c0: e1a0200d mov r2, sp
c02284c4: e3c21d7f bic r1, r2, #8128 ; 0x1fc0
c02284c8: e3c1103f bic r1, r1, #63 ; 0x3f
if (get_user(val, (int __user *)optval))
c02284cc: e5911008 ldr r1, [r1, #8]
c02284d0: e1a00003 mov r0, r3
c02284d4: e2411001 sub r1, r1, #1
c02284d8: ebfffffe bl 0 <__get_user_4>
c02284d8: R_ARM_CALL __get_user_4
c02284dc: e2505000 subs r5, r0, #0
c02284e0: e1a03002 mov r3, r2
c02284e4: 1a000054 bne c022863c <udp_lib_setsockopt+0x198>
switch (optname) {
c02284e8: e354000a cmp r4, #10
c02284ec: 0a000037 beq c02285d0 <udp_lib_setsockopt+0x12c>
c02284f0: da00000d ble c022852c <udp_lib_setsockopt+0x88>
c02284f4: e354000b cmp r4, #11
c02284f8: 0a00001e beq c0228578 <udp_lib_setsockopt+0xd4>
c02284fc: e3540064 cmp r4, #100 ; 0x64
c0228500: 1a000019 bne c022856c <udp_lib_setsockopt+0xc8>
switch (val) {
c0228504: e3520000 cmp r2, #0
c0228508: ba000017 blt c022856c <udp_lib_setsockopt+0xc8>
c022850c: e3520002 cmp r2, #2
c0228510: da000044 ble c0228628 <udp_lib_setsockopt+0x184>
c0228514: e3520003 cmp r2, #3
c0228518: 1a000013 bne c022856c <udp_lib_setsockopt+0xc8>
up->encap_type = val;
c022851c: e28cce1f add ip, ip, #496 ; 0x1f0
c0228520: e1cc30b0 strh r3, [ip]
}
c0228524: e1a00005 mov r0, r5
c0228528: e8bd8070 pop {r4, r5, r6, pc}
switch (optname) {
c022852c: e3540001 cmp r4, #1
c0228530: 1a00000d bne c022856c <udp_lib_setsockopt+0xc8>
if (val != 0) {
c0228534: e3520000 cmp r2, #0
up->corkflag = 1;
c0228538: 158c41ec strne r4, [ip, #492] ; 0x1ec
if (val != 0) {
c022853c: 1a00000b bne c0228570 <udp_lib_setsockopt+0xcc>
c0228540: e1a0400c mov r4, ip
lock_sock_nested(sk, 0);
c0228544: e1a0000c mov r0, ip
up->corkflag = 0;
c0228548: e58c51ec str r5, [ip, #492] ; 0x1ec
c022854c: e1a01005 mov r1, r5
c0228550: ebfffffe bl 0 <lock_sock_nested>
c0228550: R_ARM_CALL lock_sock_nested
(*push_pending_frames)(sk);
c0228554: e1a00004 mov r0, r4
c0228558: e59d3014 ldr r3, [sp, #20]
c022855c: e12fff33 blx r3
release_sock(sk);
c0228560: e1a00004 mov r0, r4
c0228564: ebfffffe bl 0 <release_sock>
c0228564: R_ARM_CALL release_sock
c0228568: ea000000 b c0228570 <udp_lib_setsockopt+0xcc>
return -ENOPROTOOPT;
c022856c: e3e0505b mvn r5, #91 ; 0x5b
}
c0228570: e1a00005 mov r0, r5
c0228574: e8bd8070 pop {r4, r5, r6, pc}
if (!is_udplite) /* Disable the option on UDP sockets */
c0228578: e3560000 cmp r6, #0
c022857c: 0afffffa beq c022856c <udp_lib_setsockopt+0xc8>
if (val != 0 && val < 8) /* Avoid silly minimal values. */
c0228580: e3520007 cmp r2, #7
c0228584: c3a02000 movgt r2, #0
c0228588: d3a02001 movle r2, #1
c022858c: e3530000 cmp r3, #0
c0228590: 03a02000 moveq r2, #0
c0228594: e3520000 cmp r2, #0
c0228598: 13a03008 movne r3, #8
c022859c: 1a000004 bne c02285b4 <udp_lib_setsockopt+0x110>
c02285a0: e59f209c ldr r2, [pc, #156] ; c0228644 <udp_lib_setsockopt+0x1a0>
c02285a4: e1530002 cmp r3, r2
c02285a8: a1a03002 movge r3, r2
c02285ac: e1a03803 lsl r3, r3, #16
c02285b0: e1a03823 lsr r3, r3, #16
up->pcrlen = val;
c02285b4: e28c2f7d add r2, ip, #500 ; 0x1f4
c02285b8: e1c230b2 strh r3, [r2, #2]
up->pcflag |= UDPLITE_RECV_CC;
c02285bc: e5dc31f8 ldrb r3, [ip, #504] ; 0x1f8
}
c02285c0: e1a00005 mov r0, r5
up->pcflag |= UDPLITE_RECV_CC;
c02285c4: e3833004 orr r3, r3, #4
c02285c8: e5cc31f8 strb r3, [ip, #504] ; 0x1f8
}
c02285cc: e8bd8070 pop {r4, r5, r6, pc}
if (!is_udplite) /* Disable the option on UDP sockets */
c02285d0: e3560000 cmp r6, #0
c02285d4: 0affffe4 beq c022856c <udp_lib_setsockopt+0xc8>
if (val != 0 && val < 8) /* Illegal coverage: use default (8) */
c02285d8: e3520007 cmp r2, #7
c02285dc: c3a02000 movgt r2, #0
c02285e0: d3a02001 movle r2, #1
c02285e4: e3530000 cmp r3, #0
c02285e8: 03a02000 moveq r2, #0
c02285ec: e3520000 cmp r2, #0
c02285f0: 13a03008 movne r3, #8
c02285f4: 1a000004 bne c022860c <udp_lib_setsockopt+0x168>
c02285f8: e59f2044 ldr r2, [pc, #68] ; c0228644 <udp_lib_setsockopt+0x1a0>
c02285fc: e1530002 cmp r3, r2
c0228600: a1a03002 movge r3, r2
c0228604: e1a03803 lsl r3, r3, #16
c0228608: e1a03823 lsr r3, r3, #16
up->pcslen = val;
c022860c: e28c2f7d add r2, ip, #500 ; 0x1f4
c0228610: e1c230b0 strh r3, [r2]
up->pcflag |= UDPLITE_SEND_CC;
c0228614: e5dc31f8 ldrb r3, [ip, #504] ; 0x1f8
}
c0228618: e1a00005 mov r0, r5
up->pcflag |= UDPLITE_SEND_CC;
c022861c: e3833002 orr r3, r3, #2
c0228620: e5cc31f8 strb r3, [ip, #504] ; 0x1f8
}
c0228624: e8bd8070 pop {r4, r5, r6, pc}
up->encap_rcv = xfrm4_udp_encap_rcv;
c0228628: e59f2018 ldr r2, [pc, #24] ; c0228648 <udp_lib_setsockopt+0x1a4>
c022862c: e58c21fc str r2, [ip, #508] ; 0x1fc
c0228630: eaffffb9 b c022851c <udp_lib_setsockopt+0x78>
return -EINVAL;
c0228634: e3e05015 mvn r5, #21
c0228638: eaffffcc b c0228570 <udp_lib_setsockopt+0xcc>
return -EFAULT;
c022863c: e3e0500d mvn r5, #13
c0228640: eaffffca b c0228570 <udp_lib_setsockopt+0xcc>
c0228644: 0000ffff .word 0x0000ffff
c0228648: 00000000 .word 0x00000000
c0228648: R_ARM_ABS32 xfrm4_udp_encap_rcv
c022864c <first_packet_length>:
{
c022864c: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
c0228650: e24dd010 sub sp, sp, #16
c0228654: e1a0200d mov r2, sp
list->qlen = 0;
c0228658: e3a03000 mov r3, #0
c022865c: e1a05000 mov r5, r0
list->prev = list->next = (struct sk_buff *)list;
c0228660: e28d7004 add r7, sp, #4
c0228664: e3c28d7f bic r8, r2, #8128 ; 0x1fc0
list->qlen = 0;
c0228668: e58d300c str r3, [sp, #12]
list->prev = list->next = (struct sk_buff *)list;
c022866c: e58d7004 str r7, [sp, #4]
c0228670: e58d7008 str r7, [sp, #8]
raw_spin_lock_bh(&lock->rlock);
c0228674: ebfffffe bl 0 <local_bh_disable>
c0228674: R_ARM_CALL local_bh_disable
c0228678: e3c8203f bic r2, r8, #63 ; 0x3f
c022867c: e5923004 ldr r3, [r2, #4]
struct sk_buff_head list_kill, *rcvq = &sk->sk_receive_queue;
c0228680: e285903c add r9, r5, #60 ; 0x3c
c0228684: e2833001 add r3, r3, #1
c0228688: e5823004 str r3, [r2, #4]
struct sk_buff *list = ((const struct sk_buff *)list_)->next;
c022868c: e595403c ldr r4, [r5, #60] ; 0x3c
while ((skb = skb_peek(rcvq)) != NULL &&
c0228690: e1590004 cmp r9, r4
c0228694: 13540000 cmpne r4, #0
c0228698: 0a000065 beq c0228834 <first_packet_length+0x1e8>
extern __sum16 __skb_checksum_complete_head(struct sk_buff *skb, int len);
extern __sum16 __skb_checksum_complete(struct sk_buff *skb);
static inline int skb_csum_unnecessary(const struct sk_buff *skb)
{
return skb->ip_summed & CHECKSUM_UNNECESSARY;
c022869c: e5d46060 ldrb r6, [r4, #96] ; 0x60
c02286a0: e1a06126 lsr r6, r6, #2
return !skb_csum_unnecessary(skb) &&
c02286a4: e2166001 ands r6, r6, #1
c02286a8: 0a00000b beq c02286dc <first_packet_length+0x90>
res = skb ? skb->len : 0;
c02286ac: e594404c ldr r4, [r4, #76] ; 0x4c
c02286b0: e3c8203f bic r2, r8, #63 ; 0x3f
raw_spin_unlock_bh(&lock->rlock);
c02286b4: e5923004 ldr r3, [r2, #4]
c02286b8: e2433001 sub r3, r3, #1
c02286bc: e5823004 str r3, [r2, #4]
c02286c0: ebfffffe bl 0 <local_bh_enable>
c02286c0: R_ARM_CALL local_bh_enable
if (!skb_queue_empty(&list_kill)) {
c02286c4: e59d3004 ldr r3, [sp, #4]
c02286c8: e1530007 cmp r3, r7
c02286cc: 1a000033 bne c02287a0 <first_packet_length+0x154>
}
c02286d0: e1a00004 mov r0, r4
c02286d4: e28dd010 add sp, sp, #16
c02286d8: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
UDP_INC_STATS_BH(sock_net(sk), UDP_MIB_INERRORS,
c02286dc: e59fa170 ldr sl, [pc, #368] ; c0228854 <first_packet_length+0x208>
return __skb_checksum_complete_head(skb, UDP_SKB_CB(skb)->cscov);
c02286e0: e1a00004 mov r0, r4
c02286e4: e1d412bc ldrh r1, [r4, #44] ; 0x2c
c02286e8: ebfffffe bl 0 <__skb_checksum_complete_head>
c02286e8: R_ARM_CALL __skb_checksum_complete_head
return !skb_csum_unnecessary(skb) &&
c02286ec: e3500000 cmp r0, #0
c02286f0: 0affffed beq c02286ac <first_packet_length+0x60>
c02286f4: e5d531f8 ldrb r3, [r5, #504] ; 0x1f8
c02286f8: e3530000 cmp r3, #0
c02286fc: 1a000022 bne c022878c <first_packet_length+0x140>
c0228700: e59a2098 ldr r2, [sl, #152] ; 0x98
c0228704: e592300c ldr r3, [r2, #12]
c0228708: e2833001 add r3, r3, #1
c022870c: e582300c str r3, [r2, #12]
asm volatile(
c0228710: e10f2000 mrs r2, CPSR
c0228714: e3823080 orr r3, r2, #128 ; 0x80
c0228718: e121f003 msr CPSR_c, r3
val = v->counter;
c022871c: e595305c ldr r3, [r5, #92] ; 0x5c
v->counter = val += i;
c0228720: e2833001 add r3, r3, #1
c0228724: e585305c str r3, [r5, #92] ; 0x5c
asm volatile(
c0228728: e121f002 msr CPSR_c, r2
list->qlen--;
c022872c: e5953044 ldr r3, [r5, #68] ; 0x44
c0228730: e2433001 sub r3, r3, #1
c0228734: e5853044 str r3, [r5, #68] ; 0x44
prev = skb->prev;
c0228738: e894000c ldm r4, {r2, r3}
skb->next = skb->prev = NULL;
c022873c: e5846000 str r6, [r4]
c0228740: e5846004 str r6, [r4, #4]
next->prev = prev;
c0228744: e5823004 str r3, [r2, #4]
prev->next = next;
c0228748: e5832000 str r2, [r3]
__skb_insert(newsk, next->prev, next, list);
c022874c: e59d3008 ldr r3, [sp, #8]
newsk->next = next;
c0228750: e5847000 str r7, [r4]
newsk->prev = prev;
c0228754: e5843004 str r3, [r4, #4]
next->prev = prev->next = newsk;
c0228758: e5834000 str r4, [r3]
c022875c: e58d4008 str r4, [sp, #8]
struct sk_buff *list = ((const struct sk_buff *)list_)->next;
c0228760: e595403c ldr r4, [r5, #60] ; 0x3c
list->qlen++;
c0228764: e59d300c ldr r3, [sp, #12]
while ((skb = skb_peek(rcvq)) != NULL &&
c0228768: e1590004 cmp r9, r4
c022876c: 13540000 cmpne r4, #0
c0228770: e2833001 add r3, r3, #1
c0228774: e58d300c str r3, [sp, #12]
c0228778: 0a00002d beq c0228834 <first_packet_length+0x1e8>
return skb->ip_summed & CHECKSUM_UNNECESSARY;
c022877c: e5d43060 ldrb r3, [r4, #96] ; 0x60
c0228780: e3130004 tst r3, #4
c0228784: 1affffc8 bne c02286ac <first_packet_length+0x60>
c0228788: eaffffd4 b c02286e0 <first_packet_length+0x94>
UDP_INC_STATS_BH(sock_net(sk), UDP_MIB_INERRORS,
c022878c: e59a209c ldr r2, [sl, #156] ; 0x9c
c0228790: e592300c ldr r3, [r2, #12]
c0228794: e2833001 add r3, r3, #1
c0228798: e582300c str r3, [r2, #12]
c022879c: eaffffdb b c0228710 <first_packet_length+0xc4>
bool slow = lock_sock_fast(sk);
c02287a0: e1a00005 mov r0, r5
c02287a4: ebfffffe bl 0 <lock_sock_fast>
c02287a4: R_ARM_CALL lock_sock_fast
struct sk_buff *list = ((const struct sk_buff *)list_)->next;
c02287a8: e59d3004 ldr r3, [sp, #4]
c02287ac: e1a06000 mov r6, r0
if (skb)
c02287b0: e1530007 cmp r3, r7
c02287b4: 13530000 cmpne r3, #0
c02287b8: 0a00000e beq c02287f8 <first_packet_length+0x1ac>
skb->next = skb->prev = NULL;
c02287bc: e3a09000 mov r9, #0
list->qlen--;
c02287c0: e59d200c ldr r2, [sp, #12]
kfree_skb(skb);
c02287c4: e1a00003 mov r0, r3
list->qlen--;
c02287c8: e2422001 sub r2, r2, #1
c02287cc: e58d200c str r2, [sp, #12]
prev = skb->prev;
c02287d0: e8930006 ldm r3, {r1, r2}
skb->next = skb->prev = NULL;
c02287d4: e5839000 str r9, [r3]
c02287d8: e5839004 str r9, [r3, #4]
next->prev = prev;
c02287dc: e5812004 str r2, [r1, #4]
prev->next = next;
c02287e0: e5821000 str r1, [r2]
kfree_skb(skb);
c02287e4: ebfffffe bl 0 <kfree_skb>
c02287e4: R_ARM_CALL kfree_skb
struct sk_buff *list = ((const struct sk_buff *)list_)->next;
c02287e8: e59d3004 ldr r3, [sp, #4]
if (skb)
c02287ec: e1530007 cmp r3, r7
c02287f0: 13530000 cmpne r3, #0
c02287f4: 1afffff1 bne c02287c0 <first_packet_length+0x174>
return !!sk->sk_prot->memory_allocated;
c02287f8: e595301c ldr r3, [r5, #28]
if (!sk_has_account(sk))
c02287fc: e5933058 ldr r3, [r3, #88] ; 0x58
c0228800: e3530000 cmp r3, #0
c0228804: 0a000002 beq c0228814 <first_packet_length+0x1c8>
if (sk->sk_forward_alloc > SK_MEM_QUANTUM)
c0228808: e5953058 ldr r3, [r5, #88] ; 0x58
c022880c: e3530a01 cmp r3, #4096 ; 0x1000
c0228810: ca00000c bgt c0228848 <first_packet_length+0x1fc>
if (slow)
c0228814: e3560000 cmp r6, #0
c0228818: 1a000007 bne c022883c <first_packet_length+0x1f0>
c022881c: e3c8803f bic r8, r8, #63 ; 0x3f
c0228820: e5983004 ldr r3, [r8, #4]
c0228824: e2433001 sub r3, r3, #1
c0228828: e5883004 str r3, [r8, #4]
c022882c: ebfffffe bl 0 <local_bh_enable>
c022882c: R_ARM_CALL local_bh_enable
c0228830: eaffffa6 b c02286d0 <first_packet_length+0x84>
res = skb ? skb->len : 0;
c0228834: e3a04000 mov r4, #0
c0228838: eaffff9c b c02286b0 <first_packet_length+0x64>
release_sock(sk);
c022883c: e1a00005 mov r0, r5
c0228840: ebfffffe bl 0 <release_sock>
c0228840: R_ARM_CALL release_sock
c0228844: eaffffa1 b c02286d0 <first_packet_length+0x84>
__sk_mem_reclaim(sk);
c0228848: e1a00005 mov r0, r5
c022884c: ebfffffe bl 0 <__sk_mem_reclaim>
c022884c: R_ARM_CALL __sk_mem_reclaim
c0228850: eaffffef b c0228814 <first_packet_length+0x1c8>
c0228854: 00000000 .word 0x00000000
c0228854: R_ARM_ABS32 init_net
c0228858 <udp_recvmsg>:
{
c0228858: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
c022885c: e1a05002 mov r5, r2
int peeked, off = 0;
c0228860: e3a02000 mov r2, #0
{
c0228864: e24dd02c sub sp, sp, #44 ; 0x2c
c0228868: e1a07003 mov r7, r3
if (flags & MSG_ERRQUEUE)
c022886c: e59d3054 ldr r3, [sp, #84] ; 0x54
{
c0228870: e1a06001 mov r6, r1
if (flags & MSG_ERRQUEUE)
c0228874: e3130a02 tst r3, #8192 ; 0x2000
struct sockaddr_in *sin = (struct sockaddr_in *)msg->msg_name;
c0228878: e5953000 ldr r3, [r5]
int peeked, off = 0;
c022887c: e58d2020 str r2, [sp, #32]
struct sockaddr_in *sin = (struct sockaddr_in *)msg->msg_name;
c0228880: e58d3014 str r3, [sp, #20]
int is_udplite = IS_UDPLITE(sk);
c0228884: e5d131f8 ldrb r3, [r1, #504] ; 0x1f8
c0228888: e58d3010 str r3, [sp, #16]
if (flags & MSG_ERRQUEUE)
c022888c: 1a0000a2 bne c0228b1c <udp_recvmsg+0x2c4>
c0228890: e59d3050 ldr r3, [sp, #80] ; 0x50
c0228894: e28da024 add sl, sp, #36 ; 0x24
c0228898: e3530000 cmp r3, #0
c022889c: e1a0300d mov r3, sp
c02288a0: e3c39d7f bic r9, r3, #8128 ; 0x1fc0
c02288a4: 13a08040 movne r8, #64 ; 0x40
c02288a8: 03a08000 moveq r8, #0
c02288ac: e3c9903f bic r9, r9, #63 ; 0x3f
c02288b0: e1a0b009 mov fp, r9
skb = __skb_recv_datagram(sk, flags | (noblock ? MSG_DONTWAIT : 0),
c02288b4: e59d3054 ldr r3, [sp, #84] ; 0x54
c02288b8: e1838008 orr r8, r3, r8
c02288bc: e58da000 str sl, [sp]
c02288c0: e1a00006 mov r0, r6
c02288c4: e1a01008 mov r1, r8
c02288c8: e28d201c add r2, sp, #28
c02288cc: e28d3020 add r3, sp, #32
c02288d0: ebfffffe bl 0 <__skb_recv_datagram>
c02288d0: R_ARM_CALL __skb_recv_datagram
if (!skb)
c02288d4: e2504000 subs r4, r0, #0
c02288d8: 0a000017 beq c022893c <udp_recvmsg+0xe4>
ulen = skb->len - sizeof(struct udphdr);
c02288dc: e594304c ldr r3, [r4, #76] ; 0x4c
c02288e0: e2439008 sub r9, r3, #8
if (copied > ulen)
c02288e4: e1570009 cmp r7, r9
c02288e8: 8a000016 bhi c0228948 <udp_recvmsg+0xf0>
else if (copied < ulen)
c02288ec: 2a000046 bcs c0228a0c <udp_recvmsg+0x1b4>
msg->msg_flags |= MSG_TRUNC;
c02288f0: e5952018 ldr r2, [r5, #24]
c02288f4: e58d700c str r7, [sp, #12]
c02288f8: e3822020 orr r2, r2, #32
c02288fc: e5852018 str r2, [r5, #24]
return skb->ip_summed & CHECKSUM_UNNECESSARY;
c0228900: e5d42060 ldrb r2, [r4, #96] ; 0x60
c0228904: e3120004 tst r2, #4
c0228908: 0a00004b beq c0228a3c <udp_recvmsg+0x1e4>
err = skb_copy_datagram_iovec(skb, sizeof(struct udphdr),
c022890c: e1a00004 mov r0, r4
c0228910: e3a01008 mov r1, #8
c0228914: e5952008 ldr r2, [r5, #8]
c0228918: e59d300c ldr r3, [sp, #12]
c022891c: ebfffffe bl 0 <skb_copy_datagram_iovec>
c022891c: R_ARM_CALL skb_copy_datagram_iovec
c0228920: e1a0b009 mov fp, r9
c0228924: e58d0024 str r0, [sp, #36] ; 0x24
if (err)
c0228928: e3500000 cmp r0, #0
c022892c: 0a000048 beq c0228a54 <udp_recvmsg+0x1fc>
skb_free_datagram_locked(sk, skb);
c0228930: e1a00006 mov r0, r6
c0228934: e1a01004 mov r1, r4
c0228938: ebfffffe bl 0 <skb_free_datagram_locked>
c0228938: R_ARM_CALL skb_free_datagram_locked
return err;
c022893c: e59d0024 ldr r0, [sp, #36] ; 0x24
}
c0228940: e28dd02c add sp, sp, #44 ; 0x2c
c0228944: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
c0228948: e58d900c str r9, [sp, #12]
if (copied < ulen || UDP_SKB_CB(skb)->partial_cov) {
c022894c: e5d4202e ldrb r2, [r4, #46] ; 0x2e
c0228950: e3520000 cmp r2, #0
c0228954: 1affffe9 bne c0228900 <udp_recvmsg+0xa8>
c0228958: e5d42060 ldrb r2, [r4, #96] ; 0x60
if (checksum_valid || skb_csum_unnecessary(skb))
c022895c: e3120004 tst r2, #4
c0228960: 1affffe9 bne c022890c <udp_recvmsg+0xb4>
err = skb_copy_and_csum_datagram_iovec(skb,
c0228964: e1a00004 mov r0, r4
c0228968: e3a01008 mov r1, #8
c022896c: e5952008 ldr r2, [r5, #8]
c0228970: ebfffffe bl 0 <skb_copy_and_csum_datagram_iovec>
c0228970: R_ARM_CALL skb_copy_and_csum_datagram_iovec
if (err == -EINVAL)
c0228974: e3700016 cmn r0, #22
err = skb_copy_and_csum_datagram_iovec(skb,
c0228978: e58d0024 str r0, [sp, #36] ; 0x24
if (err == -EINVAL)
c022897c: 1a000072 bne c0228b4c <udp_recvmsg+0x2f4>
slow = lock_sock_fast(sk);
c0228980: e1a00006 mov r0, r6
c0228984: ebfffffe bl 0 <lock_sock_fast>
c0228984: R_ARM_CALL lock_sock_fast
if (!skb_kill_datagram(sk, skb, flags))
c0228988: e1a01004 mov r1, r4
slow = lock_sock_fast(sk);
c022898c: e1a09000 mov r9, r0
if (!skb_kill_datagram(sk, skb, flags))
c0228990: e59d2054 ldr r2, [sp, #84] ; 0x54
c0228994: e1a00006 mov r0, r6
c0228998: ebfffffe bl 0 <skb_kill_datagram>
c0228998: R_ARM_CALL skb_kill_datagram
c022899c: e3500000 cmp r0, #0
c02289a0: 1a00000b bne c02289d4 <udp_recvmsg+0x17c>
UDP_INC_STATS_USER(sock_net(sk), UDP_MIB_INERRORS, is_udplite);
c02289a4: e59d3010 ldr r3, [sp, #16]
c02289a8: e3530000 cmp r3, #0
c02289ac: 0a000018 beq c0228a14 <udp_recvmsg+0x1bc>
asm volatile(
c02289b0: e10f1000 mrs r1, CPSR
c02289b4: e3813080 orr r3, r1, #128 ; 0x80
c02289b8: e121f003 msr CPSR_c, r3
c02289bc: e59f31c8 ldr r3, [pc, #456] ; c0228b8c <udp_recvmsg+0x334>
c02289c0: e593209c ldr r2, [r3, #156] ; 0x9c
c02289c4: e592300c ldr r3, [r2, #12]
c02289c8: e2833001 add r3, r3, #1
c02289cc: e582300c str r3, [r2, #12]
asm volatile(
c02289d0: e121f001 msr CPSR_c, r1
if (slow)
c02289d4: e3590000 cmp r9, #0
c02289d8: 0a000006 beq c02289f8 <udp_recvmsg+0x1a0>
release_sock(sk);
c02289dc: e1a00006 mov r0, r6
c02289e0: ebfffffe bl 0 <release_sock>
c02289e0: R_ARM_CALL release_sock
cond_resched();
c02289e4: ebfffffe bl 0 <_cond_resched>
c02289e4: R_ARM_CALL _cond_resched
msg->msg_flags &= ~MSG_TRUNC;
c02289e8: e5953018 ldr r3, [r5, #24]
c02289ec: e3c33020 bic r3, r3, #32
c02289f0: e5853018 str r3, [r5, #24]
goto try_again;
c02289f4: eaffffb0 b c02288bc <udp_recvmsg+0x64>
c02289f8: e59b3004 ldr r3, [fp, #4]
c02289fc: e2433001 sub r3, r3, #1
c0228a00: e58b3004 str r3, [fp, #4]
c0228a04: ebfffffe bl 0 <local_bh_enable>
c0228a04: R_ARM_CALL local_bh_enable
c0228a08: eafffff5 b c02289e4 <udp_recvmsg+0x18c>
c0228a0c: e58d700c str r7, [sp, #12]
c0228a10: eaffffcd b c022894c <udp_recvmsg+0xf4>
asm volatile(
c0228a14: e10f1000 mrs r1, CPSR
c0228a18: e3813080 orr r3, r1, #128 ; 0x80
c0228a1c: e121f003 msr CPSR_c, r3
UDP_INC_STATS_USER(sock_net(sk), UDP_MIB_INERRORS, is_udplite);
c0228a20: e59f3164 ldr r3, [pc, #356] ; c0228b8c <udp_recvmsg+0x334>
c0228a24: e5932098 ldr r2, [r3, #152] ; 0x98
c0228a28: e592300c ldr r3, [r2, #12]
c0228a2c: e2833001 add r3, r3, #1
c0228a30: e582300c str r3, [r2, #12]
asm volatile(
c0228a34: e121f001 msr CPSR_c, r1
c0228a38: eaffffe5 b c02289d4 <udp_recvmsg+0x17c>
return __skb_checksum_complete_head(skb, UDP_SKB_CB(skb)->cscov);
c0228a3c: e1a00004 mov r0, r4
c0228a40: e1d412bc ldrh r1, [r4, #44] ; 0x2c
c0228a44: ebfffffe bl 0 <__skb_checksum_complete_head>
c0228a44: R_ARM_CALL __skb_checksum_complete_head
return !skb_csum_unnecessary(skb) &&
c0228a48: e3500000 cmp r0, #0
c0228a4c: 1affffcb bne c0228980 <udp_recvmsg+0x128>
c0228a50: eaffffad b c022890c <udp_recvmsg+0xb4>
if (!peeked)
c0228a54: e59d301c ldr r3, [sp, #28]
c0228a58: e3530000 cmp r3, #0
c0228a5c: 1a00000b bne c0228a90 <udp_recvmsg+0x238>
UDP_INC_STATS_USER(sock_net(sk),
c0228a60: e59d3010 ldr r3, [sp, #16]
c0228a64: e3530000 cmp r3, #0
c0228a68: 0a00003d beq c0228b64 <udp_recvmsg+0x30c>
asm volatile(
c0228a6c: e10f1000 mrs r1, CPSR
c0228a70: e3813080 orr r3, r1, #128 ; 0x80
c0228a74: e121f003 msr CPSR_c, r3
c0228a78: e59f310c ldr r3, [pc, #268] ; c0228b8c <udp_recvmsg+0x334>
c0228a7c: e593209c ldr r2, [r3, #156] ; 0x9c
c0228a80: e5923004 ldr r3, [r2, #4]
c0228a84: e2833001 add r3, r3, #1
c0228a88: e5823004 str r3, [r2, #4]
asm volatile(
c0228a8c: e121f001 msr CPSR_c, r1
(1UL << SOCK_TIMESTAMPING_RX_SOFTWARE) | \
(1UL << SOCK_TIMESTAMPING_SOFTWARE) | \
(1UL << SOCK_TIMESTAMPING_RAW_HARDWARE) | \
(1UL << SOCK_TIMESTAMPING_SYS_HARDWARE))
if (sk->sk_flags & FLAGS_TS_OR_DROPS)
c0228a90: e596206c ldr r2, [r6, #108] ; 0x6c
c0228a94: e59f30f4 ldr r3, [pc, #244] ; c0228b90 <udp_recvmsg+0x338>
c0228a98: e0033002 and r3, r3, r2
c0228a9c: e3530000 cmp r3, #0
c0228aa0: 1a000024 bne c0228b38 <udp_recvmsg+0x2e0>
__sock_recv_ts_and_drops(msg, sk, skb);
else
sk->sk_stamp = skb->tstamp;
c0228aa4: e1c420d8 ldrd r2, [r4, #8]
c0228aa8: e2861e11 add r1, r6, #272 ; 0x110
c0228aac: e1c120f0 strd r2, [r1]
if (sin) {
c0228ab0: e59d2014 ldr r2, [sp, #20]
c0228ab4: e3520000 cmp r2, #0
c0228ab8: 0a00000d beq c0228af4 <udp_recvmsg+0x29c>
sin->sin_family = AF_INET;
c0228abc: e3a03002 mov r3, #2
c0228ac0: e1c230b0 strh r3, [r2]
sin->sin_port = udp_hdr(skb)->source;
c0228ac4: e594307c ldr r3, [r4, #124] ; 0x7c
memset(sin->sin_zero, 0, sizeof(sin->sin_zero));
c0228ac8: e2820008 add r0, r2, #8
sin->sin_port = udp_hdr(skb)->source;
c0228acc: e1d330b0 ldrh r3, [r3]
memset(sin->sin_zero, 0, sizeof(sin->sin_zero));
c0228ad0: e3a01008 mov r1, #8
sin->sin_port = udp_hdr(skb)->source;
c0228ad4: e1c230b2 strh r3, [r2, #2]
sin->sin_addr.s_addr = ip_hdr(skb)->saddr;
c0228ad8: e5943080 ldr r3, [r4, #128] ; 0x80
c0228adc: e593300c ldr r3, [r3, #12]
c0228ae0: e5823004 str r3, [r2, #4]
memset(sin->sin_zero, 0, sizeof(sin->sin_zero));
c0228ae4: ebfffffe bl 0 <__memzero>
c0228ae4: R_ARM_CALL __memzero
*addr_len = sizeof(*sin);
c0228ae8: e3a03010 mov r3, #16
c0228aec: e59d2058 ldr r2, [sp, #88] ; 0x58
c0228af0: e5823000 str r3, [r2]
if (inet->cmsg_flags)
c0228af4: e2863e16 add r3, r6, #352 ; 0x160
c0228af8: e1d330b2 ldrh r3, [r3, #2]
c0228afc: e3530000 cmp r3, #0
c0228b00: 1a000013 bne c0228b54 <udp_recvmsg+0x2fc>
err = copied;
c0228b04: e59d3054 ldr r3, [sp, #84] ; 0x54
c0228b08: e59dc00c ldr ip, [sp, #12]
c0228b0c: e3130020 tst r3, #32
c0228b10: 11a0c00b movne ip, fp
c0228b14: e58dc024 str ip, [sp, #36] ; 0x24
c0228b18: eaffff84 b c0228930 <udp_recvmsg+0xd8>
return ip_recv_error(sk, msg, len, addr_len);
c0228b1c: e1a00001 mov r0, r1
c0228b20: e1a02007 mov r2, r7
c0228b24: e1a01005 mov r1, r5
c0228b28: e59d3058 ldr r3, [sp, #88] ; 0x58
c0228b2c: ebfffffe bl 0 <ip_recv_error>
c0228b2c: R_ARM_CALL ip_recv_error
}
c0228b30: e28dd02c add sp, sp, #44 ; 0x2c
c0228b34: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
__sock_recv_ts_and_drops(msg, sk, skb);
c0228b38: e1a00005 mov r0, r5
c0228b3c: e1a01006 mov r1, r6
c0228b40: e1a02004 mov r2, r4
c0228b44: ebfffffe bl 0 <__sock_recv_ts_and_drops>
c0228b44: R_ARM_CALL __sock_recv_ts_and_drops
c0228b48: eaffffd8 b c0228ab0 <udp_recvmsg+0x258>
c0228b4c: e1a0b009 mov fp, r9
c0228b50: eaffff74 b c0228928 <udp_recvmsg+0xd0>
ip_cmsg_recv(msg, skb);
c0228b54: e1a00005 mov r0, r5
c0228b58: e1a01004 mov r1, r4
c0228b5c: ebfffffe bl 0 <ip_cmsg_recv>
c0228b5c: R_ARM_CALL ip_cmsg_recv
c0228b60: eaffffe7 b c0228b04 <udp_recvmsg+0x2ac>
asm volatile(
c0228b64: e10f1000 mrs r1, CPSR
c0228b68: e3813080 orr r3, r1, #128 ; 0x80
c0228b6c: e121f003 msr CPSR_c, r3
UDP_INC_STATS_USER(sock_net(sk),
c0228b70: e59f3014 ldr r3, [pc, #20] ; c0228b8c <udp_recvmsg+0x334>
c0228b74: e5932098 ldr r2, [r3, #152] ; 0x98
c0228b78: e5923004 ldr r3, [r2, #4]
c0228b7c: e2833001 add r3, r3, #1
c0228b80: e5823004 str r3, [r2, #4]
asm volatile(
c0228b84: e121f001 msr CPSR_c, r1
c0228b88: eaffffc0 b c0228a90 <udp_recvmsg+0x238>
c0228b8c: 00000000 .word 0x00000000
c0228b8c: R_ARM_ABS32 init_net
c0228b90: 00bc0800 .word 0x00bc0800
c0228b94 <udp_lib_unhash>:
if (sk_hashed(sk)) {
c0228b94: e5903024 ldr r3, [r0, #36] ; 0x24
c0228b98: e3530000 cmp r3, #0
c0228b9c: 012fff1e bxeq lr
{
c0228ba0: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
c0228ba4: e1a0200d mov r2, sp
struct udp_table *udptable = sk->sk_prot->h.udp_table;
c0228ba8: e590301c ldr r3, [r0, #28]
c0228bac: e3c25d7f bic r5, r2, #8128 ; 0x1fc0
c0228bb0: e5933090 ldr r3, [r3, #144] ; 0x90
c0228bb4: e1a04000 mov r4, r0
return &table->hash[udp_hashfn(net, num, table->mask)];
c0228bb8: e5936000 ldr r6, [r3]
c0228bbc: e5938008 ldr r8, [r3, #8]
return &table->hash2[hash & table->mask];
c0228bc0: e5939004 ldr r9, [r3, #4]
udp_sk(sk)->udp_port_hash);
c0228bc4: e1d070b8 ldrh r7, [r0, #8]
hslot2 = udp_hashslot2(udptable, udp_sk(sk)->udp_portaddr_hash);
c0228bc8: e1d0a0ba ldrh sl, [r0, #10]
raw_spin_lock_bh(&lock->rlock);
c0228bcc: ebfffffe bl 0 <local_bh_disable>
c0228bcc: R_ARM_CALL local_bh_disable
c0228bd0: e3c5203f bic r2, r5, #63 ; 0x3f
c0228bd4: e5923004 ldr r3, [r2, #4]
c0228bd8: e2833001 add r3, r3, #1
c0228bdc: e5823004 str r3, [r2, #4]
h->pprev = NULL;
}
static inline int hlist_unhashed(const struct hlist_node *h)
{
return !h->pprev;
c0228be0: e5943024 ldr r3, [r4, #36] ; 0x24
if (sk_hashed(sk)) {
c0228be4: e3530000 cmp r3, #0
c0228be8: 0a000034 beq c0228cc0 <udp_lib_unhash+0x12c>
struct hlist_nulls_node *next = n->next;
c0228bec: e5942020 ldr r2, [r4, #32]
if (!is_a_nulls(next))
c0228bf0: e3120001 tst r2, #1
*pprev = next;
c0228bf4: e5832000 str r2, [r3]
next->pprev = pprev;
c0228bf8: 05823004 streq r3, [r2, #4]
n->pprev = NULL;
c0228bfc: e3a02000 mov r2, #0
WARN_ON(atomic_read(&sk->sk_refcnt) == 1);
c0228c00: e594302c ldr r3, [r4, #44] ; 0x2c
c0228c04: e5842024 str r2, [r4, #36] ; 0x24
c0228c08: e3530001 cmp r3, #1
c0228c0c: 0a000033 beq c0228ce0 <udp_lib_unhash+0x14c>
#define UDP_HTABLE_SIZE_MIN (CONFIG_BASE_SMALL ? 128 : 256)
static inline int udp_hashfn(struct net *net, unsigned num, unsigned mask)
{
return (num + net_hash_mix(net)) & mask;
c0228c10: e0077008 and r7, r7, r8
return &table->hash[udp_hashfn(net, num, table->mask)];
c0228c14: e0866187 add r6, r6, r7, lsl #3
asm volatile(
c0228c18: e10f2000 mrs r2, CPSR
c0228c1c: e3823080 orr r3, r2, #128 ; 0x80
c0228c20: e121f003 msr CPSR_c, r3
val = v->counter;
c0228c24: e594302c ldr r3, [r4, #44] ; 0x2c
v->counter = val -= i;
c0228c28: e2433001 sub r3, r3, #1
c0228c2c: e584302c str r3, [r4, #44] ; 0x2c
asm volatile(
c0228c30: e121f002 msr CPSR_c, r2
inet_sk(sk)->inet_num = 0;
c0228c34: e3a01000 mov r1, #0
hslot->count--;
c0228c38: e5962004 ldr r2, [r6, #4]
inet_sk(sk)->inet_num = 0;
c0228c3c: e2843f56 add r3, r4, #344 ; 0x158
hslot->count--;
c0228c40: e2422001 sub r2, r2, #1
c0228c44: e5862004 str r2, [r6, #4]
inet_sk(sk)->inet_num = 0;
c0228c48: e1c310b2 strh r1, [r3, #2]
sock_prot_inuse_add(sock_net(sk), sk->sk_prot, -1);
c0228c4c: e594101c ldr r1, [r4, #28]
c0228c50: e59f0098 ldr r0, [pc, #152] ; c0228cf0 <udp_lib_unhash+0x15c>
c0228c54: e3e02000 mvn r2, #0
c0228c58: ebfffffe bl 0 <sock_prot_inuse_add>
c0228c58: R_ARM_CALL sock_prot_inuse_add
c0228c5c: e3c5203f bic r2, r5, #63 ; 0x3f
raw_spin_lock(&lock->rlock);
c0228c60: e5923004 ldr r3, [r2, #4]
c0228c64: e2833001 add r3, r3, #1
c0228c68: e5823004 str r3, [r2, #4]
return !h->pprev;
c0228c6c: e5943018 ldr r3, [r4, #24]
if (!hlist_nulls_unhashed(n)) {
c0228c70: e3530000 cmp r3, #0
c0228c74: 0a000005 beq c0228c90 <udp_lib_unhash+0xfc>
struct hlist_nulls_node *next = n->next;
c0228c78: e5942014 ldr r2, [r4, #20]
if (!is_a_nulls(next))
c0228c7c: e3120001 tst r2, #1
*pprev = next;
c0228c80: e5832000 str r2, [r3]
next->pprev = pprev;
c0228c84: 05823004 streq r3, [r2, #4]
n->pprev = NULL;
c0228c88: e3a03000 mov r3, #0
c0228c8c: e5843018 str r3, [r4, #24]
return &table->hash2[hash & table->mask];
c0228c90: e008800a and r8, r8, sl
c0228c94: e0898188 add r8, r9, r8, lsl #3
hslot2->count--;
c0228c98: e5983004 ldr r3, [r8, #4]
c0228c9c: e2433001 sub r3, r3, #1
c0228ca0: e5883004 str r3, [r8, #4]
c0228ca4: e3c5303f bic r3, r5, #63 ; 0x3f
raw_spin_unlock(&lock->rlock);
c0228ca8: e5932004 ldr r2, [r3, #4]
c0228cac: e2422001 sub r2, r2, #1
c0228cb0: e5832004 str r2, [r3, #4]
c0228cb4: e5933000 ldr r3, [r3]
c0228cb8: e3130002 tst r3, #2
c0228cbc: 1a000005 bne c0228cd8 <udp_lib_unhash+0x144>
c0228cc0: e3c5503f bic r5, r5, #63 ; 0x3f
raw_spin_unlock_bh(&lock->rlock);
c0228cc4: e5953004 ldr r3, [r5, #4]
c0228cc8: e2433001 sub r3, r3, #1
c0228ccc: e5853004 str r3, [r5, #4]
}
c0228cd0: e8bd47f0 pop {r4, r5, r6, r7, r8, r9, sl, lr}
c0228cd4: eafffffe b 0 <local_bh_enable>
c0228cd4: R_ARM_JUMP24 local_bh_enable
raw_spin_unlock(&lock->rlock);
c0228cd8: ebfffffe bl 0 <preempt_schedule>
c0228cd8: R_ARM_CALL preempt_schedule
c0228cdc: eafffff7 b c0228cc0 <udp_lib_unhash+0x12c>
c0228ce0: e59f000c ldr r0, [pc, #12] ; c0228cf4 <udp_lib_unhash+0x160>
c0228ce4: e3a01f85 mov r1, #532 ; 0x214
c0228ce8: ebfffffe bl 0 <warn_slowpath_null>
c0228ce8: R_ARM_CALL warn_slowpath_null
c0228cec: eaffffc7 b c0228c10 <udp_lib_unhash+0x7c>
...
c0228cf0: R_ARM_ABS32 init_net
c0228cf4: R_ARM_ABS32 .rodata.str1.4
c0228cf8 <__udp_queue_rcv_skb>:
{
c0228cf8: e92d4038 push {r3, r4, r5, lr}
c0228cfc: e1a05000 mov r5, r0
c0228d00: e1a04001 mov r4, r1
rc = sock_queue_rcv_skb(sk, skb);
c0228d04: ebfffffe bl 0 <sock_queue_rcv_skb>
c0228d04: R_ARM_CALL sock_queue_rcv_skb
if (rc < 0) {
c0228d08: e3500000 cmp r0, #0
c0228d0c: ba000001 blt c0228d18 <__udp_queue_rcv_skb+0x20>
return 0;
c0228d10: e3a00000 mov r0, #0
}
c0228d14: e8bd8038 pop {r3, r4, r5, pc}
if (rc == -ENOMEM)
c0228d18: e370000c cmn r0, #12
int is_udplite = IS_UDPLITE(sk);
c0228d1c: e5d531f8 ldrb r3, [r5, #504] ; 0x1f8
if (rc == -ENOMEM)
c0228d20: 0a000013 beq c0228d74 <__udp_queue_rcv_skb+0x7c>
UDP_INC_STATS_BH(sock_net(sk), UDP_MIB_INERRORS, is_udplite);
c0228d24: e3530000 cmp r3, #0
c0228d28: e59f3064 ldr r3, [pc, #100] ; c0228d94 <__udp_queue_rcv_skb+0x9c>
c0228d2c: 0a00000b beq c0228d60 <__udp_queue_rcv_skb+0x68>
c0228d30: e593209c ldr r2, [r3, #156] ; 0x9c
c0228d34: e592300c ldr r3, [r2, #12]
c0228d38: e2833001 add r3, r3, #1
c0228d3c: e582300c str r3, [r2, #12]
kfree_skb(skb);
c0228d40: e1a00004 mov r0, r4
c0228d44: ebfffffe bl 0 <kfree_skb>
c0228d44: R_ARM_CALL kfree_skb
return -1;
c0228d48: e3e00000 mvn r0, #0
c0228d4c: e8bd8038 pop {r3, r4, r5, pc}
UDP_INC_STATS_BH(sock_net(sk), UDP_MIB_RCVBUFERRORS,
c0228d50: e5931098 ldr r1, [r3, #152] ; 0x98
c0228d54: e5912014 ldr r2, [r1, #20]
c0228d58: e2822001 add r2, r2, #1
c0228d5c: e5812014 str r2, [r1, #20]
UDP_INC_STATS_BH(sock_net(sk), UDP_MIB_INERRORS, is_udplite);
c0228d60: e5932098 ldr r2, [r3, #152] ; 0x98
c0228d64: e592300c ldr r3, [r2, #12]
c0228d68: e2833001 add r3, r3, #1
c0228d6c: e582300c str r3, [r2, #12]
c0228d70: eafffff2 b c0228d40 <__udp_queue_rcv_skb+0x48>
UDP_INC_STATS_BH(sock_net(sk), UDP_MIB_RCVBUFERRORS,
c0228d74: e3530000 cmp r3, #0
c0228d78: e59f3014 ldr r3, [pc, #20] ; c0228d94 <__udp_queue_rcv_skb+0x9c>
c0228d7c: 0afffff3 beq c0228d50 <__udp_queue_rcv_skb+0x58>
c0228d80: e593109c ldr r1, [r3, #156] ; 0x9c
c0228d84: e5912014 ldr r2, [r1, #20]
c0228d88: e2822001 add r2, r2, #1
c0228d8c: e5812014 str r2, [r1, #20]
c0228d90: eaffffe6 b c0228d30 <__udp_queue_rcv_skb+0x38>
c0228d94: 00000000 .word 0x00000000
c0228d94: R_ARM_ABS32 init_net
c0228d98 <udp_lib_getsockopt>:
{
c0228d98: e92d4070 push {r4, r5, r6, lr}
c0228d9c: e24dd008 sub sp, sp, #8
c0228da0: e1a0100d mov r1, sp
c0228da4: e3c1cd7f bic ip, r1, #8128 ; 0x1fc0
c0228da8: e3cc103f bic r1, ip, #63 ; 0x3f
if (get_user(len, optlen))
c0228dac: e5911008 ldr r1, [r1, #8]
{
c0228db0: e1a06000 mov r6, r0
c0228db4: e1a05002 mov r5, r2
if (get_user(len, optlen))
c0228db8: e2411001 sub r1, r1, #1
c0228dbc: e59d0018 ldr r0, [sp, #24]
c0228dc0: ebfffffe bl 0 <__get_user_4>
c0228dc0: R_ARM_CALL __get_user_4
c0228dc4: e3500000 cmp r0, #0
c0228dc8: 1a000035 bne c0228ea4 <udp_lib_getsockopt+0x10c>
len = min_t(unsigned int, len, sizeof(int));
c0228dcc: e3520004 cmp r2, #4
c0228dd0: 31a04002 movcc r4, r2
c0228dd4: 23a04004 movcs r4, #4
switch (optname) {
c0228dd8: e355000a cmp r5, #10
c0228ddc: 0a00002c beq c0228e94 <udp_lib_getsockopt+0xfc>
c0228de0: da000007 ble c0228e04 <udp_lib_getsockopt+0x6c>
c0228de4: e355000b cmp r5, #11
c0228de8: 0a000025 beq c0228e84 <udp_lib_getsockopt+0xec>
c0228dec: e3550064 cmp r5, #100 ; 0x64
c0228df0: 1a00001a bne c0228e60 <udp_lib_getsockopt+0xc8>
val = up->encap_type;
c0228df4: e2866e1f add r6, r6, #496 ; 0x1f0
c0228df8: e1d620b0 ldrh r2, [r6]
c0228dfc: e58d2004 str r2, [sp, #4]
break;
c0228e00: ea000003 b c0228e14 <udp_lib_getsockopt+0x7c>
switch (optname) {
c0228e04: e3550001 cmp r5, #1
c0228e08: 1a000014 bne c0228e60 <udp_lib_getsockopt+0xc8>
val = up->corkflag;
c0228e0c: e59621ec ldr r2, [r6, #492] ; 0x1ec
c0228e10: e58d2004 str r2, [sp, #4]
c0228e14: e3ccc03f bic ip, ip, #63 ; 0x3f
if (put_user(len, optlen))
c0228e18: e59c5008 ldr r5, [ip, #8]
c0228e1c: e1a02004 mov r2, r4
c0228e20: e2451001 sub r1, r5, #1
c0228e24: e59d0018 ldr r0, [sp, #24]
c0228e28: ebfffffe bl 0 <__put_user_4>
c0228e28: R_ARM_CALL __put_user_4
c0228e2c: e2506000 subs r6, r0, #0
c0228e30: 1a00001b bne c0228ea4 <udp_lib_getsockopt+0x10c>
return n;
}
static inline unsigned long __must_check copy_to_user(void __user *to, const void *from, unsigned long n)
{
if (access_ok(VERIFY_WRITE, to, n))
c0228e34: e1a01005 mov r1, r5
c0228e38: e0930004 adds r0, r3, r4
c0228e3c: 30d00001 sbcscc r0, r0, r1
c0228e40: 33a01000 movcc r1, #0
c0228e44: e3510000 cmp r1, #0
c0228e48: 0a000008 beq c0228e70 <udp_lib_getsockopt+0xd8>
if (copy_to_user(optval, &val, len))
c0228e4c: e3540000 cmp r4, #0
c0228e50: 1a000013 bne c0228ea4 <udp_lib_getsockopt+0x10c>
}
c0228e54: e1a00006 mov r0, r6
c0228e58: e28dd008 add sp, sp, #8
c0228e5c: e8bd8070 pop {r4, r5, r6, pc}
return -ENOPROTOOPT;
c0228e60: e3e0605b mvn r6, #91 ; 0x5b
}
c0228e64: e1a00006 mov r0, r6
c0228e68: e28dd008 add sp, sp, #8
c0228e6c: e8bd8070 pop {r4, r5, r6, pc}
c0228e70: e1a00003 mov r0, r3
n = __copy_to_user(to, from, n);
c0228e74: e28d1004 add r1, sp, #4
c0228e78: ebfffffe bl 0 <__copy_to_user>
c0228e78: R_ARM_CALL __copy_to_user
c0228e7c: e1a04000 mov r4, r0
c0228e80: eafffff1 b c0228e4c <udp_lib_getsockopt+0xb4>
val = up->pcrlen;
c0228e84: e2866f7d add r6, r6, #500 ; 0x1f4
c0228e88: e1d620b2 ldrh r2, [r6, #2]
c0228e8c: e58d2004 str r2, [sp, #4]
break;
c0228e90: eaffffdf b c0228e14 <udp_lib_getsockopt+0x7c>
val = up->pcslen;
c0228e94: e2866f7d add r6, r6, #500 ; 0x1f4
c0228e98: e1d620b0 ldrh r2, [r6]
c0228e9c: e58d2004 str r2, [sp, #4]
break;
c0228ea0: eaffffdb b c0228e14 <udp_lib_getsockopt+0x7c>
return -EFAULT;
c0228ea4: e3e0600d mvn r6, #13
c0228ea8: eaffffe9 b c0228e54 <udp_lib_getsockopt+0xbc>
c0228eac <udp_getsockopt>:
if (level == SOL_UDP || level == SOL_UDPLITE)
c0228eac: e3510011 cmp r1, #17
c0228eb0: 13510088 cmpne r1, #136 ; 0x88
{
c0228eb4: e59dc000 ldr ip, [sp]
if (level == SOL_UDP || level == SOL_UDPLITE)
c0228eb8: 0a000001 beq c0228ec4 <udp_getsockopt+0x18>
return ip_getsockopt(sk, level, optname, optval, optlen);
c0228ebc: e58dc000 str ip, [sp]
c0228ec0: eafffffe b 0 <ip_getsockopt>
c0228ec0: R_ARM_JUMP24 ip_getsockopt
return udp_lib_getsockopt(sk, level, optname, optval, optlen);
c0228ec4: eafffffe b c0228d98 <udp_lib_getsockopt>
c0228ec4: R_ARM_JUMP24 udp_lib_getsockopt
c0228ec8 <udp_poll>:
{
c0228ec8: e92d4070 push {r4, r5, r6, lr}
c0228ecc: e1a05001 mov r5, r1
c0228ed0: e1a06000 mov r6, r0
unsigned int mask = datagram_poll(file, sock, wait);
c0228ed4: ebfffffe bl 0 <datagram_poll>
c0228ed4: R_ARM_CALL datagram_poll
if ((mask & POLLRDNORM) && !(file->f_flags & O_NONBLOCK) &&
c0228ed8: e3100040 tst r0, #64 ; 0x40
unsigned int mask = datagram_poll(file, sock, wait);
c0228edc: e1a04000 mov r4, r0
struct sock *sk = sock->sk;
c0228ee0: e5950014 ldr r0, [r5, #20]
if ((mask & POLLRDNORM) && !(file->f_flags & O_NONBLOCK) &&
c0228ee4: 0a000005 beq c0228f00 <udp_poll+0x38>
c0228ee8: e5963018 ldr r3, [r6, #24]
c0228eec: e3130b02 tst r3, #2048 ; 0x800
c0228ef0: 1a000002 bne c0228f00 <udp_poll+0x38>
!(sk->sk_shutdown & RCV_SHUTDOWN) && !first_packet_length(sk))
c0228ef4: e5d0308c ldrb r3, [r0, #140] ; 0x8c
if ((mask & POLLRDNORM) && !(file->f_flags & O_NONBLOCK) &&
c0228ef8: e3130001 tst r3, #1
c0228efc: 0a000001 beq c0228f08 <udp_poll+0x40>
}
c0228f00: e1a00004 mov r0, r4
c0228f04: e8bd8070 pop {r4, r5, r6, pc}
!(sk->sk_shutdown & RCV_SHUTDOWN) && !first_packet_length(sk))
c0228f08: ebfffdcf bl c022864c <first_packet_length>
c0228f0c: e3500000 cmp r0, #0
mask &= ~(POLLIN | POLLRDNORM);
c0228f10: 03c44041 biceq r4, r4, #65 ; 0x41
}
c0228f14: e1a00004 mov r0, r4
c0228f18: e8bd8070 pop {r4, r5, r6, pc}
c0228f1c <udp_seq_open>:
if (state->bucket <= state->udp_table->mask)
spin_unlock_bh(&state->udp_table->hash[state->bucket].lock);
}
int udp_seq_open(struct inode *inode, struct file *file)
{
c0228f1c: e92d4038 push {r3, r4, r5, lr}
struct udp_seq_afinfo *afinfo = PDE(inode)->data;
c0228f20: e5102014 ldr r2, [r0, #-20] ; 0xffffffec
struct udp_iter_state *s;
int err;
err = seq_open_net(inode, file, &afinfo->seq_ops,
c0228f24: e3a0300c mov r3, #12
struct udp_seq_afinfo *afinfo = PDE(inode)->data;
c0228f28: e592402c ldr r4, [r2, #44] ; 0x2c
{
c0228f2c: e1a05001 mov r5, r1
err = seq_open_net(inode, file, &afinfo->seq_ops,
c0228f30: e2842010 add r2, r4, #16
c0228f34: ebfffffe bl 0 <seq_open_net>
c0228f34: R_ARM_CALL seq_open_net
sizeof(struct udp_iter_state));
if (err < 0)
c0228f38: e3500000 cmp r0, #0
c0228f3c: b8bd8038 poplt {r3, r4, r5, pc}
return err;
s = ((struct seq_file *)file->private_data)->private;
c0228f40: e5953068 ldr r3, [r5, #104] ; 0x68
s->family = afinfo->family;
c0228f44: e1d420b4 ldrh r2, [r4, #4]
s = ((struct seq_file *)file->private_data)->private;
c0228f48: e593303c ldr r3, [r3, #60] ; 0x3c
s->family = afinfo->family;
c0228f4c: e1c320b0 strh r2, [r3]
s->udp_table = afinfo->udp_table;
c0228f50: e5942008 ldr r2, [r4, #8]
c0228f54: e5832008 str r2, [r3, #8]
return err;
}
c0228f58: e8bd8038 pop {r3, r4, r5, pc}
c0228f5c <udp_proc_register>:
EXPORT_SYMBOL(udp_seq_open);
/* ------------------------------------------------------------------------ */
int udp_proc_register(struct net *net, struct udp_seq_afinfo *afinfo)
{
c0228f5c: e52de004 push {lr} ; (str lr, [sp, #-4]!)
struct proc_dir_entry *p;
int rc = 0;
afinfo->seq_ops.start = udp_seq_start;
c0228f60: e59fc040 ldr ip, [pc, #64] ; c0228fa8 <udp_proc_register+0x4c>
afinfo->seq_ops.next = udp_seq_next;
c0228f64: e59f2040 ldr r2, [pc, #64] ; c0228fac <udp_proc_register+0x50>
afinfo->seq_ops.stop = udp_seq_stop;
c0228f68: e59f3040 ldr r3, [pc, #64] ; c0228fb0 <udp_proc_register+0x54>
afinfo->seq_ops.start = udp_seq_start;
c0228f6c: e581c010 str ip, [r1, #16]
afinfo->seq_ops.stop = udp_seq_stop;
c0228f70: e5813014 str r3, [r1, #20]
afinfo->seq_ops.next = udp_seq_next;
c0228f74: e5812018 str r2, [r1, #24]
{
c0228f78: e24dd00c sub sp, sp, #12
p = proc_create_data(afinfo->name, S_IRUGO, net->proc_net,
c0228f7c: e5902020 ldr r2, [r0, #32]
c0228f80: e591300c ldr r3, [r1, #12]
c0228f84: e5910000 ldr r0, [r1]
c0228f88: e58d1000 str r1, [sp]
c0228f8c: e3a01f49 mov r1, #292 ; 0x124
c0228f90: ebfffffe bl 0 <proc_create_data>
c0228f90: R_ARM_CALL proc_create_data
afinfo->seq_fops, afinfo);
if (!p)
c0228f94: e3500000 cmp r0, #0
rc = -ENOMEM;
return rc;
}
c0228f98: 03e0000b mvneq r0, #11
c0228f9c: 13a00000 movne r0, #0
c0228fa0: e28dd00c add sp, sp, #12
c0228fa4: e49df004 pop {pc} ; (ldr pc, [sp], #4)
...
c0228fa8: R_ARM_ABS32 udp_seq_start
c0228fac: R_ARM_ABS32 udp_seq_next
c0228fb0: R_ARM_ABS32 udp_seq_stop
c0228fb4 <udp_proc_unregister>:
EXPORT_SYMBOL(udp_proc_register);
void udp_proc_unregister(struct net *net, struct udp_seq_afinfo *afinfo)
{
proc_net_remove(net, afinfo->name);
c0228fb4: e5911000 ldr r1, [r1]
c0228fb8: eafffffe b 0 <proc_net_remove>
c0228fb8: R_ARM_JUMP24 proc_net_remove
c0228fbc <udp_seq_stop>:
struct udp_iter_state *state = seq->private;
c0228fbc: e590303c ldr r3, [r0, #60] ; 0x3c
if (state->bucket <= state->udp_table->mask)
c0228fc0: e5931008 ldr r1, [r3, #8]
c0228fc4: e5932004 ldr r2, [r3, #4]
c0228fc8: e5913008 ldr r3, [r1, #8]
c0228fcc: e1520003 cmp r2, r3
c0228fd0: 812fff1e bxhi lr
c0228fd4: e1a0300d mov r3, sp
c0228fd8: e3c33d7f bic r3, r3, #8128 ; 0x1fc0
c0228fdc: e3c3303f bic r3, r3, #63 ; 0x3f
raw_spin_unlock_bh(&lock->rlock);
c0228fe0: e5932004 ldr r2, [r3, #4]
c0228fe4: e2422001 sub r2, r2, #1
c0228fe8: e5832004 str r2, [r3, #4]
c0228fec: eafffffe b 0 <local_bh_enable>
c0228fec: R_ARM_JUMP24 local_bh_enable
c0228ff0 <udp_sendmsg>:
struct rtable *rt = NULL;
c0228ff0: e3a00000 mov r0, #0
{
c0228ff4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
int corkreq = up->corkflag || msg->msg_flags&MSG_MORE;
c0228ff8: e591c1ec ldr ip, [r1, #492] ; 0x1ec
{
c0228ffc: e24dd0b4 sub sp, sp, #180 ; 0xb4
int corkreq = up->corkflag || msg->msg_flags&MSG_MORE;
c0229000: e15c0000 cmp ip, r0
struct rtable *rt = NULL;
c0229004: e58d003c str r0, [sp, #60] ; 0x3c
int corkreq = up->corkflag || msg->msg_flags&MSG_MORE;
c0229008: 13a00001 movne r0, #1
c022900c: 05928018 ldreq r8, [r2, #24]
int err, is_udplite = IS_UDPLITE(sk);
c0229010: e5d191f8 ldrb r9, [r1, #504] ; 0x1f8
int corkreq = up->corkflag || msg->msg_flags&MSG_MORE;
c0229014: 01a087a8 lsreq r8, r8, #15
c0229018: 02080001 andeq r0, r8, #1
if (len > 0xFFFF)
c022901c: e3530801 cmp r3, #65536 ; 0x10000
int corkreq = up->corkflag || msg->msg_flags&MSG_MORE;
c0229020: e58d0018 str r0, [sp, #24]
if (len > 0xFFFF)
c0229024: 2a00018e bcs c0229664 <udp_sendmsg+0x674>
if (msg->msg_flags & MSG_OOB) /* Mirror BSD error message compatibility */
c0229028: e592a018 ldr sl, [r2, #24]
c022902c: e21aa001 ands sl, sl, #1
c0229030: 1a00018d bne c022966c <udp_sendmsg+0x67c>
c0229034: e1a04001 mov r4, r1
c0229038: e1a05002 mov r5, r2
getfrag = is_udplite ? udplite_getfrag : ip_generic_getfrag;
c022903c: e59f2724 ldr r2, [pc, #1828] ; c0229768 <udp_sendmsg+0x778>
c0229040: e3590000 cmp r9, #0
c0229044: e59f1720 ldr r1, [pc, #1824] ; c022976c <udp_sendmsg+0x77c>
c0229048: 01a01002 moveq r1, r2
c022904c: e1a07003 mov r7, r3
if (up->pending) {
c0229050: e59431e8 ldr r3, [r4, #488] ; 0x1e8
getfrag = is_udplite ? udplite_getfrag : ip_generic_getfrag;
c0229054: e58d101c str r1, [sp, #28]
if (up->pending) {
c0229058: e3530000 cmp r3, #0
ipc.opt = NULL;
c022905c: e58da048 str sl, [sp, #72] ; 0x48
ipc.tx_flags = 0;
c0229060: e5cda04c strb sl, [sp, #76] ; 0x4c
fl4 = &inet->cork.fl.u.ip4;
c0229064: e284bf6a add fp, r4, #424 ; 0x1a8
if (up->pending) {
c0229068: 1a0000a2 bne c02292f8 <udp_sendmsg+0x308>
if (msg->msg_name) {
c022906c: e5953000 ldr r3, [r5]
c0229070: e3530000 cmp r3, #0
c0229074: 0a00010b beq c02294a8 <udp_sendmsg+0x4b8>
if (msg->msg_namelen < sizeof(*usin))
c0229078: e5952004 ldr r2, [r5, #4]
c022907c: e352000f cmp r2, #15
c0229080: 9a000124 bls c0229518 <udp_sendmsg+0x528>
if (usin->sin_family != AF_UNSPEC)
c0229084: e1d360b0 ldrh r6, [r3]
c0229088: e3c66002 bic r6, r6, #2
c022908c: e3560000 cmp r6, #0
c0229090: 1a00017e bne c0229690 <udp_sendmsg+0x6a0>
dport = usin->sin_port;
c0229094: e1d320b2 ldrh r2, [r3, #2]
daddr = usin->sin_addr.s_addr;
c0229098: e593a004 ldr sl, [r3, #4]
if (dport == 0)
c022909c: e3520000 cmp r2, #0
dport = usin->sin_port;
c02290a0: e58d2028 str r2, [sp, #40] ; 0x28
if (dport == 0)
c02290a4: 0a00011b beq c0229518 <udp_sendmsg+0x528>
ipc.oif = sk->sk_bound_dev_if;
c02290a8: e5943010 ldr r3, [r4, #16]
ipc.addr = inet->inet_saddr;
c02290ac: e594215c ldr r2, [r4, #348] ; 0x15c
err = sock_tx_timestamp(sk, &ipc.tx_flags);
c02290b0: e1a00004 mov r0, r4
c02290b4: e28d104c add r1, sp, #76 ; 0x4c
ipc.oif = sk->sk_bound_dev_if;
c02290b8: e58d3044 str r3, [sp, #68] ; 0x44
ipc.addr = inet->inet_saddr;
c02290bc: e58d2040 str r2, [sp, #64] ; 0x40
err = sock_tx_timestamp(sk, &ipc.tx_flags);
c02290c0: ebfffffe bl 0 <sock_tx_timestamp>
c02290c0: R_ARM_CALL sock_tx_timestamp
c02290c4: e28d3040 add r3, sp, #64 ; 0x40
if (err)
c02290c8: e2508000 subs r8, r0, #0
err = sock_tx_timestamp(sk, &ipc.tx_flags);
c02290cc: e58d3020 str r3, [sp, #32]
if (err)
c02290d0: 1a000085 bne c02292ec <udp_sendmsg+0x2fc>
if (msg->msg_controllen) {
c02290d4: e5952014 ldr r2, [r5, #20]
c02290d8: e3520000 cmp r2, #0
c02290dc: 1a0000e5 bne c0229478 <udp_sendmsg+0x488>
c02290e0: e59d1048 ldr r1, [sp, #72] ; 0x48
int free = 0;
c02290e4: e58d8024 str r8, [sp, #36] ; 0x24
if (!ipc.opt) {
c02290e8: e3510000 cmp r1, #0
saddr = ipc.addr;
c02290ec: 159d3040 ldrne r3, [sp, #64] ; 0x40
ipc.addr = faddr = daddr;
c02290f0: 158da040 strne sl, [sp, #64] ; 0x40
if (!ipc.opt) {
c02290f4: 0a000167 beq c0229698 <udp_sendmsg+0x6a8>
if (ipc.opt && ipc.opt->opt.srr) {
c02290f8: e5d12011 ldrb r2, [r1, #17]
c02290fc: e3520000 cmp r2, #0
c0229100: 1a0000a0 bne c0229388 <udp_sendmsg+0x398>
c0229104: e58da02c str sl, [sp, #44] ; 0x2c
c0229108: e594006c ldr r0, [r4, #108] ; 0x6c
tos = RT_TOS(inet->tos);
c022910c: e5d4216c ldrb r2, [r4, #364] ; 0x16c
if (sock_flag(sk, SOCK_LOCALROUTE) ||
c0229110: e3100a02 tst r0, #8192 ; 0x2000
tos = RT_TOS(inet->tos);
c0229114: e202201e and r2, r2, #30
if (sock_flag(sk, SOCK_LOCALROUTE) ||
c0229118: 1a0000a0 bne c02293a0 <udp_sendmsg+0x3b0>
(msg->msg_flags & MSG_DONTROUTE) ||
c022911c: e5950018 ldr r0, [r5, #24]
if (sock_flag(sk, SOCK_LOCALROUTE) ||
c0229120: e3100004 tst r0, #4
c0229124: 1a00009d bne c02293a0 <udp_sendmsg+0x3b0>
(msg->msg_flags & MSG_DONTROUTE) ||
c0229128: e3510000 cmp r1, #0
c022912c: 0a000002 beq c022913c <udp_sendmsg+0x14c>
(ipc.opt && ipc.opt->opt.is_strictroute)) {
c0229130: e5d11014 ldrb r1, [r1, #20]
c0229134: e3110001 tst r1, #1
c0229138: 1a000098 bne c02293a0 <udp_sendmsg+0x3b0>
return (addr & htonl(0xff000000)) == htonl(0x7f000000);
}
static inline bool ipv4_is_multicast(__be32 addr)
{
return (addr & htonl(0xf0000000)) == htonl(0xe0000000);
c022913c: e20a10f0 and r1, sl, #240 ; 0xf0
if (ipv4_is_multicast(daddr)) {
c0229140: e35100e0 cmp r1, #224 ; 0xe0
if (!ipc.oif)
c0229144: e59d1044 ldr r1, [sp, #68] ; 0x44
if (ipv4_is_multicast(daddr)) {
c0229148: 0a0000ea beq c02294f8 <udp_sendmsg+0x508>
} else if (!ipc.oif)
c022914c: e3510000 cmp r1, #0
ipc.oif = inet->uc_index;
c0229150: 05941174 ldreq r1, [r4, #372] ; 0x174
c0229154: 058d1044 streq r1, [sp, #68] ; 0x44
if (connected)
c0229158: e3560000 cmp r6, #0
c022915c: 1a0000da bne c02294cc <udp_sendmsg+0x4dc>
c0229160: e59d103c ldr r1, [sp, #60] ; 0x3c
if (rt == NULL) {
c0229164: e3510000 cmp r1, #0
fl4 = &inet->cork.fl.u.ip4;
c0229168: 11a0600b movne r6, fp
if (rt == NULL) {
c022916c: 0a0000f0 beq c0229534 <udp_sendmsg+0x544>
if (msg->msg_flags&MSG_CONFIRM)
c0229170: e5952018 ldr r2, [r5, #24]
c0229174: e3120b02 tst r2, #2048 ; 0x800
c0229178: 0a00008b beq c02293ac <udp_sendmsg+0x3bc>
dst_confirm(&rt->dst);
c022917c: e59d103c ldr r1, [sp, #60] ; 0x3c
dst_free(dst);
}
static inline void dst_confirm(struct dst_entry *dst)
{
if (dst) {
c0229180: e3510000 cmp r1, #0
c0229184: e58d102c str r1, [sp, #44] ; 0x2c
c0229188: 0a000008 beq c02291b0 <udp_sendmsg+0x1c0>
* block, but only when acquiring spinlocks that are subject to priority
* inheritance.
*/
static inline void rcu_read_lock(void)
{
__rcu_read_lock();
c022918c: ebfffffe bl 0 <__rcu_read_lock>
c022918c: R_ARM_CALL __rcu_read_lock
return rcu_dereference(dst->_neighbour);
c0229190: e59d102c ldr r1, [sp, #44] ; 0x2c
c0229194: e5912020 ldr r2, [r1, #32]
#define neigh_hold(n) atomic_inc(&(n)->refcnt)
static inline void neigh_confirm(struct neighbour *neigh)
{
if (neigh)
c0229198: e3520000 cmp r2, #0
neigh->confirmed = jiffies;
c022919c: 159f15cc ldrne r1, [pc, #1484] ; c0229770 <udp_sendmsg+0x780>
c02291a0: 15911000 ldrne r1, [r1]
c02291a4: 1582100c strne r1, [r2, #12]
{
rcu_lockdep_assert(!rcu_is_cpu_idle(),
"rcu_read_unlock() used illegally while idle");
rcu_lock_release(&rcu_lock_map);
__release(RCU);
__rcu_read_unlock();
c02291a8: ebfffffe bl 0 <__rcu_read_unlock>
c02291a8: R_ARM_CALL __rcu_read_unlock
c02291ac: e5952018 ldr r2, [r5, #24]
if (!(msg->msg_flags&MSG_PROBE) || len)
c02291b0: e1a01222 lsr r1, r2, #4
c02291b4: e2211001 eor r1, r1, #1
c02291b8: e3570000 cmp r7, #0
c02291bc: 13811001 orrne r1, r1, #1
c02291c0: e3110001 tst r1, #1
c02291c4: 1a000078 bne c02293ac <udp_sendmsg+0x3bc>
c02291c8: e59d003c ldr r0, [sp, #60] ; 0x3c
c02291cc: ea00002c b c0229284 <udp_sendmsg+0x294>
lock_sock_nested(sk, 0);
c02291d0: e1a00004 mov r0, r4
c02291d4: e3a01000 mov r1, #0
c02291d8: e58d3018 str r3, [sp, #24]
c02291dc: ebfffffe bl 0 <lock_sock_nested>
c02291dc: R_ARM_CALL lock_sock_nested
if (unlikely(up->pending)) {
c02291e0: e59421e8 ldr r2, [r4, #488] ; 0x1e8
c02291e4: e59d3018 ldr r3, [sp, #24]
c02291e8: e3520000 cmp r2, #0
c02291ec: 1a00013a bne c02296dc <udp_sendmsg+0x6ec>
up->pending = AF_INET;
c02291f0: e3a02002 mov r2, #2
fl4->fl4_dport = dport;
c02291f4: e1dd12b8 ldrh r1, [sp, #40] ; 0x28
fl4->saddr = saddr;
c02291f8: e58431bc str r3, [r4, #444] ; 0x1bc
fl4->daddr = daddr;
c02291fc: e584a1c0 str sl, [r4, #448] ; 0x1c0
fl4->fl4_sport = inet->inet_sport;
c0229200: e2843f59 add r3, r4, #356 ; 0x164
fl4->fl4_dport = dport;
c0229204: e1cb11bc strh r1, [fp, #28]
fl4->fl4_sport = inet->inet_sport;
c0229208: e1d330b0 ldrh r3, [r3]
up->len += ulen;
c022920c: e2846e1f add r6, r4, #496 ; 0x1f0
fl4->fl4_sport = inet->inet_sport;
c0229210: e1cb31be strh r3, [fp, #30]
up->pending = AF_INET;
c0229214: e58421e8 str r2, [r4, #488] ; 0x1e8
up->len += ulen;
c0229218: e1d630b2 ldrh r3, [r6, #2]
c022921c: e0883003 add r3, r8, r3
c0229220: e1c630b2 strh r3, [r6, #2]
err = ip_append_data(sk, fl4, getfrag, msg->msg_iov, ulen,
c0229224: e5953008 ldr r3, [r5, #8]
c0229228: e3a00008 mov r0, #8
c022922c: e5952018 ldr r2, [r5, #24]
c0229230: e28dc03c add ip, sp, #60 ; 0x3c
c0229234: e3822902 orr r2, r2, #32768 ; 0x8000
c0229238: e58d2010 str r2, [sp, #16]
c022923c: e59d2020 ldr r2, [sp, #32]
c0229240: e58d8000 str r8, [sp]
c0229244: e58d2008 str r2, [sp, #8]
c0229248: e58d0004 str r0, [sp, #4]
c022924c: e1a0100b mov r1, fp
c0229250: e59d201c ldr r2, [sp, #28]
c0229254: e58dc00c str ip, [sp, #12]
c0229258: e1a00004 mov r0, r4
c022925c: ebfffffe bl 0 <ip_append_data>
c022925c: R_ARM_CALL ip_append_data
if (err)
c0229260: e2508000 subs r8, r0, #0
c0229264: 1a000074 bne c022943c <udp_sendmsg+0x44c>
else if (unlikely(skb_queue_empty(&sk->sk_write_queue)))
c0229268: e5941080 ldr r1, [r4, #128] ; 0x80
c022926c: e2842080 add r2, r4, #128 ; 0x80
c0229270: e1510002 cmp r1, r2
up->pending = 0;
c0229274: 058481e8 streq r8, [r4, #488] ; 0x1e8
release_sock(sk);
c0229278: e1a00004 mov r0, r4
c022927c: ebfffffe bl 0 <release_sock>
c022927c: R_ARM_CALL release_sock
c0229280: e59d003c ldr r0, [sp, #60] ; 0x3c
extern void fib_add_ifaddr(struct in_ifaddr *);
extern void fib_del_ifaddr(struct in_ifaddr *, struct in_ifaddr *);
static inline void ip_rt_put(struct rtable * rt)
{
if (rt)
c0229284: e3500000 cmp r0, #0
c0229288: 0a000000 beq c0229290 <udp_sendmsg+0x2a0>
dst_release(&rt->dst);
c022928c: ebfffffe bl 0 <dst_release>
c022928c: R_ARM_CALL dst_release
if (free)
c0229290: e59d3024 ldr r3, [sp, #36] ; 0x24
c0229294: e3530000 cmp r3, #0
c0229298: 1a000062 bne c0229428 <udp_sendmsg+0x438>
if (!err)
c022929c: e3580000 cmp r8, #0
return len;
c02292a0: 01a00007 moveq r0, r7
if (!err)
c02292a4: 0a000011 beq c02292f0 <udp_sendmsg+0x300>
if (err == -ENOBUFS || test_bit(SOCK_NOSPACE, &sk->sk_socket->flags)) {
c02292a8: e3780069 cmn r8, #105 ; 0x69
c02292ac: 0a000003 beq c02292c0 <udp_sendmsg+0x2d0>
c02292b0: e5942118 ldr r2, [r4, #280] ; 0x118
c02292b4: e5922008 ldr r2, [r2, #8]
c02292b8: e3120004 tst r2, #4
c02292bc: 0a00000a beq c02292ec <udp_sendmsg+0x2fc>
UDP_INC_STATS_USER(sock_net(sk),
c02292c0: e3590000 cmp r9, #0
c02292c4: 0a000065 beq c0229460 <udp_sendmsg+0x470>
asm volatile(
c02292c8: e10f0000 mrs r0, CPSR
c02292cc: e3802080 orr r2, r0, #128 ; 0x80
c02292d0: e121f002 msr CPSR_c, r2
c02292d4: e59f2498 ldr r2, [pc, #1176] ; c0229774 <udp_sendmsg+0x784>
c02292d8: e592109c ldr r1, [r2, #156] ; 0x9c
c02292dc: e5912018 ldr r2, [r1, #24]
c02292e0: e2822001 add r2, r2, #1
c02292e4: e5812018 str r2, [r1, #24]
asm volatile(
c02292e8: e121f000 msr CPSR_c, r0
c02292ec: e1a00008 mov r0, r8
}
c02292f0: e28dd0b4 add sp, sp, #180 ; 0xb4
c02292f4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
c02292f8: e1a00004 mov r0, r4
c02292fc: e1a0100a mov r1, sl
c0229300: ebfffffe bl 0 <lock_sock_nested>
c0229300: R_ARM_CALL lock_sock_nested
if (likely(up->pending)) {
c0229304: e59431e8 ldr r3, [r4, #488] ; 0x1e8
c0229308: e3530000 cmp r3, #0
c022930c: 0a0000d8 beq c0229674 <udp_sendmsg+0x684>
if (unlikely(up->pending != AF_INET)) {
c0229310: e3530002 cmp r3, #2
c0229314: 1a0000d9 bne c0229680 <udp_sendmsg+0x690>
up->len += ulen;
c0229318: e2846e1f add r6, r4, #496 ; 0x1f0
c022931c: e1d630b2 ldrh r3, [r6, #2]
err = ip_append_data(sk, fl4, getfrag, msg->msg_iov, ulen,
c0229320: e59d2018 ldr r2, [sp, #24]
up->len += ulen;
c0229324: e0873003 add r3, r7, r3
c0229328: e1c630b2 strh r3, [r6, #2]
err = ip_append_data(sk, fl4, getfrag, msg->msg_iov, ulen,
c022932c: e3520000 cmp r2, #0
c0229330: e5953008 ldr r3, [r5, #8]
c0229334: 1a000079 bne c0229520 <udp_sendmsg+0x530>
c0229338: e3a0c008 mov ip, #8
c022933c: e5952018 ldr r2, [r5, #24]
c0229340: e28de040 add lr, sp, #64 ; 0x40
c0229344: e28d003c add r0, sp, #60 ; 0x3c
c0229348: e58d2010 str r2, [sp, #16]
c022934c: e58d000c str r0, [sp, #12]
c0229350: e58d7000 str r7, [sp]
c0229354: e1a0100b mov r1, fp
c0229358: e59d201c ldr r2, [sp, #28]
c022935c: e98d5000 stmib sp, {ip, lr}
c0229360: e1a00004 mov r0, r4
c0229364: ebfffffe bl 0 <ip_append_data>
c0229364: R_ARM_CALL ip_append_data
if (err)
c0229368: e2508000 subs r8, r0, #0
c022936c: 1a000030 bne c0229434 <udp_sendmsg+0x444>
c0229370: e59d3018 ldr r3, [sp, #24]
err = udp_push_pending_frames(sk);
c0229374: e1a00004 mov r0, r4
c0229378: e58d3024 str r3, [sp, #36] ; 0x24
c022937c: ebfffffe bl c02283a8 <udp_push_pending_frames>
c022937c: R_ARM_CALL udp_push_pending_frames
c0229380: e1a08000 mov r8, r0
c0229384: eaffffbb b c0229278 <udp_sendmsg+0x288>
if (!daddr)
c0229388: e35a0000 cmp sl, #0
c022938c: 0a000061 beq c0229518 <udp_sendmsg+0x528>
faddr = ipc.opt->opt.faddr;
c0229390: e5912008 ldr r2, [r1, #8]
connected = 0;
c0229394: e3a06000 mov r6, #0
faddr = ipc.opt->opt.faddr;
c0229398: e58d202c str r2, [sp, #44] ; 0x2c
c022939c: eaffff59 b c0229108 <udp_sendmsg+0x118>
connected = 0;
c02293a0: e3a06000 mov r6, #0
tos |= RTO_ONLINK;
c02293a4: e3822001 orr r2, r2, #1
c02293a8: eaffff63 b c022913c <udp_sendmsg+0x14c>
if (!ipc.addr)
c02293ac: e59d1040 ldr r1, [sp, #64] ; 0x40
saddr = fl4->saddr;
c02293b0: e5963014 ldr r3, [r6, #20]
if (!ipc.addr)
c02293b4: e3510000 cmp r1, #0
daddr = ipc.addr = fl4->daddr;
c02293b8: 0596a018 ldreq sl, [r6, #24]
if (!corkreq) {
c02293bc: e59d1018 ldr r1, [sp, #24]
daddr = ipc.addr = fl4->daddr;
c02293c0: 058da040 streq sl, [sp, #64] ; 0x40
if (!corkreq) {
c02293c4: e3510000 cmp r1, #0
ulen += sizeof(struct udphdr);
c02293c8: e2878008 add r8, r7, #8
if (!corkreq) {
c02293cc: 1affff7f bne c02291d0 <udp_sendmsg+0x1e0>
skb = ip_make_skb(sk, fl4, getfrag, msg->msg_iov, ulen,
c02293d0: e3a00008 mov r0, #8
c02293d4: e59dc020 ldr ip, [sp, #32]
c02293d8: e28d103c add r1, sp, #60 ; 0x3c
c02293dc: e5953008 ldr r3, [r5, #8]
c02293e0: e58d8000 str r8, [sp]
c02293e4: e58d2010 str r2, [sp, #16]
c02293e8: e58d0004 str r0, [sp, #4]
c02293ec: e58d100c str r1, [sp, #12]
c02293f0: e58dc008 str ip, [sp, #8]
c02293f4: e59d201c ldr r2, [sp, #28]
c02293f8: e1a00004 mov r0, r4
c02293fc: e1a01006 mov r1, r6
c0229400: ebfffffe bl 0 <ip_make_skb>
c0229400: R_ARM_CALL ip_make_skb
if (skb && !IS_ERR(skb))
c0229404: e2508000 subs r8, r0, #0
c0229408: 0affff6e beq c02291c8 <udp_sendmsg+0x1d8>
c022940c: e3780a01 cmn r8, #4096 ; 0x1000
c0229410: 8affff6c bhi c02291c8 <udp_sendmsg+0x1d8>
err = udp_send_skb(skb, fl4);
c0229414: e1a01006 mov r1, r6
c0229418: ebfffb11 bl c0228064 <udp_send_skb>
c022941c: e1a08000 mov r8, r0
c0229420: e59d003c ldr r0, [sp, #60] ; 0x3c
c0229424: eaffff96 b c0229284 <udp_sendmsg+0x294>
kfree(ipc.opt);
c0229428: e59d0048 ldr r0, [sp, #72] ; 0x48
c022942c: ebfffffe bl 0 <kfree>
c022942c: R_ARM_CALL kfree
c0229430: eaffff99 b c022929c <udp_sendmsg+0x2ac>
int free = 0;
c0229434: e59d3018 ldr r3, [sp, #24]
c0229438: e58d3024 str r3, [sp, #36] ; 0x24
if (up->pending) {
c022943c: e59421e8 ldr r2, [r4, #488] ; 0x1e8
c0229440: e3520000 cmp r2, #0
c0229444: 0affff8b beq c0229278 <udp_sendmsg+0x288>
up->len = 0;
c0229448: e3a02000 mov r2, #0
ip_flush_pending_frames(sk);
c022944c: e1a00004 mov r0, r4
up->len = 0;
c0229450: e1c620b2 strh r2, [r6, #2]
up->pending = 0;
c0229454: e58421e8 str r2, [r4, #488] ; 0x1e8
ip_flush_pending_frames(sk);
c0229458: ebfffffe bl 0 <ip_flush_pending_frames>
c0229458: R_ARM_CALL ip_flush_pending_frames
c022945c: eaffff85 b c0229278 <udp_sendmsg+0x288>
asm volatile(
c0229460: e10f0000 mrs r0, CPSR
c0229464: e3802080 orr r2, r0, #128 ; 0x80
c0229468: e121f002 msr CPSR_c, r2
UDP_INC_STATS_USER(sock_net(sk),
c022946c: e59f2300 ldr r2, [pc, #768] ; c0229774 <udp_sendmsg+0x784>
c0229470: e5921098 ldr r1, [r2, #152] ; 0x98
c0229474: eaffff98 b c02292dc <udp_sendmsg+0x2ec>
err = ip_cmsg_send(sock_net(sk), msg, &ipc);
c0229478: e59f02f4 ldr r0, [pc, #756] ; c0229774 <udp_sendmsg+0x784>
c022947c: e1a01005 mov r1, r5
c0229480: e59d2020 ldr r2, [sp, #32]
c0229484: ebfffffe bl 0 <ip_cmsg_send>
c0229484: R_ARM_CALL ip_cmsg_send
if (err)
c0229488: e3500000 cmp r0, #0
c022948c: 1affff97 bne c02292f0 <udp_sendmsg+0x300>
if (ipc.opt)
c0229490: e59d1048 ldr r1, [sp, #72] ; 0x48
connected = 0;
c0229494: e1a06008 mov r6, r8
if (ipc.opt)
c0229498: e2913000 adds r3, r1, #0
c022949c: 13a03001 movne r3, #1
c02294a0: e58d3024 str r3, [sp, #36] ; 0x24
c02294a4: eaffff0f b c02290e8 <udp_sendmsg+0xf8>
if (sk->sk_state != TCP_ESTABLISHED)
c02294a8: e5d4600e ldrb r6, [r4, #14]
c02294ac: e20660ff and r6, r6, #255 ; 0xff
c02294b0: e3560001 cmp r6, #1
c02294b4: 1a000091 bne c0229700 <udp_sendmsg+0x710>
daddr = inet->inet_daddr;
c02294b8: e1a03004 mov r3, r4
c02294bc: e493a158 ldr sl, [r3], #344 ; 0x158
dport = inet->inet_dport;
c02294c0: e1d330b0 ldrh r3, [r3]
c02294c4: e58d3028 str r3, [sp, #40] ; 0x28
c02294c8: eafffef6 b c02290a8 <udp_sendmsg+0xb8>
rt = (struct rtable *)sk_dst_check(sk, 0);
c02294cc: e3a01000 mov r1, #0
c02294d0: e1a00004 mov r0, r4
c02294d4: e58d3034 str r3, [sp, #52] ; 0x34
c02294d8: e58d2030 str r2, [sp, #48] ; 0x30
c02294dc: ebfffffe bl 0 <sk_dst_check>
c02294dc: R_ARM_CALL sk_dst_check
c02294e0: e3a06001 mov r6, #1
c02294e4: e1a01000 mov r1, r0
c02294e8: e58d003c str r0, [sp, #60] ; 0x3c
c02294ec: e59d3034 ldr r3, [sp, #52] ; 0x34
c02294f0: e59d2030 ldr r2, [sp, #48] ; 0x30
c02294f4: eaffff1a b c0229164 <udp_sendmsg+0x174>
if (!ipc.oif)
c02294f8: e3510000 cmp r1, #0
ipc.oif = inet->mc_index;
c02294fc: 05941178 ldreq r1, [r4, #376] ; 0x178
c0229500: 058d1044 streq r1, [sp, #68] ; 0x44
if (!saddr)
c0229504: e3530000 cmp r3, #0
saddr = inet->mc_addr;
c0229508: 0594317c ldreq r3, [r4, #380] ; 0x17c
c022950c: e59d103c ldr r1, [sp, #60] ; 0x3c
connected = 0;
c0229510: e3a06000 mov r6, #0
c0229514: eaffff12 b c0229164 <udp_sendmsg+0x174>
return -EINVAL;
c0229518: e3e00015 mvn r0, #21
c022951c: eaffff73 b c02292f0 <udp_sendmsg+0x300>
c0229520: e28d2040 add r2, sp, #64 ; 0x40
int free = 0;
c0229524: e58da024 str sl, [sp, #36] ; 0x24
int ulen = len;
c0229528: e1a08007 mov r8, r7
c022952c: e58d2020 str r2, [sp, #32]
c0229530: eaffff3c b c0229228 <udp_sendmsg+0x238>
fl4->flowi4_scope = scope;
fl4->flowi4_proto = proto;
fl4->flowi4_flags = flags;
fl4->flowi4_secid = 0;
fl4->daddr = daddr;
fl4->saddr = saddr;
c0229534: e58d3064 str r3, [sp, #100] ; 0x64
fl4->fl4_dport = dport;
c0229538: e1dd32b8 ldrh r3, [sp, #40] ; 0x28
c022953c: e5d41170 ldrb r1, [r4, #368] ; 0x170
c0229540: e1cd36bc strh r3, [sp, #108] ; 0x6c
fl4->flowi4_iif = 0;
c0229544: e3a03000 mov r3, #0
static inline __u8 inet_sk_flowi_flags(const struct sock *sk)
{
__u8 flags = 0;
if (inet_sk(sk)->transparent || inet_sk(sk)->hdrincl)
c0229548: e3110028 tst r1, #40 ; 0x28
__u8 flags = 0;
c022954c: 13a01001 movne r1, #1
c0229550: 03a01000 moveq r1, #0
c0229554: e58d3054 str r3, [sp, #84] ; 0x54
fl4->flowi4_scope = scope;
c0229558: e5cd305d strb r3, [sp, #93] ; 0x5d
fl4->flowi4_secid = 0;
c022955c: e3a03000 mov r3, #0
flowi4_init_output(fl4, ipc.oif, sk->sk_mark, tos,
c0229560: e5d4e08d ldrb lr, [r4, #141] ; 0x8d
c0229564: e594c134 ldr ip, [r4, #308] ; 0x134
flags |= FLOWI_FLAG_ANYSRC;
if (sk->sk_protocol == IPPROTO_TCP)
c0229568: e35e0006 cmp lr, #6
flags |= FLOWI_FLAG_PRECOW_METRICS;
c022956c: 03811002 orreq r1, r1, #2
c0229570: 020110ff andeq r1, r1, #255 ; 0xff
c0229574: e58dc030 str ip, [sp, #48] ; 0x30
c0229578: e3811004 orr r1, r1, #4
c022957c: e59d0044 ldr r0, [sp, #68] ; 0x44
fl4->flowi4_flags = flags;
c0229580: e5cd105f strb r1, [sp, #95] ; 0x5f
fl4->flowi4_tos = tos;
c0229584: e5cd205c strb r2, [sp, #92] ; 0x5c
fl4->flowi4_mark = mark;
c0229588: e59d1030 ldr r1, [sp, #48] ; 0x30
fl4->daddr = daddr;
c022958c: e59d202c ldr r2, [sp, #44] ; 0x2c
c0229590: e284cf59 add ip, r4, #356 ; 0x164
c0229594: e1dcc0b0 ldrh ip, [ip]
fl4->flowi4_oif = oif;
c0229598: e58d0050 str r0, [sp, #80] ; 0x50
fl4->flowi4_mark = mark;
c022959c: e58d1058 str r1, [sp, #88] ; 0x58
fl4->daddr = daddr;
c02295a0: e58d2068 str r2, [sp, #104] ; 0x68
rt = ip_route_output_flow(net, fl4, sk);
c02295a4: e59f01c8 ldr r0, [pc, #456] ; c0229774 <udp_sendmsg+0x784>
c02295a8: e28d1050 add r1, sp, #80 ; 0x50
c02295ac: e1a02004 mov r2, r4
fl4->flowi4_proto = proto;
c02295b0: e5cde05e strb lr, [sp, #94] ; 0x5e
fl4->fl4_sport = sport;
c02295b4: e1cdc6be strh ip, [sp, #110] ; 0x6e
fl4->flowi4_secid = 0;
c02295b8: e58d3060 str r3, [sp, #96] ; 0x60
c02295bc: ebfffffe bl 0 <ip_route_output_flow>
c02295bc: R_ARM_CALL ip_route_output_flow
if (IS_ERR(rt)) {
c02295c0: e3700a01 cmn r0, #4096 ; 0x1000
rt = ip_route_output_flow(net, fl4, sk);
c02295c4: e58d003c str r0, [sp, #60] ; 0x3c
if (IS_ERR(rt)) {
c02295c8: 8a00004e bhi c0229708 <udp_sendmsg+0x718>
if ((rt->rt_flags & RTCF_BROADCAST) &&
c02295cc: e590205c ldr r2, [r0, #92] ; 0x5c
c02295d0: e3120201 tst r2, #268435456 ; 0x10000000
c02295d4: 0a000003 beq c02295e8 <udp_sendmsg+0x5f8>
c02295d8: e594206c ldr r2, [r4, #108] ; 0x6c
c02295dc: e3120040 tst r2, #64 ; 0x40
err = -EACCES;
c02295e0: 03e0800c mvneq r8, #12
if ((rt->rt_flags & RTCF_BROADCAST) &&
c02295e4: 0affff26 beq c0229284 <udp_sendmsg+0x294>
if (connected)
c02295e8: e3560000 cmp r6, #0
c02295ec: 0a00001a beq c022965c <udp_sendmsg+0x66c>
if (dst)
c02295f0: e3500000 cmp r0, #0
c02295f4: 0a000006 beq c0229614 <udp_sendmsg+0x624>
c02295f8: e10f1000 mrs r1, CPSR
c02295fc: e3812080 orr r2, r1, #128 ; 0x80
c0229600: e121f002 msr CPSR_c, r2
val = v->counter;
c0229604: e5902040 ldr r2, [r0, #64] ; 0x40
v->counter = val += i;
c0229608: e2822001 add r2, r2, #1
c022960c: e5802040 str r2, [r0, #64] ; 0x40
asm volatile(
c0229610: e121f001 msr CPSR_c, r1
c0229614: e1a0300d mov r3, sp
c0229618: e3c36d7f bic r6, r3, #8128 ; 0x1fc0
c022961c: e3c6603f bic r6, r6, #63 ; 0x3f
raw_spin_lock(&lock->rlock);
c0229620: e5962004 ldr r2, [r6, #4]
c0229624: e2822001 add r2, r2, #1
c0229628: e5862004 str r2, [r6, #4]
sk->sk_tx_queue_mapping = -1;
c022962c: e3e02000 mvn r2, #0
c0229630: e5842028 str r2, [r4, #40] ; 0x28
old_dst = rcu_dereference_raw(sk->sk_dst_cache);
c0229634: e5942070 ldr r2, [r4, #112] ; 0x70
rcu_assign_pointer(sk->sk_dst_cache, dst);
c0229638: e5840070 str r0, [r4, #112] ; 0x70
dst_release(old_dst);
c022963c: e1a00002 mov r0, r2
c0229640: ebfffffe bl 0 <dst_release>
c0229640: R_ARM_CALL dst_release
raw_spin_unlock(&lock->rlock);
c0229644: e5962004 ldr r2, [r6, #4]
c0229648: e2422001 sub r2, r2, #1
c022964c: e5862004 str r2, [r6, #4]
c0229650: e5962000 ldr r2, [r6]
c0229654: e3120002 tst r2, #2
c0229658: 1a000040 bne c0229760 <udp_sendmsg+0x770>
fl4 = &fl4_stack;
c022965c: e28d6050 add r6, sp, #80 ; 0x50
c0229660: eafffec2 b c0229170 <udp_sendmsg+0x180>
return -EMSGSIZE;
c0229664: e3e00059 mvn r0, #89 ; 0x59
c0229668: eaffff20 b c02292f0 <udp_sendmsg+0x300>
return -EOPNOTSUPP;
c022966c: e3e0005e mvn r0, #94 ; 0x5e
c0229670: eaffff1e b c02292f0 <udp_sendmsg+0x300>
release_sock(sk);
c0229674: e1a00004 mov r0, r4
c0229678: ebfffffe bl 0 <release_sock>
c0229678: R_ARM_CALL release_sock
c022967c: eafffe7a b c022906c <udp_sendmsg+0x7c>
release_sock(sk);
c0229680: e1a00004 mov r0, r4
c0229684: ebfffffe bl 0 <release_sock>
c0229684: R_ARM_CALL release_sock
return -EINVAL;
c0229688: e3e00015 mvn r0, #21
c022968c: eaffff17 b c02292f0 <udp_sendmsg+0x300>
return -EAFNOSUPPORT;
c0229690: e3e00060 mvn r0, #96 ; 0x60
c0229694: eaffff15 b c02292f0 <udp_sendmsg+0x300>
__rcu_read_lock();
c0229698: ebfffffe bl 0 <__rcu_read_lock>
c0229698: R_ARM_CALL __rcu_read_lock
inet_opt = rcu_dereference(inet->inet_opt);
c022969c: e5941168 ldr r1, [r4, #360] ; 0x168
if (inet_opt) {
c02296a0: e3510000 cmp r1, #0
c02296a4: 0a000005 beq c02296c0 <udp_sendmsg+0x6d0>
memcpy(&opt_copy, inet_opt,
c02296a8: e5d12010 ldrb r2, [r1, #16]
c02296ac: e28dc070 add ip, sp, #112 ; 0x70
c02296b0: e2822018 add r2, r2, #24
c02296b4: e1a0000c mov r0, ip
c02296b8: ebfffffe bl 0 <memcpy>
c02296b8: R_ARM_CALL memcpy
ipc.opt = &opt_copy.opt;
c02296bc: e58d0048 str r0, [sp, #72] ; 0x48
__rcu_read_unlock();
c02296c0: ebfffffe bl 0 <__rcu_read_unlock>
c02296c0: R_ARM_CALL __rcu_read_unlock
c02296c4: e59d1048 ldr r1, [sp, #72] ; 0x48
saddr = ipc.addr;
c02296c8: e59d3040 ldr r3, [sp, #64] ; 0x40
if (ipc.opt && ipc.opt->opt.srr) {
c02296cc: e3510000 cmp r1, #0
ipc.addr = faddr = daddr;
c02296d0: e58da040 str sl, [sp, #64] ; 0x40
if (ipc.opt && ipc.opt->opt.srr) {
c02296d4: 0afffe8a beq c0229104 <udp_sendmsg+0x114>
c02296d8: eafffe86 b c02290f8 <udp_sendmsg+0x108>
release_sock(sk);
c02296dc: e1a00004 mov r0, r4
c02296e0: ebfffffe bl 0 <release_sock>
c02296e0: R_ARM_CALL release_sock
LIMIT_NETDEBUG(KERN_DEBUG pr_fmt("cork app bug 2\n"));
c02296e4: e59f308c ldr r3, [pc, #140] ; c0229778 <udp_sendmsg+0x788>
c02296e8: e5933000 ldr r3, [r3]
c02296ec: e3530000 cmp r3, #0
c02296f0: 1a000013 bne c0229744 <udp_sendmsg+0x754>
c02296f4: e59d003c ldr r0, [sp, #60] ; 0x3c
err = -EINVAL;
c02296f8: e3e08015 mvn r8, #21
c02296fc: eafffee0 b c0229284 <udp_sendmsg+0x294>
return -EDESTADDRREQ;
c0229700: e3e00058 mvn r0, #88 ; 0x58
c0229704: eafffef9 b c02292f0 <udp_sendmsg+0x300>
rt = NULL;
c0229708: e3a03000 mov r3, #0
if (err == -ENETUNREACH)
c022970c: e3700065 cmn r0, #101 ; 0x65
return (void *) error;
}
static inline long __must_check PTR_ERR(const void *ptr)
{
return (long) ptr;
c0229710: e1a08000 mov r8, r0
rt = NULL;
c0229714: e58d303c str r3, [sp, #60] ; 0x3c
if (err == -ENETUNREACH)
c0229718: 1afffedc bne c0229290 <udp_sendmsg+0x2a0>
IP_INC_STATS(net, IPSTATS_MIB_OUTNOROUTES);
c022971c: ebfffffe bl 0 <local_bh_disable>
c022971c: R_ARM_CALL local_bh_disable
c0229720: e59f304c ldr r3, [pc, #76] ; c0229774 <udp_sendmsg+0x784>
c0229724: e5932090 ldr r2, [r3, #144] ; 0x90
c0229728: e1c206d8 ldrd r0, [r2, #104] ; 0x68
c022972c: e2900001 adds r0, r0, #1
c0229730: e2a11000 adc r1, r1, #0
c0229734: e1c206f8 strd r0, [r2, #104] ; 0x68
c0229738: ebfffffe bl 0 <local_bh_enable>
c0229738: R_ARM_CALL local_bh_enable
c022973c: e59d003c ldr r0, [sp, #60] ; 0x3c
c0229740: eafffecf b c0229284 <udp_sendmsg+0x294>
LIMIT_NETDEBUG(KERN_DEBUG pr_fmt("cork app bug 2\n"));
c0229744: ebfffffe bl 0 <net_ratelimit>
c0229744: R_ARM_CALL net_ratelimit
c0229748: e3500000 cmp r0, #0
c022974c: 0affffe8 beq c02296f4 <udp_sendmsg+0x704>
c0229750: e59f0024 ldr r0, [pc, #36] ; c022977c <udp_sendmsg+0x78c>
c0229754: ebfffffe bl 0 <printk>
c0229754: R_ARM_CALL printk
err = -EINVAL;
c0229758: e3e08015 mvn r8, #21
c022975c: eafffe99 b c02291c8 <udp_sendmsg+0x1d8>
c0229760: ebfffffe bl 0 <preempt_schedule>
c0229760: R_ARM_CALL preempt_schedule
c0229764: eaffffbc b c022965c <udp_sendmsg+0x66c>
...
c0229768: R_ARM_ABS32 ip_generic_getfrag
c022976c: R_ARM_ABS32 udplite_getfrag
c0229770: R_ARM_ABS32 jiffies
c0229774: R_ARM_ABS32 init_net
c0229778: R_ARM_ABS32 net_msg_warn
c022977c: 00000014 .word 0x00000014
c022977c: R_ARM_ABS32 .rodata.str1.4
c0229780 <udp_ioctl>:
switch (cmd) {
c0229780: e59fc07c ldr ip, [pc, #124] ; c0229804 <udp_ioctl+0x84>
{
c0229784: e92d4010 push {r4, lr}
switch (cmd) {
c0229788: e151000c cmp r1, ip
{
c022978c: e1a03002 mov r3, r2
switch (cmd) {
c0229790: 0a000011 beq c02297dc <udp_ioctl+0x5c>
c0229794: e59f206c ldr r2, [pc, #108] ; c0229808 <udp_ioctl+0x88>
c0229798: e1510002 cmp r1, r2
c022979c: 1a00000c bne c02297d4 <udp_ioctl+0x54>
c02297a0: e1a04003 mov r4, r3
unsigned int amount = first_packet_length(sk);
c02297a4: ebfffba8 bl c022864c <first_packet_length>
c02297a8: e1a0300d mov r3, sp
c02297ac: e3c33d7f bic r3, r3, #8128 ; 0x1fc0
c02297b0: e3c3303f bic r3, r3, #63 ; 0x3f
return put_user(amount, (int __user *)arg);
c02297b4: e5931008 ldr r1, [r3, #8]
if (amount)
c02297b8: e3500000 cmp r0, #0
amount -= sizeof(struct udphdr);
c02297bc: 12402008 subne r2, r0, #8
if (amount)
c02297c0: 01a02000 moveq r2, r0
return put_user(amount, (int __user *)arg);
c02297c4: e2411001 sub r1, r1, #1
c02297c8: e1a00004 mov r0, r4
c02297cc: ebfffffe bl 0 <__put_user_4>
c02297cc: R_ARM_CALL __put_user_4
c02297d0: e8bd8010 pop {r4, pc}
return -ENOIOCTLCMD;
c02297d4: e59f0030 ldr r0, [pc, #48] ; c022980c <udp_ioctl+0x8c>
}
c02297d8: e8bd8010 pop {r4, pc}
c02297dc: e1a0100d mov r1, sp
c02297e0: e3c11d7f bic r1, r1, #8128 ; 0x1fc0
c02297e4: e3c1103f bic r1, r1, #63 ; 0x3f
return atomic_read(&sk->sk_wmem_alloc) - 1;
c02297e8: e5902074 ldr r2, [r0, #116] ; 0x74
return put_user(amount, (int __user *)arg);
c02297ec: e5911008 ldr r1, [r1, #8]
c02297f0: e2422001 sub r2, r2, #1
c02297f4: e1a00003 mov r0, r3
c02297f8: e2411001 sub r1, r1, #1
c02297fc: ebfffffe bl 0 <__put_user_4>
c02297fc: R_ARM_CALL __put_user_4
c0229800: e8bd8010 pop {r4, pc}
c0229804: 00005411 .word 0x00005411
c0229808: 0000541b .word 0x0000541b
c022980c: fffffdfd .word 0xfffffdfd
c0229810 <udp_setsockopt>:
if (level == SOL_UDP || level == SOL_UDPLITE)
c0229810: e3510011 cmp r1, #17
c0229814: 13510088 cmpne r1, #136 ; 0x88
{
c0229818: e52de004 push {lr} ; (str lr, [sp, #-4]!)
c022981c: e24dd00c sub sp, sp, #12
c0229820: e59dc010 ldr ip, [sp, #16]
if (level == SOL_UDP || level == SOL_UDPLITE)
c0229824: 0a000003 beq c0229838 <udp_setsockopt+0x28>
return ip_setsockopt(sk, level, optname, optval, optlen);
c0229828: e58dc010 str ip, [sp, #16]
}
c022982c: e28dd00c add sp, sp, #12
c0229830: e49de004 pop {lr} ; (ldr lr, [sp], #4)
return ip_setsockopt(sk, level, optname, optval, optlen);
c0229834: eafffffe b 0 <ip_setsockopt>
c0229834: R_ARM_JUMP24 ip_setsockopt
return udp_lib_setsockopt(sk, level, optname, optval, optlen,
c0229838: e59fe00c ldr lr, [pc, #12] ; c022984c <udp_setsockopt+0x3c>
c022983c: e88d5000 stm sp, {ip, lr}
c0229840: ebfffffe bl c02284a4 <udp_lib_setsockopt>
c0229840: R_ARM_CALL udp_lib_setsockopt
}
c0229844: e28dd00c add sp, sp, #12
c0229848: e49df004 pop {pc} ; (ldr pc, [sp], #4)
c022984c: 00000000 .word 0x00000000
c022984c: R_ARM_ABS32 udp_push_pending_frames
c0229850 <udp4_seq_show>:
atomic_read(&sp->sk_refcnt), sp,
atomic_read(&sp->sk_drops), len);
}
int udp4_seq_show(struct seq_file *seq, void *v)
{
c0229850: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
if (v == SEQ_START_TOKEN)
c0229854: e3510001 cmp r1, #1
{
c0229858: e24dd05c sub sp, sp, #92 ; 0x5c
c022985c: e1a04001 mov r4, r1
if (v == SEQ_START_TOKEN)
c0229860: 0a000043 beq c0229974 <udp4_seq_show+0x124>
"inode ref pointer drops");
else {
struct udp_iter_state *state = seq->private;
int len;
udp4_format_sock(v, seq, state->bucket, &len);
c0229864: e590203c ldr r2, [r0, #60] ; 0x3c
bucket, src, srcp, dest, destp, sp->sk_state,
c0229868: e5d1700e ldrb r7, [r1, #14]
__u16 srcp = ntohs(inet->inet_sport);
c022986c: e2843f59 add r3, r4, #356 ; 0x164
__u16 destp = ntohs(inet->inet_dport);
c0229870: e2811f56 add r1, r1, #344 ; 0x158
udp4_format_sock(v, seq, state->bucket, &len);
c0229874: e5922004 ldr r2, [r2, #4]
__u16 destp = ntohs(inet->inet_dport);
c0229878: e1d110b0 ldrh r1, [r1]
__u16 srcp = ntohs(inet->inet_sport);
c022987c: e1d330b0 ldrh r3, [r3]
c0229880: e1a05000 mov r5, r0
seq_printf(f, "%5d: %08X:%04X %08X:%04X"
c0229884: e1a00004 mov r0, r4
udp4_format_sock(v, seq, state->bucket, &len);
c0229888: e58d204c str r2, [sp, #76] ; 0x4c
__u16 destp = ntohs(inet->inet_dport);
c022988c: e58d1048 str r1, [sp, #72] ; 0x48
__u16 srcp = ntohs(inet->inet_sport);
c0229890: e58d3044 str r3, [sp, #68] ; 0x44
c0229894: e5946074 ldr r6, [r4, #116] ; 0x74
__be32 dest = inet->inet_daddr;
c0229898: e594b000 ldr fp, [r4]
__be32 src = inet->inet_rcv_saddr;
c022989c: e5948004 ldr r8, [r4, #4]
return atomic_read(&sk->sk_rmem_alloc);
c02298a0: e594a048 ldr sl, [r4, #72] ; 0x48
seq_printf(f, "%5d: %08X:%04X %08X:%04X"
c02298a4: ebfffffe bl 0 <sock_i_uid>
c02298a4: R_ARM_CALL sock_i_uid
c02298a8: e1a09000 mov r9, r0
c02298ac: e1a00004 mov r0, r4
c02298b0: ebfffffe bl 0 <sock_i_ino>
c02298b0: R_ARM_CALL sock_i_ino
c02298b4: e3a0e000 mov lr, #0
c02298b8: e59d1048 ldr r1, [sp, #72] ; 0x48
c02298bc: e59d3044 ldr r3, [sp, #68] ; 0x44
c02298c0: e1a0c421 lsr ip, r1, #8
c02298c4: e18cc401 orr ip, ip, r1, lsl #8
c02298c8: e1a01423 lsr r1, r3, #8
c02298cc: e1811403 orr r1, r1, r3, lsl #8
c02298d0: e594302c ldr r3, [r4, #44] ; 0x2c
bucket, src, srcp, dest, destp, sp->sk_state,
c02298d4: e20770ff and r7, r7, #255 ; 0xff
seq_printf(f, "%5d: %08X:%04X %08X:%04X"
c02298d8: e1a0c80c lsl ip, ip, #16
c02298dc: e58d3044 str r3, [sp, #68] ; 0x44
c02298e0: e58d700c str r7, [sp, #12]
c02298e4: e1a0c82c lsr ip, ip, #16
c02298e8: e1a01801 lsl r1, r1, #16
c02298ec: e594705c ldr r7, [r4, #92] ; 0x5c
c02298f0: e58dc008 str ip, [sp, #8]
c02298f4: e1a0c821 lsr ip, r1, #16
c02298f8: e59d1044 ldr r1, [sp, #68] ; 0x44
c02298fc: e58d002c str r0, [sp, #44] ; 0x2c
c0229900: e28d0054 add r0, sp, #84 ; 0x54
c0229904: e59d204c ldr r2, [sp, #76] ; 0x4c
c0229908: e1a03008 mov r3, r8
c022990c: e58d1030 str r1, [sp, #48] ; 0x30
c0229910: e58de018 str lr, [sp, #24]
c0229914: e58de01c str lr, [sp, #28]
c0229918: e58de020 str lr, [sp, #32]
c022991c: e58de028 str lr, [sp, #40] ; 0x28
c0229920: e58d003c str r0, [sp, #60] ; 0x3c
return atomic_read(&sk->sk_wmem_alloc) - 1;
c0229924: e2466001 sub r6, r6, #1
c0229928: e58d9024 str r9, [sp, #36] ; 0x24
c022992c: e58d4034 str r4, [sp, #52] ; 0x34
c0229930: e58d7038 str r7, [sp, #56] ; 0x38
c0229934: e1a00005 mov r0, r5
c0229938: e59f104c ldr r1, [pc, #76] ; c022998c <udp4_seq_show+0x13c>
c022993c: e58dc000 str ip, [sp]
c0229940: e58d6010 str r6, [sp, #16]
c0229944: e58db004 str fp, [sp, #4]
c0229948: e58da014 str sl, [sp, #20]
c022994c: ebfffffe bl 0 <seq_printf>
c022994c: R_ARM_CALL seq_printf
seq_printf(seq, "%*s\n", 127 - len, "");
c0229950: e59d2054 ldr r2, [sp, #84] ; 0x54
c0229954: e1a00005 mov r0, r5
c0229958: e262207f rsb r2, r2, #127 ; 0x7f
c022995c: e59f102c ldr r1, [pc, #44] ; c0229990 <udp4_seq_show+0x140>
c0229960: e59f302c ldr r3, [pc, #44] ; c0229994 <udp4_seq_show+0x144>
c0229964: ebfffffe bl 0 <seq_printf>
c0229964: R_ARM_CALL seq_printf
}
return 0;
}
c0229968: e3a00000 mov r0, #0
c022996c: e28dd05c add sp, sp, #92 ; 0x5c
c0229970: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
seq_printf(seq, "%-127s\n",
c0229974: e59f101c ldr r1, [pc, #28] ; c0229998 <udp4_seq_show+0x148>
c0229978: e59f201c ldr r2, [pc, #28] ; c022999c <udp4_seq_show+0x14c>
c022997c: ebfffffe bl 0 <seq_printf>
c022997c: R_ARM_CALL seq_printf
}
c0229980: e3a00000 mov r0, #0
c0229984: e28dd05c add sp, sp, #92 ; 0x5c
c0229988: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
c022998c: 000000a8 .word 0x000000a8
c022998c: R_ARM_ABS32 .rodata.str1.4
c0229990: 000000f8 .word 0x000000f8
c0229990: R_ARM_ABS32 .rodata.str1.4
c0229994: 00000100 .word 0x00000100
c0229994: R_ARM_ABS32 .rodata.str1.4
c0229998: 0000002c .word 0x0000002c
c0229998: R_ARM_ABS32 .rodata.str1.4
c022999c: 00000034 .word 0x00000034
c022999c: R_ARM_ABS32 .rodata.str1.4
c02299a0 <udp_lib_lport_inuse2.constprop.7>:
static int udp_lib_lport_inuse2(struct net *net, __u16 num,
c02299a0: e92d41f0 push {r4, r5, r6, r7, r8, lr}
c02299a4: e24dd008 sub sp, sp, #8
c02299a8: e1a0c00d mov ip, sp
c02299ac: e3cc7d7f bic r7, ip, #8128 ; 0x1fc0
c02299b0: e3c7e03f bic lr, r7, #63 ; 0x3f
raw_spin_lock(&lock->rlock);
c02299b4: e59ec004 ldr ip, [lr, #4]
c02299b8: e1a06000 mov r6, r0
c02299bc: e28cc001 add ip, ip, #1
c02299c0: e1a05002 mov r5, r2
c02299c4: e1a08003 mov r8, r3
c02299c8: e58ec004 str ip, [lr, #4]
udp_portaddr_for_each_entry(sk2, node, &hslot2->head)
c02299cc: e5914000 ldr r4, [r1]
c02299d0: e3140001 tst r4, #1
c02299d4: 0a000003 beq c02299e8 <udp_lib_lport_inuse2.constprop.7+0x48>
c02299d8: ea00001b b c0229a4c <udp_lib_lport_inuse2.constprop.7+0xac>
c02299dc: e5944000 ldr r4, [r4]
c02299e0: e3140001 tst r4, #1
c02299e4: 1a000018 bne c0229a4c <udp_lib_lport_inuse2.constprop.7+0xac>
c02299e8: e2441014 sub r1, r4, #20
if (net_eq(sock_net(sk2), net) &&
c02299ec: e1550001 cmp r5, r1
c02299f0: 0afffff9 beq c02299dc <udp_lib_lport_inuse2.constprop.7+0x3c>
sk2 != sk &&
c02299f4: e154c0bc ldrh ip, [r4, #-12]
c02299f8: e15c0006 cmp ip, r6
c02299fc: 1afffff6 bne c02299dc <udp_lib_lport_inuse2.constprop.7+0x3c>
(udp_sk(sk2)->udp_port_hash == num) &&
c0229a00: e5543005 ldrb r3, [r4, #-5]
c0229a04: e3530000 cmp r3, #0
c0229a08: 0a000002 beq c0229a18 <udp_lib_lport_inuse2.constprop.7+0x78>
(!sk2->sk_reuse || !sk->sk_reuse) &&
c0229a0c: e5d5300f ldrb r3, [r5, #15]
c0229a10: e3530000 cmp r3, #0
c0229a14: 1afffff0 bne c02299dc <udp_lib_lport_inuse2.constprop.7+0x3c>
(!sk2->sk_bound_dev_if || !sk->sk_bound_dev_if ||
c0229a18: e5142004 ldr r2, [r4, #-4]
(!sk2->sk_reuse || !sk->sk_reuse) &&
c0229a1c: e3520000 cmp r2, #0
c0229a20: 0a000003 beq c0229a34 <udp_lib_lport_inuse2.constprop.7+0x94>
(!sk2->sk_bound_dev_if || !sk->sk_bound_dev_if ||
c0229a24: e5953010 ldr r3, [r5, #16]
c0229a28: e1520003 cmp r2, r3
c0229a2c: 13530000 cmpne r3, #0
c0229a30: 1affffe9 bne c02299dc <udp_lib_lport_inuse2.constprop.7+0x3c>
(*saddr_comp)(sk, sk2)) {
c0229a34: e1a00005 mov r0, r5
c0229a38: e12fff38 blx r8
sk2->sk_bound_dev_if == sk->sk_bound_dev_if) &&
c0229a3c: e3500000 cmp r0, #0
c0229a40: 0affffe5 beq c02299dc <udp_lib_lport_inuse2.constprop.7+0x3c>
res = 1;
c0229a44: e3a00001 mov r0, #1
c0229a48: ea000000 b c0229a50 <udp_lib_lport_inuse2.constprop.7+0xb0>
int res = 0;
c0229a4c: e3a00000 mov r0, #0
c0229a50: e3c7703f bic r7, r7, #63 ; 0x3f
raw_spin_unlock(&lock->rlock);
c0229a54: e5973004 ldr r3, [r7, #4]
c0229a58: e2433001 sub r3, r3, #1
c0229a5c: e5873004 str r3, [r7, #4]
c0229a60: e5973000 ldr r3, [r7]
c0229a64: e3130002 tst r3, #2
c0229a68: 1a000001 bne c0229a74 <udp_lib_lport_inuse2.constprop.7+0xd4>
}
c0229a6c: e28dd008 add sp, sp, #8
c0229a70: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
c0229a74: e58d0004 str r0, [sp, #4]
c0229a78: ebfffffe bl 0 <preempt_schedule>
c0229a78: R_ARM_CALL preempt_schedule
c0229a7c: e59d0004 ldr r0, [sp, #4]
c0229a80: e28dd008 add sp, sp, #8
c0229a84: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
c0229a88 <udp_lib_lport_inuse.constprop.8>:
static int udp_lib_lport_inuse(struct net *net, __u16 num,
c0229a88: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
sk_nulls_for_each(sk2, node, &hslot->head)
c0229a8c: e5914000 ldr r4, [r1]
static int udp_lib_lport_inuse(struct net *net, __u16 num,
c0229a90: e59d5020 ldr r5, [sp, #32]
sk_nulls_for_each(sk2, node, &hslot->head)
c0229a94: e3140001 tst r4, #1
static int udp_lib_lport_inuse(struct net *net, __u16 num,
c0229a98: e59d7024 ldr r7, [sp, #36] ; 0x24
c0229a9c: 01a09003 moveq r9, r3
c0229aa0: 01a0a002 moveq sl, r2
c0229aa4: 01a06000 moveq r6, r0
unsigned long mask = BIT_MASK(nr);
c0229aa8: 03a08001 moveq r8, #1
sk_nulls_for_each(sk2, node, &hslot->head)
c0229aac: 0a000007 beq c0229ad0 <udp_lib_lport_inuse.constprop.8+0x48>
c0229ab0: ea00002b b c0229b64 <udp_lib_lport_inuse.constprop.8+0xdc>
(!sk2->sk_bound_dev_if || !sk->sk_bound_dev_if ||
c0229ab4: e5992010 ldr r2, [r9, #16]
c0229ab8: e1530002 cmp r3, r2
c0229abc: 13520000 cmpne r2, #0
c0229ac0: 0a000010 beq c0229b08 <udp_lib_lport_inuse.constprop.8+0x80>
sk_nulls_for_each(sk2, node, &hslot->head)
c0229ac4: e5944000 ldr r4, [r4]
c0229ac8: e3140001 tst r4, #1
c0229acc: 1a000024 bne c0229b64 <udp_lib_lport_inuse.constprop.8+0xdc>
c0229ad0: e2441020 sub r1, r4, #32
if (net_eq(sock_net(sk2), net) &&
c0229ad4: e1590001 cmp r9, r1
c0229ad8: 0afffff9 beq c0229ac4 <udp_lib_lport_inuse.constprop.8+0x3c>
sk2 != sk &&
c0229adc: e35a0000 cmp sl, #0
c0229ae0: 0a000021 beq c0229b6c <udp_lib_lport_inuse.constprop.8+0xe4>
(bitmap || udp_sk(sk2)->udp_port_hash == num) &&
c0229ae4: e5543011 ldrb r3, [r4, #-17] ; 0xffffffef
c0229ae8: e3530000 cmp r3, #0
c0229aec: 0a000002 beq c0229afc <udp_lib_lport_inuse.constprop.8+0x74>
(!sk2->sk_reuse || !sk->sk_reuse) &&
c0229af0: e5d9300f ldrb r3, [r9, #15]
c0229af4: e3530000 cmp r3, #0
c0229af8: 1afffff1 bne c0229ac4 <udp_lib_lport_inuse.constprop.8+0x3c>
(!sk2->sk_bound_dev_if || !sk->sk_bound_dev_if ||
c0229afc: e5143010 ldr r3, [r4, #-16]
(!sk2->sk_reuse || !sk->sk_reuse) &&
c0229b00: e3530000 cmp r3, #0
c0229b04: 1affffea bne c0229ab4 <udp_lib_lport_inuse.constprop.8+0x2c>
(*saddr_comp)(sk, sk2)) {
c0229b08: e1a00009 mov r0, r9
c0229b0c: e12fff35 blx r5
sk2->sk_bound_dev_if == sk->sk_bound_dev_if) &&
c0229b10: e3500000 cmp r0, #0
c0229b14: 0affffea beq c0229ac4 <udp_lib_lport_inuse.constprop.8+0x3c>
if (bitmap)
c0229b18: e35a0000 cmp sl, #0
c0229b1c: 0a000016 beq c0229b7c <udp_lib_lport_inuse.constprop.8+0xf4>
__set_bit(udp_sk(sk2)->udp_port_hash >> log,
c0229b20: e15411b8 ldrh r1, [r4, #-24] ; 0xffffffe8
c0229b24: e1a01751 asr r1, r1, r7
unsigned long *p = ((unsigned long *)addr) + BIT_WORD(nr);
c0229b28: e3510000 cmp r1, #0
c0229b2c: e281301f add r3, r1, #31
c0229b30: a1a03001 movge r3, r1
unsigned long mask = BIT_MASK(nr);
c0229b34: e1a02fc1 asr r2, r1, #31
c0229b38: e1a02da2 lsr r2, r2, #27
unsigned long *p = ((unsigned long *)addr) + BIT_WORD(nr);
c0229b3c: e1a032c3 asr r3, r3, #5
unsigned long mask = BIT_MASK(nr);
c0229b40: e0811002 add r1, r1, r2
*p |= mask;
c0229b44: e79a0103 ldr r0, [sl, r3, lsl #2]
unsigned long mask = BIT_MASK(nr);
c0229b48: e201101f and r1, r1, #31
c0229b4c: e0621001 rsb r1, r2, r1
*p |= mask;
c0229b50: e1801118 orr r1, r0, r8, lsl r1
c0229b54: e78a1103 str r1, [sl, r3, lsl #2]
sk_nulls_for_each(sk2, node, &hslot->head)
c0229b58: e5944000 ldr r4, [r4]
c0229b5c: e3140001 tst r4, #1
c0229b60: 0affffda beq c0229ad0 <udp_lib_lport_inuse.constprop.8+0x48>
return 0;
c0229b64: e3a00000 mov r0, #0
c0229b68: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
(bitmap || udp_sk(sk2)->udp_port_hash == num) &&
c0229b6c: e15431b8 ldrh r3, [r4, #-24] ; 0xffffffe8
c0229b70: e1530006 cmp r3, r6
c0229b74: 1affffd2 bne c0229ac4 <udp_lib_lport_inuse.constprop.8+0x3c>
c0229b78: eaffffd9 b c0229ae4 <udp_lib_lport_inuse.constprop.8+0x5c>
return 1;
c0229b7c: e3a00001 mov r0, #1
}
c0229b80: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
c0229b84 <udp_lib_get_port>:
{
c0229b84: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
c0229b88: e24dd04c sub sp, sp, #76 ; 0x4c
c0229b8c: e58d000c str r0, [sp, #12]
struct udp_table *udptable = sk->sk_prot->h.udp_table;
c0229b90: e590001c ldr r0, [r0, #28]
if (!snum) {
c0229b94: e2514000 subs r4, r1, #0
{
c0229b98: e58d2010 str r2, [sp, #16]
struct udp_table *udptable = sk->sk_prot->h.udp_table;
c0229b9c: e5907090 ldr r7, [r0, #144] ; 0x90
if (!snum) {
c0229ba0: 1a000061 bne c0229d2c <udp_lib_get_port+0x1a8>
inet_get_local_port_range(&low, &high);
c0229ba4: e28d0020 add r0, sp, #32
c0229ba8: e28d1024 add r1, sp, #36 ; 0x24
c0229bac: ebfffffe bl 0 <inet_get_local_port_range>
c0229bac: R_ARM_CALL inet_get_local_port_range
c0229bb0: e1a0200d mov r2, sp
remaining = (high - low) + 1;
c0229bb4: e59d3024 ldr r3, [sp, #36] ; 0x24
c0229bb8: e59d5020 ldr r5, [sp, #32]
c0229bbc: e3c22d7f bic r2, r2, #8128 ; 0x1fc0
c0229bc0: e1a0a002 mov sl, r2
c0229bc4: e0655003 rsb r5, r5, r3
c0229bc8: e58d201c str r2, [sp, #28]
rand = net_random();
c0229bcc: ebfffffe bl 0 <random32>
c0229bcc: R_ARM_CALL random32
remaining = (high - low) + 1;
c0229bd0: e2855001 add r5, r5, #1
first = (((u64)rand * remaining) >> 32) + low;
c0229bd4: e0832590 umull r2, r3, r0, r5
c0229bd8: e1a09fc5 asr r9, r5, #31
c0229bdc: e0233990 mla r3, r0, r9, r3
c0229be0: e59d5020 ldr r5, [sp, #32]
rand = (rand | 1) * (udptable->mask + 1);
c0229be4: e5972008 ldr r2, [r7, #8]
first = (((u64)rand * remaining) >> 32) + low;
c0229be8: e0835005 add r5, r3, r5
c0229bec: e1a05805 lsl r5, r5, #16
rand = (rand | 1) * (udptable->mask + 1);
c0229bf0: e2823001 add r3, r2, #1
c0229bf4: e3800001 orr r0, r0, #1
first = (((u64)rand * remaining) >> 32) + low;
c0229bf8: e1a05825 lsr r5, r5, #16
rand = (rand | 1) * (udptable->mask + 1);
c0229bfc: e0060093 mul r6, r3, r0
last = first + udptable->mask + 1;
c0229c00: e0853003 add r3, r5, r3
c0229c04: e1a03803 lsl r3, r3, #16
c0229c08: e1a03823 lsr r3, r3, #16
c0229c0c: e58d3018 str r3, [sp, #24]
c0229c10: e3ca903f bic r9, sl, #63 ; 0x3f
c0229c14: e28d8028 add r8, sp, #40 ; 0x28
return &table->hash[udp_hashfn(net, num, table->mask)];
c0229c18: e597c000 ldr ip, [r7]
c0229c1c: e0053002 and r3, r5, r2
c0229c20: e08c3183 add r3, ip, r3, lsl #3
{
if (small_const_nbits(nbits))
*dst = 0UL;
else {
int len = BITS_TO_LONGS(nbits) * sizeof(unsigned long);
memset(dst, 0, len);
c0229c24: e1a00008 mov r0, r8
c0229c28: e3a01020 mov r1, #32
c0229c2c: e1a0a003 mov sl, r3
c0229c30: e58d3014 str r3, [sp, #20]
c0229c34: ebfffffe bl 0 <__memzero>
c0229c34: R_ARM_CALL __memzero
raw_spin_lock_bh(&lock->rlock);
c0229c38: ebfffffe bl 0 <local_bh_disable>
c0229c38: R_ARM_CALL local_bh_disable
c0229c3c: e5993004 ldr r3, [r9, #4]
c0229c40: e2833001 add r3, r3, #1
c0229c44: e5893004 str r3, [r9, #4]
udp_lib_lport_inuse(net, snum, hslot, bitmap, sk,
c0229c48: e1a00004 mov r0, r4
return test_bit(port, sysctl_local_reserved_ports);
c0229c4c: e1a04005 mov r4, r5
c0229c50: e59d3010 ldr r3, [sp, #16]
c0229c54: e1a0100a mov r1, sl
c0229c58: e58d3000 str r3, [sp]
c0229c5c: e597300c ldr r3, [r7, #12]
c0229c60: e1a02008 mov r2, r8
c0229c64: e58d3004 str r3, [sp, #4]
c0229c68: e59d300c ldr r3, [sp, #12]
c0229c6c: ebffff85 bl c0229a88 <udp_lib_lport_inuse.constprop.8>
c0229c70: e59f32e4 ldr r3, [pc, #740] ; c0229f5c <udp_lib_get_port+0x3d8>
c0229c74: e59d0020 ldr r0, [sp, #32]
if (low <= snum && snum <= high &&
c0229c78: e59da024 ldr sl, [sp, #36] ; 0x24
c0229c7c: e593b000 ldr fp, [r3]
c0229c80: e0843006 add r3, r4, r6
c0229c84: e1540000 cmp r4, r0
c0229c88: e1a02803 lsl r2, r3, #16
c0229c8c: ba000015 blt c0229ce8 <udp_lib_get_port+0x164>
c0229c90: e154000a cmp r4, sl
c0229c94: ca000013 bgt c0229ce8 <udp_lib_get_port+0x164>
!test_bit(snum >> udptable->log, bitmap) &&
c0229c98: e597300c ldr r3, [r7, #12]
return 1UL & (addr[BIT_WORD(nr)] >> (nr & (BITS_PER_LONG-1)));
c0229c9c: e284c01f add ip, r4, #31
c0229ca0: e1a03354 asr r3, r4, r3
c0229ca4: e3530000 cmp r3, #0
c0229ca8: e283101f add r1, r3, #31
c0229cac: a1a01003 movge r1, r3
c0229cb0: e1a012c1 asr r1, r1, #5
c0229cb4: e7981101 ldr r1, [r8, r1, lsl #2]
c0229cb8: e203301f and r3, r3, #31
c0229cbc: e1a03331 lsr r3, r1, r3
if (low <= snum && snum <= high &&
c0229cc0: e3130001 tst r3, #1
c0229cc4: e204e01f and lr, r4, #31
c0229cc8: 1a000006 bne c0229ce8 <udp_lib_get_port+0x164>
c0229ccc: e3540000 cmp r4, #0
c0229cd0: a1a0c004 movge ip, r4
c0229cd4: e1a0c2cc asr ip, ip, #5
c0229cd8: e79b310c ldr r3, [fp, ip, lsl #2]
c0229cdc: e1a0ee33 lsr lr, r3, lr
!test_bit(snum >> udptable->log, bitmap) &&
c0229ce0: e31e0001 tst lr, #1
c0229ce4: 0a00003a beq c0229dd4 <udp_lib_get_port+0x250>
c0229ce8: e1a04822 lsr r4, r2, #16
} while (snum != first);
c0229cec: e1550004 cmp r5, r4
c0229cf0: 1affffe2 bne c0229c80 <udp_lib_get_port+0xfc>
raw_spin_unlock_bh(&lock->rlock);
c0229cf4: e5993004 ldr r3, [r9, #4]
c0229cf8: e2433001 sub r3, r3, #1
c0229cfc: e5893004 str r3, [r9, #4]
c0229d00: ebfffffe bl 0 <local_bh_enable>
c0229d00: R_ARM_CALL local_bh_enable
} while (++first != last);
c0229d04: e2853001 add r3, r5, #1
c0229d08: e1a03803 lsl r3, r3, #16
c0229d0c: e59d2018 ldr r2, [sp, #24]
c0229d10: e1a03823 lsr r3, r3, #16
c0229d14: e1530002 cmp r3, r2
c0229d18: 0a000041 beq c0229e24 <udp_lib_get_port+0x2a0>
c0229d1c: e1a04005 mov r4, r5
c0229d20: e5972008 ldr r2, [r7, #8]
c0229d24: e1a05003 mov r5, r3
c0229d28: eaffffba b c0229c18 <udp_lib_get_port+0x94>
c0229d2c: e1a0100d mov r1, sp
c0229d30: e3c11d7f bic r1, r1, #8128 ; 0x1fc0
c0229d34: e1a05001 mov r5, r1
c0229d38: e1a06003 mov r6, r3
c0229d3c: e5973008 ldr r3, [r7, #8]
c0229d40: e5972000 ldr r2, [r7]
c0229d44: e0033004 and r3, r3, r4
c0229d48: e0823183 add r3, r2, r3, lsl #3
c0229d4c: e1a08003 mov r8, r3
c0229d50: e58d3014 str r3, [sp, #20]
c0229d54: e58d101c str r1, [sp, #28]
raw_spin_lock_bh(&lock->rlock);
c0229d58: ebfffffe bl 0 <local_bh_disable>
c0229d58: R_ARM_CALL local_bh_disable
c0229d5c: e3c5203f bic r2, r5, #63 ; 0x3f
c0229d60: e5923004 ldr r3, [r2, #4]
c0229d64: e2833001 add r3, r3, #1
c0229d68: e5823004 str r3, [r2, #4]
if (hslot->count > 10) {
c0229d6c: e5983004 ldr r3, [r8, #4]
c0229d70: e353000a cmp r3, #10
c0229d74: da00000b ble c0229da8 <udp_lib_get_port+0x224>
unsigned int slot2 = udp_sk(sk)->udp_portaddr_hash ^ snum;
c0229d78: e59d200c ldr r2, [sp, #12]
slot2 &= udptable->mask;
c0229d7c: e597c008 ldr ip, [r7, #8]
unsigned int slot2 = udp_sk(sk)->udp_portaddr_hash ^ snum;
c0229d80: e1d250ba ldrh r5, [r2, #10]
return &table->hash2[hash & table->mask];
c0229d84: e5972004 ldr r2, [r7, #4]
c0229d88: e0255004 eor r5, r5, r4
c0229d8c: e1a05805 lsl r5, r5, #16
slot2 &= udptable->mask;
c0229d90: e00c5825 and r5, ip, r5, lsr #16
c0229d94: e005100c and r1, r5, ip
c0229d98: e0821181 add r1, r2, r1, lsl #3
if (hslot->count < hslot2->count)
c0229d9c: e5912004 ldr r2, [r1, #4]
c0229da0: e1530002 cmp r3, r2
c0229da4: aa000022 bge c0229e34 <udp_lib_get_port+0x2b0>
if (udp_lib_lport_inuse(net, snum, hslot, NULL, sk,
c0229da8: e3a02000 mov r2, #0
c0229dac: e59d3010 ldr r3, [sp, #16]
c0229db0: e58d2004 str r2, [sp, #4]
c0229db4: e58d3000 str r3, [sp]
c0229db8: e1a00004 mov r0, r4
c0229dbc: e59d1014 ldr r1, [sp, #20]
c0229dc0: e59d300c ldr r3, [sp, #12]
c0229dc4: ebffff2f bl c0229a88 <udp_lib_lport_inuse.constprop.8>
c0229dc8: e3500000 cmp r0, #0
int error = 1;
c0229dcc: 13a04001 movne r4, #1
if (udp_lib_lport_inuse(net, snum, hslot, NULL, sk,
c0229dd0: 1a00000a bne c0229e00 <udp_lib_get_port+0x27c>
inet_sk(sk)->inet_num = snum;
c0229dd4: e59d100c ldr r1, [sp, #12]
c0229dd8: e2813f56 add r3, r1, #344 ; 0x158
c0229ddc: e1c340b2 strh r4, [r3, #2]
udp_sk(sk)->udp_portaddr_hash ^= snum;
c0229de0: e1d130ba ldrh r3, [r1, #10]
if (sk_unhashed(sk)) {
c0229de4: e5912024 ldr r2, [r1, #36] ; 0x24
udp_sk(sk)->udp_portaddr_hash ^= snum;
c0229de8: e0233004 eor r3, r3, r4
if (sk_unhashed(sk)) {
c0229dec: e3520000 cmp r2, #0
udp_sk(sk)->udp_port_hash = snum;
c0229df0: e1c140b8 strh r4, [r1, #8]
udp_sk(sk)->udp_portaddr_hash ^= snum;
c0229df4: e1c130ba strh r3, [r1, #10]
if (sk_unhashed(sk)) {
c0229df8: 0a000020 beq c0229e80 <udp_lib_get_port+0x2fc>
error = 0;
c0229dfc: e3a04000 mov r4, #0
c0229e00: e59d301c ldr r3, [sp, #28]
c0229e04: e3c3303f bic r3, r3, #63 ; 0x3f
raw_spin_unlock_bh(&lock->rlock);
c0229e08: e5932004 ldr r2, [r3, #4]
c0229e0c: e2422001 sub r2, r2, #1
c0229e10: e5832004 str r2, [r3, #4]
c0229e14: ebfffffe bl 0 <local_bh_enable>
c0229e14: R_ARM_CALL local_bh_enable
}
c0229e18: e1a00004 mov r0, r4
c0229e1c: e28dd04c add sp, sp, #76 ; 0x4c
c0229e20: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
int error = 1;
c0229e24: e3a04001 mov r4, #1
}
c0229e28: e1a00004 mov r0, r4
c0229e2c: e28dd04c add sp, sp, #76 ; 0x4c
c0229e30: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
exist = udp_lib_lport_inuse2(net, snum, hslot2,
c0229e34: e59d3010 ldr r3, [sp, #16]
c0229e38: e1a00004 mov r0, r4
c0229e3c: e59d200c ldr r2, [sp, #12]
hash2_nulladdr &= udptable->mask;
c0229e40: e006600c and r6, r6, ip
exist = udp_lib_lport_inuse2(net, snum, hslot2,
c0229e44: ebfffed5 bl c02299a0 <udp_lib_lport_inuse2.constprop.7>
if (!exist && (hash2_nulladdr != slot2)) {
c0229e48: e16f3f10 clz r3, r0
c0229e4c: e1560005 cmp r6, r5
c0229e50: e1a032a3 lsr r3, r3, #5
c0229e54: 03a03000 moveq r3, #0
c0229e58: e3530000 cmp r3, #0
c0229e5c: 0affffd9 beq c0229dc8 <udp_lib_get_port+0x244>
c0229e60: e9970006 ldmib r7, {r1, r2}
c0229e64: e0022006 and r2, r2, r6
exist = udp_lib_lport_inuse2(net, snum, hslot2,
c0229e68: e0811182 add r1, r1, r2, lsl #3
c0229e6c: e59d3010 ldr r3, [sp, #16]
c0229e70: e1a00004 mov r0, r4
c0229e74: e59d200c ldr r2, [sp, #12]
c0229e78: ebfffec8 bl c02299a0 <udp_lib_lport_inuse2.constprop.7>
c0229e7c: eaffffd1 b c0229dc8 <udp_lib_get_port+0x244>
asm volatile(
c0229e80: e10f2000 mrs r2, CPSR
c0229e84: e3823080 orr r3, r2, #128 ; 0x80
c0229e88: e121f003 msr CPSR_c, r3
val = v->counter;
c0229e8c: e59d100c ldr r1, [sp, #12]
c0229e90: e591302c ldr r3, [r1, #44] ; 0x2c
v->counter = val += i;
c0229e94: e2833001 add r3, r3, #1
c0229e98: e581302c str r3, [r1, #44] ; 0x2c
asm volatile(
c0229e9c: e121f002 msr CPSR_c, r2
struct hlist_nulls_node *first = h->first;
c0229ea0: e59d0014 ldr r0, [sp, #20]
hlist_nulls_add_head_rcu(&sk->sk_nulls_node, list);
c0229ea4: e2812020 add r2, r1, #32
c0229ea8: e5903000 ldr r3, [r0]
n->pprev = &h->first;
c0229eac: e5810024 str r0, [r1, #36] ; 0x24
n->next = first;
c0229eb0: e5813020 str r3, [r1, #32]
if (!is_a_nulls(first))
c0229eb4: e3130001 tst r3, #1
rcu_assign_pointer(hlist_nulls_first_rcu(h), n);
c0229eb8: e5802000 str r2, [r0]
first->pprev = &n->next;
c0229ebc: 05832004 streq r2, [r3, #4]
hslot->count++;
c0229ec0: e59d2014 ldr r2, [sp, #20]
sock_prot_inuse_add(sock_net(sk), sk->sk_prot, 1);
c0229ec4: e59d400c ldr r4, [sp, #12]
hslot->count++;
c0229ec8: e5923004 ldr r3, [r2, #4]
sock_prot_inuse_add(sock_net(sk), sk->sk_prot, 1);
c0229ecc: e59f008c ldr r0, [pc, #140] ; c0229f60 <udp_lib_get_port+0x3dc>
hslot->count++;
c0229ed0: e2833001 add r3, r3, #1
c0229ed4: e5823004 str r3, [r2, #4]
sock_prot_inuse_add(sock_net(sk), sk->sk_prot, 1);
c0229ed8: e594101c ldr r1, [r4, #28]
c0229edc: e3a02001 mov r2, #1
c0229ee0: ebfffffe bl 0 <sock_prot_inuse_add>
c0229ee0: R_ARM_CALL sock_prot_inuse_add
c0229ee4: e59d301c ldr r3, [sp, #28]
hslot2 = udp_hashslot2(udptable, udp_sk(sk)->udp_portaddr_hash);
c0229ee8: e1d4c0ba ldrh ip, [r4, #10]
c0229eec: e3c3103f bic r1, r3, #63 ; 0x3f
raw_spin_lock(&lock->rlock);
c0229ef0: e5912004 ldr r2, [r1, #4]
c0229ef4: e5973008 ldr r3, [r7, #8]
c0229ef8: e5970004 ldr r0, [r7, #4]
c0229efc: e2822001 add r2, r2, #1
c0229f00: e003300c and r3, r3, ip
c0229f04: e5812004 str r2, [r1, #4]
c0229f08: e0802183 add r2, r0, r3, lsl #3
struct hlist_nulls_node *first = h->first;
c0229f0c: e7901183 ldr r1, [r0, r3, lsl #3]
hlist_nulls_add_head_rcu(&udp_sk(sk)->udp_portaddr_node,
c0229f10: e284c014 add ip, r4, #20
n->next = first;
c0229f14: e5841014 str r1, [r4, #20]
n->pprev = &h->first;
c0229f18: e5842018 str r2, [r4, #24]
if (!is_a_nulls(first))
c0229f1c: e3110001 tst r1, #1
rcu_assign_pointer(hlist_nulls_first_rcu(h), n);
c0229f20: e780c183 str ip, [r0, r3, lsl #3]
first->pprev = &n->next;
c0229f24: 0581c004 streq ip, [r1, #4]
hslot2->count++;
c0229f28: e5923004 ldr r3, [r2, #4]
c0229f2c: e2833001 add r3, r3, #1
c0229f30: e5823004 str r3, [r2, #4]
c0229f34: e59d301c ldr r3, [sp, #28]
c0229f38: e3c3303f bic r3, r3, #63 ; 0x3f
raw_spin_unlock(&lock->rlock);
c0229f3c: e5932004 ldr r2, [r3, #4]
c0229f40: e2422001 sub r2, r2, #1
c0229f44: e5832004 str r2, [r3, #4]
c0229f48: e5933000 ldr r3, [r3]
c0229f4c: e3130002 tst r3, #2
c0229f50: 0affffa9 beq c0229dfc <udp_lib_get_port+0x278>
c0229f54: ebfffffe bl 0 <preempt_schedule>
c0229f54: R_ARM_CALL preempt_schedule
c0229f58: eaffffa7 b c0229dfc <udp_lib_get_port+0x278>
...
c0229f5c: R_ARM_ABS32 sysctl_local_reserved_ports
c0229f60: R_ARM_ABS32 init_net
c0229f64 <__udp4_lib_lookup>:
{
c0229f64: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
c0229f68: e24dd01c sub sp, sp, #28
c0229f6c: e1dd44b0 ldrh r4, [sp, #64] ; 0x40
c0229f70: e59da048 ldr sl, [sp, #72] ; 0x48
c0229f74: e1a0e424 lsr lr, r4, #8
c0229f78: e18e4404 orr r4, lr, r4, lsl #8
c0229f7c: e59a6008 ldr r6, [sl, #8]
c0229f80: e1a04804 lsl r4, r4, #16
struct udp_hslot *hslot2, *hslot = &udptable->hash[slot];
c0229f84: e59a5000 ldr r5, [sl]
c0229f88: e1a04824 lsr r4, r4, #16
c0229f8c: e0066004 and r6, r6, r4
c0229f90: e0855186 add r5, r5, r6, lsl #3
{
c0229f94: e1a07003 mov r7, r3
c0229f98: e1a0b000 mov fp, r0
c0229f9c: e1a08001 mov r8, r1
c0229fa0: e1a09002 mov r9, r2
__rcu_read_lock();
c0229fa4: ebfffffe bl 0 <__rcu_read_lock>
c0229fa4: R_ARM_CALL __rcu_read_lock
if (hslot->count > 10) {
c0229fa8: e5953004 ldr r3, [r5, #4]
c0229fac: e353000a cmp r3, #10
c0229fb0: e58d3014 str r3, [sp, #20]
c0229fb4: da00003a ble c022a0a4 <__udp4_lib_lookup+0x140>
hash2 = udp4_portaddr_hash(net, daddr, hnum);
c0229fb8: e1a01007 mov r1, r7
c0229fbc: e1a02004 mov r2, r4
c0229fc0: e1a0000b mov r0, fp
c0229fc4: ebfff6af bl c0227a88 <udp4_portaddr_hash>
hslot2 = &udptable->hash2[slot2];
c0229fc8: e99a0006 ldmib sl, {r1, r2}
slot2 = hash2 & udptable->mask;
c0229fcc: e0000002 and r0, r0, r2
hslot2 = &udptable->hash2[slot2];
c0229fd0: e0812180 add r2, r1, r0, lsl #3
if (hslot->count < hslot2->count)
c0229fd4: e5921004 ldr r1, [r2, #4]
c0229fd8: e59d3014 ldr r3, [sp, #20]
c0229fdc: e1530001 cmp r3, r1
c0229fe0: ba00002f blt c022a0a4 <__udp4_lib_lookup+0x140>
result = udp4_lib_lookup2(net, saddr, sport,
c0229fe4: e59d3044 ldr r3, [sp, #68] ; 0x44
c0229fe8: e58d2008 str r2, [sp, #8]
c0229fec: e58d3004 str r3, [sp, #4]
c0229ff0: e58d000c str r0, [sp, #12]
c0229ff4: e1a03007 mov r3, r7
c0229ff8: e58d4000 str r4, [sp]
c0229ffc: e1a0000b mov r0, fp
c022a000: e1a01008 mov r1, r8
c022a004: e1a02009 mov r2, r9
c022a008: ebfff791 bl c0227e54 <udp4_lib_lookup2>
if (!result) {
c022a00c: e2503000 subs r3, r0, #0
c022a010: 0a000005 beq c022a02c <__udp4_lib_lookup+0xc8>
c022a014: e58d3014 str r3, [sp, #20]
__rcu_read_unlock();
c022a018: ebfffffe bl 0 <__rcu_read_unlock>
c022a018: R_ARM_CALL __rcu_read_unlock
return result;
c022a01c: e59d3014 ldr r3, [sp, #20]
c022a020: e1a00003 mov r0, r3
}
c022a024: e28dd01c add sp, sp, #28
c022a028: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
return jhash_1word((__force u32)saddr, net_hash_mix(net)) ^ port;
c022a02c: e59f0230 ldr r0, [pc, #560] ; c022a264 <__udp4_lib_lookup+0x300>
slot2 = hash2 & udptable->mask;
c022a030: e59a2008 ldr r2, [sl, #8]
return jhash_1word((__force u32)saddr, net_hash_mix(net)) ^ port;
c022a034: e0200004 eor r0, r0, r4
hslot2 = &udptable->hash2[slot2];
c022a038: e59a1004 ldr r1, [sl, #4]
slot2 = hash2 & udptable->mask;
c022a03c: e0022000 and r2, r2, r0
hslot2 = &udptable->hash2[slot2];
c022a040: e0811182 add r1, r1, r2, lsl #3
if (hslot->count < hslot2->count)
c022a044: e5910004 ldr r0, [r1, #4]
c022a048: e595c004 ldr ip, [r5, #4]
c022a04c: e15c0000 cmp ip, r0
c022a050: ba000013 blt c022a0a4 <__udp4_lib_lookup+0x140>
result = udp4_lib_lookup2(net, saddr, sport,
c022a054: e59d0044 ldr r0, [sp, #68] ; 0x44
c022a058: e58d4000 str r4, [sp]
c022a05c: e98d0007 stmib sp, {r0, r1, r2}
c022a060: e1a0000b mov r0, fp
c022a064: e1a01008 mov r1, r8
c022a068: e1a02009 mov r2, r9
c022a06c: ebfff778 bl c0227e54 <udp4_lib_lookup2>
c022a070: e1a03000 mov r3, r0
c022a074: eaffffe6 b c022a014 <__udp4_lib_lookup+0xb0>
asm volatile(
c022a078: e10f2000 mrs r2, CPSR
c022a07c: e3823080 orr r3, r2, #128 ; 0x80
c022a080: e121f003 msr CPSR_c, r3
val = v->counter;
c022a084: e59e302c ldr r3, [lr, #44] ; 0x2c
v->counter = val -= i;
c022a088: e2433001 sub r3, r3, #1
c022a08c: e58e302c str r3, [lr, #44] ; 0x2c
asm volatile(
c022a090: e121f002 msr CPSR_c, r2
if (atomic_dec_and_test(&sk->sk_refcnt))
c022a094: e3530000 cmp r3, #0
c022a098: 1a000001 bne c022a0a4 <__udp4_lib_lookup+0x140>
sk_free(sk);
c022a09c: e1a0000e mov r0, lr
c022a0a0: ebfffffe bl 0 <sk_free>
c022a0a0: R_ARM_CALL sk_free
sk_nulls_for_each_rcu(sk, node, &hslot->head) {
c022a0a4: e595c000 ldr ip, [r5]
c022a0a8: e21ce001 ands lr, ip, #1
c022a0ac: 03e0b000 mvneq fp, #0
c022a0b0: 0a000003 beq c022a0c4 <__udp4_lib_lookup+0x160>
c022a0b4: ea000046 b c022a1d4 <__udp4_lib_lookup+0x270>
c022a0b8: e59cc000 ldr ip, [ip]
c022a0bc: e31c0001 tst ip, #1
c022a0c0: 1a000026 bne c022a160 <__udp4_lib_lookup+0x1fc>
if (net_eq(sock_net(sk), net) && udp_sk(sk)->udp_port_hash == hnum &&
c022a0c4: e15c31b8 ldrh r3, [ip, #-24] ; 0xffffffe8
c022a0c8: e1530004 cmp r3, r4
c022a0cc: 1afffff9 bne c022a0b8 <__udp4_lib_lookup+0x154>
score = (sk->sk_family == PF_INET ? 1 : 0);
c022a0d0: e15c21b4 ldrh r2, [ip, #-20] ; 0xffffffec
if (inet->inet_rcv_saddr) {
c022a0d4: e51c301c ldr r3, [ip, #-28] ; 0xffffffe4
score = (sk->sk_family == PF_INET ? 1 : 0);
c022a0d8: e2422002 sub r2, r2, #2
c022a0dc: e16f2f12 clz r2, r2
if (inet->inet_rcv_saddr) {
c022a0e0: e3530000 cmp r3, #0
score = (sk->sk_family == PF_INET ? 1 : 0);
c022a0e4: e1a022a2 lsr r2, r2, #5
if (inet->inet_rcv_saddr) {
c022a0e8: 0a000002 beq c022a0f8 <__udp4_lib_lookup+0x194>
if (inet->inet_rcv_saddr != daddr)
c022a0ec: e1570003 cmp r7, r3
c022a0f0: 1afffff0 bne c022a0b8 <__udp4_lib_lookup+0x154>
score += 2;
c022a0f4: e2822002 add r2, r2, #2
if (inet->inet_daddr) {
c022a0f8: e51c3020 ldr r3, [ip, #-32] ; 0xffffffe0
c022a0fc: e3530000 cmp r3, #0
c022a100: 0a000002 beq c022a110 <__udp4_lib_lookup+0x1ac>
if (inet->inet_daddr != saddr)
c022a104: e1580003 cmp r8, r3
c022a108: 1affffea bne c022a0b8 <__udp4_lib_lookup+0x154>
score += 2;
c022a10c: e2822002 add r2, r2, #2
if (inet->inet_dport) {
c022a110: e28c3f4e add r3, ip, #312 ; 0x138
c022a114: e1d330b0 ldrh r3, [r3]
c022a118: e3530000 cmp r3, #0
c022a11c: 0a000002 beq c022a12c <__udp4_lib_lookup+0x1c8>
if (inet->inet_dport != sport)
c022a120: e1590003 cmp r9, r3
c022a124: 1affffe3 bne c022a0b8 <__udp4_lib_lookup+0x154>
score += 2;
c022a128: e2822002 add r2, r2, #2
if (sk->sk_bound_dev_if) {
c022a12c: e51c3010 ldr r3, [ip, #-16]
c022a130: e3530000 cmp r3, #0
c022a134: 0a000003 beq c022a148 <__udp4_lib_lookup+0x1e4>
if (sk->sk_bound_dev_if != dif)
c022a138: e59d1044 ldr r1, [sp, #68] ; 0x44
c022a13c: e1510003 cmp r1, r3
c022a140: 1affffdc bne c022a0b8 <__udp4_lib_lookup+0x154>
score += 2;
c022a144: e2822002 add r2, r2, #2
if (score > badness) {
c022a148: e152000b cmp r2, fp
sk_nulls_for_each_rcu(sk, node, &hslot->head) {
c022a14c: c24ce020 subgt lr, ip, #32
c022a150: e59cc000 ldr ip, [ip]
c022a154: c1a0b002 movgt fp, r2
c022a158: e31c0001 tst ip, #1
c022a15c: 0affffd8 beq c022a0c4 <__udp4_lib_lookup+0x160>
if (get_nulls_value(node) != slot)
c022a160: e15600ac cmp r6, ip, lsr #1
c022a164: 1affffce bne c022a0a4 <__udp4_lib_lookup+0x140>
if (result) {
c022a168: e35e0000 cmp lr, #0
c022a16c: e1a0a00e mov sl, lr
c022a170: 0a000019 beq c022a1dc <__udp4_lib_lookup+0x278>
c022a174: e3a01002 mov r1, #2
c022a178: ea000001 b c022a184 <__udp4_lib_lookup+0x220>
} while (c);
c022a17c: e2521000 subs r1, r2, #0
c022a180: 0a000015 beq c022a1dc <__udp4_lib_lookup+0x278>
val = atomic_cmpxchg(v, c, c + 1);
c022a184: e2810001 add r0, r1, #1
asm volatile(
c022a188: e10fc000 mrs ip, CPSR
c022a18c: e38c2080 orr r2, ip, #128 ; 0x80
c022a190: e121f002 msr CPSR_c, r2
ret = v->counter;
c022a194: e59e202c ldr r2, [lr, #44] ; 0x2c
if (likely(ret == old))
c022a198: e1510002 cmp r1, r2
v->counter = new;
c022a19c: 058e002c streq r0, [lr, #44] ; 0x2c
asm volatile(
c022a1a0: e121f00c msr CPSR_c, ip
if (val == c)
c022a1a4: e1510002 cmp r1, r2
c022a1a8: 1afffff3 bne c022a17c <__udp4_lib_lookup+0x218>
if (net_eq(sock_net(sk), net) && udp_sk(sk)->udp_port_hash == hnum &&
c022a1ac: e1de20b8 ldrh r2, [lr, #8]
c022a1b0: e1520004 cmp r2, r4
c022a1b4: 0a00000a beq c022a1e4 <__udp4_lib_lookup+0x280>
return -1;
c022a1b8: e3e02000 mvn r2, #0
else if (unlikely(compute_score(result, net, saddr, hnum, sport,
c022a1bc: e152000b cmp r2, fp
c022a1c0: baffffac blt c022a078 <__udp4_lib_lookup+0x114>
c022a1c4: ebfffffe bl 0 <__rcu_read_unlock>
c022a1c4: R_ARM_CALL __rcu_read_unlock
return result;
c022a1c8: e1a0000a mov r0, sl
}
c022a1cc: e28dd01c add sp, sp, #28
c022a1d0: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
if (get_nulls_value(node) != slot)
c022a1d4: e15600ac cmp r6, ip, lsr #1
c022a1d8: 1affffb1 bne c022a0a4 <__udp4_lib_lookup+0x140>
return -1;
c022a1dc: e3a0a000 mov sl, #0
c022a1e0: eafffff7 b c022a1c4 <__udp4_lib_lookup+0x260>
score = (sk->sk_family == PF_INET ? 1 : 0);
c022a1e4: e1de20bc ldrh r2, [lr, #12]
if (inet->inet_rcv_saddr) {
c022a1e8: e59e1004 ldr r1, [lr, #4]
score = (sk->sk_family == PF_INET ? 1 : 0);
c022a1ec: e2422002 sub r2, r2, #2
c022a1f0: e16f2f12 clz r2, r2
if (inet->inet_rcv_saddr) {
c022a1f4: e3510000 cmp r1, #0
score = (sk->sk_family == PF_INET ? 1 : 0);
c022a1f8: e1a022a2 lsr r2, r2, #5
if (inet->inet_rcv_saddr) {
c022a1fc: 1a000014 bne c022a254 <__udp4_lib_lookup+0x2f0>
if (inet->inet_daddr) {
c022a200: e59e1000 ldr r1, [lr]
c022a204: e3510000 cmp r1, #0
c022a208: 0a000002 beq c022a218 <__udp4_lib_lookup+0x2b4>
if (inet->inet_daddr != saddr)
c022a20c: e1580001 cmp r8, r1
c022a210: 1affffe8 bne c022a1b8 <__udp4_lib_lookup+0x254>
score += 2;
c022a214: e2822002 add r2, r2, #2
if (inet->inet_dport) {
c022a218: e28e1f56 add r1, lr, #344 ; 0x158
c022a21c: e1d110b0 ldrh r1, [r1]
c022a220: e3510000 cmp r1, #0
c022a224: 0a000002 beq c022a234 <__udp4_lib_lookup+0x2d0>
if (inet->inet_dport != sport)
c022a228: e1590001 cmp r9, r1
c022a22c: 1affffe1 bne c022a1b8 <__udp4_lib_lookup+0x254>
score += 2;
c022a230: e2822002 add r2, r2, #2
if (sk->sk_bound_dev_if) {
c022a234: e59e1010 ldr r1, [lr, #16]
c022a238: e3510000 cmp r1, #0
c022a23c: 0affffde beq c022a1bc <__udp4_lib_lookup+0x258>
if (sk->sk_bound_dev_if != dif)
c022a240: e59d3044 ldr r3, [sp, #68] ; 0x44
c022a244: e1530001 cmp r3, r1
score += 2;
c022a248: 02822002 addeq r2, r2, #2
if (sk->sk_bound_dev_if != dif)
c022a24c: 1affffd9 bne c022a1b8 <__udp4_lib_lookup+0x254>
c022a250: eaffffd9 b c022a1bc <__udp4_lib_lookup+0x258>
if (inet->inet_rcv_saddr != daddr)
c022a254: e1570001 cmp r7, r1
c022a258: 1affffd6 bne c022a1b8 <__udp4_lib_lookup+0x254>
score += 2;
c022a25c: e2822002 add r2, r2, #2
c022a260: eaffffe6 b c022a200 <__udp4_lib_lookup+0x29c>
c022a264: 049396b8 .word 0x049396b8
c022a268 <udp4_lib_lookup>:
{
c022a268: e92d4010 push {r4, lr}
c022a26c: e24dd010 sub sp, sp, #16
c022a270: e1dd41b8 ldrh r4, [sp, #24]
c022a274: e59de01c ldr lr, [sp, #28]
return __udp4_lib_lookup(net, saddr, sport, daddr, dport, dif, &udp_table);
c022a278: e59fc010 ldr ip, [pc, #16] ; c022a290 <udp4_lib_lookup+0x28>
c022a27c: e88d4010 stm sp, {r4, lr}
c022a280: e58dc008 str ip, [sp, #8]
c022a284: ebfffffe bl c0229f64 <__udp4_lib_lookup>
c022a284: R_ARM_CALL __udp4_lib_lookup
}
c022a288: e28dd010 add sp, sp, #16
c022a28c: e8bd8010 pop {r4, pc}
c022a290: 00000000 .word 0x00000000
c022a290: R_ARM_ABS32 .data..read_mostly
c022a294 <udp_v4_get_port>:
{
c022a294: e92d4070 push {r4, r5, r6, lr}
c022a298: e1a04000 mov r4, r0
c022a29c: e1a05001 mov r5, r1
unsigned int hash2_partial =
c022a2a0: e3a02000 mov r2, #0
c022a2a4: e5941004 ldr r1, [r4, #4]
c022a2a8: e59f0020 ldr r0, [pc, #32] ; c022a2d0 <udp_v4_get_port+0x3c>
c022a2ac: ebfff5f5 bl c0227a88 <udp4_portaddr_hash>
return udp_lib_get_port(sk, snum, ipv4_rcv_saddr_equal, hash2_nulladdr);
c022a2b0: e59f301c ldr r3, [pc, #28] ; c022a2d4 <udp_v4_get_port+0x40>
udp_sk(sk)->udp_portaddr_hash = hash2_partial;
c022a2b4: e1c400ba strh r0, [r4, #10]
return udp_lib_get_port(sk, snum, ipv4_rcv_saddr_equal, hash2_nulladdr);
c022a2b8: e1a01005 mov r1, r5
c022a2bc: e1a00004 mov r0, r4
c022a2c0: e0233005 eor r3, r3, r5
c022a2c4: e59f200c ldr r2, [pc, #12] ; c022a2d8 <udp_v4_get_port+0x44>
}
c022a2c8: e8bd4070 pop {r4, r5, r6, lr}
return udp_lib_get_port(sk, snum, ipv4_rcv_saddr_equal, hash2_nulladdr);
c022a2cc: eafffffe b c0229b84 <udp_lib_get_port>
c022a2cc: R_ARM_JUMP24 udp_lib_get_port
c022a2d0: 00000000 .word 0x00000000
c022a2d0: R_ARM_ABS32 init_net
c022a2d4: 049396b8 .word 0x049396b8
c022a2d8: 00000000 .word 0x00000000
c022a2d8: R_ARM_ABS32 ipv4_rcv_saddr_equal
c022a2dc <udp_flush_pending_frames>:
if (up->pending) {
c022a2dc: e59021e8 ldr r2, [r0, #488] ; 0x1e8
c022a2e0: e3520000 cmp r2, #0
c022a2e4: 012fff1e bxeq lr
up->len = 0;
c022a2e8: e3a02000 mov r2, #0
c022a2ec: e2801e1f add r1, r0, #496 ; 0x1f0
c022a2f0: e1c120b2 strh r2, [r1, #2]
up->pending = 0;
c022a2f4: e58021e8 str r2, [r0, #488] ; 0x1e8
ip_flush_pending_frames(sk);
c022a2f8: eafffffe b 0 <ip_flush_pending_frames>
c022a2f8: R_ARM_JUMP24 ip_flush_pending_frames
c022a2fc <udp_destroy_sock>:
{
c022a2fc: e92d4038 push {r3, r4, r5, lr}
c022a300: e1a04000 mov r4, r0
bool slow = lock_sock_fast(sk);
c022a304: ebfffffe bl 0 <lock_sock_fast>
c022a304: R_ARM_CALL lock_sock_fast
if (up->pending) {
c022a308: e59431e8 ldr r3, [r4, #488] ; 0x1e8
bool slow = lock_sock_fast(sk);
c022a30c: e1a05000 mov r5, r0
if (up->pending) {
c022a310: e3530000 cmp r3, #0
c022a314: 1a00000c bne c022a34c <udp_destroy_sock+0x50>
if (slow)
c022a318: e3550000 cmp r5, #0
c022a31c: 1a000007 bne c022a340 <udp_destroy_sock+0x44>
c022a320: e1a0300d mov r3, sp
c022a324: e3c33d7f bic r3, r3, #8128 ; 0x1fc0
c022a328: e3c3303f bic r3, r3, #63 ; 0x3f
raw_spin_unlock_bh(&lock->rlock);
c022a32c: e5932004 ldr r2, [r3, #4]
c022a330: e2422001 sub r2, r2, #1
c022a334: e5832004 str r2, [r3, #4]
}
c022a338: e8bd4038 pop {r3, r4, r5, lr}
c022a33c: eafffffe b 0 <local_bh_enable>
c022a33c: R_ARM_JUMP24 local_bh_enable
release_sock(sk);
c022a340: e1a00004 mov r0, r4
c022a344: e8bd4038 pop {r3, r4, r5, lr}
c022a348: eafffffe b 0 <release_sock>
c022a348: R_ARM_JUMP24 release_sock
up->len = 0;
c022a34c: e3a03000 mov r3, #0
c022a350: e2842e1f add r2, r4, #496 ; 0x1f0
c022a354: e1c230b2 strh r3, [r2, #2]
ip_flush_pending_frames(sk);
c022a358: e1a00004 mov r0, r4
up->pending = 0;
c022a35c: e58431e8 str r3, [r4, #488] ; 0x1e8
ip_flush_pending_frames(sk);
c022a360: ebfffffe bl 0 <ip_flush_pending_frames>
c022a360: R_ARM_CALL ip_flush_pending_frames
c022a364: eaffffeb b c022a318 <udp_destroy_sock+0x1c>
c022a368 <udp_sendpage>:
{
c022a368: e92d43f0 push {r4, r5, r6, r7, r8, r9, lr}
c022a36c: e24dd02c sub sp, sp, #44 ; 0x2c
c022a370: e59d6048 ldr r6, [sp, #72] ; 0x48
if (!up->pending) {
c022a374: e590c1e8 ldr ip, [r0, #488] ; 0x1e8
if (flags & MSG_SENDPAGE_NOTLAST)
c022a378: e3160802 tst r6, #131072 ; 0x20000
flags |= MSG_MORE;
c022a37c: 13866902 orrne r6, r6, #32768 ; 0x8000
if (!up->pending) {
c022a380: e35c0000 cmp ip, #0
{
c022a384: e1a04000 mov r4, r0
c022a388: e1a09001 mov r9, r1
c022a38c: e1a08002 mov r8, r2
c022a390: e1a07003 mov r7, r3
if (!up->pending) {
c022a394: 1a00000e bne c022a3d4 <udp_sendpage+0x6c>
struct msghdr msg = { .msg_flags = flags|MSG_MORE };
c022a398: e386e902 orr lr, r6, #32768 ; 0x8000
ret = udp_sendmsg(NULL, sk, &msg, 0);
c022a39c: e1a0000c mov r0, ip
c022a3a0: e1a0300c mov r3, ip
c022a3a4: e1a01004 mov r1, r4
c022a3a8: e28d200c add r2, sp, #12
struct msghdr msg = { .msg_flags = flags|MSG_MORE };
c022a3ac: e58dc00c str ip, [sp, #12]
c022a3b0: e58dc010 str ip, [sp, #16]
c022a3b4: e58dc014 str ip, [sp, #20]
c022a3b8: e58dc018 str ip, [sp, #24]
c022a3bc: e58dc01c str ip, [sp, #28]
c022a3c0: e58dc020 str ip, [sp, #32]
c022a3c4: e58de024 str lr, [sp, #36] ; 0x24
ret = udp_sendmsg(NULL, sk, &msg, 0);
c022a3c8: ebfffffe bl c0228ff0 <udp_sendmsg>
c022a3c8: R_ARM_CALL udp_sendmsg
if (ret < 0)
c022a3cc: e3500000 cmp r0, #0
c022a3d0: ba00001d blt c022a44c <udp_sendpage+0xe4>
lock_sock_nested(sk, 0);
c022a3d4: e1a00004 mov r0, r4
c022a3d8: e3a01000 mov r1, #0
c022a3dc: ebfffffe bl 0 <lock_sock_nested>
c022a3dc: R_ARM_CALL lock_sock_nested
if (unlikely(!up->pending)) {
c022a3e0: e59431e8 ldr r3, [r4, #488] ; 0x1e8
c022a3e4: e3530000 cmp r3, #0
c022a3e8: 0a000029 beq c022a494 <udp_sendpage+0x12c>
ret = ip_append_page(sk, &inet->cork.fl.u.ip4,
c022a3ec: e58d7000 str r7, [sp]
c022a3f0: e58d6004 str r6, [sp, #4]
c022a3f4: e1a00004 mov r0, r4
c022a3f8: e2841f6a add r1, r4, #424 ; 0x1a8
c022a3fc: e1a02009 mov r2, r9
c022a400: e1a03008 mov r3, r8
c022a404: ebfffffe bl 0 <ip_append_page>
c022a404: R_ARM_CALL ip_append_page
if (ret == -EOPNOTSUPP) {
c022a408: e370005f cmn r0, #95 ; 0x5f
ret = ip_append_page(sk, &inet->cork.fl.u.ip4,
c022a40c: e1a05000 mov r5, r0
if (ret == -EOPNOTSUPP) {
c022a410: 0a00002a beq c022a4c0 <udp_sendpage+0x158>
if (ret < 0) {
c022a414: e3500000 cmp r0, #0
c022a418: ba000013 blt c022a46c <udp_sendpage+0x104>
up->len += size;
c022a41c: e2842e1f add r2, r4, #496 ; 0x1f0
c022a420: e1d230b2 ldrh r3, [r2, #2]
c022a424: e0873003 add r3, r7, r3
c022a428: e1c230b2 strh r3, [r2, #2]
if (!(up->corkflag || (flags&MSG_MORE)))
c022a42c: e59431ec ldr r3, [r4, #492] ; 0x1ec
c022a430: e3530000 cmp r3, #0
c022a434: 0a000006 beq c022a454 <udp_sendpage+0xec>
ret = size;
c022a438: e3550000 cmp r5, #0
c022a43c: 01a05007 moveq r5, r7
release_sock(sk);
c022a440: e1a00004 mov r0, r4
c022a444: ebfffffe bl 0 <release_sock>
c022a444: R_ARM_CALL release_sock
return ret;
c022a448: e1a00005 mov r0, r5
}
c022a44c: e28dd02c add sp, sp, #44 ; 0x2c
c022a450: e8bd83f0 pop {r4, r5, r6, r7, r8, r9, pc}
if (!(up->corkflag || (flags&MSG_MORE)))
c022a454: e3160902 tst r6, #32768 ; 0x8000
c022a458: 1afffff6 bne c022a438 <udp_sendpage+0xd0>
ret = udp_push_pending_frames(sk);
c022a45c: e1a00004 mov r0, r4
c022a460: ebfffffe bl c02283a8 <udp_push_pending_frames>
c022a460: R_ARM_CALL udp_push_pending_frames
c022a464: e1a05000 mov r5, r0
c022a468: eafffff2 b c022a438 <udp_sendpage+0xd0>
if (up->pending) {
c022a46c: e59431e8 ldr r3, [r4, #488] ; 0x1e8
c022a470: e3530000 cmp r3, #0
c022a474: 0afffff1 beq c022a440 <udp_sendpage+0xd8>
up->len = 0;
c022a478: e3a03000 mov r3, #0
c022a47c: e2842e1f add r2, r4, #496 ; 0x1f0
c022a480: e1c230b2 strh r3, [r2, #2]
ip_flush_pending_frames(sk);
c022a484: e1a00004 mov r0, r4
up->pending = 0;
c022a488: e58431e8 str r3, [r4, #488] ; 0x1e8
ip_flush_pending_frames(sk);
c022a48c: ebfffffe bl 0 <ip_flush_pending_frames>
c022a48c: R_ARM_CALL ip_flush_pending_frames
c022a490: eaffffea b c022a440 <udp_sendpage+0xd8>
release_sock(sk);
c022a494: e1a00004 mov r0, r4
c022a498: ebfffffe bl 0 <release_sock>
c022a498: R_ARM_CALL release_sock
LIMIT_NETDEBUG(KERN_DEBUG pr_fmt("udp cork app bug 3\n"));
c022a49c: e59f304c ldr r3, [pc, #76] ; c022a4f0 <udp_sendpage+0x188>
c022a4a0: e5933000 ldr r3, [r3]
c022a4a4: e3530000 cmp r3, #0
c022a4a8: 0a000002 beq c022a4b8 <udp_sendpage+0x150>
c022a4ac: ebfffffe bl 0 <net_ratelimit>
c022a4ac: R_ARM_CALL net_ratelimit
c022a4b0: e3500000 cmp r0, #0
c022a4b4: 1a00000a bne c022a4e4 <udp_sendpage+0x17c>
return -EINVAL;
c022a4b8: e3e00015 mvn r0, #21
c022a4bc: eaffffe2 b c022a44c <udp_sendpage+0xe4>
release_sock(sk);
c022a4c0: e1a00004 mov r0, r4
c022a4c4: ebfffffe bl 0 <release_sock>
c022a4c4: R_ARM_CALL release_sock
return sock_no_sendpage(sk->sk_socket, page, offset,
c022a4c8: e5940118 ldr r0, [r4, #280] ; 0x118
c022a4cc: e1a01009 mov r1, r9
c022a4d0: e58d6000 str r6, [sp]
c022a4d4: e1a02008 mov r2, r8
c022a4d8: e1a03007 mov r3, r7
c022a4dc: ebfffffe bl 0 <sock_no_sendpage>
c022a4dc: R_ARM_CALL sock_no_sendpage
c022a4e0: eaffffd9 b c022a44c <udp_sendpage+0xe4>
LIMIT_NETDEBUG(KERN_DEBUG pr_fmt("udp cork app bug 3\n"));
c022a4e4: e59f0008 ldr r0, [pc, #8] ; c022a4f4 <udp_sendpage+0x18c>
c022a4e8: ebfffffe bl 0 <printk>
c022a4e8: R_ARM_CALL printk
c022a4ec: eafffff1 b c022a4b8 <udp_sendpage+0x150>
c022a4f0: 00000000 .word 0x00000000
c022a4f0: R_ARM_ABS32 net_msg_warn
c022a4f4: 00000104 .word 0x00000104
c022a4f4: R_ARM_ABS32 .rodata.str1.4
c022a4f8 <__udp4_lib_err>:
{
c022a4f8: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
c022a4fc: e1a06000 mov r6, r0
const struct iphdr *iph = (const struct iphdr *)skb->data;
c022a500: e590c094 ldr ip, [r0, #148] ; 0x94
return skb->transport_header;
c022a504: e590007c ldr r0, [r0, #124] ; 0x7c
struct udphdr *uh = (struct udphdr *)(skb->data+(iph->ihl<<2));
c022a508: e5dc3000 ldrb r3, [ip]
sk = __udp4_lib_lookup(net, iph->daddr, uh->dest,
c022a50c: e5968014 ldr r8, [r6, #20]
struct udphdr *uh = (struct udphdr *)(skb->data+(iph->ihl<<2));
c022a510: e203300f and r3, r3, #15
c022a514: e1a03103 lsl r3, r3, #2
sk = __udp4_lib_lookup(net, iph->daddr, uh->dest,
c022a518: e19ca0b3 ldrh sl, [ip, r3]
{
c022a51c: e24dd010 sub sp, sp, #16
struct udphdr *uh = (struct udphdr *)(skb->data+(iph->ihl<<2));
c022a520: e08c4003 add r4, ip, r3
sk = __udp4_lib_lookup(net, iph->daddr, uh->dest,
c022a524: e59c5010 ldr r5, [ip, #16]
c022a528: e1d4e0b2 ldrh lr, [r4, #2]
const int type = icmp_hdr(skb)->type;
c022a52c: e5d07000 ldrb r7, [r0]
const int code = icmp_hdr(skb)->code;
c022a530: e5d09001 ldrb r9, [r0, #1]
sk = __udp4_lib_lookup(net, iph->daddr, uh->dest,
c022a534: e59c300c ldr r3, [ip, #12]
c022a538: e58da000 str sl, [sp]
c022a53c: e59800b0 ldr r0, [r8, #176] ; 0xb0
c022a540: e59f8158 ldr r8, [pc, #344] ; c022a6a0 <__udp4_lib_err+0x1a8>
c022a544: e98d0005 stmib sp, {r0, r2}
{
c022a548: e1a0a001 mov sl, r1
sk = __udp4_lib_lookup(net, iph->daddr, uh->dest,
c022a54c: e1a00008 mov r0, r8
c022a550: e1a01005 mov r1, r5
c022a554: e1a0200e mov r2, lr
c022a558: ebfffffe bl c0229f64 <__udp4_lib_lookup>
c022a558: R_ARM_CALL __udp4_lib_lookup
if (sk == NULL) {
c022a55c: e2505000 subs r5, r0, #0
c022a560: 0a000048 beq c022a688 <__udp4_lib_err+0x190>
switch (type) {
c022a564: e3570004 cmp r7, #4
c022a568: 0a000007 beq c022a58c <__udp4_lib_err+0x94>
c022a56c: e357000c cmp r7, #12
c022a570: 0a000010 beq c022a5b8 <__udp4_lib_err+0xc0>
c022a574: e3570003 cmp r7, #3
c022a578: 0a00001e beq c022a5f8 <__udp4_lib_err+0x100>
if (!inet->recverr) {
c022a57c: e5d53170 ldrb r3, [r5, #368] ; 0x170
c022a580: e3130001 tst r3, #1
c022a584: 13a07071 movne r7, #113 ; 0x71
c022a588: 1a00002c bne c022a640 <__udp4_lib_err+0x148>
asm volatile(
c022a58c: e10f2000 mrs r2, CPSR
c022a590: e3823080 orr r3, r2, #128 ; 0x80
c022a594: e121f003 msr CPSR_c, r3
val = v->counter;
c022a598: e595302c ldr r3, [r5, #44] ; 0x2c
v->counter = val -= i;
c022a59c: e2433001 sub r3, r3, #1
c022a5a0: e585302c str r3, [r5, #44] ; 0x2c
asm volatile(
c022a5a4: e121f002 msr CPSR_c, r2
if (atomic_dec_and_test(&sk->sk_refcnt))
c022a5a8: e3530000 cmp r3, #0
c022a5ac: 0a00000d beq c022a5e8 <__udp4_lib_err+0xf0>
}
c022a5b0: e28dd010 add sp, sp, #16
c022a5b4: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
err = EPROTO;
c022a5b8: e3a07047 mov r7, #71 ; 0x47
if (!inet->recverr) {
c022a5bc: e5d53170 ldrb r3, [r5, #368] ; 0x170
c022a5c0: e3130001 tst r3, #1
c022a5c4: 1a00001d bne c022a640 <__udp4_lib_err+0x148>
if (!harderr || sk->sk_state != TCP_ESTABLISHED)
c022a5c8: e5d5300e ldrb r3, [r5, #14]
c022a5cc: e3530001 cmp r3, #1
c022a5d0: 1affffed bne c022a58c <__udp4_lib_err+0x94>
sk->sk_err = err;
c022a5d4: e58570cc str r7, [r5, #204] ; 0xcc
sk->sk_error_report(sk);
c022a5d8: e595314c ldr r3, [r5, #332] ; 0x14c
c022a5dc: e1a00005 mov r0, r5
c022a5e0: e12fff33 blx r3
c022a5e4: eaffffe8 b c022a58c <__udp4_lib_err+0x94>
sk_free(sk);
c022a5e8: e1a00005 mov r0, r5
}
c022a5ec: e28dd010 add sp, sp, #16
c022a5f0: e8bd47f0 pop {r4, r5, r6, r7, r8, r9, sl, lr}
c022a5f4: eafffffe b 0 <sk_free>
c022a5f4: R_ARM_JUMP24 sk_free
if (code == ICMP_FRAG_NEEDED) { /* Path MTU discovery */
c022a5f8: e3590004 cmp r9, #4
c022a5fc: 0a00001c beq c022a674 <__udp4_lib_err+0x17c>
if (code <= NR_ICMP_UNREACH) {
c022a600: e359000f cmp r9, #15
c022a604: caffffdc bgt c022a57c <__udp4_lib_err+0x84>
harderr = icmp_err_convert[code].fatal;
c022a608: e59f2094 ldr r2, [pc, #148] ; c022a6a4 <__udp4_lib_err+0x1ac>
if (!inet->recverr) {
c022a60c: e5d51170 ldrb r1, [r5, #368] ; 0x170
harderr = icmp_err_convert[code].fatal;
c022a610: e0823189 add r3, r2, r9, lsl #3
c022a614: e5d33004 ldrb r3, [r3, #4]
if (!inet->recverr) {
c022a618: e3110001 tst r1, #1
harderr = icmp_err_convert[code].fatal;
c022a61c: e2033001 and r3, r3, #1
err = icmp_err_convert[code].errno;
c022a620: e7927189 ldr r7, [r2, r9, lsl #3]
if (!inet->recverr) {
c022a624: 1a000005 bne c022a640 <__udp4_lib_err+0x148>
if (!harderr || sk->sk_state != TCP_ESTABLISHED)
c022a628: e3530000 cmp r3, #0
c022a62c: 0affffd6 beq c022a58c <__udp4_lib_err+0x94>
c022a630: e5d5300e ldrb r3, [r5, #14]
c022a634: e3530001 cmp r3, #1
c022a638: 1affffd3 bne c022a58c <__udp4_lib_err+0x94>
c022a63c: eaffffe4 b c022a5d4 <__udp4_lib_err+0xdc>
ip_icmp_error(sk, skb, err, uh->dest, info, (u8 *)(uh+1));
c022a640: e1d430b2 ldrh r3, [r4, #2]
c022a644: e2844008 add r4, r4, #8
c022a648: e1a00005 mov r0, r5
c022a64c: e1a01006 mov r1, r6
c022a650: e58d4004 str r4, [sp, #4]
c022a654: e58da000 str sl, [sp]
c022a658: e1a02007 mov r2, r7
c022a65c: ebfffffe bl 0 <ip_icmp_error>
c022a65c: R_ARM_CALL ip_icmp_error
sk->sk_err = err;
c022a660: e58570cc str r7, [r5, #204] ; 0xcc
sk->sk_error_report(sk);
c022a664: e595314c ldr r3, [r5, #332] ; 0x14c
c022a668: e1a00005 mov r0, r5
c022a66c: e12fff33 blx r3
c022a670: eaffffc5 b c022a58c <__udp4_lib_err+0x94>
if (inet->pmtudisc != IP_PMTUDISC_DONT) {
c022a674: e5d5316f ldrb r3, [r5, #367] ; 0x16f
c022a678: e3530000 cmp r3, #0
c022a67c: 0affffc2 beq c022a58c <__udp4_lib_err+0x94>
err = EMSGSIZE;
c022a680: e3a0705a mov r7, #90 ; 0x5a
c022a684: eaffffcc b c022a5bc <__udp4_lib_err+0xc4>
ICMP_INC_STATS_BH(net, ICMP_MIB_INERRORS);
c022a688: e59820a0 ldr r2, [r8, #160] ; 0xa0
c022a68c: e5923008 ldr r3, [r2, #8]
c022a690: e2833001 add r3, r3, #1
c022a694: e5823008 str r3, [r2, #8]
}
c022a698: e28dd010 add sp, sp, #16
c022a69c: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
...
c022a6a0: R_ARM_ABS32 init_net
c022a6a4: R_ARM_ABS32 icmp_err_convert
c022a6a8 <udp_err>:
__udp4_lib_err(skb, info, &udp_table);
c022a6a8: e59f2000 ldr r2, [pc] ; c022a6b0 <udp_err+0x8>
c022a6ac: eafffffe b c022a4f8 <__udp4_lib_err>
c022a6ac: R_ARM_JUMP24 __udp4_lib_err
c022a6b0: 00000000 .word 0x00000000
c022a6b0: R_ARM_ABS32 .data..read_mostly
c022a6b4 <udp_queue_rcv_skb>:
{
c022a6b4: e92d40f8 push {r3, r4, r5, r6, r7, lr}
if (up->encap_type) {
c022a6b8: e2803e1f add r3, r0, #496 ; 0x1f0
c022a6bc: e1d330b0 ldrh r3, [r3]
{
c022a6c0: e1a04000 mov r4, r0
if (up->encap_type) {
c022a6c4: e3530000 cmp r3, #0
int is_udplite = IS_UDPLITE(sk);
c022a6c8: e5d061f8 ldrb r6, [r0, #504] ; 0x1f8
{
c022a6cc: e1a05001 mov r5, r1
if (up->encap_type) {
c022a6d0: 0a000007 beq c022a6f4 <udp_queue_rcv_skb+0x40>
encap_rcv = ACCESS_ONCE(up->encap_rcv);
c022a6d4: e59031fc ldr r3, [r0, #508] ; 0x1fc
if (skb->len > sizeof(struct udphdr) && encap_rcv != NULL) {
c022a6d8: e591204c ldr r2, [r1, #76] ; 0x4c
c022a6dc: e3530000 cmp r3, #0
c022a6e0: 13520008 cmpne r2, #8
c022a6e4: 9a000002 bls c022a6f4 <udp_queue_rcv_skb+0x40>
ret = encap_rcv(sk, skb);
c022a6e8: e12fff33 blx r3
if (ret <= 0) {
c022a6ec: e3500000 cmp r0, #0
c022a6f0: da000081 ble c022a8fc <udp_queue_rcv_skb+0x248>
if ((is_udplite & UDPLITE_RECV_CC) && UDP_SKB_CB(skb)->partial_cov) {
c022a6f4: e3160004 tst r6, #4
c022a6f8: 1a000034 bne c022a7d0 <udp_queue_rcv_skb+0x11c>
if (rcu_access_pointer(sk->sk_filter) &&
c022a6fc: e5943064 ldr r3, [r4, #100] ; 0x64
c022a700: e3530000 cmp r3, #0
c022a704: 0a000002 beq c022a714 <udp_queue_rcv_skb+0x60>
return skb->ip_summed & CHECKSUM_UNNECESSARY;
c022a708: e5d53060 ldrb r3, [r5, #96] ; 0x60
return !skb_csum_unnecessary(skb) &&
c022a70c: e3130004 tst r3, #4
c022a710: 0a000061 beq c022a89c <udp_queue_rcv_skb+0x1e8>
unsigned int qsize = sk->sk_backlog.len + atomic_read(&sk->sk_rmem_alloc);
c022a714: e5943048 ldr r3, [r4, #72] ; 0x48
c022a718: e594104c ldr r1, [r4, #76] ; 0x4c
if (sk_rcvqueues_full(sk, skb))
c022a71c: e5942060 ldr r2, [r4, #96] ; 0x60
c022a720: e0833001 add r3, r3, r1
c022a724: e1530002 cmp r3, r2
c022a728: 8a000016 bhi c022a788 <udp_queue_rcv_skb+0xd4>
c022a72c: e1a0300d mov r3, sp
ipv4_pktinfo_prepare(skb);
c022a730: e1a00005 mov r0, r5
c022a734: e3c37d7f bic r7, r3, #8128 ; 0x1fc0
c022a738: ebfffffe bl 0 <ipv4_pktinfo_prepare>
c022a738: R_ARM_CALL ipv4_pktinfo_prepare
c022a73c: e3c7303f bic r3, r7, #63 ; 0x3f
raw_spin_lock(&lock->rlock);
c022a740: e5932004 ldr r2, [r3, #4]
c022a744: e2822001 add r2, r2, #1
c022a748: e5832004 str r2, [r3, #4]
if (!sock_owned_by_user(sk))
c022a74c: e5942030 ldr r2, [r4, #48] ; 0x30
c022a750: e3520000 cmp r2, #0
c022a754: 0a00004b beq c022a888 <udp_queue_rcv_skb+0x1d4>
c022a758: e5942048 ldr r2, [r4, #72] ; 0x48
c022a75c: e594004c ldr r0, [r4, #76] ; 0x4c
if (sk_rcvqueues_full(sk, skb))
c022a760: e5941060 ldr r1, [r4, #96] ; 0x60
unsigned int qsize = sk->sk_backlog.len + atomic_read(&sk->sk_rmem_alloc);
c022a764: e0822000 add r2, r2, r0
if (sk_rcvqueues_full(sk, skb))
c022a768: e1520001 cmp r2, r1
c022a76c: 9a00002d bls c022a828 <udp_queue_rcv_skb+0x174>
raw_spin_unlock(&lock->rlock);
c022a770: e5932004 ldr r2, [r3, #4]
c022a774: e2422001 sub r2, r2, #1
c022a778: e5832004 str r2, [r3, #4]
c022a77c: e5933000 ldr r3, [r3]
c022a780: e3130002 tst r3, #2
c022a784: 1a000071 bne c022a950 <udp_queue_rcv_skb+0x29c>
UDP_INC_STATS_BH(sock_net(sk), UDP_MIB_INERRORS, is_udplite);
c022a788: e59f31c8 ldr r3, [pc, #456] ; c022a958 <udp_queue_rcv_skb+0x2a4>
c022a78c: e3560000 cmp r6, #0
c022a790: 1593209c ldrne r2, [r3, #156] ; 0x9c
c022a794: 05932098 ldreq r2, [r3, #152] ; 0x98
c022a798: e592300c ldr r3, [r2, #12]
c022a79c: e2833001 add r3, r3, #1
c022a7a0: e582300c str r3, [r2, #12]
asm volatile(
c022a7a4: e10f2000 mrs r2, CPSR
c022a7a8: e3823080 orr r3, r2, #128 ; 0x80
c022a7ac: e121f003 msr CPSR_c, r3
val = v->counter;
c022a7b0: e594305c ldr r3, [r4, #92] ; 0x5c
v->counter = val += i;
c022a7b4: e2833001 add r3, r3, #1
c022a7b8: e584305c str r3, [r4, #92] ; 0x5c
asm volatile(
c022a7bc: e121f002 msr CPSR_c, r2
kfree_skb(skb);
c022a7c0: e1a00005 mov r0, r5
c022a7c4: ebfffffe bl 0 <kfree_skb>
c022a7c4: R_ARM_CALL kfree_skb
return -1;
c022a7c8: e3e00000 mvn r0, #0
c022a7cc: e8bd80f8 pop {r3, r4, r5, r6, r7, pc}
if ((is_udplite & UDPLITE_RECV_CC) && UDP_SKB_CB(skb)->partial_cov) {
c022a7d0: e5d5302e ldrb r3, [r5, #46] ; 0x2e
c022a7d4: e3530000 cmp r3, #0
c022a7d8: 0affffc7 beq c022a6fc <udp_queue_rcv_skb+0x48>
if (up->pcrlen == 0) { /* full coverage was set */
c022a7dc: e2847f7d add r7, r4, #500 ; 0x1f4
c022a7e0: e1d730b2 ldrh r3, [r7, #2]
c022a7e4: e3530000 cmp r3, #0
c022a7e8: 0a00004c beq c022a920 <udp_queue_rcv_skb+0x26c>
if (UDP_SKB_CB(skb)->cscov < up->pcrlen) {
c022a7ec: e1d522bc ldrh r2, [r5, #44] ; 0x2c
c022a7f0: e1520003 cmp r2, r3
c022a7f4: 2affffc0 bcs c022a6fc <udp_queue_rcv_skb+0x48>
LIMIT_NETDEBUG(KERN_WARNING "UDPLite: coverage %d too small, need min %d\n",
c022a7f8: e59f315c ldr r3, [pc, #348] ; c022a95c <udp_queue_rcv_skb+0x2a8>
c022a7fc: e5933000 ldr r3, [r3]
c022a800: e3530000 cmp r3, #0
c022a804: 0affffdf beq c022a788 <udp_queue_rcv_skb+0xd4>
c022a808: ebfffffe bl 0 <net_ratelimit>
c022a808: R_ARM_CALL net_ratelimit
c022a80c: e3500000 cmp r0, #0
c022a810: 0affffdc beq c022a788 <udp_queue_rcv_skb+0xd4>
c022a814: e1d720b2 ldrh r2, [r7, #2]
c022a818: e1d512bc ldrh r1, [r5, #44] ; 0x2c
c022a81c: e59f013c ldr r0, [pc, #316] ; c022a960 <udp_queue_rcv_skb+0x2ac>
c022a820: ebfffffe bl 0 <printk>
c022a820: R_ARM_CALL printk
c022a824: eaffffd7 b c022a788 <udp_queue_rcv_skb+0xd4>
return (skb->_skb_refdst & SKB_DST_NOREF) && skb_dst(skb);
c022a828: e5953048 ldr r3, [r5, #72] ; 0x48
c022a82c: e3130001 tst r3, #1
c022a830: 1a00001f bne c022a8b4 <udp_queue_rcv_skb+0x200>
skb->next = NULL;
c022a834: e3a00000 mov r0, #0
if (!sk->sk_backlog.tail)
c022a838: e5943054 ldr r3, [r4, #84] ; 0x54
c022a83c: e3530000 cmp r3, #0
sk->sk_backlog.tail->next = skb;
c022a840: 15835000 strne r5, [r3]
sk->sk_backlog.head = skb;
c022a844: 05845050 streq r5, [r4, #80] ; 0x50
sk->sk_backlog.tail = skb;
c022a848: e5845054 str r5, [r4, #84] ; 0x54
sk->sk_backlog.len += skb->truesize;
c022a84c: e5952098 ldr r2, [r5, #152] ; 0x98
skb->next = NULL;
c022a850: e5850000 str r0, [r5]
rc = 0;
c022a854: e1a05000 mov r5, r0
sk->sk_backlog.len += skb->truesize;
c022a858: e594304c ldr r3, [r4, #76] ; 0x4c
c022a85c: e0833002 add r3, r3, r2
c022a860: e584304c str r3, [r4, #76] ; 0x4c
c022a864: e3c7303f bic r3, r7, #63 ; 0x3f
c022a868: e5932004 ldr r2, [r3, #4]
c022a86c: e2422001 sub r2, r2, #1
c022a870: e5832004 str r2, [r3, #4]
c022a874: e5933000 ldr r3, [r3]
c022a878: e3130002 tst r3, #2
c022a87c: 1a00001b bne c022a8f0 <udp_queue_rcv_skb+0x23c>
return rc;
c022a880: e1a00005 mov r0, r5
c022a884: e8bd80f8 pop {r3, r4, r5, r6, r7, pc}
rc = __udp_queue_rcv_skb(sk, skb);
c022a888: e1a01005 mov r1, r5
c022a88c: e1a00004 mov r0, r4
c022a890: ebfff918 bl c0228cf8 <__udp_queue_rcv_skb>
c022a894: e1a05000 mov r5, r0
c022a898: eafffff1 b c022a864 <udp_queue_rcv_skb+0x1b0>
return __skb_checksum_complete_head(skb, UDP_SKB_CB(skb)->cscov);
c022a89c: e1a00005 mov r0, r5
c022a8a0: e1d512bc ldrh r1, [r5, #44] ; 0x2c
c022a8a4: ebfffffe bl 0 <__skb_checksum_complete_head>
c022a8a4: R_ARM_CALL __skb_checksum_complete_head
return !skb_csum_unnecessary(skb) &&
c022a8a8: e3500000 cmp r0, #0
c022a8ac: 1affffb5 bne c022a788 <udp_queue_rcv_skb+0xd4>
c022a8b0: eaffff97 b c022a714 <udp_queue_rcv_skb+0x60>
c022a8b4: e3d33001 bics r3, r3, #1
c022a8b8: 0affffdd beq c022a834 <udp_queue_rcv_skb+0x180>
skb->_skb_refdst &= ~SKB_DST_NOREF;
c022a8bc: e5853048 str r3, [r5, #72] ; 0x48
asm volatile(
c022a8c0: e10f1000 mrs r1, CPSR
c022a8c4: e3812080 orr r2, r1, #128 ; 0x80
c022a8c8: e121f002 msr CPSR_c, r2
val = v->counter;
c022a8cc: e1d304b2 ldrh r0, [r3, #66] ; 0x42
c022a8d0: e1d324b0 ldrh r2, [r3, #64] ; 0x40
c022a8d4: e1822800 orr r2, r2, r0, lsl #16
v->counter = val += i;
c022a8d8: e2822001 add r2, r2, #1
c022a8dc: e1a00822 lsr r0, r2, #16
c022a8e0: e1c324b0 strh r2, [r3, #64] ; 0x40
c022a8e4: e1c304b2 strh r0, [r3, #66] ; 0x42
asm volatile(
c022a8e8: e121f001 msr CPSR_c, r1
c022a8ec: eaffffd0 b c022a834 <udp_queue_rcv_skb+0x180>
c022a8f0: ebfffffe bl 0 <preempt_schedule>
c022a8f0: R_ARM_CALL preempt_schedule
return rc;
c022a8f4: e1a00005 mov r0, r5
c022a8f8: e8bd80f8 pop {r3, r4, r5, r6, r7, pc}
UDP_INC_STATS_BH(sock_net(sk),
c022a8fc: e59f3054 ldr r3, [pc, #84] ; c022a958 <udp_queue_rcv_skb+0x2a4>
c022a900: e3560000 cmp r6, #0
c022a904: 1593209c ldrne r2, [r3, #156] ; 0x9c
c022a908: 05932098 ldreq r2, [r3, #152] ; 0x98
return -ret;
c022a90c: e2600000 rsb r0, r0, #0
UDP_INC_STATS_BH(sock_net(sk),
c022a910: e5923004 ldr r3, [r2, #4]
c022a914: e2833001 add r3, r3, #1
c022a918: e5823004 str r3, [r2, #4]
return -ret;
c022a91c: e8bd80f8 pop {r3, r4, r5, r6, r7, pc}
LIMIT_NETDEBUG(KERN_WARNING "UDPLite: partial coverage %d while full coverage %d requested\n",
c022a920: e59f3034 ldr r3, [pc, #52] ; c022a95c <udp_queue_rcv_skb+0x2a8>
c022a924: e5933000 ldr r3, [r3]
c022a928: e3530000 cmp r3, #0
c022a92c: 0affff95 beq c022a788 <udp_queue_rcv_skb+0xd4>
c022a930: ebfffffe bl 0 <net_ratelimit>
c022a930: R_ARM_CALL net_ratelimit
c022a934: e3500000 cmp r0, #0
c022a938: 0affff92 beq c022a788 <udp_queue_rcv_skb+0xd4>
c022a93c: e1d512bc ldrh r1, [r5, #44] ; 0x2c
c022a940: e595204c ldr r2, [r5, #76] ; 0x4c
c022a944: e59f0018 ldr r0, [pc, #24] ; c022a964 <udp_queue_rcv_skb+0x2b0>
c022a948: ebfffffe bl 0 <printk>
c022a948: R_ARM_CALL printk
c022a94c: eaffff8d b c022a788 <udp_queue_rcv_skb+0xd4>
c022a950: ebfffffe bl 0 <preempt_schedule>
c022a950: R_ARM_CALL preempt_schedule
c022a954: eaffff8b b c022a788 <udp_queue_rcv_skb+0xd4>
...
c022a958: R_ARM_ABS32 init_net
c022a95c: R_ARM_ABS32 net_msg_warn
c022a960: 00000164 .word 0x00000164
c022a960: R_ARM_ABS32 .rodata.str1.4
c022a964: 00000120 .word 0x00000120
c022a964: R_ARM_ABS32 .rodata.str1.4
c022a968 <flush_stack>:
for (i = 0; i < count; i++) {
c022a968: e3510000 cmp r1, #0
c022a96c: 012fff1e bxeq lr
{
c022a970: e92d4ff8 push {r3, r4, r5, r6, r7, r8, r9, sl, fp, lr}
for (i = 0; i < count; i++) {
c022a974: e3a04000 mov r4, #0
c022a978: e1a0a003 mov sl, r3
c022a97c: e1a09002 mov r9, r2
c022a980: e1a08001 mov r8, r1
c022a984: e1a05004 mov r5, r4
UDP_INC_STATS_BH(sock_net(sk), UDP_MIB_RCVBUFERRORS,
c022a988: e59fb0dc ldr fp, [pc, #220] ; c022aa6c <flush_stack+0x104>
c022a98c: e2406004 sub r6, r0, #4
c022a990: ea000002 b c022a9a0 <flush_stack+0x38>
for (i = 0; i < count; i++) {
c022a994: e2855001 add r5, r5, #1
c022a998: e1550008 cmp r5, r8
c022a99c: 0a000013 beq c022a9f0 <flush_stack+0x88>
if (likely(skb1 == NULL))
c022a9a0: e3540000 cmp r4, #0
sk = stack[i];
c022a9a4: e5b67004 ldr r7, [r6, #4]!
if (likely(skb1 == NULL))
c022a9a8: 1a000007 bne c022a9cc <flush_stack+0x64>
skb1 = (i == final) ? skb : skb_clone(skb, GFP_ATOMIC);
c022a9ac: e155000a cmp r5, sl
c022a9b0: 0a00002b beq c022aa64 <flush_stack+0xfc>
c022a9b4: e1a00009 mov r0, r9
c022a9b8: e3a01020 mov r1, #32
c022a9bc: ebfffffe bl 0 <skb_clone>
c022a9bc: R_ARM_CALL skb_clone
c022a9c0: e1a04000 mov r4, r0
if (!skb1) {
c022a9c4: e3540000 cmp r4, #0
c022a9c8: 0a00000d beq c022aa04 <flush_stack+0x9c>
if (skb1 && udp_queue_rcv_skb(sk, skb1) <= 0)
c022a9cc: e1a00007 mov r0, r7
c022a9d0: e1a01004 mov r1, r4
c022a9d4: ebfffffe bl c022a6b4 <udp_queue_rcv_skb>
c022a9d4: R_ARM_CALL udp_queue_rcv_skb
c022a9d8: e3500000 cmp r0, #0
c022a9dc: caffffec bgt c022a994 <flush_stack+0x2c>
skb1 = NULL;
c022a9e0: e3a04000 mov r4, #0
for (i = 0; i < count; i++) {
c022a9e4: e2855001 add r5, r5, #1
c022a9e8: e1550008 cmp r5, r8
c022a9ec: 1affffeb bne c022a9a0 <flush_stack+0x38>
if (unlikely(skb1))
c022a9f0: e3540000 cmp r4, #0
c022a9f4: 08bd8ff8 popeq {r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}
kfree_skb(skb1);
c022a9f8: e1a00004 mov r0, r4
}
c022a9fc: e8bd4ff8 pop {r3, r4, r5, r6, r7, r8, r9, sl, fp, lr}
kfree_skb(skb1);
c022aa00: eafffffe b 0 <kfree_skb>
c022aa00: R_ARM_JUMP24 kfree_skb
asm volatile(
c022aa04: e10f2000 mrs r2, CPSR
c022aa08: e3823080 orr r3, r2, #128 ; 0x80
c022aa0c: e121f003 msr CPSR_c, r3
val = v->counter;
c022aa10: e597305c ldr r3, [r7, #92] ; 0x5c
v->counter = val += i;
c022aa14: e2833001 add r3, r3, #1
c022aa18: e587305c str r3, [r7, #92] ; 0x5c
asm volatile(
c022aa1c: e121f002 msr CPSR_c, r2
UDP_INC_STATS_BH(sock_net(sk), UDP_MIB_RCVBUFERRORS,
c022aa20: e5d731f8 ldrb r3, [r7, #504] ; 0x1f8
skb1 = NULL;
c022aa24: e3a04000 mov r4, #0
UDP_INC_STATS_BH(sock_net(sk), UDP_MIB_RCVBUFERRORS,
c022aa28: e3530000 cmp r3, #0
c022aa2c: 159b109c ldrne r1, [fp, #156] ; 0x9c
c022aa30: 059b1098 ldreq r1, [fp, #152] ; 0x98
c022aa34: e59f3030 ldr r3, [pc, #48] ; c022aa6c <flush_stack+0x104>
c022aa38: e5912014 ldr r2, [r1, #20]
c022aa3c: e2822001 add r2, r2, #1
c022aa40: e5812014 str r2, [r1, #20]
UDP_INC_STATS_BH(sock_net(sk), UDP_MIB_INERRORS,
c022aa44: e5d721f8 ldrb r2, [r7, #504] ; 0x1f8
c022aa48: e3520000 cmp r2, #0
c022aa4c: 1593209c ldrne r2, [r3, #156] ; 0x9c
c022aa50: 05932098 ldreq r2, [r3, #152] ; 0x98
c022aa54: e592300c ldr r3, [r2, #12]
c022aa58: e2833001 add r3, r3, #1
c022aa5c: e582300c str r3, [r2, #12]
c022aa60: eaffffdf b c022a9e4 <flush_stack+0x7c>
skb1 = (i == final) ? skb : skb_clone(skb, GFP_ATOMIC);
c022aa64: e1a04009 mov r4, r9
c022aa68: eaffffd5 b c022a9c4 <flush_stack+0x5c>
c022aa6c: 00000000 .word 0x00000000
c022aa6c: R_ARM_ABS32 init_net
c022aa70 <__udp4_lib_mcast_deliver.constprop.6>:
static int __udp4_lib_mcast_deliver(struct net *net, struct sk_buff *skb,
c022aa70: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
c022aa74: e24ddf45 sub sp, sp, #276 ; 0x114
c022aa78: e1a0e001 mov lr, r1
c022aa7c: e58d1000 str r1, [sp]
c022aa80: e1a0100d mov r1, sp
c022aa84: e3c1cd7f bic ip, r1, #8128 ; 0x1fc0
c022aa88: e1a0100c mov r1, ip
c022aa8c: e58dc00c str ip, [sp, #12]
struct udp_hslot *hslot = udp_hashslot(udptable, net, ntohs(uh->dest));
c022aa90: e1dec0b2 ldrh ip, [lr, #2]
c022aa94: e3c1403f bic r4, r1, #63 ; 0x3f
static int __udp4_lib_mcast_deliver(struct net *net, struct sk_buff *skb,
c022aa98: e59d5138 ldr r5, [sp, #312] ; 0x138
raw_spin_lock(&lock->rlock);
c022aa9c: e5946004 ldr r6, [r4, #4]
c022aaa0: e1a0142c lsr r1, ip, #8
c022aaa4: e595e008 ldr lr, [r5, #8]
c022aaa8: e181140c orr r1, r1, ip, lsl #8
c022aaac: e2866001 add r6, r6, #1
struct udp_hslot *hslot = udp_hashslot(udptable, net, ntohs(uh->dest));
c022aab0: e1a01801 lsl r1, r1, #16
static int __udp4_lib_mcast_deliver(struct net *net, struct sk_buff *skb,
c022aab4: e1a0a003 mov sl, r3
c022aab8: e58d0008 str r0, [sp, #8]
return &table->hash[udp_hashfn(net, num, table->mask)];
c022aabc: e5953000 ldr r3, [r5]
c022aac0: e00e1821 and r1, lr, r1, lsr #16
c022aac4: e5846004 str r6, [r4, #4]
return is_a_nulls(h->first);
c022aac8: e7934181 ldr r4, [r3, r1, lsl #3]
return hlist_nulls_empty(head) ? NULL : __sk_nulls_head(head);
c022aacc: e3140001 tst r4, #1
c022aad0: 0a00002a beq c022ab80 <__udp4_lib_mcast_deliver.constprop.6+0x110>
while (sk) {
c022aad4: e3a05000 mov r5, #0
c022aad8: e59d300c ldr r3, [sp, #12]
c022aadc: e3c3303f bic r3, r3, #63 ; 0x3f
raw_spin_unlock(&lock->rlock);
c022aae0: e5932004 ldr r2, [r3, #4]
c022aae4: e2422001 sub r2, r2, #1
c022aae8: e5832004 str r2, [r3, #4]
c022aaec: e5933000 ldr r3, [r3]
c022aaf0: e3130002 tst r3, #2
c022aaf4: 1a0000ab bne c022ada8 <__udp4_lib_mcast_deliver.constprop.6+0x338>
if (count) {
c022aaf8: e3550000 cmp r5, #0
c022aafc: 0a00001a beq c022ab6c <__udp4_lib_mcast_deliver.constprop.6+0xfc>
flush_stack(stack, count, skb, count - 1);
c022ab00: e59d2008 ldr r2, [sp, #8]
c022ab04: e28d0010 add r0, sp, #16
c022ab08: e1a01005 mov r1, r5
c022ab0c: e2453001 sub r3, r5, #1
c022ab10: ebffff94 bl c022a968 <flush_stack>
while (sk) {
c022ab14: e3a04000 mov r4, #0
c022ab18: e28d600c add r6, sp, #12
c022ab1c: ea000001 b c022ab28 <__udp4_lib_mcast_deliver.constprop.6+0xb8>
for (i = 0; i < count; i++)
c022ab20: e1550004 cmp r5, r4
c022ab24: 9a00000d bls c022ab60 <__udp4_lib_mcast_deliver.constprop.6+0xf0>
sock_put(stack[i]);
c022ab28: e5b60004 ldr r0, [r6, #4]!
asm volatile(
c022ab2c: e10f2000 mrs r2, CPSR
c022ab30: e3823080 orr r3, r2, #128 ; 0x80
c022ab34: e121f003 msr CPSR_c, r3
val = v->counter;
c022ab38: e590302c ldr r3, [r0, #44] ; 0x2c
v->counter = val -= i;
c022ab3c: e2433001 sub r3, r3, #1
c022ab40: e580302c str r3, [r0, #44] ; 0x2c
asm volatile(
c022ab44: e121f002 msr CPSR_c, r2
if (atomic_dec_and_test(&sk->sk_refcnt))
c022ab48: e3530000 cmp r3, #0
for (i = 0; i < count; i++)
c022ab4c: e2844001 add r4, r4, #1
c022ab50: 1afffff2 bne c022ab20 <__udp4_lib_mcast_deliver.constprop.6+0xb0>
sk_free(sk);
c022ab54: ebfffffe bl 0 <sk_free>
c022ab54: R_ARM_CALL sk_free
c022ab58: e1550004 cmp r5, r4
c022ab5c: 8afffff1 bhi c022ab28 <__udp4_lib_mcast_deliver.constprop.6+0xb8>
}
c022ab60: e3a00000 mov r0, #0
c022ab64: e28ddf45 add sp, sp, #276 ; 0x114
c022ab68: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
kfree_skb(skb);
c022ab6c: e59d0008 ldr r0, [sp, #8]
c022ab70: ebfffffe bl 0 <kfree_skb>
c022ab70: R_ARM_CALL kfree_skb
}
c022ab74: e3a00000 mov r0, #0
c022ab78: e28ddf45 add sp, sp, #276 ; 0x114
c022ab7c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
sk = udp_v4_mcast_next(net, sk, uh->dest, daddr, uh->source, saddr, dif);
c022ab80: e59d1000 ldr r1, [sp]
dif = skb->dev->ifindex;
c022ab84: e59d3008 ldr r3, [sp, #8]
sk = udp_v4_mcast_next(net, sk, uh->dest, daddr, uh->source, saddr, dif);
c022ab88: e1d160b2 ldrh r6, [r1, #2]
c022ab8c: e1a08002 mov r8, r2
dif = skb->dev->ifindex;
c022ab90: e5932014 ldr r2, [r3, #20]
c022ab94: e1a03406 lsl r3, r6, #8
c022ab98: e1836426 orr r6, r3, r6, lsr #8
c022ab9c: e1a06806 lsl r6, r6, #16
sk_nulls_for_each_from(s, node) {
c022aba0: e3540020 cmp r4, #32
c022aba4: e1a06826 lsr r6, r6, #16
dif = skb->dev->ifindex;
c022aba8: e59290b0 ldr r9, [r2, #176] ; 0xb0
sk = udp_v4_mcast_next(net, sk, uh->dest, daddr, uh->source, saddr, dif);
c022abac: e1d1b0b0 ldrh fp, [r1]
sk_nulls_for_each_from(s, node) {
c022abb0: 1a000003 bne c022abc4 <__udp4_lib_mcast_deliver.constprop.6+0x154>
c022abb4: eaffffc6 b c022aad4 <__udp4_lib_mcast_deliver.constprop.6+0x64>
c022abb8: e5944000 ldr r4, [r4]
c022abbc: e3140001 tst r4, #1
c022abc0: 1affffc3 bne c022aad4 <__udp4_lib_mcast_deliver.constprop.6+0x64>
if (!net_eq(sock_net(s), net) ||
c022abc4: e15401b8 ldrh r0, [r4, #-24] ; 0xffffffe8
c022abc8: e1500006 cmp r0, r6
c022abcc: 1afffff9 bne c022abb8 <__udp4_lib_mcast_deliver.constprop.6+0x148>
(inet->inet_daddr && inet->inet_daddr != rmt_addr) ||
c022abd0: e5140020 ldr r0, [r4, #-32] ; 0xffffffe0
c022abd4: e1500008 cmp r0, r8
c022abd8: 13500000 cmpne r0, #0
c022abdc: 1afffff5 bne c022abb8 <__udp4_lib_mcast_deliver.constprop.6+0x148>
(inet->inet_dport != rmt_port && inet->inet_dport) ||
c022abe0: e2843f4e add r3, r4, #312 ; 0x138
c022abe4: e1d300b0 ldrh r0, [r3]
c022abe8: e15b0000 cmp fp, r0
c022abec: 13500000 cmpne r0, #0
c022abf0: 1afffff0 bne c022abb8 <__udp4_lib_mcast_deliver.constprop.6+0x148>
(inet->inet_rcv_saddr &&
c022abf4: e514301c ldr r3, [r4, #-28] ; 0xffffffe4
c022abf8: e153000a cmp r3, sl
c022abfc: 13530000 cmpne r3, #0
c022ac00: 1affffec bne c022abb8 <__udp4_lib_mcast_deliver.constprop.6+0x148>
(s->sk_bound_dev_if && s->sk_bound_dev_if != dif))
c022ac04: e5147010 ldr r7, [r4, #-16]
c022ac08: e1590007 cmp r9, r7
c022ac0c: 13570000 cmpne r7, #0
c022ac10: 13a07001 movne r7, #1
c022ac14: 03a07000 moveq r7, #0
c022ac18: 1affffe6 bne c022abb8 <__udp4_lib_mcast_deliver.constprop.6+0x148>
sk_nulls_for_each_from(s, node) {
c022ac1c: e2445020 sub r5, r4, #32
if (!ip_mc_sf_allow(s, loc_addr, rmt_addr, dif))
c022ac20: e1a00005 mov r0, r5
c022ac24: e1a0100a mov r1, sl
c022ac28: e1a02008 mov r2, r8
c022ac2c: e1a03009 mov r3, r9
c022ac30: ebfffffe bl 0 <ip_mc_sf_allow>
c022ac30: R_ARM_CALL ip_mc_sf_allow
c022ac34: e3500000 cmp r0, #0
c022ac38: 0affffde beq c022abb8 <__udp4_lib_mcast_deliver.constprop.6+0x148>
while (sk) {
c022ac3c: e3550000 cmp r5, #0
flush_stack(stack, count, skb, ~0);
c022ac40: 11a0b005 movne fp, r5
while (sk) {
c022ac44: 0affffa3 beq c022aad8 <__udp4_lib_mcast_deliver.constprop.6+0x68>
stack[count++] = sk;
c022ac48: e28d3e11 add r3, sp, #272 ; 0x110
c022ac4c: e0833107 add r3, r3, r7, lsl #2
c022ac50: e503b100 str fp, [r3, #-256] ; 0xffffff00
return (!is_a_nulls(sk->sk_nulls_node.next)) ?
c022ac54: e59b4020 ldr r4, [fp, #32]
struct sock, sk_nulls_node) :
c022ac58: e3140001 tst r4, #1
c022ac5c: 1a000032 bne c022ad2c <__udp4_lib_mcast_deliver.constprop.6+0x2bc>
sk = udp_v4_mcast_next(net, sk_nulls_next(sk), uh->dest,
c022ac60: e59d2000 ldr r2, [sp]
sk_nulls_for_each_from(s, node) {
c022ac64: e3540020 cmp r4, #32
sk = udp_v4_mcast_next(net, sk_nulls_next(sk), uh->dest,
c022ac68: e1d260b2 ldrh r6, [r2, #2]
stack[count++] = sk;
c022ac6c: e2877001 add r7, r7, #1
c022ac70: e1a03406 lsl r3, r6, #8
c022ac74: e1836426 orr r6, r3, r6, lsr #8
c022ac78: e1a06806 lsl r6, r6, #16
c022ac7c: e1a06826 lsr r6, r6, #16
sk = udp_v4_mcast_next(net, sk_nulls_next(sk), uh->dest,
c022ac80: e1d250b0 ldrh r5, [r2]
sk_nulls_for_each_from(s, node) {
c022ac84: 1a000003 bne c022ac98 <__udp4_lib_mcast_deliver.constprop.6+0x228>
c022ac88: ea000028 b c022ad30 <__udp4_lib_mcast_deliver.constprop.6+0x2c0>
c022ac8c: e5944000 ldr r4, [r4]
c022ac90: e3140001 tst r4, #1
c022ac94: 1a000025 bne c022ad30 <__udp4_lib_mcast_deliver.constprop.6+0x2c0>
if (!net_eq(sock_net(s), net) ||
c022ac98: e15401b8 ldrh r0, [r4, #-24] ; 0xffffffe8
c022ac9c: e1500006 cmp r0, r6
c022aca0: 1afffff9 bne c022ac8c <__udp4_lib_mcast_deliver.constprop.6+0x21c>
(inet->inet_daddr && inet->inet_daddr != rmt_addr) ||
c022aca4: e5140020 ldr r0, [r4, #-32] ; 0xffffffe0
c022aca8: e1580000 cmp r8, r0
c022acac: 13500000 cmpne r0, #0
c022acb0: 1afffff5 bne c022ac8c <__udp4_lib_mcast_deliver.constprop.6+0x21c>
(inet->inet_dport != rmt_port && inet->inet_dport) ||
c022acb4: e2843f4e add r3, r4, #312 ; 0x138
c022acb8: e1d330b0 ldrh r3, [r3]
c022acbc: e1550003 cmp r5, r3
c022acc0: 13530000 cmpne r3, #0
c022acc4: 1afffff0 bne c022ac8c <__udp4_lib_mcast_deliver.constprop.6+0x21c>
(inet->inet_rcv_saddr &&
c022acc8: e514301c ldr r3, [r4, #-28] ; 0xffffffe4
c022accc: e15a0003 cmp sl, r3
c022acd0: 13530000 cmpne r3, #0
c022acd4: 1affffec bne c022ac8c <__udp4_lib_mcast_deliver.constprop.6+0x21c>
(s->sk_bound_dev_if && s->sk_bound_dev_if != dif))
c022acd8: e5143010 ldr r3, [r4, #-16]
c022acdc: e1590003 cmp r9, r3
c022ace0: 13530000 cmpne r3, #0
c022ace4: 13a03001 movne r3, #1
c022ace8: 03a03000 moveq r3, #0
c022acec: e58d3004 str r3, [sp, #4]
c022acf0: 1affffe5 bne c022ac8c <__udp4_lib_mcast_deliver.constprop.6+0x21c>
sk_nulls_for_each_from(s, node) {
c022acf4: e244b020 sub fp, r4, #32
if (!ip_mc_sf_allow(s, loc_addr, rmt_addr, dif))
c022acf8: e1a0000b mov r0, fp
c022acfc: e1a0100a mov r1, sl
c022ad00: e1a02008 mov r2, r8
c022ad04: e1a03009 mov r3, r9
c022ad08: ebfffffe bl 0 <ip_mc_sf_allow>
c022ad08: R_ARM_CALL ip_mc_sf_allow
c022ad0c: e3500000 cmp r0, #0
c022ad10: 0affffdd beq c022ac8c <__udp4_lib_mcast_deliver.constprop.6+0x21c>
if (unlikely(count == ARRAY_SIZE(stack))) {
c022ad14: e3570040 cmp r7, #64 ; 0x40
c022ad18: 0a000017 beq c022ad7c <__udp4_lib_mcast_deliver.constprop.6+0x30c>
while (sk) {
c022ad1c: e35b0000 cmp fp, #0
c022ad20: 1affffc8 bne c022ac48 <__udp4_lib_mcast_deliver.constprop.6+0x1d8>
c022ad24: e1a05007 mov r5, r7
c022ad28: ea000003 b c022ad3c <__udp4_lib_mcast_deliver.constprop.6+0x2cc>
stack[count++] = sk;
c022ad2c: e2877001 add r7, r7, #1
if (unlikely(count == ARRAY_SIZE(stack))) {
c022ad30: e3570040 cmp r7, #64 ; 0x40
while (sk) {
c022ad34: e1a05007 mov r5, r7
if (unlikely(count == ARRAY_SIZE(stack))) {
c022ad38: 0a000018 beq c022ada0 <__udp4_lib_mcast_deliver.constprop.6+0x330>
for (i = 0; i < count; i++)
c022ad3c: e3570000 cmp r7, #0
c022ad40: 0affff64 beq c022aad8 <__udp4_lib_mcast_deliver.constprop.6+0x68>
while (sk) {
c022ad44: e3a02000 mov r2, #0
c022ad48: e28d100c add r1, sp, #12
sock_hold(stack[i]);
c022ad4c: e5b10004 ldr r0, [r1, #4]!
asm volatile(
c022ad50: e10fc000 mrs ip, CPSR
c022ad54: e38c3080 orr r3, ip, #128 ; 0x80
c022ad58: e121f003 msr CPSR_c, r3
val = v->counter;
c022ad5c: e590302c ldr r3, [r0, #44] ; 0x2c
v->counter = val += i;
c022ad60: e2833001 add r3, r3, #1
c022ad64: e580302c str r3, [r0, #44] ; 0x2c
asm volatile(
c022ad68: e121f00c msr CPSR_c, ip
for (i = 0; i < count; i++)
c022ad6c: e2822001 add r2, r2, #1
c022ad70: e1550002 cmp r5, r2
c022ad74: 8afffff4 bhi c022ad4c <__udp4_lib_mcast_deliver.constprop.6+0x2dc>
c022ad78: eaffff56 b c022aad8 <__udp4_lib_mcast_deliver.constprop.6+0x68>
if (!sk)
c022ad7c: e35b0000 cmp fp, #0
c022ad80: 0a000006 beq c022ada0 <__udp4_lib_mcast_deliver.constprop.6+0x330>
flush_stack(stack, count, skb, ~0);
c022ad84: e1a01007 mov r1, r7
c022ad88: e28d0010 add r0, sp, #16
c022ad8c: e59d2008 ldr r2, [sp, #8]
c022ad90: e3e03000 mvn r3, #0
count = 0;
c022ad94: e59d7004 ldr r7, [sp, #4]
flush_stack(stack, count, skb, ~0);
c022ad98: ebfffef2 bl c022a968 <flush_stack>
c022ad9c: eaffffa9 b c022ac48 <__udp4_lib_mcast_deliver.constprop.6+0x1d8>
while (sk) {
c022ada0: e3a05040 mov r5, #64 ; 0x40
c022ada4: eaffffe6 b c022ad44 <__udp4_lib_mcast_deliver.constprop.6+0x2d4>
c022ada8: ebfffffe bl 0 <preempt_schedule>
c022ada8: R_ARM_CALL preempt_schedule
c022adac: eaffff51 b c022aaf8 <__udp4_lib_mcast_deliver.constprop.6+0x88>
c022adb0 <__udp4_lib_rcv>:
{
c022adb0: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
return skb->len - skb->data_len;
c022adb4: e590c04c ldr ip, [r0, #76] ; 0x4c
c022adb8: e5903050 ldr r3, [r0, #80] ; 0x50
c022adbc: e1a08001 mov r8, r1
c022adc0: e063100c rsb r1, r3, ip
if (likely(len <= skb_headlen(skb)))
c022adc4: e3510007 cmp r1, #7
c022adc8: e24dd01c sub sp, sp, #28
c022adcc: e1a04000 mov r4, r0
c022add0: e1a05002 mov r5, r2
WARN_ON((skb->_skb_refdst & SKB_DST_NOREF) &&
c022add4: e5909048 ldr r9, [r0, #72] ; 0x48
if (likely(len <= skb_headlen(skb)))
c022add8: 9a000086 bls c022aff8 <__udp4_lib_rcv+0x248>
return skb->transport_header;
c022addc: e590607c ldr r6, [r0, #124] ; 0x7c
ulen = ntohs(uh->len);
c022ade0: e1d670b4 ldrh r7, [r6, #4]
c022ade4: e1a03407 lsl r3, r7, #8
c022ade8: e1837427 orr r7, r3, r7, lsr #8
return skb->network_header;
c022adec: e5943080 ldr r3, [r4, #128] ; 0x80
c022adf0: e1a07807 lsl r7, r7, #16
c022adf4: e1a07827 lsr r7, r7, #16
saddr = ip_hdr(skb)->saddr;
c022adf8: e593100c ldr r1, [r3, #12]
daddr = ip_hdr(skb)->daddr;
c022adfc: e5932010 ldr r2, [r3, #16]
if (ulen > skb->len)
c022ae00: e157000c cmp r7, ip
saddr = ip_hdr(skb)->saddr;
c022ae04: e58d1010 str r1, [sp, #16]
daddr = ip_hdr(skb)->daddr;
c022ae08: e58d2014 str r2, [sp, #20]
if (ulen > skb->len)
c022ae0c: 9a00000f bls c022ae50 <__udp4_lib_rcv+0xa0>
LIMIT_NETDEBUG(KERN_DEBUG "UDP%s: short packet: From %pI4:%u %d/%d to %pI4:%u\n",
c022ae10: e59f34f4 ldr r3, [pc, #1268] ; c022b30c <__udp4_lib_rcv+0x55c>
c022ae14: e5933000 ldr r3, [r3]
c022ae18: e3530000 cmp r3, #0
c022ae1c: 1a00007f bne c022b020 <__udp4_lib_rcv+0x270>
UDP_INC_STATS_BH(net, UDP_MIB_INERRORS, proto == IPPROTO_UDPLITE);
c022ae20: e3550088 cmp r5, #136 ; 0x88
c022ae24: 0a00004f beq c022af68 <__udp4_lib_rcv+0x1b8>
c022ae28: e59f34e0 ldr r3, [pc, #1248] ; c022b310 <__udp4_lib_rcv+0x560>
c022ae2c: e5932098 ldr r2, [r3, #152] ; 0x98
c022ae30: e592300c ldr r3, [r2, #12]
c022ae34: e2833001 add r3, r3, #1
c022ae38: e582300c str r3, [r2, #12]
kfree_skb(skb);
c022ae3c: e1a00004 mov r0, r4
c022ae40: ebfffffe bl 0 <kfree_skb>
c022ae40: R_ARM_CALL kfree_skb
return 0;
c022ae44: e3a00000 mov r0, #0
}
c022ae48: e28dd01c add sp, sp, #28
c022ae4c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
if (proto == IPPROTO_UDP) {
c022ae50: e3550011 cmp r5, #17
c022ae54: 0a000049 beq c022af80 <__udp4_lib_rcv+0x1d0>
UDP_SKB_CB(skb)->partial_cov = 0;
c022ae58: e3a02000 mov r2, #0
if (proto == IPPROTO_UDPLITE) {
c022ae5c: e3550088 cmp r5, #136 ; 0x88
UDP_SKB_CB(skb)->cscov = skb->len;
c022ae60: e1c4c2bc strh ip, [r4, #44] ; 0x2c
UDP_SKB_CB(skb)->partial_cov = 0;
c022ae64: e5c4202e strb r2, [r4, #46] ; 0x2e
if (proto == IPPROTO_UDPLITE) {
c022ae68: 0a000089 beq c022b094 <__udp4_lib_rcv+0x2e4>
c022ae6c: e1a0e003 mov lr, r3
c022ae70: e1d620b6 ldrh r2, [r6, #6]
if (uh->check == 0) {
c022ae74: e3520000 cmp r2, #0
c022ae78: 0a000080 beq c022b080 <__udp4_lib_rcv+0x2d0>
} else if (skb->ip_summed == CHECKSUM_COMPLETE) {
c022ae7c: e5d43060 ldrb r3, [r4, #96] ; 0x60
c022ae80: e203200c and r2, r3, #12
c022ae84: e3520008 cmp r2, #8
c022ae88: 0a00006c beq c022b040 <__udp4_lib_rcv+0x290>
return skb->ip_summed & CHECKSUM_UNNECESSARY;
c022ae8c: e1a03123 lsr r3, r3, #2
if (!skb_csum_unnecessary(skb))
c022ae90: e2133001 ands r3, r3, #1
c022ae94: 1a00000b bne c022aec8 <__udp4_lib_rcv+0x118>
c022ae98: e1a01805 lsl r1, r5, #16
c022ae9c: e1a02421 lsr r2, r1, #8
__asm__(
c022aea0: e59e0010 ldr r0, [lr, #16]
c022aea4: e59ec00c ldr ip, [lr, #12]
c022aea8: e1822c21 orr r2, r2, r1, lsr #24
skb->csum = csum_tcpudp_nofold(iph->saddr, iph->daddr,
c022aeac: e594a04c ldr sl, [r4, #76] ; 0x4c
c022aeb0: e0931000 adds r1, r3, r0
c022aeb4: e0b1100c adcs r1, r1, ip
c022aeb8: e0b1140a adcs r1, r1, sl, lsl #8
c022aebc: e0b11002 adcs r1, r1, r2
c022aec0: e2a11000 adc r1, r1, #0
c022aec4: e5841058 str r1, [r4, #88] ; 0x58
return (struct dst_entry *)(skb->_skb_refdst & SKB_DST_PTRMASK);
c022aec8: e3c99001 bic r9, r9, #1
if (rt->rt_flags & (RTCF_BROADCAST|RTCF_MULTICAST))
c022aecc: e1d935be ldrh r3, [r9, #94] ; 0x5e
c022aed0: e1a03803 lsl r3, r3, #16
c022aed4: e2133203 ands r3, r3, #805306368 ; 0x30000000
c022aed8: 1a0000c3 bne c022b1ec <__udp4_lib_rcv+0x43c>
sock_net_set(sk, hold_net(net));
}
static inline struct sock *skb_steal_sock(struct sk_buff *skb)
{
if (unlikely(skb->sk)) {
c022aedc: e5949010 ldr r9, [r4, #16]
sk = __udp4_lib_lookup_skb(skb, uh->source, uh->dest, udptable);
c022aee0: e1d620b0 ldrh r2, [r6]
c022aee4: e3590000 cmp r9, #0
c022aee8: e1d6c0b2 ldrh ip, [r6, #2]
c022aeec: 1a0000d2 bne c022b23c <__udp4_lib_rcv+0x48c>
c022aef0: e5940048 ldr r0, [r4, #72] ; 0x48
return __udp4_lib_lookup(dev_net(skb_dst(skb)->dev), iph->saddr, sport,
c022aef4: e59e100c ldr r1, [lr, #12]
c022aef8: e59e3010 ldr r3, [lr, #16]
c022aefc: e3c00001 bic r0, r0, #1
c022af00: e58dc000 str ip, [sp]
return rt->peer;
}
static inline int inet_iif(const struct sk_buff *skb)
{
return skb_rtable(skb)->rt_iif;
c022af04: e1d0c7b0 ldrh ip, [r0, #112] ; 0x70
c022af08: e1d007b2 ldrh r0, [r0, #114] ; 0x72
c022af0c: e18c0800 orr r0, ip, r0, lsl #16
c022af10: e98d0101 stmib sp, {r0, r8}
c022af14: e59f03f4 ldr r0, [pc, #1012] ; c022b310 <__udp4_lib_rcv+0x560>
c022af18: ebfffffe bl c0229f64 <__udp4_lib_lookup>
c022af18: R_ARM_CALL __udp4_lib_lookup
if (sk != NULL) {
c022af1c: e2509000 subs r9, r0, #0
c022af20: 0a00009b beq c022b194 <__udp4_lib_rcv+0x3e4>
int ret = udp_queue_rcv_skb(sk, skb);
c022af24: e1a01004 mov r1, r4
c022af28: e1a00009 mov r0, r9
c022af2c: ebfffffe bl c022a6b4 <udp_queue_rcv_skb>
c022af2c: R_ARM_CALL udp_queue_rcv_skb
c022af30: e1a04000 mov r4, r0
asm volatile(
c022af34: e10f2000 mrs r2, CPSR
c022af38: e3823080 orr r3, r2, #128 ; 0x80
c022af3c: e121f003 msr CPSR_c, r3
val = v->counter;
c022af40: e599302c ldr r3, [r9, #44] ; 0x2c
v->counter = val -= i;
c022af44: e2433001 sub r3, r3, #1
c022af48: e589302c str r3, [r9, #44] ; 0x2c
asm volatile(
c022af4c: e121f002 msr CPSR_c, r2
if (atomic_dec_and_test(&sk->sk_refcnt))
c022af50: e3530000 cmp r3, #0
c022af54: 0a0000a1 beq c022b1e0 <__udp4_lib_rcv+0x430>
if (ret > 0)
c022af58: e3540000 cmp r4, #0
return -ret;
c022af5c: c2640000 rsbgt r0, r4, #0
return 0;
c022af60: d3a00000 movle r0, #0
c022af64: eaffffb7 b c022ae48 <__udp4_lib_rcv+0x98>
UDP_INC_STATS_BH(net, UDP_MIB_INERRORS, proto == IPPROTO_UDPLITE);
c022af68: e59f33a0 ldr r3, [pc, #928] ; c022b310 <__udp4_lib_rcv+0x560>
c022af6c: e593209c ldr r2, [r3, #156] ; 0x9c
c022af70: e592300c ldr r3, [r2, #12]
c022af74: e2833001 add r3, r3, #1
c022af78: e582300c str r3, [r2, #12]
c022af7c: eaffffae b c022ae3c <__udp4_lib_rcv+0x8c>
if (ulen < sizeof(*uh) || pskb_trim_rcsum(skb, ulen))
c022af80: e3570007 cmp r7, #7
c022af84: 8a000064 bhi c022b11c <__udp4_lib_rcv+0x36c>
LIMIT_NETDEBUG(KERN_DEBUG "UDP%s: short packet: From %pI4:%u %d/%d to %pI4:%u\n",
c022af88: e59f337c ldr r3, [pc, #892] ; c022b30c <__udp4_lib_rcv+0x55c>
c022af8c: e5933000 ldr r3, [r3]
c022af90: e3530000 cmp r3, #0
c022af94: 0affffa3 beq c022ae28 <__udp4_lib_rcv+0x78>
c022af98: ebfffffe bl 0 <net_ratelimit>
c022af98: R_ARM_CALL net_ratelimit
c022af9c: e3500000 cmp r0, #0
c022afa0: 0affffa0 beq c022ae28 <__udp4_lib_rcv+0x78>
c022afa4: e1d6c0b0 ldrh ip, [r6]
c022afa8: e59f1364 ldr r1, [pc, #868] ; c022b314 <__udp4_lib_rcv+0x564>
c022afac: e1d620b2 ldrh r2, [r6, #2]
c022afb0: e1a0040c lsl r0, ip, #8
c022afb4: e1a03422 lsr r3, r2, #8
c022afb8: e1832402 orr r2, r3, r2, lsl #8
c022afbc: e1a02802 lsl r2, r2, #16
c022afc0: e180342c orr r3, r0, ip, lsr #8
c022afc4: e594c04c ldr ip, [r4, #76] ; 0x4c
c022afc8: e28d0014 add r0, sp, #20
c022afcc: e1a02822 lsr r2, r2, #16
c022afd0: e1a03803 lsl r3, r3, #16
c022afd4: e58d200c str r2, [sp, #12]
c022afd8: e58d0008 str r0, [sp, #8]
c022afdc: e58d7000 str r7, [sp]
c022afe0: e1a03823 lsr r3, r3, #16
c022afe4: e58dc004 str ip, [sp, #4]
c022afe8: e28d2010 add r2, sp, #16
c022afec: e59f0324 ldr r0, [pc, #804] ; c022b318 <__udp4_lib_rcv+0x568>
c022aff0: ebfffffe bl 0 <printk>
c022aff0: R_ARM_CALL printk
c022aff4: eaffff89 b c022ae20 <__udp4_lib_rcv+0x70>
if (unlikely(len > skb->len))
c022aff8: e35c0007 cmp ip, #7
c022affc: 9affff87 bls c022ae20 <__udp4_lib_rcv+0x70>
return __pskb_pull_tail(skb, len - skb_headlen(skb)) != NULL;
c022b000: e2611008 rsb r1, r1, #8
c022b004: ebfffffe bl 0 <__pskb_pull_tail>
c022b004: R_ARM_CALL __pskb_pull_tail
if (!pskb_may_pull(skb, sizeof(struct udphdr)))
c022b008: e3500000 cmp r0, #0
c022b00c: 0affff83 beq c022ae20 <__udp4_lib_rcv+0x70>
return skb->transport_header;
c022b010: e594607c ldr r6, [r4, #124] ; 0x7c
c022b014: e594c04c ldr ip, [r4, #76] ; 0x4c
ulen = ntohs(uh->len);
c022b018: e1d670b4 ldrh r7, [r6, #4]
c022b01c: eaffff70 b c022ade4 <__udp4_lib_rcv+0x34>
LIMIT_NETDEBUG(KERN_DEBUG "UDP%s: short packet: From %pI4:%u %d/%d to %pI4:%u\n",
c022b020: ebfffffe bl 0 <net_ratelimit>
c022b020: R_ARM_CALL net_ratelimit
c022b024: e3500000 cmp r0, #0
c022b028: 0affff7c beq c022ae20 <__udp4_lib_rcv+0x70>
c022b02c: e3550088 cmp r5, #136 ; 0x88
c022b030: 1affffdb bne c022afa4 <__udp4_lib_rcv+0x1f4>
c022b034: e1d6c0b0 ldrh ip, [r6]
c022b038: e59f12dc ldr r1, [pc, #732] ; c022b31c <__udp4_lib_rcv+0x56c>
c022b03c: eaffffda b c022afac <__udp4_lib_rcv+0x1fc>
c022b040: e1a01805 lsl r1, r5, #16
c022b044: e1a02421 lsr r2, r1, #8
c022b048: e1821c21 orr r1, r2, r1, lsr #24
c022b04c: e5940058 ldr r0, [r4, #88] ; 0x58
c022b050: e59ec010 ldr ip, [lr, #16]
c022b054: e59ea00c ldr sl, [lr, #12]
if (!csum_tcpudp_magic(iph->saddr, iph->daddr, skb->len,
c022b058: e594b04c ldr fp, [r4, #76] ; 0x4c
c022b05c: e090200c adds r2, r0, ip
c022b060: e0b2200a adcs r2, r2, sl
c022b064: e0b2240b adcs r2, r2, fp, lsl #8
c022b068: e0b22001 adcs r2, r2, r1
c022b06c: e2a22000 adc r2, r2, #0
__asm__(
c022b070: e0822862 add r2, r2, r2, ror #16
return (__force __sum16)(~(__force u32)sum >> 16);
c022b074: e1e02002 mvn r2, r2
c022b078: e1b02822 lsrs r2, r2, #16
c022b07c: 1affff82 bne c022ae8c <__udp4_lib_rcv+0xdc>
skb->ip_summed = CHECKSUM_UNNECESSARY;
c022b080: e5d43060 ldrb r3, [r4, #96] ; 0x60
c022b084: e3c33008 bic r3, r3, #8
c022b088: e3833004 orr r3, r3, #4
c022b08c: e5c43060 strb r3, [r4, #96] ; 0x60
c022b090: eaffff8c b c022aec8 <__udp4_lib_rcv+0x118>
if (uh->check == 0) {
c022b094: e1d620b6 ldrh r2, [r6, #6]
c022b098: e3520000 cmp r2, #0
c022b09c: 1a000026 bne c022b13c <__udp4_lib_rcv+0x38c>
LIMIT_NETDEBUG(KERN_DEBUG "UDPLite: zeroed checksum field\n");
c022b0a0: e59f8264 ldr r8, [pc, #612] ; c022b30c <__udp4_lib_rcv+0x55c>
c022b0a4: e5983000 ldr r3, [r8]
c022b0a8: e3530000 cmp r3, #0
c022b0ac: 0affffad beq c022af68 <__udp4_lib_rcv+0x1b8>
c022b0b0: ebfffffe bl 0 <net_ratelimit>
c022b0b0: R_ARM_CALL net_ratelimit
c022b0b4: e3500000 cmp r0, #0
c022b0b8: 1a000090 bne c022b300 <__udp4_lib_rcv+0x550>
c022b0bc: e5983000 ldr r3, [r8]
LIMIT_NETDEBUG(KERN_DEBUG "UDP%s: bad checksum. From %pI4:%u to %pI4:%u ulen %d\n",
c022b0c0: e3530000 cmp r3, #0
c022b0c4: 0affffa7 beq c022af68 <__udp4_lib_rcv+0x1b8>
c022b0c8: ebfffffe bl 0 <net_ratelimit>
c022b0c8: R_ARM_CALL net_ratelimit
c022b0cc: e3500000 cmp r0, #0
c022b0d0: 0affffa4 beq c022af68 <__udp4_lib_rcv+0x1b8>
c022b0d4: e1d6c0b0 ldrh ip, [r6]
c022b0d8: e59f123c ldr r1, [pc, #572] ; c022b31c <__udp4_lib_rcv+0x56c>
c022b0dc: e1d620b2 ldrh r2, [r6, #2]
c022b0e0: e1a0040c lsl r0, ip, #8
c022b0e4: e1a03422 lsr r3, r2, #8
c022b0e8: e1832402 orr r2, r3, r2, lsl #8
c022b0ec: e1a02802 lsl r2, r2, #16
c022b0f0: e180342c orr r3, r0, ip, lsr #8
c022b0f4: e1a02822 lsr r2, r2, #16
c022b0f8: e28d0014 add r0, sp, #20
c022b0fc: e1a03803 lsl r3, r3, #16
c022b100: e98d0084 stmib sp, {r2, r7}
c022b104: e58d0000 str r0, [sp]
c022b108: e1a03823 lsr r3, r3, #16
c022b10c: e28d2010 add r2, sp, #16
c022b110: e59f0208 ldr r0, [pc, #520] ; c022b320 <__udp4_lib_rcv+0x570>
c022b114: ebfffffe bl 0 <printk>
c022b114: R_ARM_CALL printk
c022b118: eaffff40 b c022ae20 <__udp4_lib_rcv+0x70>
if (likely(len >= skb->len))
c022b11c: e157000c cmp r7, ip
c022b120: 3a000059 bcc c022b28c <__udp4_lib_rcv+0x4dc>
{
c022b124: e1a0e003 mov lr, r3
UDP_SKB_CB(skb)->partial_cov = 0;
c022b128: e3a03000 mov r3, #0
UDP_SKB_CB(skb)->cscov = skb->len;
c022b12c: e1c4c2bc strh ip, [r4, #44] ; 0x2c
UDP_SKB_CB(skb)->partial_cov = 0;
c022b130: e5c4302e strb r3, [r4, #46] ; 0x2e
c022b134: e1d620b6 ldrh r2, [r6, #6]
c022b138: eaffff4d b c022ae74 <__udp4_lib_rcv+0xc4>
cscov = ntohs(uh->len);
c022b13c: e1d600b4 ldrh r0, [r6, #4]
c022b140: e1a01420 lsr r1, r0, #8
c022b144: e1811400 orr r1, r1, r0, lsl #8
c022b148: e1a01801 lsl r1, r1, #16
if (cscov == 0) /* Indicates that full coverage is required. */
c022b14c: e1b0a821 lsrs sl, r1, #16
c022b150: 0a00000d beq c022b18c <__udp4_lib_rcv+0x3dc>
else if (cscov < 8 || cscov > skb->len) {
c022b154: e35a0007 cmp sl, #7
c022b158: 9a00002a bls c022b208 <__udp4_lib_rcv+0x458>
c022b15c: e15a000c cmp sl, ip
c022b160: 8a000028 bhi c022b208 <__udp4_lib_rcv+0x458>
} else if (cscov < skb->len) {
c022b164: 2a000008 bcs c022b18c <__udp4_lib_rcv+0x3dc>
UDP_SKB_CB(skb)->partial_cov = 1;
c022b168: e3a01001 mov r1, #1
if (skb->ip_summed == CHECKSUM_COMPLETE)
c022b16c: e5d42060 ldrb r2, [r4, #96] ; 0x60
UDP_SKB_CB(skb)->cscov = cscov;
c022b170: e1c4a2bc strh sl, [r4, #44] ; 0x2c
if (skb->ip_summed == CHECKSUM_COMPLETE)
c022b174: e202000c and r0, r2, #12
c022b178: e3500008 cmp r0, #8
skb->ip_summed = CHECKSUM_NONE;
c022b17c: 03c2200c biceq r2, r2, #12
UDP_SKB_CB(skb)->partial_cov = 1;
c022b180: e5c4102e strb r1, [r4, #46] ; 0x2e
skb->ip_summed = CHECKSUM_NONE;
c022b184: 05c42060 strbeq r2, [r4, #96] ; 0x60
c022b188: e1d620b6 ldrh r2, [r6, #6]
{
c022b18c: e1a0e003 mov lr, r3
c022b190: eaffff37 b c022ae74 <__udp4_lib_rcv+0xc4>
return skb->ip_summed & CHECKSUM_UNNECESSARY;
c022b194: e5d43060 ldrb r3, [r4, #96] ; 0x60
return !skb_csum_unnecessary(skb) &&
c022b198: e3130004 tst r3, #4
c022b19c: 0a000029 beq c022b248 <__udp4_lib_rcv+0x498>
UDP_INC_STATS_BH(net, UDP_MIB_NOPORTS, proto == IPPROTO_UDPLITE);
c022b1a0: e3550088 cmp r5, #136 ; 0x88
c022b1a4: 0a000046 beq c022b2c4 <__udp4_lib_rcv+0x514>
c022b1a8: e59f3160 ldr r3, [pc, #352] ; c022b310 <__udp4_lib_rcv+0x560>
c022b1ac: e5932098 ldr r2, [r3, #152] ; 0x98
c022b1b0: e5923008 ldr r3, [r2, #8]
c022b1b4: e2833001 add r3, r3, #1
c022b1b8: e5823008 str r3, [r2, #8]
icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0);
c022b1bc: e3a01003 mov r1, #3
c022b1c0: e1a00004 mov r0, r4
c022b1c4: e1a02001 mov r2, r1
c022b1c8: e3a03000 mov r3, #0
c022b1cc: ebfffffe bl 0 <icmp_send>
c022b1cc: R_ARM_CALL icmp_send
kfree_skb(skb);
c022b1d0: e1a00004 mov r0, r4
c022b1d4: ebfffffe bl 0 <kfree_skb>
c022b1d4: R_ARM_CALL kfree_skb
return 0;
c022b1d8: e3a00000 mov r0, #0
c022b1dc: eaffff19 b c022ae48 <__udp4_lib_rcv+0x98>
sk_free(sk);
c022b1e0: e1a00009 mov r0, r9
c022b1e4: ebfffffe bl 0 <sk_free>
c022b1e4: R_ARM_CALL sk_free
c022b1e8: eaffff5a b c022af58 <__udp4_lib_rcv+0x1a8>
return __udp4_lib_mcast_deliver(net, skb, uh,
c022b1ec: e59d2010 ldr r2, [sp, #16]
c022b1f0: e59d3014 ldr r3, [sp, #20]
c022b1f4: e58d8000 str r8, [sp]
c022b1f8: e1a00004 mov r0, r4
c022b1fc: e1a01006 mov r1, r6
c022b200: ebfffe1a bl c022aa70 <__udp4_lib_mcast_deliver.constprop.6>
c022b204: eaffff0f b c022ae48 <__udp4_lib_rcv+0x98>
LIMIT_NETDEBUG(KERN_DEBUG "UDPLite: bad csum coverage %d/%d\n",
c022b208: e59f80fc ldr r8, [pc, #252] ; c022b30c <__udp4_lib_rcv+0x55c>
c022b20c: e5983000 ldr r3, [r8]
c022b210: e3530000 cmp r3, #0
c022b214: 0affff53 beq c022af68 <__udp4_lib_rcv+0x1b8>
c022b218: ebfffffe bl 0 <net_ratelimit>
c022b218: R_ARM_CALL net_ratelimit
c022b21c: e3500000 cmp r0, #0
c022b220: 0affffa5 beq c022b0bc <__udp4_lib_rcv+0x30c>
c022b224: e1a0100a mov r1, sl
c022b228: e59f00f4 ldr r0, [pc, #244] ; c022b324 <__udp4_lib_rcv+0x574>
c022b22c: e594204c ldr r2, [r4, #76] ; 0x4c
c022b230: ebfffffe bl 0 <printk>
c022b230: R_ARM_CALL printk
c022b234: e5983000 ldr r3, [r8]
c022b238: eaffffa0 b c022b0c0 <__udp4_lib_rcv+0x310>
struct sock *sk = skb->sk;
skb->destructor = NULL;
c022b23c: e5843064 str r3, [r4, #100] ; 0x64
skb->sk = NULL;
c022b240: e5843010 str r3, [r4, #16]
c022b244: eaffff36 b c022af24 <__udp4_lib_rcv+0x174>
return __skb_checksum_complete_head(skb, UDP_SKB_CB(skb)->cscov);
c022b248: e1a00004 mov r0, r4
c022b24c: e1d412bc ldrh r1, [r4, #44] ; 0x2c
c022b250: ebfffffe bl 0 <__skb_checksum_complete_head>
c022b250: R_ARM_CALL __skb_checksum_complete_head
return !skb_csum_unnecessary(skb) &&
c022b254: e3500000 cmp r0, #0
c022b258: 0affffd0 beq c022b1a0 <__udp4_lib_rcv+0x3f0>
LIMIT_NETDEBUG(KERN_DEBUG "UDP%s: bad checksum. From %pI4:%u to %pI4:%u ulen %d\n",
c022b25c: e59f30a8 ldr r3, [pc, #168] ; c022b30c <__udp4_lib_rcv+0x55c>
c022b260: e5933000 ldr r3, [r3]
c022b264: e3530000 cmp r3, #0
c022b268: 0afffeec beq c022ae20 <__udp4_lib_rcv+0x70>
c022b26c: ebfffffe bl 0 <net_ratelimit>
c022b26c: R_ARM_CALL net_ratelimit
c022b270: e3500000 cmp r0, #0
c022b274: 0afffee9 beq c022ae20 <__udp4_lib_rcv+0x70>
c022b278: e3550088 cmp r5, #136 ; 0x88
c022b27c: 11d6c0b0 ldrhne ip, [r6]
c022b280: 159f108c ldrne r1, [pc, #140] ; c022b314 <__udp4_lib_rcv+0x564>
c022b284: 1affff94 bne c022b0dc <__udp4_lib_rcv+0x32c>
c022b288: eaffff91 b c022b0d4 <__udp4_lib_rcv+0x324>
if (skb->ip_summed == CHECKSUM_COMPLETE)
c022b28c: e5d42060 ldrb r2, [r4, #96] ; 0x60
c022b290: e202100c and r1, r2, #12
c022b294: e3510008 cmp r1, #8
skb->ip_summed = CHECKSUM_NONE;
c022b298: 03c2200c biceq r2, r2, #12
c022b29c: 05c42060 strbeq r2, [r4, #96] ; 0x60
if (skb->data_len)
c022b2a0: e5942050 ldr r2, [r4, #80] ; 0x50
c022b2a4: e3520000 cmp r2, #0
c022b2a8: 1a00000b bne c022b2dc <__udp4_lib_rcv+0x52c>
skb->tail = skb->data + offset;
c022b2ac: e5942094 ldr r2, [r4, #148] ; 0x94
skb->len = len;
c022b2b0: e584704c str r7, [r4, #76] ; 0x4c
skb->tail = skb->data + offset;
c022b2b4: e0822007 add r2, r2, r7
c022b2b8: e5842088 str r2, [r4, #136] ; 0x88
c022b2bc: e1a0c007 mov ip, r7
c022b2c0: eaffff97 b c022b124 <__udp4_lib_rcv+0x374>
UDP_INC_STATS_BH(net, UDP_MIB_NOPORTS, proto == IPPROTO_UDPLITE);
c022b2c4: e59f3044 ldr r3, [pc, #68] ; c022b310 <__udp4_lib_rcv+0x560>
c022b2c8: e593209c ldr r2, [r3, #156] ; 0x9c
c022b2cc: e5923008 ldr r3, [r2, #8]
c022b2d0: e2833001 add r3, r3, #1
c022b2d4: e5823008 str r3, [r2, #8]
c022b2d8: eaffffb7 b c022b1bc <__udp4_lib_rcv+0x40c>
return ___pskb_trim(skb, len);
c022b2dc: e1a00004 mov r0, r4
c022b2e0: e1a01007 mov r1, r7
c022b2e4: ebfffffe bl 0 <___pskb_trim>
c022b2e4: R_ARM_CALL ___pskb_trim
if (ulen < sizeof(*uh) || pskb_trim_rcsum(skb, ulen))
c022b2e8: e3500000 cmp r0, #0
c022b2ec: 1affff25 bne c022af88 <__udp4_lib_rcv+0x1d8>
c022b2f0: e594c04c ldr ip, [r4, #76] ; 0x4c
c022b2f4: e594e080 ldr lr, [r4, #128] ; 0x80
c022b2f8: e594607c ldr r6, [r4, #124] ; 0x7c
c022b2fc: eaffff89 b c022b128 <__udp4_lib_rcv+0x378>
LIMIT_NETDEBUG(KERN_DEBUG "UDPLite: zeroed checksum field\n");
c022b300: e59f0020 ldr r0, [pc, #32] ; c022b328 <__udp4_lib_rcv+0x578>
c022b304: ebfffffe bl 0 <printk>
c022b304: R_ARM_CALL printk
c022b308: eaffff6b b c022b0bc <__udp4_lib_rcv+0x30c>
...
c022b30c: R_ARM_ABS32 net_msg_warn
c022b310: R_ARM_ABS32 init_net
c022b314: 00000100 .word 0x00000100
c022b314: R_ARM_ABS32 .rodata.str1.4
c022b318: 000001e8 .word 0x000001e8
c022b318: R_ARM_ABS32 .rodata.str1.4
c022b31c: 00000194 .word 0x00000194
c022b31c: R_ARM_ABS32 .rodata.str1.4
c022b320: 00000220 .word 0x00000220
c022b320: R_ARM_ABS32 .rodata.str1.4
c022b324: 000001c0 .word 0x000001c0
c022b324: R_ARM_ABS32 .rodata.str1.4
c022b328: 0000019c .word 0x0000019c
c022b328: R_ARM_ABS32 .rodata.str1.4
c022b32c <udp_rcv>:
return __udp4_lib_rcv(skb, &udp_table, IPPROTO_UDP);
c022b32c: e59f1004 ldr r1, [pc, #4] ; c022b338 <udp_rcv+0xc>
c022b330: e3a02011 mov r2, #17
c022b334: eafffffe b c022adb0 <__udp4_lib_rcv>
c022b334: R_ARM_JUMP24 __udp4_lib_rcv
c022b338: 00000000 .word 0x00000000
c022b338: R_ARM_ABS32 .data..read_mostly
c022b33c <udp4_proc_exit>:
return register_pernet_subsys(&udp4_net_ops);
}
void udp4_proc_exit(void)
{
unregister_pernet_subsys(&udp4_net_ops);
c022b33c: e59f0000 ldr r0, [pc] ; c022b344 <udp4_proc_exit+0x8>
c022b340: eafffffe b 0 <unregister_pernet_subsys>
c022b340: R_ARM_JUMP24 unregister_pernet_subsys
c022b344: 00000020 .word 0x00000020
c022b344: R_ARM_ABS32 .data
c022b348 <udp4_ufo_send_check>:
sysctl_udp_rmem_min = SK_MEM_QUANTUM;
sysctl_udp_wmem_min = SK_MEM_QUANTUM;
}
int udp4_ufo_send_check(struct sk_buff *skb)
{
c022b348: e92d4070 push {r4, r5, r6, lr}
return skb->len - skb->data_len;
c022b34c: e590204c ldr r2, [r0, #76] ; 0x4c
c022b350: e5901050 ldr r1, [r0, #80] ; 0x50
c022b354: e1a04000 mov r4, r0
c022b358: e0611002 rsb r1, r1, r2
if (likely(len <= skb_headlen(skb)))
c022b35c: e3510007 cmp r1, #7
c022b360: 9a000017 bls c022b3c4 <udp4_ufo_send_check+0x7c>
__asm__(
c022b364: e3a01000 mov r1, #0
uh = udp_hdr(skb);
uh->check = ~csum_tcpudp_magic(iph->saddr, iph->daddr, skb->len,
IPPROTO_UDP, 0);
skb->csum_start = skb_transport_header(skb) - skb->head;
skb->csum_offset = offsetof(struct udphdr, check);
c022b368: e3a0c006 mov ip, #6
return skb->network_header;
c022b36c: e5943080 ldr r3, [r4, #128] ; 0x80
return skb->transport_header;
c022b370: e594e07c ldr lr, [r4, #124] ; 0x7c
c022b374: e5935010 ldr r5, [r3, #16]
c022b378: e593600c ldr r6, [r3, #12]
c022b37c: e0913005 adds r3, r1, r5
c022b380: e0b33006 adcs r3, r3, r6
c022b384: e0b33402 adcs r3, r3, r2, lsl #8
c022b388: e2b33c11 adcs r3, r3, #4352 ; 0x1100
c022b38c: e2a33000 adc r3, r3, #0
__asm__(
c022b390: e0833863 add r3, r3, r3, ror #16
uh->check = ~csum_tcpudp_magic(iph->saddr, iph->daddr, skb->len,
c022b394: e1a03823 lsr r3, r3, #16
c022b398: e1ce30b6 strh r3, [lr, #6]
skb->ip_summed = CHECKSUM_PARTIAL;
c022b39c: e5d43060 ldrb r3, [r4, #96] ; 0x60
return 0;
c022b3a0: e1a00001 mov r0, r1
skb->csum_start = skb_transport_header(skb) - skb->head;
c022b3a4: e594207c ldr r2, [r4, #124] ; 0x7c
c022b3a8: e5941090 ldr r1, [r4, #144] ; 0x90
skb->ip_summed = CHECKSUM_PARTIAL;
c022b3ac: e383300c orr r3, r3, #12
skb->csum_start = skb_transport_header(skb) - skb->head;
c022b3b0: e0612002 rsb r2, r1, r2
c022b3b4: e1c425b8 strh r2, [r4, #88] ; 0x58
skb->ip_summed = CHECKSUM_PARTIAL;
c022b3b8: e5c43060 strb r3, [r4, #96] ; 0x60
skb->csum_offset = offsetof(struct udphdr, check);
c022b3bc: e1c4c5ba strh ip, [r4, #90] ; 0x5a
}
c022b3c0: e8bd8070 pop {r4, r5, r6, pc}
if (unlikely(len > skb->len))
c022b3c4: e3520007 cmp r2, #7
c022b3c8: 9a000004 bls c022b3e0 <udp4_ufo_send_check+0x98>
return __pskb_pull_tail(skb, len - skb_headlen(skb)) != NULL;
c022b3cc: e2611008 rsb r1, r1, #8
c022b3d0: ebfffffe bl 0 <__pskb_pull_tail>
c022b3d0: R_ARM_CALL __pskb_pull_tail
if (!pskb_may_pull(skb, sizeof(*uh)))
c022b3d4: e3500000 cmp r0, #0
c022b3d8: 1594204c ldrne r2, [r4, #76] ; 0x4c
c022b3dc: 1affffe0 bne c022b364 <udp4_ufo_send_check+0x1c>
return -EINVAL;
c022b3e0: e3e00015 mvn r0, #21
c022b3e4: e8bd8070 pop {r4, r5, r6, pc}
c022b3e8 <udp4_ufo_fragment>:
struct sk_buff *udp4_ufo_fragment(struct sk_buff *skb,
netdev_features_t features)
{
c022b3e8: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
return skb->end;
c022b3ec: e590508c ldr r5, [r0, #140] ; 0x8c
unsigned int mss;
int offset;
__wsum csum;
mss = skb_shinfo(skb)->gso_size;
if (unlikely(skb->len <= mss))
c022b3f0: e590c04c ldr ip, [r0, #76] ; 0x4c
mss = skb_shinfo(skb)->gso_size;
c022b3f4: e1d510b2 ldrh r1, [r5, #2]
if (unlikely(skb->len <= mss))
c022b3f8: e151000c cmp r1, ip
c022b3fc: 2a000035 bcs c022b4d8 <udp4_ufo_fragment+0xf0>
c022b400: e1a04000 mov r4, r0
return (features & feature) == feature;
}
static inline bool skb_gso_ok(struct sk_buff *skb, netdev_features_t features)
{
return net_gso_ok(features, skb_shinfo(skb)->gso_type) &&
c022b404: e1d500b6 ldrh r0, [r5, #6]
c022b408: e1a06002 mov r6, r2
netdev_features_t feature = gso_type << NETIF_F_GSO_SHIFT;
c022b40c: e1a08800 lsl r8, r0, #16
c022b410: e1a09fc8 asr r9, r8, #31
c022b414: e1a07003 mov r7, r3
goto out;
if (skb_gso_ok(skb, features | NETIF_F_GSO_ROBUST)) {
c022b418: e3822701 orr r2, r2, #262144 ; 0x40000
return (features & feature) == feature;
c022b41c: e0033009 and r3, r3, r9
c022b420: e0022008 and r2, r2, r8
return net_gso_ok(features, skb_shinfo(skb)->gso_type) &&
c022b424: e1590003 cmp r9, r3
c022b428: 01580002 cmpeq r8, r2
c022b42c: 0a000018 beq c022b494 <udp4_ufo_fragment+0xac>
return skb->data - skb->head;
c022b430: e5945090 ldr r5, [r4, #144] ; 0x90
c022b434: e5943094 ldr r3, [r4, #148] ; 0x94
return skb->csum_start - skb_headroom(skb);
c022b438: e1d425b8 ldrh r2, [r4, #88] ; 0x58
return skb->data - skb->head;
c022b43c: e0653003 rsb r3, r5, r3
return skb->csum_start - skb_headroom(skb);
c022b440: e0635002 rsb r5, r3, r2
/* Do software UFO. Complete and fill in the UDP checksum as HW cannot
* do checksum of UDP packets sent as multiple IP fragments.
*/
offset = skb_checksum_start_offset(skb);
csum = skb_checksum(skb, offset, skb->len - offset, 0);
c022b444: e065200c rsb r2, r5, ip
c022b448: e1a01005 mov r1, r5
c022b44c: e1a00004 mov r0, r4
c022b450: e3a03000 mov r3, #0
c022b454: ebfffffe bl 0 <skb_checksum>
c022b454: R_ARM_CALL skb_checksum
c022b458: e0800860 add r0, r0, r0, ror #16
return (__force __sum16)(~(__force u32)sum >> 16);
c022b45c: e1e00000 mvn r0, r0
offset += skb->csum_offset;
*(__sum16 *)(skb->data + offset) = csum_fold(csum);
c022b460: e5943094 ldr r3, [r4, #148] ; 0x94
offset += skb->csum_offset;
c022b464: e1d425ba ldrh r2, [r4, #90] ; 0x5a
*(__sum16 *)(skb->data + offset) = csum_fold(csum);
c022b468: e0835005 add r5, r3, r5
c022b46c: e1a00820 lsr r0, r0, #16
c022b470: e18500b2 strh r0, [r5, r2]
skb->ip_summed = CHECKSUM_NONE;
c022b474: e5d41060 ldrb r1, [r4, #96] ; 0x60
/* Fragment the skb. IP headers of the fragments are updated in
* inet_gso_segment()
*/
segs = skb_segment(skb, features);
c022b478: e1a02006 mov r2, r6
skb->ip_summed = CHECKSUM_NONE;
c022b47c: e3c1100c bic r1, r1, #12
c022b480: e5c41060 strb r1, [r4, #96] ; 0x60
segs = skb_segment(skb, features);
c022b484: e1a03007 mov r3, r7
c022b488: e1a00004 mov r0, r4
out:
return segs;
}
c022b48c: e8bd47f0 pop {r4, r5, r6, r7, r8, r9, sl, lr}
segs = skb_segment(skb, features);
c022b490: eafffffe b 0 <skb_segment>
c022b490: R_ARM_JUMP24 skb_segment
c022b494: e5953008 ldr r3, [r5, #8]
c022b498: e3530000 cmp r3, #0
c022b49c: 0a000003 beq c022b4b0 <udp4_ufo_fragment+0xc8>
(!skb_has_frag_list(skb) || (features & NETIF_F_FRAGLIST));
c022b4a0: e3a03000 mov r3, #0
c022b4a4: e2062040 and r2, r6, #64 ; 0x40
c022b4a8: e1923003 orrs r3, r2, r3
c022b4ac: 0affffdf beq c022b430 <udp4_ufo_fragment+0x48>
if (unlikely(type & ~(SKB_GSO_UDP | SKB_GSO_DODGY) ||
c022b4b0: e3c00004 bic r0, r0, #4
c022b4b4: e3500002 cmp r0, #2
c022b4b8: 1a000006 bne c022b4d8 <udp4_ufo_fragment+0xf0>
c022b4bc: e24c0001 sub r0, ip, #1
skb_shinfo(skb)->gso_segs = DIV_ROUND_UP(skb->len, mss);
c022b4c0: e0800001 add r0, r0, r1
c022b4c4: ebfffffe bl 0 <__aeabi_uidiv>
c022b4c4: R_ARM_CALL __aeabi_uidiv
segs = NULL;
c022b4c8: e3a03000 mov r3, #0
skb_shinfo(skb)->gso_segs = DIV_ROUND_UP(skb->len, mss);
c022b4cc: e1c500b4 strh r0, [r5, #4]
}
c022b4d0: e1a00003 mov r0, r3
c022b4d4: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
struct sk_buff *segs = ERR_PTR(-EINVAL);
c022b4d8: e3e03015 mvn r3, #21
}
c022b4dc: e1a00003 mov r0, r3
c022b4e0: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
Disassembly of section .init.text:
c0227a30 <udp4_proc_init_net>:
kfree_skb(skb);
c0227a30: e59f1000 .word 0xe59f1000
{
c0227a34: eafffffe b c0228f5c <udp_proc_register>
c0227a34: R_ARM_JUMP24 udp_proc_register
kfree_skb(skb);
c0227a38: 00000000 .word 0x00000000
c0227a38: R_ARM_ABS32 .data
c0227a3c <set_uhash_entries>:
}
c0227a3c: e52de004 push {lr} ; (str lr, [sp, #-4]!)
c0227a40: e2503000 .word 0xe2503000
{
c0227a44: e24dd00c sub sp, sp, #12
sk_common_release(sk);
c0227a48: e58d0004 .word 0xe58d0004
{
c0227a4c: 01a00003 moveq r0, r3
return memcpy_fromiovecend(to, (struct iovec *) from, offset, len);
c0227a50: 0a00000a beq c0227a80 <set_uhash_entries+0x44>
c0227a54: e3a02000 mov r2, #0
c0227a58: e28d1004 add r1, sp, #4
(!inet1->inet_rcv_saddr || !inet2->inet_rcv_saddr ||
c0227a5c: ebfffffe bl 0 <simple_strtoul>
c0227a5c: R_ARM_CALL simple_strtoul
return (!ipv6_only_sock(sk2) &&
c0227a60: e2403001 sub r3, r0, #1
c0227a64: e35300fe cmp r3, #254 ; 0xfe
(!inet1->inet_rcv_saddr || !inet2->inet_rcv_saddr ||
c0227a68: e59f3018 ldr r3, [pc, #24] ; c0227a88 <set_uhash_entries+0x4c>
return (!ipv6_only_sock(sk2) &&
c0227a6c: 93a02c01 movls r2, #256 ; 0x100
c0227a70: 85830000 strhi r0, [r3]
c0227a74: 93a00001 movls r0, #1
c0227a78: 83a00001 movhi r0, #1
c0227a7c: 95832000 strls r2, [r3]
c0227a80: e28dd00c add sp, sp, #12
}
c0227a84: e49df004 pop {pc} ; (ldr pc, [sp], #4)
a += initval;
c0227a88: 00000000 .word 0x00000000
c0227a88: R_ARM_ABS32 .init.data
c0227a8c <udp4_proc_init>:
__jhash_final(a, b, c);
c0227a8c: e59f0000 ldr r0, [pc] ; c0227a94 <udp4_proc_init+0x8>
a += initval;
c0227a90: eafffffe b 0 <register_pernet_subsys>
c0227a90: R_ARM_JUMP24 register_pernet_subsys
__jhash_final(a, b, c);
c0227a94: 00000020 .word 0x00000020
c0227a94: R_ARM_ABS32 .data
c0227a98 <udp_table_init>:
c0227a98: e92d4030 push {r4, r5, lr}
c0227a9c: e3a02801 mov r2, #65536 ; 0x10000
c0227aa0: e1a05001 mov r5, r1
c0227aa4: e3a01000 mov r1, #0
c0227aa8: e24dd014 sub sp, sp, #20
c0227aac: e1a04000 mov r4, r0
c0227ab0: e280c00c add ip, r0, #12
c0227ab4: e59f3100 ldr r3, [pc, #256] ; c0227bbc <udp_table_init+0x124>
c0227ab8: e2800008 add r0, r0, #8
c0227abc: e58d0008 str r0, [sp, #8]
c0227ac0: e58d1000 str r1, [sp]
c0227ac4: e58dc004 str ip, [sp, #4]
}
c0227ac8: e58d200c str r2, [sp, #12]
c0227acc: e5932000 ldr r2, [r3]
c0227ad0: e1a00005 mov r0, r5
c0227ad4: e3a03015 mov r3, #21
c0227ad8: e3a01010 mov r1, #16
{
c0227adc: ebfffffe bl 0 <alloc_large_system_hash>
c0227adc: R_ARM_CALL alloc_large_system_hash
if (sk_hashed(sk)) {
c0227ae0: e5943008 ldr r3, [r4, #8]
{
c0227ae4: e5840000 str r0, [r4]
if (sk_hashed(sk)) {
c0227ae8: e35300fe cmp r3, #254 ; 0xfe
c0227aec: 8a00000f bhi c0227b30 <udp_table_init+0x98>
struct udp_table *udptable = sk->sk_prot->h.udp_table;
c0227af0: e59f30c8 ldr r3, [pc, #200] ; c0227bc0 <udp_table_init+0x128>
hslot2 = udp_hashslot2(udptable, udp_sk(sk)->udp_portaddr_hash);
c0227af4: e5930030 ldr r0, [r3, #48] ; 0x30
struct udp_table *udptable = sk->sk_prot->h.udp_table;
c0227af8: e3500000 cmp r0, #0
return &table->hash2[hash & table->mask];
c0227afc: 03a00010 moveq r0, #16
c0227b00: 0a000001 beq c0227b0c <udp_table_init+0x74>
c0227b04: e3a010d0 mov r1, #208 ; 0xd0
c0227b08: ebfffffe bl 0 <kmem_cache_alloc>
c0227b08: R_ARM_CALL kmem_cache_alloc
c0227b0c: e3500000 cmp r0, #0
c0227b10: e5840000 str r0, [r4]
if (hslot2 != nhslot2) {
c0227b14: 1a000001 bne c0227b20 <udp_table_init+0x88>
udp_sk(sk)->udp_portaddr_hash = newhash;
c0227b18: e1a00005 mov r0, r5
if (hslot2 != nhslot2) {
c0227b1c: ebfffffe bl 0 <panic>
c0227b1c: R_ARM_CALL panic
c0227b20: e3a02008 mov r2, #8
c0227b24: e3a030ff mov r3, #255 ; 0xff
raw_spin_lock_bh(&lock->rlock);
c0227b28: e584200c str r2, [r4, #12]
c0227b2c: e5843008 str r3, [r4, #8]
c0227b30: e3a03000 mov r3, #0
c0227b34: e1a00003 mov r0, r3
c0227b38: e5942008 ldr r2, [r4, #8]
raw_spin_lock(&lock->rlock);
c0227b3c: e5941000 ldr r1, [r4]
c0227b40: e2822001 add r2, r2, #1
c0227b44: e0812182 add r2, r1, r2, lsl #3
return !h->pprev;
c0227b48: e5842004 str r2, [r4, #4]
if (!hlist_nulls_unhashed(n)) {
c0227b4c: e5942008 ldr r2, [r4, #8]
c0227b50: e1520003 cmp r2, r3
struct hlist_nulls_node *next = n->next;
c0227b54: 3a000008 bcc c0227b7c <udp_table_init+0xe4>
if (!is_a_nulls(next))
c0227b58: e1a02083 lsl r2, r3, #1
*pprev = next;
c0227b5c: e5941000 ldr r1, [r4]
next->pprev = pprev;
c0227b60: e3822001 orr r2, r2, #1
n->pprev = NULL;
c0227b64: e7812183 str r2, [r1, r3, lsl #3]
c0227b68: e5942000 ldr r2, [r4]
hslot2->count--;
c0227b6c: e0822183 add r2, r2, r3, lsl #3
c0227b70: e5820004 str r0, [r2, #4]
c0227b74: e2833001 add r3, r3, #1
c0227b78: eafffff3 b c0227b4c <udp_table_init+0xb4>
raw_spin_unlock(&lock->rlock);
c0227b7c: e3a03000 mov r3, #0
c0227b80: e1a00003 mov r0, r3
c0227b84: e5942008 ldr r2, [r4, #8]
c0227b88: e1520003 cmp r2, r3
c0227b8c: 3a000008 bcc c0227bb4 <udp_table_init+0x11c>
c0227b90: e1a02083 lsl r2, r3, #1
c0227b94: e5941004 ldr r1, [r4, #4]
raw_spin_lock(&lock->rlock);
c0227b98: e3822001 orr r2, r2, #1
c0227b9c: e7812183 str r2, [r1, r3, lsl #3]
c0227ba0: e5942004 ldr r2, [r4, #4]
struct hlist_nulls_node *first = h->first;
c0227ba4: e0822183 add r2, r2, r3, lsl #3
hlist_nulls_add_head_rcu(&udp_sk(sk)->udp_portaddr_node,
c0227ba8: e5820004 str r0, [r2, #4]
n->next = first;
c0227bac: e2833001 add r3, r3, #1
n->pprev = &h->first;
c0227bb0: eafffff3 b c0227b84 <udp_table_init+0xec>
if (!is_a_nulls(first))
c0227bb4: e28dd014 add sp, sp, #20
rcu_assign_pointer(hlist_nulls_first_rcu(h), n);
c0227bb8: e8bd8030 pop {r4, r5, pc}
...
c0227bbc: R_ARM_ABS32 .init.data
c0227bc0: R_ARM_ABS32 kmalloc_caches
c0227bc4 <udp_init>:
nhslot2->count++;
c0227bc4: e92d4010 push {r4, lr}
c0227bc8: e59f4040 ldr r4, [pc, #64] ; c0227c10 <udp_init+0x4c>
c0227bcc: e59f1040 ldr r1, [pc, #64] ; c0227c14 <udp_init+0x50>
raw_spin_unlock(&lock->rlock);
c0227bd0: e1a00004 mov r0, r4
c0227bd4: ebfffffe bl c0227a98 <udp_table_init>
c0227bd4: R_ARM_CALL udp_table_init
c0227bd8: ebfffffe bl 0 <nr_free_buffer_pages>
c0227bd8: R_ARM_CALL nr_free_buffer_pages
c0227bdc: e1a001a0 lsr r0, r0, #3
c0227be0: e3500080 cmp r0, #128 ; 0x80
c0227be4: 33a00080 movcc r0, #128 ; 0x80
c0227be8: e3a02a01 mov r2, #4096 ; 0x1000
raw_spin_unlock_bh(&lock->rlock);
c0227bec: e1a03120 lsr r3, r0, #2
c0227bf0: e0833083 add r3, r3, r3, lsl #1
c0227bf4: e1a01083 lsl r1, r3, #1
}
c0227bf8: e5840014 str r0, [r4, #20]
c0227bfc: e5843010 str r3, [r4, #16]
raw_spin_unlock(&lock->rlock);
c0227c00: e5841018 str r1, [r4, #24]
c0227c04: e584201c str r2, [r4, #28]
c0227c08: e5842020 str r2, [r4, #32]
c0227c0c: e8bd8010 pop {r4, pc}
{
c0227c10: 00000000 .word 0x00000000
c0227c10: R_ARM_ABS32 .data..read_mostly
inet_sk(sk)->inet_num);
c0227c14: 0000025c .word 0x0000025c
c0227c14: R_ARM_ABS32 .rodata.str1.4
Disassembly of section .ref.text:
c0227a30 <udp4_proc_exit_net>:
kfree_skb(skb);
c0227a30: e59f3004 .word 0xe59f3004
{
c0227a34: e5931000 ldr r1, [r3]
kfree_skb(skb);
c0227a38: eafffffe b 0 <proc_net_remove>
c0227a38: R_ARM_JUMP24 proc_net_remove
}
c0227a3c: 00000000 .word 0x00000000
c0227a3c: R_ARM_ABS32 .data
Raw
Oops2
[ 343.740000] Unable to handle kernel paging request at virtual address c155731e
[ 343.750000] pgd = c1e68000
[ 343.750000] [c155731e] *pgd=8140041e(bad)
[ 343.760000] Internal error: Oops: 1 [#1] PREEMPT ARM
[ 343.760000] Modules linked in:
[ 343.760000] CPU: 0 Not tainted (3.4.113.8 #1)
[ 343.760000] PC is at ip_cmsg_recv+0x9c/0x1f8
[ 343.760000] LR is at udp_recvmsg+0x308/0x33c
[ 343.760000] pc : [<c01ebeb8>] lr : [<c020a8ec>] psr: 20000013
[ 343.760000] sp : c1e53cb8 ip : c1e53cc0 fp : 00000045
[ 343.760000] r10: c1e53d34 r9 : 00000045 r8 : 00000000
[ 343.760000] r7 : 000005c0 r6 : c1e53f7c r5 : c14e50a0 r4 : 00000001
[ 343.760000] r3 : c155730e r2 : 00000000 r1 : 6200000a r0 : c1e53f7c
[ 343.760000] Flags: nzCv IRQs on FIQs on Mode SVC_32 ISA ARM Segment user
[ 343.760000] Control: 0005317f Table: 81e68000 DAC: 00000015
[ 343.760000] Process trdp.release (pid: 135, stack limit = 0xc1e52270)
[ 343.760000] Stack: (0xc1e53cb8 to 0xc1e54000)
[ 343.760000] 3ca0: ffffffff c1e53cfc
[ 343.760000] 3cc0: 00000002 6200000a 00000000 00000008 c1e53ec0 1614010a c14e50a0 c1e53f7c
[ 343.760000] 3ce0: c1e12220 000005c0 00000000 00000045 c1e53d34 00000045 00000000 c14e50a0
[ 343.760000] 3d00: c1e53f7c c1e12220 000005c0 c020a8ec c1e53d34 00000091 00000001 00000045
[ 343.760000] 3d20: 00000000 c1e53ec0 00000002 00000000 00000000 00000000 c1506302 c1e53f7c
[ 343.760000] 3d40: 00000000 00000000 00000000 000005c0 00000000 c1e53f7c c1e53ec0 c021246c
[ 343.760000] 3d60: 00000000 00000000 c1e53d74 c00172ec c1e12220 00000010 c1e53d90 00000000
[ 343.760000] 3d80: c3483000 c01b4720 00000000 00000001 c1e16e60 c030cfac 00000000 000005c0
[ 343.760000] 3da0: c3483000 c1e53e58 00000000 c1e53f7c c0327ae8 c000862c 00000041 00001d3a
[ 343.760000] 3dc0: 00000000 00000001 c034a908 ffffffff ff7b66b0 ffffffff 00000000 00000001
[ 343.760000] 3de0: ffffffff 00000000 00000000 00000000 00000000 00000000 c1e16000 00000000
[ 343.760000] 3e00: 00000000 00000000 00000000 00000001 c1e53d90 00000000 00000000 bebc9b78
[ 343.760000] 3e20: 00000004 00000000 00000004 c00afcc0 c1e53e48 c1e53e4c c1e53e50 00000001
[ 343.760000] 3e40: c1e53f7c c3483000 bebc95bc c1e53e80 c1e53f7c c1e53e80 c01b4678 c3483000
[ 343.760000] 3e60: bebc95bc 00000000 c1e53e80 c01b5a94 bebc95d8 00000008 bebc95c0 bebc959c
[ 343.760000] 3e80: b6acc4a5 0000057b 00000050 00000003 c03101d0 08a02e02 00000050 c0049a40
[ 343.760000] 3ea0: 0897ef21 00000050 c1e52000 08a02e02 00000050 c0310278 c03101d0 c004a204
[ 343.760000] 3ec0: b0040002 1614010a 00000000 00000000 00000050 c003b45c 08976402 00000050
[ 343.760000] 3ee0: 08a02e02 00000050 ffffffff 00000000 c14d0000 c003c2f8 c14d0000 00000002
[ 343.760000] 3f00: c032878c c03104c0 00000000 00000000 ffffffff 00000000 ffffffff 00000000
[ 343.760000] 3f20: c1e53f78 c1e52000 c1e53f78 bebc9cc0 00000001 bebc9cc0 00000008 bebc95bc
[ 343.760000] 3f40: 00000000 c3483000 bebc95bc 00000000 00000129 c000e188 c1e52000 00000000
[ 343.760000] 3f60: bebc97e0 c01b6aa4 00000000 bebc9860 bebc9938 00000000 fffffff7 c1e53ec0
[ 343.760000] 3f80: 00000000 c1e53e80 00000001 bebc959c 00000020 00000000 bebc959c b6acc460
[ 343.760000] 3fa0: 00000000 c000dfe0 bebc959c b6acc460 00000004 bebc95bc 00000000 00000020
[ 343.760000] 3fc0: bebc959c b6acc460 00000000 00000129 bebc97f4 00000000 00056178 bebc97e0
[ 343.760000] 3fe0: 00000004 bebc93d0 0001a904 b6f868dc 60000010 00000004 83ffe831 83ffec31
[ 343.760000] [<c01ebeb8>] (ip_cmsg_recv+0x9c/0x1f8) from [<c020a8ec>] (udp_recvmsg+0x308/0x33c)
[ 343.760000] [<c020a8ec>] (udp_recvmsg+0x308/0x33c) from [<c021246c>] (inet_recvmsg+0x38/0x4c)
[ 343.760000] [<c021246c>] (inet_recvmsg+0x38/0x4c) from [<c01b4720>] (sock_recvmsg+0xa8/0xcc)
[ 343.760000] [<c01b4720>] (sock_recvmsg+0xa8/0xcc) from [<c01b5a94>] (___sys_recvmsg.part.4+0xe0/0x1bc)
[ 343.760000] [<c01b5a94>] (___sys_recvmsg.part.4+0xe0/0x1bc) from [<c01b6aa4>] (__sys_recvmsg+0x50/0x80)
[ 343.760000] [<c01b6aa4>] (__sys_recvmsg+0x50/0x80) from [<c000dfe0>] (ret_fast_syscall+0x0/0x2c)
[ 343.760000] Code: e8930007 e88c0007 e5953080 e1a00006 (e593e010)
[ 344.140000] ---[ end trace 4c18bb0f0a672a54 ]---
[ 344.210000] lpc-eth lpc-eth.0: eth0: Ethernet MAC address d2:08:5d:30:db:f4
[ 344.220000] ------------[ cut here ]------------
[ 344.230000] WARNING: at net/ipv4/af_inet.c:153 inet_sock_destruct+0x188/0x1a8()
[ 344.240000] Modules linked in:
[ 344.240000] [<c0013ac8>] (unwind_backtrace+0x0/0xec) from [<c001c588>] (warn_slowpath_common+0x4c/0x64)
[ 344.250000] [<c001c588>] (warn_slowpath_common+0x4c/0x64) from [<c001c63c>] (warn_slowpath_null+0x1c/0x24)
[ 344.260000] [<c001c63c>] (warn_slowpath_null+0x1c/0x24) from [<c0212614>] (inet_sock_destruct+0x188/0x1a8)
[ 344.270000] [<c0212614>] (inet_sock_destruct+0x188/0x1a8) from [<c01b90dc>] (__sk_free+0x18/0x154)
[ 344.280000] [<c01b90dc>] (__sk_free+0x18/0x154) from [<c021282c>] (inet_release+0x44/0x70)
[ 344.290000] [<c021282c>] (inet_release+0x44/0x70) from [<c01b51fc>] (sock_release+0x20/0xc8)
[ 344.300000] [<c01b51fc>] (sock_release+0x20/0xc8) from [<c01b52b8>] (sock_close+0x14/0x2c)
[ 344.300000] [<c01b52b8>] (sock_close+0x14/0x2c) from [<c009f754>] (fput+0xb4/0x27c)
[ 344.310000] [<c009f754>] (fput+0xb4/0x27c) from [<c009cd5c>] (filp_close+0x64/0x88)
[ 344.320000] [<c009cd5c>] (filp_close+0x64/0x88) from [<c001fb28>] (put_files_struct+0x80/0xe0)
[ 344.330000] [<c001fb28>] (put_files_struct+0x80/0xe0) from [<c0020388>] (do_exit+0x4c8/0x748)
[ 344.340000] [<c0020388>] (do_exit+0x4c8/0x748) from [<c0011894>] (die+0x214/0x240)
[ 344.350000] [<c0011894>] (die+0x214/0x240) from [<c0231b98>] (__do_kernel_fault.part.0+0x54/0x74)
[ 344.360000] [<c0231b98>] (__do_kernel_fault.part.0+0x54/0x74) from [<c0015188>] (do_bad_area+0x88/0x8c)
[ 344.370000] [<c0015188>] (do_bad_area+0x88/0x8c) from [<c00173dc>] (do_alignment+0xf0/0x938)
[ 344.370000] [<c00173dc>] (do_alignment+0xf0/0x938) from [<c000862c>] (do_DataAbort+0x34/0x98)
[ 344.380000] [<c000862c>] (do_DataAbort+0x34/0x98) from [<c000db98>] (__dabt_svc+0x38/0x60)
[ 344.390000] Exception stack(0xc1e53c70 to 0xc1e53cb8)
[ 344.400000] 3c60: c1e53f7c 6200000a 00000000 c155730e
[ 344.400000] 3c80: 00000001 c14e50a0 c1e53f7c 000005c0 00000000 00000045 c1e53d34 00000045
[ 344.410000] 3ca0: c1e53cc0 c1e53cb8 c020a8ec c01ebeb8 20000013 ffffffff
[ 344.420000] [<c000db98>] (__dabt_svc+0x38/0x60) from [<c01ebeb8>] (ip_cmsg_recv+0x9c/0x1f8)
[ 344.430000] [<c01ebeb8>] (ip_cmsg_recv+0x9c/0x1f8) from [<c020a8ec>] (udp_recvmsg+0x308/0x33c)
[ 344.440000] [<c020a8ec>] (udp_recvmsg+0x308/0x33c) from [<c021246c>] (inet_recvmsg+0x38/0x4c)
[ 344.450000] [<c021246c>] (inet_recvmsg+0x38/0x4c) from [<c01b4720>] (sock_recvmsg+0xa8/0xcc)
[ 344.450000] [<c01b4720>] (sock_recvmsg+0xa8/0xcc) from [<c01b5a94>] (___sys_recvmsg.part.4+0xe0/0x1bc)
[ 344.460000] [<c01b5a94>] (___sys_recvmsg.part.4+0xe0/0x1bc) from [<c01b6aa4>] (__sys_recvmsg+0x50/0x80)
[ 344.470000] [<c01b6aa4>] (__sys_recvmsg+0x50/0x80) from [<c000dfe0>] (ret_fast_syscall+0x0/0x2c)
[ 344.480000] ---[ end trace 4c18bb0f0a672a55 ]---
[ 344.490000] ------------[ cut here ]------------
[ 344.490000] WARNING: at net/ipv4/af_inet.c:156 inet_sock_destruct+0x158/0x1a8()
[ 344.500000] Modules linked in:
[ 344.500000] [<c0013ac8>] (unwind_backtrace+0x0/0xec) from [<c001c588>] (warn_slowpath_common+0x4c/0x64)
[ 344.510000] [<c001c588>] (warn_slowpath_common+0x4c/0x64) from [<c001c63c>] (warn_slowpath_null+0x1c/0x24)
[ 344.520000] [<c001c63c>] (warn_slowpath_null+0x1c/0x24) from [<c02125e4>] (inet_sock_destruct+0x158/0x1a8)
[ 344.530000] [<c02125e4>] (inet_sock_destruct+0x158/0x1a8) from [<c01b90dc>] (__sk_free+0x18/0x154)
[ 344.540000] [<c01b90dc>] (__sk_free+0x18/0x154) from [<c021282c>] (inet_release+0x44/0x70)
[ 344.550000] [<c021282c>] (inet_release+0x44/0x70) from [<c01b51fc>] (sock_release+0x20/0xc8)
[ 344.560000] [<c01b51fc>] (sock_release+0x20/0xc8) from [<c01b52b8>] (sock_close+0x14/0x2c)
[ 344.570000] [<c01b52b8>] (sock_close+0x14/0x2c) from [<c009f754>] (fput+0xb4/0x27c)
[ 344.580000] [<c009f754>] (fput+0xb4/0x27c) from [<c009cd5c>] (filp_close+0x64/0x88)
[ 344.580000] [<c009cd5c>] (filp_close+0x64/0x88) from [<c001fb28>] (put_files_struct+0x80/0xe0)
[ 344.590000] [<c001fb28>] (put_files_struct+0x80/0xe0) from [<c0020388>] (do_exit+0x4c8/0x748)
[ 344.600000] [<c0020388>] (do_exit+0x4c8/0x748) from [<c0011894>] (die+0x214/0x240)
[ 344.610000] [<c0011894>] (die+0x214/0x240) from [<c0231b98>] (__do_kernel_fault.part.0+0x54/0x74)
[ 344.620000] [<c0231b98>] (__do_kernel_fault.part.0+0x54/0x74) from [<c0015188>] (do_bad_area+0x88/0x8c)
[ 344.630000] [<c0015188>] (do_bad_area+0x88/0x8c) from [<c00173dc>] (do_alignment+0xf0/0x938)
[ 344.640000] [<c00173dc>] (do_alignment+0xf0/0x938) from [<c000862c>] (do_DataAbort+0x34/0x98)
[ 344.650000] [<c000862c>] (do_DataAbort+0x34/0x98) from [<c000db98>] (__dabt_svc+0x38/0x60)
[ 344.650000] Exception stack(0xc1e53c70 to 0xc1e53cb8)
[ 344.660000] 3c60: c1e53f7c 6200000a 00000000 c155730e
[ 344.670000] 3c80: 00000001 c14e50a0 c1e53f7c 000005c0 00000000 00000045 c1e53d34 00000045
[ 344.680000] 3ca0: c1e53cc0 c1e53cb8 c020a8ec c01ebeb8 20000013 ffffffff
[ 344.680000] [<c000db98>] (__dabt_svc+0x38/0x60) from [<c01ebeb8>] (ip_cmsg_recv+0x9c/0x1f8)
[ 344.690000] [<c01ebeb8>] (ip_cmsg_recv+0x9c/0x1f8) from [<c020a8ec>] (udp_recvmsg+0x308/0x33c)
[ 344.700000] [<c020a8ec>] (udp_recvmsg+0x308/0x33c) from [<c021246c>] (inet_recvmsg+0x38/0x4c)
[ 344.710000] [<c021246c>] (inet_recvmsg+0x38/0x4c) from [<c01b4720>] (sock_recvmsg+0xa8/0xcc)
[ 344.720000] [<c01b4720>] (sock_recvmsg+0xa8/0xcc) from [<c01b5a94>] (___sys_recvmsg.part.4+0xe0/0x1bc)
[ 344.730000] [<c01b5a94>] (___sys_recvmsg.part.4+0xe0/0x1bc) from [<c01b6aa4>] (__sys_recvmsg+0x50/0x80)
[ 344.740000] [<c01b6aa4>] (__sys_recvmsg+0x50/0x80) from [<c000dfe0>] (ret_fast_syscall+0x0/0x2c)
[ 344.750000] ---[ end trace 4c18bb0f0a672a56 ]---
Raw
proc_config.gz
#
# Automatically generated file; DO NOT EDIT.
# Linux/arm 3.4.113 Kernel Configuration
#
CONFIG_ARM=y
CONFIG_SYS_SUPPORTS_APM_EMULATION=y
CONFIG_GENERIC_GPIO=y
# CONFIG_ARCH_USES_GETTIMEOFFSET is not set
CONFIG_GENERIC_CLOCKEVENTS=y
CONFIG_KTIME_SCALAR=y
CONFIG_HAVE_PROC_CPU=y
CONFIG_STACKTRACE_SUPPORT=y
CONFIG_HAVE_LATENCYTOP_SUPPORT=y
CONFIG_LOCKDEP_SUPPORT=y
CONFIG_TRACE_IRQFLAGS_SUPPORT=y
CONFIG_HARDIRQS_SW_RESEND=y
CONFIG_GENERIC_IRQ_PROBE=y
CONFIG_RWSEM_GENERIC_SPINLOCK=y
CONFIG_ARCH_HAS_CPU_IDLE_WAIT=y
CONFIG_GENERIC_HWEIGHT=y
CONFIG_GENERIC_CALIBRATE_DELAY=y
CONFIG_NEED_DMA_MAP_STATE=y
CONFIG_VECTORS_BASE=0xffff0000
CONFIG_ARM_PATCH_PHYS_VIRT=y
CONFIG_GENERIC_BUG=y
CONFIG_DEFCONFIG_LIST="/lib/modules/$UNAME_RELEASE/.config"
CONFIG_HAVE_IRQ_WORK=y
CONFIG_IRQ_WORK=y
#
# General setup
#
CONFIG_EXPERIMENTAL=y
CONFIG_BROKEN_ON_SMP=y
CONFIG_INIT_ENV_ARG_LIMIT=32
CONFIG_CROSS_COMPILE=""
CONFIG_LOCALVERSION=".7"
CONFIG_LOCALVERSION_AUTO=y
CONFIG_HAVE_KERNEL_GZIP=y
CONFIG_HAVE_KERNEL_LZMA=y
CONFIG_HAVE_KERNEL_XZ=y
CONFIG_HAVE_KERNEL_LZO=y
# CONFIG_KERNEL_GZIP is not set
# CONFIG_KERNEL_LZMA is not set
CONFIG_KERNEL_XZ=y
# CONFIG_KERNEL_LZO is not set
CONFIG_DEFAULT_HOSTNAME="mlc"
CONFIG_SYSVIPC=y
CONFIG_SYSVIPC_SYSCTL=y
# CONFIG_POSIX_MQUEUE is not set
# CONFIG_BSD_PROCESS_ACCT is not set
CONFIG_FHANDLE=y
# CONFIG_TASKSTATS is not set
# CONFIG_AUDIT is not set
CONFIG_HAVE_GENERIC_HARDIRQS=y
#
# IRQ subsystem
#
CONFIG_GENERIC_HARDIRQS=y
CONFIG_GENERIC_IRQ_SHOW=y
CONFIG_GENERIC_IRQ_CHIP=y
CONFIG_IRQ_DOMAIN=y
#
# RCU Subsystem
#
CONFIG_TINY_PREEMPT_RCU=y
CONFIG_PREEMPT_RCU=y
# CONFIG_TREE_RCU_TRACE is not set
# CONFIG_RCU_BOOST is not set
CONFIG_IKCONFIG=y
CONFIG_IKCONFIG_PROC=y
CONFIG_LOG_BUF_SHIFT=17
CONFIG_CGROUPS=y
# CONFIG_CGROUP_DEBUG is not set
# CONFIG_CGROUP_FREEZER is not set
# CONFIG_CGROUP_DEVICE is not set
# CONFIG_CPUSETS is not set
# CONFIG_CGROUP_CPUACCT is not set
# CONFIG_RESOURCE_COUNTERS is not set
# CONFIG_CGROUP_PERF is not set
# CONFIG_CGROUP_SCHED is not set
# CONFIG_CHECKPOINT_RESTORE is not set
# CONFIG_NAMESPACES is not set
# CONFIG_SCHED_AUTOGROUP is not set
CONFIG_SYSFS_DEPRECATED=y
CONFIG_SYSFS_DEPRECATED_V2=y
# CONFIG_RELAY is not set
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_CC_OPTIMIZE_FOR_SIZE is not set
CONFIG_SYSCTL=y
CONFIG_ANON_INODES=y
CONFIG_EXPERT=y
CONFIG_UID16=y
# CONFIG_SYSCTL_SYSCALL is not set
CONFIG_KALLSYMS=y
# CONFIG_KALLSYMS_ALL is not set
CONFIG_HOTPLUG=y
CONFIG_PRINTK=y
CONFIG_BUG=y
CONFIG_ELF_CORE=y
CONFIG_BASE_FULL=y
CONFIG_FUTEX=y
CONFIG_EPOLL=y
CONFIG_SIGNALFD=y
CONFIG_TIMERFD=y
CONFIG_EVENTFD=y
CONFIG_SHMEM=y
CONFIG_AIO=y
CONFIG_EMBEDDED=y
CONFIG_HAVE_PERF_EVENTS=y
CONFIG_PERF_USE_VMALLOC=y
#
# Kernel Performance Events And Counters
#
CONFIG_PERF_EVENTS=y
# CONFIG_PERF_COUNTERS is not set
# CONFIG_DEBUG_PERF_USE_VMALLOC is not set
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_PROFILING is not set
CONFIG_HAVE_OPROFILE=y
# CONFIG_KPROBES is not set
# CONFIG_JUMP_LABEL is not set
CONFIG_HAVE_KPROBES=y
CONFIG_HAVE_KRETPROBES=y
CONFIG_HAVE_REGS_AND_STACK_ACCESS_API=y
CONFIG_HAVE_CLK=y
CONFIG_HAVE_DMA_API_DEBUG=y
CONFIG_HAVE_ARCH_JUMP_LABEL=y
#
# GCOV-based kernel profiling
#
CONFIG_HAVE_GENERIC_DMA_COHERENT=y
CONFIG_SLABINFO=y
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_BLOCK is not set
# CONFIG_INLINE_SPIN_TRYLOCK is not set
# CONFIG_INLINE_SPIN_TRYLOCK_BH is not set
# CONFIG_INLINE_SPIN_LOCK is not set
# CONFIG_INLINE_SPIN_LOCK_BH is not set
# CONFIG_INLINE_SPIN_LOCK_IRQ is not set
# CONFIG_INLINE_SPIN_LOCK_IRQSAVE is not set
CONFIG_UNINLINE_SPIN_UNLOCK=y
# CONFIG_INLINE_SPIN_UNLOCK_BH is not set
# CONFIG_INLINE_SPIN_UNLOCK_IRQ is not set
# CONFIG_INLINE_SPIN_UNLOCK_IRQRESTORE is not set
# CONFIG_INLINE_READ_TRYLOCK is not set
# CONFIG_INLINE_READ_LOCK is not set
# CONFIG_INLINE_READ_LOCK_BH is not set
# CONFIG_INLINE_READ_LOCK_IRQ is not set
# CONFIG_INLINE_READ_LOCK_IRQSAVE is not set
# CONFIG_INLINE_READ_UNLOCK is not set
# CONFIG_INLINE_READ_UNLOCK_BH is not set
# CONFIG_INLINE_READ_UNLOCK_IRQ is not set
# CONFIG_INLINE_READ_UNLOCK_IRQRESTORE is not set
# CONFIG_INLINE_WRITE_TRYLOCK is not set
# CONFIG_INLINE_WRITE_LOCK is not set
# CONFIG_INLINE_WRITE_LOCK_BH is not set
# CONFIG_INLINE_WRITE_LOCK_IRQ is not set
# CONFIG_INLINE_WRITE_LOCK_IRQSAVE is not set
# CONFIG_INLINE_WRITE_UNLOCK is not set
# CONFIG_INLINE_WRITE_UNLOCK_BH is not set
# CONFIG_INLINE_WRITE_UNLOCK_IRQ is not set
# CONFIG_INLINE_WRITE_UNLOCK_IRQRESTORE is not set
# CONFIG_MUTEX_SPIN_ON_OWNER is not set
# CONFIG_FREEZER is not set
#
# System Type
#
CONFIG_MMU=y
# CONFIG_ARCH_INTEGRATOR is not set
# CONFIG_ARCH_REALVIEW is not set
# CONFIG_ARCH_VERSATILE is not set
# CONFIG_ARCH_VEXPRESS is not set
# CONFIG_ARCH_AT91 is not set
# CONFIG_ARCH_BCMRING is not set
# CONFIG_ARCH_HIGHBANK is not set
# CONFIG_ARCH_CLPS711X is not set
# CONFIG_ARCH_CNS3XXX is not set
# CONFIG_ARCH_GEMINI is not set
# CONFIG_ARCH_PRIMA2 is not set
# CONFIG_ARCH_EBSA110 is not set
# CONFIG_ARCH_EP93XX is not set
# CONFIG_ARCH_FOOTBRIDGE is not set
# CONFIG_ARCH_MXC is not set
# CONFIG_ARCH_MXS is not set
# CONFIG_ARCH_NETX is not set
# CONFIG_ARCH_H720X is not set
# CONFIG_ARCH_IOP13XX is not set
# CONFIG_ARCH_IOP32X is not set
# CONFIG_ARCH_IOP33X is not set
# CONFIG_ARCH_IXP23XX is not set
# CONFIG_ARCH_IXP2000 is not set
# CONFIG_ARCH_IXP4XX is not set
# CONFIG_ARCH_DOVE is not set
# CONFIG_ARCH_KIRKWOOD is not set
CONFIG_ARCH_LPC32XX=y
# CONFIG_ARCH_MV78XX0 is not set
# CONFIG_ARCH_ORION5X is not set
# CONFIG_ARCH_MMP is not set
# CONFIG_ARCH_KS8695 is not set
# CONFIG_ARCH_W90X900 is not set
# CONFIG_ARCH_TEGRA is not set
# CONFIG_ARCH_PICOXCELL is not set
# CONFIG_ARCH_PNX4008 is not set
# CONFIG_ARCH_PXA is not set
# CONFIG_ARCH_MSM is not set
# CONFIG_ARCH_SHMOBILE is not set
# CONFIG_ARCH_RPC is not set
# CONFIG_ARCH_SA1100 is not set
# CONFIG_ARCH_S3C24XX is not set
# CONFIG_ARCH_S3C64XX is not set
# CONFIG_ARCH_S5P64X0 is not set
# CONFIG_ARCH_S5PC100 is not set
# CONFIG_ARCH_S5PV210 is not set
# CONFIG_ARCH_EXYNOS is not set
# CONFIG_ARCH_SHARK is not set
# CONFIG_ARCH_U300 is not set
# CONFIG_ARCH_U8500 is not set
# CONFIG_ARCH_NOMADIK is not set
# CONFIG_ARCH_DAVINCI is not set
# CONFIG_ARCH_OMAP is not set
# CONFIG_PLAT_SPEAR is not set
# CONFIG_ARCH_VT8500 is not set
# CONFIG_ARCH_ZYNQ is not set
CONFIG_GPIO_PCA953X=y
#
# Individual UART enable selections
#
# CONFIG_ARCH_LPC32XX_UART3_SELECT is not set
CONFIG_ARCH_LPC32XX_UART4_SELECT=y
CONFIG_ARCH_LPC32XX_UART5_SELECT=y
# CONFIG_ARCH_LPC32XX_UART6_SELECT is not set
#
# LPC32XX chip components
#
CONFIG_ARCH_LPC32XX_IRAM_FOR_NET=y
# CONFIG_ARCH_LPC32XX_MII_SUPPORT is not set
#
# System MMU
#
#
# Processor Type
#
CONFIG_CPU_ARM926T=y
CONFIG_CPU_32v5=y
CONFIG_CPU_ABRT_EV5TJ=y
CONFIG_CPU_PABRT_LEGACY=y
CONFIG_CPU_CACHE_VIVT=y
CONFIG_CPU_COPY_V4WB=y
CONFIG_CPU_TLB_V4WBI=y
CONFIG_CPU_CP15=y
CONFIG_CPU_CP15_MMU=y
CONFIG_CPU_USE_DOMAINS=y
#
# Processor Features
#
# CONFIG_ARCH_PHYS_ADDR_T_64BIT is not set
CONFIG_ARM_THUMB=y
# CONFIG_CPU_ICACHE_DISABLE is not set
# CONFIG_CPU_DCACHE_DISABLE is not set
# CONFIG_CPU_DCACHE_WRITETHROUGH is not set
# CONFIG_CPU_CACHE_ROUND_ROBIN is not set
# CONFIG_CACHE_L2X0 is not set
CONFIG_ARM_L1_CACHE_SHIFT=5
CONFIG_ARM_NR_BANKS=8
#
# Bus support
#
CONFIG_ARM_AMBA=y
# CONFIG_PCI_SYSCALL is not set
# CONFIG_ARCH_SUPPORTS_MSI is not set
# CONFIG_PCCARD is not set
#
# Kernel Features
#
CONFIG_TICK_ONESHOT=y
CONFIG_NO_HZ=y
CONFIG_HIGH_RES_TIMERS=y
CONFIG_GENERIC_CLOCKEVENTS_BUILD=y
CONFIG_VMSPLIT_3G=y
# CONFIG_VMSPLIT_2G is not set
# CONFIG_VMSPLIT_1G is not set
CONFIG_PAGE_OFFSET=0xC0000000
CONFIG_ARCH_NR_GPIO=0
# CONFIG_PREEMPT_NONE is not set
# CONFIG_PREEMPT_VOLUNTARY is not set
CONFIG_PREEMPT=y
CONFIG_PREEMPT_COUNT=y
CONFIG_HZ=100
CONFIG_AEABI=y
CONFIG_OABI_COMPAT=y
# CONFIG_ARCH_SPARSEMEM_DEFAULT is not set
# CONFIG_ARCH_SELECT_MEMORY_MODEL is not set
CONFIG_HAVE_ARCH_PFN_VALID=y
CONFIG_HIGHMEM=y
CONFIG_HIGHPTE=y
CONFIG_SELECT_MEMORY_MODEL=y
CONFIG_FLATMEM_MANUAL=y
CONFIG_FLATMEM=y
CONFIG_FLAT_NODE_MEM_MAP=y
CONFIG_HAVE_MEMBLOCK=y
CONFIG_PAGEFLAGS_EXTENDED=y
CONFIG_SPLIT_PTLOCK_CPUS=999999
CONFIG_COMPACTION=y
CONFIG_MIGRATION=y
# CONFIG_PHYS_ADDR_T_64BIT is not set
CONFIG_ZONE_DMA_FLAG=0
CONFIG_VIRT_TO_BUS=y
# CONFIG_KSM is not set
CONFIG_DEFAULT_MMAP_MIN_ADDR=4096
CONFIG_NEED_PER_CPU_KM=y
# CONFIG_CLEANCACHE is not set
CONFIG_FORCE_MAX_ZONEORDER=11
CONFIG_ALIGNMENT_TRAP=y
# CONFIG_UACCESS_WITH_MEMCPY is not set
# CONFIG_SECCOMP is not set
# CONFIG_CC_STACKPROTECTOR is not set
# CONFIG_DEPRECATED_PARAM_STRUCT is not set
#
# Boot options
#
CONFIG_USE_OF=y
CONFIG_ZBOOT_ROM_TEXT=0
CONFIG_ZBOOT_ROM_BSS=0
# CONFIG_ARM_APPENDED_DTB is not set
CONFIG_CMDLINE="console=ttyS0,115200"
CONFIG_CMDLINE_FROM_BOOTLOADER=y
# CONFIG_CMDLINE_EXTEND is not set
# CONFIG_CMDLINE_FORCE is not set
# CONFIG_XIP_KERNEL is not set
CONFIG_KEXEC=y
CONFIG_ATAGS_PROC=y
# CONFIG_CRASH_DUMP is not set
CONFIG_AUTO_ZRELADDR=y
#
# CPU Power Management
#
CONFIG_CPU_IDLE=y
CONFIG_CPU_IDLE_GOV_LADDER=y
CONFIG_CPU_IDLE_GOV_MENU=y
#
# Floating point emulation
#
#
# At least one emulation must be selected
#
# CONFIG_FPE_NWFPE is not set
# CONFIG_FPE_FASTFPE is not set
CONFIG_VFP=y
#
# Userspace binary formats
#
CONFIG_BINFMT_ELF=y
CONFIG_ARCH_BINFMT_ELF_RANDOMIZE_PIE=y
CONFIG_CORE_DUMP_DEFAULT_ELF_HEADERS=y
# CONFIG_HAVE_AOUT is not set
# CONFIG_BINFMT_MISC is not set
#
# Power management options
#
# CONFIG_SUSPEND is not set
# CONFIG_PM_RUNTIME is not set
CONFIG_CPU_PM=y
CONFIG_ARCH_SUSPEND_POSSIBLE=y
# CONFIG_ARM_CPU_SUSPEND is not set
CONFIG_NET=y
#
# Networking options
#
CONFIG_PACKET=y
CONFIG_UNIX=y
# CONFIG_UNIX_DIAG is not set
# CONFIG_NET_KEY is not set
CONFIG_INET=y
CONFIG_IP_MULTICAST=y
# CONFIG_IP_ADVANCED_ROUTER 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_IP_MROUTE is not set
# CONFIG_ARPD is not set
# CONFIG_SYN_COOKIES is not set
# CONFIG_INET_AH is not set
# CONFIG_INET_ESP is not set
# CONFIG_INET_IPCOMP is not set
# CONFIG_INET_XFRM_TUNNEL is not set
# CONFIG_INET_TUNNEL is not set
# CONFIG_INET_XFRM_MODE_TRANSPORT is not set
# CONFIG_INET_XFRM_MODE_TUNNEL is not set
# CONFIG_INET_XFRM_MODE_BEET is not set
CONFIG_INET_LRO=y
# CONFIG_INET_DIAG 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 is not set
# CONFIG_NETWORK_SECMARK is not set
# CONFIG_NETWORK_PHY_TIMESTAMPING is not set
# CONFIG_NETFILTER 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_STP=y
CONFIG_GARP=y
# CONFIG_BRIDGE is not set
# CONFIG_NET_DSA is not set
CONFIG_VLAN_8021Q=y
CONFIG_VLAN_8021Q_GVRP=y
# CONFIG_DECNET is not set
CONFIG_LLC=y
# CONFIG_LLC2 is not set
# CONFIG_IPX is not set
# CONFIG_ATALK is not set
# CONFIG_X25 is not set
# CONFIG_LAPB is not set
# CONFIG_ECONET is not set
# CONFIG_WAN_ROUTER is not set
# CONFIG_PHONET 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_NETPRIO_CGROUP is not set
CONFIG_BQL=y
CONFIG_HAVE_BPF_JIT=y
# CONFIG_BPF_JIT is not set
#
# Network testing
#
# CONFIG_NET_PKTGEN is not set
# CONFIG_HAMRADIO is not set
CONFIG_CAN=y
CONFIG_CAN_RAW=y
CONFIG_CAN_BCM=y
# CONFIG_CAN_GW is not set
#
# CAN Device Drivers
#
# CONFIG_CAN_VCAN is not set
# CONFIG_CAN_SLCAN is not set
CONFIG_CAN_DEV=y
CONFIG_CAN_CALC_BITTIMING=y
CONFIG_CAN_MCP251X=y
# CONFIG_CAN_SJA1000 is not set
# CONFIG_CAN_C_CAN is not set
# CONFIG_CAN_CC770 is not set
# CONFIG_CAN_SOFTING is not set
# CONFIG_CAN_DEBUG_DEVICES is not set
# CONFIG_IRDA is not set
# CONFIG_BT is not set
# CONFIG_AF_RXRPC is not set
# CONFIG_WIRELESS is not set
# CONFIG_WIMAX is not set
# CONFIG_RFKILL is not set
# CONFIG_RFKILL_REGULATOR is not set
# CONFIG_NET_9P is not set
# CONFIG_CAIF is not set
# CONFIG_CEPH_LIB is not set
# CONFIG_NFC is not set
#
# Device Drivers
#
#
# Generic Driver Options
#
CONFIG_UEVENT_HELPER_PATH=""
CONFIG_DEVTMPFS=y
CONFIG_DEVTMPFS_MOUNT=y
CONFIG_STANDALONE=y
CONFIG_PREVENT_FIRMWARE_BUILD=y
CONFIG_FW_LOADER=y
CONFIG_FIRMWARE_IN_KERNEL=y
CONFIG_EXTRA_FIRMWARE=""
# CONFIG_DEBUG_DRIVER is not set
# CONFIG_DEBUG_DEVRES is not set
# CONFIG_SYS_HYPERVISOR is not set
# CONFIG_GENERIC_CPU_DEVICES is not set
# CONFIG_DMA_SHARED_BUFFER is not set
# CONFIG_CONNECTOR is not set
CONFIG_MTD=y
# CONFIG_MTD_TESTS is not set
# CONFIG_MTD_REDBOOT_PARTS is not set
CONFIG_MTD_CMDLINE_PARTS=y
CONFIG_MTD_AFS_PARTS=y
CONFIG_MTD_OF_PARTS=y
# CONFIG_MTD_AR7_PARTS is not set
#
# User Modules And Translation Layers
#
CONFIG_MTD_CHAR=y
CONFIG_MTD_OOPS=y
#
# RAM/ROM/Flash chip drivers
#
# CONFIG_MTD_CFI is not set
# CONFIG_MTD_JEDECPROBE is not set
CONFIG_MTD_MAP_BANK_WIDTH_1=y
CONFIG_MTD_MAP_BANK_WIDTH_2=y
CONFIG_MTD_MAP_BANK_WIDTH_4=y
# CONFIG_MTD_MAP_BANK_WIDTH_8 is not set
# CONFIG_MTD_MAP_BANK_WIDTH_16 is not set
# CONFIG_MTD_MAP_BANK_WIDTH_32 is not set
CONFIG_MTD_CFI_I1=y
CONFIG_MTD_CFI_I2=y
# CONFIG_MTD_CFI_I4 is not set
# CONFIG_MTD_CFI_I8 is not set
CONFIG_MTD_RAM=y
# CONFIG_MTD_ROM is not set
# CONFIG_MTD_ABSENT is not set
#
# Mapping drivers for chip access
#
CONFIG_MTD_COMPLEX_MAPPINGS=y
CONFIG_MTD_GPIO_ADDR=y
CONFIG_MTD_PLATRAM=y
# CONFIG_MTD_LATCH_ADDR is not set
#
# Self-contained MTD device drivers
#
# CONFIG_MTD_DATAFLASH is not set
CONFIG_MTD_M25P80=y
CONFIG_M25PXX_USE_FAST_READ=y
# CONFIG_MTD_SST25L is not set
# CONFIG_MTD_SLRAM is not set
# CONFIG_MTD_PHRAM is not set
# CONFIG_MTD_MTDRAM is not set
#
# Disk-On-Chip Device Drivers
#
# CONFIG_MTD_DOC2000 is not set
# CONFIG_MTD_DOC2001 is not set
# CONFIG_MTD_DOC2001PLUS is not set
# CONFIG_MTD_DOCG3 is not set
CONFIG_MTD_NAND_ECC=y
CONFIG_MTD_NAND_ECC_SMC=y
CONFIG_MTD_NAND=y
# CONFIG_MTD_NAND_VERIFY_WRITE is not set
CONFIG_MTD_NAND_BCH=y
CONFIG_MTD_NAND_ECC_BCH=y
# CONFIG_MTD_SM_COMMON is not set
# CONFIG_MTD_NAND_MUSEUM_IDS is not set
# CONFIG_MTD_NAND_GPIO is not set
CONFIG_MTD_NAND_IDS=y
# CONFIG_MTD_NAND_DISKONCHIP is not set
# CONFIG_MTD_NAND_DOCG4 is not set
# CONFIG_MTD_NAND_NANDSIM is not set
CONFIG_MTD_NAND_PLATFORM=y
# CONFIG_MTD_ONENAND is not set
#
# LPDDR flash memory drivers
#
# CONFIG_MTD_LPDDR is not set
CONFIG_MTD_UBI=y
CONFIG_MTD_UBI_WL_THRESHOLD=4096
CONFIG_MTD_UBI_BEB_RESERVE=1
CONFIG_MTD_UBI_GLUEBI=y
# CONFIG_MTD_UBI_DEBUG is not set
CONFIG_DTC=y
CONFIG_OF=y
#
# Device Tree and Open Firmware support
#
# CONFIG_PROC_DEVICETREE is not set
# CONFIG_OF_SELFTEST is not set
CONFIG_OF_FLATTREE=y
CONFIG_OF_EARLY_FLATTREE=y
CONFIG_OF_ADDRESS=y
CONFIG_OF_IRQ=y
CONFIG_OF_DEVICE=y
CONFIG_OF_GPIO=y
CONFIG_OF_I2C=y
CONFIG_OF_NET=y
CONFIG_OF_SPI=y
CONFIG_OF_MDIO=y
CONFIG_OF_MTD=y
# CONFIG_PARPORT is not set
#
# Misc devices
#
# CONFIG_AD525X_DPOT is not set
# CONFIG_ATMEL_PWM is not set
# CONFIG_ICS932S401 is not set
# CONFIG_ENCLOSURE_SERVICES 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_BH1780 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_TI_DAC7512 is not set
# CONFIG_BMP085 is not set
# CONFIG_USB_SWITCH_FSA9480 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_IWMC3200TOP is not set
#
# Texas Instruments shared transport line discipline
#
# CONFIG_TI_ST is not set
#
# Altera FPGA firmware download module
#
# CONFIG_ALTERA_STAPL is not set
CONFIG_HAVE_IDE=y
#
# SCSI device support
#
CONFIG_SCSI_MOD=y
# CONFIG_SCSI_DMA is not set
# CONFIG_SCSI_NETLINK is not set
CONFIG_NETDEVICES=y
CONFIG_NET_CORE=y
# CONFIG_BONDING is not set
# CONFIG_DUMMY is not set
# CONFIG_EQUALIZER is not set
# CONFIG_MII is not set
# CONFIG_NET_TEAM is not set
# CONFIG_MACVLAN is not set
# CONFIG_NETCONSOLE is not set
# CONFIG_NETPOLL is not set
# CONFIG_NET_POLL_CONTROLLER is not set
# CONFIG_TUN is not set
# CONFIG_VETH is not set
#
# CAIF transport drivers
#
CONFIG_ETHERNET=y
CONFIG_NET_VENDOR_BROADCOM=y
# CONFIG_B44 is not set
# CONFIG_NET_CALXEDA_XGMAC is not set
CONFIG_NET_VENDOR_CHELSIO=y
CONFIG_NET_VENDOR_CIRRUS=y
# CONFIG_CS89x0 is not set
# CONFIG_DM9000 is not set
# CONFIG_DNET is not set
CONFIG_NET_VENDOR_FARADAY=y
# CONFIG_FTMAC100 is not set
# CONFIG_FTGMAC100 is not set
CONFIG_NET_VENDOR_INTEL=y
CONFIG_NET_VENDOR_I825XX=y
CONFIG_NET_VENDOR_MARVELL=y
CONFIG_NET_VENDOR_MICREL=y
# CONFIG_KS8851 is not set
# CONFIG_KS8851_MLL is not set
CONFIG_NET_VENDOR_MICROCHIP=y
# CONFIG_ENC28J60 is not set
CONFIG_NET_VENDOR_NATSEMI=y
CONFIG_NET_VENDOR_8390=y
# CONFIG_AX88796 is not set
# CONFIG_LPC_ENET is not set
# CONFIG_ETHOC is not set
CONFIG_NET_VENDOR_SEEQ=y
# CONFIG_SEEQ8005 is not set
CONFIG_NET_VENDOR_SMSC=y
# CONFIG_SMC91X is not set
# CONFIG_SMC911X is not set
# CONFIG_SMSC911X is not set
CONFIG_NET_VENDOR_STMICRO=y
# CONFIG_STMMAC_ETH is not set
CONFIG_PHYLIB=y
#
# MII PHY device drivers
#
# CONFIG_AMD_PHY is not set
# CONFIG_MARVELL_PHY is not set
# CONFIG_DAVICOM_PHY is not set
# CONFIG_QSEMI_PHY is not set
# CONFIG_LXT_PHY is not set
# CONFIG_CICADA_PHY is not set
# CONFIG_VITESSE_PHY is not set
# CONFIG_SMSC_PHY is not set
# CONFIG_BROADCOM_PHY is not set
# CONFIG_ICPLUS_PHY is not set
# CONFIG_REALTEK_PHY is not set
# CONFIG_NATIONAL_PHY is not set
# CONFIG_STE10XP is not set
# CONFIG_LSI_ET1011C_PHY is not set
# CONFIG_MICREL_PHY is not set
CONFIG_FIXED_PHY=y
# CONFIG_MDIO_BITBANG is not set
# CONFIG_MICREL_KS8995MA is not set
# CONFIG_PPP is not set
# CONFIG_SLIP is not set
# CONFIG_WLAN is not set
#
# Enable WiMAX (Networking options) to see the WiMAX drivers
#
# CONFIG_WAN is not set
# CONFIG_ISDN is not set
#
# Input device support
#
# CONFIG_INPUT is not set
#
# Hardware I/O ports
#
# CONFIG_SERIO is not set
# CONFIG_GAMEPORT is not set
#
# Character devices
#
# CONFIG_VT is not set
# CONFIG_UNIX98_PTYS is not set
# CONFIG_LEGACY_PTYS is not set
# CONFIG_SERIAL_NONSTANDARD is not set
# CONFIG_N_GSM is not set
# CONFIG_TRACE_SINK is not set
# CONFIG_DEVKMEM is not set
#
# Serial drivers
#
CONFIG_SERIAL_8250=y
CONFIG_SERIAL_8250_CONSOLE=y
CONFIG_SERIAL_8250_NR_UARTS=4
CONFIG_SERIAL_8250_RUNTIME_UARTS=4
# CONFIG_SERIAL_8250_EXTENDED is not set
# CONFIG_SERIAL_8250_DW is not set
#
# Non-8250 serial port support
#
# CONFIG_SERIAL_AMBA_PL010 is not set
CONFIG_SERIAL_AMBA_PL011=y
CONFIG_SERIAL_AMBA_PL011_CONSOLE=y
# CONFIG_SERIAL_MAX3100 is not set
# CONFIG_SERIAL_MAX3107 is not set
CONFIG_SERIAL_CORE=y
CONFIG_SERIAL_CORE_CONSOLE=y
CONFIG_SERIAL_OF_PLATFORM=y
# CONFIG_SERIAL_TIMBERDALE is not set
# CONFIG_SERIAL_ALTERA_JTAGUART is not set
# CONFIG_SERIAL_ALTERA_UART is not set
# CONFIG_SERIAL_IFX6X60 is not set
CONFIG_SERIAL_XILINX_PS_UART=y
CONFIG_SERIAL_XILINX_PS_UART_CONSOLE=y
# CONFIG_TTY_PRINTK is not set
# CONFIG_HVC_DCC is not set
# CONFIG_IPMI_HANDLER is not set
CONFIG_HW_RANDOM=y
# CONFIG_HW_RANDOM_TIMERIOMEM is not set
# CONFIG_R3964 is not set
# CONFIG_TCG_TPM is not set
# CONFIG_RAMOOPS is not set
CONFIG_I2C=y
CONFIG_I2C_BOARDINFO=y
CONFIG_I2C_COMPAT=y
CONFIG_I2C_CHARDEV=y
CONFIG_I2C_MUX=y
#
# Multiplexer I2C Chip support
#
# CONFIG_I2C_MUX_GPIO is not set
# CONFIG_I2C_MUX_PCA9541 is not set
# CONFIG_I2C_MUX_PCA954x is not set
CONFIG_I2C_HELPER_AUTO=y
#
# I2C Hardware Bus support
#
#
# I2C system bus drivers (mostly embedded / system-on-chip)
#
# CONFIG_I2C_DESIGNWARE_PLATFORM is not set
# CONFIG_I2C_GPIO is not set
# CONFIG_I2C_OCORES is not set
# CONFIG_I2C_PCA_PLATFORM is not set
# CONFIG_I2C_PNX is not set
# CONFIG_I2C_PXA_PCI is not set
# CONFIG_I2C_SIMTEC is not set
# CONFIG_I2C_XILINX is not set
#
# External I2C/SMBus adapter drivers
#
# CONFIG_I2C_PARPORT_LIGHT is not set
# CONFIG_I2C_TAOS_EVM is not set
#
# Other I2C/SMBus bus drivers
#
# CONFIG_I2C_STUB is not set
# CONFIG_I2C_DEBUG_CORE is not set
# CONFIG_I2C_DEBUG_ALGO is not set
# CONFIG_I2C_DEBUG_BUS is not set
CONFIG_SPI=y
# CONFIG_SPI_DEBUG is not set
CONFIG_SPI_MASTER=y
#
# SPI Master Controller Drivers
#
# CONFIG_SPI_ALTERA is not set
# CONFIG_SPI_BITBANG is not set
# CONFIG_SPI_GPIO is not set
# CONFIG_SPI_OC_TINY is not set
# CONFIG_SPI_PL022 is not set
# CONFIG_SPI_PXA2XX_PCI is not set
# CONFIG_SPI_XILINX is not set
# CONFIG_SPI_DESIGNWARE is not set
#
# SPI Protocol Masters
#
# CONFIG_SPI_SPIDEV is not set
# CONFIG_SPI_TLE62X0 is not set
# CONFIG_HSI is not set
#
# PPS support
#
# CONFIG_PPS is not set
#
# PPS generators support
#
#
# PTP clock support
#
#
# Enable Device Drivers -> PPS to see the PTP clock options.
#
CONFIG_ARCH_REQUIRE_GPIOLIB=y
CONFIG_GPIOLIB=y
# CONFIG_DEBUG_GPIO is not set
# CONFIG_GPIO_SYSFS is not set
#
# Memory mapped GPIO drivers:
#
# CONFIG_GPIO_GENERIC_PLATFORM is not set
CONFIG_GPIO_PL061=y
#
# I2C GPIO expanders:
#
# CONFIG_GPIO_MAX7300 is not set
# CONFIG_GPIO_MAX732X is not set
CONFIG_GPIO_PCA953X_IRQ=y
CONFIG_GPIO_PCF857X=y
# CONFIG_GPIO_SX150X is not set
# CONFIG_GPIO_ADP5588 is not set
#
# PCI GPIO expanders:
#
#
# SPI GPIO expanders:
#
# CONFIG_GPIO_MAX7301 is not set
# CONFIG_GPIO_MCP23S08 is not set
# CONFIG_GPIO_MC33880 is not set
# CONFIG_GPIO_74X164 is not set
#
# AC97 GPIO expanders:
#
#
# MODULbus GPIO expanders:
#
# CONFIG_W1 is not set
CONFIG_POWER_SUPPLY=y
# CONFIG_POWER_SUPPLY_DEBUG is not set
# CONFIG_PDA_POWER is not set
# CONFIG_TEST_POWER is not set
# CONFIG_BATTERY_DS2780 is not set
# CONFIG_BATTERY_DS2781 is not set
# CONFIG_BATTERY_DS2782 is not set
# CONFIG_BATTERY_SBS is not set
# CONFIG_BATTERY_BQ27x00 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_GPIO is not set
# CONFIG_CHARGER_MANAGER is not set
# CONFIG_CHARGER_SMB347 is not set
CONFIG_HWMON=y
# CONFIG_HWMON_VID is not set
# 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_ADCXX 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_ADM9240 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_ASC7621 is not set
# CONFIG_SENSORS_ATXP1 is not set
# CONFIG_SENSORS_DS620 is not set
# CONFIG_SENSORS_DS1621 is not set
# CONFIG_SENSORS_F71805F is not set
# CONFIG_SENSORS_F71882FG is not set
# CONFIG_SENSORS_F75375S is not set
# CONFIG_SENSORS_G760A is not set
# CONFIG_SENSORS_GL518SM is not set
# CONFIG_SENSORS_GL520SM is not set
# CONFIG_SENSORS_GPIO_FAN is not set
# CONFIG_SENSORS_IT87 is not set
# CONFIG_SENSORS_JC42 is not set
# CONFIG_SENSORS_LINEAGE 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=y
# CONFIG_SENSORS_LM92 is not set
# CONFIG_SENSORS_LM93 is not set
# CONFIG_SENSORS_LTC4151 is not set
# CONFIG_SENSORS_LTC4215 is not set
# CONFIG_SENSORS_LTC4245 is not set
# CONFIG_SENSORS_LTC4261 is not set
# CONFIG_SENSORS_LM95241 is not set
# CONFIG_SENSORS_LM95245 is not set
# CONFIG_SENSORS_MAX1111 is not set
# CONFIG_SENSORS_MAX16065 is not set
# CONFIG_SENSORS_MAX1619 is not set
# CONFIG_SENSORS_MAX1668 is not set
# CONFIG_SENSORS_MAX6639 is not set
# CONFIG_SENSORS_MAX6642 is not set
# CONFIG_SENSORS_MAX6650 is not set
# CONFIG_SENSORS_MCP3021 is not set
# CONFIG_SENSORS_NTC_THERMISTOR is not set
# CONFIG_SENSORS_PC87360 is not set
# CONFIG_SENSORS_PC87427 is not set
# CONFIG_SENSORS_PCF8591 is not set
# CONFIG_PMBUS is not set
# CONFIG_SENSORS_SHT15 is not set
# CONFIG_SENSORS_SHT21 is not set
# CONFIG_SENSORS_SMM665 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_SCH56XX_COMMON is not set
# CONFIG_SENSORS_SCH5627 is not set
# CONFIG_SENSORS_SCH5636 is not set
# CONFIG_SENSORS_ADS1015 is not set
# CONFIG_SENSORS_ADS7828 is not set
# CONFIG_SENSORS_ADS7871 is not set
# CONFIG_SENSORS_AMC6821 is not set
# CONFIG_SENSORS_THMC50 is not set
# CONFIG_SENSORS_TMP102 is not set
# CONFIG_SENSORS_TMP401 is not set
# CONFIG_SENSORS_TMP421 is not set
# CONFIG_SENSORS_VT1211 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=y
CONFIG_THERMAL_HWMON=y
# CONFIG_WATCHDOG is not set
CONFIG_SSB_POSSIBLE=y
#
# Sonics Silicon Backplane
#
# CONFIG_SSB is not set
CONFIG_BCMA_POSSIBLE=y
#
# Broadcom specific AMBA
#
# CONFIG_BCMA is not set
#
# Multifunction device drivers
#
# CONFIG_MFD_CORE is not set
# CONFIG_MFD_88PM860X is not set
# CONFIG_MFD_SM501 is not set
# CONFIG_MFD_ASIC3 is not set
# CONFIG_HTC_EGPIO is not set
# CONFIG_HTC_PASIC3 is not set
# CONFIG_HTC_I2CPLD is not set
# CONFIG_TPS6105X is not set
# CONFIG_TPS65010 is not set
# CONFIG_TPS6507X is not set
# CONFIG_MFD_TPS65217 is not set
# CONFIG_MFD_TPS6586X is not set
# CONFIG_MFD_TPS65910 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_STMPE is not set
# CONFIG_MFD_TC3589X is not set
# CONFIG_MFD_TMIO is not set
# CONFIG_MFD_T7L66XB is not set
# CONFIG_MFD_TC6387XB is not set
# CONFIG_MFD_TC6393XB is not set
# CONFIG_PMIC_DA903X is not set
# CONFIG_MFD_DA9052_SPI is not set
# CONFIG_MFD_DA9052_I2C is not set
# CONFIG_PMIC_ADP5520 is not set
# CONFIG_MFD_MAX8925 is not set
# CONFIG_MFD_MAX8997 is not set
# CONFIG_MFD_MAX8998 is not set
# CONFIG_MFD_S5M_CORE 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_PCF50633 is not set
# CONFIG_MFD_MC13XXX is not set
# CONFIG_ABX500_CORE is not set
# CONFIG_EZX_PCAP is not set
# CONFIG_MFD_WL1273_CORE is not set
# CONFIG_MFD_TPS65090 is not set
# CONFIG_MFD_AAT2870_CORE is not set
# CONFIG_MFD_RC5T583 is not set
CONFIG_REGULATOR=y
# CONFIG_REGULATOR_DEBUG is not set
# CONFIG_REGULATOR_DUMMY is not set
CONFIG_REGULATOR_FIXED_VOLTAGE=y
# CONFIG_REGULATOR_VIRTUAL_CONSUMER is not set
# CONFIG_REGULATOR_USERSPACE_CONSUMER is not set
# CONFIG_REGULATOR_GPIO is not set
# CONFIG_REGULATOR_AD5398 is not set
# CONFIG_REGULATOR_ISL6271A is not set
# CONFIG_REGULATOR_MAX1586 is not set
# CONFIG_REGULATOR_MAX8649 is not set
# CONFIG_REGULATOR_MAX8660 is not set
# CONFIG_REGULATOR_MAX8952 is not set
# CONFIG_REGULATOR_LP3971 is not set
# CONFIG_REGULATOR_LP3972 is not set
# CONFIG_REGULATOR_TPS62360 is not set
# CONFIG_REGULATOR_TPS65023 is not set
# CONFIG_REGULATOR_TPS6507X is not set
# CONFIG_REGULATOR_TPS6524X is not set
# CONFIG_MEDIA_SUPPORT is not set
#
# Graphics support
#
# CONFIG_DRM is not set
# CONFIG_VGASTATE is not set
# CONFIG_VIDEO_OUTPUT_CONTROL is not set
# CONFIG_FB is not set
# CONFIG_EXYNOS_VIDEO is not set
# CONFIG_BACKLIGHT_LCD_SUPPORT is not set
# CONFIG_SOUND is not set
CONFIG_USB_ARCH_HAS_OHCI=y
# CONFIG_USB_ARCH_HAS_EHCI is not set
# CONFIG_USB_ARCH_HAS_XHCI is not set
# CONFIG_USB_SUPPORT is not set
CONFIG_MMC=y
# CONFIG_MMC_DEBUG is not set
# CONFIG_MMC_UNSAFE_RESUME is not set
# CONFIG_MMC_CLKGATE is not set
#
# MMC/SD/SDIO Card Drivers
#
# CONFIG_SDIO_UART is not set
# CONFIG_MMC_TEST is not set
#
# MMC/SD/SDIO Host Controller Drivers
#
# CONFIG_MMC_ARMMMCI is not set
# CONFIG_MMC_SDHCI is not set
# CONFIG_MMC_SDHCI_PXAV3 is not set
# CONFIG_MMC_SDHCI_PXAV2 is not set
# CONFIG_MMC_DW is not set
# CONFIG_MEMSTICK is not set
CONFIG_NEW_LEDS=y
CONFIG_LEDS_CLASS=y
#
# LED drivers
#
# CONFIG_LEDS_LM3530 is not set
CONFIG_LEDS_GPIO=y
# CONFIG_LEDS_LP3944 is not set
# CONFIG_LEDS_LP5521 is not set
# CONFIG_LEDS_LP5523 is not set
# CONFIG_LEDS_PCA955X is not set
# CONFIG_LEDS_PCA9633 is not set
# CONFIG_LEDS_DAC124S085 is not set
# CONFIG_LEDS_REGULATOR is not set
# CONFIG_LEDS_BD2802 is not set
# CONFIG_LEDS_LT3593 is not set
# CONFIG_LEDS_RENESAS_TPU is not set
# CONFIG_LEDS_TCA6507 is not set
# CONFIG_LEDS_OT200 is not set
CONFIG_LEDS_TRIGGERS=y
#
# LED Triggers
#
CONFIG_LEDS_TRIGGER_TIMER=y
CONFIG_LEDS_TRIGGER_HEARTBEAT=y
CONFIG_LEDS_TRIGGER_BACKLIGHT=y
CONFIG_LEDS_TRIGGER_GPIO=y
CONFIG_LEDS_TRIGGER_DEFAULT_ON=y
#
# iptables trigger is under Netfilter config (LED target)
#
# CONFIG_ACCESSIBILITY is not set
CONFIG_RTC_LIB=y
CONFIG_RTC_CLASS=y
CONFIG_RTC_HCTOSYS=y
CONFIG_RTC_HCTOSYS_DEVICE="rtc0"
# CONFIG_RTC_DEBUG is not set
#
# 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_DS1307 is not set
# CONFIG_RTC_DRV_DS1374 is not set
# CONFIG_RTC_DRV_DS1672 is not set
# CONFIG_RTC_DRV_DS3232 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_X1205 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_RX8581 is not set
# CONFIG_RTC_DRV_RX8025 is not set
# CONFIG_RTC_DRV_EM3027 is not set
# CONFIG_RTC_DRV_RV3029C2 is not set
#
# SPI RTC drivers
#
# CONFIG_RTC_DRV_M41T93 is not set
# CONFIG_RTC_DRV_M41T94 is not set
# CONFIG_RTC_DRV_DS1305 is not set
# CONFIG_RTC_DRV_DS1390 is not set
# CONFIG_RTC_DRV_MAX6902 is not set
# CONFIG_RTC_DRV_R9701 is not set
# CONFIG_RTC_DRV_RS5C348 is not set
# CONFIG_RTC_DRV_DS3234 is not set
CONFIG_RTC_DRV_PCF2123=y
#
# Platform RTC drivers
#
# CONFIG_RTC_DRV_CMOS is not set
# CONFIG_RTC_DRV_DS1286 is not set
# CONFIG_RTC_DRV_DS1511 is not set
# CONFIG_RTC_DRV_DS1553 is not set
# CONFIG_RTC_DRV_DS1742 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
#
# on-CPU RTC drivers
#
# CONFIG_RTC_DRV_PL030 is not set
# CONFIG_RTC_DRV_PL031 is not set
# CONFIG_RTC_DRV_LPC32XX is not set
CONFIG_DMADEVICES=y
# CONFIG_DMADEVICES_DEBUG is not set
#
# DMA Devices
#
# CONFIG_AMBA_PL08X is not set
# CONFIG_DW_DMAC is not set
# CONFIG_TIMB_DMA is not set
# CONFIG_PL330_DMA is not set
# CONFIG_AUXDISPLAY is not set
# CONFIG_UIO is not set
#
# Virtio drivers
#
# CONFIG_VIRTIO_BALLOON is not set
# CONFIG_VIRTIO_MMIO is not set
#
# Microsoft Hyper-V guest support
#
CONFIG_STAGING=y
# CONFIG_ECHO is not set
CONFIG_IIO=y
# CONFIG_IIO_ST_HWMON is not set
# CONFIG_IIO_BUFFER is not set
CONFIG_IIO_TRIGGER=y
CONFIG_IIO_CONSUMERS_PER_TRIGGER=2
#
# Accelerometers
#
# CONFIG_ADIS16201 is not set
# CONFIG_ADIS16203 is not set
# CONFIG_ADIS16204 is not set
# CONFIG_ADIS16209 is not set
# CONFIG_ADIS16220 is not set
# CONFIG_ADIS16240 is not set
# CONFIG_KXSD9 is not set
# CONFIG_LIS3L02DQ is not set
#
# Analog to digital converters
#
# CONFIG_AD7291 is not set
# CONFIG_AD7298 is not set
# CONFIG_AD7606 is not set
# CONFIG_AD799X is not set
# CONFIG_AD7476 is not set
# CONFIG_AD7887 is not set
# CONFIG_AD7780 is not set
# CONFIG_AD7793 is not set
# CONFIG_AD7816 is not set
# CONFIG_AD7192 is not set
# CONFIG_ADT7310 is not set
# CONFIG_ADT7410 is not set
# CONFIG_AD7280 is not set
# CONFIG_MAX1363 is not set
# CONFIG_LPC32XX_ADC is not set
#
# Analog digital bi-direction converters
#
# CONFIG_ADT7316 is not set
#
# Capacitance to digital converters
#
# CONFIG_AD7150 is not set
# CONFIG_AD7152 is not set
# CONFIG_AD7746 is not set
#
# Digital to analog converters
#
# CONFIG_AD5064 is not set
# CONFIG_AD5360 is not set
# CONFIG_AD5380 is not set
# CONFIG_AD5421 is not set
# CONFIG_AD5624R_SPI is not set
# CONFIG_AD5446 is not set
# CONFIG_AD5504 is not set
# CONFIG_AD5764 is not set
# CONFIG_AD5791 is not set
# CONFIG_AD5686 is not set
# CONFIG_MAX517 is not set
#
# Direct Digital Synthesis
#
# CONFIG_AD5930 is not set
# CONFIG_AD9832 is not set
# CONFIG_AD9834 is not set
# CONFIG_AD9850 is not set
# CONFIG_AD9852 is not set
# CONFIG_AD9910 is not set
# CONFIG_AD9951 is not set
#
# Digital gyroscope sensors
#
# CONFIG_ADIS16060 is not set
# CONFIG_ADIS16080 is not set
# CONFIG_ADIS16130 is not set
# CONFIG_ADIS16260 is not set
# CONFIG_ADXRS450 is not set
#
# Network Analyzer, Impedance Converters
#
# CONFIG_AD5933 is not set
#
# Inertial measurement units
#
# CONFIG_ADIS16400 is not set
#
# Light sensors
#
CONFIG_SENSORS_ISL29018=y
# CONFIG_SENSORS_TSL2563 is not set
# CONFIG_TSL2583 is not set
#
# Magnetometer sensors
#
# CONFIG_SENSORS_AK8975 is not set
# CONFIG_SENSORS_HMC5843 is not set
#
# Active energy metering IC
#
# CONFIG_ADE7753 is not set
# CONFIG_ADE7754 is not set
# CONFIG_ADE7758 is not set
# CONFIG_ADE7759 is not set
# CONFIG_ADE7854 is not set
#
# Resolver to digital converters
#
# CONFIG_AD2S90 is not set
# CONFIG_AD2S1200 is not set
# CONFIG_AD2S1210 is not set
#
# Triggers - standalone
#
# CONFIG_IIO_PERIODIC_RTC_TRIGGER is not set
# CONFIG_IIO_GPIO_TRIGGER is not set
# CONFIG_IIO_SYSFS_TRIGGER is not set
# CONFIG_IIO_SIMPLE_DUMMY is not set
# CONFIG_FT1000 is not set
#
# Speakup console speech
#
# CONFIG_STAGING_MEDIA is not set
#
# Android
#
# CONFIG_ANDROID is not set
# CONFIG_PHONE is not set
CONFIG_CLKDEV_LOOKUP=y
#
# Hardware Spinlock drivers
#
CONFIG_CLKSRC_MMIO=y
CONFIG_IOMMU_SUPPORT=y
#
# Remoteproc drivers (EXPERIMENTAL)
#
#
# Rpmsg drivers (EXPERIMENTAL)
#
# CONFIG_VIRT_DRIVERS is not set
# CONFIG_PM_DEVFREQ is not set
#
# File systems
#
CONFIG_FS_POSIX_ACL=y
CONFIG_EXPORTFS=y
CONFIG_FILE_LOCKING=y
CONFIG_FSNOTIFY=y
CONFIG_DNOTIFY=y
CONFIG_INOTIFY_USER=y
CONFIG_FANOTIFY=y
# CONFIG_QUOTA is not set
# CONFIG_QUOTACTL is not set
CONFIG_AUTOFS4_FS=y
CONFIG_FUSE_FS=y
CONFIG_CUSE=y
CONFIG_GENERIC_ACL=y
#
# Caches
#
# CONFIG_FSCACHE is not set
#
# Pseudo filesystems
#
CONFIG_PROC_FS=y
CONFIG_PROC_SYSCTL=y
CONFIG_PROC_PAGE_MONITOR=y
CONFIG_SYSFS=y
CONFIG_TMPFS=y
CONFIG_TMPFS_POSIX_ACL=y
CONFIG_TMPFS_XATTR=y
# CONFIG_HUGETLB_PAGE is not set
CONFIG_CONFIGFS_FS=y
CONFIG_MISC_FILESYSTEMS=y
# CONFIG_ECRYPT_FS is not set
CONFIG_JFFS2_FS=y
CONFIG_JFFS2_FS_DEBUG=0
CONFIG_JFFS2_FS_WRITEBUFFER=y
# CONFIG_JFFS2_FS_WBUF_VERIFY is not set
# CONFIG_JFFS2_SUMMARY is not set
# CONFIG_JFFS2_FS_XATTR is not set
# CONFIG_JFFS2_COMPRESSION_OPTIONS is not set
CONFIG_JFFS2_ZLIB=y
# CONFIG_JFFS2_LZO is not set
CONFIG_JFFS2_RTIME=y
# CONFIG_JFFS2_RUBIN is not set
CONFIG_UBIFS_FS=y
CONFIG_UBIFS_FS_XATTR=y
CONFIG_UBIFS_FS_ADVANCED_COMPR=y
CONFIG_UBIFS_FS_LZO=y
CONFIG_UBIFS_FS_ZLIB=y
# CONFIG_UBIFS_FS_DEBUG is not set
# CONFIG_LOGFS is not set
# CONFIG_ROMFS_FS is not set
# CONFIG_PSTORE is not set
# CONFIG_NETWORK_FILESYSTEMS is not set
# CONFIG_NLS is not set
# CONFIG_DLM is not set
#
# Kernel hacking
#
CONFIG_PRINTK_TIME=y
CONFIG_DEFAULT_MESSAGE_LOGLEVEL=4
CONFIG_ENABLE_WARN_DEPRECATED=y
CONFIG_ENABLE_MUST_CHECK=y
CONFIG_FRAME_WARN=1024
CONFIG_MAGIC_SYSRQ=y
# CONFIG_STRIP_ASM_SYMS is not set
# CONFIG_UNUSED_SYMBOLS is not set
# CONFIG_DEBUG_FS is not set
# CONFIG_HEADERS_CHECK is not set
# CONFIG_DEBUG_SECTION_MISMATCH is not set
CONFIG_DEBUG_KERNEL=y
# CONFIG_DEBUG_SHIRQ is not set
# CONFIG_LOCKUP_DETECTOR is not set
# CONFIG_HARDLOCKUP_DETECTOR is not set
# CONFIG_DETECT_HUNG_TASK is not set
# CONFIG_SCHED_DEBUG is not set
# CONFIG_SCHEDSTATS is not set
# CONFIG_TIMER_STATS is not set
# CONFIG_DEBUG_OBJECTS is not set
# CONFIG_SLUB_DEBUG_ON is not set
# CONFIG_SLUB_STATS is not set
# CONFIG_DEBUG_KMEMLEAK is not set
# CONFIG_DEBUG_PREEMPT is not set
# CONFIG_DEBUG_RT_MUTEXES is not set
# CONFIG_RT_MUTEX_TESTER is not set
# CONFIG_DEBUG_SPINLOCK is not set
# CONFIG_DEBUG_MUTEXES is not set
# CONFIG_DEBUG_LOCK_ALLOC is not set
# CONFIG_PROVE_LOCKING is not set
# CONFIG_SPARSE_RCU_POINTER is not set
# CONFIG_LOCK_STAT is not set
# CONFIG_DEBUG_ATOMIC_SLEEP is not set
# CONFIG_DEBUG_LOCKING_API_SELFTESTS is not set
# CONFIG_DEBUG_STACK_USAGE is not set
# CONFIG_DEBUG_KOBJECT is not set
# CONFIG_DEBUG_HIGHMEM is not set
CONFIG_DEBUG_BUGVERBOSE=y
CONFIG_DEBUG_INFO=y
# CONFIG_DEBUG_INFO_REDUCED is not set
# CONFIG_DEBUG_VM is not set
# CONFIG_DEBUG_WRITECOUNT is not set
# CONFIG_DEBUG_MEMORY_INIT is not set
CONFIG_DEBUG_LIST=y
# CONFIG_TEST_LIST_SORT is not set
# CONFIG_DEBUG_SG is not set
# CONFIG_DEBUG_NOTIFIERS is not set
# CONFIG_DEBUG_CREDENTIALS is not set
# CONFIG_BOOT_PRINTK_DELAY is not set
# CONFIG_RCU_TORTURE_TEST is not set
CONFIG_RCU_TRACE=y
# CONFIG_BACKTRACE_SELF_TEST is not set
# CONFIG_DEBUG_FORCE_WEAK_PER_CPU is not set
# CONFIG_FAULT_INJECTION is not set
# CONFIG_LATENCYTOP is not set
# CONFIG_DEBUG_PAGEALLOC is not set
CONFIG_HAVE_FUNCTION_TRACER=y
CONFIG_HAVE_FUNCTION_GRAPH_TRACER=y
CONFIG_HAVE_DYNAMIC_FTRACE=y
CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
CONFIG_HAVE_C_RECORDMCOUNT=y
CONFIG_TRACING_SUPPORT=y
# CONFIG_FTRACE is not set
# CONFIG_DMA_API_DEBUG is not set
# CONFIG_ATOMIC64_SELFTEST is not set
# CONFIG_SAMPLES is not set
CONFIG_HAVE_ARCH_KGDB=y
# CONFIG_KGDB is not set
# CONFIG_TEST_KSTRTOX is not set
# CONFIG_STRICT_DEVMEM is not set
CONFIG_ARM_UNWIND=y
CONFIG_DEBUG_USER=y
CONFIG_DEBUG_LL=y
CONFIG_DEBUG_LL_UART_NONE=y
# CONFIG_DEBUG_ICEDCC is not set
# CONFIG_DEBUG_SEMIHOSTING is not set
CONFIG_EARLY_PRINTK=y
# CONFIG_OC_ETM is not set
#
# Security options
#
CONFIG_KEYS=y
# CONFIG_ENCRYPTED_KEYS is not set
# CONFIG_KEYS_DEBUG_PROC_KEYS is not set
# CONFIG_SECURITY_DMESG_RESTRICT is not set
# CONFIG_SECURITY is not set
# CONFIG_SECURITYFS is not set
CONFIG_DEFAULT_SECURITY_DAC=y
CONFIG_DEFAULT_SECURITY=""
CONFIG_CRYPTO=y
#
# Crypto core or helper
#
CONFIG_CRYPTO_ALGAPI=y
CONFIG_CRYPTO_ALGAPI2=y
CONFIG_CRYPTO_AEAD2=y
CONFIG_CRYPTO_BLKCIPHER2=y
CONFIG_CRYPTO_HASH=y
CONFIG_CRYPTO_HASH2=y
CONFIG_CRYPTO_RNG2=y
CONFIG_CRYPTO_PCOMP2=y
CONFIG_CRYPTO_MANAGER=y
CONFIG_CRYPTO_MANAGER2=y
# CONFIG_CRYPTO_USER is not set
# CONFIG_CRYPTO_MANAGER_DISABLE_TESTS is not set
CONFIG_CRYPTO_GF128MUL=y
# CONFIG_CRYPTO_NULL is not set
CONFIG_CRYPTO_WORKQUEUE=y
# CONFIG_CRYPTO_CRYPTD is not set
# CONFIG_CRYPTO_AUTHENC is not set
# CONFIG_CRYPTO_TEST is not set
#
# Authenticated Encryption with Associated Data
#
# CONFIG_CRYPTO_CCM is not set
# CONFIG_CRYPTO_GCM is not set
# CONFIG_CRYPTO_SEQIV is not set
#
# Block modes
#
# CONFIG_CRYPTO_CBC is not set
# CONFIG_CRYPTO_CTR is not set
# CONFIG_CRYPTO_CTS is not set
# CONFIG_CRYPTO_ECB is not set
# CONFIG_CRYPTO_LRW is not set
# CONFIG_CRYPTO_PCBC is not set
# CONFIG_CRYPTO_XTS is not set
#
# Hash modes
#
# 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_GHASH is not set
# CONFIG_CRYPTO_MD4 is not set
# CONFIG_CRYPTO_MD5 is not set
# CONFIG_CRYPTO_MICHAEL_MIC is not set
# CONFIG_CRYPTO_RMD128 is not set
# CONFIG_CRYPTO_RMD160 is not set
# CONFIG_CRYPTO_RMD256 is not set
# CONFIG_CRYPTO_RMD320 is not set
CONFIG_CRYPTO_SHA1=y
# CONFIG_CRYPTO_SHA256 is not set
# CONFIG_CRYPTO_SHA512 is not set
# CONFIG_CRYPTO_TGR192 is not set
# CONFIG_CRYPTO_WP512 is not set
#
# Ciphers
#
CONFIG_CRYPTO_AES=y
# 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_SALSA20 is not set
# CONFIG_CRYPTO_SEED is not set
# CONFIG_CRYPTO_SERPENT is not set
# CONFIG_CRYPTO_TEA is not set
# CONFIG_CRYPTO_TWOFISH is not set
#
# Compression
#
CONFIG_CRYPTO_DEFLATE=y
# CONFIG_CRYPTO_ZLIB is not set
CONFIG_CRYPTO_LZO=y
#
# Random Number Generation
#
# CONFIG_CRYPTO_ANSI_CPRNG is not set
# CONFIG_CRYPTO_USER_API_HASH is not set
# CONFIG_CRYPTO_USER_API_SKCIPHER is not set
# CONFIG_CRYPTO_HW is not set
# CONFIG_BINARY_PRINTF is not set
#
# Library routines
#
CONFIG_BITREVERSE=y
CONFIG_GENERIC_PCI_IOMAP=y
CONFIG_GENERIC_IO=y
# CONFIG_CRC_CCITT is not set
CONFIG_CRC16=y
# CONFIG_CRC_T10DIF 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_CRC7 is not set
CONFIG_LIBCRC32C=y
# CONFIG_CRC8 is not set
CONFIG_ZLIB_INFLATE=y
CONFIG_ZLIB_DEFLATE=y
CONFIG_LZO_COMPRESS=y
CONFIG_LZO_DECOMPRESS=y
CONFIG_XZ_DEC=y
# CONFIG_XZ_DEC_X86 is not set
# CONFIG_XZ_DEC_POWERPC is not set
# CONFIG_XZ_DEC_IA64 is not set
# CONFIG_XZ_DEC_ARM is not set
# CONFIG_XZ_DEC_ARMTHUMB is not set
# CONFIG_XZ_DEC_SPARC is not set
# CONFIG_XZ_DEC_BCJ is not set
# 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_BCH=y
CONFIG_HAS_IOMEM=y
CONFIG_HAS_IOPORT=y
CONFIG_HAS_DMA=y
CONFIG_DQL=y
CONFIG_NLATTR=y
CONFIG_GENERIC_ATOMIC64=y
# CONFIG_AVERAGE is not set
# CONFIG_CORDIC is not set
Raw
proc_cpuinfo
Processor : ARM926EJ-S rev 4 (v5l)
BogoMIPS : 97.17
Features : swp half thumb fastmult vfp edsp java
CPU implementer : 0x41
CPU architecture: 5TEJ
CPU variant : 0x0
CPU part : 0x926
CPU revision : 4
Hardware : m-u-t 3250 board with the LPC3250 Microcontroller
Revision : 0000
Serial : 0000000000000000
Raw
proc_iomem
08000000-0801ffff : lpc-eth.0
31060000-31060fff : lpc-eth.0
40088000-4008801f : serial
40090000-4009001f : serial
80000000-83ffffff : System RAM
80008000-80318cb3 : Kernel code
80338000-80390df7 : Kernel data
Raw
proc_version
Linux version 3.4.113 (buildroot@buildroot) (gcc version 4.9.4 (Buildroot 2018.02.1) ) #1 PREEMPT Mon Apr 9 23:40:00 CEST 2018
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment