Skip to contentSkip to conversation

mm: add copy_remote_vm_str

PATCH Superseded Jordan Rome 2 participants 4 messages Jan 24, 2025 – Jan 27, 2025

Subsystems (4)

v3 of 8 Superseded Latest is v8 →

lore
Share & tools
lore
#0 lore raw

PATCH v3 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         |  68 ++++++++++++++++++++++++++
 3 files changed, 190 insertions(+)
include/linux/mm.h +3 -0
index f02925447e59..f3a05b3eb2f2 100644
@@ -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 +68 -0

74 lines not on this page · raw message

--
2.43.5

#1 lore raw
Quoted 12 lines · Jordan Rome

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         |  68 ++++++++++++++++++++++++++
 3 files changed, 190 insertions(+)

[...]

mm/memory.c int access_process_vm(struct task_struct *tsk, unsigned long addr, · line 6772

Quoted 11 lines
mm/memory.c +11 -0
+               maddr = kmap_local_page(page);
+               retval = strscpy(buf, maddr + offset, bytes);
+               unmap_and_put_page(page, maddr);
+
+               if (retval > -1 && retval < bytes) {
+                       /* found the end of the string */
+                       buf += retval;
+                       goto out;
+               }
+
+               if (retval == -E2BIG) {

nit: strscpy() can't return any other error, so I'd structure result handling as:

if (retval < 0) {
/* that annoying last byte copy */
retval = bytes;
}

if (retval < bytes) {
    /* "we are done" handling */
}

/* common len, buf, addr adjustment logic stays here */

but also here's the question. If we get E2BIG, while bytes is exactly how many bytes we have left in the buffer, the last byte should be zero, no? So this should be cleanly handled, right? Or do we have a test for that and it works already?

mm/memory.c int access_process_vm(struct task_struct *tsk, unsigned long addr, · line 6784

Quoted 12 lines
mm/memory.c +12 -0
+                       retval = bytes;
+                       /*
+                        * Because strscpy always null terminates we need to
+                        * copy the last byte in the page if we are going to
+                        * load more pages
+                        */
+                       if (bytes < len) {
+                               end = bytes - 1;
+                               copy_from_user_page(vma,
+                                               page,
+                                               addr + end,
+                                               buf + end,

you don't need the end variable, just use bytes - 1 twice?

Quoted 22 lines
mm/memory.c +22 -0
+                                               maddr + (PAGE_SIZE - 1),
+                                               1);
+                       }
+               }
+
+               len -= retval;
+               buf += retval;
+               addr += retval;
+       }
+
+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

mm/memory.c int access_process_vm(struct task_struct *tsk, unsigned long addr, · line 6816

Quoted 10 lines
mm/memory.c +10 -0
+ * @buf:       destination buffer
+ * @len:       number of bytes to transfer
+ * @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).
+ * If the source string is shorter than @len then return the length of the
+ * source string. If the source string is longer than @len, return @len.
+ * On any error, return -EFAULT.

strncpy_from_user_nofault() doc says:

On success, returns the length of the string INCLUDING the trailing NUL

Is this the case with copy_remote_vm_str() as well? I.e., if the source string is 5 bytes + NUL, dst buf is 10. Will we get 5 or 6 returned? We should be very careful with all this +/- 1 business in corner cases, too easy to mess this up.

Quoted 19 lines

+ */

mm/memory.c +18 -0
+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)
+               return -EFAULT;
+
+       ret = __copy_remote_vm_str(mm, addr, buf, len, gup_flags);
+
+       mmput(mm);
+
+       return ret;
+}
+EXPORT_SYMBOL_GPL(copy_remote_vm_str);
+

[...]

#2 lore raw
Quoted 36 lines · Andrii Nakryiko
Quoted 12 lines · Jordan Rome

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         |  68 ++++++++++++++++++++++++++
 3 files changed, 190 insertions(+)

[...]

