Release 4.10 fs/proc/task_nommu.c

Directory: fs/proc
#include <linux/mm.h>
#include <linux/file.h>
#include <linux/fdtable.h>
#include <linux/fs_struct.h>
#include <linux/mount.h>
#include <linux/ptrace.h>
#include <linux/slab.h>
#include <linux/seq_file.h>
#include "internal.h"

/*
 * Logic: we've got two memory sums for each process, "shared", and
 * "non-shared". Shared memory may get counted more than once, for
 * each process that owns it. Non-shared memory is counted
 * accurately.
 */


void task_mem(struct seq_file *m, struct mm_struct *mm)
{
	struct vm_area_struct *vma;
	struct vm_region *region;
	struct rb_node *p;
	unsigned long bytes = 0, sbytes = 0, slack = 0, size;
        
	down_read(&mm->mmap_sem);
	for (p = rb_first(&mm->mm_rb); p; p = rb_next(p)) {
		vma = rb_entry(p, struct vm_area_struct, vm_rb);

		bytes += kobjsize(vma);

		region = vma->vm_region;
		if (region) {
			size = kobjsize(region);
			size += region->vm_end - region->vm_start;
		} else {
			size = vma->vm_end - vma->vm_start;
		}

		if (atomic_read(&mm->mm_count) > 1 ||
		    vma->vm_flags & VM_MAYSHARE) {
			sbytes += size;
		} else {
			bytes += size;
			if (region)
				slack = region->vm_end - vma->vm_end;
		}
	}

	if (atomic_read(&mm->mm_count) > 1)
		sbytes += kobjsize(mm);
	else
		bytes += kobjsize(mm);
	
	if (current->fs && current->fs->users > 1)
		sbytes += kobjsize(current->fs);
	else
		bytes += kobjsize(current->fs);

	if (current->files && atomic_read(&current->files->count) > 1)
		sbytes += kobjsize(current->files);
	else
		bytes += kobjsize(current->files);

	if (current->sighand && atomic_read(&current->sighand->count) > 1)
		sbytes += kobjsize(current->sighand);
	else
		bytes += kobjsize(current->sighand);

	bytes += kobjsize(current); /* includes kernel stack */

	seq_printf(m,
		"Mem:\t%8lu bytes\n"
		"Slack:\t%8lu bytes\n"
		"Shared:\t%8lu bytes\n",
		bytes, slack, sbytes);

	up_read(&mm->mmap_sem);
}

Contributors
Person Tokens Prop Commits CommitProp
christoph hellwig christoph hellwig 234 67.24% 1 12.50%
david howells david howells 101 29.02% 4 50.00%
eric w. biederman eric w. biederman 8 2.30% 1 12.50%
greg ungerer greg ungerer 4 1.15% 1 12.50%
al viro al viro 1 0.29% 1 12.50%
Total 348 100.00% 8 100.00%



unsigned long task_vsize(struct mm_struct *mm)
{
	struct vm_area_struct *vma;
	struct rb_node *p;
	unsigned long vsize = 0;

	down_read(&mm->mmap_sem);
	for (p = rb_first(&mm->mm_rb); p; p = rb_next(p)) {
		vma = rb_entry(p, struct vm_area_struct, vm_rb);
		vsize += vma->vm_end - vma->vm_start;
	}
	up_read(&mm->mmap_sem);
	return vsize;
}

Contributors
Person Tokens Prop Commits CommitProp
david howells david howells 37 40.66% 2 40.00%
christoph hellwig christoph hellwig 36 39.56% 1 20.00%
william lee irwin iii william lee irwin iii 16 17.58% 1 20.00%
greg ungerer greg ungerer 2 2.20% 1 20.00%
Total 91 100.00% 5 100.00%



