X-Git-Url: https://git.liburcu.org/?a=blobdiff_plain;f=libust%2Ftracectl.c;h=463edb6b492897546a84cf3161c07c680a12eb10;hb=e005efaa25bb1c65019e147e5290733cf5e0c82d;hp=25fa4d57ecde33954791d2bca5a21a4639af9a2d;hpb=fbae86d664c12e450d3cb702b602701d37781b41;p=ust.git diff --git a/libust/tracectl.c b/libust/tracectl.c index 25fa4d5..463edb6 100644 --- a/libust/tracectl.c +++ b/libust/tracectl.c @@ -63,6 +63,16 @@ static char receive_buffer[USTCOMM_BUFFER_SIZE]; static char send_buffer[USTCOMM_BUFFER_SIZE]; static int epoll_fd; + +/* + * Listener thread data vs fork() protection mechanism. Ensures that no listener + * thread mutexes and data structures are being concurrently modified or held by + * other threads when fork() is executed. + */ +static pthread_mutex_t listener_thread_data_mutex = PTHREAD_MUTEX_INITIALIZER; + +/* Mutex protecting listen_sock. Nests inside listener_thread_data_mutex. */ +static pthread_mutex_t listen_sock_mutex = PTHREAD_MUTEX_INITIALIZER; static struct ustcomm_sock *listen_sock; extern struct chan_info_struct chan_infos[]; @@ -100,11 +110,11 @@ static void print_markers(FILE *fp) while (iter.marker) { fprintf(fp, "marker: %s/%s %d \"%s\" %p\n", - iter.marker->channel, - iter.marker->name, - (int)imv_read(iter.marker->state), - iter.marker->format, - iter.marker->location); + (*iter.marker)->channel, + (*iter.marker)->name, + (int)imv_read((*iter.marker)->state), + (*iter.marker)->format, + (*iter.marker)->location); marker_iter_next(&iter); } unlock_markers(); @@ -119,7 +129,7 @@ static void print_trace_events(FILE *fp) trace_event_iter_start(&iter); while (iter.trace_event) { - fprintf(fp, "trace_event: %s\n", iter.trace_event->name); + fprintf(fp, "trace_event: %s\n", (*iter.trace_event)->name); trace_event_iter_next(&iter); } unlock_trace_events(); @@ -533,19 +543,45 @@ unlock_traces: return retval; } +static void release_listener_mutex(void *ptr) +{ + pthread_mutex_unlock(&listener_thread_data_mutex); +} + static void listener_cleanup(void *ptr) { - ustcomm_del_named_sock(listen_sock, 0); + pthread_mutex_lock(&listen_sock_mutex); + if (listen_sock) { + ustcomm_del_named_sock(listen_sock, 0); + listen_sock = NULL; + } + pthread_mutex_unlock(&listen_sock_mutex); } -static void force_subbuf_switch() +static int force_subbuf_switch(const char *trace_name) { - struct ust_buffer *buf; + struct ust_trace *trace; + int i, j, retval = 0; - cds_list_for_each_entry(buf, &open_buffers_list, - open_buffers_list) { - ltt_force_switch(buf, FORCE_FLUSH); + ltt_lock_traces(); + trace = _ltt_trace_find(trace_name); + if (!trace) { + retval = -ENODATA; + DBG("Cannot find trace. It was likely destroyed by the user."); + goto unlock_traces; + } + + for (i = 0; i < trace->nr_channels; i++) { + for (j = 0; j < trace->channels[i].n_cpus; j++) { + ltt_force_switch(trace->channels[i].buf[j], + FORCE_FLUSH); + } } + +unlock_traces: + ltt_unlock_traces(); + + return retval; } /* Simple commands are those which need only respond with a return value. */ @@ -565,12 +601,6 @@ static int process_simple_client_cmd(int command, char *recv_buf) return setenv("UST_DAEMON_SOCKET", sock_msg->field, 1); } - case FORCE_SUBBUF_SWITCH: - /* FIXME: return codes? */ - force_subbuf_switch(); - - break; - default: return -EINVAL; } @@ -696,6 +726,15 @@ static int process_trace_cmd(int command, char *trace_name) return result; } return 0; + case FORCE_SUBBUF_SWITCH: + DBG("force switch"); + + result = force_subbuf_switch(trace_name); + if (result < 0) { + ERR("force_subbuf_switch failed"); + return result; + } + return 0; } return 0; @@ -828,7 +867,7 @@ static void process_marker_cmd(int sock, int command, { struct ustcomm_header _reply_header; struct ustcomm_header *reply_header = &_reply_header; - int result; + int result = 0; memset(reply_header, 0, sizeof(*reply_header)); @@ -937,7 +976,7 @@ static void process_client_cmd(struct ustcomm_header *recv_header, print_markers(fp); fclose(fp); - reply_header->size = size; + reply_header->size = size + 1; /* Include final \0 */ result = ustcomm_send(sock, reply_header, ptr); @@ -963,7 +1002,7 @@ static void process_client_cmd(struct ustcomm_header *recv_header, print_trace_events(fp); fclose(fp); - reply_header->size = size; + reply_header->size = size + 1; /* Include final \0 */ result = ustcomm_send(sock, reply_header, ptr); @@ -1028,6 +1067,7 @@ static void process_client_cmd(struct ustcomm_header *recv_header, case START_TRACE: case STOP_TRACE: case DESTROY_TRACE: + case FORCE_SUBBUF_SWITCH: { struct ustcomm_single_field *trace_inf = (struct ustcomm_single_field *)recv_buf; @@ -1080,6 +1120,8 @@ void *listener_main(void *p) } for (i = 0; i < nfds; i++) { + pthread_mutex_lock(&listener_thread_data_mutex); + pthread_cleanup_push(release_listener_mutex, NULL); epoll_sock = (struct ustcomm_sock *)events[i].data.ptr; if (epoll_sock == listen_sock) { addr_size = sizeof(struct sockaddr); @@ -1108,6 +1150,7 @@ void *listener_main(void *p) epoll_sock->fd); } } + pthread_cleanup_pop(1); /* release listener mutex */ } } @@ -1314,8 +1357,8 @@ static void __attribute__((constructor)) init() DBG("now iterating on markers already registered"); while (iter.marker) { - DBG("now iterating on marker %s", iter.marker->name); - auto_probe_connect(iter.marker); + DBG("now iterating on marker %s", (*iter.marker)->name); + auto_probe_connect(*iter.marker); marker_iter_next(&iter); } } @@ -1569,6 +1612,7 @@ static void ust_fork(void) { struct ust_buffer *buf, *buf_tmp; struct ustcomm_sock *sock, *sock_tmp; + struct ust_trace *trace, *trace_tmp; int result; /* FIXME: technically, the locks could have been taken before the fork */ @@ -1577,11 +1621,14 @@ static void ust_fork(void) /* Get the pid of the new process */ processpid = getpid(); - /* break lock if necessary */ - ltt_unlock_traces(); + /* + * FIXME: This could be prettier, we loop over the list twice and + * following good locking practice should lock around the loop + */ + cds_list_for_each_entry_safe(trace, trace_tmp, <t_traces.head, list) { + ltt_trace_stop(trace->trace_name); + } - ltt_trace_stop("auto"); - ltt_trace_destroy("auto", 1); /* Delete all active connections, but leave them in the epoll set */ cds_list_for_each_entry_safe(sock, sock_tmp, &ust_socks, list) { ustcomm_del_sock(sock, 1); @@ -1590,19 +1637,22 @@ static void ust_fork(void) /* Delete all blocked consumers */ cds_list_for_each_entry_safe(buf, buf_tmp, &open_buffers_list, open_buffers_list) { - result = close(buf->data_ready_fd_read); - if (result == -1) { - PERROR("close"); - } - result = close(buf->data_ready_fd_write); - if (result == -1) { - PERROR("close"); - } cds_list_del(&buf->open_buffers_list); } - /* Clean up the listener socket and epoll, keeping the scoket file */ - ustcomm_del_named_sock(listen_sock, 1); + /* + * FIXME: This could be prettier, we loop over the list twice and + * following good locking practice should lock around the loop + */ + cds_list_for_each_entry_safe(trace, trace_tmp, <t_traces.head, list) { + ltt_trace_destroy(trace->trace_name, 1); + } + + /* Clean up the listener socket and epoll, keeping the socket file */ + if (listen_sock) { + ustcomm_del_named_sock(listen_sock, 1); + listen_sock = NULL; + } close(epoll_fd); /* Re-start the launch sequence */ @@ -1657,6 +1707,17 @@ void ust_before_fork(ust_fork_info_t *fork_info) PERROR("sigprocmask"); return; } + + /* + * Take the fork lock to make sure we are not in the middle of + * something in the listener thread. + */ + pthread_mutex_lock(&listener_thread_data_mutex); + /* + * Hold listen_sock_mutex to protect from listen_sock teardown. + */ + pthread_mutex_lock(&listen_sock_mutex); + rcu_bp_before_fork(); } /* Don't call this function directly in a traced program */ @@ -1664,6 +1725,9 @@ static void ust_after_fork_common(ust_fork_info_t *fork_info) { int result; + pthread_mutex_unlock(&listen_sock_mutex); + pthread_mutex_unlock(&listener_thread_data_mutex); + /* Restore signals */ result = sigprocmask(SIG_SETMASK, &fork_info->orig_sigs, NULL); if (result == -1) { @@ -1674,16 +1738,20 @@ static void ust_after_fork_common(ust_fork_info_t *fork_info) void ust_after_fork_parent(ust_fork_info_t *fork_info) { - /* Reenable signals */ + rcu_bp_after_fork_parent(); + /* Release mutexes and reenable signals */ ust_after_fork_common(fork_info); } void ust_after_fork_child(ust_fork_info_t *fork_info) { - /* First sanitize the child */ + /* Release urcu mutexes */ + rcu_bp_after_fork_child(); + + /* Sanitize the child */ ust_fork(); - /* Then reenable interrupts */ + /* Then release mutexes and reenable signals */ ust_after_fork_common(fork_info); }