mm: add copy_remote_vm_str
Subsystems (6)
PATCH v7 1/3 mm: add copy_remote_vm_str
Similar to access_process_vm but specific to strings. Also chunks reads by page and utilizes strscpy for handling null termination.
--- include/linux/mm.h | 3 ++ mm/memory.c | 119 +++++++++++++++++++++++++++++++++++++++++++++ mm/nommu.c | 73 +++++++++++++++++++++++++++ 3 files changed, 195 insertions(+)
include/linux/mm.h +3 -0
@@ -2486,6 +2486,9 @@ extern int access_process_vm(struct task_struct *tsk, unsigned long addr,extern int access_remote_vm (struct mm_struct *mm,unsigned long addr,void *buf,int len,unsigned int gup_flags); +extern int copy_remote_vm_str (struct task_struct *tsk,unsigned long addr, +void *buf,int len,unsigned int gup_flags); + long get_user_pages_remote(struct mm_struct *mm, unsigned long start, unsigned long nr_pages, unsigned int gup_flags, struct page **pages,
mm/memory.c +119 -0
125 lines not on this page · raw message
mm/nommu.c +73 -0
79 lines not on this page · raw message
--
2.43.5
PATCH v7 2/3 bpf: Add bpf_copy_from_user_task_str kfunc
This new kfunc will be able to copy a string from another process's/task's address space. This is similar to bpf_copy_from_user_str but accepts a struct task_struct* argument.
--- kernel/bpf/helpers.c | 48 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 48 insertions(+)
kernel/bpf/helpers.c +48 -0
@@ -3082,6 +3082,53 @@ __bpf_kfunc void bpf_local_irq_restore(unsigned long *flags__irq_flag)local_irq_restore (*flags__irq_flag); } +/** +* bpf_copy_from_user_task_str() - Copy a string from an task's address space +* @dst: Destination address, in kernel space. This buffer must be +* at least @dst__sz bytes long. +* @dst__sz: Maximum number of bytes to copy, includes the trailing NUL. +* @unsafe_ptr__ign: Source address in the task's address space. +* @tsk: The task whose address space will be used +* @flags: The only supported flag is BPF_F_PAD_ZEROS +* +* Copies a NUL terminated string from a task's address space to @dst__sz +* buffer. If user string is too long this will still ensure zero termination +* in the @dst__sz buffer unless buffer size is 0. +* +* If BPF_F_PAD_ZEROS flag is set, memset the tail of @dst__sz to 0 on success +* and memset all of @dst__sz on failure. +* +* Return: The number of copied bytes on success including the NUL terminator. +* A negative error code on failure. +*/ +__bpf_kfunc int bpf_copy_from_user_task_str(void *dst, +u32 dst__sz, +const void __user *unsafe_ptr__ign, +struct task_struct *tsk, +u64 flags) +{ +int ret; + +if (unlikely (flags & ~BPF_F_PAD_ZEROS )) +return -EINVAL ; + +if (unlikely (!dst__sz)) +return 0 ; + + ret =copy_remote_vm_str (tsk, (unsigned long )unsafe_ptr__ign, dst, dst__sz,0 ); + +if (ret <0 ) { +if (flags &BPF_F_PAD_ZEROS ) +memset (dst,0 , dst__sz); +return ret; + } + +if (flags &BPF_F_PAD_ZEROS ) +memset (dst + ret,0 , dst__sz - ret); + +return ret +1 ; +} +__bpf_kfunc_end_defs ();BTF_KFUNCS_START (generic_btf_ids)
@@ -3174,6 +3221,7 @@ BTF_ID_FLAGS(func, bpf_iter_bits_new, KF_ITER_NEW) BTF_ID_FLAGS(func, bpf_iter_bits_next, KF_ITER_NEXT | KF_RET_NULL) BTF_ID_FLAGS(func, bpf_iter_bits_destroy, KF_ITER_DESTROY) BTF_ID_FLAGS(func, bpf_copy_from_user_str, KF_SLEEPABLE) +BTF_ID_FLAGS(func, bpf_copy_from_user_task_str, KF_SLEEPABLE) BTF_ID_FLAGS(func, bpf_get_kmem_cache) BTF_ID_FLAGS(func, bpf_iter_kmem_cache_new, KF_ITER_NEW | KF_SLEEPABLE)BTF_ID_FLAGS (func, bpf_iter_kmem_cache_next,KF_ITER_NEXT |KF_RET_NULL |KF_SLEEPABLE )
--
2.43.5
PATCH v7 3/3 selftests/bpf: Add tests for bpf_copy_from_user_task_str
In reply to Jordan RomeThis adds tests for both the happy path and the error path (with and without the BPF_F_PAD_ZEROS flag).
--- .../selftests/bpf/prog_tests/bpf_iter.c | 68 +++++++++++ .../selftests/bpf/prog_tests/read_vsyscall.c | 1 + .../selftests/bpf/progs/bpf_iter_tasks.c | 110 ++++++++++++++++++ .../selftests/bpf/progs/read_vsyscall.c | 11 +- 4 files changed, 188 insertions(+), 2 deletions(-)
tools/testing/selftests/bpf/prog_tests/bpf_iter.c +68 -0
@@ -323,19 +323,87 @@ static void test_task_pidfd(void)static void test_task_sleepable (void ) {struct bpf_iter_tasks *skel; +int pid, status, err, data_pipe[2 ], finish_pipe[2 ], c; +char *test_data =NULL ; +char *test_data_long =NULL ; +char *data[2 ]; + +if (!ASSERT_OK (pipe (data_pipe),"data_pipe" ) || + !ASSERT_OK (pipe (finish_pipe),"finish_pipe" )) +return ; skel =bpf_iter_tasks__open_and_load ();if (!ASSERT_OK_PTR (skel,"bpf_iter_tasks__open_and_load" ))return ; + pid =fork (); +if (!ASSERT_GE (pid,0 ,"fork" )) +return ; + +if (pid ==0 ) { +/* child */ +close (data_pipe[0 ]); +close (finish_pipe[1 ]); + + test_data =malloc (sizeof (char ) *10 ); +strncpy (test_data,"test_data" ,10 ); + test_data[9 ] ='\0' ; + + test_data_long =malloc (sizeof (char ) *5000 ); +for (int i =0 ; i <5000 ; ++i) { +if (i %2 ==0 ) + test_data_long[i] ='b' ; +else + test_data_long[i] ='a' ; + } + test_data_long[4999 ] ='\0' ; + + data[0 ] = test_data; + data[1 ] = test_data_long; + +write (data_pipe[1 ], &data,sizeof (data)); + +/* keep child alive until after the test */ + err =read (finish_pipe[0 ], &c,1 ); +if (err !=1 ) +exit (-1 ); + +close (data_pipe[1 ]); +close (finish_pipe[0 ]); +_exit (0 ); + } + +/* parent */ +close (data_pipe[1 ]); +close (finish_pipe[0 ]); + + err =read (data_pipe[0 ], &data,sizeof (data)); +ASSERT_EQ (err,sizeof (data),"read_check" ); + + skel->bss->user_ptr = data[0 ]; + skel->bss->user_ptr_long = data[1 ]; + skel->bss->pid = pid; +do_dummy_read (skel->progs.dump_task_sleepable);ASSERT_GT (skel->bss->num_expected_failure_copy_from_user_task,0 ,"num_expected_failure_copy_from_user_task" );ASSERT_GT (skel->bss->num_success_copy_from_user_task,0 ,"num_success_copy_from_user_task" ); +ASSERT_GT (skel->bss->num_expected_failure_copy_from_user_task_str,0 , +"num_expected_failure_copy_from_user_task_str" ); +ASSERT_GT (skel->bss->num_success_copy_from_user_task_str,0 , +"num_success_copy_from_user_task_str" );bpf_iter_tasks__destroy (skel); + +write (finish_pipe[1 ], &c,1 ); + err =waitpid (pid, &status,0 ); +ASSERT_EQ (err, pid,"waitpid" ); +ASSERT_EQ (status,0 ,"zero_child_exit" ); + +close (data_pipe[0 ]); +close (finish_pipe[1 ]); }static void test_task_stack (void )
tools/testing/selftests/bpf/prog_tests/read_vsyscall.c +1 -0
@@ -24,6 +24,7 @@ struct read_ret_desc { { .name = "copy_from_user", .ret = -EFAULT }, { .name = "copy_from_user_task", .ret = -EFAULT }, { .name = "copy_from_user_str", .ret = -EFAULT }, + { .name = "copy_from_user_task_str", .ret = -EFAULT }, };void test_read_vsyscall (void )
tools/testing/selftests/bpf/progs/bpf_iter_tasks.c +110 -0
137 lines not on this page · raw message
tools/testing/selftests/bpf/progs/read_vsyscall.c +9 -2
@@ -8,14 +8,16 @@int target_pid =0 ;void *user_ptr =0 ; -int read_ret[9 ]; +int read_ret[10 ]; char _license[] SEC("license") = "GPL";/* -* This is the only kfunc, the others are helpers +* These are the kfuncs, the others are helpers */ int bpf_copy_from_user_str(void *dst, u32, const void *, u64) __weak __ksym; +int bpf_copy_from_user_task_str(void *dst, u32, const void *, + struct task_struct *, u64) __weak __ksym; SEC("fentry/" SYS_PREFIX "sys_nanosleep")int do_probe_read (void *ctx)
@@ -47,6 +49,11 @@ int do_copy_from_user(void *ctx) read_ret[7 ] =bpf_copy_from_user_task (buf,sizeof (buf), user_ptr,bpf_get_current_task_btf (),0 ); read_ret[8 ] =bpf_copy_from_user_str ((char *)buf,sizeof (buf), user_ptr,0 ); + read_ret[9 ] =bpf_copy_from_user_task_str ((char *)buf, +sizeof (buf), + user_ptr, +bpf_get_current_task_btf (), +0 );return 0 ; }
--
2.43.5
Quoted 35 lines · Jordan Rome
Similar to
access_process_vmbut specific to strings. Also chunks reads by page and utilizesstrscpyfor handling null termination.Signed-off-by Jordan Rome <[email protected]>--- include/linux/mm.h | 3 ++ mm/memory.c | 119 +++++++++++++++++++++++++++++++++++++++++++++ mm/nommu.c | 73 +++++++++++++++++++++++++++ 3 files changed, 195 insertions(+)include/linux/mm.h +3
-0@@ -2486,6 +2486,9 @@ extern int access_process_vm(struct task_struct *tsk, unsigned long addr,extern int access_remote_vm (struct mm_struct *mm,unsigned long addr,void *buf,int len,unsigned int gup_flags); +extern int copy_remote_vm_str (struct task_struct *tsk,unsigned long addr, +void *buf,int len,unsigned int gup_flags); + long get_user_pages_remote(struct mm_struct *mm, unsigned long start, unsigned long nr_pages, unsigned int gup_flags, struct page **pages,mm/memory.c +1
-0@@ -6803,6 +6803,125 @@ int access_process_vm(struct task_struct *tsk, unsigned long addr, }EXPORT_SYMBOL_GPL (access_process_vm); +/*
mm/memory.c int access_process_vm(struct task_struct *tsk, unsigned long addr, · line 6816
Quoted 10 lines
mm/memory.c +10
-0+* Copy a string from another process's address space as given in mm. +* If there is any error return -EFAULT. +*/ +static int __copy_remote_vm_str (struct mm_struct *mm,unsigned long addr, +void *buf,int len,unsigned int gup_flags) +{ +void *old_buf = buf; +int err =0 ; + + *(char *)buf ='\0' ;
LGTM overall:
But note that all this unconditional buf access will be incorrect if len == 0. So either all of that has to be guarded with if (len), just dropped, or declared unsupported, depending on what mm folks think. BPF helper won't ever call with len == 0, so that's why my ack.
(And yes, it would be nice to hear from someone from the MM side at this point, thank you!).
Quoted 13 lines
mm/memory.c +13
-0+ +if (mmap_read_lock_killable (mm)) +return -EFAULT ; + +/* Untag the address before looking up the VMA */ + addr =untagged_addr_remote (mm, addr); + +/* Avoid triggering the temporary warning in __get_user_pages */ +if (!vma_lookup (mm, addr)) { + err = -EFAULT ; + goto out; + } +
[...]
Quoted 49 lines · Andrii Nakryiko
Quoted 35 lines · Jordan Rome
Similar to
access_process_vmbut specific to strings. Also chunks reads by page and utilizesstrscpyfor handling null termination.Signed-off-by Jordan Rome <[email protected]>--- include/linux/mm.h | 3 ++ mm/memory.c | 119 +++++++++++++++++++++++++++++++++++++++++++++ mm/nommu.c | 73 +++++++++++++++++++++++++++ 3 files changed, 195 insertions(+)include/linux/mm.h +3
-0@@ -2486,6 +2486,9 @@ extern int access_process_vm(struct task_struct *tsk, unsigned long addr,extern int access_remote_vm (struct mm_struct *mm,unsigned long addr,void *buf,int len,unsigned int gup_flags); +extern int copy_remote_vm_str (struct task_struct *tsk,unsigned long addr, +void *buf,int len,unsigned int gup_flags); + long get_user_pages_remote(struct mm_struct *mm, unsigned long start, unsigned long nr_pages, unsigned int gup_flags, struct page **pages,mm/memory.c +1
-0@@ -6803,6 +6803,125 @@ int access_process_vm(struct task_struct *tsk, unsigned long addr, }EXPORT_SYMBOL_GPL (access_process_vm); +/* mm/memory.c int access_process_vm(struct task_struct *tsk, unsigned long addr, · line 6816
Quoted 10 lines
mm/memory.c +10
-0+* Copy a string from another process's address space as given in mm. +* If there is any error return -EFAULT. +*/ +static int __copy_remote_vm_str (struct mm_struct *mm,unsigned long addr, +void *buf,int len,unsigned int gup_flags) +{ +void *old_buf = buf; +int err =0 ; + + *(char *)buf ='\0' ;LGTM overall:
Quoted 6 lines
Acked-by Andrii Nakryiko <[email protected]>But note that all this unconditional buf access will be incorrect if len == 0. So either all of that has to be guarded with
if (len), just dropped, or declared unsupported, depending on what mm folks think. BPF helper won't ever call with len == 0, so that's why my ack.
I think early return 0 on len == 0 should be fine.
Quoted 51 lines · Shakeel Butt
Quoted 49 lines · Andrii Nakryiko
Quoted 35 lines · Jordan Rome
Similar to
access_process_vmbut specific to strings. Also chunks reads by page and utilizesstrscpyfor handling null termination.Signed-off-by Jordan Rome <[email protected]>--- include/linux/mm.h | 3 ++ mm/memory.c | 119 +++++++++++++++++++++++++++++++++++++++++++++ mm/nommu.c | 73 +++++++++++++++++++++++++++ 3 files changed, 195 insertions(+)include/linux/mm.h +3
-0@@ -2486,6 +2486,9 @@ extern int access_process_vm(struct task_struct *tsk, unsigned long addr,extern int access_remote_vm (struct mm_struct *mm,unsigned long addr,void *buf,int len,unsigned int gup_flags); +extern int copy_remote_vm_str (struct task_struct *tsk,unsigned long addr, +void *buf,int len,unsigned int gup_flags); + long get_user_pages_remote(struct mm_struct *mm, unsigned long start, unsigned long nr_pages, unsigned int gup_flags, struct page **pages,mm/memory.c +1
-0@@ -6803,6 +6803,125 @@ int access_process_vm(struct task_struct *tsk, unsigned long addr, }EXPORT_SYMBOL_GPL (access_process_vm); +/* mm/memory.c int access_process_vm(struct task_struct *tsk, unsigned long addr, · line 6816
Quoted 10 lines
mm/memory.c +10
-0+* Copy a string from another process's address space as given in mm. +* If there is any error return -EFAULT. +*/ +static int __copy_remote_vm_str (struct mm_struct *mm,unsigned long addr, +void *buf,int len,unsigned int gup_flags) +{ +void *old_buf = buf; +int err =0 ; + + *(char *)buf ='\0' ;LGTM overall:
Quoted 8 lines
Quoted 6 lines
Acked-by Andrii Nakryiko <[email protected]>But note that all this unconditional buf access will be incorrect if len == 0. So either all of that has to be guarded with
if (len), just dropped, or declared unsupported, depending on what mm folks think. BPF helper won't ever call with len == 0, so that's why my ack.I think early return 0 on len == 0 should be fine.
Ack.
Quoted 5 lines · Jordan Rome
Similar to
access_process_vmbut specific to strings. Also chunks reads by page and utilizesstrscpyfor handling null termination.Signed-off-by Jordan Rome <[email protected]>
If you decide to send a newer version, my request would be to add some more text in the commit message particularly on the motivation. Otherwise this looks good to me.