Add SDT userspace probe location
[lttng-tools.git] / src / common / runas.c
CommitLineData
60b6c79c
MD
1/*
2 * Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca>
3 * Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
4 *
d14d33bf
AM
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.
60b6c79c
MD
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
d14d33bf 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
60b6c79c
MD
12 * more details.
13 *
d14d33bf
AM
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.
60b6c79c
MD
17 */
18
6c1c0768 19#define _LGPL_SOURCE
60b6c79c
MD
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>
c2b75c49 30#include <sched.h>
0452bf08 31#include <signal.h>
749b7a0c 32#include <assert.h>
e1055edb 33#include <signal.h>
60b6c79c 34
90e535ef 35#include <common/common.h>
3fd15a74 36#include <common/utils.h>
e8fa9fb0 37#include <common/compat/getenv.h>
e1055edb 38#include <common/compat/prctl.h>
2038dd6c
JG
39#include <common/unix.h>
40#include <common/defaults.h>
60b6c79c 41
0857097f
DG
42#include "runas.h"
43
7567352f
MD
44struct run_as_data;
45typedef int (*run_as_fct)(struct run_as_data *data);
c2b75c49 46
e11d277b 47struct run_as_mkdir_data {
7567352f 48 char path[PATH_MAX];
60b6c79c
MD
49 mode_t mode;
50};
51
e11d277b 52struct run_as_open_data {
7567352f 53 char path[PATH_MAX];
60b6c79c
MD
54 int flags;
55 mode_t mode;
56};
57
4628484a 58struct run_as_unlink_data {
7567352f 59 char path[PATH_MAX];
4628484a
MD
60};
61
7567352f
MD
62struct run_as_rmdir_recursive_data {
63 char path[PATH_MAX];
64};
65
66enum run_as_cmd {
67 RUN_AS_MKDIR,
68 RUN_AS_OPEN,
69 RUN_AS_UNLINK,
70 RUN_AS_RMDIR_RECURSIVE,
71 RUN_AS_MKDIR_RECURSIVE,
72};
73
74struct run_as_data {
75 enum run_as_cmd cmd;
76 union {
77 struct run_as_mkdir_data mkdir;
78 struct run_as_open_data open;
79 struct run_as_unlink_data unlink;
80 struct run_as_rmdir_recursive_data rmdir_recursive;
81 } u;
82 uid_t uid;
83 gid_t gid;
4628484a
MD
84};
85
df5b86c8
MD
86struct run_as_ret {
87 int ret;
88 int _errno;
89};
90
7567352f
MD
91struct run_as_worker {
92 pid_t pid; /* Worker PID. */
93 int sockpair[2];
94 char *procname;
95};
96
97/* Single global worker per process (for now). */
98static struct run_as_worker *global_worker;
99/* Lock protecting the worker. */
100static pthread_mutex_t worker_lock = PTHREAD_MUTEX_INITIALIZER;
101
8f0044bf
MD
102#ifdef VALGRIND
103static
104int use_clone(void)
105{
106 return 0;
107}
108#else
109static
110int use_clone(void)
111{
e8fa9fb0 112 return !lttng_secure_getenv("LTTNG_DEBUG_NOCLONE");
8f0044bf
MD
113}
114#endif
115
d77dded2
JG
116LTTNG_HIDDEN
117int _utils_mkdir_recursive_unsafe(const char *path, mode_t mode);
118
60b6c79c
MD
119/*
120 * Create recursively directory using the FULL path.
121 */
122static
7567352f 123int _mkdir_recursive(struct run_as_data *data)
60b6c79c 124{
60b6c79c 125 const char *path;
60b6c79c 126 mode_t mode;
60b6c79c 127
7567352f
MD
128 path = data->u.mkdir.path;
129 mode = data->u.mkdir.mode;
60b6c79c 130
d77dded2
JG
131 /* Safe to call as we have transitioned to the requested uid/gid. */
132 return _utils_mkdir_recursive_unsafe(path, mode);
60b6c79c
MD
133}
134
135static
7567352f 136int _mkdir(struct run_as_data *data)
60b6c79c 137{
7567352f
MD
138 return mkdir(data->u.mkdir.path, data->u.mkdir.mode);
139}
7ce36756 140
7567352f
MD
141static
142int _open(struct run_as_data *data)
143{
144 return open(data->u.open.path, data->u.open.flags, data->u.open.mode);
145}
146
147static
148int _unlink(struct run_as_data *data)
149{
150 return unlink(data->u.unlink.path);
60b6c79c
MD
151}
152
153static
7567352f 154int _rmdir_recursive(struct run_as_data *data)
60b6c79c 155{
7567352f
MD
156 return utils_recursive_rmdir(data->u.rmdir_recursive.path);
157}
df5b86c8 158
7567352f
MD
159static
160run_as_fct run_as_enum_to_fct(enum run_as_cmd cmd)
161{
162 switch (cmd) {
163 case RUN_AS_MKDIR:
164 return _mkdir;
165 case RUN_AS_OPEN:
166 return _open;
167 case RUN_AS_UNLINK:
168 return _unlink;
169 case RUN_AS_RMDIR_RECURSIVE:
170 return _rmdir_recursive;
171 case RUN_AS_MKDIR_RECURSIVE:
172 return _mkdir_recursive;
173 default:
62a7b8ed 174 ERR("Unknown command %d", (int) cmd);
7567352f
MD
175 return NULL;
176 }
60b6c79c
MD
177}
178
4628484a 179static
7567352f
MD
180int do_send_fd(struct run_as_worker *worker,
181 enum run_as_cmd cmd, int fd)
4628484a 182{
7567352f 183 ssize_t len;
4628484a 184
7567352f
MD
185 switch (cmd) {
186 case RUN_AS_OPEN:
187 break;
188 default:
189 return 0;
190 }
191 if (fd < 0) {
192 return 0;
193 }
194 len = lttcomm_send_fds_unix_sock(worker->sockpair[1], &fd, 1);
195 if (len < 0) {
196 PERROR("lttcomm_send_fds_unix_sock");
197 return -1;
198 }
199 if (close(fd) < 0) {
200 PERROR("close");
201 return -1;
202 }
203 return 0;
4628484a
MD
204}
205
206static
7567352f
MD
207int do_recv_fd(struct run_as_worker *worker,
208 enum run_as_cmd cmd, int *fd)
4628484a 209{
7567352f 210 ssize_t len;
4628484a 211
7567352f
MD
212 switch (cmd) {
213 case RUN_AS_OPEN:
214 break;
215 default:
216 return 0;
217 }
218 if (*fd < 0) {
219 return 0;
220 }
221 len = lttcomm_recv_fds_unix_sock(worker->sockpair[0], fd, 1);
da9ee832
JG
222 if (!len) {
223 return -1;
224 } else if (len < 0) {
7567352f
MD
225 PERROR("lttcomm_recv_fds_unix_sock");
226 return -1;
227 }
228 return 0;
4628484a
MD
229}
230
7567352f
MD
231/*
232 * Return < 0 on error, 0 if OK, 1 on hangup.
233 */
c2b75c49 234static
7567352f 235int handle_one_cmd(struct run_as_worker *worker)
c2b75c49 236{
7567352f
MD
237 int ret = 0;
238 struct run_as_data data;
239 ssize_t readlen, writelen;
df5b86c8 240 struct run_as_ret sendret;
7567352f
MD
241 run_as_fct cmd;
242 uid_t prev_euid;
243
244 /* Read data */
245 readlen = lttcomm_recv_unix_sock(worker->sockpair[1], &data,
246 sizeof(data));
247 if (readlen == 0) {
248 /* hang up */
249 ret = 1;
250 goto end;
251 }
252 if (readlen < sizeof(data)) {
253 PERROR("lttcomm_recv_unix_sock error");
254 ret = -1;
255 goto end;
256 }
c2b75c49 257
7567352f
MD
258 cmd = run_as_enum_to_fct(data.cmd);
259 if (!cmd) {
260 ret = -1;
261 goto end;
262 }
263
264 prev_euid = getuid();
265 if (data.gid != getegid()) {
266 ret = setegid(data.gid);
1576d582 267 if (ret < 0) {
4c462e79 268 PERROR("setegid");
6d73c4ef 269 goto write_return;
1576d582 270 }
c2b75c49 271 }
7567352f
MD
272 if (data.uid != prev_euid) {
273 ret = seteuid(data.uid);
1576d582 274 if (ret < 0) {
4c462e79 275 PERROR("seteuid");
6d73c4ef 276 goto write_return;
1576d582 277 }
c2b75c49
MD
278 }
279 /*
280 * Also set umask to 0 for mkdir executable bit.
281 */
282 umask(0);
7567352f 283 ret = (*cmd)(&data);
6d73c4ef
MD
284
285write_return:
df5b86c8
MD
286 sendret.ret = ret;
287 sendret._errno = errno;
c2b75c49 288 /* send back return value */
7567352f
MD
289 writelen = lttcomm_send_unix_sock(worker->sockpair[1], &sendret,
290 sizeof(sendret));
6cd525e8 291 if (writelen < sizeof(sendret)) {
7567352f
MD
292 PERROR("lttcomm_send_unix_sock error");
293 ret = -1;
294 goto end;
295 }
296 ret = do_send_fd(worker, data.cmd, ret);
297 if (ret) {
298 PERROR("do_send_fd error");
299 ret = -1;
300 goto end;
301 }
302 if (seteuid(prev_euid) < 0) {
303 PERROR("seteuid");
304 ret = -1;
305 goto end;
306 }
307 ret = 0;
308end:
309 return ret;
310}
311
312static
313int run_as_worker(struct run_as_worker *worker)
314{
315 int ret;
316 ssize_t writelen;
317 struct run_as_ret sendret;
318 size_t proc_orig_len;
319
320 /*
321 * Initialize worker. Set a different process cmdline.
322 */
323 proc_orig_len = strlen(worker->procname);
324 memset(worker->procname, 0, proc_orig_len);
325 strncpy(worker->procname, DEFAULT_RUN_AS_WORKER_NAME, proc_orig_len);
326
e1055edb
JG
327 ret = lttng_prctl(PR_SET_NAME,
328 (unsigned long) DEFAULT_RUN_AS_WORKER_NAME, 0, 0, 0);
329 if (ret && ret != -ENOSYS) {
b8090274
JG
330 /* Don't fail as this is not essential. */
331 PERROR("prctl PR_SET_NAME");
6cd525e8 332 }
7567352f
MD
333
334 sendret.ret = 0;
335 sendret._errno = 0;
336 writelen = lttcomm_send_unix_sock(worker->sockpair[1], &sendret,
337 sizeof(sendret));
338 if (writelen < sizeof(sendret)) {
339 PERROR("lttcomm_send_unix_sock error");
340 ret = EXIT_FAILURE;
341 goto end;
342 }
343
344 for (;;) {
345 ret = handle_one_cmd(worker);
346 if (ret < 0) {
347 ret = EXIT_FAILURE;
348 goto end;
349 } else if (ret > 0) {
350 break;
351 } else {
352 continue; /* Next command. */
353 }
354 }
355 ret = EXIT_SUCCESS;
356end:
357 return ret;
c2b75c49
MD
358}
359
60b6c79c 360static
7567352f
MD
361int run_as_cmd(struct run_as_worker *worker,
362 enum run_as_cmd cmd,
363 struct run_as_data *data,
364 uid_t uid, gid_t gid)
60b6c79c 365{
7567352f 366 ssize_t readlen, writelen;
df5b86c8 367 struct run_as_ret recvret;
60b6c79c
MD
368
369 /*
370 * If we are non-root, we can only deal with our own uid.
371 */
372 if (geteuid() != 0) {
373 if (uid != geteuid()) {
df5b86c8
MD
374 recvret.ret = -1;
375 recvret._errno = EPERM;
60b6c79c 376 ERR("Client (%d)/Server (%d) UID mismatch (and sessiond is not root)",
08797918 377 (int) uid, (int) geteuid());
df5b86c8 378 goto end;
60b6c79c 379 }
60b6c79c
MD
380 }
381
7567352f
MD
382 data->cmd = cmd;
383 data->uid = uid;
384 data->gid = gid;
385
386 writelen = lttcomm_send_unix_sock(worker->sockpair[0], data,
387 sizeof(*data));
388 if (writelen < sizeof(*data)) {
389 PERROR("Error writing message to run_as");
df5b86c8
MD
390 recvret.ret = -1;
391 recvret._errno = errno;
60b6c79c 392 goto end;
c2b75c49 393 }
7567352f 394
c2b75c49 395 /* receive return value */
7567352f
MD
396 readlen = lttcomm_recv_unix_sock(worker->sockpair[0], &recvret,
397 sizeof(recvret));
da9ee832
JG
398 if (!readlen) {
399 ERR("Run-as worker has hung-up during run_as_cmd");
400 recvret.ret = -1;
401 recvret._errno = EIO;
402 goto end;
403 } else if (readlen < sizeof(recvret)) {
7567352f 404 PERROR("Error reading response from run_as");
df5b86c8
MD
405 recvret.ret = -1;
406 recvret._errno = errno;
6cd525e8 407 }
7567352f 408 if (do_recv_fd(worker, cmd, &recvret.ret)) {
df5b86c8 409 recvret.ret = -1;
da9ee832 410 recvret._errno = EIO;
4c462e79 411 }
7567352f 412
60b6c79c 413end:
df5b86c8
MD
414 errno = recvret._errno;
415 return recvret.ret;
60b6c79c
MD
416}
417
2d85a600 418/*
7567352f 419 * This is for debugging ONLY and should not be considered secure.
2d85a600
MD
420 */
421static
474d7e84 422int run_as_noworker(enum run_as_cmd cmd, struct run_as_data *data)
2d85a600 423{
df5b86c8 424 int ret, saved_errno;
5b73926f 425 mode_t old_mask;
7567352f 426 run_as_fct fct;
5b73926f 427
7567352f
MD
428 fct = run_as_enum_to_fct(cmd);
429 if (!fct) {
430 errno = -ENOSYS;
431 ret = -1;
432 goto end;
433 }
5b73926f 434 old_mask = umask(0);
7567352f 435 ret = fct(data);
df5b86c8 436 saved_errno = errno;
5b73926f 437 umask(old_mask);
df5b86c8 438 errno = saved_errno;
7567352f 439end:
5b73926f 440 return ret;
2d85a600
MD
441}
442
443static
749b7a0c 444int run_as(enum run_as_cmd cmd, struct run_as_data *data, uid_t uid, gid_t gid)
2d85a600 445{
7567352f
MD
446 int ret;
447
749b7a0c 448 if (use_clone()) {
7567352f 449 DBG("Using run_as worker");
749b7a0c
JG
450 pthread_mutex_lock(&worker_lock);
451 assert(global_worker);
452 ret = run_as_cmd(global_worker, cmd, data, uid, gid);
453 pthread_mutex_unlock(&worker_lock);
454
2d85a600 455 } else {
7567352f 456 DBG("Using run_as without worker");
474d7e84 457 ret = run_as_noworker(cmd, data);
2d85a600 458 }
7567352f 459 return ret;
2d85a600
MD
460}
461
90e535ef 462LTTNG_HIDDEN
e11d277b 463int run_as_mkdir_recursive(const char *path, mode_t mode, uid_t uid, gid_t gid)
60b6c79c 464{
7567352f 465 struct run_as_data data;
60b6c79c 466
8446e5eb 467 memset(&data, 0, sizeof(data));
60b6c79c 468 DBG3("mkdir() recursive %s with mode %d for uid %d and gid %d",
08797918 469 path, (int) mode, (int) uid, (int) gid);
7567352f
MD
470 strncpy(data.u.mkdir.path, path, PATH_MAX - 1);
471 data.u.mkdir.path[PATH_MAX - 1] = '\0';
472 data.u.mkdir.mode = mode;
749b7a0c 473 return run_as(RUN_AS_MKDIR_RECURSIVE, &data, uid, gid);
60b6c79c
MD
474}
475
90e535ef 476LTTNG_HIDDEN
e11d277b 477int run_as_mkdir(const char *path, mode_t mode, uid_t uid, gid_t gid)
60b6c79c 478{
7567352f 479 struct run_as_data data;
60b6c79c 480
8446e5eb 481 memset(&data, 0, sizeof(data));
60b6c79c 482 DBG3("mkdir() %s with mode %d for uid %d and gid %d",
08797918 483 path, (int) mode, (int) uid, (int) gid);
7567352f
MD
484 strncpy(data.u.mkdir.path, path, PATH_MAX - 1);
485 data.u.mkdir.path[PATH_MAX - 1] = '\0';
486 data.u.mkdir.mode = mode;
749b7a0c 487 return run_as(RUN_AS_MKDIR, &data, uid, gid);
60b6c79c
MD
488}
489
90e535ef 490LTTNG_HIDDEN
e11d277b 491int run_as_open(const char *path, int flags, mode_t mode, uid_t uid, gid_t gid)
60b6c79c 492{
7567352f 493 struct run_as_data data;
c2b75c49 494
8446e5eb 495 memset(&data, 0, sizeof(data));
47fb7563 496 DBG3("open() %s with flags %X mode %d for uid %d and gid %d",
08797918 497 path, flags, (int) mode, (int) uid, (int) gid);
7567352f
MD
498 strncpy(data.u.open.path, path, PATH_MAX - 1);
499 data.u.open.path[PATH_MAX - 1] = '\0';
500 data.u.open.flags = flags;
501 data.u.open.mode = mode;
749b7a0c 502 return run_as(RUN_AS_OPEN, &data, uid, gid);
60b6c79c 503}
4628484a
MD
504
505LTTNG_HIDDEN
506int run_as_unlink(const char *path, uid_t uid, gid_t gid)
507{
7567352f 508 struct run_as_data data;
4628484a 509
8446e5eb 510 memset(&data, 0, sizeof(data));
4628484a 511 DBG3("unlink() %s with for uid %d and gid %d",
08797918 512 path, (int) uid, (int) gid);
7567352f
MD
513 strncpy(data.u.unlink.path, path, PATH_MAX - 1);
514 data.u.unlink.path[PATH_MAX - 1] = '\0';
749b7a0c 515 return run_as(RUN_AS_UNLINK, &data, uid, gid);
4628484a
MD
516}
517
518LTTNG_HIDDEN
7567352f 519int run_as_rmdir_recursive(const char *path, uid_t uid, gid_t gid)
4628484a 520{
7567352f 521 struct run_as_data data;
4628484a 522
7567352f 523 DBG3("rmdir_recursive() %s with for uid %d and gid %d",
08797918 524 path, (int) uid, (int) gid);
7567352f
MD
525 strncpy(data.u.rmdir_recursive.path, path, PATH_MAX - 1);
526 data.u.rmdir_recursive.path[PATH_MAX - 1] = '\0';
749b7a0c 527 return run_as(RUN_AS_RMDIR_RECURSIVE, &data, uid, gid);
7567352f
MD
528}
529
f8f66d38 530static
a80ed305 531int reset_sighandler(void)
f8f66d38 532{
5b5bb8c8 533 int sig;
f8f66d38 534
978d5d79 535 DBG("Resetting run_as worker signal handlers to default");
5b5bb8c8
JG
536 for (sig = 1; sig <= 31; sig++) {
537 (void) signal(sig, SIG_DFL);
f8f66d38 538 }
5b5bb8c8 539 return 0;
a80ed305
JG
540}
541
542static
543void worker_sighandler(int sig)
544{
545 const char *signame;
546
547 /*
cd89f030
JG
548 * The worker will inherit its parent's signals since they are part of
549 * the same process group. However, in the case of SIGINT and SIGTERM,
550 * we want to give the worker a chance to teardown gracefully when its
551 * parent closes the command socket.
a80ed305
JG
552 */
553 switch (sig) {
554 case SIGINT:
555 signame = "SIGINT";
556 break;
557 case SIGTERM:
558 signame = "SIGTERM";
559 break;
560 default:
22d5e48e 561 signame = NULL;
a80ed305
JG
562 }
563
22d5e48e
JG
564 if (signame) {
565 DBG("run_as worker received signal %s", signame);
566 } else {
567 DBG("run_as_worker received signal %d", sig);
568 }
a80ed305
JG
569}
570
571static
572int set_worker_sighandlers(void)
573{
574 int ret = 0;
575 sigset_t sigset;
576 struct sigaction sa;
577
578 if ((ret = sigemptyset(&sigset)) < 0) {
579 PERROR("sigemptyset");
580 goto end;
581 }
582
583 sa.sa_handler = worker_sighandler;
584 sa.sa_mask = sigset;
585 sa.sa_flags = 0;
586 if ((ret = sigaction(SIGINT, &sa, NULL)) < 0) {
587 PERROR("sigaction SIGINT");
588 goto end;
589 }
590
591 if ((ret = sigaction(SIGTERM, &sa, NULL)) < 0) {
592 PERROR("sigaction SIGTERM");
593 goto end;
594 }
595
596 DBG("run_as signal handler set for SIGTERM and SIGINT");
597end:
598 return ret;
f8f66d38
JG
599}
600
7567352f
MD
601LTTNG_HIDDEN
602int run_as_create_worker(char *procname)
603{
604 pid_t pid;
605 int i, ret = 0;
606 ssize_t readlen;
607 struct run_as_ret recvret;
608 struct run_as_worker *worker;
609
749b7a0c
JG
610 pthread_mutex_lock(&worker_lock);
611 assert(!global_worker);
7567352f 612 if (!use_clone()) {
749b7a0c
JG
613 /*
614 * Don't initialize a worker, all run_as tasks will be performed
615 * in the current process.
616 */
7567352f
MD
617 ret = 0;
618 goto end;
619 }
620 worker = zmalloc(sizeof(*worker));
621 if (!worker) {
622 ret = -ENOMEM;
623 goto end;
624 }
625 worker->procname = procname;
626 /* Create unix socket. */
627 if (lttcomm_create_anon_unix_socketpair(worker->sockpair) < 0) {
628 ret = -1;
629 goto error_sock;
630 }
631 /* Fork worker. */
632 pid = fork();
633 if (pid < 0) {
634 PERROR("fork");
635 ret = -1;
636 goto error_fork;
637 } else if (pid == 0) {
638 /* Child */
639
f8f66d38
JG
640 reset_sighandler();
641
a80ed305
JG
642 set_worker_sighandlers();
643
749b7a0c
JG
644 /* The child has no use for this lock. */
645 pthread_mutex_unlock(&worker_lock);
7567352f
MD
646 /* Just close, no shutdown. */
647 if (close(worker->sockpair[0])) {
648 PERROR("close");
649 exit(EXIT_FAILURE);
650 }
651 worker->sockpair[0] = -1;
652 ret = run_as_worker(worker);
653 if (lttcomm_close_unix_sock(worker->sockpair[1])) {
654 PERROR("close");
655 ret = -1;
656 }
657 worker->sockpair[1] = -1;
978d5d79 658 LOG(ret ? PRINT_ERR : PRINT_DBG, "run_as worker exiting (ret = %d)", ret);
7567352f
MD
659 exit(ret ? EXIT_FAILURE : EXIT_SUCCESS);
660 } else {
661 /* Parent */
662
663 /* Just close, no shutdown. */
664 if (close(worker->sockpair[1])) {
665 PERROR("close");
666 ret = -1;
667 goto error_fork;
668 }
669 worker->sockpair[1] = -1;
670 worker->pid = pid;
671 /* Wait for worker to become ready. */
672 readlen = lttcomm_recv_unix_sock(worker->sockpair[0],
673 &recvret, sizeof(recvret));
674 if (readlen < sizeof(recvret)) {
675 ERR("readlen: %zd", readlen);
676 PERROR("Error reading response from run_as at creation");
677 ret = -1;
678 goto error_fork;
679 }
680 global_worker = worker;
681 }
682end:
749b7a0c 683 pthread_mutex_unlock(&worker_lock);
7567352f
MD
684 return ret;
685
686 /* Error handling. */
687error_fork:
688 for (i = 0; i < 2; i++) {
689 if (worker->sockpair[i] < 0) {
690 continue;
691 }
692 if (lttcomm_close_unix_sock(worker->sockpair[i])) {
693 PERROR("close");
694 }
695 worker->sockpair[i] = -1;
696 }
697error_sock:
698 free(worker);
749b7a0c 699 pthread_mutex_unlock(&worker_lock);
7567352f
MD
700 return ret;
701}
702
703LTTNG_HIDDEN
704void run_as_destroy_worker(void)
705{
706 struct run_as_worker *worker = global_worker;
7567352f 707
978d5d79 708 DBG("Destroying run_as worker");
749b7a0c 709 pthread_mutex_lock(&worker_lock);
7567352f 710 if (!worker) {
749b7a0c 711 goto end;
7567352f
MD
712 }
713 /* Close unix socket */
978d5d79 714 DBG("Closing run_as worker socket");
7567352f
MD
715 if (lttcomm_close_unix_sock(worker->sockpair[0])) {
716 PERROR("close");
717 }
718 worker->sockpair[0] = -1;
719 /* Wait for worker. */
f8f66d38
JG
720 for (;;) {
721 int status;
722 pid_t wait_ret;
723
724 wait_ret = waitpid(worker->pid, &status, 0);
725 if (wait_ret < 0) {
726 if (errno == EINTR) {
727 continue;
728 }
729 PERROR("waitpid");
730 break;
731 }
732
733 if (WIFEXITED(status)) {
734 LOG(WEXITSTATUS(status) == 0 ? PRINT_DBG : PRINT_ERR,
735 DEFAULT_RUN_AS_WORKER_NAME " terminated with status code %d",
736 WEXITSTATUS(status));
737 break;
738 } else if (WIFSIGNALED(status)) {
739 ERR(DEFAULT_RUN_AS_WORKER_NAME " was killed by signal %d",
740 WTERMSIG(status));
741 break;
742 }
7567352f
MD
743 }
744 free(worker);
745 global_worker = NULL;
749b7a0c
JG
746end:
747 pthread_mutex_unlock(&worker_lock);
4628484a 748}
This page took 0.134794 seconds and 4 git commands to generate.