From mboxrd@z Thu Jan 1 00:00:00 1970 From: dgoulet@efficios.com (David Goulet) Date: Mon, 01 Oct 2012 18:04:57 -0400 Subject: [lttng-dev] [LTTNG-TOOLS PATCH v4] ABI with support for compat 32/64 bits In-Reply-To: <1349124140-3224-1-git-send-email-jdesfossez@efficios.com> References: <1349124140-3224-1-git-send-email-jdesfossez@efficios.com> Message-ID: <506A1389.1000702@efficios.com> -----BEGIN PGP SIGNED MESSAGE----- Hash: SHA512 Julien Desfossez: > The current ABI does not work for compat 32/64 bits. This patch > moves the current ABI as old-abi and provides a new ABI in which > all the structures exchanged between user and kernel-space are > packed. Also this new ABI moves the "int overwrite" member of the > struct lttng_kernel_channel to remove the alignment added by the > compiler. > > A patch for lttng-modules has been developed in parallel to this > one to support the new ABI. These 2 patches have been tested in > all possible configurations (applied or not) on 64-bit and 32-bit > kernels (with CONFIG_COMPAT) and a user-space in 32 and 64-bit. > > Here are the results of the tests : k 64 compat | u 32 compat > | OK k 64 compat | u 64 compat | OK k 64 compat | u 32 > non-compat | KO k 64 compat | u 64 non-compat | OK > > k 64 non-compat | u 64 compat | OK k 64 non-compat | u 32 > compat | KO k 64 non-compat | u 64 non-compat | OK k 64 > non-compat | u 32 non-compat | KO > > k 32 compat | u compat | OK k 32 compat | u > non-compat | OK > > k 32 non-compat | u compat | OK k 32 non-compat | u > non-compat | OK > > The results are as expected : - on 32-bit user-space and kernel, > every configuration works. - on 64-bit user-space and kernel, every > configuration works. - with 32-bit user-space on a 64-bit kernel > the only configuration where it works is when the compat patch is > applied everywhere. > > Signed-off-by: Julien Desfossez --- > src/bin/lttng-sessiond/trace-kernel.h | 1 + > src/common/kernel-ctl/kernel-ctl.c | 210 > +++++++++++++++++++++++++++++---- > src/common/kernel-ctl/kernel-ctl.h | 1 + > src/common/kernel-ctl/kernel-ioctl.h | 74 ++++++++---- > src/common/lttng-kernel-old.h | 115 ++++++++++++++++++ > src/common/lttng-kernel.h | 31 +++-- 6 files changed, > 383 insertions(+), 49 deletions(-) create mode 100644 > src/common/lttng-kernel-old.h > > diff --git a/src/bin/lttng-sessiond/trace-kernel.h > b/src/bin/lttng-sessiond/trace-kernel.h index f04d9e7..c86cc27 > 100644 --- a/src/bin/lttng-sessiond/trace-kernel.h +++ > b/src/bin/lttng-sessiond/trace-kernel.h @@ -22,6 +22,7 @@ > > #include #include +#include > > > #include "consumer.h" > > diff --git a/src/common/kernel-ctl/kernel-ctl.c > b/src/common/kernel-ctl/kernel-ctl.c index 1396cd9..ab29dd0 100644 > --- a/src/common/kernel-ctl/kernel-ctl.c +++ > b/src/common/kernel-ctl/kernel-ctl.c @@ -18,38 +18,163 @@ > > #define __USE_LINUX_IOCTL_DEFS #include +#include > > > #include "kernel-ctl.h" #include "kernel-ioctl.h" > > +/* + * This flag indicates whether lttng-tools must use the new or > the old kernel + * ABI (without compat support for 32/64 bits). + > */ As discuss, having a better comment to explain "what is old kernel". Since this compat layer is due to be removed someday, just explain why please. > +static int lttng_kernel_use_old_abi = -1; + I'm a bit "painful" on that but I really want each functions in lttng-tools to be commented and args explained briefly and return value. Also normally, we have a location for compat layer "stuff" which is src/common/compat. In this case I'm ok to let it here since this is _suppose_ to be temporary. However, temporary stuff always stays forever... so a clear comment that we plan to remove this compat layer after 2.1 at some point in time. (Maybe a XXX comment). I'm asking all this because, since this is named with _old*_, in a couple of months, I'll need to understand what this is about and why it's not called "compat_...2_0_..." > +static inline int compat_ioctl_no_arg(int fd, unsigned long > oldname, + unsigned long newname) +{ + int ret; + + if > (lttng_kernel_use_old_abi == -1) { + ret = ioctl(fd, newname); + > if (!ret) { + lttng_kernel_use_old_abi = 0; + goto end; + } + > lttng_kernel_use_old_abi = 1; + } + if (lttng_kernel_use_old_abi) > { + ret = ioctl(fd, oldname); + } else { + ret = ioctl(fd, > newname); + } + +end: + return ret; +} + int > kernctl_create_session(int fd) { - return ioctl(fd, > LTTNG_KERNEL_SESSION); + return compat_ioctl_no_arg(fd, > LTTNG_KERNEL_OLD_SESSION, + LTTNG_KERNEL_SESSION); } > > /* open the metadata global channel */ int > kernctl_open_metadata(int fd, struct lttng_channel_attr *chops) { - > return ioctl(fd, LTTNG_KERNEL_METADATA, chops); + struct > lttng_kernel_old_channel old_channel; + struct lttng_kernel_channel > channel; + + if (lttng_kernel_use_old_abi) { + > old_channel.overwrite = chops->overwrite; + > old_channel.subbuf_size = chops->subbuf_size; + > old_channel.num_subbuf = chops->num_subbuf; + > old_channel.switch_timer_interval = chops->switch_timer_interval; + > old_channel.read_timer_interval = chops->read_timer_interval; + > old_channel.output = chops->output; + memcpy(old_channel.padding, > chops->padding, sizeof(chops->padding)); The size of this memcpy should use the old_channel padding being the destination buffer. I know this is "controlled buffer and known size" but it can be error proned in the future with any changes to the current ABI. (More to fix below). > + + return ioctl(fd, LTTNG_KERNEL_OLD_METADATA, &old_channel); + > } + + channel.overwrite = chops->overwrite; + channel.subbuf_size = > chops->subbuf_size; + channel.num_subbuf = chops->num_subbuf; + > channel.switch_timer_interval = chops->switch_timer_interval; + > channel.read_timer_interval = chops->read_timer_interval; + > channel.output = chops->output; + memcpy(channel.padding, > chops->padding, sizeof(chops->padding)); Here. > + + return ioctl(fd, LTTNG_KERNEL_METADATA, &channel); } > > int kernctl_create_channel(int fd, struct lttng_channel_attr > *chops) { - return ioctl(fd, LTTNG_KERNEL_CHANNEL, chops); + struct > lttng_kernel_old_channel old_channel; Move this inside the if(OLD). > + struct lttng_kernel_channel channel; + + if > (lttng_kernel_use_old_abi) { + old_channel.overwrite = > chops->overwrite; + old_channel.subbuf_size = chops->subbuf_size; > + old_channel.num_subbuf = chops->num_subbuf; + > old_channel.switch_timer_interval = chops->switch_timer_interval; + > old_channel.read_timer_interval = chops->read_timer_interval; + > old_channel.output = chops->output; + memcpy(old_channel.padding, > chops->padding, sizeof(chops->padding)); Here. > + + return ioctl(fd, LTTNG_KERNEL_OLD_CHANNEL, &old_channel); + } > + + channel.overwrite = chops->overwrite; + channel.subbuf_size = > chops->subbuf_size; + channel.num_subbuf = chops->num_subbuf; + > channel.switch_timer_interval = chops->switch_timer_interval; + > channel.read_timer_interval = chops->read_timer_interval; + > channel.output = chops->output; + memcpy(channel.padding, > chops->padding, sizeof(chops->padding)); Here. > + + return ioctl(fd, LTTNG_KERNEL_CHANNEL, &channel); } > > int kernctl_create_stream(int fd) { - return ioctl(fd, > LTTNG_KERNEL_STREAM); + return compat_ioctl_no_arg(fd, > LTTNG_KERNEL_OLD_STREAM, + LTTNG_KERNEL_STREAM); } > > int kernctl_create_event(int fd, struct lttng_kernel_event *ev) { + > if (lttng_kernel_use_old_abi) { + struct lttng_kernel_event > old_event; Shouldn't that be lttng_kernel_old_event here ? > + + memcpy(old_event.name, ev->name, sizeof(old_event.name)); + > old_event.instrumentation = ev->instrumentation; + switch > (ev->instrumentation) { + case LTTNG_KERNEL_KPROBE: + > old_event.u.kprobe.addr = ev->u.kprobe.addr; + > old_event.u.kprobe.offset = ev->u.kprobe.offset; + > memcpy(old_event.u.kprobe.symbol_name, + > ev->u.kprobe.symbol_name, + > sizeof(old_event.u.kprobe.symbol_name)); + break; + case > LTTNG_KERNEL_KRETPROBE: + old_event.u.kretprobe.addr = > ev->u.kretprobe.addr; + old_event.u.kretprobe.offset = > ev->u.kretprobe.offset; + > memcpy(old_event.u.kretprobe.symbol_name, + > ev->u.kretprobe.symbol_name, + > sizeof(old_event.u.kretprobe.symbol_name)); + break; + case > LTTNG_KERNEL_FUNCTION: + memcpy(old_event.u.ftrace.symbol_name, + > ev->u.ftrace.symbol_name, + > sizeof(old_event.u.ftrace.symbol_name)); + break; + default: + > break; + } + + return ioctl(fd, LTTNG_KERNEL_OLD_EVENT, > &old_event); + } return ioctl(fd, LTTNG_KERNEL_EVENT, ev); } > > int kernctl_add_context(int fd, struct lttng_kernel_context *ctx) > { + if (lttng_kernel_use_old_abi) { + struct > lttng_kernel_old_context old_ctx; + + old_ctx.ctx = ctx->ctx; + > /* only type that uses the union */ + if (ctx->ctx == > LTTNG_KERNEL_CONTEXT_PERF_COUNTER) { + > old_ctx.u.perf_counter.type = + ctx->u.perf_counter.type; + > old_ctx.u.perf_counter.config = + ctx->u.perf_counter.config; + > memcpy(old_ctx.u.perf_counter.name, + ctx->u.perf_counter.name, > + sizeof(old_ctx.u.perf_counter.name)); + } + return ioctl(fd, > LTTNG_KERNEL_OLD_CONTEXT, &old_ctx); + } return ioctl(fd, > LTTNG_KERNEL_CONTEXT, ctx); } > > @@ -57,44 +182,96 @@ int kernctl_add_context(int fd, struct > lttng_kernel_context *ctx) /* Enable event, channel and session > ioctl */ int kernctl_enable(int fd) { - return ioctl(fd, > LTTNG_KERNEL_ENABLE); + return compat_ioctl_no_arg(fd, > LTTNG_KERNEL_OLD_ENABLE, + LTTNG_KERNEL_ENABLE); } > > /* Disable event, channel and session ioctl */ int > kernctl_disable(int fd) { - return ioctl(fd, > LTTNG_KERNEL_DISABLE); + return compat_ioctl_no_arg(fd, > LTTNG_KERNEL_OLD_DISABLE, + LTTNG_KERNEL_DISABLE); } > > int kernctl_start_session(int fd) { - return ioctl(fd, > LTTNG_KERNEL_SESSION_START); + return compat_ioctl_no_arg(fd, > LTTNG_KERNEL_OLD_SESSION_START, + LTTNG_KERNEL_SESSION_START); } > > int kernctl_stop_session(int fd) { - return ioctl(fd, > LTTNG_KERNEL_SESSION_STOP); + return compat_ioctl_no_arg(fd, > LTTNG_KERNEL_OLD_SESSION_STOP, + LTTNG_KERNEL_SESSION_STOP); } > > - int kernctl_tracepoint_list(int fd) { - return ioctl(fd, > LTTNG_KERNEL_TRACEPOINT_LIST); + return compat_ioctl_no_arg(fd, > LTTNG_KERNEL_OLD_TRACEPOINT_LIST, + > LTTNG_KERNEL_TRACEPOINT_LIST); } > > int kernctl_tracer_version(int fd, struct > lttng_kernel_tracer_version *v) { - return ioctl(fd, > LTTNG_KERNEL_TRACER_VERSION, v); + int ret; + + if > (lttng_kernel_use_old_abi == -1) { + ret = ioctl(fd, > LTTNG_KERNEL_TRACER_VERSION, v); + if (!ret) { + > lttng_kernel_use_old_abi = 0; + goto end; + } + > lttng_kernel_use_old_abi = 1; + } + if (lttng_kernel_use_old_abi) > { + struct lttng_kernel_old_tracer_version old_v; + + ret = > ioctl(fd, LTTNG_KERNEL_OLD_TRACER_VERSION, &old_v); + if (ret) + > goto end; {} missing > + v->major = old_v.major; + v->minor = old_v.minor; + > v->patchlevel = old_v.patchlevel; + } else { + ret = ioctl(fd, > LTTNG_KERNEL_TRACER_VERSION, v); + } + +end: + return ret; } > > int kernctl_wait_quiescent(int fd) { - return ioctl(fd, > LTTNG_KERNEL_WAIT_QUIESCENT); + return compat_ioctl_no_arg(fd, > LTTNG_KERNEL_OLD_WAIT_QUIESCENT, + LTTNG_KERNEL_WAIT_QUIESCENT); > } > > int kernctl_calibrate(int fd, struct lttng_kernel_calibrate > *calibrate) { - return ioctl(fd, LTTNG_KERNEL_CALIBRATE, > calibrate); + int ret; + + if (lttng_kernel_use_old_abi == -1) { + > ret = ioctl(fd, LTTNG_KERNEL_CALIBRATE, calibrate); + if (!ret) { > + lttng_kernel_use_old_abi = 0; + goto end; + } + > lttng_kernel_use_old_abi = 1; + } + if (lttng_kernel_use_old_abi) > { + struct lttng_kernel_old_calibrate old_calibrate; + + > old_calibrate.type = calibrate->type; + ret = ioctl(fd, > LTTNG_KERNEL_OLD_CALIBRATE, &old_calibrate); + if (ret) + goto > end; {} missing > + calibrate->type = old_calibrate.type; + } else { + ret = > ioctl(fd, LTTNG_KERNEL_CALIBRATE, calibrate); + } + +end: + return > ret; } > > > @@ -193,10 +370,3 @@ int kernctl_set_stream_id(int fd, unsigned > long *stream_id) { return ioctl(fd, RING_BUFFER_SET_STREAM_ID, > stream_id); } - -/* Get the offset of the stream_id in the packet > header */ -int kernctl_get_net_stream_id_offset(int fd, unsigned > long *offset) -{ - return ioctl(fd, LTTNG_KERNEL_STREAM_ID_OFFSET, > offset); - -} diff --git a/src/common/kernel-ctl/kernel-ctl.h > b/src/common/kernel-ctl/kernel-ctl.h index 18712d9..85a3a18 100644 > --- a/src/common/kernel-ctl/kernel-ctl.h +++ > b/src/common/kernel-ctl/kernel-ctl.h @@ -21,6 +21,7 @@ > > #include #include +#include > > > int kernctl_create_session(int fd); int kernctl_open_metadata(int > fd, struct lttng_channel_attr *chops); diff --git > a/src/common/kernel-ctl/kernel-ioctl.h > b/src/common/kernel-ctl/kernel-ioctl.h index 35942be..1d34222 > 100644 --- a/src/common/kernel-ctl/kernel-ioctl.h +++ > b/src/common/kernel-ctl/kernel-ioctl.h @@ -49,37 +49,69 @@ /* map > stream to stream id for network streaming */ #define > RING_BUFFER_SET_STREAM_ID _IOW(0xF6, 0x0D, unsigned > long) > > +/* Old ABI (without support for 32/64 bits compat) */ +/* LTTng > file descriptor ioctl */ +#define LTTNG_KERNEL_OLD_SESSION > _IO(0xF6, 0x40) +#define LTTNG_KERNEL_OLD_TRACER_VERSION \ > + _IOR(0xF6, 0x41, struct lttng_kernel_old_tracer_version) > +#define LTTNG_KERNEL_OLD_TRACEPOINT_LIST _IO(0xF6, 0x42) > +#define LTTNG_KERNEL_OLD_WAIT_QUIESCENT _IO(0xF6, 0x43) > +#define LTTNG_KERNEL_OLD_CALIBRATE \ + _IOWR(0xF6, 0x44, struct > lttng_kernel_old_calibrate) + +/* Session FD ioctl */ +#define > LTTNG_KERNEL_OLD_METADATA \ + _IOW(0xF6, 0x50, > struct lttng_kernel_old_channel) +#define LTTNG_KERNEL_OLD_CHANNEL > \ + _IOW(0xF6, 0x51, struct lttng_kernel_old_channel) +#define > LTTNG_KERNEL_OLD_SESSION_START _IO(0xF6, 0x52) +#define > LTTNG_KERNEL_OLD_SESSION_STOP _IO(0xF6, 0x53) + +/* > Channel FD ioctl */ +#define LTTNG_KERNEL_OLD_STREAM > _IO(0xF6, 0x60) +#define LTTNG_KERNEL_OLD_EVENT \ > + _IOW(0xF6, 0x61, struct lttng_kernel_old_event) +#define > LTTNG_KERNEL_OLD_STREAM_ID_OFFSET \ + _IOR(0xF6, 0x62, > unsigned long) > > +/* Event and Channel FD ioctl */ +#define LTTNG_KERNEL_OLD_CONTEXT > \ + _IOW(0xF6, 0x70, struct lttng_kernel_old_context) + +/* Event, > Channel and Session ioctl */ +#define LTTNG_KERNEL_OLD_ENABLE > _IO(0xF6, 0x80) +#define LTTNG_KERNEL_OLD_DISABLE > _IO(0xF6, 0x81) + + +/* New ABI (with suport for 32/64 bits compat) > */ Maybe just use "Current ABI" with version number also. (2.1 in this case I guess). Thanks David > /* LTTng file descriptor ioctl */ -#define LTTNG_KERNEL_SESSION > _IO(0xF6, 0x40) -#define LTTNG_KERNEL_TRACER_VERSION \ - > _IOR(0xF6, 0x41, struct lttng_kernel_tracer_version) -#define > LTTNG_KERNEL_TRACEPOINT_LIST _IO(0xF6, 0x42) -#define > LTTNG_KERNEL_WAIT_QUIESCENT _IO(0xF6, 0x43) +#define > LTTNG_KERNEL_SESSION _IO(0xF6, 0x45) +#define > LTTNG_KERNEL_TRACER_VERSION \ + _IOR(0xF6, 0x46, struct > lttng_kernel_tracer_version) +#define LTTNG_KERNEL_TRACEPOINT_LIST > _IO(0xF6, 0x47) +#define LTTNG_KERNEL_WAIT_QUIESCENT _IO(0xF6, > 0x48) #define LTTNG_KERNEL_CALIBRATE \ - _IOWR(0xF6, 0x44, struct > lttng_kernel_calibrate) + _IOWR(0xF6, 0x49, struct > lttng_kernel_calibrate) > > /* Session FD ioctl */ -#define LTTNG_KERNEL_METADATA > \ - _IOW(0xF6, 0x50, struct lttng_channel_attr) -#define > LTTNG_KERNEL_CHANNEL \ - _IOW(0xF6, 0x51, struct > lttng_channel_attr) -#define LTTNG_KERNEL_SESSION_START > _IO(0xF6, 0x52) -#define LTTNG_KERNEL_SESSION_STOP > _IO(0xF6, 0x53) +#define LTTNG_KERNEL_METADATA \ + _IOW(0xF6, > 0x54, struct lttng_kernel_channel) +#define LTTNG_KERNEL_CHANNEL > \ + _IOW(0xF6, 0x55, struct lttng_kernel_channel) +#define > LTTNG_KERNEL_SESSION_START _IO(0xF6, 0x56) +#define > LTTNG_KERNEL_SESSION_STOP _IO(0xF6, 0x57) > > /* Channel FD ioctl */ -#define LTTNG_KERNEL_STREAM > _IO(0xF6, 0x60) -#define LTTNG_KERNEL_EVENT \ - > _IOW(0xF6, 0x61, struct lttng_kernel_event) -#define > LTTNG_KERNEL_STREAM_ID_OFFSET \ - _IOR(0xF6, 0x62, unsigned > long) +#define LTTNG_KERNEL_STREAM _IO(0xF6, 0x62) +#define > LTTNG_KERNEL_EVENT \ + _IOW(0xF6, 0x63, struct > lttng_kernel_event) > > /* Event and Channel FD ioctl */ -#define LTTNG_KERNEL_CONTEXT > \ - _IOW(0xF6, 0x70, struct lttng_kernel_context) +#define > LTTNG_KERNEL_CONTEXT \ + _IOW(0xF6, 0x71, struct > lttng_kernel_context) > > /* Event, Channel and Session ioctl */ -#define LTTNG_KERNEL_ENABLE > _IO(0xF6, 0x80) -#define LTTNG_KERNEL_DISABLE > _IO(0xF6, 0x81) +#define LTTNG_KERNEL_ENABLE _IO(0xF6, 0x82) > +#define LTTNG_KERNEL_DISABLE _IO(0xF6, 0x83) > > #endif /* _LTT_KERNEL_IOCTL_H */ diff --git > a/src/common/lttng-kernel-old.h b/src/common/lttng-kernel-old.h new > file mode 100644 index 0000000..1b8999a --- /dev/null +++ > b/src/common/lttng-kernel-old.h @@ -0,0 +1,115 @@ +/* + * Copyright > (C) 2011 - Julien Desfossez + * > Mathieu Desnoyers + * > David Goulet + * + * This program is free > software; you can redistribute it and/or modify + * it under the > terms of the GNU General Public License, version 2 only, + * as > published by the Free Software Foundation. + * + * 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. + * + * 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. + */ + > +#ifndef _LTTNG_KERNEL_OLD_H +#define _LTTNG_KERNEL_OLD_H + > +#include +#include + +/* + * > LTTng DebugFS ABI structures. + * + * This is the kernel ABI copied > from lttng-modules tree. + */ + +/* Perf counter attributes */ > +struct lttng_kernel_old_perf_counter_ctx { + uint32_t type; + > uint64_t config; + char name[LTTNG_KERNEL_SYM_NAME_LEN]; +}; + +/* > Event/Channel context */ +#define LTTNG_KERNEL_OLD_CONTEXT_PADDING1 > 16 +#define LTTNG_KERNEL_OLD_CONTEXT_PADDING2 > LTTNG_KERNEL_SYM_NAME_LEN + 32 +struct lttng_kernel_old_context { + > enum lttng_kernel_context_type ctx; + char > padding[LTTNG_KERNEL_OLD_CONTEXT_PADDING1]; + + union { + struct > lttng_kernel_old_perf_counter_ctx perf_counter; + char > padding[LTTNG_KERNEL_OLD_CONTEXT_PADDING2]; + } u; +}; + +struct > lttng_kernel_old_kretprobe { + uint64_t addr; + + uint64_t offset; > + char symbol_name[LTTNG_KERNEL_SYM_NAME_LEN]; +}; + +/* + * Either > addr is used, or symbol_name and offset. + */ +struct > lttng_kernel_old_kprobe { + uint64_t addr; + + uint64_t offset; + > char symbol_name[LTTNG_KERNEL_SYM_NAME_LEN]; +}; + +/* Function > tracer */ +struct lttng_kernel_old_function { + char > symbol_name[LTTNG_KERNEL_SYM_NAME_LEN]; +}; + +#define > LTTNG_KERNEL_OLD_EVENT_PADDING1 16 +#define > LTTNG_KERNEL_OLD_EVENT_PADDING2 LTTNG_KERNEL_SYM_NAME_LEN + 32 > +struct lttng_kernel_old_event { + char > name[LTTNG_KERNEL_SYM_NAME_LEN]; + enum > lttng_kernel_instrumentation instrumentation; + char > padding[LTTNG_KERNEL_OLD_EVENT_PADDING1]; + + /* Per > instrumentation type configuration */ + union { + struct > lttng_kernel_old_kretprobe kretprobe; + struct > lttng_kernel_old_kprobe kprobe; + struct lttng_kernel_old_function > ftrace; + char padding[LTTNG_KERNEL_OLD_EVENT_PADDING2]; + } u; > +}; + +struct lttng_kernel_old_tracer_version { + uint32_t major; + > uint32_t minor; + uint32_t patchlevel; +}; + +struct > lttng_kernel_old_calibrate { + enum lttng_kernel_calibrate_type > type; /* type (input) */ +}; + +/* + * kernel channel + */ +#define > LTTNG_KERNEL_OLD_CHANNEL_PADDING1 LTTNG_SYMBOL_NAME_LEN + 32 > +struct lttng_kernel_old_channel { + int overwrite; > /* 1: overwrite, 0: discard */ + uint64_t subbuf_size; > /* bytes */ + uint64_t num_subbuf; /* power of 2 */ > + unsigned int switch_timer_interval; /* usec */ + unsigned int > read_timer_interval; /* usec */ + enum lttng_event_output output; > /* splice, mmap */ + + char > padding[LTTNG_KERNEL_OLD_CHANNEL_PADDING1]; +}; + +#endif /* > _LTTNG_KERNEL_OLD_H */ diff --git a/src/common/lttng-kernel.h > b/src/common/lttng-kernel.h index dbeb6aa..ac881bf 100644 --- > a/src/common/lttng-kernel.h +++ b/src/common/lttng-kernel.h @@ > -59,7 +59,7 @@ struct lttng_kernel_perf_counter_ctx { uint32_t > type; uint64_t config; char name[LTTNG_KERNEL_SYM_NAME_LEN]; -}; > +}__attribute__((packed)); > > /* Event/Channel context */ #define LTTNG_KERNEL_CONTEXT_PADDING1 > 16 @@ -72,14 +72,14 @@ struct lttng_kernel_context { struct > lttng_kernel_perf_counter_ctx perf_counter; char > padding[LTTNG_KERNEL_CONTEXT_PADDING2]; } u; -}; > +}__attribute__((packed)); > > struct lttng_kernel_kretprobe { uint64_t addr; > > uint64_t offset; char symbol_name[LTTNG_KERNEL_SYM_NAME_LEN]; -}; > +}__attribute__((packed)); > > /* * Either addr is used, or symbol_name and offset. @@ -89,12 > +89,12 @@ struct lttng_kernel_kprobe { > > uint64_t offset; char symbol_name[LTTNG_KERNEL_SYM_NAME_LEN]; -}; > +}__attribute__((packed)); > > /* Function tracer */ struct lttng_kernel_function { char > symbol_name[LTTNG_KERNEL_SYM_NAME_LEN]; -}; > +}__attribute__((packed)); > > #define LTTNG_KERNEL_EVENT_PADDING1 16 #define > LTTNG_KERNEL_EVENT_PADDING2 LTTNG_KERNEL_SYM_NAME_LEN + 32 @@ > -110,13 +110,13 @@ struct lttng_kernel_event { struct > lttng_kernel_function ftrace; char > padding[LTTNG_KERNEL_EVENT_PADDING2]; } u; -}; > +}__attribute__((packed)); > > struct lttng_kernel_tracer_version { uint32_t major; uint32_t > minor; uint32_t patchlevel; -}; +}__attribute__((packed)); > > enum lttng_kernel_calibrate_type { > LTTNG_KERNEL_CALIBRATE_KRETPROBE, @@ -124,6 +124,21 @@ enum > lttng_kernel_calibrate_type { > > struct lttng_kernel_calibrate { enum lttng_kernel_calibrate_type > type; /* type (input) */ -}; +}__attribute__((packed)); + +/* + * > kernel channel + */ +#define LTTNG_KERNEL_CHANNEL_PADDING1 > LTTNG_SYMBOL_NAME_LEN + 32 +struct lttng_kernel_channel { + > uint64_t subbuf_size; /* bytes */ + uint64_t > num_subbuf; /* power of 2 */ + unsigned int > switch_timer_interval; /* usec */ + unsigned int > read_timer_interval; /* usec */ + int overwrite; > /* 1: overwrite, 0: discard */ + enum lttng_event_output output; > /* splice, mmap */ + + char > padding[LTTNG_KERNEL_CHANNEL_PADDING1]; +}__attribute__((packed)); > > #endif /* _LTTNG_KERNEL_H */ -----BEGIN PGP SIGNATURE----- iQEcBAEBCgAGBQJQahOGAAoJEELoaioR9I02x3UIAKpJrPlrhDp+IS/bgfnN6DTs xpSN2Cfmmwsa8+rifSglsMf4FjPX4YrzB3ONhvLtyxTN81l1YhynYk87cE3aXEiw 2fZR5jXkU7jogk1BAd546pI5TpNU3i53JMjB+aN33tyJfIxo8pu2TnN94Rau0IDn a81ETaA5y9ABdMAc8nhH1UeUjVPFuoQkqmSePTpUWrVbWFbDPI+JJAtSEZV3MlZ7 sDnoaBNRqfqJ2oYld5GtHtDrU0BoGVhT/de9ED4TC/Pn4q1Tj6e4LgOXOw2ZK4Lb 7uH7XcoL87UUISsgzuEKfreeZQ+nDef8+TTk8Fe3DHoOfiW8Pp4BP8kN3VExcMA= =xWuT -----END PGP SIGNATURE-----