Fix: kconsumer: missing wait for metadata thread in do_sync_metadata
[lttng-tools.git] / src / common / tracker.c
CommitLineData
2d97a006 1/*
4942c256 2 * Copyright (C) 2019 Jonathan Rajotte <jonathan.rajotte-julien@efficios.com>
159b042f 3 * Copyright (C) 2020 Jérémie Galarneau <jeremie.galarneau@efficios.com>
2d97a006 4 *
ab5be9fa 5 * SPDX-License-Identifier: LGPL-2.1-only
2d97a006 6 *
2d97a006
JR
7 */
8
159b042f
JG
9#include <lttng/domain.h>
10#include <lttng/lttng-error.h>
11#include <lttng/tracker.h>
2d97a006 12
159b042f
JG
13#include <common/dynamic-array.h>
14#include <common/error.h>
15#include <common/hashtable/hashtable.h>
16#include <common/hashtable/utils.h>
17#include <common/tracker.h>
18
19#include <stdbool.h>
20
21struct process_attr_tracker_values_comm_header {
22 uint32_t count;
23};
24
25struct process_attr_tracker_value_comm {
26 /* enum lttng_process_attr_value_type */
27 int32_t type;
28 union {
29 struct process_attr_integral_value_comm integral;
30 /* Includes the '\0' terminator. */
31 uint32_t name_len;
32 } value;
33};
34
35#define GET_INTEGRAL_COMM_VALUE(value_ptr, as_type) \
36 ((as_type)(is_signed(as_type) ? (value_ptr)->u._signed : \
37 (value_ptr)->u._unsigned))
38
39#define SET_INTEGRAL_COMM_VALUE(comm_value, value) \
40 if (is_signed(typeof(value))) { \
41 (comm_value)->u._signed = \
42 (typeof((comm_value)->u._signed)) value; \
43 } else { \
44 (comm_value)->u._unsigned = \
45 (typeof((comm_value)->u._unsigned)) value; \
2d97a006
JR
46 }
47
159b042f
JG
48static inline bool is_virtual_process_attr(enum lttng_process_attr process_attr)
49{
50 return process_attr == LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID ||
51 process_attr == LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID ||
52 process_attr == LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID;
2d97a006
JR
53}
54
159b042f
JG
55static inline bool is_value_type_name(
56 enum lttng_process_attr_value_type value_type)
2d97a006 57{
159b042f
JG
58 return value_type == LTTNG_PROCESS_ATTR_VALUE_TYPE_USER_NAME ||
59 value_type == LTTNG_PROCESS_ATTR_VALUE_TYPE_GROUP_NAME;
2d97a006
JR
60}
61
159b042f
JG
62LTTNG_HIDDEN
63enum lttng_error_code process_attr_value_from_comm(
64 enum lttng_domain_type domain,
65 enum lttng_process_attr process_attr,
66 enum lttng_process_attr_value_type value_type,
67 const struct process_attr_integral_value_comm *integral_value,
68 const struct lttng_buffer_view *value_view,
69 struct process_attr_value **_value)
2d97a006 70{
159b042f
JG
71 char *name = NULL;
72 enum lttng_error_code ret = LTTNG_OK;
73 struct process_attr_value *value = zmalloc(sizeof(*value));
2d97a006 74
159b042f
JG
75 if (!value) {
76 ret = LTTNG_ERR_NOMEM;
2d97a006
JR
77 goto error;
78 }
79
159b042f
JG
80 if (value_view && value_view->size > 0) {
81 if (value_view->data[value_view->size - 1] != '\0') {
82 ret = LTTNG_ERR_INVALID;
83 goto error;
84 }
85 name = strdup(value_view->data);
86 if (!name) {
87 ret = LTTNG_ERR_NOMEM;
74675e31 88 goto error;
159b042f
JG
89 }
90 }
2d97a006 91
159b042f
JG
92 if (domain != LTTNG_DOMAIN_UST && domain != LTTNG_DOMAIN_KERNEL) {
93 ERR("Only the user space and kernel space domains may be specified to configure process attribute trackers");
94 ret = LTTNG_ERR_UNSUPPORTED_DOMAIN;
95 goto error;
96 }
2d97a006 97
159b042f
JG
98 if (!is_virtual_process_attr(process_attr) &&
99 domain != LTTNG_DOMAIN_KERNEL) {
100 ERR("Non-virtual process attributes can only be used in the kernel domain");
101 ret = LTTNG_ERR_UNSUPPORTED_DOMAIN;
102 goto error;
103 }
2d97a006 104
159b042f 105 /* Only expect a payload for name value types. */
b78dab17
JG
106 if (is_value_type_name(value_type) &&
107 (!value_view || value_view->size == 0)) {
159b042f
JG
108 ret = LTTNG_ERR_INVALID_PROTOCOL;
109 goto error;
1ad5cb59
JG
110 } else if (!is_value_type_name(value_type) && value_view &&
111 value_view->size != 0) {
159b042f
JG
112 ret = LTTNG_ERR_INVALID_PROTOCOL;
113 goto error;
2d97a006
JR
114 }
115
159b042f
JG
116 value->type = value_type;
117 switch (process_attr) {
118 case LTTNG_PROCESS_ATTR_PROCESS_ID:
119 case LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID:
120 if (value_type != LTTNG_PROCESS_ATTR_VALUE_TYPE_PID) {
121 ERR("Invalid value type used for process ID process attribute");
122 ret = LTTNG_ERR_INVALID;
123 goto error;
124 }
125 value->value.pid =
126 GET_INTEGRAL_COMM_VALUE(integral_value, pid_t);
127 break;
128 case LTTNG_PROCESS_ATTR_USER_ID:
129 case LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID:
130 switch (value_type) {
131 case LTTNG_PROCESS_ATTR_VALUE_TYPE_UID:
132 value->value.uid = GET_INTEGRAL_COMM_VALUE(
133 integral_value, uid_t);
134 break;
135 case LTTNG_PROCESS_ATTR_VALUE_TYPE_USER_NAME:
136 if (!name) {
137 ret = LTTNG_ERR_INVALID;
138 goto error;
139 }
140
141 value->value.user_name = name;
142 name = NULL;
143 break;
144 default:
145 ERR("Invalid value type used for user ID process attribute");
146 ret = LTTNG_ERR_INVALID;
147 goto error;
148 }
149 break;
150 case LTTNG_PROCESS_ATTR_GROUP_ID:
151 case LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID:
152 switch (value_type) {
153 case LTTNG_PROCESS_ATTR_VALUE_TYPE_GID:
154 value->value.gid = GET_INTEGRAL_COMM_VALUE(
155 integral_value, gid_t);
156 break;
157 case LTTNG_PROCESS_ATTR_VALUE_TYPE_GROUP_NAME:
158 if (!name) {
159 ret = LTTNG_ERR_INVALID;
160 goto error;
161 }
162
163 value->value.group_name = name;
164 name = NULL;
165 break;
166 default:
167 ERR("Invalid value type used for group ID process attribute");
168 ret = LTTNG_ERR_INVALID;
169 goto error;
170 }
171 break;
172 default:
173 ret = LTTNG_ERR_INVALID_PROTOCOL;
174 goto error;
2d97a006
JR
175 }
176
159b042f
JG
177 *_value = value;
178 value = NULL;
d4e37173 179 free(name);
159b042f
JG
180 return LTTNG_OK;
181error:
182 free(name);
183 process_attr_value_destroy(value);
184 return ret;
2d97a006
JR
185}
186
159b042f
JG
187LTTNG_HIDDEN
188const char *lttng_process_attr_to_string(enum lttng_process_attr process_attr)
2d97a006 189{
159b042f
JG
190 switch (process_attr) {
191 case LTTNG_PROCESS_ATTR_PROCESS_ID:
192 return "process ID";
193 case LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID:
194 return "virtual process ID";
195 case LTTNG_PROCESS_ATTR_USER_ID:
196 return "user ID";
197 case LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID:
198 return "virtual user ID";
199 case LTTNG_PROCESS_ATTR_GROUP_ID:
200 return "group ID";
201 case LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID:
202 return "virtual group ID";
203 default:
204 return "unknown process attribute";
2d97a006 205 }
2d97a006
JR
206}
207
159b042f 208static void process_attr_tracker_value_destructor(void *ptr)
2d97a006 209{
159b042f
JG
210 struct process_attr_value *value = (typeof(value)) ptr;
211
212 process_attr_value_destroy(value);
2d97a006
JR
213}
214
159b042f
JG
215LTTNG_HIDDEN
216struct lttng_process_attr_values *lttng_process_attr_values_create(void)
2d97a006 217{
159b042f 218 struct lttng_process_attr_values *values = zmalloc(sizeof(*values));
2d97a006 219
159b042f
JG
220 if (!values) {
221 goto end;
2d97a006
JR
222 }
223
159b042f
JG
224 lttng_dynamic_pointer_array_init(
225 &values->array, process_attr_tracker_value_destructor);
226end:
227 return values;
2d97a006
JR
228}
229
159b042f
JG
230LTTNG_HIDDEN
231unsigned int _lttng_process_attr_values_get_count(
232 const struct lttng_process_attr_values *values)
2d97a006 233{
159b042f
JG
234 return (unsigned int) lttng_dynamic_pointer_array_get_count(
235 &values->array);
2d97a006
JR
236}
237
159b042f
JG
238LTTNG_HIDDEN
239const struct process_attr_value *lttng_process_attr_tracker_values_get_at_index(
240 const struct lttng_process_attr_values *values,
241 unsigned int index)
2d97a006 242{
159b042f
JG
243 return lttng_dynamic_pointer_array_get_pointer(&values->array, index);
244}
2d97a006 245
159b042f
JG
246static
247int process_attr_tracker_value_serialize(const struct process_attr_value *value,
248 struct lttng_dynamic_buffer *buffer)
249{
250 int ret;
251 struct process_attr_tracker_value_comm value_comm = {
252 .type = (int32_t) value->type,
253 };
254 const char *name = NULL;
255
256 switch (value->type) {
257 case LTTNG_PROCESS_ATTR_VALUE_TYPE_PID:
258 SET_INTEGRAL_COMM_VALUE(
259 &value_comm.value.integral, value->value.pid);
2d97a006 260 break;
159b042f
JG
261 case LTTNG_PROCESS_ATTR_VALUE_TYPE_UID:
262 SET_INTEGRAL_COMM_VALUE(
263 &value_comm.value.integral, value->value.uid);
2d97a006 264 break;
159b042f
JG
265 case LTTNG_PROCESS_ATTR_VALUE_TYPE_GID:
266 SET_INTEGRAL_COMM_VALUE(
267 &value_comm.value.integral, value->value.gid);
2d97a006 268 break;
159b042f
JG
269 case LTTNG_PROCESS_ATTR_VALUE_TYPE_USER_NAME:
270 name = value->value.user_name;
2d97a006 271 break;
159b042f
JG
272 case LTTNG_PROCESS_ATTR_VALUE_TYPE_GROUP_NAME:
273 name = value->value.group_name;
274 break;
275 default:
276 abort();
2d97a006
JR
277 }
278
159b042f
JG
279 if (name) {
280 value_comm.value.name_len = strlen(name) + 1;
a7a533cd 281 }
159b042f
JG
282
283 ret = lttng_dynamic_buffer_append(
284 buffer, &value_comm, sizeof(value_comm));
285 if (ret) {
286 goto end;
287 }
288
289 if (name) {
290 ret = lttng_dynamic_buffer_append(
291 buffer, name, value_comm.value.name_len);
292 }
293end:
a7a533cd
JR
294 return ret;
295}
296
159b042f
JG
297LTTNG_HIDDEN
298int lttng_process_attr_values_serialize(
299 const struct lttng_process_attr_values *values,
300 struct lttng_dynamic_buffer *buffer)
a7a533cd
JR
301{
302 int ret;
159b042f
JG
303 unsigned int count, i;
304 struct process_attr_tracker_values_comm_header header = {};
a7a533cd 305
159b042f
JG
306 count = _lttng_process_attr_values_get_count(values);
307 header.count = (uint32_t) count;
a7a533cd 308
159b042f 309 ret = lttng_dynamic_buffer_append(buffer, &header, sizeof(header));
a7a533cd 310 if (ret) {
159b042f 311 goto end;
2d97a006
JR
312 }
313
159b042f
JG
314 for (i = 0; i < count; i++) {
315 const struct process_attr_value *value =
316 lttng_process_attr_tracker_values_get_at_index(
317 values, i);
2d97a006 318
159b042f
JG
319 ret = process_attr_tracker_value_serialize(value, buffer);
320 if (ret) {
321 goto end;
322 }
2d97a006 323 }
159b042f
JG
324end:
325 return ret;
2d97a006 326}
a7a533cd 327
159b042f
JG
328LTTNG_HIDDEN
329ssize_t lttng_process_attr_values_create_from_buffer(
330 enum lttng_domain_type domain,
331 enum lttng_process_attr process_attr,
332 const struct lttng_buffer_view *buffer_view,
333 struct lttng_process_attr_values **_values)
a7a533cd 334{
159b042f
JG
335 ssize_t offset;
336 unsigned int i;
337 struct lttng_process_attr_values *values;
338 struct lttng_buffer_view header_view;
339 const struct process_attr_tracker_values_comm_header *header;
a7a533cd 340
159b042f
JG
341 values = lttng_process_attr_values_create();
342 if (!values) {
a7a533cd
JR
343 goto error;
344 }
345
159b042f
JG
346 header_view = lttng_buffer_view_from_view(
347 buffer_view, 0, sizeof(*header));
348 if (!header_view.data) {
a7a533cd
JR
349 goto error;
350 }
159b042f
JG
351 offset = header_view.size;
352 header = (typeof(header)) header_view.data;
353
354 /*
355 * Check that the number of values is not absurdly large with respect to
356 * the received buffer's size.
357 */
358 if (buffer_view->size <
359 header->count * sizeof(struct process_attr_tracker_value_comm)) {
360 goto error;
361 }
362 for (i = 0; i < (unsigned int) header->count; i++) {
363 int ret;
364 enum lttng_error_code ret_code;
365 const struct process_attr_tracker_value_comm *value_comm;
366 struct process_attr_value *value;
367 enum lttng_process_attr_value_type type;
368 struct lttng_buffer_view value_view;
369 struct lttng_buffer_view value_name_view = {};
370
371 value_view = lttng_buffer_view_from_view(
372 buffer_view, offset, sizeof(*value_comm));
373 if (!value_view.data) {
374 goto error;
375 }
a7a533cd 376
159b042f
JG
377 offset += value_view.size;
378 value_comm = (typeof(value_comm)) value_view.data;
379 type = (typeof(type)) value_comm->type;
a7a533cd 380
159b042f
JG
381 if (is_value_type_name(type)) {
382 value_name_view = lttng_buffer_view_from_view(
383 buffer_view, offset,
384 value_comm->value.name_len);
385 offset += value_name_view.size;
386 }
387 ret_code = process_attr_value_from_comm(domain, process_attr,
388 type, &value_comm->value.integral,
389 &value_name_view, &value);
390 if (ret_code != LTTNG_OK) {
391 goto error;
392 }
a7a533cd 393
159b042f
JG
394 ret = lttng_dynamic_pointer_array_add_pointer(
395 &values->array, value);
396 if (ret) {
397 process_attr_value_destroy(value);
398 goto error;
399 }
a7a533cd
JR
400 }
401
159b042f
JG
402 *_values = values;
403 return offset;
404error:
405 lttng_process_attr_values_destroy(values);
406 return -1;
a7a533cd
JR
407}
408
159b042f
JG
409LTTNG_HIDDEN
410void lttng_process_attr_values_destroy(struct lttng_process_attr_values *values)
a7a533cd 411{
159b042f
JG
412 if (!values) {
413 return;
414 }
415 lttng_dynamic_pointer_array_reset(&values->array);
416 free(values);
a7a533cd
JR
417}
418
159b042f
JG
419LTTNG_HIDDEN
420struct process_attr_value *process_attr_value_copy(
421 const struct process_attr_value *value)
a7a533cd 422{
159b042f 423 struct process_attr_value *new_value = NULL;
e283e4a0 424
159b042f 425 if (!value) {
e283e4a0
JR
426 goto end;
427 }
428
159b042f
JG
429 new_value = zmalloc(sizeof(*new_value));
430 if (!new_value) {
431 goto end;
432 }
433 if (is_value_type_name(value->type)) {
434 const char *src =
435 value->type == LTTNG_PROCESS_ATTR_VALUE_TYPE_USER_NAME ?
436 value->value.user_name :
437 value->value.group_name;
438 char **dst = value->type == LTTNG_PROCESS_ATTR_VALUE_TYPE_USER_NAME ?
439 &new_value->value.user_name :
440 &new_value->value.group_name;
441
442 new_value->type = value->type;
443 *dst = strdup(src);
444 if (!*dst) {
445 goto error;
446 }
447 } else {
448 *new_value = *value;
449 }
e283e4a0 450end:
159b042f
JG
451 return new_value;
452error:
453 free(new_value);
454 return NULL;
a7a533cd
JR
455}
456
159b042f
JG
457LTTNG_HIDDEN
458unsigned long process_attr_value_hash(const struct process_attr_value *a)
a7a533cd 459{
159b042f 460 unsigned long hash = hash_key_ulong((void *) a->type, lttng_ht_seed);
9df6c82a 461
159b042f
JG
462 switch (a->type) {
463 case LTTNG_PROCESS_ATTR_VALUE_TYPE_PID:
464 hash ^= hash_key_ulong((void *) (unsigned long) a->value.pid,
465 lttng_ht_seed);
466 break;
467 case LTTNG_PROCESS_ATTR_VALUE_TYPE_UID:
468 hash ^= hash_key_ulong((void *) (unsigned long) a->value.uid,
469 lttng_ht_seed);
470 break;
471 case LTTNG_PROCESS_ATTR_VALUE_TYPE_GID:
472 hash ^= hash_key_ulong((void *) (unsigned long) a->value.gid,
473 lttng_ht_seed);
474 break;
475 case LTTNG_PROCESS_ATTR_VALUE_TYPE_USER_NAME:
476 hash ^= hash_key_str(a->value.user_name, lttng_ht_seed);
477 break;
478 case LTTNG_PROCESS_ATTR_VALUE_TYPE_GROUP_NAME:
479 hash ^= hash_key_str(a->value.group_name, lttng_ht_seed);
480 break;
481 default:
482 abort();
a7a533cd
JR
483 }
484
159b042f 485 return hash;
a7a533cd 486}
f19f5c96 487
159b042f
JG
488LTTNG_HIDDEN
489bool process_attr_tracker_value_equal(const struct process_attr_value *a,
490 const struct process_attr_value *b)
f19f5c96 491{
159b042f
JG
492 if (a->type != b->type) {
493 return false;
f19f5c96 494 }
159b042f
JG
495 switch (a->type) {
496 case LTTNG_PROCESS_ATTR_VALUE_TYPE_PID:
497 return a->value.pid == b->value.pid;
498 case LTTNG_PROCESS_ATTR_VALUE_TYPE_UID:
499 return a->value.uid == b->value.uid;
500 case LTTNG_PROCESS_ATTR_VALUE_TYPE_GID:
501 return a->value.gid == b->value.gid;
502 case LTTNG_PROCESS_ATTR_VALUE_TYPE_USER_NAME:
503 return !strcmp(a->value.user_name, b->value.user_name);
504 case LTTNG_PROCESS_ATTR_VALUE_TYPE_GROUP_NAME:
505 return !strcmp(a->value.group_name, b->value.group_name);
506 default:
507 abort();
508 }
509}
f19f5c96 510
159b042f
JG
511LTTNG_HIDDEN
512void process_attr_value_destroy(struct process_attr_value *value)
513{
514 if (!value) {
515 return;
f19f5c96 516 }
159b042f
JG
517 if (is_value_type_name(value->type)) {
518 free(value->type == LTTNG_PROCESS_ATTR_VALUE_TYPE_USER_NAME ?
519 value->value.user_name :
520 value->value.group_name);
521 }
522 free(value);
f19f5c96 523}
This page took 0.050417 seconds and 4 git commands to generate.