Skip to contentSkip to conversation

cpuset: zero malloc - fix for old cpusets

PATCH New Paul Jackson 1 participant 3 messages Jun 9, 2007

lore
Share & tools
lore
#0 lore raw

PATCH 1/3 cpuset: zero malloc - fix for old cpusets

From: Paul Jackson <[email protected]>

First of three -- this one goes before the container patches, and should be sent to Linus for 2.6.22.

The cpuset code to present a list of tasks using a cpuset to user space could write to an array that it had kmalloc'd, after a kmalloc request of zero size.

The problem was that the code didn't check for writes past the allocated end of the array until -after- the first write.

This is a race condition that is likely rare -- it would only show up if a cpuset went from being empty to having a task in it, during the brief time between the allocation and the first write.

Prior to roughly 2.6.22 kernels, this was also a benign problem, because a zero kmalloc returned a few usable bytes anyway, and no harm was done with the bogus write.

With the 2.6.22 kernel changes to make issue a warning if code tries to write to the location returned from a zero size allocation, this problem is no longer benign. This cpuset code would occassionally trigger that warning.

The fix is trivial -- check before storing into the array, not after, whether the array is big enough to hold the store.

Cc "Eric W. Biederman" <[email protected]>
Cc "Serge E. Hallyn" <[email protected]>
Cc Balbir Singh <[email protected]>
Cc Dave Hansen <[email protected]>
Cc Herbert Poetzl <[email protected]>
Cc Kirill Korotaev <[email protected]>
Cc Paul Menage <[email protected]>
Cc Srivatsa Vaddagiri <[email protected]>
Cc Christoph Lameter <[email protected]>

---

Andrew - this fix collides with the container changes, and now that you have sent Christoph's patch to Linus to warn on writes to zero-sized allocations, this fix should go to Linus too.

So it comes in three parts: fix the old, undo that, fix the new.

This patch should be applied first, before the container patches, and sent to Linus for 2.6.22.

 kernel/cpuset.c |    2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
kernel/cpuset.c +1 -1
@@ -1620,9 +1620,9 @@ static int pid_array_load(pid_t *pidarra
 
 	do_each_thread(g, p) {
 		if (p->cpuset == cs) {
-			pidarray[n++] = p->pid;
 			if (unlikely(n == npids))
 				goto array_full;
+			pidarray[n++] = p->pid;
 		}
 	} while_each_thread(g, p);
 
Signature · 3 lines
                          I won't rest till it's the best ...
                          Programmer, Linux Scalability
                          Paul Jackson <[email protected]> 1.650.933.1373
#1 lore raw

PATCH 2/3 cpuset: zero malloc - revert the old cpuset fix

From: Paul Jackson <[email protected]>

Second of three -- This one undoes the first one. Apply before the container patch that changes cpusets to use containers, in order to avoid a patch conflict.

The cpuset code to present a list of tasks using a cpuset to user space could write to an array that it had kmalloc'd, after a kmalloc request of zero size.

The problem was that the code didn't check for writes past the allocated end of the array until -after- the first write.

This is a race condition that is likely rare -- it would only show up if a cpuset went from being empty to having a task in it, during the brief time between the allocation and the first write.

Prior to roughly 2.6.22 kernels, this was also a benign problem, because a zero kmalloc returned a few usable bytes anyway, and no harm was done with the bogus write.

With the 2.6.22 kernel changes to make issue a warning if code tries to write to the location returned from a zero size allocation, this problem is no longer benign. This cpuset code would occassionally trigger that warning.

The fix is trivial -- check before storing into the array, not after, whether the array is big enough to hold the store.

Cc "Eric W. Biederman" <[email protected]>
Cc "Serge E. Hallyn" <[email protected]>
Cc Balbir Singh <[email protected]>
Cc Dave Hansen <[email protected]>
Cc Herbert Poetzl <[email protected]>
Cc Kirill Korotaev <[email protected]>
Cc Paul Menage <[email protected]>
Cc Srivatsa Vaddagiri <[email protected]>
Cc Christoph Lameter <[email protected]>

---

Andrew,

This is the second of three in the set - it reverses the first one, to avoid colliding with the container patches.

Apply somewhere before, or entirely merge into:
containersv10-share-css_group-arrays-between-tasks-with-same-container-memberships.patch

 kernel/cpuset.c |    2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
kernel/cpuset.c +1 -1
@@ -1620,9 +1620,9 @@ static int pid_array_load(pid_t *pidarra
 
 	do_each_thread(g, p) {
 		if (p->cpuset == cs) {
+			pidarray[n++] = p->pid;
 			if (unlikely(n == npids))
 				goto array_full;
-			pidarray[n++] = p->pid;
 		}
 	} while_each_thread(g, p);
 
Signature · 3 lines
                          I won't rest till it's the best ...
                          Programmer, Linux Scalability
                          Paul Jackson <[email protected]> 1.650.933.1373
#2 lore raw

PATCH 3/3 cpuset: zero malloc - fix for new containers

In reply to Paul Jackson

From: Paul Jackson <[email protected]>

Third of three -- This applies after the container patches, fixing a problem that earlier patches also fixed in the older cpuset code.

The container code to present a list of tasks using a container to user space could write to an array that it had kmalloc'd, after a kmalloc request of zero size.

The problem was that the code didn't check for writes past the allocated end of the array until -after- the first write.

This is a race condition that is likely rare -- it would only show up if a container went from being empty to having a task in it, during the brief time between the allocation and the first write.

Prior to roughly 2.6.22 kernels, this was also a benign problem, because a zero kmalloc returned a few usable bytes anyway, and no harm was done with the bogus write.

With the 2.6.22 kernel changes to make issue a warning if code tries to write to the location returned from a zero size allocation, this problem is no longer benign. This container code would occassionally trigger that warning.

The fix is trivial -- check before storing into the array, not after, whether the array is big enough to hold the store.

Cc "Eric W. Biederman" <[email protected]>
Cc "Serge E. Hallyn" <[email protected]>
Cc Balbir Singh <[email protected]>
Cc Dave Hansen <[email protected]>
Cc Herbert Poetzl <[email protected]>
Cc Kirill Korotaev <[email protected]>
Cc Paul Menage <[email protected]>
Cc Srivatsa Vaddagiri <[email protected]>
Cc Christoph Lameter <[email protected]>

---

Andrew - this is the third of three similar patches. This one redoes the fix for the container code.

Please apply somewhere after:
containersv10-share-css_group-arrays-between-tasks-with-same-container-memberships.patch

 kernel/container.c |    2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
kernel/container.c +1 -1
@@ -1451,9 +1451,9 @@ static int pid_array_load(pid_t *pidarra
 	struct task_struct *tsk;
 	container_iter_start(cont, &it);
 	while ((tsk = container_iter_next(cont, &it))) {
-		pidarray[n++] = pid_nr(task_pid(tsk));
 		if (unlikely(n == npids))
 			break;
+		pidarray[n++] = pid_nr(task_pid(tsk));
 	}
 	container_iter_end(cont, &it);
 	return n;
Signature · 3 lines
                          I won't rest till it's the best ...
                          Programmer, Linux Scalability
                          Paul Jackson <[email protected]> 1.650.933.1373