From: Greg Kroah-Hartman Date: Mon, 18 Nov 2013 16:50:32 +0000 (-0800) Subject: 3.10-stable patches X-Git-Tag: v3.4.70~7 X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=e690ad4d0e99a4aa6390898c1709b4d25a509356;p=thirdparty%2Fkernel%2Fstable-queue.git 3.10-stable patches added patches: perf-fix-perf-ring-buffer-memory-ordering.patch --- diff --git a/queue-3.10/perf-fix-perf-ring-buffer-memory-ordering.patch b/queue-3.10/perf-fix-perf-ring-buffer-memory-ordering.patch new file mode 100644 index 00000000000..12d9379d7a2 --- /dev/null +++ b/queue-3.10/perf-fix-perf-ring-buffer-memory-ordering.patch @@ -0,0 +1,109 @@ +From bf378d341e4873ed928dc3c636252e6895a21f50 Mon Sep 17 00:00:00 2001 +From: Peter Zijlstra +Date: Mon, 28 Oct 2013 13:55:29 +0100 +Subject: perf: Fix perf ring buffer memory ordering + +From: Peter Zijlstra + +commit bf378d341e4873ed928dc3c636252e6895a21f50 upstream. + +The PPC64 people noticed a missing memory barrier and crufty old +comments in the perf ring buffer code. So update all the comments and +add the missing barrier. + +When the architecture implements local_t using atomic_long_t there +will be double barriers issued; but short of introducing more +conditional barrier primitives this is the best we can do. + +Reported-by: Victor Kaplansky +Tested-by: Victor Kaplansky +Signed-off-by: Peter Zijlstra +Cc: Mathieu Desnoyers +Cc: michael@ellerman.id.au +Cc: Paul McKenney +Cc: Michael Neuling +Cc: Frederic Weisbecker +Cc: anton@samba.org +Cc: benh@kernel.crashing.org +Link: http://lkml.kernel.org/r/20131025173749.GG19466@laptop.lan +Signed-off-by: Ingo Molnar +Cc: Michael Neuling +Signed-off-by: Greg Kroah-Hartman + +diff --git a/include/uapi/linux/perf_event.h b/include/uapi/linux/perf_event.h +index 009a655a5d35..2fc1602e23bb 100644 +--- a/include/uapi/linux/perf_event.h ++++ b/include/uapi/linux/perf_event.h +@@ -456,13 +456,15 @@ struct perf_event_mmap_page { + /* + * Control data for the mmap() data buffer. + * +- * User-space reading the @data_head value should issue an rmb(), on +- * SMP capable platforms, after reading this value -- see +- * perf_event_wakeup(). ++ * User-space reading the @data_head value should issue an smp_rmb(), ++ * after reading this value. + * + * When the mapping is PROT_WRITE the @data_tail value should be +- * written by userspace to reflect the last read data. In this case +- * the kernel will not over-write unread data. ++ * written by userspace to reflect the last read data, after issueing ++ * an smp_mb() to separate the data read from the ->data_tail store. ++ * In this case the kernel will not over-write unread data. ++ * ++ * See perf_output_put_handle() for the data ordering. + */ + __u64 data_head; /* head in the data section */ + __u64 data_tail; /* user-space written tail */ +diff --git a/kernel/events/ring_buffer.c b/kernel/events/ring_buffer.c +index cd55144270b5..9c2ddfbf4525 100644 +--- a/kernel/events/ring_buffer.c ++++ b/kernel/events/ring_buffer.c +@@ -87,10 +87,31 @@ again: + goto out; + + /* +- * Publish the known good head. Rely on the full barrier implied +- * by atomic_dec_and_test() order the rb->head read and this +- * write. ++ * Since the mmap() consumer (userspace) can run on a different CPU: ++ * ++ * kernel user ++ * ++ * READ ->data_tail READ ->data_head ++ * smp_mb() (A) smp_rmb() (C) ++ * WRITE $data READ $data ++ * smp_wmb() (B) smp_mb() (D) ++ * STORE ->data_head WRITE ->data_tail ++ * ++ * Where A pairs with D, and B pairs with C. ++ * ++ * I don't think A needs to be a full barrier because we won't in fact ++ * write data until we see the store from userspace. So we simply don't ++ * issue the data WRITE until we observe it. Be conservative for now. ++ * ++ * OTOH, D needs to be a full barrier since it separates the data READ ++ * from the tail WRITE. ++ * ++ * For B a WMB is sufficient since it separates two WRITEs, and for C ++ * an RMB is sufficient since it separates two READs. ++ * ++ * See perf_output_begin(). + */ ++ smp_wmb(); + rb->user_page->data_head = head; + + /* +@@ -154,9 +175,11 @@ int perf_output_begin(struct perf_output_handle *handle, + * Userspace could choose to issue a mb() before updating the + * tail pointer. So that all reads will be completed before the + * write is issued. ++ * ++ * See perf_output_put_handle(). + */ + tail = ACCESS_ONCE(rb->user_page->data_tail); +- smp_rmb(); ++ smp_mb(); + offset = head = local_read(&rb->head); + head += size; + if (unlikely(!perf_output_space(rb, tail, offset, head))) diff --git a/queue-3.10/series b/queue-3.10/series index 52890deffa2..834a37f1bcc 100644 --- a/queue-3.10/series +++ b/queue-3.10/series @@ -13,3 +13,4 @@ hyperv-fb-add-pci-stub.patch usb-add-new-zte-3g-dongle-s-pid-to-option.c.patch alsa-hda-hdmi-fix-reported-channel-map-on-common-default-layouts.patch tracing-fix-potential-out-of-bounds-in-trace_get_user.patch +perf-fix-perf-ring-buffer-memory-ordering.patch