Commit | Line | Data |
---|---|---|
b7cdc182 | 1 | /* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) |
9f36eaed | 2 | * |
886d51a3 | 3 | * lttng-context-perf-counters.c |
833ad6a0 MD |
4 | * |
5 | * LTTng performance monitoring counters (perf-counters) integration module. | |
6 | * | |
886d51a3 | 7 | * Copyright (C) 2009-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com> |
833ad6a0 MD |
8 | */ |
9 | ||
10 | #include <linux/module.h> | |
11 | #include <linux/slab.h> | |
12 | #include <linux/perf_event.h> | |
13 | #include <linux/list.h> | |
c24a0d71 | 14 | #include <linux/string.h> |
5ca7b8a3 | 15 | #include <linux/cpu.h> |
c50bdba2 | 16 | #include <linux/mm.h> |
241ae9a8 | 17 | #include <lttng-events.h> |
5760f3f4 | 18 | #include <include/ringbuffer/frontend_types.h> |
241ae9a8 | 19 | #include <lttng-tracer.h> |
833ad6a0 | 20 | |
f1676205 MD |
21 | static |
22 | size_t perf_counter_get_size(size_t offset) | |
23 | { | |
24 | size_t size = 0; | |
25 | ||
a90917c3 | 26 | size += lib_ring_buffer_align(offset, lttng_alignof(uint64_t)); |
f1676205 MD |
27 | size += sizeof(uint64_t); |
28 | return size; | |
29 | } | |
30 | ||
833ad6a0 MD |
31 | static |
32 | void perf_counter_record(struct lttng_ctx_field *field, | |
33 | struct lib_ring_buffer_ctx *ctx, | |
a90917c3 | 34 | struct lttng_channel *chan) |
833ad6a0 MD |
35 | { |
36 | struct perf_event *event; | |
37 | uint64_t value; | |
38 | ||
2001023e | 39 | event = field->u.perf_counter->e[ctx->cpu]; |
0478c519 | 40 | if (likely(event)) { |
7b745a96 MD |
41 | if (unlikely(event->state == PERF_EVENT_STATE_ERROR)) { |
42 | value = 0; | |
43 | } else { | |
44 | event->pmu->read(event); | |
45 | value = local64_read(&event->count); | |
46 | } | |
f91fd73b MD |
47 | } else { |
48 | /* | |
49 | * Perf chooses not to be clever and not to support enabling a | |
50 | * perf counter before the cpu is brought up. Therefore, we need | |
51 | * to support having events coming (e.g. scheduler events) | |
52 | * before the counter is setup. Write an arbitrary 0 in this | |
53 | * case. | |
54 | */ | |
55 | value = 0; | |
56 | } | |
a90917c3 | 57 | lib_ring_buffer_align_ctx(ctx, lttng_alignof(value)); |
833ad6a0 MD |
58 | chan->ops->event_write(ctx, &value, sizeof(value)); |
59 | } | |
60 | ||
90f5546c MD |
61 | static |
62 | void overflow_callback(struct perf_event *event, | |
63 | struct perf_sample_data *data, | |
64 | struct pt_regs *regs) | |
65 | { | |
66 | } | |
833ad6a0 | 67 | |
2dccf128 MD |
68 | static |
69 | void lttng_destroy_perf_counter_field(struct lttng_ctx_field *field) | |
70 | { | |
2001023e | 71 | struct perf_event **events = field->u.perf_counter->e; |
2dccf128 | 72 | |
1e367326 MD |
73 | { |
74 | int ret; | |
75 | ||
76 | ret = cpuhp_state_remove_instance(lttng_hp_online, | |
77 | &field->u.perf_counter->cpuhp_online.node); | |
78 | WARN_ON(ret); | |
79 | ret = cpuhp_state_remove_instance(lttng_hp_prepare, | |
80 | &field->u.perf_counter->cpuhp_prepare.node); | |
81 | WARN_ON(ret); | |
82 | } | |
c24a0d71 | 83 | kfree(field->event_field.name); |
2001023e | 84 | kfree(field->u.perf_counter->attr); |
c50bdba2 | 85 | kvfree(events); |
2001023e | 86 | kfree(field->u.perf_counter); |
2dccf128 MD |
87 | } |
88 | ||
1e367326 MD |
89 | int lttng_cpuhp_perf_counter_online(unsigned int cpu, |
90 | struct lttng_cpuhp_node *node) | |
91 | { | |
92 | struct lttng_perf_counter_field *perf_field = | |
93 | container_of(node, struct lttng_perf_counter_field, | |
94 | cpuhp_online); | |
95 | struct perf_event **events = perf_field->e; | |
96 | struct perf_event_attr *attr = perf_field->attr; | |
97 | struct perf_event *pevent; | |
98 | ||
1cacbdc9 MD |
99 | pevent = perf_event_create_kernel_counter(attr, |
100 | cpu, NULL, overflow_callback, NULL); | |
1e367326 MD |
101 | if (!pevent || IS_ERR(pevent)) |
102 | return -EINVAL; | |
103 | if (pevent->state == PERF_EVENT_STATE_ERROR) { | |
104 | perf_event_release_kernel(pevent); | |
105 | return -EINVAL; | |
106 | } | |
107 | barrier(); /* Create perf counter before setting event */ | |
108 | events[cpu] = pevent; | |
109 | return 0; | |
110 | } | |
111 | ||
112 | int lttng_cpuhp_perf_counter_dead(unsigned int cpu, | |
113 | struct lttng_cpuhp_node *node) | |
114 | { | |
115 | struct lttng_perf_counter_field *perf_field = | |
116 | container_of(node, struct lttng_perf_counter_field, | |
117 | cpuhp_prepare); | |
118 | struct perf_event **events = perf_field->e; | |
119 | struct perf_event *pevent; | |
120 | ||
121 | pevent = events[cpu]; | |
122 | events[cpu] = NULL; | |
123 | barrier(); /* NULLify event before perf counter teardown */ | |
124 | perf_event_release_kernel(pevent); | |
125 | return 0; | |
126 | } | |
127 | ||
833ad6a0 MD |
128 | int lttng_add_perf_counter_to_ctx(uint32_t type, |
129 | uint64_t config, | |
c24a0d71 | 130 | const char *name, |
2dccf128 | 131 | struct lttng_ctx **ctx) |
833ad6a0 MD |
132 | { |
133 | struct lttng_ctx_field *field; | |
2001023e | 134 | struct lttng_perf_counter_field *perf_field; |
833ad6a0 MD |
135 | struct perf_event **events; |
136 | struct perf_event_attr *attr; | |
137 | int ret; | |
c24a0d71 | 138 | char *name_alloc; |
833ad6a0 | 139 | |
c50bdba2 | 140 | events = kvzalloc(num_possible_cpus() * sizeof(*events), GFP_KERNEL); |
833ad6a0 MD |
141 | if (!events) |
142 | return -ENOMEM; | |
143 | ||
2001023e | 144 | attr = kzalloc(sizeof(struct perf_event_attr), GFP_KERNEL); |
833ad6a0 MD |
145 | if (!attr) { |
146 | ret = -ENOMEM; | |
147 | goto error_attr; | |
148 | } | |
149 | ||
150 | attr->type = type; | |
151 | attr->config = config; | |
152 | attr->size = sizeof(struct perf_event_attr); | |
153 | attr->pinned = 1; | |
154 | attr->disabled = 0; | |
155 | ||
2001023e MD |
156 | perf_field = kzalloc(sizeof(struct lttng_perf_counter_field), GFP_KERNEL); |
157 | if (!perf_field) { | |
158 | ret = -ENOMEM; | |
159 | goto error_alloc_perf_field; | |
160 | } | |
161 | perf_field->e = events; | |
162 | perf_field->attr = attr; | |
163 | ||
c24a0d71 | 164 | name_alloc = kstrdup(name, GFP_KERNEL); |
bef96e48 MD |
165 | if (!name_alloc) { |
166 | ret = -ENOMEM; | |
c24a0d71 | 167 | goto name_alloc_error; |
bef96e48 | 168 | } |
c24a0d71 | 169 | |
2dccf128 MD |
170 | field = lttng_append_context(ctx); |
171 | if (!field) { | |
172 | ret = -ENOMEM; | |
8289661d | 173 | goto append_context_error; |
833ad6a0 | 174 | } |
2001023e | 175 | if (lttng_find_context(*ctx, name_alloc)) { |
44252f0f MD |
176 | ret = -EEXIST; |
177 | goto find_error; | |
178 | } | |
8289661d | 179 | |
1e367326 MD |
180 | perf_field->cpuhp_prepare.component = LTTNG_CONTEXT_PERF_COUNTERS; |
181 | ret = cpuhp_state_add_instance(lttng_hp_prepare, | |
182 | &perf_field->cpuhp_prepare.node); | |
183 | if (ret) | |
184 | goto cpuhp_prepare_error; | |
185 | ||
186 | perf_field->cpuhp_online.component = LTTNG_CONTEXT_PERF_COUNTERS; | |
187 | ret = cpuhp_state_add_instance(lttng_hp_online, | |
188 | &perf_field->cpuhp_online.node); | |
189 | if (ret) | |
190 | goto cpuhp_online_error; | |
191 | ||
2dccf128 | 192 | field->destroy = lttng_destroy_perf_counter_field; |
833ad6a0 | 193 | |
c24a0d71 | 194 | field->event_field.name = name_alloc; |
8070f5c0 | 195 | field->event_field.type.atype = atype_integer; |
ceabb767 MD |
196 | field->event_field.type.u.integer.size = sizeof(uint64_t) * CHAR_BIT; |
197 | field->event_field.type.u.integer.alignment = lttng_alignof(uint64_t) * CHAR_BIT; | |
198 | field->event_field.type.u.integer.signedness = lttng_is_signed_type(uint64_t); | |
199 | field->event_field.type.u.integer.reverse_byte_order = 0; | |
200 | field->event_field.type.u.integer.base = 10; | |
201 | field->event_field.type.u.integer.encoding = lttng_encode_none; | |
f1676205 MD |
202 | field->get_size = perf_counter_get_size; |
203 | field->record = perf_counter_record; | |
2001023e | 204 | field->u.perf_counter = perf_field; |
a9dd15da | 205 | lttng_context_update(*ctx); |
833ad6a0 | 206 | |
833ad6a0 MD |
207 | return 0; |
208 | ||
1e367326 MD |
209 | cpuhp_online_error: |
210 | { | |
211 | int remove_ret; | |
212 | ||
213 | remove_ret = cpuhp_state_remove_instance(lttng_hp_prepare, | |
214 | &perf_field->cpuhp_prepare.node); | |
215 | WARN_ON(remove_ret); | |
216 | } | |
217 | cpuhp_prepare_error: | |
44252f0f | 218 | find_error: |
8289661d MD |
219 | lttng_remove_context_field(ctx, field); |
220 | append_context_error: | |
221 | kfree(name_alloc); | |
222 | name_alloc_error: | |
2001023e MD |
223 | kfree(perf_field); |
224 | error_alloc_perf_field: | |
833ad6a0 MD |
225 | kfree(attr); |
226 | error_attr: | |
c50bdba2 | 227 | kvfree(events); |
833ad6a0 MD |
228 | return ret; |
229 | } |