liblttd/liblttdutils.c

   1 /* liblttdutils
   2  *
   3  * Linux Trace Toolkit utility library
   4  *
   5  * This is a simple daemon implementation that reads a few relay+debugfs
   6  * channels and save them in a trace.
   7  *
   8  * CPU hot-plugging is supported using inotify.
   9  *
  10  * Copyright 2005 -
  11  *      Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>
  12  * Copyright 2010 -
  13  *      Michael Sills-Lavoie <michael.sills-lavoie@polymtl.ca>
  14  *      Oumarou Dicko <oumarou.dicko@polymtl.ca>
  15  */
  16
  17 #ifdef HAVE_CONFIG_H
  18 #include <config.h>
  19 #endif
  20
  21 #define _REENTRANT
  22 #define _GNU_SOURCE
  23
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <errno.h>
  28 #include <fcntl.h>
  29 #include <dirent.h>
  30 #include <pthread.h>
  31 #include <sys/stat.h>
  32
  33 #include "liblttdutils.h"
  34
  35 struct liblttdutils_channel_data {
  36         int trace;
  37 };
  38
  39 struct liblttdutils_data {
  40         char path_trace[PATH_MAX];
  41         char *end_path_trace;
  42         int path_trace_len;
  43         int append_mode;
  44         int verbose_mode;
  45 };
  46
  47 static __thread int thread_pipe[2];
  48
  49 #define printf_verbose(fmt, args...) \
  50   do {                               \
  51     if (callbacks_data->verbose_mode)                \
  52       printf(fmt, ##args);           \
  53   } while (0)
  54
  55 int liblttdutils_local_on_open_channel(struct liblttd_callbacks *data, struct fd_pair *pair, char *relative_channel_path)
  56 {
  57         int open_ret = 0;
  58         int ret;
  59         struct stat stat_buf;
  60         struct liblttdutils_channel_data *channel_data;
  61
  62         pair->user_data = malloc(sizeof(struct liblttdutils_channel_data));
  63         channel_data = pair->user_data;
  64
  65         struct liblttdutils_data* callbacks_data = data->user_data;
  66
  67         strncpy(callbacks_data->end_path_trace, relative_channel_path, PATH_MAX - callbacks_data->path_trace_len);
  68         printf_verbose("Creating trace file %s\n", callbacks_data->path_trace);
  69
  70         ret = stat(callbacks_data->path_trace, &stat_buf);
  71         if(ret == 0) {
  72                 if(callbacks_data->append_mode) {
  73                         printf_verbose("Appending to file %s as requested\n",
  74                                 callbacks_data->path_trace);
  75
  76                         channel_data->trace = open(callbacks_data->path_trace, O_WRONLY, S_IRWXU|S_IRWXG|S_IRWXO);
  77                         if(channel_data->trace == -1) {
  78                                 perror(callbacks_data->path_trace);
  79                                 open_ret = -1;
  80                                 goto end;
  81                         }
  82                         ret = lseek(channel_data->trace, 0, SEEK_END);
  83                         if (ret < 0) {
  84                                 perror(callbacks_data->path_trace);
  85                                 open_ret = -1;
  86                                 close(channel_data->trace);
  87                                 goto end;
  88                         }
  89                 } else {
  90                         printf("File %s exists, cannot open. Try append mode.\n", callbacks_data->path_trace);
  91                         open_ret = -1;
  92                         goto end;
  93                 }
  94         } else {
  95                 if(errno == ENOENT) {
  96                         channel_data->trace =
  97                                 open(callbacks_data->path_trace, O_WRONLY|O_CREAT|O_EXCL, S_IRWXU|S_IRWXG|S_IRWXO);
  98                         if(channel_data->trace == -1) {
  99                                 perror(callbacks_data->path_trace);
 100                                 open_ret = -1;
 101                                 goto end;
 102                         }
 103                 }
 104         }
 105
 106 end:
 107         return open_ret;
 108
 109 }
 110
 111 int liblttdutils_local_on_close_channel(struct liblttd_callbacks *data, struct fd_pair *pair)
 112 {
 113         int ret;
 114         ret = close(((struct liblttdutils_channel_data *)(pair->user_data))->trace);
 115         free(pair->user_data);
 116         return ret;
 117 }
 118
 119 int liblttdutils_local_on_new_channels_folder(struct liblttd_callbacks *data, char *relative_folder_path)
 120 {
 121         int ret;
 122         int open_ret = 0;
 123         struct liblttdutils_data* callbacks_data = data->user_data;
 124
 125         strncpy(callbacks_data->end_path_trace, relative_folder_path, PATH_MAX - callbacks_data->path_trace_len);
 126         printf_verbose("Creating trace subdirectory %s\n", callbacks_data->path_trace);
 127
 128         ret = mkdir(callbacks_data->path_trace, S_IRWXU|S_IRWXG|S_IRWXO);
 129         if(ret == -1) {
 130                 if(errno != EEXIST) {
 131                         perror(callbacks_data->path_trace);
 132                         open_ret = -1;
 133                         goto end;
 134                 }
 135         }
 136
 137 end:
 138         return open_ret;
 139 }
 140
 141 int liblttdutils_local_on_read_subbuffer(struct liblttd_callbacks *data, struct fd_pair *pair, unsigned int len)
 142 {
 143         long ret;
 144         off_t offset = 0;
 145
 146         struct liblttdutils_data* callbacks_data = data->user_data;
 147
 148         while (len > 0) {
 149                 printf_verbose("splice chan to pipe offset %lu\n",
 150                         (unsigned long)offset);
 151                 ret = splice(pair->channel, &offset, thread_pipe[1], NULL,
 152                         len, SPLICE_F_MOVE | SPLICE_F_MORE);
 153                 printf_verbose("splice chan to pipe ret %ld\n", ret);
 154                 if (ret < 0) {
 155                         perror("Error in relay splice");
 156                         goto write_error;
 157                 }
 158                 ret = splice(thread_pipe[0], NULL,
 159                         ((struct liblttdutils_channel_data *)(pair->user_data))->trace,
 160                         NULL, ret, SPLICE_F_MOVE | SPLICE_F_MORE);
 161                 printf_verbose("splice pipe to file %ld\n", ret);
 162                 if (ret < 0) {
 163                         perror("Error in file splice");
 164                         goto write_error;
 165                 }
 166                 len -= ret;
 167         }
 168
 169 write_error:
 170         return ret;
 171 }
 172
 173 int liblttdutils_local_on_new_thread(struct liblttd_callbacks *data, unsigned long thread_num)
 174 {
 175         int ret;
 176         ret = pipe(thread_pipe);
 177         if (ret < 0) {
 178                 perror("Error creating pipe");
 179                 return ret;
 180         }
 181         return 0;
 182 }
 183
 184 int liblttdutils_local_on_close_thread(struct liblttd_callbacks *data, unsigned long thread_num)
 185 {
 186         close(thread_pipe[0]);  /* close read end */
 187         close(thread_pipe[1]);  /* close write end */
 188         return 0;
 189 }
 190
 191 int liblttdutils_local_on_trace_end(struct liblttd_instance *instance)
 192 {
 193         struct liblttd_callbacks *callbacks = instance->callbacks;
 194         struct liblttdutils_data *data = callbacks->user_data;
 195
 196         free(data);
 197         free(callbacks);
 198 }
 199
 200 struct liblttd_callbacks* liblttdutils_local_new_callbacks(char* trace_name,
 201         int append_mode, int verbose_mode)
 202 {
 203         struct liblttdutils_data *data;
 204         struct liblttd_callbacks *callbacks;
 205
 206         if(!trace_name) return NULL;
 207
 208         data = malloc(sizeof(struct liblttdutils_data));
 209
 210         strncpy(data->path_trace, trace_name, PATH_MAX-1);
 211         data->path_trace_len = strlen(data->path_trace);
 212         data->end_path_trace = data->path_trace + data->path_trace_len;
 213         data->append_mode = append_mode;
 214         data->verbose_mode = verbose_mode;
 215
 216         callbacks = malloc(sizeof(struct liblttd_callbacks));
 217
 218         callbacks->on_open_channel = liblttdutils_local_on_open_channel;
 219         callbacks->on_close_channel = liblttdutils_local_on_close_channel;
 220         callbacks->on_new_channels_folder = liblttdutils_local_on_new_channels_folder;
 221         callbacks->on_read_subbuffer = liblttdutils_local_on_read_subbuffer;
 222         callbacks->on_trace_end = liblttdutils_local_on_trace_end;
 223         callbacks->on_new_thread = liblttdutils_local_on_new_thread;
 224         callbacks->on_close_thread = liblttdutils_local_on_close_thread;
 225         callbacks->user_data = data;
 226
 227         return callbacks;
 228 }
 229