unsigned long task_statm(struct mm_struct *mm,
			 unsigned long *shared, unsigned long *text,
			 unsigned long *data, unsigned long *resident)
{
	struct vm_area_struct *vma;
	struct vm_region *region;
	struct rb_node *p;
	unsigned long size = kobjsize(mm);

	down_read(&mm->mmap_sem);
	for (p = rb_first(&mm->mm_rb); p; p = rb_next(p)) {
		vma = rb_entry(p, struct vm_area_struct, vm_rb);
		size += kobjsize(vma);
		region = vma->vm_region;
		if (region) {
			size += kobjsize(region);
			size += region->vm_end - region->vm_start;
		}
	}

	*text = (PAGE_ALIGN(mm->end_code) - (mm->start_code & PAGE_MASK))
		>> PAGE_SHIFT;
	*data = (PAGE_ALIGN(mm->start_stack) - (mm->start_data & PAGE_MASK))
		>> PAGE_SHIFT;
	up_read(&mm->mmap_sem);
	size >>= PAGE_SHIFT;
	size += *text + *data;
	*resident = size;
	return size;
}

Contributors
Person Tokens Prop Commits CommitProp
christoph hellwig christoph hellwig 87 42.23% 1 12.50%
david howells david howells 57 27.67% 3 37.50%
steven j. magnani steven j. magnani 32 15.53% 1 12.50%
william lee irwin iii william lee irwin iii 16 7.77% 1 12.50%
alexey dobriyan alexey dobriyan 12 5.83% 1 12.50%
greg ungerer greg ungerer 2 0.97% 1 12.50%
Total 206 100.00% 8 100.00%



static int is_stack(struct proc_maps_private *priv,
		    struct vm_area_struct *vma)
{
	struct mm_struct *mm = vma->vm_mm;

	/*
         * We make no effort to guess what a given thread considers to be
         * its "stack".  It's not even well-defined for programs written
         * languages like Go.
         */
	return vma->vm_start <= mm->start_stack &&
		vma->vm_end >= mm->start_stack;
}

Contributors
Person Tokens Prop Commits CommitProp
johannes weiner johannes weiner 25 58.14% 1 33.33%
oleg nesterov oleg nesterov 16 37.21% 1 33.33%
andy lutomirski andy lutomirski 2 4.65% 1 33.33%
Total 43 100.00% 3 100.00%

/*
 * display a single VMA to a sequenced file
 */


