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 <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>
  21 #include <sched.h>
  22 #include <signal.h>
  23 #include <assert.h>
  24 #include <signal.h>
  25
  26 #include <common/lttng-kernel.h>
  27 #include <common/common.h>
  28 #include <common/utils.h>
  29 #include <common/compat/getenv.h>
  30 #include <common/compat/string.h>
  31 #include <common/unix.h>
  32 #include <common/defaults.h>
  33 #include <common/lttng-elf.h>
  34 #include <common/thread.h>
  35
  36 #include <lttng/constant.h>
  37
  38 #include <common/sessiond-comm/sessiond-comm.h>
  39 #include <common/filter/filter-ast.h>
  40 #include <common/filter/filter-bytecode.h>
  41
  42 #include "runas.h"
  43
  44 struct run_as_data;
  45 struct run_as_ret;
  46 typedef int (*run_as_fct)(struct run_as_data *data, struct run_as_ret *ret_value);
  47
  48 enum 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,
  65         RUN_AS_GENERATE_FILTER_BYTECODE,
  66 };
  67
  68 struct run_as_mkdir_data {
  69         int dirfd;
  70         char path[LTTNG_PATH_MAX];
  71         mode_t mode;
  72 } LTTNG_PACKED;
  73
  74 struct run_as_open_data {
  75         int dirfd;
  76         char path[LTTNG_PATH_MAX];
  77         int flags;
  78         mode_t mode;
  79 } LTTNG_PACKED;
  80
  81 struct run_as_unlink_data {
  82         int dirfd;
  83         char path[LTTNG_PATH_MAX];
  84 } LTTNG_PACKED;
  85
  86 struct run_as_rmdir_data {
  87         int dirfd;
  88         char path[LTTNG_PATH_MAX];
  89         int flags; /* enum lttng_directory_handle_rmdir_recursive_flags. */
  90 } LTTNG_PACKED;
  91
  92 struct run_as_extract_elf_symbol_offset_data {
  93         int fd;
  94         char function[LTTNG_SYMBOL_NAME_LEN];
  95 } LTTNG_PACKED;
  96
  97 struct run_as_extract_sdt_probe_offsets_data {
  98         int fd;
  99         char probe_name[LTTNG_SYMBOL_NAME_LEN];
 100         char provider_name[LTTNG_SYMBOL_NAME_LEN];
 101 } LTTNG_PACKED;
 102
 103 struct run_as_generate_filter_bytecode_data {
 104         char filter_expression[LTTNG_FILTER_MAX_LEN];
 105 } LTTNG_PACKED;
 106
 107 struct 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;
 116
 117 struct run_as_open_ret {
 118         int fd;
 119 } LTTNG_PACKED;
 120
 121 struct run_as_extract_elf_symbol_offset_ret {
 122         uint64_t offset;
 123 } LTTNG_PACKED;
 124
 125 struct run_as_extract_sdt_probe_offsets_ret {
 126         uint32_t num_offset;
 127         uint64_t offsets[LTTNG_KERNEL_MAX_UPROBE_NUM];
 128 } LTTNG_PACKED;
 129
 130 struct 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
 135 struct run_as_data {
 136         enum run_as_cmd cmd;
 137         union {
 138                 struct run_as_mkdir_data mkdir;
 139                 struct run_as_open_data open;
 140                 struct run_as_unlink_data unlink;
 141                 struct run_as_rmdir_data rmdir;
 142                 struct run_as_rename_data rename;
 143                 struct run_as_extract_elf_symbol_offset_data extract_elf_symbol_offset;
 144                 struct run_as_extract_sdt_probe_offsets_data extract_sdt_probe_offsets;
 145                 struct run_as_generate_filter_bytecode_data generate_filter_bytecode;
 146         } u;
 147         uid_t uid;
 148         gid_t gid;
 149 } LTTNG_PACKED;
 150
 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  */
 166 struct run_as_ret {
 167         union {
 168                 int ret;
 169                 struct run_as_open_ret open;
 170                 struct run_as_extract_elf_symbol_offset_ret extract_elf_symbol_offset;
 171                 struct run_as_extract_sdt_probe_offsets_ret extract_sdt_probe_offsets;
 172                 struct run_as_generate_filter_bytecode_ret generate_filter_bytecode;
 173         } u;
 174         int _errno;
 175         bool _error;
 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
 204 struct 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
 211 static 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         },
 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         },
 333 };
 334
 335 struct 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). */
 342 static struct run_as_worker *global_worker;
 343 /* Lock protecting the worker. */
 344 static pthread_mutex_t worker_lock = PTHREAD_MUTEX_INITIALIZER;
 345
 346 #ifdef VALGRIND
 347 static
 348 int use_clone(void)
 349 {
 350         return 0;
 351 }
 352 #else
 353 static
 354 int use_clone(void)
 355 {
 356         return !lttng_secure_getenv("LTTNG_DEBUG_NOCLONE");
 357 }
 358 #endif
 359
 360 /*
 361  * Create recursively directory using the FULL path.
 362  */
 363 static
 364 int _mkdirat_recursive(struct run_as_data *data, struct run_as_ret *ret_value)
 365 {
 366         const char *path;
 367         mode_t mode;
 368         struct lttng_directory_handle *handle;
 369
 370         path = data->u.mkdir.path;
 371         mode = data->u.mkdir.mode;
 372
 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         }
 380         /* Ownership of dirfd is transferred to the handle. */
 381         data->u.mkdir.dirfd = -1;
 382         /* Safe to call as we have transitioned to the requested uid/gid. */
 383         ret_value->u.ret = lttng_directory_handle_create_subdirectory_recursive(
 384                         handle, path, mode);
 385         ret_value->_errno = errno;
 386         ret_value->_error = (ret_value->u.ret) ? true : false;
 387         lttng_directory_handle_put(handle);
 388 end:
 389         return ret_value->u.ret;
 390 }
 391
 392 static
 393 int _mkdirat(struct run_as_data *data, struct run_as_ret *ret_value)
 394 {
 395         const char *path;
 396         mode_t mode;
 397         struct lttng_directory_handle *handle;
 398
 399         path = data->u.mkdir.path;
 400         mode = data->u.mkdir.mode;
 401
 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         }
 409         /* Ownership of dirfd is transferred to the handle. */
 410         data->u.mkdir.dirfd = -1;
 411         /* Safe to call as we have transitioned to the requested uid/gid. */
 412         ret_value->u.ret = lttng_directory_handle_create_subdirectory(
 413                         handle, path, mode);
 414         ret_value->_errno = errno;
 415         ret_value->_error = (ret_value->u.ret) ? true : false;
 416         lttng_directory_handle_put(handle);
 417 end:
 418         return ret_value->u.ret;
 419 }
 420
 421 static
 422 int _open(struct run_as_data *data, struct run_as_ret *ret_value)
 423 {
 424         int fd;
 425         struct lttng_directory_handle *handle;
 426
 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         }
 434         /* Ownership of dirfd is transferred to the handle. */
 435         data->u.open.dirfd = -1;
 436
 437         fd = lttng_directory_handle_open_file(handle,
 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
 448         ret_value->_errno = errno;
 449         ret_value->_error = fd < 0;
 450         lttng_directory_handle_put(handle);
 451 end:
 452         return ret_value->u.ret;
 453 }
 454
 455 static
 456 int _unlink(struct run_as_data *data, struct run_as_ret *ret_value)
 457 {
 458         struct lttng_directory_handle *handle;
 459
 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         }
 467
 468         /* Ownership of dirfd is transferred to the handle. */
 469         data->u.unlink.dirfd = -1;
 470
 471         ret_value->u.ret = lttng_directory_handle_unlink_file(handle,
 472                         data->u.unlink.path);
 473         ret_value->_errno = errno;
 474         ret_value->_error = (ret_value->u.ret) ? true : false;
 475         lttng_directory_handle_put(handle);
 476 end:
 477         return ret_value->u.ret;
 478 }
 479
 480 static
 481 int _rmdir(struct run_as_data *data, struct run_as_ret *ret_value)
 482 {
 483         struct lttng_directory_handle *handle;
 484
 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         }
 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(
 497                         handle, data->u.rmdir.path);
 498         ret_value->_errno = errno;
 499         ret_value->_error = (ret_value->u.ret) ? true : false;
 500         lttng_directory_handle_put(handle);
 501 end:
 502         return ret_value->u.ret;
 503 }
 504
 505 static
 506 int _rmdir_recursive(struct run_as_data *data, struct run_as_ret *ret_value)
 507 {
 508         struct lttng_directory_handle *handle;
 509
 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         }
 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(
 522                         handle, data->u.rmdir.path, data->u.rmdir.flags);
 523         ret_value->_errno = errno;
 524         ret_value->_error = (ret_value->u.ret) ? true : false;
 525         lttng_directory_handle_put(handle);
 526 end:
 527         return ret_value->u.ret;
 528 }
 529
 530 static
 531 int _rename(struct run_as_data *data, struct run_as_ret *ret_value)
 532 {
 533         const char *old_path, *new_path;
 534         struct lttng_directory_handle *old_handle = NULL, *new_handle = NULL;
 535
 536         old_path = data->u.rename.old_path;
 537         new_path = data->u.rename.new_path;
 538
 539         old_handle = lttng_directory_handle_create_from_dirfd(
 540                         data->u.rename.dirfds[0]);
 541         if (!old_handle) {
 542                 ret_value->u.ret = -1;
 543                 goto end;
 544         }
 545         new_handle = lttng_directory_handle_create_from_dirfd(
 546                         data->u.rename.dirfds[1]);
 547         if (!new_handle) {
 548                 ret_value->u.ret = -1;
 549                 goto end;
 550         }
 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(
 557                         old_handle, old_path, new_handle, new_path);
 558 end:
 559         lttng_directory_handle_put(old_handle);
 560         lttng_directory_handle_put(new_handle);
 561         ret_value->_errno = errno;
 562         ret_value->_error = (ret_value->u.ret) ? true : false;
 563         return ret_value->u.ret;
 564 }
 565
 566 #ifdef HAVE_ELF_H
 567 static
 568 int _extract_elf_symbol_offset(struct run_as_data *data,
 569                 struct run_as_ret *ret_value)
 570 {
 571         int ret = 0;
 572         uint64_t offset;
 573
 574         ret_value->_error = false;
 575         ret = lttng_elf_get_symbol_offset(data->u.extract_elf_symbol_offset.fd,
 576                          data->u.extract_elf_symbol_offset.function,
 577                          &offset);
 578         if (ret) {
 579                 DBG("Failed to extract ELF function offset");
 580                 ret_value->_error = true;
 581         }
 582         ret_value->u.extract_elf_symbol_offset.offset = offset;
 583
 584         return ret;
 585 }
 586
 587 static
 588 int _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. */
 598         ret = lttng_elf_get_sdt_probe_offsets(
 599                         data->u.extract_sdt_probe_offsets.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
 623 free_offset:
 624         free(offsets);
 625 end:
 626         return ret;
 627 }
 628 #else
 629 static
 630 int _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
 637 static
 638 int _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
 645
 646 static
 647 int _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
 679 end:
 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 }
 688 static
 689 run_as_fct run_as_enum_to_fct(enum run_as_cmd cmd)
 690 {
 691         switch (cmd) {
 692         case RUN_AS_MKDIR:
 693         case RUN_AS_MKDIRAT:
 694                 return _mkdirat;
 695         case RUN_AS_MKDIR_RECURSIVE:
 696         case RUN_AS_MKDIRAT_RECURSIVE:
 697                 return _mkdirat_recursive;
 698         case RUN_AS_OPEN:
 699         case RUN_AS_OPENAT:
 700                 return _open;
 701         case RUN_AS_UNLINK:
 702         case RUN_AS_UNLINKAT:
 703                 return _unlink;
 704         case RUN_AS_RMDIR:
 705         case RUN_AS_RMDIRAT:
 706                 return _rmdir;
 707         case RUN_AS_RMDIR_RECURSIVE:
 708         case RUN_AS_RMDIRAT_RECURSIVE:
 709                 return _rmdir_recursive;
 710         case RUN_AS_RENAME:
 711         case RUN_AS_RENAMEAT:
 712                 return _rename;
 713         case RUN_AS_EXTRACT_ELF_SYMBOL_OFFSET:
 714                 return _extract_elf_symbol_offset;
 715         case RUN_AS_EXTRACT_SDT_PROBE_OFFSETS:
 716                 return _extract_sdt_probe_offsets;
 717         case RUN_AS_GENERATE_FILTER_BYTECODE:
 718                 return _generate_filter_bytecode;
 719         default:
 720                 ERR("Unknown command %d", (int) cmd);
 721                 return NULL;
 722         }
 723 }
 724
 725 static
 726 int do_send_fds(int sock, const int *fds, unsigned int fd_count)
 727 {
 728         ssize_t len;
 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                 }
 738         }
 739
 740         len = lttcomm_send_fds_unix_sock(sock, fds, fd_count);
 741         return len < 0 ? -1 : 0;
 742 }
 743
 744 static
 745 int do_recv_fds(int sock, int *fds, unsigned int fd_count)
 746 {
 747         int ret = 0;
 748         unsigned int i;
 749         ssize_t len;
 750
 751         len = lttcomm_recv_fds_unix_sock(sock, fds, fd_count);
 752         if (len == 0) {
 753                 ret = -1;
 754                 goto end;
 755         } else if (len < 0) {
 756                 PERROR("Failed to receive file descriptors from socket");
 757                 ret = -1;
 758                 goto end;
 759         }
 760
 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                 }
 766         }
 767 end:
 768         return ret;
 769 }
 770
 771 static
 772 int send_fds_to_worker(const struct run_as_worker *worker,
 773                 const struct run_as_data *data)
 774 {
 775         int ret = 0;
 776         unsigned int i;
 777
 778         if (COMMAND_USE_CWD_FD(data) || COMMAND_IN_FD_COUNT(data) == 0) {
 779                 goto end;
 780         }
 781
 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                 }
 789         }
 790
 791         ret = do_send_fds(worker->sockpair[0], COMMAND_IN_FDS(data),
 792                         COMMAND_IN_FD_COUNT(data));
 793         if (ret < 0) {
 794                 PERROR("Failed to send file descriptor to run-as worker");
 795                 ret = -1;
 796                 goto end;
 797         }
 798 end:
 799         return ret;
 800 }
 801
 802 static
 803 int send_fds_to_master(struct run_as_worker *worker, enum run_as_cmd cmd,
 804                 struct run_as_ret *run_as_ret)
 805 {
 806         int ret = 0;
 807         unsigned int i;
 808
 809         if (COMMAND_OUT_FD_COUNT(cmd) == 0) {
 810                 goto end;
 811         }
 812
 813         ret = do_send_fds(worker->sockpair[1], COMMAND_OUT_FDS(cmd, run_as_ret),
 814                         COMMAND_OUT_FD_COUNT(cmd));
 815         if (ret < 0) {
 816                 PERROR("Failed to send file descriptor to master process");
 817                 goto end;
 818         }
 819
 820         for (i = 0; i < COMMAND_OUT_FD_COUNT(cmd); i++) {
 821                 int ret_close = close(COMMAND_OUT_FDS(cmd, run_as_ret)[i]);
 822
 823                 if (ret_close < 0) {
 824                         PERROR("Failed to close result file descriptor");
 825                 }
 826         }
 827 end:
 828         return ret;
 829 }
 830
 831 static
 832 int recv_fds_from_worker(const struct run_as_worker *worker, enum run_as_cmd cmd,
 833                 struct run_as_ret *run_as_ret)
 834 {
 835         int ret = 0;
 836
 837         if (COMMAND_OUT_FD_COUNT(cmd) == 0) {
 838                 goto end;
 839         }
 840
 841         ret = do_recv_fds(worker->sockpair[0], COMMAND_OUT_FDS(cmd, run_as_ret),
 842                         COMMAND_OUT_FD_COUNT(cmd));
 843         if (ret < 0) {
 844                 PERROR("Failed to receive file descriptor from run-as worker");
 845                 ret = -1;
 846         }
 847 end:
 848         return ret;
 849 }
 850
 851 static
 852 int recv_fds_from_master(struct run_as_worker *worker, struct run_as_data *data)
 853 {
 854         int ret = 0;
 855
 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;
 863         }
 864
 865         if (COMMAND_IN_FD_COUNT(data) == 0) {
 866                 goto end;
 867         }
 868
 869         ret = do_recv_fds(worker->sockpair[1], COMMAND_IN_FDS(data),
 870                         COMMAND_IN_FD_COUNT(data));
 871         if (ret < 0) {
 872                 PERROR("Failed to receive file descriptors from master process");
 873                 ret = -1;
 874         }
 875 end:
 876         return ret;
 877 }
 878
 879 static
 880 int cleanup_received_fds(struct run_as_data *data)
 881 {
 882         int ret = 0, i;
 883
 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                 }
 893         }
 894 end:
 895         return ret;
 896 }
 897
 898 /*
 899  * Return < 0 on error, 0 if OK, 1 on hangup.
 900  */
 901 static
 902 int handle_one_cmd(struct run_as_worker *worker)
 903 {
 904         int ret = 0;
 905         struct run_as_data data = {};
 906         ssize_t readlen, writelen;
 907         struct run_as_ret sendret = {};
 908         run_as_fct cmd;
 909         uid_t prev_euid;
 910
 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          */
 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         }
 928
 929         cmd = run_as_enum_to_fct(data.cmd);
 930         if (!cmd) {
 931                 ret = -1;
 932                 goto end;
 933         }
 934
 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          */
 940         ret = recv_fds_from_master(worker, &data);
 941         if (ret < 0) {
 942                 PERROR("recv_fd_from_master error");
 943                 ret = -1;
 944                 goto end;
 945         }
 946
 947         prev_euid = getuid();
 948         if (data.gid != getegid()) {
 949                 ret = setegid(data.gid);
 950                 if (ret < 0) {
 951                         sendret._error = true;
 952                         sendret._errno = errno;
 953                         PERROR("setegid");
 954                         goto write_return;
 955                 }
 956         }
 957         if (data.uid != prev_euid) {
 958                 ret = seteuid(data.uid);
 959                 if (ret < 0) {
 960                         sendret._error = true;
 961                         sendret._errno = errno;
 962                         PERROR("seteuid");
 963                         goto write_return;
 964                 }
 965         }
 966
 967         /*
 968          * Also set umask to 0 for mkdir executable bit.
 969          */
 970         umask(0);
 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         }
 979
 980 write_return:
 981         ret = cleanup_received_fds(&data);
 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          */
 991         writelen = lttcomm_send_unix_sock(worker->sockpair[1], &sendret,
 992                         sizeof(sendret));
 993         if (writelen < sizeof(sendret)) {
 994                 PERROR("lttcomm_send_unix_sock error");
 995                 ret = -1;
 996                 goto end;
 997         }
 998
 999         /*
1000          * Stage 5: Send resulting file descriptors to the master.
1001          */
1002         ret = send_fds_to_master(worker, data.cmd, &sendret);
1003         if (ret < 0) {
1004                 DBG("Sending FD to master returned an error");
1005                 goto end;
1006         }
1007
1008         if (seteuid(prev_euid) < 0) {
1009                 PERROR("seteuid");
1010                 ret = -1;
1011                 goto end;
1012         }
1013         ret = 0;
1014 end:
1015         return ret;
1016 }
1017
1018 static
1019 int 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
1033         ret = lttng_thread_setname(DEFAULT_RUN_AS_WORKER_NAME);
1034         if (ret && ret != -ENOSYS) {
1035                 /* Don't fail as this is not essential. */
1036                 DBG("Failed to set pthread name attribute");
1037         }
1038
1039         memset(&sendret, 0, sizeof(sendret));
1040
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;
1061 end:
1062         return ret;
1063 }
1064
1065 static
1066 int run_as_cmd(struct run_as_worker *worker,
1067                 enum run_as_cmd cmd,
1068                 struct run_as_data *data,
1069                 struct run_as_ret *ret_value,
1070                 uid_t uid, gid_t gid)
1071 {
1072         int ret = 0;
1073         ssize_t readlen, writelen;
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()) {
1080                         ret = -1;
1081                         ret_value->_errno = EPERM;
1082                         ERR("Client (%d)/Server (%d) UID mismatch (and sessiond is not root)",
1083                                 (int) uid, (int) geteuid());
1084                         goto end;
1085                 }
1086         }
1087
1088         data->cmd = cmd;
1089         data->uid = uid;
1090         data->gid = gid;
1091
1092         /*
1093          * Stage 1: Send the run_as_data struct to the worker process
1094          */
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");
1099                 ret = -1;
1100                 ret_value->_errno = EIO;
1101                 goto end;
1102         }
1103
1104         /*
1105          * Stage 2: Send file descriptor to the worker process if needed
1106          */
1107         ret = send_fds_to_worker(worker, data);
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));
1125         if (!readlen) {
1126                 ERR("Run-as worker has hung-up during run_as_cmd");
1127                 ret = -1;
1128                 ret_value->_errno = EIO;
1129                 goto end;
1130         } else if (readlen < sizeof(*ret_value)) {
1131                 PERROR("Error reading response from run_as");
1132                 ret = -1;
1133                 ret_value->_errno = errno;
1134                 goto end;
1135         }
1136
1137         if (ret_value->_error) {
1138                 /* Skip stage 5 on error as there will be no fd to receive. */
1139                 goto end;
1140         }
1141
1142         /*
1143          * Stage 5: Receive file descriptor if needed
1144          */
1145         ret = recv_fds_from_worker(worker, cmd, ret_value);
1146         if (ret < 0) {
1147                 ERR("Error receiving fd");
1148                 ret = -1;
1149                 ret_value->_errno = EIO;
1150         }
1151
1152 end:
1153         return ret;
1154 }
1155
1156 /*
1157  * This is for debugging ONLY and should not be considered secure.
1158  */
1159 static
1160 int 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)
1163 {
1164         int ret, saved_errno;
1165         mode_t old_mask;
1166         run_as_fct fct;
1167
1168         fct = run_as_enum_to_fct(cmd);
1169         if (!fct) {
1170                 errno = -ENOSYS;
1171                 ret = -1;
1172                 goto end;
1173         }
1174         old_mask = umask(0);
1175         ret = fct(data, ret_value);
1176         saved_errno = ret_value->_errno;
1177         umask(old_mask);
1178         errno = saved_errno;
1179 end:
1180         return ret;
1181 }
1182
1183 static
1184 int 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
1195 static
1196 void 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
1224 static
1225 int 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");
1250 end:
1251         return ret;
1252 }
1253
1254 static
1255 int run_as_create_worker_no_lock(const char *procname,
1256                 post_fork_cleanup_cb clean_up_func,
1257                 void *clean_up_user_data)
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;
1282                 goto error_procname_alloc;
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();
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                 }
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;
1332                 free(worker->procname);
1333                 free(worker);
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         }
1358 end:
1359         return ret;
1360
1361         /* Error handling. */
1362 error_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         }
1372 error_sock:
1373         free(worker->procname);
1374 error_procname_alloc:
1375         free(worker);
1376         return ret;
1377 }
1378
1379 static
1380 void 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",
1411                                         WEXITSTATUS(status));
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
1424 static
1425 int run_as_restart_worker(struct run_as_worker *worker)
1426 {
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 */
1433         run_as_destroy_worker_no_lock();
1434
1435         /* Create a new run_as worker process*/
1436         ret = run_as_create_worker_no_lock(procname, NULL, NULL);
1437         if (ret < 0 ) {
1438                 ERR("Restarting the worker process failed");
1439                 ret = -1;
1440                 goto err;
1441         }
1442 err:
1443         return ret;
1444 }
1445
1446 static
1447 int 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;
1451
1452         pthread_mutex_lock(&worker_lock);
1453         if (use_clone()) {
1454                 DBG("Using run_as worker");
1455
1456                 assert(global_worker);
1457
1458                 ret = run_as_cmd(global_worker, cmd, data, ret_value, uid, gid);
1459                 saved_errno = ret_value->_errno;
1460
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);
1469                         if (ret == -1) {
1470                                 ERR("Failed to restart worker process.");
1471                                 goto err;
1472                         }
1473                 }
1474         } else {
1475                 DBG("Using run_as without worker");
1476                 ret = run_as_noworker(cmd, data, ret_value, uid, gid);
1477         }
1478 err:
1479         pthread_mutex_unlock(&worker_lock);
1480         return ret;
1481 }
1482
1483 LTTNG_HIDDEN
1484 int run_as_mkdir_recursive(const char *path, mode_t mode, uid_t uid, gid_t gid)
1485 {
1486         return run_as_mkdirat_recursive(AT_FDCWD, path, mode, uid, gid);
1487 }
1488
1489 LTTNG_HIDDEN
1490 int run_as_mkdirat_recursive(int dirfd, const char *path, mode_t mode,
1491                 uid_t uid, gid_t gid)
1492 {
1493         int ret;
1494         struct run_as_data data = {};
1495         struct run_as_ret run_as_ret = {};
1496
1497         DBG3("mkdirat() recursive fd = %d%s, path = %s, mode = %d, uid = %d, gid = %d",
1498                         dirfd, dirfd == AT_FDCWD ? " (AT_FDCWD)" : "",
1499                         path, (int) mode, (int) uid, (int) gid);
1500         ret = lttng_strncpy(data.u.mkdir.path, path,
1501                         sizeof(data.u.mkdir.path));
1502         if (ret) {
1503                 ERR("Failed to copy path argument of mkdirat recursive command");
1504                 goto error;
1505         }
1506         data.u.mkdir.path[sizeof(data.u.mkdir.path) - 1] = '\0';
1507         data.u.mkdir.mode = mode;
1508         data.u.mkdir.dirfd = dirfd;
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;
1512         ret = run_as_ret.u.ret;
1513 error:
1514         return ret;
1515 }
1516
1517 LTTNG_HIDDEN
1518 int run_as_mkdir(const char *path, mode_t mode, uid_t uid, gid_t gid)
1519 {
1520         return run_as_mkdirat(AT_FDCWD, path, mode, uid, gid);
1521 }
1522
1523 LTTNG_HIDDEN
1524 int run_as_mkdirat(int dirfd, const char *path, mode_t mode,
1525                 uid_t uid, gid_t gid)
1526 {
1527         int ret;
1528         struct run_as_data data = {};
1529         struct run_as_ret run_as_ret = {};
1530
1531         DBG3("mkdirat() recursive fd = %d%s, path = %s, mode = %d, uid = %d, gid = %d",
1532                         dirfd, dirfd == AT_FDCWD ? " (AT_FDCWD)" : "",
1533                         path, (int) mode, (int) uid, (int) gid);
1534         ret = lttng_strncpy(data.u.mkdir.path, path,
1535                         sizeof(data.u.mkdir.path));
1536         if (ret) {
1537                 ERR("Failed to copy path argument of mkdirat command");
1538                 goto error;
1539         }
1540         data.u.mkdir.path[sizeof(data.u.mkdir.path) - 1] = '\0';
1541         data.u.mkdir.mode = mode;
1542         data.u.mkdir.dirfd = dirfd;
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;
1546         ret = run_as_ret.u.ret;
1547 error:
1548         return ret;
1549 }
1550
1551 LTTNG_HIDDEN
1552 int run_as_open(const char *path, int flags, mode_t mode, uid_t uid,
1553                 gid_t gid)
1554 {
1555         return run_as_openat(AT_FDCWD, path, flags, mode, uid, gid);
1556 }
1557
1558 LTTNG_HIDDEN
1559 int run_as_openat(int dirfd, const char *path, int flags, mode_t mode,
1560                 uid_t uid, gid_t gid)
1561 {
1562         int ret;
1563         struct run_as_data data = {};
1564         struct run_as_ret run_as_ret = {};
1565
1566         DBG3("openat() fd = %d%s, path = %s, flags = %X, mode = %d, uid %d, gid %d",
1567                         dirfd, dirfd == AT_FDCWD ? " (AT_FDCWD)" : "",
1568                         path, flags, (int) mode, (int) uid, (int) gid);
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         }
1574         data.u.open.flags = flags;
1575         data.u.open.mode = mode;
1576         data.u.open.dirfd = dirfd;
1577         run_as(dirfd == AT_FDCWD ? RUN_AS_OPEN : RUN_AS_OPENAT,
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;
1582 error:
1583         return ret;
1584 }
1585
1586 LTTNG_HIDDEN
1587 int run_as_unlink(const char *path, uid_t uid, gid_t gid)
1588 {
1589         return run_as_unlinkat(AT_FDCWD, path, uid, gid);
1590 }
1591
1592 LTTNG_HIDDEN
1593 int run_as_unlinkat(int dirfd, const char *path, uid_t uid, gid_t gid)
1594 {
1595         int ret;
1596         struct run_as_data data = {};
1597         struct run_as_ret run_as_ret = {};
1598
1599         DBG3("unlinkat() fd = %d%s, path = %s, uid = %d, gid = %d",
1600                         dirfd, dirfd == AT_FDCWD ? " (AT_FDCWD)" : "",
1601                         path, (int) uid, (int) gid);
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;
1612 error:
1613         return ret;
1614 }
1615
1616 LTTNG_HIDDEN
1617 int 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
1622 LTTNG_HIDDEN
1623 int 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;
1642 error:
1643         return ret;
1644 }
1645
1646 LTTNG_HIDDEN
1647 int run_as_rmdir_recursive(const char *path, uid_t uid, gid_t gid, int flags)
1648 {
1649         return run_as_rmdirat_recursive(AT_FDCWD, path, uid, gid, flags);
1650 }
1651
1652 LTTNG_HIDDEN
1653 int run_as_rmdirat_recursive(int dirfd, const char *path, uid_t uid, gid_t gid, int flags)
1654 {
1655         int ret;
1656         struct run_as_data data = {};
1657         struct run_as_ret run_as_ret = {};
1658
1659         DBG3("rmdirat() recursive fd = %d%s, path = %s, uid = %d, gid = %d",
1660                         dirfd, dirfd == AT_FDCWD ? " (AT_FDCWD)" : "",
1661                         path, (int) uid, (int) gid);
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;
1668         data.u.rmdir.flags = flags;
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;
1673 error:
1674         return ret;
1675 }
1676
1677 LTTNG_HIDDEN
1678 int 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
1683 LTTNG_HIDDEN
1684 int 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;
1714 error:
1715         return ret;
1716 }
1717
1718 LTTNG_HIDDEN
1719 int run_as_extract_elf_symbol_offset(int fd, const char* function,
1720                 uid_t uid, gid_t gid, uint64_t *offset)
1721 {
1722         int ret;
1723         struct run_as_data data = {};
1724         struct run_as_ret run_as_ret = {};
1725
1726         DBG3("extract_elf_symbol_offset() on fd=%d and function=%s "
1727                         "with for uid %d and gid %d", fd, function,
1728                         (int) uid, (int) gid);
1729
1730         data.u.extract_elf_symbol_offset.fd = fd;
1731
1732         strncpy(data.u.extract_elf_symbol_offset.function, function, LTTNG_SYMBOL_NAME_LEN - 1);
1733         data.u.extract_elf_symbol_offset.function[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
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         }
1740
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;
1746         }
1747
1748         *offset = run_as_ret.u.extract_elf_symbol_offset.offset;
1749 error:
1750         return ret;
1751 }
1752
1753 LTTNG_HIDDEN
1754 int 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 {
1758         int ret;
1759         struct run_as_data data = {};
1760         struct run_as_ret run_as_ret = {};
1761
1762         DBG3("extract_sdt_probe_offsets() on fd=%d, probe_name=%s and "
1763                         "provider_name=%s with for uid %d and gid %d", fd,
1764                         probe_name, provider_name, (int) uid, (int) gid);
1765
1766         data.u.extract_sdt_probe_offsets.fd = fd;
1767
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;
1778         }
1779
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         }
1786
1787         *num_offset = run_as_ret.u.extract_sdt_probe_offsets.num_offset;
1788         *offsets = zmalloc(*num_offset * sizeof(uint64_t));
1789         if (!*offsets) {
1790                 ret = -ENOMEM;
1791                 goto error;
1792         }
1793
1794         memcpy(*offsets, run_as_ret.u.extract_sdt_probe_offsets.offsets,
1795                         *num_offset * sizeof(uint64_t));
1796 error:
1797         return ret;
1798 }
1799
1800 LTTNG_HIDDEN
1801 int 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;
1839 error:
1840         return ret;
1841 }
1842
1843 LTTNG_HIDDEN
1844 int run_as_create_worker(const char *procname,
1845                 post_fork_cleanup_cb clean_up_func,
1846                 void *clean_up_user_data)
1847 {
1848         int ret;
1849
1850         pthread_mutex_lock(&worker_lock);
1851         ret = run_as_create_worker_no_lock(procname, clean_up_func,
1852                         clean_up_user_data);
1853         pthread_mutex_unlock(&worker_lock);
1854         return ret;
1855 }
1856
1857 LTTNG_HIDDEN
1858 void run_as_destroy_worker(void)
1859 {
1860         pthread_mutex_lock(&worker_lock);
1861         run_as_destroy_worker_no_lock();
1862         pthread_mutex_unlock(&worker_lock);
1863 }