X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=lttng-syscalls.c;h=3215564161c1c35987a815106b8638e66db0e745;hb=refs%2Fheads%2Fstable-2.4;hp=e032e9404dba0bb3f0f33402e78fdb5a61ff4c4e;hpb=a93244f8421385c560a70d0308a69e7c9289916e;p=lttng-modules.git diff --git a/lttng-syscalls.c b/lttng-syscalls.c index e032e940..32155641 100644 --- a/lttng-syscalls.c +++ b/lttng-syscalls.c @@ -1,31 +1,54 @@ /* * lttng-syscalls.c * - * Copyright 2010-2011 (c) - Mathieu Desnoyers - * * LTTng syscall probes. * - * Dual LGPL v2.1/GPL v2 license. + * Copyright (C) 2010-2012 Mathieu Desnoyers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; only + * version 2.1 of the License. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include #include #include +#include #include #include -#include "ltt-events.h" +#include "wrapper/tracepoint.h" +#include "lttng-events.h" #ifndef CONFIG_COMPAT -static inline int is_compat_task(void) -{ - return 0; -} +# ifndef is_compat_task +# define is_compat_task() (0) +# endif #endif static void syscall_entry_probe(void *__data, struct pt_regs *regs, long id); +/* + * Forward declarations for old kernels. + */ +struct mmsghdr; +struct rlimit64; +struct oldold_utsname; +struct old_utsname; +struct sel_arg_struct; +struct mmap_arg_struct; + /* * Take care of NOARGS not supported by mainline. */ @@ -38,7 +61,7 @@ void syscall_entry_probe(void *__data, struct pt_regs *regs, long id); */ #define LTTNG_PACKAGE_BUILD #define CREATE_TRACE_POINTS -#define TP_MODULE_OVERRIDE +#define TP_MODULE_NOINIT #define TRACE_INCLUDE_PATH ../instrumentation/syscalls/headers #define PARAMS(args...) args @@ -96,7 +119,7 @@ void syscall_entry_probe(void *__data, struct pt_regs *regs, long id); #undef SC_DEFINE_EVENT_NOARGS #undef TP_PROBE_CB -#undef TP_MODULE_OVERRIDE +#undef TP_MODULE_NOINIT #undef LTTNG_PACKAGE_BUILD #undef CREATE_TRACE_POINTS @@ -140,7 +163,7 @@ const struct trace_syscall_entry compat_sc_table[] = { #undef CREATE_SYSCALL_TABLE -static void syscall_entry_unknown(struct ltt_event *event, +static void syscall_entry_unknown(struct lttng_event *event, struct pt_regs *regs, unsigned int id) { unsigned long args[UNKNOWN_SYSCALL_NRARGS]; @@ -154,8 +177,8 @@ static void syscall_entry_unknown(struct ltt_event *event, void syscall_entry_probe(void *__data, struct pt_regs *regs, long id) { - struct ltt_channel *chan = __data; - struct ltt_event *event, *unknown_event; + struct lttng_channel *chan = __data; + struct lttng_event *event, *unknown_event; const struct trace_syscall_entry *table, *entry; size_t table_len; @@ -271,16 +294,18 @@ void syscall_entry_probe(void *__data, struct pt_regs *regs, long id) } } +/* noinline to diminish caller stack size */ static int fill_table(const struct trace_syscall_entry *table, size_t table_len, - struct ltt_event **chan_table, struct ltt_channel *chan, void *filter) + struct lttng_event **chan_table, struct lttng_channel *chan, void *filter) { + const struct lttng_event_desc *desc; unsigned int i; /* Allocate events for each syscall, insert into table */ for (i = 0; i < table_len; i++) { struct lttng_kernel_event ev; - const struct lttng_event_desc *desc = table[i].desc; + desc = table[i].desc; if (!desc) { /* Unknown syscall */ @@ -293,33 +318,35 @@ int fill_table(const struct trace_syscall_entry *table, size_t table_len, if (chan_table[i]) continue; memset(&ev, 0, sizeof(ev)); - strncpy(ev.name, desc->name, LTTNG_SYM_NAME_LEN); - ev.name[LTTNG_SYM_NAME_LEN - 1] = '\0'; + strncpy(ev.name, desc->name, LTTNG_KERNEL_SYM_NAME_LEN); + ev.name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0'; ev.instrumentation = LTTNG_KERNEL_NOOP; - chan_table[i] = ltt_event_create(chan, &ev, filter, + chan_table[i] = lttng_event_create(chan, &ev, filter, desc); - if (!chan_table[i]) { + WARN_ON_ONCE(!chan_table[i]); + if (IS_ERR(chan_table[i])) { /* * If something goes wrong in event registration * after the first one, we have no choice but to * leave the previous events in there, until * deleted by session teardown. */ - return -EINVAL; + return PTR_ERR(chan_table[i]); } } return 0; } -int lttng_syscalls_register(struct ltt_channel *chan, void *filter) +int lttng_syscalls_register(struct lttng_channel *chan, void *filter) { + struct lttng_kernel_event ev; int ret; wrapper_vmalloc_sync_all(); if (!chan->sc_table) { /* create syscall table mapping syscall to events */ - chan->sc_table = kzalloc(sizeof(struct ltt_event *) + chan->sc_table = kzalloc(sizeof(struct lttng_event *) * ARRAY_SIZE(sc_table), GFP_KERNEL); if (!chan->sc_table) return -ENOMEM; @@ -328,57 +355,57 @@ int lttng_syscalls_register(struct ltt_channel *chan, void *filter) #ifdef CONFIG_COMPAT if (!chan->compat_sc_table) { /* create syscall table mapping compat syscall to events */ - chan->compat_sc_table = kzalloc(sizeof(struct ltt_event *) + chan->compat_sc_table = kzalloc(sizeof(struct lttng_event *) * ARRAY_SIZE(compat_sc_table), GFP_KERNEL); if (!chan->compat_sc_table) return -ENOMEM; } #endif if (!chan->sc_unknown) { - struct lttng_kernel_event ev; const struct lttng_event_desc *desc = &__event_desc___sys_unknown; memset(&ev, 0, sizeof(ev)); - strncpy(ev.name, desc->name, LTTNG_SYM_NAME_LEN); - ev.name[LTTNG_SYM_NAME_LEN - 1] = '\0'; + strncpy(ev.name, desc->name, LTTNG_KERNEL_SYM_NAME_LEN); + ev.name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0'; ev.instrumentation = LTTNG_KERNEL_NOOP; - chan->sc_unknown = ltt_event_create(chan, &ev, filter, + chan->sc_unknown = lttng_event_create(chan, &ev, filter, desc); - if (!chan->sc_unknown) { - return -EINVAL; + WARN_ON_ONCE(!chan->sc_unknown); + if (IS_ERR(chan->sc_unknown)) { + return PTR_ERR(chan->sc_unknown); } } if (!chan->sc_compat_unknown) { - struct lttng_kernel_event ev; const struct lttng_event_desc *desc = &__event_desc___compat_sys_unknown; memset(&ev, 0, sizeof(ev)); - strncpy(ev.name, desc->name, LTTNG_SYM_NAME_LEN); - ev.name[LTTNG_SYM_NAME_LEN - 1] = '\0'; + strncpy(ev.name, desc->name, LTTNG_KERNEL_SYM_NAME_LEN); + ev.name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0'; ev.instrumentation = LTTNG_KERNEL_NOOP; - chan->sc_compat_unknown = ltt_event_create(chan, &ev, filter, + chan->sc_compat_unknown = lttng_event_create(chan, &ev, filter, desc); - if (!chan->sc_compat_unknown) { - return -EINVAL; + WARN_ON_ONCE(!chan->sc_unknown); + if (IS_ERR(chan->sc_compat_unknown)) { + return PTR_ERR(chan->sc_compat_unknown); } } if (!chan->sc_exit) { - struct lttng_kernel_event ev; const struct lttng_event_desc *desc = &__event_desc___exit_syscall; memset(&ev, 0, sizeof(ev)); - strncpy(ev.name, desc->name, LTTNG_SYM_NAME_LEN); - ev.name[LTTNG_SYM_NAME_LEN - 1] = '\0'; + strncpy(ev.name, desc->name, LTTNG_KERNEL_SYM_NAME_LEN); + ev.name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0'; ev.instrumentation = LTTNG_KERNEL_NOOP; - chan->sc_exit = ltt_event_create(chan, &ev, filter, + chan->sc_exit = lttng_event_create(chan, &ev, filter, desc); - if (!chan->sc_exit) { - return -EINVAL; + WARN_ON_ONCE(!chan->sc_exit); + if (IS_ERR(chan->sc_exit)) { + return PTR_ERR(chan->sc_exit); } } @@ -392,7 +419,7 @@ int lttng_syscalls_register(struct ltt_channel *chan, void *filter) if (ret) return ret; #endif - ret = tracepoint_probe_register("sys_enter", + ret = kabi_2635_tracepoint_probe_register("sys_enter", (void *) syscall_entry_probe, chan); if (ret) return ret; @@ -400,11 +427,11 @@ int lttng_syscalls_register(struct ltt_channel *chan, void *filter) * We change the name of sys_exit tracepoint due to namespace * conflict with sys_exit syscall entry. */ - ret = tracepoint_probe_register("sys_exit", + ret = kabi_2635_tracepoint_probe_register("sys_exit", (void *) __event_probe__exit_syscall, chan->sc_exit); if (ret) { - WARN_ON_ONCE(tracepoint_probe_unregister("sys_enter", + WARN_ON_ONCE(kabi_2635_tracepoint_probe_unregister("sys_enter", (void *) syscall_entry_probe, chan)); } return ret; @@ -413,22 +440,22 @@ int lttng_syscalls_register(struct ltt_channel *chan, void *filter) /* * Only called at session destruction. */ -int lttng_syscalls_unregister(struct ltt_channel *chan) +int lttng_syscalls_unregister(struct lttng_channel *chan) { int ret; if (!chan->sc_table) return 0; - ret = tracepoint_probe_unregister("sys_exit", + ret = kabi_2635_tracepoint_probe_unregister("sys_exit", (void *) __event_probe__exit_syscall, chan->sc_exit); if (ret) return ret; - ret = tracepoint_probe_unregister("sys_enter", + ret = kabi_2635_tracepoint_probe_unregister("sys_enter", (void *) syscall_entry_probe, chan); if (ret) return ret; - /* ltt_event destroy will be performed by ltt_session_destroy() */ + /* lttng_event destroy will be performed by lttng_session_destroy() */ kfree(chan->sc_table); #ifdef CONFIG_COMPAT kfree(chan->compat_sc_table);