X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=ustd%2Fustd.c;h=4db550222407ba7d0773aa8b15e1b33cda777de2;hb=2a79ceebcba229c91c93272705444c61c458bb06;hp=2393ea3d45b5befa4c01cc628eeb57279b48cea4;hpb=f99c0b5cbc04e120ca0b80b472844d9b76941308;p=ust.git diff --git a/ustd/ustd.c b/ustd/ustd.c index 2393ea3..4db5502 100644 --- a/ustd/ustd.c +++ b/ustd/ustd.c @@ -33,9 +33,8 @@ #include #include "ustd.h" -#include "localerr.h" +#include "usterr.h" #include "ustcomm.h" -#include "share.h" /* return value: 0 = subbuffer is finished, it won't produce data anymore * 1 = got subbuffer successfully @@ -49,9 +48,12 @@ #define PUT_SUBBUF_OK 1 #define PUT_SUBBUF_DIED 0 #define PUT_SUBBUF_PUSHED 2 +#define PUT_SUBBUF_DONE 3 char *sock_path=NULL; char *trace_path=NULL; +int daemon_mode = 0; +char *pidfile = NULL; /* Number of active buffers and the mutex to protect it. */ int active_buffers = 0; @@ -97,6 +99,11 @@ int get_subbuffer(struct buffer_info *buf) retval = GET_SUBBUF_DONE; goto end_rep; } + else if(!strcmp(received_msg, "NOTFOUND")) { + WARN("For buffer %s, the trace was not found. This likely means it was destroyed by the user.", buf->name); + retval = GET_SUBBUF_DONE; + goto end_rep; + } else { DBG("error getting subbuffer %s", buf->name); retval = -1; @@ -129,11 +136,18 @@ int put_subbuffer(struct buffer_info *buf) retval = PUT_SUBBUF_DIED; goto end; } - if(result < 0) { + else if(result < 0) { ERR("put_subbuffer: send_message failed"); retval = -1; goto end; } + else if(result == 0) { + /* Program seems finished. However this might not be + * the last subbuffer that has to be collected. + */ + retval = PUT_SUBBUF_DIED; + goto end; + } result = sscanf(received_msg, "%as", &rep_code); if(result != 1) { @@ -146,6 +160,14 @@ int put_subbuffer(struct buffer_info *buf) DBG("subbuffer put %s", buf->name); retval = PUT_SUBBUF_OK; } + else if(!strcmp(received_msg, "NOTFOUND")) { + WARN("For buffer %s, the trace was not found. This likely means it was destroyed by the user.", buf->name); + /* However, maybe this was not the last subbuffer. So + * we return the program died. + */ + retval = PUT_SUBBUF_DIED; + goto end_rep; + } else { DBG("put_subbuffer: received error, we were pushed"); retval = PUT_SUBBUF_PUSHED; @@ -238,6 +260,9 @@ struct buffer_info *connect_buffer(pid_t pid, const char *bufname) ERR("problem in ustcomm_send_request(get_pidunique)"); return NULL; } + if(result == 0) { + goto error; + } result = sscanf(received_msg, "%lld", &buf->pidunique); if(result != 1) { @@ -255,10 +280,13 @@ struct buffer_info *connect_buffer(pid_t pid, const char *bufname) ERR("problem in ustcomm_send_request(get_shmid)"); return NULL; } + if(result == 0) { + goto error; + } result = sscanf(received_msg, "%d %d", &buf->shmid, &buf->bufstruct_shmid); if(result != 2) { - ERR("unable to parse response to get_shmid"); + ERR("unable to parse response to get_shmid (\"%s\")", received_msg); return NULL; } free(received_msg); @@ -272,6 +300,9 @@ struct buffer_info *connect_buffer(pid_t pid, const char *bufname) ERR("problem in ustcomm_send_request(g_n_subbufs)"); return NULL; } + if(result == 0) { + goto error; + } result = sscanf(received_msg, "%d", &buf->n_subbufs); if(result != 1) { @@ -283,8 +314,15 @@ struct buffer_info *connect_buffer(pid_t pid, const char *bufname) /* get subbuf size */ asprintf(&send_msg, "get_subbuf_size %s", buf->name); - ustcomm_send_request(&buf->conn, send_msg, &received_msg); + result = ustcomm_send_request(&buf->conn, send_msg, &received_msg); free(send_msg); + if(result == -1) { + ERR("problem in ustcomm_send_request(get_subbuf_size)"); + return NULL; + } + if(result == 0) { + goto error; + } result = sscanf(received_msg, "%d", &buf->subbuf_size); if(result != 1) { @@ -341,7 +379,7 @@ struct buffer_info *connect_buffer(pid_t pid, const char *bufname) } free(tmp); - asprintf(&tmp, "%s/%u_%lld/%s_0", trace_path, buf->pid, buf->pidunique, buf->name); + asprintf(&tmp, "%s/%u_%lld/%s", trace_path, buf->pid, buf->pidunique, buf->name); result = fd = open(tmp, O_WRONLY | O_CREAT | O_TRUNC | O_EXCL, 00600); if(result == -1) { PERROR("open"); @@ -356,6 +394,56 @@ struct buffer_info *connect_buffer(pid_t pid, const char *bufname) pthread_mutex_unlock(&active_buffers_mutex); return buf; + +error: + free(buf); + return NULL; +} + +int unwrite_last_subbuffer(struct buffer_info *buf) +{ + int result; + + result = ftruncate(buf->file_fd, buf->previous_offset); + if(result == -1) { + PERROR("ftruncate"); + return -1; + } + + result = lseek(buf->file_fd, buf->previous_offset, SEEK_SET); + if(result == (int)(off_t)-1) { + PERROR("lseek"); + return -1; + } + + return 0; +} + +int write_current_subbuffer(struct buffer_info *buf) +{ + int result; + + void *subbuf_mem = buf->mem + (buf->consumed_old & (buf->n_subbufs * buf->subbuf_size-1)); + + size_t cur_sb_size = subbuffer_data_size(subbuf_mem); + + off_t cur_offset = lseek(buf->file_fd, 0, SEEK_CUR); + if(cur_offset == (off_t)-1) { + PERROR("lseek"); + return -1; + } + + buf->previous_offset = cur_offset; + DBG("previous_offset: %ld", cur_offset); + + result = patient_write(buf->file_fd, subbuf_mem, cur_sb_size); + if(result == -1) { + PERROR("write"); + /* FIXME: maybe drop this trace */ + return -1; + } + + return 0; } int consumer_loop(struct buffer_info *buf) @@ -381,14 +469,10 @@ int consumer_loop(struct buffer_info *buf) } /* write data to file */ - result = patient_write(buf->file_fd, buf->mem + (buf->consumed_old & (buf->n_subbufs * buf->subbuf_size-1)), buf->subbuf_size); - if(result == -1) { - PERROR("write"); - /* FIXME: maybe drop this trace */ - } + write_current_subbuffer(buf); + /* FIXME: handle return value? */ /* put the subbuffer */ - /* FIXME: we actually should unput the buffer before consuming... */ result = put_subbuffer(buf); if(result == -1) { ERR("unknown error putting subbuffer (channel=%s)", buf->name); @@ -400,10 +484,22 @@ int consumer_loop(struct buffer_info *buf) } else if(result == PUT_SUBBUF_DIED) { WARN("application died while putting subbuffer"); - /* FIXME: probably need to skip the first subbuffer in finish_consuming_dead_subbuffer */ + /* Skip the first subbuffer. We are not sure it is trustable + * because the put_subbuffer() did not complete. + */ + unwrite_last_subbuffer(buf); finish_consuming_dead_subbuffer(buf); break; } + else if(result == PUT_SUBBUF_DONE) { + /* Done with this subbuffer */ + /* FIXME: add a case where this branch is used? Upon + * normal trace termination, at put_subbuf time, a + * special last-subbuffer code could be returned by + * the listener. + */ + break; + } else if(result == PUT_SUBBUF_OK) { } } @@ -473,7 +569,9 @@ void usage(void) fprintf(stderr, "Usage:\nustd OPTIONS\n\nOptions:\n" "\t-h\t\tDisplay this usage.\n" "\t-o DIR\t\tSpecify the directory where to output the traces.\n" - "\t-s PATH\t\tSpecify the path to use for the daemon socket.\n"); + "\t-s PATH\t\tSpecify the path to use for the daemon socket.\n" + "\t-d\t\tStart as a daemon.\n" + "\t--pidfile FILE\tWrite the PID in this file (when using -d).\n"); } int parse_args(int argc, char **argv) @@ -483,12 +581,13 @@ int parse_args(int argc, char **argv) while (1) { int option_index = 0; static struct option long_options[] = { + {"pidfile", 1, 0, 'p'}, {"help", 0, 0, 'h'}, {"version", 0, 0, 'V'}, {0, 0, 0, 0} }; - c = getopt_long(argc, argv, "hs:o:", long_options, &option_index); + c = getopt_long(argc, argv, "hs:o:d", long_options, &option_index); if (c == -1) break; @@ -509,6 +608,12 @@ int parse_args(int argc, char **argv) return -1; } break; + case 'd': + daemon_mode = 1; + break; + case 'p': + pidfile = strdup(optarg); + break; case 'h': usage(); exit(0); @@ -531,7 +636,25 @@ void sigterm_handler(int sig) terminate_req = 1; } -int main(int argc, char **argv) +static int write_pidfile(const char *file_name, pid_t pid) +{ + FILE *pidfp; + + pidfp = fopen(file_name, "w"); + if(!pidfp) { + PERROR("fopen (%s)", pidfile); + WARN("killing child process"); + return -1; + } + + fprintf(pidfp, "%d\n", pid); + + fclose(pidfp); + + return 0; +} + +int start_ustd(int fd) { struct ustcomm_ustd ustd; int result; @@ -551,10 +674,10 @@ int main(int argc, char **argv) PERROR("sigaction"); return 1; } - - result = parse_args(argc, argv); + result = sigaction(SIGINT, &sa, NULL); if(result == -1) { - exit(1); + PERROR("sigaction"); + return 1; } result = ustcomm_init_ustd(&ustd, sock_path); @@ -580,6 +703,33 @@ int main(int argc, char **argv) return 1; } + /* Write pidfile */ + if(pidfile) { + result = write_pidfile(pidfile, getpid()); + if(result == -1) { + ERR("failed to write pidfile"); + return 1; + } + } + + /* Notify parent that we are successfully started. */ + if(fd != -1) { + /* write any one character */ + result = write(fd, "!", 1); + if(result == -1) { + PERROR("write"); + return -1; + } + if(result != 1) { + ERR("Problem sending confirmation of daemon start to parent"); + return -1; + } + result = close(fd); + if(result == -1) { + PERROR("close"); + } + } + /* app loop */ for(;;) { char *recvbuf; @@ -611,6 +761,9 @@ int main(int argc, char **argv) free_bufname: free(bufname); } + else { + WARN("unknown command: %s", recvbuf); + } free(recvbuf); } @@ -627,5 +780,69 @@ int main(int argc, char **argv) } } + ustcomm_fini_ustd(&ustd); + + return 0; +} + +int start_ustd_daemon() +{ + int result; + int fd[2]; + pid_t child_pid; + + result = pipe(fd); + + result = child_pid = fork(); + if(result == -1) { + PERROR("fork"); + return -1; + } + else if(result == 0) { + return start_ustd(fd[1]); + } + else { + char buf; + + result = read(fd[0], &buf, 1); + if(result == -1) { + PERROR("read"); + return -1; + } + if(result != 1) { + ERR("did not receive valid confirmation that the daemon is started"); + return -1; + } + + result = close(fd[0]); + if(result == -1) { + PERROR("close"); + } + + DBG("The daemon is now successfully started"); + } + + /* Wait for confirmation that the server is ready. */ + + return 0; } + +int main(int argc, char **argv) +{ + int result; + + result = parse_args(argc, argv); + if(result == -1) { + exit(1); + } + + if(daemon_mode) { + result = start_ustd_daemon(); + } + else { + result = start_ustd(-1); + } + + return result; +}