mm/memory.c int access_process_vm(struct task_struct *tsk, unsigned long addr, · line 6772

Quoted 11 lines
mm/memory.c +11 -0
+               maddr = kmap_local_page(page);
+               retval = strscpy(buf, maddr + offset, bytes);
+               unmap_and_put_page(page, maddr);
+
+               if (retval > -1 && retval < bytes) {
+                       /* found the end of the string */
+                       buf += retval;
+                       goto out;
+               }
+
+               if (retval == -E2BIG) {

nit: strscpy() can't return any other error, so I'd structure result handling as:

if (retval < 0) {
/* that annoying last byte copy */
retval = bytes;
}

Quoted 6 lines
if (retval < bytes) {
    /* "we are done" handling */
}

/* common len, buf, addr adjustment logic stays here */

Ack. Actually, I thought of a way to make this cleaner and correct.

Quoted 6 lines

but also here's the question. If we get E2BIG, while bytes is exactly how many bytes we have left in the buffer, the last byte should be zero, no? So this should be cleanly handled, right? Or do we have a test for that and it works already?

Ok, I found an inconsistency that gets handled in the BPF helper bpf_copy_from_user_task_str, which I'm going to fix in the next version of this patch.

Let me explain how this function is SUPPOSED to work
and enumerate some different test cases (a lot of which are in commit 3).

Note1: all of the target strings
are null terminated (if you try to copy a string that's not null terminated you may accidentally copy junk).

Note2: strscopy returns E2BIG if the len requested isn't as long as the string INCLUDING the nul terminator. So if you want to copy "test_data\0" you need to request 10 bytes not 9. And if you request 10 or anything greater it returns 9.

Note3: This function, as opposed to the bpf helper calling this function, returns the number copied NOT including the nul terminator.

So... the target string is "test_data".

Request 10 bytes, return 9.
Request 2 bytes, return 1.
Request 20 bytes, return 9.

Now, let's say this string falls across a page boundary where "_" is the last character in the page.

Request 10 bytes, which becomes a request
for 5 bytes for the first page. strscopy returns E2BIG and copies "test\0" into the buffer. We copy the last bytes of the page into the buffer, which is the "_", and then request 5 more bytes on the next page, copying "data\0" and strscopy returns 4. Return 9.

Now let's say the last "a" is the last character on the page. Request 10 bytes, which becomes a request
for 9 bytes. strscopy returns E2BIG and copies "test_dat\0" into the buffer. Once again we copy the last byte of the page into the buffer, which is "a"
and we request 1 more byte of the next page, which is the nul terminator. strscopy returns 0 and this function returns 9.

Again note, that this version of the code has a bug that is "handled" by the bpf helper and I'm going to fix.

Quoted 50 lines

mm/memory.c int access_process_vm(struct task_struct *tsk, unsigned long addr, · line 6784

Quoted 12 lines
mm/memory.c +12 -0
+                       retval = bytes;
+                       /*
+                        * Because strscpy always null terminates we need to
+                        * copy the last byte in the page if we are going to
+                        * load more pages
+                        */
+                       if (bytes < len) {
+                               end = bytes - 1;
+                               copy_from_user_page(vma,
+                                               page,
+                                               addr + end,
+                                               buf + end,

you don't need the end variable, just use bytes - 1 twice?

Quoted 22 lines
mm/memory.c +22 -0
+                                               maddr + (PAGE_SIZE - 1),
+                                               1);
+                       }
+               }
+
+               len -= retval;
+               buf += retval;
+               addr += retval;
+       }
+
+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

mm/memory.c int access_process_vm(struct task_struct *tsk, unsigned long addr, · line 6816

Quoted 10 lines
mm/memory.c +10 -0
+ * @buf:       destination buffer
+ * @len:       number of bytes to transfer
+ * @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).
+ * If the source string is shorter than @len then return the length of the
+ * source string. If the source string is longer than @len, return @len.
+ * On any error, return -EFAULT.

strncpy_from_user_nofault() doc says:

Quoted 7 lines

On success, returns the length of the string INCLUDING the trailing NUL

Is this the case with copy_remote_vm_str() as well? I.e., if the source string is 5 bytes + NUL, dst buf is 10. Will we get 5 or 6 returned? We should be very careful with all this +/- 1 business in corner cases, too easy to mess this up.

Explained above.

Quoted 21 lines
Quoted 19 lines

+ */

mm/memory.c +18 -0
+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)
+               return -EFAULT;
+
+       ret = __copy_remote_vm_str(mm, addr, buf, len, gup_flags);
+
+       mmput(mm);
+
+       return ret;
+}
+EXPORT_SYMBOL_GPL(copy_remote_vm_str);
+

