maps2-add-proc-pid-pagemap-interface.patch
Hi Matt,
Quoted 14 lines
(quoted diff) +14
-0+#ifdef CONFIG_PROC_PAGEMAP +struct pagemapread { + struct mm_struct *mm; + unsigned long next; + unsigned long *buf; + pte_t *ptebuf; + unsigned long pos; + size_t count; + int index; + char __user *out; +}; + +static int flush_pagemap(struct pagemapread *pm) +{
Review
Quoted 10 lines
(quoted diff) +10
-0+ int n = min(pm->count, pm->index * sizeof(unsigned long)); + if (copy_to_user(pm->out, pm->buf, n)) + return -EFAULT; + pm->out += n; + pm->pos += n; + pm->count -= n; + pm->index = 0; + cond_resched(); + return 0; +}
This is a lot of complexity to buffer output (and the naming is
horrible: s/pagemap/outbuf/ would help this code). put_user() is pretty
efficient: is this really necessary?
Oh, and cond_resched() is unnecessary: there's one in copy_to_user.
Review
Quoted 5 lines
(quoted diff) +5
-0+ ret = -EIO; + svpfn = src / sizeof(unsigned long) - 1; + addr = PAGE_SIZE * svpfn; + if ((svpfn + 1) * sizeof(unsigned long) != src) + goto out;
This looks like a very complicated way to test for "*ppos % sizeof(unsigned long) != 0".
You use ppos to count records rather than bytes, and save some arithmetic here but I guess that breaks your userspace.
Review
Quoted 2 lines
(quoted diff) +2
-0+ evpfn = min((src + count) / sizeof(unsigned long), + ((~0UL) >> PAGE_SHIFT) + 1);
Why?
The mixing of byte count and record count in this function makes it quite hard to understand.
Review
Quoted 10 lines
(quoted diff) +10
-0+ ret = -ENOMEM; + page = kzalloc(PAGE_SIZE, GFP_USER); + if (!page) + goto out; + +#ifdef CONFIG_HIGHPTE + pm.ptebuf = kzalloc(PAGE_SIZE, GFP_USER); + if (!pm.ptebuf) + goto out_free; +#endif
I'm not sure either of these needs to be kzalloc'ed. And the fact that your buffer is a page long is an arbitrary choice: it'd be better using a separate BUF_SIZE constant.
Oh, and while we're here, can someone clarify GFP_USER vs GFP_KERNEL?
Review
Quoted 7 lines
(quoted diff) +7
-0+ if (svpfn == -1) { + add_to_pagemap(pm.next, 0, &pm); + ((char *)page)[0] = (ntohl(1) != 1); + ((char *)page)[1] = PAGE_SHIFT; + ((char *)page)[2] = sizeof(unsigned long); + ((char *)page)[3] = sizeof(unsigned long); + }
I think it would simplify the code if you move this to the top of the function, and copy these directly to userspace and return a short read.
And how about "cpu_to_le16(1) == 1" instead of "ntohl(1) != 1"?
Review
Quoted 5 lines
(quoted diff) +5
-0+ while (pm.count > 0 && vma) { + if (!ptrace_may_attach(task)) { + ret = -EIO; + goto out_mm; + }
You already checked ptrace_may_attach() earlier in this function; do you need to do that again?
Review
Quoted 12 lines
(quoted diff) +12
-0+ vend = min(vma->vm_start - 1, end - 1) + 1; + ret = pagemap_fill(&pm, vend); + if (ret || !pm.count) + break; + vend = min(vma->vm_end - 1, end - 1) + 1; + ret = walk_page_range(mm, vma->vm_start, vend, + &pagemap_walk, &pm); + vma = vma->vm_next; + } + up_read(&mm->mmap_sem); + + ret = pagemap_fill(&pm, end);
If the first pagemap_fill() fails, you still try again outside the loop). That's a minor nit: the second call should fail the same. But assigning the return value from walk_page_range() and then ignoring it?
This function keeps variables containing the beginning ("src") in bytes (in both a local var and inside the struct pagemapread), the count in bytes (also in two places), the start and end page numbers, the virtual address of the start (two places), and the virtual address of the end.
I'm pretty sure it could be clarified significantly with a little love...
Cheers,
Rusty.
Quoted 22 lines · Rusty Russell
Hi Matt,
Quoted 20 lines
(quoted diff) +20
-0+#ifdef CONFIG_PROC_PAGEMAP +struct pagemapread { + struct mm_struct *mm; + unsigned long next; + unsigned long *buf; + pte_t *ptebuf; + unsigned long pos; + size_t count; + int index; + char __user *out; +}; + +static int flush_pagemap(struct pagemapread *pm) +{ + int n = min(pm->count, pm->index * sizeof(unsigned long)); + if (copy_to_user(pm->out, pm->buf, n)) + return -EFAULT; + pm->out += n; + pm->pos += n; + pm->count -= n;
Quoted 8 lines
Review
Quoted 4 lines
(quoted diff) +4
-0+ pm->index = 0; + cond_resched(); + return 0; +}This is a lot of complexity to buffer output (and the naming is
horrible: s/pagemap/outbuf/ would help this code).put_user()is pretty
efficient: is this really necessary?
No, and it's also broken. It can deadlock if the user unmaps the page in another thread.
I've got a fix using getuserpages but it's crashing on my system at the moment (but not in lguest!).
Quoted 12 lines
Review
Quoted 5 lines
(quoted diff) +5
-0+ ret = -EIO; + svpfn = src / sizeof(unsigned long) - 1; + addr = PAGE_SIZE * svpfn; + if ((svpfn + 1) * sizeof(unsigned long) != src) + goto out;This looks like a very complicated way to test for "*ppos % sizeof(unsigned long) != 0".
You use ppos to count records rather than bytes, and save some arithmetic here but I guess that breaks your userspace.
Quoted 7 lines
Review
Quoted 2 lines
(quoted diff) +2
-0+ evpfn = min((src + count) / sizeof(unsigned long), + ((~0UL) >> PAGE_SHIFT) + 1);Why?
The mixing of byte count and record count in this function makes it quite hard to understand.
Agreed.
Quoted 6 lines
Quoted 6 lines
(quoted diff) +6
-0+ ret = -ENOMEM; + page = kzalloc(PAGE_SIZE, GFP_USER); + if (!page) + goto out; + +#ifdef CONFIG_HIGHPTE
Quoted 8 lines
Review
Quoted 4 lines
(quoted diff) +4
-0+ pm.ptebuf = kzalloc(PAGE_SIZE, GFP_USER); + if (!pm.ptebuf) + goto out_free; +#endifI'm not sure either of these needs to be kzalloc'ed. And the fact that your buffer is a page long is an arbitrary choice: it'd be better using a separate
BUF_SIZEconstant.
Well it's not really arbitrary. But these go away in my WIP code.
Quoted 10 lines
Review
Quoted 7 lines
(quoted diff) +7
-0+ if (svpfn == -1) { + add_to_pagemap(pm.next, 0, &pm); + ((char *)page)[0] = (ntohl(1) != 1); + ((char *)page)[1] = PAGE_SHIFT; + ((char *)page)[2] = sizeof(unsigned long); + ((char *)page)[3] = sizeof(unsigned long); + }I think it would simplify the code if you move this to the top of the function, and copy these directly to userspace and return a short read.
Done.
Quoted 1 line
And how about "
cpu_to_le16(1)== 1" instead of "ntohl(1) != 1"?
Why?
Quoted 8 lines
Review
Quoted 5 lines
(quoted diff) +5
-0+ while (pm.count > 0 && vma) { + if (!ptrace_may_attach(task)) { + ret = -EIO; + goto out_mm; + }You already checked
ptrace_may_attach()earlier in this function; do you need to do that again?
I think so. Consider exec(). This whole area is full of interesting traps and it pays to be paranoid.
Signature · 1 line
Mathematics is the supreme nostalgia of our time.
Quoted 3 lines · Matt Mackall
Quoted 1 line
And how about "
cpu_to_le16(1)== 1" instead of "ntohl(1) != 1"?Why?
Using a networking macro to detect endianness is old school: we have the nice explicit macros these days...
Quoted 11 lines
Quoted 8 lines
Review
Quoted 5 lines
(quoted diff) +5
-0+ while (pm.count > 0 && vma) { + if (!ptrace_may_attach(task)) { + ret = -EIO; + goto out_mm; + }You already checked
ptrace_may_attach()earlier in this function; do you need to do that again?I think so. Consider
exec(). This whole area is full of interesting traps and it pays to be paranoid.
I don't think normal ptraces get cut on exec, so I'm not sure why this should be different. You could argue it would be more correct to check at the open, in fact.
Cheers,
Rusty.
Quoted 17 lines · Rusty Russell
Quoted 3 lines · Matt Mackall
Quoted 1 line
And how about "
cpu_to_le16(1)== 1" instead of "ntohl(1) != 1"?Why?
Using a networking macro to detect endianness is old school: we have the nice explicit macros these days...
Quoted 9 lines
Quoted 8 lines
Review
Quoted 5 lines
(quoted diff) +5
-0+ while (pm.count > 0 && vma) { + if (!ptrace_may_attach(task)) { + ret = -EIO; + goto out_mm; + }You already checked
ptrace_may_attach()earlier in this function; do you need to do that again?
Quoted 5 lines
Quoted 2 lines
I think so. Consider
exec(). This whole area is full of interesting traps and it pays to be paranoid.I don't think normal ptraces get cut on exec, so I'm not sure why this should be different.
They absolutely do, if UID changes. Consider ptracing a shell launching a setuid binary. For something more closely analogous, consider opening /proc/pid/mem on the same shell...
Signature · 1 line
Mathematics is the supreme nostalgia of our time.
Quoted 6 lines · Matt Mackall
Quoted 2 lines · Rusty Russell
I don't think normal ptraces get cut on exec, so I'm not sure why this should be different.
They absolutely do, if UID changes. Consider ptracing a shell launching a setuid binary.
No, ptraced processes don't change uid on execing a setuid binary. Which works, but isn't what you want 8(
Quoted 2 lines
For something more closely analogous, consider opening
/proc/pid/memon the same shell...
Ah, now I see where you got this from. OK, but can I have a comment please?
Thanks!
Rusty.