Commit | Line | Data |
---|---|---|
ebdb334b JR |
1 | /* |
2 | * Copyright (C) 2020 Francis Deslauriers <francis.deslauriers@efficios.com> | |
3 | * | |
4 | * SPDX-License-Identifier: LGPL-2.1-only | |
5 | * | |
6 | */ | |
7 | ||
8 | #include <assert.h> | |
9 | #include <stdint.h> | |
10 | #include <stdlib.h> | |
11 | #include <string.h> | |
12 | ||
13 | #include <common/error.h> | |
14 | #include <common/macros.h> | |
15 | #include <common/optional.h> | |
16 | #include <common/payload.h> | |
17 | ||
18 | #include <lttng/map/map-query-internal.h> | |
19 | ||
20 | struct lttng_map_query *lttng_map_query_create( | |
21 | enum lttng_map_query_config_cpu cpu, | |
22 | enum lttng_map_query_config_buffer buffer, | |
23 | enum lttng_map_query_config_app_bitness bitness) | |
24 | { | |
25 | struct lttng_map_query *query = NULL; | |
26 | ||
27 | if ((buffer == LTTNG_MAP_QUERY_CONFIG_BUFFER_KERNEL_GLOBAL) ^ | |
28 | (bitness == LTTNG_MAP_QUERY_CONFIG_APP_BITNESS_KERNEL)) { | |
29 | /* | |
30 | * If any of the buffer or bitness config is set to kernel, | |
31 | * they other has to as well. | |
32 | */ | |
33 | goto end; | |
34 | } | |
35 | ||
36 | if (bitness != LTTNG_MAP_QUERY_CONFIG_APP_BITNESS_ALL && | |
37 | bitness != LTTNG_MAP_QUERY_CONFIG_APP_BITNESS_KERNEL) { | |
38 | /* We currently don't support targetting a specific bitness. */ | |
39 | goto end; | |
40 | } | |
41 | ||
42 | query = zmalloc(sizeof(struct lttng_map_query)); | |
43 | if (!query) { | |
44 | goto end; | |
45 | } | |
46 | ||
47 | query->config_cpu = cpu; | |
48 | query->config_buffer = buffer; | |
49 | query->config_bitness = bitness; | |
50 | ||
51 | query->sum_by_uid = false; | |
52 | query->sum_by_pid = false; | |
53 | query->sum_by_cpu = false; | |
54 | // defaults to true for now. | |
55 | query->sum_by_app_bitness = true; | |
56 | ||
57 | if (query->config_cpu == LTTNG_MAP_QUERY_CONFIG_CPU_SUBSET) { | |
58 | lttng_dynamic_array_init(&query->cpu_array, sizeof(int), NULL); | |
59 | } | |
60 | ||
61 | switch(query->config_buffer) { | |
62 | case LTTNG_MAP_QUERY_CONFIG_BUFFER_UST_UID_SUBSET: | |
63 | lttng_dynamic_array_init(&query->uid_array, sizeof(uid_t), NULL); | |
64 | break; | |
65 | case LTTNG_MAP_QUERY_CONFIG_BUFFER_UST_PID_SUBSET: | |
66 | lttng_dynamic_array_init(&query->pid_array, sizeof(pid_t), NULL); | |
67 | break; | |
68 | default: | |
69 | break; | |
70 | } | |
71 | end: | |
72 | return query; | |
73 | } | |
74 | ||
75 | enum lttng_map_query_status lttng_map_query_set_sum_by_cpu( | |
76 | struct lttng_map_query *query, bool sum_by_cpu) | |
77 | { | |
78 | query->sum_by_cpu = sum_by_cpu; | |
79 | ||
80 | return LTTNG_MAP_QUERY_STATUS_OK; | |
81 | } | |
82 | ||
83 | enum lttng_map_query_status lttng_map_query_set_sum_by_app_bitness( | |
84 | struct lttng_map_query *query, bool sum_by_app_bitness) | |
85 | { | |
86 | enum lttng_map_query_status status; | |
87 | ||
88 | if (query->config_bitness != LTTNG_MAP_QUERY_CONFIG_APP_BITNESS_ALL) { | |
89 | status = LTTNG_MAP_QUERY_STATUS_INVALID; | |
90 | goto end; | |
91 | } | |
92 | ||
93 | query->sum_by_app_bitness = sum_by_app_bitness; | |
94 | status = LTTNG_MAP_QUERY_STATUS_OK; | |
95 | ||
96 | end: | |
97 | return status; | |
98 | } | |
99 | ||
100 | enum lttng_map_query_status lttng_map_query_set_sum_by_pid( | |
101 | struct lttng_map_query *query, bool sum_by_pid) | |
102 | { | |
103 | enum lttng_map_query_status status; | |
104 | ||
105 | switch (query->config_buffer) { | |
106 | case LTTNG_MAP_QUERY_CONFIG_BUFFER_UST_PID_ALL: | |
107 | case LTTNG_MAP_QUERY_CONFIG_BUFFER_UST_PID_SUBSET: | |
108 | break; | |
109 | default: | |
110 | status = LTTNG_MAP_QUERY_STATUS_INVALID; | |
111 | goto end; | |
112 | } | |
113 | ||
114 | query->sum_by_pid = sum_by_pid; | |
115 | status = LTTNG_MAP_QUERY_STATUS_OK; | |
116 | ||
117 | end: | |
118 | return status; | |
119 | } | |
120 | ||
121 | enum lttng_map_query_status lttng_map_query_set_sum_by_uid( | |
122 | struct lttng_map_query *query, bool sum_by_uid) | |
123 | { | |
124 | enum lttng_map_query_status status; | |
125 | ||
126 | switch (query->config_buffer) { | |
127 | case LTTNG_MAP_QUERY_CONFIG_BUFFER_UST_UID_ALL: | |
128 | case LTTNG_MAP_QUERY_CONFIG_BUFFER_UST_UID_SUBSET: | |
129 | break; | |
130 | default: | |
131 | status = LTTNG_MAP_QUERY_STATUS_INVALID; | |
132 | goto end; | |
133 | } | |
134 | ||
135 | query->sum_by_uid = sum_by_uid; | |
136 | status = LTTNG_MAP_QUERY_STATUS_OK; | |
137 | ||
138 | end: | |
139 | return status; | |
140 | } | |
141 | ||
142 | enum lttng_map_query_status lttng_map_query_add_cpu( | |
143 | struct lttng_map_query *query, int cpu_id) | |
144 | { | |
145 | enum lttng_map_query_status status; | |
146 | unsigned int cpu_count; | |
147 | int ret; | |
148 | ||
149 | if (query->config_cpu != LTTNG_MAP_QUERY_CONFIG_CPU_SUBSET) { | |
150 | status = LTTNG_MAP_QUERY_STATUS_INVALID; | |
151 | goto end; | |
152 | } | |
153 | ||
154 | lttng_map_query_get_cpu_count(query, &cpu_count); | |
155 | if (cpu_count > 0) { | |
156 | ERR("Only one CPU can be targeted in a query at the moment"); | |
157 | status = LTTNG_MAP_QUERY_STATUS_INVALID; | |
158 | goto end; | |
159 | } | |
160 | ||
161 | ret = lttng_dynamic_array_add_element(&query->cpu_array, &cpu_id); | |
162 | if (ret) { | |
163 | status = LTTNG_MAP_QUERY_STATUS_ERROR; | |
164 | goto end; | |
165 | } | |
166 | ||
167 | status = LTTNG_MAP_QUERY_STATUS_OK; | |
168 | end: | |
169 | return status; | |
170 | } | |
171 | ||
172 | enum lttng_map_query_status lttng_map_query_add_uid( | |
173 | struct lttng_map_query *query, uid_t uid) | |
174 | { | |
175 | int ret; | |
176 | unsigned int uid_count; | |
177 | enum lttng_map_query_status status; | |
178 | ||
179 | if (query->config_buffer != LTTNG_MAP_QUERY_CONFIG_BUFFER_UST_UID_SUBSET) { | |
180 | status = LTTNG_MAP_QUERY_STATUS_INVALID; | |
181 | goto end; | |
182 | } | |
183 | ||
184 | lttng_map_query_get_uid_count(query, &uid_count); | |
185 | if (uid_count > 0) { | |
186 | ERR("Only one UID can be targeted in a query at the moment"); | |
187 | status = LTTNG_MAP_QUERY_STATUS_INVALID; | |
188 | goto end; | |
189 | } | |
190 | ||
191 | ret = lttng_dynamic_array_add_element(&query->uid_array, &uid); | |
192 | if (ret) { | |
193 | status = LTTNG_MAP_QUERY_STATUS_ERROR; | |
194 | goto end; | |
195 | } | |
196 | ||
197 | status = LTTNG_MAP_QUERY_STATUS_OK; | |
198 | end: | |
199 | return status; | |
200 | } | |
201 | ||
202 | enum lttng_map_query_status lttng_map_query_add_pid( | |
203 | struct lttng_map_query *query, pid_t pid) | |
204 | { | |
205 | int ret; | |
206 | unsigned int pid_count; | |
207 | enum lttng_map_query_status status; | |
208 | ||
209 | if (query->config_buffer != LTTNG_MAP_QUERY_CONFIG_BUFFER_UST_PID_SUBSET) { | |
210 | status = LTTNG_MAP_QUERY_STATUS_INVALID; | |
211 | goto end; | |
212 | } | |
213 | ||
214 | lttng_map_query_get_pid_count(query, &pid_count); | |
215 | if (pid_count > 0) { | |
216 | ERR("Only one PID can be targeted in a query at the moment"); | |
217 | status = LTTNG_MAP_QUERY_STATUS_INVALID; | |
218 | goto end; | |
219 | } | |
220 | ||
221 | ret = lttng_dynamic_array_add_element(&query->pid_array, &pid); | |
222 | if (ret) { | |
223 | status = LTTNG_MAP_QUERY_STATUS_ERROR; | |
224 | goto end; | |
225 | } | |
226 | ||
227 | status = LTTNG_MAP_QUERY_STATUS_OK; | |
228 | end: | |
229 | return status; | |
230 | } | |
231 | ||
232 | enum lttng_map_query_status lttng_map_query_add_key_filter( | |
233 | struct lttng_map_query *query, const char *key_filter) | |
234 | { | |
235 | enum lttng_map_query_status status; | |
236 | ||
237 | query->key_filter = strdup(key_filter); | |
238 | if (!query->key_filter) { | |
239 | status = LTTNG_MAP_QUERY_STATUS_ERROR; | |
240 | goto end; | |
241 | } | |
242 | ||
243 | status = LTTNG_MAP_QUERY_STATUS_OK; | |
244 | end: | |
245 | return status; | |
246 | } | |
247 | ||
248 | enum lttng_map_query_config_cpu lttng_map_query_get_config_cpu( | |
249 | const struct lttng_map_query *query) | |
250 | { | |
251 | return query->config_cpu; | |
252 | } | |
253 | ||
254 | enum lttng_map_query_config_buffer lttng_map_query_get_config_buffer( | |
255 | const struct lttng_map_query *query) | |
256 | { | |
257 | return query->config_buffer; | |
258 | } | |
259 | ||
260 | enum lttng_map_query_config_app_bitness lttng_map_query_get_config_app_bitness( | |
261 | const struct lttng_map_query *query) | |
262 | { | |
263 | return query->config_bitness; | |
264 | } | |
265 | ||
266 | bool lttng_map_query_get_config_sum_by_cpu( | |
267 | const struct lttng_map_query *query) | |
268 | { | |
269 | return query->sum_by_cpu; | |
270 | } | |
271 | ||
272 | bool lttng_map_query_get_config_sum_by_pid( | |
273 | const struct lttng_map_query *query) | |
274 | { | |
275 | return query->sum_by_pid; | |
276 | } | |
277 | ||
278 | bool lttng_map_query_get_config_sum_by_uid( | |
279 | const struct lttng_map_query *query) | |
280 | { | |
281 | return query->sum_by_uid; | |
282 | } | |
283 | ||
284 | bool lttng_map_query_get_config_sum_by_app_bitness( | |
285 | const struct lttng_map_query *query) | |
286 | { | |
287 | return query->sum_by_app_bitness; | |
288 | } | |
289 | ||
290 | enum lttng_map_query_status lttng_map_query_get_cpu_count( | |
291 | const struct lttng_map_query *query, unsigned int *count) | |
292 | { | |
293 | enum lttng_map_query_status status; | |
294 | ||
295 | assert(query); | |
296 | if (query->config_cpu != LTTNG_MAP_QUERY_CONFIG_CPU_SUBSET) { | |
297 | status = LTTNG_MAP_QUERY_STATUS_INVALID; | |
298 | goto end; | |
299 | } | |
300 | ||
301 | if (!count) { | |
302 | status = LTTNG_MAP_QUERY_STATUS_INVALID; | |
303 | goto end; | |
304 | } | |
305 | ||
306 | *count = lttng_dynamic_array_get_count(&query->cpu_array); | |
307 | status = LTTNG_MAP_QUERY_STATUS_OK; | |
308 | ||
309 | end: | |
310 | return status; | |
311 | } | |
312 | ||
313 | enum lttng_map_query_status lttng_map_query_get_cpu_at_index( | |
314 | const struct lttng_map_query *query, unsigned int index, | |
315 | int *cpu) | |
316 | { | |
317 | enum lttng_map_query_status status; | |
318 | ||
319 | assert(query); | |
320 | ||
321 | if (query->config_cpu != LTTNG_MAP_QUERY_CONFIG_CPU_SUBSET) { | |
322 | status = LTTNG_MAP_QUERY_STATUS_INVALID; | |
323 | goto end; | |
324 | } | |
325 | ||
326 | ||
327 | *cpu = *(int *) lttng_dynamic_array_get_element(&query->cpu_array, index); | |
328 | status = LTTNG_MAP_QUERY_STATUS_OK; | |
329 | end: | |
330 | return status; | |
331 | } | |
332 | ||
333 | enum lttng_map_query_status lttng_map_query_get_uid_count( | |
334 | const struct lttng_map_query *query, unsigned int *count) | |
335 | { | |
336 | enum lttng_map_query_status status; | |
337 | ||
338 | assert(query); | |
339 | if (query->config_buffer != LTTNG_MAP_QUERY_CONFIG_BUFFER_UST_UID_SUBSET) { | |
340 | status = LTTNG_MAP_QUERY_STATUS_INVALID; | |
341 | goto end; | |
342 | } | |
343 | ||
344 | if (!count) { | |
345 | status = LTTNG_MAP_QUERY_STATUS_INVALID; | |
346 | goto end; | |
347 | } | |
348 | ||
349 | *count = lttng_dynamic_array_get_count(&query->uid_array); | |
350 | status = LTTNG_MAP_QUERY_STATUS_OK; | |
351 | ||
352 | end: | |
353 | return status; | |
354 | } | |
355 | ||
356 | enum lttng_map_query_status lttng_map_query_get_uid_at_index( | |
357 | const struct lttng_map_query *query, unsigned int index, | |
358 | uid_t *uid) | |
359 | { | |
360 | enum lttng_map_query_status status; | |
361 | ||
362 | assert(query); | |
363 | ||
364 | if (query->config_buffer != LTTNG_MAP_QUERY_CONFIG_BUFFER_UST_UID_SUBSET) { | |
365 | status = LTTNG_MAP_QUERY_STATUS_INVALID; | |
366 | goto end; | |
367 | } | |
368 | ||
369 | ||
370 | *uid = *(uid_t *) lttng_dynamic_array_get_element(&query->uid_array, index); | |
371 | status = LTTNG_MAP_QUERY_STATUS_OK; | |
372 | end: | |
373 | return status; | |
374 | } | |
375 | ||
376 | enum lttng_map_query_status lttng_map_query_get_pid_count( | |
377 | const struct lttng_map_query *query, unsigned int *count) | |
378 | { | |
379 | enum lttng_map_query_status status; | |
380 | ||
381 | assert(query); | |
382 | if (query->config_buffer != LTTNG_MAP_QUERY_CONFIG_BUFFER_UST_PID_SUBSET) { | |
383 | status = LTTNG_MAP_QUERY_STATUS_INVALID; | |
384 | goto end; | |
385 | } | |
386 | ||
387 | if (!count) { | |
388 | status = LTTNG_MAP_QUERY_STATUS_INVALID; | |
389 | goto end; | |
390 | } | |
391 | ||
392 | *count = lttng_dynamic_array_get_count(&query->pid_array); | |
393 | status = LTTNG_MAP_QUERY_STATUS_OK; | |
394 | ||
395 | end: | |
396 | return status; | |
397 | } | |
398 | ||
399 | enum lttng_map_query_status lttng_map_query_get_pid_at_index( | |
400 | const struct lttng_map_query *query, unsigned int index, | |
401 | pid_t *pid) | |
402 | { | |
403 | enum lttng_map_query_status status; | |
404 | ||
405 | assert(query); | |
406 | ||
407 | if (query->config_buffer != LTTNG_MAP_QUERY_CONFIG_BUFFER_UST_PID_SUBSET) { | |
408 | status = LTTNG_MAP_QUERY_STATUS_INVALID; | |
409 | goto end; | |
410 | } | |
411 | ||
412 | ||
413 | *pid = *(pid_t *) lttng_dynamic_array_get_element(&query->pid_array, index); | |
414 | status = LTTNG_MAP_QUERY_STATUS_OK; | |
415 | end: | |
416 | return status; | |
417 | } | |
418 | ||
419 | ||
420 | enum lttng_map_query_status lttng_map_query_get_key_filter( | |
421 | const struct lttng_map_query *query, const char **key_filter) | |
422 | { | |
423 | enum lttng_map_query_status status; | |
424 | ||
425 | if (query->key_filter == NULL) { | |
426 | status = LTTNG_MAP_QUERY_STATUS_NONE; | |
427 | goto end; | |
428 | } | |
429 | ||
430 | *key_filter = query->key_filter; | |
431 | status = LTTNG_MAP_QUERY_STATUS_OK; | |
432 | end: | |
433 | return status; | |
434 | } | |
435 | ||
436 | LTTNG_HIDDEN | |
437 | ssize_t lttng_map_query_create_from_payload(struct lttng_payload_view *src_view, | |
438 | struct lttng_map_query **query) | |
439 | { | |
440 | ssize_t ret, offset = 0; | |
441 | struct lttng_map_query *local_query; | |
442 | const struct lttng_map_query_comm *query_comm; | |
443 | ||
444 | if (!src_view || !query) { | |
445 | ret = -1; | |
446 | goto end; | |
447 | } | |
448 | ||
449 | query_comm = (typeof(query_comm)) src_view->buffer.data; | |
450 | offset += sizeof(*query_comm); | |
451 | ||
452 | local_query = lttng_map_query_create(query_comm->config_cpu, | |
453 | query_comm->config_buffer, query_comm->config_app_bitness); | |
454 | if (!local_query) { | |
455 | ret = -1; | |
456 | goto end; | |
457 | } | |
458 | ||
459 | local_query->sum_by_cpu = query_comm->sum_by_cpu; | |
460 | local_query->sum_by_pid = query_comm->sum_by_pid; | |
461 | local_query->sum_by_uid = query_comm->sum_by_uid; | |
462 | local_query->sum_by_app_bitness = query_comm->sum_by_app_bitness; | |
463 | ||
464 | if (query_comm->key_filter_length != 0) { | |
465 | const char *key_filter; | |
466 | struct lttng_payload_view key_filter_view = | |
467 | lttng_payload_view_from_view( | |
468 | src_view, offset, | |
469 | query_comm->key_filter_length); | |
470 | ||
471 | key_filter = key_filter_view.buffer.data; | |
472 | if (!lttng_buffer_view_contains_string(&key_filter_view.buffer, | |
473 | key_filter, query_comm->key_filter_length)){ | |
474 | ret = -1; | |
475 | goto end; | |
476 | } | |
477 | ||
478 | lttng_map_query_add_key_filter(local_query, key_filter); | |
479 | ||
480 | offset += query_comm->key_filter_length; | |
481 | } | |
482 | ||
483 | if (local_query->config_cpu == LTTNG_MAP_QUERY_CONFIG_CPU_SUBSET) { | |
484 | unsigned int cpu_idx; | |
485 | ||
486 | assert(query_comm->cpu_count > 0); | |
487 | ||
488 | for (cpu_idx = 0; cpu_idx < query_comm->cpu_count; cpu_idx++) { | |
489 | int cpu_id; | |
490 | struct lttng_payload_view cpu_id_view = | |
491 | lttng_payload_view_from_view( src_view, | |
492 | offset, sizeof(cpu_id)); | |
493 | cpu_id = *(int *) cpu_id_view.buffer.data; | |
494 | lttng_map_query_add_cpu(local_query, cpu_id); | |
495 | offset+=sizeof(cpu_id); | |
496 | } | |
497 | } | |
498 | ||
499 | switch (local_query->config_buffer){ | |
500 | case LTTNG_MAP_QUERY_CONFIG_BUFFER_UST_PID_SUBSET: | |
501 | { | |
502 | unsigned int pid_idx; | |
503 | ||
504 | assert(query_comm->pid_count > 0); | |
505 | ||
506 | for (pid_idx = 0; pid_idx < query_comm->pid_count; pid_idx++) { | |
507 | pid_t pid; | |
508 | struct lttng_payload_view pid_view = | |
509 | lttng_payload_view_from_view( src_view, | |
510 | offset, sizeof(pid)); | |
511 | pid = *(pid_t *) pid_view.buffer.data; | |
512 | lttng_map_query_add_pid(local_query, pid); | |
513 | offset+=sizeof(pid); | |
514 | } | |
515 | break; | |
516 | } | |
517 | case LTTNG_MAP_QUERY_CONFIG_BUFFER_UST_UID_SUBSET: | |
518 | { | |
519 | unsigned int uid_idx; | |
520 | ||
521 | assert(query_comm->uid_count > 0); | |
522 | ||
523 | for (uid_idx = 0; uid_idx < query_comm->uid_count; uid_idx++) { | |
524 | uid_t uid; | |
525 | struct lttng_payload_view uid_view = | |
526 | lttng_payload_view_from_view( src_view, | |
527 | offset, sizeof(uid)); | |
528 | uid = *(uid_t *) uid_view.buffer.data; | |
529 | lttng_map_query_add_uid(local_query, uid); | |
530 | offset+=sizeof(uid); | |
531 | } | |
532 | } | |
533 | default: | |
534 | break; | |
535 | } | |
536 | ||
537 | ret = offset; | |
538 | *query = local_query; | |
539 | local_query = NULL; | |
540 | end: | |
541 | return ret; | |
542 | } | |
543 | ||
544 | LTTNG_HIDDEN | |
545 | int lttng_map_query_serialize(const struct lttng_map_query *query, | |
546 | struct lttng_payload *payload) | |
547 | { | |
548 | int ret; | |
549 | struct lttng_map_query_comm query_comm = {}; | |
550 | enum lttng_map_query_status status; | |
551 | ||
552 | query_comm.config_cpu = (uint8_t) query->config_cpu; | |
553 | query_comm.config_buffer = (uint8_t) query->config_buffer; | |
554 | query_comm.config_app_bitness = (uint8_t) query->config_bitness; | |
555 | ||
556 | query_comm.sum_by_cpu = (uint8_t) query->sum_by_cpu; | |
557 | query_comm.sum_by_uid = (uint8_t) query->sum_by_uid; | |
558 | query_comm.sum_by_pid = (uint8_t) query->sum_by_pid; | |
559 | query_comm.sum_by_app_bitness = (uint8_t) query->sum_by_app_bitness; | |
560 | ||
561 | if (query->config_cpu == LTTNG_MAP_QUERY_CONFIG_CPU_SUBSET) { | |
562 | unsigned int cpu_count; | |
563 | status = lttng_map_query_get_cpu_count(query, &cpu_count); | |
564 | if (status != LTTNG_MAP_QUERY_STATUS_OK) { | |
565 | ret = -1; | |
566 | goto end; | |
567 | } | |
568 | ||
569 | query_comm.cpu_count = cpu_count; | |
570 | } | |
571 | ||
572 | switch (query->config_buffer){ | |
573 | case LTTNG_MAP_QUERY_CONFIG_BUFFER_UST_PID_SUBSET: | |
574 | { | |
575 | unsigned int pid_count; | |
576 | status = lttng_map_query_get_pid_count(query, &pid_count); | |
577 | if (status != LTTNG_MAP_QUERY_STATUS_OK) { | |
578 | ret = -1; | |
579 | goto end; | |
580 | } | |
581 | query_comm.pid_count = pid_count; | |
582 | break; | |
583 | } | |
584 | case LTTNG_MAP_QUERY_CONFIG_BUFFER_UST_UID_SUBSET: | |
585 | { | |
586 | unsigned int uid_count; | |
587 | status = lttng_map_query_get_uid_count(query, &uid_count); | |
588 | if (status != LTTNG_MAP_QUERY_STATUS_OK) { | |
589 | ret = -1; | |
590 | goto end; | |
591 | } | |
592 | query_comm.uid_count = uid_count; | |
593 | } | |
594 | default: | |
595 | break; | |
596 | } | |
597 | ||
598 | if (query->key_filter) { | |
599 | query_comm.key_filter_length = strlen(query->key_filter) + 1; | |
600 | } else { | |
601 | query_comm.key_filter_length = 0; | |
602 | } | |
603 | ||
604 | ret = lttng_dynamic_buffer_append(&payload->buffer, &query_comm, | |
605 | sizeof(query_comm)); | |
606 | if (ret) { | |
607 | goto end; | |
608 | } | |
609 | ||
610 | /* key_filter */ | |
611 | ret = lttng_dynamic_buffer_append( | |
612 | &payload->buffer, query->key_filter, | |
613 | query_comm.key_filter_length); | |
614 | if (ret) { | |
615 | goto end; | |
616 | } | |
617 | ||
618 | if (query->config_cpu == LTTNG_MAP_QUERY_CONFIG_CPU_SUBSET) { | |
619 | ret = lttng_dynamic_buffer_append(&payload->buffer, | |
620 | query->cpu_array.buffer.data, | |
621 | query->cpu_array.buffer.size); | |
622 | if (ret) { | |
623 | goto end; | |
624 | } | |
625 | } | |
626 | ||
627 | switch (query->config_buffer){ | |
628 | case LTTNG_MAP_QUERY_CONFIG_BUFFER_UST_PID_SUBSET: | |
629 | { | |
630 | ret = lttng_dynamic_buffer_append(&payload->buffer, | |
631 | query->pid_array.buffer.data, | |
632 | query->pid_array.buffer.size); | |
633 | if (ret) { | |
634 | goto end; | |
635 | } | |
636 | } | |
637 | case LTTNG_MAP_QUERY_CONFIG_BUFFER_UST_UID_SUBSET: | |
638 | { | |
639 | ret = lttng_dynamic_buffer_append(&payload->buffer, | |
640 | query->uid_array.buffer.data, | |
641 | query->uid_array.buffer.size); | |
642 | if (ret) { | |
643 | goto end; | |
644 | } | |
645 | } | |
646 | default: | |
647 | break; | |
648 | } | |
649 | ||
650 | end: | |
651 | return ret; | |
652 | } | |
653 | ||
654 | void lttng_map_query_destroy(struct lttng_map_query *query) | |
655 | { | |
656 | if (!query) { | |
657 | return; | |
658 | } | |
659 | ||
660 | if (query->config_cpu == LTTNG_MAP_QUERY_CONFIG_CPU_SUBSET) { | |
661 | lttng_dynamic_array_reset(&query->cpu_array); | |
662 | } | |
663 | ||
664 | switch(query->config_buffer) { | |
665 | case LTTNG_MAP_QUERY_CONFIG_BUFFER_UST_UID_SUBSET: | |
666 | lttng_dynamic_array_reset(&query->uid_array); | |
667 | break; | |
668 | case LTTNG_MAP_QUERY_CONFIG_BUFFER_UST_PID_SUBSET: | |
669 | lttng_dynamic_array_reset(&query->pid_array); | |
670 | break; | |
671 | default: | |
672 | break; | |
673 | } | |
674 | free(query->key_filter); | |
675 | free(query); | |
676 | } |