[...]

#3 lore raw
Quoted 63 lines · Jordan Rome
Quoted 36 lines · Andrii Nakryiko
Quoted 12 lines · Jordan Rome

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         |  68 ++++++++++++++++++++++++++
 3 files changed, 190 insertions(+)

[...]

mm/memory.c int access_process_vm(struct task_struct *tsk, unsigned long addr, · line 6772

Quoted 11 lines
mm/memory.c +11 -0
+               maddr = kmap_local_page(page);
+               retval = strscpy(buf, maddr + offset, bytes);
+               unmap_and_put_page(page, maddr);
+
+               if (retval > -1 && retval < bytes) {
+                       /* found the end of the string */
+                       buf += retval;
+                       goto out;
+               }
+
+               if (retval == -E2BIG) {

nit: strscpy() can't return any other error, so I'd structure result handling as:

if (retval < 0) {
/* that annoying last byte copy */
retval = bytes;
}

Quoted 6 lines
if (retval < bytes) {
    /* "we are done" handling */
}

/* common len, buf, addr adjustment logic stays here */

Ack. Actually, I thought of a way to make this cleaner and correct.

Quoted 6 lines

but also here's the question. If we get E2BIG, while bytes is exactly how many bytes we have left in the buffer, the last byte should be zero, no? So this should be cleanly handled, right? Or do we have a test for that and it works already?

Ok, I found an inconsistency that gets handled in the BPF helper bpf_copy_from_user_task_str, which I'm going to fix in the next version of this patch.

Let me explain how this function is SUPPOSED to work
and enumerate some different test cases (a lot of which are in commit 3).

Quoted 8 lines

Note1: all of the target strings
are null terminated (if you try to copy a string that's not null terminated you may accidentally copy junk).

Note2: strscopy returns E2BIG if the len requested isn't as long as the string INCLUDING the nul terminator. So if you want to copy "test_data\0" you need to request 10 bytes not 9. And if you request 10 or anything greater it returns 9.

yeah, that's actually smart for strscpy() to have this protocol, it allows to read full string and know that it's full (if the string fits exactly into the dst buffer). But I think on the BPF side we have a convention to return the size *including* the NUL byte, so we get a bit of inefficiency. But oh well, I think consistency is better to be maintained.

Quoted 20 lines

Note3: This function, as opposed to the bpf helper calling this function, returns the number copied NOT including the nul terminator.

So... the target string is "test_data".

Request 10 bytes, return 9.
Request 2 bytes, return 1.
Request 20 bytes, return 9.

Now, let's say this string falls across a page boundary where "_" is the last character in the page.

Request 10 bytes, which becomes a request
for 5 bytes for the first page. strscopy returns E2BIG and copies "test\0" into the buffer. We copy the last bytes of the page into the buffer, which is the "_", and then request 5 more bytes on the next page, copying "data\0" and strscopy returns 4. Return 9.

Quoted 8 lines

Now let's say the last "a" is the last character on the page. Request 10 bytes, which becomes a request
for 9 bytes. strscopy returns E2BIG and copies "test_dat\0" into the buffer. Once again we copy the last byte of the page into the buffer, which is "a"
and we request 1 more byte of the next page, which is the nul terminator. strscopy returns 0 and this function returns 9.

so I was worried about the situation where the string is test_data|\0, like you describe (where | is denoting page boundary, NUL is right after the page end), and we request 9 bytes (not 10 like in your example). By manually copying that "a" (last byte of the page), we might not return zero terminated dst buf (that was my theory). Would be good to have a test proving otherwise.

But I'll go and read the latest version, maybe I'm overthinking this.

Quoted 16 lines

Again note, that this version of the code has a bug that is "handled" by the bpf helper and I'm going to fix.

Quoted 12 lines
Quoted 12 lines
mm/memory.c +12 -0
+                       retval = bytes;
+                       /*
+                        * Because strscpy always null terminates we need to
+                        * copy the last byte in the page if we are going to
+                        * load more pages
+                        */
+                       if (bytes < len) {
+                               end = bytes - 1;
+                               copy_from_user_page(vma,
+                                               page,
+                                               addr + end,
+                                               buf + end,

[...]