Commit | Line | Data |
---|---|---|
ce5aef0b | 1 | /* |
7dd08bec | 2 | * lttng-probes.c |
ce5aef0b | 3 | * |
ce5aef0b MD |
4 | * Holds LTTng probes registry. |
5 | * | |
e92f3e28 MD |
6 | * Copyright 2010-2012 (c) - Mathieu Desnoyers <mathieu.desnoyers@efficios.com> |
7 | * | |
8 | * This library is free software; you can redistribute it and/or | |
9 | * modify it under the terms of the GNU Lesser General Public | |
10 | * License as published by the Free Software Foundation; only | |
11 | * version 2.1 of the License. | |
12 | * | |
13 | * This library is distributed in the hope that it will be useful, | |
14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
16 | * Lesser General Public License for more details. | |
17 | * | |
18 | * You should have received a copy of the GNU Lesser General Public | |
19 | * License along with this library; if not, write to the Free Software | |
20 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | |
ce5aef0b MD |
21 | */ |
22 | ||
8d8a24c8 MD |
23 | #include <string.h> |
24 | #include <errno.h> | |
25 | #include <urcu/list.h> | |
1f18504e | 26 | #include <urcu/hlist.h> |
4318ae1b | 27 | #include <lttng/ust-events.h> |
902e1379 | 28 | #include <lttng/tracepoint.h> |
d8de1354 | 29 | #include "tracepoint-internal.h" |
a3bb4b27 | 30 | #include <assert.h> |
c8fcf224 | 31 | #include <helper.h> |
48740cab | 32 | #include <ctype.h> |
ce5aef0b | 33 | |
7dd08bec | 34 | #include "lttng-tracer-core.h" |
1f18504e MD |
35 | #include "jhash.h" |
36 | #include "error.h" | |
8165c8da MD |
37 | |
38 | /* | |
17dfb34b | 39 | * probe list is protected by ust_lock()/ust_unlock(). |
8165c8da | 40 | */ |
e58095ef MD |
41 | CDS_LIST_HEAD(probe_list); |
42 | ||
43 | struct cds_list_head *lttng_get_probe_list_head(void) | |
44 | { | |
45 | return &probe_list; | |
46 | } | |
ce5aef0b | 47 | |
df854e41 MD |
48 | static |
49 | const struct lttng_probe_desc *find_provider(const char *provider) | |
50 | { | |
51 | struct lttng_probe_desc *iter; | |
52 | ||
53 | cds_list_for_each_entry(iter, &probe_list, head) { | |
54 | if (!strcmp(iter->provider, provider)) | |
55 | return iter; | |
56 | } | |
57 | return NULL; | |
58 | } | |
59 | ||
ce5aef0b | 60 | static |
48205d60 | 61 | int check_event_provider(struct lttng_probe_desc *desc) |
ce5aef0b | 62 | { |
ce5aef0b | 63 | int i; |
48205d60 | 64 | size_t provider_name_len; |
ce5aef0b | 65 | |
48205d60 MD |
66 | provider_name_len = strnlen(desc->provider, |
67 | LTTNG_UST_SYM_NAME_LEN - 1); | |
68 | for (i = 0; i < desc->nr_events; i++) { | |
69 | if (strncmp(desc->event_desc[i]->name, | |
70 | desc->provider, | |
71 | provider_name_len)) | |
72 | return 0; /* provider mismatch */ | |
ce5aef0b | 73 | } |
48205d60 | 74 | return 1; |
ce5aef0b MD |
75 | } |
76 | ||
7dd08bec | 77 | int lttng_probe_register(struct lttng_probe_desc *desc) |
ce5aef0b | 78 | { |
df854e41 | 79 | struct lttng_probe_desc *iter; |
ce5aef0b MD |
80 | int ret = 0; |
81 | int i; | |
82 | ||
17dfb34b | 83 | ust_lock(); |
48205d60 MD |
84 | |
85 | /* | |
86 | * Check if the provider has already been registered. | |
87 | */ | |
df854e41 MD |
88 | if (find_provider(desc->provider)) { |
89 | ret = -EEXIST; | |
90 | goto end; | |
91 | } | |
48205d60 | 92 | |
ce5aef0b | 93 | /* |
48205d60 MD |
94 | * Each provider enforce that every event name begins with the |
95 | * provider name. Check this in an assertion for extra | |
96 | * carefulness. This ensures we cannot have duplicate event | |
97 | * names across providers. | |
98 | */ | |
99 | assert(check_event_provider(desc)); | |
100 | ||
101 | /* | |
102 | * The provider ensures there are no duplicate event names. | |
103 | * Duplicated TRACEPOINT_EVENT event names would generate a | |
104 | * compile-time error due to duplicated symbol names. | |
ce5aef0b | 105 | */ |
df854e41 MD |
106 | |
107 | /* | |
108 | * We sort the providers by struct lttng_probe_desc pointer | |
109 | * address. | |
110 | */ | |
111 | cds_list_for_each_entry_reverse(iter, &probe_list, head) { | |
112 | BUG_ON(iter == desc); /* Should never be in the list twice */ | |
113 | if (iter < desc) { | |
114 | /* We belong to the location right after iter. */ | |
115 | cds_list_add(&desc->head, &iter->head); | |
116 | goto desc_added; | |
117 | } | |
118 | } | |
119 | /* We should be added at the head of the list */ | |
8d8a24c8 | 120 | cds_list_add(&desc->head, &probe_list); |
df854e41 | 121 | desc_added: |
e81a53af MD |
122 | DBG("just registered probe %s containing %u events", |
123 | desc->provider, desc->nr_events); | |
8165c8da MD |
124 | /* |
125 | * fix the events awaiting probe load. | |
126 | */ | |
127 | for (i = 0; i < desc->nr_events; i++) { | |
68755429 MD |
128 | const struct lttng_event_desc *ed; |
129 | ||
130 | ed = desc->event_desc[i]; | |
131 | DBG("Registered event probe \"%s\" with signature \"%s\"", | |
132 | ed->name, ed->signature); | |
e58095ef | 133 | ret = lttng_fix_pending_event_desc(ed); |
8165c8da MD |
134 | assert(!ret); |
135 | } | |
ce5aef0b | 136 | end: |
17dfb34b | 137 | ust_unlock(); |
ce5aef0b MD |
138 | return ret; |
139 | } | |
ce5aef0b | 140 | |
7dd08bec MD |
141 | /* Backward compatibility with UST 2.0 */ |
142 | int ltt_probe_register(struct lttng_probe_desc *desc) | |
143 | { | |
144 | return lttng_probe_register(desc); | |
145 | } | |
146 | ||
147 | void lttng_probe_unregister(struct lttng_probe_desc *desc) | |
ce5aef0b | 148 | { |
17dfb34b | 149 | ust_lock(); |
8d8a24c8 | 150 | cds_list_del(&desc->head); |
e81a53af | 151 | DBG("just unregistered probe %s", desc->provider); |
17dfb34b | 152 | ust_unlock(); |
ce5aef0b | 153 | } |
ce5aef0b | 154 | |
7dd08bec MD |
155 | /* Backward compatibility with UST 2.0 */ |
156 | void ltt_probe_unregister(struct lttng_probe_desc *desc) | |
157 | { | |
158 | lttng_probe_unregister(desc); | |
159 | } | |
160 | ||
7dd08bec | 161 | void lttng_probes_prune_event_list(struct lttng_ust_tracepoint_list *list) |
c8fcf224 MD |
162 | { |
163 | struct tp_list_entry *list_entry, *tmp; | |
164 | ||
165 | cds_list_for_each_entry_safe(list_entry, tmp, &list->head, head) { | |
166 | cds_list_del(&list_entry->head); | |
167 | free(list_entry); | |
168 | } | |
169 | } | |
170 | ||
171 | /* | |
172 | * called with UST lock held. | |
173 | */ | |
7dd08bec | 174 | int lttng_probes_get_event_list(struct lttng_ust_tracepoint_list *list) |
c8fcf224 MD |
175 | { |
176 | struct lttng_probe_desc *probe_desc; | |
177 | int i; | |
178 | ||
179 | CDS_INIT_LIST_HEAD(&list->head); | |
180 | cds_list_for_each_entry(probe_desc, &probe_list, head) { | |
181 | for (i = 0; i < probe_desc->nr_events; i++) { | |
182 | struct tp_list_entry *list_entry; | |
183 | ||
184 | list_entry = zmalloc(sizeof(*list_entry)); | |
185 | if (!list_entry) | |
186 | goto err_nomem; | |
187 | cds_list_add(&list_entry->head, &list->head); | |
188 | strncpy(list_entry->tp.name, | |
189 | probe_desc->event_desc[i]->name, | |
190 | LTTNG_UST_SYM_NAME_LEN); | |
191 | list_entry->tp.name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0'; | |
192 | if (!probe_desc->event_desc[i]->loglevel) { | |
882a56d7 | 193 | list_entry->tp.loglevel = TRACE_DEFAULT; |
c8fcf224 | 194 | } else { |
882a56d7 | 195 | list_entry->tp.loglevel = *(*probe_desc->event_desc[i]->loglevel); |
c8fcf224 MD |
196 | } |
197 | } | |
198 | } | |
199 | if (cds_list_empty(&list->head)) | |
200 | list->iter = NULL; | |
201 | else | |
202 | list->iter = | |
203 | cds_list_first_entry(&list->head, struct tp_list_entry, head); | |
204 | return 0; | |
205 | ||
206 | err_nomem: | |
7dd08bec | 207 | lttng_probes_prune_event_list(list); |
c8fcf224 MD |
208 | return -ENOMEM; |
209 | } | |
210 | ||
211 | /* | |
212 | * Return current iteration position, advance internal iterator to next. | |
213 | * Return NULL if end of list. | |
214 | */ | |
215 | struct lttng_ust_tracepoint_iter * | |
216 | lttng_ust_tracepoint_list_get_iter_next(struct lttng_ust_tracepoint_list *list) | |
217 | { | |
218 | struct tp_list_entry *entry; | |
219 | ||
220 | if (!list->iter) | |
221 | return NULL; | |
222 | entry = list->iter; | |
223 | if (entry->head.next == &list->head) | |
224 | list->iter = NULL; | |
225 | else | |
226 | list->iter = cds_list_entry(entry->head.next, | |
227 | struct tp_list_entry, head); | |
228 | return &entry->tp; | |
229 | } | |
1f18504e | 230 | |
7dd08bec | 231 | void lttng_probes_prune_field_list(struct lttng_ust_field_list *list) |
06d4f27e MD |
232 | { |
233 | struct tp_field_list_entry *list_entry, *tmp; | |
234 | ||
235 | cds_list_for_each_entry_safe(list_entry, tmp, &list->head, head) { | |
236 | cds_list_del(&list_entry->head); | |
237 | free(list_entry); | |
238 | } | |
239 | } | |
240 | ||
241 | /* | |
242 | * called with UST lock held. | |
243 | */ | |
7dd08bec | 244 | int lttng_probes_get_field_list(struct lttng_ust_field_list *list) |
06d4f27e MD |
245 | { |
246 | struct lttng_probe_desc *probe_desc; | |
247 | int i; | |
248 | ||
249 | CDS_INIT_LIST_HEAD(&list->head); | |
250 | cds_list_for_each_entry(probe_desc, &probe_list, head) { | |
251 | for (i = 0; i < probe_desc->nr_events; i++) { | |
252 | const struct lttng_event_desc *event_desc = | |
253 | probe_desc->event_desc[i]; | |
254 | int j; | |
255 | ||
26329f26 MD |
256 | if (event_desc->nr_fields == 0) { |
257 | /* Events without fields. */ | |
258 | struct tp_field_list_entry *list_entry; | |
259 | ||
260 | list_entry = zmalloc(sizeof(*list_entry)); | |
261 | if (!list_entry) | |
262 | goto err_nomem; | |
263 | cds_list_add(&list_entry->head, &list->head); | |
264 | strncpy(list_entry->field.event_name, | |
265 | event_desc->name, | |
266 | LTTNG_UST_SYM_NAME_LEN); | |
267 | list_entry->field.event_name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0'; | |
268 | list_entry->field.field_name[0] = '\0'; | |
269 | list_entry->field.type = LTTNG_UST_FIELD_OTHER; | |
270 | if (!event_desc->loglevel) { | |
271 | list_entry->field.loglevel = TRACE_DEFAULT; | |
272 | } else { | |
273 | list_entry->field.loglevel = *(*event_desc->loglevel); | |
274 | } | |
275 | list_entry->field.nowrite = 1; | |
276 | } | |
277 | ||
06d4f27e MD |
278 | for (j = 0; j < event_desc->nr_fields; j++) { |
279 | const struct lttng_event_field *event_field = | |
280 | &event_desc->fields[j]; | |
281 | struct tp_field_list_entry *list_entry; | |
282 | ||
283 | list_entry = zmalloc(sizeof(*list_entry)); | |
284 | if (!list_entry) | |
285 | goto err_nomem; | |
286 | cds_list_add(&list_entry->head, &list->head); | |
287 | strncpy(list_entry->field.event_name, | |
288 | event_desc->name, | |
289 | LTTNG_UST_SYM_NAME_LEN); | |
290 | list_entry->field.event_name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0'; | |
291 | strncpy(list_entry->field.field_name, | |
292 | event_field->name, | |
293 | LTTNG_UST_SYM_NAME_LEN); | |
294 | list_entry->field.field_name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0'; | |
40003310 MD |
295 | switch (event_field->type.atype) { |
296 | case atype_integer: | |
297 | list_entry->field.type = LTTNG_UST_FIELD_INTEGER; | |
298 | break; | |
299 | case atype_string: | |
300 | list_entry->field.type = LTTNG_UST_FIELD_STRING; | |
301 | break; | |
302 | case atype_array: | |
303 | if (event_field->type.u.array.elem_type.atype != atype_integer | |
304 | || event_field->type.u.array.elem_type.u.basic.integer.encoding == lttng_encode_none) | |
305 | list_entry->field.type = LTTNG_UST_FIELD_OTHER; | |
306 | else | |
307 | list_entry->field.type = LTTNG_UST_FIELD_STRING; | |
308 | break; | |
309 | case atype_sequence: | |
310 | if (event_field->type.u.sequence.elem_type.atype != atype_integer | |
311 | || event_field->type.u.sequence.elem_type.u.basic.integer.encoding == lttng_encode_none) | |
312 | list_entry->field.type = LTTNG_UST_FIELD_OTHER; | |
313 | else | |
314 | list_entry->field.type = LTTNG_UST_FIELD_STRING; | |
315 | break; | |
316 | case atype_float: | |
317 | list_entry->field.type = LTTNG_UST_FIELD_FLOAT; | |
318 | break; | |
319 | case atype_enum: | |
320 | list_entry->field.type = LTTNG_UST_FIELD_ENUM; | |
321 | break; | |
322 | default: | |
323 | list_entry->field.type = LTTNG_UST_FIELD_OTHER; | |
324 | } | |
06d4f27e MD |
325 | if (!event_desc->loglevel) { |
326 | list_entry->field.loglevel = TRACE_DEFAULT; | |
327 | } else { | |
328 | list_entry->field.loglevel = *(*event_desc->loglevel); | |
329 | } | |
180901e6 | 330 | list_entry->field.nowrite = event_field->nowrite; |
06d4f27e MD |
331 | } |
332 | } | |
333 | } | |
334 | if (cds_list_empty(&list->head)) | |
335 | list->iter = NULL; | |
336 | else | |
337 | list->iter = | |
338 | cds_list_first_entry(&list->head, | |
339 | struct tp_field_list_entry, head); | |
340 | return 0; | |
341 | ||
342 | err_nomem: | |
7dd08bec | 343 | lttng_probes_prune_field_list(list); |
06d4f27e MD |
344 | return -ENOMEM; |
345 | } | |
346 | ||
347 | /* | |
348 | * Return current iteration position, advance internal iterator to next. | |
349 | * Return NULL if end of list. | |
350 | */ | |
351 | struct lttng_ust_field_iter * | |
352 | lttng_ust_field_list_get_iter_next(struct lttng_ust_field_list *list) | |
353 | { | |
354 | struct tp_field_list_entry *entry; | |
355 | ||
356 | if (!list->iter) | |
357 | return NULL; | |
358 | entry = list->iter; | |
359 | if (entry->head.next == &list->head) | |
360 | list->iter = NULL; | |
361 | else | |
362 | list->iter = cds_list_entry(entry->head.next, | |
363 | struct tp_field_list_entry, head); | |
364 | return &entry->field; | |
365 | } |