Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge branch 'perf-fixes-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/linux-2.6-tip
* 'perf-fixes-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/linux-2.6-tip:
perf stat: Fix aggreate counter reading accounting
tracing: Replace syscall_meta_data struct array with pointer array
tracepoints: Fix section alignment using pointer array
tracing: Replace trace_event struct array with pointer array
+106
-95
+12
-12
include/asm-generic/vmlinux.lds.h
+12
-12
include/asm-generic/vmlinux.lds.h
···
124
124
#endif
125
125
126
126
#ifdef CONFIG_EVENT_TRACING
127
-
#define FTRACE_EVENTS() VMLINUX_SYMBOL(__start_ftrace_events) = .; \
127
+
#define FTRACE_EVENTS() . = ALIGN(8); \
128
+
VMLINUX_SYMBOL(__start_ftrace_events) = .; \
128
129
*(_ftrace_events) \
129
130
VMLINUX_SYMBOL(__stop_ftrace_events) = .;
130
131
#else
···
141
140
#endif
142
141
143
142
#ifdef CONFIG_FTRACE_SYSCALLS
144
-
#define TRACE_SYSCALLS() VMLINUX_SYMBOL(__start_syscalls_metadata) = .; \
143
+
#define TRACE_SYSCALLS() . = ALIGN(8); \
144
+
VMLINUX_SYMBOL(__start_syscalls_metadata) = .; \
145
145
*(__syscalls_metadata) \
146
146
VMLINUX_SYMBOL(__stop_syscalls_metadata) = .;
147
147
#else
···
167
165
CPU_KEEP(exit.data) \
168
166
MEM_KEEP(init.data) \
169
167
MEM_KEEP(exit.data) \
170
-
. = ALIGN(32); \
171
-
VMLINUX_SYMBOL(__start___tracepoints) = .; \
168
+
STRUCT_ALIGN(); \
172
169
*(__tracepoints) \
173
-
VMLINUX_SYMBOL(__stop___tracepoints) = .; \
174
170
/* implement dynamic printk debug */ \
175
171
. = ALIGN(8); \
176
172
VMLINUX_SYMBOL(__start___verbose) = .; \
···
176
176
VMLINUX_SYMBOL(__stop___verbose) = .; \
177
177
LIKELY_PROFILE() \
178
178
BRANCH_PROFILE() \
179
-
TRACE_PRINTKS() \
180
-
\
181
-
STRUCT_ALIGN(); \
182
-
FTRACE_EVENTS() \
183
-
\
184
-
STRUCT_ALIGN(); \
185
-
TRACE_SYSCALLS()
179
+
TRACE_PRINTKS()
186
180
187
181
/*
188
182
* Data section helpers
···
214
220
VMLINUX_SYMBOL(__start_rodata) = .; \
215
221
*(.rodata) *(.rodata.*) \
216
222
*(__vermagic) /* Kernel version magic */ \
223
+
. = ALIGN(8); \
224
+
VMLINUX_SYMBOL(__start___tracepoints_ptrs) = .; \
225
+
*(__tracepoints_ptrs) /* Tracepoints: pointer array */\
226
+
VMLINUX_SYMBOL(__stop___tracepoints_ptrs) = .; \
217
227
*(__markers_strings) /* Markers: strings */ \
218
228
*(__tracepoints_strings)/* Tracepoints: strings */ \
219
229
} \
···
480
482
KERNEL_CTORS() \
481
483
*(.init.rodata) \
482
484
MCOUNT_REC() \
485
+
FTRACE_EVENTS() \
486
+
TRACE_SYSCALLS() \
483
487
DEV_DISCARD(init.rodata) \
484
488
CPU_DISCARD(init.rodata) \
485
489
MEM_DISCARD(init.rodata) \
+2
-2
include/linux/module.h
+2
-2
include/linux/module.h
···
377
377
keeping pointers to this stuff */
378
378
char *args;
379
379
#ifdef CONFIG_TRACEPOINTS
380
-
struct tracepoint *tracepoints;
380
+
struct tracepoint * const *tracepoints_ptrs;
381
381
unsigned int num_tracepoints;
382
382
#endif
383
383
#ifdef HAVE_JUMP_LABEL
···
389
389
unsigned int num_trace_bprintk_fmt;
390
390
#endif
391
391
#ifdef CONFIG_EVENT_TRACING
392
-
struct ftrace_event_call *trace_events;
392
+
struct ftrace_event_call **trace_events;
393
393
unsigned int num_trace_events;
394
394
#endif
395
395
#ifdef CONFIG_FTRACE_MCOUNT_RECORD
+15
-13
include/linux/syscalls.h
+15
-13
include/linux/syscalls.h
···
125
125
extern struct trace_event_functions exit_syscall_print_funcs;
126
126
127
127
#define SYSCALL_TRACE_ENTER_EVENT(sname) \
128
-
static struct syscall_metadata \
129
-
__attribute__((__aligned__(4))) __syscall_meta_##sname; \
128
+
static struct syscall_metadata __syscall_meta_##sname; \
130
129
static struct ftrace_event_call __used \
131
-
__attribute__((__aligned__(4))) \
132
-
__attribute__((section("_ftrace_events"))) \
133
130
event_enter_##sname = { \
134
131
.name = "sys_enter"#sname, \
135
132
.class = &event_class_syscall_enter, \
136
133
.event.funcs = &enter_syscall_print_funcs, \
137
134
.data = (void *)&__syscall_meta_##sname,\
138
135
}; \
136
+
static struct ftrace_event_call __used \
137
+
__attribute__((section("_ftrace_events"))) \
138
+
*__event_enter_##sname = &event_enter_##sname; \
139
139
__TRACE_EVENT_FLAGS(enter_##sname, TRACE_EVENT_FL_CAP_ANY)
140
140
141
141
#define SYSCALL_TRACE_EXIT_EVENT(sname) \
142
-
static struct syscall_metadata \
143
-
__attribute__((__aligned__(4))) __syscall_meta_##sname; \
142
+
static struct syscall_metadata __syscall_meta_##sname; \
144
143
static struct ftrace_event_call __used \
145
-
__attribute__((__aligned__(4))) \
146
-
__attribute__((section("_ftrace_events"))) \
147
144
event_exit_##sname = { \
148
145
.name = "sys_exit"#sname, \
149
146
.class = &event_class_syscall_exit, \
150
147
.event.funcs = &exit_syscall_print_funcs, \
151
148
.data = (void *)&__syscall_meta_##sname,\
152
149
}; \
150
+
static struct ftrace_event_call __used \
151
+
__attribute__((section("_ftrace_events"))) \
152
+
*__event_exit_##sname = &event_exit_##sname; \
153
153
__TRACE_EVENT_FLAGS(exit_##sname, TRACE_EVENT_FL_CAP_ANY)
154
154
155
155
#define SYSCALL_METADATA(sname, nb) \
156
156
SYSCALL_TRACE_ENTER_EVENT(sname); \
157
157
SYSCALL_TRACE_EXIT_EVENT(sname); \
158
158
static struct syscall_metadata __used \
159
-
__attribute__((__aligned__(4))) \
160
-
__attribute__((section("__syscalls_metadata"))) \
161
159
__syscall_meta_##sname = { \
162
160
.name = "sys"#sname, \
163
161
.nb_args = nb, \
···
164
166
.enter_event = &event_enter_##sname, \
165
167
.exit_event = &event_exit_##sname, \
166
168
.enter_fields = LIST_HEAD_INIT(__syscall_meta_##sname.enter_fields), \
167
-
};
169
+
}; \
170
+
static struct syscall_metadata __used \
171
+
__attribute__((section("__syscalls_metadata"))) \
172
+
*__p_syscall_meta_##sname = &__syscall_meta_##sname;
168
173
169
174
#define SYSCALL_DEFINE0(sname) \
170
175
SYSCALL_TRACE_ENTER_EVENT(_##sname); \
171
176
SYSCALL_TRACE_EXIT_EVENT(_##sname); \
172
177
static struct syscall_metadata __used \
173
-
__attribute__((__aligned__(4))) \
174
-
__attribute__((section("__syscalls_metadata"))) \
175
178
__syscall_meta__##sname = { \
176
179
.name = "sys_"#sname, \
177
180
.nb_args = 0, \
···
180
181
.exit_event = &event_exit__##sname, \
181
182
.enter_fields = LIST_HEAD_INIT(__syscall_meta__##sname.enter_fields), \
182
183
}; \
184
+
static struct syscall_metadata __used \
185
+
__attribute__((section("__syscalls_metadata"))) \
186
+
*__p_syscall_meta_##sname = &__syscall_meta__##sname; \
183
187
asmlinkage long sys_##sname(void)
184
188
#else
185
189
#define SYSCALL_DEFINE0(name) asmlinkage long sys_##name(void)
+20
-15
include/linux/tracepoint.h
+20
-15
include/linux/tracepoint.h
···
33
33
void (*regfunc)(void);
34
34
void (*unregfunc)(void);
35
35
struct tracepoint_func __rcu *funcs;
36
-
} __attribute__((aligned(32))); /*
37
-
* Aligned on 32 bytes because it is
38
-
* globally visible and gcc happily
39
-
* align these on the structure size.
40
-
* Keep in sync with vmlinux.lds.h.
41
-
*/
36
+
};
42
37
43
38
/*
44
39
* Connect a probe to a tracepoint.
···
56
61
57
62
struct tracepoint_iter {
58
63
struct module *module;
59
-
struct tracepoint *tracepoint;
64
+
struct tracepoint * const *tracepoint;
60
65
};
61
66
62
67
extern void tracepoint_iter_start(struct tracepoint_iter *iter);
63
68
extern void tracepoint_iter_next(struct tracepoint_iter *iter);
64
69
extern void tracepoint_iter_stop(struct tracepoint_iter *iter);
65
70
extern void tracepoint_iter_reset(struct tracepoint_iter *iter);
66
-
extern int tracepoint_get_iter_range(struct tracepoint **tracepoint,
67
-
struct tracepoint *begin, struct tracepoint *end);
71
+
extern int tracepoint_get_iter_range(struct tracepoint * const **tracepoint,
72
+
struct tracepoint * const *begin, struct tracepoint * const *end);
68
73
69
74
/*
70
75
* tracepoint_synchronize_unregister must be called between the last tracepoint
···
79
84
#define PARAMS(args...) args
80
85
81
86
#ifdef CONFIG_TRACEPOINTS
82
-
extern void tracepoint_update_probe_range(struct tracepoint *begin,
83
-
struct tracepoint *end);
87
+
extern
88
+
void tracepoint_update_probe_range(struct tracepoint * const *begin,
89
+
struct tracepoint * const *end);
84
90
#else
85
-
static inline void tracepoint_update_probe_range(struct tracepoint *begin,
86
-
struct tracepoint *end)
91
+
static inline
92
+
void tracepoint_update_probe_range(struct tracepoint * const *begin,
93
+
struct tracepoint * const *end)
87
94
{ }
88
95
#endif /* CONFIG_TRACEPOINTS */
89
96
···
171
174
{ \
172
175
}
173
176
177
+
/*
178
+
* We have no guarantee that gcc and the linker won't up-align the tracepoint
179
+
* structures, so we create an array of pointers that will be used for iteration
180
+
* on the tracepoints.
181
+
*/
174
182
#define DEFINE_TRACE_FN(name, reg, unreg) \
175
183
static const char __tpstrtab_##name[] \
176
184
__attribute__((section("__tracepoints_strings"))) = #name; \
177
185
struct tracepoint __tracepoint_##name \
178
-
__attribute__((section("__tracepoints"), aligned(32))) = \
179
-
{ __tpstrtab_##name, 0, reg, unreg, NULL }
186
+
__attribute__((section("__tracepoints"))) = \
187
+
{ __tpstrtab_##name, 0, reg, unreg, NULL }; \
188
+
static struct tracepoint * const __tracepoint_ptr_##name __used \
189
+
__attribute__((section("__tracepoints_ptrs"))) = \
190
+
&__tracepoint_##name;
180
191
181
192
#define DEFINE_TRACE(name) \
182
193
DEFINE_TRACE_FN(name, NULL, NULL);
+13
-11
include/trace/ftrace.h
+13
-11
include/trace/ftrace.h
···
446
446
* .reg = ftrace_event_reg,
447
447
* };
448
448
*
449
-
* static struct ftrace_event_call __used
450
-
* __attribute__((__aligned__(4)))
451
-
* __attribute__((section("_ftrace_events"))) event_<call> = {
449
+
* static struct ftrace_event_call event_<call> = {
452
450
* .name = "<call>",
453
451
* .class = event_class_<template>,
454
452
* .event = &ftrace_event_type_<call>,
455
453
* .print_fmt = print_fmt_<call>,
456
454
* };
455
+
* // its only safe to use pointers when doing linker tricks to
456
+
* // create an array.
457
+
* static struct ftrace_event_call __used
458
+
* __attribute__((section("_ftrace_events"))) *__event_<call> = &event_<call>;
457
459
*
458
460
*/
459
461
···
581
579
#undef DEFINE_EVENT
582
580
#define DEFINE_EVENT(template, call, proto, args) \
583
581
\
584
-
static struct ftrace_event_call __used \
585
-
__attribute__((__aligned__(4))) \
586
-
__attribute__((section("_ftrace_events"))) event_##call = { \
582
+
static struct ftrace_event_call __used event_##call = { \
587
583
.name = #call, \
588
584
.class = &event_class_##template, \
589
585
.event.funcs = &ftrace_event_type_funcs_##template, \
590
586
.print_fmt = print_fmt_##template, \
591
-
};
587
+
}; \
588
+
static struct ftrace_event_call __used \
589
+
__attribute__((section("_ftrace_events"))) *__event_##call = &event_##call
592
590
593
591
#undef DEFINE_EVENT_PRINT
594
592
#define DEFINE_EVENT_PRINT(template, call, proto, args, print) \
595
593
\
596
594
static const char print_fmt_##call[] = print; \
597
595
\
598
-
static struct ftrace_event_call __used \
599
-
__attribute__((__aligned__(4))) \
600
-
__attribute__((section("_ftrace_events"))) event_##call = { \
596
+
static struct ftrace_event_call __used event_##call = { \
601
597
.name = #call, \
602
598
.class = &event_class_##template, \
603
599
.event.funcs = &ftrace_event_type_funcs_##call, \
604
600
.print_fmt = print_fmt_##call, \
605
-
}
601
+
}; \
602
+
static struct ftrace_event_call __used \
603
+
__attribute__((section("_ftrace_events"))) *__event_##call = &event_##call
606
604
607
605
#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
608
606
+8
-8
kernel/module.c
+8
-8
kernel/module.c
···
2460
2460
#endif
2461
2461
2462
2462
#ifdef CONFIG_TRACEPOINTS
2463
-
mod->tracepoints = section_objs(info, "__tracepoints",
2464
-
sizeof(*mod->tracepoints),
2465
-
&mod->num_tracepoints);
2463
+
mod->tracepoints_ptrs = section_objs(info, "__tracepoints_ptrs",
2464
+
sizeof(*mod->tracepoints_ptrs),
2465
+
&mod->num_tracepoints);
2466
2466
#endif
2467
2467
#ifdef HAVE_JUMP_LABEL
2468
2468
mod->jump_entries = section_objs(info, "__jump_table",
···
3393
3393
struct modversion_info *ver,
3394
3394
struct kernel_param *kp,
3395
3395
struct kernel_symbol *ks,
3396
-
struct tracepoint *tp)
3396
+
struct tracepoint * const *tp)
3397
3397
{
3398
3398
}
3399
3399
EXPORT_SYMBOL(module_layout);
···
3407
3407
mutex_lock(&module_mutex);
3408
3408
list_for_each_entry(mod, &modules, list)
3409
3409
if (!mod->taints)
3410
-
tracepoint_update_probe_range(mod->tracepoints,
3411
-
mod->tracepoints + mod->num_tracepoints);
3410
+
tracepoint_update_probe_range(mod->tracepoints_ptrs,
3411
+
mod->tracepoints_ptrs + mod->num_tracepoints);
3412
3412
mutex_unlock(&module_mutex);
3413
3413
}
3414
3414
···
3432
3432
else if (iter_mod > iter->module)
3433
3433
iter->tracepoint = NULL;
3434
3434
found = tracepoint_get_iter_range(&iter->tracepoint,
3435
-
iter_mod->tracepoints,
3436
-
iter_mod->tracepoints
3435
+
iter_mod->tracepoints_ptrs,
3436
+
iter_mod->tracepoints_ptrs
3437
3437
+ iter_mod->num_tracepoints);
3438
3438
if (found) {
3439
3439
iter->module = iter_mod;
+6
-6
kernel/trace/trace_events.c
+6
-6
kernel/trace/trace_events.c
···
1284
1284
static void trace_module_add_events(struct module *mod)
1285
1285
{
1286
1286
struct ftrace_module_file_ops *file_ops = NULL;
1287
-
struct ftrace_event_call *call, *start, *end;
1287
+
struct ftrace_event_call **call, **start, **end;
1288
1288
1289
1289
start = mod->trace_events;
1290
1290
end = mod->trace_events + mod->num_trace_events;
···
1297
1297
return;
1298
1298
1299
1299
for_each_event(call, start, end) {
1300
-
__trace_add_event_call(call, mod,
1300
+
__trace_add_event_call(*call, mod,
1301
1301
&file_ops->id, &file_ops->enable,
1302
1302
&file_ops->filter, &file_ops->format);
1303
1303
}
···
1367
1367
.priority = 0,
1368
1368
};
1369
1369
1370
-
extern struct ftrace_event_call __start_ftrace_events[];
1371
-
extern struct ftrace_event_call __stop_ftrace_events[];
1370
+
extern struct ftrace_event_call *__start_ftrace_events[];
1371
+
extern struct ftrace_event_call *__stop_ftrace_events[];
1372
1372
1373
1373
static char bootup_event_buf[COMMAND_LINE_SIZE] __initdata;
1374
1374
···
1384
1384
1385
1385
static __init int event_trace_init(void)
1386
1386
{
1387
-
struct ftrace_event_call *call;
1387
+
struct ftrace_event_call **call;
1388
1388
struct dentry *d_tracer;
1389
1389
struct dentry *entry;
1390
1390
struct dentry *d_events;
···
1430
1430
pr_warning("tracing: Failed to allocate common fields");
1431
1431
1432
1432
for_each_event(call, __start_ftrace_events, __stop_ftrace_events) {
1433
-
__trace_add_event_call(call, NULL, &ftrace_event_id_fops,
1433
+
__trace_add_event_call(*call, NULL, &ftrace_event_id_fops,
1434
1434
&ftrace_enable_fops,
1435
1435
&ftrace_event_filter_fops,
1436
1436
&ftrace_event_format_fops);
+3
-3
kernel/trace/trace_export.c
+3
-3
kernel/trace/trace_export.c
···
161
161
.fields = LIST_HEAD_INIT(event_class_ftrace_##call.fields),\
162
162
}; \
163
163
\
164
-
struct ftrace_event_call __used \
165
-
__attribute__((__aligned__(4))) \
166
-
__attribute__((section("_ftrace_events"))) event_##call = { \
164
+
struct ftrace_event_call __used event_##call = { \
167
165
.name = #call, \
168
166
.event.type = etype, \
169
167
.class = &event_class_ftrace_##call, \
170
168
.print_fmt = print, \
171
169
}; \
170
+
struct ftrace_event_call __used \
171
+
__attribute__((section("_ftrace_events"))) *__event_##call = &event_##call;
172
172
173
173
#include "trace_entries.h"
+10
-9
kernel/trace/trace_syscalls.c
+10
-9
kernel/trace/trace_syscalls.c
···
55
55
.raw_init = init_syscall_trace,
56
56
};
57
57
58
-
extern unsigned long __start_syscalls_metadata[];
59
-
extern unsigned long __stop_syscalls_metadata[];
58
+
extern struct syscall_metadata *__start_syscalls_metadata[];
59
+
extern struct syscall_metadata *__stop_syscalls_metadata[];
60
60
61
61
static struct syscall_metadata **syscalls_metadata;
62
62
63
-
static struct syscall_metadata *find_syscall_meta(unsigned long syscall)
63
+
static __init struct syscall_metadata *
64
+
find_syscall_meta(unsigned long syscall)
64
65
{
65
-
struct syscall_metadata *start;
66
-
struct syscall_metadata *stop;
66
+
struct syscall_metadata **start;
67
+
struct syscall_metadata **stop;
67
68
char str[KSYM_SYMBOL_LEN];
68
69
69
70
70
-
start = (struct syscall_metadata *)__start_syscalls_metadata;
71
-
stop = (struct syscall_metadata *)__stop_syscalls_metadata;
71
+
start = __start_syscalls_metadata;
72
+
stop = __stop_syscalls_metadata;
72
73
kallsyms_lookup(syscall, NULL, NULL, NULL, str);
73
74
74
75
for ( ; start < stop; start++) {
···
79
78
* with "SyS" instead of "sys", leading to an unwanted
80
79
* mismatch.
81
80
*/
82
-
if (start->name && !strcmp(start->name + 3, str + 3))
83
-
return start;
81
+
if ((*start)->name && !strcmp((*start)->name + 3, str + 3))
82
+
return *start;
84
83
}
85
84
return NULL;
86
85
}
+16
-15
kernel/tracepoint.c
+16
-15
kernel/tracepoint.c
···
27
27
#include <linux/sched.h>
28
28
#include <linux/jump_label.h>
29
29
30
-
extern struct tracepoint __start___tracepoints[];
31
-
extern struct tracepoint __stop___tracepoints[];
30
+
extern struct tracepoint * const __start___tracepoints_ptrs[];
31
+
extern struct tracepoint * const __stop___tracepoints_ptrs[];
32
32
33
33
/* Set to 1 to enable tracepoint debug output */
34
34
static const int tracepoint_debug;
···
298
298
*
299
299
* Updates the probe callback corresponding to a range of tracepoints.
300
300
*/
301
-
void
302
-
tracepoint_update_probe_range(struct tracepoint *begin, struct tracepoint *end)
301
+
void tracepoint_update_probe_range(struct tracepoint * const *begin,
302
+
struct tracepoint * const *end)
303
303
{
304
-
struct tracepoint *iter;
304
+
struct tracepoint * const *iter;
305
305
struct tracepoint_entry *mark_entry;
306
306
307
307
if (!begin)
···
309
309
310
310
mutex_lock(&tracepoints_mutex);
311
311
for (iter = begin; iter < end; iter++) {
312
-
mark_entry = get_tracepoint(iter->name);
312
+
mark_entry = get_tracepoint((*iter)->name);
313
313
if (mark_entry) {
314
-
set_tracepoint(&mark_entry, iter,
314
+
set_tracepoint(&mark_entry, *iter,
315
315
!!mark_entry->refcount);
316
316
} else {
317
-
disable_tracepoint(iter);
317
+
disable_tracepoint(*iter);
318
318
}
319
319
}
320
320
mutex_unlock(&tracepoints_mutex);
···
326
326
static void tracepoint_update_probes(void)
327
327
{
328
328
/* Core kernel tracepoints */
329
-
tracepoint_update_probe_range(__start___tracepoints,
330
-
__stop___tracepoints);
329
+
tracepoint_update_probe_range(__start___tracepoints_ptrs,
330
+
__stop___tracepoints_ptrs);
331
331
/* tracepoints in modules. */
332
332
module_update_tracepoints();
333
333
}
···
514
514
* Will return the first tracepoint in the range if the input tracepoint is
515
515
* NULL.
516
516
*/
517
-
int tracepoint_get_iter_range(struct tracepoint **tracepoint,
518
-
struct tracepoint *begin, struct tracepoint *end)
517
+
int tracepoint_get_iter_range(struct tracepoint * const **tracepoint,
518
+
struct tracepoint * const *begin, struct tracepoint * const *end)
519
519
{
520
520
if (!*tracepoint && begin != end) {
521
521
*tracepoint = begin;
···
534
534
/* Core kernel tracepoints */
535
535
if (!iter->module) {
536
536
found = tracepoint_get_iter_range(&iter->tracepoint,
537
-
__start___tracepoints, __stop___tracepoints);
537
+
__start___tracepoints_ptrs,
538
+
__stop___tracepoints_ptrs);
538
539
if (found)
539
540
goto end;
540
541
}
···
586
585
switch (val) {
587
586
case MODULE_STATE_COMING:
588
587
case MODULE_STATE_GOING:
589
-
tracepoint_update_probe_range(mod->tracepoints,
590
-
mod->tracepoints + mod->num_tracepoints);
588
+
tracepoint_update_probe_range(mod->tracepoints_ptrs,
589
+
mod->tracepoints_ptrs + mod->num_tracepoints);
591
590
break;
592
591
}
593
592
return 0;