Skip to contentSkip to conversation

Don't truncate /proc/PID/environ at 4096 characters

PATCH In review James Pearson 4 participants 8 messages Sep 19, 2007 – Sep 21, 2007 Proc filesystem

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 Don't truncate /proc/PID/environ at 4096 characters

From: James Pearson <[email protected]>

/proc/PID/environ currently truncates at 4096 characters, patch based on the /proc/PID/mem code.

---
Patch against 2.6.23-rc6-mm1

fs/proc/base.c renamed from fs/proc/base.c.dist +75 -23
@@ -202,27 +202,6 @@ static int proc_root_link(struct inode *
 	 (task->state == TASK_STOPPED || task->state == TASK_TRACED) && \
 	 security_ptrace(current,task) == 0))
 
-static int proc_pid_environ(struct task_struct *task, char * buffer)
-{
-	int res = 0;
-	struct mm_struct *mm = get_task_mm(task);
-	if (mm) {
-		unsigned int len;
-
-		res = -ESRCH;
-		if (!ptrace_may_attach(task))
-			goto out;
-
-		len  = mm->env_end - mm->env_start;
-		if (len > PAGE_SIZE)
-			len = PAGE_SIZE;
-		res = access_process_vm(task, mm->env_start, buffer, len, 0);
-out:
-		mmput(mm);
-	}
-	return res;
-}
-
 static int proc_pid_cmdline(struct task_struct *task, char * buffer)
 {
 	int res = 0;
@@ -740,6 +719,79 @@ static const struct file_operations proc
 	.open		= mem_open,
 };
 
