Skip to contentSkip to conversation

perf: fix ring_buffer perf_output_space() boundary calculation

PATCH Superseded Stephane Eranian 2 participants 5 messages Mar 18, 2013 perf events

v1 of 2 Superseded Latest is v2 →

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 perf: fix ring_buffer perf_output_space() boundary calculation

This patch fixes a flaw in perf_output_space(). In case the size of the space needed is bigger than the actual buffer size, there may be situations where the function would return true (i.e., there is space) when it should not. head > offset due to rounding of the masking logic.

The problem can be tested by activating BTS on Intel processors. A BTS record can be as big as 16 pages. The following command fails:

$ perf record -m 4 -c 1 -e branches:u my_test_program

You will get a buffer corruption with this. Perf report won't be able to parse the perf.data.

The fix is to first check that the requested space is smaller than the buffer size. If so, then the masking logic will work fine. If not, then there is no chance the record can be saved and it will be gracefully handled by upper code layers.

This patch also fixes the writable test. If the buffer is not writable, the function should return false because obviously nothing can be written in the buffer.

---

kernel/events/ring_buffer.c +10 -3
index 23cb34f..73147b9 100644
@@ -18,12 +18,19 @@
 static bool perf_output_space(struct ring_buffer *rb, unsigned long tail,
 			      unsigned long offset, unsigned long head)
 {
-	unsigned long mask;
+	unsigned long sz = perf_data_size(rb);
+	unsigned long mask = sz - 1;
 
 	if (!rb->writable)
-		return true;
+		return false;
 
-	mask = perf_data_size(rb) - 1;
+	/*
+	 * verify that payload is not bigger than buffer
+	 * otherwise masking logic may fail to detect
+	 * the "not enough space" condition
+	 */
+	if ((head - offset) > sz)
+		return false;
 
 	offset = (offset - tail) & mask;
 	head   = (head   - tail) & mask;
maintainer
#1 lore raw

Review

Quoted 3 lines · Stephane Eranian
        if (!rb->writable)
(quoted diff) +1 -1
-               return true;
+               return false;

writable means user writable (VM_WRITE); the difference is that a !VM_WRITE buffer will simply over-write its own tail whereas a VM_WRITE buffer will drop events.

So returning true for !VM_WRITE makes sense, there's always space.

#2 lore raw
Quoted 6 lines · Peter Zijlstra

Review

Quoted 3 lines · Stephane Eranian
        if (!rb->writable)
(quoted diff) +1 -1
-               return true;
+               return false;
Quoted 6 lines

writable means user writable (VM_WRITE); the difference is that a !VM_WRITE buffer will simply over-write its own tail whereas a VM_WRITE buffer will drop events.

So returning true for !VM_WRITE makes sense, there's always space.

Ok, that was not so clear to me. I think this if() statment deserves a comment. I will add that in V2.

maintainer
#3 lore raw
Quoted 7 lines · Stephane Eranian
Quoted 6 lines · Peter Zijlstra
Quoted 3 lines · Stephane Eranian
        if (!rb->writable)
(quoted diff) +1 -1
-               return true;
+               return false;
Quoted 8 lines
Quoted 6 lines

writable means user writable (VM_WRITE); the difference is that a !VM_WRITE buffer will simply over-write its own tail whereas a VM_WRITE buffer will drop events.

So returning true for !VM_WRITE makes sense, there's always space.

Ok, that was not so clear to me. I think this if() statment deserves a comment. I will add that in V2.

Thanks; I suppose renaming the entire ->writable thing might be better though. Something like ->overwrite or so.

#4 lore raw
Quoted 12 lines · Peter Zijlstra
Quoted 11 lines · Stephane Eranian
Quoted 10 lines · Peter Zijlstra

Review

Quoted 3 lines · Stephane Eranian
        if (!rb->writable)
(quoted diff) +1 -1
-               return true;
+               return false;

writable means user writable (VM_WRITE); the difference is that a !VM_WRITE buffer will simply over-write its own tail whereas a VM_WRITE buffer will drop events.

Quoted 8 lines
Quoted 4 lines
Quoted 2 lines

So returning true for !VM_WRITE makes sense, there's always space.

Ok, that was not so clear to me. I think this if() statment deserves a comment. I will add that in V2.

Thanks; I suppose renaming the entire ->writable thing might be better though. Something like ->overwrite or so.

Yes. And if you do this you invert the logic of the field. overwrite=1 -> !VM_WRITE
overwrite=0 -> VM_WRITE