Allow run-as to generate filter bytecode.
[lttng-tools.git] / src / common / runas.c
CommitLineData
60b6c79c 1/*
ab5be9fa
MJ
2 * Copyright (C) 2011 David Goulet <david.goulet@polymtl.ca>
3 * Copyright (C) 2011 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
4 * Copyright (C) 2019 Jérémie Galarneau <jeremie.galarneau@efficios.com>
60b6c79c 5 *
ab5be9fa 6 * SPDX-License-Identifier: GPL-2.0-only
60b6c79c 7 *
60b6c79c
MD
8 */
9
6c1c0768 10#define _LGPL_SOURCE
60b6c79c
MD
11#include <errno.h>
12#include <limits.h>
13#include <stdio.h>
14#include <stdlib.h>
15#include <string.h>
16#include <sys/wait.h>
17#include <sys/types.h>
18#include <sys/stat.h>
19#include <unistd.h>
20#include <fcntl.h>
c2b75c49 21#include <sched.h>
0452bf08 22#include <signal.h>
749b7a0c 23#include <assert.h>
e1055edb 24#include <signal.h>
60b6c79c 25
0ef03255 26#include <common/lttng-kernel.h>
90e535ef 27#include <common/common.h>
3fd15a74 28#include <common/utils.h>
e8fa9fb0 29#include <common/compat/getenv.h>
c73f064a 30#include <common/compat/string.h>
2038dd6c
JG
31#include <common/unix.h>
32#include <common/defaults.h>
241e0a5a 33#include <common/lttng-elf.h>
cb8d0d24 34#include <common/thread.h>
241e0a5a
FD
35
36#include <lttng/constant.h>
60b6c79c 37
c73f064a
JR
38#include <common/sessiond-comm/sessiond-comm.h>
39#include <common/filter/filter-ast.h>
40#include <common/filter/filter-bytecode.h>
41
0857097f
DG
42#include "runas.h"
43
7567352f 44struct run_as_data;
fe9f7760
FD
45struct run_as_ret;
46typedef int (*run_as_fct)(struct run_as_data *data, struct run_as_ret *ret_value);
c2b75c49 47
93bed9fe
JG
48enum run_as_cmd {
49 RUN_AS_MKDIR,
50 RUN_AS_MKDIRAT,
51 RUN_AS_MKDIR_RECURSIVE,
52 RUN_AS_MKDIRAT_RECURSIVE,
53 RUN_AS_OPEN,
54 RUN_AS_OPENAT,
55 RUN_AS_UNLINK,
56 RUN_AS_UNLINKAT,
57 RUN_AS_RMDIR,
58 RUN_AS_RMDIRAT,
59 RUN_AS_RMDIR_RECURSIVE,
60 RUN_AS_RMDIRAT_RECURSIVE,
61 RUN_AS_RENAME,
62 RUN_AS_RENAMEAT,
63 RUN_AS_EXTRACT_ELF_SYMBOL_OFFSET,
64 RUN_AS_EXTRACT_SDT_PROBE_OFFSETS,
c73f064a 65 RUN_AS_GENERATE_FILTER_BYTECODE,
60b6c79c
MD
66};
67
93bed9fe
JG
68struct run_as_mkdir_data {
69 int dirfd;
70 char path[LTTNG_PATH_MAX];
71 mode_t mode;
72} LTTNG_PACKED;
73
e11d277b 74struct run_as_open_data {
93bed9fe
JG
75 int dirfd;
76 char path[LTTNG_PATH_MAX];
60b6c79c
MD
77 int flags;
78 mode_t mode;
93bed9fe 79} LTTNG_PACKED;
60b6c79c 80
4628484a 81struct run_as_unlink_data {
93bed9fe
JG
82 int dirfd;
83 char path[LTTNG_PATH_MAX];
84} LTTNG_PACKED;
4628484a 85
93bed9fe
JG
86struct run_as_rmdir_data {
87 int dirfd;
88 char path[LTTNG_PATH_MAX];
c73f064a 89 int flags; /* enum lttng_directory_handle_rmdir_recursive_flags. */
93bed9fe 90} LTTNG_PACKED;
7567352f 91
241e0a5a 92struct run_as_extract_elf_symbol_offset_data {
93bed9fe 93 int fd;
241e0a5a 94 char function[LTTNG_SYMBOL_NAME_LEN];
93bed9fe 95} LTTNG_PACKED;
241e0a5a 96
0ef03255 97struct run_as_extract_sdt_probe_offsets_data {
93bed9fe 98 int fd;
0ef03255
FD
99 char probe_name[LTTNG_SYMBOL_NAME_LEN];
100 char provider_name[LTTNG_SYMBOL_NAME_LEN];
93bed9fe 101} LTTNG_PACKED;
0ef03255 102
c73f064a
JR
103struct run_as_generate_filter_bytecode_data {
104 char filter_expression[LTTNG_FILTER_MAX_LEN];
105} LTTNG_PACKED;
106
93bed9fe
JG
107struct run_as_rename_data {
108 /*
109 * [0] = old_dirfd
110 * [1] = new_dirfd
111 */
112 int dirfds[2];
113 char old_path[LTTNG_PATH_MAX];
114 char new_path[LTTNG_PATH_MAX];
115} LTTNG_PACKED;
fe9f7760
FD
116
117struct run_as_open_ret {
93bed9fe
JG
118 int fd;
119} LTTNG_PACKED;
fe9f7760 120
241e0a5a
FD
121struct run_as_extract_elf_symbol_offset_ret {
122 uint64_t offset;
93bed9fe 123} LTTNG_PACKED;
241e0a5a 124
0ef03255
FD
125struct run_as_extract_sdt_probe_offsets_ret {
126 uint32_t num_offset;
127 uint64_t offsets[LTTNG_KERNEL_MAX_UPROBE_NUM];
93bed9fe 128} LTTNG_PACKED;
7567352f 129
c73f064a
JR
130struct run_as_generate_filter_bytecode_ret {
131 /* A lttng_bytecode_filter struct with 'dynamic' payload. */
132 char bytecode[LTTNG_FILTER_MAX_LEN];
133} LTTNG_PACKED;
134
7567352f
MD
135struct run_as_data {
136 enum run_as_cmd cmd;
137 union {
93bed9fe 138 struct run_as_mkdir_data mkdir;
7567352f
MD
139 struct run_as_open_data open;
140 struct run_as_unlink_data unlink;
93bed9fe
JG
141 struct run_as_rmdir_data rmdir;
142 struct run_as_rename_data rename;
241e0a5a 143 struct run_as_extract_elf_symbol_offset_data extract_elf_symbol_offset;
0ef03255 144 struct run_as_extract_sdt_probe_offsets_data extract_sdt_probe_offsets;
c73f064a 145 struct run_as_generate_filter_bytecode_data generate_filter_bytecode;
7567352f
MD
146 } u;
147 uid_t uid;
148 gid_t gid;
93bed9fe 149} LTTNG_PACKED;
4628484a 150
fe9f7760
FD
151/*
152 * The run_as_ret structure holds the returned value and status of the command.
153 *
154 * The `u` union field holds the return value of the command; in most cases it
155 * represents the success or the failure of the command. In more complex
156 * commands, it holds a computed value.
157 *
158 * The _errno field is the errno recorded after the execution of the command.
159 *
160 * The _error fields is used the signify that return status of the command. For
161 * simple commands returning `int` the _error field will be the same as the
162 * ret_int field. In complex commands, it signify the success or failure of the
163 * command.
164 *
165 */
df5b86c8 166struct run_as_ret {
fe9f7760 167 union {
93bed9fe 168 int ret;
fe9f7760 169 struct run_as_open_ret open;
241e0a5a 170 struct run_as_extract_elf_symbol_offset_ret extract_elf_symbol_offset;
0ef03255 171 struct run_as_extract_sdt_probe_offsets_ret extract_sdt_probe_offsets;
c73f064a 172 struct run_as_generate_filter_bytecode_ret generate_filter_bytecode;
fe9f7760 173 } u;
df5b86c8 174 int _errno;
fe9f7760 175 bool _error;
93bed9fe
JG
176} LTTNG_PACKED;
177
178#define COMMAND_IN_FDS(data_ptr) ({ \
179 int *fds = NULL; \
180 if (command_properties[data_ptr->cmd].in_fds_offset != -1) { \
181 fds = (int *) ((char *) data_ptr + command_properties[data_ptr->cmd].in_fds_offset); \
182 } \
183 fds; \
184})
185
186#define COMMAND_OUT_FDS(cmd, ret_ptr) ({ \
187 int *fds = NULL; \
188 if (command_properties[cmd].out_fds_offset != -1) { \
189 fds = (int *) ((char *) ret_ptr + command_properties[cmd].out_fds_offset); \
190 } \
191 fds; \
192})
193
194#define COMMAND_IN_FD_COUNT(data_ptr) ({ \
195 command_properties[data_ptr->cmd].in_fd_count; \
196})
197
198#define COMMAND_OUT_FD_COUNT(cmd) ({ \
199 command_properties[cmd].out_fd_count; \
200})
201
202#define COMMAND_USE_CWD_FD(data_ptr) command_properties[data_ptr->cmd].use_cwd_fd
203
204struct run_as_command_properties {
205 /* Set to -1 when not applicable. */
206 ptrdiff_t in_fds_offset, out_fds_offset;
207 unsigned int in_fd_count, out_fd_count;
208 bool use_cwd_fd;
209};
210
211static const struct run_as_command_properties command_properties[] = {
212 [RUN_AS_MKDIR] = {
213 .in_fds_offset = offsetof(struct run_as_data, u.mkdir.dirfd),
214 .in_fd_count = 1,
215 .out_fds_offset = -1,
216 .out_fd_count = 0,
217 .use_cwd_fd = true,
218 },
219 [RUN_AS_MKDIRAT] = {
220 .in_fds_offset = offsetof(struct run_as_data, u.mkdir.dirfd),
221 .in_fd_count = 1,
222 .out_fds_offset = -1,
223 .out_fd_count = 0,
224 .use_cwd_fd = false,
225 },
226 [RUN_AS_MKDIR_RECURSIVE] = {
227 .in_fds_offset = offsetof(struct run_as_data, u.mkdir.dirfd),
228 .in_fd_count = 1,
229 .out_fds_offset = -1,
230 .out_fd_count = 0,
231 .use_cwd_fd = true,
232 },
233 [RUN_AS_MKDIRAT_RECURSIVE] = {
234 .in_fds_offset = offsetof(struct run_as_data, u.mkdir.dirfd),
235 .in_fd_count = 1,
236 .out_fds_offset = -1,
237 .out_fd_count = 0,
238 .use_cwd_fd = false,
239 },
240 [RUN_AS_OPEN] = {
241 .in_fds_offset = offsetof(struct run_as_data, u.open.dirfd),
242 .in_fd_count = 1,
243 .out_fds_offset = offsetof(struct run_as_ret, u.open.fd),
244 .out_fd_count = 1,
245 .use_cwd_fd = true,
246 },
247 [RUN_AS_OPENAT] = {
248 .in_fds_offset = offsetof(struct run_as_data, u.open.dirfd),
249 .in_fd_count = 1,
250 .out_fds_offset = offsetof(struct run_as_ret, u.open.fd),
251 .out_fd_count = 1,
252 .use_cwd_fd = false,
253 },
254 [RUN_AS_UNLINK] = {
255 .in_fds_offset = offsetof(struct run_as_data, u.unlink.dirfd),
256 .in_fd_count = 1,
257 .out_fds_offset = -1,
258 .out_fd_count = 0,
259 .use_cwd_fd = true,
260 },
261 [RUN_AS_UNLINKAT] = {
262 .in_fds_offset = offsetof(struct run_as_data, u.unlink.dirfd),
263 .in_fd_count = 1,
264 .out_fds_offset = -1,
265 .out_fd_count = 0,
266 .use_cwd_fd = false,
267 },
268 [RUN_AS_RMDIR_RECURSIVE] = {
269 .in_fds_offset = offsetof(struct run_as_data, u.rmdir.dirfd),
270 .in_fd_count = 1,
271 .out_fds_offset = -1,
272 .out_fd_count = 0,
273 .use_cwd_fd = true,
274 },
275 [RUN_AS_RMDIRAT_RECURSIVE] = {
276 .in_fds_offset = offsetof(struct run_as_data, u.rmdir.dirfd),
277 .in_fd_count = 1,
278 .out_fds_offset = -1,
279 .out_fd_count = 0,
280 .use_cwd_fd = false,
281 },
282 [RUN_AS_RMDIR] = {
283 .in_fds_offset = offsetof(struct run_as_data, u.rmdir.dirfd),
284 .in_fd_count = 1,
285 .out_fds_offset = -1,
286 .out_fd_count = 0,
287 .use_cwd_fd = true,
288 },
289 [RUN_AS_RMDIRAT] = {
290 .in_fds_offset = offsetof(struct run_as_data, u.rmdir.dirfd),
291 .in_fd_count = 1,
292 .out_fds_offset = -1,
293 .out_fd_count = 0,
294 .use_cwd_fd = false,
295 },
296 [RUN_AS_RENAME] = {
297 .in_fds_offset = offsetof(struct run_as_data, u.rename.dirfds),
298 .in_fd_count = 2,
299 .out_fds_offset = -1,
300 .out_fd_count = 0,
301 .use_cwd_fd = true,
302 },
303 [RUN_AS_RENAMEAT] = {
304 .in_fds_offset = offsetof(struct run_as_data, u.rename.dirfds),
305 .in_fd_count = 2,
306 .out_fds_offset = -1,
307 .out_fd_count = 0,
308 .use_cwd_fd = false,
309 },
310 [RUN_AS_EXTRACT_ELF_SYMBOL_OFFSET] = {
311 .in_fds_offset = offsetof(struct run_as_data,
312 u.extract_elf_symbol_offset.fd),
313 .in_fd_count = 1,
314 .out_fds_offset = -1,
315 .out_fd_count = 0,
316 .use_cwd_fd = false,
317 },
318 [RUN_AS_EXTRACT_SDT_PROBE_OFFSETS] = {
319 .in_fds_offset = offsetof(struct run_as_data,
320 u.extract_sdt_probe_offsets.fd),
321 .in_fd_count = 1,
322 .out_fds_offset = -1,
323 .out_fd_count = 0,
324 .use_cwd_fd = false,
325 },
c73f064a
JR
326 [RUN_AS_GENERATE_FILTER_BYTECODE] = {
327 .in_fds_offset = -1,
328 .in_fd_count = 0,
329 .out_fds_offset = -1,
330 .out_fd_count = 0,
331 .use_cwd_fd = false,
332 },
df5b86c8
MD
333};
334
7567352f
MD
335struct run_as_worker {
336 pid_t pid; /* Worker PID. */
337 int sockpair[2];
338 char *procname;
339};
340
341/* Single global worker per process (for now). */
342static struct run_as_worker *global_worker;
343/* Lock protecting the worker. */
344static pthread_mutex_t worker_lock = PTHREAD_MUTEX_INITIALIZER;
345
8f0044bf
MD
346#ifdef VALGRIND
347static
348int use_clone(void)
349{
350 return 0;
351}
352#else
353static
354int use_clone(void)
355{
e8fa9fb0 356 return !lttng_secure_getenv("LTTNG_DEBUG_NOCLONE");
8f0044bf
MD
357}
358#endif
359
60b6c79c
MD
360/*
361 * Create recursively directory using the FULL path.
362 */
363static
18710679 364int _mkdirat_recursive(struct run_as_data *data, struct run_as_ret *ret_value)
60b6c79c 365{
60b6c79c 366 const char *path;
60b6c79c 367 mode_t mode;
cbf53d23 368 struct lttng_directory_handle *handle;
60b6c79c 369
93bed9fe
JG
370 path = data->u.mkdir.path;
371 mode = data->u.mkdir.mode;
60b6c79c 372
cbf53d23
JG
373 handle = lttng_directory_handle_create_from_dirfd(data->u.mkdir.dirfd);
374 if (!handle) {
375 ret_value->_errno = errno;
376 ret_value->_error = true;
377 ret_value->u.ret = -1;
378 goto end;
379 }
87bbb856 380 /* Ownership of dirfd is transferred to the handle. */
93bed9fe 381 data->u.mkdir.dirfd = -1;
d77dded2 382 /* Safe to call as we have transitioned to the requested uid/gid. */
cbf53d23
JG
383 ret_value->u.ret = lttng_directory_handle_create_subdirectory_recursive(
384 handle, path, mode);
fe9f7760 385 ret_value->_errno = errno;
93bed9fe 386 ret_value->_error = (ret_value->u.ret) ? true : false;
cbf53d23
JG
387 lttng_directory_handle_put(handle);
388end:
93bed9fe 389 return ret_value->u.ret;
60b6c79c
MD
390}
391
392static
18710679 393int _mkdirat(struct run_as_data *data, struct run_as_ret *ret_value)
60b6c79c 394{
18710679
JG
395 const char *path;
396 mode_t mode;
cbf53d23 397 struct lttng_directory_handle *handle;
18710679 398
93bed9fe
JG
399 path = data->u.mkdir.path;
400 mode = data->u.mkdir.mode;
18710679 401
cbf53d23
JG
402 handle = lttng_directory_handle_create_from_dirfd(data->u.mkdir.dirfd);
403 if (!handle) {
404 ret_value->u.ret = -1;
405 ret_value->_errno = errno;
406 ret_value->_error = true;
407 goto end;
408 }
87bbb856 409 /* Ownership of dirfd is transferred to the handle. */
93bed9fe 410 data->u.mkdir.dirfd = -1;
18710679 411 /* Safe to call as we have transitioned to the requested uid/gid. */
cbf53d23
JG
412 ret_value->u.ret = lttng_directory_handle_create_subdirectory(
413 handle, path, mode);
fe9f7760 414 ret_value->_errno = errno;
93bed9fe 415 ret_value->_error = (ret_value->u.ret) ? true : false;
cbf53d23
JG
416 lttng_directory_handle_put(handle);
417end:
93bed9fe 418 return ret_value->u.ret;
7567352f 419}
7ce36756 420
7567352f 421static
fe9f7760 422int _open(struct run_as_data *data, struct run_as_ret *ret_value)
7567352f 423{
93bed9fe 424 int fd;
cbf53d23 425 struct lttng_directory_handle *handle;
93bed9fe 426
cbf53d23
JG
427 handle = lttng_directory_handle_create_from_dirfd(data->u.open.dirfd);
428 if (!handle) {
429 ret_value->_errno = errno;
430 ret_value->_error = true;
431 ret_value->u.ret = -1;
432 goto end;
433 }
93bed9fe
JG
434 /* Ownership of dirfd is transferred to the handle. */
435 data->u.open.dirfd = -1;
436
cbf53d23 437 fd = lttng_directory_handle_open_file(handle,
93bed9fe
JG
438 data->u.open.path, data->u.open.flags,
439 data->u.open.mode);
440 if (fd < 0) {
441 ret_value->u.ret = -1;
442 ret_value->u.open.fd = -1;
443 } else {
444 ret_value->u.ret = 0;
445 ret_value->u.open.fd = fd;
446 }
447
fe9f7760 448 ret_value->_errno = errno;
93bed9fe 449 ret_value->_error = fd < 0;
cbf53d23
JG
450 lttng_directory_handle_put(handle);
451end:
93bed9fe 452 return ret_value->u.ret;
7567352f
MD
453}
454
455static
fe9f7760 456int _unlink(struct run_as_data *data, struct run_as_ret *ret_value)
7567352f 457{
cbf53d23 458 struct lttng_directory_handle *handle;
93bed9fe 459
cbf53d23
JG
460 handle = lttng_directory_handle_create_from_dirfd(data->u.unlink.dirfd);
461 if (!handle) {
462 ret_value->u.ret = -1;
463 ret_value->_errno = errno;
464 ret_value->_error = true;
465 goto end;
466 }
93bed9fe
JG
467
468 /* Ownership of dirfd is transferred to the handle. */
469 data->u.unlink.dirfd = -1;
470
cbf53d23 471 ret_value->u.ret = lttng_directory_handle_unlink_file(handle,
93bed9fe
JG
472 data->u.unlink.path);
473 ret_value->_errno = errno;
474 ret_value->_error = (ret_value->u.ret) ? true : false;
cbf53d23
JG
475 lttng_directory_handle_put(handle);
476end:
93bed9fe
JG
477 return ret_value->u.ret;
478}
479
480static
481int _rmdir(struct run_as_data *data, struct run_as_ret *ret_value)
482{
cbf53d23 483 struct lttng_directory_handle *handle;
93bed9fe 484
cbf53d23
JG
485 handle = lttng_directory_handle_create_from_dirfd(data->u.rmdir.dirfd);
486 if (!handle) {
487 ret_value->u.ret = -1;
488 ret_value->_errno = errno;
489 ret_value->_error = true;
490 goto end;
491 }
93bed9fe
JG
492
493 /* Ownership of dirfd is transferred to the handle. */
494 data->u.rmdir.dirfd = -1;
495
496 ret_value->u.ret = lttng_directory_handle_remove_subdirectory(
cbf53d23 497 handle, data->u.rmdir.path);
fe9f7760 498 ret_value->_errno = errno;
93bed9fe 499 ret_value->_error = (ret_value->u.ret) ? true : false;
cbf53d23
JG
500 lttng_directory_handle_put(handle);
501end:
93bed9fe 502 return ret_value->u.ret;
60b6c79c
MD
503}
504
505static
fe9f7760 506int _rmdir_recursive(struct run_as_data *data, struct run_as_ret *ret_value)
60b6c79c 507{
cbf53d23 508 struct lttng_directory_handle *handle;
93bed9fe 509
cbf53d23
JG
510 handle = lttng_directory_handle_create_from_dirfd(data->u.rmdir.dirfd);
511 if (!handle) {
512 ret_value->u.ret = -1;
513 ret_value->_errno = errno;
514 ret_value->_error = true;
515 goto end;
516 }
93bed9fe
JG
517
518 /* Ownership of dirfd is transferred to the handle. */
519 data->u.rmdir.dirfd = -1;
520
521 ret_value->u.ret = lttng_directory_handle_remove_subdirectory_recursive(
cbf53d23 522 handle, data->u.rmdir.path, data->u.rmdir.flags);
fe9f7760 523 ret_value->_errno = errno;
93bed9fe 524 ret_value->_error = (ret_value->u.ret) ? true : false;
cbf53d23
JG
525 lttng_directory_handle_put(handle);
526end:
93bed9fe
JG
527 return ret_value->u.ret;
528}
529
530static
531int _rename(struct run_as_data *data, struct run_as_ret *ret_value)
532{
533 const char *old_path, *new_path;
cbf53d23 534 struct lttng_directory_handle *old_handle = NULL, *new_handle = NULL;
93bed9fe
JG
535
536 old_path = data->u.rename.old_path;
537 new_path = data->u.rename.new_path;
538
cbf53d23 539 old_handle = lttng_directory_handle_create_from_dirfd(
93bed9fe 540 data->u.rename.dirfds[0]);
cbf53d23
JG
541 if (!old_handle) {
542 ret_value->u.ret = -1;
543 goto end;
544 }
545 new_handle = lttng_directory_handle_create_from_dirfd(
93bed9fe 546 data->u.rename.dirfds[1]);
cbf53d23
JG
547 if (!new_handle) {
548 ret_value->u.ret = -1;
549 goto end;
550 }
93bed9fe
JG
551
552 /* Ownership of dirfds are transferred to the handles. */
553 data->u.rename.dirfds[0] = data->u.rename.dirfds[1] = -1;
554
555 /* Safe to call as we have transitioned to the requested uid/gid. */
556 ret_value->u.ret = lttng_directory_handle_rename(
cbf53d23
JG
557 old_handle, old_path, new_handle, new_path);
558end:
559 lttng_directory_handle_put(old_handle);
560 lttng_directory_handle_put(new_handle);
93bed9fe
JG
561 ret_value->_errno = errno;
562 ret_value->_error = (ret_value->u.ret) ? true : false;
93bed9fe 563 return ret_value->u.ret;
7567352f 564}
df5b86c8 565
b1b34226 566#ifdef HAVE_ELF_H
241e0a5a
FD
567static
568int _extract_elf_symbol_offset(struct run_as_data *data,
569 struct run_as_ret *ret_value)
570{
571 int ret = 0;
65eefd4c 572 uint64_t offset;
241e0a5a 573
93bed9fe
JG
574 ret_value->_error = false;
575 ret = lttng_elf_get_symbol_offset(data->u.extract_elf_symbol_offset.fd,
241e0a5a 576 data->u.extract_elf_symbol_offset.function,
65eefd4c 577 &offset);
241e0a5a
FD
578 if (ret) {
579 DBG("Failed to extract ELF function offset");
580 ret_value->_error = true;
581 }
65eefd4c 582 ret_value->u.extract_elf_symbol_offset.offset = offset;
241e0a5a
FD
583
584 return ret;
585}
586
0ef03255
FD
587static
588int _extract_sdt_probe_offsets(struct run_as_data *data,
589 struct run_as_ret *ret_value)
590{
591 int ret = 0;
592 uint64_t *offsets = NULL;
593 uint32_t num_offset;
594
595 ret_value->_error = false;
596
597 /* On success, this call allocates the offsets paramater. */
93bed9fe
JG
598 ret = lttng_elf_get_sdt_probe_offsets(
599 data->u.extract_sdt_probe_offsets.fd,
0ef03255
FD
600 data->u.extract_sdt_probe_offsets.provider_name,
601 data->u.extract_sdt_probe_offsets.probe_name,
602 &offsets, &num_offset);
603
604 if (ret) {
605 DBG("Failed to extract SDT probe offsets");
606 ret_value->_error = true;
607 goto end;
608 }
609
610 if (num_offset <= 0 || num_offset > LTTNG_KERNEL_MAX_UPROBE_NUM) {
611 DBG("Wrong number of probes.");
612 ret = -1;
613 ret_value->_error = true;
614 goto free_offset;
615 }
616
617 /* Copy the content of the offsets array to the ret struct. */
618 memcpy(ret_value->u.extract_sdt_probe_offsets.offsets,
619 offsets, num_offset * sizeof(uint64_t));
620
621 ret_value->u.extract_sdt_probe_offsets.num_offset = num_offset;
622
623free_offset:
624 free(offsets);
625end:
626 return ret;
627}
b1b34226
MJ
628#else
629static
630int _extract_elf_symbol_offset(struct run_as_data *data,
631 struct run_as_ret *ret_value)
632{
633 ERR("Unimplemented runas command RUN_AS_EXTRACT_ELF_SYMBOL_OFFSET");
634 return -1;
635}
636
637static
638int _extract_sdt_probe_offsets(struct run_as_data *data,
639 struct run_as_ret *ret_value)
640{
641 ERR("Unimplemented runas command RUN_AS_EXTRACT_SDT_PROBE_OFFSETS");
642 return -1;
643}
644#endif
241e0a5a 645
c73f064a
JR
646static
647int _generate_filter_bytecode(struct run_as_data *data,
648 struct run_as_ret *ret_value) {
649 int ret = 0;
650 const char *filter_expression = NULL;
651 struct filter_parser_ctx *ctx = NULL;
652
653 ret_value->_error = false;
654
655 filter_expression = data->u.generate_filter_bytecode.filter_expression;
656
657 if (lttng_strnlen(filter_expression, LTTNG_FILTER_MAX_LEN - 1) == LTTNG_FILTER_MAX_LEN - 1) {
658 ret_value->_error = true;
659 ret = -1;
660 goto end;
661 }
662
663 ret = filter_parser_ctx_create_from_filter_expression(filter_expression, &ctx);
664 if (ret < 0) {
665 ret_value->_error = true;
666 ret = -1;
667 goto end;
668 }
669
670 DBG("Size of bytecode generated: %u bytes.",
671 bytecode_get_len(&ctx->bytecode->b));
672
673 /* Copy the lttng_bytecode_filter object to the return structure. */
674 memcpy(ret_value->u.generate_filter_bytecode.bytecode,
675 &ctx->bytecode->b,
676 sizeof(ctx->bytecode->b) +
677 bytecode_get_len(&ctx->bytecode->b));
678
679end:
680 if (ctx) {
681 filter_bytecode_free(ctx);
682 filter_ir_free(ctx);
683 filter_parser_ctx_free(ctx);
684 }
685
686 return ret;
687}
7567352f
MD
688static
689run_as_fct run_as_enum_to_fct(enum run_as_cmd cmd)
690{
691 switch (cmd) {
692 case RUN_AS_MKDIR:
18710679
JG
693 case RUN_AS_MKDIRAT:
694 return _mkdirat;
695 case RUN_AS_MKDIR_RECURSIVE:
696 case RUN_AS_MKDIRAT_RECURSIVE:
697 return _mkdirat_recursive;
7567352f 698 case RUN_AS_OPEN:
2912cead 699 case RUN_AS_OPENAT:
7567352f
MD
700 return _open;
701 case RUN_AS_UNLINK:
2912cead 702 case RUN_AS_UNLINKAT:
7567352f 703 return _unlink;
93bed9fe
JG
704 case RUN_AS_RMDIR:
705 case RUN_AS_RMDIRAT:
706 return _rmdir;
7567352f 707 case RUN_AS_RMDIR_RECURSIVE:
93bed9fe 708 case RUN_AS_RMDIRAT_RECURSIVE:
7567352f 709 return _rmdir_recursive;
93bed9fe
JG
710 case RUN_AS_RENAME:
711 case RUN_AS_RENAMEAT:
712 return _rename;
241e0a5a
FD
713 case RUN_AS_EXTRACT_ELF_SYMBOL_OFFSET:
714 return _extract_elf_symbol_offset;
0ef03255
FD
715 case RUN_AS_EXTRACT_SDT_PROBE_OFFSETS:
716 return _extract_sdt_probe_offsets;
c73f064a
JR
717 case RUN_AS_GENERATE_FILTER_BYTECODE:
718 return _generate_filter_bytecode;
7567352f 719 default:
62a7b8ed 720 ERR("Unknown command %d", (int) cmd);
7567352f
MD
721 return NULL;
722 }
60b6c79c
MD
723}
724
4628484a 725static
93bed9fe 726int do_send_fds(int sock, const int *fds, unsigned int fd_count)
4628484a 727{
7567352f 728 ssize_t len;
93bed9fe
JG
729 unsigned int i;
730
731 for (i = 0; i < fd_count; i++) {
732 if (fds[i] < 0) {
733 ERR("Attempt to send invalid file descriptor to master (fd = %i)",
734 fds[i]);
735 /* Return 0 as this is not a fatal error. */
736 return 0;
737 }
4a76dfd3 738 }
4628484a 739
4a76dfd3 740 len = lttcomm_send_fds_unix_sock(sock, fds, fd_count);
93bed9fe 741 return len < 0 ? -1 : 0;
4628484a
MD
742}
743
744static
93bed9fe 745int do_recv_fds(int sock, int *fds, unsigned int fd_count)
4628484a 746{
93bed9fe
JG
747 int ret = 0;
748 unsigned int i;
7567352f 749 ssize_t len;
4628484a 750
93bed9fe
JG
751 len = lttcomm_recv_fds_unix_sock(sock, fds, fd_count);
752 if (len == 0) {
753 ret = -1;
754 goto end;
da9ee832 755 } else if (len < 0) {
93bed9fe
JG
756 PERROR("Failed to receive file descriptors from socket");
757 ret = -1;
758 goto end;
ca9eb994
JG
759 }
760
93bed9fe
JG
761 for (i = 0; i < fd_count; i++) {
762 if (fds[i] < 0) {
763 ERR("Invalid file descriptor received from worker (fd = %i)", fds[i]);
764 /* Return 0 as this is not a fatal error. */
765 }
55cb0d6f 766 }
93bed9fe 767end:
55cb0d6f 768 return ret;
4628484a
MD
769}
770
fe9f7760 771static
93bed9fe
JG
772int send_fds_to_worker(const struct run_as_worker *worker,
773 const struct run_as_data *data)
fe9f7760
FD
774{
775 int ret = 0;
93bed9fe 776 unsigned int i;
fe9f7760 777
93bed9fe
JG
778 if (COMMAND_USE_CWD_FD(data) || COMMAND_IN_FD_COUNT(data) == 0) {
779 goto end;
fe9f7760
FD
780 }
781
93bed9fe
JG
782 for (i = 0; i < COMMAND_IN_FD_COUNT(data); i++) {
783 if (COMMAND_IN_FDS(data)[i] < 0) {
784 ERR("Refusing to send invalid fd to worker (fd = %i)",
785 COMMAND_IN_FDS(data)[i]);
786 ret = -1;
787 goto end;
788 }
55cb0d6f 789 }
ca9eb994 790
55cb0d6f 791 ret = do_send_fds(worker->sockpair[0], COMMAND_IN_FDS(data),
93bed9fe 792 COMMAND_IN_FD_COUNT(data));
fe9f7760 793 if (ret < 0) {
93bed9fe 794 PERROR("Failed to send file descriptor to run-as worker");
fe9f7760 795 ret = -1;
93bed9fe 796 goto end;
fe9f7760 797 }
93bed9fe 798end:
fe9f7760
FD
799 return ret;
800}
801
802static
93bed9fe
JG
803int send_fds_to_master(struct run_as_worker *worker, enum run_as_cmd cmd,
804 struct run_as_ret *run_as_ret)
fe9f7760 805{
93bed9fe
JG
806 int ret = 0;
807 unsigned int i;
fe9f7760 808
93bed9fe
JG
809 if (COMMAND_OUT_FD_COUNT(cmd) == 0) {
810 goto end;
fe9f7760
FD
811 }
812
93bed9fe
JG
813 ret = do_send_fds(worker->sockpair[1], COMMAND_OUT_FDS(cmd, run_as_ret),
814 COMMAND_OUT_FD_COUNT(cmd));
fe9f7760 815 if (ret < 0) {
93bed9fe
JG
816 PERROR("Failed to send file descriptor to master process");
817 goto end;
fe9f7760
FD
818 }
819
93bed9fe
JG
820 for (i = 0; i < COMMAND_OUT_FD_COUNT(cmd); i++) {
821 int ret_close = close(COMMAND_OUT_FDS(cmd, run_as_ret)[i]);
ca9eb994 822
93bed9fe
JG
823 if (ret_close < 0) {
824 PERROR("Failed to close result file descriptor");
825 }
826 }
827end:
fe9f7760
FD
828 return ret;
829}
830
831static
93bed9fe
JG
832int recv_fds_from_worker(const struct run_as_worker *worker, enum run_as_cmd cmd,
833 struct run_as_ret *run_as_ret)
fe9f7760
FD
834{
835 int ret = 0;
836
93bed9fe
JG
837 if (COMMAND_OUT_FD_COUNT(cmd) == 0) {
838 goto end;
fe9f7760
FD
839 }
840
93bed9fe
JG
841 ret = do_recv_fds(worker->sockpair[0], COMMAND_OUT_FDS(cmd, run_as_ret),
842 COMMAND_OUT_FD_COUNT(cmd));
fe9f7760 843 if (ret < 0) {
93bed9fe 844 PERROR("Failed to receive file descriptor from run-as worker");
fe9f7760
FD
845 ret = -1;
846 }
93bed9fe 847end:
fe9f7760
FD
848 return ret;
849}
850
851static
93bed9fe 852int recv_fds_from_master(struct run_as_worker *worker, struct run_as_data *data)
fe9f7760
FD
853{
854 int ret = 0;
855
93bed9fe
JG
856 if (COMMAND_USE_CWD_FD(data)) {
857 unsigned int i;
858
859 for (i = 0; i < COMMAND_IN_FD_COUNT(data); i++) {
860 COMMAND_IN_FDS(data)[i] = AT_FDCWD;
861 }
862 goto end;
fe9f7760
FD
863 }
864
c73f064a
JR
865 if (COMMAND_IN_FD_COUNT(data) == 0) {
866 goto end;
867 }
868
93bed9fe
JG
869 ret = do_recv_fds(worker->sockpair[1], COMMAND_IN_FDS(data),
870 COMMAND_IN_FD_COUNT(data));
fe9f7760 871 if (ret < 0) {
93bed9fe 872 PERROR("Failed to receive file descriptors from master process");
fe9f7760
FD
873 ret = -1;
874 }
93bed9fe 875end:
fe9f7760
FD
876 return ret;
877}
878
879static
93bed9fe 880int cleanup_received_fds(struct run_as_data *data)
fe9f7760 881{
93bed9fe 882 int ret = 0, i;
fe9f7760 883
93bed9fe
JG
884 for (i = 0; i < COMMAND_IN_FD_COUNT(data); i++) {
885 if (COMMAND_IN_FDS(data)[i] == -1) {
886 continue;
887 }
888 ret = close(COMMAND_IN_FDS(data)[i]);
889 if (ret) {
890 PERROR("Failed to close file descriptor received fd in run-as worker");
891 goto end;
892 }
fe9f7760 893 }
93bed9fe 894end:
fe9f7760
FD
895 return ret;
896}
0ef03255 897
7567352f
MD
898/*
899 * Return < 0 on error, 0 if OK, 1 on hangup.
900 */
c2b75c49 901static
7567352f 902int handle_one_cmd(struct run_as_worker *worker)
c2b75c49 903{
7567352f 904 int ret = 0;
55cb0d6f
JG
905 struct run_as_data data = {};
906 ssize_t readlen, writelen;
907 struct run_as_ret sendret = {};
908 run_as_fct cmd;
7567352f
MD
909 uid_t prev_euid;
910
fe9f7760
FD
911 /*
912 * Stage 1: Receive run_as_data struct from the master.
913 * The structure contains the command type and all the parameters needed for
914 * its execution
915 */
7567352f
MD
916 readlen = lttcomm_recv_unix_sock(worker->sockpair[1], &data,
917 sizeof(data));
918 if (readlen == 0) {
919 /* hang up */
920 ret = 1;
921 goto end;
922 }
923 if (readlen < sizeof(data)) {
924 PERROR("lttcomm_recv_unix_sock error");
925 ret = -1;
926 goto end;
927 }
c2b75c49 928
7567352f
MD
929 cmd = run_as_enum_to_fct(data.cmd);
930 if (!cmd) {
931 ret = -1;
932 goto end;
933 }
934
fe9f7760
FD
935 /*
936 * Stage 2: Receive file descriptor from master.
937 * Some commands need a file descriptor as input so if it's needed we
938 * receive the fd using the Unix socket.
939 */
93bed9fe 940 ret = recv_fds_from_master(worker, &data);
fe9f7760
FD
941 if (ret < 0) {
942 PERROR("recv_fd_from_master error");
943 ret = -1;
944 goto end;
945 }
946
7567352f
MD
947 prev_euid = getuid();
948 if (data.gid != getegid()) {
949 ret = setegid(data.gid);
1576d582 950 if (ret < 0) {
561f5f2c
JG
951 sendret._error = true;
952 sendret._errno = errno;
4c462e79 953 PERROR("setegid");
6d73c4ef 954 goto write_return;
1576d582 955 }
c2b75c49 956 }
7567352f
MD
957 if (data.uid != prev_euid) {
958 ret = seteuid(data.uid);
1576d582 959 if (ret < 0) {
561f5f2c
JG
960 sendret._error = true;
961 sendret._errno = errno;
4c462e79 962 PERROR("seteuid");
6d73c4ef 963 goto write_return;
1576d582 964 }
c2b75c49 965 }
fe9f7760 966
c2b75c49
MD
967 /*
968 * Also set umask to 0 for mkdir executable bit.
969 */
970 umask(0);
fe9f7760
FD
971
972 /*
973 * Stage 3: Execute the command
974 */
975 ret = (*cmd)(&data, &sendret);
976 if (ret < 0) {
977 DBG("Execution of command returned an error");
978 }
6d73c4ef
MD
979
980write_return:
93bed9fe 981 ret = cleanup_received_fds(&data);
fe9f7760
FD
982 if (ret < 0) {
983 ERR("Error cleaning up FD");
984 goto end;
985 }
986
987 /*
988 * Stage 4: Send run_as_ret structure to the master.
989 * This structure contain the return value of the command and the errno.
990 */
7567352f
MD
991 writelen = lttcomm_send_unix_sock(worker->sockpair[1], &sendret,
992 sizeof(sendret));
6cd525e8 993 if (writelen < sizeof(sendret)) {
7567352f
MD
994 PERROR("lttcomm_send_unix_sock error");
995 ret = -1;
996 goto end;
997 }
fe9f7760
FD
998
999 /*
93bed9fe 1000 * Stage 5: Send resulting file descriptors to the master.
fe9f7760 1001 */
93bed9fe 1002 ret = send_fds_to_master(worker, data.cmd, &sendret);
fe9f7760
FD
1003 if (ret < 0) {
1004 DBG("Sending FD to master returned an error");
7567352f
MD
1005 goto end;
1006 }
fe9f7760 1007
7567352f
MD
1008 if (seteuid(prev_euid) < 0) {
1009 PERROR("seteuid");
1010 ret = -1;
1011 goto end;
1012 }
1013 ret = 0;
1014end:
1015 return ret;
1016}
1017
1018static
1019int run_as_worker(struct run_as_worker *worker)
1020{
1021 int ret;
1022 ssize_t writelen;
1023 struct run_as_ret sendret;
1024 size_t proc_orig_len;
1025
1026 /*
1027 * Initialize worker. Set a different process cmdline.
1028 */
1029 proc_orig_len = strlen(worker->procname);
1030 memset(worker->procname, 0, proc_orig_len);
1031 strncpy(worker->procname, DEFAULT_RUN_AS_WORKER_NAME, proc_orig_len);
1032
cb8d0d24 1033 ret = lttng_thread_setname(DEFAULT_RUN_AS_WORKER_NAME);
e1055edb 1034 if (ret && ret != -ENOSYS) {
b8090274 1035 /* Don't fail as this is not essential. */
cb8d0d24 1036 DBG("Failed to set pthread name attribute");
6cd525e8 1037 }
7567352f 1038
fe9f7760
FD
1039 memset(&sendret, 0, sizeof(sendret));
1040
7567352f
MD
1041 writelen = lttcomm_send_unix_sock(worker->sockpair[1], &sendret,
1042 sizeof(sendret));
1043 if (writelen < sizeof(sendret)) {
1044 PERROR("lttcomm_send_unix_sock error");
1045 ret = EXIT_FAILURE;
1046 goto end;
1047 }
1048
1049 for (;;) {
1050 ret = handle_one_cmd(worker);
1051 if (ret < 0) {
1052 ret = EXIT_FAILURE;
1053 goto end;
1054 } else if (ret > 0) {
1055 break;
1056 } else {
1057 continue; /* Next command. */
1058 }
1059 }
1060 ret = EXIT_SUCCESS;
1061end:
1062 return ret;
c2b75c49
MD
1063}
1064
60b6c79c 1065static
7567352f
MD
1066int run_as_cmd(struct run_as_worker *worker,
1067 enum run_as_cmd cmd,
1068 struct run_as_data *data,
fe9f7760 1069 struct run_as_ret *ret_value,
7567352f 1070 uid_t uid, gid_t gid)
60b6c79c 1071{
fe9f7760 1072 int ret = 0;
7567352f 1073 ssize_t readlen, writelen;
60b6c79c
MD
1074
1075 /*
1076 * If we are non-root, we can only deal with our own uid.
1077 */
1078 if (geteuid() != 0) {
1079 if (uid != geteuid()) {
fe9f7760
FD
1080 ret = -1;
1081 ret_value->_errno = EPERM;
60b6c79c 1082 ERR("Client (%d)/Server (%d) UID mismatch (and sessiond is not root)",
08797918 1083 (int) uid, (int) geteuid());
df5b86c8 1084 goto end;
60b6c79c 1085 }
60b6c79c
MD
1086 }
1087
7567352f
MD
1088 data->cmd = cmd;
1089 data->uid = uid;
1090 data->gid = gid;
1091
fe9f7760
FD
1092 /*
1093 * Stage 1: Send the run_as_data struct to the worker process
1094 */
7567352f
MD
1095 writelen = lttcomm_send_unix_sock(worker->sockpair[0], data,
1096 sizeof(*data));
1097 if (writelen < sizeof(*data)) {
1098 PERROR("Error writing message to run_as");
fe9f7760
FD
1099 ret = -1;
1100 ret_value->_errno = EIO;
60b6c79c 1101 goto end;
c2b75c49 1102 }
7567352f 1103
fe9f7760
FD
1104 /*
1105 * Stage 2: Send file descriptor to the worker process if needed
1106 */
93bed9fe 1107 ret = send_fds_to_worker(worker, data);
fe9f7760
FD
1108 if (ret) {
1109 PERROR("do_send_fd error");
1110 ret = -1;
1111 ret_value->_errno = EIO;
1112 goto end;
1113 }
1114
1115 /*
1116 * Stage 3: Wait for the execution of the command
1117 */
1118
1119 /*
1120 * Stage 4: Receive the run_as_ret struct containing the return value and
1121 * errno
1122 */
1123 readlen = lttcomm_recv_unix_sock(worker->sockpair[0], ret_value,
1124 sizeof(*ret_value));
da9ee832
JG
1125 if (!readlen) {
1126 ERR("Run-as worker has hung-up during run_as_cmd");
fe9f7760
FD
1127 ret = -1;
1128 ret_value->_errno = EIO;
da9ee832 1129 goto end;
fe9f7760 1130 } else if (readlen < sizeof(*ret_value)) {
7567352f 1131 PERROR("Error reading response from run_as");
fe9f7760
FD
1132 ret = -1;
1133 ret_value->_errno = errno;
033b58a7 1134 goto end;
6cd525e8 1135 }
fe9f7760 1136
ca9eb994
JG
1137 if (ret_value->_error) {
1138 /* Skip stage 5 on error as there will be no fd to receive. */
1139 goto end;
1140 }
1141
fe9f7760
FD
1142 /*
1143 * Stage 5: Receive file descriptor if needed
1144 */
93bed9fe 1145 ret = recv_fds_from_worker(worker, cmd, ret_value);
fe9f7760
FD
1146 if (ret < 0) {
1147 ERR("Error receiving fd");
1148 ret = -1;
1149 ret_value->_errno = EIO;
4c462e79 1150 }
7567352f 1151
60b6c79c 1152end:
fe9f7760 1153 return ret;
60b6c79c
MD
1154}
1155
2d85a600 1156/*
7567352f 1157 * This is for debugging ONLY and should not be considered secure.
2d85a600
MD
1158 */
1159static
fe9f7760
FD
1160int run_as_noworker(enum run_as_cmd cmd,
1161 struct run_as_data *data, struct run_as_ret *ret_value,
1162 uid_t uid, gid_t gid)
2d85a600 1163{
df5b86c8 1164 int ret, saved_errno;
5b73926f 1165 mode_t old_mask;
7567352f 1166 run_as_fct fct;
5b73926f 1167
7567352f
MD
1168 fct = run_as_enum_to_fct(cmd);
1169 if (!fct) {
1170 errno = -ENOSYS;
1171 ret = -1;
1172 goto end;
1173 }
5b73926f 1174 old_mask = umask(0);
fe9f7760
FD
1175 ret = fct(data, ret_value);
1176 saved_errno = ret_value->_errno;
5b73926f 1177 umask(old_mask);
df5b86c8 1178 errno = saved_errno;
7567352f 1179end:
5b73926f 1180 return ret;
2d85a600
MD
1181}
1182
8fec83ea
JG
1183static
1184int reset_sighandler(void)
1185{
1186 int sig;
1187
1188 DBG("Resetting run_as worker signal handlers to default");
1189 for (sig = 1; sig <= 31; sig++) {
1190 (void) signal(sig, SIG_DFL);
1191 }
1192 return 0;
1193}
1194
1195static
1196void worker_sighandler(int sig)
1197{
1198 const char *signame;
1199
1200 /*
1201 * The worker will inherit its parent's signals since they are part of
1202 * the same process group. However, in the case of SIGINT and SIGTERM,
1203 * we want to give the worker a chance to teardown gracefully when its
1204 * parent closes the command socket.
1205 */
1206 switch (sig) {
1207 case SIGINT:
1208 signame = "SIGINT";
1209 break;
1210 case SIGTERM:
1211 signame = "SIGTERM";
1212 break;
1213 default:
1214 signame = NULL;
1215 }
1216
1217 if (signame) {
1218 DBG("run_as worker received signal %s", signame);
1219 } else {
1220 DBG("run_as_worker received signal %d", sig);
1221 }
1222}
1223
1224static
1225int set_worker_sighandlers(void)
1226{
1227 int ret = 0;
1228 sigset_t sigset;
1229 struct sigaction sa;
1230
1231 if ((ret = sigemptyset(&sigset)) < 0) {
1232 PERROR("sigemptyset");
1233 goto end;
1234 }
1235
1236 sa.sa_handler = worker_sighandler;
1237 sa.sa_mask = sigset;
1238 sa.sa_flags = 0;
1239 if ((ret = sigaction(SIGINT, &sa, NULL)) < 0) {
1240 PERROR("sigaction SIGINT");
1241 goto end;
1242 }
1243
1244 if ((ret = sigaction(SIGTERM, &sa, NULL)) < 0) {
1245 PERROR("sigaction SIGTERM");
1246 goto end;
1247 }
1248
1249 DBG("run_as signal handler set for SIGTERM and SIGINT");
1250end:
1251 return ret;
1252}
1253
1254static
929f71ec
JG
1255int run_as_create_worker_no_lock(const char *procname,
1256 post_fork_cleanup_cb clean_up_func,
1257 void *clean_up_user_data)
8fec83ea
JG
1258{
1259 pid_t pid;
1260 int i, ret = 0;
1261 ssize_t readlen;
1262 struct run_as_ret recvret;
1263 struct run_as_worker *worker;
1264
1265 assert(!global_worker);
1266 if (!use_clone()) {
1267 /*
1268 * Don't initialize a worker, all run_as tasks will be performed
1269 * in the current process.
1270 */
1271 ret = 0;
1272 goto end;
1273 }
1274 worker = zmalloc(sizeof(*worker));
1275 if (!worker) {
1276 ret = -ENOMEM;
1277 goto end;
1278 }
1279 worker->procname = strdup(procname);
1280 if (!worker->procname) {
1281 ret = -ENOMEM;
8c96eded 1282 goto error_procname_alloc;
8fec83ea
JG
1283 }
1284 /* Create unix socket. */
1285 if (lttcomm_create_anon_unix_socketpair(worker->sockpair) < 0) {
1286 ret = -1;
1287 goto error_sock;
1288 }
1289
1290 /* Fork worker. */
1291 pid = fork();
1292 if (pid < 0) {
1293 PERROR("fork");
1294 ret = -1;
1295 goto error_fork;
1296 } else if (pid == 0) {
1297 /* Child */
1298
1299 reset_sighandler();
1300
1301 set_worker_sighandlers();
929f71ec
JG
1302 if (clean_up_func) {
1303 if (clean_up_func(clean_up_user_data) < 0) {
1304 ERR("Run-as post-fork clean-up failed, exiting.");
1305 exit(EXIT_FAILURE);
1306 }
1307 }
8fec83ea
JG
1308
1309 /* Just close, no shutdown. */
1310 if (close(worker->sockpair[0])) {
1311 PERROR("close");
1312 exit(EXIT_FAILURE);
1313 }
1314
1315 /*
1316 * Close all FDs aside from STDIN, STDOUT, STDERR and sockpair[1]
1317 * Sockpair[1] is used as a control channel with the master
1318 */
1319 for (i = 3; i < sysconf(_SC_OPEN_MAX); i++) {
1320 if (i != worker->sockpair[1]) {
1321 (void) close(i);
1322 }
1323 }
1324
1325 worker->sockpair[0] = -1;
1326 ret = run_as_worker(worker);
1327 if (lttcomm_close_unix_sock(worker->sockpair[1])) {
1328 PERROR("close");
1329 ret = -1;
1330 }
1331 worker->sockpair[1] = -1;
55cb0d6f 1332 free(worker->procname);
340cf672 1333 free(worker);
8fec83ea
JG
1334 LOG(ret ? PRINT_ERR : PRINT_DBG, "run_as worker exiting (ret = %d)", ret);
1335 exit(ret ? EXIT_FAILURE : EXIT_SUCCESS);
1336 } else {
1337 /* Parent */
1338
1339 /* Just close, no shutdown. */
1340 if (close(worker->sockpair[1])) {
1341 PERROR("close");
1342 ret = -1;
1343 goto error_fork;
1344 }
1345 worker->sockpair[1] = -1;
1346 worker->pid = pid;
1347 /* Wait for worker to become ready. */
1348 readlen = lttcomm_recv_unix_sock(worker->sockpair[0],
1349 &recvret, sizeof(recvret));
1350 if (readlen < sizeof(recvret)) {
1351 ERR("readlen: %zd", readlen);
1352 PERROR("Error reading response from run_as at creation");
1353 ret = -1;
1354 goto error_fork;
1355 }
1356 global_worker = worker;
1357 }
1358end:
1359 return ret;
1360
1361 /* Error handling. */
1362error_fork:
1363 for (i = 0; i < 2; i++) {
1364 if (worker->sockpair[i] < 0) {
1365 continue;
1366 }
1367 if (lttcomm_close_unix_sock(worker->sockpair[i])) {
1368 PERROR("close");
1369 }
1370 worker->sockpair[i] = -1;
1371 }
1372error_sock:
8c96eded
FD
1373 free(worker->procname);
1374error_procname_alloc:
8fec83ea
JG
1375 free(worker);
1376 return ret;
1377}
1378
a01c682b
JR
1379static
1380void run_as_destroy_worker_no_lock(void)
1381{
1382 struct run_as_worker *worker = global_worker;
1383
1384 DBG("Destroying run_as worker");
1385 if (!worker) {
1386 return;
1387 }
1388 /* Close unix socket */
1389 DBG("Closing run_as worker socket");
1390 if (lttcomm_close_unix_sock(worker->sockpair[0])) {
1391 PERROR("close");
1392 }
1393 worker->sockpair[0] = -1;
1394 /* Wait for worker. */
1395 for (;;) {
1396 int status;
1397 pid_t wait_ret;
1398
1399 wait_ret = waitpid(worker->pid, &status, 0);
1400 if (wait_ret < 0) {
1401 if (errno == EINTR) {
1402 continue;
1403 }
1404 PERROR("waitpid");
1405 break;
1406 }
1407
1408 if (WIFEXITED(status)) {
1409 LOG(WEXITSTATUS(status) == 0 ? PRINT_DBG : PRINT_ERR,
1410 DEFAULT_RUN_AS_WORKER_NAME " terminated with status code %d",
55cb0d6f 1411 WEXITSTATUS(status));
a01c682b
JR
1412 break;
1413 } else if (WIFSIGNALED(status)) {
1414 ERR(DEFAULT_RUN_AS_WORKER_NAME " was killed by signal %d",
1415 WTERMSIG(status));
1416 break;
1417 }
1418 }
1419 free(worker->procname);
1420 free(worker);
1421 global_worker = NULL;
1422}
1423
2d85a600 1424static
fe9f7760 1425int run_as_restart_worker(struct run_as_worker *worker)
2d85a600 1426{
fe9f7760
FD
1427 int ret = 0;
1428 char *procname = NULL;
1429
1430 procname = worker->procname;
1431
1432 /* Close socket to run_as worker process and clean up the zombie process */
a01c682b 1433 run_as_destroy_worker_no_lock();
fe9f7760
FD
1434
1435 /* Create a new run_as worker process*/
929f71ec 1436 ret = run_as_create_worker_no_lock(procname, NULL, NULL);
fe9f7760
FD
1437 if (ret < 0 ) {
1438 ERR("Restarting the worker process failed");
1439 ret = -1;
1440 goto err;
1441 }
1442err:
1443 return ret;
1444}
1445
1446static
1447int run_as(enum run_as_cmd cmd, struct run_as_data *data,
1448 struct run_as_ret *ret_value, uid_t uid, gid_t gid)
1449{
1450 int ret, saved_errno;
7567352f 1451
8fec83ea 1452 pthread_mutex_lock(&worker_lock);
749b7a0c 1453 if (use_clone()) {
7567352f 1454 DBG("Using run_as worker");
8fec83ea 1455
749b7a0c 1456 assert(global_worker);
749b7a0c 1457
fe9f7760
FD
1458 ret = run_as_cmd(global_worker, cmd, data, ret_value, uid, gid);
1459 saved_errno = ret_value->_errno;
1460
fe9f7760
FD
1461 /*
1462 * If the worker thread crashed the errno is set to EIO. we log
1463 * the error and start a new worker process.
1464 */
1465 if (ret == -1 && saved_errno == EIO) {
1466 DBG("Socket closed unexpectedly... "
1467 "Restarting the worker process");
1468 ret = run_as_restart_worker(global_worker);
fe9f7760
FD
1469 if (ret == -1) {
1470 ERR("Failed to restart worker process.");
1471 goto err;
1472 }
1473 }
2d85a600 1474 } else {
7567352f 1475 DBG("Using run_as without worker");
fe9f7760 1476 ret = run_as_noworker(cmd, data, ret_value, uid, gid);
2d85a600 1477 }
fe9f7760 1478err:
8fec83ea 1479 pthread_mutex_unlock(&worker_lock);
7567352f 1480 return ret;
2d85a600
MD
1481}
1482
90e535ef 1483LTTNG_HIDDEN
e11d277b 1484int run_as_mkdir_recursive(const char *path, mode_t mode, uid_t uid, gid_t gid)
60b6c79c 1485{
18710679
JG
1486 return run_as_mkdirat_recursive(AT_FDCWD, path, mode, uid, gid);
1487}
1488
1489LTTNG_HIDDEN
1490int run_as_mkdirat_recursive(int dirfd, const char *path, mode_t mode,
1491 uid_t uid, gid_t gid)
1492{
1493 int ret;
93bed9fe
JG
1494 struct run_as_data data = {};
1495 struct run_as_ret run_as_ret = {};
60b6c79c 1496
18710679
JG
1497 DBG3("mkdirat() recursive fd = %d%s, path = %s, mode = %d, uid = %d, gid = %d",
1498 dirfd, dirfd == AT_FDCWD ? " (AT_FDCWD)" : "",
08797918 1499 path, (int) mode, (int) uid, (int) gid);
93bed9fe
JG
1500 ret = lttng_strncpy(data.u.mkdir.path, path,
1501 sizeof(data.u.mkdir.path));
18710679
JG
1502 if (ret) {
1503 ERR("Failed to copy path argument of mkdirat recursive command");
1504 goto error;
1505 }
93bed9fe
JG
1506 data.u.mkdir.path[sizeof(data.u.mkdir.path) - 1] = '\0';
1507 data.u.mkdir.mode = mode;
1508 data.u.mkdir.dirfd = dirfd;
18710679
JG
1509 run_as(dirfd == AT_FDCWD ? RUN_AS_MKDIR_RECURSIVE : RUN_AS_MKDIRAT_RECURSIVE,
1510 &data, &run_as_ret, uid, gid);
1511 errno = run_as_ret._errno;
93bed9fe 1512 ret = run_as_ret.u.ret;
18710679
JG
1513error:
1514 return ret;
60b6c79c
MD
1515}
1516
90e535ef 1517LTTNG_HIDDEN
e11d277b 1518int run_as_mkdir(const char *path, mode_t mode, uid_t uid, gid_t gid)
60b6c79c 1519{
18710679
JG
1520 return run_as_mkdirat(AT_FDCWD, path, mode, uid, gid);
1521}
1522
1523LTTNG_HIDDEN
1524int run_as_mkdirat(int dirfd, const char *path, mode_t mode,
1525 uid_t uid, gid_t gid)
1526{
1527 int ret;
93bed9fe
JG
1528 struct run_as_data data = {};
1529 struct run_as_ret run_as_ret = {};
fe9f7760 1530
18710679
JG
1531 DBG3("mkdirat() recursive fd = %d%s, path = %s, mode = %d, uid = %d, gid = %d",
1532 dirfd, dirfd == AT_FDCWD ? " (AT_FDCWD)" : "",
08797918 1533 path, (int) mode, (int) uid, (int) gid);
93bed9fe
JG
1534 ret = lttng_strncpy(data.u.mkdir.path, path,
1535 sizeof(data.u.mkdir.path));
18710679
JG
1536 if (ret) {
1537 ERR("Failed to copy path argument of mkdirat command");
1538 goto error;
1539 }
93bed9fe
JG
1540 data.u.mkdir.path[sizeof(data.u.mkdir.path) - 1] = '\0';
1541 data.u.mkdir.mode = mode;
1542 data.u.mkdir.dirfd = dirfd;
18710679
JG
1543 run_as(dirfd == AT_FDCWD ? RUN_AS_MKDIR : RUN_AS_MKDIRAT,
1544 &data, &run_as_ret, uid, gid);
1545 errno = run_as_ret._errno;
93bed9fe 1546 ret = run_as_ret.u.ret;
18710679
JG
1547error:
1548 return ret;
60b6c79c
MD
1549}
1550
90e535ef 1551LTTNG_HIDDEN
2912cead 1552int run_as_open(const char *path, int flags, mode_t mode, uid_t uid,
55cb0d6f 1553 gid_t gid)
2912cead
JG
1554{
1555 return run_as_openat(AT_FDCWD, path, flags, mode, uid, gid);
1556}
1557
1558LTTNG_HIDDEN
1559int run_as_openat(int dirfd, const char *path, int flags, mode_t mode,
1560 uid_t uid, gid_t gid)
60b6c79c 1561{
93bed9fe 1562 int ret;
55cb0d6f
JG
1563 struct run_as_data data = {};
1564 struct run_as_ret run_as_ret = {};
fe9f7760 1565
2912cead
JG
1566 DBG3("openat() fd = %d%s, path = %s, flags = %X, mode = %d, uid %d, gid %d",
1567 dirfd, dirfd == AT_FDCWD ? " (AT_FDCWD)" : "",
08797918 1568 path, flags, (int) mode, (int) uid, (int) gid);
93bed9fe
JG
1569 ret = lttng_strncpy(data.u.open.path, path, sizeof(data.u.open.path));
1570 if (ret) {
1571 ERR("Failed to copy path argument of open command");
1572 goto error;
1573 }
7567352f
MD
1574 data.u.open.flags = flags;
1575 data.u.open.mode = mode;
93bed9fe 1576 data.u.open.dirfd = dirfd;
2912cead 1577 run_as(dirfd == AT_FDCWD ? RUN_AS_OPEN : RUN_AS_OPENAT,
93bed9fe
JG
1578 &data, &run_as_ret, uid, gid);
1579 errno = run_as_ret._errno;
1580 ret = run_as_ret.u.ret < 0 ? run_as_ret.u.ret :
1581 run_as_ret.u.open.fd;
1582error:
1583 return ret;
60b6c79c 1584}
4628484a
MD
1585
1586LTTNG_HIDDEN
1587int run_as_unlink(const char *path, uid_t uid, gid_t gid)
2912cead
JG
1588{
1589 return run_as_unlinkat(AT_FDCWD, path, uid, gid);
1590}
1591
1592LTTNG_HIDDEN
1593int run_as_unlinkat(int dirfd, const char *path, uid_t uid, gid_t gid)
4628484a 1594{
93bed9fe
JG
1595 int ret;
1596 struct run_as_data data = {};
1597 struct run_as_ret run_as_ret = {};
fe9f7760 1598
2912cead
JG
1599 DBG3("unlinkat() fd = %d%s, path = %s, uid = %d, gid = %d",
1600 dirfd, dirfd == AT_FDCWD ? " (AT_FDCWD)" : "",
08797918 1601 path, (int) uid, (int) gid);
93bed9fe
JG
1602 ret = lttng_strncpy(data.u.unlink.path, path,
1603 sizeof(data.u.unlink.path));
1604 if (ret) {
1605 goto error;
1606 }
1607 data.u.unlink.dirfd = dirfd;
1608 run_as(dirfd == AT_FDCWD ? RUN_AS_UNLINK : RUN_AS_UNLINKAT, &data,
1609 &run_as_ret, uid, gid);
1610 errno = run_as_ret._errno;
1611 ret = run_as_ret.u.ret;
1612error:
1613 return ret;
1614}
1615
1616LTTNG_HIDDEN
1617int run_as_rmdir(const char *path, uid_t uid, gid_t gid)
1618{
1619 return run_as_rmdirat(AT_FDCWD, path, uid, gid);
1620}
1621
1622LTTNG_HIDDEN
1623int run_as_rmdirat(int dirfd, const char *path, uid_t uid, gid_t gid)
1624{
1625 int ret;
1626 struct run_as_data data = {};
1627 struct run_as_ret run_as_ret = {};
1628
1629 DBG3("rmdirat() fd = %d%s, path = %s, uid = %d, gid = %d",
1630 dirfd, dirfd == AT_FDCWD ? " (AT_FDCWD)" : "",
1631 path, (int) uid, (int) gid);
1632 ret = lttng_strncpy(data.u.rmdir.path, path,
1633 sizeof(data.u.rmdir.path));
1634 if (ret) {
1635 goto error;
1636 }
1637 data.u.rmdir.dirfd = dirfd;
1638 run_as(dirfd == AT_FDCWD ? RUN_AS_RMDIR : RUN_AS_RMDIRAT, &data,
1639 &run_as_ret, uid, gid);
1640 errno = run_as_ret._errno;
1641 ret = run_as_ret.u.ret;
1642error:
1643 return ret;
4628484a
MD
1644}
1645
1646LTTNG_HIDDEN
f75c5439 1647int run_as_rmdir_recursive(const char *path, uid_t uid, gid_t gid, int flags)
4628484a 1648{
f75c5439 1649 return run_as_rmdirat_recursive(AT_FDCWD, path, uid, gid, flags);
93bed9fe 1650}
fe9f7760 1651
93bed9fe 1652LTTNG_HIDDEN
f75c5439 1653int run_as_rmdirat_recursive(int dirfd, const char *path, uid_t uid, gid_t gid, int flags)
93bed9fe
JG
1654{
1655 int ret;
1656 struct run_as_data data = {};
1657 struct run_as_ret run_as_ret = {};
4628484a 1658
93bed9fe
JG
1659 DBG3("rmdirat() recursive fd = %d%s, path = %s, uid = %d, gid = %d",
1660 dirfd, dirfd == AT_FDCWD ? " (AT_FDCWD)" : "",
08797918 1661 path, (int) uid, (int) gid);
93bed9fe
JG
1662 ret = lttng_strncpy(data.u.rmdir.path, path,
1663 sizeof(data.u.rmdir.path));
1664 if (ret) {
1665 goto error;
1666 }
1667 data.u.rmdir.dirfd = dirfd;
f75c5439 1668 data.u.rmdir.flags = flags;
93bed9fe
JG
1669 run_as(dirfd == AT_FDCWD ? RUN_AS_RMDIR_RECURSIVE : RUN_AS_RMDIRAT_RECURSIVE,
1670 &data, &run_as_ret, uid, gid);
1671 errno = run_as_ret._errno;
1672 ret = run_as_ret.u.ret;
1673error:
1674 return ret;
1675}
1676
1677LTTNG_HIDDEN
1678int run_as_rename(const char *old, const char *new, uid_t uid, gid_t gid)
1679{
1680 return run_as_renameat(AT_FDCWD, old, AT_FDCWD, new, uid, gid);
1681}
1682
1683LTTNG_HIDDEN
1684int run_as_renameat(int old_dirfd, const char *old_name,
1685 int new_dirfd, const char *new_name, uid_t uid, gid_t gid)
1686{
1687 int ret;
1688 struct run_as_data data = {};
1689 struct run_as_ret run_as_ret = {};
1690
1691 DBG3("renameat() old_dirfd = %d%s, old_name = %s, new_dirfd = %d%s, new_name = %s, uid = %d, gid = %d",
1692 old_dirfd, old_dirfd == AT_FDCWD ? " (AT_FDCWD)" : "",
1693 old_name,
1694 new_dirfd, new_dirfd == AT_FDCWD ? " (AT_FDCWD)" : "",
1695 new_name, (int) uid, (int) gid);
1696 ret = lttng_strncpy(data.u.rename.old_path, old_name,
1697 sizeof(data.u.rename.old_path));
1698 if (ret) {
1699 goto error;
1700 }
1701 ret = lttng_strncpy(data.u.rename.new_path, new_name,
1702 sizeof(data.u.rename.new_path));
1703 if (ret) {
1704 goto error;
1705 }
1706
1707 data.u.rename.dirfds[0] = old_dirfd;
1708 data.u.rename.dirfds[1] = new_dirfd;
1709 run_as(old_dirfd == AT_FDCWD && new_dirfd == AT_FDCWD ?
1710 RUN_AS_RENAME : RUN_AS_RENAMEAT,
1711 &data, &run_as_ret, uid, gid);
1712 errno = run_as_ret._errno;
1713 ret = run_as_ret.u.ret;
1714error:
1715 return ret;
7567352f
MD
1716}
1717
241e0a5a
FD
1718LTTNG_HIDDEN
1719int run_as_extract_elf_symbol_offset(int fd, const char* function,
1720 uid_t uid, gid_t gid, uint64_t *offset)
1721{
93bed9fe
JG
1722 int ret;
1723 struct run_as_data data = {};
55cb0d6f 1724 struct run_as_ret run_as_ret = {};
f726677b 1725
241e0a5a 1726 DBG3("extract_elf_symbol_offset() on fd=%d and function=%s "
93bed9fe
JG
1727 "with for uid %d and gid %d", fd, function,
1728 (int) uid, (int) gid);
241e0a5a 1729
93bed9fe 1730 data.u.extract_elf_symbol_offset.fd = fd;
241e0a5a
FD
1731
1732 strncpy(data.u.extract_elf_symbol_offset.function, function, LTTNG_SYMBOL_NAME_LEN - 1);
241e0a5a 1733 data.u.extract_elf_symbol_offset.function[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
93bed9fe
JG
1734 ret = lttng_strncpy(data.u.extract_elf_symbol_offset.function,
1735 function,
1736 sizeof(data.u.extract_elf_symbol_offset.function));
1737 if (ret) {
1738 goto error;
1739 }
241e0a5a 1740
93bed9fe
JG
1741 run_as(RUN_AS_EXTRACT_ELF_SYMBOL_OFFSET, &data, &run_as_ret, uid, gid);
1742 errno = run_as_ret._errno;
1743 if (run_as_ret._error) {
1744 ret = -1;
1745 goto error;
241e0a5a
FD
1746 }
1747
93bed9fe
JG
1748 *offset = run_as_ret.u.extract_elf_symbol_offset.offset;
1749error:
1750 return ret;
241e0a5a
FD
1751}
1752
0ef03255
FD
1753LTTNG_HIDDEN
1754int run_as_extract_sdt_probe_offsets(int fd, const char* provider_name,
1755 const char* probe_name, uid_t uid, gid_t gid,
1756 uint64_t **offsets, uint32_t *num_offset)
1757{
93bed9fe
JG
1758 int ret;
1759 struct run_as_data data = {};
1760 struct run_as_ret run_as_ret = {};
f726677b 1761
0ef03255 1762 DBG3("extract_sdt_probe_offsets() on fd=%d, probe_name=%s and "
93bed9fe
JG
1763 "provider_name=%s with for uid %d and gid %d", fd,
1764 probe_name, provider_name, (int) uid, (int) gid);
0ef03255 1765
93bed9fe 1766 data.u.extract_sdt_probe_offsets.fd = fd;
0ef03255 1767
93bed9fe
JG
1768 ret = lttng_strncpy(data.u.extract_sdt_probe_offsets.probe_name, probe_name,
1769 sizeof(data.u.extract_sdt_probe_offsets.probe_name));
1770 if (ret) {
1771 goto error;
1772 }
1773 ret = lttng_strncpy(data.u.extract_sdt_probe_offsets.provider_name,
1774 provider_name,
1775 sizeof(data.u.extract_sdt_probe_offsets.provider_name));
1776 if (ret) {
1777 goto error;
0ef03255
FD
1778 }
1779
93bed9fe
JG
1780 run_as(RUN_AS_EXTRACT_SDT_PROBE_OFFSETS, &data, &run_as_ret, uid, gid);
1781 errno = run_as_ret._errno;
1782 if (run_as_ret._error) {
1783 ret = -1;
1784 goto error;
1785 }
0ef03255 1786
93bed9fe 1787 *num_offset = run_as_ret.u.extract_sdt_probe_offsets.num_offset;
0ef03255
FD
1788 *offsets = zmalloc(*num_offset * sizeof(uint64_t));
1789 if (!*offsets) {
93bed9fe
JG
1790 ret = -ENOMEM;
1791 goto error;
0ef03255
FD
1792 }
1793
93bed9fe
JG
1794 memcpy(*offsets, run_as_ret.u.extract_sdt_probe_offsets.offsets,
1795 *num_offset * sizeof(uint64_t));
1796error:
1797 return ret;
0ef03255
FD
1798}
1799
c73f064a
JR
1800LTTNG_HIDDEN
1801int run_as_generate_filter_bytecode(const char *filter_expression,
1802 uid_t uid,
1803 gid_t gid,
1804 struct lttng_filter_bytecode **bytecode)
1805{
1806 int ret;
1807 struct run_as_data data = {};
1808 struct run_as_ret run_as_ret = {};
1809 const struct lttng_filter_bytecode *view_bytecode = NULL;
1810 struct lttng_filter_bytecode *local_bytecode = NULL;
1811
1812 DBG3("generate_filter_bytecode() from expression=\"%s\" for uid %d and gid %d",
1813 filter_expression, (int) uid, (int) gid);
1814
1815 ret = lttng_strncpy(data.u.generate_filter_bytecode.filter_expression, filter_expression,
1816 sizeof(data.u.generate_filter_bytecode.filter_expression));
1817 if (ret) {
1818 goto error;
1819 }
1820
1821 run_as(RUN_AS_GENERATE_FILTER_BYTECODE, &data, &run_as_ret, uid, gid);
1822 errno = run_as_ret._errno;
1823 if (run_as_ret._error) {
1824 ret = -1;
1825 goto error;
1826 }
1827
1828 view_bytecode = (const struct lttng_filter_bytecode *) run_as_ret.u.generate_filter_bytecode.bytecode;
1829
1830 local_bytecode = zmalloc(sizeof(*local_bytecode) + view_bytecode->len);
1831 if (!local_bytecode) {
1832 ret = -ENOMEM;
1833 goto error;
1834 }
1835
1836 memcpy(local_bytecode, run_as_ret.u.generate_filter_bytecode.bytecode,
1837 sizeof(*local_bytecode) + view_bytecode->len);
1838 *bytecode = local_bytecode;
1839error:
1840 return ret;
1841}
1842
7567352f 1843LTTNG_HIDDEN
929f71ec
JG
1844int run_as_create_worker(const char *procname,
1845 post_fork_cleanup_cb clean_up_func,
1846 void *clean_up_user_data)
7567352f 1847{
8fec83ea 1848 int ret;
7567352f 1849
749b7a0c 1850 pthread_mutex_lock(&worker_lock);
929f71ec
JG
1851 ret = run_as_create_worker_no_lock(procname, clean_up_func,
1852 clean_up_user_data);
749b7a0c 1853 pthread_mutex_unlock(&worker_lock);
7567352f
MD
1854 return ret;
1855}
1856
1857LTTNG_HIDDEN
1858void run_as_destroy_worker(void)
1859{
749b7a0c 1860 pthread_mutex_lock(&worker_lock);
a01c682b 1861 run_as_destroy_worker_no_lock();
749b7a0c 1862 pthread_mutex_unlock(&worker_lock);
4628484a 1863}
This page took 0.249007 seconds and 4 git commands to generate.