+static ssize_t environ_read(struct file *file, char __user *buf,
+			size_t count, loff_t *ppos)
+{
+	struct task_struct *task = get_proc_task(file->f_dentry->d_inode);
+	char *page;
+	unsigned long src = *ppos;
+	int ret = -ESRCH;
+	struct mm_struct *mm;
+	size_t max_len;
+
+	if (!task)
+		goto out_no_task;
+
+	if (!ptrace_may_attach(task))
+		goto out;
+
+	ret = -ENOMEM;
+	page = (char *)__get_free_page(GFP_TEMPORARY);
+	if (!page)
+		goto out;
+
+	ret = 0;
+
+	mm = get_task_mm(task);
+	if (!mm)
+		goto out_free;
+
+	max_len = (count > PAGE_SIZE) ? PAGE_SIZE : count;
+
+	while (count > 0) {
+		int this_len, retval;
+
+		this_len = mm->env_end - (mm->env_start + src);
+
+		if (this_len <= 0)
+			break;
+
+		if (this_len > max_len)
+			this_len = max_len;
+
+		retval = access_process_vm(task, (mm->env_start + src),
+			page, this_len, 0);
+
+		if (retval <= 0) {
+			ret = retval;
+			break;
+		}
+
+		if (copy_to_user(buf, page, retval)) {
+			ret = -EFAULT;
+			break;
+		}
+
+		ret += retval;
+		src += retval;
+		buf += retval;
+		count -= retval;
+	}
+	*ppos = src;
+
+	mmput(mm);
+out_free:
+	free_page((unsigned long) page);
+out:
+	put_task_struct(task);
+out_no_task:
+	return ret;
+}
+
+static const struct file_operations proc_environ_operations = {
+	.read		= environ_read,
+};
+
 static ssize_t oom_adjust_read(struct file *file, char __user *buf,
 				size_t count, loff_t *ppos)
 {
@@ -2092,7 +2144,7 @@ static const struct pid_entry tgid_base_
 	DIR("task",       S_IRUGO|S_IXUGO, task),
 	DIR("fd",         S_IRUSR|S_IXUSR, fd),
 	DIR("fdinfo",     S_IRUSR|S_IXUSR, fdinfo),
-	INF("environ",    S_IRUSR, pid_environ),
+	REG("environ",    S_IRUSR, environ),
 	INF("auxv",       S_IRUSR, pid_auxv),
 	INF("status",     S_IRUGO, pid_status),
 	INF("limits",	  S_IRUSR, pid_limits),
@@ -2421,7 +2473,7 @@ out_no_task:
 static const struct pid_entry tid_base_stuff[] = {
 	DIR("fd",        S_IRUSR|S_IXUSR, fd),
 	DIR("fdinfo",    S_IRUSR|S_IXUSR, fdinfo),
-	INF("environ",   S_IRUSR, pid_environ),
+	REG("environ",   S_IRUSR, environ),
 	INF("auxv",      S_IRUSR, pid_auxv),
 	INF("status",    S_IRUGO, pid_status),
 	INF("limits",	 S_IRUSR, pid_limits),
#1 lore raw
Quoted 5 lines · On Wed, 19 Sep 2007 14:35:29 +0100 "James Pearson"…

From: James Pearson <[email protected]>

/proc/PID/environ currently truncates at 4096 characters, patch based on the /proc/PID/mem code.

patch needs to be carefully reviewed from the security POV (ie: permissions) as well as for correctness. Does anyone have time to do that?

Quoted 44 lines
fs/proc/base.c renamed from fs/proc/base.c.dist +8 -21
@@ -202,27 +202,6 @@ static int proc_root_link(struct inode *
 	 (task->state == TASK_STOPPED || task->state == TASK_TRACED) && \
 	 security_ptrace(current,task) == 0))
 
-static int proc_pid_environ(struct task_struct *task, char * buffer)
-{
-	int res = 0;
-	struct mm_struct *mm = get_task_mm(task);
-	if (mm) {
-		unsigned int len;
-
-		res = -ESRCH;
-		if (!ptrace_may_attach(task))
-			goto out;
-
-		len  = mm->env_end - mm->env_start;
-		if (len > PAGE_SIZE)
-			len = PAGE_SIZE;
-		res = access_process_vm(task, mm->env_start, buffer, len, 0);
-out:
-		mmput(mm);
-	}
-	return res;
-}
-
 static int proc_pid_cmdline(struct task_struct *task, char * buffer)
 {
 	int res = 0;
@@ -740,6 +719,79 @@ static const struct file_operations proc
 	.open		= mem_open,
 };
 
+static ssize_t environ_read(struct file *file, char __user *buf,
+			size_t count, loff_t *ppos)
+{
+	struct task_struct *task = get_proc_task(file->f_dentry->d_inode);
+	char *page;
+	unsigned long src = *ppos;
+	int ret = -ESRCH;
+	struct mm_struct *mm;

fs/proc/base.c static const struct file_operations proc · line 739

Quoted 10 lines
fs/proc/base.c renamed from fs/proc/base.c.dist +10 -0
+	size_t max_len;
+
+	if (!task)
+		goto out_no_task;
+
+	if (!ptrace_may_attach(task))
+		goto out;
+
+	ret = -ENOMEM;
+	page = (char *)__get_free_page(GFP_TEMPORARY);

Now I wonder what inspired you to reach for GFP_TEMPORARY? Perhaps the fact that it is crappily named and undocumented.

This should be GFP_KERNEL - the page you're allocating here is not reclaimable by the VM.

Quoted 30 lines
fs/proc/base.c renamed from fs/proc/base.c.dist +30 -0
+	if (!page)
+		goto out;
+
+	ret = 0;
+
+	mm = get_task_mm(task);
+	if (!mm)
+		goto out_free;
+
+	max_len = (count > PAGE_SIZE) ? PAGE_SIZE : count;
+
+	while (count > 0) {
+		int this_len, retval;
+
+		this_len = mm->env_end - (mm->env_start + src);
+
+		if (this_len <= 0)
+			break;
+
+		if (this_len > max_len)
+			this_len = max_len;
+
+		retval = access_process_vm(task, (mm->env_start + src),
+			page, this_len, 0);
+
+		if (retval <= 0) {
+			ret = retval;
+			break;
+		}
+

fs/proc/base.c static const struct file_operations proc · line 779

Quoted 10 lines
fs/proc/base.c renamed from fs/proc/base.c.dist +10 -0
+		if (copy_to_user(buf, page, retval)) {
+			ret = -EFAULT;
+			break;
+		}
+
+		ret += retval;
+		src += retval;
+		buf += retval;
+		count -= retval;
+	}

Now that's a funky loop. Someone please convince me that there is no way in which `count - retval' can ever go negative (ie: huge positive).

Quoted 36 lines
fs/proc/base.c renamed from fs/proc/base.c.dist +17 -2
+	*ppos = src;
+
+	mmput(mm);
+out_free:
+	free_page((unsigned long) page);
+out:
+	put_task_struct(task);
+out_no_task:
+	return ret;
+}
+
+static const struct file_operations proc_environ_operations = {
+	.read		= environ_read,
+};
+
 static ssize_t oom_adjust_read(struct file *file, char __user *buf,
 				size_t count, loff_t *ppos)
 {
@@ -2092,7 +2144,7 @@ static const struct pid_entry tgid_base_
 	DIR("task",       S_IRUGO|S_IXUGO, task),
 	DIR("fd",         S_IRUSR|S_IXUSR, fd),
 	DIR("fdinfo",     S_IRUSR|S_IXUSR, fdinfo),
-	INF("environ",    S_IRUSR, pid_environ),
+	REG("environ",    S_IRUSR, environ),
 	INF("auxv",       S_IRUSR, pid_auxv),
 	INF("status",     S_IRUGO, pid_status),
 	INF("limits",	  S_IRUSR, pid_limits),
@@ -2421,7 +2473,7 @@ out_no_task:
 static const struct pid_entry tid_base_stuff[] = {
 	DIR("fd",        S_IRUSR|S_IXUSR, fd),
 	DIR("fdinfo",    S_IRUSR|S_IXUSR, fdinfo),
-	INF("environ",   S_IRUSR, pid_environ),
+	REG("environ",   S_IRUSR, environ),
 	INF("auxv",      S_IRUSR, pid_auxv),
 	INF("status",    S_IRUGO, pid_status),
 	INF("limits",	 S_IRUSR, pid_limits),
#2 lore raw
Quoted 72 lines · Andrew Morton
Quoted 3 lines · On Wed, 19 Sep 2007 14:35:29 +0100 "James Pearson"…

From: James Pearson <[email protected]>

/proc/PID/environ currently truncates at 4096 characters, patch based on the /proc/PID/mem code.

patch needs to be carefully reviewed from the security POV (ie: permissions) as well as for correctness. Does anyone have time to do that?

Quoted 44 lines
fs/proc/base.c renamed from fs/proc/base.c.dist +8 -21
@@ -202,27 +202,6 @@ static int proc_root_link(struct inode *
 	 (task->state == TASK_STOPPED || task->state == TASK_TRACED) && \
 	 security_ptrace(current,task) == 0))
 
-static int proc_pid_environ(struct task_struct *task, char * buffer)
-{
-	int res = 0;
-	struct mm_struct *mm = get_task_mm(task);
-	if (mm) {
-		unsigned int len;
-
-		res = -ESRCH;
-		if (!ptrace_may_attach(task))
-			goto out;
-
-		len  = mm->env_end - mm->env_start;
-		if (len > PAGE_SIZE)
-			len = PAGE_SIZE;
-		res = access_process_vm(task, mm->env_start, buffer, len, 0);
-out:
-		mmput(mm);
-	}
-	return res;
-}
-
 static int proc_pid_cmdline(struct task_struct *task, char * buffer)
 {
 	int res = 0;
@@ -740,6 +719,79 @@ static const struct file_operations proc
 	.open		= mem_open,
 };
 
+static ssize_t environ_read(struct file *file, char __user *buf,
+			size_t count, loff_t *ppos)
+{
+	struct task_struct *task = get_proc_task(file->f_dentry->d_inode);
+	char *page;
+	unsigned long src = *ppos;
+	int ret = -ESRCH;
+	struct mm_struct *mm;

fs/proc/base.c static const struct file_operations proc · line 739

Quoted 10 lines
fs/proc/base.c renamed from fs/proc/base.c.dist +10 -0
+	size_t max_len;
+
+	if (!task)
+		goto out_no_task;
+
+	if (!ptrace_may_attach(task))
+		goto out;
+
+	ret = -ENOMEM;
+	page = (char *)__get_free_page(GFP_TEMPORARY);

Now I wonder what inspired you to reach for GFP_TEMPORARY? Perhaps the fact that it is crappily named and undocumented.

Quoted 2 lines

This should be GFP_KERNEL - the page you're allocating here is not reclaimable by the VM.

The code is based on mem_read() - and that is what mem_read() does in 2.6.23rc6-mm1 - my previous patch for 2.6.23rc5 used GFP_USER, as that is what mem_read() does in 2.6.23rc5.

Quoted 36 lines
Quoted 36 lines
fs/proc/base.c renamed from fs/proc/base.c.dist +36 -0
+	if (!page)
+		goto out;
+
+	ret = 0;
+
+	mm = get_task_mm(task);
+	if (!mm)
+		goto out_free;
+
+	max_len = (count > PAGE_SIZE) ? PAGE_SIZE : count;
+
+	while (count > 0) {
+		int this_len, retval;
+
+		this_len = mm->env_end - (mm->env_start + src);
+
+		if (this_len <= 0)
+			break;
+
+		if (this_len > max_len)
+			this_len = max_len;
+
+		retval = access_process_vm(task, (mm->env_start + src),
+			page, this_len, 0);
+
+		if (retval <= 0) {
+			ret = retval;
+			break;
+		}
+
+		if (copy_to_user(buf, page, retval)) {
+			ret = -EFAULT;
+			break;
+		}
+
+		ret += retval;
Quoted 8 lines

fs/proc/base.c static const struct file_operations proc · line 779

Quoted 4 lines
fs/proc/base.c renamed from fs/proc/base.c.dist +4 -0
+		src += retval;
+		buf += retval;
+		count -= retval;
+	}

Now that's a funky loop. Someone please convince me that there is no way in which `count - retval' can ever go negative (ie: huge positive).

Again, this is exactly the same as in mem_read()

James Pearson

#3 lore raw
In reply to Andrew Morton

On (20/09/07 16:46), Andrew Morton didst pronounce:

Quoted 61 lines
Quoted 5 lines · On Wed, 19 Sep 2007 14:35:29 +0100 "James Pearson"…

From: James Pearson <[email protected]>

/proc/PID/environ currently truncates at 4096 characters, patch based on the /proc/PID/mem code.

patch needs to be carefully reviewed from the security POV (ie: permissions) as well as for correctness. Does anyone have time to do that?

Quoted 49 lines
fs/proc/base.c renamed from fs/proc/base.c.dist +13 -21
@@ -202,27 +202,6 @@ static int proc_root_link(struct inode *
 	 (task->state == TASK_STOPPED || task->state == TASK_TRACED) && \
 	 security_ptrace(current,task) == 0))
 
-static int proc_pid_environ(struct task_struct *task, char * buffer)
-{
-	int res = 0;
-	struct mm_struct *mm = get_task_mm(task);
-	if (mm) {
-		unsigned int len;
-
-		res = -ESRCH;
-		if (!ptrace_may_attach(task))
-			goto out;
-
-		len  = mm->env_end - mm->env_start;
-		if (len > PAGE_SIZE)
-			len = PAGE_SIZE;
-		res = access_process_vm(task, mm->env_start, buffer, len, 0);
-out:
-		mmput(mm);
-	}
-	return res;
-}
-
 static int proc_pid_cmdline(struct task_struct *task, char * buffer)
 {
 	int res = 0;
@@ -740,6 +719,79 @@ static const struct file_operations proc
 	.open		= mem_open,
 };
 
+static ssize_t environ_read(struct file *file, char __user *buf,
+			size_t count, loff_t *ppos)
+{
+	struct task_struct *task = get_proc_task(file->f_dentry->d_inode);
+	char *page;
+	unsigned long src = *ppos;
+	int ret = -ESRCH;
+	struct mm_struct *mm;
+	size_t max_len;
+
+	if (!task)
+		goto out_no_task;
+
Quoted 9 lines

fs/proc/base.c static const struct file_operations proc · line 739

Quoted 5 lines
fs/proc/base.c renamed from fs/proc/base.c.dist +5 -0
+	if (!ptrace_may_attach(task))
+		goto out;
+
+	ret = -ENOMEM;
+	page = (char *)__get_free_page(GFP_TEMPORARY);

Now I wonder what inspired you to reach for GFP_TEMPORARY? Perhaps the fact that it is crappily named and undocumented.

Because it's a very short lived allocation? He allocates it here and frees it at the end of the function again.

Quoted 3 lines

This should be GFP_KERNEL - the page you're allocating here is not reclaimable by the VM.

The patch leader documented how this works although you're right in that the code doesn't explain it adequately. Temporary and short-lived allocations are grouped with kernel-reclaimable pages such as inode and dcache pages intentionally.

Quoted 82 lines
Quoted 30 lines
fs/proc/base.c renamed from fs/proc/base.c.dist +30 -0
+	if (!page)
+		goto out;
+
+	ret = 0;
+
+	mm = get_task_mm(task);
+	if (!mm)
+		goto out_free;
+
+	max_len = (count > PAGE_SIZE) ? PAGE_SIZE : count;
+
+	while (count > 0) {
+		int this_len, retval;
+
+		this_len = mm->env_end - (mm->env_start + src);
+
+		if (this_len <= 0)
+			break;
+
+		if (this_len > max_len)
+			this_len = max_len;
+
+		retval = access_process_vm(task, (mm->env_start + src),
+			page, this_len, 0);
+
+		if (retval <= 0) {
+			ret = retval;
+			break;
+		}
+

fs/proc/base.c static const struct file_operations proc · line 779

Quoted 10 lines
fs/proc/base.c renamed from fs/proc/base.c.dist +10 -0
+		if (copy_to_user(buf, page, retval)) {
+			ret = -EFAULT;
+			break;
+		}
+
+		ret += retval;
+		src += retval;
+		buf += retval;
+		count -= retval;
+	}

Now that's a funky loop. Someone please convince me that there is no way in which `count - retval' can ever go negative (ie: huge positive).

Quoted 36 lines
fs/proc/base.c renamed from fs/proc/base.c.dist +17 -2
+	*ppos = src;
+
+	mmput(mm);
+out_free:
+	free_page((unsigned long) page);
+out:
+	put_task_struct(task);
+out_no_task:
+	return ret;
+}
+
+static const struct file_operations proc_environ_operations = {
+	.read		= environ_read,
+};
+
 static ssize_t oom_adjust_read(struct file *file, char __user *buf,
 				size_t count, loff_t *ppos)
 {
@@ -2092,7 +2144,7 @@ static const struct pid_entry tgid_base_
 	DIR("task",       S_IRUGO|S_IXUGO, task),
 	DIR("fd",         S_IRUSR|S_IXUSR, fd),
 	DIR("fdinfo",     S_IRUSR|S_IXUSR, fdinfo),
-	INF("environ",    S_IRUSR, pid_environ),
+	REG("environ",    S_IRUSR, environ),
 	INF("auxv",       S_IRUSR, pid_auxv),
 	INF("status",     S_IRUGO, pid_status),
 	INF("limits",	  S_IRUSR, pid_limits),
@@ -2421,7 +2473,7 @@ out_no_task:
 static const struct pid_entry tid_base_stuff[] = {
 	DIR("fd",        S_IRUSR|S_IXUSR, fd),
 	DIR("fdinfo",    S_IRUSR|S_IXUSR, fdinfo),
-	INF("environ",   S_IRUSR, pid_environ),
+	REG("environ",   S_IRUSR, environ),
 	INF("auxv",      S_IRUSR, pid_auxv),
 	INF("status",    S_IRUGO, pid_status),
 	INF("limits",	 S_IRUSR, pid_limits),
Signature · 4 lines
-- 
Mel Gorman
Part-time Phd Student                          Linux Technology Center
University of Limerick                         IBM Dublin Software Lab
#4 lore raw
In reply to James Pearson

2007/9/19, James Pearson <[email protected]>:

Quoted 10 lines
fs/proc/base.c renamed from fs/proc/base.c.dist +10 -0
+       while (count > 0) {
+               int this_len, retval;
+
+               this_len = mm->env_end - (mm->env_start + src);
+
+               if (this_len <= 0)
+                       break;
+
+               if (this_len > max_len)
+                       this_len = max_len;

fs/proc/base.c static const struct file_operations proc · line 770

Quoted 10 lines
fs/proc/base.c renamed from fs/proc/base.c.dist +10 -0
+
+               retval = access_process_vm(task, (mm->env_start + src),
+                       page, this_len, 0);
+
+               if (retval <= 0) {
+                       ret = retval;
+                       break;
+               }
+
+               if (copy_to_user(buf, page, retval)) {
                                                                ^^^^

shouldn't you only copy min(count,retval) bytes? otherwise you could write beyond the users buffer "buf", right?

Arvin

#5 lore raw
Quoted 24 lines · Arvin Moezzi

2007/9/19, James Pearson <[email protected]>:

Quoted 10 lines
fs/proc/base.c renamed from fs/proc/base.c.dist +10 -0
+       while (count > 0) {
+               int this_len, retval;
+
+               this_len = mm->env_end - (mm->env_start + src);
+
+               if (this_len <= 0)
+                       break;
+
+               if (this_len > max_len)
+                       this_len = max_len;

fs/proc/base.c static const struct file_operations proc · line 770

Quoted 10 lines
fs/proc/base.c renamed from fs/proc/base.c.dist +10 -0
+
+               retval = access_process_vm(task, (mm->env_start + src),
+                       page, this_len, 0);
+
+               if (retval <= 0) {
+                       ret = retval;
+                       break;
+               }
+
+               if (copy_to_user(buf, page, retval)) {
                                                                ^^^^
Quoted 2 lines

shouldn't you only copy min(count,retval) bytes? otherwise you could write beyond the users buffer "buf", right?

AFAIK, 'retval' can never be greater than 'this_len', which can never be greater than 'max_len', which can never be greater than 'count'

James Pearson

#6 lore raw
Quoted 9 lines
Quoted 6 lines

Review

Quoted 2 lines
(quoted diff) +2 -0
+
+               if (copy_to_user(buf, page, retval)) {
                                                                ^^^^

shouldn't you only copy min(count,retval) bytes? otherwise you could write beyond the users buffer "buf", right?

AFAIK, 'retval' can never be greater than 'this_len', which can never be greater than 'max_len', which can never be greater than 'count'

I think that's not true. 'count' is changing through the iteration. The difference in the mem_read():

* while (count > 0) {
* int this_len, retval;
*
* this_len = (count > PAGE_SIZE) ? PAGE_SIZE : count;
* retval = access_process_vm(task, src, page, this_len, 0);
*
* ...
* }

is the fact, that this_len = min(PAGE_SIZE, count) is in the iteration block, hence retval <= this_len <= count in each iteration step. So this is ok. But IMHO in your code 'retval' may be bigger than 'count' in the last iteration of the block, because 'max_len' is fix through your iteration but 'count' is changing. Or am i missing something?

Quoted 1 line

James Pearson

Arvin

#7 lore raw
Quoted 12 lines · Arvin Moezzi

I think that's not true. 'count' is changing through the iteration. The difference in the mem_read():

* while (count > 0) {
* int this_len, retval;
*
* this_len = (count > PAGE_SIZE) ? PAGE_SIZE : count;
* retval = access_process_vm(task, src, page, this_len, 0);
*
* ...
* }

Quoted 6 lines

is the fact, that this_len = min(PAGE_SIZE, count) is in the iteration block, hence retval <= this_len <= count in each iteration step. So this is ok. But IMHO in your code 'retval' may be bigger than 'count' in the last iteration of the block, because 'max_len' is fix through your iteration but 'count' is changing. Or am i missing something?

Yes, you are correct ...

Thanks

James Pearson