net/core/filter.c

138 	 * If the skb was allocated from pfmemalloc reserves, only
829 			 * load from stack only after write, so tracking
836 		/* Load from stack. */
1205  *	Remove a filter from a socket and release its resources.
1404  *	bpf_prog_create_from_user - create an unattached filter from user buffer
1411  * that it builds up its insns buffer from user space provided buffer.
1698 	   const void *, from, u32, len, u64, flags)
1713 	memcpy(ptr, from, len);
1734 int __bpf_skb_store_bytes(struct sk_buff *skb, u32 offset, const void *from,
1737 	return ____bpf_skb_store_bytes(skb, offset, from, len, flags);
1917 	   u64, from, u64, to, u64, flags)
1931 		if (unlikely(from != 0))
1937 		csum_replace2(ptr, from, to);
1940 		csum_replace4(ptr, from, to);
1961 	   u64, from, u64, to, u64, flags)
1982 		if (unlikely(from != 0))
1988 		inet_proto_csum_replace2(ptr, skb, from, to, is_pseudo);
1991 		inet_proto_csum_replace4(ptr, skb, from, to, is_pseudo);
2013 BPF_CALL_5(bpf_csum_diff, __be32 *, from, u32, from_size,
2033 		sp->diff[j] = ~from[i];
2056 	 * as emulating csum_sub() can be done from the eBPF program.
2160 		 * the skb is originated from ingress (i.e. a forwarded skb)
2640 	u8 *raw, *to, *from;
2697 		from = sg_virt(sge);
2701 		memcpy(to, from, len);
2766 	u8 *raw, *to, *from;
2814 		from = sg_virt(psge);
2817 			memcpy(raw, from, front);
2820 			from += front;
2823 			memcpy(to, from, back);
2964 	 * pop: region to pop from element, same as input 'pop' here will be
2994 				u8 *to, *from;
3004 				from = sg_virt(sge);
3006 				memcpy(to, from, a);
3007 				memcpy(to + a, from + a + pop, b);
3258 	 * to always start from here under eBPF.
3772 	 * uncloning and drop offloads from the skb by this.
4266  * called from NAPI without a separate rcu_read_lock(). The code below does not
4319 		/* The target device is different from the receiving device, so
4321 		 * Using XDP_REDIRECT gets the correct behaviour from XDP enabled
4322 		 * drivers to unmap the packet from their rx ring.
4763 	   const struct bpf_tunnel_key *, from, u32, size, u64, flags)
4782 			memcpy(compat, from, size);
4784 			from = (const struct bpf_tunnel_key *) compat;
4790 	if (unlikely((!(flags & BPF_F_TUNINFO_IPV6) && from->tunnel_label) ||
4791 		     from->tunnel_ext))
4812 	info->key.tun_id = cpu_to_be64(from->tunnel_id);
4813 	info->key.tos = from->tunnel_tos;
4814 	info->key.ttl = from->tunnel_ttl;
4818 		memcpy(&info->key.u.ipv6.dst, from->remote_ipv6,
4819 		       sizeof(from->remote_ipv6));
4820 		memcpy(&info->key.u.ipv6.src, from->local_ipv6,
4821 		       sizeof(from->local_ipv6));
4822 		info->key.label = cpu_to_be32(from->tunnel_label) &
4825 		info->key.u.ipv4.dst = cpu_to_be32(from->remote_ipv4);
4826 		info->key.u.ipv4.src = cpu_to_be32(from->local_ipv4);
4844 	   const u8 *, from, u32, size)
4856 	ip_tunnel_info_opts_set(info, from, size, present);
5770 		/* ipv6_bpf_stub cannot be NULL, since it's called from
6445 	   const void *, from, u32, len)
6472 	memcpy(skb->data + offset, from, len);
7617 	   const void *, from, u32, len, u64, flags)
7630 	new_op = from;
7676 	memcpy(opend, from, new_kind_len);
10125  * If offset OFF is provided, the load happens from that offset relative to
12079  * The helper can only be called from BPF contexts that have acquired the socket