From mboxrd@z Thu Jan 1 00:00:00 1970 From: dgoulet@efficios.com (David Goulet) Date: Tue, 09 Oct 2012 10:41:59 -0400 Subject: [lttng-dev] [LTTNG-TOOLS PATCH v5] ABI with support for compat 32/64 bits In-Reply-To: <506C4044.7000603@efficios.com> References: <1349204606-6473-1-git-send-email-jdesfossez@efficios.com> <506C4044.7000603@efficios.com> Message-ID: <507437B7.8020309@efficios.com> Status on that patch? Mathieu? David Goulet: > This look good to me. There is a small change I would make though to the > open_metadata call where the old_channel is not in the if - else{} > statement but I'll do it before merging it. Don't bother sending back a > version. > > Acked. > > David > > 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 | 224 ++++++++++++++++++++++++++++++--- >> 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, 397 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..a93d251 100644 >> --- a/src/common/kernel-ctl/kernel-ctl.c >> +++ b/src/common/kernel-ctl/kernel-ctl.c >> @@ -18,38 +18,175 @@ >> >> #define __USE_LINUX_IOCTL_DEFS >> #include >> +#include >> >> #include "kernel-ctl.h" >> #include "kernel-ioctl.h" >> >> +/* >> + * This flag indicates which version of the kernel ABI to use. The old >> + * ABI (namespace _old) does not support a 32-bit user-space when the >> + * kernel is 64-bit. The old ABI is kept here for compatibility but is >> + * deprecated and will be removed eventually. >> + */ >> +static int lttng_kernel_use_old_abi = -1; >> + >> +/* >> + * Execute the new or old ioctl depending on the ABI version. >> + * If the ABI version is not determined yet (lttng_kernel_use_old_abi = -1), >> + * this function tests if the new ABI is available and otherwise fallbacks >> + * on the old one. >> + * This function takes the fd on which the ioctl must be executed and the old >> + * and new request codes. >> + * It returns the return value of the ioctl executed. >> + */ >> +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(old_channel.padding)); >> + >> + 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(channel.padding)); >> + >> + 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_channel channel; >> + >> + if (lttng_kernel_use_old_abi) { >> + struct lttng_kernel_old_channel old_channel; >> + >> + 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(old_channel.padding)); >> + >> + 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(channel.padding)); >> + >> + 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_old_event old_event; >> + >> + 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 +194,98 @@ 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; >> + } >> + 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; >> + } >> + calibrate->type = old_calibrate.type; >> + } else { >> + ret = ioctl(fd, LTTNG_KERNEL_CALIBRATE, calibrate); >> + } >> + >> +end: >> + return ret; >> } >> >> >> @@ -193,10 +384,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..8e22632 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) >> + >> + >> +/* Current ABI (with suport for 32/64 bits compat) */ >> /* 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..fa8ba61 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 */ >> + enum lttng_event_output output; /* splice, mmap */ >> + >> + int overwrite; /* 1: overwrite, 0: discard */ >> + char padding[LTTNG_KERNEL_CHANNEL_PADDING1]; >> +}__attribute__((packed)); >> >> #endif /* _LTTNG_KERNEL_H */ > > _______________________________________________ > lttng-dev mailing list > lttng-dev at lists.lttng.org > http://lists.lttng.org/cgi-bin/mailman/listinfo/lttng-dev