vserver 2.0 rc7

[linux-2.6.git] / fs / proc / task_mmu.c

diff --git a/fs/proc/task_mmu.c b/fs/proc/task_mmu.c
index 01353eb..28b4a02 100644 (file)
--- a/fs/proc/task_mmu.c
+++ b/fs/proc/task_mmu.c
@@ -24,7 +24,7 @@ char *task_mem(struct mm_struct *mm, char *buffer)
                "VmPTE:\t%8lu kB\n",
                (mm->total_vm - mm->reserved_vm) << (PAGE_SHIFT-10),
                mm->locked_vm << (PAGE_SHIFT-10),
-               mm->rss << (PAGE_SHIFT-10),
+               get_mm_counter(mm, rss) << (PAGE_SHIFT-10),
                data << (PAGE_SHIFT-10),
                mm->stack_vm << (PAGE_SHIFT-10), text, lib,
                (PTRS_PER_PTE*sizeof(pte_t)*mm->nr_ptes) >> 10);
@@ -39,11 +39,13 @@ unsigned long task_vsize(struct mm_struct *mm)
 int task_statm(struct mm_struct *mm, int *shared, int *text,
               int *data, int *resident)
 {
-       *shared = mm->rss - mm->anon_rss;
+       int rss = get_mm_counter(mm, rss);
+
+       *shared = rss - get_mm_counter(mm, anon_rss);
        *text = (PAGE_ALIGN(mm->end_code) - (mm->start_code & PAGE_MASK))
                                                                >> PAGE_SHIFT;
        *data = mm->total_vm - mm->shared_vm;
-       *resident = mm->rss;
+       *resident = rss;
        return mm->total_vm;
 }
 
@@ -77,9 +79,19 @@ out:
        return result;
 }
 
+static void pad_len_spaces(struct seq_file *m, int len)
+{
+       len = 25 + sizeof(void*) * 6 - len;
+       if (len < 1)
+               len = 1;
+       seq_printf(m, "%*c", len, ' ');
+}
+
 static int show_map(struct seq_file *m, void *v)
 {
+       struct task_struct *task = m->private;
        struct vm_area_struct *map = v;
+       struct mm_struct *mm = map->vm_mm;
        struct file *file = map->vm_file;
        int flags = map->vm_flags;
        unsigned long ino = 0;
@@ -102,38 +114,93 @@ static int show_map(struct seq_file *m, void *v)
                        map->vm_pgoff << PAGE_SHIFT,
                        MAJOR(dev), MINOR(dev), ino, &len);
 
+       /*
+        * Print the dentry name for named mappings, and a
+        * special [heap] marker for the heap:
+        */
        if (map->vm_file) {
-               len = 25 + sizeof(void*) * 6 - len;
-               if (len < 1)
-                       len = 1;
-               seq_printf(m, "%*c", len, ' ');
+               pad_len_spaces(m, len);
                seq_path(m, file->f_vfsmnt, file->f_dentry, "");
+       } else {
+               if (mm) {
+                       if (map->vm_start <= mm->start_brk &&
+                                               map->vm_end >= mm->brk) {
+                               pad_len_spaces(m, len);
+                               seq_puts(m, "[heap]");
+                       } else {
+                               if (map->vm_start <= mm->start_stack &&
+                                       map->vm_end >= mm->start_stack) {
+
+                                       pad_len_spaces(m, len);
+                                       seq_puts(m, "[stack]");
+                               }
+                       }
+               } else {
+                       pad_len_spaces(m, len);
+                       seq_puts(m, "[vdso]");
+               }
        }
        seq_putc(m, '\n');
+       if (m->count < m->size)  /* map is copied successfully */
+               m->version = (map != get_gate_vma(task))? map->vm_start: 0;
        return 0;
 }
 
 static void *m_start(struct seq_file *m, loff_t *pos)
 {
        struct task_struct *task = m->private;
-       struct mm_struct *mm = get_task_mm(task);
-       struct vm_area_struct * map;
+       unsigned long last_addr = m->version;
+       struct mm_struct *mm;
+       struct vm_area_struct *map, *tail_map;
        loff_t l = *pos;
 
+       /*
+        * We remember last_addr rather than next_addr to hit with
+        * mmap_cache most of the time. We have zero last_addr at
+        * the begining and also after lseek. We will have -1 last_addr
+        * after the end of the maps.
+        */
+
+       if (last_addr == -1UL)
+               return NULL;
+
+       mm = get_task_mm(task);
        if (!mm)
                return NULL;
 
+       tail_map = get_gate_vma(task);
        down_read(&mm->mmap_sem);
-       map = mm->mmap;
-       while (l-- && map)
+
+       /* Start with last addr hint */
+       if (last_addr && (map = find_vma(mm, last_addr))) {
                map = map->vm_next;
-       if (!map) {
-               up_read(&mm->mmap_sem);
-               mmput(mm);
-               if (l == -1)
-                       map = get_gate_vma(task);
+               goto out;
+       }
+
+       /*
+        * Check the map index is within the range and do
+        * sequential scan until m_index.
+        */
+       map = NULL;
+       if ((unsigned long)l < mm->map_count) {
+               map = mm->mmap;
+               while (l-- && map)
+                       map = map->vm_next;
+               goto out;
        }
-       return map;
+
+       if (l != mm->map_count)
+               tail_map = NULL; /* After gate map */
+
+out:
+       if (map)
+               return map;
+
+       /* End of maps has reached */
+       m->version = (tail_map != NULL)? 0: -1UL;
+       up_read(&mm->mmap_sem);
+       mmput(mm);
+       return tail_map;
 }
 
 static void m_stop(struct seq_file *m, void *v)
@@ -151,13 +218,13 @@ static void *m_next(struct seq_file *m, void *v, loff_t *pos)
 {
        struct task_struct *task = m->private;
        struct vm_area_struct *map = v;
+       struct vm_area_struct *tail_map = get_gate_vma(task);
+
        (*pos)++;
-       if (map->vm_next)
+       if (map && (map != tail_map) && map->vm_next)
                return map->vm_next;
        m_stop(m, v);
-       if (map != get_gate_vma(task))
-               return get_gate_vma(task);
-       return NULL;
+       return (map != tail_map)? tail_map: NULL;
 }
 
 struct seq_operations proc_pid_maps_op = {