lkml.org 
[lkml]   [2016]   [Aug]   [9]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
/
SubjectRe: [PACTH v1] mm, proc: Implement /proc/<pid>/totmaps
From
Date


On 2016-08-09 03:24 PM, Jann Horn wrote:
> On Tue, Aug 09, 2016 at 12:05:43PM -0400, robert.foss@collabora.com wrote:
>> From: Sonny Rao <sonnyrao@chromium.org>
>>
>> This is based on earlier work by Thiago Goncales. It implements a new
>> per process proc file which summarizes the contents of the smaps file
>> but doesn't display any addresses. It gives more detailed information
>> than statm like the PSS (proprotional set size). It differs from the
>> original implementation in that it doesn't use the full blown set of
>> seq operations, uses a different termination condition, and doesn't
>> displayed "Locked" as that was broken on the original implemenation.
>>
>> This new proc file provides information faster than parsing the potentially
>> huge smaps file.
>>
>> Signed-off-by: Sonny Rao <sonnyrao@chromium.org>
>>
>> Tested-by: Robert Foss <robert.foss@collabora.com>
>> Signed-off-by: Robert Foss <robert.foss@collabora.com>
>
>
>> +static int totmaps_proc_show(struct seq_file *m, void *data)
>> +{
>> + struct proc_maps_private *priv = m->private;
>> + struct mm_struct *mm;
>> + struct vm_area_struct *vma;
>> + struct mem_size_stats *mss_sum = priv->mss;
>> +
>> + /* reference to priv->task already taken */
>> + /* but need to get the mm here because */
>> + /* task could be in the process of exiting */
>
> Can you please elaborate on this? My understanding here is that you
> intend for the caller to be able to repeatedly read the same totmaps
> file with pread() and still see updated information after the target
> process has called execve() and be able to detect process death
> (instead of simply seeing stale values). Is that accurate?
>
> I would prefer it if you could grab a reference to the mm_struct
> directly at open time.

Sonny, do you know more about the above comment?

>
>
>> + mm = get_task_mm(priv->task);
>> + if (!mm || IS_ERR(mm))
>> + return -EINVAL;
>
> get_task_mm() doesn't return error codes, and all other callers just
> check whether the return value is NULL.
>

I'll have that fixed in v2, thanks for spotting it!

>
>> + down_read(&mm->mmap_sem);
>> + hold_task_mempolicy(priv);
>> +
>> + for (vma = mm->mmap; vma != priv->tail_vma; vma = vma->vm_next) {
>> + struct mem_size_stats mss;
>> + struct mm_walk smaps_walk = {
>> + .pmd_entry = smaps_pte_range,
>> + .mm = vma->vm_mm,
>> + .private = &mss,
>> + };
>> +
>> + if (vma->vm_mm && !is_vm_hugetlb_page(vma)) {
>> + memset(&mss, 0, sizeof(mss));
>> + walk_page_vma(vma, &smaps_walk);
>> + add_smaps_sum(&mss, mss_sum);
>> + }
>> + }
>
> Errrr... what? You accumulate values from mem_size_stats items into a
> struct mss_sum that is associated with the struct file? So when you
> read the file the second time, you get the old values plus the new ones?
> And when you read the file in parallel, you get inconsistent values?
>
> For most files in procfs, the behavior is that you can just call
> pread(fd, buf, sizeof(buf), 0) on the same fd again and again, giving
> you the current values every time, without mutating state. I strongly
> recommend that you get rid of priv->mss and just accumulate the state
> in a local variable (maybe one on the stack).

So a simple "static struct mem_size_stats" in totmaps_proc_show() would
be a better solution?

>
>
>> @@ -836,6 +911,50 @@ static int tid_smaps_open(struct inode *inode, struct file *file)
>> return do_maps_open(inode, file, &proc_tid_smaps_op);
>> }
>>
>> +static int totmaps_open(struct inode *inode, struct file *file)
>> +{
>> + struct proc_maps_private *priv;
>> + int ret = -ENOMEM;
>> + priv = kzalloc(sizeof(*priv), GFP_KERNEL);
>> + if (priv) {
>> + priv->mss = kzalloc(sizeof(*priv->mss), GFP_KERNEL);
>> + if (!priv->mss)
>> + return -ENOMEM;
>
> Memory leak: If the first allocation works and the second one doesn't, this
> doesn't free the first allocation.
>
> Please change this to use the typical goto pattern for error handling.

Fix will be implemented in v2.

>
>> +
>> + /* we need to grab references to the task_struct */
>> + /* at open time, because there's a potential information */
>> + /* leak where the totmaps file is opened and held open */
>> + /* while the underlying pid to task mapping changes */
>> + /* underneath it */
>
> Nit: That's not how comments are done in the kernel. Maybe change this to
> a normal block comment instead of one block comment per line?

I'm not sure how that one slipped by, but I'll change it in v2.

>
>> + priv->task = get_pid_task(proc_pid(inode), PIDTYPE_PID);
>
> `get_pid_task(proc_pid(inode), PIDTYPE_PID)` is exactly the definition
> of get_proc_task(inode), maybe use that instead?
>

Will do. v2 will fix this.

>> + if (!priv->task) {
>> + kfree(priv->mss);
>> + kfree(priv);
>> + return -ESRCH;
>> + }
>> +
>> + ret = single_open(file, totmaps_proc_show, priv);
>> + if (ret) {
>> + put_task_struct(priv->task);
>> + kfree(priv->mss);
>> + kfree(priv);
>> + }
>> + }
>> + return ret;
>> +}
>
> Please change this method to use the typical goto pattern for error
> handling. IMO repeating the undo steps in all error cases makes
> mistakes (like the one above) more likely and increases the amount
> of redundant code.

Agreed. Change queued for v2.

>
> Also: The smaps file is only accessible to callers with
> PTRACE_MODE_READ privileges on the target task. Your thing doesn't
> do any access checks, neither in the open handler nor in the read
> handler. Can you give an analysis of why it's okay to expose this
> data? As far as I can tell, without spending a lot of time thinking
> about it, this kind of data looks like it might potentially be
> useful for side-channel information leaks or so.
>

I think it should require the same permissions as smaps, so changing the
code to require PTRACE_MODE_READ privileges is most likely a good idea.
I'll have a look at it for v2.

\
 
 \ /
  Last update: 2016-08-09 23:41    [W:1.105 / U:0.108 seconds]
©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site