src/common/runas.c

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