static int nommu_vma_show(struct seq_file *m, struct vm_area_struct *vma,
			  int is_pid)
{
	struct mm_struct *mm = vma->vm_mm;
	struct proc_maps_private *priv = m->private;
	unsigned long ino = 0;
	struct file *file;
	dev_t dev = 0;
	int flags;
	unsigned long long pgoff = 0;

	flags = vma->vm_flags;
	file = vma->vm_file;

	if (file) {
		struct inode *inode = file_inode(vma->vm_file);
		dev = inode->i_sb->s_dev;
		ino = inode->i_ino;
		pgoff = (loff_t)vma->vm_pgoff << PAGE_SHIFT;
	}

	seq_setwidth(m, 25 + sizeof(void *) * 6 - 1);
	seq_printf(m,
		   "%08lx-%08lx %c%c%c%c %08llx %02x:%02x %lu ",
		   vma->vm_start,
		   vma->vm_end,
		   flags & VM_READ ? 'r' : '-',
		   flags & VM_WRITE ? 'w' : '-',
		   flags & VM_EXEC ? 'x' : '-',
		   flags & VM_MAYSHARE ? flags & VM_SHARED ? 'S' : 's' : 'p',
		   pgoff,
		   MAJOR(dev), MINOR(dev), ino);

	if (file) {
		seq_pad(m, ' ');
		seq_file_path(m, file, "");
	} else if (mm && is_stack(priv, vma)) {
		seq_pad(m, ' ');
		seq_printf(m, "[stack]");
	}

	seq_putc(m, '\n');
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
david howells david howells 170 64.89% 1 11.11%
siddhesh poyarekar siddhesh poyarekar 26 9.92% 1 11.11%
tetsuo handa tetsuo handa 22 8.40% 1 11.11%
mike frysinger mike frysinger 19 7.25% 1 11.11%
kamezawa hiroyuki kamezawa hiroyuki 18 6.87% 1 11.11%
al viro al viro 3 1.15% 1 11.11%
johannes weiner johannes weiner 2 0.76% 1 11.11%
nobuhiro iwamatsu nobuhiro iwamatsu 1 0.38% 1 11.11%
miklos szeredi miklos szeredi 1 0.38% 1 11.11%
Total 262 100.00% 9 100.00%

/*
 * display mapping lines for a particular process's /proc/pid/maps
 */


static int show_map(struct seq_file *m, void *_p, int is_pid)
{
	struct rb_node *p = _p;

	return nommu_vma_show(m, rb_entry(p, struct vm_area_struct, vm_rb),
			      is_pid);
}

Contributors
Person Tokens Prop Commits CommitProp
david howells david howells 21 48.84% 2 40.00%
andrew morton andrew morton 10 23.26% 1 20.00%
siddhesh poyarekar siddhesh poyarekar 8 18.60% 1 20.00%
christoph hellwig christoph hellwig 4 9.30% 1 20.00%
Total 43 100.00% 5 100.00%



static int show_pid_map(struct seq_file *m, void *_p)
{
	return show_map(m, _p, 1);
}

Contributors
Person Tokens Prop Commits CommitProp
siddhesh poyarekar siddhesh poyarekar 25 100.00% 1 100.00%
Total 25 100.00% 1 100.00%



static int show_tid_map(struct seq_file *m, void *_p)
{
	return show_map(m, _p, 0);
}

Contributors
Person Tokens Prop Commits CommitProp
siddhesh poyarekar siddhesh poyarekar 22 88.00% 1 33.33%
andrew morton andrew morton 2 8.00% 1 33.33%
david howells david howells 1 4.00% 1 33.33%
Total 25 100.00% 3 100.00%



static void *m_start(struct seq_file *m, loff_t *pos)
{
	struct proc_maps_private *priv = m->private;
	struct mm_struct *mm;
	struct rb_node *p;
	loff_t n = *pos;

	/* pin the task and mm whilst we play with them */
	priv->task = get_proc_task(priv->inode);
	if (!priv->task)
		return ERR_PTR(-ESRCH);

	mm = priv->mm;
	if (!mm || !atomic_inc_not_zero(&mm->mm_users))
		return NULL;

	down_read(&mm->mmap_sem);
	/* start from the Nth VMA */
	for (p = rb_first(&mm->mm_rb); p; p = rb_next(p))
		if (n-- == 0)
			return p;

	up_read(&mm->mmap_sem);
	mmput(mm);
	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
david howells david howells 88 60.27% 2 22.22%
oleg nesterov oleg nesterov 30 20.55% 4 44.44%
andrew morton andrew morton 16 10.96% 1 11.11%
al viro al viro 9 6.16% 1 11.11%
christoph hellwig christoph hellwig 3 2.05% 1 11.11%
Total 146 100.00% 9 100.00%



static void m_stop(struct seq_file *m, void *_vml)
{
	struct proc_maps_private *priv = m->private;

	if (!IS_ERR_OR_NULL(_vml)) {
		up_read(&priv->mm->mmap_sem);
		mmput(priv->mm);
	}
	if (priv->task) {
		put_task_struct(priv->task);
		priv->task = NULL;
	}
}

Contributors
Person Tokens Prop Commits CommitProp
david howells david howells 37 51.39% 1 25.00%
oleg nesterov oleg nesterov 23 31.94% 1 25.00%
andrew morton andrew morton 10 13.89% 1 25.00%
christoph hellwig christoph hellwig 2 2.78% 1 25.00%
Total 72 100.00% 4 100.00%



static void *m_next(struct seq_file *m, void *_p, loff_t *pos)
{
	struct rb_node *p = _p;

	(*pos)++;
	return p ? rb_next(p) : NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
david howells david howells 21 48.84% 2 50.00%
andrew morton andrew morton 14 32.56% 1 25.00%
christoph hellwig christoph hellwig 8 18.60% 1 25.00%
Total 43 100.00% 4 100.00%


static const struct seq_operations proc_pid_maps_ops = {
	.start	= m_start,
	.next	= m_next,
	.stop	= m_stop,
	.show	= show_pid_map
};


static const struct seq_operations proc_tid_maps_ops = {
	.start	= m_start,
	.next	= m_next,
	.stop	= m_stop,
	.show	= show_tid_map
};



static int maps_open(struct inode *inode, struct file *file,
		     const struct seq_operations *ops)
{
	struct proc_maps_private *priv;

	priv = __seq_open_private(file, ops, sizeof(*priv));
	if (!priv)
		return -ENOMEM;

	priv->inode = inode;
	priv->mm = proc_mem_open(inode, PTRACE_MODE_READ);
	if (IS_ERR(priv->mm)) {
		int err = PTR_ERR(priv->mm);

		seq_release_private(inode, file);
		return err;
	}

	return 0;
}


Contributors
Person Tokens Prop Commits CommitProp
oleg nesterov oleg nesterov 56 54.90% 3 50.00%
david howells david howells 22 21.57% 1 16.67%
eric w. biederman eric w. biederman 18 17.65% 1 16.67%
siddhesh poyarekar siddhesh poyarekar 6 5.88% 1 16.67%
Total 102 100.00% 6 100.00%



static int map_release(struct inode *inode, struct file *file)
{
	struct seq_file *seq = file->private_data;
	struct proc_maps_private *priv = seq->private;

	if (priv->mm)
		mmdrop(priv->mm);

	return seq_release_private(inode, file);
}

Contributors
Person Tokens Prop Commits CommitProp
oleg nesterov oleg nesterov 55 100.00% 1 100.00%
Total 55 100.00% 1 100.00%



static int pid_maps_open(struct inode *inode, struct file *file)
{
	return maps_open(inode, file, &proc_pid_maps_ops);
}

Contributors
Person Tokens Prop Commits CommitProp
siddhesh poyarekar siddhesh poyarekar 27 100.00% 1 100.00%
Total 27 100.00% 1 100.00%



static int tid_maps_open(struct inode *inode, struct file *file)
{
	return maps_open(inode, file, &proc_tid_maps_ops);
}

Contributors
Person Tokens Prop Commits CommitProp
siddhesh poyarekar siddhesh poyarekar 27 100.00% 1 100.00%
Total 27 100.00% 1 100.00%


const struct file_operations proc_pid_maps_operations = {
	.open		= pid_maps_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= map_release,
};


const struct file_operations proc_tid_maps_operations = {
	.open		= tid_maps_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= map_release,
};

Overall Contributors
Person Tokens Prop Commits CommitProp
david howells david howells 564 34.08% 5 13.16%
christoph hellwig christoph hellwig 377 22.78% 1 2.63%
siddhesh poyarekar siddhesh poyarekar 198 11.96% 1 2.63%
oleg nesterov oleg nesterov 182 11.00% 6 15.79%
andrew morton andrew morton 79 4.77% 1 2.63%
eric w. biederman eric w. biederman 50 3.02% 2 5.26%
steven j. magnani steven j. magnani 32 1.93% 1 2.63%
william lee irwin iii william lee irwin iii 32 1.93% 2 5.26%
johannes weiner johannes weiner 27 1.63% 1 2.63%
tetsuo handa tetsuo handa 22 1.33% 1 2.63%
mike frysinger mike frysinger 19 1.15% 1 2.63%
kamezawa hiroyuki kamezawa hiroyuki 18 1.09% 1 2.63%
al viro al viro 16 0.97% 4 10.53%
alexey dobriyan alexey dobriyan 12 0.73% 1 2.63%
greg ungerer greg ungerer 11 0.66% 1 2.63%
tejun heo tejun heo 3 0.18% 1 2.63%
kees cook kees cook 3 0.18% 1 2.63%
bryan wu bryan wu 3 0.18% 1 2.63%
andy lutomirski andy lutomirski 2 0.12% 1 2.63%
frederik schwarzer frederik schwarzer 1 0.06% 1 2.63%
miklos szeredi miklos szeredi 1 0.06% 1 2.63%
jan engelhardt jan engelhardt 1 0.06% 1 2.63%
arjan van de ven arjan van de ven 1 0.06% 1 2.63%
nobuhiro iwamatsu nobuhiro iwamatsu 1 0.06% 1 2.63%
Total 1655 100.00% 38 100.00%
Directory: fs/proc

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
	Person	Tokens	Prop	Commits	CommitProp
christoph hellwig	christoph hellwig	234	67.24%	1	12.50%
david howells	david howells	101	29.02%	4	50.00%
eric w. biederman	eric w. biederman	8	2.30%	1	12.50%
greg ungerer	greg ungerer	4	1.15%	1	12.50%
al viro	al viro	1	0.29%	1	12.50%
	Total	348	100.00%	8	100.00%
cregit-Linux how code gets into the kernel

Release 4.10 fs/proc/task_nommu.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
