#include "compat.h"
#include "../libringbuffer/tlsfixup.h"
#include "lttng-ust-baddr.h"
+#include "getenv.h"
/*
* Has lttng ust comm constructor been called ?
int ust_lock(void)
{
sigset_t sig_all_blocked, orig_mask;
- int ret;
+ int ret, oldstate;
+ ret = pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &oldstate);
+ if (ret) {
+ ERR("pthread_setcancelstate: %s", strerror(ret));
+ }
+ if (oldstate != PTHREAD_CANCEL_ENABLE) {
+ ERR("pthread_setcancelstate: unexpected oldstate");
+ }
sigfillset(&sig_all_blocked);
ret = pthread_sigmask(SIG_SETMASK, &sig_all_blocked, &orig_mask);
if (ret) {
void ust_lock_nocheck(void)
{
sigset_t sig_all_blocked, orig_mask;
- int ret;
+ int ret, oldstate;
+ ret = pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &oldstate);
+ if (ret) {
+ ERR("pthread_setcancelstate: %s", strerror(ret));
+ }
+ if (oldstate != PTHREAD_CANCEL_ENABLE) {
+ ERR("pthread_setcancelstate: unexpected oldstate");
+ }
sigfillset(&sig_all_blocked);
ret = pthread_sigmask(SIG_SETMASK, &sig_all_blocked, &orig_mask);
if (ret) {
void ust_unlock(void)
{
sigset_t sig_all_blocked, orig_mask;
- int ret;
+ int ret, oldstate;
sigfillset(&sig_all_blocked);
ret = pthread_sigmask(SIG_SETMASK, &sig_all_blocked, &orig_mask);
if (ret) {
ERR("pthread_sigmask: %s", strerror(ret));
}
+ ret = pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &oldstate);
+ if (ret) {
+ ERR("pthread_setcancelstate: %s", strerror(ret));
+ }
+ if (oldstate != PTHREAD_CANCEL_DISABLE) {
+ ERR("pthread_setcancelstate: unexpected oldstate");
+ }
}
/*
{
const char *val;
- val = (const char *) getenv("LTTNG_HOME");
+ val = (const char *) lttng_secure_getenv("LTTNG_HOME");
if (val != NULL) {
return val;
}
- return (const char *) getenv("HOME");
+ return (const char *) lttng_secure_getenv("HOME");
}
/*
/*
* Get notify_sock timeout, in ms.
- * -1: don't wait. 0: wait forever. >0: timeout, in ms.
+ * -1: wait forever. 0: don't wait. >0: timeout, in ms.
*/
static
long get_timeout(void)
}
/*
- * Return values: -1: don't wait. 0: wait forever. 1: timeout wait.
+ * Return values: -1: wait forever. 0: don't wait. 1: timeout wait.
*/
static
int get_constructor_timeout(struct timespec *constructor_timeout)
*/
ret = clock_gettime(CLOCK_REALTIME, constructor_timeout);
if (ret) {
- return -1;
+ /* Don't wait. */
+ return 0;
}
constructor_timeout->tv_sec += constructor_delay_ms / 1000UL;
constructor_timeout->tv_nsec +=
constructor_timeout->tv_sec++;
constructor_timeout->tv_nsec -= 1000000000UL;
}
+ /* Timeout wait (constructor_delay_ms). */
return 1;
}
if (ust_lock()) {
ret = -LTTNG_UST_ERR_EXITING;
- goto end;
+ goto error;
}
ops = objd_ops(lum->handle);
if (!ops) {
ret = -ENOENT;
- goto end;
+ goto error;
}
switch (lum->cmd) {
}
ret = len;
free(bytecode);
- goto end;
+ goto error;
} else {
DBG("incorrect filter data message size: %zd", len);
ret = -EINVAL;
free(bytecode);
- goto end;
+ goto error;
}
}
bytecode->bc.len = lum->u.filter.data_size;
}
ret = len;
free(node);
- goto end;
+ goto error;
} else {
DBG("Incorrect exclusion data message size: %zd", len);
ret = -EINVAL;
free(node);
- goto end;
+ goto error;
}
}
if (ops->cmd) {
goto error;
}
ret = len;
- goto end;
+ goto error;
} else {
DBG("incorrect channel data message size: %zd", len);
ret = -EINVAL;
- goto end;
+ goto error;
}
}
args.channel.chan_data = chan_data;
&args.stream.shm_fd,
&args.stream.wakeup_fd);
if (ret) {
- goto end;
+ goto error;
}
if (ops->cmd)
ret = ops->cmd(lum->handle, lum->cmd,
break;
}
-end:
lur.handle = lum->handle;
lur.cmd = lum->cmd;
lur.ret_val = ret;
long page_size;
page_size = sysconf(_SC_PAGE_SIZE);
- if (page_size > 0) {
+ if (page_size <= 0) {
+ if (!page_size) {
+ errno = EINVAL;
+ }
+ PERROR("Error in sysconf(_SC_PAGE_SIZE)");
+ } else {
ret = munmap(sock_info->wait_shm_mmap, page_size);
if (ret) {
ERR("Error unmapping wait shm");
char *wait_shm_mmap;
page_size = sysconf(_SC_PAGE_SIZE);
- if (page_size < 0) {
+ if (page_size <= 0) {
+ if (!page_size) {
+ errno = EINVAL;
+ }
+ PERROR("Error in sysconf(_SC_PAGE_SIZE)");
goto error;
}
static
void wait_for_sessiond(struct sock_info *sock_info)
{
- int ret;
-
if (ust_lock()) {
goto quit;
}
DBG("Waiting for %s apps sessiond", sock_info->name);
/* Wait for futex wakeup */
- if (uatomic_read((int32_t *) sock_info->wait_shm_mmap) == 0) {
- ret = futex_async((int32_t *) sock_info->wait_shm_mmap,
- FUTEX_WAIT, 0, NULL, NULL, 0);
- if (ret < 0) {
- if (errno == EFAULT) {
- wait_poll_fallback = 1;
- DBG(
+ if (uatomic_read((int32_t *) sock_info->wait_shm_mmap))
+ goto end_wait;
+
+ while (futex_async((int32_t *) sock_info->wait_shm_mmap,
+ FUTEX_WAIT, 0, NULL, NULL, 0)) {
+ switch (errno) {
+ case EWOULDBLOCK:
+ /* Value already changed. */
+ goto end_wait;
+ case EINTR:
+ /* Retry if interrupted by signal. */
+ break; /* Get out of switch. */
+ case EFAULT:
+ wait_poll_fallback = 1;
+ DBG(
"Linux kernels 2.6.33 to 3.0 (with the exception of stable versions) "
"do not support FUTEX_WAKE on read-only memory mappings correctly. "
"Please upgrade your kernel "
"(fix is commit 9ea71503a8ed9184d2d0b8ccc4d269d05f7940ae in Linux kernel "
"mainline). LTTng-UST will use polling mode fallback.");
- if (ust_debug())
- PERROR("futex");
- }
+ if (ust_debug())
+ PERROR("futex");
+ goto end_wait;
}
}
+end_wait:
return;
quit:
* deals with a killed or broken session daemon.
*/
sleep(5);
+ } else {
+ has_waited = 1;
}
- has_waited = 1;
prev_connect_failed = 0;
}
print_cmd(lum.cmd, lum.handle);
ret = handle_message(sock_info, sock, &lum);
if (ret) {
- ERR("Error handling message for %s socket", sock_info->name);
+ ERR("Error handling message for %s socket",
+ sock_info->name);
+ /*
+ * Close socket if protocol error is
+ * detected.
+ */
+ goto end;
}
continue;
default:
void lttng_ust_cleanup(int exiting)
{
cleanup_sock_info(&global_apps, exiting);
- if (local_apps.allowed) {
- cleanup_sock_info(&local_apps, exiting);
- }
+ cleanup_sock_info(&local_apps, exiting);
/*
* The teardown in this function all affect data structures
* accessed under the UST lock by the listener thread. This
projects / lttng-ust.git / blobdiff