[ltt-dev] [PP?] Re: Liblttd patch
Mathieu Desnoyers
compudj at krystal.dyndns.org
Sat Mar 27 15:27:50 EDT 2010
* Michael Sills-Lavoie (michael.sills.lavoie at gmail.com) wrote:
> Le 2010-03-26 16:00, Mathieu Desnoyers a écrit :
>> * Mathieu Desnoyers (compudj at krystal.dyndns.org) wrote:
>>
>>> * Mathieu Desnoyers (compudj at krystal.dyndns.org) wrote:
>>>
>>>> * Michael Sills Lavoie (michael.sills-lavoie at polymtl.ca) wrote:
>>>>
>>>>> Hey,
>>>>>
>>>>> Here is the completed version of the new lttd and liblttd. We splitted the
>>>>> work in 3 parts.
>>>>>
>>>>> 1) Move the code from lttd to liblttd and adapt everything so it works
>>>>> 2) Adds the multiple instances feature
>>>>> 3) Create utility methods in the library to support local write to disk
>>>>>
>>>>> We have done the last patch to make it possible for other programs to write
>>>>> traces to disk without creating a new process (lttd). This way, we can share
>>>>> the callbacks to write to the disk with other programs.
>>>>>
>>>>> What do you think about it?
>>>>>
>>>> I am merging these patches, thanks ! (will also merge the following fix
>>>> you sent).
>>>>
>>>> I will rename the "utility" library in a subsequent patch though, as
>>>> "local" does not seem to be appropriate here. I propose to call that
>>>> "vfswrite".
>>>>
>>> finally I'll just use the "vfs" suffix.
>>>
>>> I will also change the liblttd* license to LGPLv2.1 (unless you have any
>>> objection).
>>>
>> It's now available in ltt-control 0.81. Please see commit
>>
>> 8ba26eaefd4104c2951d4a29bec7ddd2059bbeff
>>
>> for the cleanups and error handling fixes I added.
>>
>> Thanks,
>>
>> Mathieu
>>
> Thanks for the merge.
>
> I think you forgot to add the liblttdvfs.c/h files in the latest git
> commit (tag 0.81). Those files are present in the tar.gz on lttng.org.
> It causes the git version to ouput errors at compilation.
Added and pushed, thanks for the report.
Mathieu
>
> Michael
>>
>>> Thanks,
>>>
>>> Mathieu
>>>
>>>
>>>> Thanks,
>>>>
>>>> Mathieu
>>>>
>>>>
>>>>> Thanks
>>>>>
>>>>> Michael and Oumarou
>>>>>
>>>>> 2010/2/16 Mathieu Desnoyers<compudj at krystal.dyndns.org>
>>>>>
>>>>>
>>>>>> * Michael Sills Lavoie (michael.sills-lavoie at polymtl.ca) wrote:
>>>>>>
>>>>>>> Hey,
>>>>>>>
>>>>>>> This is a working implementation of the new liblttd and lttd. This is
>>>>>>>
>>>>>> only a
>>>>>>
>>>>>>> work in progress because we don't have the possibility to create multiple
>>>>>>> instances of the "daemon" yet.
>>>>>>>
>>>>>>> You can apply the patch with : git apply liblttd.patch in the ltt-control
>>>>>>> root directory.
>>>>>>>
>>>>>>> What do you think about it ?
>>>>>>>
>>>>>>
>>>>>> A few things: please take the habit of writing your comments in english
>>>>>> so everyone on the mailing list can parse them ;)
>>>>>>
>>>>>> You should probably review the kernel doc coding styles for the function
>>>>>> comments.
>>>>>>
>>>>>> Besides that, things seems to be generally on the right track.
>>>>>>
>>>>>> You should probably submit these changes in two patches:
>>>>>>
>>>>>> - first, just move the code from lttd to liblttd and adapt everything so
>>>>>> it works (more or less this patch).
>>>>>> - second, a patch that adds the multiple instances feature.
>>>>>>
>>>>>> Thanks,
>>>>>>
>>>>>> Mathieu
>>>>>>
>>>>>>
>>>>>>> Michael
>>>>>>>
>>>>>>
>>>>>>> diff --git a/Makefile.am b/Makefile.am
>>>>>>> index 8f9974d..06500fd 100644
>>>>>>> --- a/Makefile.am
>>>>>>> +++ b/Makefile.am
>>>>>>> @@ -1,2 +1,2 @@
>>>>>>> -SUBDIRS = liblttctl lttctl lttd specs
>>>>>>> +SUBDIRS = liblttctl lttctl liblttd lttd specs
>>>>>>>
>>>>>>> diff --git a/configure.in b/configure.in
>>>>>>> index d67e7d4..a992cd8 100644
>>>>>>> --- a/configure.in
>>>>>>> +++ b/configure.in
>>>>>>> @@ -76,8 +76,10 @@ DEFAULT_INCLUDES="-I\$(top_srcdir) -I\$(top_builddir)"
>>>>>>> #AC_SUBST(CPPFLAGS)
>>>>>>>
>>>>>>> lttctlincludedir="${includedir}/liblttctl"
>>>>>>> +liblttdincludedir="${includedir}/liblttd"
>>>>>>>
>>>>>>> AC_SUBST(lttctlincludedir)
>>>>>>> +AC_SUBST(liblttdincludedir)
>>>>>>> AC_SUBST(UTIL_LIBS)
>>>>>>> AC_SUBST(THREAD_LIBS)
>>>>>>> AC_SUBST(DEFAULT_INCLUDES)
>>>>>>> @@ -85,6 +87,7 @@ AC_SUBST(DEFAULT_INCLUDES)
>>>>>>> AC_CONFIG_FILES([Makefile
>>>>>>> liblttctl/Makefile
>>>>>>> lttctl/Makefile
>>>>>>> + liblttd/Makefile
>>>>>>> lttd/Makefile
>>>>>>> specs/Makefile])
>>>>>>> AC_OUTPUT
>>>>>>> diff --git a/liblttd/Makefile.am b/liblttd/Makefile.am
>>>>>>> new file mode 100644
>>>>>>> index 0000000..3c1eeda
>>>>>>> --- /dev/null
>>>>>>> +++ b/liblttd/Makefile.am
>>>>>>> @@ -0,0 +1,7 @@
>>>>>>> +
>>>>>>> +
>>>>>>> +lib_LTLIBRARIES = liblttd.la
>>>>>>> +liblttd_la_SOURCES = liblttd.c
>>>>>>> +
>>>>>>> +liblttdinclude_HEADERS = \
>>>>>>> + liblttd.h
>>>>>>> diff --git a/liblttd/liblttd.c b/liblttd/liblttd.c
>>>>>>> new file mode 100644
>>>>>>> index 0000000..941ca87
>>>>>>> --- /dev/null
>>>>>>> +++ b/liblttd/liblttd.c
>>>>>>> @@ -0,0 +1,754 @@
>>>>>>> +/* lttd
>>>>>>> + *
>>>>>>> + * Linux Trace Toolkit Daemon
>>>>>>> + *
>>>>>>> + * This is a simple daemon that reads a few relay+debugfs channels and
>>>>>>>
>>>>>> save
>>>>>>
>>>>>>> + * them in a trace.
>>>>>>> + *
>>>>>>> + * CPU hot-plugging is supported using inotify.
>>>>>>> + *
>>>>>>> + * Copyright 2005 -
>>>>>>> + * Mathieu Desnoyers<mathieu.desnoyers at polymtl.ca>
>>>>>>> + */
>>>>>>> +
>>>>>>> +#ifdef HAVE_CONFIG_H
>>>>>>> +#include<config.h>
>>>>>>> +#endif
>>>>>>> +
>>>>>>> +#include "liblttd.h"
>>>>>>> +
>>>>>>> +#define _REENTRANT
>>>>>>> +#define _GNU_SOURCE
>>>>>>> +#include<features.h>
>>>>>>> +#include<stdio.h>
>>>>>>> +#include<unistd.h>
>>>>>>> +#include<errno.h>
>>>>>>> +#include<sys/types.h>
>>>>>>> +#include<stdlib.h>
>>>>>>> +#include<dirent.h>
>>>>>>> +#include<string.h>
>>>>>>> +#include<fcntl.h>
>>>>>>> +#include<sys/stat.h>
>>>>>>> +#include<sys/poll.h>
>>>>>>> +#include<sys/mman.h>
>>>>>>> +#include<sys/syscall.h>
>>>>>>> +#include<unistd.h>
>>>>>>> +#include<asm/ioctls.h>
>>>>>>> +
>>>>>>> +#include<linux/version.h>
>>>>>>> +
>>>>>>> +/* Relayfs IOCTL */
>>>>>>> +#include<asm/ioctl.h>
>>>>>>> +#include<asm/types.h>
>>>>>>> +
>>>>>>> +/* Get the next sub buffer that can be read. */
>>>>>>> +#define RELAY_GET_SB _IOR(0xF5, 0x00,__u32)
>>>>>>> +/* Release the oldest reserved (by "get") sub buffer. */
>>>>>>> +#define RELAY_PUT_SB _IOW(0xF5, 0x01,__u32)
>>>>>>> +/* returns the number of sub buffers in the per cpu channel. */
>>>>>>> +#define RELAY_GET_N_SB _IOR(0xF5, 0x02,__u32)
>>>>>>> +/* returns the size of the current sub buffer. */
>>>>>>> +#define RELAY_GET_SB_SIZE _IOR(0xF5, 0x03, __u32)
>>>>>>> +/* returns the size of data to consume in the current sub-buffer. */
>>>>>>> +#define RELAY_GET_MAX_SB_SIZE _IOR(0xF5, 0x04, __u32)
>>>>>>> +
>>>>>>> +
>>>>>>> +#if LINUX_VERSION_CODE>= KERNEL_VERSION(2,6,14)
>>>>>>> +#include<sys/inotify.h>
>>>>>>> +
>>>>>>> +#define HAS_INOTIFY
>>>>>>> +#else
>>>>>>> +static inline int inotify_init (void)
>>>>>>> +{
>>>>>>> + return -1;
>>>>>>> +}
>>>>>>> +
>>>>>>> +static inline int inotify_add_watch (int fd, const char *name, __u32
>>>>>>>
>>>>>> mask)
>>>>>>
>>>>>>> +{
>>>>>>> + return 0;
>>>>>>> +}
>>>>>>> +
>>>>>>> +static inline int inotify_rm_watch (int fd, __u32 wd)
>>>>>>> +{
>>>>>>> + return 0;
>>>>>>> +}
>>>>>>> +#undef HAS_INOTIFY
>>>>>>> +#endif
>>>>>>> +
>>>>>>> +/* !modif! Enlever, seulement utilisé pendant l'implémentation*/
>>>>>>> +struct liblttd_callbacks *callbacks;
>>>>>>> +
>>>>>>> +struct channel_trace_fd {
>>>>>>> + struct fd_pair *pair;
>>>>>>> + int num_pairs;
>>>>>>> +};
>>>>>>> +
>>>>>>> +/* !modif! Modifier pour pas utiliser le chemin de la trace*/
>>>>>>> +struct inotify_watch {
>>>>>>> + int wd;
>>>>>>> + char path_channel[PATH_MAX];
>>>>>>> + char *base_path_channel;
>>>>>>> +};
>>>>>>> +
>>>>>>> +struct inotify_watch_array {
>>>>>>> + struct inotify_watch *elem;
>>>>>>> + int num;
>>>>>>> +};
>>>>>>> +
>>>>>>> +struct channel_trace_fd fd_pairs = { NULL, 0 };
>>>>>>> +int inotify_fd = -1;
>>>>>>> +struct inotify_watch_array inotify_watch_array = { NULL, 0 };
>>>>>>> +
>>>>>>> +/* protects fd_pairs and inotify_watch_array */
>>>>>>> +pthread_rwlock_t fd_pairs_lock = PTHREAD_RWLOCK_INITIALIZER;
>>>>>>> +
>>>>>>> +/* !modif! Mettre dans une structure s'il faut avoir plus d'une
>>>>>>>
>>>>>> instance*/
>>>>>>
>>>>>>> +static char *channel_name = NULL;
>>>>>>> +static unsigned long num_threads = 1;
>>>>>>> +volatile static int quit_program = 0; /* For signal handler */
>>>>>>> +static int dump_flight_only = 0;
>>>>>>> +static int dump_normal_only = 0;
>>>>>>> +static int verbose_mode = 0;
>>>>>>> +
>>>>>>> +#define printf_verbose(fmt, args...) \
>>>>>>> + do { \
>>>>>>> + if (verbose_mode) \
>>>>>>> + printf(fmt, ##args); \
>>>>>>> + } while (0)
>>>>>>> +
>>>>>>> +
>>>>>>> +int open_buffer_file(char *filename, char *path_channel,
>>>>>>> + char *base_path_channel, struct channel_trace_fd *fd_pairs)
>>>>>>> +{
>>>>>>> + int open_ret = 0;
>>>>>>> + int ret = 0;
>>>>>>> +
>>>>>>> + if(strncmp(filename, "flight-", sizeof("flight-")-1) != 0) {
>>>>>>> + if(dump_flight_only) {
>>>>>>> + printf_verbose("Skipping normal channel %s\n",
>>>>>>> + path_channel);
>>>>>>> + return 0;
>>>>>>> + }
>>>>>>> + } else {
>>>>>>> + if(dump_normal_only) {
>>>>>>> + printf_verbose("Skipping flight channel %s\n",
>>>>>>> + path_channel);
>>>>>>> + return 0;
>>>>>>> + }
>>>>>>> + }
>>>>>>> + printf_verbose("Opening file.\n");
>>>>>>> +
>>>>>>> + fd_pairs->pair = realloc(fd_pairs->pair,
>>>>>>> + ++fd_pairs->num_pairs * sizeof(struct fd_pair));
>>>>>>> +
>>>>>>> + /* Open the channel in read mode */
>>>>>>> + fd_pairs->pair[fd_pairs->num_pairs-1].channel =
>>>>>>> + open(path_channel, O_RDONLY | O_NONBLOCK);
>>>>>>> + if(fd_pairs->pair[fd_pairs->num_pairs-1].channel == -1) {
>>>>>>> + perror(path_channel);
>>>>>>> + fd_pairs->num_pairs--;
>>>>>>> + return 0; /* continue */
>>>>>>> + }
>>>>>>> +
>>>>>>> + /*!callback! Ajouter un callback pour l'ouverture.*/
>>>>>>> + if(callbacks->on_open_channel) ret = callbacks->on_open_channel(
>>>>>>> + callbacks,&fd_pairs->pair[fd_pairs->num_pairs-1],
>>>>>>> + base_path_channel);
>>>>>>> +
>>>>>>> + if(ret != 0) {
>>>>>>> + open_ret = -1;
>>>>>>> + close(fd_pairs->pair[fd_pairs->num_pairs-1].channel);
>>>>>>> + fd_pairs->num_pairs--;
>>>>>>> + goto end;
>>>>>>> + }
>>>>>>> +
>>>>>>> +end:
>>>>>>> + return open_ret;
>>>>>>> +}
>>>>>>> +
>>>>>>> +int open_channel_trace_pairs(char *subchannel_name,
>>>>>>> + char *base_subchannel_name,
>>>>>>> + struct channel_trace_fd *fd_pairs, int *inotify_fd,
>>>>>>> + struct inotify_watch_array *iwatch_array)
>>>>>>> +{
>>>>>>> + DIR *channel_dir = opendir(subchannel_name);
>>>>>>> + struct dirent *entry;
>>>>>>> + struct stat stat_buf;
>>>>>>> + int ret;
>>>>>>> + char path_channel[PATH_MAX];
>>>>>>> + int path_channel_len;
>>>>>>> + char *path_channel_ptr;
>>>>>>> + char *base_subchannel_ptr;
>>>>>>> +
>>>>>>> + int open_ret = 0;
>>>>>>> +
>>>>>>> + if(channel_dir == NULL) {
>>>>>>> + perror(subchannel_name);
>>>>>>> + open_ret = ENOENT;
>>>>>>> + goto end;
>>>>>>> + }
>>>>>>> +
>>>>>>> + printf_verbose("Calling on new channels folder");
>>>>>>> + if(callbacks->on_new_channels_folder) ret = callbacks->
>>>>>>> + on_new_channels_folder(callbacks,
>>>>>>> + base_subchannel_name);
>>>>>>> + if(ret == -1) {
>>>>>>> + open_ret = -1;
>>>>>>> + goto end;
>>>>>>> + }
>>>>>>> +
>>>>>>> + strncpy(path_channel, subchannel_name, PATH_MAX-1);
>>>>>>> + path_channel_len = strlen(path_channel);
>>>>>>> + path_channel[path_channel_len] = '/';
>>>>>>> + path_channel_len++;
>>>>>>> + path_channel_ptr = path_channel + path_channel_len;
>>>>>>> + base_subchannel_ptr = path_channel +
>>>>>>> + (base_subchannel_name - subchannel_name);
>>>>>>> +
>>>>>>> +#ifdef HAS_INOTIFY
>>>>>>> + iwatch_array->elem = realloc(iwatch_array->elem,
>>>>>>> + ++iwatch_array->num * sizeof(struct inotify_watch));
>>>>>>> +
>>>>>>> + printf_verbose("Adding inotify for channel %s\n", path_channel);
>>>>>>> + iwatch_array->elem[iwatch_array->num-1].wd =
>>>>>>>
>>>>>> inotify_add_watch(*inotify_fd, path_channel, IN_CREATE);
>>>>>>
>>>>>>> + strcpy(iwatch_array->elem[iwatch_array->num-1].path_channel,
>>>>>>>
>>>>>> path_channel);
>>>>>>
>>>>>>> + iwatch_array->elem[iwatch_array->num-1].base_path_channel =
>>>>>>> + iwatch_array->elem[iwatch_array->num-1].path_channel +
>>>>>>> + (base_subchannel_name - subchannel_name);
>>>>>>> + printf_verbose("Added inotify for channel %s, wd %u\n",
>>>>>>> + iwatch_array->elem[iwatch_array->num-1].path_channel,
>>>>>>> + iwatch_array->elem[iwatch_array->num-1].wd);
>>>>>>> +#endif
>>>>>>> +
>>>>>>> + while((entry = readdir(channel_dir)) != NULL) {
>>>>>>> +
>>>>>>> + if(entry->d_name[0] == '.') continue;
>>>>>>> +
>>>>>>> + strncpy(path_channel_ptr, entry->d_name, PATH_MAX -
>>>>>>>
>>>>>> path_channel_len);
>>>>>>
>>>>>>> +
>>>>>>> + ret = stat(path_channel,&stat_buf);
>>>>>>> + if(ret == -1) {
>>>>>>> + perror(path_channel);
>>>>>>> + continue;
>>>>>>> + }
>>>>>>> +
>>>>>>> + printf_verbose("Channel file : %s\n", path_channel);
>>>>>>> +
>>>>>>> + if(S_ISDIR(stat_buf.st_mode)) {
>>>>>>> +
>>>>>>> + printf_verbose("Entering channel
>>>>>>>
>>>>>> subdirectory...\n");
>>>>>>
>>>>>>> + ret = open_channel_trace_pairs(path_channel,
>>>>>>>
>>>>>> base_subchannel_ptr, fd_pairs,
>>>>>>
>>>>>>> + inotify_fd, iwatch_array);
>>>>>>> + if(ret< 0) continue;
>>>>>>> + } else if(S_ISREG(stat_buf.st_mode)) {
>>>>>>> + open_ret = open_buffer_file(entry->d_name,
>>>>>>>
>>>>>> path_channel, base_subchannel_ptr,
>>>>>>
>>>>>>> + fd_pairs);
>>>>>>> + if(open_ret)
>>>>>>> + goto end;
>>>>>>> + }
>>>>>>> + }
>>>>>>> +
>>>>>>> +end:
>>>>>>> + closedir(channel_dir);
>>>>>>> +
>>>>>>> + return open_ret;
>>>>>>> +}
>>>>>>> +
>>>>>>> +
>>>>>>> +int read_subbuffer(struct fd_pair *pair)
>>>>>>> +{
>>>>>>> + unsigned int consumed_old, len;
>>>>>>> + int err;
>>>>>>> + long ret;
>>>>>>> + off_t offset;
>>>>>>> +
>>>>>>> +
>>>>>>> + err = ioctl(pair->channel, RELAY_GET_SB,&consumed_old);
>>>>>>> + printf_verbose("cookie : %u\n", consumed_old);
>>>>>>> + if(err != 0) {
>>>>>>> + ret = errno;
>>>>>>> + perror("Reserving sub buffer failed (everything is normal,
>>>>>>>
>>>>>> it is due to concurrency)");
>>>>>>
>>>>>>> + goto get_error;
>>>>>>> + }
>>>>>>> +
>>>>>>> + err = ioctl(pair->channel, RELAY_GET_SB_SIZE,&len);
>>>>>>> + if(err != 0) {
>>>>>>> + ret = errno;
>>>>>>> + perror("Getting sub-buffer len failed.");
>>>>>>> + goto get_error;
>>>>>>> + }
>>>>>>> +
>>>>>>> + if(callbacks->on_read_subbuffer) ret =
>>>>>>>
>>>>>> callbacks->on_read_subbuffer(
>>>>>>
>>>>>>> + callbacks, pair, len);
>>>>>>> +
>>>>>>> +write_error:
>>>>>>> + ret = 0;
>>>>>>> + err = ioctl(pair->channel, RELAY_PUT_SB,&consumed_old);
>>>>>>> + if(err != 0) {
>>>>>>> + ret = errno;
>>>>>>> + if(errno == EFAULT) {
>>>>>>> + perror("Error in unreserving sub buffer\n");
>>>>>>> + } else if(errno == EIO) {
>>>>>>> + /* Should never happen with newer LTTng versions */
>>>>>>> + perror("Reader has been pushed by the writer, last
>>>>>>>
>>>>>> sub-buffer corrupted.");
>>>>>>
>>>>>>> + }
>>>>>>> + goto get_error;
>>>>>>> + }
>>>>>>> +
>>>>>>> +get_error:
>>>>>>> + return ret;
>>>>>>> +}
>>>>>>> +
>>>>>>> +
>>>>>>> +int map_channels(struct channel_trace_fd *fd_pairs,
>>>>>>> + int idx_begin, int idx_end)
>>>>>>> +{
>>>>>>> + int i,j;
>>>>>>> + int ret=0;
>>>>>>> +
>>>>>>> + if(fd_pairs->num_pairs<= 0) {
>>>>>>> + printf("No channel to read\n");
>>>>>>> + goto end;
>>>>>>> + }
>>>>>>> +
>>>>>>> + /* Get the subbuf sizes and number */
>>>>>>> +
>>>>>>> + for(i=idx_begin;i<idx_end;i++) {
>>>>>>> + struct fd_pair *pair =&fd_pairs->pair[i];
>>>>>>> +
>>>>>>> + ret = ioctl(pair->channel, RELAY_GET_N_SB,&pair->n_sb);
>>>>>>> + if(ret != 0) {
>>>>>>> + perror("Error in getting the number of
>>>>>>>
>>>>>> sub-buffers");
>>>>>>
>>>>>>> + goto end;
>>>>>>> + }
>>>>>>> + ret = ioctl(pair->channel, RELAY_GET_MAX_SB_SIZE,
>>>>>>> +&pair->max_sb_size);
>>>>>>> + if(ret != 0) {
>>>>>>> + perror("Error in getting the max sub-buffer size");
>>>>>>> + goto end;
>>>>>>> + }
>>>>>>> + ret = pthread_mutex_init(&pair->mutex, NULL); /* Fast
>>>>>>>
>>>>>> mutex */
>>>>>>
>>>>>>> + if(ret != 0) {
>>>>>>> + perror("Error in mutex init");
>>>>>>> + goto end;
>>>>>>> + }
>>>>>>> + }
>>>>>>> +
>>>>>>> +end:
>>>>>>> + return ret;
>>>>>>> +}
>>>>>>> +
>>>>>>> +int unmap_channels(struct channel_trace_fd *fd_pairs)
>>>>>>> +{
>>>>>>> + int j;
>>>>>>> + int ret=0;
>>>>>>> +
>>>>>>> + /* Munmap each FD */
>>>>>>> + for(j=0;j<fd_pairs->num_pairs;j++) {
>>>>>>> + struct fd_pair *pair =&fd_pairs->pair[j];
>>>>>>> + int err_ret;
>>>>>>> +
>>>>>>> + err_ret = pthread_mutex_destroy(&pair->mutex);
>>>>>>> + if(err_ret != 0) {
>>>>>>> + perror("Error in mutex destroy");
>>>>>>> + }
>>>>>>> + ret |= err_ret;
>>>>>>> + }
>>>>>>> +
>>>>>>> + return ret;
>>>>>>> +}
>>>>>>> +
>>>>>>> +#ifdef HAS_INOTIFY
>>>>>>> +/* Inotify event arrived.
>>>>>>> + *
>>>>>>> + * Only support add file for now.
>>>>>>> + */
>>>>>>> +
>>>>>>> +int read_inotify(int inotify_fd,
>>>>>>> + struct channel_trace_fd *fd_pairs,
>>>>>>> + struct inotify_watch_array *iwatch_array)
>>>>>>> +{
>>>>>>> + char buf[sizeof(struct inotify_event) + PATH_MAX];
>>>>>>> + char path_channel[PATH_MAX];
>>>>>>> + ssize_t len;
>>>>>>> + struct inotify_event *ievent;
>>>>>>> + size_t offset;
>>>>>>> + unsigned int i;
>>>>>>> + int ret;
>>>>>>> + int old_num;
>>>>>>> +
>>>>>>> + offset = 0;
>>>>>>> + len = read(inotify_fd, buf, sizeof(struct inotify_event) +
>>>>>>>
>>>>>> PATH_MAX);
>>>>>>
>>>>>>> + if(len< 0) {
>>>>>>> +
>>>>>>> + if(errno == EAGAIN)
>>>>>>> + return 0; /* another thread got the data before us
>>>>>>>
>>>>>> */
>>>>>>
>>>>>>> +
>>>>>>> + printf("Error in read from inotify FD %s.\n",
>>>>>>>
>>>>>> strerror(len));
>>>>>>
>>>>>>> + return -1;
>>>>>>> + }
>>>>>>> + while(offset< len) {
>>>>>>> + ievent = (struct inotify_event *)&(buf[offset]);
>>>>>>> + for(i=0; i<iwatch_array->num; i++) {
>>>>>>> + if(iwatch_array->elem[i].wd == ievent->wd&&
>>>>>>> + ievent->mask == IN_CREATE) {
>>>>>>> + printf_verbose(
>>>>>>> + "inotify wd %u event mask : %u for
>>>>>>>
>>>>>> %s%s\n",
>>>>>>
>>>>>>> + ievent->wd, ievent->mask,
>>>>>>> + iwatch_array->elem[i].path_channel,
>>>>>>> + ievent->name);
>>>>>>> + old_num = fd_pairs->num_pairs;
>>>>>>> + strcpy(path_channel,
>>>>>>>
>>>>>> iwatch_array->elem[i].path_channel);
>>>>>>
>>>>>>> + strcat(path_channel, ievent->name);
>>>>>>> + if(ret = open_buffer_file(ievent->name,
>>>>>>>
>>>>>> path_channel,
>>>>>>
>>>>>>> + path_channel +
>>>>>>>
>>>>>> (iwatch_array->elem[i].base_path_channel -
>>>>>>
>>>>>>> +
>>>>>>>
>>>>>> iwatch_array->elem[i].path_channel), fd_pairs)) {
>>>>>>
>>>>>>> + printf("Error opening buffer
>>>>>>>
>>>>>> file\n");
>>>>>>
>>>>>>> + return -1;
>>>>>>> + }
>>>>>>> + if(ret = map_channels(fd_pairs, old_num,
>>>>>>>
>>>>>> fd_pairs->num_pairs)) {
>>>>>>
>>>>>>> + printf("Error mapping channel\n");
>>>>>>> + return -1;
>>>>>>> + }
>>>>>>> +
>>>>>>> + }
>>>>>>> + }
>>>>>>> + offset += sizeof(*ievent) + ievent->len;
>>>>>>> + }
>>>>>>> +}
>>>>>>> +#endif //HAS_INOTIFY
>>>>>>> +
>>>>>>> +/* read_channels
>>>>>>> + *
>>>>>>> + * Thread worker.
>>>>>>> + *
>>>>>>> + * Read the debugfs channels and write them in the paired tracefiles.
>>>>>>> + *
>>>>>>> + * @fd_pairs : paired channels and trace files.
>>>>>>> + *
>>>>>>> + * returns 0 on success, -1 on error.
>>>>>>> + *
>>>>>>> + * Note that the high priority polled channels are consumed first. We
>>>>>>>
>>>>>> then poll
>>>>>>
>>>>>>> + * again to see if these channels are still in priority. Only when no
>>>>>>> + * high priority channel is left, we start reading low priority
>>>>>>>
>>>>>> channels.
>>>>>>
>>>>>>> + *
>>>>>>> + * Note that a channel is considered high priority when the buffer is
>>>>>>>
>>>>>> almost
>>>>>>
>>>>>>> + * full.
>>>>>>> + */
>>>>>>> +
>>>>>>> +int read_channels(unsigned long thread_num, struct channel_trace_fd
>>>>>>>
>>>>>> *fd_pairs,
>>>>>>
>>>>>>> + int inotify_fd, struct inotify_watch_array *iwatch_array)
>>>>>>> +{
>>>>>>> + struct pollfd *pollfd = NULL;
>>>>>>> + int num_pollfd;
>>>>>>> + int i,j;
>>>>>>> + int num_rdy, num_hup;
>>>>>>> + int high_prio;
>>>>>>> + int ret = 0;
>>>>>>> + int inotify_fds;
>>>>>>> + unsigned int old_num;
>>>>>>> +
>>>>>>> +#ifdef HAS_INOTIFY
>>>>>>> + inotify_fds = 1;
>>>>>>> +#else
>>>>>>> + inotify_fds = 0;
>>>>>>> +#endif
>>>>>>> +
>>>>>>> + pthread_rwlock_rdlock(&fd_pairs_lock);
>>>>>>> +
>>>>>>> + /* Start polling the FD. Keep one fd for inotify */
>>>>>>> + pollfd = malloc((inotify_fds + fd_pairs->num_pairs) * sizeof(struct
>>>>>>>
>>>>>> pollfd));
>>>>>>
>>>>>>> +
>>>>>>> +#ifdef HAS_INOTIFY
>>>>>>> + pollfd[0].fd = inotify_fd;
>>>>>>> + pollfd[0].events = POLLIN|POLLPRI;
>>>>>>> +#endif
>>>>>>> +
>>>>>>> + for(i=0;i<fd_pairs->num_pairs;i++) {
>>>>>>> + pollfd[inotify_fds+i].fd = fd_pairs->pair[i].channel;
>>>>>>> + pollfd[inotify_fds+i].events = POLLIN|POLLPRI;
>>>>>>> + }
>>>>>>> + num_pollfd = inotify_fds + fd_pairs->num_pairs;
>>>>>>> +
>>>>>>> +
>>>>>>> + pthread_rwlock_unlock(&fd_pairs_lock);
>>>>>>> +
>>>>>>> + while(1) {
>>>>>>> + high_prio = 0;
>>>>>>> + num_hup = 0;
>>>>>>> +#ifdef DEBUG
>>>>>>> + printf("Press a key for next poll...\n");
>>>>>>> + char buf[1];
>>>>>>> + read(STDIN_FILENO,&buf, 1);
>>>>>>> + printf("Next poll (polling %d fd) :\n", num_pollfd);
>>>>>>> +#endif //DEBUG
>>>>>>> +
>>>>>>> + /* Have we received a signal ? */
>>>>>>> + if(quit_program) break;
>>>>>>> +
>>>>>>> + num_rdy = poll(pollfd, num_pollfd, -1);
>>>>>>> +
>>>>>>> + if(num_rdy == -1) {
>>>>>>> + perror("Poll error");
>>>>>>> + goto free_fd;
>>>>>>> + }
>>>>>>> +
>>>>>>> + printf_verbose("Data received\n");
>>>>>>> +#ifdef HAS_INOTIFY
>>>>>>> + switch(pollfd[0].revents) {
>>>>>>> + case POLLERR:
>>>>>>> + printf_verbose(
>>>>>>> + "Error returned in polling inotify
>>>>>>>
>>>>>> fd %d.\n",
>>>>>>
>>>>>>> + pollfd[0].fd);
>>>>>>> + break;
>>>>>>> + case POLLHUP:
>>>>>>> + printf_verbose(
>>>>>>> + "Polling inotify fd %d tells it has
>>>>>>>
>>>>>> hung up.\n",
>>>>>>
>>>>>>> + pollfd[0].fd);
>>>>>>> + break;
>>>>>>> + case POLLNVAL:
>>>>>>> + printf_verbose(
>>>>>>> + "Polling inotify fd %d tells fd is
>>>>>>>
>>>>>> not open.\n",
>>>>>>
>>>>>>> + pollfd[0].fd);
>>>>>>> + break;
>>>>>>> + case POLLPRI:
>>>>>>> + case POLLIN:
>>>>>>> + printf_verbose(
>>>>>>> + "Polling inotify fd %d : data
>>>>>>>
>>>>>> ready.\n",
>>>>>>
>>>>>>> + pollfd[0].fd);
>>>>>>> +
>>>>>>> + pthread_rwlock_wrlock(&fd_pairs_lock);
>>>>>>> + read_inotify(inotify_fd, fd_pairs,
>>>>>>>
>>>>>> iwatch_array);
>>>>>>
>>>>>>> + pthread_rwlock_unlock(&fd_pairs_lock);
>>>>>>> +
>>>>>>> + break;
>>>>>>> + }
>>>>>>> +#endif
>>>>>>> +
>>>>>>> + for(i=inotify_fds;i<num_pollfd;i++) {
>>>>>>> + switch(pollfd[i].revents) {
>>>>>>> + case POLLERR:
>>>>>>> + printf_verbose(
>>>>>>> + "Error returned in polling
>>>>>>>
>>>>>> fd %d.\n",
>>>>>>
>>>>>>> + pollfd[i].fd);
>>>>>>> + num_hup++;
>>>>>>> + break;
>>>>>>> + case POLLHUP:
>>>>>>> + printf_verbose(
>>>>>>> + "Polling fd %d tells it has
>>>>>>>
>>>>>> hung up.\n",
>>>>>>
>>>>>>> + pollfd[i].fd);
>>>>>>> + num_hup++;
>>>>>>> + break;
>>>>>>> + case POLLNVAL:
>>>>>>> + printf_verbose(
>>>>>>> + "Polling fd %d tells fd is
>>>>>>>
>>>>>> not open.\n",
>>>>>>
>>>>>>> + pollfd[i].fd);
>>>>>>> + num_hup++;
>>>>>>> + break;
>>>>>>> + case POLLPRI:
>>>>>>> +
>>>>>>>
>>>>>> pthread_rwlock_rdlock(&fd_pairs_lock);
>>>>>>
>>>>>>> +
>>>>>>>
>>>>>> if(pthread_mutex_trylock(&fd_pairs->pair[i-inotify_fds].mutex) == 0) {
>>>>>>
>>>>>>> + printf_verbose(
>>>>>>> + "Urgent read on fd
>>>>>>>
>>>>>> %d\n",
>>>>>>
>>>>>>> + pollfd[i].fd);
>>>>>>> + /* Take care of high
>>>>>>>
>>>>>> priority channels first. */
>>>>>>
>>>>>>> + high_prio = 1;
>>>>>>> + /* it's ok to have an
>>>>>>>
>>>>>> unavailable sub-buffer */
>>>>>>
>>>>>>> + ret =
>>>>>>>
>>>>>> read_subbuffer(&fd_pairs->pair[i-inotify_fds]);
>>>>>>
>>>>>>> + if(ret == EAGAIN) ret = 0;
>>>>>>> +
>>>>>>> + ret =
>>>>>>>
>>>>>> pthread_mutex_unlock(&fd_pairs->pair[i-inotify_fds].mutex);
>>>>>>
>>>>>>> + if(ret)
>>>>>>> + printf("Error in
>>>>>>>
>>>>>> mutex unlock : %s\n", strerror(ret));
>>>>>>
>>>>>>> + }
>>>>>>> +
>>>>>>>
>>>>>> pthread_rwlock_unlock(&fd_pairs_lock);
>>>>>>
>>>>>>> + break;
>>>>>>> + }
>>>>>>> + }
>>>>>>> + /* If every buffer FD has hung up, we end the read loop
>>>>>>>
>>>>>> here */
>>>>>>
>>>>>>> + if(num_hup == num_pollfd - inotify_fds) break;
>>>>>>> +
>>>>>>> + if(!high_prio) {
>>>>>>> + for(i=inotify_fds;i<num_pollfd;i++) {
>>>>>>> + switch(pollfd[i].revents) {
>>>>>>> + case POLLIN:
>>>>>>> +
>>>>>>>
>>>>>> pthread_rwlock_rdlock(&fd_pairs_lock);
>>>>>>
>>>>>>> +
>>>>>>>
>>>>>> if(pthread_mutex_trylock(&fd_pairs->pair[i-inotify_fds].mutex) == 0) {
>>>>>>
>>>>>>> + /* Take care of low
>>>>>>>
>>>>>> priority channels. */
>>>>>>
>>>>>>> + printf_verbose(
>>>>>>> + "Normal
>>>>>>>
>>>>>> read on fd %d\n",
>>>>>>
>>>>>>> +
>>>>>>>
>>>>>> pollfd[i].fd);
>>>>>>
>>>>>>> + /* it's ok to have
>>>>>>>
>>>>>> an unavailable subbuffer */
>>>>>>
>>>>>>> + ret =
>>>>>>>
>>>>>> read_subbuffer(&fd_pairs->pair[i-inotify_fds]);
>>>>>>
>>>>>>> + if(ret == EAGAIN)
>>>>>>>
>>>>>> ret = 0;
>>>>>>
>>>>>>> +
>>>>>>> + ret =
>>>>>>>
>>>>>> pthread_mutex_unlock(&fd_pairs->pair[i-inotify_fds].mutex);
>>>>>>
>>>>>>> + if(ret)
>>>>>>> +
>>>>>>>
>>>>>> printf("Error in mutex unlock : %s\n", strerror(ret));
>>>>>>
>>>>>>> + }
>>>>>>> +
>>>>>>>
>>>>>> pthread_rwlock_unlock(&fd_pairs_lock);
>>>>>>
>>>>>>> + break;
>>>>>>> + }
>>>>>>> + }
>>>>>>> + }
>>>>>>> +
>>>>>>> + /* Update pollfd array if an entry was added to fd_pairs */
>>>>>>> + pthread_rwlock_rdlock(&fd_pairs_lock);
>>>>>>> + if((inotify_fds + fd_pairs->num_pairs) != num_pollfd) {
>>>>>>> + pollfd = realloc(pollfd,
>>>>>>> + (inotify_fds + fd_pairs->num_pairs)
>>>>>>>
>>>>>> * sizeof(struct pollfd));
>>>>>>
>>>>>>> +
>>>>>>>
>>>>>> for(i=num_pollfd-inotify_fds;i<fd_pairs->num_pairs;i++) {
>>>>>>
>>>>>>> + pollfd[inotify_fds+i].fd =
>>>>>>>
>>>>>> fd_pairs->pair[i].channel;
>>>>>>
>>>>>>> + pollfd[inotify_fds+i].events =
>>>>>>>
>>>>>> POLLIN|POLLPRI;
>>>>>>
>>>>>>> + }
>>>>>>> + num_pollfd = fd_pairs->num_pairs + inotify_fds;
>>>>>>> + }
>>>>>>> + pthread_rwlock_unlock(&fd_pairs_lock);
>>>>>>> +
>>>>>>> + /* NB: If the fd_pairs structure is updated by another
>>>>>>>
>>>>>> thread from this
>>>>>>
>>>>>>> + * point forward, the current thread will wait in the
>>>>>>>
>>>>>> poll without
>>>>>>
>>>>>>> + * monitoring the new channel. However, this thread
>>>>>>>
>>>>>> will add the
>>>>>>
>>>>>>> + * new channel on next poll (and this should not take
>>>>>>>
>>>>>> too much time
>>>>>>
>>>>>>> + * on a loaded system).
>>>>>>> + *
>>>>>>> + * This event is quite unlikely and can only occur if a
>>>>>>>
>>>>>> CPU is
>>>>>>
>>>>>>> + * hot-plugged while multple lttd threads are running.
>>>>>>> + */
>>>>>>> + }
>>>>>>> +
>>>>>>> +free_fd:
>>>>>>> + free(pollfd);
>>>>>>> +
>>>>>>> +end:
>>>>>>> + return ret;
>>>>>>> +}
>>>>>>> +
>>>>>>> +
>>>>>>> +void close_channel_trace_pairs(struct channel_trace_fd *fd_pairs, int
>>>>>>>
>>>>>> inotify_fd,
>>>>>>
>>>>>>> + struct inotify_watch_array *iwatch_array)
>>>>>>> +{
>>>>>>> + int i;
>>>>>>> + int ret;
>>>>>>> +
>>>>>>> + for(i=0;i<fd_pairs->num_pairs;i++) {
>>>>>>> + ret = close(fd_pairs->pair[i].channel);
>>>>>>> + if(ret == -1) perror("Close error on channel");
>>>>>>> + if(callbacks->on_close_channel) {
>>>>>>> + ret = callbacks->on_close_channel(
>>>>>>> + callbacks,&fd_pairs->pair[i]);
>>>>>>> + if(ret != 0) perror("Error on close channel
>>>>>>>
>>>>>> callback");
>>>>>>
>>>>>>> + }
>>>>>>> + }
>>>>>>> + free(fd_pairs->pair);
>>>>>>> + free(iwatch_array->elem);
>>>>>>> +}
>>>>>>> +
>>>>>>> +/* Thread worker */
>>>>>>> +void * thread_main(void *arg)
>>>>>>> +{
>>>>>>> + long ret = 0;
>>>>>>> + unsigned long thread_num = (unsigned long)arg;
>>>>>>> +
>>>>>>> + if(callbacks->on_new_thread)
>>>>>>> + ret = callbacks->on_new_thread(callbacks, thread_num);
>>>>>>> +
>>>>>>> + if (ret< 0) {
>>>>>>> + return (void*)ret;
>>>>>>> + }
>>>>>>> + ret = read_channels(thread_num,&fd_pairs, inotify_fd,
>>>>>>>
>>>>>> &inotify_watch_array);
>>>>>>
>>>>>>> +
>>>>>>> + if(callbacks->on_close_thread)
>>>>>>> + callbacks->on_close_thread(callbacks, thread_num);
>>>>>>> +
>>>>>>> + return (void*)ret;
>>>>>>> +}
>>>>>>> +
>>>>>>> +/*on_close_thread has to be reentrant, it'll be called by many threads*/
>>>>>>> +int(*on_close_thread)(struct liblttd_callbacks *data, unsigned long
>>>>>>>
>>>>>> thread_num);
>>>>>>
>>>>>>> +
>>>>>>> +int channels_init()
>>>>>>> +{
>>>>>>> + int ret = 0;
>>>>>>> +
>>>>>>> + inotify_fd = inotify_init();
>>>>>>> + fcntl(inotify_fd, F_SETFL, O_NONBLOCK);
>>>>>>> +
>>>>>>> + if(ret = open_channel_trace_pairs(channel_name,
>>>>>>> + channel_name + strlen(channel_name),&fd_pairs,
>>>>>>> +&inotify_fd,&inotify_watch_array))
>>>>>>> + goto close_channel;
>>>>>>> + if (fd_pairs.num_pairs == 0) {
>>>>>>> + printf("No channel available for reading, exiting\n");
>>>>>>> + ret = -ENOENT;
>>>>>>> + goto close_channel;
>>>>>>> + }
>>>>>>> + if(ret = map_channels(&fd_pairs, 0, fd_pairs.num_pairs))
>>>>>>> + goto close_channel;
>>>>>>> + return 0;
>>>>>>> +
>>>>>>> +close_channel:
>>>>>>> + close_channel_trace_pairs(&fd_pairs, inotify_fd,
>>>>>>>
>>>>>> &inotify_watch_array);
>>>>>>
>>>>>>> + if(inotify_fd>= 0)
>>>>>>> + close(inotify_fd);
>>>>>>> + return ret;
>>>>>>> +}
>>>>>>> +
>>>>>>> +int liblttd_start(char *channel_path, unsigned long n_threads,
>>>>>>> + int flight_only, int normal_only, int verbose,
>>>>>>> + struct liblttd_callbacks *user_data){
>>>>>>> + int ret = 0;
>>>>>>> + pthread_t *tids;
>>>>>>> + unsigned long i;
>>>>>>> + void *tret;
>>>>>>> +
>>>>>>> + /*!modif! C'est seulement la pour tester, on devrait tester pour
>>>>>>>
>>>>>> voir si
>>>>>>
>>>>>>> + les arguments sont valide. On fera surement ca autrement avec
>>>>>>>
>>>>>> plusieurs
>>>>>>
>>>>>>> + instances*/
>>>>>>> + channel_name = channel_path;
>>>>>>> + num_threads = n_threads;
>>>>>>> + dump_flight_only = flight_only;
>>>>>>> + dump_normal_only = normal_only;
>>>>>>> + verbose_mode = verbose;
>>>>>>> + callbacks = user_data;
>>>>>>> +
>>>>>>> + if(ret = channels_init())
>>>>>>> + return ret;
>>>>>>> +
>>>>>>> + tids = malloc(sizeof(pthread_t) * num_threads);
>>>>>>> + for(i=0; i<num_threads; i++) {
>>>>>>> +
>>>>>>> + ret = pthread_create(&tids[i], NULL, thread_main,
>>>>>>>
>>>>>> (void*)i);
>>>>>>
>>>>>>> + if(ret) {
>>>>>>> + perror("Error creating thread");
>>>>>>> + break;
>>>>>>> + }
>>>>>>> + }
>>>>>>> +
>>>>>>> + for(i=0; i<num_threads; i++) {
>>>>>>> + ret = pthread_join(tids[i],&tret);
>>>>>>> + if(ret) {
>>>>>>> + perror("Error joining thread");
>>>>>>> + break;
>>>>>>> + }
>>>>>>> + if((long)tret != 0) {
>>>>>>> + printf("Error %s occured in thread %ld\n",
>>>>>>> + strerror((long)tret), i);
>>>>>>> + }
>>>>>>> + }
>>>>>>> +
>>>>>>> + free(tids);
>>>>>>> + ret = unmap_channels(&fd_pairs);
>>>>>>> + close_channel_trace_pairs(&fd_pairs, inotify_fd,
>>>>>>>
>>>>>> &inotify_watch_array);
>>>>>>
>>>>>>> + if(inotify_fd>= 0)
>>>>>>> + close(inotify_fd);
>>>>>>> +
>>>>>>> + if(callbacks->on_trace_end) callbacks->on_trace_end(callbacks);
>>>>>>> +
>>>>>>> + return ret;
>>>>>>> +}
>>>>>>> +
>>>>>>> +int liblttd_stop() {
>>>>>>> + quit_program = 1;
>>>>>>> + return 0;
>>>>>>> +}
>>>>>>> +
>>>>>>> diff --git a/liblttd/liblttd.h b/liblttd/liblttd.h
>>>>>>> new file mode 100644
>>>>>>> index 0000000..bd76eeb
>>>>>>> --- /dev/null
>>>>>>> +++ b/liblttd/liblttd.h
>>>>>>> @@ -0,0 +1,218 @@
>>>>>>> +/* liblttd header file
>>>>>>> + *
>>>>>>> + * Copyright 2010-
>>>>>>> + * Oumarou Dicko<oumarou.dicko at polymtl.ca>
>>>>>>> + * Michael Sills-Lavoie<michael.sills-lavoie at polymtl.ca>
>>>>>>> + *
>>>>>>> + *
>>>>>>> + * This program is free software; you can redistribute it and/or modify
>>>>>>> + * it under the terms of the GNU General Public License as published by
>>>>>>> + * the Free Software Foundation; either version 2 of the License, or
>>>>>>> + * (at your option) any later version.
>>>>>>> + *
>>>>>>> + * This program is distributed in the hope that it will be useful,
>>>>>>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>>>>>>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
>>>>>>> + * GNU General Public License for more details.
>>>>>>> + *
>>>>>>> + */
>>>>>>> +
>>>>>>> +#ifndef _LIBLTTD_H
>>>>>>> +#define _LIBLTTD_H
>>>>>>> +
>>>>>>> +#include<pthread.h>
>>>>>>> +
>>>>>>> +/**
>>>>>>> +* This structure contains the data associated with the channel file
>>>>>>>
>>>>>> descriptor.
>>>>>>
>>>>>>> +* The lib user can use user_data to store the data associated to the
>>>>>>>
>>>>>> specified
>>>>>>
>>>>>>> +* channel. The lib user can read but MUST NOT change the other
>>>>>>>
>>>>>> attributes.
>>>>>>
>>>>>>> +*/
>>>>>>> +struct fd_pair {
>>>>>>> + /**
>>>>>>> + * This is the channel file descriptor.
>>>>>>> + */
>>>>>>> + int channel;
>>>>>>> +
>>>>>>> + /**
>>>>>>> + * This is the number of subbuffer for this channel.
>>>>>>> + */
>>>>>>> + unsigned int n_sb;
>>>>>>> +
>>>>>>> + /**
>>>>>>> + * This is the subbuffer size for this channel.
>>>>>>> + */
>>>>>>> + unsigned int max_sb_size;
>>>>>>> +
>>>>>>> + /**
>>>>>>> + * Not used anymore.
>>>>>>> + */
>>>>>>> + void *mmap;
>>>>>>> +
>>>>>>> + /**
>>>>>>> + * This is a mutex for internal library usage.
>>>>>>> + */
>>>>>>> + pthread_mutex_t mutex;
>>>>>>> +
>>>>>>> + /**
>>>>>>> + * Library user data.
>>>>>>> + */
>>>>>>> + void *user_data;
>>>>>>> +};
>>>>>>> +
>>>>>>> +/**
>>>>>>> +* This structure contains the necessary callbacks for a tracing session.
>>>>>>>
>>>>>> The
>>>>>>
>>>>>>> +* user can set the unnecessary functions to NULL if he does not need
>>>>>>>
>>>>>> them.
>>>>>>
>>>>>>> +*/
>>>>>>> +struct liblttd_callbacks {
>>>>>>> + /**
>>>>>>> + * This callback is called after a channel file is open.
>>>>>>> + *
>>>>>>> + * @args data This argument is a pointeur to the callbacks struct
>>>>>>>
>>>>>> that
>>>>>>
>>>>>>> + * has been passed to the lib.
>>>>>>> + * @args pair This structure contains the data associated with the
>>>>>>> + * channel file descriptor. The lib user can use
>>>>>>>
>>>>>> user_data to
>>>>>>
>>>>>>> + * store the data associated to the specified channel.
>>>>>>> + * @args relative_channel_path This argument represents a relative
>>>>>>>
>>>>>> path
>>>>>>
>>>>>>> + * to the channel file. This path is relative to the root
>>>>>>> + * folder of the trace channels.
>>>>>>> + *
>>>>>>> + * @return Should return 0 if the callback succeeds else not 0.
>>>>>>> + */
>>>>>>> + int(*on_open_channel)(struct liblttd_callbacks *data,
>>>>>>> + struct fd_pair *pair, char *relative_channel_path);
>>>>>>> +
>>>>>>> + /**
>>>>>>> + * This callback is called after a channel file is closed.
>>>>>>> + *
>>>>>>> + * @remarks After a channel file has been closed, it will never be
>>>>>>>
>>>>>> read
>>>>>>
>>>>>>> + * again.
>>>>>>> + *
>>>>>>> + * @args data This argument is a pointeur to the callbacks struct
>>>>>>>
>>>>>> that
>>>>>>
>>>>>>> + * has been passed to the lib.
>>>>>>> + * @args pair This structure contains the data associated with the
>>>>>>> + * channel file descriptor. The lib user should clean
>>>>>>> + * user_data at this time.
>>>>>>> + *
>>>>>>> + * @return Should return 0 if the callback succeeds else not 0.
>>>>>>> + */
>>>>>>> + int(*on_close_channel)(struct liblttd_callbacks *data,
>>>>>>> + struct fd_pair *pair);
>>>>>>> +
>>>>>>> +
>>>>>>> + /**
>>>>>>> + * This callback is called when the library enter in a new subfolder
>>>>>>> + * while it is scanning the trace channel tree. It can be used to
>>>>>>>
>>>>>> create
>>>>>>
>>>>>>> + * the output file structure of the trace.
>>>>>>> + *
>>>>>>> + * @args data This argument is a pointeur to the callbacks struct
>>>>>>>
>>>>>> that
>>>>>>
>>>>>>> + * has been passed to the lib.
>>>>>>> + * @args relative_folder_path This argument represents a relative
>>>>>>>
>>>>>> path
>>>>>>
>>>>>>> + * to the channel folder. This path is relative to the
>>>>>>>
>>>>>> root
>>>>>>
>>>>>>> + * folder of the trace channels.
>>>>>>> + *
>>>>>>> + * @return Should return 0 if the callback succeeds else not 0.
>>>>>>> + */
>>>>>>> + int(*on_new_channels_folder)(struct liblttd_callbacks *data,
>>>>>>> + char *relative_folder_path);
>>>>>>> +
>>>>>>> + /**
>>>>>>> + * This callback is called after a subbuffer is a reserved.
>>>>>>> + *
>>>>>>> + * @attention It has to be thread safe, it'll be called by many
>>>>>>>
>>>>>> threads.
>>>>>>
>>>>>>> + *
>>>>>>> + * @args data This argument is a pointeur to the callbacks struct
>>>>>>>
>>>>>> that
>>>>>>
>>>>>>> + * has been passed to the lib.
>>>>>>> + * @args pair This structure contains the data associated with the
>>>>>>> + * channel file descriptor. The lib user should clean
>>>>>>> + * user_data at this time.
>>>>>>> + * @args len This argument represents the length the data that has
>>>>>>>
>>>>>> to be
>>>>>>
>>>>>>> + * read.
>>>>>>> + *
>>>>>>> + * @return Should return 0 if the callback succeeds else not 0.
>>>>>>> + */
>>>>>>> + int(*on_read_subbuffer)(struct liblttd_callbacks *data,
>>>>>>> + struct fd_pair *pair, unsigned int len);
>>>>>>> +
>>>>>>> + /**
>>>>>>> + * This callback is called at the very end of the tracing session.
>>>>>>>
>>>>>> At
>>>>>>
>>>>>>> + * this time, all the channels have been closed and the threads have
>>>>>>>
>>>>>> been
>>>>>>
>>>>>>> + * destroyed.
>>>>>>> + *
>>>>>>> + * @remarks After this callback is called, no other callback will be
>>>>>>> + * called again.
>>>>>>> + *
>>>>>>> + * @attention It has to be thread safe, it'll be called by many
>>>>>>>
>>>>>> threads.
>>>>>>
>>>>>>> + *
>>>>>>> + * @args data This argument is a pointeur to the callbacks struct
>>>>>>>
>>>>>> that
>>>>>>
>>>>>>> + * has been passed to the lib.
>>>>>>> + *
>>>>>>> + * @return Should return 0 if the callback succeeds else not 0.
>>>>>>> + */
>>>>>>> + int(*on_trace_end)(struct liblttd_callbacks *data);
>>>>>>> +
>>>>>>> + /**
>>>>>>> + * This callback is called after a new thread has been created.
>>>>>>> + *
>>>>>>> + * @attention It has to be thread safe, it'll be called by many
>>>>>>>
>>>>>> threads.
>>>>>>
>>>>>>> + *
>>>>>>> + * @args data This argument is a pointeur to the callbacks struct
>>>>>>>
>>>>>> that
>>>>>>
>>>>>>> + * has been passed to the lib.
>>>>>>> + * @args thread_num This argument represents the id of the thread.
>>>>>>> + *
>>>>>>> + * @return Should return 0 if the callback succeeds else not 0.
>>>>>>> + */
>>>>>>> + int(*on_new_thread)(struct liblttd_callbacks *data,
>>>>>>> + unsigned long thread_num);
>>>>>>> +
>>>>>>> + /**
>>>>>>> + * This callback is called just before a thread is destroyed.
>>>>>>> + *
>>>>>>> + * @attention It has to be thread safe, it'll be called by many
>>>>>>>
>>>>>> threads.
>>>>>>
>>>>>>> + *
>>>>>>> + * @args data This argument is a pointeur to the callbacks struct
>>>>>>>
>>>>>> that
>>>>>>
>>>>>>> + * has been passed to the lib.
>>>>>>> + * @args thread_num This argument represents the number of the
>>>>>>>
>>>>>> thread.
>>>>>>
>>>>>>> + *
>>>>>>> + * @return Should return 0 if the callback succeeds else not 0.
>>>>>>> + */
>>>>>>> + int(*on_close_thread)(struct liblttd_callbacks *data,
>>>>>>> + unsigned long thread_num);
>>>>>>> +
>>>>>>> + /**
>>>>>>> + * This is where the user can put the library's data.
>>>>>>> + */
>>>>>>> + void *user_data;
>>>>>>> +};
>>>>>>> +
>>>>>>> +/**
>>>>>>> +* This function is called to start a new tracing session.
>>>>>>> +*
>>>>>>> +* @attention It has to be thread safe, it'll be called by many threads.
>>>>>>> +*
>>>>>>> +* @args channel_path This argument is a path to the root folder of the
>>>>>>>
>>>>>> trace's
>>>>>>
>>>>>>> +* channels.
>>>>>>> +* @args n_threads This argument represents the number of threads that
>>>>>>>
>>>>>> will be
>>>>>>
>>>>>>> +* used by the library.
>>>>>>> +* @args flight_only If this argument to set to 1, only the channel that
>>>>>>>
>>>>>> are in
>>>>>>
>>>>>>> +* flight recorder mode will be recorded.
>>>>>>> +* @args normal_only If this argument to set to 1, only the channel that
>>>>>>>
>>>>>> are in
>>>>>>
>>>>>>> +* normal mode will be recorded.
>>>>>>> +* @args verbose If this argument to set to 1, more informations will be
>>>>>>>
>>>>>> printed.
>>>>>>
>>>>>>> +* @args user_data This argument is a pointeur to the callbacks struct
>>>>>>>
>>>>>> that
>>>>>>
>>>>>>> +* contains the user's functions.
>>>>>>> +*
>>>>>>> +* @return Return 0 if the function succeeds else not 0.
>>>>>>> +*/
>>>>>>> +int liblttd_start(char *channel_path, unsigned long n_threads,
>>>>>>> + int flight_only, int normal_only, int verbose,
>>>>>>> + struct liblttd_callbacks *user_data);
>>>>>>> +
>>>>>>> +/**
>>>>>>> +* This function is called to stop a tracing session.
>>>>>>> +*
>>>>>>> +* @return Return 0 if the function succeeds.
>>>>>>> +*/
>>>>>>> +int liblttd_stop();
>>>>>>> +
>>>>>>> +#endif /*_LIBLTTD_H */
>>>>>>> +
>>>>>>> diff --git a/lttd/Makefile.am b/lttd/Makefile.am
>>>>>>> index bb860bc..fc9b219 100644
>>>>>>> --- a/lttd/Makefile.am
>>>>>>> +++ b/lttd/Makefile.am
>>>>>>> @@ -6,3 +6,6 @@ bin_PROGRAMS = lttd
>>>>>>>
>>>>>>> lttd_SOURCES = lttd.c
>>>>>>>
>>>>>>> +lttd_DEPENDENCIES = ../liblttd/liblttd.la
>>>>>>> +lttd_LDADD = $(lttd_DEPENDENCIES)
>>>>>>> +
>>>>>>> diff --git a/lttd/lttd.c b/lttd/lttd.c
>>>>>>> index 773cb23..9143ef7 100644
>>>>>>> --- a/lttd/lttd.c
>>>>>>> +++ b/lttd/lttd.c
>>>>>>> @@ -17,125 +17,36 @@
>>>>>>>
>>>>>>> #define _REENTRANT
>>>>>>> #define _GNU_SOURCE
>>>>>>> -#include<features.h>
>>>>>>> +
>>>>>>> #include<stdio.h>
>>>>>>> -#include<unistd.h>
>>>>>>> -#include<errno.h>
>>>>>>> -#include<sys/types.h>
>>>>>>> -#include<sys/stat.h>
>>>>>>> #include<stdlib.h>
>>>>>>> -#include<dirent.h>
>>>>>>> #include<string.h>
>>>>>>> -#include<fcntl.h>
>>>>>>> -#include<sys/poll.h>
>>>>>>> -#include<sys/mman.h>
>>>>>>> #include<signal.h>
>>>>>>> -#include<pthread.h>
>>>>>>> -#include<sys/syscall.h>
>>>>>>> -#include<unistd.h>
>>>>>>> -#include<asm/ioctls.h>
>>>>>>> -
>>>>>>> -#include<linux/version.h>
>>>>>>> -
>>>>>>> -/* Relayfs IOCTL */
>>>>>>> -#include<asm/ioctl.h>
>>>>>>> -#include<asm/types.h>
>>>>>>> -
>>>>>>> -/* Get the next sub buffer that can be read. */
>>>>>>> -#define RELAY_GET_SB _IOR(0xF5, 0x00,__u32)
>>>>>>> -/* Release the oldest reserved (by "get") sub buffer. */
>>>>>>> -#define RELAY_PUT_SB _IOW(0xF5, 0x01,__u32)
>>>>>>> -/* returns the number of sub buffers in the per cpu channel. */
>>>>>>> -#define RELAY_GET_N_SB _IOR(0xF5, 0x02,__u32)
>>>>>>> -/* returns the size of the current sub buffer. */
>>>>>>> -#define RELAY_GET_SB_SIZE _IOR(0xF5, 0x03, __u32)
>>>>>>> -/* returns the size of data to consume in the current sub-buffer. */
>>>>>>> -#define RELAY_GET_MAX_SB_SIZE _IOR(0xF5, 0x04, __u32)
>>>>>>> -
>>>>>>> -
>>>>>>> -#if LINUX_VERSION_CODE>= KERNEL_VERSION(2,6,14)
>>>>>>> -#include<sys/inotify.h>
>>>>>>> -#if 0 /* should now be provided by libc. */
>>>>>>> -/* From the inotify-tools 2.6 package */
>>>>>>> -static inline int inotify_init (void)
>>>>>>> -{
>>>>>>> - return syscall (__NR_inotify_init);
>>>>>>> -}
>>>>>>> -
>>>>>>> -static inline int inotify_add_watch (int fd, const char *name, __u32
>>>>>>>
>>>>>> mask)
>>>>>>
>>>>>>> -{
>>>>>>> - return syscall (__NR_inotify_add_watch, fd, name, mask);
>>>>>>> -}
>>>>>>> -
>>>>>>> -static inline int inotify_rm_watch (int fd, __u32 wd)
>>>>>>> -{
>>>>>>> - return syscall (__NR_inotify_rm_watch, fd, wd);
>>>>>>> -}
>>>>>>> -#endif //0
>>>>>>> -#define HAS_INOTIFY
>>>>>>> -#else
>>>>>>> -static inline int inotify_init (void)
>>>>>>> -{
>>>>>>> - return -1;
>>>>>>> -}
>>>>>>> +#include<errno.h>
>>>>>>> +#include<fcntl.h>
>>>>>>> +#include<dirent.h>
>>>>>>> +#include<sys/stat.h>
>>>>>>>
>>>>>>> -static inline int inotify_add_watch (int fd, const char *name, __u32
>>>>>>>
>>>>>> mask)
>>>>>>
>>>>>>> -{
>>>>>>> - return 0;
>>>>>>> -}
>>>>>>> +#include<liblttd/liblttd.h>
>>>>>>>
>>>>>>> -static inline int inotify_rm_watch (int fd, __u32 wd)
>>>>>>> -{
>>>>>>> - return 0;
>>>>>>> -}
>>>>>>> -#undef HAS_INOTIFY
>>>>>>> -#endif
>>>>>>> -
>>>>>>> -struct fd_pair {
>>>>>>> - int channel;
>>>>>>> +struct lttd_channel_data {
>>>>>>> int trace;
>>>>>>> - unsigned int n_sb;
>>>>>>> - unsigned int max_sb_size;
>>>>>>> - void *mmap;
>>>>>>> - pthread_mutex_t mutex;
>>>>>>> -};
>>>>>>> -
>>>>>>> -struct channel_trace_fd {
>>>>>>> - struct fd_pair *pair;
>>>>>>> - int num_pairs;
>>>>>>> -};
>>>>>>> -
>>>>>>> -struct inotify_watch {
>>>>>>> - int wd;
>>>>>>> - char path_channel[PATH_MAX];
>>>>>>> - char path_trace[PATH_MAX];
>>>>>>> -};
>>>>>>> -
>>>>>>> -struct inotify_watch_array {
>>>>>>> - struct inotify_watch *elem;
>>>>>>> - int num;
>>>>>>> };
>>>>>>>
>>>>>>> -static __thread int thread_pipe[2];
>>>>>>> -
>>>>>>> -struct channel_trace_fd fd_pairs = { NULL, 0 };
>>>>>>> -int inotify_fd = -1;
>>>>>>> -struct inotify_watch_array inotify_watch_array = { NULL, 0 };
>>>>>>> -
>>>>>>> -/* protects fd_pairs and inotify_watch_array */
>>>>>>> -pthread_rwlock_t fd_pairs_lock = PTHREAD_RWLOCK_INITIALIZER;
>>>>>>> -
>>>>>>> -
>>>>>>> +static char path_trace[PATH_MAX];
>>>>>>> +static char *end_path_trace;
>>>>>>> +static int path_trace_len = 0;
>>>>>>> static char *trace_name = NULL;
>>>>>>> static char *channel_name = NULL;
>>>>>>> static int daemon_mode = 0;
>>>>>>> static int append_mode = 0;
>>>>>>> static unsigned long num_threads = 1;
>>>>>>> -volatile static int quit_program = 0; /* For signal handler */
>>>>>>> static int dump_flight_only = 0;
>>>>>>> static int dump_normal_only = 0;
>>>>>>> static int verbose_mode = 0;
>>>>>>>
>>>>>>> +static __thread int thread_pipe[2];
>>>>>>> +
>>>>>>> #define printf_verbose(fmt, args...) \
>>>>>>> do { \
>>>>>>> if (verbose_mode) \
>>>>>>> @@ -178,7 +89,7 @@ int parse_arguments(int argc, char **argv)
>>>>>>> {
>>>>>>> int ret = 0;
>>>>>>> int argn = 1;
>>>>>>> -
>>>>>>> +
>>>>>>> if(argc == 2) {
>>>>>>> if(strcmp(argv[1], "-h") == 0) {
>>>>>>> return 1;
>>>>>>> @@ -236,19 +147,19 @@ int parse_arguments(int argc, char **argv)
>>>>>>> }
>>>>>>> argn++;
>>>>>>> }
>>>>>>> -
>>>>>>> +
>>>>>>> if(trace_name == NULL) {
>>>>>>> printf("Please specify a trace name.\n");
>>>>>>> printf("\n");
>>>>>>> ret = -1;
>>>>>>> }
>>>>>>> -
>>>>>>> +
>>>>>>> if(channel_name == NULL) {
>>>>>>> printf("Please specify a channel name.\n");
>>>>>>> printf("\n");
>>>>>>> ret = -1;
>>>>>>> }
>>>>>>> -
>>>>>>> +
>>>>>>> return ret;
>>>>>>> }
>>>>>>>
>>>>>>> @@ -267,223 +178,96 @@ void show_info(void)
>>>>>>> static void handler(int signo)
>>>>>>> {
>>>>>>> printf("Signal %d received : exiting cleanly\n", signo);
>>>>>>> - quit_program = 1;
>>>>>>> + liblttd_stop();
>>>>>>> }
>>>>>>>
>>>>>>> -
>>>>>>> -int open_buffer_file(char *filename, char *path_channel, char
>>>>>>>
>>>>>> *path_trace,
>>>>>>
>>>>>>> - struct channel_trace_fd *fd_pairs)
>>>>>>> +int lttd_on_open_channel(struct liblttd_callbacks *data, struct fd_pair
>>>>>>>
>>>>>> *pair, char *relative_channel_path)
>>>>>>
>>>>>>> {
>>>>>>> int open_ret = 0;
>>>>>>> - int ret = 0;
>>>>>>> + int ret;
>>>>>>> struct stat stat_buf;
>>>>>>> + struct lttd_channel_data *channel_data;
>>>>>>>
>>>>>>> - if(strncmp(filename, "flight-", sizeof("flight-")-1) != 0) {
>>>>>>> - if(dump_flight_only) {
>>>>>>> - printf_verbose("Skipping normal channel %s\n",
>>>>>>> - path_channel);
>>>>>>> - return 0;
>>>>>>> - }
>>>>>>> - } else {
>>>>>>> - if(dump_normal_only) {
>>>>>>> - printf_verbose("Skipping flight channel %s\n",
>>>>>>> - path_channel);
>>>>>>> - return 0;
>>>>>>> - }
>>>>>>> - }
>>>>>>> - printf_verbose("Opening file.\n");
>>>>>>> -
>>>>>>> - fd_pairs->pair = realloc(fd_pairs->pair,
>>>>>>> - ++fd_pairs->num_pairs * sizeof(struct fd_pair));
>>>>>>> + pair->user_data = malloc(sizeof(struct lttd_channel_data));
>>>>>>> + channel_data = pair->user_data;
>>>>>>> +
>>>>>>> + strncpy(end_path_trace, relative_channel_path, PATH_MAX -
>>>>>>>
>>>>>> path_trace_len);
>>>>>>
>>>>>>> + printf_verbose("Creating trace file %s\n", path_trace);
>>>>>>>
>>>>>>> - /* Open the channel in read mode */
>>>>>>> - fd_pairs->pair[fd_pairs->num_pairs-1].channel =
>>>>>>> - open(path_channel, O_RDONLY | O_NONBLOCK);
>>>>>>> - if(fd_pairs->pair[fd_pairs->num_pairs-1].channel == -1) {
>>>>>>> - perror(path_channel);
>>>>>>> - fd_pairs->num_pairs--;
>>>>>>> - return 0; /* continue */
>>>>>>> - }
>>>>>>> - /* Open the trace in write mode, only append if append_mode */
>>>>>>> ret = stat(path_trace,&stat_buf);
>>>>>>> if(ret == 0) {
>>>>>>> if(append_mode) {
>>>>>>> printf_verbose("Appending to file %s as
>>>>>>>
>>>>>> requested\n",
>>>>>>
>>>>>>> path_trace);
>>>>>>>
>>>>>>> - fd_pairs->pair[fd_pairs->num_pairs-1].trace =
>>>>>>> - open(path_trace, O_WRONLY,
>>>>>>> - S_IRWXU|S_IRWXG|S_IRWXO);
>>>>>>> - if(fd_pairs->pair[fd_pairs->num_pairs-1].trace ==
>>>>>>>
>>>>>> -1) {
>>>>>>
>>>>>>> + channel_data->trace = open(path_trace, O_WRONLY,
>>>>>>>
>>>>>> S_IRWXU|S_IRWXG|S_IRWXO);
>>>>>>
>>>>>>> + if(channel_data->trace == -1) {
>>>>>>> perror(path_trace);
>>>>>>> open_ret = -1;
>>>>>>> -
>>>>>>>
>>>>>> close(fd_pairs->pair[fd_pairs->num_pairs-1].channel);
>>>>>>
>>>>>>> - fd_pairs->num_pairs--;
>>>>>>> goto end;
>>>>>>> }
>>>>>>> - ret =
>>>>>>>
>>>>>> lseek(fd_pairs->pair[fd_pairs->num_pairs-1].trace,
>>>>>>
>>>>>>> - 0, SEEK_END);
>>>>>>> + ret = lseek(channel_data->trace, 0, SEEK_END);
>>>>>>> if (ret< 0) {
>>>>>>> perror(path_trace);
>>>>>>> open_ret = -1;
>>>>>>> -
>>>>>>>
>>>>>> close(fd_pairs->pair[fd_pairs->num_pairs-1].channel);
>>>>>>
>>>>>>> -
>>>>>>>
>>>>>> close(fd_pairs->pair[fd_pairs->num_pairs-1].trace);
>>>>>>
>>>>>>> - fd_pairs->num_pairs--;
>>>>>>> + close(channel_data->trace);
>>>>>>> goto end;
>>>>>>> }
>>>>>>> } else {
>>>>>>> printf("File %s exists, cannot open. Try append
>>>>>>>
>>>>>> mode.\n", path_trace);
>>>>>>
>>>>>>> open_ret = -1;
>>>>>>> -
>>>>>>>
>>>>>> close(fd_pairs->pair[fd_pairs->num_pairs-1].channel);
>>>>>>
>>>>>>> - fd_pairs->num_pairs--;
>>>>>>> goto end;
>>>>>>> }
>>>>>>> } else {
>>>>>>> if(errno == ENOENT) {
>>>>>>> - fd_pairs->pair[fd_pairs->num_pairs-1].trace =
>>>>>>> - open(path_trace, O_WRONLY|O_CREAT|O_EXCL,
>>>>>>> - S_IRWXU|S_IRWXG|S_IRWXO);
>>>>>>> - if(fd_pairs->pair[fd_pairs->num_pairs-1].trace ==
>>>>>>>
>>>>>> -1) {
>>>>>>
>>>>>>> + channel_data->trace = open(path_trace,
>>>>>>>
>>>>>> O_WRONLY|O_CREAT|O_EXCL, S_IRWXU|S_IRWXG|S_IRWXO);
>>>>>>
>>>>>>> + if(channel_data->trace == -1) {
>>>>>>> perror(path_trace);
>>>>>>> open_ret = -1;
>>>>>>> -
>>>>>>>
>>>>>> close(fd_pairs->pair[fd_pairs->num_pairs-1].channel);
>>>>>>
>>>>>>> - fd_pairs->num_pairs--;
>>>>>>> goto end;
>>>>>>> }
>>>>>>> }
>>>>>>> }
>>>>>>> +
>>>>>>> end:
>>>>>>> return open_ret;
>>>>>>> +
>>>>>>> }
>>>>>>>
>>>>>>> -int open_channel_trace_pairs(char *subchannel_name, char *subtrace_name,
>>>>>>> - struct channel_trace_fd *fd_pairs, int *inotify_fd,
>>>>>>> - struct inotify_watch_array *iwatch_array)
>>>>>>> +int lttd_on_close_channel(struct liblttd_callbacks *data, struct fd_pair
>>>>>>>
>>>>>> *pair)
>>>>>>
>>>>>>> +{
>>>>>>> + int ret;
>>>>>>> + ret = close(((struct lttd_channel_data
>>>>>>>
>>>>>> *)(pair->user_data))->trace);
>>>>>>
>>>>>>> + free(pair->user_data);
>>>>>>> + return ret;
>>>>>>> +}
>>>>>>> +
>>>>>>> +int lttd_on_new_channels_folder(struct liblttd_callbacks *data, char
>>>>>>>
>>>>>> *relative_folder_path)
>>>>>>
>>>>>>> {
>>>>>>> - DIR *channel_dir = opendir(subchannel_name);
>>>>>>> - struct dirent *entry;
>>>>>>> - struct stat stat_buf;
>>>>>>> int ret;
>>>>>>> - char path_channel[PATH_MAX];
>>>>>>> - int path_channel_len;
>>>>>>> - char *path_channel_ptr;
>>>>>>> - char path_trace[PATH_MAX];
>>>>>>> - int path_trace_len;
>>>>>>> - char *path_trace_ptr;
>>>>>>> int open_ret = 0;
>>>>>>>
>>>>>>> - if(channel_dir == NULL) {
>>>>>>> - perror(subchannel_name);
>>>>>>> - open_ret = ENOENT;
>>>>>>> - goto end;
>>>>>>> - }
>>>>>>> + strncpy(end_path_trace, relative_folder_path, PATH_MAX -
>>>>>>>
>>>>>> path_trace_len);
>>>>>>
>>>>>>> + printf_verbose("Creating trace subdirectory %s\n", path_trace);
>>>>>>>
>>>>>>> - printf_verbose("Creating trace subdirectory %s\n", subtrace_name);
>>>>>>> - ret = mkdir(subtrace_name, S_IRWXU|S_IRWXG|S_IRWXO);
>>>>>>> + ret = mkdir(path_trace, S_IRWXU|S_IRWXG|S_IRWXO);
>>>>>>> if(ret == -1) {
>>>>>>> if(errno != EEXIST) {
>>>>>>> - perror(subtrace_name);
>>>>>>> + perror(path_trace);
>>>>>>> open_ret = -1;
>>>>>>> goto end;
>>>>>>> }
>>>>>>> }
>>>>>>>
>>>>>>> - strncpy(path_channel, subchannel_name, PATH_MAX-1);
>>>>>>> - path_channel_len = strlen(path_channel);
>>>>>>> - path_channel[path_channel_len] = '/';
>>>>>>> - path_channel_len++;
>>>>>>> - path_channel_ptr = path_channel + path_channel_len;
>>>>>>> -
>>>>>>> - strncpy(path_trace, subtrace_name, PATH_MAX-1);
>>>>>>> - path_trace_len = strlen(path_trace);
>>>>>>> - path_trace[path_trace_len] = '/';
>>>>>>> - path_trace_len++;
>>>>>>> - path_trace_ptr = path_trace + path_trace_len;
>>>>>>> -
>>>>>>> -#ifdef HAS_INOTIFY
>>>>>>> - iwatch_array->elem = realloc(iwatch_array->elem,
>>>>>>> - ++iwatch_array->num * sizeof(struct inotify_watch));
>>>>>>> -
>>>>>>> - printf_verbose("Adding inotify for channel %s\n", path_channel);
>>>>>>> - iwatch_array->elem[iwatch_array->num-1].wd =
>>>>>>>
>>>>>> inotify_add_watch(*inotify_fd, path_channel, IN_CREATE);
>>>>>>
>>>>>>> - strcpy(iwatch_array->elem[iwatch_array->num-1].path_channel,
>>>>>>>
>>>>>> path_channel);
>>>>>>
>>>>>>> - strcpy(iwatch_array->elem[iwatch_array->num-1].path_trace,
>>>>>>>
>>>>>> path_trace);
>>>>>>
>>>>>>> - printf_verbose("Added inotify for channel %s, wd %u\n",
>>>>>>> - iwatch_array->elem[iwatch_array->num-1].path_channel,
>>>>>>> - iwatch_array->elem[iwatch_array->num-1].wd);
>>>>>>> -#endif
>>>>>>> -
>>>>>>> - while((entry = readdir(channel_dir)) != NULL) {
>>>>>>> -
>>>>>>> - if(entry->d_name[0] == '.') continue;
>>>>>>> -
>>>>>>> - strncpy(path_channel_ptr, entry->d_name, PATH_MAX -
>>>>>>>
>>>>>> path_channel_len);
>>>>>>
>>>>>>> - strncpy(path_trace_ptr, entry->d_name, PATH_MAX -
>>>>>>>
>>>>>> path_trace_len);
>>>>>>
>>>>>>> -
>>>>>>> - ret = stat(path_channel,&stat_buf);
>>>>>>> - if(ret == -1) {
>>>>>>> - perror(path_channel);
>>>>>>> - continue;
>>>>>>> - }
>>>>>>> -
>>>>>>> - printf_verbose("Channel file : %s\n", path_channel);
>>>>>>> -
>>>>>>> - if(S_ISDIR(stat_buf.st_mode)) {
>>>>>>> -
>>>>>>> - printf_verbose("Entering channel
>>>>>>>
>>>>>> subdirectory...\n");
>>>>>>
>>>>>>> - ret = open_channel_trace_pairs(path_channel,
>>>>>>>
>>>>>> path_trace, fd_pairs,
>>>>>>
>>>>>>> - inotify_fd, iwatch_array);
>>>>>>> - if(ret< 0) continue;
>>>>>>> - } else if(S_ISREG(stat_buf.st_mode)) {
>>>>>>> - open_ret = open_buffer_file(entry->d_name,
>>>>>>>
>>>>>> path_channel, path_trace,
>>>>>>
>>>>>>> - fd_pairs);
>>>>>>> - if(open_ret)
>>>>>>> - goto end;
>>>>>>> - }
>>>>>>> - }
>>>>>>> -
>>>>>>> end:
>>>>>>> - closedir(channel_dir);
>>>>>>> -
>>>>>>> return open_ret;
>>>>>>> }
>>>>>>>
>>>>>>> -
>>>>>>> -int read_subbuffer(struct fd_pair *pair)
>>>>>>> +int lttd_on_read_subbuffer(struct liblttd_callbacks *data, struct
>>>>>>>
>>>>>> fd_pair *pair, unsigned int len)
>>>>>>
>>>>>>> {
>>>>>>> - unsigned int consumed_old, len;
>>>>>>> - int err;
>>>>>>> long ret;
>>>>>>> - off_t offset;
>>>>>>> -
>>>>>>> + off_t offset = 0;
>>>>>>>
>>>>>>> - err = ioctl(pair->channel, RELAY_GET_SB,&consumed_old);
>>>>>>> - printf_verbose("cookie : %u\n", consumed_old);
>>>>>>> - if(err != 0) {
>>>>>>> - ret = errno;
>>>>>>> - perror("Reserving sub buffer failed (everything is normal,
>>>>>>>
>>>>>> it is due to concurrency)");
>>>>>>
>>>>>>> - goto get_error;
>>>>>>> - }
>>>>>>> -#if 0
>>>>>>> - err = TEMP_FAILURE_RETRY(write(pair->trace,
>>>>>>> - pair->mmap
>>>>>>> - + (consumed_old& ((pair->n_subbufs
>>>>>>>
>>>>>> * pair->subbuf_size)-1)),
>>>>>>
>>>>>>> - pair->subbuf_size));
>>>>>>> -
>>>>>>> - if(err< 0) {
>>>>>>> - ret = errno;
>>>>>>> - perror("Error in writing to file");
>>>>>>> - goto write_error;
>>>>>>> - }
>>>>>>> -#endif //0
>>>>>>> - err = ioctl(pair->channel, RELAY_GET_SB_SIZE,&len);
>>>>>>> - if(err != 0) {
>>>>>>> - ret = errno;
>>>>>>> - perror("Getting sub-buffer len failed.");
>>>>>>> - goto get_error;
>>>>>>> - }
>>>>>>> -
>>>>>>> - offset = 0;
>>>>>>> while (len> 0) {
>>>>>>> printf_verbose("splice chan to pipe offset %lu\n",
>>>>>>> (unsigned long)offset);
>>>>>>> @@ -494,8 +278,9 @@ int read_subbuffer(struct fd_pair *pair)
>>>>>>> perror("Error in relay splice");
>>>>>>> goto write_error;
>>>>>>> }
>>>>>>> - ret = splice(thread_pipe[0], NULL, pair->trace, NULL,
>>>>>>> - ret, SPLICE_F_MOVE | SPLICE_F_MORE);
>>>>>>> + ret = splice(thread_pipe[0], NULL,
>>>>>>> + ((struct lttd_channel_data
>>>>>>>
>>>>>> *)(pair->user_data))->trace,
>>>>>>
>>>>>>> + NULL, ret, SPLICE_F_MOVE | SPLICE_F_MORE);
>>>>>>> printf_verbose("splice pipe to file %ld\n", ret);
>>>>>>> if (ret< 0) {
>>>>>>> perror("Error in file splice");
>>>>>>> @@ -504,466 +289,42 @@ int read_subbuffer(struct fd_pair *pair)
>>>>>>> len -= ret;
>>>>>>> }
>>>>>>>
>>>>>>> -#if 0
>>>>>>> - err = fsync(pair->trace);
>>>>>>> - if(err< 0) {
>>>>>>> - ret = errno;
>>>>>>> - perror("Error in writing to file");
>>>>>>> - goto write_error;
>>>>>>> - }
>>>>>>> -#endif //0
>>>>>>> write_error:
>>>>>>> - ret = 0;
>>>>>>> - err = ioctl(pair->channel, RELAY_PUT_SB,&consumed_old);
>>>>>>> - if(err != 0) {
>>>>>>> - ret = errno;
>>>>>>> - if(errno == EFAULT) {
>>>>>>> - perror("Error in unreserving sub buffer\n");
>>>>>>> - } else if(errno == EIO) {
>>>>>>> - /* Should never happen with newer LTTng versions */
>>>>>>> - perror("Reader has been pushed by the writer, last
>>>>>>>
>>>>>> sub-buffer corrupted.");
>>>>>>
>>>>>>> - }
>>>>>>> - goto get_error;
>>>>>>> - }
>>>>>>> -
>>>>>>> -get_error:
>>>>>>> - return ret;
>>>>>>> -}
>>>>>>> -
>>>>>>> -
>>>>>>> -int map_channels(struct channel_trace_fd *fd_pairs,
>>>>>>> - int idx_begin, int idx_end)
>>>>>>> -{
>>>>>>> - int i,j;
>>>>>>> - int ret=0;
>>>>>>> -
>>>>>>> - if(fd_pairs->num_pairs<= 0) {
>>>>>>> - printf("No channel to read\n");
>>>>>>> - goto end;
>>>>>>> - }
>>>>>>> -
>>>>>>> - /* Get the subbuf sizes and number */
>>>>>>> -
>>>>>>> - for(i=idx_begin;i<idx_end;i++) {
>>>>>>> - struct fd_pair *pair =&fd_pairs->pair[i];
>>>>>>> -
>>>>>>> - ret = ioctl(pair->channel, RELAY_GET_N_SB,&pair->n_sb);
>>>>>>> - if(ret != 0) {
>>>>>>> - perror("Error in getting the number of
>>>>>>>
>>>>>> sub-buffers");
>>>>>>
>>>>>>> - goto end;
>>>>>>> - }
>>>>>>> - ret = ioctl(pair->channel, RELAY_GET_MAX_SB_SIZE,
>>>>>>> -&pair->max_sb_size);
>>>>>>> - if(ret != 0) {
>>>>>>> - perror("Error in getting the max sub-buffer size");
>>>>>>> - goto end;
>>>>>>> - }
>>>>>>> - ret = pthread_mutex_init(&pair->mutex, NULL); /* Fast
>>>>>>>
>>>>>> mutex */
>>>>>>
>>>>>>> - if(ret != 0) {
>>>>>>> - perror("Error in mutex init");
>>>>>>> - goto end;
>>>>>>> - }
>>>>>>> - }
>>>>>>> -
>>>>>>> -#if 0
>>>>>>> - /* Mmap each FD */
>>>>>>> - for(i=idx_begin;i<idx_end;i++) {
>>>>>>> - struct fd_pair *pair =&fd_pairs->pair[i];
>>>>>>> -
>>>>>>> - pair->mmap = mmap(0, pair->subbuf_size * pair->n_subbufs,
>>>>>>>
>>>>>> PROT_READ,
>>>>>>
>>>>>>> - MAP_SHARED, pair->channel, 0);
>>>>>>> - if(pair->mmap == MAP_FAILED) {
>>>>>>> - perror("Mmap error");
>>>>>>> - goto munmap;
>>>>>>> - }
>>>>>>> - }
>>>>>>> -
>>>>>>> - goto end; /* success */
>>>>>>> -
>>>>>>> - /* Error handling */
>>>>>>> - /* munmap only the successfully mmapped indexes */
>>>>>>> -munmap:
>>>>>>> - /* Munmap each FD */
>>>>>>> - for(j=idx_begin;j<i;j++) {
>>>>>>> - struct fd_pair *pair =&fd_pairs->pair[j];
>>>>>>> - int err_ret;
>>>>>>> -
>>>>>>> - err_ret = munmap(pair->mmap, pair->subbuf_size *
>>>>>>>
>>>>>> pair->n_subbufs);
>>>>>>
>>>>>>> - if(err_ret != 0) {
>>>>>>> - perror("Error in munmap");
>>>>>>> - }
>>>>>>> - ret |= err_ret;
>>>>>>> - }
>>>>>>> -
>>>>>>> -#endif //0
>>>>>>> -end:
>>>>>>> return ret;
>>>>>>> }
>>>>>>>
>>>>>>> -int unmap_channels(struct channel_trace_fd *fd_pairs)
>>>>>>> -{
>>>>>>> - int j;
>>>>>>> - int ret=0;
>>>>>>> -
>>>>>>> - /* Munmap each FD */
>>>>>>> - for(j=0;j<fd_pairs->num_pairs;j++) {
>>>>>>> - struct fd_pair *pair =&fd_pairs->pair[j];
>>>>>>> - int err_ret;
>>>>>>> -
>>>>>>> -#if 0
>>>>>>> - err_ret = munmap(pair->mmap, pair->subbuf_size *
>>>>>>>
>>>>>> pair->n_subbufs);
>>>>>>
>>>>>>> - if(err_ret != 0) {
>>>>>>> - perror("Error in munmap");
>>>>>>> - }
>>>>>>> - ret |= err_ret;
>>>>>>> -#endif //0
>>>>>>> - err_ret = pthread_mutex_destroy(&pair->mutex);
>>>>>>> - if(err_ret != 0) {
>>>>>>> - perror("Error in mutex destroy");
>>>>>>> - }
>>>>>>> - ret |= err_ret;
>>>>>>> - }
>>>>>>> -
>>>>>>> - return ret;
>>>>>>> -}
>>>>>>> -
>>>>>>> -#ifdef HAS_INOTIFY
>>>>>>> -/* Inotify event arrived.
>>>>>>> - *
>>>>>>> - * Only support add file for now.
>>>>>>> - */
>>>>>>> -
>>>>>>> -int read_inotify(int inotify_fd,
>>>>>>> - struct channel_trace_fd *fd_pairs,
>>>>>>> - struct inotify_watch_array *iwatch_array)
>>>>>>> -{
>>>>>>> - char buf[sizeof(struct inotify_event) + PATH_MAX];
>>>>>>> - char path_channel[PATH_MAX];
>>>>>>> - char path_trace[PATH_MAX];
>>>>>>> - ssize_t len;
>>>>>>> - struct inotify_event *ievent;
>>>>>>> - size_t offset;
>>>>>>> - unsigned int i;
>>>>>>> - int ret;
>>>>>>> - int old_num;
>>>>>>> -
>>>>>>> - offset = 0;
>>>>>>> - len = read(inotify_fd, buf, sizeof(struct inotify_event) +
>>>>>>>
>>>>>> PATH_MAX);
>>>>>>
>>>>>>> - if(len< 0) {
>>>>>>> -
>>>>>>> - if(errno == EAGAIN)
>>>>>>> - return 0; /* another thread got the data before us
>>>>>>>
>>>>>> */
>>>>>>
>>>>>>> -
>>>>>>> - printf("Error in read from inotify FD %s.\n",
>>>>>>>
>>>>>> strerror(len));
>>>>>>
>>>>>>> - return -1;
>>>>>>> - }
>>>>>>> - while(offset< len) {
>>>>>>> - ievent = (struct inotify_event *)&(buf[offset]);
>>>>>>> - for(i=0; i<iwatch_array->num; i++) {
>>>>>>> - if(iwatch_array->elem[i].wd == ievent->wd&&
>>>>>>> - ievent->mask == IN_CREATE) {
>>>>>>> - printf_verbose(
>>>>>>> - "inotify wd %u event mask : %u for
>>>>>>>
>>>>>> %s%s\n",
>>>>>>
>>>>>>> - ievent->wd, ievent->mask,
>>>>>>> - iwatch_array->elem[i].path_channel,
>>>>>>> - ievent->name);
>>>>>>> - old_num = fd_pairs->num_pairs;
>>>>>>> - strcpy(path_channel,
>>>>>>>
>>>>>> iwatch_array->elem[i].path_channel);
>>>>>>
>>>>>>> - strcat(path_channel, ievent->name);
>>>>>>> - strcpy(path_trace,
>>>>>>>
>>>>>> iwatch_array->elem[i].path_trace);
>>>>>>
>>>>>>> - strcat(path_trace, ievent->name);
>>>>>>> - if(ret = open_buffer_file(ievent->name,
>>>>>>>
>>>>>> path_channel,
>>>>>>
>>>>>>> - path_trace, fd_pairs)) {
>>>>>>> - printf("Error opening buffer
>>>>>>>
>>>>>> file\n");
>>>>>>
>>>>>>> - return -1;
>>>>>>> - }
>>>>>>> - if(ret = map_channels(fd_pairs, old_num,
>>>>>>>
>>>>>> fd_pairs->num_pairs)) {
>>>>>>
>>>>>>> - printf("Error mapping channel\n");
>>>>>>> - return -1;
>>>>>>> - }
>>>>>>> -
>>>>>>> - }
>>>>>>> - }
>>>>>>> - offset += sizeof(*ievent) + ievent->len;
>>>>>>> - }
>>>>>>> -}
>>>>>>> -#endif //HAS_INOTIFY
>>>>>>> -
>>>>>>> -/* read_channels
>>>>>>> - *
>>>>>>> - * Thread worker.
>>>>>>> - *
>>>>>>> - * Read the debugfs channels and write them in the paired tracefiles.
>>>>>>> - *
>>>>>>> - * @fd_pairs : paired channels and trace files.
>>>>>>> - *
>>>>>>> - * returns 0 on success, -1 on error.
>>>>>>> - *
>>>>>>> - * Note that the high priority polled channels are consumed first. We
>>>>>>>
>>>>>> then poll
>>>>>>
>>>>>>> - * again to see if these channels are still in priority. Only when no
>>>>>>> - * high priority channel is left, we start reading low priority
>>>>>>>
>>>>>> channels.
>>>>>>
>>>>>>> - *
>>>>>>> - * Note that a channel is considered high priority when the buffer is
>>>>>>>
>>>>>> almost
>>>>>>
>>>>>>> - * full.
>>>>>>> - */
>>>>>>> -
>>>>>>> -int read_channels(unsigned long thread_num, struct channel_trace_fd
>>>>>>>
>>>>>> *fd_pairs,
>>>>>>
>>>>>>> - int inotify_fd, struct inotify_watch_array *iwatch_array)
>>>>>>> -{
>>>>>>> - struct pollfd *pollfd = NULL;
>>>>>>> - int num_pollfd;
>>>>>>> - int i,j;
>>>>>>> - int num_rdy, num_hup;
>>>>>>> - int high_prio;
>>>>>>> - int ret = 0;
>>>>>>> - int inotify_fds;
>>>>>>> - unsigned int old_num;
>>>>>>> -
>>>>>>> -#ifdef HAS_INOTIFY
>>>>>>> - inotify_fds = 1;
>>>>>>> -#else
>>>>>>> - inotify_fds = 0;
>>>>>>> -#endif
>>>>>>> -
>>>>>>> - pthread_rwlock_rdlock(&fd_pairs_lock);
>>>>>>> -
>>>>>>> - /* Start polling the FD. Keep one fd for inotify */
>>>>>>> - pollfd = malloc((inotify_fds + fd_pairs->num_pairs) * sizeof(struct
>>>>>>>
>>>>>> pollfd));
>>>>>>
>>>>>>> -
>>>>>>> -#ifdef HAS_INOTIFY
>>>>>>> - pollfd[0].fd = inotify_fd;
>>>>>>> - pollfd[0].events = POLLIN|POLLPRI;
>>>>>>> -#endif
>>>>>>> -
>>>>>>> - for(i=0;i<fd_pairs->num_pairs;i++) {
>>>>>>> - pollfd[inotify_fds+i].fd = fd_pairs->pair[i].channel;
>>>>>>> - pollfd[inotify_fds+i].events = POLLIN|POLLPRI;
>>>>>>> - }
>>>>>>> - num_pollfd = inotify_fds + fd_pairs->num_pairs;
>>>>>>> -
>>>>>>> -
>>>>>>> - pthread_rwlock_unlock(&fd_pairs_lock);
>>>>>>> -
>>>>>>> - while(1) {
>>>>>>> - high_prio = 0;
>>>>>>> - num_hup = 0;
>>>>>>> -#ifdef DEBUG
>>>>>>> - printf("Press a key for next poll...\n");
>>>>>>> - char buf[1];
>>>>>>> - read(STDIN_FILENO,&buf, 1);
>>>>>>> - printf("Next poll (polling %d fd) :\n", num_pollfd);
>>>>>>> -#endif //DEBUG
>>>>>>> -
>>>>>>> - /* Have we received a signal ? */
>>>>>>> - if(quit_program) break;
>>>>>>> -
>>>>>>> - num_rdy = poll(pollfd, num_pollfd, -1);
>>>>>>> -
>>>>>>> - if(num_rdy == -1) {
>>>>>>> - perror("Poll error");
>>>>>>> - goto free_fd;
>>>>>>> - }
>>>>>>> -
>>>>>>> - printf_verbose("Data received\n");
>>>>>>> -#ifdef HAS_INOTIFY
>>>>>>> - switch(pollfd[0].revents) {
>>>>>>> - case POLLERR:
>>>>>>> - printf_verbose(
>>>>>>> - "Error returned in polling inotify
>>>>>>>
>>>>>> fd %d.\n",
>>>>>>
>>>>>>> - pollfd[0].fd);
>>>>>>> - break;
>>>>>>> - case POLLHUP:
>>>>>>> - printf_verbose(
>>>>>>> - "Polling inotify fd %d tells it has
>>>>>>>
>>>>>> hung up.\n",
>>>>>>
>>>>>>> - pollfd[0].fd);
>>>>>>> - break;
>>>>>>> - case POLLNVAL:
>>>>>>> - printf_verbose(
>>>>>>> - "Polling inotify fd %d tells fd is
>>>>>>>
>>>>>> not open.\n",
>>>>>>
>>>>>>> - pollfd[0].fd);
>>>>>>> - break;
>>>>>>> - case POLLPRI:
>>>>>>> - case POLLIN:
>>>>>>> - printf_verbose(
>>>>>>> - "Polling inotify fd %d : data
>>>>>>>
>>>>>> ready.\n",
>>>>>>
>>>>>>> - pollfd[0].fd);
>>>>>>> -
>>>>>>> - pthread_rwlock_wrlock(&fd_pairs_lock);
>>>>>>> - read_inotify(inotify_fd, fd_pairs,
>>>>>>>
>>>>>> iwatch_array);
>>>>>>
>>>>>>> - pthread_rwlock_unlock(&fd_pairs_lock);
>>>>>>> -
>>>>>>> - break;
>>>>>>> - }
>>>>>>> -#endif
>>>>>>> -
>>>>>>> - for(i=inotify_fds;i<num_pollfd;i++) {
>>>>>>> - switch(pollfd[i].revents) {
>>>>>>> - case POLLERR:
>>>>>>> - printf_verbose(
>>>>>>> - "Error returned in polling
>>>>>>>
>>>>>> fd %d.\n",
>>>>>>
>>>>>>> - pollfd[i].fd);
>>>>>>> - num_hup++;
>>>>>>> - break;
>>>>>>> - case POLLHUP:
>>>>>>> - printf_verbose(
>>>>>>> - "Polling fd %d tells it has
>>>>>>>
>>>>>> hung up.\n",
>>>>>>
>>>>>>> - pollfd[i].fd);
>>>>>>> - num_hup++;
>>>>>>> - break;
>>>>>>> - case POLLNVAL:
>>>>>>> - printf_verbose(
>>>>>>> - "Polling fd %d tells fd is
>>>>>>>
>>>>>> not open.\n",
>>>>>>
>>>>>>> - pollfd[i].fd);
>>>>>>> - num_hup++;
>>>>>>> - break;
>>>>>>> - case POLLPRI:
>>>>>>> -
>>>>>>>
>>>>>> pthread_rwlock_rdlock(&fd_pairs_lock);
>>>>>>
>>>>>>> -
>>>>>>>
>>>>>> if(pthread_mutex_trylock(&fd_pairs->pair[i-inotify_fds].mutex) == 0) {
>>>>>>
>>>>>>> - printf_verbose(
>>>>>>> - "Urgent read on fd
>>>>>>>
>>>>>> %d\n",
>>>>>>
>>>>>>> - pollfd[i].fd);
>>>>>>> - /* Take care of high
>>>>>>>
>>>>>> priority channels first. */
>>>>>>
>>>>>>> - high_prio = 1;
>>>>>>> - /* it's ok to have an
>>>>>>>
>>>>>> unavailable sub-buffer */
>>>>>>
>>>>>>> - ret =
>>>>>>>
>>>>>> read_subbuffer(&fd_pairs->pair[i-inotify_fds]);
>>>>>>
>>>>>>> - if(ret == EAGAIN) ret = 0;
>>>>>>> -
>>>>>>> - ret =
>>>>>>>
>>>>>> pthread_mutex_unlock(&fd_pairs->pair[i-inotify_fds].mutex);
>>>>>>
>>>>>>> - if(ret)
>>>>>>> - printf("Error in
>>>>>>>
>>>>>> mutex unlock : %s\n", strerror(ret));
>>>>>>
>>>>>>> - }
>>>>>>> -
>>>>>>>
>>>>>> pthread_rwlock_unlock(&fd_pairs_lock);
>>>>>>
>>>>>>> - break;
>>>>>>> - }
>>>>>>> - }
>>>>>>> - /* If every buffer FD has hung up, we end the read loop
>>>>>>>
>>>>>> here */
>>>>>>
>>>>>>> - if(num_hup == num_pollfd - inotify_fds) break;
>>>>>>> -
>>>>>>> - if(!high_prio) {
>>>>>>> - for(i=inotify_fds;i<num_pollfd;i++) {
>>>>>>> - switch(pollfd[i].revents) {
>>>>>>> - case POLLIN:
>>>>>>> -
>>>>>>>
>>>>>> pthread_rwlock_rdlock(&fd_pairs_lock);
>>>>>>
>>>>>>> -
>>>>>>>
>>>>>> if(pthread_mutex_trylock(&fd_pairs->pair[i-inotify_fds].mutex) == 0) {
>>>>>>
>>>>>>> - /* Take care of low
>>>>>>>
>>>>>> priority channels. */
>>>>>>
>>>>>>> - printf_verbose(
>>>>>>> - "Normal
>>>>>>>
>>>>>> read on fd %d\n",
>>>>>>
>>>>>>> -
>>>>>>>
>>>>>> pollfd[i].fd);
>>>>>>
>>>>>>> - /* it's ok to have
>>>>>>>
>>>>>> an unavailable subbuffer */
>>>>>>
>>>>>>> - ret =
>>>>>>>
>>>>>> read_subbuffer(&fd_pairs->pair[i-inotify_fds]);
>>>>>>
>>>>>>> - if(ret == EAGAIN)
>>>>>>>
>>>>>> ret = 0;
>>>>>>
>>>>>>> -
>>>>>>> - ret =
>>>>>>>
>>>>>> pthread_mutex_unlock(&fd_pairs->pair[i-inotify_fds].mutex);
>>>>>>
>>>>>>> - if(ret)
>>>>>>> -
>>>>>>>
>>>>>> printf("Error in mutex unlock : %s\n", strerror(ret));
>>>>>>
>>>>>>> - }
>>>>>>> -
>>>>>>>
>>>>>> pthread_rwlock_unlock(&fd_pairs_lock);
>>>>>>
>>>>>>> - break;
>>>>>>> - }
>>>>>>> - }
>>>>>>> - }
>>>>>>> -
>>>>>>> - /* Update pollfd array if an entry was added to fd_pairs */
>>>>>>> - pthread_rwlock_rdlock(&fd_pairs_lock);
>>>>>>> - if((inotify_fds + fd_pairs->num_pairs) != num_pollfd) {
>>>>>>> - pollfd = realloc(pollfd,
>>>>>>> - (inotify_fds + fd_pairs->num_pairs)
>>>>>>>
>>>>>> * sizeof(struct pollfd));
>>>>>>
>>>>>>> -
>>>>>>>
>>>>>> for(i=num_pollfd-inotify_fds;i<fd_pairs->num_pairs;i++) {
>>>>>>
>>>>>>> - pollfd[inotify_fds+i].fd =
>>>>>>>
>>>>>> fd_pairs->pair[i].channel;
>>>>>>
>>>>>>> - pollfd[inotify_fds+i].events =
>>>>>>>
>>>>>> POLLIN|POLLPRI;
>>>>>>
>>>>>>> - }
>>>>>>> - num_pollfd = fd_pairs->num_pairs + inotify_fds;
>>>>>>> - }
>>>>>>> - pthread_rwlock_unlock(&fd_pairs_lock);
>>>>>>> -
>>>>>>> - /* NB: If the fd_pairs structure is updated by another
>>>>>>>
>>>>>> thread from this
>>>>>>
>>>>>>> - * point forward, the current thread will wait in the
>>>>>>>
>>>>>> poll without
>>>>>>
>>>>>>> - * monitoring the new channel. However, this thread
>>>>>>>
>>>>>> will add the
>>>>>>
>>>>>>> - * new channel on next poll (and this should not take
>>>>>>>
>>>>>> too much time
>>>>>>
>>>>>>> - * on a loaded system).
>>>>>>> - *
>>>>>>> - * This event is quite unlikely and can only occur if a
>>>>>>>
>>>>>> CPU is
>>>>>>
>>>>>>> - * hot-plugged while multple lttd threads are running.
>>>>>>> - */
>>>>>>> - }
>>>>>>> -
>>>>>>> -free_fd:
>>>>>>> - free(pollfd);
>>>>>>> -
>>>>>>> -end:
>>>>>>> - return ret;
>>>>>>> -}
>>>>>>> -
>>>>>>> -
>>>>>>> -void close_channel_trace_pairs(struct channel_trace_fd *fd_pairs, int
>>>>>>>
>>>>>> inotify_fd,
>>>>>>
>>>>>>> - struct inotify_watch_array *iwatch_array)
>>>>>>> -{
>>>>>>> - int i;
>>>>>>> +int on_new_thread(struct liblttd_callbacks *data, unsigned long
>>>>>>>
>>>>>> thread_num) {
>>>>>>
>>>>>>> int ret;
>>>>>>> -
>>>>>>> - for(i=0;i<fd_pairs->num_pairs;i++) {
>>>>>>> - ret = close(fd_pairs->pair[i].channel);
>>>>>>> - if(ret == -1) perror("Close error on channel");
>>>>>>> - ret = close(fd_pairs->pair[i].trace);
>>>>>>> - if(ret == -1) perror("Close error on trace");
>>>>>>> - }
>>>>>>> - free(fd_pairs->pair);
>>>>>>> - free(iwatch_array->elem);
>>>>>>> -}
>>>>>>> -
>>>>>>> -/* Thread worker */
>>>>>>> -void * thread_main(void *arg)
>>>>>>> -{
>>>>>>> - long ret;
>>>>>>> - unsigned long thread_num = (unsigned long)arg;
>>>>>>> -
>>>>>>> ret = pipe(thread_pipe);
>>>>>>> if (ret< 0) {
>>>>>>> perror("Error creating pipe");
>>>>>>> - return (void*)ret;
>>>>>>> + return ret;
>>>>>>> }
>>>>>>> - ret = read_channels(thread_num,&fd_pairs, inotify_fd,
>>>>>>>
>>>>>> &inotify_watch_array);
>>>>>>
>>>>>>> - close(thread_pipe[0]); /* close read end */
>>>>>>> - close(thread_pipe[1]); /* close write end */
>>>>>>> - return (void*)ret;
>>>>>>> + return 0;
>>>>>>> }
>>>>>>>
>>>>>>> -
>>>>>>> -int channels_init()
>>>>>>> -{
>>>>>>> - int ret = 0;
>>>>>>> -
>>>>>>> - inotify_fd = inotify_init();
>>>>>>> - fcntl(inotify_fd, F_SETFL, O_NONBLOCK);
>>>>>>> -
>>>>>>> - if(ret = open_channel_trace_pairs(channel_name, trace_name,
>>>>>>>
>>>>>> &fd_pairs,
>>>>>>
>>>>>>> -&inotify_fd,&inotify_watch_array))
>>>>>>> - goto close_channel;
>>>>>>> - if (fd_pairs.num_pairs == 0) {
>>>>>>> - printf("No channel available for reading, exiting\n");
>>>>>>> - ret = -ENOENT;
>>>>>>> - goto close_channel;
>>>>>>> - }
>>>>>>> - if(ret = map_channels(&fd_pairs, 0, fd_pairs.num_pairs))
>>>>>>> - goto close_channel;
>>>>>>> +int on_close_thread(struct liblttd_callbacks *data, unsigned long
>>>>>>>
>>>>>> thread_num) {
>>>>>>
>>>>>>> + close(thread_pipe[0]); /* close read end */
>>>>>>> + close(thread_pipe[1]); /* close write end */
>>>>>>> return 0;
>>>>>>> -
>>>>>>> -close_channel:
>>>>>>> - close_channel_trace_pairs(&fd_pairs, inotify_fd,
>>>>>>>
>>>>>> &inotify_watch_array);
>>>>>>
>>>>>>> - if(inotify_fd>= 0)
>>>>>>> - close(inotify_fd);
>>>>>>> - return ret;
>>>>>>> }
>>>>>>>
>>>>>>> -
>>>>>>> int main(int argc, char ** argv)
>>>>>>> {
>>>>>>> int ret = 0;
>>>>>>> struct sigaction act;
>>>>>>> - pthread_t *tids;
>>>>>>> - unsigned long i;
>>>>>>> - void *tret;
>>>>>>> -
>>>>>>> +
>>>>>>> + struct liblttd_callbacks callbacks = {
>>>>>>> + lttd_on_open_channel,
>>>>>>> + lttd_on_close_channel,
>>>>>>> + lttd_on_new_channels_folder,
>>>>>>> + lttd_on_read_subbuffer,
>>>>>>> + NULL,
>>>>>>> + on_new_thread,
>>>>>>> + on_close_thread,
>>>>>>> + NULL
>>>>>>> + };
>>>>>>> +
>>>>>>> ret = parse_arguments(argc, argv);
>>>>>>>
>>>>>>> if(ret != 0) show_arguments();
>>>>>>> @@ -983,9 +344,6 @@ int main(int argc, char ** argv)
>>>>>>> sigaction(SIGQUIT,&act, NULL);
>>>>>>> sigaction(SIGINT,&act, NULL);
>>>>>>>
>>>>>>> - if(ret = channels_init())
>>>>>>> - return ret;
>>>>>>> -
>>>>>>> if(daemon_mode) {
>>>>>>> ret = daemon(0, 0);
>>>>>>>
>>>>>>> @@ -995,33 +353,13 @@ int main(int argc, char ** argv)
>>>>>>> }
>>>>>>> }
>>>>>>>
>>>>>>> - tids = malloc(sizeof(pthread_t) * num_threads);
>>>>>>> - for(i=0; i<num_threads; i++) {
>>>>>>> -
>>>>>>> - ret = pthread_create(&tids[i], NULL, thread_main,
>>>>>>>
>>>>>> (void*)i);
>>>>>>
>>>>>>> - if(ret) {
>>>>>>> - perror("Error creating thread");
>>>>>>> - break;
>>>>>>> - }
>>>>>>> - }
>>>>>>> + strncpy(path_trace, trace_name, PATH_MAX-1);
>>>>>>> + path_trace_len = strlen(path_trace);
>>>>>>> + end_path_trace = path_trace + path_trace_len;
>>>>>>>
>>>>>>> - for(i=0; i<num_threads; i++) {
>>>>>>> - ret = pthread_join(tids[i],&tret);
>>>>>>> - if(ret) {
>>>>>>> - perror("Error joining thread");
>>>>>>> - break;
>>>>>>> - }
>>>>>>> - if((long)tret != 0) {
>>>>>>> - printf("Error %s occured in thread %u\n",
>>>>>>> - strerror((long)tret), i);
>>>>>>> - }
>>>>>>> - }
>>>>>>> + liblttd_start(channel_name, num_threads, dump_flight_only,
>>>>>>>
>>>>>> dump_normal_only,
>>>>>>
>>>>>>> + verbose_mode,&callbacks);
>>>>>>>
>>>>>>> - free(tids);
>>>>>>> - ret = unmap_channels(&fd_pairs);
>>>>>>> - close_channel_trace_pairs(&fd_pairs, inotify_fd,
>>>>>>>
>>>>>> &inotify_watch_array);
>>>>>>
>>>>>>> - if(inotify_fd>= 0)
>>>>>>> - close(inotify_fd);
>>>>>>> -
>>>>>>> return ret;
>>>>>>> }
>>>>>>> +
>>>>>>>
>>>>>>
>>>>>> --
>>>>>> Mathieu Desnoyers
>>>>>> OpenPGP key fingerprint: 8CD5 52C3 8E3C 4140 715F BA06 3F25 A8FE 3BAE 9A68
>>>>>>
>>>>>>
>>>>
>>>>> diff --git a/Makefile.am b/Makefile.am
>>>>> index 8f9974d..06500fd 100644
>>>>> --- a/Makefile.am
>>>>> +++ b/Makefile.am
>>>>> @@ -1,2 +1,2 @@
>>>>> -SUBDIRS = liblttctl lttctl lttd specs
>>>>> +SUBDIRS = liblttctl lttctl liblttd lttd specs
>>>>>
>>>>> diff --git a/configure.in b/configure.in
>>>>> index d67e7d4..a992cd8 100644
>>>>> --- a/configure.in
>>>>> +++ b/configure.in
>>>>> @@ -76,8 +76,10 @@ DEFAULT_INCLUDES="-I\$(top_srcdir) -I\$(top_builddir)"
>>>>> #AC_SUBST(CPPFLAGS)
>>>>>
>>>>> lttctlincludedir="${includedir}/liblttctl"
>>>>> +liblttdincludedir="${includedir}/liblttd"
>>>>>
>>>>> AC_SUBST(lttctlincludedir)
>>>>> +AC_SUBST(liblttdincludedir)
>>>>> AC_SUBST(UTIL_LIBS)
>>>>> AC_SUBST(THREAD_LIBS)
>>>>> AC_SUBST(DEFAULT_INCLUDES)
>>>>> @@ -85,6 +87,7 @@ AC_SUBST(DEFAULT_INCLUDES)
>>>>> AC_CONFIG_FILES([Makefile
>>>>> liblttctl/Makefile
>>>>> lttctl/Makefile
>>>>> + liblttd/Makefile
>>>>> lttd/Makefile
>>>>> specs/Makefile])
>>>>> AC_OUTPUT
>>>>> diff --git a/liblttd/Makefile.am b/liblttd/Makefile.am
>>>>> new file mode 100644
>>>>> index 0000000..3c1eeda
>>>>> --- /dev/null
>>>>> +++ b/liblttd/Makefile.am
>>>>> @@ -0,0 +1,7 @@
>>>>> +
>>>>> +
>>>>> +lib_LTLIBRARIES = liblttd.la
>>>>> +liblttd_la_SOURCES = liblttd.c
>>>>> +
>>>>> +liblttdinclude_HEADERS = \
>>>>> + liblttd.h
>>>>> diff --git a/liblttd/liblttd.c b/liblttd/liblttd.c
>>>>> new file mode 100644
>>>>> index 0000000..0f0e5b5
>>>>> --- /dev/null
>>>>> +++ b/liblttd/liblttd.c
>>>>> @@ -0,0 +1,747 @@
>>>>> +/* lttd
>>>>> + *
>>>>> + * Linux Trace Toolkit Daemon
>>>>> + *
>>>>> + * This is a simple daemon that reads a few relay+debugfs channels and save
>>>>> + * them in a trace.
>>>>> + *
>>>>> + * CPU hot-plugging is supported using inotify.
>>>>> + *
>>>>> + * Copyright 2005 -
>>>>> + * Mathieu Desnoyers<mathieu.desnoyers at polymtl.ca>
>>>>> + */
>>>>> +
>>>>> +#ifdef HAVE_CONFIG_H
>>>>> +#include<config.h>
>>>>> +#endif
>>>>> +
>>>>> +#include "liblttd.h"
>>>>> +
>>>>> +#define _REENTRANT
>>>>> +#define _GNU_SOURCE
>>>>> +#include<features.h>
>>>>> +#include<stdio.h>
>>>>> +#include<unistd.h>
>>>>> +#include<errno.h>
>>>>> +#include<sys/types.h>
>>>>> +#include<stdlib.h>
>>>>> +#include<dirent.h>
>>>>> +#include<string.h>
>>>>> +#include<fcntl.h>
>>>>> +#include<sys/stat.h>
>>>>> +#include<sys/poll.h>
>>>>> +#include<sys/mman.h>
>>>>> +#include<sys/syscall.h>
>>>>> +#include<unistd.h>
>>>>> +#include<asm/ioctls.h>
>>>>> +
>>>>> +#include<linux/version.h>
>>>>> +
>>>>> +/* Relayfs IOCTL */
>>>>> +#include<asm/ioctl.h>
>>>>> +#include<asm/types.h>
>>>>> +
>>>>> +/* Get the next sub buffer that can be read. */
>>>>> +#define RELAY_GET_SB _IOR(0xF5, 0x00,__u32)
>>>>> +/* Release the oldest reserved (by "get") sub buffer. */
>>>>> +#define RELAY_PUT_SB _IOW(0xF5, 0x01,__u32)
>>>>> +/* returns the number of sub buffers in the per cpu channel. */
>>>>> +#define RELAY_GET_N_SB _IOR(0xF5, 0x02,__u32)
>>>>> +/* returns the size of the current sub buffer. */
>>>>> +#define RELAY_GET_SB_SIZE _IOR(0xF5, 0x03, __u32)
>>>>> +/* returns the size of data to consume in the current sub-buffer. */
>>>>> +#define RELAY_GET_MAX_SB_SIZE _IOR(0xF5, 0x04, __u32)
>>>>> +
>>>>> +
>>>>> +#if LINUX_VERSION_CODE>= KERNEL_VERSION(2,6,14)
>>>>> +#include<sys/inotify.h>
>>>>> +
>>>>> +#define HAS_INOTIFY
>>>>> +#else
>>>>> +static inline int inotify_init (void)
>>>>> +{
>>>>> + return -1;
>>>>> +}
>>>>> +
>>>>> +static inline int inotify_add_watch (int fd, const char *name, __u32 mask)
>>>>> +{
>>>>> + return 0;
>>>>> +}
>>>>> +
>>>>> +static inline int inotify_rm_watch (int fd, __u32 wd)
>>>>> +{
>>>>> + return 0;
>>>>> +}
>>>>> +#undef HAS_INOTIFY
>>>>> +#endif
>>>>> +
>>>>> +struct liblttd_callbacks *callbacks;
>>>>> +
>>>>> +struct channel_trace_fd {
>>>>> + struct fd_pair *pair;
>>>>> + int num_pairs;
>>>>> +};
>>>>> +
>>>>> +struct inotify_watch {
>>>>> + int wd;
>>>>> + char path_channel[PATH_MAX];
>>>>> + char *base_path_channel;
>>>>> +};
>>>>> +
>>>>> +struct inotify_watch_array {
>>>>> + struct inotify_watch *elem;
>>>>> + int num;
>>>>> +};
>>>>> +
>>>>> +struct channel_trace_fd fd_pairs = { NULL, 0 };
>>>>> +int inotify_fd = -1;
>>>>> +struct inotify_watch_array inotify_watch_array = { NULL, 0 };
>>>>> +
>>>>> +/* protects fd_pairs and inotify_watch_array */
>>>>> +pthread_rwlock_t fd_pairs_lock = PTHREAD_RWLOCK_INITIALIZER;
>>>>> +
>>>>> +static char *channel_name = NULL;
>>>>> +static unsigned long num_threads = 1;
>>>>> +volatile static int quit_program = 0; /* For signal handler */
>>>>> +static int dump_flight_only = 0;
>>>>> +static int dump_normal_only = 0;
>>>>> +static int verbose_mode = 0;
>>>>> +
>>>>> +#define printf_verbose(fmt, args...) \
>>>>> + do { \
>>>>> + if (verbose_mode) \
>>>>> + printf(fmt, ##args); \
>>>>> + } while (0)
>>>>> +
>>>>> +
>>>>> +int open_buffer_file(char *filename, char *path_channel,
>>>>> + char *base_path_channel, struct channel_trace_fd *fd_pairs)
>>>>> +{
>>>>> + int open_ret = 0;
>>>>> + int ret = 0;
>>>>> +
>>>>> + if(strncmp(filename, "flight-", sizeof("flight-")-1) != 0) {
>>>>> + if(dump_flight_only) {
>>>>> + printf_verbose("Skipping normal channel %s\n",
>>>>> + path_channel);
>>>>> + return 0;
>>>>> + }
>>>>> + } else {
>>>>> + if(dump_normal_only) {
>>>>> + printf_verbose("Skipping flight channel %s\n",
>>>>> + path_channel);
>>>>> + return 0;
>>>>> + }
>>>>> + }
>>>>> + printf_verbose("Opening file.\n");
>>>>> +
>>>>> + fd_pairs->pair = realloc(fd_pairs->pair,
>>>>> + ++fd_pairs->num_pairs * sizeof(struct fd_pair));
>>>>> +
>>>>> + /* Open the channel in read mode */
>>>>> + fd_pairs->pair[fd_pairs->num_pairs-1].channel =
>>>>> + open(path_channel, O_RDONLY | O_NONBLOCK);
>>>>> + if(fd_pairs->pair[fd_pairs->num_pairs-1].channel == -1) {
>>>>> + perror(path_channel);
>>>>> + fd_pairs->num_pairs--;
>>>>> + return 0; /* continue */
>>>>> + }
>>>>> +
>>>>> + if(callbacks->on_open_channel) ret = callbacks->on_open_channel(
>>>>> + callbacks,&fd_pairs->pair[fd_pairs->num_pairs-1],
>>>>> + base_path_channel);
>>>>> +
>>>>> + if(ret != 0) {
>>>>> + open_ret = -1;
>>>>> + close(fd_pairs->pair[fd_pairs->num_pairs-1].channel);
>>>>> + fd_pairs->num_pairs--;
>>>>> + goto end;
>>>>> + }
>>>>> +
>>>>> +end:
>>>>> + return open_ret;
>>>>> +}
>>>>> +
>>>>> +int open_channel_trace_pairs(char *subchannel_name,
>>>>> + char *base_subchannel_name,
>>>>> + struct channel_trace_fd *fd_pairs, int *inotify_fd,
>>>>> + struct inotify_watch_array *iwatch_array)
>>>>> +{
>>>>> + DIR *channel_dir = opendir(subchannel_name);
>>>>> + struct dirent *entry;
>>>>> + struct stat stat_buf;
>>>>> + int ret;
>>>>> + char path_channel[PATH_MAX];
>>>>> + int path_channel_len;
>>>>> + char *path_channel_ptr;
>>>>> + char *base_subchannel_ptr;
>>>>> +
>>>>> + int open_ret = 0;
>>>>> +
>>>>> + if(channel_dir == NULL) {
>>>>> + perror(subchannel_name);
>>>>> + open_ret = ENOENT;
>>>>> + goto end;
>>>>> + }
>>>>> +
>>>>> + printf_verbose("Calling on new channels folder");
>>>>> + if(callbacks->on_new_channels_folder) ret = callbacks->
>>>>> + on_new_channels_folder(callbacks,
>>>>> + base_subchannel_name);
>>>>> + if(ret == -1) {
>>>>> + open_ret = -1;
>>>>> + goto end;
>>>>> + }
>>>>> +
>>>>> + strncpy(path_channel, subchannel_name, PATH_MAX-1);
>>>>> + path_channel_len = strlen(path_channel);
>>>>> + path_channel[path_channel_len] = '/';
>>>>> + path_channel_len++;
>>>>> + path_channel_ptr = path_channel + path_channel_len;
>>>>> + base_subchannel_ptr = path_channel +
>>>>> + (base_subchannel_name - subchannel_name);
>>>>> +
>>>>> +#ifdef HAS_INOTIFY
>>>>> + iwatch_array->elem = realloc(iwatch_array->elem,
>>>>> + ++iwatch_array->num * sizeof(struct inotify_watch));
>>>>> +
>>>>> + printf_verbose("Adding inotify for channel %s\n", path_channel);
>>>>> + iwatch_array->elem[iwatch_array->num-1].wd = inotify_add_watch(*inotify_fd, path_channel, IN_CREATE);
>>>>> + strcpy(iwatch_array->elem[iwatch_array->num-1].path_channel, path_channel);
>>>>> + iwatch_array->elem[iwatch_array->num-1].base_path_channel =
>>>>> + iwatch_array->elem[iwatch_array->num-1].path_channel +
>>>>> + (base_subchannel_name - subchannel_name);
>>>>> + printf_verbose("Added inotify for channel %s, wd %u\n",
>>>>> + iwatch_array->elem[iwatch_array->num-1].path_channel,
>>>>> + iwatch_array->elem[iwatch_array->num-1].wd);
>>>>> +#endif
>>>>> +
>>>>> + while((entry = readdir(channel_dir)) != NULL) {
>>>>> +
>>>>> + if(entry->d_name[0] == '.') continue;
>>>>> +
>>>>> + strncpy(path_channel_ptr, entry->d_name, PATH_MAX - path_channel_len);
>>>>> +
>>>>> + ret = stat(path_channel,&stat_buf);
>>>>> + if(ret == -1) {
>>>>> + perror(path_channel);
>>>>> + continue;
>>>>> + }
>>>>> +
>>>>> + printf_verbose("Channel file : %s\n", path_channel);
>>>>> +
>>>>> + if(S_ISDIR(stat_buf.st_mode)) {
>>>>> +
>>>>> + printf_verbose("Entering channel subdirectory...\n");
>>>>> + ret = open_channel_trace_pairs(path_channel, base_subchannel_ptr, fd_pairs,
>>>>> + inotify_fd, iwatch_array);
>>>>> + if(ret< 0) continue;
>>>>> + } else if(S_ISREG(stat_buf.st_mode)) {
>>>>> + open_ret = open_buffer_file(entry->d_name, path_channel, base_subchannel_ptr,
>>>>> + fd_pairs);
>>>>> + if(open_ret)
>>>>> + goto end;
>>>>> + }
>>>>> + }
>>>>> +
>>>>> +end:
>>>>> + closedir(channel_dir);
>>>>> +
>>>>> + return open_ret;
>>>>> +}
>>>>> +
>>>>> +
>>>>> +int read_subbuffer(struct fd_pair *pair)
>>>>> +{
>>>>> + unsigned int consumed_old, len;
>>>>> + int err;
>>>>> + long ret;
>>>>> + off_t offset;
>>>>> +
>>>>> +
>>>>> + err = ioctl(pair->channel, RELAY_GET_SB,&consumed_old);
>>>>> + printf_verbose("cookie : %u\n", consumed_old);
>>>>> + if(err != 0) {
>>>>> + ret = errno;
>>>>> + perror("Reserving sub buffer failed (everything is normal, it is due to concurrency)");
>>>>> + goto get_error;
>>>>> + }
>>>>> +
>>>>> + err = ioctl(pair->channel, RELAY_GET_SB_SIZE,&len);
>>>>> + if(err != 0) {
>>>>> + ret = errno;
>>>>> + perror("Getting sub-buffer len failed.");
>>>>> + goto get_error;
>>>>> + }
>>>>> +
>>>>> + if(callbacks->on_read_subbuffer) ret = callbacks->on_read_subbuffer(
>>>>> + callbacks, pair, len);
>>>>> +
>>>>> +write_error:
>>>>> + ret = 0;
>>>>> + err = ioctl(pair->channel, RELAY_PUT_SB,&consumed_old);
>>>>> + if(err != 0) {
>>>>> + ret = errno;
>>>>> + if(errno == EFAULT) {
>>>>> + perror("Error in unreserving sub buffer\n");
>>>>> + } else if(errno == EIO) {
>>>>> + /* Should never happen with newer LTTng versions */
>>>>> + perror("Reader has been pushed by the writer, last sub-buffer corrupted.");
>>>>> + }
>>>>> + goto get_error;
>>>>> + }
>>>>> +
>>>>> +get_error:
>>>>> + return ret;
>>>>> +}
>>>>> +
>>>>> +
>>>>> +int map_channels(struct channel_trace_fd *fd_pairs,
>>>>> + int idx_begin, int idx_end)
>>>>> +{
>>>>> + int i,j;
>>>>> + int ret=0;
>>>>> +
>>>>> + if(fd_pairs->num_pairs<= 0) {
>>>>> + printf("No channel to read\n");
>>>>> + goto end;
>>>>> + }
>>>>> +
>>>>> + /* Get the subbuf sizes and number */
>>>>> +
>>>>> + for(i=idx_begin;i<idx_end;i++) {
>>>>> + struct fd_pair *pair =&fd_pairs->pair[i];
>>>>> +
>>>>> + ret = ioctl(pair->channel, RELAY_GET_N_SB,&pair->n_sb);
>>>>> + if(ret != 0) {
>>>>> + perror("Error in getting the number of sub-buffers");
>>>>> + goto end;
>>>>> + }
>>>>> + ret = ioctl(pair->channel, RELAY_GET_MAX_SB_SIZE,
>>>>> + &pair->max_sb_size);
>>>>> + if(ret != 0) {
>>>>> + perror("Error in getting the max sub-buffer size");
>>>>> + goto end;
>>>>> + }
>>>>> + ret = pthread_mutex_init(&pair->mutex, NULL); /* Fast mutex */
>>>>> + if(ret != 0) {
>>>>> + perror("Error in mutex init");
>>>>> + goto end;
>>>>> + }
>>>>> + }
>>>>> +
>>>>> +end:
>>>>> + return ret;
>>>>> +}
>>>>> +
>>>>> +int unmap_channels(struct channel_trace_fd *fd_pairs)
>>>>> +{
>>>>> + int j;
>>>>> + int ret=0;
>>>>> +
>>>>> + /* Munmap each FD */
>>>>> + for(j=0;j<fd_pairs->num_pairs;j++) {
>>>>> + struct fd_pair *pair =&fd_pairs->pair[j];
>>>>> + int err_ret;
>>>>> +
>>>>> + err_ret = pthread_mutex_destroy(&pair->mutex);
>>>>> + if(err_ret != 0) {
>>>>> + perror("Error in mutex destroy");
>>>>> + }
>>>>> + ret |= err_ret;
>>>>> + }
>>>>> +
>>>>> + return ret;
>>>>> +}
>>>>> +
>>>>> +#ifdef HAS_INOTIFY
>>>>> +/* Inotify event arrived.
>>>>> + *
>>>>> + * Only support add file for now.
>>>>> + */
>>>>> +
>>>>> +int read_inotify(int inotify_fd,
>>>>> + struct channel_trace_fd *fd_pairs,
>>>>> + struct inotify_watch_array *iwatch_array)
>>>>> +{
>>>>> + char buf[sizeof(struct inotify_event) + PATH_MAX];
>>>>> + char path_channel[PATH_MAX];
>>>>> + ssize_t len;
>>>>> + struct inotify_event *ievent;
>>>>> + size_t offset;
>>>>> + unsigned int i;
>>>>> + int ret;
>>>>> + int old_num;
>>>>> +
>>>>> + offset = 0;
>>>>> + len = read(inotify_fd, buf, sizeof(struct inotify_event) + PATH_MAX);
>>>>> + if(len< 0) {
>>>>> +
>>>>> + if(errno == EAGAIN)
>>>>> + return 0; /* another thread got the data before us */
>>>>> +
>>>>> + printf("Error in read from inotify FD %s.\n", strerror(len));
>>>>> + return -1;
>>>>> + }
>>>>> + while(offset< len) {
>>>>> + ievent = (struct inotify_event *)&(buf[offset]);
>>>>> + for(i=0; i<iwatch_array->num; i++) {
>>>>> + if(iwatch_array->elem[i].wd == ievent->wd&&
>>>>> + ievent->mask == IN_CREATE) {
>>>>> + printf_verbose(
>>>>> + "inotify wd %u event mask : %u for %s%s\n",
>>>>> + ievent->wd, ievent->mask,
>>>>> + iwatch_array->elem[i].path_channel,
>>>>> + ievent->name);
>>>>> + old_num = fd_pairs->num_pairs;
>>>>> + strcpy(path_channel, iwatch_array->elem[i].path_channel);
>>>>> + strcat(path_channel, ievent->name);
>>>>> + if(ret = open_buffer_file(ievent->name, path_channel,
>>>>> + path_channel + (iwatch_array->elem[i].base_path_channel -
>>>>> + iwatch_array->elem[i].path_channel), fd_pairs)) {
>>>>> + printf("Error opening buffer file\n");
>>>>> + return -1;
>>>>> + }
>>>>> + if(ret = map_channels(fd_pairs, old_num, fd_pairs->num_pairs)) {
>>>>> + printf("Error mapping channel\n");
>>>>> + return -1;
>>>>> + }
>>>>> +
>>>>> + }
>>>>> + }
>>>>> + offset += sizeof(*ievent) + ievent->len;
>>>>> + }
>>>>> +}
>>>>> +#endif //HAS_INOTIFY
>>>>> +
>>>>> +/* read_channels
>>>>> + *
>>>>> + * Thread worker.
>>>>> + *
>>>>> + * Read the debugfs channels and write them in the paired tracefiles.
>>>>> + *
>>>>> + * @fd_pairs : paired channels and trace files.
>>>>> + *
>>>>> + * returns 0 on success, -1 on error.
>>>>> + *
>>>>> + * Note that the high priority polled channels are consumed first. We then poll
>>>>> + * again to see if these channels are still in priority. Only when no
>>>>> + * high priority channel is left, we start reading low priority channels.
>>>>> + *
>>>>> + * Note that a channel is considered high priority when the buffer is almost
>>>>> + * full.
>>>>> + */
>>>>> +
>>>>> +int read_channels(unsigned long thread_num, struct channel_trace_fd *fd_pairs,
>>>>> + int inotify_fd, struct inotify_watch_array *iwatch_array)
>>>>> +{
>>>>> + struct pollfd *pollfd = NULL;
>>>>> + int num_pollfd;
>>>>> + int i,j;
>>>>> + int num_rdy, num_hup;
>>>>> + int high_prio;
>>>>> + int ret = 0;
>>>>> + int inotify_fds;
>>>>> + unsigned int old_num;
>>>>> +
>>>>> +#ifdef HAS_INOTIFY
>>>>> + inotify_fds = 1;
>>>>> +#else
>>>>> + inotify_fds = 0;
>>>>> +#endif
>>>>> +
>>>>> + pthread_rwlock_rdlock(&fd_pairs_lock);
>>>>> +
>>>>> + /* Start polling the FD. Keep one fd for inotify */
>>>>> + pollfd = malloc((inotify_fds + fd_pairs->num_pairs) * sizeof(struct pollfd));
>>>>> +
>>>>> +#ifdef HAS_INOTIFY
>>>>> + pollfd[0].fd = inotify_fd;
>>>>> + pollfd[0].events = POLLIN|POLLPRI;
>>>>> +#endif
>>>>> +
>>>>> + for(i=0;i<fd_pairs->num_pairs;i++) {
>>>>> + pollfd[inotify_fds+i].fd = fd_pairs->pair[i].channel;
>>>>> + pollfd[inotify_fds+i].events = POLLIN|POLLPRI;
>>>>> + }
>>>>> + num_pollfd = inotify_fds + fd_pairs->num_pairs;
>>>>> +
>>>>> +
>>>>> + pthread_rwlock_unlock(&fd_pairs_lock);
>>>>> +
>>>>> + while(1) {
>>>>> + high_prio = 0;
>>>>> + num_hup = 0;
>>>>> +#ifdef DEBUG
>>>>> + printf("Press a key for next poll...\n");
>>>>> + char buf[1];
>>>>> + read(STDIN_FILENO,&buf, 1);
>>>>> + printf("Next poll (polling %d fd) :\n", num_pollfd);
>>>>> +#endif //DEBUG
>>>>> +
>>>>> + /* Have we received a signal ? */
>>>>> + if(quit_program) break;
>>>>> +
>>>>> + num_rdy = poll(pollfd, num_pollfd, -1);
>>>>> +
>>>>> + if(num_rdy == -1) {
>>>>> + perror("Poll error");
>>>>> + goto free_fd;
>>>>> + }
>>>>> +
>>>>> + printf_verbose("Data received\n");
>>>>> +#ifdef HAS_INOTIFY
>>>>> + switch(pollfd[0].revents) {
>>>>> + case POLLERR:
>>>>> + printf_verbose(
>>>>> + "Error returned in polling inotify fd %d.\n",
>>>>> + pollfd[0].fd);
>>>>> + break;
>>>>> + case POLLHUP:
>>>>> + printf_verbose(
>>>>> + "Polling inotify fd %d tells it has hung up.\n",
>>>>> + pollfd[0].fd);
>>>>> + break;
>>>>> + case POLLNVAL:
>>>>> + printf_verbose(
>>>>> + "Polling inotify fd %d tells fd is not open.\n",
>>>>> + pollfd[0].fd);
>>>>> + break;
>>>>> + case POLLPRI:
>>>>> + case POLLIN:
>>>>> + printf_verbose(
>>>>> + "Polling inotify fd %d : data ready.\n",
>>>>> + pollfd[0].fd);
>>>>> +
>>>>> + pthread_rwlock_wrlock(&fd_pairs_lock);
>>>>> + read_inotify(inotify_fd, fd_pairs, iwatch_array);
>>>>> + pthread_rwlock_unlock(&fd_pairs_lock);
>>>>> +
>>>>> + break;
>>>>> + }
>>>>> +#endif
>>>>> +
>>>>> + for(i=inotify_fds;i<num_pollfd;i++) {
>>>>> + switch(pollfd[i].revents) {
>>>>> + case POLLERR:
>>>>> + printf_verbose(
>>>>> + "Error returned in polling fd %d.\n",
>>>>> + pollfd[i].fd);
>>>>> + num_hup++;
>>>>> + break;
>>>>> + case POLLHUP:
>>>>> + printf_verbose(
>>>>> + "Polling fd %d tells it has hung up.\n",
>>>>> + pollfd[i].fd);
>>>>> + num_hup++;
>>>>> + break;
>>>>> + case POLLNVAL:
>>>>> + printf_verbose(
>>>>> + "Polling fd %d tells fd is not open.\n",
>>>>> + pollfd[i].fd);
>>>>> + num_hup++;
>>>>> + break;
>>>>> + case POLLPRI:
>>>>> + pthread_rwlock_rdlock(&fd_pairs_lock);
>>>>> + if(pthread_mutex_trylock(&fd_pairs->pair[i-inotify_fds].mutex) == 0) {
>>>>> + printf_verbose(
>>>>> + "Urgent read on fd %d\n",
>>>>> + pollfd[i].fd);
>>>>> + /* Take care of high priority channels first. */
>>>>> + high_prio = 1;
>>>>> + /* it's ok to have an unavailable sub-buffer */
>>>>> + ret = read_subbuffer(&fd_pairs->pair[i-inotify_fds]);
>>>>> + if(ret == EAGAIN) ret = 0;
>>>>> +
>>>>> + ret = pthread_mutex_unlock(&fd_pairs->pair[i-inotify_fds].mutex);
>>>>> + if(ret)
>>>>> + printf("Error in mutex unlock : %s\n", strerror(ret));
>>>>> + }
>>>>> + pthread_rwlock_unlock(&fd_pairs_lock);
>>>>> + break;
>>>>> + }
>>>>> + }
>>>>> + /* If every buffer FD has hung up, we end the read loop here */
>>>>> + if(num_hup == num_pollfd - inotify_fds) break;
>>>>> +
>>>>> + if(!high_prio) {
>>>>> + for(i=inotify_fds;i<num_pollfd;i++) {
>>>>> + switch(pollfd[i].revents) {
>>>>> + case POLLIN:
>>>>> + pthread_rwlock_rdlock(&fd_pairs_lock);
>>>>> + if(pthread_mutex_trylock(&fd_pairs->pair[i-inotify_fds].mutex) == 0) {
>>>>> + /* Take care of low priority channels. */
>>>>> + printf_verbose(
>>>>> + "Normal read on fd %d\n",
>>>>> + pollfd[i].fd);
>>>>> + /* it's ok to have an unavailable subbuffer */
>>>>> + ret = read_subbuffer(&fd_pairs->pair[i-inotify_fds]);
>>>>> + if(ret == EAGAIN) ret = 0;
>>>>> +
>>>>> + ret = pthread_mutex_unlock(&fd_pairs->pair[i-inotify_fds].mutex);
>>>>> + if(ret)
>>>>> + printf("Error in mutex unlock : %s\n", strerror(ret));
>>>>> + }
>>>>> + pthread_rwlock_unlock(&fd_pairs_lock);
>>>>> + break;
>>>>> + }
>>>>> + }
>>>>> + }
>>>>> +
>>>>> + /* Update pollfd array if an entry was added to fd_pairs */
>>>>> + pthread_rwlock_rdlock(&fd_pairs_lock);
>>>>> + if((inotify_fds + fd_pairs->num_pairs) != num_pollfd) {
>>>>> + pollfd = realloc(pollfd,
>>>>> + (inotify_fds + fd_pairs->num_pairs) * sizeof(struct pollfd));
>>>>> + for(i=num_pollfd-inotify_fds;i<fd_pairs->num_pairs;i++) {
>>>>> + pollfd[inotify_fds+i].fd = fd_pairs->pair[i].channel;
>>>>> + pollfd[inotify_fds+i].events = POLLIN|POLLPRI;
>>>>> + }
>>>>> + num_pollfd = fd_pairs->num_pairs + inotify_fds;
>>>>> + }
>>>>> + pthread_rwlock_unlock(&fd_pairs_lock);
>>>>> +
>>>>> + /* NB: If the fd_pairs structure is updated by another thread from this
>>>>> + * point forward, the current thread will wait in the poll without
>>>>> + * monitoring the new channel. However, this thread will add the
>>>>> + * new channel on next poll (and this should not take too much time
>>>>> + * on a loaded system).
>>>>> + *
>>>>> + * This event is quite unlikely and can only occur if a CPU is
>>>>> + * hot-plugged while multple lttd threads are running.
>>>>> + */
>>>>> + }
>>>>> +
>>>>> +free_fd:
>>>>> + free(pollfd);
>>>>> +
>>>>> +end:
>>>>> + return ret;
>>>>> +}
>>>>> +
>>>>> +
>>>>> +void close_channel_trace_pairs(struct channel_trace_fd *fd_pairs, int inotify_fd,
>>>>> + struct inotify_watch_array *iwatch_array)
>>>>> +{
>>>>> + int i;
>>>>> + int ret;
>>>>> +
>>>>> + for(i=0;i<fd_pairs->num_pairs;i++) {
>>>>> + ret = close(fd_pairs->pair[i].channel);
>>>>> + if(ret == -1) perror("Close error on channel");
>>>>> + if(callbacks->on_close_channel) {
>>>>> + ret = callbacks->on_close_channel(
>>>>> + callbacks,&fd_pairs->pair[i]);
>>>>> + if(ret != 0) perror("Error on close channel callback");
>>>>> + }
>>>>> + }
>>>>> + free(fd_pairs->pair);
>>>>> + free(iwatch_array->elem);
>>>>> +}
>>>>> +
>>>>> +/* Thread worker */
>>>>> +void * thread_main(void *arg)
>>>>> +{
>>>>> + long ret = 0;
>>>>> + unsigned long thread_num = (unsigned long)arg;
>>>>> +
>>>>> + if(callbacks->on_new_thread)
>>>>> + ret = callbacks->on_new_thread(callbacks, thread_num);
>>>>> +
>>>>> + if (ret< 0) {
>>>>> + return (void*)ret;
>>>>> + }
>>>>> + ret = read_channels(thread_num,&fd_pairs, inotify_fd,&inotify_watch_array);
>>>>> +
>>>>> + if(callbacks->on_close_thread)
>>>>> + callbacks->on_close_thread(callbacks, thread_num);
>>>>> +
>>>>> + return (void*)ret;
>>>>> +}
>>>>> +
>>>>> +/*on_close_thread has to be reentrant, it'll be called by many threads*/
>>>>> +int(*on_close_thread)(struct liblttd_callbacks *data, unsigned long thread_num);
>>>>> +
>>>>> +int channels_init()
>>>>> +{
>>>>> + int ret = 0;
>>>>> +
>>>>> + inotify_fd = inotify_init();
>>>>> + fcntl(inotify_fd, F_SETFL, O_NONBLOCK);
>>>>> +
>>>>> + if(ret = open_channel_trace_pairs(channel_name,
>>>>> + channel_name + strlen(channel_name),&fd_pairs,
>>>>> + &inotify_fd,&inotify_watch_array))
>>>>> + goto close_channel;
>>>>> + if (fd_pairs.num_pairs == 0) {
>>>>> + printf("No channel available for reading, exiting\n");
>>>>> + ret = -ENOENT;
>>>>> + goto close_channel;
>>>>> + }
>>>>> + if(ret = map_channels(&fd_pairs, 0, fd_pairs.num_pairs))
>>>>> + goto close_channel;
>>>>> + return 0;
>>>>> +
>>>>> +close_channel:
>>>>> + close_channel_trace_pairs(&fd_pairs, inotify_fd,&inotify_watch_array);
>>>>> + if(inotify_fd>= 0)
>>>>> + close(inotify_fd);
>>>>> + return ret;
>>>>> +}
>>>>> +
>>>>> +int liblttd_start(char *channel_path, unsigned long n_threads,
>>>>> + int flight_only, int normal_only, int verbose,
>>>>> + struct liblttd_callbacks *user_data){
>>>>> + int ret = 0;
>>>>> + pthread_t *tids;
>>>>> + unsigned long i;
>>>>> + void *tret;
>>>>> +
>>>>> + channel_name = channel_path;
>>>>> + num_threads = n_threads;
>>>>> + dump_flight_only = flight_only;
>>>>> + dump_normal_only = normal_only;
>>>>> + verbose_mode = verbose;
>>>>> + callbacks = user_data;
>>>>> +
>>>>> + if(ret = channels_init())
>>>>> + return ret;
>>>>> +
>>>>> + tids = malloc(sizeof(pthread_t) * num_threads);
>>>>> + for(i=0; i<num_threads; i++) {
>>>>> +
>>>>> + ret = pthread_create(&tids[i], NULL, thread_main, (void*)i);
>>>>> + if(ret) {
>>>>> + perror("Error creating thread");
>>>>> + break;
>>>>> + }
>>>>> + }
>>>>> +
>>>>> + for(i=0; i<num_threads; i++) {
>>>>> + ret = pthread_join(tids[i],&tret);
>>>>> + if(ret) {
>>>>> + perror("Error joining thread");
>>>>> + break;
>>>>> + }
>>>>> + if((long)tret != 0) {
>>>>> + printf("Error %s occured in thread %ld\n",
>>>>> + strerror((long)tret), i);
>>>>> + }
>>>>> + }
>>>>> +
>>>>> + free(tids);
>>>>> + ret = unmap_channels(&fd_pairs);
>>>>> + close_channel_trace_pairs(&fd_pairs, inotify_fd,&inotify_watch_array);
>>>>> + if(inotify_fd>= 0)
>>>>> + close(inotify_fd);
>>>>> +
>>>>> + if(callbacks->on_trace_end) callbacks->on_trace_end(callbacks);
>>>>> +
>>>>> + return ret;
>>>>> +}
>>>>> +
>>>>> +int liblttd_stop() {
>>>>> + quit_program = 1;
>>>>> + return 0;
>>>>> +}
>>>>> +
>>>>> diff --git a/liblttd/liblttd.h b/liblttd/liblttd.h
>>>>> new file mode 100644
>>>>> index 0000000..bd76eeb
>>>>> --- /dev/null
>>>>> +++ b/liblttd/liblttd.h
>>>>> @@ -0,0 +1,218 @@
>>>>> +/* liblttd header file
>>>>> + *
>>>>> + * Copyright 2010-
>>>>> + * Oumarou Dicko<oumarou.dicko at polymtl.ca>
>>>>> + * Michael Sills-Lavoie<michael.sills-lavoie at polymtl.ca>
>>>>> + *
>>>>> + *
>>>>> + * This program is free software; you can redistribute it and/or modify
>>>>> + * it under the terms of the GNU General Public License as published by
>>>>> + * the Free Software Foundation; either version 2 of the License, or
>>>>> + * (at your option) any later version.
>>>>> + *
>>>>> + * This program is distributed in the hope that it will be useful,
>>>>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>>>>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
>>>>> + * GNU General Public License for more details.
>>>>> + *
>>>>> + */
>>>>> +
>>>>> +#ifndef _LIBLTTD_H
>>>>> +#define _LIBLTTD_H
>>>>> +
>>>>> +#include<pthread.h>
>>>>> +
>>>>> +/**
>>>>> +* This structure contains the data associated with the channel file descriptor.
>>>>> +* The lib user can use user_data to store the data associated to the specified
>>>>> +* channel. The lib user can read but MUST NOT change the other attributes.
>>>>> +*/
>>>>> +struct fd_pair {
>>>>> + /**
>>>>> + * This is the channel file descriptor.
>>>>> + */
>>>>> + int channel;
>>>>> +
>>>>> + /**
>>>>> + * This is the number of subbuffer for this channel.
>>>>> + */
>>>>> + unsigned int n_sb;
>>>>> +
>>>>> + /**
>>>>> + * This is the subbuffer size for this channel.
>>>>> + */
>>>>> + unsigned int max_sb_size;
>>>>> +
>>>>> + /**
>>>>> + * Not used anymore.
>>>>> + */
>>>>> + void *mmap;
>>>>> +
>>>>> + /**
>>>>> + * This is a mutex for internal library usage.
>>>>> + */
>>>>> + pthread_mutex_t mutex;
>>>>> +
>>>>> + /**
>>>>> + * Library user data.
>>>>> + */
>>>>> + void *user_data;
>>>>> +};
>>>>> +
>>>>> +/**
>>>>> +* This structure contains the necessary callbacks for a tracing session. The
>>>>> +* user can set the unnecessary functions to NULL if he does not need them.
>>>>> +*/
>>>>> +struct liblttd_callbacks {
>>>>> + /**
>>>>> + * This callback is called after a channel file is open.
>>>>> + *
>>>>> + * @args data This argument is a pointeur to the callbacks struct that
>>>>> + * has been passed to the lib.
>>>>> + * @args pair This structure contains the data associated with the
>>>>> + * channel file descriptor. The lib user can use user_data to
>>>>> + * store the data associated to the specified channel.
>>>>> + * @args relative_channel_path This argument represents a relative path
>>>>> + * to the channel file. This path is relative to the root
>>>>> + * folder of the trace channels.
>>>>> + *
>>>>> + * @return Should return 0 if the callback succeeds else not 0.
>>>>> + */
>>>>> + int(*on_open_channel)(struct liblttd_callbacks *data,
>>>>> + struct fd_pair *pair, char *relative_channel_path);
>>>>> +
>>>>> + /**
>>>>> + * This callback is called after a channel file is closed.
>>>>> + *
>>>>> + * @remarks After a channel file has been closed, it will never be read
>>>>> + * again.
>>>>> + *
>>>>> + * @args data This argument is a pointeur to the callbacks struct that
>>>>> + * has been passed to the lib.
>>>>> + * @args pair This structure contains the data associated with the
>>>>> + * channel file descriptor. The lib user should clean
>>>>> + * user_data at this time.
>>>>> + *
>>>>> + * @return Should return 0 if the callback succeeds else not 0.
>>>>> + */
>>>>> + int(*on_close_channel)(struct liblttd_callbacks *data,
>>>>> + struct fd_pair *pair);
>>>>> +
>>>>> +
>>>>> + /**
>>>>> + * This callback is called when the library enter in a new subfolder
>>>>> + * while it is scanning the trace channel tree. It can be used to create
>>>>> + * the output file structure of the trace.
>>>>> + *
>>>>> + * @args data This argument is a pointeur to the callbacks struct that
>>>>> + * has been passed to the lib.
>>>>> + * @args relative_folder_path This argument represents a relative path
>>>>> + * to the channel folder. This path is relative to the root
>>>>> + * folder of the trace channels.
>>>>> + *
>>>>> + * @return Should return 0 if the callback succeeds else not 0.
>>>>> + */
>>>>> + int(*on_new_channels_folder)(struct liblttd_callbacks *data,
>>>>> + char *relative_folder_path);
>>>>> +
>>>>> + /**
>>>>> + * This callback is called after a subbuffer is a reserved.
>>>>> + *
>>>>> + * @attention It has to be thread safe, it'll be called by many threads.
>>>>> + *
>>>>> + * @args data This argument is a pointeur to the callbacks struct that
>>>>> + * has been passed to the lib.
>>>>> + * @args pair This structure contains the data associated with the
>>>>> + * channel file descriptor. The lib user should clean
>>>>> + * user_data at this time.
>>>>> + * @args len This argument represents the length the data that has to be
>>>>> + * read.
>>>>> + *
>>>>> + * @return Should return 0 if the callback succeeds else not 0.
>>>>> + */
>>>>> + int(*on_read_subbuffer)(struct liblttd_callbacks *data,
>>>>> + struct fd_pair *pair, unsigned int len);
>>>>> +
>>>>> + /**
>>>>> + * This callback is called at the very end of the tracing session. At
>>>>> + * this time, all the channels have been closed and the threads have been
>>>>> + * destroyed.
>>>>> + *
>>>>> + * @remarks After this callback is called, no other callback will be
>>>>> + * called again.
>>>>> + *
>>>>> + * @attention It has to be thread safe, it'll be called by many threads.
>>>>> + *
>>>>> + * @args data This argument is a pointeur to the callbacks struct that
>>>>> + * has been passed to the lib.
>>>>> + *
>>>>> + * @return Should return 0 if the callback succeeds else not 0.
>>>>> + */
>>>>> + int(*on_trace_end)(struct liblttd_callbacks *data);
>>>>> +
>>>>> + /**
>>>>> + * This callback is called after a new thread has been created.
>>>>> + *
>>>>> + * @attention It has to be thread safe, it'll be called by many threads.
>>>>> + *
>>>>> + * @args data This argument is a pointeur to the callbacks struct that
>>>>> + * has been passed to the lib.
>>>>> + * @args thread_num This argument represents the id of the thread.
>>>>> + *
>>>>> + * @return Should return 0 if the callback succeeds else not 0.
>>>>> + */
>>>>> + int(*on_new_thread)(struct liblttd_callbacks *data,
>>>>> + unsigned long thread_num);
>>>>> +
>>>>> + /**
>>>>> + * This callback is called just before a thread is destroyed.
>>>>> + *
>>>>> + * @attention It has to be thread safe, it'll be called by many threads.
>>>>> + *
>>>>> + * @args data This argument is a pointeur to the callbacks struct that
>>>>> + * has been passed to the lib.
>>>>> + * @args thread_num This argument represents the number of the thread.
>>>>> + *
>>>>> + * @return Should return 0 if the callback succeeds else not 0.
>>>>> + */
>>>>> + int(*on_close_thread)(struct liblttd_callbacks *data,
>>>>> + unsigned long thread_num);
>>>>> +
>>>>> + /**
>>>>> + * This is where the user can put the library's data.
>>>>> + */
>>>>> + void *user_data;
>>>>> +};
>>>>> +
>>>>> +/**
>>>>> +* This function is called to start a new tracing session.
>>>>> +*
>>>>> +* @attention It has to be thread safe, it'll be called by many threads.
>>>>> +*
>>>>> +* @args channel_path This argument is a path to the root folder of the trace's
>>>>> +* channels.
>>>>> +* @args n_threads This argument represents the number of threads that will be
>>>>> +* used by the library.
>>>>> +* @args flight_only If this argument to set to 1, only the channel that are in
>>>>> +* flight recorder mode will be recorded.
>>>>> +* @args normal_only If this argument to set to 1, only the channel that are in
>>>>> +* normal mode will be recorded.
>>>>> +* @args verbose If this argument to set to 1, more informations will be printed.
>>>>> +* @args user_data This argument is a pointeur to the callbacks struct that
>>>>> +* contains the user's functions.
>>>>> +*
>>>>> +* @return Return 0 if the function succeeds else not 0.
>>>>> +*/
>>>>> +int liblttd_start(char *channel_path, unsigned long n_threads,
>>>>> + int flight_only, int normal_only, int verbose,
>>>>> + struct liblttd_callbacks *user_data);
>>>>> +
>>>>> +/**
>>>>> +* This function is called to stop a tracing session.
>>>>> +*
>>>>> +* @return Return 0 if the function succeeds.
>>>>> +*/
>>>>> +int liblttd_stop();
>>>>> +
>>>>> +#endif /*_LIBLTTD_H */
>>>>> +
>>>>> diff --git a/lttd/Makefile.am b/lttd/Makefile.am
>>>>> index bb860bc..fc9b219 100644
>>>>> --- a/lttd/Makefile.am
>>>>> +++ b/lttd/Makefile.am
>>>>> @@ -6,3 +6,6 @@ bin_PROGRAMS = lttd
>>>>>
>>>>> lttd_SOURCES = lttd.c
>>>>>
>>>>> +lttd_DEPENDENCIES = ../liblttd/liblttd.la
>>>>> +lttd_LDADD = $(lttd_DEPENDENCIES)
>>>>> +
>>>>> diff --git a/lttd/lttd.c b/lttd/lttd.c
>>>>> index 78c2c80..ec757ae 100644
>>>>> --- a/lttd/lttd.c
>>>>> +++ b/lttd/lttd.c
>>>>> @@ -30,125 +30,36 @@
>>>>>
>>>>> #define _REENTRANT
>>>>> #define _GNU_SOURCE
>>>>> -#include<features.h>
>>>>> +
>>>>> #include<stdio.h>
>>>>> -#include<unistd.h>
>>>>> -#include<errno.h>
>>>>> -#include<sys/types.h>
>>>>> -#include<sys/stat.h>
>>>>> #include<stdlib.h>
>>>>> -#include<dirent.h>
>>>>> #include<string.h>
>>>>> -#include<fcntl.h>
>>>>> -#include<sys/poll.h>
>>>>> -#include<sys/mman.h>
>>>>> #include<signal.h>
>>>>> -#include<pthread.h>
>>>>> -#include<sys/syscall.h>
>>>>> -#include<unistd.h>
>>>>> -#include<asm/ioctls.h>
>>>>> -
>>>>> -#include<linux/version.h>
>>>>> -
>>>>> -/* Relayfs IOCTL */
>>>>> -#include<asm/ioctl.h>
>>>>> -#include<asm/types.h>
>>>>> -
>>>>> -/* Get the next sub buffer that can be read. */
>>>>> -#define RELAY_GET_SB _IOR(0xF5, 0x00,__u32)
>>>>> -/* Release the oldest reserved (by "get") sub buffer. */
>>>>> -#define RELAY_PUT_SB _IOW(0xF5, 0x01,__u32)
>>>>> -/* returns the number of sub buffers in the per cpu channel. */
>>>>> -#define RELAY_GET_N_SB _IOR(0xF5, 0x02,__u32)
>>>>> -/* returns the size of the current sub buffer. */
>>>>> -#define RELAY_GET_SB_SIZE _IOR(0xF5, 0x03, __u32)
>>>>> -/* returns the size of data to consume in the current sub-buffer. */
>>>>> -#define RELAY_GET_MAX_SB_SIZE _IOR(0xF5, 0x04, __u32)
>>>>> -
>>>>> -
>>>>> -#if LINUX_VERSION_CODE>= KERNEL_VERSION(2,6,14)
>>>>> -#include<sys/inotify.h>
>>>>> -#if 0 /* should now be provided by libc. */
>>>>> -/* From the inotify-tools 2.6 package */
>>>>> -static inline int inotify_init (void)
>>>>> -{
>>>>> - return syscall (__NR_inotify_init);
>>>>> -}
>>>>> -
>>>>> -static inline int inotify_add_watch (int fd, const char *name, __u32 mask)
>>>>> -{
>>>>> - return syscall (__NR_inotify_add_watch, fd, name, mask);
>>>>> -}
>>>>> -
>>>>> -static inline int inotify_rm_watch (int fd, __u32 wd)
>>>>> -{
>>>>> - return syscall (__NR_inotify_rm_watch, fd, wd);
>>>>> -}
>>>>> -#endif //0
>>>>> -#define HAS_INOTIFY
>>>>> -#else
>>>>> -static inline int inotify_init (void)
>>>>> -{
>>>>> - return -1;
>>>>> -}
>>>>> +#include<errno.h>
>>>>> +#include<fcntl.h>
>>>>> +#include<dirent.h>
>>>>> +#include<sys/stat.h>
>>>>>
>>>>> -static inline int inotify_add_watch (int fd, const char *name, __u32 mask)
>>>>> -{
>>>>> - return 0;
>>>>> -}
>>>>> +#include<liblttd/liblttd.h>
>>>>>
>>>>> -static inline int inotify_rm_watch (int fd, __u32 wd)
>>>>> -{
>>>>> - return 0;
>>>>> -}
>>>>> -#undef HAS_INOTIFY
>>>>> -#endif
>>>>> -
>>>>> -struct fd_pair {
>>>>> - int channel;
>>>>> +struct lttd_channel_data {
>>>>> int trace;
>>>>> - unsigned int n_sb;
>>>>> - unsigned int max_sb_size;
>>>>> - void *mmap;
>>>>> - pthread_mutex_t mutex;
>>>>> -};
>>>>> -
>>>>> -struct channel_trace_fd {
>>>>> - struct fd_pair *pair;
>>>>> - int num_pairs;
>>>>> -};
>>>>> -
>>>>> -struct inotify_watch {
>>>>> - int wd;
>>>>> - char path_channel[PATH_MAX];
>>>>> - char path_trace[PATH_MAX];
>>>>> -};
>>>>> -
>>>>> -struct inotify_watch_array {
>>>>> - struct inotify_watch *elem;
>>>>> - int num;
>>>>> };
>>>>>
>>>>> -static __thread int thread_pipe[2];
>>>>> -
>>>>> -struct channel_trace_fd fd_pairs = { NULL, 0 };
>>>>> -int inotify_fd = -1;
>>>>> -struct inotify_watch_array inotify_watch_array = { NULL, 0 };
>>>>> -
>>>>> -/* protects fd_pairs and inotify_watch_array */
>>>>> -pthread_rwlock_t fd_pairs_lock = PTHREAD_RWLOCK_INITIALIZER;
>>>>> -
>>>>> -
>>>>> +static char path_trace[PATH_MAX];
>>>>> +static char *end_path_trace;
>>>>> +static int path_trace_len = 0;
>>>>> static char *trace_name = NULL;
>>>>> static char *channel_name = NULL;
>>>>> static int daemon_mode = 0;
>>>>> static int append_mode = 0;
>>>>> static unsigned long num_threads = 1;
>>>>> -volatile static int quit_program = 0; /* For signal handler */
>>>>> static int dump_flight_only = 0;
>>>>> static int dump_normal_only = 0;
>>>>> static int verbose_mode = 0;
>>>>>
>>>>> +static __thread int thread_pipe[2];
>>>>> +
>>>>> #define printf_verbose(fmt, args...) \
>>>>> do { \
>>>>> if (verbose_mode) \
>>>>> @@ -191,7 +102,7 @@ int parse_arguments(int argc, char **argv)
>>>>> {
>>>>> int ret = 0;
>>>>> int argn = 1;
>>>>> -
>>>>> +
>>>>> if(argc == 2) {
>>>>> if(strcmp(argv[1], "-h") == 0) {
>>>>> return 1;
>>>>> @@ -249,19 +160,19 @@ int parse_arguments(int argc, char **argv)
>>>>> }
>>>>> argn++;
>>>>> }
>>>>> -
>>>>> +
>>>>> if(trace_name == NULL) {
>>>>> printf("Please specify a trace name.\n");
>>>>> printf("\n");
>>>>> ret = -1;
>>>>> }
>>>>> -
>>>>> +
>>>>> if(channel_name == NULL) {
>>>>> printf("Please specify a channel name.\n");
>>>>> printf("\n");
>>>>> ret = -1;
>>>>> }
>>>>> -
>>>>> +
>>>>> return ret;
>>>>> }
>>>>>
>>>>> @@ -280,223 +191,96 @@ void show_info(void)
>>>>> static void handler(int signo)
>>>>> {
>>>>> printf("Signal %d received : exiting cleanly\n", signo);
>>>>> - quit_program = 1;
>>>>> + liblttd_stop();
>>>>> }
>>>>>
>>>>> -
>>>>> -int open_buffer_file(char *filename, char *path_channel, char *path_trace,
>>>>> - struct channel_trace_fd *fd_pairs)
>>>>> +int lttd_on_open_channel(struct liblttd_callbacks *data, struct fd_pair *pair, char *relative_channel_path)
>>>>> {
>>>>> int open_ret = 0;
>>>>> - int ret = 0;
>>>>> + int ret;
>>>>> struct stat stat_buf;
>>>>> + struct lttd_channel_data *channel_data;
>>>>>
>>>>> - if(strncmp(filename, "flight-", sizeof("flight-")-1) != 0) {
>>>>> - if(dump_flight_only) {
>>>>> - printf_verbose("Skipping normal channel %s\n",
>>>>> - path_channel);
>>>>> - return 0;
>>>>> - }
>>>>> - } else {
>>>>> - if(dump_normal_only) {
>>>>> - printf_verbose("Skipping flight channel %s\n",
>>>>> - path_channel);
>>>>> - return 0;
>>>>> - }
>>>>> - }
>>>>> - printf_verbose("Opening file.\n");
>>>>> -
>>>>> - fd_pairs->pair = realloc(fd_pairs->pair,
>>>>> - ++fd_pairs->num_pairs * sizeof(struct fd_pair));
>>>>> + pair->user_data = malloc(sizeof(struct lttd_channel_data));
>>>>> + channel_data = pair->user_data;
>>>>> +
>>>>> + strncpy(end_path_trace, relative_channel_path, PATH_MAX - path_trace_len);
>>>>> + printf_verbose("Creating trace file %s\n", path_trace);
>>>>>
>>>>> - /* Open the channel in read mode */
>>>>> - fd_pairs->pair[fd_pairs->num_pairs-1].channel =
>>>>> - open(path_channel, O_RDONLY | O_NONBLOCK);
>>>>> - if(fd_pairs->pair[fd_pairs->num_pairs-1].channel == -1) {
>>>>> - perror(path_channel);
>>>>> - fd_pairs->num_pairs--;
>>>>> - return 0; /* continue */
>>>>> - }
>>>>> - /* Open the trace in write mode, only append if append_mode */
>>>>> ret = stat(path_trace,&stat_buf);
>>>>> if(ret == 0) {
>>>>> if(append_mode) {
>>>>> printf_verbose("Appending to file %s as requested\n",
>>>>> path_trace);
>>>>>
>>>>> - fd_pairs->pair[fd_pairs->num_pairs-1].trace =
>>>>> - open(path_trace, O_WRONLY,
>>>>> - S_IRWXU|S_IRWXG|S_IRWXO);
>>>>> - if(fd_pairs->pair[fd_pairs->num_pairs-1].trace == -1) {
>>>>> + channel_data->trace = open(path_trace, O_WRONLY, S_IRWXU|S_IRWXG|S_IRWXO);
>>>>> + if(channel_data->trace == -1) {
>>>>> perror(path_trace);
>>>>> open_ret = -1;
>>>>> - close(fd_pairs->pair[fd_pairs->num_pairs-1].channel);
>>>>> - fd_pairs->num_pairs--;
>>>>> goto end;
>>>>> }
>>>>> - ret = lseek(fd_pairs->pair[fd_pairs->num_pairs-1].trace,
>>>>> - 0, SEEK_END);
>>>>> + ret = lseek(channel_data->trace, 0, SEEK_END);
>>>>> if (ret< 0) {
>>>>> perror(path_trace);
>>>>> open_ret = -1;
>>>>> - close(fd_pairs->pair[fd_pairs->num_pairs-1].channel);
>>>>> - close(fd_pairs->pair[fd_pairs->num_pairs-1].trace);
>>>>> - fd_pairs->num_pairs--;
>>>>> + close(channel_data->trace);
>>>>> goto end;
>>>>> }
>>>>> } else {
>>>>> printf("File %s exists, cannot open. Try append mode.\n", path_trace);
>>>>> open_ret = -1;
>>>>> - close(fd_pairs->pair[fd_pairs->num_pairs-1].channel);
>>>>> - fd_pairs->num_pairs--;
>>>>> goto end;
>>>>> }
>>>>> } else {
>>>>> if(errno == ENOENT) {
>>>>> - fd_pairs->pair[fd_pairs->num_pairs-1].trace =
>>>>> - open(path_trace, O_WRONLY|O_CREAT|O_EXCL,
>>>>> - S_IRWXU|S_IRWXG|S_IRWXO);
>>>>> - if(fd_pairs->pair[fd_pairs->num_pairs-1].trace == -1) {
>>>>> + channel_data->trace = open(path_trace, O_WRONLY|O_CREAT|O_EXCL, S_IRWXU|S_IRWXG|S_IRWXO);
>>>>> + if(channel_data->trace == -1) {
>>>>> perror(path_trace);
>>>>> open_ret = -1;
>>>>> - close(fd_pairs->pair[fd_pairs->num_pairs-1].channel);
>>>>> - fd_pairs->num_pairs--;
>>>>> goto end;
>>>>> }
>>>>> }
>>>>> }
>>>>> +
>>>>> end:
>>>>> return open_ret;
>>>>> +
>>>>> }
>>>>>
>>>>> -int open_channel_trace_pairs(char *subchannel_name, char *subtrace_name,
>>>>> - struct channel_trace_fd *fd_pairs, int *inotify_fd,
>>>>> - struct inotify_watch_array *iwatch_array)
>>>>> +int lttd_on_close_channel(struct liblttd_callbacks *data, struct fd_pair *pair)
>>>>> +{
>>>>> + int ret;
>>>>> + ret = close(((struct lttd_channel_data *)(pair->user_data))->trace);
>>>>> + free(pair->user_data);
>>>>> + return ret;
>>>>> +}
>>>>> +
>>>>> +int lttd_on_new_channels_folder(struct liblttd_callbacks *data, char *relative_folder_path)
>>>>> {
>>>>> - DIR *channel_dir = opendir(subchannel_name);
>>>>> - struct dirent *entry;
>>>>> - struct stat stat_buf;
>>>>> int ret;
>>>>> - char path_channel[PATH_MAX];
>>>>> - int path_channel_len;
>>>>> - char *path_channel_ptr;
>>>>> - char path_trace[PATH_MAX];
>>>>> - int path_trace_len;
>>>>> - char *path_trace_ptr;
>>>>> int open_ret = 0;
>>>>>
>>>>> - if(channel_dir == NULL) {
>>>>> - perror(subchannel_name);
>>>>> - open_ret = ENOENT;
>>>>> - goto end;
>>>>> - }
>>>>> + strncpy(end_path_trace, relative_folder_path, PATH_MAX - path_trace_len);
>>>>> + printf_verbose("Creating trace subdirectory %s\n", path_trace);
>>>>>
>>>>> - printf_verbose("Creating trace subdirectory %s\n", subtrace_name);
>>>>> - ret = mkdir(subtrace_name, S_IRWXU|S_IRWXG|S_IRWXO);
>>>>> + ret = mkdir(path_trace, S_IRWXU|S_IRWXG|S_IRWXO);
>>>>> if(ret == -1) {
>>>>> if(errno != EEXIST) {
>>>>> - perror(subtrace_name);
>>>>> + perror(path_trace);
>>>>> open_ret = -1;
>>>>> goto end;
>>>>> }
>>>>> }
>>>>>
>>>>> - strncpy(path_channel, subchannel_name, PATH_MAX-1);
>>>>> - path_channel_len = strlen(path_channel);
>>>>> - path_channel[path_channel_len] = '/';
>>>>> - path_channel_len++;
>>>>> - path_channel_ptr = path_channel + path_channel_len;
>>>>> -
>>>>> - strncpy(path_trace, subtrace_name, PATH_MAX-1);
>>>>> - path_trace_len = strlen(path_trace);
>>>>> - path_trace[path_trace_len] = '/';
>>>>> - path_trace_len++;
>>>>> - path_trace_ptr = path_trace + path_trace_len;
>>>>> -
>>>>> -#ifdef HAS_INOTIFY
>>>>> - iwatch_array->elem = realloc(iwatch_array->elem,
>>>>> - ++iwatch_array->num * sizeof(struct inotify_watch));
>>>>> -
>>>>> - printf_verbose("Adding inotify for channel %s\n", path_channel);
>>>>> - iwatch_array->elem[iwatch_array->num-1].wd = inotify_add_watch(*inotify_fd, path_channel, IN_CREATE);
>>>>> - strcpy(iwatch_array->elem[iwatch_array->num-1].path_channel, path_channel);
>>>>> - strcpy(iwatch_array->elem[iwatch_array->num-1].path_trace, path_trace);
>>>>> - printf_verbose("Added inotify for channel %s, wd %u\n",
>>>>> - iwatch_array->elem[iwatch_array->num-1].path_channel,
>>>>> - iwatch_array->elem[iwatch_array->num-1].wd);
>>>>> -#endif
>>>>> -
>>>>> - while((entry = readdir(channel_dir)) != NULL) {
>>>>> -
>>>>> - if(entry->d_name[0] == '.') continue;
>>>>> -
>>>>> - strncpy(path_channel_ptr, entry->d_name, PATH_MAX - path_channel_len);
>>>>> - strncpy(path_trace_ptr, entry->d_name, PATH_MAX - path_trace_len);
>>>>> -
>>>>> - ret = stat(path_channel,&stat_buf);
>>>>> - if(ret == -1) {
>>>>> - perror(path_channel);
>>>>> - continue;
>>>>> - }
>>>>> -
>>>>> - printf_verbose("Channel file : %s\n", path_channel);
>>>>> -
>>>>> - if(S_ISDIR(stat_buf.st_mode)) {
>>>>> -
>>>>> - printf_verbose("Entering channel subdirectory...\n");
>>>>> - ret = open_channel_trace_pairs(path_channel, path_trace, fd_pairs,
>>>>> - inotify_fd, iwatch_array);
>>>>> - if(ret< 0) continue;
>>>>> - } else if(S_ISREG(stat_buf.st_mode)) {
>>>>> - open_ret = open_buffer_file(entry->d_name, path_channel, path_trace,
>>>>> - fd_pairs);
>>>>> - if(open_ret)
>>>>> - goto end;
>>>>> - }
>>>>> - }
>>>>> -
>>>>> end:
>>>>> - closedir(channel_dir);
>>>>> -
>>>>> return open_ret;
>>>>> }
>>>>>
>>>>> -
>>>>> -int read_subbuffer(struct fd_pair *pair)
>>>>> +int lttd_on_read_subbuffer(struct liblttd_callbacks *data, struct fd_pair *pair, unsigned int len)
>>>>> {
>>>>> - unsigned int consumed_old, len;
>>>>> - int err;
>>>>> long ret;
>>>>> - off_t offset;
>>>>> -
>>>>> + off_t offset = 0;
>>>>>
>>>>> - err = ioctl(pair->channel, RELAY_GET_SB,&consumed_old);
>>>>> - printf_verbose("cookie : %u\n", consumed_old);
>>>>> - if(err != 0) {
>>>>> - ret = errno;
>>>>> - perror("Reserving sub buffer failed (everything is normal, it is due to concurrency)");
>>>>> - goto get_error;
>>>>> - }
>>>>> -#if 0
>>>>> - err = TEMP_FAILURE_RETRY(write(pair->trace,
>>>>> - pair->mmap
>>>>> - + (consumed_old& ((pair->n_subbufs * pair->subbuf_size)-1)),
>>>>> - pair->subbuf_size));
>>>>> -
>>>>> - if(err< 0) {
>>>>> - ret = errno;
>>>>> - perror("Error in writing to file");
>>>>> - goto write_error;
>>>>> - }
>>>>> -#endif //0
>>>>> - err = ioctl(pair->channel, RELAY_GET_SB_SIZE,&len);
>>>>> - if(err != 0) {
>>>>> - ret = errno;
>>>>> - perror("Getting sub-buffer len failed.");
>>>>> - goto get_error;
>>>>> - }
>>>>> -
>>>>> - offset = 0;
>>>>> while (len> 0) {
>>>>> printf_verbose("splice chan to pipe offset %lu\n",
>>>>> (unsigned long)offset);
>>>>> @@ -507,8 +291,9 @@ int read_subbuffer(struct fd_pair *pair)
>>>>> perror("Error in relay splice");
>>>>> goto write_error;
>>>>> }
>>>>> - ret = splice(thread_pipe[0], NULL, pair->trace, NULL,
>>>>> - ret, SPLICE_F_MOVE | SPLICE_F_MORE);
>>>>> + ret = splice(thread_pipe[0], NULL,
>>>>> + ((struct lttd_channel_data *)(pair->user_data))->trace,
>>>>> + NULL, ret, SPLICE_F_MOVE | SPLICE_F_MORE);
>>>>> printf_verbose("splice pipe to file %ld\n", ret);
>>>>> if (ret< 0) {
>>>>> perror("Error in file splice");
>>>>> @@ -517,466 +302,42 @@ int read_subbuffer(struct fd_pair *pair)
>>>>> len -= ret;
>>>>> }
>>>>>
>>>>> -#if 0
>>>>> - err = fsync(pair->trace);
>>>>> - if(err< 0) {
>>>>> - ret = errno;
>>>>> - perror("Error in writing to file");
>>>>> - goto write_error;
>>>>> - }
>>>>> -#endif //0
>>>>> write_error:
>>>>> - ret = 0;
>>>>> - err = ioctl(pair->channel, RELAY_PUT_SB,&consumed_old);
>>>>> - if(err != 0) {
>>>>> - ret = errno;
>>>>> - if(errno == EFAULT) {
>>>>> - perror("Error in unreserving sub buffer\n");
>>>>> - } else if(errno == EIO) {
>>>>> - /* Should never happen with newer LTTng versions */
>>>>> - perror("Reader has been pushed by the writer, last sub-buffer corrupted.");
>>>>> - }
>>>>> - goto get_error;
>>>>> - }
>>>>> -
>>>>> -get_error:
>>>>> - return ret;
>>>>> -}
>>>>> -
>>>>> -
>>>>> -int map_channels(struct channel_trace_fd *fd_pairs,
>>>>> - int idx_begin, int idx_end)
>>>>> -{
>>>>> - int i,j;
>>>>> - int ret=0;
>>>>> -
>>>>> - if(fd_pairs->num_pairs<= 0) {
>>>>> - printf("No channel to read\n");
>>>>> - goto end;
>>>>> - }
>>>>> -
>>>>> - /* Get the subbuf sizes and number */
>>>>> -
>>>>> - for(i=idx_begin;i<idx_end;i++) {
>>>>> - struct fd_pair *pair =&fd_pairs->pair[i];
>>>>> -
>>>>> - ret = ioctl(pair->channel, RELAY_GET_N_SB,&pair->n_sb);
>>>>> - if(ret != 0) {
>>>>> - perror("Error in getting the number of sub-buffers");
>>>>> - goto end;
>>>>> - }
>>>>> - ret = ioctl(pair->channel, RELAY_GET_MAX_SB_SIZE,
>>>>> - &pair->max_sb_size);
>>>>> - if(ret != 0) {
>>>>> - perror("Error in getting the max sub-buffer size");
>>>>> - goto end;
>>>>> - }
>>>>> - ret = pthread_mutex_init(&pair->mutex, NULL); /* Fast mutex */
>>>>> - if(ret != 0) {
>>>>> - perror("Error in mutex init");
>>>>> - goto end;
>>>>> - }
>>>>> - }
>>>>> -
>>>>> -#if 0
>>>>> - /* Mmap each FD */
>>>>> - for(i=idx_begin;i<idx_end;i++) {
>>>>> - struct fd_pair *pair =&fd_pairs->pair[i];
>>>>> -
>>>>> - pair->mmap = mmap(0, pair->subbuf_size * pair->n_subbufs, PROT_READ,
>>>>> - MAP_SHARED, pair->channel, 0);
>>>>> - if(pair->mmap == MAP_FAILED) {
>>>>> - perror("Mmap error");
>>>>> - goto munmap;
>>>>> - }
>>>>> - }
>>>>> -
>>>>> - goto end; /* success */
>>>>> -
>>>>> - /* Error handling */
>>>>> - /* munmap only the successfully mmapped indexes */
>>>>> -munmap:
>>>>> - /* Munmap each FD */
>>>>> - for(j=idx_begin;j<i;j++) {
>>>>> - struct fd_pair *pair =&fd_pairs->pair[j];
>>>>> - int err_ret;
>>>>> -
>>>>> - err_ret = munmap(pair->mmap, pair->subbuf_size * pair->n_subbufs);
>>>>> - if(err_ret != 0) {
>>>>> - perror("Error in munmap");
>>>>> - }
>>>>> - ret |= err_ret;
>>>>> - }
>>>>> -
>>>>> -#endif //0
>>>>> -end:
>>>>> return ret;
>>>>> }
>>>>>
>>>>> -int unmap_channels(struct channel_trace_fd *fd_pairs)
>>>>> -{
>>>>> - int j;
>>>>> - int ret=0;
>>>>> -
>>>>> - /* Munmap each FD */
>>>>> - for(j=0;j<fd_pairs->num_pairs;j++) {
>>>>> - struct fd_pair *pair =&fd_pairs->pair[j];
>>>>> - int err_ret;
>>>>> -
>>>>> -#if 0
>>>>> - err_ret = munmap(pair->mmap, pair->subbuf_size * pair->n_subbufs);
>>>>> - if(err_ret != 0) {
>>>>> - perror("Error in munmap");
>>>>> - }
>>>>> - ret |= err_ret;
>>>>> -#endif //0
>>>>> - err_ret = pthread_mutex_destroy(&pair->mutex);
>>>>> - if(err_ret != 0) {
>>>>> - perror("Error in mutex destroy");
>>>>> - }
>>>>> - ret |= err_ret;
>>>>> - }
>>>>> -
>>>>> - return ret;
>>>>> -}
>>>>> -
>>>>> -#ifdef HAS_INOTIFY
>>>>> -/* Inotify event arrived.
>>>>> - *
>>>>> - * Only support add file for now.
>>>>> - */
>>>>> -
>>>>> -int read_inotify(int inotify_fd,
>>>>> - struct channel_trace_fd *fd_pairs,
>>>>> - struct inotify_watch_array *iwatch_array)
>>>>> -{
>>>>> - char buf[sizeof(struct inotify_event) + PATH_MAX];
>>>>> - char path_channel[PATH_MAX];
>>>>> - char path_trace[PATH_MAX];
>>>>> - ssize_t len;
>>>>> - struct inotify_event *ievent;
>>>>> - size_t offset;
>>>>> - unsigned int i;
>>>>> - int ret;
>>>>> - int old_num;
>>>>> -
>>>>> - offset = 0;
>>>>> - len = read(inotify_fd, buf, sizeof(struct inotify_event) + PATH_MAX);
>>>>> - if(len< 0) {
>>>>> -
>>>>> - if(errno == EAGAIN)
>>>>> - return 0; /* another thread got the data before us */
>>>>> -
>>>>> - printf("Error in read from inotify FD %s.\n", strerror(len));
>>>>> - return -1;
>>>>> - }
>>>>> - while(offset< len) {
>>>>> - ievent = (struct inotify_event *)&(buf[offset]);
>>>>> - for(i=0; i<iwatch_array->num; i++) {
>>>>> - if(iwatch_array->elem[i].wd == ievent->wd&&
>>>>> - ievent->mask == IN_CREATE) {
>>>>> - printf_verbose(
>>>>> - "inotify wd %u event mask : %u for %s%s\n",
>>>>> - ievent->wd, ievent->mask,
>>>>> - iwatch_array->elem[i].path_channel,
>>>>> - ievent->name);
>>>>> - old_num = fd_pairs->num_pairs;
>>>>> - strcpy(path_channel, iwatch_array->elem[i].path_channel);
>>>>> - strcat(path_channel, ievent->name);
>>>>> - strcpy(path_trace, iwatch_array->elem[i].path_trace);
>>>>> - strcat(path_trace, ievent->name);
>>>>> - if(ret = open_buffer_file(ievent->name, path_channel,
>>>>> - path_trace, fd_pairs)) {
>>>>> - printf("Error opening buffer file\n");
>>>>> - return -1;
>>>>> - }
>>>>> - if(ret = map_channels(fd_pairs, old_num, fd_pairs->num_pairs)) {
>>>>> - printf("Error mapping channel\n");
>>>>> - return -1;
>>>>> - }
>>>>> -
>>>>> - }
>>>>> - }
>>>>> - offset += sizeof(*ievent) + ievent->len;
>>>>> - }
>>>>> -}
>>>>> -#endif //HAS_INOTIFY
>>>>> -
>>>>> -/* read_channels
>>>>> - *
>>>>> - * Thread worker.
>>>>> - *
>>>>> - * Read the debugfs channels and write them in the paired tracefiles.
>>>>> - *
>>>>> - * @fd_pairs : paired channels and trace files.
>>>>> - *
>>>>> - * returns 0 on success, -1 on error.
>>>>> - *
>>>>> - * Note that the high priority polled channels are consumed first. We then poll
>>>>> - * again to see if these channels are still in priority. Only when no
>>>>> - * high priority channel is left, we start reading low priority channels.
>>>>> - *
>>>>> - * Note that a channel is considered high priority when the buffer is almost
>>>>> - * full.
>>>>> - */
>>>>> -
>>>>> -int read_channels(unsigned long thread_num, struct channel_trace_fd *fd_pairs,
>>>>> - int inotify_fd, struct inotify_watch_array *iwatch_array)
>>>>> -{
>>>>> - struct pollfd *pollfd = NULL;
>>>>> - int num_pollfd;
>>>>> - int i,j;
>>>>> - int num_rdy, num_hup;
>>>>> - int high_prio;
>>>>> - int ret = 0;
>>>>> - int inotify_fds;
>>>>> - unsigned int old_num;
>>>>> -
>>>>> -#ifdef HAS_INOTIFY
>>>>> - inotify_fds = 1;
>>>>> -#else
>>>>> - inotify_fds = 0;
>>>>> -#endif
>>>>> -
>>>>> - pthread_rwlock_rdlock(&fd_pairs_lock);
>>>>> -
>>>>> - /* Start polling the FD. Keep one fd for inotify */
>>>>> - pollfd = malloc((inotify_fds + fd_pairs->num_pairs) * sizeof(struct pollfd));
>>>>> -
>>>>> -#ifdef HAS_INOTIFY
>>>>> - pollfd[0].fd = inotify_fd;
>>>>> - pollfd[0].events = POLLIN|POLLPRI;
>>>>> -#endif
>>>>> -
>>>>> - for(i=0;i<fd_pairs->num_pairs;i++) {
>>>>> - pollfd[inotify_fds+i].fd = fd_pairs->pair[i].channel;
>>>>> - pollfd[inotify_fds+i].events = POLLIN|POLLPRI;
>>>>> - }
>>>>> - num_pollfd = inotify_fds + fd_pairs->num_pairs;
>>>>> -
>>>>> -
>>>>> - pthread_rwlock_unlock(&fd_pairs_lock);
>>>>> -
>>>>> - while(1) {
>>>>> - high_prio = 0;
>>>>> - num_hup = 0;
>>>>> -#ifdef DEBUG
>>>>> - printf("Press a key for next poll...\n");
>>>>> - char buf[1];
>>>>> - read(STDIN_FILENO,&buf, 1);
>>>>> - printf("Next poll (polling %d fd) :\n", num_pollfd);
>>>>> -#endif //DEBUG
>>>>> -
>>>>> - /* Have we received a signal ? */
>>>>> - if(quit_program) break;
>>>>> -
>>>>> - num_rdy = poll(pollfd, num_pollfd, -1);
>>>>> -
>>>>> - if(num_rdy == -1) {
>>>>> - perror("Poll error");
>>>>> - goto free_fd;
>>>>> - }
>>>>> -
>>>>> - printf_verbose("Data received\n");
>>>>> -#ifdef HAS_INOTIFY
>>>>> - switch(pollfd[0].revents) {
>>>>> - case POLLERR:
>>>>> - printf_verbose(
>>>>> - "Error returned in polling inotify fd %d.\n",
>>>>> - pollfd[0].fd);
>>>>> - break;
>>>>> - case POLLHUP:
>>>>> - printf_verbose(
>>>>> - "Polling inotify fd %d tells it has hung up.\n",
>>>>> - pollfd[0].fd);
>>>>> - break;
>>>>> - case POLLNVAL:
>>>>> - printf_verbose(
>>>>> - "Polling inotify fd %d tells fd is not open.\n",
>>>>> - pollfd[0].fd);
>>>>> - break;
>>>>> - case POLLPRI:
>>>>> - case POLLIN:
>>>>> - printf_verbose(
>>>>> - "Polling inotify fd %d : data ready.\n",
>>>>> - pollfd[0].fd);
>>>>> -
>>>>> - pthread_rwlock_wrlock(&fd_pairs_lock);
>>>>> - read_inotify(inotify_fd, fd_pairs, iwatch_array);
>>>>> - pthread_rwlock_unlock(&fd_pairs_lock);
>>>>> -
>>>>> - break;
>>>>> - }
>>>>> -#endif
>>>>> -
>>>>> - for(i=inotify_fds;i<num_pollfd;i++) {
>>>>> - switch(pollfd[i].revents) {
>>>>> - case POLLERR:
>>>>> - printf_verbose(
>>>>> - "Error returned in polling fd %d.\n",
>>>>> - pollfd[i].fd);
>>>>> - num_hup++;
>>>>> - break;
>>>>> - case POLLHUP:
>>>>> - printf_verbose(
>>>>> - "Polling fd %d tells it has hung up.\n",
>>>>> - pollfd[i].fd);
>>>>> - num_hup++;
>>>>> - break;
>>>>> - case POLLNVAL:
>>>>> - printf_verbose(
>>>>> - "Polling fd %d tells fd is not open.\n",
>>>>> - pollfd[i].fd);
>>>>> - num_hup++;
>>>>> - break;
>>>>> - case POLLPRI:
>>>>> - pthread_rwlock_rdlock(&fd_pairs_lock);
>>>>> - if(pthread_mutex_trylock(&fd_pairs->pair[i-inotify_fds].mutex) == 0) {
>>>>> - printf_verbose(
>>>>> - "Urgent read on fd %d\n",
>>>>> - pollfd[i].fd);
>>>>> - /* Take care of high priority channels first. */
>>>>> - high_prio = 1;
>>>>> - /* it's ok to have an unavailable sub-buffer */
>>>>> - ret = read_subbuffer(&fd_pairs->pair[i-inotify_fds]);
>>>>> - if(ret == EAGAIN) ret = 0;
>>>>> -
>>>>> - ret = pthread_mutex_unlock(&fd_pairs->pair[i-inotify_fds].mutex);
>>>>> - if(ret)
>>>>> - printf("Error in mutex unlock : %s\n", strerror(ret));
>>>>> - }
>>>>> - pthread_rwlock_unlock(&fd_pairs_lock);
>>>>> - break;
>>>>> - }
>>>>> - }
>>>>> - /* If every buffer FD has hung up, we end the read loop here */
>>>>> - if(num_hup == num_pollfd - inotify_fds) break;
>>>>> -
>>>>> - if(!high_prio) {
>>>>> - for(i=inotify_fds;i<num_pollfd;i++) {
>>>>> - switch(pollfd[i].revents) {
>>>>> - case POLLIN:
>>>>> - pthread_rwlock_rdlock(&fd_pairs_lock);
>>>>> - if(pthread_mutex_trylock(&fd_pairs->pair[i-inotify_fds].mutex) == 0) {
>>>>> - /* Take care of low priority channels. */
>>>>> - printf_verbose(
>>>>> - "Normal read on fd %d\n",
>>>>> - pollfd[i].fd);
>>>>> - /* it's ok to have an unavailable subbuffer */
>>>>> - ret = read_subbuffer(&fd_pairs->pair[i-inotify_fds]);
>>>>> - if(ret == EAGAIN) ret = 0;
>>>>> -
>>>>> - ret = pthread_mutex_unlock(&fd_pairs->pair[i-inotify_fds].mutex);
>>>>> - if(ret)
>>>>> - printf("Error in mutex unlock : %s\n", strerror(ret));
>>>>> - }
>>>>> - pthread_rwlock_unlock(&fd_pairs_lock);
>>>>> - break;
>>>>> - }
>>>>> - }
>>>>> - }
>>>>> -
>>>>> - /* Update pollfd array if an entry was added to fd_pairs */
>>>>> - pthread_rwlock_rdlock(&fd_pairs_lock);
>>>>> - if((inotify_fds + fd_pairs->num_pairs) != num_pollfd) {
>>>>> - pollfd = realloc(pollfd,
>>>>> - (inotify_fds + fd_pairs->num_pairs) * sizeof(struct pollfd));
>>>>> - for(i=num_pollfd-inotify_fds;i<fd_pairs->num_pairs;i++) {
>>>>> - pollfd[inotify_fds+i].fd = fd_pairs->pair[i].channel;
>>>>> - pollfd[inotify_fds+i].events = POLLIN|POLLPRI;
>>>>> - }
>>>>> - num_pollfd = fd_pairs->num_pairs + inotify_fds;
>>>>> - }
>>>>> - pthread_rwlock_unlock(&fd_pairs_lock);
>>>>> -
>>>>> - /* NB: If the fd_pairs structure is updated by another thread from this
>>>>> - * point forward, the current thread will wait in the poll without
>>>>> - * monitoring the new channel. However, this thread will add the
>>>>> - * new channel on next poll (and this should not take too much time
>>>>> - * on a loaded system).
>>>>> - *
>>>>> - * This event is quite unlikely and can only occur if a CPU is
>>>>> - * hot-plugged while multple lttd threads are running.
>>>>> - */
>>>>> - }
>>>>> -
>>>>> -free_fd:
>>>>> - free(pollfd);
>>>>> -
>>>>> -end:
>>>>> - return ret;
>>>>> -}
>>>>> -
>>>>> -
>>>>> -void close_channel_trace_pairs(struct channel_trace_fd *fd_pairs, int inotify_fd,
>>>>> - struct inotify_watch_array *iwatch_array)
>>>>> -{
>>>>> - int i;
>>>>> +int on_new_thread(struct liblttd_callbacks *data, unsigned long thread_num) {
>>>>> int ret;
>>>>> -
>>>>> - for(i=0;i<fd_pairs->num_pairs;i++) {
>>>>> - ret = close(fd_pairs->pair[i].channel);
>>>>> - if(ret == -1) perror("Close error on channel");
>>>>> - ret = close(fd_pairs->pair[i].trace);
>>>>> - if(ret == -1) perror("Close error on trace");
>>>>> - }
>>>>> - free(fd_pairs->pair);
>>>>> - free(iwatch_array->elem);
>>>>> -}
>>>>> -
>>>>> -/* Thread worker */
>>>>> -void * thread_main(void *arg)
>>>>> -{
>>>>> - long ret;
>>>>> - unsigned long thread_num = (unsigned long)arg;
>>>>> -
>>>>> ret = pipe(thread_pipe);
>>>>> if (ret< 0) {
>>>>> perror("Error creating pipe");
>>>>> - return (void*)ret;
>>>>> + return ret;
>>>>> }
>>>>> - ret = read_channels(thread_num,&fd_pairs, inotify_fd,&inotify_watch_array);
>>>>> - close(thread_pipe[0]); /* close read end */
>>>>> - close(thread_pipe[1]); /* close write end */
>>>>> - return (void*)ret;
>>>>> + return 0;
>>>>> }
>>>>>
>>>>> -
>>>>> -int channels_init()
>>>>> -{
>>>>> - int ret = 0;
>>>>> -
>>>>> - inotify_fd = inotify_init();
>>>>> - fcntl(inotify_fd, F_SETFL, O_NONBLOCK);
>>>>> -
>>>>> - if(ret = open_channel_trace_pairs(channel_name, trace_name,&fd_pairs,
>>>>> - &inotify_fd,&inotify_watch_array))
>>>>> - goto close_channel;
>>>>> - if (fd_pairs.num_pairs == 0) {
>>>>> - printf("No channel available for reading, exiting\n");
>>>>> - ret = -ENOENT;
>>>>> - goto close_channel;
>>>>> - }
>>>>> - if(ret = map_channels(&fd_pairs, 0, fd_pairs.num_pairs))
>>>>> - goto close_channel;
>>>>> +int on_close_thread(struct liblttd_callbacks *data, unsigned long thread_num) {
>>>>> + close(thread_pipe[0]); /* close read end */
>>>>> + close(thread_pipe[1]); /* close write end */
>>>>> return 0;
>>>>> -
>>>>> -close_channel:
>>>>> - close_channel_trace_pairs(&fd_pairs, inotify_fd,&inotify_watch_array);
>>>>> - if(inotify_fd>= 0)
>>>>> - close(inotify_fd);
>>>>> - return ret;
>>>>> }
>>>>>
>>>>> -
>>>>> int main(int argc, char ** argv)
>>>>> {
>>>>> int ret = 0;
>>>>> struct sigaction act;
>>>>> - pthread_t *tids;
>>>>> - unsigned long i;
>>>>> - void *tret;
>>>>> -
>>>>> +
>>>>> + struct liblttd_callbacks callbacks = {
>>>>> + lttd_on_open_channel,
>>>>> + lttd_on_close_channel,
>>>>> + lttd_on_new_channels_folder,
>>>>> + lttd_on_read_subbuffer,
>>>>> + NULL,
>>>>> + on_new_thread,
>>>>> + on_close_thread,
>>>>> + NULL
>>>>> + };
>>>>> +
>>>>> ret = parse_arguments(argc, argv);
>>>>>
>>>>> if(ret != 0) show_arguments();
>>>>> @@ -996,9 +357,6 @@ int main(int argc, char ** argv)
>>>>> sigaction(SIGQUIT,&act, NULL);
>>>>> sigaction(SIGINT,&act, NULL);
>>>>>
>>>>> - if(ret = channels_init())
>>>>> - return ret;
>>>>> -
>>>>> if(daemon_mode) {
>>>>> ret = daemon(0, 0);
>>>>>
>>>>> @@ -1008,33 +366,13 @@ int main(int argc, char ** argv)
>>>>> }
>>>>> }
>>>>>
>>>>> - tids = malloc(sizeof(pthread_t) * num_threads);
>>>>> - for(i=0; i<num_threads; i++) {
>>>>> -
>>>>> - ret = pthread_create(&tids[i], NULL, thread_main, (void*)i);
>>>>> - if(ret) {
>>>>> - perror("Error creating thread");
>>>>> - break;
>>>>> - }
>>>>> - }
>>>>> + strncpy(path_trace, trace_name, PATH_MAX-1);
>>>>> + path_trace_len = strlen(path_trace);
>>>>> + end_path_trace = path_trace + path_trace_len;
>>>>>
>>>>> - for(i=0; i<num_threads; i++) {
>>>>> - ret = pthread_join(tids[i],&tret);
>>>>> - if(ret) {
>>>>> - perror("Error joining thread");
>>>>> - break;
>>>>> - }
>>>>> - if((long)tret != 0) {
>>>>> - printf("Error %s occured in thread %u\n",
>>>>> - strerror((long)tret), i);
>>>>> - }
>>>>> - }
>>>>> + liblttd_start(channel_name, num_threads, dump_flight_only, dump_normal_only,
>>>>> + verbose_mode,&callbacks);
>>>>>
>>>>> - free(tids);
>>>>> - ret = unmap_channels(&fd_pairs);
>>>>> - close_channel_trace_pairs(&fd_pairs, inotify_fd,&inotify_watch_array);
>>>>> - if(inotify_fd>= 0)
>>>>> - close(inotify_fd);
>>>>> -
>>>>> return ret;
>>>>> }
>>>>> +
>>>>>
>>>>
>>>>> diff --git a/liblttd/liblttd.c b/liblttd/liblttd.c
>>>>> index 0f0e5b5..0f703f5 100644
>>>>> --- a/liblttd/liblttd.c
>>>>> +++ b/liblttd/liblttd.c
>>>>> @@ -75,8 +75,6 @@ static inline int inotify_rm_watch (int fd, __u32 wd)
>>>>> #undef HAS_INOTIFY
>>>>> #endif
>>>>>
>>>>> -struct liblttd_callbacks *callbacks;
>>>>> -
>>>>> struct channel_trace_fd {
>>>>> struct fd_pair *pair;
>>>>> int num_pairs;
>>>>> @@ -93,41 +91,50 @@ struct inotify_watch_array {
>>>>> int num;
>>>>> };
>>>>>
>>>>> -struct channel_trace_fd fd_pairs = { NULL, 0 };
>>>>> -int inotify_fd = -1;
>>>>> -struct inotify_watch_array inotify_watch_array = { NULL, 0 };
>>>>> +struct liblttd_instance {
>>>>> + struct liblttd_callbacks *callbacks;
>>>>> +
>>>>> + int inotify_fd;
>>>>> + struct channel_trace_fd fd_pairs;
>>>>> + struct inotify_watch_array inotify_watch_array;
>>>>>
>>>>> -/* protects fd_pairs and inotify_watch_array */
>>>>> -pthread_rwlock_t fd_pairs_lock = PTHREAD_RWLOCK_INITIALIZER;
>>>>> + /* protects fd_pairs and inotify_watch_array */
>>>>> + pthread_rwlock_t fd_pairs_lock;
>>>>>
>>>>> -static char *channel_name = NULL;
>>>>> -static unsigned long num_threads = 1;
>>>>> -volatile static int quit_program = 0; /* For signal handler */
>>>>> -static int dump_flight_only = 0;
>>>>> -static int dump_normal_only = 0;
>>>>> -static int verbose_mode = 0;
>>>>> + char channel_name[PATH_MAX];
>>>>> + unsigned long num_threads;
>>>>> + int quit_program; /* For signal handler */
>>>>> + int dump_flight_only;
>>>>> + int dump_normal_only;
>>>>> + int verbose_mode;
>>>>> +};
>>>>> +
>>>>> +struct liblttd_thread_data {
>>>>> + int thread_num;
>>>>> + struct liblttd_instance *instance;
>>>>> +};
>>>>>
>>>>> #define printf_verbose(fmt, args...) \
>>>>> do { \
>>>>> - if (verbose_mode) \
>>>>> + if (instance->verbose_mode) \
>>>>> printf(fmt, ##args); \
>>>>> } while (0)
>>>>>
>>>>>
>>>>> -int open_buffer_file(char *filename, char *path_channel,
>>>>> - char *base_path_channel, struct channel_trace_fd *fd_pairs)
>>>>> +int open_buffer_file(struct liblttd_instance *instance, char *filename,
>>>>> + char *path_channel, char *base_path_channel)
>>>>> {
>>>>> int open_ret = 0;
>>>>> int ret = 0;
>>>>>
>>>>> if(strncmp(filename, "flight-", sizeof("flight-")-1) != 0) {
>>>>> - if(dump_flight_only) {
>>>>> + if(instance->dump_flight_only) {
>>>>> printf_verbose("Skipping normal channel %s\n",
>>>>> path_channel);
>>>>> return 0;
>>>>> }
>>>>> } else {
>>>>> - if(dump_normal_only) {
>>>>> + if(instance->dump_normal_only) {
>>>>> printf_verbose("Skipping flight channel %s\n",
>>>>> path_channel);
>>>>> return 0;
>>>>> @@ -135,26 +142,26 @@ int open_buffer_file(char *filename, char *path_channel,
>>>>> }
>>>>> printf_verbose("Opening file.\n");
>>>>>
>>>>> - fd_pairs->pair = realloc(fd_pairs->pair,
>>>>> - ++fd_pairs->num_pairs * sizeof(struct fd_pair));
>>>>> + instance->fd_pairs.pair = realloc(instance->fd_pairs.pair,
>>>>> + ++instance->fd_pairs.num_pairs * sizeof(struct fd_pair));
>>>>>
>>>>> /* Open the channel in read mode */
>>>>> - fd_pairs->pair[fd_pairs->num_pairs-1].channel =
>>>>> + instance->fd_pairs.pair[instance->fd_pairs.num_pairs-1].channel =
>>>>> open(path_channel, O_RDONLY | O_NONBLOCK);
>>>>> - if(fd_pairs->pair[fd_pairs->num_pairs-1].channel == -1) {
>>>>> + if(instance->fd_pairs.pair[instance->fd_pairs.num_pairs-1].channel == -1) {
>>>>> perror(path_channel);
>>>>> - fd_pairs->num_pairs--;
>>>>> + instance->fd_pairs.num_pairs--;
>>>>> return 0; /* continue */
>>>>> }
>>>>>
>>>>> - if(callbacks->on_open_channel) ret = callbacks->on_open_channel(
>>>>> - callbacks,&fd_pairs->pair[fd_pairs->num_pairs-1],
>>>>> + if(instance->callbacks->on_open_channel) ret = instance->callbacks->on_open_channel(
>>>>> + instance->callbacks,&instance->fd_pairs.pair[instance->fd_pairs.num_pairs-1],
>>>>> base_path_channel);
>>>>>
>>>>> if(ret != 0) {
>>>>> open_ret = -1;
>>>>> - close(fd_pairs->pair[fd_pairs->num_pairs-1].channel);
>>>>> - fd_pairs->num_pairs--;
>>>>> + close(instance->fd_pairs.pair[instance->fd_pairs.num_pairs-1].channel);
>>>>> + instance->fd_pairs.num_pairs--;
>>>>> goto end;
>>>>> }
>>>>>
>>>>> @@ -162,10 +169,8 @@ end:
>>>>> return open_ret;
>>>>> }
>>>>>
>>>>> -int open_channel_trace_pairs(char *subchannel_name,
>>>>> - char *base_subchannel_name,
>>>>> - struct channel_trace_fd *fd_pairs, int *inotify_fd,
>>>>> - struct inotify_watch_array *iwatch_array)
>>>>> +int open_channel_trace_pairs(struct liblttd_instance *instance,
>>>>> + char *subchannel_name, char *base_subchannel_name)
>>>>> {
>>>>> DIR *channel_dir = opendir(subchannel_name);
>>>>> struct dirent *entry;
>>>>> @@ -184,9 +189,9 @@ int open_channel_trace_pairs(char *subchannel_name,
>>>>> goto end;
>>>>> }
>>>>>
>>>>> - printf_verbose("Calling on new channels folder");
>>>>> - if(callbacks->on_new_channels_folder) ret = callbacks->
>>>>> - on_new_channels_folder(callbacks,
>>>>> + printf_verbose("Calling on new channels folder\n");
>>>>> + if(instance->callbacks->on_new_channels_folder) ret = instance->callbacks->
>>>>> + on_new_channels_folder(instance->callbacks,
>>>>> base_subchannel_name);
>>>>> if(ret == -1) {
>>>>> open_ret = -1;
>>>>> @@ -202,18 +207,18 @@ int open_channel_trace_pairs(char *subchannel_name,
>>>>> (base_subchannel_name - subchannel_name);
>>>>>
>>>>> #ifdef HAS_INOTIFY
>>>>> - iwatch_array->elem = realloc(iwatch_array->elem,
>>>>> - ++iwatch_array->num * sizeof(struct inotify_watch));
>>>>> + instance->inotify_watch_array.elem = realloc(instance->inotify_watch_array.elem,
>>>>> + ++instance->inotify_watch_array.num * sizeof(struct inotify_watch));
>>>>>
>>>>> printf_verbose("Adding inotify for channel %s\n", path_channel);
>>>>> - iwatch_array->elem[iwatch_array->num-1].wd = inotify_add_watch(*inotify_fd, path_channel, IN_CREATE);
>>>>> - strcpy(iwatch_array->elem[iwatch_array->num-1].path_channel, path_channel);
>>>>> - iwatch_array->elem[iwatch_array->num-1].base_path_channel =
>>>>> - iwatch_array->elem[iwatch_array->num-1].path_channel +
>>>>> + instance->inotify_watch_array.elem[instance->inotify_watch_array.num-1].wd = inotify_add_watch(instance->inotify_fd, path_channel, IN_CREATE);
>>>>> + strcpy(instance->inotify_watch_array.elem[instance->inotify_watch_array.num-1].path_channel, path_channel);
>>>>> + instance->inotify_watch_array.elem[instance->inotify_watch_array.num-1].base_path_channel =
>>>>> + instance->inotify_watch_array.elem[instance->inotify_watch_array.num-1].path_channel +
>>>>> (base_subchannel_name - subchannel_name);
>>>>> printf_verbose("Added inotify for channel %s, wd %u\n",
>>>>> - iwatch_array->elem[iwatch_array->num-1].path_channel,
>>>>> - iwatch_array->elem[iwatch_array->num-1].wd);
>>>>> + instance->inotify_watch_array.elem[instance->inotify_watch_array.num-1].path_channel,
>>>>> + instance->inotify_watch_array.elem[instance->inotify_watch_array.num-1].wd);
>>>>> #endif
>>>>>
>>>>> while((entry = readdir(channel_dir)) != NULL) {
>>>>> @@ -233,12 +238,11 @@ int open_channel_trace_pairs(char *subchannel_name,
>>>>> if(S_ISDIR(stat_buf.st_mode)) {
>>>>>
>>>>> printf_verbose("Entering channel subdirectory...\n");
>>>>> - ret = open_channel_trace_pairs(path_channel, base_subchannel_ptr, fd_pairs,
>>>>> - inotify_fd, iwatch_array);
>>>>> + ret = open_channel_trace_pairs(instance, path_channel, base_subchannel_ptr);
>>>>> if(ret< 0) continue;
>>>>> } else if(S_ISREG(stat_buf.st_mode)) {
>>>>> - open_ret = open_buffer_file(entry->d_name, path_channel, base_subchannel_ptr,
>>>>> - fd_pairs);
>>>>> + open_ret = open_buffer_file(instance, entry->d_name,
>>>>> + path_channel, base_subchannel_ptr);
>>>>> if(open_ret)
>>>>> goto end;
>>>>> }
>>>>> @@ -251,7 +255,7 @@ end:
>>>>> }
>>>>>
>>>>>
>>>>> -int read_subbuffer(struct fd_pair *pair)
>>>>> +int read_subbuffer(struct liblttd_instance *instance, struct fd_pair *pair)
>>>>> {
>>>>> unsigned int consumed_old, len;
>>>>> int err;
>>>>> @@ -274,8 +278,8 @@ int read_subbuffer(struct fd_pair *pair)
>>>>> goto get_error;
>>>>> }
>>>>>
>>>>> - if(callbacks->on_read_subbuffer) ret = callbacks->on_read_subbuffer(
>>>>> - callbacks, pair, len);
>>>>> + if(instance->callbacks->on_read_subbuffer) ret = instance->callbacks->on_read_subbuffer(
>>>>> + instance->callbacks, pair, len);
>>>>>
>>>>> write_error:
>>>>> ret = 0;
>>>>> @@ -296,13 +300,12 @@ get_error:
>>>>> }
>>>>>
>>>>>
>>>>> -int map_channels(struct channel_trace_fd *fd_pairs,
>>>>> - int idx_begin, int idx_end)
>>>>> +int map_channels(struct liblttd_instance *instance, int idx_begin, int idx_end)
>>>>> {
>>>>> int i,j;
>>>>> int ret=0;
>>>>>
>>>>> - if(fd_pairs->num_pairs<= 0) {
>>>>> + if(instance->fd_pairs.num_pairs<= 0) {
>>>>> printf("No channel to read\n");
>>>>> goto end;
>>>>> }
>>>>> @@ -310,7 +313,7 @@ int map_channels(struct channel_trace_fd *fd_pairs,
>>>>> /* Get the subbuf sizes and number */
>>>>>
>>>>> for(i=idx_begin;i<idx_end;i++) {
>>>>> - struct fd_pair *pair =&fd_pairs->pair[i];
>>>>> + struct fd_pair *pair =&instance->fd_pairs.pair[i];
>>>>>
>>>>> ret = ioctl(pair->channel, RELAY_GET_N_SB,&pair->n_sb);
>>>>> if(ret != 0) {
>>>>> @@ -334,14 +337,14 @@ end:
>>>>> return ret;
>>>>> }
>>>>>
>>>>> -int unmap_channels(struct channel_trace_fd *fd_pairs)
>>>>> +int unmap_channels(struct liblttd_instance *instance)
>>>>> {
>>>>> int j;
>>>>> int ret=0;
>>>>>
>>>>> /* Munmap each FD */
>>>>> - for(j=0;j<fd_pairs->num_pairs;j++) {
>>>>> - struct fd_pair *pair =&fd_pairs->pair[j];
>>>>> + for(j=0;j<instance->fd_pairs.num_pairs;j++) {
>>>>> + struct fd_pair *pair =&instance->fd_pairs.pair[j];
>>>>> int err_ret;
>>>>>
>>>>> err_ret = pthread_mutex_destroy(&pair->mutex);
>>>>> @@ -359,10 +362,7 @@ int unmap_channels(struct channel_trace_fd *fd_pairs)
>>>>> *
>>>>> * Only support add file for now.
>>>>> */
>>>>> -
>>>>> -int read_inotify(int inotify_fd,
>>>>> - struct channel_trace_fd *fd_pairs,
>>>>> - struct inotify_watch_array *iwatch_array)
>>>>> +int read_inotify(struct liblttd_instance *instance)
>>>>> {
>>>>> char buf[sizeof(struct inotify_event) + PATH_MAX];
>>>>> char path_channel[PATH_MAX];
>>>>> @@ -374,7 +374,7 @@ int read_inotify(int inotify_fd,
>>>>> int old_num;
>>>>>
>>>>> offset = 0;
>>>>> - len = read(inotify_fd, buf, sizeof(struct inotify_event) + PATH_MAX);
>>>>> + len = read(instance->inotify_fd, buf, sizeof(struct inotify_event) + PATH_MAX);
>>>>> if(len< 0) {
>>>>>
>>>>> if(errno == EAGAIN)
>>>>> @@ -385,24 +385,24 @@ int read_inotify(int inotify_fd,
>>>>> }
>>>>> while(offset< len) {
>>>>> ievent = (struct inotify_event *)&(buf[offset]);
>>>>> - for(i=0; i<iwatch_array->num; i++) {
>>>>> - if(iwatch_array->elem[i].wd == ievent->wd&&
>>>>> + for(i=0; i<instance->inotify_watch_array.num; i++) {
>>>>> + if(instance->inotify_watch_array.elem[i].wd == ievent->wd&&
>>>>> ievent->mask == IN_CREATE) {
>>>>> printf_verbose(
>>>>> "inotify wd %u event mask : %u for %s%s\n",
>>>>> ievent->wd, ievent->mask,
>>>>> - iwatch_array->elem[i].path_channel,
>>>>> + instance->inotify_watch_array.elem[i].path_channel,
>>>>> ievent->name);
>>>>> - old_num = fd_pairs->num_pairs;
>>>>> - strcpy(path_channel, iwatch_array->elem[i].path_channel);
>>>>> + old_num = instance->fd_pairs.num_pairs;
>>>>> + strcpy(path_channel, instance->inotify_watch_array.elem[i].path_channel);
>>>>> strcat(path_channel, ievent->name);
>>>>> - if(ret = open_buffer_file(ievent->name, path_channel,
>>>>> - path_channel + (iwatch_array->elem[i].base_path_channel -
>>>>> - iwatch_array->elem[i].path_channel), fd_pairs)) {
>>>>> + if(ret = open_buffer_file(instance, ievent->name, path_channel,
>>>>> + path_channel + (instance->inotify_watch_array.elem[i].base_path_channel -
>>>>> + instance->inotify_watch_array.elem[i].path_channel))) {
>>>>> printf("Error opening buffer file\n");
>>>>> return -1;
>>>>> }
>>>>> - if(ret = map_channels(fd_pairs, old_num, fd_pairs->num_pairs)) {
>>>>> + if(ret = map_channels(instance, old_num, instance->fd_pairs.num_pairs)) {
>>>>> printf("Error mapping channel\n");
>>>>> return -1;
>>>>> }
>>>>> @@ -432,8 +432,7 @@ int read_inotify(int inotify_fd,
>>>>> * full.
>>>>> */
>>>>>
>>>>> -int read_channels(unsigned long thread_num, struct channel_trace_fd *fd_pairs,
>>>>> - int inotify_fd, struct inotify_watch_array *iwatch_array)
>>>>> +int read_channels(struct liblttd_instance *instance, unsigned long thread_num)
>>>>> {
>>>>> struct pollfd *pollfd = NULL;
>>>>> int num_pollfd;
>>>>> @@ -450,24 +449,24 @@ int read_channels(unsigned long thread_num, struct channel_trace_fd *fd_pairs,
>>>>> inotify_fds = 0;
>>>>> #endif
>>>>>
>>>>> - pthread_rwlock_rdlock(&fd_pairs_lock);
>>>>> + pthread_rwlock_rdlock(&instance->fd_pairs_lock);
>>>>>
>>>>> /* Start polling the FD. Keep one fd for inotify */
>>>>> - pollfd = malloc((inotify_fds + fd_pairs->num_pairs) * sizeof(struct pollfd));
>>>>> + pollfd = malloc((inotify_fds + instance->fd_pairs.num_pairs) * sizeof(struct pollfd));
>>>>>
>>>>> #ifdef HAS_INOTIFY
>>>>> - pollfd[0].fd = inotify_fd;
>>>>> + pollfd[0].fd = instance->inotify_fd;
>>>>> pollfd[0].events = POLLIN|POLLPRI;
>>>>> #endif
>>>>>
>>>>> - for(i=0;i<fd_pairs->num_pairs;i++) {
>>>>> - pollfd[inotify_fds+i].fd = fd_pairs->pair[i].channel;
>>>>> + for(i=0;i<instance->fd_pairs.num_pairs;i++) {
>>>>> + pollfd[inotify_fds+i].fd = instance->fd_pairs.pair[i].channel;
>>>>> pollfd[inotify_fds+i].events = POLLIN|POLLPRI;
>>>>> }
>>>>> - num_pollfd = inotify_fds + fd_pairs->num_pairs;
>>>>> + num_pollfd = inotify_fds + instance->fd_pairs.num_pairs;
>>>>>
>>>>>
>>>>> - pthread_rwlock_unlock(&fd_pairs_lock);
>>>>> + pthread_rwlock_unlock(&instance->fd_pairs_lock);
>>>>>
>>>>> while(1) {
>>>>> high_prio = 0;
>>>>> @@ -480,7 +479,7 @@ int read_channels(unsigned long thread_num, struct channel_trace_fd *fd_pairs,
>>>>> #endif //DEBUG
>>>>>
>>>>> /* Have we received a signal ? */
>>>>> - if(quit_program) break;
>>>>> + if(instance->quit_program) break;
>>>>>
>>>>> num_rdy = poll(pollfd, num_pollfd, -1);
>>>>>
>>>>> @@ -513,9 +512,9 @@ int read_channels(unsigned long thread_num, struct channel_trace_fd *fd_pairs,
>>>>> "Polling inotify fd %d : data ready.\n",
>>>>> pollfd[0].fd);
>>>>>
>>>>> - pthread_rwlock_wrlock(&fd_pairs_lock);
>>>>> - read_inotify(inotify_fd, fd_pairs, iwatch_array);
>>>>> - pthread_rwlock_unlock(&fd_pairs_lock);
>>>>> + pthread_rwlock_wrlock(&instance->fd_pairs_lock);
>>>>> + read_inotify(instance);
>>>>> + pthread_rwlock_unlock(&instance->fd_pairs_lock);
>>>>>
>>>>> break;
>>>>> }
>>>>> @@ -542,22 +541,22 @@ int read_channels(unsigned long thread_num, struct channel_trace_fd *fd_pairs,
>>>>> num_hup++;
>>>>> break;
>>>>> case POLLPRI:
>>>>> - pthread_rwlock_rdlock(&fd_pairs_lock);
>>>>> - if(pthread_mutex_trylock(&fd_pairs->pair[i-inotify_fds].mutex) == 0) {
>>>>> + pthread_rwlock_rdlock(&instance->fd_pairs_lock);
>>>>> + if(pthread_mutex_trylock(&instance->fd_pairs.pair[i-inotify_fds].mutex) == 0) {
>>>>> printf_verbose(
>>>>> "Urgent read on fd %d\n",
>>>>> pollfd[i].fd);
>>>>> /* Take care of high priority channels first. */
>>>>> high_prio = 1;
>>>>> /* it's ok to have an unavailable sub-buffer */
>>>>> - ret = read_subbuffer(&fd_pairs->pair[i-inotify_fds]);
>>>>> + ret = read_subbuffer(instance,&instance->fd_pairs.pair[i-inotify_fds]);
>>>>> if(ret == EAGAIN) ret = 0;
>>>>>
>>>>> - ret = pthread_mutex_unlock(&fd_pairs->pair[i-inotify_fds].mutex);
>>>>> + ret = pthread_mutex_unlock(&instance->fd_pairs.pair[i-inotify_fds].mutex);
>>>>> if(ret)
>>>>> printf("Error in mutex unlock : %s\n", strerror(ret));
>>>>> }
>>>>> - pthread_rwlock_unlock(&fd_pairs_lock);
>>>>> + pthread_rwlock_unlock(&instance->fd_pairs_lock);
>>>>> break;
>>>>> }
>>>>> }
>>>>> @@ -568,38 +567,38 @@ int read_channels(unsigned long thread_num, struct channel_trace_fd *fd_pairs,
>>>>> for(i=inotify_fds;i<num_pollfd;i++) {
>>>>> switch(pollfd[i].revents) {
>>>>> case POLLIN:
>>>>> - pthread_rwlock_rdlock(&fd_pairs_lock);
>>>>> - if(pthread_mutex_trylock(&fd_pairs->pair[i-inotify_fds].mutex) == 0) {
>>>>> + pthread_rwlock_rdlock(&instance->fd_pairs_lock);
>>>>> + if(pthread_mutex_trylock(&instance->fd_pairs.pair[i-inotify_fds].mutex) == 0) {
>>>>> /* Take care of low priority channels. */
>>>>> printf_verbose(
>>>>> "Normal read on fd %d\n",
>>>>> pollfd[i].fd);
>>>>> /* it's ok to have an unavailable subbuffer */
>>>>> - ret = read_subbuffer(&fd_pairs->pair[i-inotify_fds]);
>>>>> + ret = read_subbuffer(instance,&instance->fd_pairs.pair[i-inotify_fds]);
>>>>> if(ret == EAGAIN) ret = 0;
>>>>>
>>>>> - ret = pthread_mutex_unlock(&fd_pairs->pair[i-inotify_fds].mutex);
>>>>> + ret = pthread_mutex_unlock(&instance->fd_pairs.pair[i-inotify_fds].mutex);
>>>>> if(ret)
>>>>> printf("Error in mutex unlock : %s\n", strerror(ret));
>>>>> }
>>>>> - pthread_rwlock_unlock(&fd_pairs_lock);
>>>>> + pthread_rwlock_unlock(&instance->fd_pairs_lock);
>>>>> break;
>>>>> }
>>>>> }
>>>>> }
>>>>>
>>>>> /* Update pollfd array if an entry was added to fd_pairs */
>>>>> - pthread_rwlock_rdlock(&fd_pairs_lock);
>>>>> - if((inotify_fds + fd_pairs->num_pairs) != num_pollfd) {
>>>>> + pthread_rwlock_rdlock(&instance->fd_pairs_lock);
>>>>> + if((inotify_fds + instance->fd_pairs.num_pairs) != num_pollfd) {
>>>>> pollfd = realloc(pollfd,
>>>>> - (inotify_fds + fd_pairs->num_pairs) * sizeof(struct pollfd));
>>>>> - for(i=num_pollfd-inotify_fds;i<fd_pairs->num_pairs;i++) {
>>>>> - pollfd[inotify_fds+i].fd = fd_pairs->pair[i].channel;
>>>>> + (inotify_fds + instance->fd_pairs.num_pairs) * sizeof(struct pollfd));
>>>>> + for(i=num_pollfd-inotify_fds;i<instance->fd_pairs.num_pairs;i++) {
>>>>> + pollfd[inotify_fds+i].fd = instance->fd_pairs.pair[i].channel;
>>>>> pollfd[inotify_fds+i].events = POLLIN|POLLPRI;
>>>>> }
>>>>> - num_pollfd = fd_pairs->num_pairs + inotify_fds;
>>>>> + num_pollfd = instance->fd_pairs.num_pairs + inotify_fds;
>>>>> }
>>>>> - pthread_rwlock_unlock(&fd_pairs_lock);
>>>>> + pthread_rwlock_unlock(&instance->fd_pairs_lock);
>>>>>
>>>>> /* NB: If the fd_pairs structure is updated by another thread from this
>>>>> * point forward, the current thread will wait in the poll without
>>>>> @@ -620,104 +619,111 @@ end:
>>>>> }
>>>>>
>>>>>
>>>>> -void close_channel_trace_pairs(struct channel_trace_fd *fd_pairs, int inotify_fd,
>>>>> - struct inotify_watch_array *iwatch_array)
>>>>> +void close_channel_trace_pairs(struct liblttd_instance *instance)
>>>>> {
>>>>> int i;
>>>>> int ret;
>>>>>
>>>>> - for(i=0;i<fd_pairs->num_pairs;i++) {
>>>>> - ret = close(fd_pairs->pair[i].channel);
>>>>> + for(i=0;i<instance->fd_pairs.num_pairs;i++) {
>>>>> + ret = close(instance->fd_pairs.pair[i].channel);
>>>>> if(ret == -1) perror("Close error on channel");
>>>>> - if(callbacks->on_close_channel) {
>>>>> - ret = callbacks->on_close_channel(
>>>>> - callbacks,&fd_pairs->pair[i]);
>>>>> + if(instance->callbacks->on_close_channel) {
>>>>> + ret = instance->callbacks->on_close_channel(
>>>>> + instance->callbacks,&instance->fd_pairs.pair[i]);
>>>>> if(ret != 0) perror("Error on close channel callback");
>>>>> }
>>>>> }
>>>>> - free(fd_pairs->pair);
>>>>> - free(iwatch_array->elem);
>>>>> + free(instance->fd_pairs.pair);
>>>>> + free(instance->inotify_watch_array.elem);
>>>>> }
>>>>>
>>>>> /* Thread worker */
>>>>> void * thread_main(void *arg)
>>>>> {
>>>>> long ret = 0;
>>>>> - unsigned long thread_num = (unsigned long)arg;
>>>>> + struct liblttd_thread_data *thread_data = (struct liblttd_thread_data*) arg;
>>>>>
>>>>> - if(callbacks->on_new_thread)
>>>>> - ret = callbacks->on_new_thread(callbacks, thread_num);
>>>>> + if(thread_data->instance->callbacks->on_new_thread)
>>>>> + ret = thread_data->instance->callbacks->on_new_thread(
>>>>> + thread_data->instance->callbacks, thread_data->thread_num);
>>>>>
>>>>> if (ret< 0) {
>>>>> return (void*)ret;
>>>>> }
>>>>> - ret = read_channels(thread_num,&fd_pairs, inotify_fd,&inotify_watch_array);
>>>>> + ret = read_channels(thread_data->instance, thread_data->thread_num);
>>>>> +
>>>>> + if(thread_data->instance->callbacks->on_close_thread)
>>>>> + thread_data->instance->callbacks->on_close_thread(
>>>>> + thread_data->instance->callbacks, thread_data->thread_num);
>>>>>
>>>>> - if(callbacks->on_close_thread)
>>>>> - callbacks->on_close_thread(callbacks, thread_num);
>>>>> + free(thread_data);
>>>>>
>>>>> return (void*)ret;
>>>>> }
>>>>>
>>>>> -/*on_close_thread has to be reentrant, it'll be called by many threads*/
>>>>> -int(*on_close_thread)(struct liblttd_callbacks *data, unsigned long thread_num);
>>>>> -
>>>>> -int channels_init()
>>>>> +int channels_init(struct liblttd_instance *instance)
>>>>> {
>>>>> int ret = 0;
>>>>>
>>>>> - inotify_fd = inotify_init();
>>>>> - fcntl(inotify_fd, F_SETFL, O_NONBLOCK);
>>>>> + instance->inotify_fd = inotify_init();
>>>>> + fcntl(instance->inotify_fd, F_SETFL, O_NONBLOCK);
>>>>>
>>>>> - if(ret = open_channel_trace_pairs(channel_name,
>>>>> - channel_name + strlen(channel_name),&fd_pairs,
>>>>> - &inotify_fd,&inotify_watch_array))
>>>>> + if(ret = open_channel_trace_pairs(instance, instance->channel_name,
>>>>> + instance->channel_name +
>>>>> + strlen(instance->channel_name)))
>>>>> goto close_channel;
>>>>> - if (fd_pairs.num_pairs == 0) {
>>>>> + if (instance->fd_pairs.num_pairs == 0) {
>>>>> printf("No channel available for reading, exiting\n");
>>>>> ret = -ENOENT;
>>>>> goto close_channel;
>>>>> }
>>>>> - if(ret = map_channels(&fd_pairs, 0, fd_pairs.num_pairs))
>>>>> +
>>>>> + if(ret = map_channels(instance, 0, instance->fd_pairs.num_pairs))
>>>>> goto close_channel;
>>>>> return 0;
>>>>>
>>>>> close_channel:
>>>>> - close_channel_trace_pairs(&fd_pairs, inotify_fd,&inotify_watch_array);
>>>>> - if(inotify_fd>= 0)
>>>>> - close(inotify_fd);
>>>>> + close_channel_trace_pairs(instance);
>>>>> + if(instance->inotify_fd>= 0)
>>>>> + close(instance->inotify_fd);
>>>>> return ret;
>>>>> }
>>>>>
>>>>> -int liblttd_start(char *channel_path, unsigned long n_threads,
>>>>> - int flight_only, int normal_only, int verbose,
>>>>> - struct liblttd_callbacks *user_data){
>>>>> +int delete_instance(struct liblttd_instance *instance)
>>>>> +{
>>>>> + pthread_rwlock_destroy(&instance->fd_pairs_lock);
>>>>> + free(instance);
>>>>> + return 0;
>>>>> +}
>>>>> +
>>>>> +int liblttd_start_instance(struct liblttd_instance *instance)
>>>>> +{
>>>>> int ret = 0;
>>>>> pthread_t *tids;
>>>>> unsigned long i;
>>>>> void *tret;
>>>>>
>>>>> - channel_name = channel_path;
>>>>> - num_threads = n_threads;
>>>>> - dump_flight_only = flight_only;
>>>>> - dump_normal_only = normal_only;
>>>>> - verbose_mode = verbose;
>>>>> - callbacks = user_data;
>>>>> + if(!instance)
>>>>> + return -EINVAL;
>>>>>
>>>>> - if(ret = channels_init())
>>>>> + if(ret = channels_init(instance))
>>>>> return ret;
>>>>>
>>>>> - tids = malloc(sizeof(pthread_t) * num_threads);
>>>>> - for(i=0; i<num_threads; i++) {
>>>>> + tids = malloc(sizeof(pthread_t) * instance->num_threads);
>>>>> + for(i=0; i<instance->num_threads; i++) {
>>>>> + struct liblttd_thread_data *thread_data =
>>>>> + malloc(sizeof(struct liblttd_thread_data));
>>>>> + thread_data->thread_num = i;
>>>>> + thread_data->instance = instance;
>>>>>
>>>>> - ret = pthread_create(&tids[i], NULL, thread_main, (void*)i);
>>>>> + ret = pthread_create(&tids[i], NULL, thread_main, thread_data);
>>>>> if(ret) {
>>>>> perror("Error creating thread");
>>>>> break;
>>>>> }
>>>>> }
>>>>>
>>>>> - for(i=0; i<num_threads; i++) {
>>>>> + for(i=0; i<instance->num_threads; i++) {
>>>>> ret = pthread_join(tids[i],&tret);
>>>>> if(ret) {
>>>>> perror("Error joining thread");
>>>>> @@ -730,18 +736,55 @@ int liblttd_start(char *channel_path, unsigned long n_threads,
>>>>> }
>>>>>
>>>>> free(tids);
>>>>> - ret = unmap_channels(&fd_pairs);
>>>>> - close_channel_trace_pairs(&fd_pairs, inotify_fd,&inotify_watch_array);
>>>>> - if(inotify_fd>= 0)
>>>>> - close(inotify_fd);
>>>>> + ret = unmap_channels(instance);
>>>>> + close_channel_trace_pairs(instance);
>>>>> + if(instance->inotify_fd>= 0)
>>>>> + close(instance->inotify_fd);
>>>>>
>>>>> - if(callbacks->on_trace_end) callbacks->on_trace_end(callbacks);
>>>>> + if(instance->callbacks->on_trace_end)
>>>>> + instance->callbacks->on_trace_end(instance->callbacks);
>>>>> +
>>>>> + delete_instance(instance);
>>>>>
>>>>> return ret;
>>>>> }
>>>>>
>>>>> -int liblttd_stop() {
>>>>> - quit_program = 1;
>>>>> +struct liblttd_instance * liblttd_new_instance(
>>>>> + struct liblttd_callbacks *callbacks, char *channel_path,
>>>>> + unsigned long n_threads, int flight_only, int normal_only, int verbose)
>>>>> +{
>>>>> + struct liblttd_instance * instance;
>>>>> + if(!channel_path || !callbacks) return NULL;
>>>>> + if(n_threads == 0) n_threads = 1;
>>>>> + if(flight_only&& normal_only) return NULL;
>>>>> +
>>>>> + instance = malloc(sizeof(struct liblttd_instance));
>>>>> + if(!instance) return NULL;
>>>>> +
>>>>> + instance->callbacks = callbacks;
>>>>> +
>>>>> + instance->inotify_fd = -1;
>>>>> +
>>>>> + instance->fd_pairs.pair = NULL;
>>>>> + instance->fd_pairs.num_pairs = 0;
>>>>> +
>>>>> + instance->inotify_watch_array.elem = NULL;
>>>>> + instance->inotify_watch_array.num = 0;
>>>>> +
>>>>> + pthread_rwlock_init(&instance->fd_pairs_lock, NULL);
>>>>> +
>>>>> + strncpy(instance->channel_name, channel_path, PATH_MAX -1);
>>>>> + instance->num_threads = n_threads;
>>>>> + instance->dump_flight_only = flight_only;
>>>>> + instance->dump_normal_only = normal_only;
>>>>> + instance->verbose_mode = verbose;
>>>>> +
>>>>> + return instance;
>>>>> +}
>>>>> +
>>>>> +int liblttd_stop_instance(struct liblttd_instance *instance)
>>>>> +{
>>>>> + instance->quit_program = 1;
>>>>> return 0;
>>>>> }
>>>>>
>>>>> diff --git a/liblttd/liblttd.h b/liblttd/liblttd.h
>>>>> index bd76eeb..02e7e9c 100644
>>>>> --- a/liblttd/liblttd.h
>>>>> +++ b/liblttd/liblttd.h
>>>>> @@ -23,196 +23,192 @@
>>>>> #include<pthread.h>
>>>>>
>>>>> /**
>>>>> -* This structure contains the data associated with the channel file descriptor.
>>>>> -* The lib user can use user_data to store the data associated to the specified
>>>>> -* channel. The lib user can read but MUST NOT change the other attributes.
>>>>> -*/
>>>>> + * struct fd_pair - Contains the data associated with the channel file
>>>>> + * descriptor. The lib user can use user_data to store the data associated to
>>>>> + * the specified channel. The lib user can read but MUST NOT change the other
>>>>> + * attributes.
>>>>> + * @channel: channel file descriptor
>>>>> + * @n_sb: the number of subbuffer for this channel
>>>>> + * @max_sb_size: the subbuffer size for this channel
>>>>> + * @mmap: Not used anymore.
>>>>> + * @mutex: a mutex for internal library usage
>>>>> + * @user_data: library user data
>>>>> + */
>>>>> struct fd_pair {
>>>>> - /**
>>>>> - * This is the channel file descriptor.
>>>>> - */
>>>>> int channel;
>>>>> -
>>>>> - /**
>>>>> - * This is the number of subbuffer for this channel.
>>>>> - */
>>>>> unsigned int n_sb;
>>>>> -
>>>>> - /**
>>>>> - * This is the subbuffer size for this channel.
>>>>> - */
>>>>> unsigned int max_sb_size;
>>>>> -
>>>>> - /**
>>>>> - * Not used anymore.
>>>>> - */
>>>>> void *mmap;
>>>>> -
>>>>> - /**
>>>>> - * This is a mutex for internal library usage.
>>>>> - */
>>>>> pthread_mutex_t mutex;
>>>>> -
>>>>> - /**
>>>>> - * Library user data.
>>>>> - */
>>>>> void *user_data;
>>>>> };
>>>>>
>>>>> +struct liblttd_instance;
>>>>> +
>>>>> /**
>>>>> -* This structure contains the necessary callbacks for a tracing session. The
>>>>> -* user can set the unnecessary functions to NULL if he does not need them.
>>>>> +* struct liblttd_callbacks - Contains the necessary callbacks for a tracing
>>>>> +* session. The user can set the unnecessary functions to NULL if he does not
>>>>> +* need them.
>>>>> */
>>>>> struct liblttd_callbacks {
>>>>> /**
>>>>> - * This callback is called after a channel file is open.
>>>>> - *
>>>>> - * @args data This argument is a pointeur to the callbacks struct that
>>>>> - * has been passed to the lib.
>>>>> - * @args pair This structure contains the data associated with the
>>>>> - * channel file descriptor. The lib user can use user_data to
>>>>> - * store the data associated to the specified channel.
>>>>> - * @args relative_channel_path This argument represents a relative path
>>>>> - * to the channel file. This path is relative to the root
>>>>> - * folder of the trace channels.
>>>>> - *
>>>>> - * @return Should return 0 if the callback succeeds else not 0.
>>>>> - */
>>>>> + * on_open_channel - Is called after a channel file is open.
>>>>> + * @data: pointeur to the callbacks struct that has been passed to the
>>>>> + * lib.
>>>>> + * @pair: structure that contains the data associated with the
>>>>> + * channel file descriptor. The lib user can use user_data to
>>>>> + * store the data associated to the specified channel.
>>>>> + * @relative_channel_path: represents a relative path to the channel
>>>>> + * file. This path is relative to the root folder of the trace channels.
>>>>> + *
>>>>> + * Returns 0 if the callback succeeds else not 0.
>>>>> + */
>>>>> int(*on_open_channel)(struct liblttd_callbacks *data,
>>>>> struct fd_pair *pair, char *relative_channel_path);
>>>>>
>>>>> /**
>>>>> - * This callback is called after a channel file is closed.
>>>>> - *
>>>>> - * @remarks After a channel file has been closed, it will never be read
>>>>> - * again.
>>>>> - *
>>>>> - * @args data This argument is a pointeur to the callbacks struct that
>>>>> - * has been passed to the lib.
>>>>> - * @args pair This structure contains the data associated with the
>>>>> - * channel file descriptor. The lib user should clean
>>>>> - * user_data at this time.
>>>>> - *
>>>>> - * @return Should return 0 if the callback succeeds else not 0.
>>>>> - */
>>>>> + * on_close_channel - Is called after a channel file is closed.
>>>>> + * @data: pointeur to the callbacks struct that has been passed to the
>>>>> + * lib.
>>>>> + * @pair: structure that contains the data associated with the channel
>>>>> + * file descriptor. The lib user should clean user_data at this time.
>>>>> + *
>>>>> + * Returns 0 if the callback succeeds else not 0.
>>>>> + *
>>>>> + * After a channel file has been closed, it will never be read again.
>>>>> + */
>>>>> int(*on_close_channel)(struct liblttd_callbacks *data,
>>>>> struct fd_pair *pair);
>>>>>
>>>>> -
>>>>> /**
>>>>> - * This callback is called when the library enter in a new subfolder
>>>>> - * while it is scanning the trace channel tree. It can be used to create
>>>>> - * the output file structure of the trace.
>>>>> - *
>>>>> - * @args data This argument is a pointeur to the callbacks struct that
>>>>> - * has been passed to the lib.
>>>>> - * @args relative_folder_path This argument represents a relative path
>>>>> - * to the channel folder. This path is relative to the root
>>>>> - * folder of the trace channels.
>>>>> - *
>>>>> - * @return Should return 0 if the callback succeeds else not 0.
>>>>> - */
>>>>> + * on_new_channels_folder - Is called when the library enter in a new
>>>>> + * subfolder while it is scanning the trace channel tree. It can be used
>>>>> + * to create the output file structure of the trace.
>>>>> + * @data: pointeur to the callbacks struct that has been passed to the
>>>>> + * lib.
>>>>> + * @relative_folder_path: represents a relative path
>>>>> + * to the channel folder. This path is relative to the root
>>>>> + * folder of the trace channels.
>>>>> + *
>>>>> + * Returns 0 if the callback succeeds else not 0.
>>>>> + */
>>>>> int(*on_new_channels_folder)(struct liblttd_callbacks *data,
>>>>> char *relative_folder_path);
>>>>>
>>>>> /**
>>>>> - * This callback is called after a subbuffer is a reserved.
>>>>> - *
>>>>> - * @attention It has to be thread safe, it'll be called by many threads.
>>>>> - *
>>>>> - * @args data This argument is a pointeur to the callbacks struct that
>>>>> - * has been passed to the lib.
>>>>> - * @args pair This structure contains the data associated with the
>>>>> - * channel file descriptor. The lib user should clean
>>>>> - * user_data at this time.
>>>>> - * @args len This argument represents the length the data that has to be
>>>>> - * read.
>>>>> - *
>>>>> - * @return Should return 0 if the callback succeeds else not 0.
>>>>> - */
>>>>> + * on_read_subbuffer - Is called after a subbuffer is a reserved.
>>>>> + *
>>>>> + * @data: pointeur to the callbacks struct that has been passed to the
>>>>> + * lib.
>>>>> + * @pair: structure that contains the data associated with the
>>>>> + * channel file descriptor.
>>>>> + * @len: represents the length the data that has to be read.
>>>>> + *
>>>>> + * Returns 0 if the callback succeeds else not 0.
>>>>> + *
>>>>> + * It has to be thread safe, it'll be called by many threads.
>>>>> + */
>>>>> int(*on_read_subbuffer)(struct liblttd_callbacks *data,
>>>>> struct fd_pair *pair, unsigned int len);
>>>>>
>>>>> /**
>>>>> - * This callback is called at the very end of the tracing session. At
>>>>> - * this time, all the channels have been closed and the threads have been
>>>>> - * destroyed.
>>>>> - *
>>>>> - * @remarks After this callback is called, no other callback will be
>>>>> - * called again.
>>>>> - *
>>>>> - * @attention It has to be thread safe, it'll be called by many threads.
>>>>> - *
>>>>> - * @args data This argument is a pointeur to the callbacks struct that
>>>>> - * has been passed to the lib.
>>>>> - *
>>>>> - * @return Should return 0 if the callback succeeds else not 0.
>>>>> - */
>>>>> + * on_trace_en - Is called at the very end of the tracing session. At
>>>>> + * this time, all the channels have been closed and the threads have
>>>>> + * been destroyed.
>>>>> + *
>>>>> + * @data: pointeur to the callbacks struct that has been passed to the
>>>>> + * lib.
>>>>> + *
>>>>> + * Returns 0 if the callback succeeds else not 0.
>>>>> + *
>>>>> + * It has to be thread safe, it'll be called by many threads.
>>>>> + * After this callback is called, no other callback will be called
>>>>> + * again and the tracing instance will be deleted automatically by
>>>>> + * liblttd. After this call, the user must not use the liblttd instance.
>>>>> + */
>>>>> int(*on_trace_end)(struct liblttd_callbacks *data);
>>>>>
>>>>> /**
>>>>> - * This callback is called after a new thread has been created.
>>>>> - *
>>>>> - * @attention It has to be thread safe, it'll be called by many threads.
>>>>> - *
>>>>> - * @args data This argument is a pointeur to the callbacks struct that
>>>>> - * has been passed to the lib.
>>>>> - * @args thread_num This argument represents the id of the thread.
>>>>> - *
>>>>> - * @return Should return 0 if the callback succeeds else not 0.
>>>>> - */
>>>>> + * on_new_thread - Is called after a new thread has been created.
>>>>> + *
>>>>> + * @data: pointeur to the callbacks struct that has been passed to the
>>>>> + * lib.
>>>>> + * @thread_num: represents the id of the thread.
>>>>> + *
>>>>> + * Returns 0 if the callback succeeds else not 0.
>>>>> + *
>>>>> + * It has to be thread safe, it'll be called by many threads.
>>>>> + */
>>>>> int(*on_new_thread)(struct liblttd_callbacks *data,
>>>>> unsigned long thread_num);
>>>>>
>>>>> /**
>>>>> - * This callback is called just before a thread is destroyed.
>>>>> - *
>>>>> - * @attention It has to be thread safe, it'll be called by many threads.
>>>>> - *
>>>>> - * @args data This argument is a pointeur to the callbacks struct that
>>>>> - * has been passed to the lib.
>>>>> - * @args thread_num This argument represents the number of the thread.
>>>>> - *
>>>>> - * @return Should return 0 if the callback succeeds else not 0.
>>>>> - */
>>>>> + * on_close_thread - Is Called just before a thread is destroyed.
>>>>> + *
>>>>> + * @data: pointeur to the callbacks struct that has been passed to the
>>>>> + * lib.
>>>>> + * @thread_num: represents the number of the thread.
>>>>> + *
>>>>> + * Returns 0 if the callback succeeds else not 0.
>>>>> + *
>>>>> + * It has to be thread safe, it'll be called by many threads.
>>>>> + */
>>>>> int(*on_close_thread)(struct liblttd_callbacks *data,
>>>>> unsigned long thread_num);
>>>>>
>>>>> /**
>>>>> - * This is where the user can put the library's data.
>>>>> - */
>>>>> + * The library's data.
>>>>> + */
>>>>> void *user_data;
>>>>> };
>>>>>
>>>>> /**
>>>>> -* This function is called to start a new tracing session.
>>>>> -*
>>>>> -* @attention It has to be thread safe, it'll be called by many threads.
>>>>> -*
>>>>> -* @args channel_path This argument is a path to the root folder of the trace's
>>>>> -* channels.
>>>>> -* @args n_threads This argument represents the number of threads that will be
>>>>> -* used by the library.
>>>>> -* @args flight_only If this argument to set to 1, only the channel that are in
>>>>> -* flight recorder mode will be recorded.
>>>>> -* @args normal_only If this argument to set to 1, only the channel that are in
>>>>> -* normal mode will be recorded.
>>>>> -* @args verbose If this argument to set to 1, more informations will be printed.
>>>>> -* @args user_data This argument is a pointeur to the callbacks struct that
>>>>> -* contains the user's functions.
>>>>> -*
>>>>> -* @return Return 0 if the function succeeds else not 0.
>>>>> -*/
>>>>> -int liblttd_start(char *channel_path, unsigned long n_threads,
>>>>> - int flight_only, int normal_only, int verbose,
>>>>> - struct liblttd_callbacks *user_data);
>>>>> + * liblttd_new_instance - Is called to create a new tracing session.
>>>>> + *
>>>>> + * @callbacks: Pointer to a callbacks struct that contain the user callbacks and
>>>>> + * data.
>>>>> + * @channel_path: This argument is a path to the root folder of the trace's
>>>>> + * channels.
>>>>> + * @n_threads: This argument represents the number of threads that will be
>>>>> + * used by the library.
>>>>> + * @flight_only: If this argument to set to 1, only the channel that are in
>>>>> + * flight recorder mode will be recorded.
>>>>> + * @normal_only: If this argument to set to 1, only the channel that are in
>>>>> + * normal mode will be recorded.
>>>>> + * @verbose: If this argument to set to 1, more informations will be printed.
>>>>> + *
>>>>> + * Returns the instance if the function succeeds else NULL.
>>>>> + */
>>>>> +struct liblttd_instance * liblttd_new_instance(
>>>>> + struct liblttd_callbacks *callbacks, char *channel_path,
>>>>> + unsigned long n_threads, int flight_only, int normal_only, int verbose);
>>>>>
>>>>> /**
>>>>> -* This function is called to stop a tracing session.
>>>>> -*
>>>>> -* @return Return 0 if the function succeeds.
>>>>> -*/
>>>>> -int liblttd_stop();
>>>>> + * liblttd_start - Is called to start a new tracing session.
>>>>> + *
>>>>> + * @instance: The tracing session instance that needs to be starded.
>>>>> + *
>>>>> + * Returns 0 if the function succeeds.
>>>>> + *
>>>>> + * This is a blocking function. The caller will be bloked on it until the
>>>>> + * tracing session is stoped by the user usign liblttd_stop_instance or until
>>>>> + * the trace is stoped by LTTng directly.
>>>>> + */
>>>>> +int liblttd_start_instance(struct liblttd_instance *instance);
>>>>> +
>>>>> +/**
>>>>> + * liblttd_stop - Is called to stop a tracing session.
>>>>> + *
>>>>> + * @instance: The tracing session instance that needs to be stoped.
>>>>> + *
>>>>> + * Returns 0 if the function succeeds.
>>>>> + *
>>>>> + * This function return immediately, it only tells liblttd to stop the instance.
>>>>> + * The on_trace_end callback will be called when the tracing session will really
>>>>> + * be stoped (after every thread will be done). The instance is deleted
>>>>> + * automatically by liblttd after on_trace_end is called.
>>>>> + */
>>>>> +int liblttd_stop_instance(struct liblttd_instance *instance);
>>>>>
>>>>> #endif /*_LIBLTTD_H */
>>>>>
>>>>> diff --git a/lttd/lttd.c b/lttd/lttd.c
>>>>> index ec757ae..d3c12d5 100644
>>>>> --- a/lttd/lttd.c
>>>>> +++ b/lttd/lttd.c
>>>>> @@ -46,6 +46,7 @@ struct lttd_channel_data {
>>>>> int trace;
>>>>> };
>>>>>
>>>>> +struct liblttd_instance *instance;
>>>>> static char path_trace[PATH_MAX];
>>>>> static char *end_path_trace;
>>>>> static int path_trace_len = 0;
>>>>> @@ -191,7 +192,7 @@ void show_info(void)
>>>>> static void handler(int signo)
>>>>> {
>>>>> printf("Signal %d received : exiting cleanly\n", signo);
>>>>> - liblttd_stop();
>>>>> + liblttd_stop_instance(instance);
>>>>> }
>>>>>
>>>>> int lttd_on_open_channel(struct liblttd_callbacks *data, struct fd_pair *pair, char *relative_channel_path)
>>>>> @@ -306,7 +307,8 @@ write_error:
>>>>> return ret;
>>>>> }
>>>>>
>>>>> -int on_new_thread(struct liblttd_callbacks *data, unsigned long thread_num) {
>>>>> +int lttd_on_new_thread(struct liblttd_callbacks *data, unsigned long thread_num)
>>>>> +{
>>>>> int ret;
>>>>> ret = pipe(thread_pipe);
>>>>> if (ret< 0) {
>>>>> @@ -316,7 +318,8 @@ int on_new_thread(struct liblttd_callbacks *data, unsigned long thread_num) {
>>>>> return 0;
>>>>> }
>>>>>
>>>>> -int on_close_thread(struct liblttd_callbacks *data, unsigned long thread_num) {
>>>>> +int lttd_on_close_thread(struct liblttd_callbacks *data, unsigned long thread_num)
>>>>> +{
>>>>> close(thread_pipe[0]); /* close read end */
>>>>> close(thread_pipe[1]); /* close write end */
>>>>> return 0;
>>>>> @@ -333,8 +336,8 @@ int main(int argc, char ** argv)
>>>>> lttd_on_new_channels_folder,
>>>>> lttd_on_read_subbuffer,
>>>>> NULL,
>>>>> - on_new_thread,
>>>>> - on_close_thread,
>>>>> + lttd_on_new_thread,
>>>>> + lttd_on_close_thread,
>>>>> NULL
>>>>> };
>>>>>
>>>>> @@ -365,13 +368,18 @@ int main(int argc, char ** argv)
>>>>> exit(-1);
>>>>> }
>>>>> }
>>>>> -
>>>>> strncpy(path_trace, trace_name, PATH_MAX-1);
>>>>> path_trace_len = strlen(path_trace);
>>>>> end_path_trace = path_trace + path_trace_len;
>>>>>
>>>>> - liblttd_start(channel_name, num_threads, dump_flight_only, dump_normal_only,
>>>>> - verbose_mode,&callbacks);
>>>>> + instance = liblttd_new_instance(&callbacks, channel_name, num_threads,
>>>>> + dump_flight_only, dump_normal_only, verbose_mode);
>>>>> + if(!instance) {
>>>>> + perror("An error occured while creating the liblttd instance");
>>>>> + return ret;
>>>>> + }
>>>>> +
>>>>> + liblttd_start_instance(instance);
>>>>>
>>>>> return ret;
>>>>> }
>>>>>
>>>>
>>>>> diff --git a/liblttd/Makefile.am b/liblttd/Makefile.am
>>>>> index 3c1eeda..43859be 100644
>>>>> --- a/liblttd/Makefile.am
>>>>> +++ b/liblttd/Makefile.am
>>>>> @@ -1,7 +1,7 @@
>>>>>
>>>>>
>>>>> lib_LTLIBRARIES = liblttd.la
>>>>> -liblttd_la_SOURCES = liblttd.c
>>>>> +liblttd_la_SOURCES = liblttd.c liblttdutils.c
>>>>>
>>>>> liblttdinclude_HEADERS = \
>>>>> - liblttd.h
>>>>> + liblttd.h liblttdutils.h
>>>>> diff --git a/liblttd/liblttd.c b/liblttd/liblttd.c
>>>>> index 0f703f5..7ae01f8 100644
>>>>> --- a/liblttd/liblttd.c
>>>>> +++ b/liblttd/liblttd.c
>>>>> @@ -1,4 +1,4 @@
>>>>> -/* lttd
>>>>> +/* libttd
>>>>> *
>>>>> * Linux Trace Toolkit Daemon
>>>>> *
>>>>> @@ -9,6 +9,9 @@
>>>>> *
>>>>> * Copyright 2005 -
>>>>> * Mathieu Desnoyers<mathieu.desnoyers at polymtl.ca>
>>>>> + * Copyright 2010 -
>>>>> + * Michael Sills-Lavoie<michael.sills-lavoie at polymtl.ca>
>>>>> + * Oumarou Dicko<oumarou.dicko at polymtl.ca>
>>>>> */
>>>>>
>>>>> #ifdef HAVE_CONFIG_H
>>>>> @@ -75,40 +78,6 @@ static inline int inotify_rm_watch (int fd, __u32 wd)
>>>>> #undef HAS_INOTIFY
>>>>> #endif
>>>>>
>>>>> -struct channel_trace_fd {
>>>>> - struct fd_pair *pair;
>>>>> - int num_pairs;
>>>>> -};
>>>>> -
>>>>> -struct inotify_watch {
>>>>> - int wd;
>>>>> - char path_channel[PATH_MAX];
>>>>> - char *base_path_channel;
>>>>> -};
>>>>> -
>>>>> -struct inotify_watch_array {
>>>>> - struct inotify_watch *elem;
>>>>> - int num;
>>>>> -};
>>>>> -
>>>>> -struct liblttd_instance {
>>>>> - struct liblttd_callbacks *callbacks;
>>>>> -
>>>>> - int inotify_fd;
>>>>> - struct channel_trace_fd fd_pairs;
>>>>> - struct inotify_watch_array inotify_watch_array;
>>>>> -
>>>>> - /* protects fd_pairs and inotify_watch_array */
>>>>> - pthread_rwlock_t fd_pairs_lock;
>>>>> -
>>>>> - char channel_name[PATH_MAX];
>>>>> - unsigned long num_threads;
>>>>> - int quit_program; /* For signal handler */
>>>>> - int dump_flight_only;
>>>>> - int dump_normal_only;
>>>>> - int verbose_mode;
>>>>> -};
>>>>> -
>>>>> struct liblttd_thread_data {
>>>>> int thread_num;
>>>>> struct liblttd_instance *instance;
>>>>> @@ -189,7 +158,7 @@ int open_channel_trace_pairs(struct liblttd_instance *instance,
>>>>> goto end;
>>>>> }
>>>>>
>>>>> - printf_verbose("Calling on new channels folder\n");
>>>>> + printf_verbose("Calling : on new channels folder\n");
>>>>> if(instance->callbacks->on_new_channels_folder) ret = instance->callbacks->
>>>>> on_new_channels_folder(instance->callbacks,
>>>>> base_subchannel_name);
>>>>> @@ -742,7 +711,7 @@ int liblttd_start_instance(struct liblttd_instance *instance)
>>>>> close(instance->inotify_fd);
>>>>>
>>>>> if(instance->callbacks->on_trace_end)
>>>>> - instance->callbacks->on_trace_end(instance->callbacks);
>>>>> + instance->callbacks->on_trace_end(instance);
>>>>>
>>>>> delete_instance(instance);
>>>>>
>>>>> diff --git a/liblttd/liblttd.h b/liblttd/liblttd.h
>>>>> index 02e7e9c..d871dd7 100644
>>>>> --- a/liblttd/liblttd.h
>>>>> +++ b/liblttd/liblttd.h
>>>>> @@ -1,10 +1,11 @@
>>>>> /* liblttd header file
>>>>> *
>>>>> + * Copyright 2005 -
>>>>> + * Mathieu Desnoyers<mathieu.desnoyers at polymtl.ca>
>>>>> * Copyright 2010-
>>>>> * Oumarou Dicko<oumarou.dicko at polymtl.ca>
>>>>> * Michael Sills-Lavoie<michael.sills-lavoie at polymtl.ca>
>>>>> *
>>>>> - *
>>>>> * This program is free software; you can redistribute it and/or modify
>>>>> * it under the terms of the GNU General Public License as published by
>>>>> * the Free Software Foundation; either version 2 of the License, or
>>>>> @@ -21,6 +22,7 @@
>>>>> #define _LIBLTTD_H
>>>>>
>>>>> #include<pthread.h>
>>>>> +#include<dirent.h>
>>>>>
>>>>> /**
>>>>> * struct fd_pair - Contains the data associated with the channel file
>>>>> @@ -43,7 +45,46 @@ struct fd_pair {
>>>>> void *user_data;
>>>>> };
>>>>>
>>>>> -struct liblttd_instance;
>>>>> +struct channel_trace_fd {
>>>>> + struct fd_pair *pair;
>>>>> + int num_pairs;
>>>>> +};
>>>>> +
>>>>> +struct inotify_watch {
>>>>> + int wd;
>>>>> + char path_channel[PATH_MAX];
>>>>> + char *base_path_channel;
>>>>> +};
>>>>> +
>>>>> +struct inotify_watch_array {
>>>>> + struct inotify_watch *elem;
>>>>> + int num;
>>>>> +};
>>>>> +
>>>>> +struct liblttd_callbacks;
>>>>> +
>>>>> +/**
>>>>> + * struct liblttd_instance - Contains the data associated with a trace instance.
>>>>> + * The lib user can read but MUST NOT change any attributes but callbacks.
>>>>> + * @callbacks: Contains the necessary callbacks for a tracing session.
>>>>> + */
>>>>> +struct liblttd_instance {
>>>>> + struct liblttd_callbacks *callbacks;
>>>>> +
>>>>> + int inotify_fd;
>>>>> + struct channel_trace_fd fd_pairs;
>>>>> + struct inotify_watch_array inotify_watch_array;
>>>>> +
>>>>> + /* protects fd_pairs and inotify_watch_array */
>>>>> + pthread_rwlock_t fd_pairs_lock;
>>>>> +
>>>>> + char channel_name[PATH_MAX];
>>>>> + unsigned long num_threads;
>>>>> + int quit_program;
>>>>> + int dump_flight_only;
>>>>> + int dump_normal_only;
>>>>> + int verbose_mode;
>>>>> +};
>>>>>
>>>>> /**
>>>>> * struct liblttd_callbacks - Contains the necessary callbacks for a tracing
>>>>> @@ -116,17 +157,16 @@ struct liblttd_callbacks {
>>>>> * this time, all the channels have been closed and the threads have
>>>>> * been destroyed.
>>>>> *
>>>>> - * @data: pointeur to the callbacks struct that has been passed to the
>>>>> - * lib.
>>>>> + * @instance: pointeur to the instance struct that has been passed to
>>>>> + * the lib.
>>>>> *
>>>>> * Returns 0 if the callback succeeds else not 0.
>>>>> *
>>>>> - * It has to be thread safe, it'll be called by many threads.
>>>>> * After this callback is called, no other callback will be called
>>>>> * again and the tracing instance will be deleted automatically by
>>>>> * liblttd. After this call, the user must not use the liblttd instance.
>>>>> */
>>>>> - int(*on_trace_end)(struct liblttd_callbacks *data);
>>>>> + int(*on_trace_end)(struct liblttd_instance *instance);
>>>>>
>>>>> /**
>>>>> * on_new_thread - Is called after a new thread has been created.
>>>>> diff --git a/liblttd/liblttdutils.c b/liblttd/liblttdutils.c
>>>>> new file mode 100644
>>>>> index 0000000..3368aba
>>>>> --- /dev/null
>>>>> +++ b/liblttd/liblttdutils.c
>>>>> @@ -0,0 +1,229 @@
>>>>> +/* liblttdutils
>>>>> + *
>>>>> + * Linux Trace Toolkit utility library
>>>>> + *
>>>>> + * This is a simple daemon implementation that reads a few relay+debugfs
>>>>> + * channels and save them in a trace.
>>>>> + *
>>>>> + * CPU hot-plugging is supported using inotify.
>>>>> + *
>>>>> + * Copyright 2005 -
>>>>> + * Mathieu Desnoyers<mathieu.desnoyers at polymtl.ca>
>>>>> + * Copyright 2010 -
>>>>> + * Michael Sills-Lavoie<michael.sills-lavoie at polymtl.ca>
>>>>> + * Oumarou Dicko<oumarou.dicko at polymtl.ca>
>>>>> + */
>>>>> +
>>>>> +#ifdef HAVE_CONFIG_H
>>>>> +#include<config.h>
>>>>> +#endif
>>>>> +
>>>>> +#define _REENTRANT
>>>>> +#define _GNU_SOURCE
>>>>> +
>>>>> +#include<stdio.h>
>>>>> +#include<stdlib.h>
>>>>> +#include<string.h>
>>>>> +#include<errno.h>
>>>>> +#include<fcntl.h>
>>>>> +#include<dirent.h>
>>>>> +#include<pthread.h>
>>>>> +#include<sys/stat.h>
>>>>> +
>>>>> +#include "liblttdutils.h"
>>>>> +
>>>>> +struct liblttdutils_channel_data {
>>>>> + int trace;
>>>>> +};
>>>>> +
>>>>> +struct liblttdutils_data {
>>>>> + char path_trace[PATH_MAX];
>>>>> + char *end_path_trace;
>>>>> + int path_trace_len;
>>>>> + int append_mode;
>>>>> + int verbose_mode;
>>>>> +};
>>>>> +
>>>>> +static __thread int thread_pipe[2];
>>>>> +
>>>>> +#define printf_verbose(fmt, args...) \
>>>>> + do { \
>>>>> + if (callbacks_data->verbose_mode) \
>>>>> + printf(fmt, ##args); \
>>>>> + } while (0)
>>>>> +
>>>>> +int liblttdutils_local_on_open_channel(struct liblttd_callbacks *data, struct fd_pair *pair, char *relative_channel_path)
>>>>> +{
>>>>> + int open_ret = 0;
>>>>> + int ret;
>>>>> + struct stat stat_buf;
>>>>> + struct liblttdutils_channel_data *channel_data;
>>>>> +
>>>>> + pair->user_data = malloc(sizeof(struct liblttdutils_channel_data));
>>>>> + channel_data = pair->user_data;
>>>>> +
>>>>> + struct liblttdutils_data* callbacks_data = data->user_data;
>>>>> +
>>>>> + strncpy(callbacks_data->end_path_trace, relative_channel_path, PATH_MAX - callbacks_data->path_trace_len);
>>>>> + printf_verbose("Creating trace file %s\n", callbacks_data->path_trace);
>>>>> +
>>>>> + ret = stat(callbacks_data->path_trace,&stat_buf);
>>>>> + if(ret == 0) {
>>>>> + if(callbacks_data->append_mode) {
>>>>> + printf_verbose("Appending to file %s as requested\n",
>>>>> + callbacks_data->path_trace);
>>>>> +
>>>>> + channel_data->trace = open(callbacks_data->path_trace, O_WRONLY, S_IRWXU|S_IRWXG|S_IRWXO);
>>>>> + if(channel_data->trace == -1) {
>>>>> + perror(callbacks_data->path_trace);
>>>>> + open_ret = -1;
>>>>> + goto end;
>>>>> + }
>>>>> + ret = lseek(channel_data->trace, 0, SEEK_END);
>>>>> + if (ret< 0) {
>>>>> + perror(callbacks_data->path_trace);
>>>>> + open_ret = -1;
>>>>> + close(channel_data->trace);
>>>>> + goto end;
>>>>> + }
>>>>> + } else {
>>>>> + printf("File %s exists, cannot open. Try append mode.\n", callbacks_data->path_trace);
>>>>> + open_ret = -1;
>>>>> + goto end;
>>>>> + }
>>>>> + } else {
>>>>> + if(errno == ENOENT) {
>>>>> + channel_data->trace =
>>>>> + open(callbacks_data->path_trace, O_WRONLY|O_CREAT|O_EXCL, S_IRWXU|S_IRWXG|S_IRWXO);
>>>>> + if(channel_data->trace == -1) {
>>>>> + perror(callbacks_data->path_trace);
>>>>> + open_ret = -1;
>>>>> + goto end;
>>>>> + }
>>>>> + }
>>>>> + }
>>>>> +
>>>>> +end:
>>>>> + return open_ret;
>>>>> +
>>>>> +}
>>>>> +
>>>>> +int liblttdutils_local_on_close_channel(struct liblttd_callbacks *data, struct fd_pair *pair)
>>>>> +{
>>>>> + int ret;
>>>>> + ret = close(((struct liblttdutils_channel_data *)(pair->user_data))->trace);
>>>>> + free(pair->user_data);
>>>>> + return ret;
>>>>> +}
>>>>> +
>>>>> +int liblttdutils_local_on_new_channels_folder(struct liblttd_callbacks *data, char *relative_folder_path)
>>>>> +{
>>>>> + int ret;
>>>>> + int open_ret = 0;
>>>>> + struct liblttdutils_data* callbacks_data = data->user_data;
>>>>> +
>>>>> + strncpy(callbacks_data->end_path_trace, relative_folder_path, PATH_MAX - callbacks_data->path_trace_len);
>>>>> + printf_verbose("Creating trace subdirectory %s\n", callbacks_data->path_trace);
>>>>> +
>>>>> + ret = mkdir(callbacks_data->path_trace, S_IRWXU|S_IRWXG|S_IRWXO);
>>>>> + if(ret == -1) {
>>>>> + if(errno != EEXIST) {
>>>>> + perror(callbacks_data->path_trace);
>>>>> + open_ret = -1;
>>>>> + goto end;
>>>>> + }
>>>>> + }
>>>>> +
>>>>> +end:
>>>>> + return open_ret;
>>>>> +}
>>>>> +
>>>>> +int liblttdutils_local_on_read_subbuffer(struct liblttd_callbacks *data, struct fd_pair *pair, unsigned int len)
>>>>> +{
>>>>> + long ret;
>>>>> + off_t offset = 0;
>>>>> +
>>>>> + struct liblttdutils_data* callbacks_data = data->user_data;
>>>>> +
>>>>> + while (len> 0) {
>>>>> + printf_verbose("splice chan to pipe offset %lu\n",
>>>>> + (unsigned long)offset);
>>>>> + ret = splice(pair->channel,&offset, thread_pipe[1], NULL,
>>>>> + len, SPLICE_F_MOVE | SPLICE_F_MORE);
>>>>> + printf_verbose("splice chan to pipe ret %ld\n", ret);
>>>>> + if (ret< 0) {
>>>>> + perror("Error in relay splice");
>>>>> + goto write_error;
>>>>> + }
>>>>> + ret = splice(thread_pipe[0], NULL,
>>>>> + ((struct liblttdutils_channel_data *)(pair->user_data))->trace,
>>>>> + NULL, ret, SPLICE_F_MOVE | SPLICE_F_MORE);
>>>>> + printf_verbose("splice pipe to file %ld\n", ret);
>>>>> + if (ret< 0) {
>>>>> + perror("Error in file splice");
>>>>> + goto write_error;
>>>>> + }
>>>>> + len -= ret;
>>>>> + }
>>>>> +
>>>>> +write_error:
>>>>> + return ret;
>>>>> +}
>>>>> +
>>>>> +int liblttdutils_local_on_new_thread(struct liblttd_callbacks *data, unsigned long thread_num)
>>>>> +{
>>>>> + int ret;
>>>>> + ret = pipe(thread_pipe);
>>>>> + if (ret< 0) {
>>>>> + perror("Error creating pipe");
>>>>> + return ret;
>>>>> + }
>>>>> + return 0;
>>>>> +}
>>>>> +
>>>>> +int liblttdutils_local_on_close_thread(struct liblttd_callbacks *data, unsigned long thread_num)
>>>>> +{
>>>>> + close(thread_pipe[0]); /* close read end */
>>>>> + close(thread_pipe[1]); /* close write end */
>>>>> + return 0;
>>>>> +}
>>>>> +
>>>>> +int liblttdutils_local_on_trace_end(struct liblttd_instance *instance)
>>>>> +{
>>>>> + struct liblttd_callbacks *callbacks = instance->callbacks;
>>>>> + struct liblttdutils_data *data = callbacks->user_data;
>>>>> +
>>>>> + free(data);
>>>>> + free(callbacks);
>>>>> +}
>>>>> +
>>>>> +struct liblttd_callbacks* liblttdutils_local_new_callbacks(char* trace_name,
>>>>> + int append_mode, int verbose_mode)
>>>>> +{
>>>>> + struct liblttdutils_data *data;
>>>>> + struct liblttd_callbacks *callbacks;
>>>>> +
>>>>> + if(!trace_name) return NULL;
>>>>> +
>>>>> + data = malloc(sizeof(struct liblttdutils_data));
>>>>> +
>>>>> + strncpy(data->path_trace, trace_name, PATH_MAX-1);
>>>>> + data->path_trace_len = strlen(data->path_trace);
>>>>> + data->end_path_trace = data->path_trace + data->path_trace_len;
>>>>> + data->append_mode = append_mode;
>>>>> + data->verbose_mode = verbose_mode;
>>>>> +
>>>>> + callbacks = malloc(sizeof(struct liblttd_callbacks));
>>>>> +
>>>>> + callbacks->on_open_channel = liblttdutils_local_on_open_channel;
>>>>> + callbacks->on_close_channel = liblttdutils_local_on_close_channel;
>>>>> + callbacks->on_new_channels_folder = liblttdutils_local_on_new_channels_folder;
>>>>> + callbacks->on_read_subbuffer = liblttdutils_local_on_read_subbuffer;
>>>>> + callbacks->on_trace_end = liblttdutils_local_on_trace_end;
>>>>> + callbacks->on_new_thread = liblttdutils_local_on_new_thread;
>>>>> + callbacks->on_close_thread = liblttdutils_local_on_close_thread;
>>>>> + callbacks->user_data = data;
>>>>> +
>>>>> + return callbacks;
>>>>> +}
>>>>> +
>>>>> diff --git a/liblttd/liblttdutils.h b/liblttd/liblttdutils.h
>>>>> new file mode 100644
>>>>> index 0000000..78439d2
>>>>> --- /dev/null
>>>>> +++ b/liblttd/liblttdutils.h
>>>>> @@ -0,0 +1,38 @@
>>>>> +/* liblttdutils header file
>>>>> + *
>>>>> + * Copyright 2010-
>>>>> + * Oumarou Dicko<oumarou.dicko at polymtl.ca>
>>>>> + * Michael Sills-Lavoie<michael.sills-lavoie at polymtl.ca>
>>>>> + *
>>>>> + * This program is free software; you can redistribute it and/or modify
>>>>> + * it under the terms of the GNU General Public License as published by
>>>>> + * the Free Software Foundation; either version 2 of the License, or
>>>>> + * (at your option) any later version.
>>>>> + *
>>>>> + * This program is distributed in the hope that it will be useful,
>>>>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>>>>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
>>>>> + * GNU General Public License for more details.
>>>>> + *
>>>>> + */
>>>>> +
>>>>> +#ifndef _LIBLTTDUTILS_H
>>>>> +#define _LIBLTTDUTILS_H
>>>>> +
>>>>> +#include "liblttd.h"
>>>>> +
>>>>> +/**
>>>>> + * liblttdutils_new_callbacks - Is a utility function called to create a new
>>>>> + * callbacks struct used by liblttd to write trace data to the disk.
>>>>> + *
>>>>> + * @trace_name: Directory name of the trace to write to. It will be created.
>>>>> + * @append_mode: Append to a possibly existing trace.
>>>>> + * @verbose_mode: Verbose mode.
>>>>> + *
>>>>> + * Returns the callbacks if the function succeeds else NULL.
>>>>> + */
>>>>> +struct liblttd_callbacks* liblttdutils_local_new_callbacks(char* trace_name,
>>>>> + int append_mode, int verbose_mode);
>>>>> +
>>>>> +#endif /*_LIBLTTDUTILS_H */
>>>>> +
>>>>> diff --git a/lttd/lttd.c b/lttd/lttd.c
>>>>> index d3c12d5..b43b637 100644
>>>>> --- a/lttd/lttd.c
>>>>> +++ b/lttd/lttd.c
>>>>> @@ -8,6 +8,8 @@
>>>>> * CPU hot-plugging is supported using inotify.
>>>>> *
>>>>> * Copyright 2009-2010 - Mathieu Desnoyers<mathieu.desnoyers at efficios.com>
>>>>> + * Copyright 2010 - Michael Sills-Lavoie<michael.sills-lavoie at polymtl.ca>
>>>>> + * Copyright 2010 - Oumarou Dicko<oumarou.dicko at polymtl.ca>
>>>>> *
>>>>> * This program is free software; you can redistribute it and/or modify
>>>>> * it under the terms of the GNU General Public License as published by
>>>>> @@ -22,6 +24,7 @@
>>>>> * You should have received a copy of the GNU General Public License along
>>>>> * with this program; if not, write to the Free Software Foundation, Inc.,
>>>>> * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
>>>>> + *
>>>>> */
>>>>>
>>>>> #ifdef HAVE_CONFIG_H
>>>>> @@ -33,23 +36,14 @@
>>>>>
>>>>> #include<stdio.h>
>>>>> #include<stdlib.h>
>>>>> -#include<string.h>
>>>>> #include<signal.h>
>>>>> #include<errno.h>
>>>>> -#include<fcntl.h>
>>>>> -#include<dirent.h>
>>>>> -#include<sys/stat.h>
>>>>>
>>>>> #include<liblttd/liblttd.h>
>>>>> +#include<liblttd/liblttdutils.h>
>>>>>
>>>>> -struct lttd_channel_data {
>>>>> - int trace;
>>>>> -};
>>>>> +struct liblttd_instance* instance;
>>>>>
>>>>> -struct liblttd_instance *instance;
>>>>> -static char path_trace[PATH_MAX];
>>>>> -static char *end_path_trace;
>>>>> -static int path_trace_len = 0;
>>>>> static char *trace_name = NULL;
>>>>> static char *channel_name = NULL;
>>>>> static int daemon_mode = 0;
>>>>> @@ -59,13 +53,6 @@ static int dump_flight_only = 0;
>>>>> static int dump_normal_only = 0;
>>>>> static int verbose_mode = 0;
>>>>>
>>>>> -static __thread int thread_pipe[2];
>>>>> -
>>>>> -#define printf_verbose(fmt, args...) \
>>>>> - do { \
>>>>> - if (verbose_mode) \
>>>>> - printf(fmt, ##args); \
>>>>> - } while (0)
>>>>>
>>>>> /* Args :
>>>>> *
>>>>> @@ -195,152 +182,11 @@ static void handler(int signo)
>>>>> liblttd_stop_instance(instance);
>>>>> }
>>>>>
>>>>> -int lttd_on_open_channel(struct liblttd_callbacks *data, struct fd_pair *pair, char *relative_channel_path)
>>>>> -{
>>>>> - int open_ret = 0;
>>>>> - int ret;
>>>>> - struct stat stat_buf;
>>>>> - struct lttd_channel_data *channel_data;
>>>>> -
>>>>> - pair->user_data = malloc(sizeof(struct lttd_channel_data));
>>>>> - channel_data = pair->user_data;
>>>>> -
>>>>> - strncpy(end_path_trace, relative_channel_path, PATH_MAX - path_trace_len);
>>>>> - printf_verbose("Creating trace file %s\n", path_trace);
>>>>> -
>>>>> - ret = stat(path_trace,&stat_buf);
>>>>> - if(ret == 0) {
>>>>> - if(append_mode) {
>>>>> - printf_verbose("Appending to file %s as requested\n",
>>>>> - path_trace);
>>>>> -
>>>>> - channel_data->trace = open(path_trace, O_WRONLY, S_IRWXU|S_IRWXG|S_IRWXO);
>>>>> - if(channel_data->trace == -1) {
>>>>> - perror(path_trace);
>>>>> - open_ret = -1;
>>>>> - goto end;
>>>>> - }
>>>>> - ret = lseek(channel_data->trace, 0, SEEK_END);
>>>>> - if (ret< 0) {
>>>>> - perror(path_trace);
>>>>> - open_ret = -1;
>>>>> - close(channel_data->trace);
>>>>> - goto end;
>>>>> - }
>>>>> - } else {
>>>>> - printf("File %s exists, cannot open. Try append mode.\n", path_trace);
>>>>> - open_ret = -1;
>>>>> - goto end;
>>>>> - }
>>>>> - } else {
>>>>> - if(errno == ENOENT) {
>>>>> - channel_data->trace = open(path_trace, O_WRONLY|O_CREAT|O_EXCL, S_IRWXU|S_IRWXG|S_IRWXO);
>>>>> - if(channel_data->trace == -1) {
>>>>> - perror(path_trace);
>>>>> - open_ret = -1;
>>>>> - goto end;
>>>>> - }
>>>>> - }
>>>>> - }
>>>>> -
>>>>> -end:
>>>>> - return open_ret;
>>>>> -
>>>>> -}
>>>>> -
>>>>> -int lttd_on_close_channel(struct liblttd_callbacks *data, struct fd_pair *pair)
>>>>> -{
>>>>> - int ret;
>>>>> - ret = close(((struct lttd_channel_data *)(pair->user_data))->trace);
>>>>> - free(pair->user_data);
>>>>> - return ret;
>>>>> -}
>>>>> -
>>>>> -int lttd_on_new_channels_folder(struct liblttd_callbacks *data, char *relative_folder_path)
>>>>> -{
>>>>> - int ret;
>>>>> - int open_ret = 0;
>>>>> -
>>>>> - strncpy(end_path_trace, relative_folder_path, PATH_MAX - path_trace_len);
>>>>> - printf_verbose("Creating trace subdirectory %s\n", path_trace);
>>>>> -
>>>>> - ret = mkdir(path_trace, S_IRWXU|S_IRWXG|S_IRWXO);
>>>>> - if(ret == -1) {
>>>>> - if(errno != EEXIST) {
>>>>> - perror(path_trace);
>>>>> - open_ret = -1;
>>>>> - goto end;
>>>>> - }
>>>>> - }
>>>>> -
>>>>> -end:
>>>>> - return open_ret;
>>>>> -}
>>>>> -
>>>>> -int lttd_on_read_subbuffer(struct liblttd_callbacks *data, struct fd_pair *pair, unsigned int len)
>>>>> -{
>>>>> - long ret;
>>>>> - off_t offset = 0;
>>>>> -
>>>>> - while (len> 0) {
>>>>> - printf_verbose("splice chan to pipe offset %lu\n",
>>>>> - (unsigned long)offset);
>>>>> - ret = splice(pair->channel,&offset, thread_pipe[1], NULL,
>>>>> - len, SPLICE_F_MOVE | SPLICE_F_MORE);
>>>>> - printf_verbose("splice chan to pipe ret %ld\n", ret);
>>>>> - if (ret< 0) {
>>>>> - perror("Error in relay splice");
>>>>> - goto write_error;
>>>>> - }
>>>>> - ret = splice(thread_pipe[0], NULL,
>>>>> - ((struct lttd_channel_data *)(pair->user_data))->trace,
>>>>> - NULL, ret, SPLICE_F_MOVE | SPLICE_F_MORE);
>>>>> - printf_verbose("splice pipe to file %ld\n", ret);
>>>>> - if (ret< 0) {
>>>>> - perror("Error in file splice");
>>>>> - goto write_error;
>>>>> - }
>>>>> - len -= ret;
>>>>> - }
>>>>> -
>>>>> -write_error:
>>>>> - return ret;
>>>>> -}
>>>>> -
>>>>> -int lttd_on_new_thread(struct liblttd_callbacks *data, unsigned long thread_num)
>>>>> -{
>>>>> - int ret;
>>>>> - ret = pipe(thread_pipe);
>>>>> - if (ret< 0) {
>>>>> - perror("Error creating pipe");
>>>>> - return ret;
>>>>> - }
>>>>> - return 0;
>>>>> -}
>>>>> -
>>>>> -int lttd_on_close_thread(struct liblttd_callbacks *data, unsigned long thread_num)
>>>>> -{
>>>>> - close(thread_pipe[0]); /* close read end */
>>>>> - close(thread_pipe[1]); /* close write end */
>>>>> - return 0;
>>>>> -}
>>>>> -
>>>>> int main(int argc, char ** argv)
>>>>> {
>>>>> int ret = 0;
>>>>> struct sigaction act;
>>>>>
>>>>> - struct liblttd_callbacks callbacks = {
>>>>> - lttd_on_open_channel,
>>>>> - lttd_on_close_channel,
>>>>> - lttd_on_new_channels_folder,
>>>>> - lttd_on_read_subbuffer,
>>>>> - NULL,
>>>>> - lttd_on_new_thread,
>>>>> - lttd_on_close_thread,
>>>>> - NULL
>>>>> - };
>>>>> -
>>>>> ret = parse_arguments(argc, argv);
>>>>>
>>>>> if(ret != 0) show_arguments();
>>>>> @@ -368,12 +214,13 @@ int main(int argc, char ** argv)
>>>>> exit(-1);
>>>>> }
>>>>> }
>>>>> - strncpy(path_trace, trace_name, PATH_MAX-1);
>>>>> - path_trace_len = strlen(path_trace);
>>>>> - end_path_trace = path_trace + path_trace_len;
>>>>>
>>>>> - instance = liblttd_new_instance(&callbacks, channel_name, num_threads,
>>>>> + struct liblttd_callbacks* callbacks = liblttdutils_local_new_callbacks(
>>>>> + trace_name, append_mode, verbose_mode);
>>>>> +
>>>>> + instance = liblttd_new_instance(callbacks, channel_name, num_threads,
>>>>> dump_flight_only, dump_normal_only, verbose_mode);
>>>>> +
>>>>> if(!instance) {
>>>>> perror("An error occured while creating the liblttd instance");
>>>>> return ret;
>>>>>
>>>>
>>>> --
>>>> Mathieu Desnoyers
>>>> Operating System Efficiency R&D Consultant
>>>> EfficiOS Inc.
>>>> http://www.efficios.com
>>>>
>>>> _______________________________________________
>>>> ltt-dev mailing list
>>>> ltt-dev at lists.casi.polymtl.ca
>>>> http://lists.casi.polymtl.ca/cgi-bin/mailman/listinfo/ltt-dev
>>>>
>>>>
>>> --
>>> Mathieu Desnoyers
>>> Operating System Efficiency R&D Consultant
>>> EfficiOS Inc.
>>> http://www.efficios.com
>>>
>>> _______________________________________________
>>> ltt-dev mailing list
>>> ltt-dev at lists.casi.polymtl.ca
>>> http://lists.casi.polymtl.ca/cgi-bin/mailman/listinfo/ltt-dev
>>>
>>>
>>
>
--
Mathieu Desnoyers
Operating System Efficiency R&D Consultant
EfficiOS Inc.
http://www.efficios.com
More information about the lttng-dev
mailing list