Commit | Line | Data |
---|---|---|
ce5aef0b MD |
1 | /* |
2 | * ltt-probes.c | |
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 | |
8165c8da | 34 | #include "ltt-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 | */ |
8d8a24c8 | 41 | static CDS_LIST_HEAD(probe_list); |
ce5aef0b | 42 | |
df854e41 MD |
43 | static |
44 | const struct lttng_probe_desc *find_provider(const char *provider) | |
45 | { | |
46 | struct lttng_probe_desc *iter; | |
47 | ||
48 | cds_list_for_each_entry(iter, &probe_list, head) { | |
49 | if (!strcmp(iter->provider, provider)) | |
50 | return iter; | |
51 | } | |
52 | return NULL; | |
53 | } | |
54 | ||
ce5aef0b MD |
55 | static |
56 | const struct lttng_event_desc *find_event(const char *name) | |
57 | { | |
58 | struct lttng_probe_desc *probe_desc; | |
59 | int i; | |
60 | ||
8d8a24c8 | 61 | cds_list_for_each_entry(probe_desc, &probe_list, head) { |
ce5aef0b | 62 | for (i = 0; i < probe_desc->nr_events; i++) { |
ff412fb5 MD |
63 | if (!strncmp(probe_desc->event_desc[i]->name, name, |
64 | LTTNG_UST_SYM_NAME_LEN - 1)) | |
df854e41 | 65 | return probe_desc->event_desc[i]; |
ce5aef0b MD |
66 | } |
67 | } | |
68 | return NULL; | |
69 | } | |
70 | ||
71 | int ltt_probe_register(struct lttng_probe_desc *desc) | |
72 | { | |
df854e41 | 73 | struct lttng_probe_desc *iter; |
ce5aef0b MD |
74 | int ret = 0; |
75 | int i; | |
76 | ||
17dfb34b | 77 | ust_lock(); |
df854e41 MD |
78 | if (find_provider(desc->provider)) { |
79 | ret = -EEXIST; | |
80 | goto end; | |
81 | } | |
ce5aef0b MD |
82 | /* |
83 | * TODO: This is O(N^2). Turn into a hash table when probe registration | |
84 | * overhead becomes an issue. | |
85 | */ | |
86 | for (i = 0; i < desc->nr_events; i++) { | |
df854e41 | 87 | if (find_event(desc->event_desc[i]->name)) { |
ce5aef0b MD |
88 | ret = -EEXIST; |
89 | goto end; | |
90 | } | |
91 | } | |
df854e41 MD |
92 | |
93 | /* | |
94 | * We sort the providers by struct lttng_probe_desc pointer | |
95 | * address. | |
96 | */ | |
97 | cds_list_for_each_entry_reverse(iter, &probe_list, head) { | |
98 | BUG_ON(iter == desc); /* Should never be in the list twice */ | |
99 | if (iter < desc) { | |
100 | /* We belong to the location right after iter. */ | |
101 | cds_list_add(&desc->head, &iter->head); | |
102 | goto desc_added; | |
103 | } | |
104 | } | |
105 | /* We should be added at the head of the list */ | |
8d8a24c8 | 106 | cds_list_add(&desc->head, &probe_list); |
df854e41 | 107 | desc_added: |
e81a53af MD |
108 | DBG("just registered probe %s containing %u events", |
109 | desc->provider, desc->nr_events); | |
8165c8da MD |
110 | /* |
111 | * fix the events awaiting probe load. | |
112 | */ | |
113 | for (i = 0; i < desc->nr_events; i++) { | |
68755429 MD |
114 | const struct lttng_event_desc *ed; |
115 | ||
116 | ed = desc->event_desc[i]; | |
117 | DBG("Registered event probe \"%s\" with signature \"%s\"", | |
118 | ed->name, ed->signature); | |
119 | ret = pending_probe_fix_events(ed); | |
8165c8da MD |
120 | assert(!ret); |
121 | } | |
ce5aef0b | 122 | end: |
17dfb34b | 123 | ust_unlock(); |
ce5aef0b MD |
124 | return ret; |
125 | } | |
ce5aef0b MD |
126 | |
127 | void ltt_probe_unregister(struct lttng_probe_desc *desc) | |
128 | { | |
17dfb34b | 129 | ust_lock(); |
8d8a24c8 | 130 | cds_list_del(&desc->head); |
e81a53af | 131 | DBG("just unregistered probe %s", desc->provider); |
17dfb34b | 132 | ust_unlock(); |
ce5aef0b | 133 | } |
ce5aef0b | 134 | |
8165c8da MD |
135 | /* |
136 | * called with UST lock held. | |
137 | */ | |
ce5aef0b MD |
138 | const struct lttng_event_desc *ltt_event_get(const char *name) |
139 | { | |
140 | const struct lttng_event_desc *event; | |
ce5aef0b | 141 | |
ce5aef0b | 142 | event = find_event(name); |
ce5aef0b MD |
143 | if (!event) |
144 | return NULL; | |
ce5aef0b MD |
145 | return event; |
146 | } | |
ce5aef0b MD |
147 | |
148 | void ltt_event_put(const struct lttng_event_desc *event) | |
149 | { | |
ce5aef0b | 150 | } |
c8fcf224 MD |
151 | |
152 | void ltt_probes_prune_event_list(struct lttng_ust_tracepoint_list *list) | |
153 | { | |
154 | struct tp_list_entry *list_entry, *tmp; | |
155 | ||
156 | cds_list_for_each_entry_safe(list_entry, tmp, &list->head, head) { | |
157 | cds_list_del(&list_entry->head); | |
158 | free(list_entry); | |
159 | } | |
160 | } | |
161 | ||
162 | /* | |
163 | * called with UST lock held. | |
164 | */ | |
165 | int ltt_probes_get_event_list(struct lttng_ust_tracepoint_list *list) | |
166 | { | |
167 | struct lttng_probe_desc *probe_desc; | |
168 | int i; | |
169 | ||
170 | CDS_INIT_LIST_HEAD(&list->head); | |
171 | cds_list_for_each_entry(probe_desc, &probe_list, head) { | |
172 | for (i = 0; i < probe_desc->nr_events; i++) { | |
173 | struct tp_list_entry *list_entry; | |
174 | ||
175 | list_entry = zmalloc(sizeof(*list_entry)); | |
176 | if (!list_entry) | |
177 | goto err_nomem; | |
178 | cds_list_add(&list_entry->head, &list->head); | |
179 | strncpy(list_entry->tp.name, | |
180 | probe_desc->event_desc[i]->name, | |
181 | LTTNG_UST_SYM_NAME_LEN); | |
182 | list_entry->tp.name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0'; | |
183 | if (!probe_desc->event_desc[i]->loglevel) { | |
882a56d7 | 184 | list_entry->tp.loglevel = TRACE_DEFAULT; |
c8fcf224 | 185 | } else { |
882a56d7 | 186 | list_entry->tp.loglevel = *(*probe_desc->event_desc[i]->loglevel); |
c8fcf224 MD |
187 | } |
188 | } | |
189 | } | |
190 | if (cds_list_empty(&list->head)) | |
191 | list->iter = NULL; | |
192 | else | |
193 | list->iter = | |
194 | cds_list_first_entry(&list->head, struct tp_list_entry, head); | |
195 | return 0; | |
196 | ||
197 | err_nomem: | |
198 | ltt_probes_prune_event_list(list); | |
199 | return -ENOMEM; | |
200 | } | |
201 | ||
202 | /* | |
203 | * Return current iteration position, advance internal iterator to next. | |
204 | * Return NULL if end of list. | |
205 | */ | |
206 | struct lttng_ust_tracepoint_iter * | |
207 | lttng_ust_tracepoint_list_get_iter_next(struct lttng_ust_tracepoint_list *list) | |
208 | { | |
209 | struct tp_list_entry *entry; | |
210 | ||
211 | if (!list->iter) | |
212 | return NULL; | |
213 | entry = list->iter; | |
214 | if (entry->head.next == &list->head) | |
215 | list->iter = NULL; | |
216 | else | |
217 | list->iter = cds_list_entry(entry->head.next, | |
218 | struct tp_list_entry, head); | |
219 | return &entry->tp; | |
220 | } | |
1f18504e | 221 | |
06d4f27e MD |
222 | void ltt_probes_prune_field_list(struct lttng_ust_field_list *list) |
223 | { | |
224 | struct tp_field_list_entry *list_entry, *tmp; | |
225 | ||
226 | cds_list_for_each_entry_safe(list_entry, tmp, &list->head, head) { | |
227 | cds_list_del(&list_entry->head); | |
228 | free(list_entry); | |
229 | } | |
230 | } | |
231 | ||
232 | /* | |
233 | * called with UST lock held. | |
234 | */ | |
235 | int ltt_probes_get_field_list(struct lttng_ust_field_list *list) | |
236 | { | |
237 | struct lttng_probe_desc *probe_desc; | |
238 | int i; | |
239 | ||
240 | CDS_INIT_LIST_HEAD(&list->head); | |
241 | cds_list_for_each_entry(probe_desc, &probe_list, head) { | |
242 | for (i = 0; i < probe_desc->nr_events; i++) { | |
243 | const struct lttng_event_desc *event_desc = | |
244 | probe_desc->event_desc[i]; | |
245 | int j; | |
246 | ||
26329f26 MD |
247 | if (event_desc->nr_fields == 0) { |
248 | /* Events without fields. */ | |
249 | struct tp_field_list_entry *list_entry; | |
250 | ||
251 | list_entry = zmalloc(sizeof(*list_entry)); | |
252 | if (!list_entry) | |
253 | goto err_nomem; | |
254 | cds_list_add(&list_entry->head, &list->head); | |
255 | strncpy(list_entry->field.event_name, | |
256 | event_desc->name, | |
257 | LTTNG_UST_SYM_NAME_LEN); | |
258 | list_entry->field.event_name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0'; | |
259 | list_entry->field.field_name[0] = '\0'; | |
260 | list_entry->field.type = LTTNG_UST_FIELD_OTHER; | |
261 | if (!event_desc->loglevel) { | |
262 | list_entry->field.loglevel = TRACE_DEFAULT; | |
263 | } else { | |
264 | list_entry->field.loglevel = *(*event_desc->loglevel); | |
265 | } | |
266 | list_entry->field.nowrite = 1; | |
267 | } | |
268 | ||
06d4f27e MD |
269 | for (j = 0; j < event_desc->nr_fields; j++) { |
270 | const struct lttng_event_field *event_field = | |
271 | &event_desc->fields[j]; | |
272 | struct tp_field_list_entry *list_entry; | |
273 | ||
274 | list_entry = zmalloc(sizeof(*list_entry)); | |
275 | if (!list_entry) | |
276 | goto err_nomem; | |
277 | cds_list_add(&list_entry->head, &list->head); | |
278 | strncpy(list_entry->field.event_name, | |
279 | event_desc->name, | |
280 | LTTNG_UST_SYM_NAME_LEN); | |
281 | list_entry->field.event_name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0'; | |
282 | strncpy(list_entry->field.field_name, | |
283 | event_field->name, | |
284 | LTTNG_UST_SYM_NAME_LEN); | |
285 | list_entry->field.field_name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0'; | |
40003310 MD |
286 | switch (event_field->type.atype) { |
287 | case atype_integer: | |
288 | list_entry->field.type = LTTNG_UST_FIELD_INTEGER; | |
289 | break; | |
290 | case atype_string: | |
291 | list_entry->field.type = LTTNG_UST_FIELD_STRING; | |
292 | break; | |
293 | case atype_array: | |
294 | if (event_field->type.u.array.elem_type.atype != atype_integer | |
295 | || event_field->type.u.array.elem_type.u.basic.integer.encoding == lttng_encode_none) | |
296 | list_entry->field.type = LTTNG_UST_FIELD_OTHER; | |
297 | else | |
298 | list_entry->field.type = LTTNG_UST_FIELD_STRING; | |
299 | break; | |
300 | case atype_sequence: | |
301 | if (event_field->type.u.sequence.elem_type.atype != atype_integer | |
302 | || event_field->type.u.sequence.elem_type.u.basic.integer.encoding == lttng_encode_none) | |
303 | list_entry->field.type = LTTNG_UST_FIELD_OTHER; | |
304 | else | |
305 | list_entry->field.type = LTTNG_UST_FIELD_STRING; | |
306 | break; | |
307 | case atype_float: | |
308 | list_entry->field.type = LTTNG_UST_FIELD_FLOAT; | |
309 | break; | |
310 | case atype_enum: | |
311 | list_entry->field.type = LTTNG_UST_FIELD_ENUM; | |
312 | break; | |
313 | default: | |
314 | list_entry->field.type = LTTNG_UST_FIELD_OTHER; | |
315 | } | |
06d4f27e MD |
316 | if (!event_desc->loglevel) { |
317 | list_entry->field.loglevel = TRACE_DEFAULT; | |
318 | } else { | |
319 | list_entry->field.loglevel = *(*event_desc->loglevel); | |
320 | } | |
180901e6 | 321 | list_entry->field.nowrite = event_field->nowrite; |
06d4f27e MD |
322 | } |
323 | } | |
324 | } | |
325 | if (cds_list_empty(&list->head)) | |
326 | list->iter = NULL; | |
327 | else | |
328 | list->iter = | |
329 | cds_list_first_entry(&list->head, | |
330 | struct tp_field_list_entry, head); | |
331 | return 0; | |
332 | ||
333 | err_nomem: | |
334 | ltt_probes_prune_field_list(list); | |
335 | return -ENOMEM; | |
336 | } | |
337 | ||
338 | /* | |
339 | * Return current iteration position, advance internal iterator to next. | |
340 | * Return NULL if end of list. | |
341 | */ | |
342 | struct lttng_ust_field_iter * | |
343 | lttng_ust_field_list_get_iter_next(struct lttng_ust_field_list *list) | |
344 | { | |
345 | struct tp_field_list_entry *entry; | |
346 | ||
347 | if (!list->iter) | |
348 | return NULL; | |
349 | entry = list->iter; | |
350 | if (entry->head.next == &list->head) | |
351 | list->iter = NULL; | |
352 | else | |
353 | list->iter = cds_list_entry(entry->head.next, | |
354 | struct tp_field_list_entry, head); | |
355 | return &entry->field; | |
356 | } | |
357 | ||
e6c12e3d MD |
358 | /* |
359 | * marshall all probes/all events and create those that fit the | |
360 | * wildcard. Add them to the events list as created. | |
361 | */ | |
457a6b58 | 362 | void ltt_probes_create_wildcard_events(struct wildcard_entry *entry, |
e6c12e3d MD |
363 | struct session_wildcard *wildcard) |
364 | { | |
365 | struct lttng_probe_desc *probe_desc; | |
366 | struct lttng_ust_event event_param; | |
367 | int i; | |
368 | ||
369 | cds_list_for_each_entry(probe_desc, &probe_list, head) { | |
370 | for (i = 0; i < probe_desc->nr_events; i++) { | |
371 | const struct lttng_event_desc *event_desc; | |
372 | int match = 0; | |
373 | ||
374 | event_desc = probe_desc->event_desc[i]; | |
375 | /* compare excluding final '*' */ | |
376 | assert(strlen(entry->name) > 0); | |
377 | if (strcmp(event_desc->name, "lttng_ust:metadata") | |
378 | && (strlen(entry->name) == 1 | |
379 | || !strncmp(event_desc->name, entry->name, | |
380 | strlen(entry->name) - 1))) { | |
457a6b58 MD |
381 | if (ltt_loglevel_match(event_desc, |
382 | entry->loglevel_type, | |
383 | entry->loglevel)) { | |
384 | match = 1; | |
385 | } | |
e6c12e3d MD |
386 | } |
387 | if (match) { | |
388 | struct ltt_event *ev; | |
389 | int ret; | |
390 | ||
391 | memcpy(&event_param, &wildcard->event_param, | |
392 | sizeof(event_param)); | |
1c7b4a9b | 393 | strncpy(event_param.name, |
e6c12e3d MD |
394 | event_desc->name, |
395 | sizeof(event_param.name)); | |
1c7b4a9b | 396 | event_param.name[sizeof(event_param.name) - 1] = '\0'; |
e6c12e3d MD |
397 | /* create event */ |
398 | ret = ltt_event_create(wildcard->chan, | |
2d78951a | 399 | &event_param, &ev); |
e6c12e3d MD |
400 | if (ret) { |
401 | DBG("Error creating event"); | |
402 | continue; | |
403 | } | |
404 | cds_list_add(&ev->wildcard_list, | |
405 | &wildcard->events); | |
406 | } | |
407 | } | |
408 | } | |
2d78951a | 409 | lttng_filter_wildcard_link_bytecode(wildcard); |
e6c12e3d MD |
410 | } |
411 |