kernel/2.6.29.6-aldebaran-rt/fs/proc/task_nommu.c

   1
   2 #include <linux/mm.h>
   3 #include <linux/file.h>
   4 #include <linux/fdtable.h>
   5 #include <linux/mount.h>
   6 #include <linux/ptrace.h>
   7 #include <linux/seq_file.h>
   8 #include "internal.h"
   9
  10 /*
  11  * Logic: we've got two memory sums for each process, "shared", and
  12  * "non-shared". Shared memory may get counted more than once, for
  13  * each process that owns it. Non-shared memory is counted
  14  * accurately.
  15  */
  16 void task_mem(struct seq_file *m, struct mm_struct *mm)
  17 {
  18         struct vm_area_struct *vma;
  19         struct vm_region *region;
  20         struct rb_node *p;
  21         unsigned long bytes = 0, sbytes = 0, slack = 0, size;
  22
  23         down_read(&mm->mmap_sem);
  24         for (p = rb_first(&mm->mm_rb); p; p = rb_next(p)) {
  25                 vma = rb_entry(p, struct vm_area_struct, vm_rb);
  26
  27                 bytes += kobjsize(vma);
  28
  29                 region = vma->vm_region;
  30                 if (region) {
  31                         size = kobjsize(region);
  32                         size += region->vm_end - region->vm_start;
  33                 } else {
  34                         size = vma->vm_end - vma->vm_start;
  35                 }
  36
  37                 if (atomic_read(&mm->mm_count) > 1 ||
  38                     vma->vm_flags & VM_MAYSHARE) {
  39                         sbytes += size;
  40                 } else {
  41                         bytes += size;
  42                         if (region)
  43                                 slack = region->vm_end - vma->vm_end;
  44                 }
  45         }
  46
  47         if (atomic_read(&mm->mm_count) > 1)
  48                 sbytes += kobjsize(mm);
  49         else
  50                 bytes += kobjsize(mm);
  51
  52         if (current->fs && current->fs->users > 1)
  53                 sbytes += kobjsize(current->fs);
  54         else
  55                 bytes += kobjsize(current->fs);
  56
  57         if (current->files && atomic_read(&current->files->count) > 1)
  58                 sbytes += kobjsize(current->files);
  59         else
  60                 bytes += kobjsize(current->files);
  61
  62         if (current->sighand && atomic_read(&current->sighand->count) > 1)
  63                 sbytes += kobjsize(current->sighand);
  64         else
  65                 bytes += kobjsize(current->sighand);
  66
  67         bytes += kobjsize(current); /* includes kernel stack */
  68
  69         seq_printf(m,
  70                 "Mem:\t%8lu bytes\n"
  71                 "Slack:\t%8lu bytes\n"
  72                 "Shared:\t%8lu bytes\n",
  73                 bytes, slack, sbytes);
  74
  75         up_read(&mm->mmap_sem);
  76 }
  77
  78 unsigned long task_vsize(struct mm_struct *mm)
  79 {
  80         struct vm_area_struct *vma;
  81         struct rb_node *p;
  82         unsigned long vsize = 0;
  83
  84         down_read(&mm->mmap_sem);
  85         for (p = rb_first(&mm->mm_rb); p; p = rb_next(p)) {
  86                 vma = rb_entry(p, struct vm_area_struct, vm_rb);
  87                 vsize += vma->vm_end - vma->vm_start;
  88         }
  89         up_read(&mm->mmap_sem);
  90         return vsize;
  91 }
  92
  93 int task_statm(struct mm_struct *mm, int *shared, int *text,
  94                int *data, int *resident)
  95 {
  96         struct vm_area_struct *vma;
  97         struct vm_region *region;
  98         struct rb_node *p;
  99         int size = kobjsize(mm);
 100
 101         down_read(&mm->mmap_sem);
 102         for (p = rb_first(&mm->mm_rb); p; p = rb_next(p)) {
 103                 vma = rb_entry(p, struct vm_area_struct, vm_rb);
 104                 size += kobjsize(vma);
 105                 region = vma->vm_region;
 106                 if (region) {
 107                         size += kobjsize(region);
 108                         size += region->vm_end - region->vm_start;
 109                 }
 110         }
 111
 112         size += (*text = mm->end_code - mm->start_code);
 113         size += (*data = mm->start_stack - mm->start_data);
 114         up_read(&mm->mmap_sem);
 115         *resident = size;
 116         return size;
 117 }
 118
 119 /*
 120  * display a single VMA to a sequenced file
 121  */
 122 static int nommu_vma_show(struct seq_file *m, struct vm_area_struct *vma)
 123 {
 124         unsigned long ino = 0;
 125         struct file *file;
 126         dev_t dev = 0;
 127         int flags, len;
 128
 129         flags = vma->vm_flags;
 130         file = vma->vm_file;
 131
 132         if (file) {
 133                 struct inode *inode = vma->vm_file->f_path.dentry->d_inode;
 134                 dev = inode->i_sb->s_dev;
 135                 ino = inode->i_ino;
 136         }
 137
 138         seq_printf(m,
 139                    "%08lx-%08lx %c%c%c%c %08lx %02x:%02x %lu %n",
 140                    vma->vm_start,
 141                    vma->vm_end,
 142                    flags & VM_READ ? 'r' : '-',
 143                    flags & VM_WRITE ? 'w' : '-',
 144                    flags & VM_EXEC ? 'x' : '-',
 145                    flags & VM_MAYSHARE ? flags & VM_SHARED ? 'S' : 's' : 'p',
 146                    vma->vm_pgoff << PAGE_SHIFT,
 147                    MAJOR(dev), MINOR(dev), ino, &len);
 148
 149         if (file) {
 150                 len = 25 + sizeof(void *) * 6 - len;
 151                 if (len < 1)
 152                         len = 1;
 153                 seq_printf(m, "%*c", len, ' ');
 154                 seq_path(m, &file->f_path, "");
 155         }
 156
 157         seq_putc(m, '\n');
 158         return 0;
 159 }
 160
 161 /*
 162  * display mapping lines for a particular process's /proc/pid/maps
 163  */
 164 static int show_map(struct seq_file *m, void *_p)
 165 {
 166         struct rb_node *p = _p;
 167
 168         return nommu_vma_show(m, rb_entry(p, struct vm_area_struct, vm_rb));
 169 }
 170
 171 static void *m_start(struct seq_file *m, loff_t *pos)
 172 {
 173         struct proc_maps_private *priv = m->private;
 174         struct mm_struct *mm;
 175         struct rb_node *p;
 176         loff_t n = *pos;
 177
 178         /* pin the task and mm whilst we play with them */
 179         priv->task = get_pid_task(priv->pid, PIDTYPE_PID);
 180         if (!priv->task)
 181                 return NULL;
 182
 183         mm = mm_for_maps(priv->task);
 184         if (!mm) {
 185                 put_task_struct(priv->task);
 186                 priv->task = NULL;
 187                 return NULL;
 188         }
 189
 190         /* start from the Nth VMA */
 191         for (p = rb_first(&mm->mm_rb); p; p = rb_next(p))
 192                 if (n-- == 0)
 193                         return p;
 194         return NULL;
 195 }
 196
 197 static void m_stop(struct seq_file *m, void *_vml)
 198 {
 199         struct proc_maps_private *priv = m->private;
 200
 201         if (priv->task) {
 202                 struct mm_struct *mm = priv->task->mm;
 203                 up_read(&mm->mmap_sem);
 204                 mmput(mm);
 205                 put_task_struct(priv->task);
 206         }
 207 }
 208
 209 static void *m_next(struct seq_file *m, void *_p, loff_t *pos)
 210 {
 211         struct rb_node *p = _p;
 212
 213         (*pos)++;
 214         return p ? rb_next(p) : NULL;
 215 }
 216
 217 static const struct seq_operations proc_pid_maps_ops = {
 218         .start  = m_start,
 219         .next   = m_next,
 220         .stop   = m_stop,
 221         .show   = show_map
 222 };
 223
 224 static int maps_open(struct inode *inode, struct file *file)
 225 {
 226         struct proc_maps_private *priv;
 227         int ret = -ENOMEM;
 228
 229         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
 230         if (priv) {
 231                 priv->pid = proc_pid(inode);
 232                 ret = seq_open(file, &proc_pid_maps_ops);
 233                 if (!ret) {
 234                         struct seq_file *m = file->private_data;
 235                         m->private = priv;
 236                 } else {
 237                         kfree(priv);
 238                 }
 239         }
 240         return ret;
 241 }
 242
 243 const struct file_operations proc_maps_operations = {
 244         .open           = maps_open,
 245         .read           = seq_read,
 246         .llseek         = seq_lseek,
 247         .release        = seq_release_private,
 248 };
 249