[ltt-dev] [PP?] Re: Liblttd patch
Michael Sills-Lavoie
michael.sills.lavoie at gmail.com
Sat Mar 27 13:49:46 EDT 2010
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.
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
>>
>>
>
More information about the lttng-dev
mailing list