src/common/runas.c

   1 /*
   2  * Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca>
   3  *                      Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License, version 2 only,
   7  * as published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  12  * more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with this program; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  17  */
  18
  19 #define _LGPL_SOURCE
  20 #include <errno.h>
  21 #include <limits.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <sys/wait.h>
  26 #include <sys/types.h>
  27 #include <sys/stat.h>
  28 #include <unistd.h>
  29 #include <fcntl.h>
  30 #include <sched.h>
  31 #include <signal.h>
  32 #include <assert.h>
  33 #include <signal.h>
  34
  35 #include <common/lttng-kernel.h>
  36 #include <common/common.h>
  37 #include <common/utils.h>
  38 #include <common/compat/getenv.h>
  39 #include <common/compat/prctl.h>
  40 #include <common/unix.h>
  41 #include <common/defaults.h>
  42 #include <common/lttng-elf.h>
  43
  44 #include <lttng/constant.h>
  45
  46 #include "runas.h"
  47
  48 struct run_as_data;
  49 struct run_as_ret;
  50 typedef int (*run_as_fct)(struct run_as_data *data, struct run_as_ret *ret_value);
  51
  52 struct run_as_mkdir_data {
  53         char path[PATH_MAX];
  54         mode_t mode;
  55 };
  56
  57 struct run_as_open_data {
  58         char path[PATH_MAX];
  59         int flags;
  60         mode_t mode;
  61 };
  62
  63 struct run_as_unlink_data {
  64         char path[PATH_MAX];
  65 };
  66
  67 struct run_as_rmdir_recursive_data {
  68         char path[PATH_MAX];
  69 };
  70
  71 struct run_as_extract_elf_symbol_offset_data {
  72         char function[LTTNG_SYMBOL_NAME_LEN];
  73 };
  74
  75 struct run_as_extract_sdt_probe_offsets_data {
  76         char probe_name[LTTNG_SYMBOL_NAME_LEN];
  77         char provider_name[LTTNG_SYMBOL_NAME_LEN];
  78 };
  79
  80 struct run_as_mkdir_ret {
  81         int ret;
  82 };
  83
  84 struct run_as_open_ret {
  85         int ret;
  86 };
  87
  88 struct run_as_unlink_ret {
  89         int ret;
  90 };
  91
  92 struct run_as_rmdir_recursive_ret {
  93         int ret;
  94 };
  95
  96 struct run_as_extract_elf_symbol_offset_ret {
  97         uint64_t offset;
  98 };
  99
 100 struct run_as_extract_sdt_probe_offsets_ret {
 101         uint32_t num_offset;
 102         uint64_t offsets[LTTNG_KERNEL_MAX_UPROBE_NUM];
 103 };
 104
 105 enum run_as_cmd {
 106         RUN_AS_MKDIR,
 107         RUN_AS_OPEN,
 108         RUN_AS_UNLINK,
 109         RUN_AS_RMDIR_RECURSIVE,
 110         RUN_AS_MKDIR_RECURSIVE,
 111         RUN_AS_EXTRACT_ELF_SYMBOL_OFFSET,
 112         RUN_AS_EXTRACT_SDT_PROBE_OFFSETS,
 113 };
 114
 115 struct run_as_data {
 116         enum run_as_cmd cmd;
 117         int fd;
 118         union {
 119                 struct run_as_mkdir_data mkdir;
 120                 struct run_as_open_data open;
 121                 struct run_as_unlink_data unlink;
 122                 struct run_as_rmdir_recursive_data rmdir_recursive;
 123                 struct run_as_extract_elf_symbol_offset_data extract_elf_symbol_offset;
 124                 struct run_as_extract_sdt_probe_offsets_data extract_sdt_probe_offsets;
 125         } u;
 126         uid_t uid;
 127         gid_t gid;
 128 };
 129
 130 /*
 131  * The run_as_ret structure holds the returned value and status of the command.
 132  *
 133  * The `u` union field holds the return value of the command; in most cases it
 134  * represents the success or the failure of the command. In more complex
 135  * commands, it holds a computed value.
 136  *
 137  * The _errno field is the errno recorded after the execution of the command.
 138  *
 139  * The _error fields is used the signify that return status of the command. For
 140  * simple commands returning `int` the _error field will be the same as the
 141  * ret_int field. In complex commands, it signify the success or failure of the
 142  * command.
 143  *
 144  */
 145 struct run_as_ret {
 146         int fd;
 147         union {
 148                 struct run_as_mkdir_ret mkdir;
 149                 struct run_as_open_ret open;
 150                 struct run_as_unlink_ret unlink;
 151                 struct run_as_rmdir_recursive_ret rmdir_recursive;
 152                 struct run_as_extract_elf_symbol_offset_ret extract_elf_symbol_offset;
 153                 struct run_as_extract_sdt_probe_offsets_ret extract_sdt_probe_offsets;
 154         } u;
 155         int _errno;
 156         bool _error;
 157 };
 158
 159 struct run_as_worker {
 160         pid_t pid;      /* Worker PID. */
 161         int sockpair[2];
 162         char *procname;
 163 };
 164
 165 /* Single global worker per process (for now). */
 166 static struct run_as_worker *global_worker;
 167 /* Lock protecting the worker. */
 168 static pthread_mutex_t worker_lock = PTHREAD_MUTEX_INITIALIZER;
 169
 170 #ifdef VALGRIND
 171 static
 172 int use_clone(void)
 173 {
 174         return 0;
 175 }
 176 #else
 177 static
 178 int use_clone(void)
 179 {
 180         return !lttng_secure_getenv("LTTNG_DEBUG_NOCLONE");
 181 }
 182 #endif
 183
 184 LTTNG_HIDDEN
 185 int _utils_mkdir_recursive_unsafe(const char *path, mode_t mode);
 186
 187 /*
 188  * Create recursively directory using the FULL path.
 189  */
 190 static
 191 int _mkdir_recursive(struct run_as_data *data, struct run_as_ret *ret_value)
 192 {
 193         const char *path;
 194         mode_t mode;
 195
 196         path = data->u.mkdir.path;
 197         mode = data->u.mkdir.mode;
 198
 199         /* Safe to call as we have transitioned to the requested uid/gid. */
 200         ret_value->u.mkdir.ret = _utils_mkdir_recursive_unsafe(path, mode);
 201         ret_value->_errno = errno;
 202         ret_value->_error = (ret_value->u.mkdir.ret) ? true : false;
 203         return ret_value->u.mkdir.ret;
 204 }
 205
 206 static
 207 int _mkdir(struct run_as_data *data, struct run_as_ret *ret_value)
 208 {
 209         ret_value->u.mkdir.ret = mkdir(data->u.mkdir.path, data->u.mkdir.mode);
 210         ret_value->_errno = errno;
 211         ret_value->_error = (ret_value->u.mkdir.ret) ? true : false;
 212         return ret_value->u.mkdir.ret;
 213 }
 214
 215 static
 216 int _open(struct run_as_data *data, struct run_as_ret *ret_value)
 217 {
 218         ret_value->u.open.ret = open(data->u.open.path, data->u.open.flags, data->u.open.mode);
 219         ret_value->fd = ret_value->u.open.ret;
 220         ret_value->_errno = errno;
 221         ret_value->_error = (ret_value->u.open.ret) ? true : false;
 222         return ret_value->u.open.ret;
 223 }
 224
 225 static
 226 int _unlink(struct run_as_data *data, struct run_as_ret *ret_value)
 227 {
 228         ret_value->u.unlink.ret = unlink(data->u.unlink.path);
 229         ret_value->_errno = errno;
 230         ret_value->_error = (ret_value->u.unlink.ret) ? true : false;
 231         return ret_value->u.unlink.ret;
 232 }
 233
 234 static
 235 int _rmdir_recursive(struct run_as_data *data, struct run_as_ret *ret_value)
 236 {
 237         ret_value->u.rmdir_recursive.ret = utils_recursive_rmdir(data->u.rmdir_recursive.path);
 238         ret_value->_errno = errno;
 239         ret_value->_error = (ret_value->u.rmdir_recursive.ret) ? true : false;
 240         return ret_value->u.rmdir_recursive.ret;
 241 }
 242
 243 static
 244 int _extract_elf_symbol_offset(struct run_as_data *data,
 245                 struct run_as_ret *ret_value)
 246 {
 247         int ret = 0;
 248         ret_value->_error = false;
 249
 250         ret = lttng_elf_get_symbol_offset(data->fd,
 251                          data->u.extract_elf_symbol_offset.function,
 252                          &ret_value->u.extract_elf_symbol_offset.offset);
 253         if (ret) {
 254                 DBG("Failed to extract ELF function offset");
 255                 ret_value->_error = true;
 256         }
 257
 258         return ret;
 259 }
 260
 261 static
 262 int _extract_sdt_probe_offsets(struct run_as_data *data,
 263                 struct run_as_ret *ret_value)
 264 {
 265         int ret = 0;
 266         uint64_t *offsets = NULL;
 267         uint32_t num_offset;
 268
 269         ret_value->_error = false;
 270
 271         /* On success, this call allocates the offsets paramater. */
 272         ret = lttng_elf_get_sdt_probe_offsets(data->fd,
 273                         data->u.extract_sdt_probe_offsets.provider_name,
 274                         data->u.extract_sdt_probe_offsets.probe_name,
 275                         &offsets, &num_offset);
 276
 277         if (ret) {
 278                 DBG("Failed to extract SDT probe offsets");
 279                 ret_value->_error = true;
 280                 goto end;
 281         }
 282
 283         if (num_offset <= 0 || num_offset > LTTNG_KERNEL_MAX_UPROBE_NUM) {
 284                 DBG("Wrong number of probes.");
 285                 ret = -1;
 286                 ret_value->_error = true;
 287                 goto free_offset;
 288         }
 289
 290         /* Copy the content of the offsets array to the ret struct. */
 291         memcpy(ret_value->u.extract_sdt_probe_offsets.offsets,
 292                         offsets, num_offset * sizeof(uint64_t));
 293
 294         ret_value->u.extract_sdt_probe_offsets.num_offset = num_offset;
 295
 296 free_offset:
 297         free(offsets);
 298 end:
 299         return ret;
 300 }
 301
 302 static
 303 run_as_fct run_as_enum_to_fct(enum run_as_cmd cmd)
 304 {
 305         switch (cmd) {
 306         case RUN_AS_MKDIR:
 307                 return _mkdir;
 308         case RUN_AS_OPEN:
 309                 return _open;
 310         case RUN_AS_UNLINK:
 311                 return _unlink;
 312         case RUN_AS_RMDIR_RECURSIVE:
 313                 return _rmdir_recursive;
 314         case RUN_AS_MKDIR_RECURSIVE:
 315                 return _mkdir_recursive;
 316         case RUN_AS_EXTRACT_ELF_SYMBOL_OFFSET:
 317                 return _extract_elf_symbol_offset;
 318         case RUN_AS_EXTRACT_SDT_PROBE_OFFSETS:
 319                 return _extract_sdt_probe_offsets;
 320         default:
 321                 ERR("Unknown command %d", (int) cmd);
 322                 return NULL;
 323         }
 324 }
 325
 326 static
 327 int do_send_fd(int sock, int fd)
 328 {
 329         ssize_t len;
 330
 331         if (fd < 0) {
 332                 ERR("Invalid file description");
 333                 return 0;
 334         }
 335
 336         len = lttcomm_send_fds_unix_sock(sock, &fd, 1);
 337         if (len < 0) {
 338                 PERROR("lttcomm_send_fds_unix_sock");
 339                 return -1;
 340         }
 341         return 0;
 342 }
 343
 344 static
 345 int do_recv_fd(int sock, int *fd)
 346 {
 347         ssize_t len;
 348
 349         if (*fd < 0) {
 350                 ERR("Invalid file description");
 351                 return 0;
 352         }
 353
 354         len = lttcomm_recv_fds_unix_sock(sock, fd, 1);
 355
 356         if (!len) {
 357                 return -1;
 358         } else if (len < 0) {
 359                 PERROR("lttcomm_recv_fds_unix_sock");
 360                 return -1;
 361         }
 362         return 0;
 363 }
 364
 365 static
 366 int send_fd_to_worker(struct run_as_worker *worker, enum run_as_cmd cmd, int fd)
 367 {
 368         int ret = 0;
 369
 370         switch (cmd) {
 371         case RUN_AS_EXTRACT_ELF_SYMBOL_OFFSET:
 372         case RUN_AS_EXTRACT_SDT_PROBE_OFFSETS:
 373                 break;
 374         default:
 375                 return 0;
 376         }
 377
 378         ret = do_send_fd(worker->sockpair[0], fd);
 379         if (ret < 0) {
 380                 PERROR("do_send_fd");
 381                 ret = -1;
 382         }
 383
 384         return ret;
 385 }
 386
 387 static
 388 int send_fd_to_master(struct run_as_worker *worker, enum run_as_cmd cmd, int fd)
 389 {
 390         int ret = 0, ret_close = 0;
 391
 392         switch (cmd) {
 393         case RUN_AS_OPEN:
 394                 break;
 395         default:
 396                 return 0;
 397         }
 398
 399         ret = do_send_fd(worker->sockpair[1], fd);
 400         if (ret < 0) {
 401                 PERROR("do_send_fd error");
 402                 ret = -1;
 403         }
 404
 405         ret_close = close(fd);
 406         if (ret_close < 0) {
 407                 PERROR("close");
 408         }
 409
 410         return ret;
 411 }
 412
 413 static
 414 int recv_fd_from_worker(struct run_as_worker *worker, enum run_as_cmd cmd, int *fd)
 415 {
 416         int ret = 0;
 417
 418         switch (cmd) {
 419         case RUN_AS_OPEN:
 420                 break;
 421         default:
 422                 return 0;
 423         }
 424
 425         ret = do_recv_fd(worker->sockpair[0], fd);
 426         if (ret < 0) {
 427                 PERROR("do_recv_fd error");
 428                 ret = -1;
 429         }
 430
 431         return ret;
 432 }
 433
 434 static
 435 int recv_fd_from_master(struct run_as_worker *worker, enum run_as_cmd cmd, int *fd)
 436 {
 437         int ret = 0;
 438
 439         switch (cmd) {
 440         case RUN_AS_EXTRACT_ELF_SYMBOL_OFFSET:
 441         case RUN_AS_EXTRACT_SDT_PROBE_OFFSETS:
 442                 break;
 443         default:
 444                 return 0;
 445         }
 446
 447         ret = do_recv_fd(worker->sockpair[1], fd);
 448         if (ret < 0) {
 449                 PERROR("do_recv_fd error");
 450                 ret = -1;
 451         }
 452
 453         return ret;
 454 }
 455
 456 static
 457 int cleanup_received_fd(enum run_as_cmd cmd, int fd)
 458 {
 459         int ret = 0;
 460
 461         switch (cmd) {
 462         case RUN_AS_EXTRACT_ELF_SYMBOL_OFFSET:
 463         case RUN_AS_EXTRACT_SDT_PROBE_OFFSETS:
 464                 break;
 465         default:
 466                 return 0;
 467         }
 468
 469         if (fd < 0) {
 470                 return 0;
 471         }
 472         ret = close(fd);
 473         if (ret < 0) {
 474                 PERROR("close error");
 475                 ret = -1;
 476         }
 477
 478         return ret;
 479 }
 480
 481 /*
 482  * Return < 0 on error, 0 if OK, 1 on hangup.
 483  */
 484 static
 485 int handle_one_cmd(struct run_as_worker *worker)
 486 {
 487         int ret = 0;
 488         struct run_as_data data;
 489         ssize_t readlen, writelen;
 490         struct run_as_ret sendret;
 491         run_as_fct cmd;
 492         uid_t prev_euid;
 493
 494         memset(&sendret, 0, sizeof(sendret));
 495         sendret.fd = -1;
 496
 497         /*
 498          * Stage 1: Receive run_as_data struct from the master.
 499          * The structure contains the command type and all the parameters needed for
 500          * its execution
 501          */
 502         readlen = lttcomm_recv_unix_sock(worker->sockpair[1], &data,
 503                         sizeof(data));
 504         if (readlen == 0) {
 505                 /* hang up */
 506                 ret = 1;
 507                 goto end;
 508         }
 509         if (readlen < sizeof(data)) {
 510                 PERROR("lttcomm_recv_unix_sock error");
 511                 ret = -1;
 512                 goto end;
 513         }
 514
 515         cmd = run_as_enum_to_fct(data.cmd);
 516         if (!cmd) {
 517                 ret = -1;
 518                 goto end;
 519         }
 520
 521         /*
 522          * Stage 2: Receive file descriptor from master.
 523          * Some commands need a file descriptor as input so if it's needed we
 524          * receive the fd using the Unix socket.
 525          */
 526         ret = recv_fd_from_master(worker, data.cmd, &data.fd);
 527         if (ret < 0) {
 528                 PERROR("recv_fd_from_master error");
 529                 ret = -1;
 530                 goto end;
 531         }
 532
 533         prev_euid = getuid();
 534         if (data.gid != getegid()) {
 535                 ret = setegid(data.gid);
 536                 if (ret < 0) {
 537                         sendret._error = true;
 538                         sendret._errno = errno;
 539                         PERROR("setegid");
 540                         goto write_return;
 541                 }
 542         }
 543         if (data.uid != prev_euid) {
 544                 ret = seteuid(data.uid);
 545                 if (ret < 0) {
 546                         sendret._error = true;
 547                         sendret._errno = errno;
 548                         PERROR("seteuid");
 549                         goto write_return;
 550                 }
 551         }
 552
 553         /*
 554          * Also set umask to 0 for mkdir executable bit.
 555          */
 556         umask(0);
 557
 558         /*
 559          * Stage 3: Execute the command
 560          */
 561         ret = (*cmd)(&data, &sendret);
 562         if (ret < 0) {
 563                 DBG("Execution of command returned an error");
 564         }
 565
 566 write_return:
 567         ret = cleanup_received_fd(data.cmd, data.fd);
 568         if (ret < 0) {
 569                 ERR("Error cleaning up FD");
 570                 goto end;
 571         }
 572
 573         /*
 574          * Stage 4: Send run_as_ret structure to the master.
 575          * This structure contain the return value of the command and the errno.
 576          */
 577         writelen = lttcomm_send_unix_sock(worker->sockpair[1], &sendret,
 578                         sizeof(sendret));
 579         if (writelen < sizeof(sendret)) {
 580                 PERROR("lttcomm_send_unix_sock error");
 581                 ret = -1;
 582                 goto end;
 583         }
 584
 585         /*
 586          * Stage 5: Send file descriptor to the master
 587          * Some commands return a file descriptor so if it's needed we pass it back
 588          * to the master using the Unix socket.
 589          */
 590         ret = send_fd_to_master(worker, data.cmd, sendret.fd);
 591         if (ret < 0) {
 592                 DBG("Sending FD to master returned an error");
 593                 goto end;
 594         }
 595
 596         if (seteuid(prev_euid) < 0) {
 597                 PERROR("seteuid");
 598                 ret = -1;
 599                 goto end;
 600         }
 601         ret = 0;
 602 end:
 603         return ret;
 604 }
 605
 606 static
 607 int run_as_worker(struct run_as_worker *worker)
 608 {
 609         int ret;
 610         ssize_t writelen;
 611         struct run_as_ret sendret;
 612         size_t proc_orig_len;
 613
 614         /*
 615          * Initialize worker. Set a different process cmdline.
 616          */
 617         proc_orig_len = strlen(worker->procname);
 618         memset(worker->procname, 0, proc_orig_len);
 619         strncpy(worker->procname, DEFAULT_RUN_AS_WORKER_NAME, proc_orig_len);
 620
 621         ret = lttng_prctl(PR_SET_NAME,
 622                         (unsigned long) DEFAULT_RUN_AS_WORKER_NAME, 0, 0, 0);
 623         if (ret && ret != -ENOSYS) {
 624                 /* Don't fail as this is not essential. */
 625                 PERROR("prctl PR_SET_NAME");
 626         }
 627
 628         memset(&sendret, 0, sizeof(sendret));
 629
 630         writelen = lttcomm_send_unix_sock(worker->sockpair[1], &sendret,
 631                         sizeof(sendret));
 632         if (writelen < sizeof(sendret)) {
 633                 PERROR("lttcomm_send_unix_sock error");
 634                 ret = EXIT_FAILURE;
 635                 goto end;
 636         }
 637
 638         for (;;) {
 639                 ret = handle_one_cmd(worker);
 640                 if (ret < 0) {
 641                         ret = EXIT_FAILURE;
 642                         goto end;
 643                 } else if (ret > 0) {
 644                         break;
 645                 } else {
 646                         continue;       /* Next command. */
 647                 }
 648         }
 649         ret = EXIT_SUCCESS;
 650 end:
 651         return ret;
 652 }
 653
 654 static
 655 int run_as_cmd(struct run_as_worker *worker,
 656                 enum run_as_cmd cmd,
 657                 struct run_as_data *data,
 658                 struct run_as_ret *ret_value,
 659                 uid_t uid, gid_t gid)
 660 {
 661         int ret = 0;
 662         ssize_t readlen, writelen;
 663
 664         /*
 665          * If we are non-root, we can only deal with our own uid.
 666          */
 667         if (geteuid() != 0) {
 668                 if (uid != geteuid()) {
 669                         ret = -1;
 670                         ret_value->_errno = EPERM;
 671                         ERR("Client (%d)/Server (%d) UID mismatch (and sessiond is not root)",
 672                                 (int) uid, (int) geteuid());
 673                         goto end;
 674                 }
 675         }
 676
 677         data->cmd = cmd;
 678         data->uid = uid;
 679         data->gid = gid;
 680
 681         /*
 682          * Stage 1: Send the run_as_data struct to the worker process
 683          */
 684         writelen = lttcomm_send_unix_sock(worker->sockpair[0], data,
 685                         sizeof(*data));
 686         if (writelen < sizeof(*data)) {
 687                 PERROR("Error writing message to run_as");
 688                 ret = -1;
 689                 ret_value->_errno = EIO;
 690                 goto end;
 691         }
 692
 693         /*
 694          * Stage 2: Send file descriptor to the worker process if needed
 695          */
 696         ret = send_fd_to_worker(worker, data->cmd, data->fd);
 697         if (ret) {
 698                 PERROR("do_send_fd error");
 699                 ret = -1;
 700                 ret_value->_errno = EIO;
 701                 goto end;
 702         }
 703
 704         /*
 705          * Stage 3: Wait for the execution of the command
 706          */
 707
 708         /*
 709          * Stage 4: Receive the run_as_ret struct containing the return value and
 710          * errno
 711          */
 712         readlen = lttcomm_recv_unix_sock(worker->sockpair[0], ret_value,
 713                         sizeof(*ret_value));
 714         if (!readlen) {
 715                 ERR("Run-as worker has hung-up during run_as_cmd");
 716                 ret = -1;
 717                 ret_value->_errno = EIO;
 718                 goto end;
 719         } else if (readlen < sizeof(*ret_value)) {
 720                 PERROR("Error reading response from run_as");
 721                 ret = -1;
 722                 ret_value->_errno = errno;
 723                 goto end;
 724         }
 725
 726         /*
 727          * Stage 5: Receive file descriptor if needed
 728          */
 729         ret = recv_fd_from_worker(worker, data->cmd, &ret_value->fd);
 730         if (ret < 0) {
 731                 ERR("Error receiving fd");
 732                 ret = -1;
 733                 ret_value->_errno = EIO;
 734         }
 735
 736 end:
 737         return ret;
 738 }
 739
 740 /*
 741  * This is for debugging ONLY and should not be considered secure.
 742  */
 743 static
 744 int run_as_noworker(enum run_as_cmd cmd,
 745                 struct run_as_data *data, struct run_as_ret *ret_value,
 746                 uid_t uid, gid_t gid)
 747 {
 748         int ret, saved_errno;
 749         mode_t old_mask;
 750         run_as_fct fct;
 751
 752         fct = run_as_enum_to_fct(cmd);
 753         if (!fct) {
 754                 errno = -ENOSYS;
 755                 ret = -1;
 756                 goto end;
 757         }
 758         old_mask = umask(0);
 759         ret = fct(data, ret_value);
 760         saved_errno = ret_value->_errno;
 761         umask(old_mask);
 762         errno = saved_errno;
 763 end:
 764         return ret;
 765 }
 766
 767 static
 768 int run_as_restart_worker(struct run_as_worker *worker)
 769 {
 770         int ret = 0;
 771         char *procname = NULL;
 772
 773         procname = worker->procname;
 774
 775         /* Close socket to run_as worker process and clean up the zombie process */
 776         run_as_destroy_worker();
 777
 778         /* Create a new run_as worker process*/
 779         ret = run_as_create_worker(procname);
 780         if (ret < 0 ) {
 781                 ERR("Restarting the worker process failed");
 782                 ret = -1;
 783                 goto err;
 784         }
 785 err:
 786         return ret;
 787 }
 788
 789 static
 790 int run_as(enum run_as_cmd cmd, struct run_as_data *data,
 791                    struct run_as_ret *ret_value, uid_t uid, gid_t gid)
 792 {
 793         int ret, saved_errno;
 794
 795         if (use_clone()) {
 796                 DBG("Using run_as worker");
 797                 pthread_mutex_lock(&worker_lock);
 798                 assert(global_worker);
 799
 800                 ret = run_as_cmd(global_worker, cmd, data, ret_value, uid, gid);
 801                 saved_errno = ret_value->_errno;
 802
 803                 pthread_mutex_unlock(&worker_lock);
 804                 /*
 805                  * If the worker thread crashed the errno is set to EIO. we log
 806                  * the error and  start a new worker process.
 807                  */
 808                 if (ret == -1 && saved_errno == EIO) {
 809                         DBG("Socket closed unexpectedly... "
 810                                         "Restarting the worker process");
 811                         ret = run_as_restart_worker(global_worker);
 812
 813                         if (ret == -1) {
 814                                 ERR("Failed to restart worker process.");
 815                                 goto err;
 816                         }
 817                 }
 818         } else {
 819                 DBG("Using run_as without worker");
 820                 ret = run_as_noworker(cmd, data, ret_value, uid, gid);
 821         }
 822 err:
 823         return ret;
 824 }
 825
 826 LTTNG_HIDDEN
 827 int run_as_mkdir_recursive(const char *path, mode_t mode, uid_t uid, gid_t gid)
 828 {
 829         struct run_as_data data;
 830         struct run_as_ret ret;
 831
 832         memset(&data, 0, sizeof(data));
 833         memset(&ret, 0, sizeof(ret));
 834         DBG3("mkdir() recursive %s with mode %d for uid %d and gid %d",
 835                         path, (int) mode, (int) uid, (int) gid);
 836         strncpy(data.u.mkdir.path, path, PATH_MAX - 1);
 837         data.u.mkdir.path[PATH_MAX - 1] = '\0';
 838         data.u.mkdir.mode = mode;
 839
 840         run_as(RUN_AS_MKDIR_RECURSIVE, &data, &ret, uid, gid);
 841         errno = ret._errno;
 842         return ret.u.mkdir.ret;
 843 }
 844
 845 LTTNG_HIDDEN
 846 int run_as_mkdir(const char *path, mode_t mode, uid_t uid, gid_t gid)
 847 {
 848         struct run_as_data data;
 849         struct run_as_ret ret;
 850
 851         memset(&data, 0, sizeof(data));
 852         memset(&ret, 0, sizeof(ret));
 853
 854         DBG3("mkdir() %s with mode %d for uid %d and gid %d",
 855                         path, (int) mode, (int) uid, (int) gid);
 856         strncpy(data.u.mkdir.path, path, PATH_MAX - 1);
 857         data.u.mkdir.path[PATH_MAX - 1] = '\0';
 858         data.u.mkdir.mode = mode;
 859         run_as(RUN_AS_MKDIR, &data, &ret, uid, gid);
 860         errno = ret._errno;
 861         return ret.u.mkdir.ret;
 862 }
 863
 864 LTTNG_HIDDEN
 865 int run_as_open(const char *path, int flags, mode_t mode, uid_t uid, gid_t gid)
 866 {
 867         struct run_as_data data;
 868         struct run_as_ret ret;
 869
 870         memset(&data, 0, sizeof(data));
 871         memset(&ret, 0, sizeof(ret));
 872
 873         DBG3("open() %s with flags %X mode %d for uid %d and gid %d",
 874                         path, flags, (int) mode, (int) uid, (int) gid);
 875         strncpy(data.u.open.path, path, PATH_MAX - 1);
 876         data.u.open.path[PATH_MAX - 1] = '\0';
 877         data.u.open.flags = flags;
 878         data.u.open.mode = mode;
 879         run_as(RUN_AS_OPEN, &data, &ret, uid, gid);
 880         errno = ret._errno;
 881         ret.u.open.ret = ret.fd;
 882         return ret.u.open.ret;
 883 }
 884
 885 LTTNG_HIDDEN
 886 int run_as_unlink(const char *path, uid_t uid, gid_t gid)
 887 {
 888         struct run_as_data data;
 889         struct run_as_ret ret;
 890
 891         memset(&data, 0, sizeof(data));
 892         memset(&ret, 0, sizeof(ret));
 893
 894         DBG3("unlink() %s with for uid %d and gid %d",
 895                         path, (int) uid, (int) gid);
 896         strncpy(data.u.unlink.path, path, PATH_MAX - 1);
 897         data.u.unlink.path[PATH_MAX - 1] = '\0';
 898         run_as(RUN_AS_UNLINK, &data, &ret, uid, gid);
 899         errno = ret._errno;
 900         return ret.u.unlink.ret;
 901 }
 902
 903 LTTNG_HIDDEN
 904 int run_as_rmdir_recursive(const char *path, uid_t uid, gid_t gid)
 905 {
 906         struct run_as_data data;
 907         struct run_as_ret ret;
 908
 909         memset(&data, 0, sizeof(data));
 910         memset(&ret, 0, sizeof(ret));
 911
 912         DBG3("rmdir_recursive() %s with for uid %d and gid %d",
 913                         path, (int) uid, (int) gid);
 914         strncpy(data.u.rmdir_recursive.path, path, PATH_MAX - 1);
 915         data.u.rmdir_recursive.path[PATH_MAX - 1] = '\0';
 916         run_as(RUN_AS_RMDIR_RECURSIVE, &data, &ret, uid, gid);
 917         errno = ret._errno;
 918         return ret.u.rmdir_recursive.ret;
 919 }
 920
 921 LTTNG_HIDDEN
 922 int run_as_extract_elf_symbol_offset(int fd, const char* function,
 923                 uid_t uid, gid_t gid, uint64_t *offset)
 924 {
 925         struct run_as_data data;
 926         struct run_as_ret ret;
 927
 928         memset(&data, 0, sizeof(data));
 929         memset(&ret, 0, sizeof(ret));
 930
 931         DBG3("extract_elf_symbol_offset() on fd=%d and function=%s "
 932                 "with for uid %d and gid %d", fd, function, (int) uid, (int) gid);
 933
 934         data.fd = fd;
 935
 936         strncpy(data.u.extract_elf_symbol_offset.function, function, LTTNG_SYMBOL_NAME_LEN - 1);
 937
 938         data.u.extract_elf_symbol_offset.function[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
 939
 940         run_as(RUN_AS_EXTRACT_ELF_SYMBOL_OFFSET, &data, &ret, uid, gid);
 941
 942         errno = ret._errno;
 943
 944         if (ret._error) {
 945                 return -1;
 946         }
 947
 948         *offset = ret.u.extract_elf_symbol_offset.offset;
 949         return 0;
 950 }
 951
 952 LTTNG_HIDDEN
 953 int run_as_extract_sdt_probe_offsets(int fd, const char* provider_name,
 954                 const char* probe_name, uid_t uid, gid_t gid,
 955                 uint64_t **offsets, uint32_t *num_offset)
 956 {
 957         struct run_as_data data;
 958         struct run_as_ret ret;
 959
 960         memset(&data, 0, sizeof(data));
 961         memset(&ret, 0, sizeof(ret));
 962
 963         DBG3("extract_sdt_probe_offsets() on fd=%d, probe_name=%s and "
 964                 "provider_name=%s with for uid %d and gid %d", fd, probe_name,
 965                 provider_name, (int) uid, (int) gid);
 966
 967         data.fd = fd;
 968
 969         strncpy(data.u.extract_sdt_probe_offsets.probe_name, probe_name, LTTNG_SYMBOL_NAME_LEN - 1);
 970         strncpy(data.u.extract_sdt_probe_offsets.provider_name, provider_name, LTTNG_SYMBOL_NAME_LEN - 1);
 971
 972         data.u.extract_sdt_probe_offsets.probe_name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
 973         data.u.extract_sdt_probe_offsets.provider_name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
 974
 975         run_as(RUN_AS_EXTRACT_SDT_PROBE_OFFSETS, &data, &ret, uid, gid);
 976
 977         errno = ret._errno;
 978
 979         if (ret._error) {
 980                 return -1;
 981         }
 982
 983         *num_offset = ret.u.extract_sdt_probe_offsets.num_offset;
 984
 985         *offsets = zmalloc(*num_offset * sizeof(uint64_t));
 986         if (!*offsets) {
 987                 return -ENOMEM;
 988         }
 989
 990         memcpy(*offsets, ret.u.extract_sdt_probe_offsets.offsets, *num_offset * sizeof(uint64_t));
 991         return 0;
 992 }
 993
 994 static
 995 int reset_sighandler(void)
 996 {
 997         int sig;
 998
 999         DBG("Resetting run_as worker signal handlers to default");
1000         for (sig = 1; sig <= 31; sig++) {
1001                 (void) signal(sig, SIG_DFL);
1002         }
1003         return 0;
1004 }
1005
1006 static
1007 void worker_sighandler(int sig)
1008 {
1009         const char *signame;
1010
1011         /*
1012          * The worker will inherit its parent's signals since they are part of
1013          * the same process group. However, in the case of SIGINT and SIGTERM,
1014          * we want to give the worker a chance to teardown gracefully when its
1015          * parent closes the command socket.
1016          */
1017         switch (sig) {
1018         case SIGINT:
1019                 signame = "SIGINT";
1020                 break;
1021         case SIGTERM:
1022                 signame = "SIGTERM";
1023                 break;
1024         default:
1025                 signame = NULL;
1026         }
1027
1028         if (signame) {
1029                 DBG("run_as worker received signal %s", signame);
1030         } else {
1031                 DBG("run_as_worker received signal %d", sig);
1032         }
1033 }
1034
1035 static
1036 int set_worker_sighandlers(void)
1037 {
1038         int ret = 0;
1039         sigset_t sigset;
1040         struct sigaction sa;
1041
1042         if ((ret = sigemptyset(&sigset)) < 0) {
1043                 PERROR("sigemptyset");
1044                 goto end;
1045         }
1046
1047         sa.sa_handler = worker_sighandler;
1048         sa.sa_mask = sigset;
1049         sa.sa_flags = 0;
1050         if ((ret = sigaction(SIGINT, &sa, NULL)) < 0) {
1051                 PERROR("sigaction SIGINT");
1052                 goto end;
1053         }
1054
1055         if ((ret = sigaction(SIGTERM, &sa, NULL)) < 0) {
1056                 PERROR("sigaction SIGTERM");
1057                 goto end;
1058         }
1059
1060         DBG("run_as signal handler set for SIGTERM and SIGINT");
1061 end:
1062         return ret;
1063 }
1064
1065 LTTNG_HIDDEN
1066 int run_as_create_worker(char *procname)
1067 {
1068         pid_t pid;
1069         int i, ret = 0;
1070         ssize_t readlen;
1071         struct run_as_ret recvret;
1072         struct run_as_worker *worker;
1073
1074         pthread_mutex_lock(&worker_lock);
1075         assert(!global_worker);
1076         if (!use_clone()) {
1077                 /*
1078                  * Don't initialize a worker, all run_as tasks will be performed
1079                  * in the current process.
1080                  */
1081                 ret = 0;
1082                 goto end;
1083         }
1084         worker = zmalloc(sizeof(*worker));
1085         if (!worker) {
1086                 ret = -ENOMEM;
1087                 goto end;
1088         }
1089         worker->procname = procname;
1090         /* Create unix socket. */
1091         if (lttcomm_create_anon_unix_socketpair(worker->sockpair) < 0) {
1092                 ret = -1;
1093                 goto error_sock;
1094         }
1095
1096         /* Fork worker. */
1097         pid = fork();
1098         if (pid < 0) {
1099                 PERROR("fork");
1100                 ret = -1;
1101                 goto error_fork;
1102         } else if (pid == 0) {
1103                 /* Child */
1104
1105                 reset_sighandler();
1106
1107                 set_worker_sighandlers();
1108
1109                 /* The child has no use for this lock. */
1110                 pthread_mutex_unlock(&worker_lock);
1111                 /* Just close, no shutdown. */
1112                 if (close(worker->sockpair[0])) {
1113                         PERROR("close");
1114                         exit(EXIT_FAILURE);
1115                 }
1116
1117                 /*
1118                  * Close all FDs aside from STDIN, STDOUT, STDERR and sockpair[1]
1119                  * Sockpair[1] is used as a control channel with the master
1120                  */
1121                 for (i = 3; i < sysconf(_SC_OPEN_MAX); i++) {
1122                         if (i != worker->sockpair[1]) {
1123                                 (void) close(i);
1124                         }
1125                 }
1126
1127                 worker->sockpair[0] = -1;
1128                 ret = run_as_worker(worker);
1129                 if (lttcomm_close_unix_sock(worker->sockpair[1])) {
1130                         PERROR("close");
1131                         ret = -1;
1132                 }
1133                 worker->sockpair[1] = -1;
1134                 LOG(ret ? PRINT_ERR : PRINT_DBG, "run_as worker exiting (ret = %d)", ret);
1135                 exit(ret ? EXIT_FAILURE : EXIT_SUCCESS);
1136         } else {
1137                 /* Parent */
1138
1139                 /* Just close, no shutdown. */
1140                 if (close(worker->sockpair[1])) {
1141                         PERROR("close");
1142                         ret = -1;
1143                         goto error_fork;
1144                 }
1145                 worker->sockpair[1] = -1;
1146                 worker->pid = pid;
1147                 /* Wait for worker to become ready. */
1148                 readlen = lttcomm_recv_unix_sock(worker->sockpair[0],
1149                                 &recvret, sizeof(recvret));
1150                 if (readlen < sizeof(recvret)) {
1151                         ERR("readlen: %zd", readlen);
1152                         PERROR("Error reading response from run_as at creation");
1153                         ret = -1;
1154                         goto error_fork;
1155                 }
1156                 global_worker = worker;
1157         }
1158 end:
1159         pthread_mutex_unlock(&worker_lock);
1160         return ret;
1161
1162         /* Error handling. */
1163 error_fork:
1164         for (i = 0; i < 2; i++) {
1165                 if (worker->sockpair[i] < 0) {
1166                         continue;
1167                 }
1168                 if (lttcomm_close_unix_sock(worker->sockpair[i])) {
1169                         PERROR("close");
1170                 }
1171                 worker->sockpair[i] = -1;
1172         }
1173 error_sock:
1174         free(worker);
1175         pthread_mutex_unlock(&worker_lock);
1176         return ret;
1177 }
1178
1179 LTTNG_HIDDEN
1180 void run_as_destroy_worker(void)
1181 {
1182         struct run_as_worker *worker = global_worker;
1183
1184         DBG("Destroying run_as worker");
1185         pthread_mutex_lock(&worker_lock);
1186         if (!worker) {
1187                 goto end;
1188         }
1189         /* Close unix socket */
1190         DBG("Closing run_as worker socket");
1191         if (lttcomm_close_unix_sock(worker->sockpair[0])) {
1192                 PERROR("close");
1193         }
1194         worker->sockpair[0] = -1;
1195         /* Wait for worker. */
1196         for (;;) {
1197                 int status;
1198                 pid_t wait_ret;
1199
1200                 wait_ret = waitpid(worker->pid, &status, 0);
1201                 if (wait_ret < 0) {
1202                         if (errno == EINTR) {
1203                                 continue;
1204                         }
1205                         PERROR("waitpid");
1206                         break;
1207                 }
1208
1209                 if (WIFEXITED(status)) {
1210                         LOG(WEXITSTATUS(status) == 0 ? PRINT_DBG : PRINT_ERR,
1211                                         DEFAULT_RUN_AS_WORKER_NAME " terminated with status code %d",
1212                                         WEXITSTATUS(status));
1213                         break;
1214                 } else if (WIFSIGNALED(status)) {
1215                         ERR(DEFAULT_RUN_AS_WORKER_NAME " was killed by signal %d",
1216                                         WTERMSIG(status));
1217                         break;
1218                 }
1219         }
1220         free(worker);
1221         global_worker = NULL;
1222 end:
1223         pthread_mutex_unlock(&worker_lock);
1224 }