Commit ff880798 authored by Alexei Starovoitov's avatar Alexei Starovoitov
Browse files

Merge branch 'bpf-introduce-file-dynptr' 

Mykyta Yatsenko says:

====================
bpf: Introduce file dynptr

From: Mykyta Yatsenko <yatsenko@meta.com>

This series adds a new dynptr kind, file dynptr, which enables BPF
programs to perform safe reads from files in a structured way.
Initial motivations include:
 * Parsing the executable’s ELF to locate thread-local variable symbols
 * Capturing stack traces when frame pointers are disabled

By leveraging the existing dynptr abstraction, we reuse the verifier’s
lifetime/size checks and keep the API consistent with existing dynptr
read helpers.

Technical details:
1. Reuses the existing freader library to read files a folio at a time.
2. bpf_dynptr_slice() and bpf_dynptr_read() always copy data from folios
into a program-provided buffer; zero-copy access is intentionally not
supported to keep it simple.
3. Reads may sleep if the requested folios are not in the page cache.
4. Few verifier changes required:
  * Support dynptr destruction in kfuncs
  * Add kfunc address substitution based on whether the program runs in
  a sleepable or non-sleepable context.

Testing:
The final patch adds a selftest that validates BPF program reads the
same data as userspace, page faults are enabled in sleepable context and
disabled in non-sleepable.

Changelog:
---
v4 -> v5
v4: https://lore.kernel.org/all/20251021200334.220542-1-mykyta.yatsenko5@gmail.com/
 * Inlined and removed kfunc_call_imm(), run overflow check for call_imm
 only if !bpf_jit_supports_far_kfunc_call().

v3 -> v4
v3: https://lore.kernel.org/bpf/20251020222538.932915-1-mykyta.yatsenko5@gmail.com/
 * Remove ringbuf usage from selftests
 * bpf_dynptr_set_null(ptr) when discarding file dynptr
 * call kfunc_call_imm() in specialize_kfunc() only, removed
 call from add_kfunc_call()

v2 -> v3
v2: https://lore.kernel.org/bpf/20251015161155.120148-1-mykyta.yatsenko5@gmail.com/
 * Add negative tests
 * Rewrote tests to use LSM for bpf_get_task_exe_file()
 * Move call_imm overflow check into kfunc_call_imm()

v1 -> v2
v1: https://lore.kernel.org/bpf/20251003160416.585080-1-mykyta.yatsenko5@gmail.com/
 * Remove ELF parsing selftest
 * Expanded u32 -> u64 refactoring, changes in include/uapi/linux/bpf.h
 * Removed freader.{c,h}, instead move freader definitions into
 buildid.h.
 * Small refactoring of the multiple folios reading algorithm
 * Directly return error after unmark_stack_slots_dynptr().
 * Make kfuncs receive trusted arguments.
 * Remove enum bpf_is_sleepable, use bool instead
 * Remove unnecessary sorting from specialize_kfunc()
 * Remove bool kfunc_in_sleepable_ctx; field from the struct
 bpf_insn_aux_data, rely on non_sleepable field introduced by Kumar
 * Refactor selftests, do madvise(...MADV_PAGEOUT) for all pages read by
 the test
 * Introduce the test for non-sleepable case, verify it fails with -EFAULT
====================

Link: https://lore.kernel.org/r/20251026203853.135105-1-mykyta.yatsenko5@gmail.com


Signed-off-by: default avatarAlexei Starovoitov <ast@kernel.org>
parents e7586577 784cdf93

MAINTAINERS

