mm: add copy_remote_vm_str
Subsystems (6)
PATCH v6 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 | 74 ++++++++++++++++++++++++++++ 3 files changed, 196 insertions(+)
include/linux/mm.h +3 -0
@@ -2485,6 +2485,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 +74 -0
80 lines not on this page · raw message
--
2.43.5
PATCH v6 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 v6 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 5 lines · Jordan Rome
Similar to
access_process_vmbut specific to strings. Also chunks reads by page and utilizesstrscpyfor handling null termination.
Quoted 7 lines
Signed-off-by Jordan Rome <[email protected]>--- include/linux/mm.h | 3 ++ mm/memory.c | 119 +++++++++++++++++++++++++++++++++++++++++++++ mm/nommu.c | 74 ++++++++++++++++++++++++++++ 3 files changed, 196 insertions(+)
The logic looks good, but I have a bunch of stylistic nits below. It would be nice for someone from mm side to take a look as well.
Quoted 21 lines
include/linux/mm.h +3
-0@@ -2485,6 +2485,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 +0
-0@@ -6714,6 +6714,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 6725
Quoted 10 lines
mm/memory.c +9
-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 ;
empty line between variables and statements
mm/memory.c int access_process_vm(struct task_struct *tsk, unsigned long addr, · line 6726
Quoted 1 line
mm/memory.c +1
-0+ ((char *)buf)[0 ] ='\0' ;
nit: this would be probably a bit more "canonical": *(char *)buf = '\0';
Quoted 32 lines
mm/memory.c +32
-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; + } + +while (len) { +int bytes, offset, retval; +void *maddr; +struct page *page; +struct vm_area_struct *vma =NULL ; + + page =get_user_page_vma_remote (mm, addr, gup_flags, &vma); + +if (IS_ERR (page)) { +/* +* Treat as a total failure for now until we decide how +* to handle the CONFIG_HAVE_IOREMAP_PROT case and +* stack expansion. +*/ + ((char *)buf)[0 ] ='\0' ; + err = -EFAULT ; + goto out; + } +
mm/memory.c int access_process_vm(struct task_struct *tsk, unsigned long addr, · line 6768
Quoted 10 lines
mm/memory.c +10
-0+ bytes = len; + offset = addr & (PAGE_SIZE -1 ); +if (bytes >PAGE_SIZE - offset) + bytes =PAGE_SIZE - offset; + + maddr =kmap_local_page (page); + retval =strscpy (buf, maddr + offset, bytes); + +if (retval <0 ) { + buf += (bytes -1 );
nit: unnecessary ()
another nit: you could have had addr += bytes - 1; here, to keep addr and buf adjustment code close
Quoted 13 lines
mm/memory.c +13
-0+/* +* Because strscpy always NUL terminates we need to +* copy the last byte in the page if we are going to +* load more pages +*/ +if (bytes != len) { + addr += (bytes -1 ); +copy_from_user_page (vma, page, addr, buf, + maddr + (PAGE_SIZE -1 ),1 ); + + buf +=1 ; + addr +=1 ; + }
mm/memory.c int access_process_vm(struct task_struct *tsk, unsigned long addr, · line 6791
Quoted 10 lines
mm/memory.c +10
-0+ len -= bytes; + } + +unmap_and_put_page (page, maddr); + +if (retval >=0 ) { +/* Found the end of the string */ + buf += retval; + goto out; + }
it's not incorrect, but it would be nice not to have to re-check retval twice. Why not this structure:
ret = strscpy(...)
if (retval >= 0) {
unmap_and_put_page(page, maddr);
buf += retval;
break;
}/* this is -E2BIG case */
buf += bytes - 1;
addr += bytes - 1;
if (bytes != len) { copy, buf += 1, addr += 1 }
unmap_and_put_page(page, maddr);
Note that you don't need goto, break is fine. And yes, I don't think duplicating unmap_and_put_page() is a problem.
Quoted 53 lines
mm/memory.c +44
-0+ } + +out: +mmap_read_unlock (mm); +if (err) +return err; + +return buf - old_buf; +} + +/** +* copy_remote_vm_str - copy a string from another process's address space. +* @tsk: the task of the target address space +* @addr: start address to read from +* @buf: destination buffer +* @len: number of bytes to copy +* @gup_flags: flags modifying lookup behaviour +* +* The caller must hold a reference on @mm. +* +* Return: number of bytes copied from @addr (source) to @buf (destination); +* not including the trailing NUL. Always guaranteed to leave NUL-terminated +* buffer. On any error, return -EFAULT. +*/ +int copy_remote_vm_str (struct task_struct *tsk,unsigned long addr, +void *buf,int len,unsigned int gup_flags) +{ +struct mm_struct *mm; +int ret; + + mm =get_task_mm (tsk); +if (!mm) { + ((char *)buf)[0 ] ='\0' ; +return -EFAULT ; + } + + ret =__copy_remote_vm_str (mm, addr, buf, len, gup_flags); + +mmput (mm); + +return ret; +} +EXPORT_SYMBOL_GPL (copy_remote_vm_str); +/* * Print the name of a VMA. */ mm/nommu.c +0
-0@@ -1701,6 +1701,80 @@ int access_process_vm(struct task_struct *tsk, unsigned long addr, void *buf, in }
mm/nommu.c int access_process_vm(struct task_struct *tsk, unsigned long addr, void *buf, in · line 1711
Quoted 10 lines
mm/nommu.c +8
-0EXPORT_SYMBOL_GPL (access_process_vm); +/* +* 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) +{ +uint64_t tmp;
s/uint64_t/unsigned long/
also tmp -> addr_end ?
mm/nommu.c int access_process_vm(struct task_struct *tsk, unsigned long addr, void *buf, in · line 1713
Quoted 2 lines
mm/nommu.c +2
-0+struct vm_area_struct *vma; +
nit: no empty line here, why?
Quoted 6 lines
mm/nommu.c +6
-0+int ret = -EFAULT ; + + ((char *)buf)[0 ] ='\0' ; + +if (mmap_read_lock_killable (mm)) +return ret;
mm/nommu.c int access_process_vm(struct task_struct *tsk, unsigned long addr, void *buf, in · line 1729
Quoted 10 lines
mm/nommu.c +10
-0+ +/* the access must start within one of the target process's mappings */ + vma =find_vma (mm, addr); +if (!vma) + goto out; + +if (check_add_overflow (addr, len, &tmp)) + goto out; +/* don't overrun this mapping */ +if (tmp >= vma->vm_end)
nit: strictly speaking only tmp > vma->vm_end needs special handling
Quoted 54 lines
mm/nommu.c +48
-1+ len = vma->vm_end - addr; + +/* only read mappings where it is permitted */ +if (vma->vm_flags &VM_MAYREAD ) { + ret =strscpy (buf, (char *)addr, len); +if (ret <0 ) + ret = len -1 ; + } + +out: +mmap_read_unlock (mm); +return ret; +} + +/** +* copy_remote_vm_str - copy a string from another process's address space. +* @tsk: the task of the target address space +* @addr: start address to read from +* @buf: destination buffer +* @len: number of bytes to copy +* @gup_flags: flags modifying lookup behaviour (unused) +* +* The caller must hold a reference on @mm. +* +* Return: number of bytes copied from @addr (source) to @buf (destination); +* not including the trailing NUL. Always guaranteed to leave NUL-terminated +* buffer. On any error, return -EFAULT. +*/ +int copy_remote_vm_str (struct task_struct *tsk,unsigned long addr, +void *buf,int len,unsigned int gup_flags) +{ +struct mm_struct *mm; +int ret; + + mm =get_task_mm (tsk); +if (!mm) { + ((char *)buf)[0 ] ='\0' ; +return -EFAULT ; + } + + ret =__copy_remote_vm_str (mm, addr, buf, len); + +mmput (mm); + +return ret; +} +EXPORT_SYMBOL_GPL (copy_remote_vm_str); +/** * nommu_shrink_inode_mappings - Shrink the shared mappings on an inode * @inode: The inode to check -- 2.43.5