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