fs/proc/task_mmu.c

   1 #include <linux/mm.h>
   2 #include <linux/hugetlb.h>
   3 #include <linux/seq_file.h>
   4 #include <asm/elf.h>
   5 #include <asm/uaccess.h>
   6
   7 char *task_mem(struct mm_struct *mm, char *buffer)
   8 {
   9         unsigned long data, text, lib;
  10
  11         data = mm->total_vm - mm->shared_vm - mm->stack_vm;
  12         text = (mm->end_code - mm->start_code) >> 10;
  13         lib = (mm->exec_vm << (PAGE_SHIFT-10)) - text;
  14         buffer += sprintf(buffer,
  15                 "VmSize:\t%8lu kB\n"
  16                 "VmLck:\t%8lu kB\n"
  17                 "VmRSS:\t%8lu kB\n"
  18                 "VmData:\t%8lu kB\n"
  19                 "VmStk:\t%8lu kB\n"
  20                 "VmExe:\t%8lu kB\n"
  21                 "VmLib:\t%8lu kB\n"
  22                 "StaBrk:\t%08lx kB\n"
  23                 "Brk:\t%08lx kB\n"
  24                 "StaStk:\t%08lx kB\n"
  25 #if __i386__
  26                 "ExecLim:\t%08lx\n"
  27 #endif
  28                 ,
  29                 (mm->total_vm - mm->reserved_vm) << (PAGE_SHIFT-10),
  30                 mm->locked_vm << (PAGE_SHIFT-10),
  31                 mm->rss << (PAGE_SHIFT-10),
  32                 data << (PAGE_SHIFT-10),
  33                 mm->stack_vm << (PAGE_SHIFT-10), text, lib, mm->start_brk, mm->brk, mm->start_stack
  34 #if __i386__
  35                 , mm->context.exec_limit
  36 #endif
  37                 );
  38         return buffer;
  39 }
  40
  41 unsigned long task_vsize(struct mm_struct *mm)
  42 {
  43         return PAGE_SIZE * mm->total_vm;
  44 }
  45
  46 int task_statm(struct mm_struct *mm, int *shared, int *text,
  47                int *data, int *resident)
  48 {
  49         *shared = mm->rss - mm->anon_rss;
  50         *text = (mm->end_code - mm->start_code) >> PAGE_SHIFT;
  51         *data = mm->total_vm - mm->shared_vm;
  52         *resident = mm->rss;
  53         return mm->total_vm;
  54 }
  55
  56 static int show_map(struct seq_file *m, void *v)
  57 {
  58         struct vm_area_struct *map = v;
  59         struct file *file = map->vm_file;
  60         int flags = map->vm_flags;
  61         unsigned long ino = 0;
  62         dev_t dev = 0;
  63         int len;
  64
  65         if (file) {
  66                 struct inode *inode = map->vm_file->f_dentry->d_inode;
  67                 dev = inode->i_sb->s_dev;
  68                 ino = inode->i_ino;
  69         }
  70
  71         seq_printf(m, "%08lx-%08lx %c%c%c%c %08lx %02x:%02x %lu %n",
  72                         map->vm_start,
  73                         map->vm_end,
  74                         flags & VM_READ ? 'r' : '-',
  75                         flags & VM_WRITE ? 'w' : '-',
  76                         flags & VM_EXEC ? 'x' : '-',
  77                         flags & VM_MAYSHARE ? 's' : 'p',
  78                         map->vm_pgoff << PAGE_SHIFT,
  79                         MAJOR(dev), MINOR(dev), ino, &len);
  80
  81         if (map->vm_file) {
  82                 len = 25 + sizeof(void*) * 6 - len;
  83                 if (len < 1)
  84                         len = 1;
  85                 seq_printf(m, "%*c", len, ' ');
  86                 seq_path(m, file->f_vfsmnt, file->f_dentry, "");
  87         }
  88         seq_putc(m, '\n');
  89         return 0;
  90 }
  91
  92 static void *m_start(struct seq_file *m, loff_t *pos)
  93 {
  94         struct task_struct *task = m->private;
  95         struct mm_struct *mm = get_task_mm(task);
  96         struct vm_area_struct * map;
  97         loff_t l = *pos;
  98
  99         if (!mm)
 100                 return NULL;
 101
 102         down_read(&mm->mmap_sem);
 103         map = mm->mmap;
 104         while (l-- && map)
 105                 map = map->vm_next;
 106         if (!map) {
 107                 up_read(&mm->mmap_sem);
 108                 mmput(mm);
 109                 if (l == -1)
 110                         map = get_gate_vma(task);
 111         }
 112         return map;
 113 }
 114
 115 static void m_stop(struct seq_file *m, void *v)
 116 {
 117         struct task_struct *task = m->private;
 118         struct vm_area_struct *map = v;
 119         if (map && map != get_gate_vma(task)) {
 120                 struct mm_struct *mm = map->vm_mm;
 121                 up_read(&mm->mmap_sem);
 122                 mmput(mm);
 123         }
 124 }
 125
 126 static void *m_next(struct seq_file *m, void *v, loff_t *pos)
 127 {
 128         struct task_struct *task = m->private;
 129         struct vm_area_struct *map = v;
 130         (*pos)++;
 131         if (map->vm_next)
 132                 return map->vm_next;
 133         m_stop(m, v);
 134         if (map != get_gate_vma(task))
 135                 return get_gate_vma(task);
 136         return NULL;
 137 }
 138
 139 struct seq_operations proc_pid_maps_op = {
 140         .start  = m_start,
 141         .next   = m_next,
 142         .stop   = m_stop,
 143         .show   = show_map
 144 };