+1 −0
Original line number Diff line number Diff line
@@ -4648,6 +4648,7 @@ F: Documentation/userspace-api/ebpf/ 
F:	arch/*/net/*

F:	include/linux/bpf*

F:	include/linux/btf*

F:	include/linux/buildid.h

F:	include/linux/filter.h

F:	include/trace/events/xdp.h

F:	include/uapi/linux/bpf*

include/linux/bpf.h

+19 −11
Original line number Diff line number Diff line
@@ -670,6 +670,9 @@ static inline bool bpf_map_has_internal_structs(struct bpf_map *map) 


void bpf_map_free_internal_structs(struct bpf_map *map, void *obj);



int bpf_dynptr_from_file_sleepable(struct file *file, u32 flags,

				   struct bpf_dynptr *ptr__uninit);



extern const struct bpf_map_ops bpf_map_offload_ops;



/* bpf_type_flag contains a set of flags that are applicable to the values of
@@ -792,12 +795,15 @@ enum bpf_type_flag { 
	/* DYNPTR points to skb_metadata_end()-skb_metadata_len() */

	DYNPTR_TYPE_SKB_META	= BIT(19 + BPF_BASE_TYPE_BITS),



	/* DYNPTR points to file */

	DYNPTR_TYPE_FILE	= BIT(20 + BPF_BASE_TYPE_BITS),



	__BPF_TYPE_FLAG_MAX,

	__BPF_TYPE_LAST_FLAG	= __BPF_TYPE_FLAG_MAX - 1,

};



#define DYNPTR_TYPE_FLAG_MASK	(DYNPTR_TYPE_LOCAL | DYNPTR_TYPE_RINGBUF | DYNPTR_TYPE_SKB \

				 | DYNPTR_TYPE_XDP | DYNPTR_TYPE_SKB_META)

				 | DYNPTR_TYPE_XDP | DYNPTR_TYPE_SKB_META | DYNPTR_TYPE_FILE)



/* Max number of base types. */

#define BPF_BASE_TYPE_LIMIT	(1UL << BPF_BASE_TYPE_BITS)
@@ -1385,21 +1391,23 @@ enum bpf_dynptr_type { 
	BPF_DYNPTR_TYPE_XDP,

	/* Points to skb_metadata_end()-skb_metadata_len() */

	BPF_DYNPTR_TYPE_SKB_META,

	/* Underlying data is a file */

	BPF_DYNPTR_TYPE_FILE,

};



int bpf_dynptr_check_size(u32 size);

u32 __bpf_dynptr_size(const struct bpf_dynptr_kern *ptr);

const void *__bpf_dynptr_data(const struct bpf_dynptr_kern *ptr, u32 len);

void *__bpf_dynptr_data_rw(const struct bpf_dynptr_kern *ptr, u32 len);

int bpf_dynptr_check_size(u64 size);

u64 __bpf_dynptr_size(const struct bpf_dynptr_kern *ptr);

const void *__bpf_dynptr_data(const struct bpf_dynptr_kern *ptr, u64 len);

void *__bpf_dynptr_data_rw(const struct bpf_dynptr_kern *ptr, u64 len);

bool __bpf_dynptr_is_rdonly(const struct bpf_dynptr_kern *ptr);

int __bpf_dynptr_write(const struct bpf_dynptr_kern *dst, u32 offset,

		       void *src, u32 len, u64 flags);

void *bpf_dynptr_slice_rdwr(const struct bpf_dynptr *p, u32 offset,

			    void *buffer__opt, u32 buffer__szk);

int __bpf_dynptr_write(const struct bpf_dynptr_kern *dst, u64 offset,

		       void *src, u64 len, u64 flags);

void *bpf_dynptr_slice_rdwr(const struct bpf_dynptr *p, u64 offset,

			    void *buffer__opt, u64 buffer__szk);



static inline int bpf_dynptr_check_off_len(const struct bpf_dynptr_kern *ptr, u32 offset, u32 len)

static inline int bpf_dynptr_check_off_len(const struct bpf_dynptr_kern *ptr, u64 offset, u64 len)

