]> git.pld-linux.org Git - packages/lttng-modules.git/blame - kernel-4.15-atomics.patch
projects / packages / lttng-modules.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
- upstream fixes for kernel 4.15
[packages/lttng-modules.git] / kernel-4.15-atomics.patch
CommitLineData
9fd83755
JR		 1From a8f2d0c75c9cc179fc9e7f7ca17ea3b3b3b5af41 Mon Sep 17 00:00:00 2001
2From: Michael Jeanson <mjeanson@efficios.com>
3Date: Tue, 19 Dec 2017 15:06:42 -0500
4Subject: [PATCH] Fix: ACCESS_ONCE() removed in kernel 4.15
5
6The ACCESS_ONCE() macro was removed in kernel 4.15 and should be
7replaced by READ_ONCE and WRITE_ONCE which were introduced in kernel
83.19.
9
10This commit replaces all calls to ACCESS_ONCE() with the appropriate
11READ_ONCE or WRITE_ONCE and adds compatibility macros for kernels that
12have them.
13
14See this upstream commit:
15
16 commit b03a0fe0c5e4b46dcd400d27395b124499554a71
17 Author: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
18 Date: Mon Oct 23 14:07:25 2017 -0700
19
20 locking/atomics, mm: Convert ACCESS_ONCE() to READ_ONCE()/WRITE_ONCE()
21
22 For several reasons, it is desirable to use {READ,WRITE}_ONCE() in
23 preference to ACCESS_ONCE(), and new code is expected to use one of the
24 former. So far, there's been no reason to change most existing uses of
25 ACCESS_ONCE(), as these aren't currently harmful.
26
27 However, for some features it is necessary to instrument reads and
28 writes separately, which is not possible with ACCESS_ONCE(). This
29 distinction is critical to correct operation.
30
31 It's possible to transform the bulk of kernel code using the Coccinelle
32 script below. However, this doesn't handle comments, leaving references
33 to ACCESS_ONCE() instances which have been removed. As a preparatory
34 step, this patch converts the mm code and comments to use
35 {READ,WRITE}_ONCE() consistently.
36
37 ----
38 virtual patch
39
40 @ depends on patch @
41 expression E1, E2;
42 @@
43
44 - ACCESS_ONCE(E1) = E2
45 + WRITE_ONCE(E1, E2)
46
47 @ depends on patch @
48 expression E;
49 @@
50
51 - ACCESS_ONCE(E)
52 + READ_ONCE(E)
53 ----
54
55Signed-off-by: Michael Jeanson <mjeanson@efficios.com>
56Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
57---
58 instrumentation/events/lttng-module/i2c.h | 4 ++--
59 lib/ringbuffer/backend.h | 2 +-
60 lib/ringbuffer/backend_internal.h | 7 ++++---
61 lib/ringbuffer/frontend.h | 2 +-
62 lib/ringbuffer/ring_buffer_frontend.c | 10 +++++-----
63 lib/ringbuffer/ring_buffer_iterator.c | 2 +-
64 lttng-clock.c | 6 +++---
65 lttng-events.c | 30 +++++++++++++++---------------
66 probes/lttng-ftrace.c | 12 ++++++------
67 probes/lttng-kprobes.c | 6 +++---
68 probes/lttng-kretprobes.c | 10 +++++-----
69 probes/lttng-tracepoint-event-impl.h | 12 ++++++------
70 wrapper/compiler.h | 13 +++++++++++++
71 wrapper/trace-clock.h | 11 ++++++-----
72 14 files changed, 71 insertions(+), 56 deletions(-)
73
74diff --git a/instrumentation/events/lttng-module/i2c.h b/instrumentation/events/lttng-module/i2c.h
75index 4088b60..dd91c9b 100644
76--- a/instrumentation/events/lttng-module/i2c.h
77+++ b/instrumentation/events/lttng-module/i2c.h
78@@ -22,7 +22,7 @@ LTTNG_TRACEPOINT_EVENT_CODE(i2c_write,
79
80 TP_code_pre(
81 tp_locvar->extract_sensitive_payload =
82- ACCESS_ONCE(extract_sensitive_payload);
83+ READ_ONCE(extract_sensitive_payload);
84 ),
85
86 TP_FIELDS(
87@@ -77,7 +77,7 @@ LTTNG_TRACEPOINT_EVENT_CODE(i2c_reply,
88
89 TP_code_pre(
90 tp_locvar->extract_sensitive_payload =
91- ACCESS_ONCE(extract_sensitive_payload);
92+ READ_ONCE(extract_sensitive_payload);
93 ),
94
95 TP_FIELDS(
96diff --git a/lib/ringbuffer/backend.h b/lib/ringbuffer/backend.h
97index 9db0095..0b75de8 100644
98--- a/lib/ringbuffer/backend.h
99+++ b/lib/ringbuffer/backend.h
100@@ -169,7 +169,7 @@ size_t lib_ring_buffer_do_strcpy(const struct lib_ring_buffer_config *config,
101 * Only read source character once, in case it is
102 * modified concurrently.
103 */
104- c = ACCESS_ONCE(src[count]);
105+ c = READ_ONCE(src[count]);
106 if (!c)
107 break;
108 lib_ring_buffer_do_copy(config, &dest[count], &c, 1);
109diff --git a/lib/ringbuffer/backend_internal.h b/lib/ringbuffer/backend_internal.h
110index 2e59b68..dc69ecf 100644
111--- a/lib/ringbuffer/backend_internal.h
112+++ b/lib/ringbuffer/backend_internal.h
113@@ -23,6 +23,7 @@
114 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
115 */
116
117+#include <wrapper/compiler.h>
118 #include <wrapper/ringbuffer/config.h>
119 #include <wrapper/ringbuffer/backend_types.h>
120 #include <wrapper/ringbuffer/frontend_types.h>
121@@ -171,7 +172,7 @@ void subbuffer_id_set_noref_offset(const struct lib_ring_buffer_config *config,
122 tmp |= offset << SB_ID_OFFSET_SHIFT;
123 tmp |= SB_ID_NOREF_MASK;
124 /* Volatile store, read concurrently by readers. */
125- ACCESS_ONCE(*id) = tmp;
126+ WRITE_ONCE(*id, tmp);
127 }
128 }
129
130@@ -379,7 +380,7 @@ void lib_ring_buffer_clear_noref(const struct lib_ring_buffer_config *config,
131 * Performing a volatile access to read the sb_pages, because we want to
132 * read a coherent version of the pointer and the associated noref flag.
133 */
134- id = ACCESS_ONCE(bufb->buf_wsb[idx].id);
135+ id = READ_ONCE(bufb->buf_wsb[idx].id);
136 for (;;) {
137 /* This check is called on the fast path for each record. */
138 if (likely(!subbuffer_id_is_noref(config, id))) {
139@@ -448,7 +449,7 @@ int update_read_sb_index(const struct lib_ring_buffer_config *config,
140 if (config->mode == RING_BUFFER_OVERWRITE) {
141 /*
142 * Exchange the target writer subbuffer with our own unused
143- * subbuffer. No need to use ACCESS_ONCE() here to read the
144+ * subbuffer. No need to use READ_ONCE() here to read the
145 * old_wpage, because the value read will be confirmed by the
146 * following cmpxchg().
147 */
148diff --git a/lib/ringbuffer/frontend.h b/lib/ringbuffer/frontend.h
149index 909abc2..1450cb7 100644
150--- a/lib/ringbuffer/frontend.h
151+++ b/lib/ringbuffer/frontend.h
152@@ -168,7 +168,7 @@ static inline
153 int lib_ring_buffer_is_finalized(const struct lib_ring_buffer_config *config,
154 struct lib_ring_buffer *buf)
155 {
156- int finalized = ACCESS_ONCE(buf->finalized);
157+ int finalized = READ_ONCE(buf->finalized);
158 /*
159 * Read finalized before counters.
160 */
161diff --git a/lib/ringbuffer/ring_buffer_frontend.c b/lib/ringbuffer/ring_buffer_frontend.c
162index abd9757..0d8279b 100644
163--- a/lib/ringbuffer/ring_buffer_frontend.c
164+++ b/lib/ringbuffer/ring_buffer_frontend.c
165@@ -983,7 +983,7 @@ void *channel_destroy(struct channel *chan)
166 * Perform flush before writing to finalized.
167 */
168 smp_wmb();
169- ACCESS_ONCE(buf->finalized) = 1;
170+ WRITE_ONCE(buf->finalized, 1);
171 wake_up_interruptible(&buf->read_wait);
172 }
173 } else {
174@@ -997,10 +997,10 @@ void *channel_destroy(struct channel *chan)
175 * Perform flush before writing to finalized.
176 */
177 smp_wmb();
178- ACCESS_ONCE(buf->finalized) = 1;
179+ WRITE_ONCE(buf->finalized, 1);
180 wake_up_interruptible(&buf->read_wait);
181 }
182- ACCESS_ONCE(chan->finalized) = 1;
183+ WRITE_ONCE(chan->finalized, 1);
184 wake_up_interruptible(&chan->hp_wait);
185 wake_up_interruptible(&chan->read_wait);
186 priv = chan->backend.priv;
187@@ -1077,7 +1077,7 @@ int lib_ring_buffer_snapshot(struct lib_ring_buffer *buf,
188 int finalized;
189
190 retry:
191- finalized = ACCESS_ONCE(buf->finalized);
192+ finalized = READ_ONCE(buf->finalized);
193 /*
194 * Read finalized before counters.
195 */
196@@ -1248,7 +1248,7 @@ int lib_ring_buffer_get_subbuf(struct lib_ring_buffer *buf,
197 return -EBUSY;
198 }
199 retry:
200- finalized = ACCESS_ONCE(buf->finalized);
201+ finalized = READ_ONCE(buf->finalized);
202 /*
203 * Read finalized before counters.
204 */
205diff --git a/lib/ringbuffer/ring_buffer_iterator.c b/lib/ringbuffer/ring_buffer_iterator.c
206index b6bec48..61eaa5b 100644
207--- a/lib/ringbuffer/ring_buffer_iterator.c
208+++ b/lib/ringbuffer/ring_buffer_iterator.c
209@@ -61,7 +61,7 @@ ssize_t lib_ring_buffer_get_next_record(struct channel *chan,
210 switch (iter->state) {
211 case ITER_GET_SUBBUF:
212 ret = lib_ring_buffer_get_next_subbuf(buf);
213- if (ret && !ACCESS_ONCE(buf->finalized)
214+ if (ret && !READ_ONCE(buf->finalized)
215 && config->alloc == RING_BUFFER_ALLOC_GLOBAL) {
216 /*
217 * Use "pull" scheme for global buffers. The reader
218diff --git a/lttng-clock.c b/lttng-clock.c
219index a5a7eaa..48b4be5 100644
220--- a/lttng-clock.c
221+++ b/lttng-clock.c
222@@ -48,7 +48,7 @@ int lttng_clock_register_plugin(struct lttng_trace_clock *ltc,
223 goto end;
224 }
225 /* set clock */
226- ACCESS_ONCE(lttng_trace_clock) = ltc;
227+ WRITE_ONCE(lttng_trace_clock, ltc);
228 lttng_trace_clock_mod = mod;
229 end:
230 mutex_unlock(&clock_mutex);
231@@ -66,7 +66,7 @@ void lttng_clock_unregister_plugin(struct lttng_trace_clock *ltc,
232 }
233 WARN_ON_ONCE(lttng_trace_clock_mod != mod);
234
235- ACCESS_ONCE(lttng_trace_clock) = NULL;
236+ WRITE_ONCE(lttng_trace_clock, NULL);
237 lttng_trace_clock_mod = NULL;
238 end:
239 mutex_unlock(&clock_mutex);
240@@ -83,7 +83,7 @@ void lttng_clock_ref(void)
241 ret = try_module_get(lttng_trace_clock_mod);
242 if (!ret) {
243 printk(KERN_ERR "LTTng-clock cannot get clock plugin module\n");
244- ACCESS_ONCE(lttng_trace_clock) = NULL;
245+ WRITE_ONCE(lttng_trace_clock, NULL);
246 lttng_trace_clock_mod = NULL;
247 }
248 }
249diff --git a/lttng-events.c b/lttng-events.c
250index 21c4113..75c3fb1 100644
251--- a/lttng-events.c
252+++ b/lttng-events.c
253@@ -186,7 +186,7 @@ void lttng_session_destroy(struct lttng_session *session)
254 int ret;
255
256 mutex_lock(&sessions_mutex);
257- ACCESS_ONCE(session->active) = 0;
258+ WRITE_ONCE(session->active, 0);
259 list_for_each_entry(chan, &session->chan, list) {
260 ret = lttng_syscalls_unregister(chan);
261 WARN_ON(ret);
262@@ -261,16 +261,16 @@ int lttng_session_enable(struct lttng_session *session)
263 lib_ring_buffer_clear_quiescent_channel(chan->chan);
264 }
265
266- ACCESS_ONCE(session->active) = 1;
267- ACCESS_ONCE(session->been_active) = 1;
268+ WRITE_ONCE(session->active, 1);
269+ WRITE_ONCE(session->been_active, 1);
270 ret = _lttng_session_metadata_statedump(session);
271 if (ret) {
272- ACCESS_ONCE(session->active) = 0;
273+ WRITE_ONCE(session->active, 0);
274 goto end;
275 }
276 ret = lttng_statedump_start(session);
277 if (ret)
278- ACCESS_ONCE(session->active) = 0;
279+ WRITE_ONCE(session->active, 0);
280 end:
281 mutex_unlock(&sessions_mutex);
282 return ret;
283@@ -286,7 +286,7 @@ int lttng_session_disable(struct lttng_session *session)
284 ret = -EBUSY;
285 goto end;
286 }
287- ACCESS_ONCE(session->active) = 0;
288+ WRITE_ONCE(session->active, 0);
289
290 /* Set transient enabler state to "disabled" */
291 session->tstate = 0;
292@@ -361,7 +361,7 @@ int lttng_channel_enable(struct lttng_channel *channel)
293 channel->tstate = 1;
294 lttng_session_sync_enablers(channel->session);
295 /* Set atomically the state to "enabled" */
296- ACCESS_ONCE(channel->enabled) = 1;
297+ WRITE_ONCE(channel->enabled, 1);
298 end:
299 mutex_unlock(&sessions_mutex);
300 return ret;
301@@ -381,7 +381,7 @@ int lttng_channel_disable(struct lttng_channel *channel)
302 goto end;
303 }
304 /* Set atomically the state to "disabled" */
305- ACCESS_ONCE(channel->enabled) = 0;
306+ WRITE_ONCE(channel->enabled, 0);
307 /* Set transient enabler state to "enabled" */
308 channel->tstate = 0;
309 lttng_session_sync_enablers(channel->session);
310@@ -411,7 +411,7 @@ int lttng_event_enable(struct lttng_event *event)
311 case LTTNG_KERNEL_KPROBE:
312 case LTTNG_KERNEL_FUNCTION:
313 case LTTNG_KERNEL_NOOP:
314- ACCESS_ONCE(event->enabled) = 1;
315+ WRITE_ONCE(event->enabled, 1);
316 break;
317 case LTTNG_KERNEL_KRETPROBE:
318 ret = lttng_kretprobes_event_enable_state(event, 1);
319@@ -446,7 +446,7 @@ int lttng_event_disable(struct lttng_event *event)
320 case LTTNG_KERNEL_KPROBE:
321 case LTTNG_KERNEL_FUNCTION:
322 case LTTNG_KERNEL_NOOP:
323- ACCESS_ONCE(event->enabled) = 0;
324+ WRITE_ONCE(event->enabled, 0);
325 break;
326 case LTTNG_KERNEL_KRETPROBE:
327 ret = lttng_kretprobes_event_enable_state(event, 0);
328@@ -1517,7 +1517,7 @@ void lttng_session_sync_enablers(struct lttng_session *session)
329 */
330 enabled = enabled && session->tstate && event->chan->tstate;
331
332- ACCESS_ONCE(event->enabled) = enabled;
333+ WRITE_ONCE(event->enabled, enabled);
334 /*
335 * Sync tracepoint registration with event enabled
336 * state.
337@@ -1643,7 +1643,7 @@ int lttng_metadata_printf(struct lttng_session *session,
338 va_list ap;
339 struct lttng_metadata_stream *stream;
340
341- WARN_ON_ONCE(!ACCESS_ONCE(session->active));
342+ WARN_ON_ONCE(!READ_ONCE(session->active));
343
344 va_start(ap, fmt);
345 str = kvasprintf(GFP_KERNEL, fmt, ap);
346@@ -2230,7 +2230,7 @@ int _lttng_event_metadata_statedump(struct lttng_session *session,
347 {
348 int ret = 0;
349
350- if (event->metadata_dumped || !ACCESS_ONCE(session->active))
351+ if (event->metadata_dumped || !READ_ONCE(session->active))
352 return 0;
353 if (chan->channel_type == METADATA_CHANNEL)
354 return 0;
355@@ -2297,7 +2297,7 @@ int _lttng_channel_metadata_statedump(struct lttng_session *session,
356 {
357 int ret = 0;
358
359- if (chan->metadata_dumped || !ACCESS_ONCE(session->active))
360+ if (chan->metadata_dumped || !READ_ONCE(session->active))
361 return 0;
362
363 if (chan->channel_type == METADATA_CHANNEL)
364@@ -2454,7 +2454,7 @@ int _lttng_session_metadata_statedump(struct lttng_session *session)
365 struct lttng_event *event;
366 int ret = 0;
367
368- if (!ACCESS_ONCE(session->active))
369+ if (!READ_ONCE(session->active))
370 return 0;
371 if (session->metadata_dumped)
372 goto skip_session;
373diff --git a/probes/lttng-ftrace.c b/probes/lttng-ftrace.c
374index 9ec326e..50675a4 100644
375--- a/probes/lttng-ftrace.c
376+++ b/probes/lttng-ftrace.c
377@@ -58,11 +58,11 @@ void lttng_ftrace_handler(unsigned long ip, unsigned long parent_ip,
378 } payload;
379 int ret;
380
381- if (unlikely(!ACCESS_ONCE(chan->session->active)))
382+ if (unlikely(!READ_ONCE(chan->session->active)))
383 return;
384- if (unlikely(!ACCESS_ONCE(chan->enabled)))
385+ if (unlikely(!READ_ONCE(chan->enabled)))
386 return;
387- if (unlikely(!ACCESS_ONCE(event->enabled)))
388+ if (unlikely(!READ_ONCE(event->enabled)))
389 return;
390
391 lib_ring_buffer_ctx_init(&ctx, chan->chan, &lttng_probe_ctx,
392@@ -94,11 +94,11 @@ void lttng_ftrace_handler(unsigned long ip, unsigned long parent_ip, void **data
393 } payload;
394 int ret;
395
396- if (unlikely(!ACCESS_ONCE(chan->session->active)))
397+ if (unlikely(!READ_ONCE(chan->session->active)))
398 return;
399- if (unlikely(!ACCESS_ONCE(chan->enabled)))
400+ if (unlikely(!READ_ONCE(chan->enabled)))
401 return;
402- if (unlikely(!ACCESS_ONCE(event->enabled)))
403+ if (unlikely(!READ_ONCE(event->enabled)))
404 return;
405
406 lib_ring_buffer_ctx_init(&ctx, chan->chan, &lttng_probe_ctx,
407diff --git a/probes/lttng-kprobes.c b/probes/lttng-kprobes.c
408index daf14ce..b58a09b 100644
409--- a/probes/lttng-kprobes.c
410+++ b/probes/lttng-kprobes.c
411@@ -43,11 +43,11 @@ int lttng_kprobes_handler_pre(struct kprobe *p, struct pt_regs *regs)
412 int ret;
413 unsigned long data = (unsigned long) p->addr;
414
415- if (unlikely(!ACCESS_ONCE(chan->session->active)))
416+ if (unlikely(!READ_ONCE(chan->session->active)))
417 return 0;
418- if (unlikely(!ACCESS_ONCE(chan->enabled)))
419+ if (unlikely(!READ_ONCE(chan->enabled)))
420 return 0;
421- if (unlikely(!ACCESS_ONCE(event->enabled)))
422+ if (unlikely(!READ_ONCE(event->enabled)))
423 return 0;
424
425 lib_ring_buffer_ctx_init(&ctx, chan->chan, &lttng_probe_ctx, sizeof(data),
426diff --git a/probes/lttng-kretprobes.c b/probes/lttng-kretprobes.c
427index 498df62..49b7de8 100644
428--- a/probes/lttng-kretprobes.c
429+++ b/probes/lttng-kretprobes.c
430@@ -63,11 +63,11 @@ int _lttng_kretprobes_handler(struct kretprobe_instance *krpi,
431 unsigned long parent_ip;
432 } payload;
433
434- if (unlikely(!ACCESS_ONCE(chan->session->active)))
435+ if (unlikely(!READ_ONCE(chan->session->active)))
436 return 0;
437- if (unlikely(!ACCESS_ONCE(chan->enabled)))
438+ if (unlikely(!READ_ONCE(chan->enabled)))
439 return 0;
440- if (unlikely(!ACCESS_ONCE(event->enabled)))
441+ if (unlikely(!READ_ONCE(event->enabled)))
442 return 0;
443
444 payload.ip = (unsigned long) krpi->rp->kp.addr;
445@@ -304,8 +304,8 @@ int lttng_kretprobes_event_enable_state(struct lttng_event *event,
446 }
447 lttng_krp = event->u.kretprobe.lttng_krp;
448 event_return = lttng_krp->event[EVENT_RETURN];
449- ACCESS_ONCE(event->enabled) = enable;
450- ACCESS_ONCE(event_return->enabled) = enable;
451+ WRITE_ONCE(event->enabled, enable);
452+ WRITE_ONCE(event_return->enabled, enable);
453 return 0;
454 }
455 EXPORT_SYMBOL_GPL(lttng_kretprobes_event_enable_state);
456diff --git a/probes/lttng-tracepoint-event-impl.h b/probes/lttng-tracepoint-event-impl.h
457index 7ec0d75..61f1c2d 100644
458--- a/probes/lttng-tracepoint-event-impl.h
459+++ b/probes/lttng-tracepoint-event-impl.h
460@@ -1143,11 +1143,11 @@ static void __event_probe__##_name(void *__data, _proto) \
461 \
462 if (!_TP_SESSION_CHECK(session, __session)) \
463 return; \
464- if (unlikely(!ACCESS_ONCE(__session->active))) \
465+ if (unlikely(!READ_ONCE(__session->active))) \
466 return; \
467- if (unlikely(!ACCESS_ONCE(__chan->enabled))) \
468+ if (unlikely(!READ_ONCE(__chan->enabled))) \
469 return; \
470- if (unlikely(!ACCESS_ONCE(__event->enabled))) \
471+ if (unlikely(!READ_ONCE(__event->enabled))) \
472 return; \
473 __lpf = lttng_rcu_dereference(__session->pid_tracker); \
474 if (__lpf && likely(!lttng_pid_tracker_lookup(__lpf, current->tgid))) \
475@@ -1217,11 +1217,11 @@ static void __event_probe__##_name(void *__data) \
476 \
477 if (!_TP_SESSION_CHECK(session, __session)) \
478 return; \
479- if (unlikely(!ACCESS_ONCE(__session->active))) \
480+ if (unlikely(!READ_ONCE(__session->active))) \
481 return; \
482- if (unlikely(!ACCESS_ONCE(__chan->enabled))) \
483+ if (unlikely(!READ_ONCE(__chan->enabled))) \
484 return; \
485- if (unlikely(!ACCESS_ONCE(__event->enabled))) \
486+ if (unlikely(!READ_ONCE(__event->enabled))) \
487 return; \
488 __lpf = lttng_rcu_dereference(__session->pid_tracker); \
489 if (__lpf && likely(!lttng_pid_tracker_lookup(__lpf, current->pid))) \
490diff --git a/wrapper/compiler.h b/wrapper/compiler.h
491index 0c01632..e4533d4 100644
492--- a/wrapper/compiler.h
493+++ b/wrapper/compiler.h
494@@ -39,4 +39,17 @@
495 # endif
496 #endif
497
498+/*
499+ * READ/WRITE_ONCE were introduced in kernel 3.19 and ACCESS_ONCE
500+ * was removed in 4.15. Prefer READ/WRITE but fallback to ACCESS
501+ * when they are not available.
502+ */
503+#ifndef READ_ONCE
504+# define READ_ONCE(x) ACCESS_ONCE(x)
505+#endif
506+
507+#ifndef WRITE_ONCE
508+# define WRITE_ONCE(x, val) ({ ACCESS_ONCE(x) = val; })
509+#endif
510+
511 #endif /* _LTTNG_WRAPPER_COMPILER_H */
512diff --git a/wrapper/trace-clock.h b/wrapper/trace-clock.h
513index 7f17ccd..08f9922 100644
514--- a/wrapper/trace-clock.h
515+++ b/wrapper/trace-clock.h
516@@ -37,6 +37,7 @@
517 #include <asm/local.h>
518 #include <lttng-kernel-version.h>
519 #include <lttng-clock.h>
520+#include <wrapper/compiler.h>
521 #include <wrapper/percpu-defs.h>
522 #include <wrapper/random.h>
523
524@@ -176,7 +177,7 @@ static inline void put_trace_clock(void)
525
526 static inline u64 trace_clock_read64(void)
527 {
528- struct lttng_trace_clock *ltc = ACCESS_ONCE(lttng_trace_clock);
529+ struct lttng_trace_clock *ltc = READ_ONCE(lttng_trace_clock);
530
531 if (likely(!ltc)) {
532 return trace_clock_read64_monotonic();
533@@ -188,7 +189,7 @@ static inline u64 trace_clock_read64(void)
534
535 static inline u64 trace_clock_freq(void)
536 {
537- struct lttng_trace_clock *ltc = ACCESS_ONCE(lttng_trace_clock);
538+ struct lttng_trace_clock *ltc = READ_ONCE(lttng_trace_clock);
539
540 if (!ltc) {
541 return trace_clock_freq_monotonic();
542@@ -200,7 +201,7 @@ static inline u64 trace_clock_freq(void)
543
544 static inline int trace_clock_uuid(char *uuid)
545 {
546- struct lttng_trace_clock *ltc = ACCESS_ONCE(lttng_trace_clock);
547+ struct lttng_trace_clock *ltc = READ_ONCE(lttng_trace_clock);
548
549 read_barrier_depends(); /* load ltc before content */
550 /* Use default UUID cb when NULL */
551@@ -213,7 +214,7 @@ static inline int trace_clock_uuid(char *uuid)
552
553 static inline const char *trace_clock_name(void)
554 {
555- struct lttng_trace_clock *ltc = ACCESS_ONCE(lttng_trace_clock);
556+ struct lttng_trace_clock *ltc = READ_ONCE(lttng_trace_clock);
557
558 if (!ltc) {
559 return trace_clock_name_monotonic();
560@@ -225,7 +226,7 @@ static inline const char *trace_clock_name(void)
561
562 static inline const char *trace_clock_description(void)
563 {
564- struct lttng_trace_clock *ltc = ACCESS_ONCE(lttng_trace_clock);
565+ struct lttng_trace_clock *ltc = READ_ONCE(lttng_trace_clock);
566
567 if (!ltc) {
568 return trace_clock_description_monotonic();
LTTng 2.x kernel modules
This page took 0.118244 seconds and 4 git commands to generate.