{

	u32 size = __bpf_dynptr_size(ptr);

	u64 size = __bpf_dynptr_size(ptr);



	if (len > size || offset > size - len)

		return -E2BIG;

include/linux/buildid.h

+25 −0
Original line number Diff line number Diff line
@@ -18,4 +18,29 @@ void init_vmlinux_build_id(void); 
static inline void init_vmlinux_build_id(void) { }

#endif



struct freader {

	void *buf;

	u32 buf_sz;

	int err;

	union {

		struct {

			struct file *file;

			struct folio *folio;

			void *addr;

			loff_t folio_off;

			bool may_fault;

		};

		struct {

			const char *data;

			u64 data_sz;

		};

	};

};



void freader_init_from_file(struct freader *r, void *buf, u32 buf_sz,

			    struct file *file, bool may_fault);

void freader_init_from_mem(struct freader *r, const char *data, u64 data_sz);

const void *freader_fetch(struct freader *r, loff_t file_off, size_t sz);

void freader_cleanup(struct freader *r);



#endif

include/uapi/linux/bpf.h

+4 −4
Original line number Diff line number Diff line
@@ -5618,7 +5618,7 @@ union bpf_attr { 
 *	Return

 *		*sk* if casting is valid, or **NULL** otherwise.

 *

 * long bpf_dynptr_from_mem(void *data, u32 size, u64 flags, struct bpf_dynptr *ptr)

 * long bpf_dynptr_from_mem(void *data, u64 size, u64 flags, struct bpf_dynptr *ptr)

 *	Description

 *		Get a dynptr to local memory *data*.

 *
@@ -5661,7 +5661,7 @@ union bpf_attr { 
 *	Return

 *		Nothing. Always succeeds.

 *

 * long bpf_dynptr_read(void *dst, u32 len, const struct bpf_dynptr *src, u32 offset, u64 flags)

 * long bpf_dynptr_read(void *dst, u64 len, const struct bpf_dynptr *src, u64 offset, u64 flags)

 *	Description

 *		Read *len* bytes from *src* into *dst*, starting from *offset*

 *		into *src*.
@@ -5671,7 +5671,7 @@ union bpf_attr { 
 *		of *src*'s data, -EINVAL if *src* is an invalid dynptr or if

 *		*flags* is not 0.

 *

 * long bpf_dynptr_write(const struct bpf_dynptr *dst, u32 offset, void *src, u32 len, u64 flags)

 * long bpf_dynptr_write(const struct bpf_dynptr *dst, u64 offset, void *src, u64 len, u64 flags)

 *	Description

 *		Write *len* bytes from *src* into *dst*, starting from *offset*

 *		into *dst*.
@@ -5692,7 +5692,7 @@ union bpf_attr { 
 *		is a read-only dynptr or if *flags* is not correct. For skb-type dynptrs,

 *		other errors correspond to errors returned by **bpf_skb_store_bytes**\ ().

 *

 * void *bpf_dynptr_data(const struct bpf_dynptr *ptr, u32 offset, u32 len)

 * void *bpf_dynptr_data(const struct bpf_dynptr *ptr, u64 offset, u64 len)

 *	Description

 *		Get a pointer to the underlying dynptr data.

 *

kernel/bpf/helpers.c

+139 −34
Original line number Diff line number Diff line
@@ -28,6 +28,7 @@ 
#include <linux/verification.h>

#include <linux/task_work.h>

#include <linux/irq_work.h>

#include <linux/buildid.h>



#include "../../lib/kstrtox.h"
@@ -1656,6 +1657,13 @@ static const struct bpf_func_proto bpf_kptr_xchg_proto = { 
	.arg2_btf_id  = BPF_PTR_POISON,

};



struct bpf_dynptr_file_impl {

	struct freader freader;

	/* 64 bit offset and size overriding 32 bit ones in bpf_dynptr_kern */

	u64 offset;

	u64 size;

};



/* Since the upper 8 bits of dynptr->size is reserved, the

 * maximum supported size is 2^24 - 1.

 */
@@ -1684,23 +1692,65 @@ static enum bpf_dynptr_type bpf_dynptr_get_type(const struct bpf_dynptr_kern *pt 
	return (ptr->size & ~(DYNPTR_RDONLY_BIT)) >> DYNPTR_TYPE_SHIFT;

}



u32 __bpf_dynptr_size(const struct bpf_dynptr_kern *ptr)

u64 __bpf_dynptr_size(const struct bpf_dynptr_kern *ptr)

{

	if (bpf_dynptr_get_type(ptr) == BPF_DYNPTR_TYPE_FILE) {

		struct bpf_dynptr_file_impl *df = ptr->data;



		return df->size;

	}



	return ptr->size & DYNPTR_SIZE_MASK;

}



static void bpf_dynptr_set_size(struct bpf_dynptr_kern *ptr, u32 new_size)

static void bpf_dynptr_advance_offset(struct bpf_dynptr_kern *ptr, u64 off)

{

	if (bpf_dynptr_get_type(ptr) == BPF_DYNPTR_TYPE_FILE) {

		struct bpf_dynptr_file_impl *df = ptr->data;



		df->offset += off;

		return;

	}

	ptr->offset += off;

}



static void bpf_dynptr_set_size(struct bpf_dynptr_kern *ptr, u64 new_size)

{

	u32 metadata = ptr->size & ~DYNPTR_SIZE_MASK;



	ptr->size = new_size | metadata;

	if (bpf_dynptr_get_type(ptr) == BPF_DYNPTR_TYPE_FILE) {

		struct bpf_dynptr_file_impl *df = ptr->data;



		df->size = new_size;

		return;

	}

	ptr->size = (u32)new_size | metadata;

}



int bpf_dynptr_check_size(u32 size)

int bpf_dynptr_check_size(u64 size)

{

	return size > DYNPTR_MAX_SIZE ? -E2BIG : 0;

}



static int bpf_file_fetch_bytes(struct bpf_dynptr_file_impl *df, u64 offset, void *buf, u64 len)

{

	const void *ptr;



	if (!buf)

		return -EINVAL;



	df->freader.buf = buf;

	df->freader.buf_sz = len;

	ptr = freader_fetch(&df->freader, offset + df->offset, len);

	if (!ptr)

		return df->freader.err;



	if (ptr != buf) /* Force copying into the buffer */

		memcpy(buf, ptr, len);



	return 0;

}



void bpf_dynptr_init(struct bpf_dynptr_kern *ptr, void *data,

		     enum bpf_dynptr_type type, u32 offset, u32 size)

{
@@ -1715,7 +1765,7 @@ void bpf_dynptr_set_null(struct bpf_dynptr_kern *ptr) 
	memset(ptr, 0, sizeof(*ptr));

}



BPF_CALL_4(bpf_dynptr_from_mem, void *, data, u32, size, u64, flags, struct bpf_dynptr_kern *, ptr)

BPF_CALL_4(bpf_dynptr_from_mem, void *, data, u64, size, u64, flags, struct bpf_dynptr_kern *, ptr)

{

	int err;
@@ -1750,8 +1800,8 @@ static const struct bpf_func_proto bpf_dynptr_from_mem_proto = { 
	.arg4_type	= ARG_PTR_TO_DYNPTR | DYNPTR_TYPE_LOCAL | MEM_UNINIT | MEM_WRITE,

};



static int __bpf_dynptr_read(void *dst, u32 len, const struct bpf_dynptr_kern *src,

			     u32 offset, u64 flags)

static int __bpf_dynptr_read(void *dst, u64 len, const struct bpf_dynptr_kern *src,

			     u64 offset, u64 flags)

{

	enum bpf_dynptr_type type;

	int err;
@@ -1781,14 +1831,16 @@ static int __bpf_dynptr_read(void *dst, u32 len, const struct bpf_dynptr_kern *s 
	case BPF_DYNPTR_TYPE_SKB_META:

		memmove(dst, bpf_skb_meta_pointer(src->data, src->offset + offset), len);

		return 0;

	case BPF_DYNPTR_TYPE_FILE:

		return bpf_file_fetch_bytes(src->data, offset, dst, len);

	default:

		WARN_ONCE(true, "bpf_dynptr_read: unknown dynptr type %d\n", type);

		return -EFAULT;

	}

}



BPF_CALL_5(bpf_dynptr_read, void *, dst, u32, len, const struct bpf_dynptr_kern *, src,

	   u32, offset, u64, flags)

BPF_CALL_5(bpf_dynptr_read, void *, dst, u64, len, const struct bpf_dynptr_kern *, src,

	   u64, offset, u64, flags)

{

	return __bpf_dynptr_read(dst, len, src, offset, flags);

}
@@ -1804,8 +1856,8 @@ static const struct bpf_func_proto bpf_dynptr_read_proto = { 
	.arg5_type	= ARG_ANYTHING,

};



int __bpf_dynptr_write(const struct bpf_dynptr_kern *dst, u32 offset, void *src,

		       u32 len, u64 flags)

int __bpf_dynptr_write(const struct bpf_dynptr_kern *dst, u64 offset, void *src,

		       u64 len, u64 flags)

{

	enum bpf_dynptr_type type;

	int err;
@@ -1848,8 +1900,8 @@ int __bpf_dynptr_write(const struct bpf_dynptr_kern *dst, u32 offset, void *src, 
	}

}



BPF_CALL_5(bpf_dynptr_write, const struct bpf_dynptr_kern *, dst, u32, offset, void *, src,

	   u32, len, u64, flags)

BPF_CALL_5(bpf_dynptr_write, const struct bpf_dynptr_kern *, dst, u64, offset, void *, src,

	   u64, len, u64, flags)

{

	return __bpf_dynptr_write(dst, offset, src, len, flags);

}
@@ -1865,7 +1917,7 @@ static const struct bpf_func_proto bpf_dynptr_write_proto = { 
	.arg5_type	= ARG_ANYTHING,

};



BPF_CALL_3(bpf_dynptr_data, const struct bpf_dynptr_kern *, ptr, u32, offset, u32, len)

BPF_CALL_3(bpf_dynptr_data, const struct bpf_dynptr_kern *, ptr, u64, offset, u64, len)

{

	enum bpf_dynptr_type type;

	int err;
@@ -2680,12 +2732,12 @@ __bpf_kfunc struct task_struct *bpf_task_from_vpid(s32 vpid) 
 * provided buffer, with its contents containing the data, if unable to obtain

 * direct pointer)

 */

__bpf_kfunc void *bpf_dynptr_slice(const struct bpf_dynptr *p, u32 offset,

				   void *buffer__opt, u32 buffer__szk)

__bpf_kfunc void *bpf_dynptr_slice(const struct bpf_dynptr *p, u64 offset,

				   void *buffer__opt, u64 buffer__szk)

{

	const struct bpf_dynptr_kern *ptr = (struct bpf_dynptr_kern *)p;

	enum bpf_dynptr_type type;

	u32 len = buffer__szk;

	u64 len = buffer__szk;

	int err;



	if (!ptr->data)
@@ -2719,6 +2771,9 @@ __bpf_kfunc void *bpf_dynptr_slice(const struct bpf_dynptr *p, u32 offset, 
	}

	case BPF_DYNPTR_TYPE_SKB_META:

		return bpf_skb_meta_pointer(ptr->data, ptr->offset + offset);

	case BPF_DYNPTR_TYPE_FILE:

		err = bpf_file_fetch_bytes(ptr->data, offset, buffer__opt, buffer__szk);

		return err ? NULL : buffer__opt;

	default:

		WARN_ONCE(true, "unknown dynptr type %d\n", type);

		return NULL;
@@ -2767,8 +2822,8 @@ __bpf_kfunc void *bpf_dynptr_slice(const struct bpf_dynptr *p, u32 offset, 
 * provided buffer, with its contents containing the data, if unable to obtain

 * direct pointer)

 */

__bpf_kfunc void *bpf_dynptr_slice_rdwr(const struct bpf_dynptr *p, u32 offset,

					void *buffer__opt, u32 buffer__szk)

__bpf_kfunc void *bpf_dynptr_slice_rdwr(const struct bpf_dynptr *p, u64 offset,

					void *buffer__opt, u64 buffer__szk)

{

	const struct bpf_dynptr_kern *ptr = (struct bpf_dynptr_kern *)p;
@@ -2800,10 +2855,10 @@ __bpf_kfunc void *bpf_dynptr_slice_rdwr(const struct bpf_dynptr *p, u32 offset, 
	return bpf_dynptr_slice(p, offset, buffer__opt, buffer__szk);

}



__bpf_kfunc int bpf_dynptr_adjust(const struct bpf_dynptr *p, u32 start, u32 end)

__bpf_kfunc int bpf_dynptr_adjust(const struct bpf_dynptr *p, u64 start, u64 end)

{

	struct bpf_dynptr_kern *ptr = (struct bpf_dynptr_kern *)p;

	u32 size;

	u64 size;



	if (!ptr->data || start > end)

		return -EINVAL;
@@ -2813,7 +2868,7 @@ __bpf_kfunc int bpf_dynptr_adjust(const struct bpf_dynptr *p, u32 start, u32 end 
	if (start > size || end > size)

		return -ERANGE;



	ptr->offset += start;

	bpf_dynptr_advance_offset(ptr, start);

	bpf_dynptr_set_size(ptr, end - start);



	return 0;
@@ -2836,7 +2891,7 @@ __bpf_kfunc bool bpf_dynptr_is_rdonly(const struct bpf_dynptr *p) 
	return __bpf_dynptr_is_rdonly(ptr);

}



__bpf_kfunc __u32 bpf_dynptr_size(const struct bpf_dynptr *p)

__bpf_kfunc u64 bpf_dynptr_size(const struct bpf_dynptr *p)

{

	struct bpf_dynptr_kern *ptr = (struct bpf_dynptr_kern *)p;
@@ -2873,14 +2928,14 @@ __bpf_kfunc int bpf_dynptr_clone(const struct bpf_dynptr *p, 
 * Copies data from source dynptr to destination dynptr.

 * Returns 0 on success; negative error, otherwise.

 */

__bpf_kfunc int bpf_dynptr_copy(struct bpf_dynptr *dst_ptr, u32 dst_off,

				struct bpf_dynptr *src_ptr, u32 src_off, u32 size)

__bpf_kfunc int bpf_dynptr_copy(struct bpf_dynptr *dst_ptr, u64 dst_off,

				struct bpf_dynptr *src_ptr, u64 src_off, u64 size)

{

	struct bpf_dynptr_kern *dst = (struct bpf_dynptr_kern *)dst_ptr;

	struct bpf_dynptr_kern *src = (struct bpf_dynptr_kern *)src_ptr;

	void *src_slice, *dst_slice;

	char buf[256];

	u32 off;

	u64 off;



	src_slice = bpf_dynptr_slice(src_ptr, src_off, NULL, size);

	dst_slice = bpf_dynptr_slice_rdwr(dst_ptr, dst_off, NULL, size);
@@ -2902,7 +2957,7 @@ __bpf_kfunc int bpf_dynptr_copy(struct bpf_dynptr *dst_ptr, u32 dst_off, 


	off = 0;

	while (off < size) {

		u32 chunk_sz = min_t(u32, sizeof(buf), size - off);

		u64 chunk_sz = min_t(u64, sizeof(buf), size - off);

		int err;



		err = __bpf_dynptr_read(buf, chunk_sz, src, src_off + off, 0);
@@ -2928,10 +2983,10 @@ __bpf_kfunc int bpf_dynptr_copy(struct bpf_dynptr *dst_ptr, u32 dst_off, 
 * at @offset with the constant byte @val.

 * Returns 0 on success; negative error, otherwise.

 */

 __bpf_kfunc int bpf_dynptr_memset(struct bpf_dynptr *p, u32 offset, u32 size, u8 val)

__bpf_kfunc int bpf_dynptr_memset(struct bpf_dynptr *p, u64 offset, u64 size, u8 val)

{

	struct bpf_dynptr_kern *ptr = (struct bpf_dynptr_kern *)p;

	u32 chunk_sz, write_off;

	u64 chunk_sz, write_off;

	char buf[256];

	void* slice;

	int err;
@@ -2950,11 +3005,11 @@ __bpf_kfunc int bpf_dynptr_copy(struct bpf_dynptr *dst_ptr, u32 dst_off, 
		return err;



	/* Non-linear data under the dynptr, write from a local buffer */

	chunk_sz = min_t(u32, sizeof(buf), size);

	chunk_sz = min_t(u64, sizeof(buf), size);

	memset(buf, val, chunk_sz);



	for (write_off = 0; write_off < size; write_off += chunk_sz) {

		chunk_sz = min_t(u32, sizeof(buf), size - write_off);

		chunk_sz = min_t(u64, sizeof(buf), size - write_off);

		err = __bpf_dynptr_write(ptr, offset + write_off, buf, chunk_sz, 0);

		if (err)

			return err;
@@ -4252,6 +4307,54 @@ __bpf_kfunc int bpf_task_work_schedule_resume(struct task_struct *task, struct b 
	return bpf_task_work_schedule(task, tw, map__map, callback, aux__prog, TWA_RESUME);

}



static int make_file_dynptr(struct file *file, u32 flags, bool may_sleep,

			    struct bpf_dynptr_kern *ptr)

{

	struct bpf_dynptr_file_impl *state;



	/* flags is currently unsupported */

	if (flags) {

		bpf_dynptr_set_null(ptr);

		return -EINVAL;

	}



	state = bpf_mem_alloc(&bpf_global_ma, sizeof(struct bpf_dynptr_file_impl));

	if (!state) {

		bpf_dynptr_set_null(ptr);

		return -ENOMEM;

	}

	state->offset = 0;

	state->size = U64_MAX; /* Don't restrict size, as file may change anyways */

	freader_init_from_file(&state->freader, NULL, 0, file, may_sleep);

	bpf_dynptr_init(ptr, state, BPF_DYNPTR_TYPE_FILE, 0, 0);

	bpf_dynptr_set_rdonly(ptr);

	return 0;

}



__bpf_kfunc int bpf_dynptr_from_file(struct file *file, u32 flags, struct bpf_dynptr *ptr__uninit)

{

	return make_file_dynptr(file, flags, false, (struct bpf_dynptr_kern *)ptr__uninit);

}



int bpf_dynptr_from_file_sleepable(struct file *file, u32 flags, struct bpf_dynptr *ptr__uninit)

{

	return make_file_dynptr(file, flags, true, (struct bpf_dynptr_kern *)ptr__uninit);

}



__bpf_kfunc int bpf_dynptr_file_discard(struct bpf_dynptr *dynptr)

{

	struct bpf_dynptr_kern *ptr = (struct bpf_dynptr_kern *)dynptr;

	struct bpf_dynptr_file_impl *df = ptr->data;



	if (!df)

		return 0;



	freader_cleanup(&df->freader);

	bpf_mem_free(&bpf_global_ma, df);

	bpf_dynptr_set_null(ptr);

	return 0;

}



__bpf_kfunc_end_defs();



static void bpf_task_work_cancel_scheduled(struct irq_work *irq_work)
@@ -4429,6 +4532,8 @@ BTF_ID_FLAGS(func, bpf_cgroup_read_xattr, KF_RCU) 
BTF_ID_FLAGS(func, bpf_stream_vprintk, KF_TRUSTED_ARGS)

BTF_ID_FLAGS(func, bpf_task_work_schedule_signal, KF_TRUSTED_ARGS)

BTF_ID_FLAGS(func, bpf_task_work_schedule_resume, KF_TRUSTED_ARGS)

BTF_ID_FLAGS(func, bpf_dynptr_from_file, KF_TRUSTED_ARGS)

BTF_ID_FLAGS(func, bpf_dynptr_file_discard)

BTF_KFUNCS_END(common_btf_ids)



static const struct btf_kfunc_id_set common_kfunc_set = {
@@ -4469,7 +4574,7 @@ late_initcall(kfunc_init); 
/* Get a pointer to dynptr data up to len bytes for read only access. If

 * the dynptr doesn't have continuous data up to len bytes, return NULL.

 */

const void *__bpf_dynptr_data(const struct bpf_dynptr_kern *ptr, u32 len)

const void *__bpf_dynptr_data(const struct bpf_dynptr_kern *ptr, u64 len)

{

	const struct bpf_dynptr *p = (struct bpf_dynptr *)ptr;
@@ -4480,7 +4585,7 @@ const void *__bpf_dynptr_data(const struct bpf_dynptr_kern *ptr, u32 len) 
 * the dynptr doesn't have continuous data up to len bytes, or the dynptr

 * is read only, return NULL.

 */

void *__bpf_dynptr_data_rw(const struct bpf_dynptr_kern *ptr, u32 len)

void *__bpf_dynptr_data_rw(const struct bpf_dynptr_kern *ptr, u64 len)

{

	if (__bpf_dynptr_is_rdonly(ptr))

		return NULL;