From: Mathieu Desnoyers Date: Tue, 14 Apr 2020 15:31:36 +0000 (-0400) Subject: Move headers under include/ X-Git-Tag: for-upstreaming-review-1 X-Git-Url: http://git.liburcu.org/?p=lttng-modules.git;a=commitdiff_plain;h=refs%2Ftags%2Ffor-upstreaming-review-1 Move headers under include/ --- diff --git a/LICENSE b/LICENSE index 060e266a..3b8eaf84 100644 --- a/LICENSE +++ b/LICENSE @@ -22,12 +22,12 @@ instrumentation/events/lttng-module/*.h These files are licensed under an MIT-style license. See LICENSES/MIT for details. -lib/prio_heap/lttng_prio_heap.h +include/lttng/lttng_prio_heap.h +include/lttng/bitfield.h +include/lttng/filter-bytecode.h +include/lttng/lttng-filter.h lib/prio_heap/lttng_prio_heap.c -lib/bitfield.h -filter-bytecode.h lttng-filter-interpreter.c lttng-filter-specialize.c lttng-filter-validator.c lttng-filter.c -lttng-filter.h diff --git a/Makefile b/Makefile index 3486002b..9de6aed1 100644 --- a/Makefile +++ b/Makefile @@ -29,7 +29,7 @@ ifneq ($(KERNELRELEASE),) include $(TOP_LTTNG_MODULES_DIR)/Kbuild.common - ccflags-y += -I$(TOP_LTTNG_MODULES_DIR) + ccflags-y += -I$(TOP_LTTNG_MODULES_DIR)/include obj-$(CONFIG_LTTNG) += lttng-ring-buffer-client-discard.o obj-$(CONFIG_LTTNG) += lttng-ring-buffer-client-overwrite.o @@ -64,7 +64,7 @@ ifneq ($(KERNELRELEASE),) lttng-context-need-reschedule.o \ lttng-context-callstack.o lttng-calibrate.o \ lttng-context-hostname.o \ - probes/lttng.o wrapper/trace-clock.o \ + probes/lttng.o trace-clock.o \ lttng-tracker-id.o \ lttng-filter.o lttng-filter-interpreter.o \ lttng-filter-specialize.o \ diff --git a/filter-bytecode.h b/filter-bytecode.h deleted file mode 100644 index 65d34f02..00000000 --- a/filter-bytecode.h +++ /dev/null @@ -1,225 +0,0 @@ -/* SPDX-License-Identifier: MIT - * - * filter-bytecode.h - * - * LTTng filter bytecode - * - * Copyright 2012-2016 - Mathieu Desnoyers - */ - -#ifndef _FILTER_BYTECODE_H -#define _FILTER_BYTECODE_H - -/* - * offsets are absolute from start of bytecode. - */ - -struct field_ref { - /* Initially, symbol offset. After link, field offset. */ - uint16_t offset; -} __attribute__((packed)); - -struct get_symbol { - /* Symbol offset. */ - uint16_t offset; -} __attribute__((packed)); - -struct get_index_u16 { - uint16_t index; -} __attribute__((packed)); - -struct get_index_u64 { - uint64_t index; -} __attribute__((packed)); - -struct literal_numeric { - int64_t v; -} __attribute__((packed)); - -struct literal_double { - double v; -} __attribute__((packed)); - -struct literal_string { - char string[0]; -} __attribute__((packed)); - -enum filter_op { - FILTER_OP_UNKNOWN = 0, - - FILTER_OP_RETURN = 1, - - /* binary */ - FILTER_OP_MUL = 2, - FILTER_OP_DIV = 3, - FILTER_OP_MOD = 4, - FILTER_OP_PLUS = 5, - FILTER_OP_MINUS = 6, - FILTER_OP_BIT_RSHIFT = 7, - FILTER_OP_BIT_LSHIFT = 8, - FILTER_OP_BIT_AND = 9, - FILTER_OP_BIT_OR = 10, - FILTER_OP_BIT_XOR = 11, - - /* binary comparators */ - FILTER_OP_EQ = 12, - FILTER_OP_NE = 13, - FILTER_OP_GT = 14, - FILTER_OP_LT = 15, - FILTER_OP_GE = 16, - FILTER_OP_LE = 17, - - /* string binary comparator: apply to */ - FILTER_OP_EQ_STRING = 18, - FILTER_OP_NE_STRING = 19, - FILTER_OP_GT_STRING = 20, - FILTER_OP_LT_STRING = 21, - FILTER_OP_GE_STRING = 22, - FILTER_OP_LE_STRING = 23, - - /* s64 binary comparator */ - FILTER_OP_EQ_S64 = 24, - FILTER_OP_NE_S64 = 25, - FILTER_OP_GT_S64 = 26, - FILTER_OP_LT_S64 = 27, - FILTER_OP_GE_S64 = 28, - FILTER_OP_LE_S64 = 29, - - /* double binary comparator */ - FILTER_OP_EQ_DOUBLE = 30, - FILTER_OP_NE_DOUBLE = 31, - FILTER_OP_GT_DOUBLE = 32, - FILTER_OP_LT_DOUBLE = 33, - FILTER_OP_GE_DOUBLE = 34, - FILTER_OP_LE_DOUBLE = 35, - - /* Mixed S64-double binary comparators */ - FILTER_OP_EQ_DOUBLE_S64 = 36, - FILTER_OP_NE_DOUBLE_S64 = 37, - FILTER_OP_GT_DOUBLE_S64 = 38, - FILTER_OP_LT_DOUBLE_S64 = 39, - FILTER_OP_GE_DOUBLE_S64 = 40, - FILTER_OP_LE_DOUBLE_S64 = 41, - - FILTER_OP_EQ_S64_DOUBLE = 42, - FILTER_OP_NE_S64_DOUBLE = 43, - FILTER_OP_GT_S64_DOUBLE = 44, - FILTER_OP_LT_S64_DOUBLE = 45, - FILTER_OP_GE_S64_DOUBLE = 46, - FILTER_OP_LE_S64_DOUBLE = 47, - - /* unary */ - FILTER_OP_UNARY_PLUS = 48, - FILTER_OP_UNARY_MINUS = 49, - FILTER_OP_UNARY_NOT = 50, - FILTER_OP_UNARY_PLUS_S64 = 51, - FILTER_OP_UNARY_MINUS_S64 = 52, - FILTER_OP_UNARY_NOT_S64 = 53, - FILTER_OP_UNARY_PLUS_DOUBLE = 54, - FILTER_OP_UNARY_MINUS_DOUBLE = 55, - FILTER_OP_UNARY_NOT_DOUBLE = 56, - - /* logical */ - FILTER_OP_AND = 57, - FILTER_OP_OR = 58, - - /* load field ref */ - FILTER_OP_LOAD_FIELD_REF = 59, - FILTER_OP_LOAD_FIELD_REF_STRING = 60, - FILTER_OP_LOAD_FIELD_REF_SEQUENCE = 61, - FILTER_OP_LOAD_FIELD_REF_S64 = 62, - FILTER_OP_LOAD_FIELD_REF_DOUBLE = 63, - - /* load immediate from operand */ - FILTER_OP_LOAD_STRING = 64, - FILTER_OP_LOAD_S64 = 65, - FILTER_OP_LOAD_DOUBLE = 66, - - /* cast */ - FILTER_OP_CAST_TO_S64 = 67, - FILTER_OP_CAST_DOUBLE_TO_S64 = 68, - FILTER_OP_CAST_NOP = 69, - - /* get context ref */ - FILTER_OP_GET_CONTEXT_REF = 70, - FILTER_OP_GET_CONTEXT_REF_STRING = 71, - FILTER_OP_GET_CONTEXT_REF_S64 = 72, - FILTER_OP_GET_CONTEXT_REF_DOUBLE = 73, - - /* load userspace field ref */ - FILTER_OP_LOAD_FIELD_REF_USER_STRING = 74, - FILTER_OP_LOAD_FIELD_REF_USER_SEQUENCE = 75, - - /* - * load immediate star globbing pattern (literal string) - * from immediate - */ - FILTER_OP_LOAD_STAR_GLOB_STRING = 76, - - /* globbing pattern binary operator: apply to */ - FILTER_OP_EQ_STAR_GLOB_STRING = 77, - FILTER_OP_NE_STAR_GLOB_STRING = 78, - - /* - * Instructions for recursive traversal through composed types. - */ - FILTER_OP_GET_CONTEXT_ROOT = 79, - FILTER_OP_GET_APP_CONTEXT_ROOT = 80, - FILTER_OP_GET_PAYLOAD_ROOT = 81, - - FILTER_OP_GET_SYMBOL = 82, - FILTER_OP_GET_SYMBOL_FIELD = 83, - FILTER_OP_GET_INDEX_U16 = 84, - FILTER_OP_GET_INDEX_U64 = 85, - - FILTER_OP_LOAD_FIELD = 86, - FILTER_OP_LOAD_FIELD_S8 = 87, - FILTER_OP_LOAD_FIELD_S16 = 88, - FILTER_OP_LOAD_FIELD_S32 = 89, - FILTER_OP_LOAD_FIELD_S64 = 90, - FILTER_OP_LOAD_FIELD_U8 = 91, - FILTER_OP_LOAD_FIELD_U16 = 92, - FILTER_OP_LOAD_FIELD_U32 = 93, - FILTER_OP_LOAD_FIELD_U64 = 94, - FILTER_OP_LOAD_FIELD_STRING = 95, - FILTER_OP_LOAD_FIELD_SEQUENCE = 96, - FILTER_OP_LOAD_FIELD_DOUBLE = 97, - - FILTER_OP_UNARY_BIT_NOT = 98, - - FILTER_OP_RETURN_S64 = 99, - - NR_FILTER_OPS, -}; - -typedef uint8_t filter_opcode_t; - -struct load_op { - filter_opcode_t op; - char data[0]; - /* data to load. Size known by enum filter_opcode and null-term char. */ -} __attribute__((packed)); - -struct binary_op { - filter_opcode_t op; -} __attribute__((packed)); - -struct unary_op { - filter_opcode_t op; -} __attribute__((packed)); - -/* skip_offset is absolute from start of bytecode */ -struct logical_op { - filter_opcode_t op; - uint16_t skip_offset; /* bytecode insn, if skip second test */ -} __attribute__((packed)); - -struct cast_op { - filter_opcode_t op; -} __attribute__((packed)); - -struct return_op { - filter_opcode_t op; -} __attribute__((packed)); - -#endif /* _FILTER_BYTECODE_H */ diff --git a/include/instrumentation/events/README b/include/instrumentation/events/README new file mode 100644 index 00000000..fc3cd6e2 --- /dev/null +++ b/include/instrumentation/events/README @@ -0,0 +1,24 @@ +* Workflow for updating patches from newer kernel: + +Pull the new headers from mainline kernel to lttng-modules/. +Update those headers to fix the lttng-modules instrumentation style. + + +* Workflow to add new Tracepoint instrumentation to newer kernel, + and add support for it into LTTng: + +a) instrument the kernel with new trace events headers. If you want that + instrumentation distributed, you will have to push those changes into + the upstream Linux kernel first, +b) copy those headers into lttng-modules/ directory, +c) look at a diff from other headers between mainline kernel version and + lttng-modules/, and use that as a recipe to alter the new + lttng-modules/ headers. +d) create a new file in probes/ for the new trace event header you added, +e) add it to probes/Makefile, +f) build, make modules_install, +g) don't forget to load that new module too. + +Currently, LTTng policy is to only accept headers derived from trace +event headers accepted into the Linux kernel upstream for tracepoints +related to upstream kernel instrumentation. diff --git a/include/instrumentation/events/lttng-module/9p.h b/include/instrumentation/events/lttng-module/9p.h new file mode 100644 index 00000000..43283e8a --- /dev/null +++ b/include/instrumentation/events/lttng-module/9p.h @@ -0,0 +1,54 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#undef TRACE_SYSTEM +#define TRACE_SYSTEM 9p + +#if !defined(LTTNG_TRACE_9P_H) || defined(TRACE_HEADER_MULTI_READ) +#define LTTNG_TRACE_9P_H + +#include + +LTTNG_TRACEPOINT_EVENT(9p_client_req, + + TP_PROTO(struct p9_client *clnt, int8_t type, int tag), + + TP_ARGS(clnt, type, tag), + + TP_FIELDS( + ctf_integer_hex(void *, clnt, clnt) + ctf_integer(u8, type, type) + ctf_integer(u32, tag, tag) + ) +) + +LTTNG_TRACEPOINT_EVENT(9p_client_res, + + TP_PROTO(struct p9_client *clnt, int8_t type, int tag, int err), + + TP_ARGS(clnt, type, tag, err), + + TP_FIELDS( + ctf_integer_hex(void *, clnt, clnt) + ctf_integer(u8, type, type) + ctf_integer(u32, tag, tag) + ctf_integer(u32, err, err) + ) +) + +LTTNG_TRACEPOINT_EVENT(9p_protocol_dump, + + TP_PROTO(struct p9_client *clnt, struct p9_fcall *pdu), + + TP_ARGS(clnt, pdu), + + TP_FIELDS( + ctf_integer_hex(void *, clnt, clnt) + ctf_integer(u8, type, pdu->id) + ctf_integer(u16, tag, pdu->tag) + ctf_array(unsigned char, line, pdu->sdata, P9_PROTO_DUMP_SZ) + ) +) + +#endif /* LTTNG_TRACE_9P_H */ + +/* This part must be outside protection */ +#include diff --git a/include/instrumentation/events/lttng-module/arch/x86/exceptions.h b/include/instrumentation/events/lttng-module/arch/x86/exceptions.h new file mode 100644 index 00000000..d8bca0d9 --- /dev/null +++ b/include/instrumentation/events/lttng-module/arch/x86/exceptions.h @@ -0,0 +1,53 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#if !defined(LTTNG_TRACE_EXCEPTIONS_H) || defined(TRACE_HEADER_MULTI_READ) +#define LTTNG_TRACE_EXCEPTIONS_H + +#include +#include + +#undef TRACE_SYSTEM +#define TRACE_SYSTEM x86_exceptions + +LTTNG_TRACEPOINT_EVENT_CLASS(x86_exceptions_class, + + TP_PROTO(unsigned long address, struct pt_regs *regs, + unsigned long error_code), + + TP_ARGS(address, regs, error_code), + + TP_FIELDS( + ctf_integer_hex(unsigned long, address, address) + ctf_integer_hex(unsigned long, ip, regs->ip) + /* + * Note: we cast error_code from unsigned long + * to unsigned char to save space in the trace. + * Currently, only 5 low bits are used. Should be made + * larger if error codes are added to the kernel. + */ + ctf_integer_hex(unsigned char, error_code, error_code) + ) +) + +#define LTTNG_EXCEPTIONS_TRACEPOINT_EVENT_INSTANCE_MAP(name, map) \ +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(x86_exceptions_class, \ + name, \ + map, \ + TP_PROTO(unsigned long address, struct pt_regs *regs, \ + unsigned long error_code), \ + TP_ARGS(address, regs, error_code) \ +) + +LTTNG_EXCEPTIONS_TRACEPOINT_EVENT_INSTANCE_MAP(page_fault_user, + x86_exceptions_page_fault_user) +LTTNG_EXCEPTIONS_TRACEPOINT_EVENT_INSTANCE_MAP(page_fault_kernel, + x86_exceptions_page_fault_kernel) + +#endif /* LTTNG_TRACE_EXCEPTIONS_H */ + +#undef TRACE_INCLUDE_PATH +#define TRACE_INCLUDE_PATH instrumentation/events/lttng-module/arch/x86 +#undef TRACE_INCLUDE_FILE +#define TRACE_INCLUDE_FILE exceptions + +/* This part must be outside protection */ +#include diff --git a/include/instrumentation/events/lttng-module/arch/x86/irq_vectors.h b/include/instrumentation/events/lttng-module/arch/x86/irq_vectors.h new file mode 100644 index 00000000..bcf4819a --- /dev/null +++ b/include/instrumentation/events/lttng-module/arch/x86/irq_vectors.h @@ -0,0 +1,116 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#if !defined(LTTNG_TRACE_IRQ_VECTORS_H) || defined(TRACE_HEADER_MULTI_READ) +#define LTTNG_TRACE_IRQ_VECTORS_H + +#include +#include + +#undef TRACE_SYSTEM +#define TRACE_SYSTEM x86_irq_vectors + +LTTNG_TRACEPOINT_EVENT_CLASS(x86_irq_vectors_vector_class, + TP_PROTO(int vector), + TP_ARGS(vector), + + TP_FIELDS( + ctf_integer(int, vector, vector) + ) +) + +#define LTTNG_IRQ_VECTOR_TRACEPOINT_EVENT_INSTANCE_MAP(name, map) \ +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(x86_irq_vectors_vector_class, \ + name##_entry, \ + map##_entry, \ + TP_PROTO(int vector), \ + TP_ARGS(vector) \ +) \ +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(x86_irq_vectors_vector_class, \ + name##_exit, \ + map##_exit, \ + TP_PROTO(int vector), \ + TP_ARGS(vector) \ +) + +/* + * local_timer - called when entering/exiting a local timer interrupt + * vector handler + */ +LTTNG_IRQ_VECTOR_TRACEPOINT_EVENT_INSTANCE_MAP(local_timer, + x86_irq_vectors_local_timer) + +/* + * reschedule - called when entering/exiting a reschedule vector handler + */ +LTTNG_IRQ_VECTOR_TRACEPOINT_EVENT_INSTANCE_MAP(reschedule, + x86_irq_vectors_reschedule) + +/* + * spurious_apic - called when entering/exiting a spurious apic vector handler + */ +LTTNG_IRQ_VECTOR_TRACEPOINT_EVENT_INSTANCE_MAP(spurious_apic, + x86_irq_vectors_spurious_apic) + +/* + * error_apic - called when entering/exiting an error apic vector handler + */ +LTTNG_IRQ_VECTOR_TRACEPOINT_EVENT_INSTANCE_MAP(error_apic, + x86_irq_vectors_error_apic) + +/* + * x86_platform_ipi - called when entering/exiting a x86 platform ipi interrupt + * vector handler + */ +LTTNG_IRQ_VECTOR_TRACEPOINT_EVENT_INSTANCE_MAP(x86_platform_ipi, + x86_irq_vectors_ipi) + +/* + * irq_work - called when entering/exiting a irq work interrupt + * vector handler + */ +LTTNG_IRQ_VECTOR_TRACEPOINT_EVENT_INSTANCE_MAP(irq_work, + x86_irq_vectors_irq_work) + +/* + * call_function - called when entering/exiting a call function interrupt + * vector handler + */ +LTTNG_IRQ_VECTOR_TRACEPOINT_EVENT_INSTANCE_MAP(call_function, + x86_irq_vectors_call_function) + +/* + * call_function_single - called when entering/exiting a call function + * single interrupt vector handler + */ +LTTNG_IRQ_VECTOR_TRACEPOINT_EVENT_INSTANCE_MAP(call_function_single, + x86_irq_vectors_call_function_single) + +/* + * threshold_apic - called when entering/exiting a threshold apic interrupt + * vector handler + */ +LTTNG_IRQ_VECTOR_TRACEPOINT_EVENT_INSTANCE_MAP(threshold_apic, + x86_irq_vectors_threshold_apic) + +/* + * deferred_error_apic - called when entering/exiting a deferred apic interrupt + * vector handler + */ +LTTNG_IRQ_VECTOR_TRACEPOINT_EVENT_INSTANCE_MAP(deferred_error_apic, + x86_irq_vectors_deferred_error_apic) + +/* + * thermal_apic - called when entering/exiting a thermal apic interrupt + * vector handler + */ +LTTNG_IRQ_VECTOR_TRACEPOINT_EVENT_INSTANCE_MAP(thermal_apic, + x86_irq_vectors_thermal_apic) + +#endif /* LTTNG_TRACE_IRQ_VECTORS_H */ + +#undef TRACE_INCLUDE_PATH +#define TRACE_INCLUDE_PATH instrumentation/events/lttng-module/arch/x86 +#undef TRACE_INCLUDE_FILE +#define TRACE_INCLUDE_FILE irq_vectors + +/* This part must be outside protection */ +#include diff --git a/include/instrumentation/events/lttng-module/arch/x86/kvm/mmutrace.h b/include/instrumentation/events/lttng-module/arch/x86/kvm/mmutrace.h new file mode 100644 index 00000000..70d6e865 --- /dev/null +++ b/include/instrumentation/events/lttng-module/arch/x86/kvm/mmutrace.h @@ -0,0 +1,180 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#if !defined(LTTNG_TRACE_KVM_MMU_H) || defined(TRACE_HEADER_MULTI_READ) +#define LTTNG_TRACE_KVM_MMU_H + +#include + +#include + +#undef TRACE_SYSTEM +#define TRACE_SYSTEM kvm_mmu + +#define LTTNG_KVM_MMU_PAGE_FIELDS \ + ctf_integer(__u64, gfn, (sp)->gfn) \ + ctf_integer(__u32, role, (sp)->role.word) \ + ctf_integer(__u32, root_count, (sp)->root_count) \ + ctf_integer(bool, unsync, (sp)->unsync) + +/* + * A pagetable walk has started + */ +LTTNG_TRACEPOINT_EVENT( + kvm_mmu_pagetable_walk, + TP_PROTO(u64 addr, u32 pferr), + TP_ARGS(addr, pferr), + + TP_FIELDS( + ctf_integer_hex(__u64, addr, addr) + ctf_integer(__u32, pferr, pferr) + ) +) + +/* We just walked a paging element */ +LTTNG_TRACEPOINT_EVENT( + kvm_mmu_paging_element, + TP_PROTO(u64 pte, int level), + TP_ARGS(pte, level), + + TP_FIELDS( + ctf_integer(__u64, pte, pte) + ctf_integer(__u32, level, level) + ) +) + +LTTNG_TRACEPOINT_EVENT_CLASS(kvm_mmu_set_bit_class, + + TP_PROTO(unsigned long table_gfn, unsigned index, unsigned size), + + TP_ARGS(table_gfn, index, size), + + TP_FIELDS( + ctf_integer(__u64, gpa, + ((u64)table_gfn << PAGE_SHIFT) + index * size) + ) +) + +/* We set a pte accessed bit */ +LTTNG_TRACEPOINT_EVENT_INSTANCE(kvm_mmu_set_bit_class, kvm_mmu_set_accessed_bit, + + TP_PROTO(unsigned long table_gfn, unsigned index, unsigned size), + + TP_ARGS(table_gfn, index, size) +) + +/* We set a pte dirty bit */ +LTTNG_TRACEPOINT_EVENT_INSTANCE(kvm_mmu_set_bit_class, kvm_mmu_set_dirty_bit, + + TP_PROTO(unsigned long table_gfn, unsigned index, unsigned size), + + TP_ARGS(table_gfn, index, size) +) + +LTTNG_TRACEPOINT_EVENT( + kvm_mmu_walker_error, + TP_PROTO(u32 pferr), + TP_ARGS(pferr), + + TP_FIELDS( + ctf_integer(__u32, pferr, pferr) + ) +) + +LTTNG_TRACEPOINT_EVENT( + kvm_mmu_get_page, + TP_PROTO(struct kvm_mmu_page *sp, bool created), + TP_ARGS(sp, created), + + TP_FIELDS( + LTTNG_KVM_MMU_PAGE_FIELDS + ctf_integer(bool, created, created) + ) +) + +LTTNG_TRACEPOINT_EVENT_CLASS(kvm_mmu_page_class, + + TP_PROTO(struct kvm_mmu_page *sp), + TP_ARGS(sp), + + TP_FIELDS( + LTTNG_KVM_MMU_PAGE_FIELDS + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(kvm_mmu_page_class, kvm_mmu_sync_page, + TP_PROTO(struct kvm_mmu_page *sp), + + TP_ARGS(sp) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(kvm_mmu_page_class, kvm_mmu_unsync_page, + TP_PROTO(struct kvm_mmu_page *sp), + + TP_ARGS(sp) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(kvm_mmu_page_class, kvm_mmu_prepare_zap_page, + TP_PROTO(struct kvm_mmu_page *sp), + + TP_ARGS(sp) +) + +LTTNG_TRACEPOINT_EVENT_MAP( + mark_mmio_spte, + + kvm_mmu_mark_mmio_spte, + + TP_PROTO(u64 *sptep, gfn_t gfn, unsigned access, unsigned int gen), + TP_ARGS(sptep, gfn, access, gen), + + TP_FIELDS( + ctf_integer_hex(void *, sptep, sptep) + ctf_integer(gfn_t, gfn, gfn) + ctf_integer(unsigned, access, access) + ctf_integer(unsigned int, gen, gen) + ) +) + +LTTNG_TRACEPOINT_EVENT_MAP( + handle_mmio_page_fault, + + kvm_mmu_handle_mmio_page_fault, + + TP_PROTO(u64 addr, gfn_t gfn, unsigned access), + TP_ARGS(addr, gfn, access), + + TP_FIELDS( + ctf_integer_hex(u64, addr, addr) + ctf_integer(gfn_t, gfn, gfn) + ctf_integer(unsigned, access, access) + ) +) + +LTTNG_TRACEPOINT_EVENT_MAP( + fast_page_fault, + + kvm_mmu_fast_page_fault, + + TP_PROTO(struct kvm_vcpu *vcpu, gpa_t cr2_or_gpa, u32 error_code, + u64 *sptep, u64 old_spte, bool retry), + TP_ARGS(vcpu, cr2_or_gpa, error_code, sptep, old_spte, retry), + + TP_FIELDS( + ctf_integer(int, vcpu_id, vcpu->vcpu_id) + ctf_integer(gpa_t, cr2_or_gpa, cr2_or_gpa) + ctf_integer(u32, error_code, error_code) + ctf_integer_hex(u64 *, sptep, sptep) + ctf_integer(u64, old_spte, old_spte) + ctf_integer(u64, new_spte, *sptep) + ctf_integer(bool, retry, retry) + ) +) + +#endif /* LTTNG_TRACE_KVM_MMU_H */ + +#undef TRACE_INCLUDE_PATH +#define TRACE_INCLUDE_PATH instrumentation/events/lttng-module/arch/x86/kvm +#undef TRACE_INCLUDE_FILE +#define TRACE_INCLUDE_FILE mmutrace + +/* This part must be outside protection */ +#include diff --git a/include/instrumentation/events/lttng-module/arch/x86/kvm/trace.h b/include/instrumentation/events/lttng-module/arch/x86/kvm/trace.h new file mode 100644 index 00000000..22a1a580 --- /dev/null +++ b/include/instrumentation/events/lttng-module/arch/x86/kvm/trace.h @@ -0,0 +1,503 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#if !defined(LTTNG_TRACE_KVM_H) || defined(TRACE_HEADER_MULTI_READ) +#define LTTNG_TRACE_KVM_H + +#include +#include +#include +#include +#include <../arch/x86/kvm/lapic.h> +#include <../arch/x86/kvm/kvm_cache_regs.h> + +#undef TRACE_SYSTEM +#define TRACE_SYSTEM kvm_x86 + +/* + * Tracepoint for guest mode entry. + */ +LTTNG_TRACEPOINT_EVENT_MAP(kvm_entry, kvm_x86_entry, + TP_PROTO(unsigned int vcpu_id), + TP_ARGS(vcpu_id), + + TP_FIELDS( + ctf_integer(unsigned int, vcpu_id, vcpu_id) + ) +) + +/* + * Tracepoint for hypercall. + */ +LTTNG_TRACEPOINT_EVENT_MAP(kvm_hypercall, kvm_x86_hypercall, + TP_PROTO(unsigned long nr, unsigned long a0, unsigned long a1, + unsigned long a2, unsigned long a3), + TP_ARGS(nr, a0, a1, a2, a3), + + TP_FIELDS( + ctf_integer(unsigned long, nr, nr) + ctf_integer(unsigned long, a0, a0) + ctf_integer(unsigned long, a1, a1) + ctf_integer(unsigned long, a2, a2) + ctf_integer(unsigned long, a3, a3) + ) +) + +/* + * Tracepoint for hypercall. + */ +LTTNG_TRACEPOINT_EVENT_MAP(kvm_hv_hypercall, kvm_x86_hv_hypercall, + TP_PROTO(__u16 code, bool fast, __u16 rep_cnt, __u16 rep_idx, + __u64 ingpa, __u64 outgpa), + TP_ARGS(code, fast, rep_cnt, rep_idx, ingpa, outgpa), + + TP_FIELDS( + ctf_integer(__u16, rep_cnt, rep_cnt) + ctf_integer(__u16, rep_idx, rep_idx) + ctf_integer(__u64, ingpa, ingpa) + ctf_integer(__u64, outgpa, outgpa) + ctf_integer(__u16, code, code) + ctf_integer(bool, fast, fast) + ) +) + +/* + * Tracepoint for PIO. + */ +LTTNG_TRACEPOINT_EVENT_MAP(kvm_pio, kvm_x86_pio, + TP_PROTO(unsigned int rw, unsigned int port, unsigned int size, + unsigned int count), + TP_ARGS(rw, port, size, count), + + TP_FIELDS( + ctf_integer(unsigned int, rw, rw) + ctf_integer(unsigned int, port, port) + ctf_integer(unsigned int, size, size) + ctf_integer(unsigned int, count, count) + ) +) + +/* + * Tracepoint for cpuid. + */ +LTTNG_TRACEPOINT_EVENT_MAP(kvm_cpuid, kvm_x86_cpuid, + TP_PROTO(unsigned int function, unsigned long rax, unsigned long rbx, + unsigned long rcx, unsigned long rdx), + TP_ARGS(function, rax, rbx, rcx, rdx), + + TP_FIELDS( + ctf_integer(unsigned int, function, function) + ctf_integer(unsigned long, rax, rax) + ctf_integer(unsigned long, rbx, rbx) + ctf_integer(unsigned long, rcx, rcx) + ctf_integer(unsigned long, rdx, rdx) + ) +) + +/* + * Tracepoint for apic access. + */ +LTTNG_TRACEPOINT_EVENT_MAP(kvm_apic, kvm_x86_apic, + TP_PROTO(unsigned int rw, unsigned int reg, unsigned int val), + TP_ARGS(rw, reg, val), + + TP_FIELDS( + ctf_integer(unsigned int, rw, rw) + ctf_integer(unsigned int, reg, reg) + ctf_integer(unsigned int, val, val) + ) +) + +#define trace_kvm_apic_read(reg, val) trace_kvm_apic(0, reg, val) +#define trace_kvm_apic_write(reg, val) trace_kvm_apic(1, reg, val) + +/* + * Tracepoint for kvm guest exit: + */ +LTTNG_TRACEPOINT_EVENT_CODE_MAP(kvm_exit, kvm_x86_exit, + TP_PROTO(unsigned int exit_reason, struct kvm_vcpu *vcpu, u32 isa), + TP_ARGS(exit_reason, vcpu, isa), + + TP_locvar( + u64 info1, info2; + ), + + TP_code_pre( + kvm_x86_ops.get_exit_info(vcpu, &tp_locvar->info1, + &tp_locvar->info2); + ), + + TP_FIELDS( + ctf_integer(unsigned int, exit_reason, exit_reason) + ctf_integer(unsigned long, guest_rip, kvm_rip_read(vcpu)) + ctf_integer(u32, isa, isa) + ctf_integer(u64, info1, tp_locvar->info1) + ctf_integer(u64, info2, tp_locvar->info2) + ), + + TP_code_post() +) + +/* + * Tracepoint for kvm interrupt injection: + */ +LTTNG_TRACEPOINT_EVENT_MAP(kvm_inj_virq, kvm_x86_inj_virq, + TP_PROTO(unsigned int irq), + TP_ARGS(irq), + + TP_FIELDS( + ctf_integer(unsigned int, irq, irq) + ) +) + +/* + * Tracepoint for kvm interrupt injection: + */ +LTTNG_TRACEPOINT_EVENT_MAP(kvm_inj_exception, kvm_x86_inj_exception, + TP_PROTO(unsigned exception, bool has_error, unsigned error_code), + TP_ARGS(exception, has_error, error_code), + + TP_FIELDS( + ctf_integer(u8, exception, exception) + ctf_integer(u8, has_error, has_error) + ctf_integer(u32, error_code, error_code) + ) +) + +/* + * Tracepoint for page fault. + */ +LTTNG_TRACEPOINT_EVENT_MAP(kvm_page_fault, kvm_x86_page_fault, + TP_PROTO(unsigned long fault_address, unsigned int error_code), + TP_ARGS(fault_address, error_code), + + TP_FIELDS( + ctf_integer_hex(unsigned long, fault_address, fault_address) + ctf_integer(unsigned int, error_code, error_code) + ) +) + +/* + * Tracepoint for guest MSR access. + */ +LTTNG_TRACEPOINT_EVENT_MAP(kvm_msr, kvm_x86_msr, + TP_PROTO(unsigned write, u32 ecx, u64 data, bool exception), + TP_ARGS(write, ecx, data, exception), + + TP_FIELDS( + ctf_integer(unsigned, write, write) + ctf_integer(u32, ecx, ecx) + ctf_integer(u64, data, data) + ctf_integer(u8, exception, exception) + ) +) + +#define trace_kvm_msr_read(ecx, data) trace_kvm_msr(0, ecx, data, false) +#define trace_kvm_msr_write(ecx, data) trace_kvm_msr(1, ecx, data, false) +#define trace_kvm_msr_read_ex(ecx) trace_kvm_msr(0, ecx, 0, true) +#define trace_kvm_msr_write_ex(ecx, data) trace_kvm_msr(1, ecx, data, true) + +/* + * Tracepoint for guest CR access. + */ +LTTNG_TRACEPOINT_EVENT_MAP(kvm_cr, kvm_x86_cr, + TP_PROTO(unsigned int rw, unsigned int cr, unsigned long val), + TP_ARGS(rw, cr, val), + + TP_FIELDS( + ctf_integer(unsigned int, rw, rw) + ctf_integer(unsigned int, cr, cr) + ctf_integer(unsigned long, val, val) + ) +) + +#define trace_kvm_cr_read(cr, val) trace_kvm_cr(0, cr, val) +#define trace_kvm_cr_write(cr, val) trace_kvm_cr(1, cr, val) + +LTTNG_TRACEPOINT_EVENT_MAP(kvm_pic_set_irq, kvm_x86_pic_set_irq, + TP_PROTO(__u8 chip, __u8 pin, __u8 elcr, __u8 imr, bool coalesced), + TP_ARGS(chip, pin, elcr, imr, coalesced), + + TP_FIELDS( + ctf_integer(__u8, chip, chip) + ctf_integer(__u8, pin, pin) + ctf_integer(__u8, elcr, elcr) + ctf_integer(__u8, imr, imr) + ctf_integer(bool, coalesced, coalesced) + ) +) + +LTTNG_TRACEPOINT_EVENT_MAP(kvm_apic_ipi, kvm_x86_apic_ipi, + TP_PROTO(__u32 icr_low, __u32 dest_id), + TP_ARGS(icr_low, dest_id), + + TP_FIELDS( + ctf_integer(__u32, icr_low, icr_low) + ctf_integer(__u32, dest_id, dest_id) + ) +) + +LTTNG_TRACEPOINT_EVENT_MAP(kvm_apic_accept_irq, kvm_x86_apic_accept_irq, + TP_PROTO(__u32 apicid, __u16 dm, __u8 tm, __u8 vec, bool coalesced), + TP_ARGS(apicid, dm, tm, vec, coalesced), + + TP_FIELDS( + ctf_integer(__u32, apicid, apicid) + ctf_integer(__u16, dm, dm) + ctf_integer(__u8, tm, tm) + ctf_integer(__u8, vec, vec) + ctf_integer(bool, coalesced, coalesced) + ) +) + +LTTNG_TRACEPOINT_EVENT_MAP(kvm_eoi, kvm_x86_eoi, + TP_PROTO(struct kvm_lapic *apic, int vector), + TP_ARGS(apic, vector), + + TP_FIELDS( + ctf_integer(__u32, apicid, apic->vcpu->vcpu_id) + ctf_integer(int, vector, vector) + ) +) + +LTTNG_TRACEPOINT_EVENT_MAP(kvm_pv_eoi, kvm_x86_pv_eoi, + TP_PROTO(struct kvm_lapic *apic, int vector), + TP_ARGS(apic, vector), + + TP_FIELDS( + ctf_integer(__u32, apicid, apic->vcpu->vcpu_id) + ctf_integer(int, vector, vector) + ) +) + +/* + * Tracepoint for nested VMRUN + */ +LTTNG_TRACEPOINT_EVENT_MAP(kvm_nested_vmrun, kvm_x86_nested_vmrun, + TP_PROTO(__u64 rip, __u64 vmcb, __u64 nested_rip, __u32 int_ctl, + __u32 event_inj, bool npt), + TP_ARGS(rip, vmcb, nested_rip, int_ctl, event_inj, npt), + + TP_FIELDS( + ctf_integer(__u64, rip, rip) + ctf_integer(__u64, vmcb, vmcb) + ctf_integer(__u64, nested_rip, nested_rip) + ctf_integer(__u32, int_ctl, int_ctl) + ctf_integer(__u32, event_inj, event_inj) + ctf_integer(bool, npt, npt) + ) +) + +LTTNG_TRACEPOINT_EVENT_MAP(kvm_nested_intercepts, kvm_x86_nested_intercepts, + TP_PROTO(__u16 cr_read, __u16 cr_write, __u32 exceptions, __u64 intercept), + TP_ARGS(cr_read, cr_write, exceptions, intercept), + + TP_FIELDS( + ctf_integer(__u16, cr_read, cr_read) + ctf_integer(__u16, cr_write, cr_write) + ctf_integer(__u32, exceptions, exceptions) + ctf_integer(__u64, intercept, intercept) + ) +) +/* + * Tracepoint for #VMEXIT while nested + */ +LTTNG_TRACEPOINT_EVENT_MAP(kvm_nested_vmexit, kvm_x86_nested_vmexit, + TP_PROTO(__u64 rip, __u32 exit_code, + __u64 exit_info1, __u64 exit_info2, + __u32 exit_int_info, __u32 exit_int_info_err, __u32 isa), + TP_ARGS(rip, exit_code, exit_info1, exit_info2, + exit_int_info, exit_int_info_err, isa), + + TP_FIELDS( + ctf_integer(__u64, rip, rip) + ctf_integer(__u32, exit_code, exit_code) + ctf_integer(__u64, exit_info1, exit_info1) + ctf_integer(__u64, exit_info2, exit_info2) + ctf_integer(__u32, exit_int_info, exit_int_info) + ctf_integer(__u32, exit_int_info_err, exit_int_info_err) + ctf_integer(__u32, isa, isa) + ) +) + +/* + * Tracepoint for #VMEXIT reinjected to the guest + */ +LTTNG_TRACEPOINT_EVENT_MAP(kvm_nested_vmexit_inject, kvm_x86_nested_vmexit_inject, + TP_PROTO(__u32 exit_code, + __u64 exit_info1, __u64 exit_info2, + __u32 exit_int_info, __u32 exit_int_info_err, __u32 isa), + TP_ARGS(exit_code, exit_info1, exit_info2, + exit_int_info, exit_int_info_err, isa), + + TP_FIELDS( + ctf_integer(__u32, exit_code, exit_code) + ctf_integer(__u64, exit_info1, exit_info1) + ctf_integer(__u64, exit_info2, exit_info2) + ctf_integer(__u32, exit_int_info, exit_int_info) + ctf_integer(__u32, exit_int_info_err, exit_int_info_err) + ctf_integer(__u32, isa, isa) + ) +) + +/* + * Tracepoint for nested #vmexit because of interrupt pending + */ +LTTNG_TRACEPOINT_EVENT_MAP(kvm_nested_intr_vmexit, kvm_x86_nested_intr_vmexit, + TP_PROTO(__u64 rip), + TP_ARGS(rip), + + TP_FIELDS( + ctf_integer(__u64, rip, rip) + ) +) + +/* + * Tracepoint for nested #vmexit because of interrupt pending + */ +LTTNG_TRACEPOINT_EVENT_MAP(kvm_invlpga, kvm_x86_invlpga, + TP_PROTO(__u64 rip, int asid, u64 address), + TP_ARGS(rip, asid, address), + + TP_FIELDS( + ctf_integer(__u64, rip, rip) + ctf_integer(int, asid, asid) + ctf_integer_hex(__u64, address, address) + ) +) + +/* + * Tracepoint for nested #vmexit because of interrupt pending + */ +LTTNG_TRACEPOINT_EVENT_MAP(kvm_skinit, kvm_x86_skinit, + TP_PROTO(__u64 rip, __u32 slb), + TP_ARGS(rip, slb), + + TP_FIELDS( + ctf_integer(__u64, rip, rip) + ctf_integer(__u32, slb, slb) + ) +) + +#define KVM_EMUL_INSN_F_CR0_PE (1 << 0) +#define KVM_EMUL_INSN_F_EFL_VM (1 << 1) +#define KVM_EMUL_INSN_F_CS_D (1 << 2) +#define KVM_EMUL_INSN_F_CS_L (1 << 3) + +#define kvm_trace_symbol_emul_flags \ + { 0, "real" }, \ + { KVM_EMUL_INSN_F_CR0_PE \ + | KVM_EMUL_INSN_F_EFL_VM, "vm16" }, \ + { KVM_EMUL_INSN_F_CR0_PE, "prot16" }, \ + { KVM_EMUL_INSN_F_CR0_PE \ + | KVM_EMUL_INSN_F_CS_D, "prot32" }, \ + { KVM_EMUL_INSN_F_CR0_PE \ + | KVM_EMUL_INSN_F_CS_L, "prot64" } + +#define kei_decode_mode(mode) ({ \ + u8 flags = 0xff; \ + switch (mode) { \ + case X86EMUL_MODE_REAL: \ + flags = 0; \ + break; \ + case X86EMUL_MODE_VM86: \ + flags = KVM_EMUL_INSN_F_EFL_VM; \ + break; \ + case X86EMUL_MODE_PROT16: \ + flags = KVM_EMUL_INSN_F_CR0_PE; \ + break; \ + case X86EMUL_MODE_PROT32: \ + flags = KVM_EMUL_INSN_F_CR0_PE \ + | KVM_EMUL_INSN_F_CS_D; \ + break; \ + case X86EMUL_MODE_PROT64: \ + flags = KVM_EMUL_INSN_F_CR0_PE \ + | KVM_EMUL_INSN_F_CS_L; \ + break; \ + } \ + flags; \ + }) + +LTTNG_TRACEPOINT_EVENT_MAP(kvm_emulate_insn, kvm_x86_emulate_insn, + TP_PROTO(struct kvm_vcpu *vcpu, __u8 failed), + TP_ARGS(vcpu, failed), + + TP_FIELDS( + ctf_integer(__u64, rip, vcpu->arch.emulate_ctxt->_eip - + (vcpu->arch.emulate_ctxt->fetch.ptr - + vcpu->arch.emulate_ctxt->fetch.data)) + ctf_integer(__u32, csbase, kvm_x86_ops.get_segment_base(vcpu, VCPU_SREG_CS)) + ctf_integer(__u8, len, vcpu->arch.emulate_ctxt->fetch.ptr - + vcpu->arch.emulate_ctxt->fetch.data) + ctf_array(__u8, insn, vcpu->arch.emulate_ctxt->fetch.data, 15) + ctf_integer(__u8, flags, kei_decode_mode(vcpu->arch.emulate_ctxt->mode)) + ctf_integer(__u8, failed, failed) + ) +) + +#define trace_kvm_emulate_insn_start(vcpu) trace_kvm_emulate_insn(vcpu, 0) +#define trace_kvm_emulate_insn_failed(vcpu) trace_kvm_emulate_insn(vcpu, 1) + +LTTNG_TRACEPOINT_EVENT_MAP( + vcpu_match_mmio, kvm_x86_vcpu_match_mmio, + TP_PROTO(gva_t gva, gpa_t gpa, bool write, bool gpa_match), + TP_ARGS(gva, gpa, write, gpa_match), + + TP_FIELDS( + ctf_integer(gva_t, gva, gva) + ctf_integer(gpa_t, gpa, gpa) + ctf_integer(bool, write, write) + ctf_integer(bool, gpa_match, gpa_match) + ) +) + +LTTNG_TRACEPOINT_EVENT_MAP(kvm_write_tsc_offset, kvm_x86_write_tsc_offset, + TP_PROTO(unsigned int vcpu_id, __u64 previous_tsc_offset, + __u64 next_tsc_offset), + TP_ARGS(vcpu_id, previous_tsc_offset, next_tsc_offset), + + TP_FIELDS( + ctf_integer(unsigned int, vcpu_id, vcpu_id) + ctf_integer(__u64, previous_tsc_offset, previous_tsc_offset) + ctf_integer(__u64, next_tsc_offset, next_tsc_offset) + ) +) + +#ifdef CONFIG_X86_64 + +LTTNG_TRACEPOINT_EVENT_MAP(kvm_update_master_clock, kvm_x86_update_master_clock, + TP_PROTO(bool use_master_clock, unsigned int host_clock, bool offset_matched), + TP_ARGS(use_master_clock, host_clock, offset_matched), + + TP_FIELDS( + ctf_integer(bool, use_master_clock, use_master_clock) + ctf_integer(unsigned int, host_clock, host_clock) + ctf_integer(bool, offset_matched, offset_matched) + ) +) + +LTTNG_TRACEPOINT_EVENT_MAP(kvm_track_tsc, kvm_x86_track_tsc, + TP_PROTO(unsigned int vcpu_id, unsigned int nr_matched, + unsigned int online_vcpus, bool use_master_clock, + unsigned int host_clock), + TP_ARGS(vcpu_id, nr_matched, online_vcpus, use_master_clock, + host_clock), + + TP_FIELDS( + ctf_integer(unsigned int, vcpu_id, vcpu_id) + ctf_integer(unsigned int, nr_vcpus_matched_tsc, nr_matched) + ctf_integer(unsigned int, online_vcpus, online_vcpus) + ctf_integer(bool, use_master_clock, use_master_clock) + ctf_integer(unsigned int, host_clock, host_clock) + ) +) + +#endif /* CONFIG_X86_64 */ + +#endif /* LTTNG_TRACE_KVM_H */ + +#undef TRACE_INCLUDE_PATH +#define TRACE_INCLUDE_PATH instrumentation/events/lttng-module/arch/x86/kvm +#undef TRACE_INCLUDE_FILE +#define TRACE_INCLUDE_FILE trace + +/* This part must be outside protection */ +#include diff --git a/include/instrumentation/events/lttng-module/block.h b/include/instrumentation/events/lttng-module/block.h new file mode 100644 index 00000000..b4fd4bfc --- /dev/null +++ b/include/instrumentation/events/lttng-module/block.h @@ -0,0 +1,538 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#undef TRACE_SYSTEM +#define TRACE_SYSTEM block + +#if !defined(LTTNG_TRACE_BLOCK_H) || defined(TRACE_HEADER_MULTI_READ) +#define LTTNG_TRACE_BLOCK_H + +#include +#include +#include +#include + +#include + +#ifndef _TRACE_BLOCK_DEF_ +#define _TRACE_BLOCK_DEF_ + +enum { + RWBS_FLAG_WRITE = (1 << 0), + RWBS_FLAG_DISCARD = (1 << 1), + RWBS_FLAG_READ = (1 << 2), + RWBS_FLAG_RAHEAD = (1 << 3), + RWBS_FLAG_BARRIER = (1 << 4), + RWBS_FLAG_SYNC = (1 << 5), + RWBS_FLAG_META = (1 << 6), + RWBS_FLAG_SECURE = (1 << 7), + RWBS_FLAG_FLUSH = (1 << 8), + RWBS_FLAG_FUA = (1 << 9), + RWBS_FLAG_PREFLUSH = (1 << 10), +}; + +#endif /* _TRACE_BLOCK_DEF_ */ + +LTTNG_TRACEPOINT_ENUM(block_rq_type, + TP_ENUM_VALUES( + ctf_enum_value("RWBS_FLAG_WRITE", RWBS_FLAG_WRITE) + ctf_enum_value("RWBS_FLAG_DISCARD", RWBS_FLAG_DISCARD) + ctf_enum_value("RWBS_FLAG_READ", RWBS_FLAG_READ) + ctf_enum_value("RWBS_FLAG_RAHEAD", RWBS_FLAG_RAHEAD) + ctf_enum_value("RWBS_FLAG_BARRIER", RWBS_FLAG_BARRIER) + ctf_enum_value("RWBS_FLAG_SYNC", RWBS_FLAG_SYNC) + ctf_enum_value("RWBS_FLAG_META", RWBS_FLAG_META) + ctf_enum_value("RWBS_FLAG_SECURE", RWBS_FLAG_SECURE) + ctf_enum_value("RWBS_FLAG_FLUSH", RWBS_FLAG_FLUSH) + ctf_enum_value("RWBS_FLAG_FUA", RWBS_FLAG_FUA) + ctf_enum_value("RWBS_FLAG_PREFLUSH", RWBS_FLAG_PREFLUSH) + ) +) + +#define lttng_req_op(rq) req_op(rq) +#define lttng_req_rw(rq) ((rq)->cmd_flags) +#define lttng_bio_op(bio) bio_op(bio) +#define lttng_bio_rw(bio) ((bio)->bi_opf) + +#define blk_rwbs_ctf_integer(type, rwbs, op, rw, bytes) \ + ctf_enum(block_rq_type, type, rwbs, \ + (((op) == REQ_OP_WRITE || (op) == REQ_OP_WRITE_SAME) ? RWBS_FLAG_WRITE : \ + ( (op) == REQ_OP_DISCARD ? RWBS_FLAG_DISCARD : \ + ( (op) == REQ_OP_SECURE_ERASE ? (RWBS_FLAG_DISCARD | RWBS_FLAG_SECURE) : \ + ( (op) == REQ_OP_FLUSH ? RWBS_FLAG_FLUSH : \ + ( (op) == REQ_OP_READ ? RWBS_FLAG_READ : \ + ( 0 )))))) \ + | ((rw) & REQ_RAHEAD ? RWBS_FLAG_RAHEAD : 0) \ + | ((rw) & REQ_SYNC ? RWBS_FLAG_SYNC : 0) \ + | ((rw) & REQ_META ? RWBS_FLAG_META : 0) \ + | ((rw) & REQ_PREFLUSH ? RWBS_FLAG_PREFLUSH : 0) \ + | ((rw) & REQ_FUA ? RWBS_FLAG_FUA : 0)) + +LTTNG_TRACEPOINT_EVENT_CLASS(block_buffer, + + TP_PROTO(struct buffer_head *bh), + + TP_ARGS(bh), + + TP_FIELDS ( + ctf_integer(dev_t, dev, bh->b_bdev->bd_dev) + ctf_integer(sector_t, sector, bh->b_blocknr) + ctf_integer(size_t, size, bh->b_size) + ) +) + +/** + * block_touch_buffer - mark a buffer accessed + * @bh: buffer_head being touched + * + * Called from touch_buffer(). + */ +LTTNG_TRACEPOINT_EVENT_INSTANCE(block_buffer, block_touch_buffer, + + TP_PROTO(struct buffer_head *bh), + + TP_ARGS(bh) +) + +/** + * block_dirty_buffer - mark a buffer dirty + * @bh: buffer_head being dirtied + * + * Called from mark_buffer_dirty(). + */ +LTTNG_TRACEPOINT_EVENT_INSTANCE(block_buffer, block_dirty_buffer, + + TP_PROTO(struct buffer_head *bh), + + TP_ARGS(bh) +) + +/** + * block_rq_requeue - place block IO request back on a queue + * @q: queue holding operation + * @rq: block IO operation request + * + * The block operation request @rq is being placed back into queue + * @q. For some reason the request was not completed and needs to be + * put back in the queue. + */ +LTTNG_TRACEPOINT_EVENT(block_rq_requeue, + + TP_PROTO(struct request_queue *q, struct request *rq), + + TP_ARGS(q, rq), + + TP_FIELDS( + ctf_integer(dev_t, dev, + rq->rq_disk ? disk_devt(rq->rq_disk) : 0) + ctf_integer(sector_t, sector, blk_rq_trace_sector(rq)) + ctf_integer(unsigned int, nr_sector, blk_rq_trace_nr_sectors(rq)) + blk_rwbs_ctf_integer(unsigned int, rwbs, + lttng_req_op(rq), lttng_req_rw(rq), blk_rq_bytes(rq)) + ) +) + +/** + * block_rq_complete - block IO operation completed by device driver + * @q: queue containing the block operation request + * @rq: block operations request + * @nr_bytes: number of completed bytes + * + * The block_rq_complete tracepoint event indicates that some portion + * of operation request has been completed by the device driver. If + * the @rq->bio is %NULL, then there is absolutely no additional work to + * do for the request. If @rq->bio is non-NULL then there is + * additional work required to complete the request. + */ +LTTNG_TRACEPOINT_EVENT(block_rq_complete, + + TP_PROTO(struct request *rq, int error, unsigned int nr_bytes), + + TP_ARGS(rq, error, nr_bytes), + + TP_FIELDS( + ctf_integer(dev_t, dev, + rq->rq_disk ? disk_devt(rq->rq_disk) : 0) + ctf_integer(sector_t, sector, blk_rq_pos(rq)) + ctf_integer(unsigned int, nr_sector, nr_bytes >> 9) + ctf_integer(int, error, error) + blk_rwbs_ctf_integer(unsigned int, rwbs, + lttng_req_op(rq), lttng_req_rw(rq), nr_bytes) + ) +) + +LTTNG_TRACEPOINT_EVENT_CLASS(block_rq, + + TP_PROTO(struct request_queue *q, struct request *rq), + + TP_ARGS(q, rq), + + TP_FIELDS( + ctf_integer(dev_t, dev, + rq->rq_disk ? disk_devt(rq->rq_disk) : 0) + ctf_integer(sector_t, sector, blk_rq_trace_sector(rq)) + ctf_integer(unsigned int, nr_sector, blk_rq_trace_nr_sectors(rq)) + ctf_integer(unsigned int, bytes, blk_rq_bytes(rq)) + ctf_integer(pid_t, tid, current->pid) + blk_rwbs_ctf_integer(unsigned int, rwbs, + lttng_req_op(rq), lttng_req_rw(rq), blk_rq_bytes(rq)) + ctf_array_text(char, comm, current->comm, TASK_COMM_LEN) + ) +) + +/** + * block_rq_insert - insert block operation request into queue + * @q: target queue + * @rq: block IO operation request + * + * Called immediately before block operation request @rq is inserted + * into queue @q. The fields in the operation request @rq struct can + * be examined to determine which device and sectors the pending + * operation would access. + */ +LTTNG_TRACEPOINT_EVENT_INSTANCE(block_rq, block_rq_insert, + + TP_PROTO(struct request_queue *q, struct request *rq), + + TP_ARGS(q, rq) +) + +/** + * block_rq_issue - issue pending block IO request operation to device driver + * @q: queue holding operation + * @rq: block IO operation operation request + * + * Called when block operation request @rq from queue @q is sent to a + * device driver for processing. + */ +LTTNG_TRACEPOINT_EVENT_INSTANCE(block_rq, block_rq_issue, + + TP_PROTO(struct request_queue *q, struct request *rq), + + TP_ARGS(q, rq) +) + +/** + * block_bio_bounce - used bounce buffer when processing block operation + * @q: queue holding the block operation + * @bio: block operation + * + * A bounce buffer was used to handle the block operation @bio in @q. + * This occurs when hardware limitations prevent a direct transfer of + * data between the @bio data memory area and the IO device. Use of a + * bounce buffer requires extra copying of data and decreases + * performance. + */ +LTTNG_TRACEPOINT_EVENT(block_bio_bounce, + + TP_PROTO(struct request_queue *q, struct bio *bio), + + TP_ARGS(q, bio), + + TP_FIELDS( + ctf_integer(dev_t, dev, bio_dev(bio)) + ctf_integer(sector_t, sector, bio->bi_iter.bi_sector) + ctf_integer(unsigned int, nr_sector, bio_sectors(bio)) + blk_rwbs_ctf_integer(unsigned int, rwbs, + lttng_bio_op(bio), lttng_bio_rw(bio), + bio->bi_iter.bi_size) + ctf_integer(pid_t, tid, current->pid) + ctf_array_text(char, comm, current->comm, TASK_COMM_LEN) + ) +) + +/** + * block_bio_complete - completed all work on the block operation + * @q: queue holding the block operation + * @bio: block operation completed + * @error: io error value + * + * This tracepoint indicates there is no further work to do on this + * block IO operation @bio. + */ +LTTNG_TRACEPOINT_EVENT(block_bio_complete, + + TP_PROTO(struct request_queue *q, struct bio *bio, int error), + + TP_ARGS(q, bio, error), + + TP_FIELDS( + ctf_integer(dev_t, dev, bio_dev(bio)) + ctf_integer(sector_t, sector, bio->bi_iter.bi_sector) + ctf_integer(unsigned int, nr_sector, bio_sectors(bio)) + ctf_integer(int, error, error) + blk_rwbs_ctf_integer(unsigned int, rwbs, + lttng_bio_op(bio), lttng_bio_rw(bio), + bio->bi_iter.bi_size) + ) +) + +LTTNG_TRACEPOINT_EVENT_CLASS(block_bio_merge, + + TP_PROTO(struct request_queue *q, struct request *rq, struct bio *bio), + + TP_ARGS(q, rq, bio), + + TP_FIELDS( + ctf_integer(dev_t, dev, bio_dev(bio)) + ctf_integer(sector_t, sector, bio->bi_iter.bi_sector) + ctf_integer(unsigned int, nr_sector, bio_sectors(bio)) + blk_rwbs_ctf_integer(unsigned int, rwbs, + lttng_bio_op(bio), lttng_bio_rw(bio), + bio->bi_iter.bi_size) + ctf_integer(pid_t, tid, current->pid) + ctf_array_text(char, comm, current->comm, TASK_COMM_LEN) + ) +) + +/** + * block_bio_backmerge - merging block operation to the end of an existing operation + * @q: queue holding operation + * @bio: new block operation to merge + * + * Merging block request @bio to the end of an existing block request + * in queue @q. + */ +LTTNG_TRACEPOINT_EVENT_INSTANCE(block_bio_merge, block_bio_backmerge, + + TP_PROTO(struct request_queue *q, struct request *rq, struct bio *bio), + + TP_ARGS(q, rq, bio) +) + +/** + * block_bio_frontmerge - merging block operation to the beginning of an existing operation + * @q: queue holding operation + * @bio: new block operation to merge + * + * Merging block IO operation @bio to the beginning of an existing block + * operation in queue @q. + */ +LTTNG_TRACEPOINT_EVENT_INSTANCE(block_bio_merge, block_bio_frontmerge, + + TP_PROTO(struct request_queue *q, struct request *rq, struct bio *bio), + + TP_ARGS(q, rq, bio) +) + +/** + * block_bio_queue - putting new block IO operation in queue + * @q: queue holding operation + * @bio: new block operation + * + * About to place the block IO operation @bio into queue @q. + */ +LTTNG_TRACEPOINT_EVENT(block_bio_queue, + + TP_PROTO(struct request_queue *q, struct bio *bio), + + TP_ARGS(q, bio), + + TP_FIELDS( + ctf_integer(dev_t, dev, bio_dev(bio)) + ctf_integer(sector_t, sector, bio->bi_iter.bi_sector) + ctf_integer(unsigned int, nr_sector, bio_sectors(bio)) + blk_rwbs_ctf_integer(unsigned int, rwbs, + lttng_bio_op(bio), lttng_bio_rw(bio), + bio->bi_iter.bi_size) + ctf_integer(pid_t, tid, current->pid) + ctf_array_text(char, comm, current->comm, TASK_COMM_LEN) + ) +) + +LTTNG_TRACEPOINT_EVENT_CLASS(block_get_rq, + + TP_PROTO(struct request_queue *q, struct bio *bio, int rw), + + TP_ARGS(q, bio, rw), + + TP_FIELDS( + ctf_integer(dev_t, dev, bio ? bio_dev(bio) : 0) + ctf_integer(sector_t, sector, bio ? bio->bi_iter.bi_sector : 0) + ctf_integer(unsigned int, nr_sector, + bio ? bio_sectors(bio) : 0) + blk_rwbs_ctf_integer(unsigned int, rwbs, + bio ? lttng_bio_op(bio) : 0, + bio ? lttng_bio_rw(bio) : 0, + bio ? bio->bi_iter.bi_size : 0) + ctf_integer(pid_t, tid, current->pid) + ctf_array_text(char, comm, current->comm, TASK_COMM_LEN) + ) +) + +/** + * block_getrq - get a free request entry in queue for block IO operations + * @q: queue for operations + * @bio: pending block IO operation (can be %NULL) + * @rw: low bit indicates a read (%0) or a write (%1) + * + * A request struct for queue @q has been allocated to handle the + * block IO operation @bio. + */ +LTTNG_TRACEPOINT_EVENT_INSTANCE(block_get_rq, block_getrq, + + TP_PROTO(struct request_queue *q, struct bio *bio, int rw), + + TP_ARGS(q, bio, rw) +) + +/** + * block_sleeprq - waiting to get a free request entry in queue for block IO operation + * @q: queue for operation + * @bio: pending block IO operation (can be %NULL) + * @rw: low bit indicates a read (%0) or a write (%1) + * + * In the case where a request struct cannot be provided for queue @q + * the process needs to wait for an request struct to become + * available. This tracepoint event is generated each time the + * process goes to sleep waiting for request struct become available. + */ +LTTNG_TRACEPOINT_EVENT_INSTANCE(block_get_rq, block_sleeprq, + + TP_PROTO(struct request_queue *q, struct bio *bio, int rw), + + TP_ARGS(q, bio, rw) +) + +/** + * block_plug - keep operations requests in request queue + * @q: request queue to plug + * + * Plug the request queue @q. Do not allow block operation requests + * to be sent to the device driver. Instead, accumulate requests in + * the queue to improve throughput performance of the block device. + */ +LTTNG_TRACEPOINT_EVENT(block_plug, + + TP_PROTO(struct request_queue *q), + + TP_ARGS(q), + + TP_FIELDS( + ctf_integer(pid_t, tid, current->pid) + ctf_array_text(char, comm, current->comm, TASK_COMM_LEN) + ) +) + +LTTNG_TRACEPOINT_EVENT_CLASS(block_unplug, + + TP_PROTO(struct request_queue *q, unsigned int depth, bool explicit), + + TP_ARGS(q, depth, explicit), + + TP_FIELDS( + ctf_integer(int, nr_rq, depth) + ctf_integer(pid_t, tid, current->pid) + ctf_array_text(char, comm, current->comm, TASK_COMM_LEN) + ) +) + +/** + * block_unplug - release of operations requests in request queue + * @q: request queue to unplug + * @depth: number of requests just added to the queue + * @explicit: whether this was an explicit unplug, or one from schedule() + * + * Unplug request queue @q because device driver is scheduled to work + * on elements in the request queue. + */ +LTTNG_TRACEPOINT_EVENT_INSTANCE(block_unplug, block_unplug, + + TP_PROTO(struct request_queue *q, unsigned int depth, bool explicit), + + TP_ARGS(q, depth, explicit) +) + +/** + * block_split - split a single bio struct into two bio structs + * @q: queue containing the bio + * @bio: block operation being split + * @new_sector: The starting sector for the new bio + * + * The bio request @bio in request queue @q needs to be split into two + * bio requests. The newly created @bio request starts at + * @new_sector. This split may be required due to hardware limitation + * such as operation crossing device boundaries in a RAID system. + */ +LTTNG_TRACEPOINT_EVENT(block_split, + + TP_PROTO(struct request_queue *q, struct bio *bio, + unsigned int new_sector), + + TP_ARGS(q, bio, new_sector), + + TP_FIELDS( + ctf_integer(dev_t, dev, bio_dev(bio)) + ctf_integer(sector_t, sector, bio->bi_iter.bi_sector) + blk_rwbs_ctf_integer(unsigned int, rwbs, + lttng_bio_op(bio), lttng_bio_rw(bio), + bio->bi_iter.bi_size) + ctf_integer(sector_t, new_sector, new_sector) + ctf_integer(pid_t, tid, current->pid) + ctf_array_text(char, comm, current->comm, TASK_COMM_LEN) + ) +) + +/** + * block_bio_remap - map request for a logical device to the raw device + * @q: queue holding the operation + * @bio: revised operation + * @dev: device for the operation + * @from: original sector for the operation + * + * An operation for a logical device has been mapped to the + * raw block device. + */ +LTTNG_TRACEPOINT_EVENT(block_bio_remap, + + TP_PROTO(struct request_queue *q, struct bio *bio, dev_t dev, + sector_t from), + + TP_ARGS(q, bio, dev, from), + + TP_FIELDS( + ctf_integer(dev_t, dev, bio_dev(bio)) + ctf_integer(sector_t, sector, bio->bi_iter.bi_sector) + ctf_integer(unsigned int, nr_sector, bio_sectors(bio)) + blk_rwbs_ctf_integer(unsigned int, rwbs, + lttng_bio_op(bio), lttng_bio_rw(bio), + bio->bi_iter.bi_size) + ctf_integer(dev_t, old_dev, dev) + ctf_integer(sector_t, old_sector, from) + ) +) + +/** + * block_rq_remap - map request for a block operation request + * @q: queue holding the operation + * @rq: block IO operation request + * @dev: device for the operation + * @from: original sector for the operation + * + * The block operation request @rq in @q has been remapped. The block + * operation request @rq holds the current information and @from hold + * the original sector. + */ +LTTNG_TRACEPOINT_EVENT(block_rq_remap, + + TP_PROTO(struct request_queue *q, struct request *rq, dev_t dev, + sector_t from), + + TP_ARGS(q, rq, dev, from), + + TP_FIELDS( + ctf_integer(dev_t, dev, disk_devt(rq->rq_disk)) + ctf_integer(sector_t, sector, blk_rq_pos(rq)) + ctf_integer(unsigned int, nr_sector, blk_rq_sectors(rq)) + ctf_integer(dev_t, old_dev, dev) + ctf_integer(sector_t, old_sector, from) + blk_rwbs_ctf_integer(unsigned int, rwbs, + lttng_req_op(rq), lttng_req_rw(rq), blk_rq_bytes(rq)) + ) +) + +#undef __print_rwbs_flags +#undef blk_fill_rwbs + +#endif /* LTTNG_TRACE_BLOCK_H */ + +/* This part must be outside protection */ +#include diff --git a/include/instrumentation/events/lttng-module/btrfs.h b/include/instrumentation/events/lttng-module/btrfs.h new file mode 100644 index 00000000..e7df77cc --- /dev/null +++ b/include/instrumentation/events/lttng-module/btrfs.h @@ -0,0 +1,636 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#undef TRACE_SYSTEM +#define TRACE_SYSTEM btrfs + +#if !defined(LTTNG_TRACE_BTRFS_H) || defined(TRACE_HEADER_MULTI_READ) +#define LTTNG_TRACE_BTRFS_H + +#include +#include + +#ifndef _TRACE_BTRFS_DEF_ +#define _TRACE_BTRFS_DEF_ +struct btrfs_root; +struct btrfs_fs_info; +struct btrfs_inode; +struct extent_map; +struct btrfs_ordered_extent; +struct btrfs_delayed_ref_node; +struct btrfs_delayed_tree_ref; +struct btrfs_delayed_data_ref; +struct btrfs_delayed_ref_head; +struct btrfs_block_group; +struct btrfs_free_cluster; +struct map_lookup; +struct extent_buffer; +struct extent_state; +#endif + +#define BTRFS_UUID_SIZE 16 + +#define lttng_fs_info_fsid fs_info->fs_devices->fsid + +LTTNG_TRACEPOINT_EVENT(btrfs_transaction_commit, + + TP_PROTO(const struct btrfs_root *root), + + TP_ARGS(root), + + TP_FIELDS( + ctf_integer(u64, generation, root->fs_info->generation) + ctf_integer(u64, root_objectid, root->root_key.objectid) + ) +) + +LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__inode, + + TP_PROTO(const struct inode *inode), + + TP_ARGS(inode), + + TP_FIELDS( + ctf_integer(ino_t, ino, inode->i_ino) + ctf_integer(blkcnt_t, blocks, inode->i_blocks) + ctf_integer(u64, disk_i_size, BTRFS_I(inode)->disk_i_size) + ctf_integer(u64, generation, BTRFS_I(inode)->generation) + ctf_integer(u64, last_trans, BTRFS_I(inode)->last_trans) + ctf_integer(u64, logged_trans, BTRFS_I(inode)->logged_trans) + ctf_integer(u64, root_objectid, + BTRFS_I(inode)->root->root_key.objectid) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__inode, btrfs_inode_new, + + TP_PROTO(const struct inode *inode), + + TP_ARGS(inode) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__inode, btrfs_inode_request, + + TP_PROTO(const struct inode *inode), + + TP_ARGS(inode) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__inode, btrfs_inode_evict, + + TP_PROTO(const struct inode *inode), + + TP_ARGS(inode) +) + +LTTNG_TRACEPOINT_EVENT(btrfs_get_extent, + + TP_PROTO(const struct btrfs_root *root, const struct btrfs_inode *inode, + const struct extent_map *map), + + TP_ARGS(root, inode, map), + + TP_FIELDS( + ctf_integer(u64, root_objectid, root->root_key.objectid) + ctf_integer(u64, ino, btrfs_ino(inode)) + ctf_integer(u64, start, map->start) + ctf_integer(u64, len, map->len) + ctf_integer(u64, orig_start, map->orig_start) + ctf_integer(u64, block_start, map->block_start) + ctf_integer(u64, block_len, map->block_len) + ctf_integer(unsigned long, flags, map->flags) + ctf_integer(int, refs, refcount_read(&map->refs)) + ctf_integer(unsigned int, compress_type, map->compress_type) + ) +) + +LTTNG_TRACEPOINT_EVENT(btrfs_handle_em_exist, + + TP_PROTO(const struct btrfs_fs_info *fs_info, + const struct extent_map *existing, const struct extent_map *map, + u64 start, u64 len), + + TP_ARGS(fs_info, existing, map, start, len), + + TP_FIELDS( + ctf_array(u8, fsid, lttng_fs_info_fsid, BTRFS_UUID_SIZE) + ctf_integer(u64, e_start, existing->start) + ctf_integer(u64, e_len, existing->len) + ctf_integer(u64, map_start, map->start) + ctf_integer(u64, map_len, map->len) + ctf_integer(u64, start, start) + ctf_integer(u64, len, len) + ) +) + +LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__ordered_extent, + + TP_PROTO(const struct inode *inode, + const struct btrfs_ordered_extent *ordered), + + TP_ARGS(inode, ordered), + + TP_FIELDS( + ctf_integer(ino_t, ino, inode->i_ino) + ctf_integer(u64, file_offset, ordered->file_offset) + ctf_integer(u64, start, ordered->disk_bytenr) + ctf_integer(u64, len, ordered->num_bytes) + ctf_integer(u64, disk_len, ordered->disk_num_bytes) + ctf_integer(u64, bytes_left, ordered->bytes_left) + ctf_integer(unsigned long, flags, ordered->flags) + ctf_integer(int, compress_type, ordered->compress_type) + ctf_integer(int, refs, refcount_read(&ordered->refs)) + ctf_integer(u64, root_objectid, + BTRFS_I(inode)->root->root_key.objectid) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__ordered_extent, btrfs_ordered_extent_add, + + TP_PROTO(const struct inode *inode, + const struct btrfs_ordered_extent *ordered), + + TP_ARGS(inode, ordered) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__ordered_extent, btrfs_ordered_extent_remove, + + TP_PROTO(const struct inode *inode, + const struct btrfs_ordered_extent *ordered), + + TP_ARGS(inode, ordered) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__ordered_extent, btrfs_ordered_extent_start, + + TP_PROTO(const struct inode *inode, + const struct btrfs_ordered_extent *ordered), + + TP_ARGS(inode, ordered) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__ordered_extent, btrfs_ordered_extent_put, + + TP_PROTO(const struct inode *inode, + const struct btrfs_ordered_extent *ordered), + + TP_ARGS(inode, ordered) +) + +LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__writepage, + + TP_PROTO(const struct page *page, const struct inode *inode, + const struct writeback_control *wbc), + + TP_ARGS(page, inode, wbc), + + TP_FIELDS( + ctf_integer(ino_t, ino, inode->i_ino) + ctf_integer(pgoff_t, index, page->index) + ctf_integer(long, nr_to_write, wbc->nr_to_write) + ctf_integer(long, pages_skipped, wbc->pages_skipped) + ctf_integer(loff_t, range_start, wbc->range_start) + ctf_integer(loff_t, range_end, wbc->range_end) + ctf_integer(char, for_kupdate, wbc->for_kupdate) + ctf_integer(char, for_reclaim, wbc->for_reclaim) + ctf_integer(char, range_cyclic, wbc->range_cyclic) + ctf_integer(pgoff_t, writeback_index, + inode->i_mapping->writeback_index) + ctf_integer(u64, root_objectid, + BTRFS_I(inode)->root->root_key.objectid) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(btrfs__writepage, + + __extent_writepage, + + btrfs__extent_writepage, + + TP_PROTO(const struct page *page, const struct inode *inode, + const struct writeback_control *wbc), + + TP_ARGS(page, inode, wbc) +) + +LTTNG_TRACEPOINT_EVENT(btrfs_writepage_end_io_hook, + + TP_PROTO(const struct page *page, u64 start, u64 end, int uptodate), + + TP_ARGS(page, start, end, uptodate), + + TP_FIELDS( + ctf_integer(ino_t, ino, page->mapping->host->i_ino) + ctf_integer(pgoff_t, index, page->index) + ctf_integer(u64, start, start) + ctf_integer(u64, end, end) + ctf_integer(int, uptodate, uptodate) + ctf_integer(u64, root_objectid, + BTRFS_I(page->mapping->host)->root->root_key.objectid) + ) +) + +LTTNG_TRACEPOINT_EVENT(btrfs_sync_file, + + TP_PROTO(const struct file *file, int datasync), + + TP_ARGS(file, datasync), + + TP_FIELDS( + ctf_integer(ino_t, ino, file->f_path.dentry->d_inode->i_ino) + ctf_integer(ino_t, parent, file->f_path.dentry->d_parent->d_inode->i_ino) + ctf_integer(int, datasync, datasync) + ctf_integer(u64, root_objectid, + BTRFS_I(file->f_path.dentry->d_inode)->root->root_key.objectid) + ) +) + +LTTNG_TRACEPOINT_EVENT(btrfs_sync_fs, + + TP_PROTO(const struct btrfs_fs_info *fs_info, int wait), + + TP_ARGS(fs_info, wait), + + TP_FIELDS( + ctf_integer(int, wait, wait) + ) +) + +LTTNG_TRACEPOINT_EVENT(btrfs_add_block_group, + + TP_PROTO(const struct btrfs_fs_info *fs_info, + const struct btrfs_block_group *block_group, int create), + + TP_ARGS(fs_info, block_group, create), + + TP_FIELDS( + ctf_array(u8, fsid, lttng_fs_info_fsid, BTRFS_UUID_SIZE) + ctf_integer(u64, offset, block_group->start) + ctf_integer(u64, size, block_group->length) + ctf_integer(u64, flags, block_group->flags) + ctf_integer(u64, bytes_used, block_group->used) + ctf_integer(u64, bytes_super, block_group->bytes_super) + ctf_integer(int, create, create) + ) +) + +LTTNG_TRACEPOINT_EVENT_CLASS(btrfs_delayed_tree_ref, + + TP_PROTO(const struct btrfs_fs_info *fs_info, + const struct btrfs_delayed_ref_node *ref, + const struct btrfs_delayed_tree_ref *full_ref, + int action), + + TP_ARGS(fs_info, ref, full_ref, action), + + TP_FIELDS( + ctf_array(u8, fsid, lttng_fs_info_fsid, BTRFS_UUID_SIZE) + ctf_integer(u64, bytenr, ref->bytenr) + ctf_integer(u64, num_bytes, ref->num_bytes) + ctf_integer(int, action, action) + ctf_integer(u64, parent, full_ref->parent) + ctf_integer(u64, ref_root, full_ref->root) + ctf_integer(int, level, full_ref->level) + ctf_integer(int, type, ref->type) + ctf_integer(u64, seq, ref->seq) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(btrfs_delayed_tree_ref, + + add_delayed_tree_ref, + + btrfs_add_delayed_tree_ref, + + TP_PROTO(const struct btrfs_fs_info *fs_info, + const struct btrfs_delayed_ref_node *ref, + const struct btrfs_delayed_tree_ref *full_ref, + int action), + + TP_ARGS(fs_info, ref, full_ref, action) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(btrfs_delayed_tree_ref, + + run_delayed_tree_ref, + + btrfs_run_delayed_tree_ref, + + TP_PROTO(const struct btrfs_fs_info *fs_info, + const struct btrfs_delayed_ref_node *ref, + const struct btrfs_delayed_tree_ref *full_ref, + int action), + + TP_ARGS(fs_info, ref, full_ref, action) +) + +LTTNG_TRACEPOINT_EVENT_CLASS(btrfs_delayed_data_ref, + + TP_PROTO(const struct btrfs_fs_info *fs_info, + const struct btrfs_delayed_ref_node *ref, + const struct btrfs_delayed_data_ref *full_ref, + int action), + + TP_ARGS(fs_info, ref, full_ref, action), + + TP_FIELDS( + ctf_array(u8, fsid, lttng_fs_info_fsid, BTRFS_UUID_SIZE) + ctf_integer(u64, bytenr, ref->bytenr) + ctf_integer(u64, num_bytes, ref->num_bytes) + ctf_integer(int, action, action) + ctf_integer(u64, parent, full_ref->parent) + ctf_integer(u64, ref_root, full_ref->root) + ctf_integer(u64, owner, full_ref->objectid) + ctf_integer(u64, offset, full_ref->offset) + ctf_integer(int, type, ref->type) + ctf_integer(u64, seq, ref->seq) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(btrfs_delayed_data_ref, + + add_delayed_data_ref, + + btrfs_add_delayed_data_ref, + + TP_PROTO(const struct btrfs_fs_info *fs_info, + const struct btrfs_delayed_ref_node *ref, + const struct btrfs_delayed_data_ref *full_ref, + int action), + + TP_ARGS(fs_info, ref, full_ref, action) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(btrfs_delayed_data_ref, + + run_delayed_data_ref, + + btrfs_run_delayed_data_ref, + + TP_PROTO(const struct btrfs_fs_info *fs_info, + const struct btrfs_delayed_ref_node *ref, + const struct btrfs_delayed_data_ref *full_ref, + int action), + + TP_ARGS(fs_info, ref, full_ref, action) +) + +LTTNG_TRACEPOINT_EVENT_CLASS(btrfs_delayed_ref_head, + + TP_PROTO(const struct btrfs_fs_info *fs_info, + const struct btrfs_delayed_ref_head *head_ref, + int action), + + TP_ARGS(fs_info, head_ref, action), + + TP_FIELDS( + ctf_integer(u64, bytenr, head_ref->bytenr) + ctf_integer(u64, num_bytes, head_ref->num_bytes) + ctf_integer(int, action, action) + ctf_integer(int, is_data, head_ref->is_data) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(btrfs_delayed_ref_head, + + add_delayed_ref_head, + + btrfs_add_delayed_ref_head, + + TP_PROTO(const struct btrfs_fs_info *fs_info, + const struct btrfs_delayed_ref_head *head_ref, + int action), + + TP_ARGS(fs_info, head_ref, action) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(btrfs_delayed_ref_head, + + run_delayed_ref_head, + + btrfs_run_delayed_ref_head, + + TP_PROTO(const struct btrfs_fs_info *fs_info, + const struct btrfs_delayed_ref_head *head_ref, + int action), + + TP_ARGS(fs_info, head_ref, action) +) + +LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__chunk, + + TP_PROTO(const struct btrfs_fs_info *fs_info, const struct map_lookup *map, + u64 offset, u64 size), + + TP_ARGS(fs_info, map, offset, size), + + TP_FIELDS( + ctf_integer(int, num_stripes, map->num_stripes) + ctf_integer(u64, type, map->type) + ctf_integer(int, sub_stripes, map->sub_stripes) + ctf_integer(u64, offset, offset) + ctf_integer(u64, size, size) + ctf_integer(u64, root_objectid, fs_info->chunk_root->root_key.objectid) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__chunk, btrfs_chunk_alloc, + + TP_PROTO(const struct btrfs_fs_info *fs_info, const struct map_lookup *map, + u64 offset, u64 size), + + TP_ARGS(fs_info, map, offset, size) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__chunk, btrfs_chunk_free, + + TP_PROTO(const struct btrfs_fs_info *fs_info, const struct map_lookup *map, + u64 offset, u64 size), + + TP_ARGS(fs_info, map, offset, size) +) + +LTTNG_TRACEPOINT_EVENT(btrfs_cow_block, + + TP_PROTO(const struct btrfs_root *root, const struct extent_buffer *buf, + const struct extent_buffer *cow), + + TP_ARGS(root, buf, cow), + + TP_FIELDS( + ctf_integer(u64, root_objectid, root->root_key.objectid) + ctf_integer(u64, buf_start, buf->start) + ctf_integer(int, refs, atomic_read(&buf->refs)) + ctf_integer(u64, cow_start, cow->start) + ctf_integer(int, buf_level, btrfs_header_level(buf)) + ctf_integer(int, cow_level, btrfs_header_level(cow)) + ) +) + +LTTNG_TRACEPOINT_EVENT(btrfs_space_reservation, + + TP_PROTO(const struct btrfs_fs_info *fs_info, const char *type, u64 val, + u64 bytes, int reserve), + + TP_ARGS(fs_info, type, val, bytes, reserve), + + TP_FIELDS( + ctf_array(u8, fsid, lttng_fs_info_fsid, BTRFS_UUID_SIZE) + ctf_string(type, type) + ctf_integer(u64, val, val) + ctf_integer(u64, bytes, bytes) + ctf_integer(int, reserve, reserve) + ) +) + +LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__reserved_extent, + + TP_PROTO(const struct btrfs_fs_info *fs_info, u64 start, u64 len), + + TP_ARGS(fs_info, start, len), + + TP_FIELDS( + ctf_integer(u64, start, start) + ctf_integer(u64, len, len) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserved_extent, btrfs_reserved_extent_alloc, + + TP_PROTO(const struct btrfs_fs_info *fs_info, u64 start, u64 len), + + TP_ARGS(fs_info, start, len) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserved_extent, btrfs_reserved_extent_free, + + TP_PROTO(const struct btrfs_fs_info *fs_info, u64 start, u64 len), + + TP_ARGS(fs_info, start, len) +) + +LTTNG_TRACEPOINT_EVENT_MAP(find_free_extent, + + btrfs_find_free_extent, + + TP_PROTO(const struct btrfs_fs_info *fs_info, u64 num_bytes, u64 empty_size, + u64 data), + + TP_ARGS(fs_info, num_bytes, empty_size, data), + + TP_FIELDS( + ctf_array(u8, fsid, lttng_fs_info_fsid, BTRFS_UUID_SIZE) + ctf_integer(u64, num_bytes, num_bytes) + ctf_integer(u64, empty_size, empty_size) + ctf_integer(u64, data, data) + ) +) + +LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__reserve_extent, + + TP_PROTO(const struct btrfs_block_group *block_group, u64 start, + u64 len), + + TP_ARGS(block_group, start, len), + + TP_FIELDS( + ctf_array(u8, fsid, block_group->lttng_fs_info_fsid, BTRFS_UUID_SIZE) + ctf_integer(u64, bg_objectid, block_group->start) + ctf_integer(u64, flags, block_group->flags) + ctf_integer(u64, start, start) + ctf_integer(u64, len, len) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserve_extent, btrfs_reserve_extent, + + TP_PROTO(const struct btrfs_block_group *block_group, u64 start, + u64 len), + + TP_ARGS(block_group, start, len) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserve_extent, btrfs_reserve_extent_cluster, + + TP_PROTO(const struct btrfs_block_group *block_group, u64 start, + u64 len), + + TP_ARGS(block_group, start, len) +) + +LTTNG_TRACEPOINT_EVENT(btrfs_find_cluster, + + TP_PROTO(const struct btrfs_block_group *block_group, u64 start, + u64 bytes, u64 empty_size, u64 min_bytes), + + TP_ARGS(block_group, start, bytes, empty_size, min_bytes), + + TP_FIELDS( + ctf_integer(u64, bg_objectid, block_group->start) + ctf_integer(u64, flags, block_group->flags) + ctf_integer(u64, start, start) + ctf_integer(u64, bytes, bytes) + ctf_integer(u64, empty_size, empty_size) + ctf_integer(u64, min_bytes, min_bytes) + ) +) + +LTTNG_TRACEPOINT_EVENT(btrfs_failed_cluster_setup, + + TP_PROTO(const struct btrfs_block_group *block_group), + + TP_ARGS(block_group), + + TP_FIELDS( + ctf_integer(u64, bg_objectid, block_group->start) + ) +) + +LTTNG_TRACEPOINT_EVENT(btrfs_setup_cluster, + + TP_PROTO(const struct btrfs_block_group *block_group, + const struct btrfs_free_cluster *cluster, u64 size, int bitmap), + + TP_ARGS(block_group, cluster, size, bitmap), + + TP_FIELDS( + ctf_integer(u64, bg_objectid, block_group->start) + ctf_integer(u64, flags, block_group->flags) + ctf_integer(u64, start, cluster->window_start) + ctf_integer(u64, max_size, cluster->max_size) + ctf_integer(u64, size, size) + ctf_integer(int, bitmap, bitmap) + ) +) + +LTTNG_TRACEPOINT_EVENT_MAP(alloc_extent_state, + + btrfs_alloc_extent_state, + + TP_PROTO(const struct extent_state *state, gfp_t mask, unsigned long IP), + + TP_ARGS(state, mask, IP), + + TP_FIELDS( + ctf_integer_hex(const struct extent_state *, state, state) + ctf_integer(gfp_t, mask, mask) + ctf_integer_hex(unsigned long, ip, IP) + ) +) + +LTTNG_TRACEPOINT_EVENT_MAP(free_extent_state, + + btrfs_free_extent_state, + + TP_PROTO(const struct extent_state *state, unsigned long IP), + + TP_ARGS(state, IP), + + TP_FIELDS( + ctf_integer_hex(const struct extent_state *, state, state) + ctf_integer_hex(unsigned long, ip, IP) + ) +) + +#endif /* LTTNG_TRACE_BTRFS_H */ + +/* This part must be outside protection */ +#include diff --git a/include/instrumentation/events/lttng-module/compaction.h b/include/instrumentation/events/lttng-module/compaction.h new file mode 100644 index 00000000..1e5cccfc --- /dev/null +++ b/include/instrumentation/events/lttng-module/compaction.h @@ -0,0 +1,95 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#undef TRACE_SYSTEM +#define TRACE_SYSTEM compaction + +#if !defined(LTTNG_TRACE_COMPACTION_H) || defined(TRACE_HEADER_MULTI_READ) +#define LTTNG_TRACE_COMPACTION_H + +#include +#include + +LTTNG_TRACEPOINT_EVENT_CLASS(compaction_isolate_template, + + TP_PROTO(unsigned long start_pfn, + unsigned long end_pfn, + unsigned long nr_scanned, + unsigned long nr_taken), + + TP_ARGS(start_pfn, end_pfn, nr_scanned, nr_taken), + + TP_FIELDS( + ctf_integer(unsigned long, start_pfn, start_pfn) + ctf_integer(unsigned long, end_pfn, end_pfn) + ctf_integer(unsigned long, nr_scanned, nr_scanned) + ctf_integer(unsigned long, nr_taken, nr_taken) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(compaction_isolate_template, + + mm_compaction_isolate_migratepages, + + compaction_isolate_migratepages, + + TP_PROTO(unsigned long start_pfn, + unsigned long end_pfn, + unsigned long nr_scanned, + unsigned long nr_taken), + + TP_ARGS(start_pfn, end_pfn, nr_scanned, nr_taken) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(compaction_isolate_template, + + mm_compaction_isolate_freepages, + + compaction_isolate_freepages, + + TP_PROTO(unsigned long start_pfn, + unsigned long end_pfn, + unsigned long nr_scanned, + unsigned long nr_taken), + + TP_ARGS(start_pfn, end_pfn, nr_scanned, nr_taken) +) + +LTTNG_TRACEPOINT_EVENT_CODE_MAP(mm_compaction_migratepages, + + compaction_migratepages, + + TP_PROTO(unsigned long nr_all, + int migrate_rc, + struct list_head *migratepages), + + TP_ARGS(nr_all, migrate_rc, migratepages), + + TP_locvar( + unsigned long nr_failed; + ), + + TP_code_pre( + tp_locvar->nr_failed = 0; + + { + struct list_head *page_lru; + + if (migrate_rc >= 0) + tp_locvar->nr_failed = migrate_rc; + else + list_for_each(page_lru, migratepages) + tp_locvar->nr_failed++; + } + ), + + TP_FIELDS( + ctf_integer(unsigned long, nr_migrated, nr_all - tp_locvar->nr_failed) + ctf_integer(unsigned long, nr_failed, tp_locvar->nr_failed) + ), + + TP_code_post() +) + +#endif /* LTTNG_TRACE_COMPACTION_H */ + +/* This part must be outside protection */ +#include diff --git a/include/instrumentation/events/lttng-module/ext4.h b/include/instrumentation/events/lttng-module/ext4.h new file mode 100644 index 00000000..26118a9e --- /dev/null +++ b/include/instrumentation/events/lttng-module/ext4.h @@ -0,0 +1,1211 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#undef TRACE_SYSTEM +#define TRACE_SYSTEM ext4 + +#if !defined(LTTNG_TRACE_EXT4_H) || defined(TRACE_HEADER_MULTI_READ) +#define LTTNG_TRACE_EXT4_H + +#include +#include + +#ifndef _TRACE_EXT4_DEF_ +#define _TRACE_EXT4_DEF_ +struct ext4_allocation_context; +struct ext4_allocation_request; +struct ext4_prealloc_space; +struct ext4_inode_info; +struct mpage_da_data; +struct ext4_map_blocks; +struct ext4_extent; +#endif + +#define EXT4_I(inode) (container_of(inode, struct ext4_inode_info, vfs_inode)) +#define TP_MODE_T __u16 + +LTTNG_TRACEPOINT_EVENT(ext4_free_inode, + TP_PROTO(struct inode *inode), + + TP_ARGS(inode), + + TP_FIELDS( + ctf_integer(dev_t, dev, inode->i_sb->s_dev) + ctf_integer(ino_t, ino, inode->i_ino) + ctf_integer(uid_t, uid, i_uid_read(inode)) + ctf_integer(gid_t, gid, i_gid_read(inode)) + ctf_integer(__u64, blocks, inode->i_blocks) + ctf_integer(TP_MODE_T, mode, inode->i_mode) + ) +) + +LTTNG_TRACEPOINT_EVENT(ext4_request_inode, + TP_PROTO(struct inode *dir, int mode), + + TP_ARGS(dir, mode), + + TP_FIELDS( + ctf_integer(dev_t, dev, dir->i_sb->s_dev) + ctf_integer(ino_t, dir, dir->i_ino) + ctf_integer(TP_MODE_T, mode, mode) + ) +) + +LTTNG_TRACEPOINT_EVENT(ext4_allocate_inode, + TP_PROTO(struct inode *inode, struct inode *dir, int mode), + + TP_ARGS(inode, dir, mode), + + TP_FIELDS( + ctf_integer(dev_t, dev, inode->i_sb->s_dev) + ctf_integer(ino_t, ino, inode->i_ino) + ctf_integer(ino_t, dir, dir->i_ino) + ctf_integer(TP_MODE_T, mode, mode) + ) +) + +LTTNG_TRACEPOINT_EVENT(ext4_evict_inode, + TP_PROTO(struct inode *inode), + + TP_ARGS(inode), + + TP_FIELDS( + ctf_integer(dev_t, dev, inode->i_sb->s_dev) + ctf_integer(ino_t, ino, inode->i_ino) + ctf_integer(int, nlink, inode->i_nlink) + ) +) + +LTTNG_TRACEPOINT_EVENT(ext4_drop_inode, + TP_PROTO(struct inode *inode, int drop), + + TP_ARGS(inode, drop), + + TP_FIELDS( + ctf_integer(dev_t, dev, inode->i_sb->s_dev) + ctf_integer(ino_t, ino, inode->i_ino) + ctf_integer(int, drop, drop) + ) +) + +LTTNG_TRACEPOINT_EVENT(ext4_mark_inode_dirty, + TP_PROTO(struct inode *inode, unsigned long IP), + + TP_ARGS(inode, IP), + + TP_FIELDS( + ctf_integer(dev_t, dev, inode->i_sb->s_dev) + ctf_integer(ino_t, ino, inode->i_ino) + ctf_integer_hex(unsigned long, ip, IP) + ) +) + +LTTNG_TRACEPOINT_EVENT(ext4_begin_ordered_truncate, + TP_PROTO(struct inode *inode, loff_t new_size), + + TP_ARGS(inode, new_size), + + TP_FIELDS( + ctf_integer(dev_t, dev, inode->i_sb->s_dev) + ctf_integer(ino_t, ino, inode->i_ino) + ctf_integer(loff_t, new_size, new_size) + ) +) + +LTTNG_TRACEPOINT_EVENT_CLASS(ext4__write_begin, + + TP_PROTO(struct inode *inode, loff_t pos, unsigned int len, + unsigned int flags), + + TP_ARGS(inode, pos, len, flags), + + TP_FIELDS( + ctf_integer(dev_t, dev, inode->i_sb->s_dev) + ctf_integer(ino_t, ino, inode->i_ino) + ctf_integer(loff_t, pos, pos) + ctf_integer(unsigned int, len, len) + ctf_integer(unsigned int, flags, flags) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__write_begin, ext4_write_begin, + + TP_PROTO(struct inode *inode, loff_t pos, unsigned int len, + unsigned int flags), + + TP_ARGS(inode, pos, len, flags) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__write_begin, ext4_da_write_begin, + + TP_PROTO(struct inode *inode, loff_t pos, unsigned int len, + unsigned int flags), + + TP_ARGS(inode, pos, len, flags) +) + +LTTNG_TRACEPOINT_EVENT_CLASS(ext4__write_end, + TP_PROTO(struct inode *inode, loff_t pos, unsigned int len, + unsigned int copied), + + TP_ARGS(inode, pos, len, copied), + + TP_FIELDS( + ctf_integer(dev_t, dev, inode->i_sb->s_dev) + ctf_integer(ino_t, ino, inode->i_ino) + ctf_integer(loff_t, pos, pos) + ctf_integer(unsigned int, len, len) + ctf_integer(unsigned int, copied, copied) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__write_end, ext4_ordered_write_end, + + TP_PROTO(struct inode *inode, loff_t pos, unsigned int len, + unsigned int copied), + + TP_ARGS(inode, pos, len, copied) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__write_end, ext4_writeback_write_end, + + TP_PROTO(struct inode *inode, loff_t pos, unsigned int len, + unsigned int copied), + + TP_ARGS(inode, pos, len, copied) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__write_end, ext4_journalled_write_end, + + TP_PROTO(struct inode *inode, loff_t pos, unsigned int len, + unsigned int copied), + + TP_ARGS(inode, pos, len, copied) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__write_end, ext4_da_write_end, + + TP_PROTO(struct inode *inode, loff_t pos, unsigned int len, + unsigned int copied), + + TP_ARGS(inode, pos, len, copied) +) + +LTTNG_TRACEPOINT_EVENT(ext4_da_writepages, + TP_PROTO(struct inode *inode, struct writeback_control *wbc), + + TP_ARGS(inode, wbc), + + TP_FIELDS( + ctf_integer(dev_t, dev, inode->i_sb->s_dev) + ctf_integer(ino_t, ino, inode->i_ino) + ctf_integer(long, nr_to_write, wbc->nr_to_write) + ctf_integer(long, pages_skipped, wbc->pages_skipped) + ctf_integer(loff_t, range_start, wbc->range_start) + ctf_integer(loff_t, range_end, wbc->range_end) + ctf_integer(pgoff_t, writeback_index, inode->i_mapping->writeback_index) + ctf_integer(int, sync_mode, wbc->sync_mode) + ctf_integer(char, for_kupdate, wbc->for_kupdate) + ctf_integer(char, range_cyclic, wbc->range_cyclic) + ) +) + +LTTNG_TRACEPOINT_EVENT(ext4_da_write_pages, + TP_PROTO(struct inode *inode, pgoff_t first_page, + struct writeback_control *wbc), + + TP_ARGS(inode, first_page, wbc), + + TP_FIELDS( + ctf_integer(dev_t, dev, inode->i_sb->s_dev) + ctf_integer(ino_t, ino, inode->i_ino) + ctf_integer(pgoff_t, first_page, first_page) + ctf_integer(long, nr_to_write, wbc->nr_to_write) + ctf_integer(int, sync_mode, wbc->sync_mode) + ) +) + +LTTNG_TRACEPOINT_EVENT(ext4_da_write_pages_extent, + TP_PROTO(struct inode *inode, struct ext4_map_blocks *map), + + TP_ARGS(inode, map), + + TP_FIELDS( + ctf_integer(dev_t, dev, inode->i_sb->s_dev) + ctf_integer(ino_t, ino, inode->i_ino) + ctf_integer(__u64, lblk, map->m_lblk) + ctf_integer(__u32, len, map->m_len) + ctf_integer(__u32, flags, map->m_flags) + ) +) + +LTTNG_TRACEPOINT_EVENT(ext4_da_writepages_result, + TP_PROTO(struct inode *inode, struct writeback_control *wbc, + int ret, int pages_written), + + TP_ARGS(inode, wbc, ret, pages_written), + + TP_FIELDS( + ctf_integer(dev_t, dev, inode->i_sb->s_dev) + ctf_integer(ino_t, ino, inode->i_ino) + ctf_integer(int, ret, ret) + ctf_integer(int, pages_written, pages_written) + ctf_integer(long, pages_skipped, wbc->pages_skipped) + ctf_integer(pgoff_t, writeback_index, inode->i_mapping->writeback_index) + ctf_integer(int, sync_mode, wbc->sync_mode) + ) +) + +LTTNG_TRACEPOINT_EVENT_CLASS(ext4__page_op, + TP_PROTO(struct page *page), + + TP_ARGS(page), + + TP_FIELDS( + ctf_integer(dev_t, dev, page->mapping->host->i_sb->s_dev) + ctf_integer(ino_t, ino, page->mapping->host->i_ino) + ctf_integer(pgoff_t, index, page->index) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__page_op, ext4_writepage, + + TP_PROTO(struct page *page), + + TP_ARGS(page) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__page_op, ext4_readpage, + + TP_PROTO(struct page *page), + + TP_ARGS(page) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__page_op, ext4_releasepage, + + TP_PROTO(struct page *page), + + TP_ARGS(page) +) + +LTTNG_TRACEPOINT_EVENT_CLASS(ext4_invalidatepage_op, + TP_PROTO(struct page *page, unsigned int offset, unsigned int length), + + TP_ARGS(page, offset, length), + + TP_FIELDS( + ctf_integer(dev_t, dev, page->mapping->host->i_sb->s_dev) + ctf_integer(ino_t, ino, page->mapping->host->i_ino) + ctf_integer(pgoff_t, index, page->index) + ctf_integer(unsigned int, offset, offset) + ctf_integer(unsigned int, length, length) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4_invalidatepage_op, ext4_invalidatepage, + TP_PROTO(struct page *page, unsigned int offset, unsigned int length), + + TP_ARGS(page, offset, length) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4_invalidatepage_op, ext4_journalled_invalidatepage, + TP_PROTO(struct page *page, unsigned int offset, unsigned int length), + + TP_ARGS(page, offset, length) +) + +LTTNG_TRACEPOINT_EVENT(ext4_discard_blocks, + TP_PROTO(struct super_block *sb, unsigned long long blk, + unsigned long long count), + + TP_ARGS(sb, blk, count), + + TP_FIELDS( + ctf_integer(dev_t, dev, sb->s_dev) + ctf_integer(__u64, blk, blk) + ctf_integer(__u64, count, count) + ) +) + +LTTNG_TRACEPOINT_EVENT_CLASS(ext4__mb_new_pa, + TP_PROTO(struct ext4_allocation_context *ac, + struct ext4_prealloc_space *pa), + + TP_ARGS(ac, pa), + + TP_FIELDS( + ctf_integer(dev_t, dev, ac->ac_sb->s_dev) + ctf_integer(ino_t, ino, ac->ac_inode->i_ino) + ctf_integer(__u64, pa_pstart, pa->pa_pstart) + ctf_integer(__u64, pa_lstart, pa->pa_lstart) + ctf_integer(__u32, pa_len, pa->pa_len) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__mb_new_pa, ext4_mb_new_inode_pa, + + TP_PROTO(struct ext4_allocation_context *ac, + struct ext4_prealloc_space *pa), + + TP_ARGS(ac, pa) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__mb_new_pa, ext4_mb_new_group_pa, + + TP_PROTO(struct ext4_allocation_context *ac, + struct ext4_prealloc_space *pa), + + TP_ARGS(ac, pa) +) + +LTTNG_TRACEPOINT_EVENT(ext4_mb_release_inode_pa, + TP_PROTO( + struct ext4_prealloc_space *pa, + unsigned long long block, unsigned int count), + + TP_ARGS(pa, block, count), + + TP_FIELDS( + ctf_integer(dev_t, dev, pa->pa_inode->i_sb->s_dev) + ctf_integer(ino_t, ino, pa->pa_inode->i_ino) + ctf_integer(__u64, block, block) + ctf_integer(__u32, count, count) + ) +) + +LTTNG_TRACEPOINT_EVENT(ext4_mb_release_group_pa, + + TP_PROTO(struct super_block *sb, struct ext4_prealloc_space *pa), + + TP_ARGS(sb, pa), + + TP_FIELDS( + ctf_integer(dev_t, dev, sb->s_dev) + ctf_integer(__u64, pa_pstart, pa->pa_pstart) + ctf_integer(__u32, pa_len, pa->pa_len) + ) +) + +LTTNG_TRACEPOINT_EVENT(ext4_discard_preallocations, + TP_PROTO(struct inode *inode), + + TP_ARGS(inode), + + TP_FIELDS( + ctf_integer(dev_t, dev, inode->i_sb->s_dev) + ctf_integer(ino_t, ino, inode->i_ino) + ) +) + +LTTNG_TRACEPOINT_EVENT(ext4_mb_discard_preallocations, + TP_PROTO(struct super_block *sb, int needed), + + TP_ARGS(sb, needed), + + TP_FIELDS( + ctf_integer(dev_t, dev, sb->s_dev) + ctf_integer(int, needed, needed) + ) +) + +LTTNG_TRACEPOINT_EVENT(ext4_request_blocks, + TP_PROTO(struct ext4_allocation_request *ar), + + TP_ARGS(ar), + + TP_FIELDS( + ctf_integer(dev_t, dev, ar->inode->i_sb->s_dev) + ctf_integer(ino_t, ino, ar->inode->i_ino) + ctf_integer(unsigned int, len, ar->len) + ctf_integer(__u32, logical, ar->logical) + ctf_integer(__u32, lleft, ar->lleft) + ctf_integer(__u32, lright, ar->lright) + ctf_integer(__u64, goal, ar->goal) + ctf_integer(__u64, pleft, ar->pleft) + ctf_integer(__u64, pright, ar->pright) + ctf_integer(unsigned int, flags, ar->flags) + ) +) + +LTTNG_TRACEPOINT_EVENT(ext4_allocate_blocks, + TP_PROTO(struct ext4_allocation_request *ar, unsigned long long block), + + TP_ARGS(ar, block), + + TP_FIELDS( + ctf_integer(dev_t, dev, ar->inode->i_sb->s_dev) + ctf_integer(ino_t, ino, ar->inode->i_ino) + ctf_integer(__u64, block, block) + ctf_integer(unsigned int, len, ar->len) + ctf_integer(__u32, logical, ar->logical) + ctf_integer(__u32, lleft, ar->lleft) + ctf_integer(__u32, lright, ar->lright) + ctf_integer(__u64, goal, ar->goal) + ctf_integer(__u64, pleft, ar->pleft) + ctf_integer(__u64, pright, ar->pright) + ctf_integer(unsigned int, flags, ar->flags) + ) +) + +LTTNG_TRACEPOINT_EVENT(ext4_free_blocks, + TP_PROTO(struct inode *inode, __u64 block, unsigned long count, + int flags), + + TP_ARGS(inode, block, count, flags), + + TP_FIELDS( + ctf_integer(dev_t, dev, inode->i_sb->s_dev) + ctf_integer(ino_t, ino, inode->i_ino) + ctf_integer(__u64, block, block) + ctf_integer(unsigned long, count, count) + ctf_integer(int, flags, flags) + ctf_integer(TP_MODE_T, mode, inode->i_mode) + ) +) + +LTTNG_TRACEPOINT_EVENT(ext4_sync_file_enter, + TP_PROTO(struct file *file, int datasync), + + TP_ARGS(file, datasync), + + TP_FIELDS( + ctf_integer(dev_t, dev, file->f_path.dentry->d_inode->i_sb->s_dev) + ctf_integer(ino_t, ino, file->f_path.dentry->d_inode->i_ino) + ctf_integer(ino_t, parent, file->f_path.dentry->d_parent->d_inode->i_ino) + ctf_integer(int, datasync, datasync) + ) +) + +LTTNG_TRACEPOINT_EVENT(ext4_sync_file_exit, + TP_PROTO(struct inode *inode, int ret), + + TP_ARGS(inode, ret), + + TP_FIELDS( + ctf_integer(dev_t, dev, inode->i_sb->s_dev) + ctf_integer(ino_t, ino, inode->i_ino) + ctf_integer(int, ret, ret) + ) +) + +LTTNG_TRACEPOINT_EVENT(ext4_sync_fs, + TP_PROTO(struct super_block *sb, int wait), + + TP_ARGS(sb, wait), + + TP_FIELDS( + ctf_integer(dev_t, dev, sb->s_dev) + ctf_integer(int, wait, wait) + + ) +) + +LTTNG_TRACEPOINT_EVENT(ext4_alloc_da_blocks, + TP_PROTO(struct inode *inode), + + TP_ARGS(inode), + + TP_FIELDS( + ctf_integer(dev_t, dev, inode->i_sb->s_dev) + ctf_integer(ino_t, ino, inode->i_ino) + ctf_integer(unsigned int, data_blocks, EXT4_I(inode)->i_reserved_data_blocks) + ) +) + +LTTNG_TRACEPOINT_EVENT(ext4_mballoc_alloc, + TP_PROTO(struct ext4_allocation_context *ac), + + TP_ARGS(ac), + + TP_FIELDS( + ctf_integer(dev_t, dev, ac->ac_inode->i_sb->s_dev) + ctf_integer(ino_t, ino, ac->ac_inode->i_ino) + ctf_integer(__u32, orig_logical, ac->ac_o_ex.fe_logical) + ctf_integer(int, orig_start, ac->ac_o_ex.fe_start) + ctf_integer(__u32, orig_group, ac->ac_o_ex.fe_group) + ctf_integer(int, orig_len, ac->ac_o_ex.fe_len) + ctf_integer(__u32, goal_logical, ac->ac_g_ex.fe_logical) + ctf_integer(int, goal_start, ac->ac_g_ex.fe_start) + ctf_integer(__u32, goal_group, ac->ac_g_ex.fe_group) + ctf_integer(int, goal_len, ac->ac_g_ex.fe_len) + ctf_integer(__u32, result_logical, ac->ac_f_ex.fe_logical) + ctf_integer(int, result_start, ac->ac_f_ex.fe_start) + ctf_integer(__u32, result_group, ac->ac_f_ex.fe_group) + ctf_integer(int, result_len, ac->ac_f_ex.fe_len) + ctf_integer(__u16, found, ac->ac_found) + ctf_integer(__u16, groups, ac->ac_groups_scanned) + ctf_integer(__u16, buddy, ac->ac_buddy) + ctf_integer(__u16, flags, ac->ac_flags) + ctf_integer(__u16, tail, ac->ac_tail) + ctf_integer(__u8, cr, ac->ac_criteria) + ) +) + +LTTNG_TRACEPOINT_EVENT(ext4_mballoc_prealloc, + TP_PROTO(struct ext4_allocation_context *ac), + + TP_ARGS(ac), + + TP_FIELDS( + ctf_integer(dev_t, dev, ac->ac_inode->i_sb->s_dev) + ctf_integer(ino_t, ino, ac->ac_inode->i_ino) + ctf_integer(__u32, orig_logical, ac->ac_o_ex.fe_logical) + ctf_integer(int, orig_start, ac->ac_o_ex.fe_start) + ctf_integer(__u32, orig_group, ac->ac_o_ex.fe_group) + ctf_integer(int, orig_len, ac->ac_o_ex.fe_len) + ctf_integer(__u32, result_logical, ac->ac_b_ex.fe_logical) + ctf_integer(int, result_start, ac->ac_b_ex.fe_start) + ctf_integer(__u32, result_group, ac->ac_b_ex.fe_group) + ctf_integer(int, result_len, ac->ac_b_ex.fe_len) + ) +) + +LTTNG_TRACEPOINT_EVENT_CLASS(ext4__mballoc, + TP_PROTO(struct super_block *sb, + struct inode *inode, + ext4_group_t group, + ext4_grpblk_t start, + ext4_grpblk_t len), + + TP_ARGS(sb, inode, group, start, len), + + TP_FIELDS( + ctf_integer(dev_t, dev, sb->s_dev) + ctf_integer(ino_t, ino, inode ? inode->i_ino : 0) + ctf_integer(int, result_start, start) + ctf_integer(__u32, result_group, group) + ctf_integer(int, result_len, len) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__mballoc, ext4_mballoc_discard, + + TP_PROTO(struct super_block *sb, + struct inode *inode, + ext4_group_t group, + ext4_grpblk_t start, + ext4_grpblk_t len), + + TP_ARGS(sb, inode, group, start, len) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__mballoc, ext4_mballoc_free, + + TP_PROTO(struct super_block *sb, + struct inode *inode, + ext4_group_t group, + ext4_grpblk_t start, + ext4_grpblk_t len), + + TP_ARGS(sb, inode, group, start, len) +) + +LTTNG_TRACEPOINT_EVENT(ext4_forget, + TP_PROTO(struct inode *inode, int is_metadata, __u64 block), + + TP_ARGS(inode, is_metadata, block), + + TP_FIELDS( + ctf_integer(dev_t, dev, inode->i_sb->s_dev) + ctf_integer(ino_t, ino, inode->i_ino) + ctf_integer(__u64, block, block) + ctf_integer(int, is_metadata, is_metadata) + ctf_integer(TP_MODE_T, mode, inode->i_mode) + ) +) + +LTTNG_TRACEPOINT_EVENT(ext4_da_update_reserve_space, + TP_PROTO(struct inode *inode, int used_blocks, int quota_claim), + + TP_ARGS(inode, used_blocks, quota_claim), + + TP_FIELDS( + ctf_integer(dev_t, dev, inode->i_sb->s_dev) + ctf_integer(ino_t, ino, inode->i_ino) + ctf_integer(__u64, i_blocks, inode->i_blocks) + ctf_integer(int, used_blocks, used_blocks) + ctf_integer(int, reserved_data_blocks, + EXT4_I(inode)->i_reserved_data_blocks) + ctf_integer(int, quota_claim, quota_claim) + ctf_integer(TP_MODE_T, mode, inode->i_mode) + ) +) + +LTTNG_TRACEPOINT_EVENT(ext4_da_reserve_space, + TP_PROTO(struct inode *inode), + + TP_ARGS(inode), + + TP_FIELDS( + ctf_integer(dev_t, dev, inode->i_sb->s_dev) + ctf_integer(ino_t, ino, inode->i_ino) + ctf_integer(__u64, i_blocks, inode->i_blocks) + ctf_integer(int, reserved_data_blocks, + EXT4_I(inode)->i_reserved_data_blocks) + ctf_integer(TP_MODE_T, mode, inode->i_mode) + ) +) + +LTTNG_TRACEPOINT_EVENT(ext4_da_release_space, + TP_PROTO(struct inode *inode, int freed_blocks), + + TP_ARGS(inode, freed_blocks), + + TP_FIELDS( + ctf_integer(dev_t, dev, inode->i_sb->s_dev) + ctf_integer(ino_t, ino, inode->i_ino) + ctf_integer(__u64, i_blocks, inode->i_blocks) + ctf_integer(int, freed_blocks, freed_blocks) + ctf_integer(int, reserved_data_blocks, + EXT4_I(inode)->i_reserved_data_blocks) + ctf_integer(TP_MODE_T, mode, inode->i_mode) + ) +) + +LTTNG_TRACEPOINT_EVENT_CLASS(ext4__bitmap_load, + TP_PROTO(struct super_block *sb, unsigned long group), + + TP_ARGS(sb, group), + + TP_FIELDS( + ctf_integer(dev_t, dev, sb->s_dev) + ctf_integer(__u32, group, group) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__bitmap_load, ext4_mb_bitmap_load, + + TP_PROTO(struct super_block *sb, unsigned long group), + + TP_ARGS(sb, group) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__bitmap_load, ext4_mb_buddy_bitmap_load, + + TP_PROTO(struct super_block *sb, unsigned long group), + + TP_ARGS(sb, group) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__bitmap_load, ext4_read_block_bitmap_load, + + TP_PROTO(struct super_block *sb, unsigned long group), + + TP_ARGS(sb, group) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__bitmap_load, ext4_load_inode_bitmap, + + TP_PROTO(struct super_block *sb, unsigned long group), + + TP_ARGS(sb, group) +) + +LTTNG_TRACEPOINT_EVENT(ext4_direct_IO_enter, + TP_PROTO(struct inode *inode, loff_t offset, unsigned long len, int rw), + + TP_ARGS(inode, offset, len, rw), + + TP_FIELDS( + ctf_integer(dev_t, dev, inode->i_sb->s_dev) + ctf_integer(ino_t, ino, inode->i_ino) + ctf_integer(loff_t, pos, offset) + ctf_integer(unsigned long, len, len) + ctf_integer(int, rw, rw) + ) +) + +LTTNG_TRACEPOINT_EVENT(ext4_direct_IO_exit, + TP_PROTO(struct inode *inode, loff_t offset, unsigned long len, + int rw, int ret), + + TP_ARGS(inode, offset, len, rw, ret), + + TP_FIELDS( + ctf_integer(dev_t, dev, inode->i_sb->s_dev) + ctf_integer(ino_t, ino, inode->i_ino) + ctf_integer(loff_t, pos, offset) + ctf_integer(unsigned long, len, len) + ctf_integer(int, rw, rw) + ctf_integer(int, ret, ret) + ) +) + +LTTNG_TRACEPOINT_EVENT(ext4_fallocate_exit, + TP_PROTO(struct inode *inode, loff_t offset, + unsigned int max_blocks, int ret), + + TP_ARGS(inode, offset, max_blocks, ret), + + TP_FIELDS( + ctf_integer(dev_t, dev, inode->i_sb->s_dev) + ctf_integer(ino_t, ino, inode->i_ino) + ctf_integer(loff_t, pos, offset) + ctf_integer(unsigned int, blocks, max_blocks) + ctf_integer(int, ret, ret) + ) +) + +LTTNG_TRACEPOINT_EVENT_CLASS(ext4__fallocate_mode, + TP_PROTO(struct inode *inode, loff_t offset, loff_t len, int mode), + + TP_ARGS(inode, offset, len, mode), + + TP_FIELDS( + ctf_integer(dev_t, dev, inode->i_sb->s_dev) + ctf_integer(ino_t, ino, inode->i_ino) + ctf_integer(loff_t, pos, offset) + ctf_integer(loff_t, len, len) + ctf_integer(int, mode, mode) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__fallocate_mode, ext4_fallocate_enter, + + TP_PROTO(struct inode *inode, loff_t offset, loff_t len, int mode), + + TP_ARGS(inode, offset, len, mode) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__fallocate_mode, ext4_punch_hole, + + TP_PROTO(struct inode *inode, loff_t offset, loff_t len, int mode), + + TP_ARGS(inode, offset, len, mode) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__fallocate_mode, ext4_zero_range, + + TP_PROTO(struct inode *inode, loff_t offset, loff_t len, int mode), + + TP_ARGS(inode, offset, len, mode) +) + +LTTNG_TRACEPOINT_EVENT(ext4_unlink_enter, + TP_PROTO(struct inode *parent, struct dentry *dentry), + + TP_ARGS(parent, dentry), + + TP_FIELDS( + ctf_integer(dev_t, dev, dentry->d_inode->i_sb->s_dev) + ctf_integer(ino_t, ino, dentry->d_inode->i_ino) + ctf_integer(ino_t, parent, parent->i_ino) + ctf_integer(loff_t, size, dentry->d_inode->i_size) + ) +) + +LTTNG_TRACEPOINT_EVENT(ext4_unlink_exit, + TP_PROTO(struct dentry *dentry, int ret), + + TP_ARGS(dentry, ret), + + TP_FIELDS( + ctf_integer(dev_t, dev, dentry->d_inode->i_sb->s_dev) + ctf_integer(ino_t, ino, dentry->d_inode->i_ino) + ctf_integer(int, ret, ret) + ) +) + +LTTNG_TRACEPOINT_EVENT_CLASS(ext4__truncate, + TP_PROTO(struct inode *inode), + + TP_ARGS(inode), + + TP_FIELDS( + ctf_integer(dev_t, dev, inode->i_sb->s_dev) + ctf_integer(ino_t, ino, inode->i_ino) + ctf_integer(unsigned int, blocks, inode->i_blocks) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__truncate, ext4_truncate_enter, + + TP_PROTO(struct inode *inode), + + TP_ARGS(inode) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__truncate, ext4_truncate_exit, + + TP_PROTO(struct inode *inode), + + TP_ARGS(inode) +) + +/* 'ux' is the uninitialized extent. */ +LTTNG_TRACEPOINT_EVENT(ext4_ext_convert_to_initialized_enter, + TP_PROTO(struct inode *inode, struct ext4_map_blocks *map, + struct ext4_extent *ux), + + TP_ARGS(inode, map, ux), + + TP_FIELDS( + ctf_integer(dev_t, dev, inode->i_sb->s_dev) + ctf_integer(ino_t, ino, inode->i_ino) + ctf_integer(ext4_lblk_t, m_lblk, map->m_lblk) + ctf_integer(unsigned, m_len, map->m_len) + ctf_integer(ext4_lblk_t, u_lblk, le32_to_cpu(ux->ee_block)) + ctf_integer(unsigned, u_len, ext4_ext_get_actual_len(ux)) + ctf_integer(ext4_fsblk_t, u_pblk, ext4_ext_pblock(ux)) + ) +) + +/* + * 'ux' is the uninitialized extent. + * 'ix' is the initialized extent to which blocks are transferred. + */ +LTTNG_TRACEPOINT_EVENT(ext4_ext_convert_to_initialized_fastpath, + TP_PROTO(struct inode *inode, struct ext4_map_blocks *map, + struct ext4_extent *ux, struct ext4_extent *ix), + + TP_ARGS(inode, map, ux, ix), + + TP_FIELDS( + ctf_integer(dev_t, dev, inode->i_sb->s_dev) + ctf_integer(ino_t, ino, inode->i_ino) + ctf_integer(ext4_lblk_t, m_lblk, map->m_lblk) + ctf_integer(unsigned, m_len, map->m_len) + ctf_integer(ext4_lblk_t, u_lblk, le32_to_cpu(ux->ee_block)) + ctf_integer(unsigned, u_len, ext4_ext_get_actual_len(ux)) + ctf_integer(ext4_fsblk_t, u_pblk, ext4_ext_pblock(ux)) + ctf_integer(ext4_lblk_t, i_lblk, le32_to_cpu(ix->ee_block)) + ctf_integer(unsigned, i_len, ext4_ext_get_actual_len(ix)) + ctf_integer(ext4_fsblk_t, i_pblk, ext4_ext_pblock(ix)) + ) +) + +LTTNG_TRACEPOINT_EVENT_CLASS(ext4__map_blocks_enter, + TP_PROTO(struct inode *inode, ext4_lblk_t lblk, + unsigned int len, unsigned int flags), + + TP_ARGS(inode, lblk, len, flags), + + TP_FIELDS( + ctf_integer(dev_t, dev, inode->i_sb->s_dev) + ctf_integer(ino_t, ino, inode->i_ino) + ctf_integer(ext4_lblk_t, lblk, lblk) + ctf_integer(unsigned int, len, len) + ctf_integer(unsigned int, flags, flags) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__map_blocks_enter, ext4_ext_map_blocks_enter, + TP_PROTO(struct inode *inode, ext4_lblk_t lblk, + unsigned len, unsigned flags), + + TP_ARGS(inode, lblk, len, flags) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__map_blocks_enter, ext4_ind_map_blocks_enter, + TP_PROTO(struct inode *inode, ext4_lblk_t lblk, + unsigned len, unsigned flags), + + TP_ARGS(inode, lblk, len, flags) +) + +LTTNG_TRACEPOINT_EVENT_CLASS(ext4__map_blocks_exit, + TP_PROTO(struct inode *inode, unsigned flags, struct ext4_map_blocks *map, + int ret), + + TP_ARGS(inode, flags, map, ret), + + TP_FIELDS( + ctf_integer(dev_t, dev, inode->i_sb->s_dev) + ctf_integer(ino_t, ino, inode->i_ino) + ctf_integer(unsigned int, flags, flags) + ctf_integer(ext4_fsblk_t, pblk, map->m_pblk) + ctf_integer(ext4_lblk_t, lblk, map->m_lblk) + ctf_integer(unsigned int, len, map->m_len) + ctf_integer(unsigned int, mflags, map->m_flags) + ctf_integer(int, ret, ret) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__map_blocks_exit, ext4_ext_map_blocks_exit, + TP_PROTO(struct inode *inode, unsigned flags, + struct ext4_map_blocks *map, int ret), + + TP_ARGS(inode, flags, map, ret) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__map_blocks_exit, ext4_ind_map_blocks_exit, + TP_PROTO(struct inode *inode, unsigned flags, + struct ext4_map_blocks *map, int ret), + + TP_ARGS(inode, flags, map, ret) +) + +LTTNG_TRACEPOINT_EVENT(ext4_ext_load_extent, + TP_PROTO(struct inode *inode, ext4_lblk_t lblk, ext4_fsblk_t pblk), + + TP_ARGS(inode, lblk, pblk), + + TP_FIELDS( + ctf_integer(dev_t, dev, inode->i_sb->s_dev) + ctf_integer(ino_t, ino, inode->i_ino) + ctf_integer(ext4_fsblk_t, pblk, pblk) + ctf_integer(ext4_lblk_t, lblk, lblk) + ) +) + +LTTNG_TRACEPOINT_EVENT(ext4_load_inode, + TP_PROTO(struct inode *inode), + + TP_ARGS(inode), + + TP_FIELDS( + ctf_integer(dev_t, dev, inode->i_sb->s_dev) + ctf_integer(ino_t, ino, inode->i_ino) + ) +) + +LTTNG_TRACEPOINT_EVENT(ext4_journal_start, + TP_PROTO(struct super_block *sb, int blocks, int rsv_blocks, + int revoke_creds, unsigned long IP), + + TP_ARGS(sb, blocks, rsv_blocks, revoke_creds, IP), + + TP_FIELDS( + ctf_integer(dev_t, dev, sb->s_dev) + ctf_integer_hex(unsigned long, ip, IP) + ctf_integer(int, blocks, blocks) + ctf_integer(int, rsv_blocks, rsv_blocks) + ctf_integer(int, revoke_creds, revoke_creds) + ) +) + +LTTNG_TRACEPOINT_EVENT(ext4_journal_start_reserved, + TP_PROTO(struct super_block *sb, int blocks, unsigned long IP), + + TP_ARGS(sb, blocks, IP), + + TP_FIELDS( + ctf_integer(dev_t, dev, sb->s_dev) + ctf_integer_hex(unsigned long, ip, IP) + ctf_integer(int, blocks, blocks) + ) +) + +LTTNG_TRACEPOINT_EVENT(ext4_ext_handle_uninitialized_extents, + TP_PROTO(struct inode *inode, struct ext4_map_blocks *map, int flags, + unsigned int allocated, ext4_fsblk_t newblock), + + TP_ARGS(inode, map, flags, allocated, newblock), + + TP_FIELDS( + ctf_integer(dev_t, dev, inode->i_sb->s_dev) + ctf_integer(ino_t, ino, inode->i_ino) + ctf_integer(int, flags, flags) + ctf_integer(ext4_lblk_t, lblk, map->m_lblk) + ctf_integer(ext4_fsblk_t, pblk, map->m_pblk) + ctf_integer(unsigned int, len, map->m_len) + ctf_integer(unsigned int, allocated, allocated) + ctf_integer(ext4_fsblk_t, newblk, newblock) + ) +) + +LTTNG_TRACEPOINT_EVENT(ext4_get_implied_cluster_alloc_exit, + TP_PROTO(struct super_block *sb, struct ext4_map_blocks *map, int ret), + + TP_ARGS(sb, map, ret), + + TP_FIELDS( + ctf_integer(dev_t, dev, sb->s_dev) + ctf_integer(unsigned int, flags, map->m_flags) + ctf_integer(ext4_lblk_t, lblk, map->m_lblk) + ctf_integer(ext4_fsblk_t, pblk, map->m_pblk) + ctf_integer(unsigned int, len, map->m_len) + ctf_integer(int, ret, ret) + ) +) + +LTTNG_TRACEPOINT_EVENT(ext4_ext_put_in_cache, + TP_PROTO(struct inode *inode, ext4_lblk_t lblk, unsigned int len, + ext4_fsblk_t start), + + TP_ARGS(inode, lblk, len, start), + + TP_FIELDS( + ctf_integer(dev_t, dev, inode->i_sb->s_dev) + ctf_integer(ino_t, ino, inode->i_ino) + ctf_integer(ext4_lblk_t, lblk, lblk) + ctf_integer(unsigned int, len, len) + ctf_integer(ext4_fsblk_t, start, start) + ) +) + +LTTNG_TRACEPOINT_EVENT(ext4_ext_in_cache, + TP_PROTO(struct inode *inode, ext4_lblk_t lblk, int ret), + + TP_ARGS(inode, lblk, ret), + + TP_FIELDS( + ctf_integer(dev_t, dev, inode->i_sb->s_dev) + ctf_integer(ino_t, ino, inode->i_ino) + ctf_integer(ext4_lblk_t, lblk, lblk) + ctf_integer(int, ret, ret) + ) +) + +LTTNG_TRACEPOINT_EVENT(ext4_find_delalloc_range, + TP_PROTO(struct inode *inode, ext4_lblk_t from, ext4_lblk_t to, + int reverse, int found, ext4_lblk_t found_blk), + + TP_ARGS(inode, from, to, reverse, found, found_blk), + + TP_FIELDS( + ctf_integer(dev_t, dev, inode->i_sb->s_dev) + ctf_integer(ino_t, ino, inode->i_ino) + ctf_integer(ext4_lblk_t, from, from) + ctf_integer(ext4_lblk_t, to, to) + ctf_integer(int, reverse, reverse) + ctf_integer(int, found, found) + ctf_integer(ext4_lblk_t, found_blk, found_blk) + ) +) + +LTTNG_TRACEPOINT_EVENT(ext4_get_reserved_cluster_alloc, + TP_PROTO(struct inode *inode, ext4_lblk_t lblk, unsigned int len), + + TP_ARGS(inode, lblk, len), + + TP_FIELDS( + ctf_integer(dev_t, dev, inode->i_sb->s_dev) + ctf_integer(ino_t, ino, inode->i_ino) + ctf_integer(ext4_lblk_t, lblk, lblk) + ctf_integer(unsigned int, len, len) + ) +) + +LTTNG_TRACEPOINT_EVENT(ext4_ext_show_extent, + TP_PROTO(struct inode *inode, ext4_lblk_t lblk, ext4_fsblk_t pblk, + unsigned short len), + + TP_ARGS(inode, lblk, pblk, len), + + TP_FIELDS( + ctf_integer(dev_t, dev, inode->i_sb->s_dev) + ctf_integer(ino_t, ino, inode->i_ino) + ctf_integer(ext4_fsblk_t, pblk, pblk) + ctf_integer(ext4_lblk_t, lblk, lblk) + ctf_integer(unsigned short, len, len) + ) +) + +LTTNG_TRACEPOINT_EVENT(ext4_remove_blocks, + TP_PROTO(struct inode *inode, struct ext4_extent *ex, + ext4_lblk_t from, ext4_fsblk_t to, + struct partial_cluster *pc), + + TP_ARGS(inode, ex, from, to, pc), + + TP_FIELDS( + ctf_integer(dev_t, dev, inode->i_sb->s_dev) + ctf_integer(ino_t, ino, inode->i_ino) + ctf_integer(ext4_lblk_t, from, from) + ctf_integer(ext4_lblk_t, to, to) + ctf_integer(ext4_fsblk_t, ee_pblk, ext4_ext_pblock(ex)) + ctf_integer(ext4_lblk_t, ee_lblk, le32_to_cpu(ex->ee_block)) + ctf_integer(unsigned short, ee_len, ext4_ext_get_actual_len(ex)) + ctf_integer(ext4_fsblk_t, pc_pclu, pc->pclu) + ctf_integer(ext4_lblk_t, pc_lblk, pc->lblk) + ctf_integer(int, pc_state, pc->state) + ) +) + +LTTNG_TRACEPOINT_EVENT(ext4_ext_rm_leaf, + TP_PROTO(struct inode *inode, ext4_lblk_t start, + struct ext4_extent *ex, + struct partial_cluster *pc), + + TP_ARGS(inode, start, ex, pc), + + TP_FIELDS( + ctf_integer(dev_t, dev, inode->i_sb->s_dev) + ctf_integer(ino_t, ino, inode->i_ino) + ctf_integer(ext4_lblk_t, start, start) + ctf_integer(ext4_lblk_t, ee_lblk, le32_to_cpu(ex->ee_block)) + ctf_integer(ext4_fsblk_t, ee_pblk, ext4_ext_pblock(ex)) + ctf_integer(short, ee_len, ext4_ext_get_actual_len(ex)) + ctf_integer(ext4_fsblk_t, pc_pclu, pc->pclu) + ctf_integer(ext4_lblk_t, pc_lblk, pc->lblk) + ctf_integer(int, pc_state, pc->state) + ) +) + +LTTNG_TRACEPOINT_EVENT(ext4_ext_rm_idx, + TP_PROTO(struct inode *inode, ext4_fsblk_t pblk), + + TP_ARGS(inode, pblk), + + TP_FIELDS( + ctf_integer(dev_t, dev, inode->i_sb->s_dev) + ctf_integer(ino_t, ino, inode->i_ino) + ctf_integer(ext4_fsblk_t, pblk, pblk) + ) +) + +LTTNG_TRACEPOINT_EVENT(ext4_ext_remove_space, + TP_PROTO(struct inode *inode, ext4_lblk_t start, + ext4_lblk_t end, int depth), + + TP_ARGS(inode, start, end, depth), + + TP_FIELDS( + ctf_integer(dev_t, dev, inode->i_sb->s_dev) + ctf_integer(ino_t, ino, inode->i_ino) + ctf_integer(ext4_lblk_t, start, start) + ctf_integer(ext4_lblk_t, end, end) + ctf_integer(int, depth, depth) + ) +) + +LTTNG_TRACEPOINT_EVENT(ext4_ext_remove_space_done, + TP_PROTO(struct inode *inode, ext4_lblk_t start, ext4_lblk_t end, + int depth, struct partial_cluster *pc, __le16 eh_entries), + + TP_ARGS(inode, start, end, depth, pc, eh_entries), + + TP_FIELDS( + ctf_integer(dev_t, dev, inode->i_sb->s_dev) + ctf_integer(ino_t, ino, inode->i_ino) + ctf_integer(ext4_lblk_t, start, start) + ctf_integer(ext4_lblk_t, end, end) + ctf_integer(int, depth, depth) + ctf_integer(unsigned short, eh_entries, le16_to_cpu(eh_entries)) + ctf_integer(ext4_fsblk_t, pc_pclu, pc->pclu) + ctf_integer(ext4_lblk_t, pc_lblk, pc->lblk) + ctf_integer(int, pc_state, pc->state) + ) +) + +LTTNG_TRACEPOINT_EVENT_CLASS(ext4__es_extent, + TP_PROTO(struct inode *inode, struct extent_status *es), + + TP_ARGS(inode, es), + + TP_FIELDS( + ctf_integer(dev_t, dev, inode->i_sb->s_dev) + ctf_integer(ino_t, ino, inode->i_ino) + ctf_integer(ext4_lblk_t, lblk, es->es_lblk) + ctf_integer(ext4_lblk_t, len, es->es_len) + ctf_integer(ext4_fsblk_t, pblk, ext4_es_pblock(es)) + ctf_integer(char, status, ext4_es_status(es)) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__es_extent, ext4_es_insert_extent, + TP_PROTO(struct inode *inode, struct extent_status *es), + + TP_ARGS(inode, es) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__es_extent, ext4_es_cache_extent, + TP_PROTO(struct inode *inode, struct extent_status *es), + + TP_ARGS(inode, es) +) + +#endif /* LTTNG_TRACE_EXT4_H */ + +/* This part must be outside protection */ +#include diff --git a/include/instrumentation/events/lttng-module/gpio.h b/include/instrumentation/events/lttng-module/gpio.h new file mode 100644 index 00000000..c0419d1e --- /dev/null +++ b/include/instrumentation/events/lttng-module/gpio.h @@ -0,0 +1,39 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#undef TRACE_SYSTEM +#define TRACE_SYSTEM gpio + +#if !defined(LTTNG_TRACE_GPIO_H) || defined(TRACE_HEADER_MULTI_READ) +#define LTTNG_TRACE_GPIO_H + +#include + +LTTNG_TRACEPOINT_EVENT(gpio_direction, + + TP_PROTO(unsigned gpio, int in, int err), + + TP_ARGS(gpio, in, err), + + TP_FIELDS( + ctf_integer(unsigned, gpio, gpio) + ctf_integer(int, in, in) + ctf_integer(int, err, err) + ) +) + +LTTNG_TRACEPOINT_EVENT(gpio_value, + + TP_PROTO(unsigned gpio, int get, int value), + + TP_ARGS(gpio, get, value), + + TP_FIELDS( + ctf_integer(unsigned, gpio, gpio) + ctf_integer(int, get, get) + ctf_integer(int, value, value) + ) +) + +#endif /* if !defined(LTTNG_TRACE_GPIO_H) || defined(TRACE_HEADER_MULTI_READ) */ + +/* This part must be outside protection */ +#include diff --git a/include/instrumentation/events/lttng-module/i2c.h b/include/instrumentation/events/lttng-module/i2c.h new file mode 100644 index 00000000..f65c2849 --- /dev/null +++ b/include/instrumentation/events/lttng-module/i2c.h @@ -0,0 +1,120 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#undef TRACE_SYSTEM +#define TRACE_SYSTEM i2c + +#if !defined(LTTNG_TRACE_I2C_H) || defined(TRACE_HEADER_MULTI_READ) +#define LTTNG_TRACE_I2C_H + +#include + +/* + * __i2c_transfer() write request + */ +LTTNG_TRACEPOINT_EVENT_CODE(i2c_write, + + TP_PROTO(const struct i2c_adapter *adap, const struct i2c_msg *msg, + int num), + + TP_ARGS(adap, msg, num), + + TP_locvar( + int extract_sensitive_payload; + ), + + TP_code_pre( + tp_locvar->extract_sensitive_payload = + READ_ONCE(extract_sensitive_payload); + ), + + TP_FIELDS( + ctf_integer(int, adapter_nr, adap->nr) + ctf_integer(__u16, msg_nr, num) + ctf_integer(__u16, addr, msg->addr) + ctf_integer(__u16, flags, msg->flags) + ctf_integer(__u16, len, msg->len) + ctf_sequence_hex(__u8, buf, + tp_locvar->extract_sensitive_payload ? + msg->buf : NULL, + __u16, + tp_locvar->extract_sensitive_payload ? + msg->len : 0) + ), + + TP_code_post() +) + +/* + * __i2c_transfer() read request + */ +LTTNG_TRACEPOINT_EVENT(i2c_read, + + TP_PROTO(const struct i2c_adapter *adap, const struct i2c_msg *msg, + int num), + + TP_ARGS(adap, msg, num), + + TP_FIELDS( + ctf_integer(int, adapter_nr, adap->nr) + ctf_integer(__u16, msg_nr, num) + ctf_integer(__u16, addr, msg->addr) + ctf_integer(__u16, flags, msg->flags) + ctf_integer(__u16, len, msg->len) + ) +) + +/* + * __i2c_transfer() read reply + */ +LTTNG_TRACEPOINT_EVENT_CODE(i2c_reply, + + TP_PROTO(const struct i2c_adapter *adap, const struct i2c_msg *msg, + int num), + + TP_ARGS(adap, msg, num), + + TP_locvar( + int extract_sensitive_payload; + ), + + TP_code_pre( + tp_locvar->extract_sensitive_payload = + READ_ONCE(extract_sensitive_payload); + ), + + TP_FIELDS( + ctf_integer(int, adapter_nr, adap->nr) + ctf_integer(__u16, msg_nr, num) + ctf_integer(__u16, addr, msg->addr) + ctf_integer(__u16, flags, msg->flags) + ctf_integer(__u16, len, msg->len) + ctf_sequence_hex(__u8, buf, + tp_locvar->extract_sensitive_payload ? + msg->buf : NULL, + __u16, + tp_locvar->extract_sensitive_payload ? + msg->len : 0) + ), + + TP_code_post() +) + +/* + * __i2c_transfer() result + */ +LTTNG_TRACEPOINT_EVENT(i2c_result, + + TP_PROTO(const struct i2c_adapter *adap, int num, int ret), + + TP_ARGS(adap, num, ret), + + TP_FIELDS( + ctf_integer(int, adapter_nr, adap->nr) + ctf_integer(__u16, nr_msgs, num) + ctf_integer(__s16, ret, ret) + ) +) + +#endif /* LTTNG_TRACE_I2C_H */ + +/* This part must be outside protection */ +#include diff --git a/include/instrumentation/events/lttng-module/irq.h b/include/instrumentation/events/lttng-module/irq.h new file mode 100644 index 00000000..3995add4 --- /dev/null +++ b/include/instrumentation/events/lttng-module/irq.h @@ -0,0 +1,126 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#undef TRACE_SYSTEM +#define TRACE_SYSTEM irq + +#if !defined(LTTNG_TRACE_IRQ_H) || defined(TRACE_HEADER_MULTI_READ) +#define LTTNG_TRACE_IRQ_H + +#include + +#ifndef _TRACE_IRQ_DEF_ +#define _TRACE_IRQ_DEF_ + +struct irqaction; +struct softirq_action; + +#endif /* _TRACE_IRQ_DEF_ */ + +/** + * irq_handler_entry - called immediately before the irq action handler + * @irq: irq number + * @action: pointer to struct irqaction + * + * The struct irqaction pointed to by @action contains various + * information about the handler, including the device name, + * @action->name, and the device id, @action->dev_id. When used in + * conjunction with the irq_handler_exit tracepoint, we can figure + * out irq handler latencies. + */ +LTTNG_TRACEPOINT_EVENT(irq_handler_entry, + + TP_PROTO(int irq, struct irqaction *action), + + TP_ARGS(irq, action), + + TP_FIELDS( + ctf_integer(int, irq, irq) + ctf_string(name, action->name) + ) +) + +/** + * irq_handler_exit - called immediately after the irq action handler returns + * @irq: irq number + * @action: pointer to struct irqaction + * @ret: return value + * + * If the @ret value is set to IRQ_HANDLED, then we know that the corresponding + * @action->handler scuccessully handled this irq. Otherwise, the irq might be + * a shared irq line, or the irq was not handled successfully. Can be used in + * conjunction with the irq_handler_entry to understand irq handler latencies. + */ +LTTNG_TRACEPOINT_EVENT(irq_handler_exit, + + TP_PROTO(int irq, struct irqaction *action, int ret), + + TP_ARGS(irq, action, ret), + + TP_FIELDS( + ctf_integer(int, irq, irq) + ctf_integer(int, ret, ret) + ) +) + +LTTNG_TRACEPOINT_EVENT_CLASS(irq_softirq, + + TP_PROTO(unsigned int vec_nr), + + TP_ARGS(vec_nr), + + TP_FIELDS( + ctf_integer(unsigned int, vec, vec_nr) + ) +) + +/** + * softirq_entry - called immediately before the softirq handler + * @vec_nr: softirq vector number + * + * When used in combination with the softirq_exit tracepoint + * we can determine the softirq handler runtine. + */ +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(irq_softirq, softirq_entry, + + irq_softirq_entry, + + TP_PROTO(unsigned int vec_nr), + + TP_ARGS(vec_nr) +) + +/** + * softirq_exit - called immediately after the softirq handler returns + * @vec_nr: softirq vector number + * + * When used in combination with the softirq_entry tracepoint + * we can determine the softirq handler runtine. + */ +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(irq_softirq, softirq_exit, + + irq_softirq_exit, + + TP_PROTO(unsigned int vec_nr), + + TP_ARGS(vec_nr) +) + +/** + * softirq_raise - called immediately when a softirq is raised + * @vec_nr: softirq vector number + * + * When used in combination with the softirq_entry tracepoint + * we can determine the softirq raise to run latency. + */ +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(irq_softirq, softirq_raise, + + irq_softirq_raise, + + TP_PROTO(unsigned int vec_nr), + + TP_ARGS(vec_nr) +) + +#endif /* LTTNG_TRACE_IRQ_H */ + +/* This part must be outside protection */ +#include diff --git a/include/instrumentation/events/lttng-module/jbd2.h b/include/instrumentation/events/lttng-module/jbd2.h new file mode 100644 index 00000000..1b0d00d3 --- /dev/null +++ b/include/instrumentation/events/lttng-module/jbd2.h @@ -0,0 +1,168 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#undef TRACE_SYSTEM +#define TRACE_SYSTEM jbd2 + +#if !defined(LTTNG_TRACE_JBD2_H) || defined(TRACE_HEADER_MULTI_READ) +#define LTTNG_TRACE_JBD2_H + +#include +#include + +#ifndef _TRACE_JBD2_DEF +#define _TRACE_JBD2_DEF +struct transaction_chp_stats_s; +struct transaction_run_stats_s; +#endif + +LTTNG_TRACEPOINT_EVENT(jbd2_checkpoint, + + TP_PROTO(journal_t *journal, int result), + + TP_ARGS(journal, result), + + TP_FIELDS( + ctf_integer(dev_t, dev, journal->j_fs_dev->bd_dev) + ctf_integer(int, result, result) + ) +) + +LTTNG_TRACEPOINT_EVENT_CLASS(jbd2_commit, + + TP_PROTO(journal_t *journal, transaction_t *commit_transaction), + + TP_ARGS(journal, commit_transaction), + + TP_FIELDS( + ctf_integer(dev_t, dev, journal->j_fs_dev->bd_dev) + ctf_integer(char, sync_commit, commit_transaction->t_synchronous_commit) + ctf_integer(int, transaction, commit_transaction->t_tid) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(jbd2_commit, jbd2_start_commit, + + TP_PROTO(journal_t *journal, transaction_t *commit_transaction), + + TP_ARGS(journal, commit_transaction) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(jbd2_commit, jbd2_commit_locking, + + TP_PROTO(journal_t *journal, transaction_t *commit_transaction), + + TP_ARGS(journal, commit_transaction) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(jbd2_commit, jbd2_commit_flushing, + + TP_PROTO(journal_t *journal, transaction_t *commit_transaction), + + TP_ARGS(journal, commit_transaction) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(jbd2_commit, jbd2_commit_logging, + + TP_PROTO(journal_t *journal, transaction_t *commit_transaction), + + TP_ARGS(journal, commit_transaction) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(jbd2_commit, jbd2_drop_transaction, + + TP_PROTO(journal_t *journal, transaction_t *commit_transaction), + + TP_ARGS(journal, commit_transaction) +) + +LTTNG_TRACEPOINT_EVENT(jbd2_end_commit, + TP_PROTO(journal_t *journal, transaction_t *commit_transaction), + + TP_ARGS(journal, commit_transaction), + + TP_FIELDS( + ctf_integer(dev_t, dev, journal->j_fs_dev->bd_dev) + ctf_integer(char, sync_commit, commit_transaction->t_synchronous_commit) + ctf_integer(int, transaction, commit_transaction->t_tid) + ctf_integer(int, head, journal->j_tail_sequence) + ) +) + +LTTNG_TRACEPOINT_EVENT(jbd2_submit_inode_data, + TP_PROTO(struct inode *inode), + + TP_ARGS(inode), + + TP_FIELDS( + ctf_integer(dev_t, dev, inode->i_sb->s_dev) + ctf_integer(ino_t, ino, inode->i_ino) + ) +) + +LTTNG_TRACEPOINT_EVENT(jbd2_run_stats, + TP_PROTO(dev_t dev, unsigned long tid, + struct transaction_run_stats_s *stats), + + TP_ARGS(dev, tid, stats), + + TP_FIELDS( + ctf_integer(dev_t, dev, dev) + ctf_integer(unsigned long, tid, tid) + ctf_integer(unsigned long, wait, stats->rs_wait) + ctf_integer(unsigned long, running, stats->rs_running) + ctf_integer(unsigned long, locked, stats->rs_locked) + ctf_integer(unsigned long, flushing, stats->rs_flushing) + ctf_integer(unsigned long, logging, stats->rs_logging) + ctf_integer(__u32, handle_count, stats->rs_handle_count) + ctf_integer(__u32, blocks, stats->rs_blocks) + ctf_integer(__u32, blocks_logged, stats->rs_blocks_logged) + ) +) + +LTTNG_TRACEPOINT_EVENT(jbd2_checkpoint_stats, + TP_PROTO(dev_t dev, unsigned long tid, + struct transaction_chp_stats_s *stats), + + TP_ARGS(dev, tid, stats), + + TP_FIELDS( + ctf_integer(dev_t, dev, dev) + ctf_integer(unsigned long, tid, tid) + ctf_integer(unsigned long, chp_time, stats->cs_chp_time) + ctf_integer(__u32, forced_to_close, stats->cs_forced_to_close) + ctf_integer(__u32, written, stats->cs_written) + ctf_integer(__u32, dropped, stats->cs_dropped) + ) +) + +LTTNG_TRACEPOINT_EVENT(jbd2_update_log_tail, + + TP_PROTO(journal_t *journal, tid_t first_tid, + unsigned long block_nr, unsigned long freed), + + TP_ARGS(journal, first_tid, block_nr, freed), + + TP_FIELDS( + ctf_integer(dev_t, dev, journal->j_fs_dev->bd_dev) + ctf_integer(tid_t, tail_sequence, journal->j_tail_sequence) + ctf_integer(tid_t, first_tid, first_tid) + ctf_integer(unsigned long, block_nr, block_nr) + ctf_integer(unsigned long, freed, freed) + ) +) + +LTTNG_TRACEPOINT_EVENT(jbd2_write_superblock, + + TP_PROTO(journal_t *journal, int write_op), + + TP_ARGS(journal, write_op), + + TP_FIELDS( + ctf_integer(dev_t, dev, journal->j_fs_dev->bd_dev) + ctf_integer(int, write_op, write_op) + ) +) + +#endif /* LTTNG_TRACE_JBD2_H */ + +/* This part must be outside protection */ +#include diff --git a/include/instrumentation/events/lttng-module/kmem.h b/include/instrumentation/events/lttng-module/kmem.h new file mode 100644 index 00000000..560b9be7 --- /dev/null +++ b/include/instrumentation/events/lttng-module/kmem.h @@ -0,0 +1,219 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#undef TRACE_SYSTEM +#define TRACE_SYSTEM kmem + +#if !defined(LTTNG_TRACE_KMEM_H) || defined(TRACE_HEADER_MULTI_READ) +#define LTTNG_TRACE_KMEM_H + +#include +#include + +LTTNG_TRACEPOINT_EVENT_CLASS(kmem_alloc, + + TP_PROTO(unsigned long call_site, + const void *ptr, + size_t bytes_req, + size_t bytes_alloc, + gfp_t gfp_flags), + + TP_ARGS(call_site, ptr, bytes_req, bytes_alloc, gfp_flags), + + TP_FIELDS( + ctf_integer_hex(unsigned long, call_site, call_site) + ctf_integer_hex(const void *, ptr, ptr) + ctf_integer(size_t, bytes_req, bytes_req) + ctf_integer(size_t, bytes_alloc, bytes_alloc) + ctf_integer(gfp_t, gfp_flags, gfp_flags) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(kmem_alloc, kmalloc, + + kmem_kmalloc, + + TP_PROTO(unsigned long call_site, const void *ptr, + size_t bytes_req, size_t bytes_alloc, gfp_t gfp_flags), + + TP_ARGS(call_site, ptr, bytes_req, bytes_alloc, gfp_flags) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(kmem_alloc, kmem_cache_alloc, + + TP_PROTO(unsigned long call_site, const void *ptr, + size_t bytes_req, size_t bytes_alloc, gfp_t gfp_flags), + + TP_ARGS(call_site, ptr, bytes_req, bytes_alloc, gfp_flags) +) + +LTTNG_TRACEPOINT_EVENT_CLASS(kmem_alloc_node, + + TP_PROTO(unsigned long call_site, + const void *ptr, + size_t bytes_req, + size_t bytes_alloc, + gfp_t gfp_flags, + int node), + + TP_ARGS(call_site, ptr, bytes_req, bytes_alloc, gfp_flags, node), + + TP_FIELDS( + ctf_integer_hex(unsigned long, call_site, call_site) + ctf_integer_hex(const void *, ptr, ptr) + ctf_integer(size_t, bytes_req, bytes_req) + ctf_integer(size_t, bytes_alloc, bytes_alloc) + ctf_integer(gfp_t, gfp_flags, gfp_flags) + ctf_integer(int, node, node) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(kmem_alloc_node, kmalloc_node, + + kmem_kmalloc_node, + + TP_PROTO(unsigned long call_site, const void *ptr, + size_t bytes_req, size_t bytes_alloc, + gfp_t gfp_flags, int node), + + TP_ARGS(call_site, ptr, bytes_req, bytes_alloc, gfp_flags, node) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(kmem_alloc_node, kmem_cache_alloc_node, + + TP_PROTO(unsigned long call_site, const void *ptr, + size_t bytes_req, size_t bytes_alloc, + gfp_t gfp_flags, int node), + + TP_ARGS(call_site, ptr, bytes_req, bytes_alloc, gfp_flags, node) +) + +LTTNG_TRACEPOINT_EVENT_CLASS(kmem_free, + + TP_PROTO(unsigned long call_site, const void *ptr), + + TP_ARGS(call_site, ptr), + + TP_FIELDS( + ctf_integer_hex(unsigned long, call_site, call_site) + ctf_integer_hex(const void *, ptr, ptr) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(kmem_free, kfree, + + kmem_kfree, + + TP_PROTO(unsigned long call_site, const void *ptr), + + TP_ARGS(call_site, ptr) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(kmem_free, kmem_cache_free, + + TP_PROTO(unsigned long call_site, const void *ptr), + + TP_ARGS(call_site, ptr) +) + +LTTNG_TRACEPOINT_EVENT_MAP(mm_page_free, kmem_mm_page_free, + + TP_PROTO(struct page *page, unsigned int order), + + TP_ARGS(page, order), + + TP_FIELDS( + ctf_integer_hex(struct page *, page, page) + ctf_integer(unsigned long, pfn, page_to_pfn(page)) + ctf_integer(unsigned int, order, order) + ) +) + +LTTNG_TRACEPOINT_EVENT_MAP(mm_page_free_batched, kmem_mm_page_free_batched, + + TP_PROTO(struct page *page), + + TP_ARGS(page), + + TP_FIELDS( + ctf_integer_hex(struct page *, page, page) + ctf_integer(unsigned long, pfn, page_to_pfn(page)) + ) +) + +LTTNG_TRACEPOINT_EVENT_MAP(mm_page_alloc, kmem_mm_page_alloc, + + TP_PROTO(struct page *page, unsigned int order, + gfp_t gfp_flags, int migratetype), + + TP_ARGS(page, order, gfp_flags, migratetype), + + TP_FIELDS( + ctf_integer_hex(struct page *, page, page) + ctf_integer(unsigned long, pfn, + page ? page_to_pfn(page) : -1UL) + ctf_integer(unsigned int, order, order) + ctf_integer(gfp_t, gfp_flags, gfp_flags) + ctf_integer(int, migratetype, migratetype) + ) +) + +LTTNG_TRACEPOINT_EVENT_CLASS(kmem_mm_page, + + TP_PROTO(struct page *page, unsigned int order, int migratetype), + + TP_ARGS(page, order, migratetype), + + TP_FIELDS( + ctf_integer_hex(struct page *, page, page) + ctf_integer(unsigned long, pfn, + page ? page_to_pfn(page) : -1UL) + ctf_integer(unsigned int, order, order) + ctf_integer(int, migratetype, migratetype) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(kmem_mm_page, mm_page_alloc_zone_locked, + + kmem_mm_page_alloc_zone_locked, + + TP_PROTO(struct page *page, unsigned int order, int migratetype), + + TP_ARGS(page, order, migratetype) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(kmem_mm_page, mm_page_pcpu_drain, + + kmem_mm_page_pcpu_drain, + + TP_PROTO(struct page *page, unsigned int order, int migratetype), + + TP_ARGS(page, order, migratetype) +) + +LTTNG_TRACEPOINT_EVENT_MAP(mm_page_alloc_extfrag, + + kmem_mm_page_alloc_extfrag, + + TP_PROTO(struct page *page, + int alloc_order, int fallback_order, + int alloc_migratetype, int fallback_migratetype), + + TP_ARGS(page, + alloc_order, fallback_order, + alloc_migratetype, fallback_migratetype), + + TP_FIELDS( + ctf_integer_hex(struct page *, page, page) + ctf_integer(unsigned long, pfn, page_to_pfn(page)) + ctf_integer(int, alloc_order, alloc_order) + ctf_integer(int, fallback_order, fallback_order) + ctf_integer(int, alloc_migratetype, alloc_migratetype) + ctf_integer(int, fallback_migratetype, fallback_migratetype) + ctf_integer(int, change_ownership, + (alloc_migratetype == get_pageblock_migratetype(page))) + ) +) + +#endif /* LTTNG_TRACE_KMEM_H */ + +/* This part must be outside protection */ +#include diff --git a/include/instrumentation/events/lttng-module/kvm.h b/include/instrumentation/events/lttng-module/kvm.h new file mode 100644 index 00000000..35b65839 --- /dev/null +++ b/include/instrumentation/events/lttng-module/kvm.h @@ -0,0 +1,185 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#if !defined(LTTNG_TRACE_KVM_MAIN_H) || defined(TRACE_HEADER_MULTI_READ) +#define LTTNG_TRACE_KVM_MAIN_H + +#include + +#undef TRACE_SYSTEM +#define TRACE_SYSTEM kvm + +LTTNG_TRACEPOINT_EVENT(kvm_userspace_exit, + TP_PROTO(__u32 reason, int errno), + TP_ARGS(reason, errno), + + TP_FIELDS( + ctf_integer(__u32, reason, reason) + ctf_integer(int, errno, errno) + ) +) + +#if defined(__KVM_HAVE_IRQ_LINE) +LTTNG_TRACEPOINT_EVENT(kvm_set_irq, + TP_PROTO(unsigned int gsi, int level, int irq_source_id), + TP_ARGS(gsi, level, irq_source_id), + + TP_FIELDS( + ctf_integer(unsigned int, gsi, gsi) + ctf_integer(int, level, level) + ctf_integer(int, irq_source_id, irq_source_id) + ) +) +#endif + +#if defined(__KVM_HAVE_IOAPIC) + +LTTNG_TRACEPOINT_EVENT(kvm_ioapic_set_irq, + TP_PROTO(__u64 e, int pin, bool coalesced), + TP_ARGS(e, pin, coalesced), + + TP_FIELDS( + ctf_integer(__u64, e, e) + ctf_integer(int, pin, pin) + ctf_integer(bool, coalesced, coalesced) + ) +) + +LTTNG_TRACEPOINT_EVENT(kvm_msi_set_irq, + TP_PROTO(__u64 address, __u64 data), + TP_ARGS(address, data), + + TP_FIELDS( + ctf_integer_hex(__u64, address, address) + ctf_integer(__u64, data, data) + ) +) + +LTTNG_TRACEPOINT_EVENT(kvm_ack_irq, + TP_PROTO(unsigned int irqchip, unsigned int pin), + TP_ARGS(irqchip, pin), + + TP_FIELDS( + ctf_integer(unsigned int, irqchip, irqchip) + ctf_integer(unsigned int, pin, pin) + ) +) + +#endif /* defined(__KVM_HAVE_IOAPIC) */ + +#define KVM_TRACE_MMIO_READ_UNSATISFIED 0 +#define KVM_TRACE_MMIO_READ 1 +#define KVM_TRACE_MMIO_WRITE 2 + +#define kvm_trace_symbol_mmio \ + { KVM_TRACE_MMIO_READ_UNSATISFIED, "unsatisfied-read" }, \ + { KVM_TRACE_MMIO_READ, "read" }, \ + { KVM_TRACE_MMIO_WRITE, "write" } + + +LTTNG_TRACEPOINT_EVENT(kvm_mmio, + TP_PROTO(int type, int len, u64 gpa, void *val), + TP_ARGS(type, len, gpa, val), + + TP_FIELDS( + ctf_integer(u32, type, type) + ctf_integer(u32, len, len) + ctf_integer(u64, gpa, gpa) + ctf_sequence_hex(unsigned char, val, val, u32, len) + ) +) + +#define kvm_fpu_load_symbol \ + {0, "unload"}, \ + {1, "load"} + +LTTNG_TRACEPOINT_EVENT(kvm_fpu, + TP_PROTO(int load), + TP_ARGS(load), + + TP_FIELDS( + ctf_integer(u32, load, load) + ) +) + +LTTNG_TRACEPOINT_EVENT(kvm_age_page, + TP_PROTO(ulong gfn, int level, struct kvm_memory_slot *slot, int ref), + TP_ARGS(gfn, level, slot, ref), + + TP_FIELDS( + ctf_integer(u64, hva, + ((gfn - slot->base_gfn) << PAGE_SHIFT) + slot->userspace_addr) + ctf_integer(u64, gfn, gfn) + ctf_integer(u8, level, level) + ctf_integer(u8, referenced, ref) + ) +) + +#ifdef CONFIG_KVM_ASYNC_PF +LTTNG_TRACEPOINT_EVENT_CLASS(kvm_async_get_page_class, + + TP_PROTO(u64 gva, u64 gfn), + + TP_ARGS(gva, gfn), + + TP_FIELDS( + ctf_integer(__u64, gva, gva) + ctf_integer(u64, gfn, gfn) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(kvm_async_get_page_class, kvm_try_async_get_page, + + TP_PROTO(u64 gva, u64 gfn), + + TP_ARGS(gva, gfn) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(kvm_async_get_page_class, kvm_async_pf_doublefault, + + TP_PROTO(u64 gva, u64 gfn), + + TP_ARGS(gva, gfn) +) + +LTTNG_TRACEPOINT_EVENT_CLASS(kvm_async_pf_nopresent_ready, + + TP_PROTO(u64 token, u64 gva), + + TP_ARGS(token, gva), + + TP_FIELDS( + ctf_integer(__u64, token, token) + ctf_integer(__u64, gva, gva) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(kvm_async_pf_nopresent_ready, kvm_async_pf_not_present, + + TP_PROTO(u64 token, u64 gva), + + TP_ARGS(token, gva) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(kvm_async_pf_nopresent_ready, kvm_async_pf_ready, + + TP_PROTO(u64 token, u64 gva), + + TP_ARGS(token, gva) +) + +LTTNG_TRACEPOINT_EVENT( + kvm_async_pf_completed, + TP_PROTO(unsigned long address, u64 gva), + TP_ARGS(address, gva), + + TP_FIELDS( + ctf_integer_hex(unsigned long, address, address) + ctf_integer(u64, gva, gva) + ) +) + +#endif + +#endif /* LTTNG_TRACE_KVM_MAIN_H */ + +/* This part must be outside protection */ +#include diff --git a/include/instrumentation/events/lttng-module/lock.h b/include/instrumentation/events/lttng-module/lock.h new file mode 100644 index 00000000..5f0f09da --- /dev/null +++ b/include/instrumentation/events/lttng-module/lock.h @@ -0,0 +1,71 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ + +#undef TRACE_SYSTEM +#define TRACE_SYSTEM lock + +#if !defined(LTTNG_TRACE_LOCK_H) || defined(TRACE_HEADER_MULTI_READ) +#define LTTNG_TRACE_LOCK_H + +#include +#include + +#ifdef CONFIG_LOCKDEP + +LTTNG_TRACEPOINT_EVENT(lock_acquire, + + TP_PROTO(struct lockdep_map *lock, unsigned int subclass, + int trylock, int read, int check, + struct lockdep_map *next_lock, unsigned long ip), + + TP_ARGS(lock, subclass, trylock, read, check, next_lock, ip), + + TP_FIELDS( + ctf_integer(unsigned int, flags, (trylock ? 1 : 0) | (read ? 2 : 0)) + ctf_string(name, lock->name) + ctf_integer_hex(void *, lockdep_addr, lock) + ) +) + +LTTNG_TRACEPOINT_EVENT_CLASS(lock, + + TP_PROTO(struct lockdep_map *lock, unsigned long ip), + + TP_ARGS(lock, ip), + + TP_FIELDS( + ctf_string(name, lock->name) + ctf_integer_hex(void *, lockdep_addr, lock) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(lock, lock_release, + + TP_PROTO(struct lockdep_map *lock, unsigned long ip), + + TP_ARGS(lock, ip) +) + +#ifdef CONFIG_LOCK_STAT + +LTTNG_TRACEPOINT_EVENT_INSTANCE(lock, lock_contended, + + TP_PROTO(struct lockdep_map *lock, unsigned long ip), + + TP_ARGS(lock, ip) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(lock, lock_acquired, + + TP_PROTO(struct lockdep_map *lock, unsigned long ip), + + TP_ARGS(lock, ip) +) + +#endif /* CONFIG_LOCK_STAT */ + +#endif /* CONFIG_LOCKDEP */ + +#endif /* LTTNG_TRACE_LOCK_H */ + +/* This part must be outside protection */ +#include diff --git a/include/instrumentation/events/lttng-module/lttng-statedump.h b/include/instrumentation/events/lttng-module/lttng-statedump.h new file mode 100644 index 00000000..ee3a841e --- /dev/null +++ b/include/instrumentation/events/lttng-module/lttng-statedump.h @@ -0,0 +1,253 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#undef TRACE_SYSTEM +#define TRACE_SYSTEM lttng_statedump + +#if !defined(LTTNG_TRACE_LTTNG_STATEDUMP_H) || defined(TRACE_HEADER_MULTI_READ) +#define LTTNG_TRACE_LTTNG_STATEDUMP_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifndef LTTNG_MNT_NS_MISSING_HEADER +# ifndef ONCE_LTTNG_FS_MOUNT_H +# define ONCE_LTTNG_FS_MOUNT_H +# include <../fs/mount.h> +# endif +#endif + +LTTNG_TRACEPOINT_EVENT(lttng_statedump_start, + TP_PROTO(struct lttng_session *session), + TP_ARGS(session), + TP_FIELDS() +) + +LTTNG_TRACEPOINT_EVENT(lttng_statedump_end, + TP_PROTO(struct lttng_session *session), + TP_ARGS(session), + TP_FIELDS() +) + +LTTNG_TRACEPOINT_EVENT(lttng_statedump_process_state, + TP_PROTO(struct lttng_session *session, + struct task_struct *p, + int type, int mode, int submode, int status, + struct files_struct *files), + TP_ARGS(session, p, type, mode, submode, status, files), + TP_FIELDS( + ctf_integer(pid_t, tid, p->pid) + ctf_integer(pid_t, pid, p->tgid) + ctf_integer(pid_t, ppid, + ({ + pid_t ret; + + rcu_read_lock(); + ret = task_tgid_nr(p->real_parent); + rcu_read_unlock(); + ret; + })) + ctf_array_text(char, name, p->comm, TASK_COMM_LEN) + ctf_integer(int, type, type) + ctf_integer(int, mode, mode) + ctf_integer(int, submode, submode) + ctf_integer(int, status, status) + ctf_integer(unsigned int, cpu, task_cpu(p)) + ctf_integer_hex(struct files_struct *, file_table_address, files) + ) +) + +LTTNG_TRACEPOINT_EVENT(lttng_statedump_process_cgroup_ns, + TP_PROTO(struct lttng_session *session, + struct task_struct *p, + struct cgroup_namespace *cgroup_ns), + TP_ARGS(session, p, cgroup_ns), + TP_FIELDS( + ctf_integer(pid_t, tid, p->pid) + ctf_integer(unsigned int, ns_inum, cgroup_ns ? cgroup_ns->ns.inum : 0) + ) +) + +LTTNG_TRACEPOINT_EVENT(lttng_statedump_process_ipc_ns, + TP_PROTO(struct lttng_session *session, + struct task_struct *p, + struct ipc_namespace *ipc_ns), + TP_ARGS(session, p, ipc_ns), + TP_FIELDS( + ctf_integer(pid_t, tid, p->pid) + ctf_integer(unsigned int, ns_inum, ipc_ns ? ipc_ns->ns.inum : 0) + ) +) + +#if !defined(LTTNG_MNT_NS_MISSING_HEADER) +LTTNG_TRACEPOINT_EVENT(lttng_statedump_process_mnt_ns, + TP_PROTO(struct lttng_session *session, + struct task_struct *p, + struct mnt_namespace *mnt_ns), + TP_ARGS(session, p, mnt_ns), + TP_FIELDS( + ctf_integer(pid_t, tid, p->pid) + ctf_integer(unsigned int, ns_inum, mnt_ns ? mnt_ns->ns.inum : 0) + ) +) +#endif + +LTTNG_TRACEPOINT_EVENT(lttng_statedump_process_net_ns, + TP_PROTO(struct lttng_session *session, + struct task_struct *p, + struct net *net_ns), + TP_ARGS(session, p, net_ns), + TP_FIELDS( + ctf_integer(pid_t, tid, p->pid) + ctf_integer(unsigned int, ns_inum, net_ns ? net_ns->ns.inum : 0) + ) +) + +LTTNG_TRACEPOINT_EVENT(lttng_statedump_process_pid_ns, + TP_PROTO(struct lttng_session *session, + struct task_struct *p, + struct pid_namespace *pid_ns), + TP_ARGS(session, p, pid_ns), + TP_FIELDS( + ctf_integer(pid_t, tid, p->pid) + ctf_integer(pid_t, vtid, pid_ns ? task_pid_nr_ns(p, pid_ns) : 0) + ctf_integer(pid_t, vpid, pid_ns ? task_tgid_nr_ns(p, pid_ns) : 0) + ctf_integer(pid_t, vppid, + ({ + struct task_struct *parent; + pid_t ret = 0; + + if (pid_ns) { + rcu_read_lock(); + parent = rcu_dereference(p->real_parent); + ret = task_tgid_nr_ns(parent, pid_ns); + rcu_read_unlock(); + } + ret; + })) + ctf_integer(int, ns_level, pid_ns ? pid_ns->level : 0) + ctf_integer(unsigned int, ns_inum, pid_ns ? pid_ns->ns.inum : 0) + ) +) + +LTTNG_TRACEPOINT_EVENT(lttng_statedump_process_user_ns, + TP_PROTO(struct lttng_session *session, + struct task_struct *p, + struct user_namespace *user_ns), + TP_ARGS(session, p, user_ns), + TP_FIELDS( + ctf_integer(pid_t, tid, p->pid) + ctf_integer(uid_t, vuid, user_ns ? lttng_task_vuid(p, user_ns) : 0) + ctf_integer(gid_t, vgid, user_ns ? lttng_task_vgid(p, user_ns) : 0) + ctf_integer(int, ns_level, user_ns ? user_ns->level : 0) + ctf_integer(unsigned int, ns_inum, user_ns ? user_ns->ns.inum : 0) + ) +) + +LTTNG_TRACEPOINT_EVENT(lttng_statedump_process_uts_ns, + TP_PROTO(struct lttng_session *session, + struct task_struct *p, + struct uts_namespace *uts_ns), + TP_ARGS(session, p, uts_ns), + TP_FIELDS( + ctf_integer(pid_t, tid, p->pid) + ctf_integer(unsigned int, ns_inum, uts_ns ? uts_ns->ns.inum : 0) + ) +) + +LTTNG_TRACEPOINT_EVENT(lttng_statedump_file_descriptor, + TP_PROTO(struct lttng_session *session, + struct files_struct *files, + int fd, const char *filename, + unsigned int flags, fmode_t fmode), + TP_ARGS(session, files, fd, filename, flags, fmode), + TP_FIELDS( + ctf_integer_hex(struct files_struct *, file_table_address, files) + ctf_integer(int, fd, fd) + ctf_integer_oct(unsigned int, flags, flags) + ctf_integer_hex(fmode_t, fmode, fmode) + ctf_string(filename, filename) + ) +) + +LTTNG_TRACEPOINT_EVENT(lttng_statedump_vm_map, + TP_PROTO(struct lttng_session *session, + struct task_struct *p, struct vm_area_struct *map, + unsigned long inode), + TP_ARGS(session, p, map, inode), + TP_FIELDS( + ctf_integer(pid_t, pid, p->tgid) + ctf_integer_hex(unsigned long, start, map->vm_start) + ctf_integer_hex(unsigned long, end, map->vm_end) + ctf_integer_hex(unsigned long, flags, map->vm_flags) + ctf_integer(unsigned long, inode, inode) + ctf_integer(unsigned long, pgoff, map->vm_pgoff << PAGE_SHIFT) + ) +) + +LTTNG_TRACEPOINT_EVENT(lttng_statedump_network_interface, + TP_PROTO(struct lttng_session *session, + struct net_device *dev, struct in_ifaddr *ifa), + TP_ARGS(session, dev, ifa), + TP_FIELDS( + ctf_string(name, dev->name) + ctf_integer_network_hex(uint32_t, address_ipv4, + ifa ? ifa->ifa_address : 0U) + ) +) + +LTTNG_TRACEPOINT_EVENT(lttng_statedump_block_device, + TP_PROTO(struct lttng_session *session, + dev_t dev, const char *diskname), + TP_ARGS(session, dev, diskname), + TP_FIELDS( + ctf_integer(dev_t, dev, dev) + ctf_string(diskname, diskname) + ) +) + +/* Called with desc->lock held */ +LTTNG_TRACEPOINT_EVENT(lttng_statedump_interrupt, + TP_PROTO(struct lttng_session *session, + unsigned int irq, const char *chip_name, + struct irqaction *action), + TP_ARGS(session, irq, chip_name, action), + TP_FIELDS( + ctf_integer(unsigned int, irq, irq) + ctf_string(name, chip_name) + ctf_string(action, action->name ? : "") + ctf_integer(pid_t, tid, action->thread ? action->thread->pid : 0) + ) +) + +#if defined(CONFIG_X86_32) || defined(CONFIG_X86_64) + +#define LTTNG_HAVE_STATEDUMP_CPU_TOPOLOGY + +LTTNG_TRACEPOINT_EVENT(lttng_statedump_cpu_topology, + TP_PROTO(struct lttng_session *session, struct cpuinfo_x86 *c), + TP_ARGS(session, c), + TP_FIELDS( + ctf_string(architecture, "x86") + ctf_integer(uint16_t, cpu_id, c->cpu_index) + ctf_string(vendor, c->x86_vendor_id[0] ? c->x86_vendor_id : "unknown") + ctf_integer(uint8_t, family, c->x86) + ctf_integer(uint8_t, model, c->x86_model) + ctf_string(model_name, c->x86_model_id[0] ? c->x86_model_id : "unknown") + ctf_integer(uint16_t, physical_id, c->phys_proc_id) + ctf_integer(uint16_t, core_id, c->cpu_core_id) + ctf_integer(uint16_t, cores, c->booted_cores) + ) +) +#endif /* CONFIG_X86_32 || CONFIG_X86_64 */ + +#endif /* LTTNG_TRACE_LTTNG_STATEDUMP_H */ + +/* This part must be outside protection */ +#include diff --git a/include/instrumentation/events/lttng-module/lttng-test.h b/include/instrumentation/events/lttng-module/lttng-test.h new file mode 100644 index 00000000..ad4b1779 --- /dev/null +++ b/include/instrumentation/events/lttng-module/lttng-test.h @@ -0,0 +1,57 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#undef TRACE_SYSTEM +#define TRACE_SYSTEM lttng_test + +#if !defined(LTTNG_TRACE_LTTNG_TEST_H) || defined(TRACE_HEADER_MULTI_READ) +#define LTTNG_TRACE_LTTNG_TEST_H + +#include +#include + +LTTNG_TRACEPOINT_ENUM( + lttng_test_filter_event_enum, + TP_ENUM_VALUES( + ctf_enum_auto("AUTO: EXPECT 0") + ctf_enum_value("VALUE: 23", 23) + ctf_enum_value("VALUE: 27", 27) + ctf_enum_auto("AUTO: EXPECT 28") + ctf_enum_range("RANGE: 101 TO 303", 101, 303) + ctf_enum_auto("AUTO: EXPECT 304") + ) +) + +LTTNG_TRACEPOINT_EVENT(lttng_test_filter_event, + TP_PROTO(int anint, int netint, long *values, + char *text, size_t textlen, + char *etext, uint32_t * net_values), + TP_ARGS(anint, netint, values, text, textlen, etext, net_values), + TP_FIELDS( + ctf_integer(int, intfield, anint) + ctf_integer_hex(int, intfield2, anint) + ctf_integer(long, longfield, anint) + ctf_integer_network(int, netintfield, netint) + ctf_integer_network_hex(int, netintfieldhex, netint) + ctf_array(long, arrfield1, values, 3) + ctf_array_text(char, arrfield2, text, 10) + ctf_array_network(uint32_t, arrfield3, net_values, 3) + ctf_sequence(char, seqfield1, text, size_t, textlen) + ctf_sequence_text(char, seqfield2, text, size_t, textlen) + ctf_sequence_network(uint32_t, seqfield3, net_values, size_t, 3) + ctf_sequence(long, seqfield4, values, size_t, 3) + ctf_string(stringfield, text) + ctf_string(stringfield2, etext) + ctf_sequence_bitfield(long, bitfield_seq, values, uint8_t, 3) + ctf_array_bitfield(long, bitfield_array, values, 3) + ctf_enum(lttng_test_filter_event_enum, int, enum0, 0) + ctf_enum(lttng_test_filter_event_enum, int, enum23, 23) + ctf_enum(lttng_test_filter_event_enum, int, enum27, 27) + ctf_enum(lttng_test_filter_event_enum, int, enum28, 28) + ctf_enum(lttng_test_filter_event_enum, int, enum202, 202) + ctf_enum(lttng_test_filter_event_enum, int, enum304, 304) + ) +) + +#endif /* LTTNG_TRACE_LTTNG_TEST_H */ + +/* This part must be outside protection */ +#include diff --git a/include/instrumentation/events/lttng-module/lttng.h b/include/instrumentation/events/lttng-module/lttng.h new file mode 100644 index 00000000..50a3d693 --- /dev/null +++ b/include/instrumentation/events/lttng-module/lttng.h @@ -0,0 +1,21 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#undef TRACE_SYSTEM +#define TRACE_SYSTEM lttng + +#if !defined(LTTNG_TRACE_LTTNG_H) || defined(TRACE_HEADER_MULTI_READ) +#define LTTNG_TRACE_LTTNG_H + +#include + +LTTNG_TRACEPOINT_EVENT(lttng_logger, + TP_PROTO(const char __user *text, size_t len), + TP_ARGS(text, len), + TP_FIELDS( + ctf_user_sequence_text(char, msg, text, size_t, len) + ) +) + +#endif /* LTTNG_TRACE_LTTNG_H */ + +/* This part must be outside protection */ +#include diff --git a/include/instrumentation/events/lttng-module/mm_vmscan.h b/include/instrumentation/events/lttng-module/mm_vmscan.h new file mode 100644 index 00000000..c0a259b4 --- /dev/null +++ b/include/instrumentation/events/lttng-module/mm_vmscan.h @@ -0,0 +1,247 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#undef TRACE_SYSTEM +#define TRACE_SYSTEM mm_vmscan + +#if !defined(LTTNG_TRACE_MM_VMSCAN_H) || defined(TRACE_HEADER_MULTI_READ) +#define LTTNG_TRACE_MM_VMSCAN_H + +#include +#include +#include +#include + +#ifndef _TRACE_VMSCAN_DEF +#define _TRACE_VMSCAN_DEF +#define RECLAIM_WB_ANON 0x0001u +#define RECLAIM_WB_FILE 0x0002u +#define RECLAIM_WB_MIXED 0x0010u +#define RECLAIM_WB_SYNC 0x0004u /* Unused, all reclaim async */ +#define RECLAIM_WB_ASYNC 0x0008u +#endif + +#include + +#define trace_reclaim_flags(file) ( \ + (file ? RECLAIM_WB_FILE : RECLAIM_WB_ANON) | \ + (RECLAIM_WB_ASYNC) \ + ) + +LTTNG_TRACEPOINT_EVENT(mm_vmscan_kswapd_sleep, + + TP_PROTO(int nid), + + TP_ARGS(nid), + + TP_FIELDS( + ctf_integer(int, nid, nid) + ) +) + +LTTNG_TRACEPOINT_EVENT(mm_vmscan_kswapd_wake, + + TP_PROTO(int nid, int zid, int order), + + TP_ARGS(nid, zid, order), + + TP_FIELDS( + ctf_integer(int, nid, nid) + ctf_integer(int, zid, zid) + ctf_integer(int, order, order) + ) +) + +LTTNG_TRACEPOINT_EVENT(mm_vmscan_wakeup_kswapd, + + TP_PROTO(int nid, int zid, int order, gfp_t gfp_flags), + + TP_ARGS(nid, zid, order, gfp_flags), + + TP_FIELDS( + ctf_integer(int, nid, nid) + ctf_integer(int, zid, zid) + ctf_integer(int, order, order) + ctf_integer(gfp_t, gfp_flags, gfp_flags) + ) +) + +LTTNG_TRACEPOINT_EVENT_CLASS(mm_vmscan_direct_reclaim_begin_template, + + TP_PROTO(int order, gfp_t gfp_flags), + + TP_ARGS(order, gfp_flags), + + TP_FIELDS( + ctf_integer(int, order, order) + ctf_integer(gfp_t, gfp_flags, gfp_flags) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(mm_vmscan_direct_reclaim_begin_template, mm_vmscan_direct_reclaim_begin, + + TP_PROTO(int order, gfp_t gfp_flags), + + TP_ARGS(order, gfp_flags) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(mm_vmscan_direct_reclaim_begin_template, mm_vmscan_memcg_reclaim_begin, + + TP_PROTO(int order, gfp_t gfp_flags), + + TP_ARGS(order, gfp_flags) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(mm_vmscan_direct_reclaim_begin_template, mm_vmscan_memcg_softlimit_reclaim_begin, + + TP_PROTO(int order, gfp_t gfp_flags), + + TP_ARGS(order, gfp_flags) +) + +LTTNG_TRACEPOINT_EVENT_CLASS(mm_vmscan_direct_reclaim_end_template, + + TP_PROTO(unsigned long nr_reclaimed), + + TP_ARGS(nr_reclaimed), + + TP_FIELDS( + ctf_integer(unsigned long, nr_reclaimed, nr_reclaimed) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(mm_vmscan_direct_reclaim_end_template, mm_vmscan_direct_reclaim_end, + + TP_PROTO(unsigned long nr_reclaimed), + + TP_ARGS(nr_reclaimed) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(mm_vmscan_direct_reclaim_end_template, mm_vmscan_memcg_reclaim_end, + + TP_PROTO(unsigned long nr_reclaimed), + + TP_ARGS(nr_reclaimed) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(mm_vmscan_direct_reclaim_end_template, mm_vmscan_memcg_softlimit_reclaim_end, + + TP_PROTO(unsigned long nr_reclaimed), + + TP_ARGS(nr_reclaimed) +) + +LTTNG_TRACEPOINT_EVENT_MAP(mm_shrink_slab_start, + + mm_vmscan_shrink_slab_start, + + TP_PROTO(struct shrinker *shr, struct shrink_control *sc, + long nr_objects_to_shrink, unsigned long cache_items, + unsigned long long delta, unsigned long total_scan, + int priority), + + TP_ARGS(shr, sc, nr_objects_to_shrink, cache_items, delta, total_scan, + priority), + + TP_FIELDS( + ctf_integer_hex(struct shrinker *, shr, shr) + ctf_integer_hex(void *, shrink, shr->scan_objects) + ctf_integer(int, nid, sc->nid) + ctf_integer(long, nr_objects_to_shrink, nr_objects_to_shrink) + ctf_integer(gfp_t, gfp_flags, sc->gfp_mask) + ctf_integer(unsigned long, cache_items, cache_items) + ctf_integer(unsigned long long, delta, delta) + ctf_integer(unsigned long, total_scan, total_scan) + ctf_integer(int, priority, priority) + ) +) + +LTTNG_TRACEPOINT_EVENT_MAP(mm_shrink_slab_end, + + mm_vmscan_shrink_slab_end, + + TP_PROTO(struct shrinker *shr, int nid, int shrinker_retval, + long unused_scan_cnt, long new_scan_cnt, long total_scan), + + TP_ARGS(shr, nid, shrinker_retval, unused_scan_cnt, new_scan_cnt, + total_scan), + + TP_FIELDS( + ctf_integer_hex(struct shrinker *, shr, shr) + ctf_integer(int, nid, nid) + ctf_integer_hex(void *, shrink, shr->scan_objects) + ctf_integer(long, unused_scan, unused_scan_cnt) + ctf_integer(long, new_scan, new_scan_cnt) + ctf_integer(int, retval, shrinker_retval) + ctf_integer(long, total_scan, total_scan) + ) +) + +LTTNG_TRACEPOINT_EVENT(mm_vmscan_lru_isolate, + + TP_PROTO(int classzone_idx, + int order, + unsigned long nr_requested, + unsigned long nr_scanned, + unsigned long nr_skipped, + unsigned long nr_taken, + isolate_mode_t isolate_mode, + int lru + ), + + TP_ARGS(classzone_idx, order, nr_requested, nr_scanned, nr_skipped, + nr_taken, isolate_mode, lru + ), + + TP_FIELDS( + ctf_integer(int, classzone_idx, classzone_idx) + ctf_integer(int, order, order) + ctf_integer(unsigned long, nr_requested, nr_requested) + ctf_integer(unsigned long, nr_scanned, nr_scanned) + ctf_integer(unsigned long, nr_skipped, nr_skipped) + ctf_integer(unsigned long, nr_taken, nr_taken) + ctf_integer(isolate_mode_t, isolate_mode, isolate_mode) + ctf_integer(int, lru, lru) + ) +) + +LTTNG_TRACEPOINT_EVENT(mm_vmscan_writepage, + + TP_PROTO(struct page *page), + + TP_ARGS(page), + + TP_FIELDS( + ctf_integer_hex(struct page *, page, page) + ctf_integer(int, reclaim_flags, trace_reclaim_flags( + page_is_file_lru(page))) + ) +) + +LTTNG_TRACEPOINT_EVENT(mm_vmscan_lru_shrink_inactive, + + TP_PROTO(int nid, + unsigned long nr_scanned, unsigned long nr_reclaimed, + struct reclaim_stat *stat, int priority, int file), + + TP_ARGS(nid, nr_scanned, nr_reclaimed, stat, priority, file), + + TP_FIELDS( + ctf_integer(int, nid, nid) + ctf_integer(unsigned long, nr_scanned, nr_scanned) + ctf_integer(unsigned long, nr_reclaimed, nr_reclaimed) + ctf_integer(unsigned long, nr_dirty, stat->nr_dirty) + ctf_integer(unsigned long, nr_writeback, stat->nr_writeback) + ctf_integer(unsigned long, nr_congested, stat->nr_congested) + ctf_integer(unsigned long, nr_immediate, stat->nr_immediate) + ctf_integer(unsigned long, nr_activate_anon, stat->nr_activate[0]) + ctf_integer(unsigned long, nr_activate_file, stat->nr_activate[1]) + ctf_integer(unsigned long, nr_ref_keep, stat->nr_ref_keep) + ctf_integer(unsigned long, nr_unmap_fail, stat->nr_unmap_fail) + ctf_integer(int, priority, priority) + ctf_integer(int, reclaim_flags, trace_reclaim_flags(file)) + ) +) + +#endif /* LTTNG_TRACE_MM_VMSCAN_H */ + +/* This part must be outside protection */ +#include diff --git a/include/instrumentation/events/lttng-module/module.h b/include/instrumentation/events/lttng-module/module.h new file mode 100644 index 00000000..04baeae0 --- /dev/null +++ b/include/instrumentation/events/lttng-module/module.h @@ -0,0 +1,100 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * Because linux/module.h has tracepoints in the header, and ftrace.h + * eventually includes this file, define_trace.h includes linux/module.h + * But we do not want the module.h to override the TRACE_SYSTEM macro + * variable that define_trace.h is processing, so we only set it + * when module events are being processed, which would happen when + * CREATE_TRACE_POINTS is defined. + */ +#ifdef CREATE_TRACE_POINTS +#undef TRACE_SYSTEM +#define TRACE_SYSTEM module +#endif + +#if !defined(LTTNG_TRACE_MODULE_H) || defined(TRACE_HEADER_MULTI_READ) +#define LTTNG_TRACE_MODULE_H + +#include + +#ifdef CONFIG_MODULES + +#ifndef _TRACE_MODULE_DEF +#define _TRACE_MODULE_DEF +struct module; + +#endif + +LTTNG_TRACEPOINT_EVENT(module_load, + + TP_PROTO(struct module *mod), + + TP_ARGS(mod), + + TP_FIELDS( + ctf_integer(unsigned int, taints, mod->taints) + ctf_string(name, mod->name) + ) +) + +LTTNG_TRACEPOINT_EVENT(module_free, + + TP_PROTO(struct module *mod), + + TP_ARGS(mod), + + TP_FIELDS( + ctf_string(name, mod->name) + ) +) + +#ifdef CONFIG_MODULE_UNLOAD +/* trace_module_get/put are only used if CONFIG_MODULE_UNLOAD is defined */ + +LTTNG_TRACEPOINT_EVENT_CLASS(module_refcnt, + + TP_PROTO(struct module *mod, unsigned long ip), + + TP_ARGS(mod, ip), + + TP_FIELDS( + ctf_integer_hex(unsigned long, ip, ip) + ctf_integer(int, refcnt, atomic_read(&mod->refcnt)) + ctf_string(name, mod->name) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(module_refcnt, module_get, + + TP_PROTO(struct module *mod, unsigned long ip), + + TP_ARGS(mod, ip) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(module_refcnt, module_put, + + TP_PROTO(struct module *mod, unsigned long ip), + + TP_ARGS(mod, ip) +) +#endif /* CONFIG_MODULE_UNLOAD */ + +LTTNG_TRACEPOINT_EVENT(module_request, + + TP_PROTO(char *name, bool wait, unsigned long ip), + + TP_ARGS(name, wait, ip), + + TP_FIELDS( + ctf_integer_hex(unsigned long, ip, ip) + ctf_integer(bool, wait, wait) + ctf_string(name, name) + ) +) + +#endif /* CONFIG_MODULES */ + +#endif /* LTTNG_TRACE_MODULE_H */ + +/* This part must be outside protection */ +#include diff --git a/include/instrumentation/events/lttng-module/napi.h b/include/instrumentation/events/lttng-module/napi.h new file mode 100644 index 00000000..a7415206 --- /dev/null +++ b/include/instrumentation/events/lttng-module/napi.h @@ -0,0 +1,33 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#undef TRACE_SYSTEM +#define TRACE_SYSTEM napi + +#if !defined(LTTNG_TRACE_NAPI_H) || defined(TRACE_HEADER_MULTI_READ) +#define LTTNG_TRACE_NAPI_H + +#include +#include +#include + +#define NO_DEV "(no_device)" + +LTTNG_TRACEPOINT_EVENT(napi_poll, + + TP_PROTO(struct napi_struct *napi, int work, int budget), + + TP_ARGS(napi, work, budget), + + TP_FIELDS( + ctf_integer_hex(struct napi_struct *, napi, napi) + ctf_string(dev_name, napi->dev ? napi->dev->name : NO_DEV) + ctf_integer(int, work, work) + ctf_integer(int, budget, budget) + ) +) + +#undef NO_DEV + +#endif /* LTTNG_TRACE_NAPI_H */ + +/* This part must be outside protection */ +#include diff --git a/include/instrumentation/events/lttng-module/net.h b/include/instrumentation/events/lttng-module/net.h new file mode 100644 index 00000000..4d0cbf1e --- /dev/null +++ b/include/instrumentation/events/lttng-module/net.h @@ -0,0 +1,858 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#undef TRACE_SYSTEM +#define TRACE_SYSTEM net + +#if !defined(LTTNG_TRACE_NET_H) || defined(TRACE_HEADER_MULTI_READ) +#define LTTNG_TRACE_NET_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifndef ONCE_LTTNG_NET_H +#define ONCE_LTTNG_NET_H + +static inline unsigned char __has_network_hdr(struct sk_buff *skb) +{ + /* + * If the header is not set yet, the network header will point + * to the head. + */ + return skb_network_header(skb) != skb->head; +} + +static struct lttng_event_field emptyfields[] = { +}; + +/* Structures for transport headers. */ + +static struct lttng_event_field tcpfields[] = { + [0] = { + .name = "source_port", + .type = __type_integer(uint16_t, 0, 0, 0, + __BIG_ENDIAN, 10, none), + }, + [1] = { + .name = "dest_port", + .type = __type_integer(uint16_t, 0, 0, 0, + __BIG_ENDIAN, 10, none), + }, + [2] = { + .name = "seq", + .type = __type_integer(uint32_t, 0, 0, 0, + __BIG_ENDIAN, 10, none), + }, + [3] = { + .name = "ack_seq", + .type = __type_integer(uint32_t, 0, 0, 0, + __BIG_ENDIAN, 10, none), + }, + [4] = { + .name = "data_offset", + .type = __type_integer(uint8_t, 4, 4, 0, + __BIG_ENDIAN, 10, none), + }, + [5] = { + .name = "reserved", + .type = __type_integer(uint8_t, 3, 1, 0, + __BIG_ENDIAN, 10, none), + }, + [6] = { + .name = "flags", + .type = __type_integer(uint8_t, 9, 1, 0, + __BIG_ENDIAN, 16, none), + }, + [7] = { + .name = "window_size", + .type = __type_integer(uint16_t, 0, 0, 0, + __BIG_ENDIAN, 10, none), + }, + [8] = { + .name = "checksum", + .type = __type_integer(uint16_t, 0, 0, 0, + __BIG_ENDIAN, 16, none), + }, + [9] = { + .name = "urg_ptr", + .type = __type_integer(uint16_t, 0, 0, 0, + __BIG_ENDIAN, 10, none), + }, +}; + +static struct lttng_event_field udpfields[] = { + [0] = { + .name = "source_port", + .type = __type_integer(uint16_t, 0, 0, 0, + __BIG_ENDIAN, 10, none), + }, + [1] = { + .name = "dest_port", + .type = __type_integer(uint16_t, 0, 0, 0, + __BIG_ENDIAN, 10, none), + }, + [2] = { + .name = "len", + .type = __type_integer(uint16_t, 0, 0, 0, + __BIG_ENDIAN, 10, none), + }, + [3] = { + .name = "check", + .type = __type_integer(uint16_t, 0, 0, 0, + __BIG_ENDIAN, 10, none), + }, +}; + +static struct lttng_event_field icmpfields[] = { + [0] = { + .name = "type", + .type = __type_integer(uint8_t, 0, 0, 0, + __BIG_ENDIAN, 10, none), + }, + [1] = { + .name = "code", + .type = __type_integer(uint8_t, 0, 0, 0, + __BIG_ENDIAN, 10, none), + }, + [2] = { + .name = "checksum", + .type = __type_integer(uint16_t, 0, 0, 0, + __BIG_ENDIAN, 10, none), + }, + [3] = { + .name = "gateway", + .type = __type_integer(uint32_t, 0, 0, 0, + __BIG_ENDIAN, 10, none), + }, +}; + + +static struct lttng_event_field transport_fields[] = { + [0] = { + .name = "unknown", + .type = { + .atype = atype_struct_nestable, + .u.struct_nestable.nr_fields = ARRAY_SIZE(emptyfields), + .u.struct_nestable.fields = emptyfields, + .u.struct_nestable.alignment = 0, + }, + .nofilter = 1, + }, + [1] = { + .name = "tcp", + .type = { + .atype = atype_struct_nestable, + .u.struct_nestable.nr_fields = ARRAY_SIZE(tcpfields), + .u.struct_nestable.fields = tcpfields, + .u.struct_nestable.alignment = 0, + }, + .nofilter = 1, + }, + [2] = { + .name = "udp", + .type = { + .atype = atype_struct_nestable, + .u.struct_nestable.nr_fields = ARRAY_SIZE(udpfields), + .u.struct_nestable.fields = udpfields, + .u.struct_nestable.alignment = 0, + }, + .nofilter = 1, + }, + [3] = { + .name = "icmp", + .type = { + .atype = atype_struct_nestable, + .u.struct_nestable.nr_fields = ARRAY_SIZE(icmpfields), + .u.struct_nestable.fields = icmpfields, + .u.struct_nestable.alignment = 0, + }, + .nofilter = 1, + }, +}; + +enum transport_header_types { + TH_NONE = 0, + TH_TCP = 1, + TH_UDP = 2, + TH_ICMP = 3, +}; + +static inline enum transport_header_types __get_transport_header_type_ip(struct sk_buff *skb) +{ + switch (ip_hdr(skb)->protocol) { + case IPPROTO_TCP: + return TH_TCP; + case IPPROTO_UDP: + return TH_UDP; + case IPPROTO_ICMP: + return TH_ICMP; + } + return TH_NONE; +} + +static inline enum transport_header_types __get_transport_header_type_ipv6(struct sk_buff *skb) +{ + switch (ipv6_hdr(skb)->nexthdr) { + case IPPROTO_TCP: + return TH_TCP; + case IPPROTO_UDP: + return TH_UDP; + case IPPROTO_ICMP: + return TH_ICMP; + } + return TH_NONE; +} + +static inline enum transport_header_types __get_transport_header_type(struct sk_buff *skb) +{ + if (__has_network_hdr(skb)) { + /* + * When both transport and network headers are set, + * transport header is greater than network header, + * otherwise it points to head. + */ + if (skb->transport_header > skb->network_header) { + /* + * Get the transport protocol from the network + * header's data. This method works both for + * sent and received packets. + */ + if (skb->protocol == htons(ETH_P_IP)) { + return __get_transport_header_type_ip(skb); + } else if(skb->protocol == htons(ETH_P_IPV6)) { + return __get_transport_header_type_ipv6(skb); + } + } + /* Fallthrough for other cases where header is not recognized. */ + } + return TH_NONE; +} + +static struct lttng_enum_entry proto_transport_enum_entries[] = { + [0] = { + .start = { .value = 0, .signedness = 0, }, + .end = { .value = IPPROTO_ICMP - 1, .signedness = 0, }, + .string = "_unknown", + }, + [1] = { + .start = { .value = IPPROTO_ICMP, .signedness = 0, }, + .end = { .value = IPPROTO_ICMP, .signedness = 0, }, + .string = "_icmp", + }, + [2] = { + .start = { .value = IPPROTO_ICMP + 1, .signedness = 0, }, + .end = { .value = IPPROTO_TCP - 1, .signedness = 0, }, + .string = "_unknown", + }, + [3] = { + .start = { .value = IPPROTO_TCP, .signedness = 0, }, + .end = { .value = IPPROTO_TCP, .signedness = 0, }, + .string = "_tcp", + }, + [4] = { + .start = { .value = IPPROTO_TCP + 1, .signedness = 0, }, + .end = { .value = IPPROTO_UDP - 1, .signedness = 0, }, + .string = "_unknown", + }, + [5] = { + .start = { .value = IPPROTO_UDP, .signedness = 0, }, + .end = { .value = IPPROTO_UDP, .signedness = 0, }, + .string = "_udp", + }, + [6] = { + .start = { .value = IPPROTO_UDP + 1, .signedness = 0, }, + .end = { .value = 255, .signedness = 0, }, + .string = "_unknown", + }, +}; + +static const struct lttng_enum_desc proto_transport_header_type = { + .name = "proto_transport_header_type", + .entries = proto_transport_enum_entries, + .nr_entries = ARRAY_SIZE(proto_transport_enum_entries), +}; + +static struct lttng_enum_entry transport_enum_entries[] = { + [0] = { + .start = { .value = TH_NONE, .signedness = 0, }, + .end = { .value = TH_NONE, .signedness = 0, }, + .string = "_unknown", + }, + [1] = { + .start = { .value = TH_TCP, .signedness = 0, }, + .end = { .value = TH_TCP, .signedness = 0, }, + .string = "_tcp", + }, + [2] = { + .start = { .value = TH_UDP, .signedness = 0, }, + .end = { .value = TH_UDP, .signedness = 0, }, + .string = "_udp", + }, + [3] = { + .start = { .value = TH_ICMP, .signedness = 0, }, + .end = { .value = TH_ICMP, .signedness = 0, }, + .string = "_icmp", + }, +}; + +static const struct lttng_enum_desc transport_header_type = { + .name = "transport_header_type", + .entries = transport_enum_entries, + .nr_entries = ARRAY_SIZE(transport_enum_entries), +}; + +/* Structures for network headers. */ + +static struct lttng_event_field ipv4fields[] = { + [0] = { + .name = "version", + .type = __type_integer(uint8_t, 4, 4, 0, + __BIG_ENDIAN, 10, none), + }, + [1] = { + .name = "ihl", + .type = __type_integer(uint8_t, 4, 4, 0, + __BIG_ENDIAN, 10, none), + }, + [2] = { + .name = "tos", + .type = __type_integer(uint8_t, 0, 0, 0, + __BIG_ENDIAN, 10, none), + }, + [3] = { + .name = "tot_len", + .type = __type_integer(uint16_t, 0, 0, 0, + __BIG_ENDIAN, 10, none), + }, + [4] = { + .name = "id", + .type = __type_integer(uint16_t, 0, 0, 0, + __BIG_ENDIAN, 16, none), + }, + [5] = { + .name = "frag_off", + .type = __type_integer(uint16_t, 0, 0, 0, + __BIG_ENDIAN, 10, none), + }, + [6] = { + .name = "ttl", + .type = __type_integer(uint8_t, 0, 0, 0, + __BIG_ENDIAN, 10, none), + }, + [7] = { + .name = "protocol", + .type = { + .atype = atype_enum_nestable, + .u.enum_nestable.desc = + &proto_transport_header_type, + .u.enum_nestable.container_type = + __LTTNG_COMPOUND_LITERAL(struct lttng_type, + __type_integer(uint8_t, 0, 0, -1, + __BIG_ENDIAN, 10, none)), + }, + }, + [8] = { + .name = "checksum", + .type = __type_integer(uint16_t, 0, 0, 0, + __BIG_ENDIAN, 16, none), + }, + [9] = { + .name = "saddr", + .type = { + .atype = atype_array_nestable, + .u.array_nestable.elem_type = + __LTTNG_COMPOUND_LITERAL(struct lttng_type, + __type_integer(uint8_t, 0, 0, 0, + __BIG_ENDIAN, 10, none)), + .u.array_nestable.length = 4, + .u.array_nestable.alignment = lttng_alignof(uint8_t), + }, + }, + [10] = { + .name = "daddr", + .type = { + .atype = atype_array_nestable, + .u.array_nestable.elem_type = + __LTTNG_COMPOUND_LITERAL(struct lttng_type, + __type_integer(uint8_t, 0, 0, 0, + __BIG_ENDIAN, 10, none)), + .u.array_nestable.length = 4, + .u.array_nestable.alignment = lttng_alignof(uint8_t), + }, + }, + [11] = { + .name = "transport_header_type", + .type = { + .atype = atype_enum_nestable, + .u.enum_nestable.desc = &transport_header_type, + .u.enum_nestable.container_type = + __LTTNG_COMPOUND_LITERAL(struct lttng_type, + __type_integer(uint8_t, 0, 0, -1, + __BYTE_ORDER, 10, none)), + }, + }, + [12] = { + .name = "transport_header", + .type = { + .atype = atype_variant_nestable, + .u.variant_nestable.tag_name = "transport_header_type", + .u.variant_nestable.choices = transport_fields, + .u.variant_nestable.nr_choices = ARRAY_SIZE(transport_fields), + .u.variant_nestable.alignment = 0, + }, + }, +}; + +static struct lttng_event_field ipv6fields[] = { + [0] = { + .name = "version", + .type = __type_integer(uint8_t, 4, 4, 0, + __BIG_ENDIAN, 10, none), + }, + [1] = { + .name = "prio", + .type = __type_integer(uint8_t, 4, 4, 0, + __BIG_ENDIAN, 10, none), + }, + [2] = { + .name = "flow_lbl", + .type = { + .atype = atype_array_nestable, + .u.array_nestable.elem_type = + __LTTNG_COMPOUND_LITERAL(struct lttng_type, + __type_integer(uint8_t, 0, 0, 0, + __BIG_ENDIAN, 16, none)), + .u.array_nestable.length = 3, + .u.array_nestable.alignment = lttng_alignof(uint8_t), + }, + }, + [3] = { + .name = "payload_len", + .type = __type_integer(uint16_t, 0, 0, 0, + __BIG_ENDIAN, 10, none), + }, + [4] = { + .name = "nexthdr", + .type = { + .atype = atype_enum_nestable, + .u.enum_nestable.desc = + &proto_transport_header_type, + .u.enum_nestable.container_type = + __LTTNG_COMPOUND_LITERAL(struct lttng_type, + __type_integer(uint8_t, 0, 0, -1, + __BIG_ENDIAN, 10, none)), + }, + }, + [5] = { + .name = "hop_limit", + .type = __type_integer(uint8_t, 0, 0, 0, + __BIG_ENDIAN, 10, none), + }, + [6] = { + .name = "saddr", + .type = { + .atype = atype_array_nestable, + .u.array_nestable.elem_type = + __LTTNG_COMPOUND_LITERAL(struct lttng_type, + __type_integer(uint16_t, 0, 0, 0, + __BIG_ENDIAN, 16, none)), + .u.array_nestable.length = 8, + .u.array_nestable.alignment = lttng_alignof(uint16_t), + }, + }, + [7] = { + .name = "daddr", + .type = { + .atype = atype_array_nestable, + .u.array_nestable.elem_type = + __LTTNG_COMPOUND_LITERAL(struct lttng_type, + __type_integer(uint16_t, 0, 0, 0, + __BIG_ENDIAN, 16, none)), + .u.array_nestable.length = 8, + .u.array_nestable.alignment = lttng_alignof(uint16_t), + }, + }, + [8] = { + .name = "transport_header_type", + .type = { + .atype = atype_enum_nestable, + .u.enum_nestable.desc = &transport_header_type, + .u.enum_nestable.container_type = + __LTTNG_COMPOUND_LITERAL(struct lttng_type, + __type_integer(uint8_t, 0, 0, -1, + __BYTE_ORDER, 10, none)), + }, + }, + [9] = { + .name = "transport_header", + .type = { + .atype = atype_variant_nestable, + .u.variant_nestable.tag_name = "transport_header_type", + .u.variant_nestable.choices = transport_fields, + .u.variant_nestable.nr_choices = ARRAY_SIZE(transport_fields), + .u.variant_nestable.alignment = 0, + }, + }, +}; + +static struct lttng_event_field network_fields[] = { + [0] = { + .name = "unknown", + .type = { + .atype = atype_struct_nestable, + .u.struct_nestable.nr_fields = 0, + .u.struct_nestable.fields = emptyfields, + .u.struct_nestable.alignment = 0, + }, + }, + [1] = { + .name = "ipv4", + .type = { + .atype = atype_struct_nestable, + .u.struct_nestable.nr_fields = ARRAY_SIZE(ipv4fields), + .u.struct_nestable.fields = ipv4fields, + .u.struct_nestable.alignment = 0, + }, + }, + [2] = { + .name = "ipv6", + .type = { + .atype = atype_struct_nestable, + .u.struct_nestable.nr_fields = ARRAY_SIZE(ipv6fields), + .u.struct_nestable.fields = ipv6fields, + .u.struct_nestable.alignment = 0, + }, + }, +}; + +enum network_header_types { + NH_NONE, + NH_IPV4, + NH_IPV6, +}; + +static inline unsigned char __get_network_header_type(struct sk_buff *skb) +{ + if (__has_network_hdr(skb)) { + if (skb->protocol == htons(ETH_P_IPV6)) + return NH_IPV6; + else if (skb->protocol == htons(ETH_P_IP)) + return NH_IPV4; + /* Fallthrough for other header types. */ + } + return NH_NONE; +} + +#endif + +LTTNG_TRACEPOINT_ENUM(net_network_header, + TP_ENUM_VALUES( + ctf_enum_value("_unknown", NH_NONE) + ctf_enum_value("_ipv4", NH_IPV4) + ctf_enum_value("_ipv6", NH_IPV6) + ) +) + +LTTNG_TRACEPOINT_EVENT(net_dev_xmit, + + TP_PROTO(struct sk_buff *skb, + int rc, + struct net_device *dev, + unsigned int skb_len), + + TP_ARGS(skb, rc, dev, skb_len), + + TP_FIELDS( + ctf_integer_hex(void *, skbaddr, skb) + ctf_integer(int, rc, rc) + ctf_integer(unsigned int, len, skb_len) + ctf_string(name, dev->name) + ) +) + +LTTNG_TRACEPOINT_EVENT_CLASS(net_dev_template, + + TP_PROTO(struct sk_buff *skb), + + TP_ARGS(skb), + + TP_FIELDS( + ctf_integer_hex(void *, skbaddr, skb) + ctf_integer(unsigned int, len, skb->len) + ctf_string(name, skb->dev->name) + ctf_enum(net_network_header, unsigned char, + network_header_type, __get_network_header_type(skb)) + ctf_custom_field( + ctf_custom_type( + { + .atype = atype_variant_nestable, + .u.variant_nestable.tag_name = "network_header_type", + .u.variant_nestable.choices = network_fields, + .u.variant_nestable.nr_choices = + ARRAY_SIZE(network_fields), + .u.variant_nestable.alignment = 0, + } + ), + network_header, + ctf_custom_code( + bool has_network_header = false; + + /* Copy the network header. */ + switch (__get_network_header_type(skb)) { + case NH_IPV4: { + ctf_align(uint16_t) + ctf_array_type(uint8_t, ip_hdr(skb), + sizeof(struct iphdr)) + has_network_header = true; + break; + } + case NH_IPV6: { + ctf_align(uint16_t) + ctf_array_type(uint8_t, ipv6_hdr(skb), + sizeof(struct ipv6hdr)) + has_network_header = true; + break; + } + default: + /* + * For any other network header + * type, there is nothing to do. + */ + break; + } + + if (has_network_header) { + enum transport_header_types th_type = + __get_transport_header_type(skb); + + /* Transport header type field. */ + ctf_integer_type(unsigned char, th_type) + + /* Copy the transport header. */ + switch (th_type) { + case TH_TCP: { + ctf_align(uint32_t) + ctf_array_type(uint8_t, tcp_hdr(skb), + sizeof(struct tcphdr)) + break; + } + case TH_UDP: { + ctf_align(uint32_t) + ctf_array_type(uint8_t, udp_hdr(skb), + sizeof(struct udphdr)) + break; + } + case TH_ICMP: { + ctf_align(uint32_t) + ctf_array_type(uint8_t, icmp_hdr(skb), + sizeof(struct icmphdr)) + break; + } + default: + /* + * For any other transport header type, + * there is nothing to do. + */ + break; + } + } + ) + ) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(net_dev_template, net_dev_queue, + + TP_PROTO(struct sk_buff *skb), + + TP_ARGS(skb) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_template, + + netif_receive_skb, + + net_if_receive_skb, + + TP_PROTO(struct sk_buff *skb), + + TP_ARGS(skb) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_template, + + netif_rx, + + net_if_rx, + + TP_PROTO(struct sk_buff *skb), + + TP_ARGS(skb) +) + +/* Trace events for the receive entry points */ +LTTNG_TRACEPOINT_EVENT_CLASS(net_dev_receive_entry_template, + + TP_PROTO(const struct sk_buff *skb), + + TP_ARGS(skb), + + TP_FIELDS( + ctf_integer_hex(const void *, skbaddr, skb) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_receive_entry_template, + + napi_gro_frags_entry, + + net_napi_gro_frags_entry, + + TP_PROTO(const struct sk_buff *skb), + + TP_ARGS(skb) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_receive_entry_template, + + napi_gro_receive_entry, + + net_napi_gro_receive_entry, + + TP_PROTO(const struct sk_buff *skb), + + TP_ARGS(skb) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_receive_entry_template, + + netif_receive_skb_entry, + + net_if_receive_skb_entry, + + TP_PROTO(const struct sk_buff *skb), + + TP_ARGS(skb) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_receive_entry_template, + + netif_rx_entry, + + net_if_rx_entry, + + TP_PROTO(const struct sk_buff *skb), + + TP_ARGS(skb) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_receive_entry_template, + + netif_rx_ni_entry, + + net_if_rx_ni_entry, + + TP_PROTO(const struct sk_buff *skb), + + TP_ARGS(skb) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_receive_entry_template, + + netif_receive_skb_list_entry, + + net_if_receive_skb_list_entry, + + TP_PROTO(const struct sk_buff *skb), + + TP_ARGS(skb) +) + +/* Trace events for the receive exit points */ +LTTNG_TRACEPOINT_EVENT_CLASS(net_dev_receive_exit_template, + + TP_PROTO(int ret), + + TP_ARGS(ret), + + TP_FIELDS( + ctf_integer(int, ret, ret) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_receive_exit_template, + + napi_gro_frags_exit, + + net_napi_gro_frags_exit, + + TP_PROTO(int ret), + + TP_ARGS(ret) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_receive_exit_template, + + napi_gro_receive_exit, + + net_napi_gro_receive_exit, + + TP_PROTO(int ret), + + TP_ARGS(ret) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_receive_exit_template, + + netif_receive_skb_exit, + + net_if_receive_skb_exit, + + TP_PROTO(int ret), + + TP_ARGS(ret) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_receive_exit_template, + + netif_rx_exit, + + net_if_rx_exit, + + TP_PROTO(int ret), + + TP_ARGS(ret) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_receive_exit_template, + + netif_rx_ni_exit, + + net_if_rx_ni_exit, + + TP_PROTO(int ret), + + TP_ARGS(ret) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_receive_exit_template, + + netif_receive_skb_list_exit, + + net_if_receive_skb_list_exit, + + TP_PROTO(int ret), + + TP_ARGS(ret) +) + +#endif /* LTTNG_TRACE_NET_H */ + +/* This part must be outside protection */ +#include diff --git a/include/instrumentation/events/lttng-module/power.h b/include/instrumentation/events/lttng-module/power.h new file mode 100644 index 00000000..299183cc --- /dev/null +++ b/include/instrumentation/events/lttng-module/power.h @@ -0,0 +1,161 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#undef TRACE_SYSTEM +#define TRACE_SYSTEM power + +#if !defined(LTTNG_TRACE_POWER_H) || defined(TRACE_HEADER_MULTI_READ) +#define LTTNG_TRACE_POWER_H + +#include +#include + +LTTNG_TRACEPOINT_EVENT_CLASS(power_cpu, + + TP_PROTO(unsigned int state, unsigned int cpu_id), + + TP_ARGS(state, cpu_id), + + TP_FIELDS( + ctf_integer(u32, state, state) + ctf_integer(u32, cpu_id, cpu_id) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(power_cpu, cpu_idle, + + power_cpu_idle, + + TP_PROTO(unsigned int state, unsigned int cpu_id), + + TP_ARGS(state, cpu_id) +) + +/* This file can get included multiple times, TRACE_HEADER_MULTI_READ at top */ +#ifndef _PWR_EVENT_AVOID_DOUBLE_DEFINING +#define _PWR_EVENT_AVOID_DOUBLE_DEFINING + +#define PWR_EVENT_EXIT -1 +#endif + +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(power_cpu, cpu_frequency, + + power_cpu_frequency, + + TP_PROTO(unsigned int frequency, unsigned int cpu_id), + + TP_ARGS(frequency, cpu_id) +) + +LTTNG_TRACEPOINT_EVENT_MAP(machine_suspend, + + power_machine_suspend, + + TP_PROTO(unsigned int state), + + TP_ARGS(state), + + TP_FIELDS( + ctf_integer(u32, state, state) + ) +) + +LTTNG_TRACEPOINT_EVENT_CLASS(power_wakeup_source, + + TP_PROTO(const char *name, unsigned int state), + + TP_ARGS(name, state), + + TP_FIELDS( + ctf_string(name, name) + ctf_integer(u64, state, state) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(power_wakeup_source, wakeup_source_activate, + + power_wakeup_source_activate, + + TP_PROTO(const char *name, unsigned int state), + + TP_ARGS(name, state) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(power_wakeup_source, wakeup_source_deactivate, + + power_wakeup_source_deactivate, + + TP_PROTO(const char *name, unsigned int state), + + TP_ARGS(name, state) +) + +/* + * The clock events are used for clock enable/disable and for + * clock rate change + */ +LTTNG_TRACEPOINT_EVENT_CLASS(power_clock, + + TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id), + + TP_ARGS(name, state, cpu_id), + + TP_FIELDS( + ctf_string(name, name) + ctf_integer(u64, state, state) + ctf_integer(u64, cpu_id, cpu_id) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(power_clock, clock_enable, + + power_clock_enable, + + TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id), + + TP_ARGS(name, state, cpu_id) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(power_clock, clock_disable, + + power_clock_disable, + + TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id), + + TP_ARGS(name, state, cpu_id) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(power_clock, clock_set_rate, + + power_clock_set_rate, + + TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id), + + TP_ARGS(name, state, cpu_id) +) + +/* + * The power domain events are used for power domains transitions + */ +LTTNG_TRACEPOINT_EVENT_CLASS(power_domain, + + TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id), + + TP_ARGS(name, state, cpu_id), + + TP_FIELDS( + ctf_string(name, name) + ctf_integer(u64, state, state) + ctf_integer(u64, cpu_id, cpu_id) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(power_domain, power_domain_target, + + TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id), + + TP_ARGS(name, state, cpu_id) +) + +#endif /* LTTNG_TRACE_POWER_H */ + +/* This part must be outside protection */ +#include diff --git a/include/instrumentation/events/lttng-module/preemptirq.h b/include/instrumentation/events/lttng-module/preemptirq.h new file mode 100644 index 00000000..27960427 --- /dev/null +++ b/include/instrumentation/events/lttng-module/preemptirq.h @@ -0,0 +1,84 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#ifdef CONFIG_PREEMPTIRQ_EVENTS + +#undef TRACE_SYSTEM +#define TRACE_SYSTEM preemptirq + +#if !defined(LTTNG_TRACE_PREEMPTIRQ_H) || defined(TRACE_HEADER_MULTI_READ) +#define LTTNG_TRACE_PREEMPTIRQ_H + +#include +#include +#include +#include + +/* + * The preemptirq probe is built when CONFIG_PREEMPTIRQ_EVENTS is defined. + */ + +LTTNG_TRACEPOINT_EVENT_CLASS(preemptirq_template, + + TP_PROTO(unsigned long ip, unsigned long parent_ip), + + TP_ARGS(ip, parent_ip), + + TP_FIELDS( + ctf_integer_hex(unsigned long, caller, ip) + ctf_integer_hex(unsigned long, parent, parent_ip) + ) +) + +#if defined(CONFIG_TRACE_IRQFLAGS) +#define LTTNG_TRACE_IRQ +#endif + +#ifdef LTTNG_TRACE_IRQ +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(preemptirq_template, irq_disable, + + preemptirq_irq_disable, + + TP_PROTO(unsigned long ip, unsigned long parent_ip), + + TP_ARGS(ip, parent_ip) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(preemptirq_template, irq_enable, + + preemptirq_irq_enable, + + TP_PROTO(unsigned long ip, unsigned long parent_ip), + + TP_ARGS(ip, parent_ip) +) +#endif /* LTTNG_TRACE_IRQ */ + +#if defined(CONFIG_TRACE_PREEMPT_TOGGLE) +#define LTTNG_TRACE_PREEMPT +#endif + +#ifdef LTTNG_TRACE_PREEMPT +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(preemptirq_template, preempt_disable, + + preemptirq_preempt_disable, + + TP_PROTO(unsigned long ip, unsigned long parent_ip), + + TP_ARGS(ip, parent_ip) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(preemptirq_template, preempt_enable, + + preemptirq_preempt_enable, + + TP_PROTO(unsigned long ip, unsigned long parent_ip), + + TP_ARGS(ip, parent_ip) +) +#endif /* LTTNG_TRACE_PREEMPT */ + +#endif /* LTTNG_TRACE_PREEMPTIRQ_H */ + +/* This part must be outside protection */ +#include + +#endif /* CONFIG_PREEMPTIRQ_EVENTS */ diff --git a/include/instrumentation/events/lttng-module/printk.h b/include/instrumentation/events/lttng-module/printk.h new file mode 100644 index 00000000..3cbf2c9a --- /dev/null +++ b/include/instrumentation/events/lttng-module/printk.h @@ -0,0 +1,26 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#undef TRACE_SYSTEM +#define TRACE_SYSTEM printk + +#if !defined(LTTNG_TRACE_PRINTK_H) || defined(TRACE_HEADER_MULTI_READ) +#define LTTNG_TRACE_PRINTK_H + +#include + +LTTNG_TRACEPOINT_EVENT_MAP(console, + + printk_console, + + TP_PROTO(const char *text, size_t len), + + TP_ARGS(text, len), + + TP_FIELDS( + ctf_sequence_text(char, msg, text, size_t, len) + ) +) + +#endif /* LTTNG_TRACE_PRINTK_H */ + +/* This part must be outside protection */ +#include diff --git a/include/instrumentation/events/lttng-module/random.h b/include/instrumentation/events/lttng-module/random.h new file mode 100644 index 00000000..633bf67d --- /dev/null +++ b/include/instrumentation/events/lttng-module/random.h @@ -0,0 +1,112 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#undef TRACE_SYSTEM +#define TRACE_SYSTEM random + +#if !defined(LTTNG_TRACE_RANDOM_H) || defined(TRACE_HEADER_MULTI_READ) +#define LTTNG_TRACE_RANDOM_H + +#include +#include + +LTTNG_TRACEPOINT_EVENT_CLASS(random__mix_pool_bytes, + TP_PROTO(const char *pool_name, int bytes, unsigned long IP), + + TP_ARGS(pool_name, bytes, IP), + + TP_FIELDS( + ctf_string(pool_name, pool_name) + ctf_integer(int, bytes, bytes) + ctf_integer_hex(unsigned long, IP, IP) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(random__mix_pool_bytes, mix_pool_bytes, + + random_mix_pool_bytes, + + TP_PROTO(const char *pool_name, int bytes, unsigned long IP), + + TP_ARGS(pool_name, bytes, IP) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(random__mix_pool_bytes, mix_pool_bytes_nolock, + + random_mix_pool_bytes_nolock, + + TP_PROTO(const char *pool_name, int bytes, unsigned long IP), + + TP_ARGS(pool_name, bytes, IP) +) + +LTTNG_TRACEPOINT_EVENT_MAP(credit_entropy_bits, + + random_credit_entropy_bits, + + TP_PROTO(const char *pool_name, int bits, int entropy_count, + unsigned long IP), + + TP_ARGS(pool_name, bits, entropy_count, IP), + + TP_FIELDS( + ctf_string(pool_name, pool_name) + ctf_integer(int, bits, bits) + ctf_integer(int, entropy_count, entropy_count) + ctf_integer_hex(unsigned long, IP, IP) + ) +) + +LTTNG_TRACEPOINT_EVENT_MAP(get_random_bytes, + + random_get_random_bytes, + + TP_PROTO(int nbytes, unsigned long IP), + + TP_ARGS(nbytes, IP), + + TP_FIELDS( + ctf_integer(int, nbytes, nbytes) + ctf_integer_hex(unsigned long, IP, IP) + ) +) + +LTTNG_TRACEPOINT_EVENT_CLASS(random__extract_entropy, + TP_PROTO(const char *pool_name, int nbytes, int entropy_count, + unsigned long IP), + + TP_ARGS(pool_name, nbytes, entropy_count, IP), + + TP_FIELDS( + ctf_string(pool_name, pool_name) + ctf_integer(int, nbytes, nbytes) + ctf_integer(int, entropy_count, entropy_count) + ctf_integer_hex(unsigned long, IP, IP) + ) +) + + +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(random__extract_entropy, extract_entropy, + + random_extract_entropy, + + TP_PROTO(const char *pool_name, int nbytes, int entropy_count, + unsigned long IP), + + TP_ARGS(pool_name, nbytes, entropy_count, IP) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(random__extract_entropy, extract_entropy_user, + + random_extract_entropy_user, + + TP_PROTO(const char *pool_name, int nbytes, int entropy_count, + unsigned long IP), + + TP_ARGS(pool_name, nbytes, entropy_count, IP) +) + + + +#endif /* LTTNG_TRACE_RANDOM_H */ + +/* This part must be outside protection */ +#include diff --git a/include/instrumentation/events/lttng-module/rcu.h b/include/instrumentation/events/lttng-module/rcu.h new file mode 100644 index 00000000..73dc18c2 --- /dev/null +++ b/include/instrumentation/events/lttng-module/rcu.h @@ -0,0 +1,445 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#undef TRACE_SYSTEM +#define TRACE_SYSTEM rcu + +#if !defined(LTTNG_TRACE_RCU_H) || defined(TRACE_HEADER_MULTI_READ) +#define LTTNG_TRACE_RCU_H + +#include + +/* + * Tracepoint for start/end markers used for utilization calculations. + * By convention, the string is of the following forms: + * + * "Start " -- Mark the start of the specified activity, + * such as "context switch". Nesting is permitted. + * "End " -- Mark the end of the specified activity. + * + * An "@" character within "" is a comment character: Data + * reduction scripts will ignore the "@" and the remainder of the line. + */ +LTTNG_TRACEPOINT_EVENT(rcu_utilization, + + TP_PROTO(const char *s), + + TP_ARGS(s), + + TP_FIELDS( + ctf_string(s, s) + ) +) + +#ifdef CONFIG_RCU_TRACE + +#if defined(CONFIG_TREE_RCU) + +/* + * Tracepoint for grace-period events: starting and ending a grace + * period ("start" and "end", respectively), a CPU noting the start + * of a new grace period or the end of an old grace period ("cpustart" + * and "cpuend", respectively), a CPU passing through a quiescent + * state ("cpuqs"), a CPU coming online or going offline ("cpuonl" + * and "cpuofl", respectively), and a CPU being kicked for being too + * long in dyntick-idle mode ("kick"). + */ +LTTNG_TRACEPOINT_EVENT(rcu_grace_period, + + TP_PROTO(const char *rcuname, unsigned long gp_seq, const char *gpevent), + + TP_ARGS(rcuname, gp_seq, gpevent), + + TP_FIELDS( + ctf_string(rcuname, rcuname) + ctf_integer(unsigned long, gp_seq, gp_seq) + ctf_string(gpevent, gpevent) + ) +) + +/* + * Tracepoint for grace-period-initialization events. These are + * distinguished by the type of RCU, the new grace-period number, the + * rcu_node structure level, the starting and ending CPU covered by the + * rcu_node structure, and the mask of CPUs that will be waited for. + * All but the type of RCU are extracted from the rcu_node structure. + */ +LTTNG_TRACEPOINT_EVENT(rcu_grace_period_init, + + TP_PROTO(const char *rcuname, unsigned long gp_seq, u8 level, + int grplo, int grphi, unsigned long qsmask), + + TP_ARGS(rcuname, gp_seq, level, grplo, grphi, qsmask), + + TP_FIELDS( + ctf_string(rcuname, rcuname) + ctf_integer(unsigned long, gp_seq, gp_seq) + ctf_integer(u8, level, level) + ctf_integer(int, grplo, grplo) + ctf_integer(int, grphi, grphi) + ctf_integer(unsigned long, qsmask, qsmask) + ) +) + +/* + * Tracepoint for tasks blocking within preemptible-RCU read-side + * critical sections. Track the type of RCU (which one day might + * include SRCU), the grace-period number that the task is blocking + * (the current or the next), and the task's PID. + */ +LTTNG_TRACEPOINT_EVENT(rcu_preempt_task, + + TP_PROTO(const char *rcuname, int pid, unsigned long gp_seq), + + TP_ARGS(rcuname, pid, gp_seq), + + TP_FIELDS( + ctf_string(rcuname, rcuname) + ctf_integer(unsigned long, gp_seq, gp_seq) + ctf_integer(int, pid, pid) + ) +) + +/* + * Tracepoint for tasks that blocked within a given preemptible-RCU + * read-side critical section exiting that critical section. Track the + * type of RCU (which one day might include SRCU) and the task's PID. + */ +LTTNG_TRACEPOINT_EVENT(rcu_unlock_preempted_task, + + TP_PROTO(const char *rcuname, unsigned long gp_seq, int pid), + + TP_ARGS(rcuname, gp_seq, pid), + + TP_FIELDS( + ctf_string(rcuname, rcuname) + ctf_integer(unsigned long, gp_seq, gp_seq) + ctf_integer(int, pid, pid) + ) +) + +/* + * Tracepoint for quiescent-state-reporting events. These are + * distinguished by the type of RCU, the grace-period number, the + * mask of quiescent lower-level entities, the rcu_node structure level, + * the starting and ending CPU covered by the rcu_node structure, and + * whether there are any blocked tasks blocking the current grace period. + * All but the type of RCU are extracted from the rcu_node structure. + */ +LTTNG_TRACEPOINT_EVENT(rcu_quiescent_state_report, + + TP_PROTO(const char *rcuname, unsigned long gp_seq, + unsigned long mask, unsigned long qsmask, + u8 level, int grplo, int grphi, int gp_tasks), + + TP_ARGS(rcuname, gp_seq, mask, qsmask, level, grplo, grphi, gp_tasks), + + TP_FIELDS( + ctf_string(rcuname, rcuname) + ctf_integer(unsigned long, gp_seq, gp_seq) + ctf_integer(unsigned long, mask, mask) + ctf_integer(unsigned long, qsmask, qsmask) + ctf_integer(u8, level, level) + ctf_integer(int, grplo, grplo) + ctf_integer(int, grphi, grphi) + ctf_integer(u8, gp_tasks, gp_tasks) + ) +) + +/* + * Tracepoint for quiescent states detected by force_quiescent_state(). + * These trace events include the type of RCU, the grace-period number + * that was blocked by the CPU, the CPU itself, and the type of quiescent + * state, which can be "dti" for dyntick-idle mode, "ofl" for CPU offline, + * or "kick" when kicking a CPU that has been in dyntick-idle mode for + * too long. + */ +LTTNG_TRACEPOINT_EVENT(rcu_fqs, + + TP_PROTO(const char *rcuname, unsigned long gp_seq, int cpu, const char *qsevent), + + TP_ARGS(rcuname, gp_seq, cpu, qsevent), + + TP_FIELDS( + ctf_integer(unsigned long, gp_seq, gp_seq) + ctf_integer(int, cpu, cpu) + ctf_string(rcuname, rcuname) + ctf_string(qsevent, qsevent) + ) +) + +#endif + +/* + * Tracepoint for dyntick-idle entry/exit events. These take a string + * as argument: "Start" for entering dyntick-idle mode, "End" for + * leaving it, "--=" for events moving towards idle, and "++=" for events + * moving away from idle. "Error on entry: not idle task" and "Error on + * exit: not idle task" indicate that a non-idle task is erroneously + * toying with the idle loop. + * + * These events also take a pair of numbers, which indicate the nesting + * depth before and after the event of interest. Note that task-related + * events use the upper bits of each number, while interrupt-related + * events use the lower bits. + */ +LTTNG_TRACEPOINT_EVENT(rcu_dyntick, + + TP_PROTO(const char *polarity, long oldnesting, long newnesting, int dynticks), + + TP_ARGS(polarity, oldnesting, newnesting, dynticks), + + TP_FIELDS( + ctf_string(polarity, polarity) + ctf_integer(long, oldnesting, oldnesting) + ctf_integer(long, newnesting, newnesting) + ctf_integer(int, dynticks, dynticks) + ) +) + +/* + * Tracepoint for RCU preparation for idle, the goal being to get RCU + * processing done so that the current CPU can shut off its scheduling + * clock and enter dyntick-idle mode. One way to accomplish this is + * to drain all RCU callbacks from this CPU, and the other is to have + * done everything RCU requires for the current grace period. In this + * latter case, the CPU will be awakened at the end of the current grace + * period in order to process the remainder of its callbacks. + * + * These tracepoints take a string as argument: + * + * "No callbacks": Nothing to do, no callbacks on this CPU. + * "In holdoff": Nothing to do, holding off after unsuccessful attempt. + * "Begin holdoff": Attempt failed, don't retry until next jiffy. + * "Dyntick with callbacks": Entering dyntick-idle despite callbacks. + * "Dyntick with lazy callbacks": Entering dyntick-idle w/lazy callbacks. + * "More callbacks": Still more callbacks, try again to clear them out. + * "Callbacks drained": All callbacks processed, off to dyntick idle! + * "Timer": Timer fired to cause CPU to continue processing callbacks. + * "Demigrate": Timer fired on wrong CPU, woke up correct CPU. + * "Cleanup after idle": Idle exited, timer canceled. + */ +LTTNG_TRACEPOINT_EVENT(rcu_prep_idle, + + TP_PROTO(const char *reason), + + TP_ARGS(reason), + + TP_FIELDS( + ctf_string(reason, reason) + ) +) + +/* + * Tracepoint for the registration of a single RCU callback function. + * The first argument is the type of RCU, the second argument is + * a pointer to the RCU callback itself, the third element is the + * number of lazy callbacks queued, and the fourth element is the + * total number of callbacks queued. + */ +LTTNG_TRACEPOINT_EVENT(rcu_callback, + + TP_PROTO(const char *rcuname, struct rcu_head *rhp, long qlen), + + TP_ARGS(rcuname, rhp, qlen), + + TP_FIELDS( + ctf_string(rcuname, rcuname) + ctf_integer_hex(void *, rhp, rhp) + ctf_integer_hex(void *, func, rhp->func) + ctf_integer(long, qlen, qlen) + ) +) + +/* + * Tracepoint for the registration of a single RCU callback of the special + * kfree() form. The first argument is the RCU type, the second argument + * is a pointer to the RCU callback, the third argument is the offset + * of the callback within the enclosing RCU-protected data structure, + * the fourth argument is the number of lazy callbacks queued, and the + * fifth argument is the total number of callbacks queued. + */ +LTTNG_TRACEPOINT_EVENT(rcu_kfree_callback, + + TP_PROTO(const char *rcuname, struct rcu_head *rhp, unsigned long offset, + long qlen), + + TP_ARGS(rcuname, rhp, offset, qlen), + + TP_FIELDS( + ctf_string(rcuname, rcuname) + ctf_integer_hex(void *, rhp, rhp) + ctf_integer_hex(unsigned long, offset, offset) + ctf_integer(long, qlen, qlen) + ) +) + +/* + * Tracepoint for marking the beginning rcu_do_batch, performed to start + * RCU callback invocation. The first argument is the RCU flavor, + * the second is the number of lazy callbacks queued, the third is + * the total number of callbacks queued, and the fourth argument is + * the current RCU-callback batch limit. + */ +LTTNG_TRACEPOINT_EVENT(rcu_batch_start, + + TP_PROTO(const char *rcuname, long qlen, long blimit), + + TP_ARGS(rcuname, qlen, blimit), + + TP_FIELDS( + ctf_string(rcuname, rcuname) + ctf_integer(long, qlen, qlen) + ctf_integer(long, blimit, blimit) + ) +) + +/* + * Tracepoint for the invocation of a single RCU callback function. + * The first argument is the type of RCU, and the second argument is + * a pointer to the RCU callback itself. + */ +LTTNG_TRACEPOINT_EVENT(rcu_invoke_callback, + + TP_PROTO(const char *rcuname, struct rcu_head *rhp), + + TP_ARGS(rcuname, rhp), + + TP_FIELDS( + ctf_string(rcuname, rcuname) + ctf_integer_hex(void *, rhp, rhp) + ctf_integer_hex(void *, func, rhp->func) + ) +) + +/* + * Tracepoint for the invocation of a single RCU callback of the special + * kfree() form. The first argument is the RCU flavor, the second + * argument is a pointer to the RCU callback, and the third argument + * is the offset of the callback within the enclosing RCU-protected + * data structure. + */ +LTTNG_TRACEPOINT_EVENT(rcu_invoke_kfree_callback, + + TP_PROTO(const char *rcuname, struct rcu_head *rhp, unsigned long offset), + + TP_ARGS(rcuname, rhp, offset), + + TP_FIELDS( + ctf_string(rcuname, rcuname) + ctf_integer_hex(void *, rhp, rhp) + ctf_integer(unsigned long, offset, offset) + ) +) + +/* + * Tracepoint for exiting rcu_do_batch after RCU callbacks have been + * invoked. The first argument is the name of the RCU flavor, + * the second argument is number of callbacks actually invoked, + * the third argument (cb) is whether or not any of the callbacks that + * were ready to invoke at the beginning of this batch are still + * queued, the fourth argument (nr) is the return value of need_resched(), + * the fifth argument (iit) is 1 if the current task is the idle task, + * and the sixth argument (risk) is the return value from + * rcu_is_callbacks_kthread(). + */ +LTTNG_TRACEPOINT_EVENT(rcu_batch_end, + + TP_PROTO(const char *rcuname, int callbacks_invoked, + char cb, char nr, char iit, char risk), + + TP_ARGS(rcuname, callbacks_invoked, cb, nr, iit, risk), + + TP_FIELDS( + ctf_string(rcuname, rcuname) + ctf_integer(int, callbacks_invoked, callbacks_invoked) + ctf_integer(char, cb, cb) + ctf_integer(char, nr, nr) + ctf_integer(char, iit, iit) + ctf_integer(char, risk, risk) + ) +) + +/* + * Tracepoint for rcutorture readers. The first argument is the name + * of the RCU flavor from rcutorture's viewpoint and the second argument + * is the callback address. + */ +LTTNG_TRACEPOINT_EVENT(rcu_torture_read, + + TP_PROTO(const char *rcutorturename, struct rcu_head *rhp, + unsigned long secs, unsigned long c_old, unsigned long c), + + TP_ARGS(rcutorturename, rhp, secs, c_old, c), + + TP_FIELDS( + ctf_string(rcutorturename, rcutorturename) + ctf_integer_hex(struct rcu_head *, rhp, rhp) + ctf_integer(unsigned long, secs, secs) + ctf_integer(unsigned long, c_old, c_old) + ctf_integer(unsigned long, c, c) + ) +) + +/* + * Tracepoint for _rcu_barrier() execution. The string "s" describes + * the _rcu_barrier phase: + * "Begin": rcu_barrier_callback() started. + * "Check": rcu_barrier_callback() checking for piggybacking. + * "EarlyExit": rcu_barrier_callback() piggybacked, thus early exit. + * "Inc1": rcu_barrier_callback() piggyback check counter incremented. + * "Offline": rcu_barrier_callback() found offline CPU + * "OnlineQ": rcu_barrier_callback() found online CPU with callbacks. + * "OnlineNQ": rcu_barrier_callback() found online CPU, no callbacks. + * "IRQ": An rcu_barrier_callback() callback posted on remote CPU. + * "CB": An rcu_barrier_callback() invoked a callback, not the last. + * "LastCB": An rcu_barrier_callback() invoked the last callback. + * "Inc2": rcu_barrier_callback() piggyback check counter incremented. + * The "cpu" argument is the CPU or -1 if meaningless, the "cnt" argument + * is the count of remaining callbacks, and "done" is the piggybacking count. + */ +LTTNG_TRACEPOINT_EVENT(rcu_barrier, + + TP_PROTO(const char *rcuname, const char *s, int cpu, int cnt, unsigned long done), + + TP_ARGS(rcuname, s, cpu, cnt, done), + + TP_FIELDS( + ctf_string(rcuname, rcuname) + ctf_string(s, s) + ctf_integer(int, cpu, cpu) + ctf_integer(int, cnt, cnt) + ctf_integer(unsigned long, done, done) + ) +) + +#else /* #ifdef CONFIG_RCU_TRACE */ + +#define trace_rcu_grace_period(rcuname, gp_seq, gpevent) do { } while (0) +#define trace_rcu_grace_period_init(rcuname, gp_seq, level, grplo, grphi, \ + qsmask) do { } while (0) +#define trace_rcu_preempt_task(rcuname, pid, gp_seq) do { } while (0) +#define trace_rcu_unlock_preempted_task(rcuname, gp_seq, pid) do { } while (0) +#define trace_rcu_quiescent_state_report(rcuname, gp_seq, mask, qsmask, level, \ + grplo, grphi, gp_tasks) do { } \ + while (0) +#define trace_rcu_fqs(rcuname, gp_seq, cpu, qsevent) do { } while (0) + +#define trace_rcu_dyntick(polarity, oldnesting, newnesting, dyntick) do { } while (0) +#define trace_rcu_prep_idle(reason) do { } while (0) +#define trace_rcu_callback(rcuname, rhp, qlen_lazy, qlen) do { } while (0) +#define trace_rcu_kfree_callback(rcuname, rhp, offset, qlen_lazy, qlen) \ + do { } while (0) +#define trace_rcu_batch_start(rcuname, qlen_lazy, qlen, blimit) \ + do { } while (0) +#define trace_rcu_invoke_callback(rcuname, rhp) do { } while (0) +#define trace_rcu_invoke_kfree_callback(rcuname, rhp, offset) do { } while (0) +#define trace_rcu_batch_end(rcuname, callbacks_invoked, cb, nr, iit, risk) \ + do { } while (0) +#define trace_rcu_torture_read(rcutorturename, rhp, secs, c_old, c) \ + do { } while (0) +#define trace_rcu_barrier(name, s, cpu, cnt, done) do { } while (0) +#endif /* #else #ifdef CONFIG_RCU_TRACE */ + +#endif /* LTTNG_TRACE_RCU_H */ + +/* This part must be outside protection */ +#include diff --git a/include/instrumentation/events/lttng-module/regmap.h b/include/instrumentation/events/lttng-module/regmap.h new file mode 100644 index 00000000..d7277cb2 --- /dev/null +++ b/include/instrumentation/events/lttng-module/regmap.h @@ -0,0 +1,144 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#undef TRACE_SYSTEM +#define TRACE_SYSTEM regmap + +#if !defined(LTTNG_TRACE_REGMAP_H) || defined(TRACE_HEADER_MULTI_READ) +#define LTTNG_TRACE_REGMAP_H + +#include +#include + +#ifndef _TRACE_REGMAP_DEF_ +#define _TRACE_REGMAP_DEF_ +struct device; +struct regmap; +#endif + +/* + * Log register events + */ +LTTNG_TRACEPOINT_EVENT_CLASS(regmap_reg, + + TP_PROTO(struct regmap *map, unsigned int reg, + unsigned int val), + + TP_ARGS(map, reg, val), + + TP_FIELDS( + ctf_string(name, regmap_name(map)) + ctf_integer(unsigned int, reg, reg) + ctf_integer(unsigned int, val, val) + ) +) +LTTNG_TRACEPOINT_EVENT_INSTANCE(regmap_reg, regmap_reg_write, + + TP_PROTO(struct regmap *map, unsigned int reg, + unsigned int val), + + TP_ARGS(map, reg, val) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(regmap_reg, regmap_reg_read, + + TP_PROTO(struct regmap *map, unsigned int reg, + unsigned int val), + + TP_ARGS(map, reg, val) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(regmap_reg, regmap_reg_read_cache, + + TP_PROTO(struct regmap *map, unsigned int reg, + unsigned int val), + + TP_ARGS(map, reg, val) +) + +LTTNG_TRACEPOINT_EVENT_CLASS(regmap_block, + + TP_PROTO(struct regmap *map, unsigned int reg, int count), + + TP_ARGS(map, reg, count), + + TP_FIELDS( + ctf_string(name, regmap_name(map)) + ctf_integer(unsigned int, reg, reg) + ctf_integer(int, count, count) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(regmap_block, regmap_hw_read_start, + + TP_PROTO(struct regmap *map, unsigned int reg, int count), + + TP_ARGS(map, reg, count) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(regmap_block, regmap_hw_read_done, + + TP_PROTO(struct regmap *map, unsigned int reg, int count), + + TP_ARGS(map, reg, count) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(regmap_block, regmap_hw_write_start, + + TP_PROTO(struct regmap *map, unsigned int reg, int count), + + TP_ARGS(map, reg, count) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(regmap_block, regmap_hw_write_done, + + TP_PROTO(struct regmap *map, unsigned int reg, int count), + + TP_ARGS(map, reg, count) +) + +LTTNG_TRACEPOINT_EVENT_MAP(regcache_sync, + + regmap_regcache_sync, + + TP_PROTO(struct regmap *map, const char *type, + const char *status), + + TP_ARGS(map, type, status), + + TP_FIELDS( + ctf_string(name, regmap_name(map)) + ctf_string(status, status) + ctf_string(type, type) + ) +) + +LTTNG_TRACEPOINT_EVENT_CLASS(regmap_bool, + + TP_PROTO(struct regmap *map, bool flag), + + TP_ARGS(map, flag), + + TP_FIELDS( + ctf_string(name, regmap_name(map)) + ctf_integer(int, flag, flag) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(regmap_bool, regmap_cache_only, + + TP_PROTO(struct regmap *map, bool flag), + + TP_ARGS(map, flag) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(regmap_bool, regmap_cache_bypass, + + TP_PROTO(struct regmap *map, bool flag), + + TP_ARGS(map, flag) + +) + +#endif /* LTTNG_TRACE_REGMAP_H */ + +/* This part must be outside protection */ +#include diff --git a/include/instrumentation/events/lttng-module/regulator.h b/include/instrumentation/events/lttng-module/regulator.h new file mode 100644 index 00000000..44f83caa --- /dev/null +++ b/include/instrumentation/events/lttng-module/regulator.h @@ -0,0 +1,118 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#undef TRACE_SYSTEM +#define TRACE_SYSTEM regulator + +#if !defined(LTTNG_TRACE_REGULATOR_H) || defined(TRACE_HEADER_MULTI_READ) +#define LTTNG_TRACE_REGULATOR_H + +#include +#include + +/* + * Events which just log themselves and the regulator name for enable/disable + * type tracking. + */ +LTTNG_TRACEPOINT_EVENT_CLASS(regulator_basic, + + TP_PROTO(const char *name), + + TP_ARGS(name), + + TP_FIELDS( + ctf_string(name, name) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(regulator_basic, regulator_enable, + + TP_PROTO(const char *name), + + TP_ARGS(name) + +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(regulator_basic, regulator_enable_delay, + + TP_PROTO(const char *name), + + TP_ARGS(name) + +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(regulator_basic, regulator_enable_complete, + + TP_PROTO(const char *name), + + TP_ARGS(name) + +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(regulator_basic, regulator_disable, + + TP_PROTO(const char *name), + + TP_ARGS(name) + +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(regulator_basic, regulator_disable_complete, + + TP_PROTO(const char *name), + + TP_ARGS(name) + +) + +/* + * Events that take a range of numerical values, mostly for voltages + * and so on. + */ +LTTNG_TRACEPOINT_EVENT_CLASS(regulator_range, + + TP_PROTO(const char *name, int min, int max), + + TP_ARGS(name, min, max), + + TP_FIELDS( + ctf_string(name, name) + ctf_integer(int, min, min) + ctf_integer(int, max, max) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(regulator_range, regulator_set_voltage, + + TP_PROTO(const char *name, int min, int max), + + TP_ARGS(name, min, max) + +) + + +/* + * Events that take a single value, mostly for readback and refcounts. + */ +LTTNG_TRACEPOINT_EVENT_CLASS(regulator_value, + + TP_PROTO(const char *name, unsigned int val), + + TP_ARGS(name, val), + + TP_FIELDS( + ctf_string(name, name) + ctf_integer(unsigned int, val, val) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(regulator_value, regulator_set_voltage_complete, + + TP_PROTO(const char *name, unsigned int value), + + TP_ARGS(name, value) + +) + +#endif /* _TRACE_POWER_H */ + +/* This part must be outside protection */ +#include diff --git a/include/instrumentation/events/lttng-module/rpc.h b/include/instrumentation/events/lttng-module/rpc.h new file mode 100644 index 00000000..a6bada96 --- /dev/null +++ b/include/instrumentation/events/lttng-module/rpc.h @@ -0,0 +1,134 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#undef TRACE_SYSTEM +#define TRACE_SYSTEM rpc + +#if !defined(LTTNG_TRACE_RPC_H) || defined(TRACE_HEADER_MULTI_READ) +#define LTTNG_TRACE_RPC_H + +#include +#include +#include + +#ifndef ONCE_LTTNG_RPC_H +#define ONCE_LTTNG_RPC_H + +static inline +int lttng_get_clid(const struct rpc_task *task) +{ + struct rpc_clnt *tk_client; + + tk_client = task->tk_client; + if (!tk_client) + return -1; + /* + * The cl_clid field is always initialized to positive signed + * integers. Negative signed integer values are treated as + * errors. + */ + return (int) tk_client->cl_clid; +} + +#endif /* ONCE_LTTNG_RPC_H */ + +LTTNG_TRACEPOINT_EVENT_CLASS(rpc_task_status, + + TP_PROTO(const struct rpc_task *task), + + TP_ARGS(task), + + TP_FIELDS( + ctf_integer(unsigned int, task_id, task->tk_pid) + ctf_integer(int, client_id, lttng_get_clid(task)) + ctf_integer(int, status, task->tk_status) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(rpc_task_status, rpc_call_status, + TP_PROTO(const struct rpc_task *task), + + TP_ARGS(task) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(rpc_task_status, rpc_bind_status, + TP_PROTO(const struct rpc_task *task), + + TP_ARGS(task) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(rpc_task_status, rpc_connect_status, + TP_PROTO(const struct rpc_task *task), + + TP_ARGS(task) +) + +LTTNG_TRACEPOINT_EVENT_CLASS(rpc_task_running, + + TP_PROTO(const struct rpc_task *task, const void *action), + + TP_ARGS(task, action), + + TP_FIELDS( + ctf_integer(unsigned int, task_id, task->tk_pid) + ctf_integer(int, client_id, lttng_get_clid(task)) + ctf_integer_hex(const void *, action, action) + ctf_integer(unsigned long, runstate, task->tk_runstate) + ctf_integer(int, status, task->tk_status) + ctf_integer(unsigned short, flags, task->tk_flags) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(rpc_task_running, rpc_task_begin, + + TP_PROTO(const struct rpc_task *task, const void *action), + + TP_ARGS(task, action) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(rpc_task_running, rpc_task_run_action, + + TP_PROTO(const struct rpc_task *task, const void *action), + + TP_ARGS(task, action) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(rpc_task_running, rpc_task_complete, + + TP_PROTO(const struct rpc_task *task, const void *action), + + TP_ARGS(task, action) +) + +LTTNG_TRACEPOINT_EVENT_CLASS(rpc_task_queued, + + TP_PROTO(const struct rpc_task *task, const struct rpc_wait_queue *q), + + TP_ARGS(task, q), + + TP_FIELDS( + ctf_integer(unsigned int, task_id, task->tk_pid) + ctf_integer(int, client_id, lttng_get_clid(task)) + ctf_integer(unsigned long, timeout, task->tk_timeout) + ctf_integer(unsigned long, runstate, task->tk_runstate) + ctf_integer(int, status, task->tk_status) + ctf_integer(unsigned short, flags, task->tk_flags) + ctf_string(q_name, rpc_qname(q)) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(rpc_task_queued, rpc_task_sleep, + + TP_PROTO(const struct rpc_task *task, const struct rpc_wait_queue *q), + + TP_ARGS(task, q) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(rpc_task_queued, rpc_task_wakeup, + + TP_PROTO(const struct rpc_task *task, const struct rpc_wait_queue *q), + + TP_ARGS(task, q) +) + +#endif /* LTTNG_TRACE_RPC_H */ + +#include diff --git a/include/instrumentation/events/lttng-module/rpm.h b/include/instrumentation/events/lttng-module/rpm.h new file mode 100644 index 00000000..71909fc8 --- /dev/null +++ b/include/instrumentation/events/lttng-module/rpm.h @@ -0,0 +1,73 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#undef TRACE_SYSTEM +#define TRACE_SYSTEM rpm + +#if !defined(LTTNG_TRACE_RUNTIME_POWER_H) || defined(TRACE_HEADER_MULTI_READ) +#define LTTNG_TRACE_RUNTIME_POWER_H + +#include +#include + +#ifndef _TRACE_RPM_DEF_ +#define _TRACE_RPM_DEF_ +struct device; +#endif + +/* + * The rpm_internal events are used for tracing some important + * runtime pm internal functions. + */ +LTTNG_TRACEPOINT_EVENT_CLASS(rpm_internal, + + TP_PROTO(struct device *dev, int flags), + + TP_ARGS(dev, flags), + + TP_FIELDS( + ctf_string(name, dev_name(dev)) + ctf_integer(int, flags, flags) + ctf_integer(int, usage_count, atomic_read(&dev->power.usage_count)) + ctf_integer(int, disable_depth, dev->power.disable_depth) + ctf_integer(int, runtime_auto, dev->power.runtime_auto) + ctf_integer(int, request_pending, dev->power.request_pending) + ctf_integer(int, irq_safe, dev->power.irq_safe) + ctf_integer(int, child_count, atomic_read(&dev->power.child_count)) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(rpm_internal, rpm_suspend, + + TP_PROTO(struct device *dev, int flags), + + TP_ARGS(dev, flags) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(rpm_internal, rpm_resume, + + TP_PROTO(struct device *dev, int flags), + + TP_ARGS(dev, flags) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(rpm_internal, rpm_idle, + + TP_PROTO(struct device *dev, int flags), + + TP_ARGS(dev, flags) +) + +LTTNG_TRACEPOINT_EVENT(rpm_return_int, + TP_PROTO(struct device *dev, unsigned long ip, int ret), + TP_ARGS(dev, ip, ret), + + TP_FIELDS( + ctf_string(name, dev_name(dev)) + ctf_integer_hex(unsigned long, ip, ip) + ctf_integer(int, ret, ret) + ) +) + +#endif /* LTTNG_TRACE_RUNTIME_POWER_H */ + +/* This part must be outside protection */ +#include diff --git a/include/instrumentation/events/lttng-module/sched.h b/include/instrumentation/events/lttng-module/sched.h new file mode 100644 index 00000000..a13e5990 --- /dev/null +++ b/include/instrumentation/events/lttng-module/sched.h @@ -0,0 +1,409 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#undef TRACE_SYSTEM +#define TRACE_SYSTEM sched + +#if !defined(LTTNG_TRACE_SCHED_H) || defined(TRACE_HEADER_MULTI_READ) +#define LTTNG_TRACE_SCHED_H + +#include +#include +#include +#include +#include + +#define LTTNG_MAX_PID_NS_LEVEL 32 + +#ifndef _TRACE_SCHED_DEF_ +#define _TRACE_SCHED_DEF_ + +static inline long __trace_sched_switch_state(bool preempt, struct task_struct *p) +{ + unsigned int state; + +#ifdef CONFIG_SCHED_DEBUG + BUG_ON(p != current); +#endif /* CONFIG_SCHED_DEBUG */ + + /* + * Preemption ignores task state, therefore preempted tasks are always + * RUNNING (we will not have dequeued if state != RUNNING). + */ + if (preempt) + return TASK_REPORT_MAX; + + /* + * task_state_index() uses fls() and returns a value from 0-8 range. + * Decrement it by 1 (except TASK_RUNNING state i.e 0) before using + * it for left shift operation to get the correct task->state + * mapping. + */ + state = task_state_index(p); + + return state ? (1 << (state - 1)) : state; +} + +#endif /* _TRACE_SCHED_DEF_ */ + +/* + * Enumeration of the task state bitmask. + * Only bit flags are enumerated here, not composition of states. + */ +LTTNG_TRACEPOINT_ENUM(task_state, + TP_ENUM_VALUES( + ctf_enum_value("TASK_RUNNING", TASK_RUNNING) + ctf_enum_value("TASK_INTERRUPTIBLE", TASK_INTERRUPTIBLE) + ctf_enum_value("TASK_UNINTERRUPTIBLE", TASK_UNINTERRUPTIBLE) + ctf_enum_value("TASK_STOPPED", __TASK_STOPPED) + ctf_enum_value("TASK_TRACED", __TASK_TRACED) + ctf_enum_value("EXIT_DEAD", EXIT_DEAD) + ctf_enum_value("EXIT_ZOMBIE", EXIT_ZOMBIE) + ctf_enum_value("TASK_PARKED", TASK_PARKED) + ctf_enum_value("TASK_DEAD", TASK_DEAD) + ctf_enum_value("TASK_WAKEKILL", TASK_WAKEKILL) + ctf_enum_value("TASK_WAKING", TASK_WAKING) + ctf_enum_value("TASK_NOLOAD", TASK_NOLOAD) + ctf_enum_value("TASK_NEW", TASK_NEW) + ctf_enum_value("TASK_STATE_MAX", TASK_STATE_MAX) + ) +) + +/* + * Tracepoint for calling kthread_stop, performed to end a kthread: + */ +LTTNG_TRACEPOINT_EVENT(sched_kthread_stop, + + TP_PROTO(struct task_struct *t), + + TP_ARGS(t), + + TP_FIELDS( + ctf_array_text(char, comm, t->comm, TASK_COMM_LEN) + ctf_integer(pid_t, tid, t->pid) + ) +) + +/* + * Tracepoint for the return value of the kthread stopping: + */ +LTTNG_TRACEPOINT_EVENT(sched_kthread_stop_ret, + + TP_PROTO(int ret), + + TP_ARGS(ret), + + TP_FIELDS( + ctf_integer(int, ret, ret) + ) +) + +/* + * Tracepoint for waking up a task: + */ +LTTNG_TRACEPOINT_EVENT_CLASS(sched_wakeup_template, + + TP_PROTO(struct task_struct *p), + + TP_ARGS(p), + + TP_FIELDS( + ctf_array_text(char, comm, p->comm, TASK_COMM_LEN) + ctf_integer(pid_t, tid, p->pid) + ctf_integer(int, prio, p->prio - MAX_RT_PRIO) + ctf_integer(int, target_cpu, task_cpu(p)) + ) +) + +/* + * Tracepoint called when waking a task; this tracepoint is guaranteed to be + * called from the waking context. + */ +LTTNG_TRACEPOINT_EVENT_INSTANCE(sched_wakeup_template, sched_waking, + TP_PROTO(struct task_struct *p), + TP_ARGS(p)) + +/* + * Tracepoint called when the task is actually woken; p->state == TASK_RUNNNG. + * It it not always called from the waking context. + */ +LTTNG_TRACEPOINT_EVENT_INSTANCE(sched_wakeup_template, sched_wakeup, + TP_PROTO(struct task_struct *p), + TP_ARGS(p)) + +/* + * Tracepoint for waking up a new task: + */ +LTTNG_TRACEPOINT_EVENT_INSTANCE(sched_wakeup_template, sched_wakeup_new, + TP_PROTO(struct task_struct *p), + TP_ARGS(p)) + +/* + * Tracepoint for task switches, performed by the scheduler: + */ +LTTNG_TRACEPOINT_EVENT(sched_switch, + + TP_PROTO(bool preempt, + struct task_struct *prev, + struct task_struct *next), + + TP_ARGS(preempt, prev, next), + + TP_FIELDS( + ctf_array_text(char, prev_comm, prev->comm, TASK_COMM_LEN) + ctf_integer(pid_t, prev_tid, prev->pid) + ctf_integer(int, prev_prio, prev->prio - MAX_RT_PRIO) + ctf_enum(task_state, long, prev_state, __trace_sched_switch_state(preempt, prev)) + ctf_array_text(char, next_comm, next->comm, TASK_COMM_LEN) + ctf_integer(pid_t, next_tid, next->pid) + ctf_integer(int, next_prio, next->prio - MAX_RT_PRIO) + ) +) + +/* + * Tracepoint for a task being migrated: + */ +LTTNG_TRACEPOINT_EVENT(sched_migrate_task, + + TP_PROTO(struct task_struct *p, int dest_cpu), + + TP_ARGS(p, dest_cpu), + + TP_FIELDS( + ctf_array_text(char, comm, p->comm, TASK_COMM_LEN) + ctf_integer(pid_t, tid, p->pid) + ctf_integer(int, prio, p->prio - MAX_RT_PRIO) + ctf_integer(int, orig_cpu, task_cpu(p)) + ctf_integer(int, dest_cpu, dest_cpu) + ) +) + +LTTNG_TRACEPOINT_EVENT_CLASS(sched_process_template, + + TP_PROTO(struct task_struct *p), + + TP_ARGS(p), + + TP_FIELDS( + ctf_array_text(char, comm, p->comm, TASK_COMM_LEN) + ctf_integer(pid_t, tid, p->pid) + ctf_integer(int, prio, p->prio - MAX_RT_PRIO) + ) +) + +/* + * Tracepoint for freeing a task: + */ +LTTNG_TRACEPOINT_EVENT_INSTANCE(sched_process_template, sched_process_free, + TP_PROTO(struct task_struct *p), + TP_ARGS(p)) + + +/* + * Tracepoint for a task exiting: + */ +LTTNG_TRACEPOINT_EVENT_INSTANCE(sched_process_template, sched_process_exit, + TP_PROTO(struct task_struct *p), + TP_ARGS(p)) + +/* + * Tracepoint for waiting on task to unschedule: + */ +LTTNG_TRACEPOINT_EVENT_INSTANCE(sched_process_template, sched_wait_task, + TP_PROTO(struct task_struct *p), + TP_ARGS(p)) + +/* + * Tracepoint for a waiting task: + */ +LTTNG_TRACEPOINT_EVENT(sched_process_wait, + + TP_PROTO(struct pid *pid), + + TP_ARGS(pid), + + TP_FIELDS( + ctf_array_text(char, comm, current->comm, TASK_COMM_LEN) + ctf_integer(pid_t, tid, pid_nr(pid)) + ctf_integer(int, prio, current->prio - MAX_RT_PRIO) + ) +) + +/* + * Tracepoint for do_fork. + * Saving both TID and PID information, especially for the child, allows + * trace analyzers to distinguish between creation of a new process and + * creation of a new thread. Newly created processes will have child_tid + * == child_pid, while creation of a thread yields to child_tid != + * child_pid. + */ +LTTNG_TRACEPOINT_EVENT_CODE(sched_process_fork, + + TP_PROTO(struct task_struct *parent, struct task_struct *child), + + TP_ARGS(parent, child), + + TP_locvar( + pid_t vtids[LTTNG_MAX_PID_NS_LEVEL]; + unsigned int ns_level; + ), + + TP_code_pre( + if (child) { + struct pid *child_pid; + unsigned int i; + + child_pid = task_pid(child); + tp_locvar->ns_level = + min_t(unsigned int, child_pid->level + 1, + LTTNG_MAX_PID_NS_LEVEL); + for (i = 0; i < tp_locvar->ns_level; i++) + tp_locvar->vtids[i] = child_pid->numbers[i].nr; + } + ), + + TP_FIELDS( + ctf_array_text(char, parent_comm, parent->comm, TASK_COMM_LEN) + ctf_integer(pid_t, parent_tid, parent->pid) + ctf_integer(pid_t, parent_pid, parent->tgid) + ctf_integer(unsigned int, parent_ns_inum, + ({ + unsigned int parent_ns_inum = 0; + + if (parent) { + struct pid_namespace *pid_ns; + + pid_ns = task_active_pid_ns(parent); + if (pid_ns) + parent_ns_inum = + pid_ns->ns.inum; + } + parent_ns_inum; + })) + ctf_array_text(char, child_comm, child->comm, TASK_COMM_LEN) + ctf_integer(pid_t, child_tid, child->pid) + ctf_sequence(pid_t, vtids, tp_locvar->vtids, u8, tp_locvar->ns_level) + ctf_integer(pid_t, child_pid, child->tgid) + ctf_integer(unsigned int, child_ns_inum, + ({ + unsigned int child_ns_inum = 0; + + if (child) { + struct pid_namespace *pid_ns; + + pid_ns = task_active_pid_ns(child); + if (pid_ns) + child_ns_inum = + pid_ns->ns.inum; + } + child_ns_inum; + })) + ), + + TP_code_post() +) + +/* + * Tracepoint for exec: + */ +LTTNG_TRACEPOINT_EVENT(sched_process_exec, + + TP_PROTO(struct task_struct *p, pid_t old_pid, + struct linux_binprm *bprm), + + TP_ARGS(p, old_pid, bprm), + + TP_FIELDS( + ctf_string(filename, bprm->filename) + ctf_integer(pid_t, tid, p->pid) + ctf_integer(pid_t, old_tid, old_pid) + ) +) + +/* + * XXX the below sched_stat tracepoints only apply to SCHED_OTHER/BATCH/IDLE + * adding sched_stat support to SCHED_FIFO/RR would be welcome. + */ +LTTNG_TRACEPOINT_EVENT_CLASS(sched_stat_template, + + TP_PROTO(struct task_struct *tsk, u64 delay), + + TP_ARGS(tsk, delay), + + TP_FIELDS( + ctf_array_text(char, comm, tsk->comm, TASK_COMM_LEN) + ctf_integer(pid_t, tid, tsk->pid) + ctf_integer(u64, delay, delay) + ) +) + + +/* + * Tracepoint for accounting wait time (time the task is runnable + * but not actually running due to scheduler contention). + */ +LTTNG_TRACEPOINT_EVENT_INSTANCE(sched_stat_template, sched_stat_wait, + TP_PROTO(struct task_struct *tsk, u64 delay), + TP_ARGS(tsk, delay)) + +/* + * Tracepoint for accounting sleep time (time the task is not runnable, + * including iowait, see below). + */ +LTTNG_TRACEPOINT_EVENT_INSTANCE(sched_stat_template, sched_stat_sleep, + TP_PROTO(struct task_struct *tsk, u64 delay), + TP_ARGS(tsk, delay)) + +/* + * Tracepoint for accounting iowait time (time the task is not runnable + * due to waiting on IO to complete). + */ +LTTNG_TRACEPOINT_EVENT_INSTANCE(sched_stat_template, sched_stat_iowait, + TP_PROTO(struct task_struct *tsk, u64 delay), + TP_ARGS(tsk, delay)) + +/* + * Tracepoint for accounting blocked time (time the task is in uninterruptible). + */ +LTTNG_TRACEPOINT_EVENT_INSTANCE(sched_stat_template, sched_stat_blocked, + TP_PROTO(struct task_struct *tsk, u64 delay), + TP_ARGS(tsk, delay)) + +/* + * Tracepoint for accounting runtime (time the task is executing + * on a CPU). + */ +LTTNG_TRACEPOINT_EVENT(sched_stat_runtime, + + TP_PROTO(struct task_struct *tsk, u64 runtime, u64 vruntime), + + TP_ARGS(tsk, runtime, vruntime), + + TP_FIELDS( + ctf_array_text(char, comm, tsk->comm, TASK_COMM_LEN) + ctf_integer(pid_t, tid, tsk->pid) + ctf_integer(u64, runtime, runtime) + ctf_integer(u64, vruntime, vruntime) + ) +) + +/* + * Tracepoint for showing priority inheritance modifying a tasks + * priority. + */ +LTTNG_TRACEPOINT_EVENT(sched_pi_setprio, + + TP_PROTO(struct task_struct *tsk, struct task_struct *pi_task), + + TP_ARGS(tsk, pi_task), + + TP_FIELDS( + ctf_array_text(char, comm, tsk->comm, TASK_COMM_LEN) + ctf_integer(pid_t, tid, tsk->pid) + ctf_integer(int, oldprio, tsk->prio - MAX_RT_PRIO) + ctf_integer(int, newprio, pi_task ? pi_task->prio - MAX_RT_PRIO : tsk->prio - MAX_RT_PRIO) + ) +) + +#endif /* LTTNG_TRACE_SCHED_H */ + +/* This part must be outside protection */ +#include diff --git a/include/instrumentation/events/lttng-module/scsi.h b/include/instrumentation/events/lttng-module/scsi.h new file mode 100644 index 00000000..ea317adc --- /dev/null +++ b/include/instrumentation/events/lttng-module/scsi.h @@ -0,0 +1,289 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#undef TRACE_SYSTEM +#define TRACE_SYSTEM scsi + +#if !defined(LTTNG_TRACE_SCSI_H) || defined(TRACE_HEADER_MULTI_READ) +#define LTTNG_TRACE_SCSI_H + +#include +#include +#include +#include + +#ifndef _TRACE_SCSI_DEF +#define _TRACE_SCSI_DEF + +#define scsi_opcode_name(opcode) { opcode, #opcode } + +#define show_opcode_name(val) \ + __print_symbolic(val, \ + scsi_opcode_name(TEST_UNIT_READY), \ + scsi_opcode_name(REZERO_UNIT), \ + scsi_opcode_name(REQUEST_SENSE), \ + scsi_opcode_name(FORMAT_UNIT), \ + scsi_opcode_name(READ_BLOCK_LIMITS), \ + scsi_opcode_name(REASSIGN_BLOCKS), \ + scsi_opcode_name(INITIALIZE_ELEMENT_STATUS), \ + scsi_opcode_name(READ_6), \ + scsi_opcode_name(WRITE_6), \ + scsi_opcode_name(SEEK_6), \ + scsi_opcode_name(READ_REVERSE), \ + scsi_opcode_name(WRITE_FILEMARKS), \ + scsi_opcode_name(SPACE), \ + scsi_opcode_name(INQUIRY), \ + scsi_opcode_name(RECOVER_BUFFERED_DATA), \ + scsi_opcode_name(MODE_SELECT), \ + scsi_opcode_name(RESERVE), \ + scsi_opcode_name(RELEASE), \ + scsi_opcode_name(COPY), \ + scsi_opcode_name(ERASE), \ + scsi_opcode_name(MODE_SENSE), \ + scsi_opcode_name(START_STOP), \ + scsi_opcode_name(RECEIVE_DIAGNOSTIC), \ + scsi_opcode_name(SEND_DIAGNOSTIC), \ + scsi_opcode_name(ALLOW_MEDIUM_REMOVAL), \ + scsi_opcode_name(SET_WINDOW), \ + scsi_opcode_name(READ_CAPACITY), \ + scsi_opcode_name(READ_10), \ + scsi_opcode_name(WRITE_10), \ + scsi_opcode_name(SEEK_10), \ + scsi_opcode_name(POSITION_TO_ELEMENT), \ + scsi_opcode_name(WRITE_VERIFY), \ + scsi_opcode_name(VERIFY), \ + scsi_opcode_name(SEARCH_HIGH), \ + scsi_opcode_name(SEARCH_EQUAL), \ + scsi_opcode_name(SEARCH_LOW), \ + scsi_opcode_name(SET_LIMITS), \ + scsi_opcode_name(PRE_FETCH), \ + scsi_opcode_name(READ_POSITION), \ + scsi_opcode_name(SYNCHRONIZE_CACHE), \ + scsi_opcode_name(LOCK_UNLOCK_CACHE), \ + scsi_opcode_name(READ_DEFECT_DATA), \ + scsi_opcode_name(MEDIUM_SCAN), \ + scsi_opcode_name(COMPARE), \ + scsi_opcode_name(COPY_VERIFY), \ + scsi_opcode_name(WRITE_BUFFER), \ + scsi_opcode_name(READ_BUFFER), \ + scsi_opcode_name(UPDATE_BLOCK), \ + scsi_opcode_name(READ_LONG), \ + scsi_opcode_name(WRITE_LONG), \ + scsi_opcode_name(CHANGE_DEFINITION), \ + scsi_opcode_name(WRITE_SAME), \ + scsi_opcode_name(UNMAP), \ + scsi_opcode_name(READ_TOC), \ + scsi_opcode_name(LOG_SELECT), \ + scsi_opcode_name(LOG_SENSE), \ + scsi_opcode_name(XDWRITEREAD_10), \ + scsi_opcode_name(MODE_SELECT_10), \ + scsi_opcode_name(RESERVE_10), \ + scsi_opcode_name(RELEASE_10), \ + scsi_opcode_name(MODE_SENSE_10), \ + scsi_opcode_name(PERSISTENT_RESERVE_IN), \ + scsi_opcode_name(PERSISTENT_RESERVE_OUT), \ + scsi_opcode_name(VARIABLE_LENGTH_CMD), \ + scsi_opcode_name(REPORT_LUNS), \ + scsi_opcode_name(MAINTENANCE_IN), \ + scsi_opcode_name(MAINTENANCE_OUT), \ + scsi_opcode_name(MOVE_MEDIUM), \ + scsi_opcode_name(EXCHANGE_MEDIUM), \ + scsi_opcode_name(READ_12), \ + scsi_opcode_name(WRITE_12), \ + scsi_opcode_name(WRITE_VERIFY_12), \ + scsi_opcode_name(SEARCH_HIGH_12), \ + scsi_opcode_name(SEARCH_EQUAL_12), \ + scsi_opcode_name(SEARCH_LOW_12), \ + scsi_opcode_name(READ_ELEMENT_STATUS), \ + scsi_opcode_name(SEND_VOLUME_TAG), \ + scsi_opcode_name(WRITE_LONG_2), \ + scsi_opcode_name(READ_16), \ + scsi_opcode_name(WRITE_16), \ + scsi_opcode_name(VERIFY_16), \ + scsi_opcode_name(WRITE_SAME_16), \ + scsi_opcode_name(ZBC_OUT), \ + scsi_opcode_name(ZBC_IN), \ + scsi_opcode_name(SERVICE_ACTION_IN_16), \ + scsi_opcode_name(READ_32), \ + scsi_opcode_name(WRITE_32), \ + scsi_opcode_name(WRITE_SAME_32), \ + scsi_opcode_name(ATA_16), \ + scsi_opcode_name(ATA_12)) + +#define scsi_hostbyte_name(result) { result, #result } +#define show_hostbyte_name(val) \ + __print_symbolic(val, \ + scsi_hostbyte_name(DID_OK), \ + scsi_hostbyte_name(DID_NO_CONNECT), \ + scsi_hostbyte_name(DID_BUS_BUSY), \ + scsi_hostbyte_name(DID_TIME_OUT), \ + scsi_hostbyte_name(DID_BAD_TARGET), \ + scsi_hostbyte_name(DID_ABORT), \ + scsi_hostbyte_name(DID_PARITY), \ + scsi_hostbyte_name(DID_ERROR), \ + scsi_hostbyte_name(DID_RESET), \ + scsi_hostbyte_name(DID_BAD_INTR), \ + scsi_hostbyte_name(DID_PASSTHROUGH), \ + scsi_hostbyte_name(DID_SOFT_ERROR), \ + scsi_hostbyte_name(DID_IMM_RETRY), \ + scsi_hostbyte_name(DID_REQUEUE), \ + scsi_hostbyte_name(DID_TRANSPORT_DISRUPTED), \ + scsi_hostbyte_name(DID_TRANSPORT_FAILFAST)) + +#define scsi_driverbyte_name(result) { result, #result } +#define show_driverbyte_name(val) \ + __print_symbolic(val, \ + scsi_driverbyte_name(DRIVER_OK), \ + scsi_driverbyte_name(DRIVER_BUSY), \ + scsi_driverbyte_name(DRIVER_SOFT), \ + scsi_driverbyte_name(DRIVER_MEDIA), \ + scsi_driverbyte_name(DRIVER_ERROR), \ + scsi_driverbyte_name(DRIVER_INVALID), \ + scsi_driverbyte_name(DRIVER_TIMEOUT), \ + scsi_driverbyte_name(DRIVER_HARD), \ + scsi_driverbyte_name(DRIVER_SENSE)) + +#define scsi_msgbyte_name(result) { result, #result } +#define show_msgbyte_name(val) \ + __print_symbolic(val, \ + scsi_msgbyte_name(COMMAND_COMPLETE), \ + scsi_msgbyte_name(EXTENDED_MESSAGE), \ + scsi_msgbyte_name(SAVE_POINTERS), \ + scsi_msgbyte_name(RESTORE_POINTERS), \ + scsi_msgbyte_name(DISCONNECT), \ + scsi_msgbyte_name(INITIATOR_ERROR), \ + scsi_msgbyte_name(ABORT_TASK_SET), \ + scsi_msgbyte_name(MESSAGE_REJECT), \ + scsi_msgbyte_name(NOP), \ + scsi_msgbyte_name(MSG_PARITY_ERROR), \ + scsi_msgbyte_name(LINKED_CMD_COMPLETE), \ + scsi_msgbyte_name(LINKED_FLG_CMD_COMPLETE), \ + scsi_msgbyte_name(TARGET_RESET), \ + scsi_msgbyte_name(ABORT_TASK), \ + scsi_msgbyte_name(CLEAR_TASK_SET), \ + scsi_msgbyte_name(INITIATE_RECOVERY), \ + scsi_msgbyte_name(RELEASE_RECOVERY), \ + scsi_msgbyte_name(CLEAR_ACA), \ + scsi_msgbyte_name(LOGICAL_UNIT_RESET), \ + scsi_msgbyte_name(SIMPLE_QUEUE_TAG), \ + scsi_msgbyte_name(HEAD_OF_QUEUE_TAG), \ + scsi_msgbyte_name(ORDERED_QUEUE_TAG), \ + scsi_msgbyte_name(IGNORE_WIDE_RESIDUE), \ + scsi_msgbyte_name(ACA), \ + scsi_msgbyte_name(QAS_REQUEST), \ + scsi_msgbyte_name(BUS_DEVICE_RESET), \ + scsi_msgbyte_name(ABORT)) + +#define scsi_statusbyte_name(result) { result, #result } +#define show_statusbyte_name(val) \ + __print_symbolic(val, \ + scsi_statusbyte_name(SAM_STAT_GOOD), \ + scsi_statusbyte_name(SAM_STAT_CHECK_CONDITION), \ + scsi_statusbyte_name(SAM_STAT_CONDITION_MET), \ + scsi_statusbyte_name(SAM_STAT_BUSY), \ + scsi_statusbyte_name(SAM_STAT_INTERMEDIATE), \ + scsi_statusbyte_name(SAM_STAT_INTERMEDIATE_CONDITION_MET), \ + scsi_statusbyte_name(SAM_STAT_RESERVATION_CONFLICT), \ + scsi_statusbyte_name(SAM_STAT_COMMAND_TERMINATED), \ + scsi_statusbyte_name(SAM_STAT_TASK_SET_FULL), \ + scsi_statusbyte_name(SAM_STAT_ACA_ACTIVE), \ + scsi_statusbyte_name(SAM_STAT_TASK_ABORTED)) + +#define scsi_prot_op_name(result) { result, #result } +#define show_prot_op_name(val) \ + __print_symbolic(val, \ + scsi_prot_op_name(SCSI_PROT_NORMAL), \ + scsi_prot_op_name(SCSI_PROT_READ_INSERT), \ + scsi_prot_op_name(SCSI_PROT_WRITE_STRIP), \ + scsi_prot_op_name(SCSI_PROT_READ_STRIP), \ + scsi_prot_op_name(SCSI_PROT_WRITE_INSERT), \ + scsi_prot_op_name(SCSI_PROT_READ_PASS), \ + scsi_prot_op_name(SCSI_PROT_WRITE_PASS)) + +const char *scsi_trace_parse_cdb(struct trace_seq*, unsigned char*, int); +#define __parse_cdb(cdb, len) scsi_trace_parse_cdb(p, cdb, len) +#endif + +LTTNG_TRACEPOINT_EVENT(scsi_dispatch_cmd_start, + + TP_PROTO(struct scsi_cmnd *cmd), + + TP_ARGS(cmd), + + TP_FIELDS( + ctf_integer(unsigned int, host_no, cmd->device->host->host_no) + ctf_integer(unsigned int, channel, cmd->device->channel) + ctf_integer(unsigned int, id, cmd->device->id) + ctf_integer(unsigned int, lun, cmd->device->lun) + ctf_integer(unsigned int, opcode, cmd->cmnd[0]) + ctf_integer(unsigned int, cmd_len, cmd->cmd_len) + ctf_integer(unsigned int, data_sglen, scsi_sg_count(cmd)) + ctf_integer(unsigned int, prot_sglen, scsi_prot_sg_count(cmd)) + ctf_integer(unsigned char, prot_op, scsi_get_prot_op(cmd)) + ctf_sequence_hex(unsigned char, cmnd, cmd->cmnd, u32, cmd->cmd_len) + ) +) + +LTTNG_TRACEPOINT_EVENT(scsi_dispatch_cmd_error, + + TP_PROTO(struct scsi_cmnd *cmd, int rtn), + + TP_ARGS(cmd, rtn), + + TP_FIELDS( + ctf_integer(unsigned int, host_no, cmd->device->host->host_no) + ctf_integer(unsigned int, channel, cmd->device->channel) + ctf_integer(unsigned int, id, cmd->device->id) + ctf_integer(unsigned int, lun, cmd->device->lun) + ctf_integer(int, rtn, rtn) + ctf_integer(unsigned int, opcode, cmd->cmnd[0]) + ctf_integer(unsigned int, cmd_len, cmd->cmd_len) + ctf_integer(unsigned int, data_sglen, scsi_sg_count(cmd)) + ctf_integer(unsigned int, prot_sglen, scsi_prot_sg_count(cmd)) + ctf_integer(unsigned char, prot_op, scsi_get_prot_op(cmd)) + ctf_sequence_hex(unsigned char, cmnd, cmd->cmnd, u32, cmd->cmd_len) + ) +) + +LTTNG_TRACEPOINT_EVENT_CLASS(scsi_cmd_done_timeout_template, + + TP_PROTO(struct scsi_cmnd *cmd), + + TP_ARGS(cmd), + + TP_FIELDS( + ctf_integer(unsigned int, host_no, cmd->device->host->host_no) + ctf_integer(unsigned int, channel, cmd->device->channel) + ctf_integer(unsigned int, id, cmd->device->id) + ctf_integer(unsigned int, lun, cmd->device->lun) + ctf_integer(int, result, cmd->result) + ctf_integer(unsigned int, opcode, cmd->cmnd[0]) + ctf_integer(unsigned int, cmd_len, cmd->cmd_len) + ctf_integer(unsigned int, data_sglen, scsi_sg_count(cmd)) + ctf_integer(unsigned int, prot_sglen, scsi_prot_sg_count(cmd)) + ctf_integer(unsigned char, prot_op, scsi_get_prot_op(cmd)) + ctf_sequence_hex(unsigned char, cmnd, cmd->cmnd, u32, cmd->cmd_len) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(scsi_cmd_done_timeout_template, scsi_dispatch_cmd_done, + TP_PROTO(struct scsi_cmnd *cmd), + TP_ARGS(cmd)) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(scsi_cmd_done_timeout_template, scsi_dispatch_cmd_timeout, + TP_PROTO(struct scsi_cmnd *cmd), + TP_ARGS(cmd)) + +LTTNG_TRACEPOINT_EVENT(scsi_eh_wakeup, + + TP_PROTO(struct Scsi_Host *shost), + + TP_ARGS(shost), + + TP_FIELDS( + ctf_integer(unsigned int, host_no, shost->host_no) + ) +) + +#endif /* LTTNG_TRACE_SCSI_H */ + +/* This part must be outside protection */ +#include diff --git a/include/instrumentation/events/lttng-module/signal.h b/include/instrumentation/events/lttng-module/signal.h new file mode 100644 index 00000000..8af34d7a --- /dev/null +++ b/include/instrumentation/events/lttng-module/signal.h @@ -0,0 +1,86 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#undef TRACE_SYSTEM +#define TRACE_SYSTEM signal + +#if !defined(LTTNG_TRACE_SIGNAL_H) || defined(TRACE_HEADER_MULTI_READ) +#define LTTNG_TRACE_SIGNAL_H + +#include + +#ifndef _TRACE_SIGNAL_DEF +#define _TRACE_SIGNAL_DEF +#include +#include +#undef LTTNG_FIELDS_SIGINFO +#define LTTNG_FIELDS_SIGINFO(info) \ + ctf_integer(int, errno, \ + (info == SEND_SIG_NOINFO || info == SEND_SIG_PRIV) ? \ + 0 : \ + info->si_errno) \ + ctf_integer(int, code, \ + (info == SEND_SIG_NOINFO) ? \ + SI_USER : \ + ((info == SEND_SIG_PRIV) ? SI_KERNEL : info->si_code)) +#endif /* _TRACE_SIGNAL_DEF */ + +/** + * signal_generate - called when a signal is generated + * @sig: signal number + * @info: pointer to struct siginfo + * @task: pointer to struct task_struct + * + * Current process sends a 'sig' signal to 'task' process with + * 'info' siginfo. If 'info' is SEND_SIG_NOINFO or SEND_SIG_PRIV, + * 'info' is not a pointer and you can't access its field. Instead, + * SEND_SIG_NOINFO means that si_code is SI_USER, and SEND_SIG_PRIV + * means that si_code is SI_KERNEL. + */ +LTTNG_TRACEPOINT_EVENT(signal_generate, + + TP_PROTO(int sig, struct kernel_siginfo *info, struct task_struct *task, + int group, int result), + + TP_ARGS(sig, info, task, group, result), + + TP_FIELDS( + ctf_integer(int, sig, sig) + LTTNG_FIELDS_SIGINFO(info) + ctf_array_text(char, comm, task->comm, TASK_COMM_LEN) + ctf_integer(pid_t, pid, task->pid) + ctf_integer(int, group, group) + ctf_integer(int, result, result) + ) +) + +/** + * signal_deliver - called when a signal is delivered + * @sig: signal number + * @info: pointer to struct siginfo + * @ka: pointer to struct k_sigaction + * + * A 'sig' signal is delivered to current process with 'info' siginfo, + * and it will be handled by 'ka'. ka->sa.sa_handler can be SIG_IGN or + * SIG_DFL. + * Note that some signals reported by signal_generate tracepoint can be + * lost, ignored or modified (by debugger) before hitting this tracepoint. + * This means, this can show which signals are actually delivered, but + * matching generated signals and delivered signals may not be correct. + */ +LTTNG_TRACEPOINT_EVENT(signal_deliver, + + TP_PROTO(int sig, struct kernel_siginfo *info, struct k_sigaction *ka), + + TP_ARGS(sig, info, ka), + + TP_FIELDS( + ctf_integer(int, sig, sig) + LTTNG_FIELDS_SIGINFO(info) + ctf_integer(unsigned long, sa_handler, (unsigned long) ka->sa.sa_handler) + ctf_integer(unsigned long, sa_flags, ka->sa.sa_flags) + ) +) + +#endif /* LTTNG_TRACE_SIGNAL_H */ + +/* This part must be outside protection */ +#include diff --git a/include/instrumentation/events/lttng-module/skb.h b/include/instrumentation/events/lttng-module/skb.h new file mode 100644 index 00000000..63afe180 --- /dev/null +++ b/include/instrumentation/events/lttng-module/skb.h @@ -0,0 +1,58 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#undef TRACE_SYSTEM +#define TRACE_SYSTEM skb + +#if !defined(LTTNG_TRACE_SKB_H) || defined(TRACE_HEADER_MULTI_READ) +#define LTTNG_TRACE_SKB_H + +#include +#include +#include + +/* + * Tracepoint for free an sk_buff: + */ +LTTNG_TRACEPOINT_EVENT_MAP(kfree_skb, + + skb_kfree, + + TP_PROTO(struct sk_buff *skb, void *location), + + TP_ARGS(skb, location), + + TP_FIELDS( + ctf_integer_hex(void *, skbaddr, skb) + ctf_integer_hex(void *, location, location) + ctf_integer_network(unsigned short, protocol, skb->protocol) + ) +) + +LTTNG_TRACEPOINT_EVENT_MAP(consume_skb, + + skb_consume, + + TP_PROTO(struct sk_buff *skb), + + TP_ARGS(skb), + + TP_FIELDS( + ctf_integer_hex(void *, skbaddr, skb) + ) +) + +LTTNG_TRACEPOINT_EVENT(skb_copy_datagram_iovec, + + TP_PROTO(const struct sk_buff *skb, int len), + + TP_ARGS(skb, len), + + TP_FIELDS( + ctf_integer_hex(const void *, skbaddr, skb) + ctf_integer(int, len, len) + ) +) + +#endif /* LTTNG_TRACE_SKB_H */ + +/* This part must be outside protection */ +#include diff --git a/include/instrumentation/events/lttng-module/sock.h b/include/instrumentation/events/lttng-module/sock.h new file mode 100644 index 00000000..532f511e --- /dev/null +++ b/include/instrumentation/events/lttng-module/sock.h @@ -0,0 +1,46 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#undef TRACE_SYSTEM +#define TRACE_SYSTEM sock + +#if !defined(LTTNG_TRACE_SOCK_H) || defined(TRACE_HEADER_MULTI_READ) +#define LTTNG_TRACE_SOCK_H + +#include +#include + +LTTNG_TRACEPOINT_EVENT(sock_rcvqueue_full, + + TP_PROTO(struct sock *sk, struct sk_buff *skb), + + TP_ARGS(sk, skb), + + TP_FIELDS( + ctf_integer(int, rmem_alloc, atomic_read(&sk->sk_rmem_alloc)) + ctf_integer(unsigned int, truesize, skb->truesize) + ctf_integer(int, sk_rcvbuf, sk->sk_rcvbuf) + ) +) + +LTTNG_TRACEPOINT_EVENT(sock_exceed_buf_limit, + + TP_PROTO(struct sock *sk, struct proto *prot, long allocated, int kind), + + TP_ARGS(sk, prot, allocated, kind), + + TP_FIELDS( + ctf_string(name, prot->name) + ctf_array(long, sysctl_mem, prot->sysctl_mem, 3) + ctf_integer(long, allocated, allocated) + ctf_integer(int, sysctl_rmem, sk_get_rmem0(sk, prot)) + ctf_integer(int, rmem_alloc, atomic_read(&sk->sk_rmem_alloc)) + ctf_integer(int, sysctl_wmem, sk_get_wmem0(sk, prot)) + ctf_integer(int, wmem_alloc, refcount_read(&sk->sk_wmem_alloc)) + ctf_integer(int, wmem_queued, sk->sk_wmem_queued) + ctf_integer(int, kind, kind) + ) +) + +#endif /* LTTNG_TRACE_SOCK_H */ + +/* This part must be outside protection */ +#include diff --git a/include/instrumentation/events/lttng-module/timer.h b/include/instrumentation/events/lttng-module/timer.h new file mode 100644 index 00000000..c8f3507c --- /dev/null +++ b/include/instrumentation/events/lttng-module/timer.h @@ -0,0 +1,271 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#undef TRACE_SYSTEM +#define TRACE_SYSTEM timer + +#if !defined(LTTNG_TRACE_TIMER_H) || defined(TRACE_HEADER_MULTI_READ) +#define LTTNG_TRACE_TIMER_H + +#include + +#ifndef _TRACE_TIMER_DEF_ +#define _TRACE_TIMER_DEF_ +#include +#include + +struct timer_list; + +#endif /* _TRACE_TIMER_DEF_ */ + +#define lttng_ktime_get_tv64(kt) (kt) + +LTTNG_TRACEPOINT_EVENT_CLASS(timer_class, + + TP_PROTO(struct timer_list *timer), + + TP_ARGS(timer), + + TP_FIELDS( + ctf_integer_hex(void *, timer, timer) + ) +) + +/** + * timer_init - called when the timer is initialized + * @timer: pointer to struct timer_list + */ +LTTNG_TRACEPOINT_EVENT_INSTANCE(timer_class, timer_init, + + TP_PROTO(struct timer_list *timer), + + TP_ARGS(timer) +) + +/** + * timer_start - called when the timer is started + * @timer: pointer to struct timer_list + * @expires: the timers expiry time + * @flags: the timers expiry time + */ +LTTNG_TRACEPOINT_EVENT(timer_start, + + TP_PROTO(struct timer_list *timer, unsigned long expires, + unsigned int flags), + + TP_ARGS(timer, expires, flags), + + TP_FIELDS( + ctf_integer_hex(void *, timer, timer) + ctf_integer_hex(void *, function, timer->function) + ctf_integer(unsigned long, expires, expires) + ctf_integer(unsigned long, now, jiffies) + ctf_integer(unsigned int, flags, flags) + ) +) + +/** + * timer_expire_entry - called immediately before the timer callback + * @timer: pointer to struct timer_list + * + * Allows to determine the timer latency. + */ +LTTNG_TRACEPOINT_EVENT(timer_expire_entry, + + TP_PROTO(struct timer_list *timer, unsigned long baseclk), + + TP_ARGS(timer, baseclk), + + TP_FIELDS( + ctf_integer_hex(void *, timer, timer) + ctf_integer(unsigned long, now, jiffies) + ctf_integer_hex(void *, function, timer->function) + ctf_integer(unsigned long, baseclk, baseclk) + ) +) + +/** + * timer_expire_exit - called immediately after the timer callback returns + * @timer: pointer to struct timer_list + * + * When used in combination with the timer_expire_entry tracepoint we can + * determine the runtime of the timer callback function. + * + * NOTE: Do NOT derefernce timer in TP_fast_assign. The pointer might + * be invalid. We solely track the pointer. + */ +LTTNG_TRACEPOINT_EVENT_INSTANCE(timer_class, timer_expire_exit, + + TP_PROTO(struct timer_list *timer), + + TP_ARGS(timer) +) + +/** + * timer_cancel - called when the timer is canceled + * @timer: pointer to struct timer_list + */ +LTTNG_TRACEPOINT_EVENT_INSTANCE(timer_class, timer_cancel, + + TP_PROTO(struct timer_list *timer), + + TP_ARGS(timer) +) + +/** + * hrtimer_init - called when the hrtimer is initialized + * @timer: pointer to struct hrtimer + * @clockid: the hrtimers clock + * @mode: the hrtimers mode + */ +LTTNG_TRACEPOINT_EVENT_MAP(hrtimer_init, + + timer_hrtimer_init, + + TP_PROTO(struct hrtimer *hrtimer, clockid_t clockid, + enum hrtimer_mode mode), + + TP_ARGS(hrtimer, clockid, mode), + + TP_FIELDS( + ctf_integer_hex(void *, hrtimer, hrtimer) + ctf_integer(clockid_t, clockid, clockid) + ctf_integer(enum hrtimer_mode, mode, mode) + ) +) + +/** + * hrtimer_start - called when the hrtimer is started + * @timer: pointer to struct hrtimer + */ +LTTNG_TRACEPOINT_EVENT_MAP(hrtimer_start, + + timer_hrtimer_start, + + TP_PROTO(struct hrtimer *hrtimer, enum hrtimer_mode mode), + + TP_ARGS(hrtimer, mode), + + TP_FIELDS( + ctf_integer_hex(void *, hrtimer, hrtimer) + ctf_integer_hex(void *, function, hrtimer->function) + ctf_integer(s64, expires, + lttng_ktime_get_tv64(hrtimer_get_expires(hrtimer))) + ctf_integer(s64, softexpires, + lttng_ktime_get_tv64(hrtimer_get_softexpires(hrtimer))) + ctf_integer(enum hrtimer_mode, mode, mode) + ) +) + +/** + * htimmer_expire_entry - called immediately before the hrtimer callback + * @timer: pointer to struct hrtimer + * @now: pointer to variable which contains current time of the + * timers base. + * + * Allows to determine the timer latency. + */ +LTTNG_TRACEPOINT_EVENT_MAP(hrtimer_expire_entry, + + timer_hrtimer_expire_entry, + + TP_PROTO(struct hrtimer *hrtimer, ktime_t *now), + + TP_ARGS(hrtimer, now), + + TP_FIELDS( + ctf_integer_hex(void *, hrtimer, hrtimer) + ctf_integer(s64, now, lttng_ktime_get_tv64(*now)) + ctf_integer_hex(void *, function, hrtimer->function) + ) +) + +LTTNG_TRACEPOINT_EVENT_CLASS(timer_hrtimer_class, + + TP_PROTO(struct hrtimer *hrtimer), + + TP_ARGS(hrtimer), + + TP_FIELDS( + ctf_integer_hex(void *, hrtimer, hrtimer) + ) +) + +/** + * hrtimer_expire_exit - called immediately after the hrtimer callback returns + * @timer: pointer to struct hrtimer + * + * When used in combination with the hrtimer_expire_entry tracepoint we can + * determine the runtime of the callback function. + */ +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(timer_hrtimer_class, hrtimer_expire_exit, + + timer_hrtimer_expire_exit, + + TP_PROTO(struct hrtimer *hrtimer), + + TP_ARGS(hrtimer) +) + +/** + * hrtimer_cancel - called when the hrtimer is canceled + * @hrtimer: pointer to struct hrtimer + */ +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(timer_hrtimer_class, hrtimer_cancel, + + timer_hrtimer_cancel, + + TP_PROTO(struct hrtimer *hrtimer), + + TP_ARGS(hrtimer) +) + +/** + * itimer_state - called when itimer is started or canceled + * @which: name of the interval timer + * @value: the itimers value, itimer is canceled if value->it_value is + * zero, otherwise it is started + * @expires: the itimers expiry time + */ +LTTNG_TRACEPOINT_EVENT_MAP(itimer_state, + + timer_itimer_state, + + TP_PROTO(int which, const struct itimerspec64 *const value, + unsigned long long expires), + + TP_ARGS(which, value, expires), + + TP_FIELDS( + ctf_integer(int, which, which) + ctf_integer(unsigned long long, expires, expires) + ctf_integer(long, value_sec, value->it_value.tv_sec) + ctf_integer(long, value_nsec, value->it_value.tv_nsec) + ctf_integer(long, interval_sec, value->it_interval.tv_sec) + ctf_integer(long, interval_nsec, value->it_interval.tv_nsec) + ) +) + +/** + * itimer_expire - called when itimer expires + * @which: type of the interval timer + * @pid: pid of the process which owns the timer + * @now: current time, used to calculate the latency of itimer + */ +LTTNG_TRACEPOINT_EVENT_MAP(itimer_expire, + + timer_itimer_expire, + + TP_PROTO(int which, struct pid *pid, unsigned long long now), + + TP_ARGS(which, pid, now), + + TP_FIELDS( + ctf_integer(int , which, which) + ctf_integer(pid_t, pid, pid_nr(pid)) + ctf_integer(unsigned long long, now, now) + ) +) + +#endif /* LTTNG_TRACE_TIMER_H */ + +/* This part must be outside protection */ +#include diff --git a/include/instrumentation/events/lttng-module/udp.h b/include/instrumentation/events/lttng-module/udp.h new file mode 100644 index 00000000..ec7ba2fd --- /dev/null +++ b/include/instrumentation/events/lttng-module/udp.h @@ -0,0 +1,26 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#undef TRACE_SYSTEM +#define TRACE_SYSTEM udp + +#if !defined(LTTNG_TRACE_UDP_H) || defined(TRACE_HEADER_MULTI_READ) +#define LTTNG_TRACE_UDP_H + +#include +#include + +LTTNG_TRACEPOINT_EVENT(udp_fail_queue_rcv_skb, + + TP_PROTO(int rc, struct sock *sk), + + TP_ARGS(rc, sk), + + TP_FIELDS( + ctf_integer(int, rc, rc) + ctf_integer(__u16, lport, inet_sk(sk)->inet_num) + ) +) + +#endif /* LTTNG_TRACE_UDP_H */ + +/* This part must be outside protection */ +#include diff --git a/include/instrumentation/events/lttng-module/v4l2.h b/include/instrumentation/events/lttng-module/v4l2.h new file mode 100644 index 00000000..c42aa4c5 --- /dev/null +++ b/include/instrumentation/events/lttng-module/v4l2.h @@ -0,0 +1,55 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#undef TRACE_SYSTEM +#define TRACE_SYSTEM v4l2 + +#if !defined(LTTNG_TRACE_V4L2_H) || defined(TRACE_HEADER_MULTI_READ) +#define LTTNG_TRACE_V4L2_H + +#include + +LTTNG_TRACEPOINT_EVENT_CLASS(v4l2_class, + + TP_PROTO(int minor, struct v4l2_buffer *buf), + + TP_ARGS(minor, buf), + + TP_FIELDS( + ctf_integer(int, minor, minor) + ctf_integer(u32, index, buf->index) + ctf_integer(u32, type, buf->type) + ctf_integer(u32, bytesused, buf->bytesused) + ctf_integer(u32, flags, buf->flags) + ctf_integer(u32, field, buf->field) + ctf_integer(s64, timestamp, v4l2_buffer_get_timestamp(buf)) + ctf_integer(u32, timecode_type, buf->timecode.type) + ctf_integer(u32, timecode_flags, buf->timecode.flags) + ctf_integer(u8, timecode_frames, buf->timecode.frames) + ctf_integer(u8, timecode_seconds, buf->timecode.seconds) + ctf_integer(u8, timecode_minutes, buf->timecode.minutes) + ctf_integer(u8, timecode_hours, buf->timecode.hours) + ctf_array(u8, timecode_userbits, buf->timecode.userbits, 4) + ctf_integer(u32, sequence, buf->sequence) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(v4l2_class, + v4l2_dqbuf, + + TP_PROTO(int minor, struct v4l2_buffer *buf), + + TP_ARGS(minor, buf) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(v4l2_class, + + v4l2_qbuf, + + TP_PROTO(int minor, struct v4l2_buffer *buf), + + TP_ARGS(minor, buf) +) + +#endif /* if !defined(LTTNG_TRACE_V4L2_H) || defined(TRACE_HEADER_MULTI_READ) */ + +/* This part must be outside protection */ +#include diff --git a/include/instrumentation/events/lttng-module/workqueue.h b/include/instrumentation/events/lttng-module/workqueue.h new file mode 100644 index 00000000..dcd3f017 --- /dev/null +++ b/include/instrumentation/events/lttng-module/workqueue.h @@ -0,0 +1,109 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#undef TRACE_SYSTEM +#define TRACE_SYSTEM workqueue + +#if !defined(LTTNG_TRACE_WORKQUEUE_H) || defined(TRACE_HEADER_MULTI_READ) +#define LTTNG_TRACE_WORKQUEUE_H + +#include +#include + +#ifndef _TRACE_WORKQUEUE_DEF_ +#define _TRACE_WORKQUEUE_DEF_ + +struct worker; +struct global_cwq; + +#endif + +LTTNG_TRACEPOINT_EVENT_CLASS(workqueue_work, + + TP_PROTO(struct work_struct *work), + + TP_ARGS(work), + + TP_FIELDS( + ctf_integer_hex(void *, work, work) + ) +) + +/** + * workqueue_queue_work - called when a work gets queued + * @req_cpu: the requested cpu + * @cwq: pointer to struct cpu_workqueue_struct + * @work: pointer to struct work_struct + * + * This event occurs when a work is queued immediately or once a + * delayed work is actually queued on a workqueue (ie: once the delay + * has been reached). + */ +LTTNG_TRACEPOINT_EVENT(workqueue_queue_work, + + TP_PROTO(unsigned int req_cpu, struct pool_workqueue *pwq, + struct work_struct *work), + + TP_ARGS(req_cpu, pwq, work), + + TP_FIELDS( + ctf_integer_hex(void *, work, work) + ctf_integer_hex(void *, function, work->func) + ctf_integer(unsigned int, req_cpu, req_cpu) + ) +) + +/** + * workqueue_activate_work - called when a work gets activated + * @work: pointer to struct work_struct + * + * This event occurs when a queued work is put on the active queue, + * which happens immediately after queueing unless @max_active limit + * is reached. + */ +LTTNG_TRACEPOINT_EVENT_INSTANCE(workqueue_work, workqueue_activate_work, + + TP_PROTO(struct work_struct *work), + + TP_ARGS(work) +) + +/** + * workqueue_execute_start - called immediately before the workqueue callback + * @work: pointer to struct work_struct + * + * Allows to track workqueue execution. + */ +LTTNG_TRACEPOINT_EVENT(workqueue_execute_start, + + TP_PROTO(struct work_struct *work), + + TP_ARGS(work), + + TP_FIELDS( + ctf_integer_hex(void *, work, work) + ctf_integer_hex(void *, function, work->func) + ) +) + +/** + * workqueue_execute_end - called immediately after the workqueue callback + * @work: pointer to struct work_struct + * @function: pointer to worker function + * + * Allows to track workqueue execution. + */ +LTTNG_TRACEPOINT_EVENT(workqueue_execute_end, + + TP_PROTO(struct work_struct *work, work_func_t function), + + TP_ARGS(work, function), + + TP_FIELDS( + ctf_integer_hex(void *, work, work) + ctf_integer_hex(void *, function, function) + ) +) + +#endif /* LTTNG_TRACE_WORKQUEUE_H */ + +/* This part must be outside protection */ +#include diff --git a/include/instrumentation/events/lttng-module/writeback.h b/include/instrumentation/events/lttng-module/writeback.h new file mode 100644 index 00000000..6430dc87 --- /dev/null +++ b/include/instrumentation/events/lttng-module/writeback.h @@ -0,0 +1,359 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#undef TRACE_SYSTEM +#define TRACE_SYSTEM writeback + +#if !defined(LTTNG_TRACE_WRITEBACK_H) || defined(TRACE_HEADER_MULTI_READ) +#define LTTNG_TRACE_WRITEBACK_H + +#include +#include +#include +#include + +#ifndef _TRACE_WRITEBACK_DEF_ +#define _TRACE_WRITEBACK_DEF_ + +static inline struct backing_dev_info *lttng_inode_to_bdi(struct inode *inode) +{ + return inode_to_bdi(inode); +} + +#endif + +#define show_inode_state(state) \ + __print_flags(state, "|", \ + {I_DIRTY_SYNC, "I_DIRTY_SYNC"}, \ + {I_DIRTY_DATASYNC, "I_DIRTY_DATASYNC"}, \ + {I_DIRTY_PAGES, "I_DIRTY_PAGES"}, \ + {I_NEW, "I_NEW"}, \ + {I_WILL_FREE, "I_WILL_FREE"}, \ + {I_FREEING, "I_FREEING"}, \ + {I_CLEAR, "I_CLEAR"}, \ + {I_SYNC, "I_SYNC"}, \ + {I_DIRTY_TIME, "I_DIRTY_TIME"}, \ + {I_DIRTY_TIME_EXPIRED, "I_DIRTY_TIME_EXPIRED"}, \ + {I_REFERENCED, "I_REFERENCED"} \ + ) + +LTTNG_TRACEPOINT_EVENT(writeback_dirty_page, + TP_PROTO(struct page *page, struct address_space *mapping), + TP_ARGS(page, mapping), + TP_FIELDS( + ctf_array_text(char, name, + mapping ? dev_name(lttng_inode_to_bdi(mapping->host)->dev) : "(unknown)", 32) + ctf_integer(unsigned long, ino, mapping ? mapping->host->i_ino : 0) + ctf_integer(pgoff_t, index, page->index) + ) +) + +LTTNG_TRACEPOINT_EVENT_CLASS(writeback_dirty_inode_template, + TP_PROTO(struct inode *inode, int flags), + TP_ARGS(inode, flags), + TP_FIELDS( + /* may be called for files on pseudo FSes w/ unregistered bdi */ + ctf_array_text(char, name, + lttng_inode_to_bdi(inode)->dev ? + dev_name(lttng_inode_to_bdi(inode)->dev) : "(unknown)", 32) + ctf_integer(unsigned long, ino, inode->i_ino) + ctf_integer(unsigned long, state, inode->i_state) + ctf_integer(unsigned long, flags, flags) + ) +) +#define LTTNG_TRACEPOINT_EVENT_WRITEBACK_DIRTY_INODE_TEMPLATE(name) \ +LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_dirty_inode_template, name, \ + TP_PROTO(struct inode *inode, int flags), \ + TP_ARGS(inode, flags)) +LTTNG_TRACEPOINT_EVENT_WRITEBACK_DIRTY_INODE_TEMPLATE(writeback_dirty_inode_start) +LTTNG_TRACEPOINT_EVENT_WRITEBACK_DIRTY_INODE_TEMPLATE(writeback_dirty_inode) +LTTNG_TRACEPOINT_EVENT_WRITEBACK_DIRTY_INODE_TEMPLATE(writeback_mark_inode_dirty) + +LTTNG_TRACEPOINT_EVENT_CLASS(writeback_write_inode_template, + TP_PROTO(struct inode *inode, struct writeback_control *wbc), + TP_ARGS(inode, wbc), + TP_FIELDS( + ctf_array_text(char, name, + dev_name(lttng_inode_to_bdi(inode)->dev), 32) + ctf_integer(unsigned long, ino, inode->i_ino) + ctf_integer(int, sync_mode, wbc->sync_mode) + ) +) + +#define LTTNG_TRACEPOINT_EVENT_WRITEBACK_WRITE_INODE(name) \ +LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_write_inode_template, name, \ + TP_PROTO(struct inode *inode, struct writeback_control *wbc), \ + TP_ARGS(inode, wbc)) +LTTNG_TRACEPOINT_EVENT_WRITEBACK_WRITE_INODE(writeback_write_inode_start) +LTTNG_TRACEPOINT_EVENT_WRITEBACK_WRITE_INODE(writeback_write_inode) + +LTTNG_TRACEPOINT_EVENT_CLASS(writeback_work_class, + TP_PROTO(struct bdi_writeback *wb, struct wb_writeback_work *work), + TP_ARGS(wb, work), + TP_FIELDS( + ctf_array_text(char, name, wb->bdi->dev ? dev_name(wb->bdi->dev) : + "(unknown)", 32) + ) +) + +#define LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(name) \ +LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_work_class, name, \ + TP_PROTO(struct bdi_writeback *wb, struct wb_writeback_work *work), \ + TP_ARGS(wb, work)) + +LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(writeback_nothread) +LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(writeback_queue) +LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(writeback_exec) +LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(writeback_start) +LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(writeback_written) +LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(writeback_wait) + +LTTNG_TRACEPOINT_EVENT(writeback_pages_written, + TP_PROTO(long pages_written), + TP_ARGS(pages_written), + TP_FIELDS( + ctf_integer(long, pages, pages_written) + ) +) + +LTTNG_TRACEPOINT_EVENT_CLASS(writeback_class, + TP_PROTO(struct bdi_writeback *wb), + TP_ARGS(wb), + TP_FIELDS( + ctf_array_text(char, name, + dev_name(wb->bdi->dev), 32) + ) +) + +#undef DEFINE_WRITEBACK_EVENT +#define DEFINE_WRITEBACK_EVENT(name) \ +LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_class, name, \ + TP_PROTO(struct bdi_writeback *wb), \ + TP_ARGS(wb)) + +#define DEFINE_WRITEBACK_EVENT_MAP(name, map) \ +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(writeback_class, name, map, \ + TP_PROTO(struct bdi_writeback *wb), \ + TP_ARGS(wb)) + +LTTNG_TRACEPOINT_EVENT(writeback_bdi_register, + TP_PROTO(struct backing_dev_info *bdi), + TP_ARGS(bdi), + TP_FIELDS( + ctf_array_text(char, name, + dev_name(bdi->dev), 32) + ) +) + +DEFINE_WRITEBACK_EVENT(writeback_nowork) +DEFINE_WRITEBACK_EVENT(writeback_wake_background) +DEFINE_WRITEBACK_EVENT(writeback_wake_thread) +DEFINE_WRITEBACK_EVENT(writeback_wake_forker_thread) +DEFINE_WRITEBACK_EVENT(writeback_bdi_unregister) +DEFINE_WRITEBACK_EVENT(writeback_thread_start) +DEFINE_WRITEBACK_EVENT(writeback_thread_stop) + +LTTNG_TRACEPOINT_EVENT_CLASS(writeback_wbc_class, + TP_PROTO(struct writeback_control *wbc, struct backing_dev_info *bdi), + TP_ARGS(wbc, bdi), + TP_FIELDS( + ctf_array_text(char, name, dev_name(bdi->dev), 32) + ctf_integer(long, nr_to_write, wbc->nr_to_write) + ctf_integer(long, pages_skipped, wbc->pages_skipped) + ctf_integer(int, sync_mode, wbc->sync_mode) + ctf_integer(int, for_kupdate, wbc->for_kupdate) + ctf_integer(int, for_background, wbc->for_background) + ctf_integer(int, for_reclaim, wbc->for_reclaim) + ctf_integer(int, range_cyclic, wbc->range_cyclic) + ctf_integer(long, range_start, (long) wbc->range_start) + ctf_integer(long, range_end, (long) wbc->range_end) + ) +) + +#undef DEFINE_WBC_EVENT +#define LTTNG_TRACEPOINT_EVENT_WBC_INSTANCE(name, map) \ +LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(writeback_wbc_class, name, map, \ + TP_PROTO(struct writeback_control *wbc, struct backing_dev_info *bdi), \ + TP_ARGS(wbc, bdi)) +LTTNG_TRACEPOINT_EVENT_WBC_INSTANCE(wbc_writepage, writeback_wbc_writepage) + +LTTNG_TRACEPOINT_EVENT(writeback_queue_io, + TP_PROTO(struct bdi_writeback *wb, + struct wb_writeback_work *work, + int moved), + TP_ARGS(wb, work, moved), + TP_FIELDS( + ctf_array_text(char, name, dev_name(wb->bdi->dev), 32) + ctf_integer(int, moved, moved) + ) +) + +LTTNG_TRACEPOINT_EVENT_MAP(global_dirty_state, + + writeback_global_dirty_state, + + TP_PROTO(struct wb_domain *domain, + unsigned long background_thresh, + unsigned long dirty_thresh + ), + + TP_ARGS(domain, + background_thresh, + dirty_thresh + ), + + TP_FIELDS( + ctf_integer(unsigned long, nr_dirty, global_node_page_state(NR_FILE_DIRTY)) + ctf_integer(unsigned long, nr_writeback, global_node_page_state(NR_WRITEBACK)) + ctf_integer(unsigned long, nr_unstable, global_node_page_state(NR_UNSTABLE_NFS)) + ctf_integer(unsigned long, nr_dirtied, global_node_page_state(NR_DIRTIED)) + ctf_integer(unsigned long, nr_written, global_node_page_state(NR_WRITTEN)) + ctf_integer(unsigned long, background_thresh, background_thresh) + ctf_integer(unsigned long, dirty_thresh, dirty_thresh) + ctf_integer(unsigned long, dirty_limit, domain->dirty_limit) + ) +) + +#define KBps(x) ((x) << (PAGE_SHIFT - 10)) + +LTTNG_TRACEPOINT_EVENT_MAP(bdi_dirty_ratelimit, + + writeback_bdi_dirty_ratelimit, + + TP_PROTO(struct bdi_writeback *wb, + unsigned long dirty_rate, + unsigned long task_ratelimit), + + TP_ARGS(wb, dirty_rate, task_ratelimit), + + TP_FIELDS( + ctf_array_text(char, bdi, dev_name(wb->bdi->dev), 32) + ctf_integer(unsigned long, write_bw, KBps(wb->bdi->wb.write_bandwidth)) + ctf_integer(unsigned long, avg_write_bw, KBps(wb->bdi->wb.avg_write_bandwidth)) + ctf_integer(unsigned long, dirty_rate, KBps(dirty_rate)) + ctf_integer(unsigned long, dirty_ratelimit, KBps(wb->bdi->wb.dirty_ratelimit)) + ctf_integer(unsigned long, task_ratelimit, KBps(task_ratelimit)) + ctf_integer(unsigned long, balanced_dirty_ratelimit, + KBps(wb->bdi->wb.balanced_dirty_ratelimit)) + ) +) + +LTTNG_TRACEPOINT_EVENT_MAP(balance_dirty_pages, + + writeback_balance_dirty_pages, + + TP_PROTO(struct wb_domain *domain, + struct bdi_writeback *wb, + struct dirty_throttle_control *sdtc, + unsigned long dirty_ratelimit, + unsigned long task_ratelimit, + unsigned long dirtied, + unsigned long period, + long pause, + unsigned long start_time), + + TP_ARGS(domain, wb, sdtc, + dirty_ratelimit, task_ratelimit, + dirtied, period, pause, start_time + ), + + TP_FIELDS( + ctf_array_text(char, bdi, dev_name(wb->bdi->dev), 32) + ctf_integer(unsigned long, limit, domain->dirty_limit) + ctf_integer(unsigned long, setpoint, + (domain->dirty_limit + (sdtc->thresh + sdtc->bg_thresh) / 2) / 2) + ctf_integer(unsigned long, dirty, sdtc->dirty) + ctf_integer(unsigned long, bdi_setpoint, + ((domain->dirty_limit + (sdtc->thresh + sdtc->bg_thresh) / 2) / 2) * + sdtc->wb_thresh / (sdtc->thresh + 1)) + ctf_integer(unsigned long, bdi_dirty, sdtc->wb_dirty) + ctf_integer(unsigned long, dirty_ratelimit, + KBps(dirty_ratelimit)) + ctf_integer(unsigned long, task_ratelimit, + KBps(task_ratelimit)) + ctf_integer(unsigned int, dirtied, dirtied) + ctf_integer(unsigned int, dirtied_pause, + current->nr_dirtied_pause) + ctf_integer(unsigned long, paused, + (jiffies - start_time) * 1000 / HZ) + ctf_integer(long, pause, pause * 1000 / HZ) + ctf_integer(unsigned long, period, + period * 1000 / HZ) + ctf_integer(long, think, + current->dirty_paused_when == 0 ? 0 : + (long)(jiffies - current->dirty_paused_when) * 1000/HZ) + ) +) + +LTTNG_TRACEPOINT_EVENT(writeback_sb_inodes_requeue, + + TP_PROTO(struct inode *inode), + TP_ARGS(inode), + + TP_FIELDS( + ctf_array_text(char, name, + dev_name(lttng_inode_to_bdi(inode)->dev), 32) + ctf_integer(unsigned long, ino, inode->i_ino) + ctf_integer(unsigned long, state, inode->i_state) + ctf_integer(unsigned long, dirtied_when, inode->dirtied_when) + ) +) + +LTTNG_TRACEPOINT_EVENT_CLASS(writeback_congest_waited_template, + + TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed), + + TP_ARGS(usec_timeout, usec_delayed), + + TP_FIELDS( + ctf_integer(unsigned int, usec_timeout, usec_timeout) + ctf_integer(unsigned int, usec_delayed, usec_delayed) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_congest_waited_template, writeback_congestion_wait, + + TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed), + + TP_ARGS(usec_timeout, usec_delayed) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_congest_waited_template, writeback_wait_iff_congested, + + TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed), + + TP_ARGS(usec_timeout, usec_delayed) +) + +LTTNG_TRACEPOINT_EVENT_CLASS(writeback_single_inode_template, + + TP_PROTO(struct inode *inode, + struct writeback_control *wbc, + unsigned long nr_to_write + ), + + TP_ARGS(inode, wbc, nr_to_write), + + TP_FIELDS( + ctf_array_text(char, name, + dev_name(lttng_inode_to_bdi(inode)->dev), 32) + ctf_integer(unsigned long, ino, inode->i_ino) + ctf_integer(unsigned long, state, inode->i_state) + ctf_integer(unsigned long, dirtied_when, inode->dirtied_when) + ctf_integer(unsigned long, writeback_index, + inode->i_mapping->writeback_index) + ctf_integer(long, nr_to_write, nr_to_write) + ctf_integer(unsigned long, wrote, + nr_to_write - wbc->nr_to_write) + ) +) + +LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_single_inode_template, writeback_single_inode, + TP_PROTO(struct inode *inode, + struct writeback_control *wbc, + unsigned long nr_to_write), + TP_ARGS(inode, wbc, nr_to_write) +) + +#endif /* LTTNG_TRACE_WRITEBACK_H */ + +/* This part must be outside protection */ +#include diff --git a/include/instrumentation/syscalls/3.0.34/powerpc-32-syscalls b/include/instrumentation/syscalls/3.0.34/powerpc-32-syscalls new file mode 100644 index 00000000..f951c7ad --- /dev/null +++ b/include/instrumentation/syscalls/3.0.34/powerpc-32-syscalls @@ -0,0 +1,286 @@ +syscall sys_restart_syscall nr 0 nbargs 0 types: () args: () +syscall sys_exit nr 1 nbargs 1 types: (int) args: (error_code) +syscall sys_read nr 3 nbargs 3 types: (unsigned int, char *, size_t) args: (fd, buf, count) +syscall sys_write nr 4 nbargs 3 types: (unsigned int, const char *, size_t) args: (fd, buf, count) +syscall sys_open nr 5 nbargs 3 types: (const char *, int, int) args: (filename, flags, mode) +syscall sys_close nr 6 nbargs 1 types: (unsigned int) args: (fd) +syscall sys_waitpid nr 7 nbargs 3 types: (pid_t, int *, int) args: (pid, stat_addr, options) +syscall sys_creat nr 8 nbargs 2 types: (const char *, int) args: (pathname, mode) +syscall sys_link nr 9 nbargs 2 types: (const char *, const char *) args: (oldname, newname) +syscall sys_unlink nr 10 nbargs 1 types: (const char *) args: (pathname) +syscall sys_chdir nr 12 nbargs 1 types: (const char *) args: (filename) +syscall sys_time nr 13 nbargs 1 types: (time_t *) args: (tloc) +syscall sys_mknod nr 14 nbargs 3 types: (const char *, int, unsigned) args: (filename, mode, dev) +syscall sys_chmod nr 15 nbargs 2 types: (const char *, mode_t) args: (filename, mode) +syscall sys_lchown nr 16 nbargs 3 types: (const char *, uid_t, gid_t) args: (filename, user, group) +syscall sys_stat nr 18 nbargs 2 types: (const char *, struct __old_kernel_stat *) args: (filename, statbuf) +syscall sys_lseek nr 19 nbargs 3 types: (unsigned int, off_t, unsigned int) args: (fd, offset, origin) +syscall sys_getpid nr 20 nbargs 0 types: () args: () +syscall sys_mount nr 21 nbargs 5 types: (char *, char *, char *, unsigned long, void *) args: (dev_name, dir_name, type, flags, data) +syscall sys_oldumount nr 22 nbargs 1 types: (char *) args: (name) +syscall sys_setuid nr 23 nbargs 1 types: (uid_t) args: (uid) +syscall sys_getuid nr 24 nbargs 0 types: () args: () +syscall sys_stime nr 25 nbargs 1 types: (time_t *) args: (tptr) +syscall sys_ptrace nr 26 nbargs 4 types: (long, long, unsigned long, unsigned long) args: (request, pid, addr, data) +syscall sys_alarm nr 27 nbargs 1 types: (unsigned int) args: (seconds) +syscall sys_fstat nr 28 nbargs 2 types: (unsigned int, struct __old_kernel_stat *) args: (fd, statbuf) +syscall sys_pause nr 29 nbargs 0 types: () args: () +syscall sys_utime nr 30 nbargs 2 types: (char *, struct utimbuf *) args: (filename, times) +syscall sys_access nr 33 nbargs 2 types: (const char *, int) args: (filename, mode) +syscall sys_nice nr 34 nbargs 1 types: (int) args: (increment) +syscall sys_sync nr 36 nbargs 0 types: () args: () +syscall sys_kill nr 37 nbargs 2 types: (pid_t, int) args: (pid, sig) +syscall sys_rename nr 38 nbargs 2 types: (const char *, const char *) args: (oldname, newname) +syscall sys_mkdir nr 39 nbargs 2 types: (const char *, int) args: (pathname, mode) +syscall sys_rmdir nr 40 nbargs 1 types: (const char *) args: (pathname) +syscall sys_dup nr 41 nbargs 1 types: (unsigned int) args: (fildes) +syscall sys_pipe nr 42 nbargs 1 types: (int *) args: (fildes) +syscall sys_times nr 43 nbargs 1 types: (struct tms *) args: (tbuf) +syscall sys_brk nr 45 nbargs 1 types: (unsigned long) args: (brk) +syscall sys_setgid nr 46 nbargs 1 types: (gid_t) args: (gid) +syscall sys_getgid nr 47 nbargs 0 types: () args: () +syscall sys_signal nr 48 nbargs 2 types: (int, __sighandler_t) args: (sig, handler) +syscall sys_geteuid nr 49 nbargs 0 types: () args: () +syscall sys_getegid nr 50 nbargs 0 types: () args: () +syscall sys_acct nr 51 nbargs 1 types: (const char *) args: (name) +syscall sys_umount nr 52 nbargs 2 types: (char *, int) args: (name, flags) +syscall sys_ioctl nr 54 nbargs 3 types: (unsigned int, unsigned int, unsigned long) args: (fd, cmd, arg) +syscall sys_fcntl nr 55 nbargs 3 types: (unsigned int, unsigned int, unsigned long) args: (fd, cmd, arg) +syscall sys_setpgid nr 57 nbargs 2 types: (pid_t, pid_t) args: (pid, pgid) +syscall sys_olduname nr 59 nbargs 1 types: (struct oldold_utsname *) args: (name) +syscall sys_umask nr 60 nbargs 1 types: (int) args: (mask) +syscall sys_chroot nr 61 nbargs 1 types: (const char *) args: (filename) +syscall sys_ustat nr 62 nbargs 2 types: (unsigned, struct ustat *) args: (dev, ubuf) +syscall sys_dup2 nr 63 nbargs 2 types: (unsigned int, unsigned int) args: (oldfd, newfd) +syscall sys_getppid nr 64 nbargs 0 types: () args: () +syscall sys_getpgrp nr 65 nbargs 0 types: () args: () +syscall sys_setsid nr 66 nbargs 0 types: () args: () +syscall sys_sgetmask nr 68 nbargs 0 types: () args: () +syscall sys_ssetmask nr 69 nbargs 1 types: (int) args: (newmask) +syscall sys_setreuid nr 70 nbargs 2 types: (uid_t, uid_t) args: (ruid, euid) +syscall sys_setregid nr 71 nbargs 2 types: (gid_t, gid_t) args: (rgid, egid) +syscall sys_sigpending nr 73 nbargs 1 types: (old_sigset_t *) args: (set) +syscall sys_sethostname nr 74 nbargs 2 types: (char *, int) args: (name, len) +syscall sys_setrlimit nr 75 nbargs 2 types: (unsigned int, struct rlimit *) args: (resource, rlim) +syscall sys_old_getrlimit nr 76 nbargs 2 types: (unsigned int, struct rlimit *) args: (resource, rlim) +syscall sys_getrusage nr 77 nbargs 2 types: (int, struct rusage *) args: (who, ru) +syscall sys_gettimeofday nr 78 nbargs 2 types: (struct timeval *, struct timezone *) args: (tv, tz) +syscall sys_settimeofday nr 79 nbargs 2 types: (struct timeval *, struct timezone *) args: (tv, tz) +syscall sys_getgroups nr 80 nbargs 2 types: (int, gid_t *) args: (gidsetsize, grouplist) +syscall sys_setgroups nr 81 nbargs 2 types: (int, gid_t *) args: (gidsetsize, grouplist) +syscall sys_symlink nr 83 nbargs 2 types: (const char *, const char *) args: (oldname, newname) +syscall sys_lstat nr 84 nbargs 2 types: (const char *, struct __old_kernel_stat *) args: (filename, statbuf) +syscall sys_readlink nr 85 nbargs 3 types: (const char *, char *, int) args: (path, buf, bufsiz) +syscall sys_uselib nr 86 nbargs 1 types: (const char *) args: (library) +syscall sys_swapon nr 87 nbargs 2 types: (const char *, int) args: (specialfile, swap_flags) +syscall sys_reboot nr 88 nbargs 4 types: (int, int, unsigned int, void *) args: (magic1, magic2, cmd, arg) +syscall sys_old_readdir nr 89 nbargs 3 types: (unsigned int, struct old_linux_dirent *, unsigned int) args: (fd, dirent, count) +syscall sys_munmap nr 91 nbargs 2 types: (unsigned long, size_t) args: (addr, len) +syscall sys_truncate nr 92 nbargs 2 types: (const char *, long) args: (path, length) +syscall sys_ftruncate nr 93 nbargs 2 types: (unsigned int, unsigned long) args: (fd, length) +syscall sys_fchmod nr 94 nbargs 2 types: (unsigned int, mode_t) args: (fd, mode) +syscall sys_fchown nr 95 nbargs 3 types: (unsigned int, uid_t, gid_t) args: (fd, user, group) +syscall sys_getpriority nr 96 nbargs 2 types: (int, int) args: (which, who) +syscall sys_setpriority nr 97 nbargs 3 types: (int, int, int) args: (which, who, niceval) +syscall sys_statfs nr 99 nbargs 2 types: (const char *, struct statfs *) args: (pathname, buf) +syscall sys_fstatfs nr 100 nbargs 2 types: (unsigned int, struct statfs *) args: (fd, buf) +syscall sys_socketcall nr 102 nbargs 2 types: (int, unsigned long *) args: (call, args) +syscall sys_syslog nr 103 nbargs 3 types: (int, char *, int) args: (type, buf, len) +syscall sys_setitimer nr 104 nbargs 3 types: (int, struct itimerval *, struct itimerval *) args: (which, value, ovalue) +syscall sys_getitimer nr 105 nbargs 2 types: (int, struct itimerval *) args: (which, value) +syscall sys_newstat nr 106 nbargs 2 types: (const char *, struct stat *) args: (filename, statbuf) +syscall sys_newlstat nr 107 nbargs 2 types: (const char *, struct stat *) args: (filename, statbuf) +syscall sys_newfstat nr 108 nbargs 2 types: (unsigned int, struct stat *) args: (fd, statbuf) +syscall sys_uname nr 109 nbargs 1 types: (struct old_utsname *) args: (name) +syscall sys_vhangup nr 111 nbargs 0 types: () args: () +syscall sys_wait4 nr 114 nbargs 4 types: (pid_t, int *, int, struct rusage *) args: (upid, stat_addr, options, ru) +syscall sys_swapoff nr 115 nbargs 1 types: (const char *) args: (specialfile) +syscall sys_sysinfo nr 116 nbargs 1 types: (struct sysinfo *) args: (info) +syscall sys_ipc nr 117 nbargs 6 types: (unsigned int, int, unsigned long, unsigned long, void *, long) args: (call, first, second, third, ptr, fifth) +syscall sys_fsync nr 118 nbargs 1 types: (unsigned int) args: (fd) +syscall sys_setdomainname nr 121 nbargs 2 types: (char *, int) args: (name, len) +syscall sys_newuname nr 122 nbargs 1 types: (struct new_utsname *) args: (name) +syscall sys_adjtimex nr 124 nbargs 1 types: (struct timex *) args: (txc_p) +syscall sys_mprotect nr 125 nbargs 3 types: (unsigned long, size_t, unsigned long) args: (start, len, prot) +syscall sys_sigprocmask nr 126 nbargs 3 types: (int, old_sigset_t *, old_sigset_t *) args: (how, nset, oset) +syscall sys_init_module nr 128 nbargs 3 types: (void *, unsigned long, const char *) args: (umod, len, uargs) +syscall sys_delete_module nr 129 nbargs 2 types: (const char *, unsigned int) args: (name_user, flags) +syscall sys_getpgid nr 132 nbargs 1 types: (pid_t) args: (pid) +syscall sys_fchdir nr 133 nbargs 1 types: (unsigned int) args: (fd) +syscall sys_bdflush nr 134 nbargs 2 types: (int, long) args: (func, data) +syscall sys_sysfs nr 135 nbargs 3 types: (int, unsigned long, unsigned long) args: (option, arg1, arg2) +syscall sys_personality nr 136 nbargs 1 types: (unsigned int) args: (personality) +syscall sys_setfsuid nr 138 nbargs 1 types: (uid_t) args: (uid) +syscall sys_setfsgid nr 139 nbargs 1 types: (gid_t) args: (gid) +syscall sys_llseek nr 140 nbargs 5 types: (unsigned int, unsigned long, unsigned long, loff_t *, unsigned int) args: (fd, offset_high, offset_low, result, origin) +syscall sys_getdents nr 141 nbargs 3 types: (unsigned int, struct linux_dirent *, unsigned int) args: (fd, dirent, count) +syscall sys_select nr 142 nbargs 5 types: (int, fd_set *, fd_set *, fd_set *, struct timeval *) args: (n, inp, outp, exp, tvp) +syscall sys_flock nr 143 nbargs 2 types: (unsigned int, unsigned int) args: (fd, cmd) +syscall sys_msync nr 144 nbargs 3 types: (unsigned long, size_t, int) args: (start, len, flags) +syscall sys_readv nr 145 nbargs 3 types: (unsigned long, const struct iovec *, unsigned long) args: (fd, vec, vlen) +syscall sys_writev nr 146 nbargs 3 types: (unsigned long, const struct iovec *, unsigned long) args: (fd, vec, vlen) +syscall sys_getsid nr 147 nbargs 1 types: (pid_t) args: (pid) +syscall sys_fdatasync nr 148 nbargs 1 types: (unsigned int) args: (fd) +syscall sys_sysctl nr 149 nbargs 1 types: (struct __sysctl_args *) args: (args) +syscall sys_mlock nr 150 nbargs 2 types: (unsigned long, size_t) args: (start, len) +syscall sys_munlock nr 151 nbargs 2 types: (unsigned long, size_t) args: (start, len) +syscall sys_mlockall nr 152 nbargs 1 types: (int) args: (flags) +syscall sys_munlockall nr 153 nbargs 0 types: () args: () +syscall sys_sched_setparam nr 154 nbargs 2 types: (pid_t, struct sched_param *) args: (pid, param) +syscall sys_sched_getparam nr 155 nbargs 2 types: (pid_t, struct sched_param *) args: (pid, param) +syscall sys_sched_setscheduler nr 156 nbargs 3 types: (pid_t, int, struct sched_param *) args: (pid, policy, param) +syscall sys_sched_getscheduler nr 157 nbargs 1 types: (pid_t) args: (pid) +syscall sys_sched_yield nr 158 nbargs 0 types: () args: () +syscall sys_sched_get_priority_max nr 159 nbargs 1 types: (int) args: (policy) +syscall sys_sched_get_priority_min nr 160 nbargs 1 types: (int) args: (policy) +syscall sys_sched_rr_get_interval nr 161 nbargs 2 types: (pid_t, struct timespec *) args: (pid, interval) +syscall sys_nanosleep nr 162 nbargs 2 types: (struct timespec *, struct timespec *) args: (rqtp, rmtp) +syscall sys_mremap nr 163 nbargs 5 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long) args: (addr, old_len, new_len, flags, new_addr) +syscall sys_setresuid nr 164 nbargs 3 types: (uid_t, uid_t, uid_t) args: (ruid, euid, suid) +syscall sys_getresuid nr 165 nbargs 3 types: (uid_t *, uid_t *, uid_t *) args: (ruid, euid, suid) +syscall sys_poll nr 167 nbargs 3 types: (struct pollfd *, unsigned int, long) args: (ufds, nfds, timeout_msecs) +syscall sys_nfsservctl nr 168 nbargs 3 types: (int, struct nfsctl_arg *, void *) args: (cmd, arg, res) +syscall sys_setresgid nr 169 nbargs 3 types: (gid_t, gid_t, gid_t) args: (rgid, egid, sgid) +syscall sys_getresgid nr 170 nbargs 3 types: (gid_t *, gid_t *, gid_t *) args: (rgid, egid, sgid) +syscall sys_prctl nr 171 nbargs 5 types: (int, unsigned long, unsigned long, unsigned long, unsigned long) args: (option, arg2, arg3, arg4, arg5) +syscall sys_rt_sigaction nr 173 nbargs 4 types: (int, const struct sigaction *, struct sigaction *, size_t) args: (sig, act, oact, sigsetsize) +syscall sys_rt_sigprocmask nr 174 nbargs 4 types: (int, sigset_t *, sigset_t *, size_t) args: (how, nset, oset, sigsetsize) +syscall sys_rt_sigpending nr 175 nbargs 2 types: (sigset_t *, size_t) args: (set, sigsetsize) +syscall sys_rt_sigtimedwait nr 176 nbargs 4 types: (const sigset_t *, siginfo_t *, const struct timespec *, size_t) args: (uthese, uinfo, uts, sigsetsize) +syscall sys_rt_sigqueueinfo nr 177 nbargs 3 types: (pid_t, int, siginfo_t *) args: (pid, sig, uinfo) +syscall sys_rt_sigsuspend nr 178 nbargs 2 types: (sigset_t *, size_t) args: (unewset, sigsetsize) +syscall sys_chown nr 181 nbargs 3 types: (const char *, uid_t, gid_t) args: (filename, user, group) +syscall sys_getcwd nr 182 nbargs 2 types: (char *, unsigned long) args: (buf, size) +syscall sys_capget nr 183 nbargs 2 types: (cap_user_header_t, cap_user_data_t) args: (header, dataptr) +syscall sys_capset nr 184 nbargs 2 types: (cap_user_header_t, const cap_user_data_t) args: (header, data) +syscall sys_sendfile nr 186 nbargs 4 types: (int, int, off_t *, size_t) args: (out_fd, in_fd, offset, count) +syscall sys_getrlimit nr 190 nbargs 2 types: (unsigned int, struct rlimit *) args: (resource, rlim) +syscall sys_stat64 nr 195 nbargs 2 types: (const char *, struct stat64 *) args: (filename, statbuf) +syscall sys_lstat64 nr 196 nbargs 2 types: (const char *, struct stat64 *) args: (filename, statbuf) +syscall sys_fstat64 nr 197 nbargs 2 types: (unsigned long, struct stat64 *) args: (fd, statbuf) +syscall sys_pciconfig_read nr 198 nbargs 5 types: (unsigned long, unsigned long, unsigned long, unsigned long, void *) args: (bus, dfn, off, len, buf) +syscall sys_pciconfig_write nr 199 nbargs 5 types: (unsigned long, unsigned long, unsigned long, unsigned long, void *) args: (bus, dfn, off, len, buf) +syscall sys_getdents64 nr 202 nbargs 3 types: (unsigned int, struct linux_dirent64 *, unsigned int) args: (fd, dirent, count) +syscall sys_pivot_root nr 203 nbargs 2 types: (const char *, const char *) args: (new_root, put_old) +syscall sys_fcntl64 nr 204 nbargs 3 types: (unsigned int, unsigned int, unsigned long) args: (fd, cmd, arg) +syscall sys_madvise nr 205 nbargs 3 types: (unsigned long, size_t, int) args: (start, len_in, behavior) +syscall sys_mincore nr 206 nbargs 3 types: (unsigned long, size_t, unsigned char *) args: (start, len, vec) +syscall sys_gettid nr 207 nbargs 0 types: () args: () +syscall sys_tkill nr 208 nbargs 2 types: (pid_t, int) args: (pid, sig) +syscall sys_setxattr nr 209 nbargs 5 types: (const char *, const char *, const void *, size_t, int) args: (pathname, name, value, size, flags) +syscall sys_lsetxattr nr 210 nbargs 5 types: (const char *, const char *, const void *, size_t, int) args: (pathname, name, value, size, flags) +syscall sys_fsetxattr nr 211 nbargs 5 types: (int, const char *, const void *, size_t, int) args: (fd, name, value, size, flags) +syscall sys_getxattr nr 212 nbargs 4 types: (const char *, const char *, void *, size_t) args: (pathname, name, value, size) +syscall sys_lgetxattr nr 213 nbargs 4 types: (const char *, const char *, void *, size_t) args: (pathname, name, value, size) +syscall sys_fgetxattr nr 214 nbargs 4 types: (int, const char *, void *, size_t) args: (fd, name, value, size) +syscall sys_listxattr nr 215 nbargs 3 types: (const char *, char *, size_t) args: (pathname, list, size) +syscall sys_llistxattr nr 216 nbargs 3 types: (const char *, char *, size_t) args: (pathname, list, size) +syscall sys_flistxattr nr 217 nbargs 3 types: (int, char *, size_t) args: (fd, list, size) +syscall sys_removexattr nr 218 nbargs 2 types: (const char *, const char *) args: (pathname, name) +syscall sys_lremovexattr nr 219 nbargs 2 types: (const char *, const char *) args: (pathname, name) +syscall sys_fremovexattr nr 220 nbargs 2 types: (int, const char *) args: (fd, name) +syscall sys_futex nr 221 nbargs 6 types: (u32 *, int, u32, struct timespec *, u32 *, u32) args: (uaddr, op, val, utime, uaddr2, val3) +syscall sys_sched_setaffinity nr 222 nbargs 3 types: (pid_t, unsigned int, unsigned long *) args: (pid, len, user_mask_ptr) +syscall sys_sched_getaffinity nr 223 nbargs 3 types: (pid_t, unsigned int, unsigned long *) args: (pid, len, user_mask_ptr) +syscall sys_sendfile64 nr 226 nbargs 4 types: (int, int, loff_t *, size_t) args: (out_fd, in_fd, offset, count) +syscall sys_io_setup nr 227 nbargs 2 types: (unsigned, aio_context_t *) args: (nr_events, ctxp) +syscall sys_io_destroy nr 228 nbargs 1 types: (aio_context_t) args: (ctx) +syscall sys_io_getevents nr 229 nbargs 5 types: (aio_context_t, long, long, struct io_event *, struct timespec *) args: (ctx_id, min_nr, nr, events, timeout) +syscall sys_io_submit nr 230 nbargs 3 types: (aio_context_t, long, struct iocb * *) args: (ctx_id, nr, iocbpp) +syscall sys_io_cancel nr 231 nbargs 3 types: (aio_context_t, struct iocb *, struct io_event *) args: (ctx_id, iocb, result) +syscall sys_set_tid_address nr 232 nbargs 1 types: (int *) args: (tidptr) +syscall sys_exit_group nr 234 nbargs 1 types: (int) args: (error_code) +syscall sys_epoll_create nr 236 nbargs 1 types: (int) args: (size) +syscall sys_epoll_ctl nr 237 nbargs 4 types: (int, int, int, struct epoll_event *) args: (epfd, op, fd, event) +syscall sys_epoll_wait nr 238 nbargs 4 types: (int, struct epoll_event *, int, int) args: (epfd, events, maxevents, timeout) +syscall sys_remap_file_pages nr 239 nbargs 5 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long) args: (start, size, prot, pgoff, flags) +syscall sys_timer_create nr 240 nbargs 3 types: (const clockid_t, struct sigevent *, timer_t *) args: (which_clock, timer_event_spec, created_timer_id) +syscall sys_timer_settime nr 241 nbargs 4 types: (timer_t, int, const struct itimerspec *, struct itimerspec *) args: (timer_id, flags, new_setting, old_setting) +syscall sys_timer_gettime nr 242 nbargs 2 types: (timer_t, struct itimerspec *) args: (timer_id, setting) +syscall sys_timer_getoverrun nr 243 nbargs 1 types: (timer_t) args: (timer_id) +syscall sys_timer_delete nr 244 nbargs 1 types: (timer_t) args: (timer_id) +syscall sys_clock_settime nr 245 nbargs 2 types: (const clockid_t, const struct timespec *) args: (which_clock, tp) +syscall sys_clock_gettime nr 246 nbargs 2 types: (const clockid_t, struct timespec *) args: (which_clock, tp) +syscall sys_clock_getres nr 247 nbargs 2 types: (const clockid_t, struct timespec *) args: (which_clock, tp) +syscall sys_clock_nanosleep nr 248 nbargs 4 types: (const clockid_t, int, const struct timespec *, struct timespec *) args: (which_clock, flags, rqtp, rmtp) +syscall sys_tgkill nr 250 nbargs 3 types: (pid_t, pid_t, int) args: (tgid, pid, sig) +syscall sys_utimes nr 251 nbargs 2 types: (char *, struct timeval *) args: (filename, utimes) +syscall sys_statfs64 nr 252 nbargs 3 types: (const char *, size_t, struct statfs64 *) args: (pathname, sz, buf) +syscall sys_fstatfs64 nr 253 nbargs 3 types: (unsigned int, size_t, struct statfs64 *) args: (fd, sz, buf) +syscall sys_mq_open nr 262 nbargs 4 types: (const char *, int, mode_t, struct mq_attr *) args: (u_name, oflag, mode, u_attr) +syscall sys_mq_unlink nr 263 nbargs 1 types: (const char *) args: (u_name) +syscall sys_mq_timedsend nr 264 nbargs 5 types: (mqd_t, const char *, size_t, unsigned int, const struct timespec *) args: (mqdes, u_msg_ptr, msg_len, msg_prio, u_abs_timeout) +syscall sys_mq_timedreceive nr 265 nbargs 5 types: (mqd_t, char *, size_t, unsigned int *, const struct timespec *) args: (mqdes, u_msg_ptr, msg_len, u_msg_prio, u_abs_timeout) +syscall sys_mq_notify nr 266 nbargs 2 types: (mqd_t, const struct sigevent *) args: (mqdes, u_notification) +syscall sys_mq_getsetattr nr 267 nbargs 3 types: (mqd_t, const struct mq_attr *, struct mq_attr *) args: (mqdes, u_mqstat, u_omqstat) +syscall sys_add_key nr 269 nbargs 5 types: (const char *, const char *, const void *, size_t, key_serial_t) args: (_type, _description, _payload, plen, ringid) +syscall sys_request_key nr 270 nbargs 4 types: (const char *, const char *, const char *, key_serial_t) args: (_type, _description, _callout_info, destringid) +syscall sys_keyctl nr 271 nbargs 5 types: (int, unsigned long, unsigned long, unsigned long, unsigned long) args: (option, arg2, arg3, arg4, arg5) +syscall sys_waitid nr 272 nbargs 5 types: (int, pid_t, struct siginfo *, int, struct rusage *) args: (which, upid, infop, options, ru) +syscall sys_ioprio_set nr 273 nbargs 3 types: (int, int, int) args: (which, who, ioprio) +syscall sys_ioprio_get nr 274 nbargs 2 types: (int, int) args: (which, who) +syscall sys_inotify_init nr 275 nbargs 0 types: () args: () +syscall sys_inotify_add_watch nr 276 nbargs 3 types: (int, const char *, u32) args: (fd, pathname, mask) +syscall sys_inotify_rm_watch nr 277 nbargs 2 types: (int, __s32) args: (fd, wd) +syscall sys_pselect6 nr 280 nbargs 6 types: (int, fd_set *, fd_set *, fd_set *, struct timespec *, void *) args: (n, inp, outp, exp, tsp, sig) +syscall sys_ppoll nr 281 nbargs 5 types: (struct pollfd *, unsigned int, struct timespec *, const sigset_t *, size_t) args: (ufds, nfds, tsp, sigmask, sigsetsize) +syscall sys_unshare nr 282 nbargs 1 types: (unsigned long) args: (unshare_flags) +syscall sys_splice nr 283 nbargs 6 types: (int, loff_t *, int, loff_t *, size_t, unsigned int) args: (fd_in, off_in, fd_out, off_out, len, flags) +syscall sys_tee nr 284 nbargs 4 types: (int, int, size_t, unsigned int) args: (fdin, fdout, len, flags) +syscall sys_vmsplice nr 285 nbargs 4 types: (int, const struct iovec *, unsigned long, unsigned int) args: (fd, iov, nr_segs, flags) +syscall sys_openat nr 286 nbargs 4 types: (int, const char *, int, int) args: (dfd, filename, flags, mode) +syscall sys_mkdirat nr 287 nbargs 3 types: (int, const char *, int) args: (dfd, pathname, mode) +syscall sys_mknodat nr 288 nbargs 4 types: (int, const char *, int, unsigned) args: (dfd, filename, mode, dev) +syscall sys_fchownat nr 289 nbargs 5 types: (int, const char *, uid_t, gid_t, int) args: (dfd, filename, user, group, flag) +syscall sys_futimesat nr 290 nbargs 3 types: (int, const char *, struct timeval *) args: (dfd, filename, utimes) +syscall sys_fstatat64 nr 291 nbargs 4 types: (int, const char *, struct stat64 *, int) args: (dfd, filename, statbuf, flag) +syscall sys_unlinkat nr 292 nbargs 3 types: (int, const char *, int) args: (dfd, pathname, flag) +syscall sys_renameat nr 293 nbargs 4 types: (int, const char *, int, const char *) args: (olddfd, oldname, newdfd, newname) +syscall sys_linkat nr 294 nbargs 5 types: (int, const char *, int, const char *, int) args: (olddfd, oldname, newdfd, newname, flags) +syscall sys_symlinkat nr 295 nbargs 3 types: (const char *, int, const char *) args: (oldname, newdfd, newname) +syscall sys_readlinkat nr 296 nbargs 4 types: (int, const char *, char *, int) args: (dfd, pathname, buf, bufsiz) +syscall sys_fchmodat nr 297 nbargs 3 types: (int, const char *, mode_t) args: (dfd, filename, mode) +syscall sys_faccessat nr 298 nbargs 3 types: (int, const char *, int) args: (dfd, filename, mode) +syscall sys_get_robust_list nr 299 nbargs 3 types: (int, struct robust_list_head * *, size_t *) args: (pid, head_ptr, len_ptr) +syscall sys_set_robust_list nr 300 nbargs 2 types: (struct robust_list_head *, size_t) args: (head, len) +syscall sys_getcpu nr 302 nbargs 3 types: (unsigned *, unsigned *, struct getcpu_cache *) args: (cpup, nodep, unused) +syscall sys_epoll_pwait nr 303 nbargs 6 types: (int, struct epoll_event *, int, int, const sigset_t *, size_t) args: (epfd, events, maxevents, timeout, sigmask, sigsetsize) +syscall sys_utimensat nr 304 nbargs 4 types: (int, const char *, struct timespec *, int) args: (dfd, filename, utimes, flags) +syscall sys_signalfd nr 305 nbargs 3 types: (int, sigset_t *, size_t) args: (ufd, user_mask, sizemask) +syscall sys_timerfd_create nr 306 nbargs 2 types: (int, int) args: (clockid, flags) +syscall sys_eventfd nr 307 nbargs 1 types: (unsigned int) args: (count) +syscall sys_timerfd_settime nr 311 nbargs 4 types: (int, int, const struct itimerspec *, struct itimerspec *) args: (ufd, flags, utmr, otmr) +syscall sys_timerfd_gettime nr 312 nbargs 2 types: (int, struct itimerspec *) args: (ufd, otmr) +syscall sys_signalfd4 nr 313 nbargs 4 types: (int, sigset_t *, size_t, int) args: (ufd, user_mask, sizemask, flags) +syscall sys_eventfd2 nr 314 nbargs 2 types: (unsigned int, int) args: (count, flags) +syscall sys_epoll_create1 nr 315 nbargs 1 types: (int) args: (flags) +syscall sys_dup3 nr 316 nbargs 3 types: (unsigned int, unsigned int, int) args: (oldfd, newfd, flags) +syscall sys_pipe2 nr 317 nbargs 2 types: (int *, int) args: (fildes, flags) +syscall sys_inotify_init1 nr 318 nbargs 1 types: (int) args: (flags) +syscall sys_perf_event_open nr 319 nbargs 5 types: (struct perf_event_attr *, pid_t, int, int, unsigned long) args: (attr_uptr, pid, cpu, group_fd, flags) +syscall sys_preadv nr 320 nbargs 5 types: (unsigned long, const struct iovec *, unsigned long, unsigned long, unsigned long) args: (fd, vec, vlen, pos_l, pos_h) +syscall sys_pwritev nr 321 nbargs 5 types: (unsigned long, const struct iovec *, unsigned long, unsigned long, unsigned long) args: (fd, vec, vlen, pos_l, pos_h) +syscall sys_rt_tgsigqueueinfo nr 322 nbargs 4 types: (pid_t, pid_t, int, siginfo_t *) args: (tgid, pid, sig, uinfo) +syscall sys_prlimit64 nr 325 nbargs 4 types: (pid_t, unsigned int, const struct rlimit64 *, struct rlimit64 *) args: (pid, resource, new_rlim, old_rlim) +syscall sys_socket nr 326 nbargs 3 types: (int, int, int) args: (family, type, protocol) +syscall sys_bind nr 327 nbargs 3 types: (int, struct sockaddr *, int) args: (fd, umyaddr, addrlen) +syscall sys_connect nr 328 nbargs 3 types: (int, struct sockaddr *, int) args: (fd, uservaddr, addrlen) +syscall sys_listen nr 329 nbargs 2 types: (int, int) args: (fd, backlog) +syscall sys_accept nr 330 nbargs 3 types: (int, struct sockaddr *, int *) args: (fd, upeer_sockaddr, upeer_addrlen) +syscall sys_getsockname nr 331 nbargs 3 types: (int, struct sockaddr *, int *) args: (fd, usockaddr, usockaddr_len) +syscall sys_getpeername nr 332 nbargs 3 types: (int, struct sockaddr *, int *) args: (fd, usockaddr, usockaddr_len) +syscall sys_socketpair nr 333 nbargs 4 types: (int, int, int, int *) args: (family, type, protocol, usockvec) +syscall sys_send nr 334 nbargs 4 types: (int, void *, size_t, unsigned) args: (fd, buff, len, flags) +syscall sys_sendto nr 335 nbargs 6 types: (int, void *, size_t, unsigned, struct sockaddr *, int) args: (fd, buff, len, flags, addr, addr_len) +syscall sys_recvfrom nr 337 nbargs 6 types: (int, void *, size_t, unsigned, struct sockaddr *, int *) args: (fd, ubuf, size, flags, addr, addr_len) +syscall sys_shutdown nr 338 nbargs 2 types: (int, int) args: (fd, how) +syscall sys_setsockopt nr 339 nbargs 5 types: (int, int, int, char *, int) args: (fd, level, optname, optval, optlen) +syscall sys_getsockopt nr 340 nbargs 5 types: (int, int, int, char *, int *) args: (fd, level, optname, optval, optlen) +syscall sys_sendmsg nr 341 nbargs 3 types: (int, struct msghdr *, unsigned) args: (fd, msg, flags) +syscall sys_recvmsg nr 342 nbargs 3 types: (int, struct msghdr *, unsigned int) args: (fd, msg, flags) +syscall sys_recvmmsg nr 343 nbargs 5 types: (int, struct mmsghdr *, unsigned int, unsigned int, struct timespec *) args: (fd, mmsg, vlen, flags, timeout) +syscall sys_accept4 nr 344 nbargs 4 types: (int, struct sockaddr *, int *, int) args: (fd, upeer_sockaddr, upeer_addrlen, flags) +syscall sys_clock_adjtime nr 347 nbargs 2 types: (const clockid_t, struct timex *) args: (which_clock, utx) +syscall sys_syncfs nr 348 nbargs 1 types: (int) args: (fd) +syscall sys_sendmmsg nr 349 nbargs 4 types: (int, struct mmsghdr *, unsigned int, unsigned int) args: (fd, mmsg, vlen, flags) +syscall sys_setns nr 350 nbargs 2 types: (int, int) args: (fd, nstype) diff --git a/include/instrumentation/syscalls/3.1.0-rc6/x86-32-syscalls b/include/instrumentation/syscalls/3.1.0-rc6/x86-32-syscalls new file mode 100644 index 00000000..130c1e3e --- /dev/null +++ b/include/instrumentation/syscalls/3.1.0-rc6/x86-32-syscalls @@ -0,0 +1,291 @@ +syscall sys_restart_syscall nr 0 nbargs 0 types: () args: () +syscall sys_exit nr 1 nbargs 1 types: (int) args: (error_code) +syscall sys_read nr 3 nbargs 3 types: (unsigned int, char *, size_t) args: (fd, buf, count) +syscall sys_write nr 4 nbargs 3 types: (unsigned int, const char *, size_t) args: (fd, buf, count) +syscall sys_open nr 5 nbargs 3 types: (const char *, int, int) args: (filename, flags, mode) +syscall sys_close nr 6 nbargs 1 types: (unsigned int) args: (fd) +syscall sys_waitpid nr 7 nbargs 3 types: (pid_t, int *, int) args: (pid, stat_addr, options) +syscall sys_creat nr 8 nbargs 2 types: (const char *, int) args: (pathname, mode) +syscall sys_link nr 9 nbargs 2 types: (const char *, const char *) args: (oldname, newname) +syscall sys_unlink nr 10 nbargs 1 types: (const char *) args: (pathname) +syscall sys_chdir nr 12 nbargs 1 types: (const char *) args: (filename) +syscall sys_time nr 13 nbargs 1 types: (time_t *) args: (tloc) +syscall sys_mknod nr 14 nbargs 3 types: (const char *, int, unsigned) args: (filename, mode, dev) +syscall sys_chmod nr 15 nbargs 2 types: (const char *, mode_t) args: (filename, mode) +syscall sys_lchown16 nr 16 nbargs 3 types: (const char *, old_uid_t, old_gid_t) args: (filename, user, group) +syscall sys_stat nr 18 nbargs 2 types: (const char *, struct __old_kernel_stat *) args: (filename, statbuf) +syscall sys_lseek nr 19 nbargs 3 types: (unsigned int, off_t, unsigned int) args: (fd, offset, origin) +syscall sys_getpid nr 20 nbargs 0 types: () args: () +syscall sys_mount nr 21 nbargs 5 types: (char *, char *, char *, unsigned long, void *) args: (dev_name, dir_name, type, flags, data) +syscall sys_oldumount nr 22 nbargs 1 types: (char *) args: (name) +syscall sys_setuid16 nr 23 nbargs 1 types: (old_uid_t) args: (uid) +syscall sys_getuid16 nr 24 nbargs 0 types: () args: () +syscall sys_stime nr 25 nbargs 1 types: (time_t *) args: (tptr) +syscall sys_ptrace nr 26 nbargs 4 types: (long, long, unsigned long, unsigned long) args: (request, pid, addr, data) +syscall sys_alarm nr 27 nbargs 1 types: (unsigned int) args: (seconds) +syscall sys_fstat nr 28 nbargs 2 types: (unsigned int, struct __old_kernel_stat *) args: (fd, statbuf) +syscall sys_pause nr 29 nbargs 0 types: () args: () +syscall sys_utime nr 30 nbargs 2 types: (char *, struct utimbuf *) args: (filename, times) +syscall sys_access nr 33 nbargs 2 types: (const char *, int) args: (filename, mode) +syscall sys_nice nr 34 nbargs 1 types: (int) args: (increment) +syscall sys_sync nr 36 nbargs 0 types: () args: () +syscall sys_kill nr 37 nbargs 2 types: (pid_t, int) args: (pid, sig) +syscall sys_rename nr 38 nbargs 2 types: (const char *, const char *) args: (oldname, newname) +syscall sys_mkdir nr 39 nbargs 2 types: (const char *, int) args: (pathname, mode) +syscall sys_rmdir nr 40 nbargs 1 types: (const char *) args: (pathname) +syscall sys_dup nr 41 nbargs 1 types: (unsigned int) args: (fildes) +syscall sys_pipe nr 42 nbargs 1 types: (int *) args: (fildes) +syscall sys_times nr 43 nbargs 1 types: (struct tms *) args: (tbuf) +syscall sys_brk nr 45 nbargs 1 types: (unsigned long) args: (brk) +syscall sys_setgid16 nr 46 nbargs 1 types: (old_gid_t) args: (gid) +syscall sys_getgid16 nr 47 nbargs 0 types: () args: () +syscall sys_signal nr 48 nbargs 2 types: (int, __sighandler_t) args: (sig, handler) +syscall sys_geteuid16 nr 49 nbargs 0 types: () args: () +syscall sys_getegid16 nr 50 nbargs 0 types: () args: () +syscall sys_acct nr 51 nbargs 1 types: (const char *) args: (name) +syscall sys_umount nr 52 nbargs 2 types: (char *, int) args: (name, flags) +syscall sys_ioctl nr 54 nbargs 3 types: (unsigned int, unsigned int, unsigned long) args: (fd, cmd, arg) +syscall sys_fcntl nr 55 nbargs 3 types: (unsigned int, unsigned int, unsigned long) args: (fd, cmd, arg) +syscall sys_setpgid nr 57 nbargs 2 types: (pid_t, pid_t) args: (pid, pgid) +syscall sys_olduname nr 59 nbargs 1 types: (struct oldold_utsname *) args: (name) +syscall sys_umask nr 60 nbargs 1 types: (int) args: (mask) +syscall sys_chroot nr 61 nbargs 1 types: (const char *) args: (filename) +syscall sys_ustat nr 62 nbargs 2 types: (unsigned, struct ustat *) args: (dev, ubuf) +syscall sys_dup2 nr 63 nbargs 2 types: (unsigned int, unsigned int) args: (oldfd, newfd) +syscall sys_getppid nr 64 nbargs 0 types: () args: () +syscall sys_getpgrp nr 65 nbargs 0 types: () args: () +syscall sys_setsid nr 66 nbargs 0 types: () args: () +syscall sys_sgetmask nr 68 nbargs 0 types: () args: () +syscall sys_ssetmask nr 69 nbargs 1 types: (int) args: (newmask) +syscall sys_setreuid16 nr 70 nbargs 2 types: (old_uid_t, old_uid_t) args: (ruid, euid) +syscall sys_setregid16 nr 71 nbargs 2 types: (old_gid_t, old_gid_t) args: (rgid, egid) +syscall sys_sigpending nr 73 nbargs 1 types: (old_sigset_t *) args: (set) +syscall sys_sethostname nr 74 nbargs 2 types: (char *, int) args: (name, len) +syscall sys_setrlimit nr 75 nbargs 2 types: (unsigned int, struct rlimit *) args: (resource, rlim) +syscall sys_old_getrlimit nr 76 nbargs 2 types: (unsigned int, struct rlimit *) args: (resource, rlim) +syscall sys_getrusage nr 77 nbargs 2 types: (int, struct rusage *) args: (who, ru) +syscall sys_gettimeofday nr 78 nbargs 2 types: (struct timeval *, struct timezone *) args: (tv, tz) +syscall sys_settimeofday nr 79 nbargs 2 types: (struct timeval *, struct timezone *) args: (tv, tz) +syscall sys_getgroups16 nr 80 nbargs 2 types: (int, old_gid_t *) args: (gidsetsize, grouplist) +syscall sys_setgroups16 nr 81 nbargs 2 types: (int, old_gid_t *) args: (gidsetsize, grouplist) +syscall sys_old_select nr 82 nbargs 1 types: (struct sel_arg_struct *) args: (arg) +syscall sys_symlink nr 83 nbargs 2 types: (const char *, const char *) args: (oldname, newname) +syscall sys_lstat nr 84 nbargs 2 types: (const char *, struct __old_kernel_stat *) args: (filename, statbuf) +syscall sys_readlink nr 85 nbargs 3 types: (const char *, char *, int) args: (path, buf, bufsiz) +syscall sys_uselib nr 86 nbargs 1 types: (const char *) args: (library) +syscall sys_swapon nr 87 nbargs 2 types: (const char *, int) args: (specialfile, swap_flags) +syscall sys_reboot nr 88 nbargs 4 types: (int, int, unsigned int, void *) args: (magic1, magic2, cmd, arg) +syscall sys_old_readdir nr 89 nbargs 3 types: (unsigned int, struct old_linux_dirent *, unsigned int) args: (fd, dirent, count) +syscall sys_old_mmap nr 90 nbargs 1 types: (struct mmap_arg_struct *) args: (arg) +syscall sys_munmap nr 91 nbargs 2 types: (unsigned long, size_t) args: (addr, len) +syscall sys_truncate nr 92 nbargs 2 types: (const char *, long) args: (path, length) +syscall sys_ftruncate nr 93 nbargs 2 types: (unsigned int, unsigned long) args: (fd, length) +syscall sys_fchmod nr 94 nbargs 2 types: (unsigned int, mode_t) args: (fd, mode) +syscall sys_fchown16 nr 95 nbargs 3 types: (unsigned int, old_uid_t, old_gid_t) args: (fd, user, group) +syscall sys_getpriority nr 96 nbargs 2 types: (int, int) args: (which, who) +syscall sys_setpriority nr 97 nbargs 3 types: (int, int, int) args: (which, who, niceval) +syscall sys_statfs nr 99 nbargs 2 types: (const char *, struct statfs *) args: (pathname, buf) +syscall sys_fstatfs nr 100 nbargs 2 types: (unsigned int, struct statfs *) args: (fd, buf) +syscall sys_socketcall nr 102 nbargs 2 types: (int, unsigned long *) args: (call, args) +syscall sys_syslog nr 103 nbargs 3 types: (int, char *, int) args: (type, buf, len) +syscall sys_setitimer nr 104 nbargs 3 types: (int, struct itimerval *, struct itimerval *) args: (which, value, ovalue) +syscall sys_getitimer nr 105 nbargs 2 types: (int, struct itimerval *) args: (which, value) +syscall sys_newstat nr 106 nbargs 2 types: (const char *, struct stat *) args: (filename, statbuf) +syscall sys_newlstat nr 107 nbargs 2 types: (const char *, struct stat *) args: (filename, statbuf) +syscall sys_newfstat nr 108 nbargs 2 types: (unsigned int, struct stat *) args: (fd, statbuf) +syscall sys_uname nr 109 nbargs 1 types: (struct old_utsname *) args: (name) +syscall sys_vhangup nr 111 nbargs 0 types: () args: () +syscall sys_wait4 nr 114 nbargs 4 types: (pid_t, int *, int, struct rusage *) args: (upid, stat_addr, options, ru) +syscall sys_swapoff nr 115 nbargs 1 types: (const char *) args: (specialfile) +syscall sys_sysinfo nr 116 nbargs 1 types: (struct sysinfo *) args: (info) +syscall sys_ipc nr 117 nbargs 6 types: (unsigned int, int, unsigned long, unsigned long, void *, long) args: (call, first, second, third, ptr, fifth) +syscall sys_fsync nr 118 nbargs 1 types: (unsigned int) args: (fd) +syscall sys_setdomainname nr 121 nbargs 2 types: (char *, int) args: (name, len) +syscall sys_newuname nr 122 nbargs 1 types: (struct new_utsname *) args: (name) +syscall sys_adjtimex nr 124 nbargs 1 types: (struct timex *) args: (txc_p) +syscall sys_mprotect nr 125 nbargs 3 types: (unsigned long, size_t, unsigned long) args: (start, len, prot) +syscall sys_sigprocmask nr 126 nbargs 3 types: (int, old_sigset_t *, old_sigset_t *) args: (how, nset, oset) +syscall sys_init_module nr 128 nbargs 3 types: (void *, unsigned long, const char *) args: (umod, len, uargs) +syscall sys_delete_module nr 129 nbargs 2 types: (const char *, unsigned int) args: (name_user, flags) +syscall sys_quotactl nr 131 nbargs 4 types: (unsigned int, const char *, qid_t, void *) args: (cmd, special, id, addr) +syscall sys_getpgid nr 132 nbargs 1 types: (pid_t) args: (pid) +syscall sys_fchdir nr 133 nbargs 1 types: (unsigned int) args: (fd) +syscall sys_bdflush nr 134 nbargs 2 types: (int, long) args: (func, data) +syscall sys_sysfs nr 135 nbargs 3 types: (int, unsigned long, unsigned long) args: (option, arg1, arg2) +syscall sys_personality nr 136 nbargs 1 types: (unsigned int) args: (personality) +syscall sys_setfsuid16 nr 138 nbargs 1 types: (old_uid_t) args: (uid) +syscall sys_setfsgid16 nr 139 nbargs 1 types: (old_gid_t) args: (gid) +syscall sys_llseek nr 140 nbargs 5 types: (unsigned int, unsigned long, unsigned long, loff_t *, unsigned int) args: (fd, offset_high, offset_low, result, origin) +syscall sys_getdents nr 141 nbargs 3 types: (unsigned int, struct linux_dirent *, unsigned int) args: (fd, dirent, count) +syscall sys_select nr 142 nbargs 5 types: (int, fd_set *, fd_set *, fd_set *, struct timeval *) args: (n, inp, outp, exp, tvp) +syscall sys_flock nr 143 nbargs 2 types: (unsigned int, unsigned int) args: (fd, cmd) +syscall sys_msync nr 144 nbargs 3 types: (unsigned long, size_t, int) args: (start, len, flags) +syscall sys_readv nr 145 nbargs 3 types: (unsigned long, const struct iovec *, unsigned long) args: (fd, vec, vlen) +syscall sys_writev nr 146 nbargs 3 types: (unsigned long, const struct iovec *, unsigned long) args: (fd, vec, vlen) +syscall sys_getsid nr 147 nbargs 1 types: (pid_t) args: (pid) +syscall sys_fdatasync nr 148 nbargs 1 types: (unsigned int) args: (fd) +syscall sys_sysctl nr 149 nbargs 1 types: (struct __sysctl_args *) args: (args) +syscall sys_mlock nr 150 nbargs 2 types: (unsigned long, size_t) args: (start, len) +syscall sys_munlock nr 151 nbargs 2 types: (unsigned long, size_t) args: (start, len) +syscall sys_mlockall nr 152 nbargs 1 types: (int) args: (flags) +syscall sys_munlockall nr 153 nbargs 0 types: () args: () +syscall sys_sched_setparam nr 154 nbargs 2 types: (pid_t, struct sched_param *) args: (pid, param) +syscall sys_sched_getparam nr 155 nbargs 2 types: (pid_t, struct sched_param *) args: (pid, param) +syscall sys_sched_setscheduler nr 156 nbargs 3 types: (pid_t, int, struct sched_param *) args: (pid, policy, param) +syscall sys_sched_getscheduler nr 157 nbargs 1 types: (pid_t) args: (pid) +syscall sys_sched_yield nr 158 nbargs 0 types: () args: () +syscall sys_sched_get_priority_max nr 159 nbargs 1 types: (int) args: (policy) +syscall sys_sched_get_priority_min nr 160 nbargs 1 types: (int) args: (policy) +syscall sys_sched_rr_get_interval nr 161 nbargs 2 types: (pid_t, struct timespec *) args: (pid, interval) +syscall sys_nanosleep nr 162 nbargs 2 types: (struct timespec *, struct timespec *) args: (rqtp, rmtp) +syscall sys_mremap nr 163 nbargs 5 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long) args: (addr, old_len, new_len, flags, new_addr) +syscall sys_setresuid16 nr 164 nbargs 3 types: (old_uid_t, old_uid_t, old_uid_t) args: (ruid, euid, suid) +syscall sys_getresuid16 nr 165 nbargs 3 types: (old_uid_t *, old_uid_t *, old_uid_t *) args: (ruid, euid, suid) +syscall sys_poll nr 168 nbargs 3 types: (struct pollfd *, unsigned int, long) args: (ufds, nfds, timeout_msecs) +syscall sys_setresgid16 nr 170 nbargs 3 types: (old_gid_t, old_gid_t, old_gid_t) args: (rgid, egid, sgid) +syscall sys_getresgid16 nr 171 nbargs 3 types: (old_gid_t *, old_gid_t *, old_gid_t *) args: (rgid, egid, sgid) +syscall sys_prctl nr 172 nbargs 5 types: (int, unsigned long, unsigned long, unsigned long, unsigned long) args: (option, arg2, arg3, arg4, arg5) +syscall sys_rt_sigaction nr 174 nbargs 4 types: (int, const struct sigaction *, struct sigaction *, size_t) args: (sig, act, oact, sigsetsize) +syscall sys_rt_sigprocmask nr 175 nbargs 4 types: (int, sigset_t *, sigset_t *, size_t) args: (how, nset, oset, sigsetsize) +syscall sys_rt_sigpending nr 176 nbargs 2 types: (sigset_t *, size_t) args: (set, sigsetsize) +syscall sys_rt_sigtimedwait nr 177 nbargs 4 types: (const sigset_t *, siginfo_t *, const struct timespec *, size_t) args: (uthese, uinfo, uts, sigsetsize) +syscall sys_rt_sigqueueinfo nr 178 nbargs 3 types: (pid_t, int, siginfo_t *) args: (pid, sig, uinfo) +syscall sys_rt_sigsuspend nr 179 nbargs 2 types: (sigset_t *, size_t) args: (unewset, sigsetsize) +syscall sys_chown16 nr 182 nbargs 3 types: (const char *, old_uid_t, old_gid_t) args: (filename, user, group) +syscall sys_getcwd nr 183 nbargs 2 types: (char *, unsigned long) args: (buf, size) +syscall sys_capget nr 184 nbargs 2 types: (cap_user_header_t, cap_user_data_t) args: (header, dataptr) +syscall sys_capset nr 185 nbargs 2 types: (cap_user_header_t, const cap_user_data_t) args: (header, data) +syscall sys_sendfile nr 187 nbargs 4 types: (int, int, off_t *, size_t) args: (out_fd, in_fd, offset, count) +syscall sys_getrlimit nr 191 nbargs 2 types: (unsigned int, struct rlimit *) args: (resource, rlim) +syscall sys_mmap_pgoff nr 192 nbargs 6 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long, unsigned long) args: (addr, len, prot, flags, fd, pgoff) +syscall sys_stat64 nr 195 nbargs 2 types: (const char *, struct stat64 *) args: (filename, statbuf) +syscall sys_lstat64 nr 196 nbargs 2 types: (const char *, struct stat64 *) args: (filename, statbuf) +syscall sys_fstat64 nr 197 nbargs 2 types: (unsigned long, struct stat64 *) args: (fd, statbuf) +syscall sys_lchown nr 198 nbargs 3 types: (const char *, uid_t, gid_t) args: (filename, user, group) +syscall sys_getuid nr 199 nbargs 0 types: () args: () +syscall sys_getgid nr 200 nbargs 0 types: () args: () +syscall sys_geteuid nr 201 nbargs 0 types: () args: () +syscall sys_getegid nr 202 nbargs 0 types: () args: () +syscall sys_setreuid nr 203 nbargs 2 types: (uid_t, uid_t) args: (ruid, euid) +syscall sys_setregid nr 204 nbargs 2 types: (gid_t, gid_t) args: (rgid, egid) +syscall sys_getgroups nr 205 nbargs 2 types: (int, gid_t *) args: (gidsetsize, grouplist) +syscall sys_setgroups nr 206 nbargs 2 types: (int, gid_t *) args: (gidsetsize, grouplist) +syscall sys_fchown nr 207 nbargs 3 types: (unsigned int, uid_t, gid_t) args: (fd, user, group) +syscall sys_setresuid nr 208 nbargs 3 types: (uid_t, uid_t, uid_t) args: (ruid, euid, suid) +syscall sys_getresuid nr 209 nbargs 3 types: (uid_t *, uid_t *, uid_t *) args: (ruid, euid, suid) +syscall sys_setresgid nr 210 nbargs 3 types: (gid_t, gid_t, gid_t) args: (rgid, egid, sgid) +syscall sys_getresgid nr 211 nbargs 3 types: (gid_t *, gid_t *, gid_t *) args: (rgid, egid, sgid) +syscall sys_chown nr 212 nbargs 3 types: (const char *, uid_t, gid_t) args: (filename, user, group) +syscall sys_setuid nr 213 nbargs 1 types: (uid_t) args: (uid) +syscall sys_setgid nr 214 nbargs 1 types: (gid_t) args: (gid) +syscall sys_setfsuid nr 215 nbargs 1 types: (uid_t) args: (uid) +syscall sys_setfsgid nr 216 nbargs 1 types: (gid_t) args: (gid) +syscall sys_pivot_root nr 217 nbargs 2 types: (const char *, const char *) args: (new_root, put_old) +syscall sys_mincore nr 218 nbargs 3 types: (unsigned long, size_t, unsigned char *) args: (start, len, vec) +syscall sys_madvise nr 219 nbargs 3 types: (unsigned long, size_t, int) args: (start, len_in, behavior) +syscall sys_getdents64 nr 220 nbargs 3 types: (unsigned int, struct linux_dirent64 *, unsigned int) args: (fd, dirent, count) +syscall sys_fcntl64 nr 221 nbargs 3 types: (unsigned int, unsigned int, unsigned long) args: (fd, cmd, arg) +syscall sys_gettid nr 224 nbargs 0 types: () args: () +syscall sys_setxattr nr 226 nbargs 5 types: (const char *, const char *, const void *, size_t, int) args: (pathname, name, value, size, flags) +syscall sys_lsetxattr nr 227 nbargs 5 types: (const char *, const char *, const void *, size_t, int) args: (pathname, name, value, size, flags) +syscall sys_fsetxattr nr 228 nbargs 5 types: (int, const char *, const void *, size_t, int) args: (fd, name, value, size, flags) +syscall sys_getxattr nr 229 nbargs 4 types: (const char *, const char *, void *, size_t) args: (pathname, name, value, size) +syscall sys_lgetxattr nr 230 nbargs 4 types: (const char *, const char *, void *, size_t) args: (pathname, name, value, size) +syscall sys_fgetxattr nr 231 nbargs 4 types: (int, const char *, void *, size_t) args: (fd, name, value, size) +syscall sys_listxattr nr 232 nbargs 3 types: (const char *, char *, size_t) args: (pathname, list, size) +syscall sys_llistxattr nr 233 nbargs 3 types: (const char *, char *, size_t) args: (pathname, list, size) +syscall sys_flistxattr nr 234 nbargs 3 types: (int, char *, size_t) args: (fd, list, size) +syscall sys_removexattr nr 235 nbargs 2 types: (const char *, const char *) args: (pathname, name) +syscall sys_lremovexattr nr 236 nbargs 2 types: (const char *, const char *) args: (pathname, name) +syscall sys_fremovexattr nr 237 nbargs 2 types: (int, const char *) args: (fd, name) +syscall sys_tkill nr 238 nbargs 2 types: (pid_t, int) args: (pid, sig) +syscall sys_sendfile64 nr 239 nbargs 4 types: (int, int, loff_t *, size_t) args: (out_fd, in_fd, offset, count) +syscall sys_futex nr 240 nbargs 6 types: (u32 *, int, u32, struct timespec *, u32 *, u32) args: (uaddr, op, val, utime, uaddr2, val3) +syscall sys_sched_setaffinity nr 241 nbargs 3 types: (pid_t, unsigned int, unsigned long *) args: (pid, len, user_mask_ptr) +syscall sys_sched_getaffinity nr 242 nbargs 3 types: (pid_t, unsigned int, unsigned long *) args: (pid, len, user_mask_ptr) +syscall sys_io_setup nr 245 nbargs 2 types: (unsigned, aio_context_t *) args: (nr_events, ctxp) +syscall sys_io_destroy nr 246 nbargs 1 types: (aio_context_t) args: (ctx) +syscall sys_io_getevents nr 247 nbargs 5 types: (aio_context_t, long, long, struct io_event *, struct timespec *) args: (ctx_id, min_nr, nr, events, timeout) +syscall sys_io_submit nr 248 nbargs 3 types: (aio_context_t, long, struct iocb * *) args: (ctx_id, nr, iocbpp) +syscall sys_io_cancel nr 249 nbargs 3 types: (aio_context_t, struct iocb *, struct io_event *) args: (ctx_id, iocb, result) +syscall sys_exit_group nr 252 nbargs 1 types: (int) args: (error_code) +syscall sys_epoll_create nr 254 nbargs 1 types: (int) args: (size) +syscall sys_epoll_ctl nr 255 nbargs 4 types: (int, int, int, struct epoll_event *) args: (epfd, op, fd, event) +syscall sys_epoll_wait nr 256 nbargs 4 types: (int, struct epoll_event *, int, int) args: (epfd, events, maxevents, timeout) +syscall sys_remap_file_pages nr 257 nbargs 5 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long) args: (start, size, prot, pgoff, flags) +syscall sys_set_tid_address nr 258 nbargs 1 types: (int *) args: (tidptr) +syscall sys_timer_create nr 259 nbargs 3 types: (const clockid_t, struct sigevent *, timer_t *) args: (which_clock, timer_event_spec, created_timer_id) +syscall sys_timer_settime nr 260 nbargs 4 types: (timer_t, int, const struct itimerspec *, struct itimerspec *) args: (timer_id, flags, new_setting, old_setting) +syscall sys_timer_gettime nr 261 nbargs 2 types: (timer_t, struct itimerspec *) args: (timer_id, setting) +syscall sys_timer_getoverrun nr 262 nbargs 1 types: (timer_t) args: (timer_id) +syscall sys_timer_delete nr 263 nbargs 1 types: (timer_t) args: (timer_id) +syscall sys_clock_settime nr 264 nbargs 2 types: (const clockid_t, const struct timespec *) args: (which_clock, tp) +syscall sys_clock_gettime nr 265 nbargs 2 types: (const clockid_t, struct timespec *) args: (which_clock, tp) +syscall sys_clock_getres nr 266 nbargs 2 types: (const clockid_t, struct timespec *) args: (which_clock, tp) +syscall sys_clock_nanosleep nr 267 nbargs 4 types: (const clockid_t, int, const struct timespec *, struct timespec *) args: (which_clock, flags, rqtp, rmtp) +syscall sys_statfs64 nr 268 nbargs 3 types: (const char *, size_t, struct statfs64 *) args: (pathname, sz, buf) +syscall sys_fstatfs64 nr 269 nbargs 3 types: (unsigned int, size_t, struct statfs64 *) args: (fd, sz, buf) +syscall sys_tgkill nr 270 nbargs 3 types: (pid_t, pid_t, int) args: (tgid, pid, sig) +syscall sys_utimes nr 271 nbargs 2 types: (char *, struct timeval *) args: (filename, utimes) +syscall sys_mq_open nr 277 nbargs 4 types: (const char *, int, mode_t, struct mq_attr *) args: (u_name, oflag, mode, u_attr) +syscall sys_mq_unlink nr 278 nbargs 1 types: (const char *) args: (u_name) +syscall sys_mq_timedsend nr 279 nbargs 5 types: (mqd_t, const char *, size_t, unsigned int, const struct timespec *) args: (mqdes, u_msg_ptr, msg_len, msg_prio, u_abs_timeout) +syscall sys_mq_timedreceive nr 280 nbargs 5 types: (mqd_t, char *, size_t, unsigned int *, const struct timespec *) args: (mqdes, u_msg_ptr, msg_len, u_msg_prio, u_abs_timeout) +syscall sys_mq_notify nr 281 nbargs 2 types: (mqd_t, const struct sigevent *) args: (mqdes, u_notification) +syscall sys_mq_getsetattr nr 282 nbargs 3 types: (mqd_t, const struct mq_attr *, struct mq_attr *) args: (mqdes, u_mqstat, u_omqstat) +syscall sys_kexec_load nr 283 nbargs 4 types: (unsigned long, unsigned long, struct kexec_segment *, unsigned long) args: (entry, nr_segments, segments, flags) +syscall sys_waitid nr 284 nbargs 5 types: (int, pid_t, struct siginfo *, int, struct rusage *) args: (which, upid, infop, options, ru) +syscall sys_add_key nr 286 nbargs 5 types: (const char *, const char *, const void *, size_t, key_serial_t) args: (_type, _description, _payload, plen, ringid) +syscall sys_request_key nr 287 nbargs 4 types: (const char *, const char *, const char *, key_serial_t) args: (_type, _description, _callout_info, destringid) +syscall sys_keyctl nr 288 nbargs 5 types: (int, unsigned long, unsigned long, unsigned long, unsigned long) args: (option, arg2, arg3, arg4, arg5) +syscall sys_ioprio_set nr 289 nbargs 3 types: (int, int, int) args: (which, who, ioprio) +syscall sys_ioprio_get nr 290 nbargs 2 types: (int, int) args: (which, who) +syscall sys_inotify_init nr 291 nbargs 0 types: () args: () +syscall sys_inotify_add_watch nr 292 nbargs 3 types: (int, const char *, u32) args: (fd, pathname, mask) +syscall sys_inotify_rm_watch nr 293 nbargs 2 types: (int, __s32) args: (fd, wd) +syscall sys_openat nr 295 nbargs 4 types: (int, const char *, int, int) args: (dfd, filename, flags, mode) +syscall sys_mkdirat nr 296 nbargs 3 types: (int, const char *, int) args: (dfd, pathname, mode) +syscall sys_mknodat nr 297 nbargs 4 types: (int, const char *, int, unsigned) args: (dfd, filename, mode, dev) +syscall sys_fchownat nr 298 nbargs 5 types: (int, const char *, uid_t, gid_t, int) args: (dfd, filename, user, group, flag) +syscall sys_futimesat nr 299 nbargs 3 types: (int, const char *, struct timeval *) args: (dfd, filename, utimes) +syscall sys_fstatat64 nr 300 nbargs 4 types: (int, const char *, struct stat64 *, int) args: (dfd, filename, statbuf, flag) +syscall sys_unlinkat nr 301 nbargs 3 types: (int, const char *, int) args: (dfd, pathname, flag) +syscall sys_renameat nr 302 nbargs 4 types: (int, const char *, int, const char *) args: (olddfd, oldname, newdfd, newname) +syscall sys_linkat nr 303 nbargs 5 types: (int, const char *, int, const char *, int) args: (olddfd, oldname, newdfd, newname, flags) +syscall sys_symlinkat nr 304 nbargs 3 types: (const char *, int, const char *) args: (oldname, newdfd, newname) +syscall sys_readlinkat nr 305 nbargs 4 types: (int, const char *, char *, int) args: (dfd, pathname, buf, bufsiz) +syscall sys_fchmodat nr 306 nbargs 3 types: (int, const char *, mode_t) args: (dfd, filename, mode) +syscall sys_faccessat nr 307 nbargs 3 types: (int, const char *, int) args: (dfd, filename, mode) +syscall sys_pselect6 nr 308 nbargs 6 types: (int, fd_set *, fd_set *, fd_set *, struct timespec *, void *) args: (n, inp, outp, exp, tsp, sig) +syscall sys_ppoll nr 309 nbargs 5 types: (struct pollfd *, unsigned int, struct timespec *, const sigset_t *, size_t) args: (ufds, nfds, tsp, sigmask, sigsetsize) +syscall sys_unshare nr 310 nbargs 1 types: (unsigned long) args: (unshare_flags) +syscall sys_set_robust_list nr 311 nbargs 2 types: (struct robust_list_head *, size_t) args: (head, len) +syscall sys_get_robust_list nr 312 nbargs 3 types: (int, struct robust_list_head * *, size_t *) args: (pid, head_ptr, len_ptr) +syscall sys_splice nr 313 nbargs 6 types: (int, loff_t *, int, loff_t *, size_t, unsigned int) args: (fd_in, off_in, fd_out, off_out, len, flags) +syscall sys_tee nr 315 nbargs 4 types: (int, int, size_t, unsigned int) args: (fdin, fdout, len, flags) +syscall sys_vmsplice nr 316 nbargs 4 types: (int, const struct iovec *, unsigned long, unsigned int) args: (fd, iov, nr_segs, flags) +syscall sys_getcpu nr 318 nbargs 3 types: (unsigned *, unsigned *, struct getcpu_cache *) args: (cpup, nodep, unused) +syscall sys_epoll_pwait nr 319 nbargs 6 types: (int, struct epoll_event *, int, int, const sigset_t *, size_t) args: (epfd, events, maxevents, timeout, sigmask, sigsetsize) +syscall sys_utimensat nr 320 nbargs 4 types: (int, const char *, struct timespec *, int) args: (dfd, filename, utimes, flags) +syscall sys_signalfd nr 321 nbargs 3 types: (int, sigset_t *, size_t) args: (ufd, user_mask, sizemask) +syscall sys_timerfd_create nr 322 nbargs 2 types: (int, int) args: (clockid, flags) +syscall sys_eventfd nr 323 nbargs 1 types: (unsigned int) args: (count) +syscall sys_timerfd_settime nr 325 nbargs 4 types: (int, int, const struct itimerspec *, struct itimerspec *) args: (ufd, flags, utmr, otmr) +syscall sys_timerfd_gettime nr 326 nbargs 2 types: (int, struct itimerspec *) args: (ufd, otmr) +syscall sys_signalfd4 nr 327 nbargs 4 types: (int, sigset_t *, size_t, int) args: (ufd, user_mask, sizemask, flags) +syscall sys_eventfd2 nr 328 nbargs 2 types: (unsigned int, int) args: (count, flags) +syscall sys_epoll_create1 nr 329 nbargs 1 types: (int) args: (flags) +syscall sys_dup3 nr 330 nbargs 3 types: (unsigned int, unsigned int, int) args: (oldfd, newfd, flags) +syscall sys_pipe2 nr 331 nbargs 2 types: (int *, int) args: (fildes, flags) +syscall sys_inotify_init1 nr 332 nbargs 1 types: (int) args: (flags) +syscall sys_preadv nr 333 nbargs 5 types: (unsigned long, const struct iovec *, unsigned long, unsigned long, unsigned long) args: (fd, vec, vlen, pos_l, pos_h) +syscall sys_pwritev nr 334 nbargs 5 types: (unsigned long, const struct iovec *, unsigned long, unsigned long, unsigned long) args: (fd, vec, vlen, pos_l, pos_h) +syscall sys_rt_tgsigqueueinfo nr 335 nbargs 4 types: (pid_t, pid_t, int, siginfo_t *) args: (tgid, pid, sig, uinfo) +syscall sys_perf_event_open nr 336 nbargs 5 types: (struct perf_event_attr *, pid_t, int, int, unsigned long) args: (attr_uptr, pid, cpu, group_fd, flags) +syscall sys_recvmmsg nr 337 nbargs 5 types: (int, struct mmsghdr *, unsigned int, unsigned int, struct timespec *) args: (fd, mmsg, vlen, flags, timeout) +syscall sys_fanotify_init nr 338 nbargs 2 types: (unsigned int, unsigned int) args: (flags, event_f_flags) +syscall sys_prlimit64 nr 340 nbargs 4 types: (pid_t, unsigned int, const struct rlimit64 *, struct rlimit64 *) args: (pid, resource, new_rlim, old_rlim) +syscall sys_clock_adjtime nr 343 nbargs 2 types: (const clockid_t, struct timex *) args: (which_clock, utx) +syscall sys_syncfs nr 344 nbargs 1 types: (int) args: (fd) +syscall sys_sendmmsg nr 345 nbargs 4 types: (int, struct mmsghdr *, unsigned int, unsigned int) args: (fd, mmsg, vlen, flags) +syscall sys_setns nr 346 nbargs 2 types: (int, int) args: (fd, nstype) diff --git a/include/instrumentation/syscalls/3.10.0-rc7/x86-64-syscalls b/include/instrumentation/syscalls/3.10.0-rc7/x86-64-syscalls new file mode 100644 index 00000000..5db1a4f1 --- /dev/null +++ b/include/instrumentation/syscalls/3.10.0-rc7/x86-64-syscalls @@ -0,0 +1,289 @@ +syscall sys_read nr 0 nbargs 3 types: (unsigned int, char *, size_t) args: (fd, buf, count) +syscall sys_write nr 1 nbargs 3 types: (unsigned int, const char *, size_t) args: (fd, buf, count) +syscall sys_open nr 2 nbargs 3 types: (const char *, int, umode_t) args: (filename, flags, mode) +syscall sys_close nr 3 nbargs 1 types: (unsigned int) args: (fd) +syscall sys_newstat nr 4 nbargs 2 types: (const char *, struct stat *) args: (filename, statbuf) +syscall sys_newfstat nr 5 nbargs 2 types: (unsigned int, struct stat *) args: (fd, statbuf) +syscall sys_newlstat nr 6 nbargs 2 types: (const char *, struct stat *) args: (filename, statbuf) +syscall sys_poll nr 7 nbargs 3 types: (struct pollfd *, unsigned int, int) args: (ufds, nfds, timeout_msecs) +syscall sys_lseek nr 8 nbargs 3 types: (unsigned int, off_t, unsigned int) args: (fd, offset, whence) +syscall sys_mmap nr 9 nbargs 6 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long, unsigned long) args: (addr, len, prot, flags, fd, off) +syscall sys_mprotect nr 10 nbargs 3 types: (unsigned long, size_t, unsigned long) args: (start, len, prot) +syscall sys_munmap nr 11 nbargs 2 types: (unsigned long, size_t) args: (addr, len) +syscall sys_brk nr 12 nbargs 1 types: (unsigned long) args: (brk) +syscall sys_rt_sigaction nr 13 nbargs 4 types: (int, const struct sigaction *, struct sigaction *, size_t) args: (sig, act, oact, sigsetsize) +syscall sys_rt_sigprocmask nr 14 nbargs 4 types: (int, sigset_t *, sigset_t *, size_t) args: (how, nset, oset, sigsetsize) +syscall sys_ioctl nr 16 nbargs 3 types: (unsigned int, unsigned int, unsigned long) args: (fd, cmd, arg) +syscall sys_pread64 nr 17 nbargs 4 types: (unsigned int, char *, size_t, loff_t) args: (fd, buf, count, pos) +syscall sys_pwrite64 nr 18 nbargs 4 types: (unsigned int, const char *, size_t, loff_t) args: (fd, buf, count, pos) +syscall sys_readv nr 19 nbargs 3 types: (unsigned long, const struct iovec *, unsigned long) args: (fd, vec, vlen) +syscall sys_writev nr 20 nbargs 3 types: (unsigned long, const struct iovec *, unsigned long) args: (fd, vec, vlen) +syscall sys_access nr 21 nbargs 2 types: (const char *, int) args: (filename, mode) +syscall sys_pipe nr 22 nbargs 1 types: (int *) args: (fildes) +syscall sys_select nr 23 nbargs 5 types: (int, fd_set *, fd_set *, fd_set *, struct timeval *) args: (n, inp, outp, exp, tvp) +syscall sys_sched_yield nr 24 nbargs 0 types: () args: () +syscall sys_mremap nr 25 nbargs 5 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long) args: (addr, old_len, new_len, flags, new_addr) +syscall sys_msync nr 26 nbargs 3 types: (unsigned long, size_t, int) args: (start, len, flags) +syscall sys_mincore nr 27 nbargs 3 types: (unsigned long, size_t, unsigned char *) args: (start, len, vec) +syscall sys_madvise nr 28 nbargs 3 types: (unsigned long, size_t, int) args: (start, len_in, behavior) +syscall sys_shmget nr 29 nbargs 3 types: (key_t, size_t, int) args: (key, size, shmflg) +syscall sys_shmat nr 30 nbargs 3 types: (int, char *, int) args: (shmid, shmaddr, shmflg) +syscall sys_shmctl nr 31 nbargs 3 types: (int, int, struct shmid_ds *) args: (shmid, cmd, buf) +syscall sys_dup nr 32 nbargs 1 types: (unsigned int) args: (fildes) +syscall sys_dup2 nr 33 nbargs 2 types: (unsigned int, unsigned int) args: (oldfd, newfd) +syscall sys_pause nr 34 nbargs 0 types: () args: () +syscall sys_nanosleep nr 35 nbargs 2 types: (struct timespec *, struct timespec *) args: (rqtp, rmtp) +syscall sys_getitimer nr 36 nbargs 2 types: (int, struct itimerval *) args: (which, value) +syscall sys_alarm nr 37 nbargs 1 types: (unsigned int) args: (seconds) +syscall sys_setitimer nr 38 nbargs 3 types: (int, struct itimerval *, struct itimerval *) args: (which, value, ovalue) +syscall sys_getpid nr 39 nbargs 0 types: () args: () +syscall sys_sendfile64 nr 40 nbargs 4 types: (int, int, loff_t *, size_t) args: (out_fd, in_fd, offset, count) +syscall sys_socket nr 41 nbargs 3 types: (int, int, int) args: (family, type, protocol) +syscall sys_connect nr 42 nbargs 3 types: (int, struct sockaddr *, int) args: (fd, uservaddr, addrlen) +syscall sys_accept nr 43 nbargs 3 types: (int, struct sockaddr *, int *) args: (fd, upeer_sockaddr, upeer_addrlen) +syscall sys_sendto nr 44 nbargs 6 types: (int, void *, size_t, unsigned int, struct sockaddr *, int) args: (fd, buff, len, flags, addr, addr_len) +syscall sys_recvfrom nr 45 nbargs 6 types: (int, void *, size_t, unsigned int, struct sockaddr *, int *) args: (fd, ubuf, size, flags, addr, addr_len) +syscall sys_sendmsg nr 46 nbargs 3 types: (int, struct msghdr *, unsigned int) args: (fd, msg, flags) +syscall sys_recvmsg nr 47 nbargs 3 types: (int, struct msghdr *, unsigned int) args: (fd, msg, flags) +syscall sys_shutdown nr 48 nbargs 2 types: (int, int) args: (fd, how) +syscall sys_bind nr 49 nbargs 3 types: (int, struct sockaddr *, int) args: (fd, umyaddr, addrlen) +syscall sys_listen nr 50 nbargs 2 types: (int, int) args: (fd, backlog) +syscall sys_getsockname nr 51 nbargs 3 types: (int, struct sockaddr *, int *) args: (fd, usockaddr, usockaddr_len) +syscall sys_getpeername nr 52 nbargs 3 types: (int, struct sockaddr *, int *) args: (fd, usockaddr, usockaddr_len) +syscall sys_socketpair nr 53 nbargs 4 types: (int, int, int, int *) args: (family, type, protocol, usockvec) +syscall sys_setsockopt nr 54 nbargs 5 types: (int, int, int, char *, int) args: (fd, level, optname, optval, optlen) +syscall sys_getsockopt nr 55 nbargs 5 types: (int, int, int, char *, int *) args: (fd, level, optname, optval, optlen) +syscall sys_exit nr 60 nbargs 1 types: (int) args: (error_code) +syscall sys_wait4 nr 61 nbargs 4 types: (pid_t, int *, int, struct rusage *) args: (upid, stat_addr, options, ru) +syscall sys_kill nr 62 nbargs 2 types: (pid_t, int) args: (pid, sig) +syscall sys_newuname nr 63 nbargs 1 types: (struct new_utsname *) args: (name) +syscall sys_semget nr 64 nbargs 3 types: (key_t, int, int) args: (key, nsems, semflg) +syscall sys_semop nr 65 nbargs 3 types: (int, struct sembuf *, unsigned) args: (semid, tsops, nsops) +syscall sys_semctl nr 66 nbargs 4 types: (int, int, int, unsigned long) args: (semid, semnum, cmd, arg) +syscall sys_shmdt nr 67 nbargs 1 types: (char *) args: (shmaddr) +syscall sys_msgget nr 68 nbargs 2 types: (key_t, int) args: (key, msgflg) +syscall sys_msgsnd nr 69 nbargs 4 types: (int, struct msgbuf *, size_t, int) args: (msqid, msgp, msgsz, msgflg) +syscall sys_msgrcv nr 70 nbargs 5 types: (int, struct msgbuf *, size_t, long, int) args: (msqid, msgp, msgsz, msgtyp, msgflg) +syscall sys_msgctl nr 71 nbargs 3 types: (int, int, struct msqid_ds *) args: (msqid, cmd, buf) +syscall sys_fcntl nr 72 nbargs 3 types: (unsigned int, unsigned int, unsigned long) args: (fd, cmd, arg) +syscall sys_flock nr 73 nbargs 2 types: (unsigned int, unsigned int) args: (fd, cmd) +syscall sys_fsync nr 74 nbargs 1 types: (unsigned int) args: (fd) +syscall sys_fdatasync nr 75 nbargs 1 types: (unsigned int) args: (fd) +syscall sys_truncate nr 76 nbargs 2 types: (const char *, long) args: (path, length) +syscall sys_ftruncate nr 77 nbargs 2 types: (unsigned int, unsigned long) args: (fd, length) +syscall sys_getdents nr 78 nbargs 3 types: (unsigned int, struct linux_dirent *, unsigned int) args: (fd, dirent, count) +syscall sys_getcwd nr 79 nbargs 2 types: (char *, unsigned long) args: (buf, size) +syscall sys_chdir nr 80 nbargs 1 types: (const char *) args: (filename) +syscall sys_fchdir nr 81 nbargs 1 types: (unsigned int) args: (fd) +syscall sys_rename nr 82 nbargs 2 types: (const char *, const char *) args: (oldname, newname) +syscall sys_mkdir nr 83 nbargs 2 types: (const char *, umode_t) args: (pathname, mode) +syscall sys_rmdir nr 84 nbargs 1 types: (const char *) args: (pathname) +syscall sys_creat nr 85 nbargs 2 types: (const char *, umode_t) args: (pathname, mode) +syscall sys_link nr 86 nbargs 2 types: (const char *, const char *) args: (oldname, newname) +syscall sys_unlink nr 87 nbargs 1 types: (const char *) args: (pathname) +syscall sys_symlink nr 88 nbargs 2 types: (const char *, const char *) args: (oldname, newname) +syscall sys_readlink nr 89 nbargs 3 types: (const char *, char *, int) args: (path, buf, bufsiz) +syscall sys_chmod nr 90 nbargs 2 types: (const char *, umode_t) args: (filename, mode) +syscall sys_fchmod nr 91 nbargs 2 types: (unsigned int, umode_t) args: (fd, mode) +syscall sys_chown nr 92 nbargs 3 types: (const char *, uid_t, gid_t) args: (filename, user, group) +syscall sys_fchown nr 93 nbargs 3 types: (unsigned int, uid_t, gid_t) args: (fd, user, group) +syscall sys_lchown nr 94 nbargs 3 types: (const char *, uid_t, gid_t) args: (filename, user, group) +syscall sys_umask nr 95 nbargs 1 types: (int) args: (mask) +syscall sys_gettimeofday nr 96 nbargs 2 types: (struct timeval *, struct timezone *) args: (tv, tz) +syscall sys_getrlimit nr 97 nbargs 2 types: (unsigned int, struct rlimit *) args: (resource, rlim) +syscall sys_getrusage nr 98 nbargs 2 types: (int, struct rusage *) args: (who, ru) +syscall sys_sysinfo nr 99 nbargs 1 types: (struct sysinfo *) args: (info) +syscall sys_times nr 100 nbargs 1 types: (struct tms *) args: (tbuf) +syscall sys_ptrace nr 101 nbargs 4 types: (long, long, unsigned long, unsigned long) args: (request, pid, addr, data) +syscall sys_getuid nr 102 nbargs 0 types: () args: () +syscall sys_syslog nr 103 nbargs 3 types: (int, char *, int) args: (type, buf, len) +syscall sys_getgid nr 104 nbargs 0 types: () args: () +syscall sys_setuid nr 105 nbargs 1 types: (uid_t) args: (uid) +syscall sys_setgid nr 106 nbargs 1 types: (gid_t) args: (gid) +syscall sys_geteuid nr 107 nbargs 0 types: () args: () +syscall sys_getegid nr 108 nbargs 0 types: () args: () +syscall sys_setpgid nr 109 nbargs 2 types: (pid_t, pid_t) args: (pid, pgid) +syscall sys_getppid nr 110 nbargs 0 types: () args: () +syscall sys_getpgrp nr 111 nbargs 0 types: () args: () +syscall sys_setsid nr 112 nbargs 0 types: () args: () +syscall sys_setreuid nr 113 nbargs 2 types: (uid_t, uid_t) args: (ruid, euid) +syscall sys_setregid nr 114 nbargs 2 types: (gid_t, gid_t) args: (rgid, egid) +syscall sys_getgroups nr 115 nbargs 2 types: (int, gid_t *) args: (gidsetsize, grouplist) +syscall sys_setgroups nr 116 nbargs 2 types: (int, gid_t *) args: (gidsetsize, grouplist) +syscall sys_setresuid nr 117 nbargs 3 types: (uid_t, uid_t, uid_t) args: (ruid, euid, suid) +syscall sys_getresuid nr 118 nbargs 3 types: (uid_t *, uid_t *, uid_t *) args: (ruidp, euidp, suidp) +syscall sys_setresgid nr 119 nbargs 3 types: (gid_t, gid_t, gid_t) args: (rgid, egid, sgid) +syscall sys_getresgid nr 120 nbargs 3 types: (gid_t *, gid_t *, gid_t *) args: (rgidp, egidp, sgidp) +syscall sys_getpgid nr 121 nbargs 1 types: (pid_t) args: (pid) +syscall sys_setfsuid nr 122 nbargs 1 types: (uid_t) args: (uid) +syscall sys_setfsgid nr 123 nbargs 1 types: (gid_t) args: (gid) +syscall sys_getsid nr 124 nbargs 1 types: (pid_t) args: (pid) +syscall sys_capget nr 125 nbargs 2 types: (cap_user_header_t, cap_user_data_t) args: (header, dataptr) +syscall sys_capset nr 126 nbargs 2 types: (cap_user_header_t, const cap_user_data_t) args: (header, data) +syscall sys_rt_sigpending nr 127 nbargs 2 types: (sigset_t *, size_t) args: (uset, sigsetsize) +syscall sys_rt_sigtimedwait nr 128 nbargs 4 types: (const sigset_t *, siginfo_t *, const struct timespec *, size_t) args: (uthese, uinfo, uts, sigsetsize) +syscall sys_rt_sigqueueinfo nr 129 nbargs 3 types: (pid_t, int, siginfo_t *) args: (pid, sig, uinfo) +syscall sys_rt_sigsuspend nr 130 nbargs 2 types: (sigset_t *, size_t) args: (unewset, sigsetsize) +syscall sys_sigaltstack nr 131 nbargs 2 types: (const stack_t *, stack_t *) args: (uss, uoss) +syscall sys_utime nr 132 nbargs 2 types: (char *, struct utimbuf *) args: (filename, times) +syscall sys_mknod nr 133 nbargs 3 types: (const char *, umode_t, unsigned) args: (filename, mode, dev) +syscall sys_personality nr 135 nbargs 1 types: (unsigned int) args: (personality) +syscall sys_ustat nr 136 nbargs 2 types: (unsigned, struct ustat *) args: (dev, ubuf) +syscall sys_statfs nr 137 nbargs 2 types: (const char *, struct statfs *) args: (pathname, buf) +syscall sys_fstatfs nr 138 nbargs 2 types: (unsigned int, struct statfs *) args: (fd, buf) +syscall sys_sysfs nr 139 nbargs 3 types: (int, unsigned long, unsigned long) args: (option, arg1, arg2) +syscall sys_getpriority nr 140 nbargs 2 types: (int, int) args: (which, who) +syscall sys_setpriority nr 141 nbargs 3 types: (int, int, int) args: (which, who, niceval) +syscall sys_sched_setparam nr 142 nbargs 2 types: (pid_t, struct sched_param *) args: (pid, param) +syscall sys_sched_getparam nr 143 nbargs 2 types: (pid_t, struct sched_param *) args: (pid, param) +syscall sys_sched_setscheduler nr 144 nbargs 3 types: (pid_t, int, struct sched_param *) args: (pid, policy, param) +syscall sys_sched_getscheduler nr 145 nbargs 1 types: (pid_t) args: (pid) +syscall sys_sched_get_priority_max nr 146 nbargs 1 types: (int) args: (policy) +syscall sys_sched_get_priority_min nr 147 nbargs 1 types: (int) args: (policy) +syscall sys_sched_rr_get_interval nr 148 nbargs 2 types: (pid_t, struct timespec *) args: (pid, interval) +syscall sys_mlock nr 149 nbargs 2 types: (unsigned long, size_t) args: (start, len) +syscall sys_munlock nr 150 nbargs 2 types: (unsigned long, size_t) args: (start, len) +syscall sys_mlockall nr 151 nbargs 1 types: (int) args: (flags) +syscall sys_munlockall nr 152 nbargs 0 types: () args: () +syscall sys_vhangup nr 153 nbargs 0 types: () args: () +syscall sys_pivot_root nr 155 nbargs 2 types: (const char *, const char *) args: (new_root, put_old) +syscall sys_sysctl nr 156 nbargs 1 types: (struct __sysctl_args *) args: (args) +syscall sys_prctl nr 157 nbargs 5 types: (int, unsigned long, unsigned long, unsigned long, unsigned long) args: (option, arg2, arg3, arg4, arg5) +syscall sys_adjtimex nr 159 nbargs 1 types: (struct timex *) args: (txc_p) +syscall sys_setrlimit nr 160 nbargs 2 types: (unsigned int, struct rlimit *) args: (resource, rlim) +syscall sys_chroot nr 161 nbargs 1 types: (const char *) args: (filename) +syscall sys_sync nr 162 nbargs 0 types: () args: () +syscall sys_acct nr 163 nbargs 1 types: (const char *) args: (name) +syscall sys_settimeofday nr 164 nbargs 2 types: (struct timeval *, struct timezone *) args: (tv, tz) +syscall sys_mount nr 165 nbargs 5 types: (char *, char *, char *, unsigned long, void *) args: (dev_name, dir_name, type, flags, data) +syscall sys_umount nr 166 nbargs 2 types: (char *, int) args: (name, flags) +syscall sys_swapon nr 167 nbargs 2 types: (const char *, int) args: (specialfile, swap_flags) +syscall sys_swapoff nr 168 nbargs 1 types: (const char *) args: (specialfile) +syscall sys_reboot nr 169 nbargs 4 types: (int, int, unsigned int, void *) args: (magic1, magic2, cmd, arg) +syscall sys_sethostname nr 170 nbargs 2 types: (char *, int) args: (name, len) +syscall sys_setdomainname nr 171 nbargs 2 types: (char *, int) args: (name, len) +syscall sys_init_module nr 175 nbargs 3 types: (void *, unsigned long, const char *) args: (umod, len, uargs) +syscall sys_delete_module nr 176 nbargs 2 types: (const char *, unsigned int) args: (name_user, flags) +syscall sys_quotactl nr 179 nbargs 4 types: (unsigned int, const char *, qid_t, void *) args: (cmd, special, id, addr) +syscall sys_gettid nr 186 nbargs 0 types: () args: () +syscall sys_readahead nr 187 nbargs 3 types: (int, loff_t, size_t) args: (fd, offset, count) +syscall sys_setxattr nr 188 nbargs 5 types: (const char *, const char *, const void *, size_t, int) args: (pathname, name, value, size, flags) +syscall sys_lsetxattr nr 189 nbargs 5 types: (const char *, const char *, const void *, size_t, int) args: (pathname, name, value, size, flags) +syscall sys_fsetxattr nr 190 nbargs 5 types: (int, const char *, const void *, size_t, int) args: (fd, name, value, size, flags) +syscall sys_getxattr nr 191 nbargs 4 types: (const char *, const char *, void *, size_t) args: (pathname, name, value, size) +syscall sys_lgetxattr nr 192 nbargs 4 types: (const char *, const char *, void *, size_t) args: (pathname, name, value, size) +syscall sys_fgetxattr nr 193 nbargs 4 types: (int, const char *, void *, size_t) args: (fd, name, value, size) +syscall sys_listxattr nr 194 nbargs 3 types: (const char *, char *, size_t) args: (pathname, list, size) +syscall sys_llistxattr nr 195 nbargs 3 types: (const char *, char *, size_t) args: (pathname, list, size) +syscall sys_flistxattr nr 196 nbargs 3 types: (int, char *, size_t) args: (fd, list, size) +syscall sys_removexattr nr 197 nbargs 2 types: (const char *, const char *) args: (pathname, name) +syscall sys_lremovexattr nr 198 nbargs 2 types: (const char *, const char *) args: (pathname, name) +syscall sys_fremovexattr nr 199 nbargs 2 types: (int, const char *) args: (fd, name) +syscall sys_tkill nr 200 nbargs 2 types: (pid_t, int) args: (pid, sig) +syscall sys_time nr 201 nbargs 1 types: (time_t *) args: (tloc) +syscall sys_futex nr 202 nbargs 6 types: (u32 *, int, u32, struct timespec *, u32 *, u32) args: (uaddr, op, val, utime, uaddr2, val3) +syscall sys_sched_setaffinity nr 203 nbargs 3 types: (pid_t, unsigned int, unsigned long *) args: (pid, len, user_mask_ptr) +syscall sys_sched_getaffinity nr 204 nbargs 3 types: (pid_t, unsigned int, unsigned long *) args: (pid, len, user_mask_ptr) +syscall sys_io_setup nr 206 nbargs 2 types: (unsigned, aio_context_t *) args: (nr_events, ctxp) +syscall sys_io_destroy nr 207 nbargs 1 types: (aio_context_t) args: (ctx) +syscall sys_io_getevents nr 208 nbargs 5 types: (aio_context_t, long, long, struct io_event *, struct timespec *) args: (ctx_id, min_nr, nr, events, timeout) +syscall sys_io_submit nr 209 nbargs 3 types: (aio_context_t, long, struct iocb * *) args: (ctx_id, nr, iocbpp) +syscall sys_io_cancel nr 210 nbargs 3 types: (aio_context_t, struct iocb *, struct io_event *) args: (ctx_id, iocb, result) +syscall sys_lookup_dcookie nr 212 nbargs 3 types: (u64, char *, size_t) args: (cookie64, buf, len) +syscall sys_epoll_create nr 213 nbargs 1 types: (int) args: (size) +syscall sys_remap_file_pages nr 216 nbargs 5 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long) args: (start, size, prot, pgoff, flags) +syscall sys_getdents64 nr 217 nbargs 3 types: (unsigned int, struct linux_dirent64 *, unsigned int) args: (fd, dirent, count) +syscall sys_set_tid_address nr 218 nbargs 1 types: (int *) args: (tidptr) +syscall sys_restart_syscall nr 219 nbargs 0 types: () args: () +syscall sys_semtimedop nr 220 nbargs 4 types: (int, struct sembuf *, unsigned, const struct timespec *) args: (semid, tsops, nsops, timeout) +syscall sys_fadvise64 nr 221 nbargs 4 types: (int, loff_t, size_t, int) args: (fd, offset, len, advice) +syscall sys_timer_create nr 222 nbargs 3 types: (const clockid_t, struct sigevent *, timer_t *) args: (which_clock, timer_event_spec, created_timer_id) +syscall sys_timer_settime nr 223 nbargs 4 types: (timer_t, int, const struct itimerspec *, struct itimerspec *) args: (timer_id, flags, new_setting, old_setting) +syscall sys_timer_gettime nr 224 nbargs 2 types: (timer_t, struct itimerspec *) args: (timer_id, setting) +syscall sys_timer_getoverrun nr 225 nbargs 1 types: (timer_t) args: (timer_id) +syscall sys_timer_delete nr 226 nbargs 1 types: (timer_t) args: (timer_id) +syscall sys_clock_settime nr 227 nbargs 2 types: (const clockid_t, const struct timespec *) args: (which_clock, tp) +syscall sys_clock_gettime nr 228 nbargs 2 types: (const clockid_t, struct timespec *) args: (which_clock, tp) +syscall sys_clock_getres nr 229 nbargs 2 types: (const clockid_t, struct timespec *) args: (which_clock, tp) +syscall sys_clock_nanosleep nr 230 nbargs 4 types: (const clockid_t, int, const struct timespec *, struct timespec *) args: (which_clock, flags, rqtp, rmtp) +syscall sys_exit_group nr 231 nbargs 1 types: (int) args: (error_code) +syscall sys_epoll_wait nr 232 nbargs 4 types: (int, struct epoll_event *, int, int) args: (epfd, events, maxevents, timeout) +syscall sys_epoll_ctl nr 233 nbargs 4 types: (int, int, int, struct epoll_event *) args: (epfd, op, fd, event) +syscall sys_tgkill nr 234 nbargs 3 types: (pid_t, pid_t, int) args: (tgid, pid, sig) +syscall sys_utimes nr 235 nbargs 2 types: (char *, struct timeval *) args: (filename, utimes) +syscall sys_mbind nr 237 nbargs 6 types: (unsigned long, unsigned long, unsigned long, unsigned long *, unsigned long, unsigned) args: (start, len, mode, nmask, maxnode, flags) +syscall sys_set_mempolicy nr 238 nbargs 3 types: (int, unsigned long *, unsigned long) args: (mode, nmask, maxnode) +syscall sys_get_mempolicy nr 239 nbargs 5 types: (int *, unsigned long *, unsigned long, unsigned long, unsigned long) args: (policy, nmask, maxnode, addr, flags) +syscall sys_mq_open nr 240 nbargs 4 types: (const char *, int, umode_t, struct mq_attr *) args: (u_name, oflag, mode, u_attr) +syscall sys_mq_unlink nr 241 nbargs 1 types: (const char *) args: (u_name) +syscall sys_mq_timedsend nr 242 nbargs 5 types: (mqd_t, const char *, size_t, unsigned int, const struct timespec *) args: (mqdes, u_msg_ptr, msg_len, msg_prio, u_abs_timeout) +syscall sys_mq_timedreceive nr 243 nbargs 5 types: (mqd_t, char *, size_t, unsigned int *, const struct timespec *) args: (mqdes, u_msg_ptr, msg_len, u_msg_prio, u_abs_timeout) +syscall sys_mq_notify nr 244 nbargs 2 types: (mqd_t, const struct sigevent *) args: (mqdes, u_notification) +syscall sys_mq_getsetattr nr 245 nbargs 3 types: (mqd_t, const struct mq_attr *, struct mq_attr *) args: (mqdes, u_mqstat, u_omqstat) +syscall sys_kexec_load nr 246 nbargs 4 types: (unsigned long, unsigned long, struct kexec_segment *, unsigned long) args: (entry, nr_segments, segments, flags) +syscall sys_waitid nr 247 nbargs 5 types: (int, pid_t, struct siginfo *, int, struct rusage *) args: (which, upid, infop, options, ru) +syscall sys_add_key nr 248 nbargs 5 types: (const char *, const char *, const void *, size_t, key_serial_t) args: (_type, _description, _payload, plen, ringid) +syscall sys_request_key nr 249 nbargs 4 types: (const char *, const char *, const char *, key_serial_t) args: (_type, _description, _callout_info, destringid) +syscall sys_keyctl nr 250 nbargs 5 types: (int, unsigned long, unsigned long, unsigned long, unsigned long) args: (option, arg2, arg3, arg4, arg5) +syscall sys_ioprio_set nr 251 nbargs 3 types: (int, int, int) args: (which, who, ioprio) +syscall sys_ioprio_get nr 252 nbargs 2 types: (int, int) args: (which, who) +syscall sys_inotify_init nr 253 nbargs 0 types: () args: () +syscall sys_inotify_add_watch nr 254 nbargs 3 types: (int, const char *, u32) args: (fd, pathname, mask) +syscall sys_inotify_rm_watch nr 255 nbargs 2 types: (int, __s32) args: (fd, wd) +syscall sys_migrate_pages nr 256 nbargs 4 types: (pid_t, unsigned long, const unsigned long *, const unsigned long *) args: (pid, maxnode, old_nodes, new_nodes) +syscall sys_openat nr 257 nbargs 4 types: (int, const char *, int, umode_t) args: (dfd, filename, flags, mode) +syscall sys_mkdirat nr 258 nbargs 3 types: (int, const char *, umode_t) args: (dfd, pathname, mode) +syscall sys_mknodat nr 259 nbargs 4 types: (int, const char *, umode_t, unsigned) args: (dfd, filename, mode, dev) +syscall sys_fchownat nr 260 nbargs 5 types: (int, const char *, uid_t, gid_t, int) args: (dfd, filename, user, group, flag) +syscall sys_futimesat nr 261 nbargs 3 types: (int, const char *, struct timeval *) args: (dfd, filename, utimes) +syscall sys_newfstatat nr 262 nbargs 4 types: (int, const char *, struct stat *, int) args: (dfd, filename, statbuf, flag) +syscall sys_unlinkat nr 263 nbargs 3 types: (int, const char *, int) args: (dfd, pathname, flag) +syscall sys_renameat nr 264 nbargs 4 types: (int, const char *, int, const char *) args: (olddfd, oldname, newdfd, newname) +syscall sys_linkat nr 265 nbargs 5 types: (int, const char *, int, const char *, int) args: (olddfd, oldname, newdfd, newname, flags) +syscall sys_symlinkat nr 266 nbargs 3 types: (const char *, int, const char *) args: (oldname, newdfd, newname) +syscall sys_readlinkat nr 267 nbargs 4 types: (int, const char *, char *, int) args: (dfd, pathname, buf, bufsiz) +syscall sys_fchmodat nr 268 nbargs 3 types: (int, const char *, umode_t) args: (dfd, filename, mode) +syscall sys_faccessat nr 269 nbargs 3 types: (int, const char *, int) args: (dfd, filename, mode) +syscall sys_pselect6 nr 270 nbargs 6 types: (int, fd_set *, fd_set *, fd_set *, struct timespec *, void *) args: (n, inp, outp, exp, tsp, sig) +syscall sys_ppoll nr 271 nbargs 5 types: (struct pollfd *, unsigned int, struct timespec *, const sigset_t *, size_t) args: (ufds, nfds, tsp, sigmask, sigsetsize) +syscall sys_unshare nr 272 nbargs 1 types: (unsigned long) args: (unshare_flags) +syscall sys_set_robust_list nr 273 nbargs 2 types: (struct robust_list_head *, size_t) args: (head, len) +syscall sys_get_robust_list nr 274 nbargs 3 types: (int, struct robust_list_head * *, size_t *) args: (pid, head_ptr, len_ptr) +syscall sys_splice nr 275 nbargs 6 types: (int, loff_t *, int, loff_t *, size_t, unsigned int) args: (fd_in, off_in, fd_out, off_out, len, flags) +syscall sys_tee nr 276 nbargs 4 types: (int, int, size_t, unsigned int) args: (fdin, fdout, len, flags) +syscall sys_sync_file_range nr 277 nbargs 4 types: (int, loff_t, loff_t, unsigned int) args: (fd, offset, nbytes, flags) +syscall sys_vmsplice nr 278 nbargs 4 types: (int, const struct iovec *, unsigned long, unsigned int) args: (fd, iov, nr_segs, flags) +syscall sys_move_pages nr 279 nbargs 6 types: (pid_t, unsigned long, const void * *, const int *, int *, int) args: (pid, nr_pages, pages, nodes, status, flags) +syscall sys_utimensat nr 280 nbargs 4 types: (int, const char *, struct timespec *, int) args: (dfd, filename, utimes, flags) +syscall sys_epoll_pwait nr 281 nbargs 6 types: (int, struct epoll_event *, int, int, const sigset_t *, size_t) args: (epfd, events, maxevents, timeout, sigmask, sigsetsize) +syscall sys_signalfd nr 282 nbargs 3 types: (int, sigset_t *, size_t) args: (ufd, user_mask, sizemask) +syscall sys_timerfd_create nr 283 nbargs 2 types: (int, int) args: (clockid, flags) +syscall sys_eventfd nr 284 nbargs 1 types: (unsigned int) args: (count) +syscall sys_fallocate nr 285 nbargs 4 types: (int, int, loff_t, loff_t) args: (fd, mode, offset, len) +syscall sys_timerfd_settime nr 286 nbargs 4 types: (int, int, const struct itimerspec *, struct itimerspec *) args: (ufd, flags, utmr, otmr) +syscall sys_timerfd_gettime nr 287 nbargs 2 types: (int, struct itimerspec *) args: (ufd, otmr) +syscall sys_accept4 nr 288 nbargs 4 types: (int, struct sockaddr *, int *, int) args: (fd, upeer_sockaddr, upeer_addrlen, flags) +syscall sys_signalfd4 nr 289 nbargs 4 types: (int, sigset_t *, size_t, int) args: (ufd, user_mask, sizemask, flags) +syscall sys_eventfd2 nr 290 nbargs 2 types: (unsigned int, int) args: (count, flags) +syscall sys_epoll_create1 nr 291 nbargs 1 types: (int) args: (flags) +syscall sys_dup3 nr 292 nbargs 3 types: (unsigned int, unsigned int, int) args: (oldfd, newfd, flags) +syscall sys_pipe2 nr 293 nbargs 2 types: (int *, int) args: (fildes, flags) +syscall sys_inotify_init1 nr 294 nbargs 1 types: (int) args: (flags) +syscall sys_preadv nr 295 nbargs 5 types: (unsigned long, const struct iovec *, unsigned long, unsigned long, unsigned long) args: (fd, vec, vlen, pos_l, pos_h) +syscall sys_pwritev nr 296 nbargs 5 types: (unsigned long, const struct iovec *, unsigned long, unsigned long, unsigned long) args: (fd, vec, vlen, pos_l, pos_h) +syscall sys_rt_tgsigqueueinfo nr 297 nbargs 4 types: (pid_t, pid_t, int, siginfo_t *) args: (tgid, pid, sig, uinfo) +syscall sys_perf_event_open nr 298 nbargs 5 types: (struct perf_event_attr *, pid_t, int, int, unsigned long) args: (attr_uptr, pid, cpu, group_fd, flags) +syscall sys_recvmmsg nr 299 nbargs 5 types: (int, struct mmsghdr *, unsigned int, unsigned int, struct timespec *) args: (fd, mmsg, vlen, flags, timeout) +syscall sys_fanotify_init nr 300 nbargs 2 types: (unsigned int, unsigned int) args: (flags, event_f_flags) +syscall sys_fanotify_mark nr 301 nbargs 5 types: (int, unsigned int, __u64, int, const char *) args: (fanotify_fd, flags, mask, dfd, pathname) +syscall sys_prlimit64 nr 302 nbargs 4 types: (pid_t, unsigned int, const struct rlimit64 *, struct rlimit64 *) args: (pid, resource, new_rlim, old_rlim) +syscall sys_name_to_handle_at nr 303 nbargs 5 types: (int, const char *, struct file_handle *, int *, int) args: (dfd, name, handle, mnt_id, flag) +syscall sys_open_by_handle_at nr 304 nbargs 3 types: (int, struct file_handle *, int) args: (mountdirfd, handle, flags) +syscall sys_clock_adjtime nr 305 nbargs 2 types: (const clockid_t, struct timex *) args: (which_clock, utx) +syscall sys_syncfs nr 306 nbargs 1 types: (int) args: (fd) +syscall sys_sendmmsg nr 307 nbargs 4 types: (int, struct mmsghdr *, unsigned int, unsigned int) args: (fd, mmsg, vlen, flags) +syscall sys_setns nr 308 nbargs 2 types: (int, int) args: (fd, nstype) +syscall sys_getcpu nr 309 nbargs 3 types: (unsigned *, unsigned *, struct getcpu_cache *) args: (cpup, nodep, unused) +syscall sys_process_vm_readv nr 310 nbargs 6 types: (pid_t, const struct iovec *, unsigned long, const struct iovec *, unsigned long, unsigned long) args: (pid, lvec, liovcnt, rvec, riovcnt, flags) +syscall sys_process_vm_writev nr 311 nbargs 6 types: (pid_t, const struct iovec *, unsigned long, const struct iovec *, unsigned long, unsigned long) args: (pid, lvec, liovcnt, rvec, riovcnt, flags) +syscall sys_finit_module nr 313 nbargs 3 types: (int, const char *, int) args: (fd, uargs, flags) diff --git a/include/instrumentation/syscalls/3.13.0/mips-32-syscalls b/include/instrumentation/syscalls/3.13.0/mips-32-syscalls new file mode 100644 index 00000000..e815a989 --- /dev/null +++ b/include/instrumentation/syscalls/3.13.0/mips-32-syscalls @@ -0,0 +1,283 @@ +syscall sys_exit nr 4001 nbargs 1 types: (int) args: (error_code) +syscall sys_read nr 4003 nbargs 3 types: (unsigned int, char *, size_t) args: (fd, buf, count) +syscall sys_write nr 4004 nbargs 3 types: (unsigned int, const char *, size_t) args: (fd, buf, count) +syscall sys_open nr 4005 nbargs 3 types: (const char *, int, umode_t) args: (filename, flags, mode) +syscall sys_close nr 4006 nbargs 1 types: (unsigned int) args: (fd) +syscall sys_waitpid nr 4007 nbargs 3 types: (pid_t, int *, int) args: (pid, stat_addr, options) +syscall sys_creat nr 4008 nbargs 2 types: (const char *, umode_t) args: (pathname, mode) +syscall sys_link nr 4009 nbargs 2 types: (const char *, const char *) args: (oldname, newname) +syscall sys_unlink nr 4010 nbargs 1 types: (const char *) args: (pathname) +syscall sys_execve nr 4011 nbargs 3 types: (const char *, const char *const *, const char *const *) args: (filename, argv, envp) +syscall sys_chdir nr 4012 nbargs 1 types: (const char *) args: (filename) +syscall sys_time nr 4013 nbargs 1 types: (time_t *) args: (tloc) +syscall sys_mknod nr 4014 nbargs 3 types: (const char *, umode_t, unsigned) args: (filename, mode, dev) +syscall sys_chmod nr 4015 nbargs 2 types: (const char *, umode_t) args: (filename, mode) +syscall sys_lchown nr 4016 nbargs 3 types: (const char *, uid_t, gid_t) args: (filename, user, group) +syscall sys_lseek nr 4019 nbargs 3 types: (unsigned int, off_t, unsigned int) args: (fd, offset, whence) +syscall sys_getpid nr 4020 nbargs 0 types: () args: () +syscall sys_mount nr 4021 nbargs 5 types: (char *, char *, char *, unsigned long, void *) args: (dev_name, dir_name, type, flags, data) +syscall sys_oldumount nr 4022 nbargs 1 types: (char *) args: (name) +syscall sys_setuid nr 4023 nbargs 1 types: (uid_t) args: (uid) +syscall sys_getuid nr 4024 nbargs 0 types: () args: () +syscall sys_stime nr 4025 nbargs 1 types: (time_t *) args: (tptr) +syscall sys_ptrace nr 4026 nbargs 4 types: (long, long, unsigned long, unsigned long) args: (request, pid, addr, data) +syscall sys_alarm nr 4027 nbargs 1 types: (unsigned int) args: (seconds) +syscall sys_pause nr 4029 nbargs 0 types: () args: () +syscall sys_utime nr 4030 nbargs 2 types: (char *, struct utimbuf *) args: (filename, times) +syscall sys_access nr 4033 nbargs 2 types: (const char *, int) args: (filename, mode) +syscall sys_nice nr 4034 nbargs 1 types: (int) args: (increment) +syscall sys_sync nr 4036 nbargs 0 types: () args: () +syscall sys_kill nr 4037 nbargs 2 types: (pid_t, int) args: (pid, sig) +syscall sys_rename nr 4038 nbargs 2 types: (const char *, const char *) args: (oldname, newname) +syscall sys_mkdir nr 4039 nbargs 2 types: (const char *, umode_t) args: (pathname, mode) +syscall sys_rmdir nr 4040 nbargs 1 types: (const char *) args: (pathname) +syscall sys_dup nr 4041 nbargs 1 types: (unsigned int) args: (fildes) +syscall sys_times nr 4043 nbargs 1 types: (struct tms *) args: (tbuf) +syscall sys_brk nr 4045 nbargs 1 types: (unsigned long) args: (brk) +syscall sys_setgid nr 4046 nbargs 1 types: (gid_t) args: (gid) +syscall sys_getgid nr 4047 nbargs 0 types: () args: () +syscall sys_geteuid nr 4049 nbargs 0 types: () args: () +syscall sys_getegid nr 4050 nbargs 0 types: () args: () +syscall sys_umount nr 4052 nbargs 2 types: (char *, int) args: (name, flags) +syscall sys_ioctl nr 4054 nbargs 3 types: (unsigned int, unsigned int, unsigned long) args: (fd, cmd, arg) +syscall sys_fcntl nr 4055 nbargs 3 types: (unsigned int, unsigned int, unsigned long) args: (fd, cmd, arg) +syscall sys_setpgid nr 4057 nbargs 2 types: (pid_t, pid_t) args: (pid, pgid) +syscall sys_olduname nr 4059 nbargs 1 types: (struct oldold_utsname *) args: (name) +syscall sys_umask nr 4060 nbargs 1 types: (int) args: (mask) +syscall sys_chroot nr 4061 nbargs 1 types: (const char *) args: (filename) +syscall sys_ustat nr 4062 nbargs 2 types: (unsigned, struct ustat *) args: (dev, ubuf) +syscall sys_dup2 nr 4063 nbargs 2 types: (unsigned int, unsigned int) args: (oldfd, newfd) +syscall sys_getppid nr 4064 nbargs 0 types: () args: () +syscall sys_getpgrp nr 4065 nbargs 0 types: () args: () +syscall sys_setsid nr 4066 nbargs 0 types: () args: () +syscall sys_sigaction nr 4067 nbargs 3 types: (int, const struct sigaction *, struct sigaction *) args: (sig, act, oact) +syscall sys_sgetmask nr 4068 nbargs 0 types: () args: () +syscall sys_ssetmask nr 4069 nbargs 1 types: (int) args: (newmask) +syscall sys_setreuid nr 4070 nbargs 2 types: (uid_t, uid_t) args: (ruid, euid) +syscall sys_setregid nr 4071 nbargs 2 types: (gid_t, gid_t) args: (rgid, egid) +syscall sys_sigsuspend nr 4072 nbargs 1 types: (sigset_t *) args: (uset) +syscall sys_sigpending nr 4073 nbargs 1 types: (old_sigset_t *) args: (set) +syscall sys_sethostname nr 4074 nbargs 2 types: (char *, int) args: (name, len) +syscall sys_setrlimit nr 4075 nbargs 2 types: (unsigned int, struct rlimit *) args: (resource, rlim) +syscall sys_getrlimit nr 4076 nbargs 2 types: (unsigned int, struct rlimit *) args: (resource, rlim) +syscall sys_getrusage nr 4077 nbargs 2 types: (int, struct rusage *) args: (who, ru) +syscall sys_gettimeofday nr 4078 nbargs 2 types: (struct timeval *, struct timezone *) args: (tv, tz) +syscall sys_settimeofday nr 4079 nbargs 2 types: (struct timeval *, struct timezone *) args: (tv, tz) +syscall sys_getgroups nr 4080 nbargs 2 types: (int, gid_t *) args: (gidsetsize, grouplist) +syscall sys_setgroups nr 4081 nbargs 2 types: (int, gid_t *) args: (gidsetsize, grouplist) +syscall sys_symlink nr 4083 nbargs 2 types: (const char *, const char *) args: (oldname, newname) +syscall sys_readlink nr 4085 nbargs 3 types: (const char *, char *, int) args: (path, buf, bufsiz) +syscall sys_uselib nr 4086 nbargs 1 types: (const char *) args: (library) +syscall sys_reboot nr 4088 nbargs 4 types: (int, int, unsigned int, void *) args: (magic1, magic2, cmd, arg) +syscall sys_old_readdir nr 4089 nbargs 3 types: (unsigned int, struct old_linux_dirent *, unsigned int) args: (fd, dirent, count) +syscall sys_mips_mmap nr 4090 nbargs 6 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long, off_t) args: (addr, len, prot, flags, fd, offset) +syscall sys_munmap nr 4091 nbargs 2 types: (unsigned long, size_t) args: (addr, len) +syscall sys_truncate nr 4092 nbargs 2 types: (const char *, long) args: (path, length) +syscall sys_ftruncate nr 4093 nbargs 2 types: (unsigned int, unsigned long) args: (fd, length) +syscall sys_fchmod nr 4094 nbargs 2 types: (unsigned int, umode_t) args: (fd, mode) +syscall sys_fchown nr 4095 nbargs 3 types: (unsigned int, uid_t, gid_t) args: (fd, user, group) +syscall sys_getpriority nr 4096 nbargs 2 types: (int, int) args: (which, who) +syscall sys_setpriority nr 4097 nbargs 3 types: (int, int, int) args: (which, who, niceval) +syscall sys_statfs nr 4099 nbargs 2 types: (const char *, struct statfs *) args: (pathname, buf) +syscall sys_fstatfs nr 4100 nbargs 2 types: (unsigned int, struct statfs *) args: (fd, buf) +syscall sys_socketcall nr 4102 nbargs 2 types: (int, unsigned long *) args: (call, args) +syscall sys_syslog nr 4103 nbargs 3 types: (int, char *, int) args: (type, buf, len) +syscall sys_setitimer nr 4104 nbargs 3 types: (int, struct itimerval *, struct itimerval *) args: (which, value, ovalue) +syscall sys_getitimer nr 4105 nbargs 2 types: (int, struct itimerval *) args: (which, value) +syscall sys_newstat nr 4106 nbargs 2 types: (const char *, struct stat *) args: (filename, statbuf) +syscall sys_newlstat nr 4107 nbargs 2 types: (const char *, struct stat *) args: (filename, statbuf) +syscall sys_newfstat nr 4108 nbargs 2 types: (unsigned int, struct stat *) args: (fd, statbuf) +syscall sys_uname nr 4109 nbargs 1 types: (struct old_utsname *) args: (name) +syscall sys_vhangup nr 4111 nbargs 0 types: () args: () +syscall sys_wait4 nr 4114 nbargs 4 types: (pid_t, int *, int, struct rusage *) args: (upid, stat_addr, options, ru) +syscall sys_sysinfo nr 4116 nbargs 1 types: (struct sysinfo *) args: (info) +syscall sys_ipc nr 4117 nbargs 6 types: (unsigned int, int, unsigned long, unsigned long, void *, long) args: (call, first, second, third, ptr, fifth) +syscall sys_fsync nr 4118 nbargs 1 types: (unsigned int) args: (fd) +syscall sys_setdomainname nr 4121 nbargs 2 types: (char *, int) args: (name, len) +syscall sys_newuname nr 4122 nbargs 1 types: (struct new_utsname *) args: (name) +syscall sys_adjtimex nr 4124 nbargs 1 types: (struct timex *) args: (txc_p) +syscall sys_mprotect nr 4125 nbargs 3 types: (unsigned long, size_t, unsigned long) args: (start, len, prot) +syscall sys_sigprocmask nr 4126 nbargs 3 types: (int, old_sigset_t *, old_sigset_t *) args: (how, nset, oset) +syscall sys_init_module nr 4128 nbargs 3 types: (void *, unsigned long, const char *) args: (umod, len, uargs) +syscall sys_delete_module nr 4129 nbargs 2 types: (const char *, unsigned int) args: (name_user, flags) +syscall sys_getpgid nr 4132 nbargs 1 types: (pid_t) args: (pid) +syscall sys_fchdir nr 4133 nbargs 1 types: (unsigned int) args: (fd) +syscall sys_bdflush nr 4134 nbargs 2 types: (int, long) args: (func, data) +syscall sys_sysfs nr 4135 nbargs 3 types: (int, unsigned long, unsigned long) args: (option, arg1, arg2) +syscall sys_personality nr 4136 nbargs 1 types: (unsigned int) args: (personality) +syscall sys_setfsuid nr 4138 nbargs 1 types: (uid_t) args: (uid) +syscall sys_setfsgid nr 4139 nbargs 1 types: (gid_t) args: (gid) +syscall sys_llseek nr 4140 nbargs 5 types: (unsigned int, unsigned long, unsigned long, loff_t *, unsigned int) args: (fd, offset_high, offset_low, result, whence) +syscall sys_getdents nr 4141 nbargs 3 types: (unsigned int, struct linux_dirent *, unsigned int) args: (fd, dirent, count) +syscall sys_select nr 4142 nbargs 5 types: (int, fd_set *, fd_set *, fd_set *, struct timeval *) args: (n, inp, outp, exp, tvp) +syscall sys_flock nr 4143 nbargs 2 types: (unsigned int, unsigned int) args: (fd, cmd) +syscall sys_msync nr 4144 nbargs 3 types: (unsigned long, size_t, int) args: (start, len, flags) +syscall sys_readv nr 4145 nbargs 3 types: (unsigned long, const struct iovec *, unsigned long) args: (fd, vec, vlen) +syscall sys_writev nr 4146 nbargs 3 types: (unsigned long, const struct iovec *, unsigned long) args: (fd, vec, vlen) +syscall sys_cacheflush nr 4147 nbargs 3 types: (unsigned long, unsigned long, unsigned int) args: (addr, bytes, cache) +syscall sys_cachectl nr 4148 nbargs 3 types: (char *, int, int) args: (addr, nbytes, op) +syscall sys_sysmips nr 4149 nbargs 3 types: (long, long, long) args: (cmd, arg1, arg2) +syscall sys_getsid nr 4151 nbargs 1 types: (pid_t) args: (pid) +syscall sys_fdatasync nr 4152 nbargs 1 types: (unsigned int) args: (fd) +syscall sys_sysctl nr 4153 nbargs 1 types: (struct __sysctl_args *) args: (args) +syscall sys_mlock nr 4154 nbargs 2 types: (unsigned long, size_t) args: (start, len) +syscall sys_munlock nr 4155 nbargs 2 types: (unsigned long, size_t) args: (start, len) +syscall sys_mlockall nr 4156 nbargs 1 types: (int) args: (flags) +syscall sys_munlockall nr 4157 nbargs 0 types: () args: () +syscall sys_sched_setparam nr 4158 nbargs 2 types: (pid_t, struct sched_param *) args: (pid, param) +syscall sys_sched_getparam nr 4159 nbargs 2 types: (pid_t, struct sched_param *) args: (pid, param) +syscall sys_sched_setscheduler nr 4160 nbargs 3 types: (pid_t, int, struct sched_param *) args: (pid, policy, param) +syscall sys_sched_getscheduler nr 4161 nbargs 1 types: (pid_t) args: (pid) +syscall sys_sched_yield nr 4162 nbargs 0 types: () args: () +syscall sys_sched_get_priority_max nr 4163 nbargs 1 types: (int) args: (policy) +syscall sys_sched_get_priority_min nr 4164 nbargs 1 types: (int) args: (policy) +syscall sys_sched_rr_get_interval nr 4165 nbargs 2 types: (pid_t, struct timespec *) args: (pid, interval) +syscall sys_nanosleep nr 4166 nbargs 2 types: (struct timespec *, struct timespec *) args: (rqtp, rmtp) +syscall sys_mremap nr 4167 nbargs 5 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long) args: (addr, old_len, new_len, flags, new_addr) +syscall sys_accept nr 4168 nbargs 3 types: (int, struct sockaddr *, int *) args: (fd, upeer_sockaddr, upeer_addrlen) +syscall sys_bind nr 4169 nbargs 3 types: (int, struct sockaddr *, int) args: (fd, umyaddr, addrlen) +syscall sys_connect nr 4170 nbargs 3 types: (int, struct sockaddr *, int) args: (fd, uservaddr, addrlen) +syscall sys_getpeername nr 4171 nbargs 3 types: (int, struct sockaddr *, int *) args: (fd, usockaddr, usockaddr_len) +syscall sys_getsockname nr 4172 nbargs 3 types: (int, struct sockaddr *, int *) args: (fd, usockaddr, usockaddr_len) +syscall sys_getsockopt nr 4173 nbargs 5 types: (int, int, int, char *, int *) args: (fd, level, optname, optval, optlen) +syscall sys_listen nr 4174 nbargs 2 types: (int, int) args: (fd, backlog) +syscall sys_recvfrom nr 4176 nbargs 6 types: (int, void *, size_t, unsigned int, struct sockaddr *, int *) args: (fd, ubuf, size, flags, addr, addr_len) +syscall sys_recvmsg nr 4177 nbargs 3 types: (int, struct msghdr *, unsigned int) args: (fd, msg, flags) +syscall sys_send nr 4178 nbargs 4 types: (int, void *, size_t, unsigned int) args: (fd, buff, len, flags) +syscall sys_sendmsg nr 4179 nbargs 3 types: (int, struct msghdr *, unsigned int) args: (fd, msg, flags) +syscall sys_sendto nr 4180 nbargs 6 types: (int, void *, size_t, unsigned int, struct sockaddr *, int) args: (fd, buff, len, flags, addr, addr_len) +syscall sys_setsockopt nr 4181 nbargs 5 types: (int, int, int, char *, int) args: (fd, level, optname, optval, optlen) +syscall sys_shutdown nr 4182 nbargs 2 types: (int, int) args: (fd, how) +syscall sys_socket nr 4183 nbargs 3 types: (int, int, int) args: (family, type, protocol) +syscall sys_socketpair nr 4184 nbargs 4 types: (int, int, int, int *) args: (family, type, protocol, usockvec) +syscall sys_setresuid nr 4185 nbargs 3 types: (uid_t, uid_t, uid_t) args: (ruid, euid, suid) +syscall sys_getresuid nr 4186 nbargs 3 types: (uid_t *, uid_t *, uid_t *) args: (ruidp, euidp, suidp) +syscall sys_poll nr 4188 nbargs 3 types: (struct pollfd *, unsigned int, int) args: (ufds, nfds, timeout_msecs) +syscall sys_setresgid nr 4190 nbargs 3 types: (gid_t, gid_t, gid_t) args: (rgid, egid, sgid) +syscall sys_getresgid nr 4191 nbargs 3 types: (gid_t *, gid_t *, gid_t *) args: (rgidp, egidp, sgidp) +syscall sys_prctl nr 4192 nbargs 5 types: (int, unsigned long, unsigned long, unsigned long, unsigned long) args: (option, arg2, arg3, arg4, arg5) +syscall sys_rt_sigaction nr 4194 nbargs 4 types: (int, const struct sigaction *, struct sigaction *, size_t) args: (sig, act, oact, sigsetsize) +syscall sys_rt_sigprocmask nr 4195 nbargs 4 types: (int, sigset_t *, sigset_t *, size_t) args: (how, nset, oset, sigsetsize) +syscall sys_rt_sigpending nr 4196 nbargs 2 types: (sigset_t *, size_t) args: (uset, sigsetsize) +syscall sys_rt_sigtimedwait nr 4197 nbargs 4 types: (const sigset_t *, siginfo_t *, const struct timespec *, size_t) args: (uthese, uinfo, uts, sigsetsize) +syscall sys_rt_sigqueueinfo nr 4198 nbargs 3 types: (pid_t, int, siginfo_t *) args: (pid, sig, uinfo) +syscall sys_rt_sigsuspend nr 4199 nbargs 2 types: (sigset_t *, size_t) args: (unewset, sigsetsize) +syscall sys_pread64 nr 4200 nbargs 4 types: (unsigned int, char *, size_t, loff_t) args: (fd, buf, count, pos) +syscall sys_pwrite64 nr 4201 nbargs 4 types: (unsigned int, const char *, size_t, loff_t) args: (fd, buf, count, pos) +syscall sys_chown nr 4202 nbargs 3 types: (const char *, uid_t, gid_t) args: (filename, user, group) +syscall sys_getcwd nr 4203 nbargs 2 types: (char *, unsigned long) args: (buf, size) +syscall sys_capget nr 4204 nbargs 2 types: (cap_user_header_t, cap_user_data_t) args: (header, dataptr) +syscall sys_capset nr 4205 nbargs 2 types: (cap_user_header_t, const cap_user_data_t) args: (header, data) +syscall sys_sigaltstack nr 4206 nbargs 2 types: (const stack_t *, stack_t *) args: (uss, uoss) +syscall sys_sendfile nr 4207 nbargs 4 types: (int, int, off_t *, size_t) args: (out_fd, in_fd, offset, count) +syscall sys_mips_mmap2 nr 4210 nbargs 6 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long, unsigned long) args: (addr, len, prot, flags, fd, pgoff) +syscall sys_truncate64 nr 4211 nbargs 2 types: (const char *, loff_t) args: (path, length) +syscall sys_ftruncate64 nr 4212 nbargs 2 types: (unsigned int, loff_t) args: (fd, length) +syscall sys_stat64 nr 4213 nbargs 2 types: (const char *, struct stat64 *) args: (filename, statbuf) +syscall sys_lstat64 nr 4214 nbargs 2 types: (const char *, struct stat64 *) args: (filename, statbuf) +syscall sys_fstat64 nr 4215 nbargs 2 types: (unsigned long, struct stat64 *) args: (fd, statbuf) +syscall sys_pivot_root nr 4216 nbargs 2 types: (const char *, const char *) args: (new_root, put_old) +syscall sys_mincore nr 4217 nbargs 3 types: (unsigned long, size_t, unsigned char *) args: (start, len, vec) +syscall sys_madvise nr 4218 nbargs 3 types: (unsigned long, size_t, int) args: (start, len_in, behavior) +syscall sys_getdents64 nr 4219 nbargs 3 types: (unsigned int, struct linux_dirent64 *, unsigned int) args: (fd, dirent, count) +syscall sys_fcntl64 nr 4220 nbargs 3 types: (unsigned int, unsigned int, unsigned long) args: (fd, cmd, arg) +syscall sys_gettid nr 4222 nbargs 0 types: () args: () +syscall sys_readahead nr 4223 nbargs 3 types: (int, loff_t, size_t) args: (fd, offset, count) +syscall sys_setxattr nr 4224 nbargs 5 types: (const char *, const char *, const void *, size_t, int) args: (pathname, name, value, size, flags) +syscall sys_lsetxattr nr 4225 nbargs 5 types: (const char *, const char *, const void *, size_t, int) args: (pathname, name, value, size, flags) +syscall sys_fsetxattr nr 4226 nbargs 5 types: (int, const char *, const void *, size_t, int) args: (fd, name, value, size, flags) +syscall sys_getxattr nr 4227 nbargs 4 types: (const char *, const char *, void *, size_t) args: (pathname, name, value, size) +syscall sys_lgetxattr nr 4228 nbargs 4 types: (const char *, const char *, void *, size_t) args: (pathname, name, value, size) +syscall sys_fgetxattr nr 4229 nbargs 4 types: (int, const char *, void *, size_t) args: (fd, name, value, size) +syscall sys_listxattr nr 4230 nbargs 3 types: (const char *, char *, size_t) args: (pathname, list, size) +syscall sys_llistxattr nr 4231 nbargs 3 types: (const char *, char *, size_t) args: (pathname, list, size) +syscall sys_flistxattr nr 4232 nbargs 3 types: (int, char *, size_t) args: (fd, list, size) +syscall sys_removexattr nr 4233 nbargs 2 types: (const char *, const char *) args: (pathname, name) +syscall sys_lremovexattr nr 4234 nbargs 2 types: (const char *, const char *) args: (pathname, name) +syscall sys_fremovexattr nr 4235 nbargs 2 types: (int, const char *) args: (fd, name) +syscall sys_tkill nr 4236 nbargs 2 types: (pid_t, int) args: (pid, sig) +syscall sys_sendfile64 nr 4237 nbargs 4 types: (int, int, loff_t *, size_t) args: (out_fd, in_fd, offset, count) +syscall sys_futex nr 4238 nbargs 6 types: (u32 *, int, u32, struct timespec *, u32 *, u32) args: (uaddr, op, val, utime, uaddr2, val3) +syscall sys_io_setup nr 4241 nbargs 2 types: (unsigned, aio_context_t *) args: (nr_events, ctxp) +syscall sys_io_destroy nr 4242 nbargs 1 types: (aio_context_t) args: (ctx) +syscall sys_io_getevents nr 4243 nbargs 5 types: (aio_context_t, long, long, struct io_event *, struct timespec *) args: (ctx_id, min_nr, nr, events, timeout) +syscall sys_io_submit nr 4244 nbargs 3 types: (aio_context_t, long, struct iocb * *) args: (ctx_id, nr, iocbpp) +syscall sys_io_cancel nr 4245 nbargs 3 types: (aio_context_t, struct iocb *, struct io_event *) args: (ctx_id, iocb, result) +syscall sys_exit_group nr 4246 nbargs 1 types: (int) args: (error_code) +syscall sys_epoll_create nr 4248 nbargs 1 types: (int) args: (size) +syscall sys_epoll_ctl nr 4249 nbargs 4 types: (int, int, int, struct epoll_event *) args: (epfd, op, fd, event) +syscall sys_epoll_wait nr 4250 nbargs 4 types: (int, struct epoll_event *, int, int) args: (epfd, events, maxevents, timeout) +syscall sys_remap_file_pages nr 4251 nbargs 5 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long) args: (start, size, prot, pgoff, flags) +syscall sys_set_tid_address nr 4252 nbargs 1 types: (int *) args: (tidptr) +syscall sys_restart_syscall nr 4253 nbargs 0 types: () args: () +syscall sys_fadvise64_64 nr 4254 nbargs 4 types: (int, loff_t, loff_t, int) args: (fd, offset, len, advice) +syscall sys_statfs64 nr 4255 nbargs 3 types: (const char *, size_t, struct statfs64 *) args: (pathname, sz, buf) +syscall sys_fstatfs64 nr 4256 nbargs 3 types: (unsigned int, size_t, struct statfs64 *) args: (fd, sz, buf) +syscall sys_timer_create nr 4257 nbargs 3 types: (const clockid_t, struct sigevent *, timer_t *) args: (which_clock, timer_event_spec, created_timer_id) +syscall sys_timer_settime nr 4258 nbargs 4 types: (timer_t, int, const struct itimerspec *, struct itimerspec *) args: (timer_id, flags, new_setting, old_setting) +syscall sys_timer_gettime nr 4259 nbargs 2 types: (timer_t, struct itimerspec *) args: (timer_id, setting) +syscall sys_timer_getoverrun nr 4260 nbargs 1 types: (timer_t) args: (timer_id) +syscall sys_timer_delete nr 4261 nbargs 1 types: (timer_t) args: (timer_id) +syscall sys_clock_settime nr 4262 nbargs 2 types: (const clockid_t, const struct timespec *) args: (which_clock, tp) +syscall sys_clock_gettime nr 4263 nbargs 2 types: (const clockid_t, struct timespec *) args: (which_clock, tp) +syscall sys_clock_getres nr 4264 nbargs 2 types: (const clockid_t, struct timespec *) args: (which_clock, tp) +syscall sys_clock_nanosleep nr 4265 nbargs 4 types: (const clockid_t, int, const struct timespec *, struct timespec *) args: (which_clock, flags, rqtp, rmtp) +syscall sys_tgkill nr 4266 nbargs 3 types: (pid_t, pid_t, int) args: (tgid, pid, sig) +syscall sys_utimes nr 4267 nbargs 2 types: (char *, struct timeval *) args: (filename, utimes) +syscall sys_waitid nr 4278 nbargs 5 types: (int, pid_t, struct siginfo *, int, struct rusage *) args: (which, upid, infop, options, ru) +syscall sys_set_thread_area nr 4283 nbargs 1 types: (unsigned long) args: (addr) +syscall sys_inotify_init nr 4284 nbargs 0 types: () args: () +syscall sys_inotify_add_watch nr 4285 nbargs 3 types: (int, const char *, u32) args: (fd, pathname, mask) +syscall sys_inotify_rm_watch nr 4286 nbargs 2 types: (int, __s32) args: (fd, wd) +syscall sys_openat nr 4288 nbargs 4 types: (int, const char *, int, umode_t) args: (dfd, filename, flags, mode) +syscall sys_mkdirat nr 4289 nbargs 3 types: (int, const char *, umode_t) args: (dfd, pathname, mode) +syscall sys_mknodat nr 4290 nbargs 4 types: (int, const char *, umode_t, unsigned) args: (dfd, filename, mode, dev) +syscall sys_fchownat nr 4291 nbargs 5 types: (int, const char *, uid_t, gid_t, int) args: (dfd, filename, user, group, flag) +syscall sys_futimesat nr 4292 nbargs 3 types: (int, const char *, struct timeval *) args: (dfd, filename, utimes) +syscall sys_fstatat64 nr 4293 nbargs 4 types: (int, const char *, struct stat64 *, int) args: (dfd, filename, statbuf, flag) +syscall sys_unlinkat nr 4294 nbargs 3 types: (int, const char *, int) args: (dfd, pathname, flag) +syscall sys_renameat nr 4295 nbargs 4 types: (int, const char *, int, const char *) args: (olddfd, oldname, newdfd, newname) +syscall sys_linkat nr 4296 nbargs 5 types: (int, const char *, int, const char *, int) args: (olddfd, oldname, newdfd, newname, flags) +syscall sys_symlinkat nr 4297 nbargs 3 types: (const char *, int, const char *) args: (oldname, newdfd, newname) +syscall sys_readlinkat nr 4298 nbargs 4 types: (int, const char *, char *, int) args: (dfd, pathname, buf, bufsiz) +syscall sys_fchmodat nr 4299 nbargs 3 types: (int, const char *, umode_t) args: (dfd, filename, mode) +syscall sys_faccessat nr 4300 nbargs 3 types: (int, const char *, int) args: (dfd, filename, mode) +syscall sys_pselect6 nr 4301 nbargs 6 types: (int, fd_set *, fd_set *, fd_set *, struct timespec *, void *) args: (n, inp, outp, exp, tsp, sig) +syscall sys_ppoll nr 4302 nbargs 5 types: (struct pollfd *, unsigned int, struct timespec *, const sigset_t *, size_t) args: (ufds, nfds, tsp, sigmask, sigsetsize) +syscall sys_unshare nr 4303 nbargs 1 types: (unsigned long) args: (unshare_flags) +syscall sys_splice nr 4304 nbargs 6 types: (int, loff_t *, int, loff_t *, size_t, unsigned int) args: (fd_in, off_in, fd_out, off_out, len, flags) +syscall sys_sync_file_range nr 4305 nbargs 4 types: (int, loff_t, loff_t, unsigned int) args: (fd, offset, nbytes, flags) +syscall sys_tee nr 4306 nbargs 4 types: (int, int, size_t, unsigned int) args: (fdin, fdout, len, flags) +syscall sys_vmsplice nr 4307 nbargs 4 types: (int, const struct iovec *, unsigned long, unsigned int) args: (fd, iov, nr_segs, flags) +syscall sys_set_robust_list nr 4309 nbargs 2 types: (struct robust_list_head *, size_t) args: (head, len) +syscall sys_get_robust_list nr 4310 nbargs 3 types: (int, struct robust_list_head * *, size_t *) args: (pid, head_ptr, len_ptr) +syscall sys_getcpu nr 4312 nbargs 3 types: (unsigned *, unsigned *, struct getcpu_cache *) args: (cpup, nodep, unused) +syscall sys_epoll_pwait nr 4313 nbargs 6 types: (int, struct epoll_event *, int, int, const sigset_t *, size_t) args: (epfd, events, maxevents, timeout, sigmask, sigsetsize) +syscall sys_ioprio_set nr 4314 nbargs 3 types: (int, int, int) args: (which, who, ioprio) +syscall sys_ioprio_get nr 4315 nbargs 2 types: (int, int) args: (which, who) +syscall sys_utimensat nr 4316 nbargs 4 types: (int, const char *, struct timespec *, int) args: (dfd, filename, utimes, flags) +syscall sys_signalfd nr 4317 nbargs 3 types: (int, sigset_t *, size_t) args: (ufd, user_mask, sizemask) +syscall sys_eventfd nr 4319 nbargs 1 types: (unsigned int) args: (count) +syscall sys_fallocate nr 4320 nbargs 4 types: (int, int, loff_t, loff_t) args: (fd, mode, offset, len) +syscall sys_timerfd_create nr 4321 nbargs 2 types: (int, int) args: (clockid, flags) +syscall sys_timerfd_gettime nr 4322 nbargs 2 types: (int, struct itimerspec *) args: (ufd, otmr) +syscall sys_timerfd_settime nr 4323 nbargs 4 types: (int, int, const struct itimerspec *, struct itimerspec *) args: (ufd, flags, utmr, otmr) +syscall sys_signalfd4 nr 4324 nbargs 4 types: (int, sigset_t *, size_t, int) args: (ufd, user_mask, sizemask, flags) +syscall sys_eventfd2 nr 4325 nbargs 2 types: (unsigned int, int) args: (count, flags) +syscall sys_epoll_create1 nr 4326 nbargs 1 types: (int) args: (flags) +syscall sys_dup3 nr 4327 nbargs 3 types: (unsigned int, unsigned int, int) args: (oldfd, newfd, flags) +syscall sys_pipe2 nr 4328 nbargs 2 types: (int *, int) args: (fildes, flags) +syscall sys_inotify_init1 nr 4329 nbargs 1 types: (int) args: (flags) +syscall sys_preadv nr 4330 nbargs 5 types: (unsigned long, const struct iovec *, unsigned long, unsigned long, unsigned long) args: (fd, vec, vlen, pos_l, pos_h) +syscall sys_pwritev nr 4331 nbargs 5 types: (unsigned long, const struct iovec *, unsigned long, unsigned long, unsigned long) args: (fd, vec, vlen, pos_l, pos_h) +syscall sys_rt_tgsigqueueinfo nr 4332 nbargs 4 types: (pid_t, pid_t, int, siginfo_t *) args: (tgid, pid, sig, uinfo) +syscall sys_perf_event_open nr 4333 nbargs 5 types: (struct perf_event_attr *, pid_t, int, int, unsigned long) args: (attr_uptr, pid, cpu, group_fd, flags) +syscall sys_accept4 nr 4334 nbargs 4 types: (int, struct sockaddr *, int *, int) args: (fd, upeer_sockaddr, upeer_addrlen, flags) +syscall sys_recvmmsg nr 4335 nbargs 5 types: (int, struct mmsghdr *, unsigned int, unsigned int, struct timespec *) args: (fd, mmsg, vlen, flags, timeout) +syscall sys_prlimit64 nr 4338 nbargs 4 types: (pid_t, unsigned int, const struct rlimit64 *, struct rlimit64 *) args: (pid, resource, new_rlim, old_rlim) +syscall sys_name_to_handle_at nr 4339 nbargs 5 types: (int, const char *, struct file_handle *, int *, int) args: (dfd, name, handle, mnt_id, flag) +syscall sys_open_by_handle_at nr 4340 nbargs 3 types: (int, struct file_handle *, int) args: (mountdirfd, handle, flags) +syscall sys_clock_adjtime nr 4341 nbargs 2 types: (const clockid_t, struct timex *) args: (which_clock, utx) +syscall sys_syncfs nr 4342 nbargs 1 types: (int) args: (fd) +syscall sys_sendmmsg nr 4343 nbargs 4 types: (int, struct mmsghdr *, unsigned int, unsigned int) args: (fd, mmsg, vlen, flags) +syscall sys_setns nr 4344 nbargs 2 types: (int, int) args: (fd, nstype) diff --git a/include/instrumentation/syscalls/3.18.0/mips-32-syscalls b/include/instrumentation/syscalls/3.18.0/mips-32-syscalls new file mode 100644 index 00000000..d0b35a67 --- /dev/null +++ b/include/instrumentation/syscalls/3.18.0/mips-32-syscalls @@ -0,0 +1,287 @@ +syscall sys_exit nr 4001 nbargs 1 types: (int) args: (error_code) +syscall sys_read nr 4003 nbargs 3 types: (unsigned int, char *, size_t) args: (fd, buf, count) +syscall sys_write nr 4004 nbargs 3 types: (unsigned int, const char *, size_t) args: (fd, buf, count) +syscall sys_open nr 4005 nbargs 3 types: (const char *, int, umode_t) args: (filename, flags, mode) +syscall sys_close nr 4006 nbargs 1 types: (unsigned int) args: (fd) +syscall sys_waitpid nr 4007 nbargs 3 types: (pid_t, int *, int) args: (pid, stat_addr, options) +syscall sys_creat nr 4008 nbargs 2 types: (const char *, umode_t) args: (pathname, mode) +syscall sys_link nr 4009 nbargs 2 types: (const char *, const char *) args: (oldname, newname) +syscall sys_unlink nr 4010 nbargs 1 types: (const char *) args: (pathname) +syscall sys_execve nr 4011 nbargs 3 types: (const char *, const char *const *, const char *const *) args: (filename, argv, envp) +syscall sys_chdir nr 4012 nbargs 1 types: (const char *) args: (filename) +syscall sys_time nr 4013 nbargs 1 types: (time_t *) args: (tloc) +syscall sys_mknod nr 4014 nbargs 3 types: (const char *, umode_t, unsigned) args: (filename, mode, dev) +syscall sys_chmod nr 4015 nbargs 2 types: (const char *, umode_t) args: (filename, mode) +syscall sys_lchown nr 4016 nbargs 3 types: (const char *, uid_t, gid_t) args: (filename, user, group) +syscall sys_lseek nr 4019 nbargs 3 types: (unsigned int, off_t, unsigned int) args: (fd, offset, whence) +syscall sys_getpid nr 4020 nbargs 0 types: () args: () +syscall sys_mount nr 4021 nbargs 5 types: (char *, char *, char *, unsigned long, void *) args: (dev_name, dir_name, type, flags, data) +syscall sys_oldumount nr 4022 nbargs 1 types: (char *) args: (name) +syscall sys_setuid nr 4023 nbargs 1 types: (uid_t) args: (uid) +syscall sys_getuid nr 4024 nbargs 0 types: () args: () +syscall sys_stime nr 4025 nbargs 1 types: (time_t *) args: (tptr) +syscall sys_ptrace nr 4026 nbargs 4 types: (long, long, unsigned long, unsigned long) args: (request, pid, addr, data) +syscall sys_alarm nr 4027 nbargs 1 types: (unsigned int) args: (seconds) +syscall sys_pause nr 4029 nbargs 0 types: () args: () +syscall sys_utime nr 4030 nbargs 2 types: (char *, struct utimbuf *) args: (filename, times) +syscall sys_access nr 4033 nbargs 2 types: (const char *, int) args: (filename, mode) +syscall sys_nice nr 4034 nbargs 1 types: (int) args: (increment) +syscall sys_sync nr 4036 nbargs 0 types: () args: () +syscall sys_kill nr 4037 nbargs 2 types: (pid_t, int) args: (pid, sig) +syscall sys_rename nr 4038 nbargs 2 types: (const char *, const char *) args: (oldname, newname) +syscall sys_mkdir nr 4039 nbargs 2 types: (const char *, umode_t) args: (pathname, mode) +syscall sys_rmdir nr 4040 nbargs 1 types: (const char *) args: (pathname) +syscall sys_dup nr 4041 nbargs 1 types: (unsigned int) args: (fildes) +syscall sys_times nr 4043 nbargs 1 types: (struct tms *) args: (tbuf) +syscall sys_brk nr 4045 nbargs 1 types: (unsigned long) args: (brk) +syscall sys_setgid nr 4046 nbargs 1 types: (gid_t) args: (gid) +syscall sys_getgid nr 4047 nbargs 0 types: () args: () +syscall sys_geteuid nr 4049 nbargs 0 types: () args: () +syscall sys_getegid nr 4050 nbargs 0 types: () args: () +syscall sys_umount nr 4052 nbargs 2 types: (char *, int) args: (name, flags) +syscall sys_ioctl nr 4054 nbargs 3 types: (unsigned int, unsigned int, unsigned long) args: (fd, cmd, arg) +syscall sys_fcntl nr 4055 nbargs 3 types: (unsigned int, unsigned int, unsigned long) args: (fd, cmd, arg) +syscall sys_setpgid nr 4057 nbargs 2 types: (pid_t, pid_t) args: (pid, pgid) +syscall sys_olduname nr 4059 nbargs 1 types: (struct oldold_utsname *) args: (name) +syscall sys_umask nr 4060 nbargs 1 types: (int) args: (mask) +syscall sys_chroot nr 4061 nbargs 1 types: (const char *) args: (filename) +syscall sys_ustat nr 4062 nbargs 2 types: (unsigned, struct ustat *) args: (dev, ubuf) +syscall sys_dup2 nr 4063 nbargs 2 types: (unsigned int, unsigned int) args: (oldfd, newfd) +syscall sys_getppid nr 4064 nbargs 0 types: () args: () +syscall sys_getpgrp nr 4065 nbargs 0 types: () args: () +syscall sys_setsid nr 4066 nbargs 0 types: () args: () +syscall sys_sigaction nr 4067 nbargs 3 types: (int, const struct sigaction *, struct sigaction *) args: (sig, act, oact) +syscall sys_setreuid nr 4070 nbargs 2 types: (uid_t, uid_t) args: (ruid, euid) +syscall sys_setregid nr 4071 nbargs 2 types: (gid_t, gid_t) args: (rgid, egid) +syscall sys_sigsuspend nr 4072 nbargs 1 types: (sigset_t *) args: (uset) +syscall sys_sigpending nr 4073 nbargs 1 types: (old_sigset_t *) args: (set) +syscall sys_sethostname nr 4074 nbargs 2 types: (char *, int) args: (name, len) +syscall sys_setrlimit nr 4075 nbargs 2 types: (unsigned int, struct rlimit *) args: (resource, rlim) +syscall sys_getrlimit nr 4076 nbargs 2 types: (unsigned int, struct rlimit *) args: (resource, rlim) +syscall sys_getrusage nr 4077 nbargs 2 types: (int, struct rusage *) args: (who, ru) +syscall sys_gettimeofday nr 4078 nbargs 2 types: (struct timeval *, struct timezone *) args: (tv, tz) +syscall sys_settimeofday nr 4079 nbargs 2 types: (struct timeval *, struct timezone *) args: (tv, tz) +syscall sys_getgroups nr 4080 nbargs 2 types: (int, gid_t *) args: (gidsetsize, grouplist) +syscall sys_setgroups nr 4081 nbargs 2 types: (int, gid_t *) args: (gidsetsize, grouplist) +syscall sys_symlink nr 4083 nbargs 2 types: (const char *, const char *) args: (oldname, newname) +syscall sys_readlink nr 4085 nbargs 3 types: (const char *, char *, int) args: (path, buf, bufsiz) +syscall sys_reboot nr 4088 nbargs 4 types: (int, int, unsigned int, void *) args: (magic1, magic2, cmd, arg) +syscall sys_old_readdir nr 4089 nbargs 3 types: (unsigned int, struct old_linux_dirent *, unsigned int) args: (fd, dirent, count) +syscall sys_mmap nr 4090 nbargs 6 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long, off_t) args: (addr, len, prot, flags, fd, offset) +syscall sys_munmap nr 4091 nbargs 2 types: (unsigned long, size_t) args: (addr, len) +syscall sys_truncate nr 4092 nbargs 2 types: (const char *, long) args: (path, length) +syscall sys_ftruncate nr 4093 nbargs 2 types: (unsigned int, unsigned long) args: (fd, length) +syscall sys_fchmod nr 4094 nbargs 2 types: (unsigned int, umode_t) args: (fd, mode) +syscall sys_fchown nr 4095 nbargs 3 types: (unsigned int, uid_t, gid_t) args: (fd, user, group) +syscall sys_getpriority nr 4096 nbargs 2 types: (int, int) args: (which, who) +syscall sys_setpriority nr 4097 nbargs 3 types: (int, int, int) args: (which, who, niceval) +syscall sys_statfs nr 4099 nbargs 2 types: (const char *, struct statfs *) args: (pathname, buf) +syscall sys_fstatfs nr 4100 nbargs 2 types: (unsigned int, struct statfs *) args: (fd, buf) +syscall sys_socketcall nr 4102 nbargs 2 types: (int, unsigned long *) args: (call, args) +syscall sys_syslog nr 4103 nbargs 3 types: (int, char *, int) args: (type, buf, len) +syscall sys_setitimer nr 4104 nbargs 3 types: (int, struct itimerval *, struct itimerval *) args: (which, value, ovalue) +syscall sys_getitimer nr 4105 nbargs 2 types: (int, struct itimerval *) args: (which, value) +syscall sys_newstat nr 4106 nbargs 2 types: (const char *, struct stat *) args: (filename, statbuf) +syscall sys_newlstat nr 4107 nbargs 2 types: (const char *, struct stat *) args: (filename, statbuf) +syscall sys_newfstat nr 4108 nbargs 2 types: (unsigned int, struct stat *) args: (fd, statbuf) +syscall sys_uname nr 4109 nbargs 1 types: (struct old_utsname *) args: (name) +syscall sys_vhangup nr 4111 nbargs 0 types: () args: () +syscall sys_wait4 nr 4114 nbargs 4 types: (pid_t, int *, int, struct rusage *) args: (upid, stat_addr, options, ru) +syscall sys_sysinfo nr 4116 nbargs 1 types: (struct sysinfo *) args: (info) +syscall sys_ipc nr 4117 nbargs 6 types: (unsigned int, int, unsigned long, unsigned long, void *, long) args: (call, first, second, third, ptr, fifth) +syscall sys_fsync nr 4118 nbargs 1 types: (unsigned int) args: (fd) +syscall sys_setdomainname nr 4121 nbargs 2 types: (char *, int) args: (name, len) +syscall sys_newuname nr 4122 nbargs 1 types: (struct new_utsname *) args: (name) +syscall sys_adjtimex nr 4124 nbargs 1 types: (struct timex *) args: (txc_p) +syscall sys_mprotect nr 4125 nbargs 3 types: (unsigned long, size_t, unsigned long) args: (start, len, prot) +syscall sys_sigprocmask nr 4126 nbargs 3 types: (int, old_sigset_t *, old_sigset_t *) args: (how, nset, oset) +syscall sys_init_module nr 4128 nbargs 3 types: (void *, unsigned long, const char *) args: (umod, len, uargs) +syscall sys_delete_module nr 4129 nbargs 2 types: (const char *, unsigned int) args: (name_user, flags) +syscall sys_getpgid nr 4132 nbargs 1 types: (pid_t) args: (pid) +syscall sys_fchdir nr 4133 nbargs 1 types: (unsigned int) args: (fd) +syscall sys_bdflush nr 4134 nbargs 2 types: (int, long) args: (func, data) +syscall sys_personality nr 4136 nbargs 1 types: (unsigned int) args: (personality) +syscall sys_setfsuid nr 4138 nbargs 1 types: (uid_t) args: (uid) +syscall sys_setfsgid nr 4139 nbargs 1 types: (gid_t) args: (gid) +syscall sys_llseek nr 4140 nbargs 5 types: (unsigned int, unsigned long, unsigned long, loff_t *, unsigned int) args: (fd, offset_high, offset_low, result, whence) +syscall sys_getdents nr 4141 nbargs 3 types: (unsigned int, struct linux_dirent *, unsigned int) args: (fd, dirent, count) +syscall sys_select nr 4142 nbargs 5 types: (int, fd_set *, fd_set *, fd_set *, struct timeval *) args: (n, inp, outp, exp, tvp) +syscall sys_flock nr 4143 nbargs 2 types: (unsigned int, unsigned int) args: (fd, cmd) +syscall sys_msync nr 4144 nbargs 3 types: (unsigned long, size_t, int) args: (start, len, flags) +syscall sys_readv nr 4145 nbargs 3 types: (unsigned long, const struct iovec *, unsigned long) args: (fd, vec, vlen) +syscall sys_writev nr 4146 nbargs 3 types: (unsigned long, const struct iovec *, unsigned long) args: (fd, vec, vlen) +syscall sys_cacheflush nr 4147 nbargs 3 types: (unsigned long, unsigned long, unsigned int) args: (addr, bytes, cache) +syscall sys_cachectl nr 4148 nbargs 3 types: (char *, int, int) args: (addr, nbytes, op) +syscall sys_sysmips nr 4149 nbargs 3 types: (long, long, long) args: (cmd, arg1, arg2) +syscall sys_getsid nr 4151 nbargs 1 types: (pid_t) args: (pid) +syscall sys_fdatasync nr 4152 nbargs 1 types: (unsigned int) args: (fd) +syscall sys_sysctl nr 4153 nbargs 1 types: (struct __sysctl_args *) args: (args) +syscall sys_mlock nr 4154 nbargs 2 types: (unsigned long, size_t) args: (start, len) +syscall sys_munlock nr 4155 nbargs 2 types: (unsigned long, size_t) args: (start, len) +syscall sys_mlockall nr 4156 nbargs 1 types: (int) args: (flags) +syscall sys_munlockall nr 4157 nbargs 0 types: () args: () +syscall sys_sched_setparam nr 4158 nbargs 2 types: (pid_t, struct sched_param *) args: (pid, param) +syscall sys_sched_getparam nr 4159 nbargs 2 types: (pid_t, struct sched_param *) args: (pid, param) +syscall sys_sched_setscheduler nr 4160 nbargs 3 types: (pid_t, int, struct sched_param *) args: (pid, policy, param) +syscall sys_sched_getscheduler nr 4161 nbargs 1 types: (pid_t) args: (pid) +syscall sys_sched_yield nr 4162 nbargs 0 types: () args: () +syscall sys_sched_get_priority_max nr 4163 nbargs 1 types: (int) args: (policy) +syscall sys_sched_get_priority_min nr 4164 nbargs 1 types: (int) args: (policy) +syscall sys_sched_rr_get_interval nr 4165 nbargs 2 types: (pid_t, struct timespec *) args: (pid, interval) +syscall sys_nanosleep nr 4166 nbargs 2 types: (struct timespec *, struct timespec *) args: (rqtp, rmtp) +syscall sys_mremap nr 4167 nbargs 5 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long) args: (addr, old_len, new_len, flags, new_addr) +syscall sys_accept nr 4168 nbargs 3 types: (int, struct sockaddr *, int *) args: (fd, upeer_sockaddr, upeer_addrlen) +syscall sys_bind nr 4169 nbargs 3 types: (int, struct sockaddr *, int) args: (fd, umyaddr, addrlen) +syscall sys_connect nr 4170 nbargs 3 types: (int, struct sockaddr *, int) args: (fd, uservaddr, addrlen) +syscall sys_getpeername nr 4171 nbargs 3 types: (int, struct sockaddr *, int *) args: (fd, usockaddr, usockaddr_len) +syscall sys_getsockname nr 4172 nbargs 3 types: (int, struct sockaddr *, int *) args: (fd, usockaddr, usockaddr_len) +syscall sys_getsockopt nr 4173 nbargs 5 types: (int, int, int, char *, int *) args: (fd, level, optname, optval, optlen) +syscall sys_listen nr 4174 nbargs 2 types: (int, int) args: (fd, backlog) +syscall sys_recv nr 4175 nbargs 4 types: (int, void *, size_t, unsigned int) args: (fd, ubuf, size, flags) +syscall sys_recvfrom nr 4176 nbargs 6 types: (int, void *, size_t, unsigned int, struct sockaddr *, int *) args: (fd, ubuf, size, flags, addr, addr_len) +syscall sys_recvmsg nr 4177 nbargs 3 types: (int, struct msghdr *, unsigned int) args: (fd, msg, flags) +syscall sys_send nr 4178 nbargs 4 types: (int, void *, size_t, unsigned int) args: (fd, buff, len, flags) +syscall sys_sendmsg nr 4179 nbargs 3 types: (int, struct msghdr *, unsigned int) args: (fd, msg, flags) +syscall sys_sendto nr 4180 nbargs 6 types: (int, void *, size_t, unsigned int, struct sockaddr *, int) args: (fd, buff, len, flags, addr, addr_len) +syscall sys_setsockopt nr 4181 nbargs 5 types: (int, int, int, char *, int) args: (fd, level, optname, optval, optlen) +syscall sys_shutdown nr 4182 nbargs 2 types: (int, int) args: (fd, how) +syscall sys_socket nr 4183 nbargs 3 types: (int, int, int) args: (family, type, protocol) +syscall sys_socketpair nr 4184 nbargs 4 types: (int, int, int, int *) args: (family, type, protocol, usockvec) +syscall sys_setresuid nr 4185 nbargs 3 types: (uid_t, uid_t, uid_t) args: (ruid, euid, suid) +syscall sys_getresuid nr 4186 nbargs 3 types: (uid_t *, uid_t *, uid_t *) args: (ruidp, euidp, suidp) +syscall sys_poll nr 4188 nbargs 3 types: (struct pollfd *, unsigned int, int) args: (ufds, nfds, timeout_msecs) +syscall sys_setresgid nr 4190 nbargs 3 types: (gid_t, gid_t, gid_t) args: (rgid, egid, sgid) +syscall sys_getresgid nr 4191 nbargs 3 types: (gid_t *, gid_t *, gid_t *) args: (rgidp, egidp, sgidp) +syscall sys_prctl nr 4192 nbargs 5 types: (int, unsigned long, unsigned long, unsigned long, unsigned long) args: (option, arg2, arg3, arg4, arg5) +syscall sys_rt_sigaction nr 4194 nbargs 4 types: (int, const struct sigaction *, struct sigaction *, size_t) args: (sig, act, oact, sigsetsize) +syscall sys_rt_sigprocmask nr 4195 nbargs 4 types: (int, sigset_t *, sigset_t *, size_t) args: (how, nset, oset, sigsetsize) +syscall sys_rt_sigpending nr 4196 nbargs 2 types: (sigset_t *, size_t) args: (uset, sigsetsize) +syscall sys_rt_sigtimedwait nr 4197 nbargs 4 types: (const sigset_t *, siginfo_t *, const struct timespec *, size_t) args: (uthese, uinfo, uts, sigsetsize) +syscall sys_rt_sigqueueinfo nr 4198 nbargs 3 types: (pid_t, int, siginfo_t *) args: (pid, sig, uinfo) +syscall sys_rt_sigsuspend nr 4199 nbargs 2 types: (sigset_t *, size_t) args: (unewset, sigsetsize) +syscall sys_pread64 nr 4200 nbargs 4 types: (unsigned int, char *, size_t, loff_t) args: (fd, buf, count, pos) +syscall sys_pwrite64 nr 4201 nbargs 4 types: (unsigned int, const char *, size_t, loff_t) args: (fd, buf, count, pos) +syscall sys_chown nr 4202 nbargs 3 types: (const char *, uid_t, gid_t) args: (filename, user, group) +syscall sys_getcwd nr 4203 nbargs 2 types: (char *, unsigned long) args: (buf, size) +syscall sys_capget nr 4204 nbargs 2 types: (cap_user_header_t, cap_user_data_t) args: (header, dataptr) +syscall sys_capset nr 4205 nbargs 2 types: (cap_user_header_t, const cap_user_data_t) args: (header, data) +syscall sys_sigaltstack nr 4206 nbargs 2 types: (const stack_t *, stack_t *) args: (uss, uoss) +syscall sys_sendfile nr 4207 nbargs 4 types: (int, int, off_t *, size_t) args: (out_fd, in_fd, offset, count) +syscall sys_mips_mmap2 nr 4210 nbargs 6 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long, unsigned long) args: (addr, len, prot, flags, fd, pgoff) +syscall sys_truncate64 nr 4211 nbargs 2 types: (const char *, loff_t) args: (path, length) +syscall sys_ftruncate64 nr 4212 nbargs 2 types: (unsigned int, loff_t) args: (fd, length) +syscall sys_stat64 nr 4213 nbargs 2 types: (const char *, struct stat64 *) args: (filename, statbuf) +syscall sys_lstat64 nr 4214 nbargs 2 types: (const char *, struct stat64 *) args: (filename, statbuf) +syscall sys_fstat64 nr 4215 nbargs 2 types: (unsigned long, struct stat64 *) args: (fd, statbuf) +syscall sys_pivot_root nr 4216 nbargs 2 types: (const char *, const char *) args: (new_root, put_old) +syscall sys_mincore nr 4217 nbargs 3 types: (unsigned long, size_t, unsigned char *) args: (start, len, vec) +syscall sys_madvise nr 4218 nbargs 3 types: (unsigned long, size_t, int) args: (start, len_in, behavior) +syscall sys_getdents64 nr 4219 nbargs 3 types: (unsigned int, struct linux_dirent64 *, unsigned int) args: (fd, dirent, count) +syscall sys_fcntl64 nr 4220 nbargs 3 types: (unsigned int, unsigned int, unsigned long) args: (fd, cmd, arg) +syscall sys_gettid nr 4222 nbargs 0 types: () args: () +syscall sys_readahead nr 4223 nbargs 3 types: (int, loff_t, size_t) args: (fd, offset, count) +syscall sys_setxattr nr 4224 nbargs 5 types: (const char *, const char *, const void *, size_t, int) args: (pathname, name, value, size, flags) +syscall sys_lsetxattr nr 4225 nbargs 5 types: (const char *, const char *, const void *, size_t, int) args: (pathname, name, value, size, flags) +syscall sys_fsetxattr nr 4226 nbargs 5 types: (int, const char *, const void *, size_t, int) args: (fd, name, value, size, flags) +syscall sys_getxattr nr 4227 nbargs 4 types: (const char *, const char *, void *, size_t) args: (pathname, name, value, size) +syscall sys_lgetxattr nr 4228 nbargs 4 types: (const char *, const char *, void *, size_t) args: (pathname, name, value, size) +syscall sys_fgetxattr nr 4229 nbargs 4 types: (int, const char *, void *, size_t) args: (fd, name, value, size) +syscall sys_listxattr nr 4230 nbargs 3 types: (const char *, char *, size_t) args: (pathname, list, size) +syscall sys_llistxattr nr 4231 nbargs 3 types: (const char *, char *, size_t) args: (pathname, list, size) +syscall sys_flistxattr nr 4232 nbargs 3 types: (int, char *, size_t) args: (fd, list, size) +syscall sys_removexattr nr 4233 nbargs 2 types: (const char *, const char *) args: (pathname, name) +syscall sys_lremovexattr nr 4234 nbargs 2 types: (const char *, const char *) args: (pathname, name) +syscall sys_fremovexattr nr 4235 nbargs 2 types: (int, const char *) args: (fd, name) +syscall sys_tkill nr 4236 nbargs 2 types: (pid_t, int) args: (pid, sig) +syscall sys_sendfile64 nr 4237 nbargs 4 types: (int, int, loff_t *, size_t) args: (out_fd, in_fd, offset, count) +syscall sys_futex nr 4238 nbargs 6 types: (u32 *, int, u32, struct timespec *, u32 *, u32) args: (uaddr, op, val, utime, uaddr2, val3) +syscall sys_io_setup nr 4241 nbargs 2 types: (unsigned, aio_context_t *) args: (nr_events, ctxp) +syscall sys_io_destroy nr 4242 nbargs 1 types: (aio_context_t) args: (ctx) +syscall sys_io_getevents nr 4243 nbargs 5 types: (aio_context_t, long, long, struct io_event *, struct timespec *) args: (ctx_id, min_nr, nr, events, timeout) +syscall sys_io_submit nr 4244 nbargs 3 types: (aio_context_t, long, struct iocb * *) args: (ctx_id, nr, iocbpp) +syscall sys_io_cancel nr 4245 nbargs 3 types: (aio_context_t, struct iocb *, struct io_event *) args: (ctx_id, iocb, result) +syscall sys_exit_group nr 4246 nbargs 1 types: (int) args: (error_code) +syscall sys_epoll_create nr 4248 nbargs 1 types: (int) args: (size) +syscall sys_epoll_ctl nr 4249 nbargs 4 types: (int, int, int, struct epoll_event *) args: (epfd, op, fd, event) +syscall sys_epoll_wait nr 4250 nbargs 4 types: (int, struct epoll_event *, int, int) args: (epfd, events, maxevents, timeout) +syscall sys_remap_file_pages nr 4251 nbargs 5 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long) args: (start, size, prot, pgoff, flags) +syscall sys_set_tid_address nr 4252 nbargs 1 types: (int *) args: (tidptr) +syscall sys_restart_syscall nr 4253 nbargs 0 types: () args: () +syscall sys_fadvise64_64 nr 4254 nbargs 4 types: (int, loff_t, loff_t, int) args: (fd, offset, len, advice) +syscall sys_statfs64 nr 4255 nbargs 3 types: (const char *, size_t, struct statfs64 *) args: (pathname, sz, buf) +syscall sys_fstatfs64 nr 4256 nbargs 3 types: (unsigned int, size_t, struct statfs64 *) args: (fd, sz, buf) +syscall sys_timer_create nr 4257 nbargs 3 types: (const clockid_t, struct sigevent *, timer_t *) args: (which_clock, timer_event_spec, created_timer_id) +syscall sys_timer_settime nr 4258 nbargs 4 types: (timer_t, int, const struct itimerspec *, struct itimerspec *) args: (timer_id, flags, new_setting, old_setting) +syscall sys_timer_gettime nr 4259 nbargs 2 types: (timer_t, struct itimerspec *) args: (timer_id, setting) +syscall sys_timer_getoverrun nr 4260 nbargs 1 types: (timer_t) args: (timer_id) +syscall sys_timer_delete nr 4261 nbargs 1 types: (timer_t) args: (timer_id) +syscall sys_clock_settime nr 4262 nbargs 2 types: (const clockid_t, const struct timespec *) args: (which_clock, tp) +syscall sys_clock_gettime nr 4263 nbargs 2 types: (const clockid_t, struct timespec *) args: (which_clock, tp) +syscall sys_clock_getres nr 4264 nbargs 2 types: (const clockid_t, struct timespec *) args: (which_clock, tp) +syscall sys_clock_nanosleep nr 4265 nbargs 4 types: (const clockid_t, int, const struct timespec *, struct timespec *) args: (which_clock, flags, rqtp, rmtp) +syscall sys_tgkill nr 4266 nbargs 3 types: (pid_t, pid_t, int) args: (tgid, pid, sig) +syscall sys_utimes nr 4267 nbargs 2 types: (char *, struct timeval *) args: (filename, utimes) +syscall sys_waitid nr 4278 nbargs 5 types: (int, pid_t, struct siginfo *, int, struct rusage *) args: (which, upid, infop, options, ru) +syscall sys_set_thread_area nr 4283 nbargs 1 types: (unsigned long) args: (addr) +syscall sys_inotify_init nr 4284 nbargs 0 types: () args: () +syscall sys_inotify_add_watch nr 4285 nbargs 3 types: (int, const char *, u32) args: (fd, pathname, mask) +syscall sys_inotify_rm_watch nr 4286 nbargs 2 types: (int, __s32) args: (fd, wd) +syscall sys_openat nr 4288 nbargs 4 types: (int, const char *, int, umode_t) args: (dfd, filename, flags, mode) +syscall sys_mkdirat nr 4289 nbargs 3 types: (int, const char *, umode_t) args: (dfd, pathname, mode) +syscall sys_mknodat nr 4290 nbargs 4 types: (int, const char *, umode_t, unsigned) args: (dfd, filename, mode, dev) +syscall sys_fchownat nr 4291 nbargs 5 types: (int, const char *, uid_t, gid_t, int) args: (dfd, filename, user, group, flag) +syscall sys_futimesat nr 4292 nbargs 3 types: (int, const char *, struct timeval *) args: (dfd, filename, utimes) +syscall sys_fstatat64 nr 4293 nbargs 4 types: (int, const char *, struct stat64 *, int) args: (dfd, filename, statbuf, flag) +syscall sys_unlinkat nr 4294 nbargs 3 types: (int, const char *, int) args: (dfd, pathname, flag) +syscall sys_renameat nr 4295 nbargs 4 types: (int, const char *, int, const char *) args: (olddfd, oldname, newdfd, newname) +syscall sys_linkat nr 4296 nbargs 5 types: (int, const char *, int, const char *, int) args: (olddfd, oldname, newdfd, newname, flags) +syscall sys_symlinkat nr 4297 nbargs 3 types: (const char *, int, const char *) args: (oldname, newdfd, newname) +syscall sys_readlinkat nr 4298 nbargs 4 types: (int, const char *, char *, int) args: (dfd, pathname, buf, bufsiz) +syscall sys_fchmodat nr 4299 nbargs 3 types: (int, const char *, umode_t) args: (dfd, filename, mode) +syscall sys_faccessat nr 4300 nbargs 3 types: (int, const char *, int) args: (dfd, filename, mode) +syscall sys_pselect6 nr 4301 nbargs 6 types: (int, fd_set *, fd_set *, fd_set *, struct timespec *, void *) args: (n, inp, outp, exp, tsp, sig) +syscall sys_ppoll nr 4302 nbargs 5 types: (struct pollfd *, unsigned int, struct timespec *, const sigset_t *, size_t) args: (ufds, nfds, tsp, sigmask, sigsetsize) +syscall sys_unshare nr 4303 nbargs 1 types: (unsigned long) args: (unshare_flags) +syscall sys_splice nr 4304 nbargs 6 types: (int, loff_t *, int, loff_t *, size_t, unsigned int) args: (fd_in, off_in, fd_out, off_out, len, flags) +syscall sys_sync_file_range nr 4305 nbargs 4 types: (int, loff_t, loff_t, unsigned int) args: (fd, offset, nbytes, flags) +syscall sys_tee nr 4306 nbargs 4 types: (int, int, size_t, unsigned int) args: (fdin, fdout, len, flags) +syscall sys_vmsplice nr 4307 nbargs 4 types: (int, const struct iovec *, unsigned long, unsigned int) args: (fd, iov, nr_segs, flags) +syscall sys_set_robust_list nr 4309 nbargs 2 types: (struct robust_list_head *, size_t) args: (head, len) +syscall sys_get_robust_list nr 4310 nbargs 3 types: (int, struct robust_list_head * *, size_t *) args: (pid, head_ptr, len_ptr) +syscall sys_getcpu nr 4312 nbargs 3 types: (unsigned *, unsigned *, struct getcpu_cache *) args: (cpup, nodep, unused) +syscall sys_epoll_pwait nr 4313 nbargs 6 types: (int, struct epoll_event *, int, int, const sigset_t *, size_t) args: (epfd, events, maxevents, timeout, sigmask, sigsetsize) +syscall sys_ioprio_set nr 4314 nbargs 3 types: (int, int, int) args: (which, who, ioprio) +syscall sys_ioprio_get nr 4315 nbargs 2 types: (int, int) args: (which, who) +syscall sys_utimensat nr 4316 nbargs 4 types: (int, const char *, struct timespec *, int) args: (dfd, filename, utimes, flags) +syscall sys_signalfd nr 4317 nbargs 3 types: (int, sigset_t *, size_t) args: (ufd, user_mask, sizemask) +syscall sys_eventfd nr 4319 nbargs 1 types: (unsigned int) args: (count) +syscall sys_fallocate nr 4320 nbargs 4 types: (int, int, loff_t, loff_t) args: (fd, mode, offset, len) +syscall sys_timerfd_create nr 4321 nbargs 2 types: (int, int) args: (clockid, flags) +syscall sys_timerfd_gettime nr 4322 nbargs 2 types: (int, struct itimerspec *) args: (ufd, otmr) +syscall sys_timerfd_settime nr 4323 nbargs 4 types: (int, int, const struct itimerspec *, struct itimerspec *) args: (ufd, flags, utmr, otmr) +syscall sys_signalfd4 nr 4324 nbargs 4 types: (int, sigset_t *, size_t, int) args: (ufd, user_mask, sizemask, flags) +syscall sys_eventfd2 nr 4325 nbargs 2 types: (unsigned int, int) args: (count, flags) +syscall sys_epoll_create1 nr 4326 nbargs 1 types: (int) args: (flags) +syscall sys_dup3 nr 4327 nbargs 3 types: (unsigned int, unsigned int, int) args: (oldfd, newfd, flags) +syscall sys_pipe2 nr 4328 nbargs 2 types: (int *, int) args: (fildes, flags) +syscall sys_inotify_init1 nr 4329 nbargs 1 types: (int) args: (flags) +syscall sys_preadv nr 4330 nbargs 5 types: (unsigned long, const struct iovec *, unsigned long, unsigned long, unsigned long) args: (fd, vec, vlen, pos_l, pos_h) +syscall sys_pwritev nr 4331 nbargs 5 types: (unsigned long, const struct iovec *, unsigned long, unsigned long, unsigned long) args: (fd, vec, vlen, pos_l, pos_h) +syscall sys_rt_tgsigqueueinfo nr 4332 nbargs 4 types: (pid_t, pid_t, int, siginfo_t *) args: (tgid, pid, sig, uinfo) +syscall sys_perf_event_open nr 4333 nbargs 5 types: (struct perf_event_attr *, pid_t, int, int, unsigned long) args: (attr_uptr, pid, cpu, group_fd, flags) +syscall sys_accept4 nr 4334 nbargs 4 types: (int, struct sockaddr *, int *, int) args: (fd, upeer_sockaddr, upeer_addrlen, flags) +syscall sys_recvmmsg nr 4335 nbargs 5 types: (int, struct mmsghdr *, unsigned int, unsigned int, struct timespec *) args: (fd, mmsg, vlen, flags, timeout) +syscall sys_prlimit64 nr 4338 nbargs 4 types: (pid_t, unsigned int, const struct rlimit64 *, struct rlimit64 *) args: (pid, resource, new_rlim, old_rlim) +syscall sys_name_to_handle_at nr 4339 nbargs 5 types: (int, const char *, struct file_handle *, int *, int) args: (dfd, name, handle, mnt_id, flag) +syscall sys_open_by_handle_at nr 4340 nbargs 3 types: (int, struct file_handle *, int) args: (mountdirfd, handle, flags) +syscall sys_clock_adjtime nr 4341 nbargs 2 types: (const clockid_t, struct timex *) args: (which_clock, utx) +syscall sys_syncfs nr 4342 nbargs 1 types: (int) args: (fd) +syscall sys_sendmmsg nr 4343 nbargs 4 types: (int, struct mmsghdr *, unsigned int, unsigned int) args: (fd, mmsg, vlen, flags) +syscall sys_setns nr 4344 nbargs 2 types: (int, int) args: (fd, nstype) +syscall sys_finit_module nr 4348 nbargs 3 types: (int, const char *, int) args: (fd, uargs, flags) +syscall sys_sched_setattr nr 4349 nbargs 3 types: (pid_t, struct sched_attr *, unsigned int) args: (pid, uattr, flags) +syscall sys_sched_getattr nr 4350 nbargs 4 types: (pid_t, struct sched_attr *, unsigned int, unsigned int) args: (pid, uattr, size, flags) +syscall sys_renameat2 nr 4351 nbargs 5 types: (int, const char *, int, const char *, unsigned int) args: (olddfd, oldname, newdfd, newname, flags) +syscall sys_seccomp nr 4352 nbargs 3 types: (unsigned int, unsigned int, const char *) args: (op, flags, uargs) +syscall sys_getrandom nr 4353 nbargs 3 types: (char *, size_t, unsigned int) args: (buf, count, flags) +syscall sys_memfd_create nr 4354 nbargs 2 types: (const char *, unsigned int) args: (uname, flags) diff --git a/include/instrumentation/syscalls/3.4.25/arm-32-syscalls b/include/instrumentation/syscalls/3.4.25/arm-32-syscalls new file mode 100644 index 00000000..65c3973d --- /dev/null +++ b/include/instrumentation/syscalls/3.4.25/arm-32-syscalls @@ -0,0 +1,299 @@ +syscall sys_restart_syscall nr 0 nbargs 0 types: () args: () +syscall sys_exit nr 1 nbargs 1 types: (int) args: (error_code) +syscall sys_read nr 3 nbargs 3 types: (unsigned int, char *, size_t) args: (fd, buf, count) +syscall sys_write nr 4 nbargs 3 types: (unsigned int, const char *, size_t) args: (fd, buf, count) +syscall sys_open nr 5 nbargs 3 types: (const char *, int, umode_t) args: (filename, flags, mode) +syscall sys_close nr 6 nbargs 1 types: (unsigned int) args: (fd) +syscall sys_creat nr 8 nbargs 2 types: (const char *, umode_t) args: (pathname, mode) +syscall sys_link nr 9 nbargs 2 types: (const char *, const char *) args: (oldname, newname) +syscall sys_unlink nr 10 nbargs 1 types: (const char *) args: (pathname) +syscall sys_chdir nr 12 nbargs 1 types: (const char *) args: (filename) +syscall sys_mknod nr 14 nbargs 3 types: (const char *, umode_t, unsigned) args: (filename, mode, dev) +syscall sys_chmod nr 15 nbargs 2 types: (const char *, umode_t) args: (filename, mode) +syscall sys_lchown16 nr 16 nbargs 3 types: (const char *, old_uid_t, old_gid_t) args: (filename, user, group) +syscall sys_lseek nr 19 nbargs 3 types: (unsigned int, off_t, unsigned int) args: (fd, offset, origin) +syscall sys_getpid nr 20 nbargs 0 types: () args: () +syscall sys_mount nr 21 nbargs 5 types: (char *, char *, char *, unsigned long, void *) args: (dev_name, dir_name, type, flags, data) +syscall sys_setuid16 nr 23 nbargs 1 types: (old_uid_t) args: (uid) +syscall sys_getuid16 nr 24 nbargs 0 types: () args: () +syscall sys_ptrace nr 26 nbargs 4 types: (long, long, unsigned long, unsigned long) args: (request, pid, addr, data) +syscall sys_pause nr 29 nbargs 0 types: () args: () +syscall sys_access nr 33 nbargs 2 types: (const char *, int) args: (filename, mode) +syscall sys_nice nr 34 nbargs 1 types: (int) args: (increment) +syscall sys_sync nr 36 nbargs 0 types: () args: () +syscall sys_kill nr 37 nbargs 2 types: (pid_t, int) args: (pid, sig) +syscall sys_rename nr 38 nbargs 2 types: (const char *, const char *) args: (oldname, newname) +syscall sys_mkdir nr 39 nbargs 2 types: (const char *, umode_t) args: (pathname, mode) +syscall sys_rmdir nr 40 nbargs 1 types: (const char *) args: (pathname) +syscall sys_dup nr 41 nbargs 1 types: (unsigned int) args: (fildes) +syscall sys_pipe nr 42 nbargs 1 types: (int *) args: (fildes) +syscall sys_times nr 43 nbargs 1 types: (struct tms *) args: (tbuf) +syscall sys_brk nr 45 nbargs 1 types: (unsigned long) args: (brk) +syscall sys_setgid16 nr 46 nbargs 1 types: (old_gid_t) args: (gid) +syscall sys_getgid16 nr 47 nbargs 0 types: () args: () +syscall sys_geteuid16 nr 49 nbargs 0 types: () args: () +syscall sys_getegid16 nr 50 nbargs 0 types: () args: () +syscall sys_acct nr 51 nbargs 1 types: (const char *) args: (name) +syscall sys_umount nr 52 nbargs 2 types: (char *, int) args: (name, flags) +syscall sys_ioctl nr 54 nbargs 3 types: (unsigned int, unsigned int, unsigned long) args: (fd, cmd, arg) +syscall sys_fcntl nr 55 nbargs 3 types: (unsigned int, unsigned int, unsigned long) args: (fd, cmd, arg) +syscall sys_setpgid nr 57 nbargs 2 types: (pid_t, pid_t) args: (pid, pgid) +syscall sys_umask nr 60 nbargs 1 types: (int) args: (mask) +syscall sys_chroot nr 61 nbargs 1 types: (const char *) args: (filename) +syscall sys_ustat nr 62 nbargs 2 types: (unsigned, struct ustat *) args: (dev, ubuf) +syscall sys_dup2 nr 63 nbargs 2 types: (unsigned int, unsigned int) args: (oldfd, newfd) +syscall sys_getppid nr 64 nbargs 0 types: () args: () +syscall sys_getpgrp nr 65 nbargs 0 types: () args: () +syscall sys_setsid nr 66 nbargs 0 types: () args: () +syscall sys_setreuid16 nr 70 nbargs 2 types: (old_uid_t, old_uid_t) args: (ruid, euid) +syscall sys_setregid16 nr 71 nbargs 2 types: (old_gid_t, old_gid_t) args: (rgid, egid) +syscall sys_sigpending nr 73 nbargs 1 types: (old_sigset_t *) args: (set) +syscall sys_sethostname nr 74 nbargs 2 types: (char *, int) args: (name, len) +syscall sys_setrlimit nr 75 nbargs 2 types: (unsigned int, struct rlimit *) args: (resource, rlim) +syscall sys_getrusage nr 77 nbargs 2 types: (int, struct rusage *) args: (who, ru) +syscall sys_gettimeofday nr 78 nbargs 2 types: (struct timeval *, struct timezone *) args: (tv, tz) +syscall sys_settimeofday nr 79 nbargs 2 types: (struct timeval *, struct timezone *) args: (tv, tz) +syscall sys_getgroups16 nr 80 nbargs 2 types: (int, old_gid_t *) args: (gidsetsize, grouplist) +syscall sys_setgroups16 nr 81 nbargs 2 types: (int, old_gid_t *) args: (gidsetsize, grouplist) +syscall sys_symlink nr 83 nbargs 2 types: (const char *, const char *) args: (oldname, newname) +syscall sys_readlink nr 85 nbargs 3 types: (const char *, char *, int) args: (path, buf, bufsiz) +syscall sys_uselib nr 86 nbargs 1 types: (const char *) args: (library) +syscall sys_swapon nr 87 nbargs 2 types: (const char *, int) args: (specialfile, swap_flags) +syscall sys_reboot nr 88 nbargs 4 types: (int, int, unsigned int, void *) args: (magic1, magic2, cmd, arg) +syscall sys_munmap nr 91 nbargs 2 types: (unsigned long, size_t) args: (addr, len) +syscall sys_truncate nr 92 nbargs 2 types: (const char *, long) args: (path, length) +syscall sys_ftruncate nr 93 nbargs 2 types: (unsigned int, unsigned long) args: (fd, length) +syscall sys_fchmod nr 94 nbargs 2 types: (unsigned int, umode_t) args: (fd, mode) +syscall sys_fchown16 nr 95 nbargs 3 types: (unsigned int, old_uid_t, old_gid_t) args: (fd, user, group) +syscall sys_getpriority nr 96 nbargs 2 types: (int, int) args: (which, who) +syscall sys_setpriority nr 97 nbargs 3 types: (int, int, int) args: (which, who, niceval) +syscall sys_statfs nr 99 nbargs 2 types: (const char *, struct statfs *) args: (pathname, buf) +syscall sys_fstatfs nr 100 nbargs 2 types: (unsigned int, struct statfs *) args: (fd, buf) +syscall sys_syslog nr 103 nbargs 3 types: (int, char *, int) args: (type, buf, len) +syscall sys_setitimer nr 104 nbargs 3 types: (int, struct itimerval *, struct itimerval *) args: (which, value, ovalue) +syscall sys_getitimer nr 105 nbargs 2 types: (int, struct itimerval *) args: (which, value) +syscall sys_newstat nr 106 nbargs 2 types: (const char *, struct stat *) args: (filename, statbuf) +syscall sys_newlstat nr 107 nbargs 2 types: (const char *, struct stat *) args: (filename, statbuf) +syscall sys_newfstat nr 108 nbargs 2 types: (unsigned int, struct stat *) args: (fd, statbuf) +syscall sys_vhangup nr 111 nbargs 0 types: () args: () +syscall sys_wait4 nr 114 nbargs 4 types: (pid_t, int *, int, struct rusage *) args: (upid, stat_addr, options, ru) +syscall sys_swapoff nr 115 nbargs 1 types: (const char *) args: (specialfile) +syscall sys_sysinfo nr 116 nbargs 1 types: (struct sysinfo *) args: (info) +syscall sys_fsync nr 118 nbargs 1 types: (unsigned int) args: (fd) +syscall sys_setdomainname nr 121 nbargs 2 types: (char *, int) args: (name, len) +syscall sys_newuname nr 122 nbargs 1 types: (struct new_utsname *) args: (name) +syscall sys_adjtimex nr 124 nbargs 1 types: (struct timex *) args: (txc_p) +syscall sys_mprotect nr 125 nbargs 3 types: (unsigned long, size_t, unsigned long) args: (start, len, prot) +syscall sys_sigprocmask nr 126 nbargs 3 types: (int, old_sigset_t *, old_sigset_t *) args: (how, nset, oset) +syscall sys_init_module nr 128 nbargs 3 types: (void *, unsigned long, const char *) args: (umod, len, uargs) +syscall sys_delete_module nr 129 nbargs 2 types: (const char *, unsigned int) args: (name_user, flags) +syscall sys_quotactl nr 131 nbargs 4 types: (unsigned int, const char *, qid_t, void *) args: (cmd, special, id, addr) +syscall sys_getpgid nr 132 nbargs 1 types: (pid_t) args: (pid) +syscall sys_fchdir nr 133 nbargs 1 types: (unsigned int) args: (fd) +syscall sys_bdflush nr 134 nbargs 2 types: (int, long) args: (func, data) +syscall sys_sysfs nr 135 nbargs 3 types: (int, unsigned long, unsigned long) args: (option, arg1, arg2) +syscall sys_personality nr 136 nbargs 1 types: (unsigned int) args: (personality) +syscall sys_setfsuid16 nr 138 nbargs 1 types: (old_uid_t) args: (uid) +syscall sys_setfsgid16 nr 139 nbargs 1 types: (old_gid_t) args: (gid) +syscall sys_llseek nr 140 nbargs 5 types: (unsigned int, unsigned long, unsigned long, loff_t *, unsigned int) args: (fd, offset_high, offset_low, result, origin) +syscall sys_getdents nr 141 nbargs 3 types: (unsigned int, struct linux_dirent *, unsigned int) args: (fd, dirent, count) +syscall sys_select nr 142 nbargs 5 types: (int, fd_set *, fd_set *, fd_set *, struct timeval *) args: (n, inp, outp, exp, tvp) +syscall sys_flock nr 143 nbargs 2 types: (unsigned int, unsigned int) args: (fd, cmd) +syscall sys_msync nr 144 nbargs 3 types: (unsigned long, size_t, int) args: (start, len, flags) +syscall sys_readv nr 145 nbargs 3 types: (unsigned long, const struct iovec *, unsigned long) args: (fd, vec, vlen) +syscall sys_writev nr 146 nbargs 3 types: (unsigned long, const struct iovec *, unsigned long) args: (fd, vec, vlen) +syscall sys_getsid nr 147 nbargs 1 types: (pid_t) args: (pid) +syscall sys_fdatasync nr 148 nbargs 1 types: (unsigned int) args: (fd) +syscall sys_sysctl nr 149 nbargs 1 types: (struct __sysctl_args *) args: (args) +syscall sys_mlock nr 150 nbargs 2 types: (unsigned long, size_t) args: (start, len) +syscall sys_munlock nr 151 nbargs 2 types: (unsigned long, size_t) args: (start, len) +syscall sys_mlockall nr 152 nbargs 1 types: (int) args: (flags) +syscall sys_munlockall nr 153 nbargs 0 types: () args: () +syscall sys_sched_setparam nr 154 nbargs 2 types: (pid_t, struct sched_param *) args: (pid, param) +syscall sys_sched_getparam nr 155 nbargs 2 types: (pid_t, struct sched_param *) args: (pid, param) +syscall sys_sched_setscheduler nr 156 nbargs 3 types: (pid_t, int, struct sched_param *) args: (pid, policy, param) +syscall sys_sched_getscheduler nr 157 nbargs 1 types: (pid_t) args: (pid) +syscall sys_sched_yield nr 158 nbargs 0 types: () args: () +syscall sys_sched_get_priority_max nr 159 nbargs 1 types: (int) args: (policy) +syscall sys_sched_get_priority_min nr 160 nbargs 1 types: (int) args: (policy) +syscall sys_sched_rr_get_interval nr 161 nbargs 2 types: (pid_t, struct timespec *) args: (pid, interval) +syscall sys_nanosleep nr 162 nbargs 2 types: (struct timespec *, struct timespec *) args: (rqtp, rmtp) +syscall sys_mremap nr 163 nbargs 5 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long) args: (addr, old_len, new_len, flags, new_addr) +syscall sys_setresuid16 nr 164 nbargs 3 types: (old_uid_t, old_uid_t, old_uid_t) args: (ruid, euid, suid) +syscall sys_getresuid16 nr 165 nbargs 3 types: (old_uid_t *, old_uid_t *, old_uid_t *) args: (ruid, euid, suid) +syscall sys_poll nr 168 nbargs 3 types: (struct pollfd *, unsigned int, int) args: (ufds, nfds, timeout_msecs) +syscall sys_setresgid16 nr 170 nbargs 3 types: (old_gid_t, old_gid_t, old_gid_t) args: (rgid, egid, sgid) +syscall sys_getresgid16 nr 171 nbargs 3 types: (old_gid_t *, old_gid_t *, old_gid_t *) args: (rgid, egid, sgid) +syscall sys_prctl nr 172 nbargs 5 types: (int, unsigned long, unsigned long, unsigned long, unsigned long) args: (option, arg2, arg3, arg4, arg5) +syscall sys_rt_sigaction nr 174 nbargs 4 types: (int, const struct sigaction *, struct sigaction *, size_t) args: (sig, act, oact, sigsetsize) +syscall sys_rt_sigprocmask nr 175 nbargs 4 types: (int, sigset_t *, sigset_t *, size_t) args: (how, nset, oset, sigsetsize) +syscall sys_rt_sigpending nr 176 nbargs 2 types: (sigset_t *, size_t) args: (set, sigsetsize) +syscall sys_rt_sigtimedwait nr 177 nbargs 4 types: (const sigset_t *, siginfo_t *, const struct timespec *, size_t) args: (uthese, uinfo, uts, sigsetsize) +syscall sys_rt_sigqueueinfo nr 178 nbargs 3 types: (pid_t, int, siginfo_t *) args: (pid, sig, uinfo) +syscall sys_rt_sigsuspend nr 179 nbargs 2 types: (sigset_t *, size_t) args: (unewset, sigsetsize) +syscall sys_chown16 nr 182 nbargs 3 types: (const char *, old_uid_t, old_gid_t) args: (filename, user, group) +syscall sys_getcwd nr 183 nbargs 2 types: (char *, unsigned long) args: (buf, size) +syscall sys_capget nr 184 nbargs 2 types: (cap_user_header_t, cap_user_data_t) args: (header, dataptr) +syscall sys_capset nr 185 nbargs 2 types: (cap_user_header_t, const cap_user_data_t) args: (header, data) +syscall sys_sendfile nr 187 nbargs 4 types: (int, int, off_t *, size_t) args: (out_fd, in_fd, offset, count) +syscall sys_getrlimit nr 191 nbargs 2 types: (unsigned int, struct rlimit *) args: (resource, rlim) +syscall sys_stat64 nr 195 nbargs 2 types: (const char *, struct stat64 *) args: (filename, statbuf) +syscall sys_lstat64 nr 196 nbargs 2 types: (const char *, struct stat64 *) args: (filename, statbuf) +syscall sys_fstat64 nr 197 nbargs 2 types: (unsigned long, struct stat64 *) args: (fd, statbuf) +syscall sys_lchown nr 198 nbargs 3 types: (const char *, uid_t, gid_t) args: (filename, user, group) +syscall sys_getuid nr 199 nbargs 0 types: () args: () +syscall sys_getgid nr 200 nbargs 0 types: () args: () +syscall sys_geteuid nr 201 nbargs 0 types: () args: () +syscall sys_getegid nr 202 nbargs 0 types: () args: () +syscall sys_setreuid nr 203 nbargs 2 types: (uid_t, uid_t) args: (ruid, euid) +syscall sys_setregid nr 204 nbargs 2 types: (gid_t, gid_t) args: (rgid, egid) +syscall sys_getgroups nr 205 nbargs 2 types: (int, gid_t *) args: (gidsetsize, grouplist) +syscall sys_setgroups nr 206 nbargs 2 types: (int, gid_t *) args: (gidsetsize, grouplist) +syscall sys_fchown nr 207 nbargs 3 types: (unsigned int, uid_t, gid_t) args: (fd, user, group) +syscall sys_setresuid nr 208 nbargs 3 types: (uid_t, uid_t, uid_t) args: (ruid, euid, suid) +syscall sys_getresuid nr 209 nbargs 3 types: (uid_t *, uid_t *, uid_t *) args: (ruid, euid, suid) +syscall sys_setresgid nr 210 nbargs 3 types: (gid_t, gid_t, gid_t) args: (rgid, egid, sgid) +syscall sys_getresgid nr 211 nbargs 3 types: (gid_t *, gid_t *, gid_t *) args: (rgid, egid, sgid) +syscall sys_chown nr 212 nbargs 3 types: (const char *, uid_t, gid_t) args: (filename, user, group) +syscall sys_setuid nr 213 nbargs 1 types: (uid_t) args: (uid) +syscall sys_setgid nr 214 nbargs 1 types: (gid_t) args: (gid) +syscall sys_setfsuid nr 215 nbargs 1 types: (uid_t) args: (uid) +syscall sys_setfsgid nr 216 nbargs 1 types: (gid_t) args: (gid) +syscall sys_getdents64 nr 217 nbargs 3 types: (unsigned int, struct linux_dirent64 *, unsigned int) args: (fd, dirent, count) +syscall sys_pivot_root nr 218 nbargs 2 types: (const char *, const char *) args: (new_root, put_old) +syscall sys_mincore nr 219 nbargs 3 types: (unsigned long, size_t, unsigned char *) args: (start, len, vec) +syscall sys_madvise nr 220 nbargs 3 types: (unsigned long, size_t, int) args: (start, len_in, behavior) +syscall sys_fcntl64 nr 221 nbargs 3 types: (unsigned int, unsigned int, unsigned long) args: (fd, cmd, arg) +syscall sys_gettid nr 224 nbargs 0 types: () args: () +syscall sys_setxattr nr 226 nbargs 5 types: (const char *, const char *, const void *, size_t, int) args: (pathname, name, value, size, flags) +syscall sys_lsetxattr nr 227 nbargs 5 types: (const char *, const char *, const void *, size_t, int) args: (pathname, name, value, size, flags) +syscall sys_fsetxattr nr 228 nbargs 5 types: (int, const char *, const void *, size_t, int) args: (fd, name, value, size, flags) +syscall sys_getxattr nr 229 nbargs 4 types: (const char *, const char *, void *, size_t) args: (pathname, name, value, size) +syscall sys_lgetxattr nr 230 nbargs 4 types: (const char *, const char *, void *, size_t) args: (pathname, name, value, size) +syscall sys_fgetxattr nr 231 nbargs 4 types: (int, const char *, void *, size_t) args: (fd, name, value, size) +syscall sys_listxattr nr 232 nbargs 3 types: (const char *, char *, size_t) args: (pathname, list, size) +syscall sys_llistxattr nr 233 nbargs 3 types: (const char *, char *, size_t) args: (pathname, list, size) +syscall sys_flistxattr nr 234 nbargs 3 types: (int, char *, size_t) args: (fd, list, size) +syscall sys_removexattr nr 235 nbargs 2 types: (const char *, const char *) args: (pathname, name) +syscall sys_lremovexattr nr 236 nbargs 2 types: (const char *, const char *) args: (pathname, name) +syscall sys_fremovexattr nr 237 nbargs 2 types: (int, const char *) args: (fd, name) +syscall sys_tkill nr 238 nbargs 2 types: (pid_t, int) args: (pid, sig) +syscall sys_sendfile64 nr 239 nbargs 4 types: (int, int, loff_t *, size_t) args: (out_fd, in_fd, offset, count) +syscall sys_futex nr 240 nbargs 6 types: (u32 *, int, u32, struct timespec *, u32 *, u32) args: (uaddr, op, val, utime, uaddr2, val3) +syscall sys_sched_setaffinity nr 241 nbargs 3 types: (pid_t, unsigned int, unsigned long *) args: (pid, len, user_mask_ptr) +syscall sys_sched_getaffinity nr 242 nbargs 3 types: (pid_t, unsigned int, unsigned long *) args: (pid, len, user_mask_ptr) +syscall sys_io_setup nr 243 nbargs 2 types: (unsigned, aio_context_t *) args: (nr_events, ctxp) +syscall sys_io_destroy nr 244 nbargs 1 types: (aio_context_t) args: (ctx) +syscall sys_io_getevents nr 245 nbargs 5 types: (aio_context_t, long, long, struct io_event *, struct timespec *) args: (ctx_id, min_nr, nr, events, timeout) +syscall sys_io_submit nr 246 nbargs 3 types: (aio_context_t, long, struct iocb * *) args: (ctx_id, nr, iocbpp) +syscall sys_io_cancel nr 247 nbargs 3 types: (aio_context_t, struct iocb *, struct io_event *) args: (ctx_id, iocb, result) +syscall sys_exit_group nr 248 nbargs 1 types: (int) args: (error_code) +syscall sys_epoll_create nr 250 nbargs 1 types: (int) args: (size) +syscall sys_epoll_ctl nr 251 nbargs 4 types: (int, int, int, struct epoll_event *) args: (epfd, op, fd, event) +syscall sys_epoll_wait nr 252 nbargs 4 types: (int, struct epoll_event *, int, int) args: (epfd, events, maxevents, timeout) +syscall sys_remap_file_pages nr 253 nbargs 5 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long) args: (start, size, prot, pgoff, flags) +syscall sys_set_tid_address nr 256 nbargs 1 types: (int *) args: (tidptr) +syscall sys_timer_create nr 257 nbargs 3 types: (const clockid_t, struct sigevent *, timer_t *) args: (which_clock, timer_event_spec, created_timer_id) +syscall sys_timer_settime nr 258 nbargs 4 types: (timer_t, int, const struct itimerspec *, struct itimerspec *) args: (timer_id, flags, new_setting, old_setting) +syscall sys_timer_gettime nr 259 nbargs 2 types: (timer_t, struct itimerspec *) args: (timer_id, setting) +syscall sys_timer_getoverrun nr 260 nbargs 1 types: (timer_t) args: (timer_id) +syscall sys_timer_delete nr 261 nbargs 1 types: (timer_t) args: (timer_id) +syscall sys_clock_settime nr 262 nbargs 2 types: (const clockid_t, const struct timespec *) args: (which_clock, tp) +syscall sys_clock_gettime nr 263 nbargs 2 types: (const clockid_t, struct timespec *) args: (which_clock, tp) +syscall sys_clock_getres nr 264 nbargs 2 types: (const clockid_t, struct timespec *) args: (which_clock, tp) +syscall sys_clock_nanosleep nr 265 nbargs 4 types: (const clockid_t, int, const struct timespec *, struct timespec *) args: (which_clock, flags, rqtp, rmtp) +syscall sys_tgkill nr 268 nbargs 3 types: (pid_t, pid_t, int) args: (tgid, pid, sig) +syscall sys_utimes nr 269 nbargs 2 types: (char *, struct timeval *) args: (filename, utimes) +syscall sys_mq_open nr 274 nbargs 4 types: (const char *, int, umode_t, struct mq_attr *) args: (u_name, oflag, mode, u_attr) +syscall sys_mq_unlink nr 275 nbargs 1 types: (const char *) args: (u_name) +syscall sys_mq_timedsend nr 276 nbargs 5 types: (mqd_t, const char *, size_t, unsigned int, const struct timespec *) args: (mqdes, u_msg_ptr, msg_len, msg_prio, u_abs_timeout) +syscall sys_mq_timedreceive nr 277 nbargs 5 types: (mqd_t, char *, size_t, unsigned int *, const struct timespec *) args: (mqdes, u_msg_ptr, msg_len, u_msg_prio, u_abs_timeout) +syscall sys_mq_notify nr 278 nbargs 2 types: (mqd_t, const struct sigevent *) args: (mqdes, u_notification) +syscall sys_mq_getsetattr nr 279 nbargs 3 types: (mqd_t, const struct mq_attr *, struct mq_attr *) args: (mqdes, u_mqstat, u_omqstat) +syscall sys_waitid nr 280 nbargs 5 types: (int, pid_t, struct siginfo *, int, struct rusage *) args: (which, upid, infop, options, ru) +syscall sys_socket nr 281 nbargs 3 types: (int, int, int) args: (family, type, protocol) +syscall sys_bind nr 282 nbargs 3 types: (int, struct sockaddr *, int) args: (fd, umyaddr, addrlen) +syscall sys_connect nr 283 nbargs 3 types: (int, struct sockaddr *, int) args: (fd, uservaddr, addrlen) +syscall sys_listen nr 284 nbargs 2 types: (int, int) args: (fd, backlog) +syscall sys_accept nr 285 nbargs 3 types: (int, struct sockaddr *, int *) args: (fd, upeer_sockaddr, upeer_addrlen) +syscall sys_getsockname nr 286 nbargs 3 types: (int, struct sockaddr *, int *) args: (fd, usockaddr, usockaddr_len) +syscall sys_getpeername nr 287 nbargs 3 types: (int, struct sockaddr *, int *) args: (fd, usockaddr, usockaddr_len) +syscall sys_socketpair nr 288 nbargs 4 types: (int, int, int, int *) args: (family, type, protocol, usockvec) +syscall sys_send nr 289 nbargs 4 types: (int, void *, size_t, unsigned) args: (fd, buff, len, flags) +syscall sys_sendto nr 290 nbargs 6 types: (int, void *, size_t, unsigned, struct sockaddr *, int) args: (fd, buff, len, flags, addr, addr_len) +syscall sys_recvfrom nr 292 nbargs 6 types: (int, void *, size_t, unsigned, struct sockaddr *, int *) args: (fd, ubuf, size, flags, addr, addr_len) +syscall sys_shutdown nr 293 nbargs 2 types: (int, int) args: (fd, how) +syscall sys_setsockopt nr 294 nbargs 5 types: (int, int, int, char *, int) args: (fd, level, optname, optval, optlen) +syscall sys_getsockopt nr 295 nbargs 5 types: (int, int, int, char *, int *) args: (fd, level, optname, optval, optlen) +syscall sys_sendmsg nr 296 nbargs 3 types: (int, struct msghdr *, unsigned) args: (fd, msg, flags) +syscall sys_recvmsg nr 297 nbargs 3 types: (int, struct msghdr *, unsigned int) args: (fd, msg, flags) +syscall sys_semop nr 298 nbargs 3 types: (int, struct sembuf *, unsigned) args: (semid, tsops, nsops) +syscall sys_semget nr 299 nbargs 3 types: (key_t, int, int) args: (key, nsems, semflg) +syscall sys_msgsnd nr 301 nbargs 4 types: (int, struct msgbuf *, size_t, int) args: (msqid, msgp, msgsz, msgflg) +syscall sys_msgrcv nr 302 nbargs 5 types: (int, struct msgbuf *, size_t, long, int) args: (msqid, msgp, msgsz, msgtyp, msgflg) +syscall sys_msgget nr 303 nbargs 2 types: (key_t, int) args: (key, msgflg) +syscall sys_msgctl nr 304 nbargs 3 types: (int, int, struct msqid_ds *) args: (msqid, cmd, buf) +syscall sys_shmat nr 305 nbargs 3 types: (int, char *, int) args: (shmid, shmaddr, shmflg) +syscall sys_shmdt nr 306 nbargs 1 types: (char *) args: (shmaddr) +syscall sys_shmget nr 307 nbargs 3 types: (key_t, size_t, int) args: (key, size, shmflg) +syscall sys_shmctl nr 308 nbargs 3 types: (int, int, struct shmid_ds *) args: (shmid, cmd, buf) +syscall sys_add_key nr 309 nbargs 5 types: (const char *, const char *, const void *, size_t, key_serial_t) args: (_type, _description, _payload, plen, ringid) +syscall sys_request_key nr 310 nbargs 4 types: (const char *, const char *, const char *, key_serial_t) args: (_type, _description, _callout_info, destringid) +syscall sys_keyctl nr 311 nbargs 5 types: (int, unsigned long, unsigned long, unsigned long, unsigned long) args: (option, arg2, arg3, arg4, arg5) +syscall sys_semtimedop nr 312 nbargs 4 types: (int, struct sembuf *, unsigned, const struct timespec *) args: (semid, tsops, nsops, timeout) +syscall sys_ioprio_set nr 314 nbargs 3 types: (int, int, int) args: (which, who, ioprio) +syscall sys_ioprio_get nr 315 nbargs 2 types: (int, int) args: (which, who) +syscall sys_inotify_init nr 316 nbargs 0 types: () args: () +syscall sys_inotify_add_watch nr 317 nbargs 3 types: (int, const char *, u32) args: (fd, pathname, mask) +syscall sys_inotify_rm_watch nr 318 nbargs 2 types: (int, __s32) args: (fd, wd) +syscall sys_openat nr 322 nbargs 4 types: (int, const char *, int, umode_t) args: (dfd, filename, flags, mode) +syscall sys_mkdirat nr 323 nbargs 3 types: (int, const char *, umode_t) args: (dfd, pathname, mode) +syscall sys_mknodat nr 324 nbargs 4 types: (int, const char *, umode_t, unsigned) args: (dfd, filename, mode, dev) +syscall sys_fchownat nr 325 nbargs 5 types: (int, const char *, uid_t, gid_t, int) args: (dfd, filename, user, group, flag) +syscall sys_futimesat nr 326 nbargs 3 types: (int, const char *, struct timeval *) args: (dfd, filename, utimes) +syscall sys_fstatat64 nr 327 nbargs 4 types: (int, const char *, struct stat64 *, int) args: (dfd, filename, statbuf, flag) +syscall sys_unlinkat nr 328 nbargs 3 types: (int, const char *, int) args: (dfd, pathname, flag) +syscall sys_renameat nr 329 nbargs 4 types: (int, const char *, int, const char *) args: (olddfd, oldname, newdfd, newname) +syscall sys_linkat nr 330 nbargs 5 types: (int, const char *, int, const char *, int) args: (olddfd, oldname, newdfd, newname, flags) +syscall sys_symlinkat nr 331 nbargs 3 types: (const char *, int, const char *) args: (oldname, newdfd, newname) +syscall sys_readlinkat nr 332 nbargs 4 types: (int, const char *, char *, int) args: (dfd, pathname, buf, bufsiz) +syscall sys_fchmodat nr 333 nbargs 3 types: (int, const char *, umode_t) args: (dfd, filename, mode) +syscall sys_faccessat nr 334 nbargs 3 types: (int, const char *, int) args: (dfd, filename, mode) +syscall sys_pselect6 nr 335 nbargs 6 types: (int, fd_set *, fd_set *, fd_set *, struct timespec *, void *) args: (n, inp, outp, exp, tsp, sig) +syscall sys_ppoll nr 336 nbargs 5 types: (struct pollfd *, unsigned int, struct timespec *, const sigset_t *, size_t) args: (ufds, nfds, tsp, sigmask, sigsetsize) +syscall sys_unshare nr 337 nbargs 1 types: (unsigned long) args: (unshare_flags) +syscall sys_set_robust_list nr 338 nbargs 2 types: (struct robust_list_head *, size_t) args: (head, len) +syscall sys_get_robust_list nr 339 nbargs 3 types: (int, struct robust_list_head * *, size_t *) args: (pid, head_ptr, len_ptr) +syscall sys_splice nr 340 nbargs 6 types: (int, loff_t *, int, loff_t *, size_t, unsigned int) args: (fd_in, off_in, fd_out, off_out, len, flags) +syscall sys_tee nr 342 nbargs 4 types: (int, int, size_t, unsigned int) args: (fdin, fdout, len, flags) +syscall sys_vmsplice nr 343 nbargs 4 types: (int, const struct iovec *, unsigned long, unsigned int) args: (fd, iov, nr_segs, flags) +syscall sys_getcpu nr 345 nbargs 3 types: (unsigned *, unsigned *, struct getcpu_cache *) args: (cpup, nodep, unused) +syscall sys_epoll_pwait nr 346 nbargs 6 types: (int, struct epoll_event *, int, int, const sigset_t *, size_t) args: (epfd, events, maxevents, timeout, sigmask, sigsetsize) +syscall sys_utimensat nr 348 nbargs 4 types: (int, const char *, struct timespec *, int) args: (dfd, filename, utimes, flags) +syscall sys_signalfd nr 349 nbargs 3 types: (int, sigset_t *, size_t) args: (ufd, user_mask, sizemask) +syscall sys_timerfd_create nr 350 nbargs 2 types: (int, int) args: (clockid, flags) +syscall sys_eventfd nr 351 nbargs 1 types: (unsigned int) args: (count) +syscall sys_timerfd_settime nr 353 nbargs 4 types: (int, int, const struct itimerspec *, struct itimerspec *) args: (ufd, flags, utmr, otmr) +syscall sys_timerfd_gettime nr 354 nbargs 2 types: (int, struct itimerspec *) args: (ufd, otmr) +syscall sys_signalfd4 nr 355 nbargs 4 types: (int, sigset_t *, size_t, int) args: (ufd, user_mask, sizemask, flags) +syscall sys_eventfd2 nr 356 nbargs 2 types: (unsigned int, int) args: (count, flags) +syscall sys_epoll_create1 nr 357 nbargs 1 types: (int) args: (flags) +syscall sys_dup3 nr 358 nbargs 3 types: (unsigned int, unsigned int, int) args: (oldfd, newfd, flags) +syscall sys_pipe2 nr 359 nbargs 2 types: (int *, int) args: (fildes, flags) +syscall sys_inotify_init1 nr 360 nbargs 1 types: (int) args: (flags) +syscall sys_preadv nr 361 nbargs 5 types: (unsigned long, const struct iovec *, unsigned long, unsigned long, unsigned long) args: (fd, vec, vlen, pos_l, pos_h) +syscall sys_pwritev nr 362 nbargs 5 types: (unsigned long, const struct iovec *, unsigned long, unsigned long, unsigned long) args: (fd, vec, vlen, pos_l, pos_h) +syscall sys_rt_tgsigqueueinfo nr 363 nbargs 4 types: (pid_t, pid_t, int, siginfo_t *) args: (tgid, pid, sig, uinfo) +syscall sys_perf_event_open nr 364 nbargs 5 types: (struct perf_event_attr *, pid_t, int, int, unsigned long) args: (attr_uptr, pid, cpu, group_fd, flags) +syscall sys_recvmmsg nr 365 nbargs 5 types: (int, struct mmsghdr *, unsigned int, unsigned int, struct timespec *) args: (fd, mmsg, vlen, flags, timeout) +syscall sys_accept4 nr 366 nbargs 4 types: (int, struct sockaddr *, int *, int) args: (fd, upeer_sockaddr, upeer_addrlen, flags) +syscall sys_fanotify_init nr 367 nbargs 2 types: (unsigned int, unsigned int) args: (flags, event_f_flags) +syscall sys_prlimit64 nr 369 nbargs 4 types: (pid_t, unsigned int, const struct rlimit64 *, struct rlimit64 *) args: (pid, resource, new_rlim, old_rlim) +syscall sys_name_to_handle_at nr 370 nbargs 5 types: (int, const char *, struct file_handle *, int *, int) args: (dfd, name, handle, mnt_id, flag) +syscall sys_open_by_handle_at nr 371 nbargs 3 types: (int, struct file_handle *, int) args: (mountdirfd, handle, flags) +syscall sys_clock_adjtime nr 372 nbargs 2 types: (const clockid_t, struct timex *) args: (which_clock, utx) +syscall sys_syncfs nr 373 nbargs 1 types: (int) args: (fd) +syscall sys_sendmmsg nr 374 nbargs 4 types: (int, struct mmsghdr *, unsigned int, unsigned int) args: (fd, mmsg, vlen, flags) +syscall sys_setns nr 375 nbargs 2 types: (int, int) args: (fd, nstype) +syscall sys_process_vm_readv nr 376 nbargs 6 types: (pid_t, const struct iovec *, unsigned long, const struct iovec *, unsigned long, unsigned long) args: (pid, lvec, liovcnt, rvec, riovcnt, flags) +syscall sys_process_vm_writev nr 377 nbargs 6 types: (pid_t, const struct iovec *, unsigned long, const struct iovec *, unsigned long, unsigned long) args: (pid, lvec, liovcnt, rvec, riovcnt, flags) diff --git a/include/instrumentation/syscalls/3.5.0/mips-32-syscalls b/include/instrumentation/syscalls/3.5.0/mips-32-syscalls new file mode 100644 index 00000000..5b62cc7b --- /dev/null +++ b/include/instrumentation/syscalls/3.5.0/mips-32-syscalls @@ -0,0 +1,141 @@ +syscall sys_exit nr 4003 nbargs 1 types: (int) args: (error_code) +syscall sys_read nr 4007 nbargs 3 types: (unsigned int, char *, size_t) args: (fd, buf, count) +syscall sys_write nr 4009 nbargs 3 types: (unsigned int, const char *, size_t) args: (fd, buf, count) +syscall sys_open nr 4011 nbargs 3 types: (const char *, int, umode_t) args: (filename, flags, mode) +syscall sys_close nr 4013 nbargs 1 types: (unsigned int) args: (fd) +syscall sys_waitpid nr 4015 nbargs 3 types: (pid_t, int *, int) args: (pid, stat_addr, options) +syscall sys_creat nr 4017 nbargs 2 types: (const char *, umode_t) args: (pathname, mode) +syscall sys_link nr 4019 nbargs 2 types: (const char *, const char *) args: (oldname, newname) +syscall sys_unlink nr 4021 nbargs 1 types: (const char *) args: (pathname) +syscall sys_chdir nr 4025 nbargs 1 types: (const char *) args: (filename) +syscall sys_time nr 4027 nbargs 1 types: (time_t *) args: (tloc) +syscall sys_mknod nr 4029 nbargs 3 types: (const char *, umode_t, unsigned) args: (filename, mode, dev) +syscall sys_chmod nr 4031 nbargs 2 types: (const char *, umode_t) args: (filename, mode) +syscall sys_lchown nr 4033 nbargs 3 types: (const char *, uid_t, gid_t) args: (filename, user, group) +syscall sys_lseek nr 4039 nbargs 3 types: (unsigned int, off_t, unsigned int) args: (fd, offset, origin) +syscall sys_getpid nr 4041 nbargs 0 types: () args: () +syscall sys_mount nr 4043 nbargs 5 types: (char *, char *, char *, unsigned long, void *) args: (dev_name, dir_name, type, flags, data) +syscall sys_oldumount nr 4045 nbargs 1 types: (char *) args: (name) +syscall sys_setuid nr 4047 nbargs 1 types: (uid_t) args: (uid) +syscall sys_getuid nr 4049 nbargs 0 types: () args: () +syscall sys_stime nr 4051 nbargs 1 types: (time_t *) args: (tptr) +syscall sys_ptrace nr 4053 nbargs 4 types: (long, long, unsigned long, unsigned long) args: (request, pid, addr, data) +syscall sys_alarm nr 4055 nbargs 1 types: (unsigned int) args: (seconds) +syscall sys_pause nr 4059 nbargs 0 types: () args: () +syscall sys_utime nr 4061 nbargs 2 types: (char *, struct utimbuf *) args: (filename, times) +syscall sys_access nr 4067 nbargs 2 types: (const char *, int) args: (filename, mode) +syscall sys_nice nr 4069 nbargs 1 types: (int) args: (increment) +syscall sys_sync nr 4073 nbargs 0 types: () args: () +syscall sys_kill nr 4075 nbargs 2 types: (pid_t, int) args: (pid, sig) +syscall sys_rename nr 4077 nbargs 2 types: (const char *, const char *) args: (oldname, newname) +syscall sys_mkdir nr 4079 nbargs 2 types: (const char *, umode_t) args: (pathname, mode) +syscall sys_rmdir nr 4081 nbargs 1 types: (const char *) args: (pathname) +syscall sys_dup nr 4083 nbargs 1 types: (unsigned int) args: (fildes) +syscall sys_times nr 4087 nbargs 1 types: (struct tms *) args: (tbuf) +syscall sys_brk nr 4091 nbargs 1 types: (unsigned long) args: (brk) +syscall sys_setgid nr 4093 nbargs 1 types: (gid_t) args: (gid) +syscall sys_getgid nr 4095 nbargs 0 types: () args: () +syscall sys_geteuid nr 4099 nbargs 0 types: () args: () +syscall sys_getegid nr 4101 nbargs 0 types: () args: () +syscall sys_umount nr 4105 nbargs 2 types: (char *, int) args: (name, flags) +syscall sys_ioctl nr 4109 nbargs 3 types: (unsigned int, unsigned int, unsigned long) args: (fd, cmd, arg) +syscall sys_fcntl nr 4111 nbargs 3 types: (unsigned int, unsigned int, unsigned long) args: (fd, cmd, arg) +syscall sys_setpgid nr 4115 nbargs 2 types: (pid_t, pid_t) args: (pid, pgid) +syscall sys_olduname nr 4119 nbargs 1 types: (struct oldold_utsname *) args: (name) +syscall sys_umask nr 4121 nbargs 1 types: (int) args: (mask) +syscall sys_chroot nr 4123 nbargs 1 types: (const char *) args: (filename) +syscall sys_ustat nr 4125 nbargs 2 types: (unsigned, struct ustat *) args: (dev, ubuf) +syscall sys_dup2 nr 4127 nbargs 2 types: (unsigned int, unsigned int) args: (oldfd, newfd) +syscall sys_getppid nr 4129 nbargs 0 types: () args: () +syscall sys_getpgrp nr 4131 nbargs 0 types: () args: () +syscall sys_setsid nr 4133 nbargs 0 types: () args: () +syscall sys_sigaction nr 4135 nbargs 3 types: (int, const struct sigaction *, struct sigaction *) args: (sig, act, oact) +syscall sys_sgetmask nr 4137 nbargs 0 types: () args: () +syscall sys_ssetmask nr 4139 nbargs 1 types: (int) args: (newmask) +syscall sys_setreuid nr 4141 nbargs 2 types: (uid_t, uid_t) args: (ruid, euid) +syscall sys_setregid nr 4143 nbargs 2 types: (gid_t, gid_t) args: (rgid, egid) +syscall sys_sigpending nr 4147 nbargs 1 types: (old_sigset_t *) args: (set) +syscall sys_sethostname nr 4149 nbargs 2 types: (char *, int) args: (name, len) +syscall sys_setrlimit nr 4151 nbargs 2 types: (unsigned int, struct rlimit *) args: (resource, rlim) +syscall sys_getrlimit nr 4153 nbargs 2 types: (unsigned int, struct rlimit *) args: (resource, rlim) +syscall sys_getrusage nr 4155 nbargs 2 types: (int, struct rusage *) args: (who, ru) +syscall sys_gettimeofday nr 4157 nbargs 2 types: (struct timeval *, struct timezone *) args: (tv, tz) +syscall sys_settimeofday nr 4159 nbargs 2 types: (struct timeval *, struct timezone *) args: (tv, tz) +syscall sys_getgroups nr 4161 nbargs 2 types: (int, gid_t *) args: (gidsetsize, grouplist) +syscall sys_setgroups nr 4163 nbargs 2 types: (int, gid_t *) args: (gidsetsize, grouplist) +syscall sys_symlink nr 4167 nbargs 2 types: (const char *, const char *) args: (oldname, newname) +syscall sys_readlink nr 4171 nbargs 3 types: (const char *, char *, int) args: (path, buf, bufsiz) +syscall sys_uselib nr 4173 nbargs 1 types: (const char *) args: (library) +syscall sys_swapon nr 4175 nbargs 2 types: (const char *, int) args: (specialfile, swap_flags) +syscall sys_reboot nr 4177 nbargs 4 types: (int, int, unsigned int, void *) args: (magic1, magic2, cmd, arg) +syscall sys_old_readdir nr 4179 nbargs 3 types: (unsigned int, struct old_linux_dirent *, unsigned int) args: (fd, dirent, count) +syscall sys_mips_mmap nr 4181 nbargs 6 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long, off_t) args: (addr, len, prot, flags, fd, offset) +syscall sys_munmap nr 4183 nbargs 2 types: (unsigned long, size_t) args: (addr, len) +syscall sys_truncate nr 4185 nbargs 2 types: (const char *, long) args: (path, length) +syscall sys_ftruncate nr 4187 nbargs 2 types: (unsigned int, unsigned long) args: (fd, length) +syscall sys_fchmod nr 4189 nbargs 2 types: (unsigned int, umode_t) args: (fd, mode) +syscall sys_fchown nr 4191 nbargs 3 types: (unsigned int, uid_t, gid_t) args: (fd, user, group) +syscall sys_getpriority nr 4193 nbargs 2 types: (int, int) args: (which, who) +syscall sys_setpriority nr 4195 nbargs 3 types: (int, int, int) args: (which, who, niceval) +syscall sys_statfs nr 4199 nbargs 2 types: (const char *, struct statfs *) args: (pathname, buf) +syscall sys_fstatfs nr 4201 nbargs 2 types: (unsigned int, struct statfs *) args: (fd, buf) +syscall sys_socketcall nr 4205 nbargs 2 types: (int, unsigned long *) args: (call, args) +syscall sys_syslog nr 4207 nbargs 3 types: (int, char *, int) args: (type, buf, len) +syscall sys_setitimer nr 4209 nbargs 3 types: (int, struct itimerval *, struct itimerval *) args: (which, value, ovalue) +syscall sys_getitimer nr 4211 nbargs 2 types: (int, struct itimerval *) args: (which, value) +syscall sys_newstat nr 4213 nbargs 2 types: (const char *, struct stat *) args: (filename, statbuf) +syscall sys_newlstat nr 4215 nbargs 2 types: (const char *, struct stat *) args: (filename, statbuf) +syscall sys_newfstat nr 4217 nbargs 2 types: (unsigned int, struct stat *) args: (fd, statbuf) +syscall sys_uname nr 4219 nbargs 1 types: (struct old_utsname *) args: (name) +syscall sys_vhangup nr 4223 nbargs 0 types: () args: () +syscall sys_wait4 nr 4229 nbargs 4 types: (pid_t, int *, int, struct rusage *) args: (upid, stat_addr, options, ru) +syscall sys_swapoff nr 4231 nbargs 1 types: (const char *) args: (specialfile) +syscall sys_sysinfo nr 4233 nbargs 1 types: (struct sysinfo *) args: (info) +syscall sys_ipc nr 4235 nbargs 6 types: (unsigned int, int, unsigned long, unsigned long, void *, long) args: (call, first, second, third, ptr, fifth) +syscall sys_fsync nr 4237 nbargs 1 types: (unsigned int) args: (fd) +syscall sys_setdomainname nr 4243 nbargs 2 types: (char *, int) args: (name, len) +syscall sys_newuname nr 4245 nbargs 1 types: (struct new_utsname *) args: (name) +syscall sys_adjtimex nr 4249 nbargs 1 types: (struct timex *) args: (txc_p) +syscall sys_mprotect nr 4251 nbargs 3 types: (unsigned long, size_t, unsigned long) args: (start, len, prot) +syscall sys_sigprocmask nr 4253 nbargs 3 types: (int, old_sigset_t *, old_sigset_t *) args: (how, nset, oset) +syscall sys_init_module nr 4257 nbargs 3 types: (void *, unsigned long, const char *) args: (umod, len, uargs) +syscall sys_delete_module nr 4259 nbargs 2 types: (const char *, unsigned int) args: (name_user, flags) +syscall sys_quotactl nr 4263 nbargs 4 types: (unsigned int, const char *, qid_t, void *) args: (cmd, special, id, addr) +syscall sys_getpgid nr 4265 nbargs 1 types: (pid_t) args: (pid) +syscall sys_fchdir nr 4267 nbargs 1 types: (unsigned int) args: (fd) +syscall sys_bdflush nr 4269 nbargs 2 types: (int, long) args: (func, data) +syscall sys_sysfs nr 4271 nbargs 3 types: (int, unsigned long, unsigned long) args: (option, arg1, arg2) +syscall sys_personality nr 4273 nbargs 1 types: (unsigned int) args: (personality) +syscall sys_setfsuid nr 4277 nbargs 1 types: (uid_t) args: (uid) +syscall sys_setfsgid nr 4279 nbargs 1 types: (gid_t) args: (gid) +syscall sys_llseek nr 4281 nbargs 5 types: (unsigned int, unsigned long, unsigned long, loff_t *, unsigned int) args: (fd, offset_high, offset_low, result, origin) +syscall sys_getdents nr 4283 nbargs 3 types: (unsigned int, struct linux_dirent *, unsigned int) args: (fd, dirent, count) +syscall sys_select nr 4285 nbargs 5 types: (int, fd_set *, fd_set *, fd_set *, struct timeval *) args: (n, inp, outp, exp, tvp) +syscall sys_flock nr 4287 nbargs 2 types: (unsigned int, unsigned int) args: (fd, cmd) +syscall sys_msync nr 4289 nbargs 3 types: (unsigned long, size_t, int) args: (start, len, flags) +syscall sys_readv nr 4291 nbargs 3 types: (unsigned long, const struct iovec *, unsigned long) args: (fd, vec, vlen) +syscall sys_writev nr 4293 nbargs 3 types: (unsigned long, const struct iovec *, unsigned long) args: (fd, vec, vlen) +syscall sys_cacheflush nr 4295 nbargs 3 types: (unsigned long, unsigned long, unsigned int) args: (addr, bytes, cache) +syscall sys_cachectl nr 4297 nbargs 3 types: (char *, int, int) args: (addr, nbytes, op) +syscall sys_getsid nr 4303 nbargs 1 types: (pid_t) args: (pid) +syscall sys_fdatasync nr 4305 nbargs 1 types: (unsigned int) args: (fd) +syscall sys_sysctl nr 4307 nbargs 1 types: (struct __sysctl_args *) args: (args) +syscall sys_mlock nr 4309 nbargs 2 types: (unsigned long, size_t) args: (start, len) +syscall sys_munlock nr 4311 nbargs 2 types: (unsigned long, size_t) args: (start, len) +syscall sys_mlockall nr 4313 nbargs 1 types: (int) args: (flags) +syscall sys_munlockall nr 4315 nbargs 0 types: () args: () +syscall sys_sched_setparam nr 4317 nbargs 2 types: (pid_t, struct sched_param *) args: (pid, param) +syscall sys_sched_getparam nr 4319 nbargs 2 types: (pid_t, struct sched_param *) args: (pid, param) +syscall sys_sched_setscheduler nr 4321 nbargs 3 types: (pid_t, int, struct sched_param *) args: (pid, policy, param) +syscall sys_sched_getscheduler nr 4323 nbargs 1 types: (pid_t) args: (pid) +syscall sys_sched_yield nr 4325 nbargs 0 types: () args: () +syscall sys_sched_get_priority_max nr 4327 nbargs 1 types: (int) args: (policy) +syscall sys_sched_get_priority_min nr 4329 nbargs 1 types: (int) args: (policy) +syscall sys_sched_rr_get_interval nr 4331 nbargs 2 types: (pid_t, struct timespec *) args: (pid, interval) +syscall sys_nanosleep nr 4333 nbargs 2 types: (struct timespec *, struct timespec *) args: (rqtp, rmtp) +syscall sys_mremap nr 4335 nbargs 5 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long) args: (addr, old_len, new_len, flags, new_addr) +syscall sys_accept nr 4337 nbargs 3 types: (int, struct sockaddr *, int *) args: (fd, upeer_sockaddr, upeer_addrlen) +syscall sys_bind nr 4339 nbargs 3 types: (int, struct sockaddr *, int) args: (fd, umyaddr, addrlen) +syscall sys_connect nr 4341 nbargs 3 types: (int, struct sockaddr *, int) args: (fd, uservaddr, addrlen) +syscall sys_getpeername nr 4343 nbargs 3 types: (int, struct sockaddr *, int *) args: (fd, usockaddr, usockaddr_len) +syscall sys_getsockname nr 4345 nbargs 3 types: (int, struct sockaddr *, int *) args: (fd, usockaddr, usockaddr_len) diff --git a/include/instrumentation/syscalls/3.5.0/mips-64-syscalls b/include/instrumentation/syscalls/3.5.0/mips-64-syscalls new file mode 100644 index 00000000..7753e06e --- /dev/null +++ b/include/instrumentation/syscalls/3.5.0/mips-64-syscalls @@ -0,0 +1,289 @@ +syscall sys_waitpid nr 4007 nbargs 3 types: (pid_t, int *, int) args: (pid, stat_addr, options) +syscall sys_oldumount nr 4022 nbargs 1 types: (char *) args: (name) +syscall sys_nice nr 4034 nbargs 1 types: (int) args: (increment) +syscall sys_olduname nr 4059 nbargs 1 types: (struct oldold_utsname *) args: (name) +syscall sys_32_sigaction nr 4067 nbargs 3 types: (long, const struct sigaction32 *, struct sigaction32 *) args: (sig, act, oact) +syscall sys_sgetmask nr 4068 nbargs 0 types: () args: () +syscall sys_ssetmask nr 4069 nbargs 1 types: (int) args: (newmask) +syscall sys_uselib nr 4086 nbargs 1 types: (const char *) args: (library) +syscall sys_uname nr 4109 nbargs 1 types: (struct old_utsname *) args: (name) +syscall sys_32_ipc nr 4117 nbargs 6 types: (u32, long, long, long, unsigned long, unsigned long) args: (call, first, second, third, ptr, fifth) +syscall sys_bdflush nr 4134 nbargs 2 types: (int, long) args: (func, data) +syscall sys_32_llseek nr 4140 nbargs 5 types: (unsigned int, unsigned int, unsigned int, loff_t *, unsigned int) args: (fd, offset_high, offset_low, result, origin) +syscall sys_send nr 4178 nbargs 4 types: (int, void *, size_t, unsigned int) args: (fd, buff, len, flags) +syscall sys_32_pread nr 4200 nbargs 6 types: (unsigned long, char *, size_t, unsigned long, unsigned long, unsigned long) args: (fd, buf, count, unused, a4, a5) +syscall sys_32_pwrite nr 4201 nbargs 6 types: (unsigned int, const char *, size_t, u32, u64, u64) args: (fd, buf, count, unused, a4, a5) +syscall sys_mips_mmap2 nr 4210 nbargs 6 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long, unsigned long) args: (addr, len, prot, flags, fd, pgoff) +syscall sys_32_truncate64 nr 4211 nbargs 4 types: (const char *, unsigned long, unsigned long, unsigned long) args: (path, __dummy, a2, a3) +syscall sys_32_ftruncate64 nr 4212 nbargs 4 types: (unsigned long, unsigned long, unsigned long, unsigned long) args: (fd, __dummy, a2, a3) +syscall sys_32_waitid nr 4278 nbargs 5 types: (int, compat_pid_t, compat_siginfo_t *, int, struct compat_rusage *) args: (which, pid, uinfo, options, uru) +syscall sys_32_fanotify_mark nr 4337 nbargs 6 types: (int, unsigned int, u64, u64, int, const char *) args: (fanotify_fd, flags, a3, a4, dfd, pathname) +syscall sys_rt_sigaction nr 5013 nbargs 4 types: (int, const struct sigaction *, struct sigaction *, size_t) args: (sig, act, oact, sigsetsize) +syscall sys_rt_sigprocmask nr 5014 nbargs 4 types: (int, sigset_t *, sigset_t *, size_t) args: (how, nset, oset, sigsetsize) +syscall sys_ioctl nr 5015 nbargs 3 types: (unsigned int, unsigned int, unsigned long) args: (fd, cmd, arg) +syscall sys_readv nr 5018 nbargs 3 types: (unsigned long, const struct iovec *, unsigned long) args: (fd, vec, vlen) +syscall sys_writev nr 5019 nbargs 3 types: (unsigned long, const struct iovec *, unsigned long) args: (fd, vec, vlen) +syscall sys_select nr 5022 nbargs 5 types: (int, fd_set *, fd_set *, fd_set *, struct timeval *) args: (n, inp, outp, exp, tvp) +syscall sys_shmctl nr 5030 nbargs 3 types: (int, int, struct shmid_ds *) args: (shmid, cmd, buf) +syscall sys_nanosleep nr 5034 nbargs 2 types: (struct timespec *, struct timespec *) args: (rqtp, rmtp) +syscall sys_getitimer nr 5035 nbargs 2 types: (int, struct itimerval *) args: (which, value) +syscall sys_setitimer nr 5036 nbargs 3 types: (int, struct itimerval *, struct itimerval *) args: (which, value, ovalue) +syscall sys_recvfrom nr 5044 nbargs 6 types: (int, void *, size_t, unsigned int, struct sockaddr *, int *) args: (fd, ubuf, size, flags, addr, addr_len) +syscall sys_sendmsg nr 5045 nbargs 3 types: (int, struct msghdr *, unsigned int) args: (fd, msg, flags) +syscall sys_recvmsg nr 5046 nbargs 3 types: (int, struct msghdr *, unsigned int) args: (fd, msg, flags) +syscall sys_setsockopt nr 5053 nbargs 5 types: (int, int, int, char *, int) args: (fd, level, optname, optval, optlen) +syscall sys_wait4 nr 5059 nbargs 4 types: (pid_t, int *, int, struct rusage *) args: (upid, stat_addr, options, ru) +syscall sys_msgsnd nr 5067 nbargs 4 types: (int, struct msgbuf *, size_t, int) args: (msqid, msgp, msgsz, msgflg) +syscall sys_msgrcv nr 5068 nbargs 5 types: (int, struct msgbuf *, size_t, long, int) args: (msqid, msgp, msgsz, msgtyp, msgflg) +syscall sys_msgctl nr 5069 nbargs 3 types: (int, int, struct msqid_ds *) args: (msqid, cmd, buf) +syscall sys_fcntl nr 5070 nbargs 3 types: (unsigned int, unsigned int, unsigned long) args: (fd, cmd, arg) +syscall sys_getdents nr 5076 nbargs 3 types: (unsigned int, struct linux_dirent *, unsigned int) args: (fd, dirent, count) +syscall sys_gettimeofday nr 5094 nbargs 2 types: (struct timeval *, struct timezone *) args: (tv, tz) +syscall sys_getrlimit nr 5095 nbargs 2 types: (unsigned int, struct rlimit *) args: (resource, rlim) +syscall sys_getrusage nr 5096 nbargs 2 types: (int, struct rusage *) args: (who, ru) +syscall sys_sysinfo nr 5097 nbargs 1 types: (struct sysinfo *) args: (info) +syscall sys_times nr 5098 nbargs 1 types: (struct tms *) args: (tbuf) +syscall sys_ptrace nr 5099 nbargs 4 types: (long, long, unsigned long, unsigned long) args: (request, pid, addr, data) +syscall sys_rt_sigpending nr 5125 nbargs 2 types: (sigset_t *, size_t) args: (set, sigsetsize) +syscall sys_rt_sigtimedwait nr 5126 nbargs 4 types: (const sigset_t *, siginfo_t *, const struct timespec *, size_t) args: (uthese, uinfo, uts, sigsetsize) +syscall sys_rt_sigqueueinfo nr 5127 nbargs 3 types: (pid_t, int, siginfo_t *) args: (pid, sig, uinfo) +syscall sys_utime nr 5130 nbargs 2 types: (char *, struct utimbuf *) args: (filename, times) +syscall sys_personality nr 5132 nbargs 1 types: (unsigned int) args: (personality) +syscall sys_ustat nr 5133 nbargs 2 types: (unsigned, struct ustat *) args: (dev, ubuf) +syscall sys_statfs nr 5134 nbargs 2 types: (const char *, struct statfs *) args: (pathname, buf) +syscall sys_fstatfs nr 5135 nbargs 2 types: (unsigned int, struct statfs *) args: (fd, buf) +syscall sys_sched_rr_get_interval nr 5145 nbargs 2 types: (pid_t, struct timespec *) args: (pid, interval) +syscall sys_sysctl nr 5152 nbargs 1 types: (struct __sysctl_args *) args: (args) +syscall sys_adjtimex nr 5154 nbargs 1 types: (struct timex *) args: (txc_p) +syscall sys_setrlimit nr 5155 nbargs 2 types: (unsigned int, struct rlimit *) args: (resource, rlim) +syscall sys_settimeofday nr 5159 nbargs 2 types: (struct timeval *, struct timezone *) args: (tv, tz) +syscall sys_mount nr 5160 nbargs 5 types: (char *, char *, char *, unsigned long, void *) args: (dev_name, dir_name, type, flags, data) +syscall sys_futex nr 5194 nbargs 6 types: (u32 *, int, u32, struct timespec *, u32 *, u32) args: (uaddr, op, val, utime, uaddr2, val3) +syscall sys_sched_setaffinity nr 5195 nbargs 3 types: (pid_t, unsigned int, unsigned long *) args: (pid, len, user_mask_ptr) +syscall sys_sched_getaffinity nr 5196 nbargs 3 types: (pid_t, unsigned int, unsigned long *) args: (pid, len, user_mask_ptr) +syscall sys_io_setup nr 5200 nbargs 2 types: (unsigned, aio_context_t *) args: (nr_events, ctxp) +syscall sys_io_getevents nr 5202 nbargs 5 types: (aio_context_t, long, long, struct io_event *, struct timespec *) args: (ctx_id, min_nr, nr, events, timeout) +syscall sys_io_submit nr 5203 nbargs 3 types: (aio_context_t, long, struct iocb * *) args: (ctx_id, nr, iocbpp) +syscall sys_semtimedop nr 5214 nbargs 4 types: (int, struct sembuf *, unsigned, const struct timespec *) args: (semid, tsops, nsops, timeout) +syscall sys_timer_create nr 5216 nbargs 3 types: (const clockid_t, struct sigevent *, timer_t *) args: (which_clock, timer_event_spec, created_timer_id) +syscall sys_timer_settime nr 5217 nbargs 4 types: (timer_t, int, const struct itimerspec *, struct itimerspec *) args: (timer_id, flags, new_setting, old_setting) +syscall sys_timer_gettime nr 5218 nbargs 2 types: (timer_t, struct itimerspec *) args: (timer_id, setting) +syscall sys_clock_settime nr 5221 nbargs 2 types: (const clockid_t, const struct timespec *) args: (which_clock, tp) +syscall sys_clock_gettime nr 5222 nbargs 2 types: (const clockid_t, struct timespec *) args: (which_clock, tp) +syscall sys_clock_getres nr 5223 nbargs 2 types: (const clockid_t, struct timespec *) args: (which_clock, tp) +syscall sys_clock_nanosleep nr 5224 nbargs 4 types: (const clockid_t, int, const struct timespec *, struct timespec *) args: (which_clock, flags, rqtp, rmtp) +syscall sys_utimes nr 5226 nbargs 2 types: (char *, struct timeval *) args: (filename, utimes) +syscall sys_waitid nr 5237 nbargs 5 types: (int, pid_t, struct siginfo *, int, struct rusage *) args: (which, upid, infop, options, ru) +syscall sys_futimesat nr 5251 nbargs 3 types: (int, const char *, struct timeval *) args: (dfd, filename, utimes) +syscall sys_pselect6 nr 5260 nbargs 6 types: (int, fd_set *, fd_set *, fd_set *, struct timespec *, void *) args: (n, inp, outp, exp, tsp, sig) +syscall sys_ppoll nr 5261 nbargs 5 types: (struct pollfd *, unsigned int, struct timespec *, const sigset_t *, size_t) args: (ufds, nfds, tsp, sigmask, sigsetsize) +syscall sys_vmsplice nr 5266 nbargs 4 types: (int, const struct iovec *, unsigned long, unsigned int) args: (fd, iov, nr_segs, flags) +syscall sys_set_robust_list nr 5268 nbargs 2 types: (struct robust_list_head *, size_t) args: (head, len) +syscall sys_get_robust_list nr 5269 nbargs 3 types: (int, struct robust_list_head * *, size_t *) args: (pid, head_ptr, len_ptr) +syscall sys_epoll_pwait nr 5272 nbargs 6 types: (int, struct epoll_event *, int, int, const sigset_t *, size_t) args: (epfd, events, maxevents, timeout, sigmask, sigsetsize) +syscall sys_utimensat nr 5275 nbargs 4 types: (int, const char *, struct timespec *, int) args: (dfd, filename, utimes, flags) +syscall sys_signalfd nr 5276 nbargs 3 types: (int, sigset_t *, size_t) args: (ufd, user_mask, sizemask) +syscall sys_timerfd_gettime nr 5281 nbargs 2 types: (int, struct itimerspec *) args: (ufd, otmr) +syscall sys_timerfd_settime nr 5282 nbargs 4 types: (int, int, const struct itimerspec *, struct itimerspec *) args: (ufd, flags, utmr, otmr) +syscall sys_rt_tgsigqueueinfo nr 5291 nbargs 4 types: (pid_t, pid_t, int, siginfo_t *) args: (tgid, pid, sig, uinfo) +syscall sys_recvmmsg nr 5294 nbargs 5 types: (int, struct mmsghdr *, unsigned int, unsigned int, struct timespec *) args: (fd, mmsg, vlen, flags, timeout) +syscall sys_clock_adjtime nr 5300 nbargs 2 types: (const clockid_t, struct timex *) args: (which_clock, utx) +syscall sys_sendmmsg nr 5302 nbargs 4 types: (int, struct mmsghdr *, unsigned int, unsigned int) args: (fd, mmsg, vlen, flags) +syscall sys_process_vm_readv nr 5304 nbargs 6 types: (pid_t, const struct iovec *, unsigned long, const struct iovec *, unsigned long, unsigned long) args: (pid, lvec, liovcnt, rvec, riovcnt, flags) +syscall sys_process_vm_writev nr 5305 nbargs 6 types: (pid_t, const struct iovec *, unsigned long, const struct iovec *, unsigned long, unsigned long) args: (pid, lvec, liovcnt, rvec, riovcnt, flags) +syscall sys_read nr 6000 nbargs 3 types: (unsigned int, char *, size_t) args: (fd, buf, count) +syscall sys_write nr 6001 nbargs 3 types: (unsigned int, const char *, size_t) args: (fd, buf, count) +syscall sys_open nr 6002 nbargs 3 types: (const char *, int, umode_t) args: (filename, flags, mode) +syscall sys_close nr 6003 nbargs 1 types: (unsigned int) args: (fd) +syscall sys_newstat nr 6004 nbargs 2 types: (const char *, struct stat *) args: (filename, statbuf) +syscall sys_newfstat nr 6005 nbargs 2 types: (unsigned int, struct stat *) args: (fd, statbuf) +syscall sys_newlstat nr 6006 nbargs 2 types: (const char *, struct stat *) args: (filename, statbuf) +syscall sys_poll nr 6007 nbargs 3 types: (struct pollfd *, unsigned int, int) args: (ufds, nfds, timeout_msecs) +syscall sys_lseek nr 6008 nbargs 3 types: (unsigned int, off_t, unsigned int) args: (fd, offset, origin) +syscall sys_mips_mmap nr 6009 nbargs 6 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long, off_t) args: (addr, len, prot, flags, fd, offset) +syscall sys_mprotect nr 6010 nbargs 3 types: (unsigned long, size_t, unsigned long) args: (start, len, prot) +syscall sys_munmap nr 6011 nbargs 2 types: (unsigned long, size_t) args: (addr, len) +syscall sys_brk nr 6012 nbargs 1 types: (unsigned long) args: (brk) +syscall sys_32_rt_sigaction nr 6013 nbargs 4 types: (int, const struct sigaction32 *, struct sigaction32 *, unsigned int) args: (sig, act, oact, sigsetsize) +syscall sys_32_rt_sigprocmask nr 6014 nbargs 4 types: (int, compat_sigset_t *, compat_sigset_t *, unsigned int) args: (how, set, oset, sigsetsize) +syscall sys_access nr 6020 nbargs 2 types: (const char *, int) args: (filename, mode) +syscall sys_sched_yield nr 6023 nbargs 0 types: () args: () +syscall sys_mremap nr 6024 nbargs 5 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long) args: (addr, old_len, new_len, flags, new_addr) +syscall sys_msync nr 6025 nbargs 3 types: (unsigned long, size_t, int) args: (start, len, flags) +syscall sys_mincore nr 6026 nbargs 3 types: (unsigned long, size_t, unsigned char *) args: (start, len, vec) +syscall sys_madvise nr 6027 nbargs 3 types: (unsigned long, size_t, int) args: (start, len_in, behavior) +syscall sys_shmget nr 6028 nbargs 3 types: (key_t, size_t, int) args: (key, size, shmflg) +syscall sys_shmat nr 6029 nbargs 3 types: (int, char *, int) args: (shmid, shmaddr, shmflg) +syscall sys_dup nr 6031 nbargs 1 types: (unsigned int) args: (fildes) +syscall sys_dup2 nr 6032 nbargs 2 types: (unsigned int, unsigned int) args: (oldfd, newfd) +syscall sys_pause nr 6033 nbargs 0 types: () args: () +syscall sys_alarm nr 6037 nbargs 1 types: (unsigned int) args: (seconds) +syscall sys_getpid nr 6038 nbargs 0 types: () args: () +syscall sys_32_sendfile nr 6039 nbargs 4 types: (long, long, compat_off_t *, s32) args: (out_fd, in_fd, offset, count) +syscall sys_socket nr 6040 nbargs 3 types: (int, int, int) args: (family, type, protocol) +syscall sys_connect nr 6041 nbargs 3 types: (int, struct sockaddr *, int) args: (fd, uservaddr, addrlen) +syscall sys_accept nr 6042 nbargs 3 types: (int, struct sockaddr *, int *) args: (fd, upeer_sockaddr, upeer_addrlen) +syscall sys_sendto nr 6043 nbargs 6 types: (int, void *, size_t, unsigned int, struct sockaddr *, int) args: (fd, buff, len, flags, addr, addr_len) +syscall sys_shutdown nr 6047 nbargs 2 types: (int, int) args: (fd, how) +syscall sys_bind nr 6048 nbargs 3 types: (int, struct sockaddr *, int) args: (fd, umyaddr, addrlen) +syscall sys_listen nr 6049 nbargs 2 types: (int, int) args: (fd, backlog) +syscall sys_getsockname nr 6050 nbargs 3 types: (int, struct sockaddr *, int *) args: (fd, usockaddr, usockaddr_len) +syscall sys_getpeername nr 6051 nbargs 3 types: (int, struct sockaddr *, int *) args: (fd, usockaddr, usockaddr_len) +syscall sys_socketpair nr 6052 nbargs 4 types: (int, int, int, int *) args: (family, type, protocol, usockvec) +syscall sys_getsockopt nr 6054 nbargs 5 types: (int, int, int, char *, int *) args: (fd, level, optname, optval, optlen) +syscall sys_exit nr 6058 nbargs 1 types: (int) args: (error_code) +syscall sys_kill nr 6060 nbargs 2 types: (pid_t, int) args: (pid, sig) +syscall sys_newuname nr 6061 nbargs 1 types: (struct new_utsname *) args: (name) +syscall sys_semget nr 6062 nbargs 3 types: (key_t, int, int) args: (key, nsems, semflg) +syscall sys_semop nr 6063 nbargs 3 types: (int, struct sembuf *, unsigned) args: (semid, tsops, nsops) +syscall sys_n32_semctl nr 6064 nbargs 4 types: (int, int, int, u32) args: (semid, semnum, cmd, arg) +syscall sys_shmdt nr 6065 nbargs 1 types: (char *) args: (shmaddr) +syscall sys_msgget nr 6066 nbargs 2 types: (key_t, int) args: (key, msgflg) +syscall sys_n32_msgsnd nr 6067 nbargs 4 types: (int, u32, unsigned int, int) args: (msqid, msgp, msgsz, msgflg) +syscall sys_n32_msgrcv nr 6068 nbargs 5 types: (int, u32, size_t, int, int) args: (msqid, msgp, msgsz, msgtyp, msgflg) +syscall sys_flock nr 6071 nbargs 2 types: (unsigned int, unsigned int) args: (fd, cmd) +syscall sys_fsync nr 6072 nbargs 1 types: (unsigned int) args: (fd) +syscall sys_fdatasync nr 6073 nbargs 1 types: (unsigned int) args: (fd) +syscall sys_truncate nr 6074 nbargs 2 types: (const char *, long) args: (path, length) +syscall sys_ftruncate nr 6075 nbargs 2 types: (unsigned int, unsigned long) args: (fd, length) +syscall sys_getcwd nr 6077 nbargs 2 types: (char *, unsigned long) args: (buf, size) +syscall sys_chdir nr 6078 nbargs 1 types: (const char *) args: (filename) +syscall sys_fchdir nr 6079 nbargs 1 types: (unsigned int) args: (fd) +syscall sys_rename nr 6080 nbargs 2 types: (const char *, const char *) args: (oldname, newname) +syscall sys_mkdir nr 6081 nbargs 2 types: (const char *, umode_t) args: (pathname, mode) +syscall sys_rmdir nr 6082 nbargs 1 types: (const char *) args: (pathname) +syscall sys_creat nr 6083 nbargs 2 types: (const char *, umode_t) args: (pathname, mode) +syscall sys_link nr 6084 nbargs 2 types: (const char *, const char *) args: (oldname, newname) +syscall sys_unlink nr 6085 nbargs 1 types: (const char *) args: (pathname) +syscall sys_symlink nr 6086 nbargs 2 types: (const char *, const char *) args: (oldname, newname) +syscall sys_readlink nr 6087 nbargs 3 types: (const char *, char *, int) args: (path, buf, bufsiz) +syscall sys_chmod nr 6088 nbargs 2 types: (const char *, umode_t) args: (filename, mode) +syscall sys_fchmod nr 6089 nbargs 2 types: (unsigned int, umode_t) args: (fd, mode) +syscall sys_chown nr 6090 nbargs 3 types: (const char *, uid_t, gid_t) args: (filename, user, group) +syscall sys_fchown nr 6091 nbargs 3 types: (unsigned int, uid_t, gid_t) args: (fd, user, group) +syscall sys_lchown nr 6092 nbargs 3 types: (const char *, uid_t, gid_t) args: (filename, user, group) +syscall sys_umask nr 6093 nbargs 1 types: (int) args: (mask) +syscall sys_getuid nr 6100 nbargs 0 types: () args: () +syscall sys_syslog nr 6101 nbargs 3 types: (int, char *, int) args: (type, buf, len) +syscall sys_getgid nr 6102 nbargs 0 types: () args: () +syscall sys_setuid nr 6103 nbargs 1 types: (uid_t) args: (uid) +syscall sys_setgid nr 6104 nbargs 1 types: (gid_t) args: (gid) +syscall sys_geteuid nr 6105 nbargs 0 types: () args: () +syscall sys_getegid nr 6106 nbargs 0 types: () args: () +syscall sys_setpgid nr 6107 nbargs 2 types: (pid_t, pid_t) args: (pid, pgid) +syscall sys_getppid nr 6108 nbargs 0 types: () args: () +syscall sys_getpgrp nr 6109 nbargs 0 types: () args: () +syscall sys_setsid nr 6110 nbargs 0 types: () args: () +syscall sys_setreuid nr 6111 nbargs 2 types: (uid_t, uid_t) args: (ruid, euid) +syscall sys_setregid nr 6112 nbargs 2 types: (gid_t, gid_t) args: (rgid, egid) +syscall sys_getgroups nr 6113 nbargs 2 types: (int, gid_t *) args: (gidsetsize, grouplist) +syscall sys_setgroups nr 6114 nbargs 2 types: (int, gid_t *) args: (gidsetsize, grouplist) +syscall sys_setresuid nr 6115 nbargs 3 types: (uid_t, uid_t, uid_t) args: (ruid, euid, suid) +syscall sys_getresuid nr 6116 nbargs 3 types: (uid_t *, uid_t *, uid_t *) args: (ruidp, euidp, suidp) +syscall sys_setresgid nr 6117 nbargs 3 types: (gid_t, gid_t, gid_t) args: (rgid, egid, sgid) +syscall sys_getresgid nr 6118 nbargs 3 types: (gid_t *, gid_t *, gid_t *) args: (rgidp, egidp, sgidp) +syscall sys_getpgid nr 6119 nbargs 1 types: (pid_t) args: (pid) +syscall sys_setfsuid nr 6120 nbargs 1 types: (uid_t) args: (uid) +syscall sys_setfsgid nr 6121 nbargs 1 types: (gid_t) args: (gid) +syscall sys_getsid nr 6122 nbargs 1 types: (pid_t) args: (pid) +syscall sys_capget nr 6123 nbargs 2 types: (cap_user_header_t, cap_user_data_t) args: (header, dataptr) +syscall sys_capset nr 6124 nbargs 2 types: (cap_user_header_t, const cap_user_data_t) args: (header, data) +syscall sys_32_rt_sigpending nr 6125 nbargs 2 types: (compat_sigset_t *, unsigned int) args: (uset, sigsetsize) +syscall sys_32_rt_sigqueueinfo nr 6127 nbargs 3 types: (int, int, compat_siginfo_t *) args: (pid, sig, uinfo) +syscall sys_mknod nr 6131 nbargs 3 types: (const char *, umode_t, unsigned) args: (filename, mode, dev) +syscall sys_32_personality nr 6132 nbargs 1 types: (unsigned long) args: (personality) +syscall sys_sysfs nr 6136 nbargs 3 types: (int, unsigned long, unsigned long) args: (option, arg1, arg2) +syscall sys_getpriority nr 6137 nbargs 2 types: (int, int) args: (which, who) +syscall sys_setpriority nr 6138 nbargs 3 types: (int, int, int) args: (which, who, niceval) +syscall sys_sched_setparam nr 6139 nbargs 2 types: (pid_t, struct sched_param *) args: (pid, param) +syscall sys_sched_getparam nr 6140 nbargs 2 types: (pid_t, struct sched_param *) args: (pid, param) +syscall sys_sched_setscheduler nr 6141 nbargs 3 types: (pid_t, int, struct sched_param *) args: (pid, policy, param) +syscall sys_sched_getscheduler nr 6142 nbargs 1 types: (pid_t) args: (pid) +syscall sys_sched_get_priority_max nr 6143 nbargs 1 types: (int) args: (policy) +syscall sys_sched_get_priority_min nr 6144 nbargs 1 types: (int) args: (policy) +syscall sys_32_sched_rr_get_interval nr 6145 nbargs 2 types: (compat_pid_t, struct compat_timespec *) args: (pid, interval) +syscall sys_mlock nr 6146 nbargs 2 types: (unsigned long, size_t) args: (start, len) +syscall sys_munlock nr 6147 nbargs 2 types: (unsigned long, size_t) args: (start, len) +syscall sys_mlockall nr 6148 nbargs 1 types: (int) args: (flags) +syscall sys_munlockall nr 6149 nbargs 0 types: () args: () +syscall sys_vhangup nr 6150 nbargs 0 types: () args: () +syscall sys_pivot_root nr 6151 nbargs 2 types: (const char *, const char *) args: (new_root, put_old) +syscall sys_prctl nr 6153 nbargs 5 types: (int, unsigned long, unsigned long, unsigned long, unsigned long) args: (option, arg2, arg3, arg4, arg5) +syscall sys_chroot nr 6156 nbargs 1 types: (const char *) args: (filename) +syscall sys_sync nr 6157 nbargs 0 types: () args: () +syscall sys_umount nr 6161 nbargs 2 types: (char *, int) args: (name, flags) +syscall sys_swapon nr 6162 nbargs 2 types: (const char *, int) args: (specialfile, swap_flags) +syscall sys_swapoff nr 6163 nbargs 1 types: (const char *) args: (specialfile) +syscall sys_reboot nr 6164 nbargs 4 types: (int, int, unsigned int, void *) args: (magic1, magic2, cmd, arg) +syscall sys_sethostname nr 6165 nbargs 2 types: (char *, int) args: (name, len) +syscall sys_setdomainname nr 6166 nbargs 2 types: (char *, int) args: (name, len) +syscall sys_init_module nr 6168 nbargs 3 types: (void *, unsigned long, const char *) args: (umod, len, uargs) +syscall sys_delete_module nr 6169 nbargs 2 types: (const char *, unsigned int) args: (name_user, flags) +syscall sys_quotactl nr 6172 nbargs 4 types: (unsigned int, const char *, qid_t, void *) args: (cmd, special, id, addr) +syscall sys_gettid nr 6178 nbargs 0 types: () args: () +syscall sys_setxattr nr 6180 nbargs 5 types: (const char *, const char *, const void *, size_t, int) args: (pathname, name, value, size, flags) +syscall sys_lsetxattr nr 6181 nbargs 5 types: (const char *, const char *, const void *, size_t, int) args: (pathname, name, value, size, flags) +syscall sys_fsetxattr nr 6182 nbargs 5 types: (int, const char *, const void *, size_t, int) args: (fd, name, value, size, flags) +syscall sys_getxattr nr 6183 nbargs 4 types: (const char *, const char *, void *, size_t) args: (pathname, name, value, size) +syscall sys_lgetxattr nr 6184 nbargs 4 types: (const char *, const char *, void *, size_t) args: (pathname, name, value, size) +syscall sys_fgetxattr nr 6185 nbargs 4 types: (int, const char *, void *, size_t) args: (fd, name, value, size) +syscall sys_listxattr nr 6186 nbargs 3 types: (const char *, char *, size_t) args: (pathname, list, size) +syscall sys_llistxattr nr 6187 nbargs 3 types: (const char *, char *, size_t) args: (pathname, list, size) +syscall sys_flistxattr nr 6188 nbargs 3 types: (int, char *, size_t) args: (fd, list, size) +syscall sys_removexattr nr 6189 nbargs 2 types: (const char *, const char *) args: (pathname, name) +syscall sys_lremovexattr nr 6190 nbargs 2 types: (const char *, const char *) args: (pathname, name) +syscall sys_fremovexattr nr 6191 nbargs 2 types: (int, const char *) args: (fd, name) +syscall sys_tkill nr 6192 nbargs 2 types: (pid_t, int) args: (pid, sig) +syscall sys_32_futex nr 6194 nbargs 6 types: (u32 *, int, u32, struct compat_timespec *, u32 *, u32) args: (uaddr, op, val, utime, uaddr2, val3) +syscall sys_cacheflush nr 6197 nbargs 3 types: (unsigned long, unsigned long, unsigned int) args: (addr, bytes, cache) +syscall sys_cachectl nr 6198 nbargs 3 types: (char *, int, int) args: (addr, nbytes, op) +syscall sys_io_destroy nr 6201 nbargs 1 types: (aio_context_t) args: (ctx) +syscall sys_io_cancel nr 6204 nbargs 3 types: (aio_context_t, struct iocb *, struct io_event *) args: (ctx_id, iocb, result) +syscall sys_exit_group nr 6205 nbargs 1 types: (int) args: (error_code) +syscall sys_epoll_create nr 6207 nbargs 1 types: (int) args: (size) +syscall sys_epoll_ctl nr 6208 nbargs 4 types: (int, int, int, struct epoll_event *) args: (epfd, op, fd, event) +syscall sys_epoll_wait nr 6209 nbargs 4 types: (int, struct epoll_event *, int, int) args: (epfd, events, maxevents, timeout) +syscall sys_remap_file_pages nr 6210 nbargs 5 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long) args: (start, size, prot, pgoff, flags) +syscall sys_set_tid_address nr 6213 nbargs 1 types: (int *) args: (tidptr) +syscall sys_restart_syscall nr 6214 nbargs 0 types: () args: () +syscall sys_sendfile64 nr 6219 nbargs 4 types: (int, int, loff_t *, size_t) args: (out_fd, in_fd, offset, count) +syscall sys_timer_getoverrun nr 6223 nbargs 1 types: (timer_t) args: (timer_id) +syscall sys_timer_delete nr 6224 nbargs 1 types: (timer_t) args: (timer_id) +syscall sys_tgkill nr 6229 nbargs 3 types: (pid_t, pid_t, int) args: (tgid, pid, sig) +syscall sys_set_thread_area nr 6246 nbargs 1 types: (unsigned long) args: (addr) +syscall sys_inotify_init nr 6247 nbargs 0 types: () args: () +syscall sys_inotify_add_watch nr 6248 nbargs 3 types: (int, const char *, u32) args: (fd, pathname, mask) +syscall sys_inotify_rm_watch nr 6249 nbargs 2 types: (int, __s32) args: (fd, wd) +syscall sys_openat nr 6251 nbargs 4 types: (int, const char *, int, umode_t) args: (dfd, filename, flags, mode) +syscall sys_mkdirat nr 6252 nbargs 3 types: (int, const char *, umode_t) args: (dfd, pathname, mode) +syscall sys_mknodat nr 6253 nbargs 4 types: (int, const char *, umode_t, unsigned) args: (dfd, filename, mode, dev) +syscall sys_fchownat nr 6254 nbargs 5 types: (int, const char *, uid_t, gid_t, int) args: (dfd, filename, user, group, flag) +syscall sys_newfstatat nr 6256 nbargs 4 types: (int, const char *, struct stat *, int) args: (dfd, filename, statbuf, flag) +syscall sys_unlinkat nr 6257 nbargs 3 types: (int, const char *, int) args: (dfd, pathname, flag) +syscall sys_renameat nr 6258 nbargs 4 types: (int, const char *, int, const char *) args: (olddfd, oldname, newdfd, newname) +syscall sys_linkat nr 6259 nbargs 5 types: (int, const char *, int, const char *, int) args: (olddfd, oldname, newdfd, newname, flags) +syscall sys_symlinkat nr 6260 nbargs 3 types: (const char *, int, const char *) args: (oldname, newdfd, newname) +syscall sys_readlinkat nr 6261 nbargs 4 types: (int, const char *, char *, int) args: (dfd, pathname, buf, bufsiz) +syscall sys_fchmodat nr 6262 nbargs 3 types: (int, const char *, umode_t) args: (dfd, filename, mode) +syscall sys_faccessat nr 6263 nbargs 3 types: (int, const char *, int) args: (dfd, filename, mode) +syscall sys_unshare nr 6266 nbargs 1 types: (unsigned long) args: (unshare_flags) +syscall sys_splice nr 6267 nbargs 6 types: (int, loff_t *, int, loff_t *, size_t, unsigned int) args: (fd_in, off_in, fd_out, off_out, len, flags) +syscall sys_tee nr 6269 nbargs 4 types: (int, int, size_t, unsigned int) args: (fdin, fdout, len, flags) +syscall sys_getcpu nr 6275 nbargs 3 types: (unsigned *, unsigned *, struct getcpu_cache *) args: (cpup, nodep, unused) +syscall sys_ioprio_set nr 6277 nbargs 3 types: (int, int, int) args: (which, who, ioprio) +syscall sys_ioprio_get nr 6278 nbargs 2 types: (int, int) args: (which, who) +syscall sys_eventfd nr 6282 nbargs 1 types: (unsigned int) args: (count) +syscall sys_timerfd_create nr 6284 nbargs 2 types: (int, int) args: (clockid, flags) +syscall sys_signalfd4 nr 6287 nbargs 4 types: (int, sigset_t *, size_t, int) args: (ufd, user_mask, sizemask, flags) +syscall sys_eventfd2 nr 6288 nbargs 2 types: (unsigned int, int) args: (count, flags) +syscall sys_epoll_create1 nr 6289 nbargs 1 types: (int) args: (flags) +syscall sys_dup3 nr 6290 nbargs 3 types: (unsigned int, unsigned int, int) args: (oldfd, newfd, flags) +syscall sys_pipe2 nr 6291 nbargs 2 types: (int *, int) args: (fildes, flags) +syscall sys_inotify_init1 nr 6292 nbargs 1 types: (int) args: (flags) +syscall sys_preadv nr 6293 nbargs 5 types: (unsigned long, const struct iovec *, unsigned long, unsigned long, unsigned long) args: (fd, vec, vlen, pos_l, pos_h) +syscall sys_pwritev nr 6294 nbargs 5 types: (unsigned long, const struct iovec *, unsigned long, unsigned long, unsigned long) args: (fd, vec, vlen, pos_l, pos_h) +syscall sys_accept4 nr 6297 nbargs 4 types: (int, struct sockaddr *, int *, int) args: (fd, upeer_sockaddr, upeer_addrlen, flags) +syscall sys_getdents64 nr 6299 nbargs 3 types: (unsigned int, struct linux_dirent64 *, unsigned int) args: (fd, dirent, count) +syscall sys_prlimit64 nr 6302 nbargs 4 types: (pid_t, unsigned int, const struct rlimit64 *, struct rlimit64 *) args: (pid, resource, new_rlim, old_rlim) +syscall sys_syncfs nr 6306 nbargs 1 types: (int) args: (fd) +syscall sys_setns nr 6308 nbargs 2 types: (int, int) args: (fd, nstype) diff --git a/include/instrumentation/syscalls/4.4.0/arm-64-syscalls b/include/instrumentation/syscalls/4.4.0/arm-64-syscalls new file mode 100644 index 00000000..99360cee --- /dev/null +++ b/include/instrumentation/syscalls/4.4.0/arm-64-syscalls @@ -0,0 +1,256 @@ +syscall sys_io_setup nr 0 nbargs 2 types: (unsigned, aio_context_t *) args: (nr_events, ctxp) +syscall sys_io_destroy nr 1 nbargs 1 types: (aio_context_t) args: (ctx) +syscall sys_io_submit nr 2 nbargs 3 types: (aio_context_t, long, struct iocb * *) args: (ctx_id, nr, iocbpp) +syscall sys_io_cancel nr 3 nbargs 3 types: (aio_context_t, struct iocb *, struct io_event *) args: (ctx_id, iocb, result) +syscall sys_io_getevents nr 4 nbargs 5 types: (aio_context_t, long, long, struct io_event *, struct timespec *) args: (ctx_id, min_nr, nr, events, timeout) +syscall sys_setxattr nr 5 nbargs 5 types: (const char *, const char *, const void *, size_t, int) args: (pathname, name, value, size, flags) +syscall sys_lsetxattr nr 6 nbargs 5 types: (const char *, const char *, const void *, size_t, int) args: (pathname, name, value, size, flags) +syscall sys_fsetxattr nr 7 nbargs 5 types: (int, const char *, const void *, size_t, int) args: (fd, name, value, size, flags) +syscall sys_getxattr nr 8 nbargs 4 types: (const char *, const char *, void *, size_t) args: (pathname, name, value, size) +syscall sys_lgetxattr nr 9 nbargs 4 types: (const char *, const char *, void *, size_t) args: (pathname, name, value, size) +syscall sys_fgetxattr nr 10 nbargs 4 types: (int, const char *, void *, size_t) args: (fd, name, value, size) +syscall sys_listxattr nr 11 nbargs 3 types: (const char *, char *, size_t) args: (pathname, list, size) +syscall sys_llistxattr nr 12 nbargs 3 types: (const char *, char *, size_t) args: (pathname, list, size) +syscall sys_flistxattr nr 13 nbargs 3 types: (int, char *, size_t) args: (fd, list, size) +syscall sys_removexattr nr 14 nbargs 2 types: (const char *, const char *) args: (pathname, name) +syscall sys_lremovexattr nr 15 nbargs 2 types: (const char *, const char *) args: (pathname, name) +syscall sys_fremovexattr nr 16 nbargs 2 types: (int, const char *) args: (fd, name) +syscall sys_getcwd nr 17 nbargs 2 types: (char *, unsigned long) args: (buf, size) +syscall sys_lookup_dcookie nr 18 nbargs 3 types: (u64, char *, size_t) args: (cookie64, buf, len) +syscall sys_eventfd2 nr 19 nbargs 2 types: (unsigned int, int) args: (count, flags) +syscall sys_epoll_create1 nr 20 nbargs 1 types: (int) args: (flags) +syscall sys_epoll_ctl nr 21 nbargs 4 types: (int, int, int, struct epoll_event *) args: (epfd, op, fd, event) +syscall sys_epoll_pwait nr 22 nbargs 6 types: (int, struct epoll_event *, int, int, const sigset_t *, size_t) args: (epfd, events, maxevents, timeout, sigmask, sigsetsize) +syscall sys_dup nr 23 nbargs 1 types: (unsigned int) args: (fildes) +syscall sys_dup3 nr 24 nbargs 3 types: (unsigned int, unsigned int, int) args: (oldfd, newfd, flags) +syscall sys_fcntl nr 25 nbargs 3 types: (unsigned int, unsigned int, unsigned long) args: (fd, cmd, arg) +syscall sys_inotify_init1 nr 26 nbargs 1 types: (int) args: (flags) +syscall sys_inotify_add_watch nr 27 nbargs 3 types: (int, const char *, u32) args: (fd, pathname, mask) +syscall sys_inotify_rm_watch nr 28 nbargs 2 types: (int, __s32) args: (fd, wd) +syscall sys_ioctl nr 29 nbargs 3 types: (unsigned int, unsigned int, unsigned long) args: (fd, cmd, arg) +syscall sys_ioprio_set nr 30 nbargs 3 types: (int, int, int) args: (which, who, ioprio) +syscall sys_ioprio_get nr 31 nbargs 2 types: (int, int) args: (which, who) +syscall sys_flock nr 32 nbargs 2 types: (unsigned int, unsigned int) args: (fd, cmd) +syscall sys_mknodat nr 33 nbargs 4 types: (int, const char *, umode_t, unsigned) args: (dfd, filename, mode, dev) +syscall sys_mkdirat nr 34 nbargs 3 types: (int, const char *, umode_t) args: (dfd, pathname, mode) +syscall sys_unlinkat nr 35 nbargs 3 types: (int, const char *, int) args: (dfd, pathname, flag) +syscall sys_symlinkat nr 36 nbargs 3 types: (const char *, int, const char *) args: (oldname, newdfd, newname) +syscall sys_linkat nr 37 nbargs 5 types: (int, const char *, int, const char *, int) args: (olddfd, oldname, newdfd, newname, flags) +syscall sys_renameat nr 38 nbargs 4 types: (int, const char *, int, const char *) args: (olddfd, oldname, newdfd, newname) +syscall sys_umount nr 39 nbargs 2 types: (char *, int) args: (name, flags) +syscall sys_mount nr 40 nbargs 5 types: (char *, char *, char *, unsigned long, void *) args: (dev_name, dir_name, type, flags, data) +syscall sys_pivot_root nr 41 nbargs 2 types: (const char *, const char *) args: (new_root, put_old) +syscall sys_statfs nr 43 nbargs 2 types: (const char *, struct statfs *) args: (pathname, buf) +syscall sys_fstatfs nr 44 nbargs 2 types: (unsigned int, struct statfs *) args: (fd, buf) +syscall sys_truncate nr 45 nbargs 2 types: (const char *, long) args: (path, length) +syscall sys_ftruncate nr 46 nbargs 2 types: (unsigned int, unsigned long) args: (fd, length) +syscall sys_fallocate nr 47 nbargs 4 types: (int, int, loff_t, loff_t) args: (fd, mode, offset, len) +syscall sys_faccessat nr 48 nbargs 3 types: (int, const char *, int) args: (dfd, filename, mode) +syscall sys_chdir nr 49 nbargs 1 types: (const char *) args: (filename) +syscall sys_fchdir nr 50 nbargs 1 types: (unsigned int) args: (fd) +syscall sys_chroot nr 51 nbargs 1 types: (const char *) args: (filename) +syscall sys_fchmod nr 52 nbargs 2 types: (unsigned int, umode_t) args: (fd, mode) +syscall sys_fchmodat nr 53 nbargs 3 types: (int, const char *, umode_t) args: (dfd, filename, mode) +syscall sys_fchownat nr 54 nbargs 5 types: (int, const char *, uid_t, gid_t, int) args: (dfd, filename, user, group, flag) +syscall sys_fchown nr 55 nbargs 3 types: (unsigned int, uid_t, gid_t) args: (fd, user, group) +syscall sys_openat nr 56 nbargs 4 types: (int, const char *, int, umode_t) args: (dfd, filename, flags, mode) +syscall sys_close nr 57 nbargs 1 types: (unsigned int) args: (fd) +syscall sys_vhangup nr 58 nbargs 0 types: () args: () +syscall sys_pipe2 nr 59 nbargs 2 types: (int *, int) args: (fildes, flags) +syscall sys_quotactl nr 60 nbargs 4 types: (unsigned int, const char *, qid_t, void *) args: (cmd, special, id, addr) +syscall sys_getdents64 nr 61 nbargs 3 types: (unsigned int, struct linux_dirent64 *, unsigned int) args: (fd, dirent, count) +syscall sys_lseek nr 62 nbargs 3 types: (unsigned int, off_t, unsigned int) args: (fd, offset, whence) +syscall sys_read nr 63 nbargs 3 types: (unsigned int, char *, size_t) args: (fd, buf, count) +syscall sys_write nr 64 nbargs 3 types: (unsigned int, const char *, size_t) args: (fd, buf, count) +syscall sys_readv nr 65 nbargs 3 types: (unsigned long, const struct iovec *, unsigned long) args: (fd, vec, vlen) +syscall sys_writev nr 66 nbargs 3 types: (unsigned long, const struct iovec *, unsigned long) args: (fd, vec, vlen) +syscall sys_pread64 nr 67 nbargs 4 types: (unsigned int, char *, size_t, loff_t) args: (fd, buf, count, pos) +syscall sys_pwrite64 nr 68 nbargs 4 types: (unsigned int, const char *, size_t, loff_t) args: (fd, buf, count, pos) +syscall sys_preadv nr 69 nbargs 5 types: (unsigned long, const struct iovec *, unsigned long, unsigned long, unsigned long) args: (fd, vec, vlen, pos_l, pos_h) +syscall sys_pwritev nr 70 nbargs 5 types: (unsigned long, const struct iovec *, unsigned long, unsigned long, unsigned long) args: (fd, vec, vlen, pos_l, pos_h) +syscall sys_sendfile64 nr 71 nbargs 4 types: (int, int, loff_t *, size_t) args: (out_fd, in_fd, offset, count) +syscall sys_pselect6 nr 72 nbargs 6 types: (int, fd_set *, fd_set *, fd_set *, struct timespec *, void *) args: (n, inp, outp, exp, tsp, sig) +syscall sys_ppoll nr 73 nbargs 5 types: (struct pollfd *, unsigned int, struct timespec *, const sigset_t *, size_t) args: (ufds, nfds, tsp, sigmask, sigsetsize) +syscall sys_signalfd4 nr 74 nbargs 4 types: (int, sigset_t *, size_t, int) args: (ufd, user_mask, sizemask, flags) +syscall sys_vmsplice nr 75 nbargs 4 types: (int, const struct iovec *, unsigned long, unsigned int) args: (fd, iov, nr_segs, flags) +syscall sys_splice nr 76 nbargs 6 types: (int, loff_t *, int, loff_t *, size_t, unsigned int) args: (fd_in, off_in, fd_out, off_out, len, flags) +syscall sys_tee nr 77 nbargs 4 types: (int, int, size_t, unsigned int) args: (fdin, fdout, len, flags) +syscall sys_readlinkat nr 78 nbargs 4 types: (int, const char *, char *, int) args: (dfd, pathname, buf, bufsiz) +syscall sys_newfstatat nr 79 nbargs 4 types: (int, const char *, struct stat *, int) args: (dfd, filename, statbuf, flag) +syscall sys_newfstat nr 80 nbargs 2 types: (unsigned int, struct stat *) args: (fd, statbuf) +syscall sys_sync nr 81 nbargs 0 types: () args: () +syscall sys_fsync nr 82 nbargs 1 types: (unsigned int) args: (fd) +syscall sys_fdatasync nr 83 nbargs 1 types: (unsigned int) args: (fd) +syscall sys_sync_file_range nr 84 nbargs 4 types: (int, loff_t, loff_t, unsigned int) args: (fd, offset, nbytes, flags) +syscall sys_timerfd_create nr 85 nbargs 2 types: (int, int) args: (clockid, flags) +syscall sys_timerfd_settime nr 86 nbargs 4 types: (int, int, const struct itimerspec *, struct itimerspec *) args: (ufd, flags, utmr, otmr) +syscall sys_timerfd_gettime nr 87 nbargs 2 types: (int, struct itimerspec *) args: (ufd, otmr) +syscall sys_utimensat nr 88 nbargs 4 types: (int, const char *, struct timespec *, int) args: (dfd, filename, utimes, flags) +syscall sys_acct nr 89 nbargs 1 types: (const char *) args: (name) +syscall sys_capget nr 90 nbargs 2 types: (cap_user_header_t, cap_user_data_t) args: (header, dataptr) +syscall sys_capset nr 91 nbargs 2 types: (cap_user_header_t, const cap_user_data_t) args: (header, data) +syscall sys_personality nr 92 nbargs 1 types: (unsigned int) args: (personality) +syscall sys_exit nr 93 nbargs 1 types: (int) args: (error_code) +syscall sys_exit_group nr 94 nbargs 1 types: (int) args: (error_code) +syscall sys_waitid nr 95 nbargs 5 types: (int, pid_t, struct siginfo *, int, struct rusage *) args: (which, upid, infop, options, ru) +syscall sys_set_tid_address nr 96 nbargs 1 types: (int *) args: (tidptr) +syscall sys_unshare nr 97 nbargs 1 types: (unsigned long) args: (unshare_flags) +syscall sys_futex nr 98 nbargs 6 types: (u32 *, int, u32, struct timespec *, u32 *, u32) args: (uaddr, op, val, utime, uaddr2, val3) +syscall sys_set_robust_list nr 99 nbargs 2 types: (struct robust_list_head *, size_t) args: (head, len) +syscall sys_get_robust_list nr 100 nbargs 3 types: (int, struct robust_list_head * *, size_t *) args: (pid, head_ptr, len_ptr) +syscall sys_nanosleep nr 101 nbargs 2 types: (struct timespec *, struct timespec *) args: (rqtp, rmtp) +syscall sys_getitimer nr 102 nbargs 2 types: (int, struct itimerval *) args: (which, value) +syscall sys_setitimer nr 103 nbargs 3 types: (int, struct itimerval *, struct itimerval *) args: (which, value, ovalue) +syscall sys_init_module nr 105 nbargs 3 types: (void *, unsigned long, const char *) args: (umod, len, uargs) +syscall sys_delete_module nr 106 nbargs 2 types: (const char *, unsigned int) args: (name_user, flags) +syscall sys_timer_create nr 107 nbargs 3 types: (const clockid_t, struct sigevent *, timer_t *) args: (which_clock, timer_event_spec, created_timer_id) +syscall sys_timer_gettime nr 108 nbargs 2 types: (timer_t, struct itimerspec *) args: (timer_id, setting) +syscall sys_timer_getoverrun nr 109 nbargs 1 types: (timer_t) args: (timer_id) +syscall sys_timer_settime nr 110 nbargs 4 types: (timer_t, int, const struct itimerspec *, struct itimerspec *) args: (timer_id, flags, new_setting, old_setting) +syscall sys_timer_delete nr 111 nbargs 1 types: (timer_t) args: (timer_id) +syscall sys_clock_settime nr 112 nbargs 2 types: (const clockid_t, const struct timespec *) args: (which_clock, tp) +syscall sys_clock_gettime nr 113 nbargs 2 types: (const clockid_t, struct timespec *) args: (which_clock, tp) +syscall sys_clock_getres nr 114 nbargs 2 types: (const clockid_t, struct timespec *) args: (which_clock, tp) +syscall sys_clock_nanosleep nr 115 nbargs 4 types: (const clockid_t, int, const struct timespec *, struct timespec *) args: (which_clock, flags, rqtp, rmtp) +syscall sys_syslog nr 116 nbargs 3 types: (int, char *, int) args: (type, buf, len) +syscall sys_ptrace nr 117 nbargs 4 types: (long, long, unsigned long, unsigned long) args: (request, pid, addr, data) +syscall sys_sched_setparam nr 118 nbargs 2 types: (pid_t, struct sched_param *) args: (pid, param) +syscall sys_sched_setscheduler nr 119 nbargs 3 types: (pid_t, int, struct sched_param *) args: (pid, policy, param) +syscall sys_sched_getscheduler nr 120 nbargs 1 types: (pid_t) args: (pid) +syscall sys_sched_getparam nr 121 nbargs 2 types: (pid_t, struct sched_param *) args: (pid, param) +syscall sys_sched_setaffinity nr 122 nbargs 3 types: (pid_t, unsigned int, unsigned long *) args: (pid, len, user_mask_ptr) +syscall sys_sched_getaffinity nr 123 nbargs 3 types: (pid_t, unsigned int, unsigned long *) args: (pid, len, user_mask_ptr) +syscall sys_sched_yield nr 124 nbargs 0 types: () args: () +syscall sys_sched_get_priority_max nr 125 nbargs 1 types: (int) args: (policy) +syscall sys_sched_get_priority_min nr 126 nbargs 1 types: (int) args: (policy) +syscall sys_sched_rr_get_interval nr 127 nbargs 2 types: (pid_t, struct timespec *) args: (pid, interval) +syscall sys_restart_syscall nr 128 nbargs 0 types: () args: () +syscall sys_kill nr 129 nbargs 2 types: (pid_t, int) args: (pid, sig) +syscall sys_tkill nr 130 nbargs 2 types: (pid_t, int) args: (pid, sig) +syscall sys_tgkill nr 131 nbargs 3 types: (pid_t, pid_t, int) args: (tgid, pid, sig) +syscall sys_sigaltstack nr 132 nbargs 2 types: (const stack_t *, stack_t *) args: (uss, uoss) +syscall sys_rt_sigsuspend nr 133 nbargs 2 types: (sigset_t *, size_t) args: (unewset, sigsetsize) +syscall sys_rt_sigaction nr 134 nbargs 4 types: (int, const struct sigaction *, struct sigaction *, size_t) args: (sig, act, oact, sigsetsize) +syscall sys_rt_sigprocmask nr 135 nbargs 4 types: (int, sigset_t *, sigset_t *, size_t) args: (how, nset, oset, sigsetsize) +syscall sys_rt_sigpending nr 136 nbargs 2 types: (sigset_t *, size_t) args: (uset, sigsetsize) +syscall sys_rt_sigtimedwait nr 137 nbargs 4 types: (const sigset_t *, siginfo_t *, const struct timespec *, size_t) args: (uthese, uinfo, uts, sigsetsize) +syscall sys_rt_sigqueueinfo nr 138 nbargs 3 types: (pid_t, int, siginfo_t *) args: (pid, sig, uinfo) +syscall sys_setpriority nr 140 nbargs 3 types: (int, int, int) args: (which, who, niceval) +syscall sys_getpriority nr 141 nbargs 2 types: (int, int) args: (which, who) +syscall sys_reboot nr 142 nbargs 4 types: (int, int, unsigned int, void *) args: (magic1, magic2, cmd, arg) +syscall sys_setregid nr 143 nbargs 2 types: (gid_t, gid_t) args: (rgid, egid) +syscall sys_setgid nr 144 nbargs 1 types: (gid_t) args: (gid) +syscall sys_setreuid nr 145 nbargs 2 types: (uid_t, uid_t) args: (ruid, euid) +syscall sys_setuid nr 146 nbargs 1 types: (uid_t) args: (uid) +syscall sys_setresuid nr 147 nbargs 3 types: (uid_t, uid_t, uid_t) args: (ruid, euid, suid) +syscall sys_getresuid nr 148 nbargs 3 types: (uid_t *, uid_t *, uid_t *) args: (ruidp, euidp, suidp) +syscall sys_setresgid nr 149 nbargs 3 types: (gid_t, gid_t, gid_t) args: (rgid, egid, sgid) +syscall sys_getresgid nr 150 nbargs 3 types: (gid_t *, gid_t *, gid_t *) args: (rgidp, egidp, sgidp) +syscall sys_setfsuid nr 151 nbargs 1 types: (uid_t) args: (uid) +syscall sys_setfsgid nr 152 nbargs 1 types: (gid_t) args: (gid) +syscall sys_times nr 153 nbargs 1 types: (struct tms *) args: (tbuf) +syscall sys_setpgid nr 154 nbargs 2 types: (pid_t, pid_t) args: (pid, pgid) +syscall sys_getpgid nr 155 nbargs 1 types: (pid_t) args: (pid) +syscall sys_getsid nr 156 nbargs 1 types: (pid_t) args: (pid) +syscall sys_setsid nr 157 nbargs 0 types: () args: () +syscall sys_getgroups nr 158 nbargs 2 types: (int, gid_t *) args: (gidsetsize, grouplist) +syscall sys_setgroups nr 159 nbargs 2 types: (int, gid_t *) args: (gidsetsize, grouplist) +syscall sys_newuname nr 160 nbargs 1 types: (struct new_utsname *) args: (name) +syscall sys_sethostname nr 161 nbargs 2 types: (char *, int) args: (name, len) +syscall sys_setdomainname nr 162 nbargs 2 types: (char *, int) args: (name, len) +syscall sys_getrlimit nr 163 nbargs 2 types: (unsigned int, struct rlimit *) args: (resource, rlim) +syscall sys_setrlimit nr 164 nbargs 2 types: (unsigned int, struct rlimit *) args: (resource, rlim) +syscall sys_getrusage nr 165 nbargs 2 types: (int, struct rusage *) args: (who, ru) +syscall sys_umask nr 166 nbargs 1 types: (int) args: (mask) +syscall sys_prctl nr 167 nbargs 5 types: (int, unsigned long, unsigned long, unsigned long, unsigned long) args: (option, arg2, arg3, arg4, arg5) +syscall sys_getcpu nr 168 nbargs 3 types: (unsigned *, unsigned *, struct getcpu_cache *) args: (cpup, nodep, unused) +syscall sys_gettimeofday nr 169 nbargs 2 types: (struct timeval *, struct timezone *) args: (tv, tz) +syscall sys_settimeofday nr 170 nbargs 2 types: (struct timeval *, struct timezone *) args: (tv, tz) +syscall sys_adjtimex nr 171 nbargs 1 types: (struct timex *) args: (txc_p) +syscall sys_getpid nr 172 nbargs 0 types: () args: () +syscall sys_getppid nr 173 nbargs 0 types: () args: () +syscall sys_getuid nr 174 nbargs 0 types: () args: () +syscall sys_geteuid nr 175 nbargs 0 types: () args: () +syscall sys_getgid nr 176 nbargs 0 types: () args: () +syscall sys_getegid nr 177 nbargs 0 types: () args: () +syscall sys_gettid nr 178 nbargs 0 types: () args: () +syscall sys_sysinfo nr 179 nbargs 1 types: (struct sysinfo *) args: (info) +syscall sys_mq_open nr 180 nbargs 4 types: (const char *, int, umode_t, struct mq_attr *) args: (u_name, oflag, mode, u_attr) +syscall sys_mq_unlink nr 181 nbargs 1 types: (const char *) args: (u_name) +syscall sys_mq_timedsend nr 182 nbargs 5 types: (mqd_t, const char *, size_t, unsigned int, const struct timespec *) args: (mqdes, u_msg_ptr, msg_len, msg_prio, u_abs_timeout) +syscall sys_mq_timedreceive nr 183 nbargs 5 types: (mqd_t, char *, size_t, unsigned int *, const struct timespec *) args: (mqdes, u_msg_ptr, msg_len, u_msg_prio, u_abs_timeout) +syscall sys_mq_notify nr 184 nbargs 2 types: (mqd_t, const struct sigevent *) args: (mqdes, u_notification) +syscall sys_mq_getsetattr nr 185 nbargs 3 types: (mqd_t, const struct mq_attr *, struct mq_attr *) args: (mqdes, u_mqstat, u_omqstat) +syscall sys_msgget nr 186 nbargs 2 types: (key_t, int) args: (key, msgflg) +syscall sys_msgctl nr 187 nbargs 3 types: (int, int, struct msqid_ds *) args: (msqid, cmd, buf) +syscall sys_msgrcv nr 188 nbargs 5 types: (int, struct msgbuf *, size_t, long, int) args: (msqid, msgp, msgsz, msgtyp, msgflg) +syscall sys_msgsnd nr 189 nbargs 4 types: (int, struct msgbuf *, size_t, int) args: (msqid, msgp, msgsz, msgflg) +syscall sys_semget nr 190 nbargs 3 types: (key_t, int, int) args: (key, nsems, semflg) +syscall sys_semctl nr 191 nbargs 4 types: (int, int, int, unsigned long) args: (semid, semnum, cmd, arg) +syscall sys_semtimedop nr 192 nbargs 4 types: (int, struct sembuf *, unsigned, const struct timespec *) args: (semid, tsops, nsops, timeout) +syscall sys_semop nr 193 nbargs 3 types: (int, struct sembuf *, unsigned) args: (semid, tsops, nsops) +syscall sys_shmget nr 194 nbargs 3 types: (key_t, size_t, int) args: (key, size, shmflg) +syscall sys_shmctl nr 195 nbargs 3 types: (int, int, struct shmid_ds *) args: (shmid, cmd, buf) +syscall sys_shmat nr 196 nbargs 3 types: (int, char *, int) args: (shmid, shmaddr, shmflg) +syscall sys_shmdt nr 197 nbargs 1 types: (char *) args: (shmaddr) +syscall sys_socket nr 198 nbargs 3 types: (int, int, int) args: (family, type, protocol) +syscall sys_socketpair nr 199 nbargs 4 types: (int, int, int, int *) args: (family, type, protocol, usockvec) +syscall sys_bind nr 200 nbargs 3 types: (int, struct sockaddr *, int) args: (fd, umyaddr, addrlen) +syscall sys_listen nr 201 nbargs 2 types: (int, int) args: (fd, backlog) +syscall sys_accept nr 202 nbargs 3 types: (int, struct sockaddr *, int *) args: (fd, upeer_sockaddr, upeer_addrlen) +syscall sys_connect nr 203 nbargs 3 types: (int, struct sockaddr *, int) args: (fd, uservaddr, addrlen) +syscall sys_getsockname nr 204 nbargs 3 types: (int, struct sockaddr *, int *) args: (fd, usockaddr, usockaddr_len) +syscall sys_getpeername nr 205 nbargs 3 types: (int, struct sockaddr *, int *) args: (fd, usockaddr, usockaddr_len) +syscall sys_sendto nr 206 nbargs 6 types: (int, void *, size_t, unsigned int, struct sockaddr *, int) args: (fd, buff, len, flags, addr, addr_len) +syscall sys_recvfrom nr 207 nbargs 6 types: (int, void *, size_t, unsigned int, struct sockaddr *, int *) args: (fd, ubuf, size, flags, addr, addr_len) +syscall sys_setsockopt nr 208 nbargs 5 types: (int, int, int, char *, int) args: (fd, level, optname, optval, optlen) +syscall sys_getsockopt nr 209 nbargs 5 types: (int, int, int, char *, int *) args: (fd, level, optname, optval, optlen) +syscall sys_shutdown nr 210 nbargs 2 types: (int, int) args: (fd, how) +syscall sys_sendmsg nr 211 nbargs 3 types: (int, struct user_msghdr *, unsigned int) args: (fd, msg, flags) +syscall sys_recvmsg nr 212 nbargs 3 types: (int, struct user_msghdr *, unsigned int) args: (fd, msg, flags) +syscall sys_readahead nr 213 nbargs 3 types: (int, loff_t, size_t) args: (fd, offset, count) +syscall sys_brk nr 214 nbargs 1 types: (unsigned long) args: (brk) +syscall sys_munmap nr 215 nbargs 2 types: (unsigned long, size_t) args: (addr, len) +syscall sys_mremap nr 216 nbargs 5 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long) args: (addr, old_len, new_len, flags, new_addr) +syscall sys_add_key nr 217 nbargs 5 types: (const char *, const char *, const void *, size_t, key_serial_t) args: (_type, _description, _payload, plen, ringid) +syscall sys_request_key nr 218 nbargs 4 types: (const char *, const char *, const char *, key_serial_t) args: (_type, _description, _callout_info, destringid) +syscall sys_keyctl nr 219 nbargs 5 types: (int, unsigned long, unsigned long, unsigned long, unsigned long) args: (option, arg2, arg3, arg4, arg5) +syscall sys_execve nr 221 nbargs 3 types: (const char *, const char *const *, const char *const *) args: (filename, argv, envp) +syscall sys_fadvise64_64 nr 223 nbargs 4 types: (int, loff_t, loff_t, int) args: (fd, offset, len, advice) +syscall sys_swapon nr 224 nbargs 2 types: (const char *, int) args: (specialfile, swap_flags) +syscall sys_swapoff nr 225 nbargs 1 types: (const char *) args: (specialfile) +syscall sys_mprotect nr 226 nbargs 3 types: (unsigned long, size_t, unsigned long) args: (start, len, prot) +syscall sys_msync nr 227 nbargs 3 types: (unsigned long, size_t, int) args: (start, len, flags) +syscall sys_mlock nr 228 nbargs 2 types: (unsigned long, size_t) args: (start, len) +syscall sys_munlock nr 229 nbargs 2 types: (unsigned long, size_t) args: (start, len) +syscall sys_mlockall nr 230 nbargs 1 types: (int) args: (flags) +syscall sys_munlockall nr 231 nbargs 0 types: () args: () +syscall sys_mincore nr 232 nbargs 3 types: (unsigned long, size_t, unsigned char *) args: (start, len, vec) +syscall sys_madvise nr 233 nbargs 3 types: (unsigned long, size_t, int) args: (start, len_in, behavior) +syscall sys_remap_file_pages nr 234 nbargs 5 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long) args: (start, size, prot, pgoff, flags) +syscall sys_rt_tgsigqueueinfo nr 240 nbargs 4 types: (pid_t, pid_t, int, siginfo_t *) args: (tgid, pid, sig, uinfo) +syscall sys_perf_event_open nr 241 nbargs 5 types: (struct perf_event_attr *, pid_t, int, int, unsigned long) args: (attr_uptr, pid, cpu, group_fd, flags) +syscall sys_accept4 nr 242 nbargs 4 types: (int, struct sockaddr *, int *, int) args: (fd, upeer_sockaddr, upeer_addrlen, flags) +syscall sys_recvmmsg nr 243 nbargs 5 types: (int, struct mmsghdr *, unsigned int, unsigned int, struct timespec *) args: (fd, mmsg, vlen, flags, timeout) +syscall sys_wait4 nr 260 nbargs 4 types: (pid_t, int *, int, struct rusage *) args: (upid, stat_addr, options, ru) +syscall sys_prlimit64 nr 261 nbargs 4 types: (pid_t, unsigned int, const struct rlimit64 *, struct rlimit64 *) args: (pid, resource, new_rlim, old_rlim) +syscall sys_fanotify_init nr 262 nbargs 2 types: (unsigned int, unsigned int) args: (flags, event_f_flags) +syscall sys_fanotify_mark nr 263 nbargs 5 types: (int, unsigned int, __u64, int, const char *) args: (fanotify_fd, flags, mask, dfd, pathname) +syscall sys_name_to_handle_at nr 264 nbargs 5 types: (int, const char *, struct file_handle *, int *, int) args: (dfd, name, handle, mnt_id, flag) +syscall sys_open_by_handle_at nr 265 nbargs 3 types: (int, struct file_handle *, int) args: (mountdirfd, handle, flags) +syscall sys_clock_adjtime nr 266 nbargs 2 types: (const clockid_t, struct timex *) args: (which_clock, utx) +syscall sys_syncfs nr 267 nbargs 1 types: (int) args: (fd) +syscall sys_setns nr 268 nbargs 2 types: (int, int) args: (fd, nstype) +syscall sys_sendmmsg nr 269 nbargs 4 types: (int, struct mmsghdr *, unsigned int, unsigned int) args: (fd, mmsg, vlen, flags) +syscall sys_process_vm_readv nr 270 nbargs 6 types: (pid_t, const struct iovec *, unsigned long, const struct iovec *, unsigned long, unsigned long) args: (pid, lvec, liovcnt, rvec, riovcnt, flags) +syscall sys_process_vm_writev nr 271 nbargs 6 types: (pid_t, const struct iovec *, unsigned long, const struct iovec *, unsigned long, unsigned long) args: (pid, lvec, liovcnt, rvec, riovcnt, flags) +syscall sys_finit_module nr 273 nbargs 3 types: (int, const char *, int) args: (fd, uargs, flags) +syscall sys_sched_setattr nr 274 nbargs 3 types: (pid_t, struct sched_attr *, unsigned int) args: (pid, uattr, flags) +syscall sys_sched_getattr nr 275 nbargs 4 types: (pid_t, struct sched_attr *, unsigned int, unsigned int) args: (pid, uattr, size, flags) +syscall sys_renameat2 nr 276 nbargs 5 types: (int, const char *, int, const char *, unsigned int) args: (olddfd, oldname, newdfd, newname, flags) +syscall sys_seccomp nr 277 nbargs 3 types: (unsigned int, unsigned int, const char *) args: (op, flags, uargs) +syscall sys_getrandom nr 278 nbargs 3 types: (char *, size_t, unsigned int) args: (buf, count, flags) +syscall sys_memfd_create nr 279 nbargs 2 types: (const char *, unsigned int) args: (uname, flags) +syscall sys_execveat nr 281 nbargs 5 types: (int, const char *, const char *const *, const char *const *, int) args: (fd, filename, argv, envp, flags) +syscall sys_membarrier nr 283 nbargs 2 types: (int, int) args: (cmd, flags) +syscall sys_mlock2 nr 284 nbargs 3 types: (unsigned long, size_t, int) args: (start, len, flags) \ No newline at end of file diff --git a/include/instrumentation/syscalls/README b/include/instrumentation/syscalls/README new file mode 100644 index 00000000..6dbc640e --- /dev/null +++ b/include/instrumentation/syscalls/README @@ -0,0 +1,33 @@ +LTTng system call tracing + +1) lttng-syscall-extractor + +You need to build a kernel with CONFIG_FTRACE_SYSCALLS=y and +CONFIG_KALLSYMS_ALL=y for extraction. Apply the linker patch to get your +kernel to keep the system call metadata after boot. Then build and load +the LTTng syscall extractor module. The module will fail to load (this +is expected). See the dmesg output for system call metadata. + +2) Generate system call TRACE_EVENT(). + +Take the dmesg data and feed it to lttng-syscalls-generate-headers.sh from +the instrumentation/syscalls directory. See the script header for usage +example. It should be run for both the integers and pointers types. + +After these are created, you just need to follow the new system call additions, +no need to regenerate the whole thing, since system calls are only appended to. + +3) Override headers + +You need to provide override headers (even if they don't contain +overrides) for each architecture. Those are meant to contain manual +overrides for specific system calls for cases where the script do not +generate the correct typing for specific system calls. + +4) Integrating the new architecture, updating architecture header + +Edit instrumentation/syscalls/headers/syscalls_integers.h and +syscalls_pointers.h. Add the new architecture +(e.g. CONFIG_X86_64) to the newly-generated headers +(e.g. changing the current x86-64-syscalls-3.10.0-rc7_.h into +x86-64-syscalls-3.13.7_.h), then rebuild lttng-modules. diff --git a/include/instrumentation/syscalls/headers/arm-32-syscalls_integers.h b/include/instrumentation/syscalls/headers/arm-32-syscalls_integers.h new file mode 100644 index 00000000..db02762e --- /dev/null +++ b/include/instrumentation/syscalls/headers/arm-32-syscalls_integers.h @@ -0,0 +1,1218 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ + +/* THIS FILE IS AUTO-GENERATED. DO NOT EDIT */ + +/* Generated from arm-32-syscalls 3.4.25 */ + +#ifndef CREATE_SYSCALL_TABLE + +#if !defined(_TRACE_SYSCALLS_INTEGERS_H) || defined(TRACE_HEADER_MULTI_READ) +#define _TRACE_SYSCALLS_INTEGERS_H + +#include +#include +#include "arm-32-syscalls_integers_override.h" +#include "syscalls_integers_override.h" + +#ifdef SC_ENTER +SC_LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(syscalls_noargs, + TP_FIELDS() +) +#ifndef OVERRIDE_32_restart_syscall +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, restart_syscall) +#endif +#ifndef OVERRIDE_32_getpid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getpid) +#endif +#ifndef OVERRIDE_32_getuid16 +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getuid16) +#endif +#ifndef OVERRIDE_32_pause +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, pause) +#endif +#ifndef OVERRIDE_32_sync +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, sync) +#endif +#ifndef OVERRIDE_32_getgid16 +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getgid16) +#endif +#ifndef OVERRIDE_32_geteuid16 +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, geteuid16) +#endif +#ifndef OVERRIDE_32_getegid16 +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getegid16) +#endif +#ifndef OVERRIDE_32_getppid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getppid) +#endif +#ifndef OVERRIDE_32_getpgrp +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getpgrp) +#endif +#ifndef OVERRIDE_32_setsid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, setsid) +#endif +#ifndef OVERRIDE_32_vhangup +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, vhangup) +#endif +#ifndef OVERRIDE_32_munlockall +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, munlockall) +#endif +#ifndef OVERRIDE_32_sched_yield +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, sched_yield) +#endif +#ifndef OVERRIDE_32_getuid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getuid) +#endif +#ifndef OVERRIDE_32_getgid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getgid) +#endif +#ifndef OVERRIDE_32_geteuid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, geteuid) +#endif +#ifndef OVERRIDE_32_getegid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getegid) +#endif +#ifndef OVERRIDE_32_gettid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, gettid) +#endif +#ifndef OVERRIDE_32_inotify_init +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, inotify_init) +#endif +#else /* #ifdef SC_ENTER */ +#ifndef OVERRIDE_32_restart_syscall +SC_LTTNG_TRACEPOINT_EVENT(restart_syscall, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_getpid +SC_LTTNG_TRACEPOINT_EVENT(getpid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_getuid16 +SC_LTTNG_TRACEPOINT_EVENT(getuid16, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_pause +SC_LTTNG_TRACEPOINT_EVENT(pause, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_sync +SC_LTTNG_TRACEPOINT_EVENT(sync, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_getgid16 +SC_LTTNG_TRACEPOINT_EVENT(getgid16, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_geteuid16 +SC_LTTNG_TRACEPOINT_EVENT(geteuid16, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_getegid16 +SC_LTTNG_TRACEPOINT_EVENT(getegid16, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_getppid +SC_LTTNG_TRACEPOINT_EVENT(getppid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_getpgrp +SC_LTTNG_TRACEPOINT_EVENT(getpgrp, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_setsid +SC_LTTNG_TRACEPOINT_EVENT(setsid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_vhangup +SC_LTTNG_TRACEPOINT_EVENT(vhangup, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_munlockall +SC_LTTNG_TRACEPOINT_EVENT(munlockall, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_sched_yield +SC_LTTNG_TRACEPOINT_EVENT(sched_yield, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_getuid +SC_LTTNG_TRACEPOINT_EVENT(getuid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_getgid +SC_LTTNG_TRACEPOINT_EVENT(getgid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_geteuid +SC_LTTNG_TRACEPOINT_EVENT(geteuid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_getegid +SC_LTTNG_TRACEPOINT_EVENT(getegid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_gettid +SC_LTTNG_TRACEPOINT_EVENT(gettid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_inotify_init +SC_LTTNG_TRACEPOINT_EVENT(inotify_init, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#endif /* else #ifdef SC_ENTER */ +#ifndef OVERRIDE_32_exit +SC_LTTNG_TRACEPOINT_EVENT(exit, + TP_PROTO(sc_exit(long ret,) int error_code), + TP_ARGS(sc_exit(ret,) error_code), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, error_code, error_code))) +) +#endif +#ifndef OVERRIDE_32_close +SC_LTTNG_TRACEPOINT_EVENT(close, + TP_PROTO(sc_exit(long ret,) unsigned int fd), + TP_ARGS(sc_exit(ret,) fd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) +) +#endif +#ifndef OVERRIDE_32_setuid16 +SC_LTTNG_TRACEPOINT_EVENT(setuid16, + TP_PROTO(sc_exit(long ret,) old_uid_t uid), + TP_ARGS(sc_exit(ret,) uid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(old_uid_t, uid, uid))) +) +#endif +#ifndef OVERRIDE_32_nice +SC_LTTNG_TRACEPOINT_EVENT(nice, + TP_PROTO(sc_exit(long ret,) int increment), + TP_ARGS(sc_exit(ret,) increment), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, increment, increment))) +) +#endif +#ifndef OVERRIDE_32_dup +SC_LTTNG_TRACEPOINT_EVENT(dup, + TP_PROTO(sc_exit(long ret,) unsigned int fildes), + TP_ARGS(sc_exit(ret,) fildes), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fildes, fildes))) +) +#endif +#ifndef OVERRIDE_32_brk +SC_LTTNG_TRACEPOINT_EVENT(brk, + TP_PROTO(sc_exit(long ret,) unsigned long brk), + TP_ARGS(sc_exit(ret,) brk), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, brk, brk))) +) +#endif +#ifndef OVERRIDE_32_setgid16 +SC_LTTNG_TRACEPOINT_EVENT(setgid16, + TP_PROTO(sc_exit(long ret,) old_gid_t gid), + TP_ARGS(sc_exit(ret,) gid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(old_gid_t, gid, gid))) +) +#endif +#ifndef OVERRIDE_32_umask +SC_LTTNG_TRACEPOINT_EVENT(umask, + TP_PROTO(sc_exit(long ret,) int mask), + TP_ARGS(sc_exit(ret,) mask), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, mask, mask))) +) +#endif +#ifndef OVERRIDE_32_fsync +SC_LTTNG_TRACEPOINT_EVENT(fsync, + TP_PROTO(sc_exit(long ret,) unsigned int fd), + TP_ARGS(sc_exit(ret,) fd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) +) +#endif +#ifndef OVERRIDE_32_getpgid +SC_LTTNG_TRACEPOINT_EVENT(getpgid, + TP_PROTO(sc_exit(long ret,) pid_t pid), + TP_ARGS(sc_exit(ret,) pid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid))) +) +#endif +#ifndef OVERRIDE_32_fchdir +SC_LTTNG_TRACEPOINT_EVENT(fchdir, + TP_PROTO(sc_exit(long ret,) unsigned int fd), + TP_ARGS(sc_exit(ret,) fd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) +) +#endif +#ifndef OVERRIDE_32_personality +SC_LTTNG_TRACEPOINT_EVENT(personality, + TP_PROTO(sc_exit(long ret,) unsigned int personality), + TP_ARGS(sc_exit(ret,) personality), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, personality, personality))) +) +#endif +#ifndef OVERRIDE_32_setfsuid16 +SC_LTTNG_TRACEPOINT_EVENT(setfsuid16, + TP_PROTO(sc_exit(long ret,) old_uid_t uid), + TP_ARGS(sc_exit(ret,) uid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(old_uid_t, uid, uid))) +) +#endif +#ifndef OVERRIDE_32_setfsgid16 +SC_LTTNG_TRACEPOINT_EVENT(setfsgid16, + TP_PROTO(sc_exit(long ret,) old_gid_t gid), + TP_ARGS(sc_exit(ret,) gid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(old_gid_t, gid, gid))) +) +#endif +#ifndef OVERRIDE_32_getsid +SC_LTTNG_TRACEPOINT_EVENT(getsid, + TP_PROTO(sc_exit(long ret,) pid_t pid), + TP_ARGS(sc_exit(ret,) pid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid))) +) +#endif +#ifndef OVERRIDE_32_fdatasync +SC_LTTNG_TRACEPOINT_EVENT(fdatasync, + TP_PROTO(sc_exit(long ret,) unsigned int fd), + TP_ARGS(sc_exit(ret,) fd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) +) +#endif +#ifndef OVERRIDE_32_mlockall +SC_LTTNG_TRACEPOINT_EVENT(mlockall, + TP_PROTO(sc_exit(long ret,) int flags), + TP_ARGS(sc_exit(ret,) flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_sched_getscheduler +SC_LTTNG_TRACEPOINT_EVENT(sched_getscheduler, + TP_PROTO(sc_exit(long ret,) pid_t pid), + TP_ARGS(sc_exit(ret,) pid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid))) +) +#endif +#ifndef OVERRIDE_32_sched_get_priority_max +SC_LTTNG_TRACEPOINT_EVENT(sched_get_priority_max, + TP_PROTO(sc_exit(long ret,) int policy), + TP_ARGS(sc_exit(ret,) policy), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, policy, policy))) +) +#endif +#ifndef OVERRIDE_32_sched_get_priority_min +SC_LTTNG_TRACEPOINT_EVENT(sched_get_priority_min, + TP_PROTO(sc_exit(long ret,) int policy), + TP_ARGS(sc_exit(ret,) policy), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, policy, policy))) +) +#endif +#ifndef OVERRIDE_32_setuid +SC_LTTNG_TRACEPOINT_EVENT(setuid, + TP_PROTO(sc_exit(long ret,) uid_t uid), + TP_ARGS(sc_exit(ret,) uid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, uid, uid))) +) +#endif +#ifndef OVERRIDE_32_setgid +SC_LTTNG_TRACEPOINT_EVENT(setgid, + TP_PROTO(sc_exit(long ret,) gid_t gid), + TP_ARGS(sc_exit(ret,) gid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, gid, gid))) +) +#endif +#ifndef OVERRIDE_32_setfsuid +SC_LTTNG_TRACEPOINT_EVENT(setfsuid, + TP_PROTO(sc_exit(long ret,) uid_t uid), + TP_ARGS(sc_exit(ret,) uid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, uid, uid))) +) +#endif +#ifndef OVERRIDE_32_setfsgid +SC_LTTNG_TRACEPOINT_EVENT(setfsgid, + TP_PROTO(sc_exit(long ret,) gid_t gid), + TP_ARGS(sc_exit(ret,) gid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, gid, gid))) +) +#endif +#ifndef OVERRIDE_32_io_destroy +SC_LTTNG_TRACEPOINT_EVENT(io_destroy, + TP_PROTO(sc_exit(long ret,) aio_context_t ctx), + TP_ARGS(sc_exit(ret,) ctx), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx, ctx))) +) +#endif +#ifndef OVERRIDE_32_exit_group +SC_LTTNG_TRACEPOINT_EVENT(exit_group, + TP_PROTO(sc_exit(long ret,) int error_code), + TP_ARGS(sc_exit(ret,) error_code), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, error_code, error_code))) +) +#endif +#ifndef OVERRIDE_32_epoll_create +SC_LTTNG_TRACEPOINT_EVENT(epoll_create, + TP_PROTO(sc_exit(long ret,) int size), + TP_ARGS(sc_exit(ret,) size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, size, size))) +) +#endif +#ifndef OVERRIDE_32_timer_getoverrun +SC_LTTNG_TRACEPOINT_EVENT(timer_getoverrun, + TP_PROTO(sc_exit(long ret,) timer_t timer_id), + TP_ARGS(sc_exit(ret,) timer_id), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id))) +) +#endif +#ifndef OVERRIDE_32_timer_delete +SC_LTTNG_TRACEPOINT_EVENT(timer_delete, + TP_PROTO(sc_exit(long ret,) timer_t timer_id), + TP_ARGS(sc_exit(ret,) timer_id), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id))) +) +#endif +#ifndef OVERRIDE_32_unshare +SC_LTTNG_TRACEPOINT_EVENT(unshare, + TP_PROTO(sc_exit(long ret,) unsigned long unshare_flags), + TP_ARGS(sc_exit(ret,) unshare_flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, unshare_flags, unshare_flags))) +) +#endif +#ifndef OVERRIDE_32_eventfd +SC_LTTNG_TRACEPOINT_EVENT(eventfd, + TP_PROTO(sc_exit(long ret,) unsigned int count), + TP_ARGS(sc_exit(ret,) count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, count, count))) +) +#endif +#ifndef OVERRIDE_32_epoll_create1 +SC_LTTNG_TRACEPOINT_EVENT(epoll_create1, + TP_PROTO(sc_exit(long ret,) int flags), + TP_ARGS(sc_exit(ret,) flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_inotify_init1 +SC_LTTNG_TRACEPOINT_EVENT(inotify_init1, + TP_PROTO(sc_exit(long ret,) int flags), + TP_ARGS(sc_exit(ret,) flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_syncfs +SC_LTTNG_TRACEPOINT_EVENT(syncfs, + TP_PROTO(sc_exit(long ret,) int fd), + TP_ARGS(sc_exit(ret,) fd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd))) +) +#endif +#ifndef OVERRIDE_32_kill +SC_LTTNG_TRACEPOINT_EVENT(kill, + TP_PROTO(sc_exit(long ret,) pid_t pid, int sig), + TP_ARGS(sc_exit(ret,) pid, sig), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig))) +) +#endif +#ifndef OVERRIDE_32_setpgid +SC_LTTNG_TRACEPOINT_EVENT(setpgid, + TP_PROTO(sc_exit(long ret,) pid_t pid, pid_t pgid), + TP_ARGS(sc_exit(ret,) pid, pgid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(pid_t, pgid, pgid))) +) +#endif +#ifndef OVERRIDE_32_dup2 +SC_LTTNG_TRACEPOINT_EVENT(dup2, + TP_PROTO(sc_exit(long ret,) unsigned int oldfd, unsigned int newfd), + TP_ARGS(sc_exit(ret,) oldfd, newfd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, oldfd, oldfd)) sc_in(ctf_integer(unsigned int, newfd, newfd))) +) +#endif +#ifndef OVERRIDE_32_setreuid16 +SC_LTTNG_TRACEPOINT_EVENT(setreuid16, + TP_PROTO(sc_exit(long ret,) old_uid_t ruid, old_uid_t euid), + TP_ARGS(sc_exit(ret,) ruid, euid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(old_uid_t, ruid, ruid)) sc_inout(ctf_integer(old_uid_t, euid, euid))) +) +#endif +#ifndef OVERRIDE_32_setregid16 +SC_LTTNG_TRACEPOINT_EVENT(setregid16, + TP_PROTO(sc_exit(long ret,) old_gid_t rgid, old_gid_t egid), + TP_ARGS(sc_exit(ret,) rgid, egid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(old_gid_t, rgid, rgid)) sc_inout(ctf_integer(old_gid_t, egid, egid))) +) +#endif +#ifndef OVERRIDE_32_munmap +SC_LTTNG_TRACEPOINT_EVENT(munmap, + TP_PROTO(sc_exit(long ret,) unsigned long addr, size_t len), + TP_ARGS(sc_exit(ret,) addr, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, addr, addr)) sc_in(ctf_integer(size_t, len, len))) +) +#endif +#ifndef OVERRIDE_32_ftruncate +SC_LTTNG_TRACEPOINT_EVENT(ftruncate, + TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned long length), + TP_ARGS(sc_exit(ret,) fd, length), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned long, length, length))) +) +#endif +#ifndef OVERRIDE_32_fchmod +SC_LTTNG_TRACEPOINT_EVENT(fchmod, + TP_PROTO(sc_exit(long ret,) unsigned int fd, umode_t mode), + TP_ARGS(sc_exit(ret,) fd, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(umode_t, mode, mode))) +) +#endif +#ifndef OVERRIDE_32_getpriority +SC_LTTNG_TRACEPOINT_EVENT(getpriority, + TP_PROTO(sc_exit(long ret,) int which, int who), + TP_ARGS(sc_exit(ret,) which, who), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who))) +) +#endif +#ifndef OVERRIDE_32_bdflush +SC_LTTNG_TRACEPOINT_EVENT(bdflush, + TP_PROTO(sc_exit(long ret,) int func, long data), + TP_ARGS(sc_exit(ret,) func, data), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, func, func)) sc_inout(ctf_integer(long, data, data))) +) +#endif +#ifndef OVERRIDE_32_flock +SC_LTTNG_TRACEPOINT_EVENT(flock, + TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd), + TP_ARGS(sc_exit(ret,) fd, cmd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned int, cmd, cmd))) +) +#endif +#ifndef OVERRIDE_32_mlock +SC_LTTNG_TRACEPOINT_EVENT(mlock, + TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len), + TP_ARGS(sc_exit(ret,) start, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len))) +) +#endif +#ifndef OVERRIDE_32_munlock +SC_LTTNG_TRACEPOINT_EVENT(munlock, + TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len), + TP_ARGS(sc_exit(ret,) start, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len))) +) +#endif +#ifndef OVERRIDE_32_setreuid +SC_LTTNG_TRACEPOINT_EVENT(setreuid, + TP_PROTO(sc_exit(long ret,) uid_t ruid, uid_t euid), + TP_ARGS(sc_exit(ret,) ruid, euid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, ruid, ruid)) sc_in(ctf_integer(uid_t, euid, euid))) +) +#endif +#ifndef OVERRIDE_32_setregid +SC_LTTNG_TRACEPOINT_EVENT(setregid, + TP_PROTO(sc_exit(long ret,) gid_t rgid, gid_t egid), + TP_ARGS(sc_exit(ret,) rgid, egid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, rgid, rgid)) sc_in(ctf_integer(gid_t, egid, egid))) +) +#endif +#ifndef OVERRIDE_32_tkill +SC_LTTNG_TRACEPOINT_EVENT(tkill, + TP_PROTO(sc_exit(long ret,) pid_t pid, int sig), + TP_ARGS(sc_exit(ret,) pid, sig), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig))) +) +#endif +#ifndef OVERRIDE_32_listen +SC_LTTNG_TRACEPOINT_EVENT(listen, + TP_PROTO(sc_exit(long ret,) int fd, int backlog), + TP_ARGS(sc_exit(ret,) fd, backlog), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, backlog, backlog))) +) +#endif +#ifndef OVERRIDE_32_shutdown +SC_LTTNG_TRACEPOINT_EVENT(shutdown, + TP_PROTO(sc_exit(long ret,) int fd, int how), + TP_ARGS(sc_exit(ret,) fd, how), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, how, how))) +) +#endif +#ifndef OVERRIDE_32_msgget +SC_LTTNG_TRACEPOINT_EVENT(msgget, + TP_PROTO(sc_exit(long ret,) key_t key, int msgflg), + TP_ARGS(sc_exit(ret,) key, msgflg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(key_t, key, key)) sc_in(ctf_integer(int, msgflg, msgflg))) +) +#endif +#ifndef OVERRIDE_32_ioprio_get +SC_LTTNG_TRACEPOINT_EVENT(ioprio_get, + TP_PROTO(sc_exit(long ret,) int which, int who), + TP_ARGS(sc_exit(ret,) which, who), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who))) +) +#endif +#ifndef OVERRIDE_32_inotify_rm_watch +SC_LTTNG_TRACEPOINT_EVENT(inotify_rm_watch, + TP_PROTO(sc_exit(long ret,) int fd, __s32 wd), + TP_ARGS(sc_exit(ret,) fd, wd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(__s32, wd, wd))) +) +#endif +#ifndef OVERRIDE_32_timerfd_create +SC_LTTNG_TRACEPOINT_EVENT(timerfd_create, + TP_PROTO(sc_exit(long ret,) int clockid, int flags), + TP_ARGS(sc_exit(ret,) clockid, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, clockid, clockid)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_eventfd2 +SC_LTTNG_TRACEPOINT_EVENT(eventfd2, + TP_PROTO(sc_exit(long ret,) unsigned int count, int flags), + TP_ARGS(sc_exit(ret,) count, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, count, count)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_fanotify_init +SC_LTTNG_TRACEPOINT_EVENT(fanotify_init, + TP_PROTO(sc_exit(long ret,) unsigned int flags, unsigned int event_f_flags), + TP_ARGS(sc_exit(ret,) flags, event_f_flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, flags, flags)) sc_in(ctf_integer(unsigned int, event_f_flags, event_f_flags))) +) +#endif +#ifndef OVERRIDE_32_setns +SC_LTTNG_TRACEPOINT_EVENT(setns, + TP_PROTO(sc_exit(long ret,) int fd, int nstype), + TP_ARGS(sc_exit(ret,) fd, nstype), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, nstype, nstype))) +) +#endif +#ifndef OVERRIDE_32_lseek +SC_LTTNG_TRACEPOINT_EVENT(lseek, + TP_PROTO(sc_exit(long ret,) unsigned int fd, off_t offset, unsigned int origin), + TP_ARGS(sc_exit(ret,) fd, offset, origin), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(off_t, offset, offset)) sc_in(ctf_integer(unsigned int, origin, origin))) +) +#endif +#ifndef OVERRIDE_32_ioctl +SC_LTTNG_TRACEPOINT_EVENT(ioctl, + TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd, unsigned long arg), + TP_ARGS(sc_exit(ret,) fd, cmd, arg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_inout(ctf_integer(unsigned long, arg, arg))) +) +#endif +#ifndef OVERRIDE_32_fcntl +SC_LTTNG_TRACEPOINT_EVENT(fcntl, + TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd, unsigned long arg), + TP_ARGS(sc_exit(ret,) fd, cmd, arg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_inout(ctf_integer(unsigned long, arg, arg))) +) +#endif +#ifndef OVERRIDE_32_fchown16 +SC_LTTNG_TRACEPOINT_EVENT(fchown16, + TP_PROTO(sc_exit(long ret,) unsigned int fd, old_uid_t user, old_gid_t group), + TP_ARGS(sc_exit(ret,) fd, user, group), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, fd, fd)) sc_inout(ctf_integer(old_uid_t, user, user)) sc_inout(ctf_integer(old_gid_t, group, group))) +) +#endif +#ifndef OVERRIDE_32_setpriority +SC_LTTNG_TRACEPOINT_EVENT(setpriority, + TP_PROTO(sc_exit(long ret,) int which, int who, int niceval), + TP_ARGS(sc_exit(ret,) which, who, niceval), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who)) sc_in(ctf_integer(int, niceval, niceval))) +) +#endif +#ifndef OVERRIDE_32_mprotect +SC_LTTNG_TRACEPOINT_EVENT(mprotect, + TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len, unsigned long prot), + TP_ARGS(sc_exit(ret,) start, len, prot), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned long, prot, prot))) +) +#endif +#ifndef OVERRIDE_32_sysfs +SC_LTTNG_TRACEPOINT_EVENT(sysfs, + TP_PROTO(sc_exit(long ret,) int option, unsigned long arg1, unsigned long arg2), + TP_ARGS(sc_exit(ret,) option, arg1, arg2), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, option, option)) sc_in(ctf_integer(unsigned long, arg1, arg1)) sc_in(ctf_integer(unsigned long, arg2, arg2))) +) +#endif +#ifndef OVERRIDE_32_msync +SC_LTTNG_TRACEPOINT_EVENT(msync, + TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len, int flags), + TP_ARGS(sc_exit(ret,) start, len, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_setresuid16 +SC_LTTNG_TRACEPOINT_EVENT(setresuid16, + TP_PROTO(sc_exit(long ret,) old_uid_t ruid, old_uid_t euid, old_uid_t suid), + TP_ARGS(sc_exit(ret,) ruid, euid, suid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(old_uid_t, ruid, ruid)) sc_inout(ctf_integer(old_uid_t, euid, euid)) sc_inout(ctf_integer(old_uid_t, suid, suid))) +) +#endif +#ifndef OVERRIDE_32_setresgid16 +SC_LTTNG_TRACEPOINT_EVENT(setresgid16, + TP_PROTO(sc_exit(long ret,) old_gid_t rgid, old_gid_t egid, old_gid_t sgid), + TP_ARGS(sc_exit(ret,) rgid, egid, sgid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(old_gid_t, rgid, rgid)) sc_inout(ctf_integer(old_gid_t, egid, egid)) sc_inout(ctf_integer(old_gid_t, sgid, sgid))) +) +#endif +#ifndef OVERRIDE_32_fchown +SC_LTTNG_TRACEPOINT_EVENT(fchown, + TP_PROTO(sc_exit(long ret,) unsigned int fd, uid_t user, gid_t group), + TP_ARGS(sc_exit(ret,) fd, user, group), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group))) +) +#endif +#ifndef OVERRIDE_32_setresuid +SC_LTTNG_TRACEPOINT_EVENT(setresuid, + TP_PROTO(sc_exit(long ret,) uid_t ruid, uid_t euid, uid_t suid), + TP_ARGS(sc_exit(ret,) ruid, euid, suid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, ruid, ruid)) sc_in(ctf_integer(uid_t, euid, euid)) sc_in(ctf_integer(uid_t, suid, suid))) +) +#endif +#ifndef OVERRIDE_32_setresgid +SC_LTTNG_TRACEPOINT_EVENT(setresgid, + TP_PROTO(sc_exit(long ret,) gid_t rgid, gid_t egid, gid_t sgid), + TP_ARGS(sc_exit(ret,) rgid, egid, sgid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, rgid, rgid)) sc_in(ctf_integer(gid_t, egid, egid)) sc_in(ctf_integer(gid_t, sgid, sgid))) +) +#endif +#ifndef OVERRIDE_32_madvise +SC_LTTNG_TRACEPOINT_EVENT(madvise, + TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len_in, int behavior), + TP_ARGS(sc_exit(ret,) start, len_in, behavior), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len_in, len_in)) sc_in(ctf_integer(int, behavior, behavior))) +) +#endif +#ifndef OVERRIDE_32_fcntl64 +SC_LTTNG_TRACEPOINT_EVENT(fcntl64, + TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd, unsigned long arg), + TP_ARGS(sc_exit(ret,) fd, cmd, arg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, fd, fd)) sc_inout(ctf_integer(unsigned int, cmd, cmd)) sc_inout(ctf_integer(unsigned long, arg, arg))) +) +#endif +#ifndef OVERRIDE_32_tgkill +SC_LTTNG_TRACEPOINT_EVENT(tgkill, + TP_PROTO(sc_exit(long ret,) pid_t tgid, pid_t pid, int sig), + TP_ARGS(sc_exit(ret,) tgid, pid, sig), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, tgid, tgid)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig))) +) +#endif +#ifndef OVERRIDE_32_socket +SC_LTTNG_TRACEPOINT_EVENT(socket, + TP_PROTO(sc_exit(long ret,) int family, int type, int protocol), + TP_ARGS(sc_exit(ret,) family, type, protocol), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, family, family)) sc_in(ctf_integer(int, type, type)) sc_in(ctf_integer(int, protocol, protocol))) +) +#endif +#ifndef OVERRIDE_32_semget +SC_LTTNG_TRACEPOINT_EVENT(semget, + TP_PROTO(sc_exit(long ret,) key_t key, int nsems, int semflg), + TP_ARGS(sc_exit(ret,) key, nsems, semflg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(key_t, key, key)) sc_in(ctf_integer(int, nsems, nsems)) sc_in(ctf_integer(int, semflg, semflg))) +) +#endif +#ifndef OVERRIDE_32_shmget +SC_LTTNG_TRACEPOINT_EVENT(shmget, + TP_PROTO(sc_exit(long ret,) key_t key, size_t size, int shmflg), + TP_ARGS(sc_exit(ret,) key, size, shmflg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(key_t, key, key)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(int, shmflg, shmflg))) +) +#endif +#ifndef OVERRIDE_32_ioprio_set +SC_LTTNG_TRACEPOINT_EVENT(ioprio_set, + TP_PROTO(sc_exit(long ret,) int which, int who, int ioprio), + TP_ARGS(sc_exit(ret,) which, who, ioprio), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who)) sc_in(ctf_integer(int, ioprio, ioprio))) +) +#endif +#ifndef OVERRIDE_32_dup3 +SC_LTTNG_TRACEPOINT_EVENT(dup3, + TP_PROTO(sc_exit(long ret,) unsigned int oldfd, unsigned int newfd, int flags), + TP_ARGS(sc_exit(ret,) oldfd, newfd, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, oldfd, oldfd)) sc_in(ctf_integer(unsigned int, newfd, newfd)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_ptrace +SC_LTTNG_TRACEPOINT_EVENT(ptrace, + TP_PROTO(sc_exit(long ret,) long request, long pid, unsigned long addr, unsigned long data), + TP_ARGS(sc_exit(ret,) request, pid, addr, data), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(long, request, request)) sc_in(ctf_integer(long, pid, pid)) sc_inout(ctf_integer(unsigned long, addr, addr)) sc_inout(ctf_integer(unsigned long, data, data))) +) +#endif +#ifndef OVERRIDE_32_tee +SC_LTTNG_TRACEPOINT_EVENT(tee, + TP_PROTO(sc_exit(long ret,) int fdin, int fdout, size_t len, unsigned int flags), + TP_ARGS(sc_exit(ret,) fdin, fdout, len, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fdin, fdin)) sc_in(ctf_integer(int, fdout, fdout)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_mremap +SC_LTTNG_TRACEPOINT_EVENT(mremap, + TP_PROTO(sc_exit(long ret,) unsigned long addr, unsigned long old_len, unsigned long new_len, unsigned long flags, unsigned long new_addr), + TP_ARGS(sc_exit(ret,) addr, old_len, new_len, flags, new_addr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, addr, addr)) sc_in(ctf_integer(unsigned long, old_len, old_len)) sc_in(ctf_integer(unsigned long, new_len, new_len)) sc_in(ctf_integer(unsigned long, flags, flags)) sc_in(ctf_integer(unsigned long, new_addr, new_addr))) +) +#endif +#ifndef OVERRIDE_32_prctl +SC_LTTNG_TRACEPOINT_EVENT(prctl, + TP_PROTO(sc_exit(long ret,) int option, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5), + TP_ARGS(sc_exit(ret,) option, arg2, arg3, arg4, arg5), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, option, option)) sc_inout(ctf_integer(unsigned long, arg2, arg2)) sc_in(ctf_integer(unsigned long, arg3, arg3)) sc_in(ctf_integer(unsigned long, arg4, arg4)) sc_in(ctf_integer(unsigned long, arg5, arg5))) +) +#endif +#ifndef OVERRIDE_32_remap_file_pages +SC_LTTNG_TRACEPOINT_EVENT(remap_file_pages, + TP_PROTO(sc_exit(long ret,) unsigned long start, unsigned long size, unsigned long prot, unsigned long pgoff, unsigned long flags), + TP_ARGS(sc_exit(ret,) start, size, prot, pgoff, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(unsigned long, size, size)) sc_in(ctf_integer(unsigned long, prot, prot)) sc_in(ctf_integer(unsigned long, pgoff, pgoff)) sc_in(ctf_integer(unsigned long, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_keyctl +SC_LTTNG_TRACEPOINT_EVENT(keyctl, + TP_PROTO(sc_exit(long ret,) int option, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5), + TP_ARGS(sc_exit(ret,) option, arg2, arg3, arg4, arg5), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, option, option)) sc_inout(ctf_integer(unsigned long, arg2, arg2)) sc_inout(ctf_integer(unsigned long, arg3, arg3)) sc_inout(ctf_integer(unsigned long, arg4, arg4)) sc_inout(ctf_integer(unsigned long, arg5, arg5))) +) +#endif + +#endif /* _TRACE_SYSCALLS_INTEGERS_H */ + +/* This part must be outside protection */ +#include + +#else /* CREATE_SYSCALL_TABLE */ + +#include "arm-32-syscalls_integers_override.h" +#include "syscalls_integers_override.h" + +#ifdef SC_ENTER +#ifndef OVERRIDE_TABLE_32_restart_syscall +TRACE_SYSCALL_TABLE(syscalls_noargs, restart_syscall, 0, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getpid +TRACE_SYSCALL_TABLE(syscalls_noargs, getpid, 20, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getuid16 +TRACE_SYSCALL_TABLE(syscalls_noargs, getuid16, 24, 0) +#endif +#ifndef OVERRIDE_TABLE_32_pause +TRACE_SYSCALL_TABLE(syscalls_noargs, pause, 29, 0) +#endif +#ifndef OVERRIDE_TABLE_32_sync +TRACE_SYSCALL_TABLE(syscalls_noargs, sync, 36, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getgid16 +TRACE_SYSCALL_TABLE(syscalls_noargs, getgid16, 47, 0) +#endif +#ifndef OVERRIDE_TABLE_32_geteuid16 +TRACE_SYSCALL_TABLE(syscalls_noargs, geteuid16, 49, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getegid16 +TRACE_SYSCALL_TABLE(syscalls_noargs, getegid16, 50, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getppid +TRACE_SYSCALL_TABLE(syscalls_noargs, getppid, 64, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getpgrp +TRACE_SYSCALL_TABLE(syscalls_noargs, getpgrp, 65, 0) +#endif +#ifndef OVERRIDE_TABLE_32_setsid +TRACE_SYSCALL_TABLE(syscalls_noargs, setsid, 66, 0) +#endif +#ifndef OVERRIDE_TABLE_32_vhangup +TRACE_SYSCALL_TABLE(syscalls_noargs, vhangup, 111, 0) +#endif +#ifndef OVERRIDE_TABLE_32_munlockall +TRACE_SYSCALL_TABLE(syscalls_noargs, munlockall, 153, 0) +#endif +#ifndef OVERRIDE_TABLE_32_sched_yield +TRACE_SYSCALL_TABLE(syscalls_noargs, sched_yield, 158, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getuid +TRACE_SYSCALL_TABLE(syscalls_noargs, getuid, 199, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getgid +TRACE_SYSCALL_TABLE(syscalls_noargs, getgid, 200, 0) +#endif +#ifndef OVERRIDE_TABLE_32_geteuid +TRACE_SYSCALL_TABLE(syscalls_noargs, geteuid, 201, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getegid +TRACE_SYSCALL_TABLE(syscalls_noargs, getegid, 202, 0) +#endif +#ifndef OVERRIDE_TABLE_32_gettid +TRACE_SYSCALL_TABLE(syscalls_noargs, gettid, 224, 0) +#endif +#ifndef OVERRIDE_TABLE_32_inotify_init +TRACE_SYSCALL_TABLE(syscalls_noargs, inotify_init, 316, 0) +#endif +#else /* #ifdef SC_ENTER */ +#ifndef OVERRIDE_TABLE_32_restart_syscall +TRACE_SYSCALL_TABLE(restart_syscall, restart_syscall, 0, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getpid +TRACE_SYSCALL_TABLE(getpid, getpid, 20, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getuid16 +TRACE_SYSCALL_TABLE(getuid16, getuid16, 24, 0) +#endif +#ifndef OVERRIDE_TABLE_32_pause +TRACE_SYSCALL_TABLE(pause, pause, 29, 0) +#endif +#ifndef OVERRIDE_TABLE_32_sync +TRACE_SYSCALL_TABLE(sync, sync, 36, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getgid16 +TRACE_SYSCALL_TABLE(getgid16, getgid16, 47, 0) +#endif +#ifndef OVERRIDE_TABLE_32_geteuid16 +TRACE_SYSCALL_TABLE(geteuid16, geteuid16, 49, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getegid16 +TRACE_SYSCALL_TABLE(getegid16, getegid16, 50, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getppid +TRACE_SYSCALL_TABLE(getppid, getppid, 64, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getpgrp +TRACE_SYSCALL_TABLE(getpgrp, getpgrp, 65, 0) +#endif +#ifndef OVERRIDE_TABLE_32_setsid +TRACE_SYSCALL_TABLE(setsid, setsid, 66, 0) +#endif +#ifndef OVERRIDE_TABLE_32_vhangup +TRACE_SYSCALL_TABLE(vhangup, vhangup, 111, 0) +#endif +#ifndef OVERRIDE_TABLE_32_munlockall +TRACE_SYSCALL_TABLE(munlockall, munlockall, 153, 0) +#endif +#ifndef OVERRIDE_TABLE_32_sched_yield +TRACE_SYSCALL_TABLE(sched_yield, sched_yield, 158, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getuid +TRACE_SYSCALL_TABLE(getuid, getuid, 199, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getgid +TRACE_SYSCALL_TABLE(getgid, getgid, 200, 0) +#endif +#ifndef OVERRIDE_TABLE_32_geteuid +TRACE_SYSCALL_TABLE(geteuid, geteuid, 201, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getegid +TRACE_SYSCALL_TABLE(getegid, getegid, 202, 0) +#endif +#ifndef OVERRIDE_TABLE_32_gettid +TRACE_SYSCALL_TABLE(gettid, gettid, 224, 0) +#endif +#ifndef OVERRIDE_TABLE_32_inotify_init +TRACE_SYSCALL_TABLE(inotify_init, inotify_init, 316, 0) +#endif +#endif /* else #ifdef SC_ENTER */ +#ifndef OVERRIDE_TABLE_32_exit +TRACE_SYSCALL_TABLE(exit, exit, 1, 1) +#endif +#ifndef OVERRIDE_TABLE_32_close +TRACE_SYSCALL_TABLE(close, close, 6, 1) +#endif +#ifndef OVERRIDE_TABLE_32_lseek +TRACE_SYSCALL_TABLE(lseek, lseek, 19, 3) +#endif +#ifndef OVERRIDE_TABLE_32_setuid16 +TRACE_SYSCALL_TABLE(setuid16, setuid16, 23, 1) +#endif +#ifndef OVERRIDE_TABLE_32_ptrace +TRACE_SYSCALL_TABLE(ptrace, ptrace, 26, 4) +#endif +#ifndef OVERRIDE_TABLE_32_nice +TRACE_SYSCALL_TABLE(nice, nice, 34, 1) +#endif +#ifndef OVERRIDE_TABLE_32_kill +TRACE_SYSCALL_TABLE(kill, kill, 37, 2) +#endif +#ifndef OVERRIDE_TABLE_32_dup +TRACE_SYSCALL_TABLE(dup, dup, 41, 1) +#endif +#ifndef OVERRIDE_TABLE_32_brk +TRACE_SYSCALL_TABLE(brk, brk, 45, 1) +#endif +#ifndef OVERRIDE_TABLE_32_setgid16 +TRACE_SYSCALL_TABLE(setgid16, setgid16, 46, 1) +#endif +#ifndef OVERRIDE_TABLE_32_ioctl +TRACE_SYSCALL_TABLE(ioctl, ioctl, 54, 3) +#endif +#ifndef OVERRIDE_TABLE_32_fcntl +TRACE_SYSCALL_TABLE(fcntl, fcntl, 55, 3) +#endif +#ifndef OVERRIDE_TABLE_32_setpgid +TRACE_SYSCALL_TABLE(setpgid, setpgid, 57, 2) +#endif +#ifndef OVERRIDE_TABLE_32_umask +TRACE_SYSCALL_TABLE(umask, umask, 60, 1) +#endif +#ifndef OVERRIDE_TABLE_32_dup2 +TRACE_SYSCALL_TABLE(dup2, dup2, 63, 2) +#endif +#ifndef OVERRIDE_TABLE_32_setreuid16 +TRACE_SYSCALL_TABLE(setreuid16, setreuid16, 70, 2) +#endif +#ifndef OVERRIDE_TABLE_32_setregid16 +TRACE_SYSCALL_TABLE(setregid16, setregid16, 71, 2) +#endif +#ifndef OVERRIDE_TABLE_32_munmap +TRACE_SYSCALL_TABLE(munmap, munmap, 91, 2) +#endif +#ifndef OVERRIDE_TABLE_32_ftruncate +TRACE_SYSCALL_TABLE(ftruncate, ftruncate, 93, 2) +#endif +#ifndef OVERRIDE_TABLE_32_fchmod +TRACE_SYSCALL_TABLE(fchmod, fchmod, 94, 2) +#endif +#ifndef OVERRIDE_TABLE_32_fchown16 +TRACE_SYSCALL_TABLE(fchown16, fchown16, 95, 3) +#endif +#ifndef OVERRIDE_TABLE_32_getpriority +TRACE_SYSCALL_TABLE(getpriority, getpriority, 96, 2) +#endif +#ifndef OVERRIDE_TABLE_32_setpriority +TRACE_SYSCALL_TABLE(setpriority, setpriority, 97, 3) +#endif +#ifndef OVERRIDE_TABLE_32_fsync +TRACE_SYSCALL_TABLE(fsync, fsync, 118, 1) +#endif +#ifndef OVERRIDE_TABLE_32_mprotect +TRACE_SYSCALL_TABLE(mprotect, mprotect, 125, 3) +#endif +#ifndef OVERRIDE_TABLE_32_getpgid +TRACE_SYSCALL_TABLE(getpgid, getpgid, 132, 1) +#endif +#ifndef OVERRIDE_TABLE_32_fchdir +TRACE_SYSCALL_TABLE(fchdir, fchdir, 133, 1) +#endif +#ifndef OVERRIDE_TABLE_32_bdflush +TRACE_SYSCALL_TABLE(bdflush, bdflush, 134, 2) +#endif +#ifndef OVERRIDE_TABLE_32_sysfs +TRACE_SYSCALL_TABLE(sysfs, sysfs, 135, 3) +#endif +#ifndef OVERRIDE_TABLE_32_personality +TRACE_SYSCALL_TABLE(personality, personality, 136, 1) +#endif +#ifndef OVERRIDE_TABLE_32_setfsuid16 +TRACE_SYSCALL_TABLE(setfsuid16, setfsuid16, 138, 1) +#endif +#ifndef OVERRIDE_TABLE_32_setfsgid16 +TRACE_SYSCALL_TABLE(setfsgid16, setfsgid16, 139, 1) +#endif +#ifndef OVERRIDE_TABLE_32_flock +TRACE_SYSCALL_TABLE(flock, flock, 143, 2) +#endif +#ifndef OVERRIDE_TABLE_32_msync +TRACE_SYSCALL_TABLE(msync, msync, 144, 3) +#endif +#ifndef OVERRIDE_TABLE_32_getsid +TRACE_SYSCALL_TABLE(getsid, getsid, 147, 1) +#endif +#ifndef OVERRIDE_TABLE_32_fdatasync +TRACE_SYSCALL_TABLE(fdatasync, fdatasync, 148, 1) +#endif +#ifndef OVERRIDE_TABLE_32_mlock +TRACE_SYSCALL_TABLE(mlock, mlock, 150, 2) +#endif +#ifndef OVERRIDE_TABLE_32_munlock +TRACE_SYSCALL_TABLE(munlock, munlock, 151, 2) +#endif +#ifndef OVERRIDE_TABLE_32_mlockall +TRACE_SYSCALL_TABLE(mlockall, mlockall, 152, 1) +#endif +#ifndef OVERRIDE_TABLE_32_sched_getscheduler +TRACE_SYSCALL_TABLE(sched_getscheduler, sched_getscheduler, 157, 1) +#endif +#ifndef OVERRIDE_TABLE_32_sched_get_priority_max +TRACE_SYSCALL_TABLE(sched_get_priority_max, sched_get_priority_max, 159, 1) +#endif +#ifndef OVERRIDE_TABLE_32_sched_get_priority_min +TRACE_SYSCALL_TABLE(sched_get_priority_min, sched_get_priority_min, 160, 1) +#endif +#ifndef OVERRIDE_TABLE_32_mremap +TRACE_SYSCALL_TABLE(mremap, mremap, 163, 5) +#endif +#ifndef OVERRIDE_TABLE_32_setresuid16 +TRACE_SYSCALL_TABLE(setresuid16, setresuid16, 164, 3) +#endif +#ifndef OVERRIDE_TABLE_32_setresgid16 +TRACE_SYSCALL_TABLE(setresgid16, setresgid16, 170, 3) +#endif +#ifndef OVERRIDE_TABLE_32_prctl +TRACE_SYSCALL_TABLE(prctl, prctl, 172, 5) +#endif +#ifndef OVERRIDE_TABLE_32_setreuid +TRACE_SYSCALL_TABLE(setreuid, setreuid, 203, 2) +#endif +#ifndef OVERRIDE_TABLE_32_setregid +TRACE_SYSCALL_TABLE(setregid, setregid, 204, 2) +#endif +#ifndef OVERRIDE_TABLE_32_fchown +TRACE_SYSCALL_TABLE(fchown, fchown, 207, 3) +#endif +#ifndef OVERRIDE_TABLE_32_setresuid +TRACE_SYSCALL_TABLE(setresuid, setresuid, 208, 3) +#endif +#ifndef OVERRIDE_TABLE_32_setresgid +TRACE_SYSCALL_TABLE(setresgid, setresgid, 210, 3) +#endif +#ifndef OVERRIDE_TABLE_32_setuid +TRACE_SYSCALL_TABLE(setuid, setuid, 213, 1) +#endif +#ifndef OVERRIDE_TABLE_32_setgid +TRACE_SYSCALL_TABLE(setgid, setgid, 214, 1) +#endif +#ifndef OVERRIDE_TABLE_32_setfsuid +TRACE_SYSCALL_TABLE(setfsuid, setfsuid, 215, 1) +#endif +#ifndef OVERRIDE_TABLE_32_setfsgid +TRACE_SYSCALL_TABLE(setfsgid, setfsgid, 216, 1) +#endif +#ifndef OVERRIDE_TABLE_32_madvise +TRACE_SYSCALL_TABLE(madvise, madvise, 220, 3) +#endif +#ifndef OVERRIDE_TABLE_32_fcntl64 +TRACE_SYSCALL_TABLE(fcntl64, fcntl64, 221, 3) +#endif +#ifndef OVERRIDE_TABLE_32_tkill +TRACE_SYSCALL_TABLE(tkill, tkill, 238, 2) +#endif +#ifndef OVERRIDE_TABLE_32_io_destroy +TRACE_SYSCALL_TABLE(io_destroy, io_destroy, 244, 1) +#endif +#ifndef OVERRIDE_TABLE_32_exit_group +TRACE_SYSCALL_TABLE(exit_group, exit_group, 248, 1) +#endif +#ifndef OVERRIDE_TABLE_32_epoll_create +TRACE_SYSCALL_TABLE(epoll_create, epoll_create, 250, 1) +#endif +#ifndef OVERRIDE_TABLE_32_remap_file_pages +TRACE_SYSCALL_TABLE(remap_file_pages, remap_file_pages, 253, 5) +#endif +#ifndef OVERRIDE_TABLE_32_timer_getoverrun +TRACE_SYSCALL_TABLE(timer_getoverrun, timer_getoverrun, 260, 1) +#endif +#ifndef OVERRIDE_TABLE_32_timer_delete +TRACE_SYSCALL_TABLE(timer_delete, timer_delete, 261, 1) +#endif +#ifndef OVERRIDE_TABLE_32_tgkill +TRACE_SYSCALL_TABLE(tgkill, tgkill, 268, 3) +#endif +#ifndef OVERRIDE_TABLE_32_socket +TRACE_SYSCALL_TABLE(socket, socket, 281, 3) +#endif +#ifndef OVERRIDE_TABLE_32_listen +TRACE_SYSCALL_TABLE(listen, listen, 284, 2) +#endif +#ifndef OVERRIDE_TABLE_32_shutdown +TRACE_SYSCALL_TABLE(shutdown, shutdown, 293, 2) +#endif +#ifndef OVERRIDE_TABLE_32_semget +TRACE_SYSCALL_TABLE(semget, semget, 299, 3) +#endif +#ifndef OVERRIDE_TABLE_32_msgget +TRACE_SYSCALL_TABLE(msgget, msgget, 303, 2) +#endif +#ifndef OVERRIDE_TABLE_32_shmget +TRACE_SYSCALL_TABLE(shmget, shmget, 307, 3) +#endif +#ifndef OVERRIDE_TABLE_32_keyctl +TRACE_SYSCALL_TABLE(keyctl, keyctl, 311, 5) +#endif +#ifndef OVERRIDE_TABLE_32_ioprio_set +TRACE_SYSCALL_TABLE(ioprio_set, ioprio_set, 314, 3) +#endif +#ifndef OVERRIDE_TABLE_32_ioprio_get +TRACE_SYSCALL_TABLE(ioprio_get, ioprio_get, 315, 2) +#endif +#ifndef OVERRIDE_TABLE_32_inotify_rm_watch +TRACE_SYSCALL_TABLE(inotify_rm_watch, inotify_rm_watch, 318, 2) +#endif +#ifndef OVERRIDE_TABLE_32_unshare +TRACE_SYSCALL_TABLE(unshare, unshare, 337, 1) +#endif +#ifndef OVERRIDE_TABLE_32_tee +TRACE_SYSCALL_TABLE(tee, tee, 342, 4) +#endif +#ifndef OVERRIDE_TABLE_32_timerfd_create +TRACE_SYSCALL_TABLE(timerfd_create, timerfd_create, 350, 2) +#endif +#ifndef OVERRIDE_TABLE_32_eventfd +TRACE_SYSCALL_TABLE(eventfd, eventfd, 351, 1) +#endif +#ifndef OVERRIDE_TABLE_32_eventfd2 +TRACE_SYSCALL_TABLE(eventfd2, eventfd2, 356, 2) +#endif +#ifndef OVERRIDE_TABLE_32_epoll_create1 +TRACE_SYSCALL_TABLE(epoll_create1, epoll_create1, 357, 1) +#endif +#ifndef OVERRIDE_TABLE_32_dup3 +TRACE_SYSCALL_TABLE(dup3, dup3, 358, 3) +#endif +#ifndef OVERRIDE_TABLE_32_inotify_init1 +TRACE_SYSCALL_TABLE(inotify_init1, inotify_init1, 360, 1) +#endif +#ifndef OVERRIDE_TABLE_32_fanotify_init +TRACE_SYSCALL_TABLE(fanotify_init, fanotify_init, 367, 2) +#endif +#ifndef OVERRIDE_TABLE_32_syncfs +TRACE_SYSCALL_TABLE(syncfs, syncfs, 373, 1) +#endif +#ifndef OVERRIDE_TABLE_32_setns +TRACE_SYSCALL_TABLE(setns, setns, 375, 2) +#endif + +#endif /* CREATE_SYSCALL_TABLE */ diff --git a/include/instrumentation/syscalls/headers/arm-32-syscalls_integers_override.h b/include/instrumentation/syscalls/headers/arm-32-syscalls_integers_override.h new file mode 100644 index 00000000..4dfbdebf --- /dev/null +++ b/include/instrumentation/syscalls/headers/arm-32-syscalls_integers_override.h @@ -0,0 +1,143 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ + +#ifndef CONFIG_UID16 + +#define OVERRIDE_32_getuid16 +#define OVERRIDE_32_getgid16 +#define OVERRIDE_32_geteuid16 +#define OVERRIDE_32_getegid16 +#define OVERRIDE_32_setuid16 +#define OVERRIDE_32_setgid16 +#define OVERRIDE_32_setfsuid16 +#define OVERRIDE_32_setfsgid16 +#define OVERRIDE_32_setreuid16 +#define OVERRIDE_32_setregid16 +#define OVERRIDE_32_fchown16 +#define OVERRIDE_32_setresuid16 +#define OVERRIDE_32_setresgid16 + +#define OVERRIDE_TABLE_32_getuid16 +#define OVERRIDE_TABLE_32_getgid16 +#define OVERRIDE_TABLE_32_geteuid16 +#define OVERRIDE_TABLE_32_getegid16 +#define OVERRIDE_TABLE_32_setuid16 +#define OVERRIDE_TABLE_32_setgid16 +#define OVERRIDE_TABLE_32_setreuid16 +#define OVERRIDE_TABLE_32_setregid16 +#define OVERRIDE_TABLE_32_fchown16 +#define OVERRIDE_TABLE_32_setfsuid16 +#define OVERRIDE_TABLE_32_setfsgid16 +#define OVERRIDE_TABLE_32_setresuid16 +#define OVERRIDE_TABLE_32_setresgid16 + +#endif + +#ifndef CREATE_SYSCALL_TABLE + +#if (__BYTE_ORDER == __LITTLE_ENDIAN) + +#define OVERRIDE_32_arm_fadvise64_64 +SC_LTTNG_TRACEPOINT_EVENT(arm_fadvise64_64, + TP_PROTO(sc_exit(long ret,) int fd, int advice, + int32_t offset_low, int32_t offset_high, + int32_t len_low, int32_t len_high), + TP_ARGS(sc_exit(ret,) fd, advice, offset_low, offset_high, + len_low, len_high), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) + sc_in(ctf_integer(int, fd, fd)) + sc_in(ctf_integer(int, advice, advice)) + sc_in(ctf_integer(loff_t, offset, + ((loff_t) offset_high << 32) | offset_low)) + sc_in(ctf_integer(loff_t, len, + ((loff_t) len_high << 32) | len_low)) + ) +) + +#define OVERRIDE_32_sync_file_range2 +SC_LTTNG_TRACEPOINT_EVENT(sync_file_range2, + TP_PROTO(sc_exit(long ret,) int fd, + unsigned int flags, + int32_t offset_low, int32_t offset_high, + int32_t nbytes_low, int32_t nbytes_high), + TP_ARGS(sc_exit(ret,) fd, flags, offset_low, offset_high, + nbytes_low, nbytes_high), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) + sc_in(ctf_integer(int, fd, fd)) + sc_in(ctf_integer(unsigned int, flags, flags)) + sc_in(ctf_integer(loff_t, offset, + ((loff_t) offset_high << 32) | offset_low)) + sc_in(ctf_integer(loff_t, nbytes, + ((loff_t) nbytes_high << 32) | nbytes_low)) + ) +) + +#else /* __BIG_ENDIAN */ + +#define OVERRIDE_32_arm_fadvise64_64 +SC_LTTNG_TRACEPOINT_EVENT(arm_fadvise64_64, + TP_PROTO(sc_exit(long ret,) int fd, int advice, + int32_t offset_high, int32_t offset_low, + int32_t len_high, int32_t len_low), + TP_ARGS(sc_exit(ret,) fd, advice, offset_high, offset_low, + len_high, len_low), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) + sc_in(ctf_integer(int, fd, fd)) + sc_in(ctf_integer(int, advice, advice)) + sc_in(ctf_integer(loff_t, offset, + ((loff_t) offset_high << 32) | offset_low)) + sc_in(ctf_integer(loff_t, len, + ((loff_t) len_high << 32) | len_low)) + ) +) + +#define OVERRIDE_32_sync_file_range2 +SC_LTTNG_TRACEPOINT_EVENT(sync_file_range2, + TP_PROTO(sc_exit(long ret,) int fd, + unsigned int flags, + int32_t offset_high, int32_t offset_low, + int32_t nbytes_high, int32_t nbytes_low), + TP_ARGS(sc_exit(ret,) fd, flags, offset_high, offset_low, + nbytes_high, nbytes_low), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) + sc_in(ctf_integer(int, fd, fd)) + sc_in(ctf_integer(unsigned int, flags, flags)) + sc_in(ctf_integer(loff_t, offset, + ((loff_t) offset_high << 32) | offset_low)) + sc_in(ctf_integer(loff_t, nbytes, + ((loff_t) nbytes_high << 32) | nbytes_low)) + ) +) + +#endif + +#define OVERRIDE_32_mmap2 +SC_LTTNG_TRACEPOINT_EVENT(mmap2, + TP_PROTO(sc_exit(unsigned long ret,) + unsigned long addr, unsigned long len, + unsigned long prot, unsigned long flags, + unsigned long fd, unsigned long pgoff), + TP_ARGS(sc_exit(ret,) addr, len, prot, flags, fd, pgoff), + TP_FIELDS(sc_exit(ctf_integer_hex(unsigned long, ret, ret)) + sc_in(ctf_integer_hex(unsigned long, addr, addr)) + sc_in(ctf_integer(size_t, len, len)) + sc_in(ctf_integer(int, prot, prot)) + sc_in(ctf_integer(int, flags, flags)) + sc_in(ctf_integer(int, fd, fd)) + sc_in(ctf_integer(off_t, pgoff, pgoff)) + ) +) + +#else /* CREATE_SYSCALL_TABLE */ + +#define OVERRIDE_TABLE_32_mmap +TRACE_SYSCALL_TABLE(mmap, mmap, 90, 6) +#define OVERRIDE_TABLE_32_mmap2 +TRACE_SYSCALL_TABLE(mmap2, mmap2, 192, 6) +#define OVERRIDE_TABLE_32_arm_fadvise64_64 +TRACE_SYSCALL_TABLE(arm_fadvise64_64, arm_fadvise64_64, 270, 6) +#define OVERRIDE_TABLE_32_sync_file_range2 +TRACE_SYSCALL_TABLE(sync_file_range2, sync_file_range2, 341, 6) + +#endif /* CREATE_SYSCALL_TABLE */ + + diff --git a/include/instrumentation/syscalls/headers/arm-32-syscalls_pointers.h b/include/instrumentation/syscalls/headers/arm-32-syscalls_pointers.h new file mode 100644 index 00000000..73122679 --- /dev/null +++ b/include/instrumentation/syscalls/headers/arm-32-syscalls_pointers.h @@ -0,0 +1,1939 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ + +/* THIS FILE IS AUTO-GENERATED. DO NOT EDIT */ + +/* Generated from arm-32-syscalls 3.4.25 */ + +#ifndef CREATE_SYSCALL_TABLE + +#if !defined(_TRACE_SYSCALLS_POINTERS_H) || defined(TRACE_HEADER_MULTI_READ) +#define _TRACE_SYSCALLS_POINTERS_H + +#include +#include +#include "arm-32-syscalls_pointers_override.h" +#include "syscalls_pointers_override.h" + +#ifndef OVERRIDE_32_unlink +SC_LTTNG_TRACEPOINT_EVENT(unlink, + TP_PROTO(sc_exit(long ret,) const char * pathname), + TP_ARGS(sc_exit(ret,) pathname), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname))) +) +#endif +#ifndef OVERRIDE_32_chdir +SC_LTTNG_TRACEPOINT_EVENT(chdir, + TP_PROTO(sc_exit(long ret,) const char * filename), + TP_ARGS(sc_exit(ret,) filename), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename))) +) +#endif +#ifndef OVERRIDE_32_rmdir +SC_LTTNG_TRACEPOINT_EVENT(rmdir, + TP_PROTO(sc_exit(long ret,) const char * pathname), + TP_ARGS(sc_exit(ret,) pathname), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname))) +) +#endif +#ifndef OVERRIDE_32_pipe +SC_LTTNG_TRACEPOINT_EVENT(pipe, + TP_PROTO(sc_exit(long ret,) int * fildes), + TP_ARGS(sc_exit(ret,) fildes), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(int *, fildes, fildes))) +) +#endif +#ifndef OVERRIDE_32_times +SC_LTTNG_TRACEPOINT_EVENT(times, + TP_PROTO(sc_exit(long ret,) struct tms * tbuf), + TP_ARGS(sc_exit(ret,) tbuf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct tms *, tbuf, tbuf))) +) +#endif +#ifndef OVERRIDE_32_acct +SC_LTTNG_TRACEPOINT_EVENT(acct, + TP_PROTO(sc_exit(long ret,) const char * name), + TP_ARGS(sc_exit(ret,) name), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name))) +) +#endif +#ifndef OVERRIDE_32_chroot +SC_LTTNG_TRACEPOINT_EVENT(chroot, + TP_PROTO(sc_exit(long ret,) const char * filename), + TP_ARGS(sc_exit(ret,) filename), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename))) +) +#endif +#ifndef OVERRIDE_32_sigpending +SC_LTTNG_TRACEPOINT_EVENT(sigpending, + TP_PROTO(sc_exit(long ret,) old_sigset_t * set), + TP_ARGS(sc_exit(ret,) set), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(old_sigset_t *, set, set))) +) +#endif +#ifndef OVERRIDE_32_uselib +SC_LTTNG_TRACEPOINT_EVENT(uselib, + TP_PROTO(sc_exit(long ret,) const char * library), + TP_ARGS(sc_exit(ret,) library), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(const char *, library, library))) +) +#endif +#ifndef OVERRIDE_32_swapoff +SC_LTTNG_TRACEPOINT_EVENT(swapoff, + TP_PROTO(sc_exit(long ret,) const char * specialfile), + TP_ARGS(sc_exit(ret,) specialfile), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(specialfile, specialfile))) +) +#endif +#ifndef OVERRIDE_32_sysinfo +SC_LTTNG_TRACEPOINT_EVENT(sysinfo, + TP_PROTO(sc_exit(long ret,) struct sysinfo * info), + TP_ARGS(sc_exit(ret,) info), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct sysinfo *, info, info))) +) +#endif +#ifndef OVERRIDE_32_newuname +SC_LTTNG_TRACEPOINT_EVENT(newuname, + TP_PROTO(sc_exit(long ret,) struct new_utsname * name), + TP_ARGS(sc_exit(ret,) name), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct new_utsname *, name, name))) +) +#endif +#ifndef OVERRIDE_32_adjtimex +SC_LTTNG_TRACEPOINT_EVENT(adjtimex, + TP_PROTO(sc_exit(long ret,) struct timex * txc_p), + TP_ARGS(sc_exit(ret,) txc_p), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct timex *, txc_p, txc_p))) +) +#endif +#ifndef OVERRIDE_32_sysctl +SC_LTTNG_TRACEPOINT_EVENT(sysctl, + TP_PROTO(sc_exit(long ret,) struct __sysctl_args * args), + TP_ARGS(sc_exit(ret,) args), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct __sysctl_args *, args, args))) +) +#endif +#ifndef OVERRIDE_32_set_tid_address +SC_LTTNG_TRACEPOINT_EVENT(set_tid_address, + TP_PROTO(sc_exit(long ret,) int * tidptr), + TP_ARGS(sc_exit(ret,) tidptr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int *, tidptr, tidptr))) +) +#endif +#ifndef OVERRIDE_32_mq_unlink +SC_LTTNG_TRACEPOINT_EVENT(mq_unlink, + TP_PROTO(sc_exit(long ret,) const char * u_name), + TP_ARGS(sc_exit(ret,) u_name), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(u_name, u_name))) +) +#endif +#ifndef OVERRIDE_32_shmdt +SC_LTTNG_TRACEPOINT_EVENT(shmdt, + TP_PROTO(sc_exit(long ret,) char * shmaddr), + TP_ARGS(sc_exit(ret,) shmaddr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(char *, shmaddr, shmaddr))) +) +#endif +#ifndef OVERRIDE_32_creat +SC_LTTNG_TRACEPOINT_EVENT(creat, + TP_PROTO(sc_exit(long ret,) const char * pathname, umode_t mode), + TP_ARGS(sc_exit(ret,) pathname, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(umode_t, mode, mode))) +) +#endif +#ifndef OVERRIDE_32_link +SC_LTTNG_TRACEPOINT_EVENT(link, + TP_PROTO(sc_exit(long ret,) const char * oldname, const char * newname), + TP_ARGS(sc_exit(ret,) oldname, newname), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_user_string(newname, newname))) +) +#endif +#ifndef OVERRIDE_32_chmod +SC_LTTNG_TRACEPOINT_EVENT(chmod, + TP_PROTO(sc_exit(long ret,) const char * filename, umode_t mode), + TP_ARGS(sc_exit(ret,) filename, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(umode_t, mode, mode))) +) +#endif +#ifndef OVERRIDE_32_access +SC_LTTNG_TRACEPOINT_EVENT(access, + TP_PROTO(sc_exit(long ret,) const char * filename, int mode), + TP_ARGS(sc_exit(ret,) filename, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, mode, mode))) +) +#endif +#ifndef OVERRIDE_32_rename +SC_LTTNG_TRACEPOINT_EVENT(rename, + TP_PROTO(sc_exit(long ret,) const char * oldname, const char * newname), + TP_ARGS(sc_exit(ret,) oldname, newname), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_user_string(newname, newname))) +) +#endif +#ifndef OVERRIDE_32_mkdir +SC_LTTNG_TRACEPOINT_EVENT(mkdir, + TP_PROTO(sc_exit(long ret,) const char * pathname, umode_t mode), + TP_ARGS(sc_exit(ret,) pathname, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(umode_t, mode, mode))) +) +#endif +#ifndef OVERRIDE_32_umount +SC_LTTNG_TRACEPOINT_EVENT(umount, + TP_PROTO(sc_exit(long ret,) char * name, int flags), + TP_ARGS(sc_exit(ret,) name, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_ustat +SC_LTTNG_TRACEPOINT_EVENT(ustat, + TP_PROTO(sc_exit(long ret,) unsigned dev, struct ustat * ubuf), + TP_ARGS(sc_exit(ret,) dev, ubuf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned, dev, dev)) sc_out(ctf_integer(struct ustat *, ubuf, ubuf))) +) +#endif +#ifndef OVERRIDE_32_sethostname +SC_LTTNG_TRACEPOINT_EVENT(sethostname, + TP_PROTO(sc_exit(long ret,) char * name, int len), + TP_ARGS(sc_exit(ret,) name, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(int, len, len))) +) +#endif +#ifndef OVERRIDE_32_setrlimit +SC_LTTNG_TRACEPOINT_EVENT(setrlimit, + TP_PROTO(sc_exit(long ret,) unsigned int resource, struct rlimit * rlim), + TP_ARGS(sc_exit(ret,) resource, rlim), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, resource, resource)) sc_in(ctf_integer(struct rlimit *, rlim, rlim))) +) +#endif +#ifndef OVERRIDE_32_getrusage +SC_LTTNG_TRACEPOINT_EVENT(getrusage, + TP_PROTO(sc_exit(long ret,) int who, struct rusage * ru), + TP_ARGS(sc_exit(ret,) who, ru), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, who, who)) sc_out(ctf_integer(struct rusage *, ru, ru))) +) +#endif +#ifndef OVERRIDE_32_gettimeofday +SC_LTTNG_TRACEPOINT_EVENT(gettimeofday, + TP_PROTO(sc_exit(long ret,) struct timeval * tv, struct timezone * tz), + TP_ARGS(sc_exit(ret,) tv, tz), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct timeval *, tv, tv)) sc_out(ctf_integer(struct timezone *, tz, tz))) +) +#endif +#ifndef OVERRIDE_32_settimeofday +SC_LTTNG_TRACEPOINT_EVENT(settimeofday, + TP_PROTO(sc_exit(long ret,) struct timeval * tv, struct timezone * tz), + TP_ARGS(sc_exit(ret,) tv, tz), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct timeval *, tv, tv)) sc_in(ctf_integer(struct timezone *, tz, tz))) +) +#endif +#ifndef OVERRIDE_32_getgroups16 +SC_LTTNG_TRACEPOINT_EVENT(getgroups16, + TP_PROTO(sc_exit(long ret,) int gidsetsize, old_gid_t * grouplist), + TP_ARGS(sc_exit(ret,) gidsetsize, grouplist), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, gidsetsize, gidsetsize)) sc_inout(ctf_integer(old_gid_t *, grouplist, grouplist))) +) +#endif +#ifndef OVERRIDE_32_setgroups16 +SC_LTTNG_TRACEPOINT_EVENT(setgroups16, + TP_PROTO(sc_exit(long ret,) int gidsetsize, old_gid_t * grouplist), + TP_ARGS(sc_exit(ret,) gidsetsize, grouplist), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, gidsetsize, gidsetsize)) sc_inout(ctf_integer(old_gid_t *, grouplist, grouplist))) +) +#endif +#ifndef OVERRIDE_32_symlink +SC_LTTNG_TRACEPOINT_EVENT(symlink, + TP_PROTO(sc_exit(long ret,) const char * oldname, const char * newname), + TP_ARGS(sc_exit(ret,) oldname, newname), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_user_string(newname, newname))) +) +#endif +#ifndef OVERRIDE_32_swapon +SC_LTTNG_TRACEPOINT_EVENT(swapon, + TP_PROTO(sc_exit(long ret,) const char * specialfile, int swap_flags), + TP_ARGS(sc_exit(ret,) specialfile, swap_flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(specialfile, specialfile)) sc_in(ctf_integer(int, swap_flags, swap_flags))) +) +#endif +#ifndef OVERRIDE_32_truncate +SC_LTTNG_TRACEPOINT_EVENT(truncate, + TP_PROTO(sc_exit(long ret,) const char * path, long length), + TP_ARGS(sc_exit(ret,) path, length), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(path, path)) sc_in(ctf_integer(long, length, length))) +) +#endif +#ifndef OVERRIDE_32_statfs +SC_LTTNG_TRACEPOINT_EVENT(statfs, + TP_PROTO(sc_exit(long ret,) const char * pathname, struct statfs * buf), + TP_ARGS(sc_exit(ret,) pathname, buf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(struct statfs *, buf, buf))) +) +#endif +#ifndef OVERRIDE_32_fstatfs +SC_LTTNG_TRACEPOINT_EVENT(fstatfs, + TP_PROTO(sc_exit(long ret,) unsigned int fd, struct statfs * buf), + TP_ARGS(sc_exit(ret,) fd, buf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct statfs *, buf, buf))) +) +#endif +#ifndef OVERRIDE_32_getitimer +SC_LTTNG_TRACEPOINT_EVENT(getitimer, + TP_PROTO(sc_exit(long ret,) int which, struct itimerval * value), + TP_ARGS(sc_exit(ret,) which, value), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_out(ctf_integer(struct itimerval *, value, value))) +) +#endif +#ifndef OVERRIDE_32_newstat +SC_LTTNG_TRACEPOINT_EVENT(newstat, + TP_PROTO(sc_exit(long ret,) const char * filename, struct stat * statbuf), + TP_ARGS(sc_exit(ret,) filename, statbuf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_out(ctf_integer(struct stat *, statbuf, statbuf))) +) +#endif +#ifndef OVERRIDE_32_newlstat +SC_LTTNG_TRACEPOINT_EVENT(newlstat, + TP_PROTO(sc_exit(long ret,) const char * filename, struct stat * statbuf), + TP_ARGS(sc_exit(ret,) filename, statbuf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_out(ctf_integer(struct stat *, statbuf, statbuf))) +) +#endif +#ifndef OVERRIDE_32_newfstat +SC_LTTNG_TRACEPOINT_EVENT(newfstat, + TP_PROTO(sc_exit(long ret,) unsigned int fd, struct stat * statbuf), + TP_ARGS(sc_exit(ret,) fd, statbuf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct stat *, statbuf, statbuf))) +) +#endif +#ifndef OVERRIDE_32_setdomainname +SC_LTTNG_TRACEPOINT_EVENT(setdomainname, + TP_PROTO(sc_exit(long ret,) char * name, int len), + TP_ARGS(sc_exit(ret,) name, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(int, len, len))) +) +#endif +#ifndef OVERRIDE_32_delete_module +SC_LTTNG_TRACEPOINT_EVENT(delete_module, + TP_PROTO(sc_exit(long ret,) const char * name_user, unsigned int flags), + TP_ARGS(sc_exit(ret,) name_user, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name_user, name_user)) sc_in(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_sched_setparam +SC_LTTNG_TRACEPOINT_EVENT(sched_setparam, + TP_PROTO(sc_exit(long ret,) pid_t pid, struct sched_param * param), + TP_ARGS(sc_exit(ret,) pid, param), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(struct sched_param *, param, param))) +) +#endif +#ifndef OVERRIDE_32_sched_getparam +SC_LTTNG_TRACEPOINT_EVENT(sched_getparam, + TP_PROTO(sc_exit(long ret,) pid_t pid, struct sched_param * param), + TP_ARGS(sc_exit(ret,) pid, param), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_out(ctf_integer(struct sched_param *, param, param))) +) +#endif +#ifndef OVERRIDE_32_sched_rr_get_interval +SC_LTTNG_TRACEPOINT_EVENT(sched_rr_get_interval, + TP_PROTO(sc_exit(long ret,) pid_t pid, struct timespec * interval), + TP_ARGS(sc_exit(ret,) pid, interval), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_out(ctf_integer(struct timespec *, interval, interval))) +) +#endif +#ifndef OVERRIDE_32_nanosleep +SC_LTTNG_TRACEPOINT_EVENT(nanosleep, + TP_PROTO(sc_exit(long ret,) struct timespec * rqtp, struct timespec * rmtp), + TP_ARGS(sc_exit(ret,) rqtp, rmtp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct timespec *, rqtp, rqtp)) sc_out(ctf_integer(struct timespec *, rmtp, rmtp))) +) +#endif +#ifndef OVERRIDE_32_rt_sigpending +SC_LTTNG_TRACEPOINT_EVENT(rt_sigpending, + TP_PROTO(sc_exit(long ret,) sigset_t * set, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) set, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(sigset_t *, set, set)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) +) +#endif +#ifndef OVERRIDE_32_rt_sigsuspend +SC_LTTNG_TRACEPOINT_EVENT(rt_sigsuspend, + TP_PROTO(sc_exit(long ret,) sigset_t * unewset, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) unewset, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(sigset_t *, unewset, unewset)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) +) +#endif +#ifndef OVERRIDE_32_getcwd +SC_LTTNG_TRACEPOINT_EVENT(getcwd, + TP_PROTO(sc_exit(long ret,) char * buf, unsigned long size), + TP_ARGS(sc_exit(ret,) buf, size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(unsigned long, size, size))) +) +#endif +#ifndef OVERRIDE_32_getrlimit +SC_LTTNG_TRACEPOINT_EVENT(getrlimit, + TP_PROTO(sc_exit(long ret,) unsigned int resource, struct rlimit * rlim), + TP_ARGS(sc_exit(ret,) resource, rlim), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, resource, resource)) sc_out(ctf_integer(struct rlimit *, rlim, rlim))) +) +#endif +#ifndef OVERRIDE_32_stat64 +SC_LTTNG_TRACEPOINT_EVENT(stat64, + TP_PROTO(sc_exit(long ret,) const char * filename, struct stat64 * statbuf), + TP_ARGS(sc_exit(ret,) filename, statbuf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(filename, filename)) sc_inout(ctf_integer(struct stat64 *, statbuf, statbuf))) +) +#endif +#ifndef OVERRIDE_32_lstat64 +SC_LTTNG_TRACEPOINT_EVENT(lstat64, + TP_PROTO(sc_exit(long ret,) const char * filename, struct stat64 * statbuf), + TP_ARGS(sc_exit(ret,) filename, statbuf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(filename, filename)) sc_inout(ctf_integer(struct stat64 *, statbuf, statbuf))) +) +#endif +#ifndef OVERRIDE_32_fstat64 +SC_LTTNG_TRACEPOINT_EVENT(fstat64, + TP_PROTO(sc_exit(long ret,) unsigned long fd, struct stat64 * statbuf), + TP_ARGS(sc_exit(ret,) fd, statbuf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned long, fd, fd)) sc_inout(ctf_integer(struct stat64 *, statbuf, statbuf))) +) +#endif +#ifndef OVERRIDE_32_getgroups +SC_LTTNG_TRACEPOINT_EVENT(getgroups, + TP_PROTO(sc_exit(long ret,) int gidsetsize, gid_t * grouplist), + TP_ARGS(sc_exit(ret,) gidsetsize, grouplist), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, gidsetsize, gidsetsize)) sc_out(ctf_integer(gid_t *, grouplist, grouplist))) +) +#endif +#ifndef OVERRIDE_32_setgroups +SC_LTTNG_TRACEPOINT_EVENT(setgroups, + TP_PROTO(sc_exit(long ret,) int gidsetsize, gid_t * grouplist), + TP_ARGS(sc_exit(ret,) gidsetsize, grouplist), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, gidsetsize, gidsetsize)) sc_in(ctf_integer(gid_t *, grouplist, grouplist))) +) +#endif +#ifndef OVERRIDE_32_pivot_root +SC_LTTNG_TRACEPOINT_EVENT(pivot_root, + TP_PROTO(sc_exit(long ret,) const char * new_root, const char * put_old), + TP_ARGS(sc_exit(ret,) new_root, put_old), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(new_root, new_root)) sc_in(ctf_user_string(put_old, put_old))) +) +#endif +#ifndef OVERRIDE_32_removexattr +SC_LTTNG_TRACEPOINT_EVENT(removexattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name), + TP_ARGS(sc_exit(ret,) pathname, name), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name))) +) +#endif +#ifndef OVERRIDE_32_lremovexattr +SC_LTTNG_TRACEPOINT_EVENT(lremovexattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name), + TP_ARGS(sc_exit(ret,) pathname, name), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name))) +) +#endif +#ifndef OVERRIDE_32_fremovexattr +SC_LTTNG_TRACEPOINT_EVENT(fremovexattr, + TP_PROTO(sc_exit(long ret,) int fd, const char * name), + TP_ARGS(sc_exit(ret,) fd, name), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(name, name))) +) +#endif +#ifndef OVERRIDE_32_io_setup +SC_LTTNG_TRACEPOINT_EVENT(io_setup, + TP_PROTO(sc_exit(long ret,) unsigned nr_events, aio_context_t * ctxp), + TP_ARGS(sc_exit(ret,) nr_events, ctxp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned, nr_events, nr_events)) sc_in(ctf_integer(aio_context_t *, ctxp, ctxp))) +) +#endif +#ifndef OVERRIDE_32_timer_gettime +SC_LTTNG_TRACEPOINT_EVENT(timer_gettime, + TP_PROTO(sc_exit(long ret,) timer_t timer_id, struct itimerspec * setting), + TP_ARGS(sc_exit(ret,) timer_id, setting), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id)) sc_out(ctf_integer(struct itimerspec *, setting, setting))) +) +#endif +#ifndef OVERRIDE_32_clock_settime +SC_LTTNG_TRACEPOINT_EVENT(clock_settime, + TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, const struct timespec * tp), + TP_ARGS(sc_exit(ret,) which_clock, tp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_in(ctf_integer(const struct timespec *, tp, tp))) +) +#endif +#ifndef OVERRIDE_32_clock_gettime +SC_LTTNG_TRACEPOINT_EVENT(clock_gettime, + TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct timespec * tp), + TP_ARGS(sc_exit(ret,) which_clock, tp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_out(ctf_integer(struct timespec *, tp, tp))) +) +#endif +#ifndef OVERRIDE_32_clock_getres +SC_LTTNG_TRACEPOINT_EVENT(clock_getres, + TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct timespec * tp), + TP_ARGS(sc_exit(ret,) which_clock, tp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_out(ctf_integer(struct timespec *, tp, tp))) +) +#endif +#ifndef OVERRIDE_32_utimes +SC_LTTNG_TRACEPOINT_EVENT(utimes, + TP_PROTO(sc_exit(long ret,) char * filename, struct timeval * utimes), + TP_ARGS(sc_exit(ret,) filename, utimes), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(struct timeval *, utimes, utimes))) +) +#endif +#ifndef OVERRIDE_32_mq_notify +SC_LTTNG_TRACEPOINT_EVENT(mq_notify, + TP_PROTO(sc_exit(long ret,) mqd_t mqdes, const struct sigevent * u_notification), + TP_ARGS(sc_exit(ret,) mqdes, u_notification), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(mqd_t, mqdes, mqdes)) sc_in(ctf_integer(const struct sigevent *, u_notification, u_notification))) +) +#endif +#ifndef OVERRIDE_32_set_robust_list +SC_LTTNG_TRACEPOINT_EVENT(set_robust_list, + TP_PROTO(sc_exit(long ret,) struct robust_list_head * head, size_t len), + TP_ARGS(sc_exit(ret,) head, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct robust_list_head *, head, head)) sc_in(ctf_integer(size_t, len, len))) +) +#endif +#ifndef OVERRIDE_32_timerfd_gettime +SC_LTTNG_TRACEPOINT_EVENT(timerfd_gettime, + TP_PROTO(sc_exit(long ret,) int ufd, struct itimerspec * otmr), + TP_ARGS(sc_exit(ret,) ufd, otmr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_out(ctf_integer(struct itimerspec *, otmr, otmr))) +) +#endif +#ifndef OVERRIDE_32_pipe2 +SC_LTTNG_TRACEPOINT_EVENT(pipe2, + TP_PROTO(sc_exit(long ret,) int * fildes, int flags), + TP_ARGS(sc_exit(ret,) fildes, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(int *, fildes, fildes)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_clock_adjtime +SC_LTTNG_TRACEPOINT_EVENT(clock_adjtime, + TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct timex * utx), + TP_ARGS(sc_exit(ret,) which_clock, utx), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_inout(ctf_integer(struct timex *, utx, utx))) +) +#endif +#ifndef OVERRIDE_32_read +SC_LTTNG_TRACEPOINT_EVENT(read, + TP_PROTO(sc_exit(long ret,) unsigned int fd, char * buf, size_t count), + TP_ARGS(sc_exit(ret,) fd, buf, count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(size_t, count, count))) +) +#endif +#ifndef OVERRIDE_32_write +SC_LTTNG_TRACEPOINT_EVENT(write, + TP_PROTO(sc_exit(long ret,) unsigned int fd, const char * buf, size_t count), + TP_ARGS(sc_exit(ret,) fd, buf, count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(const char *, buf, buf)) sc_in(ctf_integer(size_t, count, count))) +) +#endif +#ifndef OVERRIDE_32_open +SC_LTTNG_TRACEPOINT_EVENT(open, + TP_PROTO(sc_exit(long ret,) const char * filename, int flags, umode_t mode), + TP_ARGS(sc_exit(ret,) filename, flags, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(umode_t, mode, mode))) +) +#endif +#ifndef OVERRIDE_32_mknod +SC_LTTNG_TRACEPOINT_EVENT(mknod, + TP_PROTO(sc_exit(long ret,) const char * filename, umode_t mode, unsigned dev), + TP_ARGS(sc_exit(ret,) filename, mode, dev), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(umode_t, mode, mode)) sc_in(ctf_integer(unsigned, dev, dev))) +) +#endif +#ifndef OVERRIDE_32_lchown16 +SC_LTTNG_TRACEPOINT_EVENT(lchown16, + TP_PROTO(sc_exit(long ret,) const char * filename, old_uid_t user, old_gid_t group), + TP_ARGS(sc_exit(ret,) filename, user, group), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(filename, filename)) sc_inout(ctf_integer(old_uid_t, user, user)) sc_inout(ctf_integer(old_gid_t, group, group))) +) +#endif +#ifndef OVERRIDE_32_readlink +SC_LTTNG_TRACEPOINT_EVENT(readlink, + TP_PROTO(sc_exit(long ret,) const char * path, char * buf, int bufsiz), + TP_ARGS(sc_exit(ret,) path, buf, bufsiz), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(path, path)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(int, bufsiz, bufsiz))) +) +#endif +#ifndef OVERRIDE_32_syslog +SC_LTTNG_TRACEPOINT_EVENT(syslog, + TP_PROTO(sc_exit(long ret,) int type, char * buf, int len), + TP_ARGS(sc_exit(ret,) type, buf, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, type, type)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(int, len, len))) +) +#endif +#ifndef OVERRIDE_32_setitimer +SC_LTTNG_TRACEPOINT_EVENT(setitimer, + TP_PROTO(sc_exit(long ret,) int which, struct itimerval * value, struct itimerval * ovalue), + TP_ARGS(sc_exit(ret,) which, value, ovalue), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(struct itimerval *, value, value)) sc_out(ctf_integer(struct itimerval *, ovalue, ovalue))) +) +#endif +#ifndef OVERRIDE_32_sigprocmask +SC_LTTNG_TRACEPOINT_EVENT(sigprocmask, + TP_PROTO(sc_exit(long ret,) int how, old_sigset_t * nset, old_sigset_t * oset), + TP_ARGS(sc_exit(ret,) how, nset, oset), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, how, how)) sc_inout(ctf_integer(old_sigset_t *, nset, nset)) sc_inout(ctf_integer(old_sigset_t *, oset, oset))) +) +#endif +#ifndef OVERRIDE_32_init_module +SC_LTTNG_TRACEPOINT_EVENT(init_module, + TP_PROTO(sc_exit(long ret,) void * umod, unsigned long len, const char * uargs), + TP_ARGS(sc_exit(ret,) umod, len, uargs), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(void *, umod, umod)) sc_in(ctf_integer(unsigned long, len, len)) sc_in(ctf_integer(const char *, uargs, uargs))) +) +#endif +#ifndef OVERRIDE_32_getdents +SC_LTTNG_TRACEPOINT_EVENT(getdents, + TP_PROTO(sc_exit(long ret,) unsigned int fd, struct linux_dirent * dirent, unsigned int count), + TP_ARGS(sc_exit(ret,) fd, dirent, count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct linux_dirent *, dirent, dirent)) sc_in(ctf_integer(unsigned int, count, count))) +) +#endif +#ifndef OVERRIDE_32_readv +SC_LTTNG_TRACEPOINT_EVENT(readv, + TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen), + TP_ARGS(sc_exit(ret,) fd, vec, vlen), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_inout(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen))) +) +#endif +#ifndef OVERRIDE_32_writev +SC_LTTNG_TRACEPOINT_EVENT(writev, + TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen), + TP_ARGS(sc_exit(ret,) fd, vec, vlen), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_inout(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen))) +) +#endif +#ifndef OVERRIDE_32_sched_setscheduler +SC_LTTNG_TRACEPOINT_EVENT(sched_setscheduler, + TP_PROTO(sc_exit(long ret,) pid_t pid, int policy, struct sched_param * param), + TP_ARGS(sc_exit(ret,) pid, policy, param), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, policy, policy)) sc_in(ctf_integer(struct sched_param *, param, param))) +) +#endif +#ifndef OVERRIDE_32_getresuid16 +SC_LTTNG_TRACEPOINT_EVENT(getresuid16, + TP_PROTO(sc_exit(long ret,) old_uid_t * ruid, old_uid_t * euid, old_uid_t * suid), + TP_ARGS(sc_exit(ret,) ruid, euid, suid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(old_uid_t *, ruid, ruid)) sc_inout(ctf_integer(old_uid_t *, euid, euid)) sc_inout(ctf_integer(old_uid_t *, suid, suid))) +) +#endif +#ifndef OVERRIDE_32_poll +SC_LTTNG_TRACEPOINT_EVENT(poll, + TP_PROTO(sc_exit(long ret,) struct pollfd * ufds, unsigned int nfds, int timeout_msecs), + TP_ARGS(sc_exit(ret,) ufds, nfds, timeout_msecs), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct pollfd *, ufds, ufds)) sc_in(ctf_integer(unsigned int, nfds, nfds)) sc_in(ctf_integer(int, timeout_msecs, timeout_msecs))) +) +#endif +#ifndef OVERRIDE_32_getresgid16 +SC_LTTNG_TRACEPOINT_EVENT(getresgid16, + TP_PROTO(sc_exit(long ret,) old_gid_t * rgid, old_gid_t * egid, old_gid_t * sgid), + TP_ARGS(sc_exit(ret,) rgid, egid, sgid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(old_gid_t *, rgid, rgid)) sc_inout(ctf_integer(old_gid_t *, egid, egid)) sc_inout(ctf_integer(old_gid_t *, sgid, sgid))) +) +#endif +#ifndef OVERRIDE_32_rt_sigqueueinfo +SC_LTTNG_TRACEPOINT_EVENT(rt_sigqueueinfo, + TP_PROTO(sc_exit(long ret,) pid_t pid, int sig, siginfo_t * uinfo), + TP_ARGS(sc_exit(ret,) pid, sig, uinfo), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig)) sc_in(ctf_integer(siginfo_t *, uinfo, uinfo))) +) +#endif +#ifndef OVERRIDE_32_chown16 +SC_LTTNG_TRACEPOINT_EVENT(chown16, + TP_PROTO(sc_exit(long ret,) const char * filename, old_uid_t user, old_gid_t group), + TP_ARGS(sc_exit(ret,) filename, user, group), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(filename, filename)) sc_inout(ctf_integer(old_uid_t, user, user)) sc_inout(ctf_integer(old_gid_t, group, group))) +) +#endif +#ifndef OVERRIDE_32_lchown +SC_LTTNG_TRACEPOINT_EVENT(lchown, + TP_PROTO(sc_exit(long ret,) const char * filename, uid_t user, gid_t group), + TP_ARGS(sc_exit(ret,) filename, user, group), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group))) +) +#endif +#ifndef OVERRIDE_32_getresuid +SC_LTTNG_TRACEPOINT_EVENT(getresuid, + TP_PROTO(sc_exit(long ret,) uid_t * ruid, uid_t * euid, uid_t * suid), + TP_ARGS(sc_exit(ret,) ruid, euid, suid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(uid_t *, ruid, ruid)) sc_out(ctf_integer(uid_t *, euid, euid)) sc_out(ctf_integer(uid_t *, suid, suid))) +) +#endif +#ifndef OVERRIDE_32_getresgid +SC_LTTNG_TRACEPOINT_EVENT(getresgid, + TP_PROTO(sc_exit(long ret,) gid_t * rgid, gid_t * egid, gid_t * sgid), + TP_ARGS(sc_exit(ret,) rgid, egid, sgid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(gid_t *, rgid, rgid)) sc_out(ctf_integer(gid_t *, egid, egid)) sc_out(ctf_integer(gid_t *, sgid, sgid))) +) +#endif +#ifndef OVERRIDE_32_chown +SC_LTTNG_TRACEPOINT_EVENT(chown, + TP_PROTO(sc_exit(long ret,) const char * filename, uid_t user, gid_t group), + TP_ARGS(sc_exit(ret,) filename, user, group), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group))) +) +#endif +#ifndef OVERRIDE_32_getdents64 +SC_LTTNG_TRACEPOINT_EVENT(getdents64, + TP_PROTO(sc_exit(long ret,) unsigned int fd, struct linux_dirent64 * dirent, unsigned int count), + TP_ARGS(sc_exit(ret,) fd, dirent, count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct linux_dirent64 *, dirent, dirent)) sc_in(ctf_integer(unsigned int, count, count))) +) +#endif +#ifndef OVERRIDE_32_mincore +SC_LTTNG_TRACEPOINT_EVENT(mincore, + TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len, unsigned char * vec), + TP_ARGS(sc_exit(ret,) start, len, vec), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len)) sc_out(ctf_integer(unsigned char *, vec, vec))) +) +#endif +#ifndef OVERRIDE_32_listxattr +SC_LTTNG_TRACEPOINT_EVENT(listxattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, char * list, size_t size), + TP_ARGS(sc_exit(ret,) pathname, list, size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(char *, list, list)) sc_in(ctf_integer(size_t, size, size))) +) +#endif +#ifndef OVERRIDE_32_llistxattr +SC_LTTNG_TRACEPOINT_EVENT(llistxattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, char * list, size_t size), + TP_ARGS(sc_exit(ret,) pathname, list, size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(char *, list, list)) sc_in(ctf_integer(size_t, size, size))) +) +#endif +#ifndef OVERRIDE_32_flistxattr +SC_LTTNG_TRACEPOINT_EVENT(flistxattr, + TP_PROTO(sc_exit(long ret,) int fd, char * list, size_t size), + TP_ARGS(sc_exit(ret,) fd, list, size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(char *, list, list)) sc_in(ctf_integer(size_t, size, size))) +) +#endif +#ifndef OVERRIDE_32_sched_setaffinity +SC_LTTNG_TRACEPOINT_EVENT(sched_setaffinity, + TP_PROTO(sc_exit(long ret,) pid_t pid, unsigned int len, unsigned long * user_mask_ptr), + TP_ARGS(sc_exit(ret,) pid, len, user_mask_ptr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(unsigned int, len, len)) sc_in(ctf_integer(unsigned long *, user_mask_ptr, user_mask_ptr))) +) +#endif +#ifndef OVERRIDE_32_sched_getaffinity +SC_LTTNG_TRACEPOINT_EVENT(sched_getaffinity, + TP_PROTO(sc_exit(long ret,) pid_t pid, unsigned int len, unsigned long * user_mask_ptr), + TP_ARGS(sc_exit(ret,) pid, len, user_mask_ptr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(unsigned int, len, len)) sc_out(ctf_integer(unsigned long *, user_mask_ptr, user_mask_ptr))) +) +#endif +#ifndef OVERRIDE_32_io_submit +SC_LTTNG_TRACEPOINT_EVENT(io_submit, + TP_PROTO(sc_exit(long ret,) aio_context_t ctx_id, long nr, struct iocb * * iocbpp), + TP_ARGS(sc_exit(ret,) ctx_id, nr, iocbpp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx_id, ctx_id)) sc_in(ctf_integer(long, nr, nr)) sc_in(ctf_integer(struct iocb * *, iocbpp, iocbpp))) +) +#endif +#ifndef OVERRIDE_32_io_cancel +SC_LTTNG_TRACEPOINT_EVENT(io_cancel, + TP_PROTO(sc_exit(long ret,) aio_context_t ctx_id, struct iocb * iocb, struct io_event * result), + TP_ARGS(sc_exit(ret,) ctx_id, iocb, result), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx_id, ctx_id)) sc_in(ctf_integer(struct iocb *, iocb, iocb)) sc_out(ctf_integer(struct io_event *, result, result))) +) +#endif +#ifndef OVERRIDE_32_timer_create +SC_LTTNG_TRACEPOINT_EVENT(timer_create, + TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct sigevent * timer_event_spec, timer_t * created_timer_id), + TP_ARGS(sc_exit(ret,) which_clock, timer_event_spec, created_timer_id), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_in(ctf_integer(struct sigevent *, timer_event_spec, timer_event_spec)) sc_out(ctf_integer(timer_t *, created_timer_id, created_timer_id))) +) +#endif +#ifndef OVERRIDE_32_mq_getsetattr +SC_LTTNG_TRACEPOINT_EVENT(mq_getsetattr, + TP_PROTO(sc_exit(long ret,) mqd_t mqdes, const struct mq_attr * u_mqstat, struct mq_attr * u_omqstat), + TP_ARGS(sc_exit(ret,) mqdes, u_mqstat, u_omqstat), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(mqd_t, mqdes, mqdes)) sc_in(ctf_integer(const struct mq_attr *, u_mqstat, u_mqstat)) sc_out(ctf_integer(struct mq_attr *, u_omqstat, u_omqstat))) +) +#endif +#ifndef OVERRIDE_32_bind +SC_LTTNG_TRACEPOINT_EVENT(bind, + TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * umyaddr, int addrlen), + TP_ARGS(sc_exit(ret,) fd, umyaddr, addrlen), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct sockaddr *, umyaddr, umyaddr)) sc_in(ctf_integer(int, addrlen, addrlen))) +) +#endif +#ifndef OVERRIDE_32_connect +SC_LTTNG_TRACEPOINT_EVENT(connect, + TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * uservaddr, int addrlen), + TP_ARGS(sc_exit(ret,) fd, uservaddr, addrlen), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct sockaddr *, uservaddr, uservaddr)) sc_in(ctf_integer(int, addrlen, addrlen))) +) +#endif +#ifndef OVERRIDE_32_accept +SC_LTTNG_TRACEPOINT_EVENT(accept, + TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * upeer_sockaddr, int * upeer_addrlen), + TP_ARGS(sc_exit(ret,) fd, upeer_sockaddr, upeer_addrlen), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct sockaddr *, upeer_sockaddr, upeer_sockaddr)) sc_inout(ctf_integer(int *, upeer_addrlen, upeer_addrlen))) +) +#endif +#ifndef OVERRIDE_32_getsockname +SC_LTTNG_TRACEPOINT_EVENT(getsockname, + TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * usockaddr, int * usockaddr_len), + TP_ARGS(sc_exit(ret,) fd, usockaddr, usockaddr_len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct sockaddr *, usockaddr, usockaddr)) sc_inout(ctf_integer(int *, usockaddr_len, usockaddr_len))) +) +#endif +#ifndef OVERRIDE_32_getpeername +SC_LTTNG_TRACEPOINT_EVENT(getpeername, + TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * usockaddr, int * usockaddr_len), + TP_ARGS(sc_exit(ret,) fd, usockaddr, usockaddr_len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct sockaddr *, usockaddr, usockaddr)) sc_inout(ctf_integer(int *, usockaddr_len, usockaddr_len))) +) +#endif +#ifndef OVERRIDE_32_sendmsg +SC_LTTNG_TRACEPOINT_EVENT(sendmsg, + TP_PROTO(sc_exit(long ret,) int fd, struct msghdr * msg, unsigned flags), + TP_ARGS(sc_exit(ret,) fd, msg, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct msghdr *, msg, msg)) sc_in(ctf_integer(unsigned, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_recvmsg +SC_LTTNG_TRACEPOINT_EVENT(recvmsg, + TP_PROTO(sc_exit(long ret,) int fd, struct msghdr * msg, unsigned int flags), + TP_ARGS(sc_exit(ret,) fd, msg, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_inout(ctf_integer(struct msghdr *, msg, msg)) sc_in(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_semop +SC_LTTNG_TRACEPOINT_EVENT(semop, + TP_PROTO(sc_exit(long ret,) int semid, struct sembuf * tsops, unsigned nsops), + TP_ARGS(sc_exit(ret,) semid, tsops, nsops), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, semid, semid)) sc_in(ctf_integer(struct sembuf *, tsops, tsops)) sc_in(ctf_integer(unsigned, nsops, nsops))) +) +#endif +#ifndef OVERRIDE_32_msgctl +SC_LTTNG_TRACEPOINT_EVENT(msgctl, + TP_PROTO(sc_exit(long ret,) int msqid, int cmd, struct msqid_ds * buf), + TP_ARGS(sc_exit(ret,) msqid, cmd, buf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, msqid, msqid)) sc_in(ctf_integer(int, cmd, cmd)) sc_inout(ctf_integer(struct msqid_ds *, buf, buf))) +) +#endif +#ifndef OVERRIDE_32_shmat +SC_LTTNG_TRACEPOINT_EVENT(shmat, + TP_PROTO(sc_exit(long ret,) int shmid, char * shmaddr, int shmflg), + TP_ARGS(sc_exit(ret,) shmid, shmaddr, shmflg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, shmid, shmid)) sc_in(ctf_integer(char *, shmaddr, shmaddr)) sc_in(ctf_integer(int, shmflg, shmflg))) +) +#endif +#ifndef OVERRIDE_32_shmctl +SC_LTTNG_TRACEPOINT_EVENT(shmctl, + TP_PROTO(sc_exit(long ret,) int shmid, int cmd, struct shmid_ds * buf), + TP_ARGS(sc_exit(ret,) shmid, cmd, buf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, shmid, shmid)) sc_in(ctf_integer(int, cmd, cmd)) sc_inout(ctf_integer(struct shmid_ds *, buf, buf))) +) +#endif +#ifndef OVERRIDE_32_inotify_add_watch +SC_LTTNG_TRACEPOINT_EVENT(inotify_add_watch, + TP_PROTO(sc_exit(long ret,) int fd, const char * pathname, u32 mask), + TP_ARGS(sc_exit(ret,) fd, pathname, mask), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(u32, mask, mask))) +) +#endif +#ifndef OVERRIDE_32_mkdirat +SC_LTTNG_TRACEPOINT_EVENT(mkdirat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * pathname, umode_t mode), + TP_ARGS(sc_exit(ret,) dfd, pathname, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(umode_t, mode, mode))) +) +#endif +#ifndef OVERRIDE_32_futimesat +SC_LTTNG_TRACEPOINT_EVENT(futimesat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, struct timeval * utimes), + TP_ARGS(sc_exit(ret,) dfd, filename, utimes), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(struct timeval *, utimes, utimes))) +) +#endif +#ifndef OVERRIDE_32_unlinkat +SC_LTTNG_TRACEPOINT_EVENT(unlinkat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * pathname, int flag), + TP_ARGS(sc_exit(ret,) dfd, pathname, flag), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(int, flag, flag))) +) +#endif +#ifndef OVERRIDE_32_symlinkat +SC_LTTNG_TRACEPOINT_EVENT(symlinkat, + TP_PROTO(sc_exit(long ret,) const char * oldname, int newdfd, const char * newname), + TP_ARGS(sc_exit(ret,) oldname, newdfd, newname), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_integer(int, newdfd, newdfd)) sc_in(ctf_user_string(newname, newname))) +) +#endif +#ifndef OVERRIDE_32_fchmodat +SC_LTTNG_TRACEPOINT_EVENT(fchmodat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, umode_t mode), + TP_ARGS(sc_exit(ret,) dfd, filename, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(umode_t, mode, mode))) +) +#endif +#ifndef OVERRIDE_32_faccessat +SC_LTTNG_TRACEPOINT_EVENT(faccessat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, int mode), + TP_ARGS(sc_exit(ret,) dfd, filename, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, mode, mode))) +) +#endif +#ifndef OVERRIDE_32_get_robust_list +SC_LTTNG_TRACEPOINT_EVENT(get_robust_list, + TP_PROTO(sc_exit(long ret,) int pid, struct robust_list_head * * head_ptr, size_t * len_ptr), + TP_ARGS(sc_exit(ret,) pid, head_ptr, len_ptr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, pid, pid)) sc_out(ctf_integer(struct robust_list_head * *, head_ptr, head_ptr)) sc_out(ctf_integer(size_t *, len_ptr, len_ptr))) +) +#endif +#ifndef OVERRIDE_32_getcpu +SC_LTTNG_TRACEPOINT_EVENT(getcpu, + TP_PROTO(sc_exit(long ret,) unsigned * cpup, unsigned * nodep, struct getcpu_cache * unused), + TP_ARGS(sc_exit(ret,) cpup, nodep, unused), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(unsigned *, cpup, cpup)) sc_out(ctf_integer(unsigned *, nodep, nodep)) sc_inout(ctf_integer(struct getcpu_cache *, unused, unused))) +) +#endif +#ifndef OVERRIDE_32_signalfd +SC_LTTNG_TRACEPOINT_EVENT(signalfd, + TP_PROTO(sc_exit(long ret,) int ufd, sigset_t * user_mask, size_t sizemask), + TP_ARGS(sc_exit(ret,) ufd, user_mask, sizemask), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_in(ctf_integer(sigset_t *, user_mask, user_mask)) sc_in(ctf_integer(size_t, sizemask, sizemask))) +) +#endif +#ifndef OVERRIDE_32_open_by_handle_at +SC_LTTNG_TRACEPOINT_EVENT(open_by_handle_at, + TP_PROTO(sc_exit(long ret,) int mountdirfd, struct file_handle * handle, int flags), + TP_ARGS(sc_exit(ret,) mountdirfd, handle, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, mountdirfd, mountdirfd)) sc_in(ctf_integer(struct file_handle *, handle, handle)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_reboot +SC_LTTNG_TRACEPOINT_EVENT(reboot, + TP_PROTO(sc_exit(long ret,) int magic1, int magic2, unsigned int cmd, void * arg), + TP_ARGS(sc_exit(ret,) magic1, magic2, cmd, arg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, magic1, magic1)) sc_in(ctf_integer(int, magic2, magic2)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_in(ctf_integer(void *, arg, arg))) +) +#endif +#ifndef OVERRIDE_32_wait4 +SC_LTTNG_TRACEPOINT_EVENT(wait4, + TP_PROTO(sc_exit(long ret,) pid_t upid, int * stat_addr, int options, struct rusage * ru), + TP_ARGS(sc_exit(ret,) upid, stat_addr, options, ru), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, upid, upid)) sc_out(ctf_integer(int *, stat_addr, stat_addr)) sc_in(ctf_integer(int, options, options)) sc_out(ctf_integer(struct rusage *, ru, ru))) +) +#endif +#ifndef OVERRIDE_32_quotactl +SC_LTTNG_TRACEPOINT_EVENT(quotactl, + TP_PROTO(sc_exit(long ret,) unsigned int cmd, const char * special, qid_t id, void * addr), + TP_ARGS(sc_exit(ret,) cmd, special, id, addr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_in(ctf_integer(const char *, special, special)) sc_in(ctf_integer(qid_t, id, id)) sc_inout(ctf_integer(void *, addr, addr))) +) +#endif +#ifndef OVERRIDE_32_rt_sigaction +SC_LTTNG_TRACEPOINT_EVENT(rt_sigaction, + TP_PROTO(sc_exit(long ret,) int sig, const struct sigaction * act, struct sigaction * oact, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) sig, act, oact, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, sig, sig)) sc_in(ctf_integer(const struct sigaction *, act, act)) sc_out(ctf_integer(struct sigaction *, oact, oact)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) +) +#endif +#ifndef OVERRIDE_32_rt_sigprocmask +SC_LTTNG_TRACEPOINT_EVENT(rt_sigprocmask, + TP_PROTO(sc_exit(long ret,) int how, sigset_t * nset, sigset_t * oset, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) how, nset, oset, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, how, how)) sc_in(ctf_integer(sigset_t *, nset, nset)) sc_out(ctf_integer(sigset_t *, oset, oset)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) +) +#endif +#ifndef OVERRIDE_32_rt_sigtimedwait +SC_LTTNG_TRACEPOINT_EVENT(rt_sigtimedwait, + TP_PROTO(sc_exit(long ret,) const sigset_t * uthese, siginfo_t * uinfo, const struct timespec * uts, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) uthese, uinfo, uts, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(const sigset_t *, uthese, uthese)) sc_out(ctf_integer(siginfo_t *, uinfo, uinfo)) sc_in(ctf_integer(const struct timespec *, uts, uts)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) +) +#endif +#ifndef OVERRIDE_32_sendfile +SC_LTTNG_TRACEPOINT_EVENT(sendfile, + TP_PROTO(sc_exit(long ret,) int out_fd, int in_fd, off_t * offset, size_t count), + TP_ARGS(sc_exit(ret,) out_fd, in_fd, offset, count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, out_fd, out_fd)) sc_inout(ctf_integer(int, in_fd, in_fd)) sc_inout(ctf_integer(off_t *, offset, offset)) sc_inout(ctf_integer(size_t, count, count))) +) +#endif +#ifndef OVERRIDE_32_getxattr +SC_LTTNG_TRACEPOINT_EVENT(getxattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, void * value, size_t size), + TP_ARGS(sc_exit(ret,) pathname, name, value, size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_out(ctf_integer(void *, value, value)) sc_in(ctf_integer(size_t, size, size))) +) +#endif +#ifndef OVERRIDE_32_lgetxattr +SC_LTTNG_TRACEPOINT_EVENT(lgetxattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, void * value, size_t size), + TP_ARGS(sc_exit(ret,) pathname, name, value, size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_out(ctf_integer(void *, value, value)) sc_in(ctf_integer(size_t, size, size))) +) +#endif +#ifndef OVERRIDE_32_fgetxattr +SC_LTTNG_TRACEPOINT_EVENT(fgetxattr, + TP_PROTO(sc_exit(long ret,) int fd, const char * name, void * value, size_t size), + TP_ARGS(sc_exit(ret,) fd, name, value, size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(name, name)) sc_out(ctf_integer(void *, value, value)) sc_in(ctf_integer(size_t, size, size))) +) +#endif +#ifndef OVERRIDE_32_sendfile64 +SC_LTTNG_TRACEPOINT_EVENT(sendfile64, + TP_PROTO(sc_exit(long ret,) int out_fd, int in_fd, loff_t * offset, size_t count), + TP_ARGS(sc_exit(ret,) out_fd, in_fd, offset, count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, out_fd, out_fd)) sc_in(ctf_integer(int, in_fd, in_fd)) sc_inout(ctf_integer(loff_t *, offset, offset)) sc_in(ctf_integer(size_t, count, count))) +) +#endif +#ifndef OVERRIDE_32_epoll_ctl +SC_LTTNG_TRACEPOINT_EVENT(epoll_ctl, + TP_PROTO(sc_exit(long ret,) int epfd, int op, int fd, struct epoll_event * event), + TP_ARGS(sc_exit(ret,) epfd, op, fd, event), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, epfd, epfd)) sc_in(ctf_integer(int, op, op)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct epoll_event *, event, event))) +) +#endif +#ifndef OVERRIDE_32_epoll_wait +SC_LTTNG_TRACEPOINT_EVENT(epoll_wait, + TP_PROTO(sc_exit(long ret,) int epfd, struct epoll_event * events, int maxevents, int timeout), + TP_ARGS(sc_exit(ret,) epfd, events, maxevents, timeout), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, epfd, epfd)) sc_out(ctf_integer(struct epoll_event *, events, events)) sc_in(ctf_integer(int, maxevents, maxevents)) sc_in(ctf_integer(int, timeout, timeout))) +) +#endif +#ifndef OVERRIDE_32_timer_settime +SC_LTTNG_TRACEPOINT_EVENT(timer_settime, + TP_PROTO(sc_exit(long ret,) timer_t timer_id, int flags, const struct itimerspec * new_setting, struct itimerspec * old_setting), + TP_ARGS(sc_exit(ret,) timer_id, flags, new_setting, old_setting), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(const struct itimerspec *, new_setting, new_setting)) sc_out(ctf_integer(struct itimerspec *, old_setting, old_setting))) +) +#endif +#ifndef OVERRIDE_32_clock_nanosleep +SC_LTTNG_TRACEPOINT_EVENT(clock_nanosleep, + TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, int flags, const struct timespec * rqtp, struct timespec * rmtp), + TP_ARGS(sc_exit(ret,) which_clock, flags, rqtp, rmtp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(const struct timespec *, rqtp, rqtp)) sc_out(ctf_integer(struct timespec *, rmtp, rmtp))) +) +#endif +#ifndef OVERRIDE_32_mq_open +SC_LTTNG_TRACEPOINT_EVENT(mq_open, + TP_PROTO(sc_exit(long ret,) const char * u_name, int oflag, umode_t mode, struct mq_attr * u_attr), + TP_ARGS(sc_exit(ret,) u_name, oflag, mode, u_attr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(u_name, u_name)) sc_in(ctf_integer(int, oflag, oflag)) sc_in(ctf_integer(umode_t, mode, mode)) sc_in(ctf_integer(struct mq_attr *, u_attr, u_attr))) +) +#endif +#ifndef OVERRIDE_32_socketpair +SC_LTTNG_TRACEPOINT_EVENT(socketpair, + TP_PROTO(sc_exit(long ret,) int family, int type, int protocol, int * usockvec), + TP_ARGS(sc_exit(ret,) family, type, protocol, usockvec), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, family, family)) sc_in(ctf_integer(int, type, type)) sc_in(ctf_integer(int, protocol, protocol)) sc_out(ctf_integer(int *, usockvec, usockvec))) +) +#endif +#ifndef OVERRIDE_32_send +SC_LTTNG_TRACEPOINT_EVENT(send, + TP_PROTO(sc_exit(long ret,) int fd, void * buff, size_t len, unsigned flags), + TP_ARGS(sc_exit(ret,) fd, buff, len, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, fd, fd)) sc_inout(ctf_integer(void *, buff, buff)) sc_inout(ctf_integer(size_t, len, len)) sc_inout(ctf_integer(unsigned, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_msgsnd +SC_LTTNG_TRACEPOINT_EVENT(msgsnd, + TP_PROTO(sc_exit(long ret,) int msqid, struct msgbuf * msgp, size_t msgsz, int msgflg), + TP_ARGS(sc_exit(ret,) msqid, msgp, msgsz, msgflg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, msqid, msqid)) sc_in(ctf_integer(struct msgbuf *, msgp, msgp)) sc_in(ctf_integer(size_t, msgsz, msgsz)) sc_in(ctf_integer(int, msgflg, msgflg))) +) +#endif +#ifndef OVERRIDE_32_request_key +SC_LTTNG_TRACEPOINT_EVENT(request_key, + TP_PROTO(sc_exit(long ret,) const char * _type, const char * _description, const char * _callout_info, key_serial_t destringid), + TP_ARGS(sc_exit(ret,) _type, _description, _callout_info, destringid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(_type, _type)) sc_in(ctf_integer(const char *, _description, _description)) sc_in(ctf_integer(const char *, _callout_info, _callout_info)) sc_in(ctf_integer(key_serial_t, destringid, destringid))) +) +#endif +#ifndef OVERRIDE_32_semtimedop +SC_LTTNG_TRACEPOINT_EVENT(semtimedop, + TP_PROTO(sc_exit(long ret,) int semid, struct sembuf * tsops, unsigned nsops, const struct timespec * timeout), + TP_ARGS(sc_exit(ret,) semid, tsops, nsops, timeout), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, semid, semid)) sc_in(ctf_integer(struct sembuf *, tsops, tsops)) sc_in(ctf_integer(unsigned, nsops, nsops)) sc_inout(ctf_integer(const struct timespec *, timeout, timeout))) +) +#endif +#ifndef OVERRIDE_32_openat +SC_LTTNG_TRACEPOINT_EVENT(openat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, int flags, umode_t mode), + TP_ARGS(sc_exit(ret,) dfd, filename, flags, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(umode_t, mode, mode))) +) +#endif +#ifndef OVERRIDE_32_mknodat +SC_LTTNG_TRACEPOINT_EVENT(mknodat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, umode_t mode, unsigned dev), + TP_ARGS(sc_exit(ret,) dfd, filename, mode, dev), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(umode_t, mode, mode)) sc_in(ctf_integer(unsigned, dev, dev))) +) +#endif +#ifndef OVERRIDE_32_fstatat64 +SC_LTTNG_TRACEPOINT_EVENT(fstatat64, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, struct stat64 * statbuf, int flag), + TP_ARGS(sc_exit(ret,) dfd, filename, statbuf, flag), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, dfd, dfd)) sc_inout(ctf_user_string(filename, filename)) sc_inout(ctf_integer(struct stat64 *, statbuf, statbuf)) sc_inout(ctf_integer(int, flag, flag))) +) +#endif +#ifndef OVERRIDE_32_renameat +SC_LTTNG_TRACEPOINT_EVENT(renameat, + TP_PROTO(sc_exit(long ret,) int olddfd, const char * oldname, int newdfd, const char * newname), + TP_ARGS(sc_exit(ret,) olddfd, oldname, newdfd, newname), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, olddfd, olddfd)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_integer(int, newdfd, newdfd)) sc_in(ctf_user_string(newname, newname))) +) +#endif +#ifndef OVERRIDE_32_readlinkat +SC_LTTNG_TRACEPOINT_EVENT(readlinkat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * pathname, char * buf, int bufsiz), + TP_ARGS(sc_exit(ret,) dfd, pathname, buf, bufsiz), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(int, bufsiz, bufsiz))) +) +#endif +#ifndef OVERRIDE_32_vmsplice +SC_LTTNG_TRACEPOINT_EVENT(vmsplice, + TP_PROTO(sc_exit(long ret,) int fd, const struct iovec * iov, unsigned long nr_segs, unsigned int flags), + TP_ARGS(sc_exit(ret,) fd, iov, nr_segs, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(const struct iovec *, iov, iov)) sc_in(ctf_integer(unsigned long, nr_segs, nr_segs)) sc_in(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_utimensat +SC_LTTNG_TRACEPOINT_EVENT(utimensat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, struct timespec * utimes, int flags), + TP_ARGS(sc_exit(ret,) dfd, filename, utimes, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(struct timespec *, utimes, utimes)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_timerfd_settime +SC_LTTNG_TRACEPOINT_EVENT(timerfd_settime, + TP_PROTO(sc_exit(long ret,) int ufd, int flags, const struct itimerspec * utmr, struct itimerspec * otmr), + TP_ARGS(sc_exit(ret,) ufd, flags, utmr, otmr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(const struct itimerspec *, utmr, utmr)) sc_out(ctf_integer(struct itimerspec *, otmr, otmr))) +) +#endif +#ifndef OVERRIDE_32_signalfd4 +SC_LTTNG_TRACEPOINT_EVENT(signalfd4, + TP_PROTO(sc_exit(long ret,) int ufd, sigset_t * user_mask, size_t sizemask, int flags), + TP_ARGS(sc_exit(ret,) ufd, user_mask, sizemask, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_in(ctf_integer(sigset_t *, user_mask, user_mask)) sc_in(ctf_integer(size_t, sizemask, sizemask)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_rt_tgsigqueueinfo +SC_LTTNG_TRACEPOINT_EVENT(rt_tgsigqueueinfo, + TP_PROTO(sc_exit(long ret,) pid_t tgid, pid_t pid, int sig, siginfo_t * uinfo), + TP_ARGS(sc_exit(ret,) tgid, pid, sig, uinfo), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, tgid, tgid)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig)) sc_in(ctf_integer(siginfo_t *, uinfo, uinfo))) +) +#endif +#ifndef OVERRIDE_32_accept4 +SC_LTTNG_TRACEPOINT_EVENT(accept4, + TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * upeer_sockaddr, int * upeer_addrlen, int flags), + TP_ARGS(sc_exit(ret,) fd, upeer_sockaddr, upeer_addrlen, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct sockaddr *, upeer_sockaddr, upeer_sockaddr)) sc_inout(ctf_integer(int *, upeer_addrlen, upeer_addrlen)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_prlimit64 +SC_LTTNG_TRACEPOINT_EVENT(prlimit64, + TP_PROTO(sc_exit(long ret,) pid_t pid, unsigned int resource, const struct rlimit64 * new_rlim, struct rlimit64 * old_rlim), + TP_ARGS(sc_exit(ret,) pid, resource, new_rlim, old_rlim), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(unsigned int, resource, resource)) sc_in(ctf_integer(const struct rlimit64 *, new_rlim, new_rlim)) sc_out(ctf_integer(struct rlimit64 *, old_rlim, old_rlim))) +) +#endif +#ifndef OVERRIDE_32_sendmmsg +SC_LTTNG_TRACEPOINT_EVENT(sendmmsg, + TP_PROTO(sc_exit(long ret,) int fd, struct mmsghdr * mmsg, unsigned int vlen, unsigned int flags), + TP_ARGS(sc_exit(ret,) fd, mmsg, vlen, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct mmsghdr *, mmsg, mmsg)) sc_in(ctf_integer(unsigned int, vlen, vlen)) sc_in(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_mount +SC_LTTNG_TRACEPOINT_EVENT(mount, + TP_PROTO(sc_exit(long ret,) char * dev_name, char * dir_name, char * type, unsigned long flags, void * data), + TP_ARGS(sc_exit(ret,) dev_name, dir_name, type, flags, data), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(dev_name, dev_name)) sc_in(ctf_user_string(dir_name, dir_name)) sc_in(ctf_user_string(type, type)) sc_in(ctf_integer(unsigned long, flags, flags)) sc_in(ctf_integer(void *, data, data))) +) +#endif +#ifndef OVERRIDE_32_llseek +SC_LTTNG_TRACEPOINT_EVENT(llseek, + TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned long offset_high, unsigned long offset_low, loff_t * result, unsigned int origin), + TP_ARGS(sc_exit(ret,) fd, offset_high, offset_low, result, origin), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, fd, fd)) sc_inout(ctf_integer(unsigned long, offset_high, offset_high)) sc_inout(ctf_integer(unsigned long, offset_low, offset_low)) sc_inout(ctf_integer(loff_t *, result, result)) sc_inout(ctf_integer(unsigned int, origin, origin))) +) +#endif +#ifndef OVERRIDE_32_select +SC_LTTNG_TRACEPOINT_EVENT(select, + TP_PROTO(sc_exit(long ret,) int n, fd_set * inp, fd_set * outp, fd_set * exp, struct timeval * tvp), + TP_ARGS(sc_exit(ret,) n, inp, outp, exp, tvp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, n, n)) sc_inout(ctf_integer(fd_set *, inp, inp)) sc_inout(ctf_integer(fd_set *, outp, outp)) sc_inout(ctf_integer(fd_set *, exp, exp)) sc_inout(ctf_integer(struct timeval *, tvp, tvp))) +) +#endif +#ifndef OVERRIDE_32_setxattr +SC_LTTNG_TRACEPOINT_EVENT(setxattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, const void * value, size_t size, int flags), + TP_ARGS(sc_exit(ret,) pathname, name, value, size, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(const void *, value, value)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_lsetxattr +SC_LTTNG_TRACEPOINT_EVENT(lsetxattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, const void * value, size_t size, int flags), + TP_ARGS(sc_exit(ret,) pathname, name, value, size, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(const void *, value, value)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_fsetxattr +SC_LTTNG_TRACEPOINT_EVENT(fsetxattr, + TP_PROTO(sc_exit(long ret,) int fd, const char * name, const void * value, size_t size, int flags), + TP_ARGS(sc_exit(ret,) fd, name, value, size, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(const void *, value, value)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_io_getevents +SC_LTTNG_TRACEPOINT_EVENT(io_getevents, + TP_PROTO(sc_exit(long ret,) aio_context_t ctx_id, long min_nr, long nr, struct io_event * events, struct timespec * timeout), + TP_ARGS(sc_exit(ret,) ctx_id, min_nr, nr, events, timeout), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx_id, ctx_id)) sc_in(ctf_integer(long, min_nr, min_nr)) sc_in(ctf_integer(long, nr, nr)) sc_out(ctf_integer(struct io_event *, events, events)) sc_inout(ctf_integer(struct timespec *, timeout, timeout))) +) +#endif +#ifndef OVERRIDE_32_mq_timedsend +SC_LTTNG_TRACEPOINT_EVENT(mq_timedsend, + TP_PROTO(sc_exit(long ret,) mqd_t mqdes, const char * u_msg_ptr, size_t msg_len, unsigned int msg_prio, const struct timespec * u_abs_timeout), + TP_ARGS(sc_exit(ret,) mqdes, u_msg_ptr, msg_len, msg_prio, u_abs_timeout), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(mqd_t, mqdes, mqdes)) sc_in(ctf_integer(const char *, u_msg_ptr, u_msg_ptr)) sc_in(ctf_integer(size_t, msg_len, msg_len)) sc_in(ctf_integer(unsigned int, msg_prio, msg_prio)) sc_in(ctf_integer(const struct timespec *, u_abs_timeout, u_abs_timeout))) +) +#endif +#ifndef OVERRIDE_32_mq_timedreceive +SC_LTTNG_TRACEPOINT_EVENT(mq_timedreceive, + TP_PROTO(sc_exit(long ret,) mqd_t mqdes, char * u_msg_ptr, size_t msg_len, unsigned int * u_msg_prio, const struct timespec * u_abs_timeout), + TP_ARGS(sc_exit(ret,) mqdes, u_msg_ptr, msg_len, u_msg_prio, u_abs_timeout), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(mqd_t, mqdes, mqdes)) sc_out(ctf_integer(char *, u_msg_ptr, u_msg_ptr)) sc_in(ctf_integer(size_t, msg_len, msg_len)) sc_out(ctf_integer(unsigned int *, u_msg_prio, u_msg_prio)) sc_in(ctf_integer(const struct timespec *, u_abs_timeout, u_abs_timeout))) +) +#endif +#ifndef OVERRIDE_32_waitid +SC_LTTNG_TRACEPOINT_EVENT(waitid, + TP_PROTO(sc_exit(long ret,) int which, pid_t upid, struct siginfo * infop, int options, struct rusage * ru), + TP_ARGS(sc_exit(ret,) which, upid, infop, options, ru), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(pid_t, upid, upid)) sc_out(ctf_integer(struct siginfo *, infop, infop)) sc_in(ctf_integer(int, options, options)) sc_out(ctf_integer(struct rusage *, ru, ru))) +) +#endif +#ifndef OVERRIDE_32_setsockopt +SC_LTTNG_TRACEPOINT_EVENT(setsockopt, + TP_PROTO(sc_exit(long ret,) int fd, int level, int optname, char * optval, int optlen), + TP_ARGS(sc_exit(ret,) fd, level, optname, optval, optlen), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, level, level)) sc_in(ctf_integer(int, optname, optname)) sc_in(ctf_integer(char *, optval, optval)) sc_in(ctf_integer(int, optlen, optlen))) +) +#endif +#ifndef OVERRIDE_32_getsockopt +SC_LTTNG_TRACEPOINT_EVENT(getsockopt, + TP_PROTO(sc_exit(long ret,) int fd, int level, int optname, char * optval, int * optlen), + TP_ARGS(sc_exit(ret,) fd, level, optname, optval, optlen), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, level, level)) sc_in(ctf_integer(int, optname, optname)) sc_out(ctf_integer(char *, optval, optval)) sc_inout(ctf_integer(int *, optlen, optlen))) +) +#endif +#ifndef OVERRIDE_32_msgrcv +SC_LTTNG_TRACEPOINT_EVENT(msgrcv, + TP_PROTO(sc_exit(long ret,) int msqid, struct msgbuf * msgp, size_t msgsz, long msgtyp, int msgflg), + TP_ARGS(sc_exit(ret,) msqid, msgp, msgsz, msgtyp, msgflg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, msqid, msqid)) sc_out(ctf_integer(struct msgbuf *, msgp, msgp)) sc_in(ctf_integer(size_t, msgsz, msgsz)) sc_in(ctf_integer(long, msgtyp, msgtyp)) sc_in(ctf_integer(int, msgflg, msgflg))) +) +#endif +#ifndef OVERRIDE_32_add_key +SC_LTTNG_TRACEPOINT_EVENT(add_key, + TP_PROTO(sc_exit(long ret,) const char * _type, const char * _description, const void * _payload, size_t plen, key_serial_t ringid), + TP_ARGS(sc_exit(ret,) _type, _description, _payload, plen, ringid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(_type, _type)) sc_in(ctf_integer(const char *, _description, _description)) sc_in(ctf_integer(const void *, _payload, _payload)) sc_in(ctf_integer(size_t, plen, plen)) sc_in(ctf_integer(key_serial_t, ringid, ringid))) +) +#endif +#ifndef OVERRIDE_32_fchownat +SC_LTTNG_TRACEPOINT_EVENT(fchownat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, uid_t user, gid_t group, int flag), + TP_ARGS(sc_exit(ret,) dfd, filename, user, group, flag), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group)) sc_in(ctf_integer(int, flag, flag))) +) +#endif +#ifndef OVERRIDE_32_linkat +SC_LTTNG_TRACEPOINT_EVENT(linkat, + TP_PROTO(sc_exit(long ret,) int olddfd, const char * oldname, int newdfd, const char * newname, int flags), + TP_ARGS(sc_exit(ret,) olddfd, oldname, newdfd, newname, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, olddfd, olddfd)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_integer(int, newdfd, newdfd)) sc_in(ctf_user_string(newname, newname)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_ppoll +SC_LTTNG_TRACEPOINT_EVENT(ppoll, + TP_PROTO(sc_exit(long ret,) struct pollfd * ufds, unsigned int nfds, struct timespec * tsp, const sigset_t * sigmask, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) ufds, nfds, tsp, sigmask, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct pollfd *, ufds, ufds)) sc_in(ctf_integer(unsigned int, nfds, nfds)) sc_in(ctf_integer(struct timespec *, tsp, tsp)) sc_in(ctf_integer(const sigset_t *, sigmask, sigmask)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) +) +#endif +#ifndef OVERRIDE_32_preadv +SC_LTTNG_TRACEPOINT_EVENT(preadv, + TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen, unsigned long pos_l, unsigned long pos_h), + TP_ARGS(sc_exit(ret,) fd, vec, vlen, pos_l, pos_h), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_out(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen)) sc_in(ctf_integer(unsigned long, pos_l, pos_l)) sc_in(ctf_integer(unsigned long, pos_h, pos_h))) +) +#endif +#ifndef OVERRIDE_32_pwritev +SC_LTTNG_TRACEPOINT_EVENT(pwritev, + TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen, unsigned long pos_l, unsigned long pos_h), + TP_ARGS(sc_exit(ret,) fd, vec, vlen, pos_l, pos_h), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_in(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen)) sc_in(ctf_integer(unsigned long, pos_l, pos_l)) sc_in(ctf_integer(unsigned long, pos_h, pos_h))) +) +#endif +#ifndef OVERRIDE_32_perf_event_open +SC_LTTNG_TRACEPOINT_EVENT(perf_event_open, + TP_PROTO(sc_exit(long ret,) struct perf_event_attr * attr_uptr, pid_t pid, int cpu, int group_fd, unsigned long flags), + TP_ARGS(sc_exit(ret,) attr_uptr, pid, cpu, group_fd, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct perf_event_attr *, attr_uptr, attr_uptr)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, cpu, cpu)) sc_in(ctf_integer(int, group_fd, group_fd)) sc_in(ctf_integer(unsigned long, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_recvmmsg +SC_LTTNG_TRACEPOINT_EVENT(recvmmsg, + TP_PROTO(sc_exit(long ret,) int fd, struct mmsghdr * mmsg, unsigned int vlen, unsigned int flags, struct timespec * timeout), + TP_ARGS(sc_exit(ret,) fd, mmsg, vlen, flags, timeout), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct mmsghdr *, mmsg, mmsg)) sc_in(ctf_integer(unsigned int, vlen, vlen)) sc_in(ctf_integer(unsigned int, flags, flags)) sc_inout(ctf_integer(struct timespec *, timeout, timeout))) +) +#endif +#ifndef OVERRIDE_32_name_to_handle_at +SC_LTTNG_TRACEPOINT_EVENT(name_to_handle_at, + TP_PROTO(sc_exit(long ret,) int dfd, const char * name, struct file_handle * handle, int * mnt_id, int flag), + TP_ARGS(sc_exit(ret,) dfd, name, handle, mnt_id, flag), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(name, name)) sc_inout(ctf_integer(struct file_handle *, handle, handle)) sc_out(ctf_integer(int *, mnt_id, mnt_id)) sc_in(ctf_integer(int, flag, flag))) +) +#endif +#ifndef OVERRIDE_32_futex +SC_LTTNG_TRACEPOINT_EVENT(futex, + TP_PROTO(sc_exit(long ret,) u32 * uaddr, int op, u32 val, struct timespec * utime, u32 * uaddr2, u32 val3), + TP_ARGS(sc_exit(ret,) uaddr, op, val, utime, uaddr2, val3), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(u32 *, uaddr, uaddr)) sc_in(ctf_integer(int, op, op)) sc_in(ctf_integer(u32, val, val)) sc_in(ctf_integer(struct timespec *, utime, utime)) sc_inout(ctf_integer(u32 *, uaddr2, uaddr2)) sc_in(ctf_integer(u32, val3, val3))) +) +#endif +#ifndef OVERRIDE_32_sendto +SC_LTTNG_TRACEPOINT_EVENT(sendto, + TP_PROTO(sc_exit(long ret,) int fd, void * buff, size_t len, unsigned flags, struct sockaddr * addr, int addr_len), + TP_ARGS(sc_exit(ret,) fd, buff, len, flags, addr, addr_len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(void *, buff, buff)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned, flags, flags)) sc_in(ctf_integer(struct sockaddr *, addr, addr)) sc_in(ctf_integer(int, addr_len, addr_len))) +) +#endif +#ifndef OVERRIDE_32_recvfrom +SC_LTTNG_TRACEPOINT_EVENT(recvfrom, + TP_PROTO(sc_exit(long ret,) int fd, void * ubuf, size_t size, unsigned flags, struct sockaddr * addr, int * addr_len), + TP_ARGS(sc_exit(ret,) fd, ubuf, size, flags, addr, addr_len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(void *, ubuf, ubuf)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(unsigned, flags, flags)) sc_out(ctf_integer(struct sockaddr *, addr, addr)) sc_inout(ctf_integer(int *, addr_len, addr_len))) +) +#endif +#ifndef OVERRIDE_32_pselect6 +SC_LTTNG_TRACEPOINT_EVENT(pselect6, + TP_PROTO(sc_exit(long ret,) int n, fd_set * inp, fd_set * outp, fd_set * exp, struct timespec * tsp, void * sig), + TP_ARGS(sc_exit(ret,) n, inp, outp, exp, tsp, sig), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, n, n)) sc_inout(ctf_integer(fd_set *, inp, inp)) sc_inout(ctf_integer(fd_set *, outp, outp)) sc_inout(ctf_integer(fd_set *, exp, exp)) sc_inout(ctf_integer(struct timespec *, tsp, tsp)) sc_in(ctf_integer(void *, sig, sig))) +) +#endif +#ifndef OVERRIDE_32_splice +SC_LTTNG_TRACEPOINT_EVENT(splice, + TP_PROTO(sc_exit(long ret,) int fd_in, loff_t * off_in, int fd_out, loff_t * off_out, size_t len, unsigned int flags), + TP_ARGS(sc_exit(ret,) fd_in, off_in, fd_out, off_out, len, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd_in, fd_in)) sc_in(ctf_integer(loff_t *, off_in, off_in)) sc_in(ctf_integer(int, fd_out, fd_out)) sc_in(ctf_integer(loff_t *, off_out, off_out)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_epoll_pwait +SC_LTTNG_TRACEPOINT_EVENT(epoll_pwait, + TP_PROTO(sc_exit(long ret,) int epfd, struct epoll_event * events, int maxevents, int timeout, const sigset_t * sigmask, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) epfd, events, maxevents, timeout, sigmask, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, epfd, epfd)) sc_out(ctf_integer(struct epoll_event *, events, events)) sc_in(ctf_integer(int, maxevents, maxevents)) sc_in(ctf_integer(int, timeout, timeout)) sc_in(ctf_integer(const sigset_t *, sigmask, sigmask)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) +) +#endif +#ifndef OVERRIDE_32_process_vm_readv +SC_LTTNG_TRACEPOINT_EVENT(process_vm_readv, + TP_PROTO(sc_exit(long ret,) pid_t pid, const struct iovec * lvec, unsigned long liovcnt, const struct iovec * rvec, unsigned long riovcnt, unsigned long flags), + TP_ARGS(sc_exit(ret,) pid, lvec, liovcnt, rvec, riovcnt, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_out(ctf_integer(const struct iovec *, lvec, lvec)) sc_in(ctf_integer(unsigned long, liovcnt, liovcnt)) sc_in(ctf_integer(const struct iovec *, rvec, rvec)) sc_in(ctf_integer(unsigned long, riovcnt, riovcnt)) sc_in(ctf_integer(unsigned long, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_process_vm_writev +SC_LTTNG_TRACEPOINT_EVENT(process_vm_writev, + TP_PROTO(sc_exit(long ret,) pid_t pid, const struct iovec * lvec, unsigned long liovcnt, const struct iovec * rvec, unsigned long riovcnt, unsigned long flags), + TP_ARGS(sc_exit(ret,) pid, lvec, liovcnt, rvec, riovcnt, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(const struct iovec *, lvec, lvec)) sc_in(ctf_integer(unsigned long, liovcnt, liovcnt)) sc_in(ctf_integer(const struct iovec *, rvec, rvec)) sc_in(ctf_integer(unsigned long, riovcnt, riovcnt)) sc_in(ctf_integer(unsigned long, flags, flags))) +) +#endif + +#endif /* _TRACE_SYSCALLS_POINTERS_H */ + +/* This part must be outside protection */ +#include + +#else /* CREATE_SYSCALL_TABLE */ + +#include "arm-32-syscalls_pointers_override.h" +#include "syscalls_pointers_override.h" + +#ifndef OVERRIDE_TABLE_32_read +TRACE_SYSCALL_TABLE(read, read, 3, 3) +#endif +#ifndef OVERRIDE_TABLE_32_write +TRACE_SYSCALL_TABLE(write, write, 4, 3) +#endif +#ifndef OVERRIDE_TABLE_32_open +TRACE_SYSCALL_TABLE(open, open, 5, 3) +#endif +#ifndef OVERRIDE_TABLE_32_creat +TRACE_SYSCALL_TABLE(creat, creat, 8, 2) +#endif +#ifndef OVERRIDE_TABLE_32_link +TRACE_SYSCALL_TABLE(link, link, 9, 2) +#endif +#ifndef OVERRIDE_TABLE_32_unlink +TRACE_SYSCALL_TABLE(unlink, unlink, 10, 1) +#endif +#ifndef OVERRIDE_TABLE_32_chdir +TRACE_SYSCALL_TABLE(chdir, chdir, 12, 1) +#endif +#ifndef OVERRIDE_TABLE_32_mknod +TRACE_SYSCALL_TABLE(mknod, mknod, 14, 3) +#endif +#ifndef OVERRIDE_TABLE_32_chmod +TRACE_SYSCALL_TABLE(chmod, chmod, 15, 2) +#endif +#ifndef OVERRIDE_TABLE_32_lchown16 +TRACE_SYSCALL_TABLE(lchown16, lchown16, 16, 3) +#endif +#ifndef OVERRIDE_TABLE_32_mount +TRACE_SYSCALL_TABLE(mount, mount, 21, 5) +#endif +#ifndef OVERRIDE_TABLE_32_access +TRACE_SYSCALL_TABLE(access, access, 33, 2) +#endif +#ifndef OVERRIDE_TABLE_32_rename +TRACE_SYSCALL_TABLE(rename, rename, 38, 2) +#endif +#ifndef OVERRIDE_TABLE_32_mkdir +TRACE_SYSCALL_TABLE(mkdir, mkdir, 39, 2) +#endif +#ifndef OVERRIDE_TABLE_32_rmdir +TRACE_SYSCALL_TABLE(rmdir, rmdir, 40, 1) +#endif +#ifndef OVERRIDE_TABLE_32_pipe +TRACE_SYSCALL_TABLE(pipe, pipe, 42, 1) +#endif +#ifndef OVERRIDE_TABLE_32_times +TRACE_SYSCALL_TABLE(times, times, 43, 1) +#endif +#ifndef OVERRIDE_TABLE_32_acct +TRACE_SYSCALL_TABLE(acct, acct, 51, 1) +#endif +#ifndef OVERRIDE_TABLE_32_umount +TRACE_SYSCALL_TABLE(umount, umount, 52, 2) +#endif +#ifndef OVERRIDE_TABLE_32_chroot +TRACE_SYSCALL_TABLE(chroot, chroot, 61, 1) +#endif +#ifndef OVERRIDE_TABLE_32_ustat +TRACE_SYSCALL_TABLE(ustat, ustat, 62, 2) +#endif +#ifndef OVERRIDE_TABLE_32_sigpending +TRACE_SYSCALL_TABLE(sigpending, sigpending, 73, 1) +#endif +#ifndef OVERRIDE_TABLE_32_sethostname +TRACE_SYSCALL_TABLE(sethostname, sethostname, 74, 2) +#endif +#ifndef OVERRIDE_TABLE_32_setrlimit +TRACE_SYSCALL_TABLE(setrlimit, setrlimit, 75, 2) +#endif +#ifndef OVERRIDE_TABLE_32_getrusage +TRACE_SYSCALL_TABLE(getrusage, getrusage, 77, 2) +#endif +#ifndef OVERRIDE_TABLE_32_gettimeofday +TRACE_SYSCALL_TABLE(gettimeofday, gettimeofday, 78, 2) +#endif +#ifndef OVERRIDE_TABLE_32_settimeofday +TRACE_SYSCALL_TABLE(settimeofday, settimeofday, 79, 2) +#endif +#ifndef OVERRIDE_TABLE_32_getgroups16 +TRACE_SYSCALL_TABLE(getgroups16, getgroups16, 80, 2) +#endif +#ifndef OVERRIDE_TABLE_32_setgroups16 +TRACE_SYSCALL_TABLE(setgroups16, setgroups16, 81, 2) +#endif +#ifndef OVERRIDE_TABLE_32_symlink +TRACE_SYSCALL_TABLE(symlink, symlink, 83, 2) +#endif +#ifndef OVERRIDE_TABLE_32_readlink +TRACE_SYSCALL_TABLE(readlink, readlink, 85, 3) +#endif +#ifndef OVERRIDE_TABLE_32_uselib +TRACE_SYSCALL_TABLE(uselib, uselib, 86, 1) +#endif +#ifndef OVERRIDE_TABLE_32_swapon +TRACE_SYSCALL_TABLE(swapon, swapon, 87, 2) +#endif +#ifndef OVERRIDE_TABLE_32_reboot +TRACE_SYSCALL_TABLE(reboot, reboot, 88, 4) +#endif +#ifndef OVERRIDE_TABLE_32_truncate +TRACE_SYSCALL_TABLE(truncate, truncate, 92, 2) +#endif +#ifndef OVERRIDE_TABLE_32_statfs +TRACE_SYSCALL_TABLE(statfs, statfs, 99, 2) +#endif +#ifndef OVERRIDE_TABLE_32_fstatfs +TRACE_SYSCALL_TABLE(fstatfs, fstatfs, 100, 2) +#endif +#ifndef OVERRIDE_TABLE_32_syslog +TRACE_SYSCALL_TABLE(syslog, syslog, 103, 3) +#endif +#ifndef OVERRIDE_TABLE_32_setitimer +TRACE_SYSCALL_TABLE(setitimer, setitimer, 104, 3) +#endif +#ifndef OVERRIDE_TABLE_32_getitimer +TRACE_SYSCALL_TABLE(getitimer, getitimer, 105, 2) +#endif +#ifndef OVERRIDE_TABLE_32_newstat +TRACE_SYSCALL_TABLE(newstat, newstat, 106, 2) +#endif +#ifndef OVERRIDE_TABLE_32_newlstat +TRACE_SYSCALL_TABLE(newlstat, newlstat, 107, 2) +#endif +#ifndef OVERRIDE_TABLE_32_newfstat +TRACE_SYSCALL_TABLE(newfstat, newfstat, 108, 2) +#endif +#ifndef OVERRIDE_TABLE_32_wait4 +TRACE_SYSCALL_TABLE(wait4, wait4, 114, 4) +#endif +#ifndef OVERRIDE_TABLE_32_swapoff +TRACE_SYSCALL_TABLE(swapoff, swapoff, 115, 1) +#endif +#ifndef OVERRIDE_TABLE_32_sysinfo +TRACE_SYSCALL_TABLE(sysinfo, sysinfo, 116, 1) +#endif +#ifndef OVERRIDE_TABLE_32_setdomainname +TRACE_SYSCALL_TABLE(setdomainname, setdomainname, 121, 2) +#endif +#ifndef OVERRIDE_TABLE_32_newuname +TRACE_SYSCALL_TABLE(newuname, newuname, 122, 1) +#endif +#ifndef OVERRIDE_TABLE_32_adjtimex +TRACE_SYSCALL_TABLE(adjtimex, adjtimex, 124, 1) +#endif +#ifndef OVERRIDE_TABLE_32_sigprocmask +TRACE_SYSCALL_TABLE(sigprocmask, sigprocmask, 126, 3) +#endif +#ifndef OVERRIDE_TABLE_32_init_module +TRACE_SYSCALL_TABLE(init_module, init_module, 128, 3) +#endif +#ifndef OVERRIDE_TABLE_32_delete_module +TRACE_SYSCALL_TABLE(delete_module, delete_module, 129, 2) +#endif +#ifndef OVERRIDE_TABLE_32_quotactl +TRACE_SYSCALL_TABLE(quotactl, quotactl, 131, 4) +#endif +#ifndef OVERRIDE_TABLE_32_llseek +TRACE_SYSCALL_TABLE(llseek, llseek, 140, 5) +#endif +#ifndef OVERRIDE_TABLE_32_getdents +TRACE_SYSCALL_TABLE(getdents, getdents, 141, 3) +#endif +#ifndef OVERRIDE_TABLE_32_select +TRACE_SYSCALL_TABLE(select, select, 142, 5) +#endif +#ifndef OVERRIDE_TABLE_32_readv +TRACE_SYSCALL_TABLE(readv, readv, 145, 3) +#endif +#ifndef OVERRIDE_TABLE_32_writev +TRACE_SYSCALL_TABLE(writev, writev, 146, 3) +#endif +#ifndef OVERRIDE_TABLE_32_sysctl +TRACE_SYSCALL_TABLE(sysctl, sysctl, 149, 1) +#endif +#ifndef OVERRIDE_TABLE_32_sched_setparam +TRACE_SYSCALL_TABLE(sched_setparam, sched_setparam, 154, 2) +#endif +#ifndef OVERRIDE_TABLE_32_sched_getparam +TRACE_SYSCALL_TABLE(sched_getparam, sched_getparam, 155, 2) +#endif +#ifndef OVERRIDE_TABLE_32_sched_setscheduler +TRACE_SYSCALL_TABLE(sched_setscheduler, sched_setscheduler, 156, 3) +#endif +#ifndef OVERRIDE_TABLE_32_sched_rr_get_interval +TRACE_SYSCALL_TABLE(sched_rr_get_interval, sched_rr_get_interval, 161, 2) +#endif +#ifndef OVERRIDE_TABLE_32_nanosleep +TRACE_SYSCALL_TABLE(nanosleep, nanosleep, 162, 2) +#endif +#ifndef OVERRIDE_TABLE_32_getresuid16 +TRACE_SYSCALL_TABLE(getresuid16, getresuid16, 165, 3) +#endif +#ifndef OVERRIDE_TABLE_32_poll +TRACE_SYSCALL_TABLE(poll, poll, 168, 3) +#endif +#ifndef OVERRIDE_TABLE_32_getresgid16 +TRACE_SYSCALL_TABLE(getresgid16, getresgid16, 171, 3) +#endif +#ifndef OVERRIDE_TABLE_32_rt_sigaction +TRACE_SYSCALL_TABLE(rt_sigaction, rt_sigaction, 174, 4) +#endif +#ifndef OVERRIDE_TABLE_32_rt_sigprocmask +TRACE_SYSCALL_TABLE(rt_sigprocmask, rt_sigprocmask, 175, 4) +#endif +#ifndef OVERRIDE_TABLE_32_rt_sigpending +TRACE_SYSCALL_TABLE(rt_sigpending, rt_sigpending, 176, 2) +#endif +#ifndef OVERRIDE_TABLE_32_rt_sigtimedwait +TRACE_SYSCALL_TABLE(rt_sigtimedwait, rt_sigtimedwait, 177, 4) +#endif +#ifndef OVERRIDE_TABLE_32_rt_sigqueueinfo +TRACE_SYSCALL_TABLE(rt_sigqueueinfo, rt_sigqueueinfo, 178, 3) +#endif +#ifndef OVERRIDE_TABLE_32_rt_sigsuspend +TRACE_SYSCALL_TABLE(rt_sigsuspend, rt_sigsuspend, 179, 2) +#endif +#ifndef OVERRIDE_TABLE_32_chown16 +TRACE_SYSCALL_TABLE(chown16, chown16, 182, 3) +#endif +#ifndef OVERRIDE_TABLE_32_getcwd +TRACE_SYSCALL_TABLE(getcwd, getcwd, 183, 2) +#endif +#ifndef OVERRIDE_TABLE_32_sendfile +TRACE_SYSCALL_TABLE(sendfile, sendfile, 187, 4) +#endif +#ifndef OVERRIDE_TABLE_32_getrlimit +TRACE_SYSCALL_TABLE(getrlimit, getrlimit, 191, 2) +#endif +#ifndef OVERRIDE_TABLE_32_stat64 +TRACE_SYSCALL_TABLE(stat64, stat64, 195, 2) +#endif +#ifndef OVERRIDE_TABLE_32_lstat64 +TRACE_SYSCALL_TABLE(lstat64, lstat64, 196, 2) +#endif +#ifndef OVERRIDE_TABLE_32_fstat64 +TRACE_SYSCALL_TABLE(fstat64, fstat64, 197, 2) +#endif +#ifndef OVERRIDE_TABLE_32_lchown +TRACE_SYSCALL_TABLE(lchown, lchown, 198, 3) +#endif +#ifndef OVERRIDE_TABLE_32_getgroups +TRACE_SYSCALL_TABLE(getgroups, getgroups, 205, 2) +#endif +#ifndef OVERRIDE_TABLE_32_setgroups +TRACE_SYSCALL_TABLE(setgroups, setgroups, 206, 2) +#endif +#ifndef OVERRIDE_TABLE_32_getresuid +TRACE_SYSCALL_TABLE(getresuid, getresuid, 209, 3) +#endif +#ifndef OVERRIDE_TABLE_32_getresgid +TRACE_SYSCALL_TABLE(getresgid, getresgid, 211, 3) +#endif +#ifndef OVERRIDE_TABLE_32_chown +TRACE_SYSCALL_TABLE(chown, chown, 212, 3) +#endif +#ifndef OVERRIDE_TABLE_32_getdents64 +TRACE_SYSCALL_TABLE(getdents64, getdents64, 217, 3) +#endif +#ifndef OVERRIDE_TABLE_32_pivot_root +TRACE_SYSCALL_TABLE(pivot_root, pivot_root, 218, 2) +#endif +#ifndef OVERRIDE_TABLE_32_mincore +TRACE_SYSCALL_TABLE(mincore, mincore, 219, 3) +#endif +#ifndef OVERRIDE_TABLE_32_setxattr +TRACE_SYSCALL_TABLE(setxattr, setxattr, 226, 5) +#endif +#ifndef OVERRIDE_TABLE_32_lsetxattr +TRACE_SYSCALL_TABLE(lsetxattr, lsetxattr, 227, 5) +#endif +#ifndef OVERRIDE_TABLE_32_fsetxattr +TRACE_SYSCALL_TABLE(fsetxattr, fsetxattr, 228, 5) +#endif +#ifndef OVERRIDE_TABLE_32_getxattr +TRACE_SYSCALL_TABLE(getxattr, getxattr, 229, 4) +#endif +#ifndef OVERRIDE_TABLE_32_lgetxattr +TRACE_SYSCALL_TABLE(lgetxattr, lgetxattr, 230, 4) +#endif +#ifndef OVERRIDE_TABLE_32_fgetxattr +TRACE_SYSCALL_TABLE(fgetxattr, fgetxattr, 231, 4) +#endif +#ifndef OVERRIDE_TABLE_32_listxattr +TRACE_SYSCALL_TABLE(listxattr, listxattr, 232, 3) +#endif +#ifndef OVERRIDE_TABLE_32_llistxattr +TRACE_SYSCALL_TABLE(llistxattr, llistxattr, 233, 3) +#endif +#ifndef OVERRIDE_TABLE_32_flistxattr +TRACE_SYSCALL_TABLE(flistxattr, flistxattr, 234, 3) +#endif +#ifndef OVERRIDE_TABLE_32_removexattr +TRACE_SYSCALL_TABLE(removexattr, removexattr, 235, 2) +#endif +#ifndef OVERRIDE_TABLE_32_lremovexattr +TRACE_SYSCALL_TABLE(lremovexattr, lremovexattr, 236, 2) +#endif +#ifndef OVERRIDE_TABLE_32_fremovexattr +TRACE_SYSCALL_TABLE(fremovexattr, fremovexattr, 237, 2) +#endif +#ifndef OVERRIDE_TABLE_32_sendfile64 +TRACE_SYSCALL_TABLE(sendfile64, sendfile64, 239, 4) +#endif +#ifndef OVERRIDE_TABLE_32_futex +TRACE_SYSCALL_TABLE(futex, futex, 240, 6) +#endif +#ifndef OVERRIDE_TABLE_32_sched_setaffinity +TRACE_SYSCALL_TABLE(sched_setaffinity, sched_setaffinity, 241, 3) +#endif +#ifndef OVERRIDE_TABLE_32_sched_getaffinity +TRACE_SYSCALL_TABLE(sched_getaffinity, sched_getaffinity, 242, 3) +#endif +#ifndef OVERRIDE_TABLE_32_io_setup +TRACE_SYSCALL_TABLE(io_setup, io_setup, 243, 2) +#endif +#ifndef OVERRIDE_TABLE_32_io_getevents +TRACE_SYSCALL_TABLE(io_getevents, io_getevents, 245, 5) +#endif +#ifndef OVERRIDE_TABLE_32_io_submit +TRACE_SYSCALL_TABLE(io_submit, io_submit, 246, 3) +#endif +#ifndef OVERRIDE_TABLE_32_io_cancel +TRACE_SYSCALL_TABLE(io_cancel, io_cancel, 247, 3) +#endif +#ifndef OVERRIDE_TABLE_32_epoll_ctl +TRACE_SYSCALL_TABLE(epoll_ctl, epoll_ctl, 251, 4) +#endif +#ifndef OVERRIDE_TABLE_32_epoll_wait +TRACE_SYSCALL_TABLE(epoll_wait, epoll_wait, 252, 4) +#endif +#ifndef OVERRIDE_TABLE_32_set_tid_address +TRACE_SYSCALL_TABLE(set_tid_address, set_tid_address, 256, 1) +#endif +#ifndef OVERRIDE_TABLE_32_timer_create +TRACE_SYSCALL_TABLE(timer_create, timer_create, 257, 3) +#endif +#ifndef OVERRIDE_TABLE_32_timer_settime +TRACE_SYSCALL_TABLE(timer_settime, timer_settime, 258, 4) +#endif +#ifndef OVERRIDE_TABLE_32_timer_gettime +TRACE_SYSCALL_TABLE(timer_gettime, timer_gettime, 259, 2) +#endif +#ifndef OVERRIDE_TABLE_32_clock_settime +TRACE_SYSCALL_TABLE(clock_settime, clock_settime, 262, 2) +#endif +#ifndef OVERRIDE_TABLE_32_clock_gettime +TRACE_SYSCALL_TABLE(clock_gettime, clock_gettime, 263, 2) +#endif +#ifndef OVERRIDE_TABLE_32_clock_getres +TRACE_SYSCALL_TABLE(clock_getres, clock_getres, 264, 2) +#endif +#ifndef OVERRIDE_TABLE_32_clock_nanosleep +TRACE_SYSCALL_TABLE(clock_nanosleep, clock_nanosleep, 265, 4) +#endif +#ifndef OVERRIDE_TABLE_32_utimes +TRACE_SYSCALL_TABLE(utimes, utimes, 269, 2) +#endif +#ifndef OVERRIDE_TABLE_32_mq_open +TRACE_SYSCALL_TABLE(mq_open, mq_open, 274, 4) +#endif +#ifndef OVERRIDE_TABLE_32_mq_unlink +TRACE_SYSCALL_TABLE(mq_unlink, mq_unlink, 275, 1) +#endif +#ifndef OVERRIDE_TABLE_32_mq_timedsend +TRACE_SYSCALL_TABLE(mq_timedsend, mq_timedsend, 276, 5) +#endif +#ifndef OVERRIDE_TABLE_32_mq_timedreceive +TRACE_SYSCALL_TABLE(mq_timedreceive, mq_timedreceive, 277, 5) +#endif +#ifndef OVERRIDE_TABLE_32_mq_notify +TRACE_SYSCALL_TABLE(mq_notify, mq_notify, 278, 2) +#endif +#ifndef OVERRIDE_TABLE_32_mq_getsetattr +TRACE_SYSCALL_TABLE(mq_getsetattr, mq_getsetattr, 279, 3) +#endif +#ifndef OVERRIDE_TABLE_32_waitid +TRACE_SYSCALL_TABLE(waitid, waitid, 280, 5) +#endif +#ifndef OVERRIDE_TABLE_32_bind +TRACE_SYSCALL_TABLE(bind, bind, 282, 3) +#endif +#ifndef OVERRIDE_TABLE_32_connect +TRACE_SYSCALL_TABLE(connect, connect, 283, 3) +#endif +#ifndef OVERRIDE_TABLE_32_accept +TRACE_SYSCALL_TABLE(accept, accept, 285, 3) +#endif +#ifndef OVERRIDE_TABLE_32_getsockname +TRACE_SYSCALL_TABLE(getsockname, getsockname, 286, 3) +#endif +#ifndef OVERRIDE_TABLE_32_getpeername +TRACE_SYSCALL_TABLE(getpeername, getpeername, 287, 3) +#endif +#ifndef OVERRIDE_TABLE_32_socketpair +TRACE_SYSCALL_TABLE(socketpair, socketpair, 288, 4) +#endif +#ifndef OVERRIDE_TABLE_32_send +TRACE_SYSCALL_TABLE(send, send, 289, 4) +#endif +#ifndef OVERRIDE_TABLE_32_sendto +TRACE_SYSCALL_TABLE(sendto, sendto, 290, 6) +#endif +#ifndef OVERRIDE_TABLE_32_recvfrom +TRACE_SYSCALL_TABLE(recvfrom, recvfrom, 292, 6) +#endif +#ifndef OVERRIDE_TABLE_32_setsockopt +TRACE_SYSCALL_TABLE(setsockopt, setsockopt, 294, 5) +#endif +#ifndef OVERRIDE_TABLE_32_getsockopt +TRACE_SYSCALL_TABLE(getsockopt, getsockopt, 295, 5) +#endif +#ifndef OVERRIDE_TABLE_32_sendmsg +TRACE_SYSCALL_TABLE(sendmsg, sendmsg, 296, 3) +#endif +#ifndef OVERRIDE_TABLE_32_recvmsg +TRACE_SYSCALL_TABLE(recvmsg, recvmsg, 297, 3) +#endif +#ifndef OVERRIDE_TABLE_32_semop +TRACE_SYSCALL_TABLE(semop, semop, 298, 3) +#endif +#ifndef OVERRIDE_TABLE_32_msgsnd +TRACE_SYSCALL_TABLE(msgsnd, msgsnd, 301, 4) +#endif +#ifndef OVERRIDE_TABLE_32_msgrcv +TRACE_SYSCALL_TABLE(msgrcv, msgrcv, 302, 5) +#endif +#ifndef OVERRIDE_TABLE_32_msgctl +TRACE_SYSCALL_TABLE(msgctl, msgctl, 304, 3) +#endif +#ifndef OVERRIDE_TABLE_32_shmat +TRACE_SYSCALL_TABLE(shmat, shmat, 305, 3) +#endif +#ifndef OVERRIDE_TABLE_32_shmdt +TRACE_SYSCALL_TABLE(shmdt, shmdt, 306, 1) +#endif +#ifndef OVERRIDE_TABLE_32_shmctl +TRACE_SYSCALL_TABLE(shmctl, shmctl, 308, 3) +#endif +#ifndef OVERRIDE_TABLE_32_add_key +TRACE_SYSCALL_TABLE(add_key, add_key, 309, 5) +#endif +#ifndef OVERRIDE_TABLE_32_request_key +TRACE_SYSCALL_TABLE(request_key, request_key, 310, 4) +#endif +#ifndef OVERRIDE_TABLE_32_semtimedop +TRACE_SYSCALL_TABLE(semtimedop, semtimedop, 312, 4) +#endif +#ifndef OVERRIDE_TABLE_32_inotify_add_watch +TRACE_SYSCALL_TABLE(inotify_add_watch, inotify_add_watch, 317, 3) +#endif +#ifndef OVERRIDE_TABLE_32_openat +TRACE_SYSCALL_TABLE(openat, openat, 322, 4) +#endif +#ifndef OVERRIDE_TABLE_32_mkdirat +TRACE_SYSCALL_TABLE(mkdirat, mkdirat, 323, 3) +#endif +#ifndef OVERRIDE_TABLE_32_mknodat +TRACE_SYSCALL_TABLE(mknodat, mknodat, 324, 4) +#endif +#ifndef OVERRIDE_TABLE_32_fchownat +TRACE_SYSCALL_TABLE(fchownat, fchownat, 325, 5) +#endif +#ifndef OVERRIDE_TABLE_32_futimesat +TRACE_SYSCALL_TABLE(futimesat, futimesat, 326, 3) +#endif +#ifndef OVERRIDE_TABLE_32_fstatat64 +TRACE_SYSCALL_TABLE(fstatat64, fstatat64, 327, 4) +#endif +#ifndef OVERRIDE_TABLE_32_unlinkat +TRACE_SYSCALL_TABLE(unlinkat, unlinkat, 328, 3) +#endif +#ifndef OVERRIDE_TABLE_32_renameat +TRACE_SYSCALL_TABLE(renameat, renameat, 329, 4) +#endif +#ifndef OVERRIDE_TABLE_32_linkat +TRACE_SYSCALL_TABLE(linkat, linkat, 330, 5) +#endif +#ifndef OVERRIDE_TABLE_32_symlinkat +TRACE_SYSCALL_TABLE(symlinkat, symlinkat, 331, 3) +#endif +#ifndef OVERRIDE_TABLE_32_readlinkat +TRACE_SYSCALL_TABLE(readlinkat, readlinkat, 332, 4) +#endif +#ifndef OVERRIDE_TABLE_32_fchmodat +TRACE_SYSCALL_TABLE(fchmodat, fchmodat, 333, 3) +#endif +#ifndef OVERRIDE_TABLE_32_faccessat +TRACE_SYSCALL_TABLE(faccessat, faccessat, 334, 3) +#endif +#ifndef OVERRIDE_TABLE_32_pselect6 +TRACE_SYSCALL_TABLE(pselect6, pselect6, 335, 6) +#endif +#ifndef OVERRIDE_TABLE_32_ppoll +TRACE_SYSCALL_TABLE(ppoll, ppoll, 336, 5) +#endif +#ifndef OVERRIDE_TABLE_32_set_robust_list +TRACE_SYSCALL_TABLE(set_robust_list, set_robust_list, 338, 2) +#endif +#ifndef OVERRIDE_TABLE_32_get_robust_list +TRACE_SYSCALL_TABLE(get_robust_list, get_robust_list, 339, 3) +#endif +#ifndef OVERRIDE_TABLE_32_splice +TRACE_SYSCALL_TABLE(splice, splice, 340, 6) +#endif +#ifndef OVERRIDE_TABLE_32_vmsplice +TRACE_SYSCALL_TABLE(vmsplice, vmsplice, 343, 4) +#endif +#ifndef OVERRIDE_TABLE_32_getcpu +TRACE_SYSCALL_TABLE(getcpu, getcpu, 345, 3) +#endif +#ifndef OVERRIDE_TABLE_32_epoll_pwait +TRACE_SYSCALL_TABLE(epoll_pwait, epoll_pwait, 346, 6) +#endif +#ifndef OVERRIDE_TABLE_32_utimensat +TRACE_SYSCALL_TABLE(utimensat, utimensat, 348, 4) +#endif +#ifndef OVERRIDE_TABLE_32_signalfd +TRACE_SYSCALL_TABLE(signalfd, signalfd, 349, 3) +#endif +#ifndef OVERRIDE_TABLE_32_timerfd_settime +TRACE_SYSCALL_TABLE(timerfd_settime, timerfd_settime, 353, 4) +#endif +#ifndef OVERRIDE_TABLE_32_timerfd_gettime +TRACE_SYSCALL_TABLE(timerfd_gettime, timerfd_gettime, 354, 2) +#endif +#ifndef OVERRIDE_TABLE_32_signalfd4 +TRACE_SYSCALL_TABLE(signalfd4, signalfd4, 355, 4) +#endif +#ifndef OVERRIDE_TABLE_32_pipe2 +TRACE_SYSCALL_TABLE(pipe2, pipe2, 359, 2) +#endif +#ifndef OVERRIDE_TABLE_32_preadv +TRACE_SYSCALL_TABLE(preadv, preadv, 361, 5) +#endif +#ifndef OVERRIDE_TABLE_32_pwritev +TRACE_SYSCALL_TABLE(pwritev, pwritev, 362, 5) +#endif +#ifndef OVERRIDE_TABLE_32_rt_tgsigqueueinfo +TRACE_SYSCALL_TABLE(rt_tgsigqueueinfo, rt_tgsigqueueinfo, 363, 4) +#endif +#ifndef OVERRIDE_TABLE_32_perf_event_open +TRACE_SYSCALL_TABLE(perf_event_open, perf_event_open, 364, 5) +#endif +#ifndef OVERRIDE_TABLE_32_recvmmsg +TRACE_SYSCALL_TABLE(recvmmsg, recvmmsg, 365, 5) +#endif +#ifndef OVERRIDE_TABLE_32_accept4 +TRACE_SYSCALL_TABLE(accept4, accept4, 366, 4) +#endif +#ifndef OVERRIDE_TABLE_32_prlimit64 +TRACE_SYSCALL_TABLE(prlimit64, prlimit64, 369, 4) +#endif +#ifndef OVERRIDE_TABLE_32_name_to_handle_at +TRACE_SYSCALL_TABLE(name_to_handle_at, name_to_handle_at, 370, 5) +#endif +#ifndef OVERRIDE_TABLE_32_open_by_handle_at +TRACE_SYSCALL_TABLE(open_by_handle_at, open_by_handle_at, 371, 3) +#endif +#ifndef OVERRIDE_TABLE_32_clock_adjtime +TRACE_SYSCALL_TABLE(clock_adjtime, clock_adjtime, 372, 2) +#endif +#ifndef OVERRIDE_TABLE_32_sendmmsg +TRACE_SYSCALL_TABLE(sendmmsg, sendmmsg, 374, 4) +#endif +#ifndef OVERRIDE_TABLE_32_process_vm_readv +TRACE_SYSCALL_TABLE(process_vm_readv, process_vm_readv, 376, 6) +#endif +#ifndef OVERRIDE_TABLE_32_process_vm_writev +TRACE_SYSCALL_TABLE(process_vm_writev, process_vm_writev, 377, 6) +#endif + +#endif /* CREATE_SYSCALL_TABLE */ diff --git a/include/instrumentation/syscalls/headers/arm-32-syscalls_pointers_override.h b/include/instrumentation/syscalls/headers/arm-32-syscalls_pointers_override.h new file mode 100644 index 00000000..68ba1c4e --- /dev/null +++ b/include/instrumentation/syscalls/headers/arm-32-syscalls_pointers_override.h @@ -0,0 +1,43 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ + +#define OVERRIDE_TABLE_32_mmap2 + +# ifndef CONFIG_UID16 +# define OVERRIDE_32_getgroups16 +# define OVERRIDE_32_setgroups16 +# define OVERRIDE_32_lchown16 +# define OVERRIDE_32_getresuid16 +# define OVERRIDE_32_getresgid16 +# define OVERRIDE_32_chown16 +# endif + +#ifndef CREATE_SYSCALL_TABLE + +#define OVERRIDE_32_pipe +SC_LTTNG_TRACEPOINT_EVENT(pipe, + TP_PROTO(sc_exit(long ret,) int * fildes), + TP_ARGS(sc_exit(ret,) fildes), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) + sc_out(ctf_user_array(int, fildes, fildes, 2)) + ) +) + +#else /* CREATE_SYSCALL_TABLE */ + +# ifndef CONFIG_UID16 +# define OVERRIDE_TABLE_32_getgroups16 +# define OVERRIDE_TABLE_32_setgroups16 +# define OVERRIDE_TABLE_32_lchown16 +# define OVERRIDE_TABLE_32_getresuid16 +# define OVERRIDE_TABLE_32_getresgid16 +# define OVERRIDE_TABLE_32_chown16 +# endif + +#define OVERRIDE_TABLE_32_execve +TRACE_SYSCALL_TABLE(execve, execve, 11, 3) +#define OVERRIDE_TABLE_32_clone +TRACE_SYSCALL_TABLE(clone, clone, 120, 5) + +#endif /* CREATE_SYSCALL_TABLE */ + + diff --git a/include/instrumentation/syscalls/headers/arm-64-syscalls_integers.h b/include/instrumentation/syscalls/headers/arm-64-syscalls_integers.h new file mode 100644 index 00000000..71cc60be --- /dev/null +++ b/include/instrumentation/syscalls/headers/arm-64-syscalls_integers.h @@ -0,0 +1,1016 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ + +/* THIS FILE IS AUTO-GENERATED. DO NOT EDIT */ + +/* Generated from arm-64-syscalls 4.4.0 */ + +#ifndef CREATE_SYSCALL_TABLE + +#if !defined(_TRACE_SYSCALLS_INTEGERS_H) || defined(TRACE_HEADER_MULTI_READ) +#define _TRACE_SYSCALLS_INTEGERS_H + +#include +#include +#include "arm-64-syscalls_integers_override.h" +#include "syscalls_integers_override.h" + +#ifdef SC_ENTER +SC_LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(syscalls_noargs, + TP_FIELDS() +) +#ifndef OVERRIDE_64_vhangup +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, vhangup) +#endif +#ifndef OVERRIDE_64_sync +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, sync) +#endif +#ifndef OVERRIDE_64_sched_yield +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, sched_yield) +#endif +#ifndef OVERRIDE_64_restart_syscall +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, restart_syscall) +#endif +#ifndef OVERRIDE_64_setsid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, setsid) +#endif +#ifndef OVERRIDE_64_getpid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getpid) +#endif +#ifndef OVERRIDE_64_getppid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getppid) +#endif +#ifndef OVERRIDE_64_getuid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getuid) +#endif +#ifndef OVERRIDE_64_geteuid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, geteuid) +#endif +#ifndef OVERRIDE_64_getgid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getgid) +#endif +#ifndef OVERRIDE_64_getegid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getegid) +#endif +#ifndef OVERRIDE_64_gettid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, gettid) +#endif +#ifndef OVERRIDE_64_munlockall +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, munlockall) +#endif +#else /* #ifdef SC_ENTER */ +#ifndef OVERRIDE_64_vhangup +SC_LTTNG_TRACEPOINT_EVENT(vhangup, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_64_sync +SC_LTTNG_TRACEPOINT_EVENT(sync, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_64_sched_yield +SC_LTTNG_TRACEPOINT_EVENT(sched_yield, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_64_restart_syscall +SC_LTTNG_TRACEPOINT_EVENT(restart_syscall, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_64_setsid +SC_LTTNG_TRACEPOINT_EVENT(setsid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_64_getpid +SC_LTTNG_TRACEPOINT_EVENT(getpid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_64_getppid +SC_LTTNG_TRACEPOINT_EVENT(getppid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_64_getuid +SC_LTTNG_TRACEPOINT_EVENT(getuid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_64_geteuid +SC_LTTNG_TRACEPOINT_EVENT(geteuid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_64_getgid +SC_LTTNG_TRACEPOINT_EVENT(getgid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_64_getegid +SC_LTTNG_TRACEPOINT_EVENT(getegid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_64_gettid +SC_LTTNG_TRACEPOINT_EVENT(gettid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_64_munlockall +SC_LTTNG_TRACEPOINT_EVENT(munlockall, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#endif /* else #ifdef SC_ENTER */ +#ifndef OVERRIDE_64_io_destroy +SC_LTTNG_TRACEPOINT_EVENT(io_destroy, + TP_PROTO(sc_exit(long ret,) aio_context_t ctx), + TP_ARGS(sc_exit(ret,) ctx), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx, ctx))) +) +#endif +#ifndef OVERRIDE_64_epoll_create1 +SC_LTTNG_TRACEPOINT_EVENT(epoll_create1, + TP_PROTO(sc_exit(long ret,) int flags), + TP_ARGS(sc_exit(ret,) flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_dup +SC_LTTNG_TRACEPOINT_EVENT(dup, + TP_PROTO(sc_exit(long ret,) unsigned int fildes), + TP_ARGS(sc_exit(ret,) fildes), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fildes, fildes))) +) +#endif +#ifndef OVERRIDE_64_inotify_init1 +SC_LTTNG_TRACEPOINT_EVENT(inotify_init1, + TP_PROTO(sc_exit(long ret,) int flags), + TP_ARGS(sc_exit(ret,) flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_fchdir +SC_LTTNG_TRACEPOINT_EVENT(fchdir, + TP_PROTO(sc_exit(long ret,) unsigned int fd), + TP_ARGS(sc_exit(ret,) fd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) +) +#endif +#ifndef OVERRIDE_64_close +SC_LTTNG_TRACEPOINT_EVENT(close, + TP_PROTO(sc_exit(long ret,) unsigned int fd), + TP_ARGS(sc_exit(ret,) fd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) +) +#endif +#ifndef OVERRIDE_64_fsync +SC_LTTNG_TRACEPOINT_EVENT(fsync, + TP_PROTO(sc_exit(long ret,) unsigned int fd), + TP_ARGS(sc_exit(ret,) fd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) +) +#endif +#ifndef OVERRIDE_64_fdatasync +SC_LTTNG_TRACEPOINT_EVENT(fdatasync, + TP_PROTO(sc_exit(long ret,) unsigned int fd), + TP_ARGS(sc_exit(ret,) fd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) +) +#endif +#ifndef OVERRIDE_64_personality +SC_LTTNG_TRACEPOINT_EVENT(personality, + TP_PROTO(sc_exit(long ret,) unsigned int personality), + TP_ARGS(sc_exit(ret,) personality), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, personality, personality))) +) +#endif +#ifndef OVERRIDE_64_exit +SC_LTTNG_TRACEPOINT_EVENT(exit, + TP_PROTO(sc_exit(long ret,) int error_code), + TP_ARGS(sc_exit(ret,) error_code), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, error_code, error_code))) +) +#endif +#ifndef OVERRIDE_64_exit_group +SC_LTTNG_TRACEPOINT_EVENT(exit_group, + TP_PROTO(sc_exit(long ret,) int error_code), + TP_ARGS(sc_exit(ret,) error_code), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, error_code, error_code))) +) +#endif +#ifndef OVERRIDE_64_unshare +SC_LTTNG_TRACEPOINT_EVENT(unshare, + TP_PROTO(sc_exit(long ret,) unsigned long unshare_flags), + TP_ARGS(sc_exit(ret,) unshare_flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, unshare_flags, unshare_flags))) +) +#endif +#ifndef OVERRIDE_64_timer_getoverrun +SC_LTTNG_TRACEPOINT_EVENT(timer_getoverrun, + TP_PROTO(sc_exit(long ret,) timer_t timer_id), + TP_ARGS(sc_exit(ret,) timer_id), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id))) +) +#endif +#ifndef OVERRIDE_64_timer_delete +SC_LTTNG_TRACEPOINT_EVENT(timer_delete, + TP_PROTO(sc_exit(long ret,) timer_t timer_id), + TP_ARGS(sc_exit(ret,) timer_id), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id))) +) +#endif +#ifndef OVERRIDE_64_sched_getscheduler +SC_LTTNG_TRACEPOINT_EVENT(sched_getscheduler, + TP_PROTO(sc_exit(long ret,) pid_t pid), + TP_ARGS(sc_exit(ret,) pid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid))) +) +#endif +#ifndef OVERRIDE_64_sched_get_priority_max +SC_LTTNG_TRACEPOINT_EVENT(sched_get_priority_max, + TP_PROTO(sc_exit(long ret,) int policy), + TP_ARGS(sc_exit(ret,) policy), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, policy, policy))) +) +#endif +#ifndef OVERRIDE_64_sched_get_priority_min +SC_LTTNG_TRACEPOINT_EVENT(sched_get_priority_min, + TP_PROTO(sc_exit(long ret,) int policy), + TP_ARGS(sc_exit(ret,) policy), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, policy, policy))) +) +#endif +#ifndef OVERRIDE_64_setgid +SC_LTTNG_TRACEPOINT_EVENT(setgid, + TP_PROTO(sc_exit(long ret,) gid_t gid), + TP_ARGS(sc_exit(ret,) gid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, gid, gid))) +) +#endif +#ifndef OVERRIDE_64_setuid +SC_LTTNG_TRACEPOINT_EVENT(setuid, + TP_PROTO(sc_exit(long ret,) uid_t uid), + TP_ARGS(sc_exit(ret,) uid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, uid, uid))) +) +#endif +#ifndef OVERRIDE_64_setfsuid +SC_LTTNG_TRACEPOINT_EVENT(setfsuid, + TP_PROTO(sc_exit(long ret,) uid_t uid), + TP_ARGS(sc_exit(ret,) uid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, uid, uid))) +) +#endif +#ifndef OVERRIDE_64_setfsgid +SC_LTTNG_TRACEPOINT_EVENT(setfsgid, + TP_PROTO(sc_exit(long ret,) gid_t gid), + TP_ARGS(sc_exit(ret,) gid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, gid, gid))) +) +#endif +#ifndef OVERRIDE_64_getpgid +SC_LTTNG_TRACEPOINT_EVENT(getpgid, + TP_PROTO(sc_exit(long ret,) pid_t pid), + TP_ARGS(sc_exit(ret,) pid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid))) +) +#endif +#ifndef OVERRIDE_64_getsid +SC_LTTNG_TRACEPOINT_EVENT(getsid, + TP_PROTO(sc_exit(long ret,) pid_t pid), + TP_ARGS(sc_exit(ret,) pid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid))) +) +#endif +#ifndef OVERRIDE_64_umask +SC_LTTNG_TRACEPOINT_EVENT(umask, + TP_PROTO(sc_exit(long ret,) int mask), + TP_ARGS(sc_exit(ret,) mask), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, mask, mask))) +) +#endif +#ifndef OVERRIDE_64_brk +SC_LTTNG_TRACEPOINT_EVENT(brk, + TP_PROTO(sc_exit(long ret,) unsigned long brk), + TP_ARGS(sc_exit(ret,) brk), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, brk, brk))) +) +#endif +#ifndef OVERRIDE_64_mlockall +SC_LTTNG_TRACEPOINT_EVENT(mlockall, + TP_PROTO(sc_exit(long ret,) int flags), + TP_ARGS(sc_exit(ret,) flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_syncfs +SC_LTTNG_TRACEPOINT_EVENT(syncfs, + TP_PROTO(sc_exit(long ret,) int fd), + TP_ARGS(sc_exit(ret,) fd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd))) +) +#endif +#ifndef OVERRIDE_64_eventfd2 +SC_LTTNG_TRACEPOINT_EVENT(eventfd2, + TP_PROTO(sc_exit(long ret,) unsigned int count, int flags), + TP_ARGS(sc_exit(ret,) count, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, count, count)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_inotify_rm_watch +SC_LTTNG_TRACEPOINT_EVENT(inotify_rm_watch, + TP_PROTO(sc_exit(long ret,) int fd, __s32 wd), + TP_ARGS(sc_exit(ret,) fd, wd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(__s32, wd, wd))) +) +#endif +#ifndef OVERRIDE_64_ioprio_get +SC_LTTNG_TRACEPOINT_EVENT(ioprio_get, + TP_PROTO(sc_exit(long ret,) int which, int who), + TP_ARGS(sc_exit(ret,) which, who), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who))) +) +#endif +#ifndef OVERRIDE_64_flock +SC_LTTNG_TRACEPOINT_EVENT(flock, + TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd), + TP_ARGS(sc_exit(ret,) fd, cmd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned int, cmd, cmd))) +) +#endif +#ifndef OVERRIDE_64_ftruncate +SC_LTTNG_TRACEPOINT_EVENT(ftruncate, + TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned long length), + TP_ARGS(sc_exit(ret,) fd, length), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned long, length, length))) +) +#endif +#ifndef OVERRIDE_64_fchmod +SC_LTTNG_TRACEPOINT_EVENT(fchmod, + TP_PROTO(sc_exit(long ret,) unsigned int fd, umode_t mode), + TP_ARGS(sc_exit(ret,) fd, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(umode_t, mode, mode))) +) +#endif +#ifndef OVERRIDE_64_timerfd_create +SC_LTTNG_TRACEPOINT_EVENT(timerfd_create, + TP_PROTO(sc_exit(long ret,) int clockid, int flags), + TP_ARGS(sc_exit(ret,) clockid, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, clockid, clockid)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_kill +SC_LTTNG_TRACEPOINT_EVENT(kill, + TP_PROTO(sc_exit(long ret,) pid_t pid, int sig), + TP_ARGS(sc_exit(ret,) pid, sig), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig))) +) +#endif +#ifndef OVERRIDE_64_tkill +SC_LTTNG_TRACEPOINT_EVENT(tkill, + TP_PROTO(sc_exit(long ret,) pid_t pid, int sig), + TP_ARGS(sc_exit(ret,) pid, sig), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig))) +) +#endif +#ifndef OVERRIDE_64_getpriority +SC_LTTNG_TRACEPOINT_EVENT(getpriority, + TP_PROTO(sc_exit(long ret,) int which, int who), + TP_ARGS(sc_exit(ret,) which, who), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who))) +) +#endif +#ifndef OVERRIDE_64_setregid +SC_LTTNG_TRACEPOINT_EVENT(setregid, + TP_PROTO(sc_exit(long ret,) gid_t rgid, gid_t egid), + TP_ARGS(sc_exit(ret,) rgid, egid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, rgid, rgid)) sc_in(ctf_integer(gid_t, egid, egid))) +) +#endif +#ifndef OVERRIDE_64_setreuid +SC_LTTNG_TRACEPOINT_EVENT(setreuid, + TP_PROTO(sc_exit(long ret,) uid_t ruid, uid_t euid), + TP_ARGS(sc_exit(ret,) ruid, euid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, ruid, ruid)) sc_in(ctf_integer(uid_t, euid, euid))) +) +#endif +#ifndef OVERRIDE_64_setpgid +SC_LTTNG_TRACEPOINT_EVENT(setpgid, + TP_PROTO(sc_exit(long ret,) pid_t pid, pid_t pgid), + TP_ARGS(sc_exit(ret,) pid, pgid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(pid_t, pgid, pgid))) +) +#endif +#ifndef OVERRIDE_64_msgget +SC_LTTNG_TRACEPOINT_EVENT(msgget, + TP_PROTO(sc_exit(long ret,) key_t key, int msgflg), + TP_ARGS(sc_exit(ret,) key, msgflg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(key_t, key, key)) sc_in(ctf_integer(int, msgflg, msgflg))) +) +#endif +#ifndef OVERRIDE_64_listen +SC_LTTNG_TRACEPOINT_EVENT(listen, + TP_PROTO(sc_exit(long ret,) int fd, int backlog), + TP_ARGS(sc_exit(ret,) fd, backlog), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, backlog, backlog))) +) +#endif +#ifndef OVERRIDE_64_shutdown +SC_LTTNG_TRACEPOINT_EVENT(shutdown, + TP_PROTO(sc_exit(long ret,) int fd, int how), + TP_ARGS(sc_exit(ret,) fd, how), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, how, how))) +) +#endif +#ifndef OVERRIDE_64_munmap +SC_LTTNG_TRACEPOINT_EVENT(munmap, + TP_PROTO(sc_exit(long ret,) unsigned long addr, size_t len), + TP_ARGS(sc_exit(ret,) addr, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, addr, addr)) sc_in(ctf_integer(size_t, len, len))) +) +#endif +#ifndef OVERRIDE_64_mlock +SC_LTTNG_TRACEPOINT_EVENT(mlock, + TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len), + TP_ARGS(sc_exit(ret,) start, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len))) +) +#endif +#ifndef OVERRIDE_64_munlock +SC_LTTNG_TRACEPOINT_EVENT(munlock, + TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len), + TP_ARGS(sc_exit(ret,) start, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len))) +) +#endif +#ifndef OVERRIDE_64_fanotify_init +SC_LTTNG_TRACEPOINT_EVENT(fanotify_init, + TP_PROTO(sc_exit(long ret,) unsigned int flags, unsigned int event_f_flags), + TP_ARGS(sc_exit(ret,) flags, event_f_flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, flags, flags)) sc_in(ctf_integer(unsigned int, event_f_flags, event_f_flags))) +) +#endif +#ifndef OVERRIDE_64_setns +SC_LTTNG_TRACEPOINT_EVENT(setns, + TP_PROTO(sc_exit(long ret,) int fd, int nstype), + TP_ARGS(sc_exit(ret,) fd, nstype), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, nstype, nstype))) +) +#endif +#ifndef OVERRIDE_64_membarrier +SC_LTTNG_TRACEPOINT_EVENT(membarrier, + TP_PROTO(sc_exit(long ret,) int cmd, int flags), + TP_ARGS(sc_exit(ret,) cmd, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, cmd, cmd)) sc_inout(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_dup3 +SC_LTTNG_TRACEPOINT_EVENT(dup3, + TP_PROTO(sc_exit(long ret,) unsigned int oldfd, unsigned int newfd, int flags), + TP_ARGS(sc_exit(ret,) oldfd, newfd, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, oldfd, oldfd)) sc_in(ctf_integer(unsigned int, newfd, newfd)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_fcntl +SC_LTTNG_TRACEPOINT_EVENT(fcntl, + TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd, unsigned long arg), + TP_ARGS(sc_exit(ret,) fd, cmd, arg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_inout(ctf_integer(unsigned long, arg, arg))) +) +#endif +#ifndef OVERRIDE_64_ioctl +SC_LTTNG_TRACEPOINT_EVENT(ioctl, + TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd, unsigned long arg), + TP_ARGS(sc_exit(ret,) fd, cmd, arg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_inout(ctf_integer(unsigned long, arg, arg))) +) +#endif +#ifndef OVERRIDE_64_ioprio_set +SC_LTTNG_TRACEPOINT_EVENT(ioprio_set, + TP_PROTO(sc_exit(long ret,) int which, int who, int ioprio), + TP_ARGS(sc_exit(ret,) which, who, ioprio), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who)) sc_in(ctf_integer(int, ioprio, ioprio))) +) +#endif +#ifndef OVERRIDE_64_fchown +SC_LTTNG_TRACEPOINT_EVENT(fchown, + TP_PROTO(sc_exit(long ret,) unsigned int fd, uid_t user, gid_t group), + TP_ARGS(sc_exit(ret,) fd, user, group), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group))) +) +#endif +#ifndef OVERRIDE_64_lseek +SC_LTTNG_TRACEPOINT_EVENT(lseek, + TP_PROTO(sc_exit(long ret,) unsigned int fd, off_t offset, unsigned int whence), + TP_ARGS(sc_exit(ret,) fd, offset, whence), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(off_t, offset, offset)) sc_in(ctf_integer(unsigned int, whence, whence))) +) +#endif +#ifndef OVERRIDE_64_tgkill +SC_LTTNG_TRACEPOINT_EVENT(tgkill, + TP_PROTO(sc_exit(long ret,) pid_t tgid, pid_t pid, int sig), + TP_ARGS(sc_exit(ret,) tgid, pid, sig), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, tgid, tgid)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig))) +) +#endif +#ifndef OVERRIDE_64_setpriority +SC_LTTNG_TRACEPOINT_EVENT(setpriority, + TP_PROTO(sc_exit(long ret,) int which, int who, int niceval), + TP_ARGS(sc_exit(ret,) which, who, niceval), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who)) sc_in(ctf_integer(int, niceval, niceval))) +) +#endif +#ifndef OVERRIDE_64_setresuid +SC_LTTNG_TRACEPOINT_EVENT(setresuid, + TP_PROTO(sc_exit(long ret,) uid_t ruid, uid_t euid, uid_t suid), + TP_ARGS(sc_exit(ret,) ruid, euid, suid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, ruid, ruid)) sc_in(ctf_integer(uid_t, euid, euid)) sc_in(ctf_integer(uid_t, suid, suid))) +) +#endif +#ifndef OVERRIDE_64_setresgid +SC_LTTNG_TRACEPOINT_EVENT(setresgid, + TP_PROTO(sc_exit(long ret,) gid_t rgid, gid_t egid, gid_t sgid), + TP_ARGS(sc_exit(ret,) rgid, egid, sgid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, rgid, rgid)) sc_in(ctf_integer(gid_t, egid, egid)) sc_in(ctf_integer(gid_t, sgid, sgid))) +) +#endif +#ifndef OVERRIDE_64_semget +SC_LTTNG_TRACEPOINT_EVENT(semget, + TP_PROTO(sc_exit(long ret,) key_t key, int nsems, int semflg), + TP_ARGS(sc_exit(ret,) key, nsems, semflg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(key_t, key, key)) sc_in(ctf_integer(int, nsems, nsems)) sc_in(ctf_integer(int, semflg, semflg))) +) +#endif +#ifndef OVERRIDE_64_shmget +SC_LTTNG_TRACEPOINT_EVENT(shmget, + TP_PROTO(sc_exit(long ret,) key_t key, size_t size, int shmflg), + TP_ARGS(sc_exit(ret,) key, size, shmflg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(key_t, key, key)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(int, shmflg, shmflg))) +) +#endif +#ifndef OVERRIDE_64_socket +SC_LTTNG_TRACEPOINT_EVENT(socket, + TP_PROTO(sc_exit(long ret,) int family, int type, int protocol), + TP_ARGS(sc_exit(ret,) family, type, protocol), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, family, family)) sc_in(ctf_integer(int, type, type)) sc_in(ctf_integer(int, protocol, protocol))) +) +#endif +#ifndef OVERRIDE_64_readahead +SC_LTTNG_TRACEPOINT_EVENT(readahead, + TP_PROTO(sc_exit(long ret,) int fd, loff_t offset, size_t count), + TP_ARGS(sc_exit(ret,) fd, offset, count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(loff_t, offset, offset)) sc_in(ctf_integer(size_t, count, count))) +) +#endif +#ifndef OVERRIDE_64_mprotect +SC_LTTNG_TRACEPOINT_EVENT(mprotect, + TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len, unsigned long prot), + TP_ARGS(sc_exit(ret,) start, len, prot), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned long, prot, prot))) +) +#endif +#ifndef OVERRIDE_64_msync +SC_LTTNG_TRACEPOINT_EVENT(msync, + TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len, int flags), + TP_ARGS(sc_exit(ret,) start, len, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_madvise +SC_LTTNG_TRACEPOINT_EVENT(madvise, + TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len_in, int behavior), + TP_ARGS(sc_exit(ret,) start, len_in, behavior), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len_in, len_in)) sc_in(ctf_integer(int, behavior, behavior))) +) +#endif +#ifndef OVERRIDE_64_mlock2 +SC_LTTNG_TRACEPOINT_EVENT(mlock2, + TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len, int flags), + TP_ARGS(sc_exit(ret,) start, len, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned long, start, start)) sc_inout(ctf_integer(size_t, len, len)) sc_inout(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_fallocate +SC_LTTNG_TRACEPOINT_EVENT(fallocate, + TP_PROTO(sc_exit(long ret,) int fd, int mode, loff_t offset, loff_t len), + TP_ARGS(sc_exit(ret,) fd, mode, offset, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, mode, mode)) sc_in(ctf_integer(loff_t, offset, offset)) sc_in(ctf_integer(loff_t, len, len))) +) +#endif +#ifndef OVERRIDE_64_tee +SC_LTTNG_TRACEPOINT_EVENT(tee, + TP_PROTO(sc_exit(long ret,) int fdin, int fdout, size_t len, unsigned int flags), + TP_ARGS(sc_exit(ret,) fdin, fdout, len, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fdin, fdin)) sc_in(ctf_integer(int, fdout, fdout)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_sync_file_range +SC_LTTNG_TRACEPOINT_EVENT(sync_file_range, + TP_PROTO(sc_exit(long ret,) int fd, loff_t offset, loff_t nbytes, unsigned int flags), + TP_ARGS(sc_exit(ret,) fd, offset, nbytes, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(loff_t, offset, offset)) sc_in(ctf_integer(loff_t, nbytes, nbytes)) sc_in(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_ptrace +SC_LTTNG_TRACEPOINT_EVENT(ptrace, + TP_PROTO(sc_exit(long ret,) long request, long pid, unsigned long addr, unsigned long data), + TP_ARGS(sc_exit(ret,) request, pid, addr, data), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(long, request, request)) sc_in(ctf_integer(long, pid, pid)) sc_inout(ctf_integer(unsigned long, addr, addr)) sc_inout(ctf_integer(unsigned long, data, data))) +) +#endif +#ifndef OVERRIDE_64_semctl +SC_LTTNG_TRACEPOINT_EVENT(semctl, + TP_PROTO(sc_exit(long ret,) int semid, int semnum, int cmd, unsigned long arg), + TP_ARGS(sc_exit(ret,) semid, semnum, cmd, arg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, semid, semid)) sc_in(ctf_integer(int, semnum, semnum)) sc_in(ctf_integer(int, cmd, cmd)) sc_inout(ctf_integer(unsigned long, arg, arg))) +) +#endif +#ifndef OVERRIDE_64_fadvise64_64 +SC_LTTNG_TRACEPOINT_EVENT(fadvise64_64, + TP_PROTO(sc_exit(long ret,) int fd, loff_t offset, loff_t len, int advice), + TP_ARGS(sc_exit(ret,) fd, offset, len, advice), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, fd, fd)) sc_inout(ctf_integer(loff_t, offset, offset)) sc_inout(ctf_integer(loff_t, len, len)) sc_inout(ctf_integer(int, advice, advice))) +) +#endif +#ifndef OVERRIDE_64_prctl +SC_LTTNG_TRACEPOINT_EVENT(prctl, + TP_PROTO(sc_exit(long ret,) int option, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5), + TP_ARGS(sc_exit(ret,) option, arg2, arg3, arg4, arg5), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, option, option)) sc_inout(ctf_integer(unsigned long, arg2, arg2)) sc_in(ctf_integer(unsigned long, arg3, arg3)) sc_in(ctf_integer(unsigned long, arg4, arg4)) sc_in(ctf_integer(unsigned long, arg5, arg5))) +) +#endif +#ifndef OVERRIDE_64_mremap +SC_LTTNG_TRACEPOINT_EVENT(mremap, + TP_PROTO(sc_exit(long ret,) unsigned long addr, unsigned long old_len, unsigned long new_len, unsigned long flags, unsigned long new_addr), + TP_ARGS(sc_exit(ret,) addr, old_len, new_len, flags, new_addr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, addr, addr)) sc_in(ctf_integer(unsigned long, old_len, old_len)) sc_in(ctf_integer(unsigned long, new_len, new_len)) sc_in(ctf_integer(unsigned long, flags, flags)) sc_in(ctf_integer(unsigned long, new_addr, new_addr))) +) +#endif +#ifndef OVERRIDE_64_keyctl +SC_LTTNG_TRACEPOINT_EVENT(keyctl, + TP_PROTO(sc_exit(long ret,) int option, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5), + TP_ARGS(sc_exit(ret,) option, arg2, arg3, arg4, arg5), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, option, option)) sc_inout(ctf_integer(unsigned long, arg2, arg2)) sc_inout(ctf_integer(unsigned long, arg3, arg3)) sc_inout(ctf_integer(unsigned long, arg4, arg4)) sc_inout(ctf_integer(unsigned long, arg5, arg5))) +) +#endif +#ifndef OVERRIDE_64_remap_file_pages +SC_LTTNG_TRACEPOINT_EVENT(remap_file_pages, + TP_PROTO(sc_exit(long ret,) unsigned long start, unsigned long size, unsigned long prot, unsigned long pgoff, unsigned long flags), + TP_ARGS(sc_exit(ret,) start, size, prot, pgoff, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(unsigned long, size, size)) sc_in(ctf_integer(unsigned long, prot, prot)) sc_in(ctf_integer(unsigned long, pgoff, pgoff)) sc_in(ctf_integer(unsigned long, flags, flags))) +) +#endif + +#endif /* _TRACE_SYSCALLS_INTEGERS_H */ + +/* This part must be outside protection */ +#include + +#else /* CREATE_SYSCALL_TABLE */ + +#include "arm-64-syscalls_integers_override.h" +#include "syscalls_integers_override.h" + +#ifdef SC_ENTER +#ifndef OVERRIDE_TABLE_64_vhangup +TRACE_SYSCALL_TABLE(syscalls_noargs, vhangup, 58, 0) +#endif +#ifndef OVERRIDE_TABLE_64_sync +TRACE_SYSCALL_TABLE(syscalls_noargs, sync, 81, 0) +#endif +#ifndef OVERRIDE_TABLE_64_sched_yield +TRACE_SYSCALL_TABLE(syscalls_noargs, sched_yield, 124, 0) +#endif +#ifndef OVERRIDE_TABLE_64_restart_syscall +TRACE_SYSCALL_TABLE(syscalls_noargs, restart_syscall, 128, 0) +#endif +#ifndef OVERRIDE_TABLE_64_setsid +TRACE_SYSCALL_TABLE(syscalls_noargs, setsid, 157, 0) +#endif +#ifndef OVERRIDE_TABLE_64_getpid +TRACE_SYSCALL_TABLE(syscalls_noargs, getpid, 172, 0) +#endif +#ifndef OVERRIDE_TABLE_64_getppid +TRACE_SYSCALL_TABLE(syscalls_noargs, getppid, 173, 0) +#endif +#ifndef OVERRIDE_TABLE_64_getuid +TRACE_SYSCALL_TABLE(syscalls_noargs, getuid, 174, 0) +#endif +#ifndef OVERRIDE_TABLE_64_geteuid +TRACE_SYSCALL_TABLE(syscalls_noargs, geteuid, 175, 0) +#endif +#ifndef OVERRIDE_TABLE_64_getgid +TRACE_SYSCALL_TABLE(syscalls_noargs, getgid, 176, 0) +#endif +#ifndef OVERRIDE_TABLE_64_getegid +TRACE_SYSCALL_TABLE(syscalls_noargs, getegid, 177, 0) +#endif +#ifndef OVERRIDE_TABLE_64_gettid +TRACE_SYSCALL_TABLE(syscalls_noargs, gettid, 178, 0) +#endif +#ifndef OVERRIDE_TABLE_64_munlockall +TRACE_SYSCALL_TABLE(syscalls_noargs, munlockall, 231, 0) +#endif +#else /* #ifdef SC_ENTER */ +#ifndef OVERRIDE_TABLE_64_vhangup +TRACE_SYSCALL_TABLE(vhangup, vhangup, 58, 0) +#endif +#ifndef OVERRIDE_TABLE_64_sync +TRACE_SYSCALL_TABLE(sync, sync, 81, 0) +#endif +#ifndef OVERRIDE_TABLE_64_sched_yield +TRACE_SYSCALL_TABLE(sched_yield, sched_yield, 124, 0) +#endif +#ifndef OVERRIDE_TABLE_64_restart_syscall +TRACE_SYSCALL_TABLE(restart_syscall, restart_syscall, 128, 0) +#endif +#ifndef OVERRIDE_TABLE_64_setsid +TRACE_SYSCALL_TABLE(setsid, setsid, 157, 0) +#endif +#ifndef OVERRIDE_TABLE_64_getpid +TRACE_SYSCALL_TABLE(getpid, getpid, 172, 0) +#endif +#ifndef OVERRIDE_TABLE_64_getppid +TRACE_SYSCALL_TABLE(getppid, getppid, 173, 0) +#endif +#ifndef OVERRIDE_TABLE_64_getuid +TRACE_SYSCALL_TABLE(getuid, getuid, 174, 0) +#endif +#ifndef OVERRIDE_TABLE_64_geteuid +TRACE_SYSCALL_TABLE(geteuid, geteuid, 175, 0) +#endif +#ifndef OVERRIDE_TABLE_64_getgid +TRACE_SYSCALL_TABLE(getgid, getgid, 176, 0) +#endif +#ifndef OVERRIDE_TABLE_64_getegid +TRACE_SYSCALL_TABLE(getegid, getegid, 177, 0) +#endif +#ifndef OVERRIDE_TABLE_64_gettid +TRACE_SYSCALL_TABLE(gettid, gettid, 178, 0) +#endif +#ifndef OVERRIDE_TABLE_64_munlockall +TRACE_SYSCALL_TABLE(munlockall, munlockall, 231, 0) +#endif +#endif /* else #ifdef SC_ENTER */ +#ifndef OVERRIDE_TABLE_64_io_destroy +TRACE_SYSCALL_TABLE(io_destroy, io_destroy, 1, 1) +#endif +#ifndef OVERRIDE_TABLE_64_eventfd2 +TRACE_SYSCALL_TABLE(eventfd2, eventfd2, 19, 2) +#endif +#ifndef OVERRIDE_TABLE_64_epoll_create1 +TRACE_SYSCALL_TABLE(epoll_create1, epoll_create1, 20, 1) +#endif +#ifndef OVERRIDE_TABLE_64_dup +TRACE_SYSCALL_TABLE(dup, dup, 23, 1) +#endif +#ifndef OVERRIDE_TABLE_64_dup3 +TRACE_SYSCALL_TABLE(dup3, dup3, 24, 3) +#endif +#ifndef OVERRIDE_TABLE_64_fcntl +TRACE_SYSCALL_TABLE(fcntl, fcntl, 25, 3) +#endif +#ifndef OVERRIDE_TABLE_64_inotify_init1 +TRACE_SYSCALL_TABLE(inotify_init1, inotify_init1, 26, 1) +#endif +#ifndef OVERRIDE_TABLE_64_inotify_rm_watch +TRACE_SYSCALL_TABLE(inotify_rm_watch, inotify_rm_watch, 28, 2) +#endif +#ifndef OVERRIDE_TABLE_64_ioctl +TRACE_SYSCALL_TABLE(ioctl, ioctl, 29, 3) +#endif +#ifndef OVERRIDE_TABLE_64_ioprio_set +TRACE_SYSCALL_TABLE(ioprio_set, ioprio_set, 30, 3) +#endif +#ifndef OVERRIDE_TABLE_64_ioprio_get +TRACE_SYSCALL_TABLE(ioprio_get, ioprio_get, 31, 2) +#endif +#ifndef OVERRIDE_TABLE_64_flock +TRACE_SYSCALL_TABLE(flock, flock, 32, 2) +#endif +#ifndef OVERRIDE_TABLE_64_ftruncate +TRACE_SYSCALL_TABLE(ftruncate, ftruncate, 46, 2) +#endif +#ifndef OVERRIDE_TABLE_64_fallocate +TRACE_SYSCALL_TABLE(fallocate, fallocate, 47, 4) +#endif +#ifndef OVERRIDE_TABLE_64_fchdir +TRACE_SYSCALL_TABLE(fchdir, fchdir, 50, 1) +#endif +#ifndef OVERRIDE_TABLE_64_fchmod +TRACE_SYSCALL_TABLE(fchmod, fchmod, 52, 2) +#endif +#ifndef OVERRIDE_TABLE_64_fchown +TRACE_SYSCALL_TABLE(fchown, fchown, 55, 3) +#endif +#ifndef OVERRIDE_TABLE_64_close +TRACE_SYSCALL_TABLE(close, close, 57, 1) +#endif +#ifndef OVERRIDE_TABLE_64_lseek +TRACE_SYSCALL_TABLE(lseek, lseek, 62, 3) +#endif +#ifndef OVERRIDE_TABLE_64_tee +TRACE_SYSCALL_TABLE(tee, tee, 77, 4) +#endif +#ifndef OVERRIDE_TABLE_64_fsync +TRACE_SYSCALL_TABLE(fsync, fsync, 82, 1) +#endif +#ifndef OVERRIDE_TABLE_64_fdatasync +TRACE_SYSCALL_TABLE(fdatasync, fdatasync, 83, 1) +#endif +#ifndef OVERRIDE_TABLE_64_sync_file_range +TRACE_SYSCALL_TABLE(sync_file_range, sync_file_range, 84, 4) +#endif +#ifndef OVERRIDE_TABLE_64_timerfd_create +TRACE_SYSCALL_TABLE(timerfd_create, timerfd_create, 85, 2) +#endif +#ifndef OVERRIDE_TABLE_64_personality +TRACE_SYSCALL_TABLE(personality, personality, 92, 1) +#endif +#ifndef OVERRIDE_TABLE_64_exit +TRACE_SYSCALL_TABLE(exit, exit, 93, 1) +#endif +#ifndef OVERRIDE_TABLE_64_exit_group +TRACE_SYSCALL_TABLE(exit_group, exit_group, 94, 1) +#endif +#ifndef OVERRIDE_TABLE_64_unshare +TRACE_SYSCALL_TABLE(unshare, unshare, 97, 1) +#endif +#ifndef OVERRIDE_TABLE_64_timer_getoverrun +TRACE_SYSCALL_TABLE(timer_getoverrun, timer_getoverrun, 109, 1) +#endif +#ifndef OVERRIDE_TABLE_64_timer_delete +TRACE_SYSCALL_TABLE(timer_delete, timer_delete, 111, 1) +#endif +#ifndef OVERRIDE_TABLE_64_ptrace +TRACE_SYSCALL_TABLE(ptrace, ptrace, 117, 4) +#endif +#ifndef OVERRIDE_TABLE_64_sched_getscheduler +TRACE_SYSCALL_TABLE(sched_getscheduler, sched_getscheduler, 120, 1) +#endif +#ifndef OVERRIDE_TABLE_64_sched_get_priority_max +TRACE_SYSCALL_TABLE(sched_get_priority_max, sched_get_priority_max, 125, 1) +#endif +#ifndef OVERRIDE_TABLE_64_sched_get_priority_min +TRACE_SYSCALL_TABLE(sched_get_priority_min, sched_get_priority_min, 126, 1) +#endif +#ifndef OVERRIDE_TABLE_64_kill +TRACE_SYSCALL_TABLE(kill, kill, 129, 2) +#endif +#ifndef OVERRIDE_TABLE_64_tkill +TRACE_SYSCALL_TABLE(tkill, tkill, 130, 2) +#endif +#ifndef OVERRIDE_TABLE_64_tgkill +TRACE_SYSCALL_TABLE(tgkill, tgkill, 131, 3) +#endif +#ifndef OVERRIDE_TABLE_64_setpriority +TRACE_SYSCALL_TABLE(setpriority, setpriority, 140, 3) +#endif +#ifndef OVERRIDE_TABLE_64_getpriority +TRACE_SYSCALL_TABLE(getpriority, getpriority, 141, 2) +#endif +#ifndef OVERRIDE_TABLE_64_setregid +TRACE_SYSCALL_TABLE(setregid, setregid, 143, 2) +#endif +#ifndef OVERRIDE_TABLE_64_setgid +TRACE_SYSCALL_TABLE(setgid, setgid, 144, 1) +#endif +#ifndef OVERRIDE_TABLE_64_setreuid +TRACE_SYSCALL_TABLE(setreuid, setreuid, 145, 2) +#endif +#ifndef OVERRIDE_TABLE_64_setuid +TRACE_SYSCALL_TABLE(setuid, setuid, 146, 1) +#endif +#ifndef OVERRIDE_TABLE_64_setresuid +TRACE_SYSCALL_TABLE(setresuid, setresuid, 147, 3) +#endif +#ifndef OVERRIDE_TABLE_64_setresgid +TRACE_SYSCALL_TABLE(setresgid, setresgid, 149, 3) +#endif +#ifndef OVERRIDE_TABLE_64_setfsuid +TRACE_SYSCALL_TABLE(setfsuid, setfsuid, 151, 1) +#endif +#ifndef OVERRIDE_TABLE_64_setfsgid +TRACE_SYSCALL_TABLE(setfsgid, setfsgid, 152, 1) +#endif +#ifndef OVERRIDE_TABLE_64_setpgid +TRACE_SYSCALL_TABLE(setpgid, setpgid, 154, 2) +#endif +#ifndef OVERRIDE_TABLE_64_getpgid +TRACE_SYSCALL_TABLE(getpgid, getpgid, 155, 1) +#endif +#ifndef OVERRIDE_TABLE_64_getsid +TRACE_SYSCALL_TABLE(getsid, getsid, 156, 1) +#endif +#ifndef OVERRIDE_TABLE_64_umask +TRACE_SYSCALL_TABLE(umask, umask, 166, 1) +#endif +#ifndef OVERRIDE_TABLE_64_prctl +TRACE_SYSCALL_TABLE(prctl, prctl, 167, 5) +#endif +#ifndef OVERRIDE_TABLE_64_msgget +TRACE_SYSCALL_TABLE(msgget, msgget, 186, 2) +#endif +#ifndef OVERRIDE_TABLE_64_semget +TRACE_SYSCALL_TABLE(semget, semget, 190, 3) +#endif +#ifndef OVERRIDE_TABLE_64_semctl +TRACE_SYSCALL_TABLE(semctl, semctl, 191, 4) +#endif +#ifndef OVERRIDE_TABLE_64_shmget +TRACE_SYSCALL_TABLE(shmget, shmget, 194, 3) +#endif +#ifndef OVERRIDE_TABLE_64_socket +TRACE_SYSCALL_TABLE(socket, socket, 198, 3) +#endif +#ifndef OVERRIDE_TABLE_64_listen +TRACE_SYSCALL_TABLE(listen, listen, 201, 2) +#endif +#ifndef OVERRIDE_TABLE_64_shutdown +TRACE_SYSCALL_TABLE(shutdown, shutdown, 210, 2) +#endif +#ifndef OVERRIDE_TABLE_64_readahead +TRACE_SYSCALL_TABLE(readahead, readahead, 213, 3) +#endif +#ifndef OVERRIDE_TABLE_64_brk +TRACE_SYSCALL_TABLE(brk, brk, 214, 1) +#endif +#ifndef OVERRIDE_TABLE_64_munmap +TRACE_SYSCALL_TABLE(munmap, munmap, 215, 2) +#endif +#ifndef OVERRIDE_TABLE_64_mremap +TRACE_SYSCALL_TABLE(mremap, mremap, 216, 5) +#endif +#ifndef OVERRIDE_TABLE_64_keyctl +TRACE_SYSCALL_TABLE(keyctl, keyctl, 219, 5) +#endif +#ifndef OVERRIDE_TABLE_64_fadvise64_64 +TRACE_SYSCALL_TABLE(fadvise64_64, fadvise64_64, 223, 4) +#endif +#ifndef OVERRIDE_TABLE_64_mprotect +TRACE_SYSCALL_TABLE(mprotect, mprotect, 226, 3) +#endif +#ifndef OVERRIDE_TABLE_64_msync +TRACE_SYSCALL_TABLE(msync, msync, 227, 3) +#endif +#ifndef OVERRIDE_TABLE_64_mlock +TRACE_SYSCALL_TABLE(mlock, mlock, 228, 2) +#endif +#ifndef OVERRIDE_TABLE_64_munlock +TRACE_SYSCALL_TABLE(munlock, munlock, 229, 2) +#endif +#ifndef OVERRIDE_TABLE_64_mlockall +TRACE_SYSCALL_TABLE(mlockall, mlockall, 230, 1) +#endif +#ifndef OVERRIDE_TABLE_64_madvise +TRACE_SYSCALL_TABLE(madvise, madvise, 233, 3) +#endif +#ifndef OVERRIDE_TABLE_64_remap_file_pages +TRACE_SYSCALL_TABLE(remap_file_pages, remap_file_pages, 234, 5) +#endif +#ifndef OVERRIDE_TABLE_64_fanotify_init +TRACE_SYSCALL_TABLE(fanotify_init, fanotify_init, 262, 2) +#endif +#ifndef OVERRIDE_TABLE_64_syncfs +TRACE_SYSCALL_TABLE(syncfs, syncfs, 267, 1) +#endif +#ifndef OVERRIDE_TABLE_64_setns +TRACE_SYSCALL_TABLE(setns, setns, 268, 2) +#endif +#ifndef OVERRIDE_TABLE_64_membarrier +TRACE_SYSCALL_TABLE(membarrier, membarrier, 283, 2) +#endif +#ifndef OVERRIDE_TABLE_64_mlock2 +TRACE_SYSCALL_TABLE(mlock2, mlock2, 284, 3) +#endif + +#endif /* CREATE_SYSCALL_TABLE */ diff --git a/include/instrumentation/syscalls/headers/arm-64-syscalls_integers_override.h b/include/instrumentation/syscalls/headers/arm-64-syscalls_integers_override.h new file mode 100644 index 00000000..ac0d5443 --- /dev/null +++ b/include/instrumentation/syscalls/headers/arm-64-syscalls_integers_override.h @@ -0,0 +1,10 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ + +/* + * this is a place-holder for arm64 integer syscall definition override. + */ +#ifndef CREATE_SYSCALL_TABLE +#else /* CREATE_SYSCALL_TABLE */ +#define OVERRIDE_TABLE_64_mmap +TRACE_SYSCALL_TABLE(mmap, mmap, 222, 6) +#endif /* CREATE_SYSCALL_TABLE */ diff --git a/include/instrumentation/syscalls/headers/arm-64-syscalls_pointers.h b/include/instrumentation/syscalls/headers/arm-64-syscalls_pointers.h new file mode 100644 index 00000000..3b918aa8 --- /dev/null +++ b/include/instrumentation/syscalls/headers/arm-64-syscalls_pointers.h @@ -0,0 +1,1669 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ + +/* THIS FILE IS AUTO-GENERATED. DO NOT EDIT */ + +/* Generated from arm-64-syscalls 4.4.0 */ + +#ifndef CREATE_SYSCALL_TABLE + +#if !defined(_TRACE_SYSCALLS_POINTERS_H) || defined(TRACE_HEADER_MULTI_READ) +#define _TRACE_SYSCALLS_POINTERS_H + +#include +#include +#include "arm-64-syscalls_pointers_override.h" +#include "syscalls_pointers_override.h" + +#ifndef OVERRIDE_64_chdir +SC_LTTNG_TRACEPOINT_EVENT(chdir, + TP_PROTO(sc_exit(long ret,) const char * filename), + TP_ARGS(sc_exit(ret,) filename), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename))) +) +#endif +#ifndef OVERRIDE_64_chroot +SC_LTTNG_TRACEPOINT_EVENT(chroot, + TP_PROTO(sc_exit(long ret,) const char * filename), + TP_ARGS(sc_exit(ret,) filename), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename))) +) +#endif +#ifndef OVERRIDE_64_acct +SC_LTTNG_TRACEPOINT_EVENT(acct, + TP_PROTO(sc_exit(long ret,) const char * name), + TP_ARGS(sc_exit(ret,) name), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name))) +) +#endif +#ifndef OVERRIDE_64_set_tid_address +SC_LTTNG_TRACEPOINT_EVENT(set_tid_address, + TP_PROTO(sc_exit(long ret,) int * tidptr), + TP_ARGS(sc_exit(ret,) tidptr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int *, tidptr, tidptr))) +) +#endif +#ifndef OVERRIDE_64_times +SC_LTTNG_TRACEPOINT_EVENT(times, + TP_PROTO(sc_exit(long ret,) struct tms * tbuf), + TP_ARGS(sc_exit(ret,) tbuf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct tms *, tbuf, tbuf))) +) +#endif +#ifndef OVERRIDE_64_newuname +SC_LTTNG_TRACEPOINT_EVENT(newuname, + TP_PROTO(sc_exit(long ret,) struct new_utsname * name), + TP_ARGS(sc_exit(ret,) name), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct new_utsname *, name, name))) +) +#endif +#ifndef OVERRIDE_64_adjtimex +SC_LTTNG_TRACEPOINT_EVENT(adjtimex, + TP_PROTO(sc_exit(long ret,) struct timex * txc_p), + TP_ARGS(sc_exit(ret,) txc_p), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct timex *, txc_p, txc_p))) +) +#endif +#ifndef OVERRIDE_64_sysinfo +SC_LTTNG_TRACEPOINT_EVENT(sysinfo, + TP_PROTO(sc_exit(long ret,) struct sysinfo * info), + TP_ARGS(sc_exit(ret,) info), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct sysinfo *, info, info))) +) +#endif +#ifndef OVERRIDE_64_mq_unlink +SC_LTTNG_TRACEPOINT_EVENT(mq_unlink, + TP_PROTO(sc_exit(long ret,) const char * u_name), + TP_ARGS(sc_exit(ret,) u_name), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(u_name, u_name))) +) +#endif +#ifndef OVERRIDE_64_shmdt +SC_LTTNG_TRACEPOINT_EVENT(shmdt, + TP_PROTO(sc_exit(long ret,) char * shmaddr), + TP_ARGS(sc_exit(ret,) shmaddr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(char *, shmaddr, shmaddr))) +) +#endif +#ifndef OVERRIDE_64_swapoff +SC_LTTNG_TRACEPOINT_EVENT(swapoff, + TP_PROTO(sc_exit(long ret,) const char * specialfile), + TP_ARGS(sc_exit(ret,) specialfile), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(specialfile, specialfile))) +) +#endif +#ifndef OVERRIDE_64_io_setup +SC_LTTNG_TRACEPOINT_EVENT(io_setup, + TP_PROTO(sc_exit(long ret,) unsigned nr_events, aio_context_t * ctxp), + TP_ARGS(sc_exit(ret,) nr_events, ctxp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned, nr_events, nr_events)) sc_in(ctf_integer(aio_context_t *, ctxp, ctxp))) +) +#endif +#ifndef OVERRIDE_64_removexattr +SC_LTTNG_TRACEPOINT_EVENT(removexattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name), + TP_ARGS(sc_exit(ret,) pathname, name), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name))) +) +#endif +#ifndef OVERRIDE_64_lremovexattr +SC_LTTNG_TRACEPOINT_EVENT(lremovexattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name), + TP_ARGS(sc_exit(ret,) pathname, name), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name))) +) +#endif +#ifndef OVERRIDE_64_fremovexattr +SC_LTTNG_TRACEPOINT_EVENT(fremovexattr, + TP_PROTO(sc_exit(long ret,) int fd, const char * name), + TP_ARGS(sc_exit(ret,) fd, name), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(name, name))) +) +#endif +#ifndef OVERRIDE_64_getcwd +SC_LTTNG_TRACEPOINT_EVENT(getcwd, + TP_PROTO(sc_exit(long ret,) char * buf, unsigned long size), + TP_ARGS(sc_exit(ret,) buf, size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(unsigned long, size, size))) +) +#endif +#ifndef OVERRIDE_64_umount +SC_LTTNG_TRACEPOINT_EVENT(umount, + TP_PROTO(sc_exit(long ret,) char * name, int flags), + TP_ARGS(sc_exit(ret,) name, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_pivot_root +SC_LTTNG_TRACEPOINT_EVENT(pivot_root, + TP_PROTO(sc_exit(long ret,) const char * new_root, const char * put_old), + TP_ARGS(sc_exit(ret,) new_root, put_old), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(new_root, new_root)) sc_in(ctf_user_string(put_old, put_old))) +) +#endif +#ifndef OVERRIDE_64_statfs +SC_LTTNG_TRACEPOINT_EVENT(statfs, + TP_PROTO(sc_exit(long ret,) const char * pathname, struct statfs * buf), + TP_ARGS(sc_exit(ret,) pathname, buf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(struct statfs *, buf, buf))) +) +#endif +#ifndef OVERRIDE_64_fstatfs +SC_LTTNG_TRACEPOINT_EVENT(fstatfs, + TP_PROTO(sc_exit(long ret,) unsigned int fd, struct statfs * buf), + TP_ARGS(sc_exit(ret,) fd, buf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct statfs *, buf, buf))) +) +#endif +#ifndef OVERRIDE_64_truncate +SC_LTTNG_TRACEPOINT_EVENT(truncate, + TP_PROTO(sc_exit(long ret,) const char * path, long length), + TP_ARGS(sc_exit(ret,) path, length), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(path, path)) sc_in(ctf_integer(long, length, length))) +) +#endif +#ifndef OVERRIDE_64_pipe2 +SC_LTTNG_TRACEPOINT_EVENT(pipe2, + TP_PROTO(sc_exit(long ret,) int * fildes, int flags), + TP_ARGS(sc_exit(ret,) fildes, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(int *, fildes, fildes)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_newfstat +SC_LTTNG_TRACEPOINT_EVENT(newfstat, + TP_PROTO(sc_exit(long ret,) unsigned int fd, struct stat * statbuf), + TP_ARGS(sc_exit(ret,) fd, statbuf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct stat *, statbuf, statbuf))) +) +#endif +#ifndef OVERRIDE_64_timerfd_gettime +SC_LTTNG_TRACEPOINT_EVENT(timerfd_gettime, + TP_PROTO(sc_exit(long ret,) int ufd, struct itimerspec * otmr), + TP_ARGS(sc_exit(ret,) ufd, otmr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_out(ctf_integer(struct itimerspec *, otmr, otmr))) +) +#endif +#ifndef OVERRIDE_64_set_robust_list +SC_LTTNG_TRACEPOINT_EVENT(set_robust_list, + TP_PROTO(sc_exit(long ret,) struct robust_list_head * head, size_t len), + TP_ARGS(sc_exit(ret,) head, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct robust_list_head *, head, head)) sc_in(ctf_integer(size_t, len, len))) +) +#endif +#ifndef OVERRIDE_64_nanosleep +SC_LTTNG_TRACEPOINT_EVENT(nanosleep, + TP_PROTO(sc_exit(long ret,) struct timespec * rqtp, struct timespec * rmtp), + TP_ARGS(sc_exit(ret,) rqtp, rmtp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct timespec *, rqtp, rqtp)) sc_out(ctf_integer(struct timespec *, rmtp, rmtp))) +) +#endif +#ifndef OVERRIDE_64_getitimer +SC_LTTNG_TRACEPOINT_EVENT(getitimer, + TP_PROTO(sc_exit(long ret,) int which, struct itimerval * value), + TP_ARGS(sc_exit(ret,) which, value), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_out(ctf_integer(struct itimerval *, value, value))) +) +#endif +#ifndef OVERRIDE_64_delete_module +SC_LTTNG_TRACEPOINT_EVENT(delete_module, + TP_PROTO(sc_exit(long ret,) const char * name_user, unsigned int flags), + TP_ARGS(sc_exit(ret,) name_user, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name_user, name_user)) sc_in(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_timer_gettime +SC_LTTNG_TRACEPOINT_EVENT(timer_gettime, + TP_PROTO(sc_exit(long ret,) timer_t timer_id, struct itimerspec * setting), + TP_ARGS(sc_exit(ret,) timer_id, setting), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id)) sc_out(ctf_integer(struct itimerspec *, setting, setting))) +) +#endif +#ifndef OVERRIDE_64_clock_settime +SC_LTTNG_TRACEPOINT_EVENT(clock_settime, + TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, const struct timespec * tp), + TP_ARGS(sc_exit(ret,) which_clock, tp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_in(ctf_integer(const struct timespec *, tp, tp))) +) +#endif +#ifndef OVERRIDE_64_clock_gettime +SC_LTTNG_TRACEPOINT_EVENT(clock_gettime, + TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct timespec * tp), + TP_ARGS(sc_exit(ret,) which_clock, tp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_out(ctf_integer(struct timespec *, tp, tp))) +) +#endif +#ifndef OVERRIDE_64_clock_getres +SC_LTTNG_TRACEPOINT_EVENT(clock_getres, + TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct timespec * tp), + TP_ARGS(sc_exit(ret,) which_clock, tp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_out(ctf_integer(struct timespec *, tp, tp))) +) +#endif +#ifndef OVERRIDE_64_sched_setparam +SC_LTTNG_TRACEPOINT_EVENT(sched_setparam, + TP_PROTO(sc_exit(long ret,) pid_t pid, struct sched_param * param), + TP_ARGS(sc_exit(ret,) pid, param), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(struct sched_param *, param, param))) +) +#endif +#ifndef OVERRIDE_64_sched_getparam +SC_LTTNG_TRACEPOINT_EVENT(sched_getparam, + TP_PROTO(sc_exit(long ret,) pid_t pid, struct sched_param * param), + TP_ARGS(sc_exit(ret,) pid, param), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_out(ctf_integer(struct sched_param *, param, param))) +) +#endif +#ifndef OVERRIDE_64_sched_rr_get_interval +SC_LTTNG_TRACEPOINT_EVENT(sched_rr_get_interval, + TP_PROTO(sc_exit(long ret,) pid_t pid, struct timespec * interval), + TP_ARGS(sc_exit(ret,) pid, interval), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_out(ctf_integer(struct timespec *, interval, interval))) +) +#endif +#ifndef OVERRIDE_64_sigaltstack +SC_LTTNG_TRACEPOINT_EVENT(sigaltstack, + TP_PROTO(sc_exit(long ret,) const stack_t * uss, stack_t * uoss), + TP_ARGS(sc_exit(ret,) uss, uoss), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const stack_t *, uss, uss)) sc_inout(ctf_integer(stack_t *, uoss, uoss))) +) +#endif +#ifndef OVERRIDE_64_rt_sigsuspend +SC_LTTNG_TRACEPOINT_EVENT(rt_sigsuspend, + TP_PROTO(sc_exit(long ret,) sigset_t * unewset, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) unewset, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(sigset_t *, unewset, unewset)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) +) +#endif +#ifndef OVERRIDE_64_rt_sigpending +SC_LTTNG_TRACEPOINT_EVENT(rt_sigpending, + TP_PROTO(sc_exit(long ret,) sigset_t * uset, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) uset, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(sigset_t *, uset, uset)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) +) +#endif +#ifndef OVERRIDE_64_getgroups +SC_LTTNG_TRACEPOINT_EVENT(getgroups, + TP_PROTO(sc_exit(long ret,) int gidsetsize, gid_t * grouplist), + TP_ARGS(sc_exit(ret,) gidsetsize, grouplist), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, gidsetsize, gidsetsize)) sc_out(ctf_integer(gid_t *, grouplist, grouplist))) +) +#endif +#ifndef OVERRIDE_64_setgroups +SC_LTTNG_TRACEPOINT_EVENT(setgroups, + TP_PROTO(sc_exit(long ret,) int gidsetsize, gid_t * grouplist), + TP_ARGS(sc_exit(ret,) gidsetsize, grouplist), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, gidsetsize, gidsetsize)) sc_in(ctf_integer(gid_t *, grouplist, grouplist))) +) +#endif +#ifndef OVERRIDE_64_sethostname +SC_LTTNG_TRACEPOINT_EVENT(sethostname, + TP_PROTO(sc_exit(long ret,) char * name, int len), + TP_ARGS(sc_exit(ret,) name, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(int, len, len))) +) +#endif +#ifndef OVERRIDE_64_setdomainname +SC_LTTNG_TRACEPOINT_EVENT(setdomainname, + TP_PROTO(sc_exit(long ret,) char * name, int len), + TP_ARGS(sc_exit(ret,) name, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(int, len, len))) +) +#endif +#ifndef OVERRIDE_64_getrlimit +SC_LTTNG_TRACEPOINT_EVENT(getrlimit, + TP_PROTO(sc_exit(long ret,) unsigned int resource, struct rlimit * rlim), + TP_ARGS(sc_exit(ret,) resource, rlim), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, resource, resource)) sc_out(ctf_integer(struct rlimit *, rlim, rlim))) +) +#endif +#ifndef OVERRIDE_64_setrlimit +SC_LTTNG_TRACEPOINT_EVENT(setrlimit, + TP_PROTO(sc_exit(long ret,) unsigned int resource, struct rlimit * rlim), + TP_ARGS(sc_exit(ret,) resource, rlim), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, resource, resource)) sc_in(ctf_integer(struct rlimit *, rlim, rlim))) +) +#endif +#ifndef OVERRIDE_64_getrusage +SC_LTTNG_TRACEPOINT_EVENT(getrusage, + TP_PROTO(sc_exit(long ret,) int who, struct rusage * ru), + TP_ARGS(sc_exit(ret,) who, ru), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, who, who)) sc_out(ctf_integer(struct rusage *, ru, ru))) +) +#endif +#ifndef OVERRIDE_64_gettimeofday +SC_LTTNG_TRACEPOINT_EVENT(gettimeofday, + TP_PROTO(sc_exit(long ret,) struct timeval * tv, struct timezone * tz), + TP_ARGS(sc_exit(ret,) tv, tz), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct timeval *, tv, tv)) sc_out(ctf_integer(struct timezone *, tz, tz))) +) +#endif +#ifndef OVERRIDE_64_settimeofday +SC_LTTNG_TRACEPOINT_EVENT(settimeofday, + TP_PROTO(sc_exit(long ret,) struct timeval * tv, struct timezone * tz), + TP_ARGS(sc_exit(ret,) tv, tz), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct timeval *, tv, tv)) sc_in(ctf_integer(struct timezone *, tz, tz))) +) +#endif +#ifndef OVERRIDE_64_mq_notify +SC_LTTNG_TRACEPOINT_EVENT(mq_notify, + TP_PROTO(sc_exit(long ret,) mqd_t mqdes, const struct sigevent * u_notification), + TP_ARGS(sc_exit(ret,) mqdes, u_notification), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(mqd_t, mqdes, mqdes)) sc_in(ctf_integer(const struct sigevent *, u_notification, u_notification))) +) +#endif +#ifndef OVERRIDE_64_swapon +SC_LTTNG_TRACEPOINT_EVENT(swapon, + TP_PROTO(sc_exit(long ret,) const char * specialfile, int swap_flags), + TP_ARGS(sc_exit(ret,) specialfile, swap_flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(specialfile, specialfile)) sc_in(ctf_integer(int, swap_flags, swap_flags))) +) +#endif +#ifndef OVERRIDE_64_clock_adjtime +SC_LTTNG_TRACEPOINT_EVENT(clock_adjtime, + TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct timex * utx), + TP_ARGS(sc_exit(ret,) which_clock, utx), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_inout(ctf_integer(struct timex *, utx, utx))) +) +#endif +#ifndef OVERRIDE_64_memfd_create +SC_LTTNG_TRACEPOINT_EVENT(memfd_create, + TP_PROTO(sc_exit(long ret,) const char * uname, unsigned int flags), + TP_ARGS(sc_exit(ret,) uname, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(uname, uname)) sc_inout(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_io_submit +SC_LTTNG_TRACEPOINT_EVENT(io_submit, + TP_PROTO(sc_exit(long ret,) aio_context_t ctx_id, long nr, struct iocb * * iocbpp), + TP_ARGS(sc_exit(ret,) ctx_id, nr, iocbpp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx_id, ctx_id)) sc_in(ctf_integer(long, nr, nr)) sc_in(ctf_integer(struct iocb * *, iocbpp, iocbpp))) +) +#endif +#ifndef OVERRIDE_64_io_cancel +SC_LTTNG_TRACEPOINT_EVENT(io_cancel, + TP_PROTO(sc_exit(long ret,) aio_context_t ctx_id, struct iocb * iocb, struct io_event * result), + TP_ARGS(sc_exit(ret,) ctx_id, iocb, result), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx_id, ctx_id)) sc_in(ctf_integer(struct iocb *, iocb, iocb)) sc_out(ctf_integer(struct io_event *, result, result))) +) +#endif +#ifndef OVERRIDE_64_listxattr +SC_LTTNG_TRACEPOINT_EVENT(listxattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, char * list, size_t size), + TP_ARGS(sc_exit(ret,) pathname, list, size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(char *, list, list)) sc_in(ctf_integer(size_t, size, size))) +) +#endif +#ifndef OVERRIDE_64_llistxattr +SC_LTTNG_TRACEPOINT_EVENT(llistxattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, char * list, size_t size), + TP_ARGS(sc_exit(ret,) pathname, list, size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(char *, list, list)) sc_in(ctf_integer(size_t, size, size))) +) +#endif +#ifndef OVERRIDE_64_flistxattr +SC_LTTNG_TRACEPOINT_EVENT(flistxattr, + TP_PROTO(sc_exit(long ret,) int fd, char * list, size_t size), + TP_ARGS(sc_exit(ret,) fd, list, size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(char *, list, list)) sc_in(ctf_integer(size_t, size, size))) +) +#endif +#ifndef OVERRIDE_64_lookup_dcookie +SC_LTTNG_TRACEPOINT_EVENT(lookup_dcookie, + TP_PROTO(sc_exit(long ret,) u64 cookie64, char * buf, size_t len), + TP_ARGS(sc_exit(ret,) cookie64, buf, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(u64, cookie64, cookie64)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(size_t, len, len))) +) +#endif +#ifndef OVERRIDE_64_inotify_add_watch +SC_LTTNG_TRACEPOINT_EVENT(inotify_add_watch, + TP_PROTO(sc_exit(long ret,) int fd, const char * pathname, u32 mask), + TP_ARGS(sc_exit(ret,) fd, pathname, mask), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(u32, mask, mask))) +) +#endif +#ifndef OVERRIDE_64_mkdirat +SC_LTTNG_TRACEPOINT_EVENT(mkdirat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * pathname, umode_t mode), + TP_ARGS(sc_exit(ret,) dfd, pathname, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(umode_t, mode, mode))) +) +#endif +#ifndef OVERRIDE_64_unlinkat +SC_LTTNG_TRACEPOINT_EVENT(unlinkat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * pathname, int flag), + TP_ARGS(sc_exit(ret,) dfd, pathname, flag), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(int, flag, flag))) +) +#endif +#ifndef OVERRIDE_64_symlinkat +SC_LTTNG_TRACEPOINT_EVENT(symlinkat, + TP_PROTO(sc_exit(long ret,) const char * oldname, int newdfd, const char * newname), + TP_ARGS(sc_exit(ret,) oldname, newdfd, newname), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_integer(int, newdfd, newdfd)) sc_in(ctf_user_string(newname, newname))) +) +#endif +#ifndef OVERRIDE_64_faccessat +SC_LTTNG_TRACEPOINT_EVENT(faccessat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, int mode), + TP_ARGS(sc_exit(ret,) dfd, filename, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, mode, mode))) +) +#endif +#ifndef OVERRIDE_64_fchmodat +SC_LTTNG_TRACEPOINT_EVENT(fchmodat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, umode_t mode), + TP_ARGS(sc_exit(ret,) dfd, filename, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(umode_t, mode, mode))) +) +#endif +#ifndef OVERRIDE_64_getdents64 +SC_LTTNG_TRACEPOINT_EVENT(getdents64, + TP_PROTO(sc_exit(long ret,) unsigned int fd, struct linux_dirent64 * dirent, unsigned int count), + TP_ARGS(sc_exit(ret,) fd, dirent, count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct linux_dirent64 *, dirent, dirent)) sc_in(ctf_integer(unsigned int, count, count))) +) +#endif +#ifndef OVERRIDE_64_read +SC_LTTNG_TRACEPOINT_EVENT(read, + TP_PROTO(sc_exit(long ret,) unsigned int fd, char * buf, size_t count), + TP_ARGS(sc_exit(ret,) fd, buf, count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(size_t, count, count))) +) +#endif +#ifndef OVERRIDE_64_write +SC_LTTNG_TRACEPOINT_EVENT(write, + TP_PROTO(sc_exit(long ret,) unsigned int fd, const char * buf, size_t count), + TP_ARGS(sc_exit(ret,) fd, buf, count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(const char *, buf, buf)) sc_in(ctf_integer(size_t, count, count))) +) +#endif +#ifndef OVERRIDE_64_readv +SC_LTTNG_TRACEPOINT_EVENT(readv, + TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen), + TP_ARGS(sc_exit(ret,) fd, vec, vlen), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_inout(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen))) +) +#endif +#ifndef OVERRIDE_64_writev +SC_LTTNG_TRACEPOINT_EVENT(writev, + TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen), + TP_ARGS(sc_exit(ret,) fd, vec, vlen), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_inout(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen))) +) +#endif +#ifndef OVERRIDE_64_get_robust_list +SC_LTTNG_TRACEPOINT_EVENT(get_robust_list, + TP_PROTO(sc_exit(long ret,) int pid, struct robust_list_head * * head_ptr, size_t * len_ptr), + TP_ARGS(sc_exit(ret,) pid, head_ptr, len_ptr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, pid, pid)) sc_out(ctf_integer(struct robust_list_head * *, head_ptr, head_ptr)) sc_out(ctf_integer(size_t *, len_ptr, len_ptr))) +) +#endif +#ifndef OVERRIDE_64_setitimer +SC_LTTNG_TRACEPOINT_EVENT(setitimer, + TP_PROTO(sc_exit(long ret,) int which, struct itimerval * value, struct itimerval * ovalue), + TP_ARGS(sc_exit(ret,) which, value, ovalue), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(struct itimerval *, value, value)) sc_out(ctf_integer(struct itimerval *, ovalue, ovalue))) +) +#endif +#ifndef OVERRIDE_64_init_module +SC_LTTNG_TRACEPOINT_EVENT(init_module, + TP_PROTO(sc_exit(long ret,) void * umod, unsigned long len, const char * uargs), + TP_ARGS(sc_exit(ret,) umod, len, uargs), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(void *, umod, umod)) sc_in(ctf_integer(unsigned long, len, len)) sc_in(ctf_integer(const char *, uargs, uargs))) +) +#endif +#ifndef OVERRIDE_64_timer_create +SC_LTTNG_TRACEPOINT_EVENT(timer_create, + TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct sigevent * timer_event_spec, timer_t * created_timer_id), + TP_ARGS(sc_exit(ret,) which_clock, timer_event_spec, created_timer_id), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_in(ctf_integer(struct sigevent *, timer_event_spec, timer_event_spec)) sc_out(ctf_integer(timer_t *, created_timer_id, created_timer_id))) +) +#endif +#ifndef OVERRIDE_64_syslog +SC_LTTNG_TRACEPOINT_EVENT(syslog, + TP_PROTO(sc_exit(long ret,) int type, char * buf, int len), + TP_ARGS(sc_exit(ret,) type, buf, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, type, type)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(int, len, len))) +) +#endif +#ifndef OVERRIDE_64_sched_setscheduler +SC_LTTNG_TRACEPOINT_EVENT(sched_setscheduler, + TP_PROTO(sc_exit(long ret,) pid_t pid, int policy, struct sched_param * param), + TP_ARGS(sc_exit(ret,) pid, policy, param), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, policy, policy)) sc_in(ctf_integer(struct sched_param *, param, param))) +) +#endif +#ifndef OVERRIDE_64_sched_setaffinity +SC_LTTNG_TRACEPOINT_EVENT(sched_setaffinity, + TP_PROTO(sc_exit(long ret,) pid_t pid, unsigned int len, unsigned long * user_mask_ptr), + TP_ARGS(sc_exit(ret,) pid, len, user_mask_ptr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(unsigned int, len, len)) sc_in(ctf_integer(unsigned long *, user_mask_ptr, user_mask_ptr))) +) +#endif +#ifndef OVERRIDE_64_sched_getaffinity +SC_LTTNG_TRACEPOINT_EVENT(sched_getaffinity, + TP_PROTO(sc_exit(long ret,) pid_t pid, unsigned int len, unsigned long * user_mask_ptr), + TP_ARGS(sc_exit(ret,) pid, len, user_mask_ptr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(unsigned int, len, len)) sc_out(ctf_integer(unsigned long *, user_mask_ptr, user_mask_ptr))) +) +#endif +#ifndef OVERRIDE_64_rt_sigqueueinfo +SC_LTTNG_TRACEPOINT_EVENT(rt_sigqueueinfo, + TP_PROTO(sc_exit(long ret,) pid_t pid, int sig, siginfo_t * uinfo), + TP_ARGS(sc_exit(ret,) pid, sig, uinfo), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig)) sc_in(ctf_integer(siginfo_t *, uinfo, uinfo))) +) +#endif +#ifndef OVERRIDE_64_getresuid +SC_LTTNG_TRACEPOINT_EVENT(getresuid, + TP_PROTO(sc_exit(long ret,) uid_t * ruidp, uid_t * euidp, uid_t * suidp), + TP_ARGS(sc_exit(ret,) ruidp, euidp, suidp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(uid_t *, ruidp, ruidp)) sc_out(ctf_integer(uid_t *, euidp, euidp)) sc_out(ctf_integer(uid_t *, suidp, suidp))) +) +#endif +#ifndef OVERRIDE_64_getresgid +SC_LTTNG_TRACEPOINT_EVENT(getresgid, + TP_PROTO(sc_exit(long ret,) gid_t * rgidp, gid_t * egidp, gid_t * sgidp), + TP_ARGS(sc_exit(ret,) rgidp, egidp, sgidp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(gid_t *, rgidp, rgidp)) sc_out(ctf_integer(gid_t *, egidp, egidp)) sc_out(ctf_integer(gid_t *, sgidp, sgidp))) +) +#endif +#ifndef OVERRIDE_64_getcpu +SC_LTTNG_TRACEPOINT_EVENT(getcpu, + TP_PROTO(sc_exit(long ret,) unsigned * cpup, unsigned * nodep, struct getcpu_cache * unused), + TP_ARGS(sc_exit(ret,) cpup, nodep, unused), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(unsigned *, cpup, cpup)) sc_out(ctf_integer(unsigned *, nodep, nodep)) sc_inout(ctf_integer(struct getcpu_cache *, unused, unused))) +) +#endif +#ifndef OVERRIDE_64_mq_getsetattr +SC_LTTNG_TRACEPOINT_EVENT(mq_getsetattr, + TP_PROTO(sc_exit(long ret,) mqd_t mqdes, const struct mq_attr * u_mqstat, struct mq_attr * u_omqstat), + TP_ARGS(sc_exit(ret,) mqdes, u_mqstat, u_omqstat), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(mqd_t, mqdes, mqdes)) sc_in(ctf_integer(const struct mq_attr *, u_mqstat, u_mqstat)) sc_out(ctf_integer(struct mq_attr *, u_omqstat, u_omqstat))) +) +#endif +#ifndef OVERRIDE_64_msgctl +SC_LTTNG_TRACEPOINT_EVENT(msgctl, + TP_PROTO(sc_exit(long ret,) int msqid, int cmd, struct msqid_ds * buf), + TP_ARGS(sc_exit(ret,) msqid, cmd, buf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, msqid, msqid)) sc_in(ctf_integer(int, cmd, cmd)) sc_inout(ctf_integer(struct msqid_ds *, buf, buf))) +) +#endif +#ifndef OVERRIDE_64_semop +SC_LTTNG_TRACEPOINT_EVENT(semop, + TP_PROTO(sc_exit(long ret,) int semid, struct sembuf * tsops, unsigned nsops), + TP_ARGS(sc_exit(ret,) semid, tsops, nsops), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, semid, semid)) sc_in(ctf_integer(struct sembuf *, tsops, tsops)) sc_in(ctf_integer(unsigned, nsops, nsops))) +) +#endif +#ifndef OVERRIDE_64_shmctl +SC_LTTNG_TRACEPOINT_EVENT(shmctl, + TP_PROTO(sc_exit(long ret,) int shmid, int cmd, struct shmid_ds * buf), + TP_ARGS(sc_exit(ret,) shmid, cmd, buf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, shmid, shmid)) sc_in(ctf_integer(int, cmd, cmd)) sc_inout(ctf_integer(struct shmid_ds *, buf, buf))) +) +#endif +#ifndef OVERRIDE_64_shmat +SC_LTTNG_TRACEPOINT_EVENT(shmat, + TP_PROTO(sc_exit(long ret,) int shmid, char * shmaddr, int shmflg), + TP_ARGS(sc_exit(ret,) shmid, shmaddr, shmflg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, shmid, shmid)) sc_in(ctf_integer(char *, shmaddr, shmaddr)) sc_in(ctf_integer(int, shmflg, shmflg))) +) +#endif +#ifndef OVERRIDE_64_bind +SC_LTTNG_TRACEPOINT_EVENT(bind, + TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * umyaddr, int addrlen), + TP_ARGS(sc_exit(ret,) fd, umyaddr, addrlen), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct sockaddr *, umyaddr, umyaddr)) sc_in(ctf_integer(int, addrlen, addrlen))) +) +#endif +#ifndef OVERRIDE_64_accept +SC_LTTNG_TRACEPOINT_EVENT(accept, + TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * upeer_sockaddr, int * upeer_addrlen), + TP_ARGS(sc_exit(ret,) fd, upeer_sockaddr, upeer_addrlen), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct sockaddr *, upeer_sockaddr, upeer_sockaddr)) sc_inout(ctf_integer(int *, upeer_addrlen, upeer_addrlen))) +) +#endif +#ifndef OVERRIDE_64_connect +SC_LTTNG_TRACEPOINT_EVENT(connect, + TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * uservaddr, int addrlen), + TP_ARGS(sc_exit(ret,) fd, uservaddr, addrlen), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct sockaddr *, uservaddr, uservaddr)) sc_in(ctf_integer(int, addrlen, addrlen))) +) +#endif +#ifndef OVERRIDE_64_getsockname +SC_LTTNG_TRACEPOINT_EVENT(getsockname, + TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * usockaddr, int * usockaddr_len), + TP_ARGS(sc_exit(ret,) fd, usockaddr, usockaddr_len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct sockaddr *, usockaddr, usockaddr)) sc_inout(ctf_integer(int *, usockaddr_len, usockaddr_len))) +) +#endif +#ifndef OVERRIDE_64_getpeername +SC_LTTNG_TRACEPOINT_EVENT(getpeername, + TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * usockaddr, int * usockaddr_len), + TP_ARGS(sc_exit(ret,) fd, usockaddr, usockaddr_len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct sockaddr *, usockaddr, usockaddr)) sc_inout(ctf_integer(int *, usockaddr_len, usockaddr_len))) +) +#endif +#ifndef OVERRIDE_64_sendmsg +SC_LTTNG_TRACEPOINT_EVENT(sendmsg, + TP_PROTO(sc_exit(long ret,) int fd, struct user_msghdr * msg, unsigned int flags), + TP_ARGS(sc_exit(ret,) fd, msg, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct user_msghdr *, msg, msg)) sc_in(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_recvmsg +SC_LTTNG_TRACEPOINT_EVENT(recvmsg, + TP_PROTO(sc_exit(long ret,) int fd, struct user_msghdr * msg, unsigned int flags), + TP_ARGS(sc_exit(ret,) fd, msg, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_inout(ctf_integer(struct user_msghdr *, msg, msg)) sc_in(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_execve +SC_LTTNG_TRACEPOINT_EVENT(execve, + TP_PROTO(sc_exit(long ret,) const char * filename, const char *const * argv, const char *const * envp), + TP_ARGS(sc_exit(ret,) filename, argv, envp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(filename, filename)) sc_inout(ctf_integer(const char *const *, argv, argv)) sc_inout(ctf_integer(const char *const *, envp, envp))) +) +#endif +#ifndef OVERRIDE_64_mincore +SC_LTTNG_TRACEPOINT_EVENT(mincore, + TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len, unsigned char * vec), + TP_ARGS(sc_exit(ret,) start, len, vec), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len)) sc_out(ctf_integer(unsigned char *, vec, vec))) +) +#endif +#ifndef OVERRIDE_64_open_by_handle_at +SC_LTTNG_TRACEPOINT_EVENT(open_by_handle_at, + TP_PROTO(sc_exit(long ret,) int mountdirfd, struct file_handle * handle, int flags), + TP_ARGS(sc_exit(ret,) mountdirfd, handle, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, mountdirfd, mountdirfd)) sc_in(ctf_integer(struct file_handle *, handle, handle)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_finit_module +SC_LTTNG_TRACEPOINT_EVENT(finit_module, + TP_PROTO(sc_exit(long ret,) int fd, const char * uargs, int flags), + TP_ARGS(sc_exit(ret,) fd, uargs, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(const char *, uargs, uargs)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_sched_setattr +SC_LTTNG_TRACEPOINT_EVENT(sched_setattr, + TP_PROTO(sc_exit(long ret,) pid_t pid, struct sched_attr * uattr, unsigned int flags), + TP_ARGS(sc_exit(ret,) pid, uattr, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(pid_t, pid, pid)) sc_inout(ctf_integer(struct sched_attr *, uattr, uattr)) sc_inout(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_seccomp +SC_LTTNG_TRACEPOINT_EVENT(seccomp, + TP_PROTO(sc_exit(long ret,) unsigned int op, unsigned int flags, const char * uargs), + TP_ARGS(sc_exit(ret,) op, flags, uargs), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, op, op)) sc_inout(ctf_integer(unsigned int, flags, flags)) sc_inout(ctf_integer(const char *, uargs, uargs))) +) +#endif +#ifndef OVERRIDE_64_getrandom +SC_LTTNG_TRACEPOINT_EVENT(getrandom, + TP_PROTO(sc_exit(long ret,) char * buf, size_t count, unsigned int flags), + TP_ARGS(sc_exit(ret,) buf, count, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(char *, buf, buf)) sc_inout(ctf_integer(size_t, count, count)) sc_inout(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_getxattr +SC_LTTNG_TRACEPOINT_EVENT(getxattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, void * value, size_t size), + TP_ARGS(sc_exit(ret,) pathname, name, value, size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_out(ctf_integer(void *, value, value)) sc_in(ctf_integer(size_t, size, size))) +) +#endif +#ifndef OVERRIDE_64_lgetxattr +SC_LTTNG_TRACEPOINT_EVENT(lgetxattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, void * value, size_t size), + TP_ARGS(sc_exit(ret,) pathname, name, value, size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_out(ctf_integer(void *, value, value)) sc_in(ctf_integer(size_t, size, size))) +) +#endif +#ifndef OVERRIDE_64_fgetxattr +SC_LTTNG_TRACEPOINT_EVENT(fgetxattr, + TP_PROTO(sc_exit(long ret,) int fd, const char * name, void * value, size_t size), + TP_ARGS(sc_exit(ret,) fd, name, value, size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(name, name)) sc_out(ctf_integer(void *, value, value)) sc_in(ctf_integer(size_t, size, size))) +) +#endif +#ifndef OVERRIDE_64_epoll_ctl +SC_LTTNG_TRACEPOINT_EVENT(epoll_ctl, + TP_PROTO(sc_exit(long ret,) int epfd, int op, int fd, struct epoll_event * event), + TP_ARGS(sc_exit(ret,) epfd, op, fd, event), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, epfd, epfd)) sc_in(ctf_integer(int, op, op)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct epoll_event *, event, event))) +) +#endif +#ifndef OVERRIDE_64_mknodat +SC_LTTNG_TRACEPOINT_EVENT(mknodat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, umode_t mode, unsigned dev), + TP_ARGS(sc_exit(ret,) dfd, filename, mode, dev), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(umode_t, mode, mode)) sc_in(ctf_integer(unsigned, dev, dev))) +) +#endif +#ifndef OVERRIDE_64_renameat +SC_LTTNG_TRACEPOINT_EVENT(renameat, + TP_PROTO(sc_exit(long ret,) int olddfd, const char * oldname, int newdfd, const char * newname), + TP_ARGS(sc_exit(ret,) olddfd, oldname, newdfd, newname), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, olddfd, olddfd)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_integer(int, newdfd, newdfd)) sc_in(ctf_user_string(newname, newname))) +) +#endif +#ifndef OVERRIDE_64_openat +SC_LTTNG_TRACEPOINT_EVENT(openat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, int flags, umode_t mode), + TP_ARGS(sc_exit(ret,) dfd, filename, flags, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(umode_t, mode, mode))) +) +#endif +#ifndef OVERRIDE_64_quotactl +SC_LTTNG_TRACEPOINT_EVENT(quotactl, + TP_PROTO(sc_exit(long ret,) unsigned int cmd, const char * special, qid_t id, void * addr), + TP_ARGS(sc_exit(ret,) cmd, special, id, addr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_in(ctf_integer(const char *, special, special)) sc_in(ctf_integer(qid_t, id, id)) sc_inout(ctf_integer(void *, addr, addr))) +) +#endif +#ifndef OVERRIDE_64_pread64 +SC_LTTNG_TRACEPOINT_EVENT(pread64, + TP_PROTO(sc_exit(long ret,) unsigned int fd, char * buf, size_t count, loff_t pos), + TP_ARGS(sc_exit(ret,) fd, buf, count, pos), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(size_t, count, count)) sc_in(ctf_integer(loff_t, pos, pos))) +) +#endif +#ifndef OVERRIDE_64_pwrite64 +SC_LTTNG_TRACEPOINT_EVENT(pwrite64, + TP_PROTO(sc_exit(long ret,) unsigned int fd, const char * buf, size_t count, loff_t pos), + TP_ARGS(sc_exit(ret,) fd, buf, count, pos), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(const char *, buf, buf)) sc_in(ctf_integer(size_t, count, count)) sc_in(ctf_integer(loff_t, pos, pos))) +) +#endif +#ifndef OVERRIDE_64_sendfile64 +SC_LTTNG_TRACEPOINT_EVENT(sendfile64, + TP_PROTO(sc_exit(long ret,) int out_fd, int in_fd, loff_t * offset, size_t count), + TP_ARGS(sc_exit(ret,) out_fd, in_fd, offset, count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, out_fd, out_fd)) sc_in(ctf_integer(int, in_fd, in_fd)) sc_inout(ctf_integer(loff_t *, offset, offset)) sc_in(ctf_integer(size_t, count, count))) +) +#endif +#ifndef OVERRIDE_64_signalfd4 +SC_LTTNG_TRACEPOINT_EVENT(signalfd4, + TP_PROTO(sc_exit(long ret,) int ufd, sigset_t * user_mask, size_t sizemask, int flags), + TP_ARGS(sc_exit(ret,) ufd, user_mask, sizemask, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_in(ctf_integer(sigset_t *, user_mask, user_mask)) sc_in(ctf_integer(size_t, sizemask, sizemask)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_vmsplice +SC_LTTNG_TRACEPOINT_EVENT(vmsplice, + TP_PROTO(sc_exit(long ret,) int fd, const struct iovec * iov, unsigned long nr_segs, unsigned int flags), + TP_ARGS(sc_exit(ret,) fd, iov, nr_segs, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(const struct iovec *, iov, iov)) sc_in(ctf_integer(unsigned long, nr_segs, nr_segs)) sc_in(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_readlinkat +SC_LTTNG_TRACEPOINT_EVENT(readlinkat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * pathname, char * buf, int bufsiz), + TP_ARGS(sc_exit(ret,) dfd, pathname, buf, bufsiz), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(int, bufsiz, bufsiz))) +) +#endif +#ifndef OVERRIDE_64_newfstatat +SC_LTTNG_TRACEPOINT_EVENT(newfstatat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, struct stat * statbuf, int flag), + TP_ARGS(sc_exit(ret,) dfd, filename, statbuf, flag), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_out(ctf_integer(struct stat *, statbuf, statbuf)) sc_in(ctf_integer(int, flag, flag))) +) +#endif +#ifndef OVERRIDE_64_timerfd_settime +SC_LTTNG_TRACEPOINT_EVENT(timerfd_settime, + TP_PROTO(sc_exit(long ret,) int ufd, int flags, const struct itimerspec * utmr, struct itimerspec * otmr), + TP_ARGS(sc_exit(ret,) ufd, flags, utmr, otmr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(const struct itimerspec *, utmr, utmr)) sc_out(ctf_integer(struct itimerspec *, otmr, otmr))) +) +#endif +#ifndef OVERRIDE_64_utimensat +SC_LTTNG_TRACEPOINT_EVENT(utimensat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, struct timespec * utimes, int flags), + TP_ARGS(sc_exit(ret,) dfd, filename, utimes, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(struct timespec *, utimes, utimes)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_timer_settime +SC_LTTNG_TRACEPOINT_EVENT(timer_settime, + TP_PROTO(sc_exit(long ret,) timer_t timer_id, int flags, const struct itimerspec * new_setting, struct itimerspec * old_setting), + TP_ARGS(sc_exit(ret,) timer_id, flags, new_setting, old_setting), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(const struct itimerspec *, new_setting, new_setting)) sc_out(ctf_integer(struct itimerspec *, old_setting, old_setting))) +) +#endif +#ifndef OVERRIDE_64_clock_nanosleep +SC_LTTNG_TRACEPOINT_EVENT(clock_nanosleep, + TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, int flags, const struct timespec * rqtp, struct timespec * rmtp), + TP_ARGS(sc_exit(ret,) which_clock, flags, rqtp, rmtp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(const struct timespec *, rqtp, rqtp)) sc_out(ctf_integer(struct timespec *, rmtp, rmtp))) +) +#endif +#ifndef OVERRIDE_64_rt_sigaction +SC_LTTNG_TRACEPOINT_EVENT(rt_sigaction, + TP_PROTO(sc_exit(long ret,) int sig, const struct sigaction * act, struct sigaction * oact, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) sig, act, oact, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, sig, sig)) sc_in(ctf_integer(const struct sigaction *, act, act)) sc_out(ctf_integer(struct sigaction *, oact, oact)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) +) +#endif +#ifndef OVERRIDE_64_rt_sigprocmask +SC_LTTNG_TRACEPOINT_EVENT(rt_sigprocmask, + TP_PROTO(sc_exit(long ret,) int how, sigset_t * nset, sigset_t * oset, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) how, nset, oset, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, how, how)) sc_in(ctf_integer(sigset_t *, nset, nset)) sc_out(ctf_integer(sigset_t *, oset, oset)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) +) +#endif +#ifndef OVERRIDE_64_rt_sigtimedwait +SC_LTTNG_TRACEPOINT_EVENT(rt_sigtimedwait, + TP_PROTO(sc_exit(long ret,) const sigset_t * uthese, siginfo_t * uinfo, const struct timespec * uts, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) uthese, uinfo, uts, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(const sigset_t *, uthese, uthese)) sc_out(ctf_integer(siginfo_t *, uinfo, uinfo)) sc_in(ctf_integer(const struct timespec *, uts, uts)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) +) +#endif +#ifndef OVERRIDE_64_reboot +SC_LTTNG_TRACEPOINT_EVENT(reboot, + TP_PROTO(sc_exit(long ret,) int magic1, int magic2, unsigned int cmd, void * arg), + TP_ARGS(sc_exit(ret,) magic1, magic2, cmd, arg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, magic1, magic1)) sc_in(ctf_integer(int, magic2, magic2)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_in(ctf_integer(void *, arg, arg))) +) +#endif +#ifndef OVERRIDE_64_mq_open +SC_LTTNG_TRACEPOINT_EVENT(mq_open, + TP_PROTO(sc_exit(long ret,) const char * u_name, int oflag, umode_t mode, struct mq_attr * u_attr), + TP_ARGS(sc_exit(ret,) u_name, oflag, mode, u_attr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(u_name, u_name)) sc_in(ctf_integer(int, oflag, oflag)) sc_in(ctf_integer(umode_t, mode, mode)) sc_in(ctf_integer(struct mq_attr *, u_attr, u_attr))) +) +#endif +#ifndef OVERRIDE_64_msgsnd +SC_LTTNG_TRACEPOINT_EVENT(msgsnd, + TP_PROTO(sc_exit(long ret,) int msqid, struct msgbuf * msgp, size_t msgsz, int msgflg), + TP_ARGS(sc_exit(ret,) msqid, msgp, msgsz, msgflg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, msqid, msqid)) sc_in(ctf_integer(struct msgbuf *, msgp, msgp)) sc_in(ctf_integer(size_t, msgsz, msgsz)) sc_in(ctf_integer(int, msgflg, msgflg))) +) +#endif +#ifndef OVERRIDE_64_semtimedop +SC_LTTNG_TRACEPOINT_EVENT(semtimedop, + TP_PROTO(sc_exit(long ret,) int semid, struct sembuf * tsops, unsigned nsops, const struct timespec * timeout), + TP_ARGS(sc_exit(ret,) semid, tsops, nsops, timeout), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, semid, semid)) sc_in(ctf_integer(struct sembuf *, tsops, tsops)) sc_in(ctf_integer(unsigned, nsops, nsops)) sc_inout(ctf_integer(const struct timespec *, timeout, timeout))) +) +#endif +#ifndef OVERRIDE_64_socketpair +SC_LTTNG_TRACEPOINT_EVENT(socketpair, + TP_PROTO(sc_exit(long ret,) int family, int type, int protocol, int * usockvec), + TP_ARGS(sc_exit(ret,) family, type, protocol, usockvec), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, family, family)) sc_in(ctf_integer(int, type, type)) sc_in(ctf_integer(int, protocol, protocol)) sc_out(ctf_integer(int *, usockvec, usockvec))) +) +#endif +#ifndef OVERRIDE_64_request_key +SC_LTTNG_TRACEPOINT_EVENT(request_key, + TP_PROTO(sc_exit(long ret,) const char * _type, const char * _description, const char * _callout_info, key_serial_t destringid), + TP_ARGS(sc_exit(ret,) _type, _description, _callout_info, destringid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(_type, _type)) sc_in(ctf_integer(const char *, _description, _description)) sc_in(ctf_integer(const char *, _callout_info, _callout_info)) sc_in(ctf_integer(key_serial_t, destringid, destringid))) +) +#endif +#ifndef OVERRIDE_64_rt_tgsigqueueinfo +SC_LTTNG_TRACEPOINT_EVENT(rt_tgsigqueueinfo, + TP_PROTO(sc_exit(long ret,) pid_t tgid, pid_t pid, int sig, siginfo_t * uinfo), + TP_ARGS(sc_exit(ret,) tgid, pid, sig, uinfo), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, tgid, tgid)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig)) sc_in(ctf_integer(siginfo_t *, uinfo, uinfo))) +) +#endif +#ifndef OVERRIDE_64_accept4 +SC_LTTNG_TRACEPOINT_EVENT(accept4, + TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * upeer_sockaddr, int * upeer_addrlen, int flags), + TP_ARGS(sc_exit(ret,) fd, upeer_sockaddr, upeer_addrlen, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct sockaddr *, upeer_sockaddr, upeer_sockaddr)) sc_inout(ctf_integer(int *, upeer_addrlen, upeer_addrlen)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_wait4 +SC_LTTNG_TRACEPOINT_EVENT(wait4, + TP_PROTO(sc_exit(long ret,) pid_t upid, int * stat_addr, int options, struct rusage * ru), + TP_ARGS(sc_exit(ret,) upid, stat_addr, options, ru), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, upid, upid)) sc_out(ctf_integer(int *, stat_addr, stat_addr)) sc_in(ctf_integer(int, options, options)) sc_out(ctf_integer(struct rusage *, ru, ru))) +) +#endif +#ifndef OVERRIDE_64_prlimit64 +SC_LTTNG_TRACEPOINT_EVENT(prlimit64, + TP_PROTO(sc_exit(long ret,) pid_t pid, unsigned int resource, const struct rlimit64 * new_rlim, struct rlimit64 * old_rlim), + TP_ARGS(sc_exit(ret,) pid, resource, new_rlim, old_rlim), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(unsigned int, resource, resource)) sc_in(ctf_integer(const struct rlimit64 *, new_rlim, new_rlim)) sc_out(ctf_integer(struct rlimit64 *, old_rlim, old_rlim))) +) +#endif +#ifndef OVERRIDE_64_sendmmsg +SC_LTTNG_TRACEPOINT_EVENT(sendmmsg, + TP_PROTO(sc_exit(long ret,) int fd, struct mmsghdr * mmsg, unsigned int vlen, unsigned int flags), + TP_ARGS(sc_exit(ret,) fd, mmsg, vlen, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct mmsghdr *, mmsg, mmsg)) sc_in(ctf_integer(unsigned int, vlen, vlen)) sc_in(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_sched_getattr +SC_LTTNG_TRACEPOINT_EVENT(sched_getattr, + TP_PROTO(sc_exit(long ret,) pid_t pid, struct sched_attr * uattr, unsigned int size, unsigned int flags), + TP_ARGS(sc_exit(ret,) pid, uattr, size, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(pid_t, pid, pid)) sc_inout(ctf_integer(struct sched_attr *, uattr, uattr)) sc_inout(ctf_integer(unsigned int, size, size)) sc_inout(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_io_getevents +SC_LTTNG_TRACEPOINT_EVENT(io_getevents, + TP_PROTO(sc_exit(long ret,) aio_context_t ctx_id, long min_nr, long nr, struct io_event * events, struct timespec * timeout), + TP_ARGS(sc_exit(ret,) ctx_id, min_nr, nr, events, timeout), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx_id, ctx_id)) sc_in(ctf_integer(long, min_nr, min_nr)) sc_in(ctf_integer(long, nr, nr)) sc_out(ctf_integer(struct io_event *, events, events)) sc_inout(ctf_integer(struct timespec *, timeout, timeout))) +) +#endif +#ifndef OVERRIDE_64_setxattr +SC_LTTNG_TRACEPOINT_EVENT(setxattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, const void * value, size_t size, int flags), + TP_ARGS(sc_exit(ret,) pathname, name, value, size, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(const void *, value, value)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_lsetxattr +SC_LTTNG_TRACEPOINT_EVENT(lsetxattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, const void * value, size_t size, int flags), + TP_ARGS(sc_exit(ret,) pathname, name, value, size, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(const void *, value, value)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_fsetxattr +SC_LTTNG_TRACEPOINT_EVENT(fsetxattr, + TP_PROTO(sc_exit(long ret,) int fd, const char * name, const void * value, size_t size, int flags), + TP_ARGS(sc_exit(ret,) fd, name, value, size, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(const void *, value, value)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_linkat +SC_LTTNG_TRACEPOINT_EVENT(linkat, + TP_PROTO(sc_exit(long ret,) int olddfd, const char * oldname, int newdfd, const char * newname, int flags), + TP_ARGS(sc_exit(ret,) olddfd, oldname, newdfd, newname, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, olddfd, olddfd)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_integer(int, newdfd, newdfd)) sc_in(ctf_user_string(newname, newname)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_mount +SC_LTTNG_TRACEPOINT_EVENT(mount, + TP_PROTO(sc_exit(long ret,) char * dev_name, char * dir_name, char * type, unsigned long flags, void * data), + TP_ARGS(sc_exit(ret,) dev_name, dir_name, type, flags, data), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(dev_name, dev_name)) sc_in(ctf_user_string(dir_name, dir_name)) sc_in(ctf_user_string(type, type)) sc_in(ctf_integer(unsigned long, flags, flags)) sc_in(ctf_integer(void *, data, data))) +) +#endif +#ifndef OVERRIDE_64_fchownat +SC_LTTNG_TRACEPOINT_EVENT(fchownat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, uid_t user, gid_t group, int flag), + TP_ARGS(sc_exit(ret,) dfd, filename, user, group, flag), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group)) sc_in(ctf_integer(int, flag, flag))) +) +#endif +#ifndef OVERRIDE_64_preadv +SC_LTTNG_TRACEPOINT_EVENT(preadv, + TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen, unsigned long pos_l, unsigned long pos_h), + TP_ARGS(sc_exit(ret,) fd, vec, vlen, pos_l, pos_h), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_out(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen)) sc_in(ctf_integer(unsigned long, pos_l, pos_l)) sc_in(ctf_integer(unsigned long, pos_h, pos_h))) +) +#endif +#ifndef OVERRIDE_64_pwritev +SC_LTTNG_TRACEPOINT_EVENT(pwritev, + TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen, unsigned long pos_l, unsigned long pos_h), + TP_ARGS(sc_exit(ret,) fd, vec, vlen, pos_l, pos_h), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_in(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen)) sc_in(ctf_integer(unsigned long, pos_l, pos_l)) sc_in(ctf_integer(unsigned long, pos_h, pos_h))) +) +#endif +#ifndef OVERRIDE_64_ppoll +SC_LTTNG_TRACEPOINT_EVENT(ppoll, + TP_PROTO(sc_exit(long ret,) struct pollfd * ufds, unsigned int nfds, struct timespec * tsp, const sigset_t * sigmask, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) ufds, nfds, tsp, sigmask, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct pollfd *, ufds, ufds)) sc_in(ctf_integer(unsigned int, nfds, nfds)) sc_in(ctf_integer(struct timespec *, tsp, tsp)) sc_in(ctf_integer(const sigset_t *, sigmask, sigmask)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) +) +#endif +#ifndef OVERRIDE_64_waitid +SC_LTTNG_TRACEPOINT_EVENT(waitid, + TP_PROTO(sc_exit(long ret,) int which, pid_t upid, struct siginfo * infop, int options, struct rusage * ru), + TP_ARGS(sc_exit(ret,) which, upid, infop, options, ru), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(pid_t, upid, upid)) sc_out(ctf_integer(struct siginfo *, infop, infop)) sc_in(ctf_integer(int, options, options)) sc_out(ctf_integer(struct rusage *, ru, ru))) +) +#endif +#ifndef OVERRIDE_64_mq_timedsend +SC_LTTNG_TRACEPOINT_EVENT(mq_timedsend, + TP_PROTO(sc_exit(long ret,) mqd_t mqdes, const char * u_msg_ptr, size_t msg_len, unsigned int msg_prio, const struct timespec * u_abs_timeout), + TP_ARGS(sc_exit(ret,) mqdes, u_msg_ptr, msg_len, msg_prio, u_abs_timeout), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(mqd_t, mqdes, mqdes)) sc_in(ctf_integer(const char *, u_msg_ptr, u_msg_ptr)) sc_in(ctf_integer(size_t, msg_len, msg_len)) sc_in(ctf_integer(unsigned int, msg_prio, msg_prio)) sc_in(ctf_integer(const struct timespec *, u_abs_timeout, u_abs_timeout))) +) +#endif +#ifndef OVERRIDE_64_mq_timedreceive +SC_LTTNG_TRACEPOINT_EVENT(mq_timedreceive, + TP_PROTO(sc_exit(long ret,) mqd_t mqdes, char * u_msg_ptr, size_t msg_len, unsigned int * u_msg_prio, const struct timespec * u_abs_timeout), + TP_ARGS(sc_exit(ret,) mqdes, u_msg_ptr, msg_len, u_msg_prio, u_abs_timeout), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(mqd_t, mqdes, mqdes)) sc_out(ctf_integer(char *, u_msg_ptr, u_msg_ptr)) sc_in(ctf_integer(size_t, msg_len, msg_len)) sc_out(ctf_integer(unsigned int *, u_msg_prio, u_msg_prio)) sc_in(ctf_integer(const struct timespec *, u_abs_timeout, u_abs_timeout))) +) +#endif +#ifndef OVERRIDE_64_msgrcv +SC_LTTNG_TRACEPOINT_EVENT(msgrcv, + TP_PROTO(sc_exit(long ret,) int msqid, struct msgbuf * msgp, size_t msgsz, long msgtyp, int msgflg), + TP_ARGS(sc_exit(ret,) msqid, msgp, msgsz, msgtyp, msgflg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, msqid, msqid)) sc_out(ctf_integer(struct msgbuf *, msgp, msgp)) sc_in(ctf_integer(size_t, msgsz, msgsz)) sc_in(ctf_integer(long, msgtyp, msgtyp)) sc_in(ctf_integer(int, msgflg, msgflg))) +) +#endif +#ifndef OVERRIDE_64_setsockopt +SC_LTTNG_TRACEPOINT_EVENT(setsockopt, + TP_PROTO(sc_exit(long ret,) int fd, int level, int optname, char * optval, int optlen), + TP_ARGS(sc_exit(ret,) fd, level, optname, optval, optlen), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, level, level)) sc_in(ctf_integer(int, optname, optname)) sc_in(ctf_integer(char *, optval, optval)) sc_in(ctf_integer(int, optlen, optlen))) +) +#endif +#ifndef OVERRIDE_64_getsockopt +SC_LTTNG_TRACEPOINT_EVENT(getsockopt, + TP_PROTO(sc_exit(long ret,) int fd, int level, int optname, char * optval, int * optlen), + TP_ARGS(sc_exit(ret,) fd, level, optname, optval, optlen), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, level, level)) sc_in(ctf_integer(int, optname, optname)) sc_out(ctf_integer(char *, optval, optval)) sc_inout(ctf_integer(int *, optlen, optlen))) +) +#endif +#ifndef OVERRIDE_64_add_key +SC_LTTNG_TRACEPOINT_EVENT(add_key, + TP_PROTO(sc_exit(long ret,) const char * _type, const char * _description, const void * _payload, size_t plen, key_serial_t ringid), + TP_ARGS(sc_exit(ret,) _type, _description, _payload, plen, ringid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(_type, _type)) sc_in(ctf_integer(const char *, _description, _description)) sc_in(ctf_integer(const void *, _payload, _payload)) sc_in(ctf_integer(size_t, plen, plen)) sc_in(ctf_integer(key_serial_t, ringid, ringid))) +) +#endif +#ifndef OVERRIDE_64_perf_event_open +SC_LTTNG_TRACEPOINT_EVENT(perf_event_open, + TP_PROTO(sc_exit(long ret,) struct perf_event_attr * attr_uptr, pid_t pid, int cpu, int group_fd, unsigned long flags), + TP_ARGS(sc_exit(ret,) attr_uptr, pid, cpu, group_fd, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct perf_event_attr *, attr_uptr, attr_uptr)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, cpu, cpu)) sc_in(ctf_integer(int, group_fd, group_fd)) sc_in(ctf_integer(unsigned long, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_recvmmsg +SC_LTTNG_TRACEPOINT_EVENT(recvmmsg, + TP_PROTO(sc_exit(long ret,) int fd, struct mmsghdr * mmsg, unsigned int vlen, unsigned int flags, struct timespec * timeout), + TP_ARGS(sc_exit(ret,) fd, mmsg, vlen, flags, timeout), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct mmsghdr *, mmsg, mmsg)) sc_in(ctf_integer(unsigned int, vlen, vlen)) sc_in(ctf_integer(unsigned int, flags, flags)) sc_inout(ctf_integer(struct timespec *, timeout, timeout))) +) +#endif +#ifndef OVERRIDE_64_fanotify_mark +SC_LTTNG_TRACEPOINT_EVENT(fanotify_mark, + TP_PROTO(sc_exit(long ret,) int fanotify_fd, unsigned int flags, __u64 mask, int dfd, const char * pathname), + TP_ARGS(sc_exit(ret,) fanotify_fd, flags, mask, dfd, pathname), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fanotify_fd, fanotify_fd)) sc_in(ctf_integer(unsigned int, flags, flags)) sc_in(ctf_integer(__u64, mask, mask)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(pathname, pathname))) +) +#endif +#ifndef OVERRIDE_64_name_to_handle_at +SC_LTTNG_TRACEPOINT_EVENT(name_to_handle_at, + TP_PROTO(sc_exit(long ret,) int dfd, const char * name, struct file_handle * handle, int * mnt_id, int flag), + TP_ARGS(sc_exit(ret,) dfd, name, handle, mnt_id, flag), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(name, name)) sc_inout(ctf_integer(struct file_handle *, handle, handle)) sc_out(ctf_integer(int *, mnt_id, mnt_id)) sc_in(ctf_integer(int, flag, flag))) +) +#endif +#ifndef OVERRIDE_64_renameat2 +SC_LTTNG_TRACEPOINT_EVENT(renameat2, + TP_PROTO(sc_exit(long ret,) int olddfd, const char * oldname, int newdfd, const char * newname, unsigned int flags), + TP_ARGS(sc_exit(ret,) olddfd, oldname, newdfd, newname, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, olddfd, olddfd)) sc_inout(ctf_user_string(oldname, oldname)) sc_inout(ctf_integer(int, newdfd, newdfd)) sc_inout(ctf_user_string(newname, newname)) sc_inout(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_execveat +SC_LTTNG_TRACEPOINT_EVENT(execveat, + TP_PROTO(sc_exit(long ret,) int fd, const char * filename, const char *const * argv, const char *const * envp, int flags), + TP_ARGS(sc_exit(ret,) fd, filename, argv, envp, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, fd, fd)) sc_inout(ctf_user_string(filename, filename)) sc_inout(ctf_integer(const char *const *, argv, argv)) sc_inout(ctf_integer(const char *const *, envp, envp)) sc_inout(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_epoll_pwait +SC_LTTNG_TRACEPOINT_EVENT(epoll_pwait, + TP_PROTO(sc_exit(long ret,) int epfd, struct epoll_event * events, int maxevents, int timeout, const sigset_t * sigmask, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) epfd, events, maxevents, timeout, sigmask, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, epfd, epfd)) sc_out(ctf_integer(struct epoll_event *, events, events)) sc_in(ctf_integer(int, maxevents, maxevents)) sc_in(ctf_integer(int, timeout, timeout)) sc_in(ctf_integer(const sigset_t *, sigmask, sigmask)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) +) +#endif +#ifndef OVERRIDE_64_pselect6 +SC_LTTNG_TRACEPOINT_EVENT(pselect6, + TP_PROTO(sc_exit(long ret,) int n, fd_set * inp, fd_set * outp, fd_set * exp, struct timespec * tsp, void * sig), + TP_ARGS(sc_exit(ret,) n, inp, outp, exp, tsp, sig), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, n, n)) sc_inout(ctf_integer(fd_set *, inp, inp)) sc_inout(ctf_integer(fd_set *, outp, outp)) sc_inout(ctf_integer(fd_set *, exp, exp)) sc_inout(ctf_integer(struct timespec *, tsp, tsp)) sc_in(ctf_integer(void *, sig, sig))) +) +#endif +#ifndef OVERRIDE_64_splice +SC_LTTNG_TRACEPOINT_EVENT(splice, + TP_PROTO(sc_exit(long ret,) int fd_in, loff_t * off_in, int fd_out, loff_t * off_out, size_t len, unsigned int flags), + TP_ARGS(sc_exit(ret,) fd_in, off_in, fd_out, off_out, len, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd_in, fd_in)) sc_in(ctf_integer(loff_t *, off_in, off_in)) sc_in(ctf_integer(int, fd_out, fd_out)) sc_in(ctf_integer(loff_t *, off_out, off_out)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_futex +SC_LTTNG_TRACEPOINT_EVENT(futex, + TP_PROTO(sc_exit(long ret,) u32 * uaddr, int op, u32 val, struct timespec * utime, u32 * uaddr2, u32 val3), + TP_ARGS(sc_exit(ret,) uaddr, op, val, utime, uaddr2, val3), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(u32 *, uaddr, uaddr)) sc_in(ctf_integer(int, op, op)) sc_in(ctf_integer(u32, val, val)) sc_in(ctf_integer(struct timespec *, utime, utime)) sc_inout(ctf_integer(u32 *, uaddr2, uaddr2)) sc_in(ctf_integer(u32, val3, val3))) +) +#endif +#ifndef OVERRIDE_64_sendto +SC_LTTNG_TRACEPOINT_EVENT(sendto, + TP_PROTO(sc_exit(long ret,) int fd, void * buff, size_t len, unsigned int flags, struct sockaddr * addr, int addr_len), + TP_ARGS(sc_exit(ret,) fd, buff, len, flags, addr, addr_len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(void *, buff, buff)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned int, flags, flags)) sc_in(ctf_integer(struct sockaddr *, addr, addr)) sc_in(ctf_integer(int, addr_len, addr_len))) +) +#endif +#ifndef OVERRIDE_64_recvfrom +SC_LTTNG_TRACEPOINT_EVENT(recvfrom, + TP_PROTO(sc_exit(long ret,) int fd, void * ubuf, size_t size, unsigned int flags, struct sockaddr * addr, int * addr_len), + TP_ARGS(sc_exit(ret,) fd, ubuf, size, flags, addr, addr_len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(void *, ubuf, ubuf)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(unsigned int, flags, flags)) sc_out(ctf_integer(struct sockaddr *, addr, addr)) sc_inout(ctf_integer(int *, addr_len, addr_len))) +) +#endif +#ifndef OVERRIDE_64_process_vm_readv +SC_LTTNG_TRACEPOINT_EVENT(process_vm_readv, + TP_PROTO(sc_exit(long ret,) pid_t pid, const struct iovec * lvec, unsigned long liovcnt, const struct iovec * rvec, unsigned long riovcnt, unsigned long flags), + TP_ARGS(sc_exit(ret,) pid, lvec, liovcnt, rvec, riovcnt, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_out(ctf_integer(const struct iovec *, lvec, lvec)) sc_in(ctf_integer(unsigned long, liovcnt, liovcnt)) sc_in(ctf_integer(const struct iovec *, rvec, rvec)) sc_in(ctf_integer(unsigned long, riovcnt, riovcnt)) sc_in(ctf_integer(unsigned long, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_process_vm_writev +SC_LTTNG_TRACEPOINT_EVENT(process_vm_writev, + TP_PROTO(sc_exit(long ret,) pid_t pid, const struct iovec * lvec, unsigned long liovcnt, const struct iovec * rvec, unsigned long riovcnt, unsigned long flags), + TP_ARGS(sc_exit(ret,) pid, lvec, liovcnt, rvec, riovcnt, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(const struct iovec *, lvec, lvec)) sc_in(ctf_integer(unsigned long, liovcnt, liovcnt)) sc_in(ctf_integer(const struct iovec *, rvec, rvec)) sc_in(ctf_integer(unsigned long, riovcnt, riovcnt)) sc_in(ctf_integer(unsigned long, flags, flags))) +) +#endif + +#endif /* _TRACE_SYSCALLS_POINTERS_H */ + +/* This part must be outside protection */ +#include + +#else /* CREATE_SYSCALL_TABLE */ + +#include "arm-64-syscalls_pointers_override.h" +#include "syscalls_pointers_override.h" + +#ifndef OVERRIDE_TABLE_64_io_setup +TRACE_SYSCALL_TABLE(io_setup, io_setup, 0, 2) +#endif +#ifndef OVERRIDE_TABLE_64_io_submit +TRACE_SYSCALL_TABLE(io_submit, io_submit, 2, 3) +#endif +#ifndef OVERRIDE_TABLE_64_io_cancel +TRACE_SYSCALL_TABLE(io_cancel, io_cancel, 3, 3) +#endif +#ifndef OVERRIDE_TABLE_64_io_getevents +TRACE_SYSCALL_TABLE(io_getevents, io_getevents, 4, 5) +#endif +#ifndef OVERRIDE_TABLE_64_setxattr +TRACE_SYSCALL_TABLE(setxattr, setxattr, 5, 5) +#endif +#ifndef OVERRIDE_TABLE_64_lsetxattr +TRACE_SYSCALL_TABLE(lsetxattr, lsetxattr, 6, 5) +#endif +#ifndef OVERRIDE_TABLE_64_fsetxattr +TRACE_SYSCALL_TABLE(fsetxattr, fsetxattr, 7, 5) +#endif +#ifndef OVERRIDE_TABLE_64_getxattr +TRACE_SYSCALL_TABLE(getxattr, getxattr, 8, 4) +#endif +#ifndef OVERRIDE_TABLE_64_lgetxattr +TRACE_SYSCALL_TABLE(lgetxattr, lgetxattr, 9, 4) +#endif +#ifndef OVERRIDE_TABLE_64_fgetxattr +TRACE_SYSCALL_TABLE(fgetxattr, fgetxattr, 10, 4) +#endif +#ifndef OVERRIDE_TABLE_64_listxattr +TRACE_SYSCALL_TABLE(listxattr, listxattr, 11, 3) +#endif +#ifndef OVERRIDE_TABLE_64_llistxattr +TRACE_SYSCALL_TABLE(llistxattr, llistxattr, 12, 3) +#endif +#ifndef OVERRIDE_TABLE_64_flistxattr +TRACE_SYSCALL_TABLE(flistxattr, flistxattr, 13, 3) +#endif +#ifndef OVERRIDE_TABLE_64_removexattr +TRACE_SYSCALL_TABLE(removexattr, removexattr, 14, 2) +#endif +#ifndef OVERRIDE_TABLE_64_lremovexattr +TRACE_SYSCALL_TABLE(lremovexattr, lremovexattr, 15, 2) +#endif +#ifndef OVERRIDE_TABLE_64_fremovexattr +TRACE_SYSCALL_TABLE(fremovexattr, fremovexattr, 16, 2) +#endif +#ifndef OVERRIDE_TABLE_64_getcwd +TRACE_SYSCALL_TABLE(getcwd, getcwd, 17, 2) +#endif +#ifndef OVERRIDE_TABLE_64_lookup_dcookie +TRACE_SYSCALL_TABLE(lookup_dcookie, lookup_dcookie, 18, 3) +#endif +#ifndef OVERRIDE_TABLE_64_epoll_ctl +TRACE_SYSCALL_TABLE(epoll_ctl, epoll_ctl, 21, 4) +#endif +#ifndef OVERRIDE_TABLE_64_epoll_pwait +TRACE_SYSCALL_TABLE(epoll_pwait, epoll_pwait, 22, 6) +#endif +#ifndef OVERRIDE_TABLE_64_inotify_add_watch +TRACE_SYSCALL_TABLE(inotify_add_watch, inotify_add_watch, 27, 3) +#endif +#ifndef OVERRIDE_TABLE_64_mknodat +TRACE_SYSCALL_TABLE(mknodat, mknodat, 33, 4) +#endif +#ifndef OVERRIDE_TABLE_64_mkdirat +TRACE_SYSCALL_TABLE(mkdirat, mkdirat, 34, 3) +#endif +#ifndef OVERRIDE_TABLE_64_unlinkat +TRACE_SYSCALL_TABLE(unlinkat, unlinkat, 35, 3) +#endif +#ifndef OVERRIDE_TABLE_64_symlinkat +TRACE_SYSCALL_TABLE(symlinkat, symlinkat, 36, 3) +#endif +#ifndef OVERRIDE_TABLE_64_linkat +TRACE_SYSCALL_TABLE(linkat, linkat, 37, 5) +#endif +#ifndef OVERRIDE_TABLE_64_renameat +TRACE_SYSCALL_TABLE(renameat, renameat, 38, 4) +#endif +#ifndef OVERRIDE_TABLE_64_umount +TRACE_SYSCALL_TABLE(umount, umount, 39, 2) +#endif +#ifndef OVERRIDE_TABLE_64_mount +TRACE_SYSCALL_TABLE(mount, mount, 40, 5) +#endif +#ifndef OVERRIDE_TABLE_64_pivot_root +TRACE_SYSCALL_TABLE(pivot_root, pivot_root, 41, 2) +#endif +#ifndef OVERRIDE_TABLE_64_statfs +TRACE_SYSCALL_TABLE(statfs, statfs, 43, 2) +#endif +#ifndef OVERRIDE_TABLE_64_fstatfs +TRACE_SYSCALL_TABLE(fstatfs, fstatfs, 44, 2) +#endif +#ifndef OVERRIDE_TABLE_64_truncate +TRACE_SYSCALL_TABLE(truncate, truncate, 45, 2) +#endif +#ifndef OVERRIDE_TABLE_64_faccessat +TRACE_SYSCALL_TABLE(faccessat, faccessat, 48, 3) +#endif +#ifndef OVERRIDE_TABLE_64_chdir +TRACE_SYSCALL_TABLE(chdir, chdir, 49, 1) +#endif +#ifndef OVERRIDE_TABLE_64_chroot +TRACE_SYSCALL_TABLE(chroot, chroot, 51, 1) +#endif +#ifndef OVERRIDE_TABLE_64_fchmodat +TRACE_SYSCALL_TABLE(fchmodat, fchmodat, 53, 3) +#endif +#ifndef OVERRIDE_TABLE_64_fchownat +TRACE_SYSCALL_TABLE(fchownat, fchownat, 54, 5) +#endif +#ifndef OVERRIDE_TABLE_64_openat +TRACE_SYSCALL_TABLE(openat, openat, 56, 4) +#endif +#ifndef OVERRIDE_TABLE_64_pipe2 +TRACE_SYSCALL_TABLE(pipe2, pipe2, 59, 2) +#endif +#ifndef OVERRIDE_TABLE_64_quotactl +TRACE_SYSCALL_TABLE(quotactl, quotactl, 60, 4) +#endif +#ifndef OVERRIDE_TABLE_64_getdents64 +TRACE_SYSCALL_TABLE(getdents64, getdents64, 61, 3) +#endif +#ifndef OVERRIDE_TABLE_64_read +TRACE_SYSCALL_TABLE(read, read, 63, 3) +#endif +#ifndef OVERRIDE_TABLE_64_write +TRACE_SYSCALL_TABLE(write, write, 64, 3) +#endif +#ifndef OVERRIDE_TABLE_64_readv +TRACE_SYSCALL_TABLE(readv, readv, 65, 3) +#endif +#ifndef OVERRIDE_TABLE_64_writev +TRACE_SYSCALL_TABLE(writev, writev, 66, 3) +#endif +#ifndef OVERRIDE_TABLE_64_pread64 +TRACE_SYSCALL_TABLE(pread64, pread64, 67, 4) +#endif +#ifndef OVERRIDE_TABLE_64_pwrite64 +TRACE_SYSCALL_TABLE(pwrite64, pwrite64, 68, 4) +#endif +#ifndef OVERRIDE_TABLE_64_preadv +TRACE_SYSCALL_TABLE(preadv, preadv, 69, 5) +#endif +#ifndef OVERRIDE_TABLE_64_pwritev +TRACE_SYSCALL_TABLE(pwritev, pwritev, 70, 5) +#endif +#ifndef OVERRIDE_TABLE_64_sendfile64 +TRACE_SYSCALL_TABLE(sendfile64, sendfile64, 71, 4) +#endif +#ifndef OVERRIDE_TABLE_64_pselect6 +TRACE_SYSCALL_TABLE(pselect6, pselect6, 72, 6) +#endif +#ifndef OVERRIDE_TABLE_64_ppoll +TRACE_SYSCALL_TABLE(ppoll, ppoll, 73, 5) +#endif +#ifndef OVERRIDE_TABLE_64_signalfd4 +TRACE_SYSCALL_TABLE(signalfd4, signalfd4, 74, 4) +#endif +#ifndef OVERRIDE_TABLE_64_vmsplice +TRACE_SYSCALL_TABLE(vmsplice, vmsplice, 75, 4) +#endif +#ifndef OVERRIDE_TABLE_64_splice +TRACE_SYSCALL_TABLE(splice, splice, 76, 6) +#endif +#ifndef OVERRIDE_TABLE_64_readlinkat +TRACE_SYSCALL_TABLE(readlinkat, readlinkat, 78, 4) +#endif +#ifndef OVERRIDE_TABLE_64_newfstatat +TRACE_SYSCALL_TABLE(newfstatat, newfstatat, 79, 4) +#endif +#ifndef OVERRIDE_TABLE_64_newfstat +TRACE_SYSCALL_TABLE(newfstat, newfstat, 80, 2) +#endif +#ifndef OVERRIDE_TABLE_64_timerfd_settime +TRACE_SYSCALL_TABLE(timerfd_settime, timerfd_settime, 86, 4) +#endif +#ifndef OVERRIDE_TABLE_64_timerfd_gettime +TRACE_SYSCALL_TABLE(timerfd_gettime, timerfd_gettime, 87, 2) +#endif +#ifndef OVERRIDE_TABLE_64_utimensat +TRACE_SYSCALL_TABLE(utimensat, utimensat, 88, 4) +#endif +#ifndef OVERRIDE_TABLE_64_acct +TRACE_SYSCALL_TABLE(acct, acct, 89, 1) +#endif +#ifndef OVERRIDE_TABLE_64_waitid +TRACE_SYSCALL_TABLE(waitid, waitid, 95, 5) +#endif +#ifndef OVERRIDE_TABLE_64_set_tid_address +TRACE_SYSCALL_TABLE(set_tid_address, set_tid_address, 96, 1) +#endif +#ifndef OVERRIDE_TABLE_64_futex +TRACE_SYSCALL_TABLE(futex, futex, 98, 6) +#endif +#ifndef OVERRIDE_TABLE_64_set_robust_list +TRACE_SYSCALL_TABLE(set_robust_list, set_robust_list, 99, 2) +#endif +#ifndef OVERRIDE_TABLE_64_get_robust_list +TRACE_SYSCALL_TABLE(get_robust_list, get_robust_list, 100, 3) +#endif +#ifndef OVERRIDE_TABLE_64_nanosleep +TRACE_SYSCALL_TABLE(nanosleep, nanosleep, 101, 2) +#endif +#ifndef OVERRIDE_TABLE_64_getitimer +TRACE_SYSCALL_TABLE(getitimer, getitimer, 102, 2) +#endif +#ifndef OVERRIDE_TABLE_64_setitimer +TRACE_SYSCALL_TABLE(setitimer, setitimer, 103, 3) +#endif +#ifndef OVERRIDE_TABLE_64_init_module +TRACE_SYSCALL_TABLE(init_module, init_module, 105, 3) +#endif +#ifndef OVERRIDE_TABLE_64_delete_module +TRACE_SYSCALL_TABLE(delete_module, delete_module, 106, 2) +#endif +#ifndef OVERRIDE_TABLE_64_timer_create +TRACE_SYSCALL_TABLE(timer_create, timer_create, 107, 3) +#endif +#ifndef OVERRIDE_TABLE_64_timer_gettime +TRACE_SYSCALL_TABLE(timer_gettime, timer_gettime, 108, 2) +#endif +#ifndef OVERRIDE_TABLE_64_timer_settime +TRACE_SYSCALL_TABLE(timer_settime, timer_settime, 110, 4) +#endif +#ifndef OVERRIDE_TABLE_64_clock_settime +TRACE_SYSCALL_TABLE(clock_settime, clock_settime, 112, 2) +#endif +#ifndef OVERRIDE_TABLE_64_clock_gettime +TRACE_SYSCALL_TABLE(clock_gettime, clock_gettime, 113, 2) +#endif +#ifndef OVERRIDE_TABLE_64_clock_getres +TRACE_SYSCALL_TABLE(clock_getres, clock_getres, 114, 2) +#endif +#ifndef OVERRIDE_TABLE_64_clock_nanosleep +TRACE_SYSCALL_TABLE(clock_nanosleep, clock_nanosleep, 115, 4) +#endif +#ifndef OVERRIDE_TABLE_64_syslog +TRACE_SYSCALL_TABLE(syslog, syslog, 116, 3) +#endif +#ifndef OVERRIDE_TABLE_64_sched_setparam +TRACE_SYSCALL_TABLE(sched_setparam, sched_setparam, 118, 2) +#endif +#ifndef OVERRIDE_TABLE_64_sched_setscheduler +TRACE_SYSCALL_TABLE(sched_setscheduler, sched_setscheduler, 119, 3) +#endif +#ifndef OVERRIDE_TABLE_64_sched_getparam +TRACE_SYSCALL_TABLE(sched_getparam, sched_getparam, 121, 2) +#endif +#ifndef OVERRIDE_TABLE_64_sched_setaffinity +TRACE_SYSCALL_TABLE(sched_setaffinity, sched_setaffinity, 122, 3) +#endif +#ifndef OVERRIDE_TABLE_64_sched_getaffinity +TRACE_SYSCALL_TABLE(sched_getaffinity, sched_getaffinity, 123, 3) +#endif +#ifndef OVERRIDE_TABLE_64_sched_rr_get_interval +TRACE_SYSCALL_TABLE(sched_rr_get_interval, sched_rr_get_interval, 127, 2) +#endif +#ifndef OVERRIDE_TABLE_64_sigaltstack +TRACE_SYSCALL_TABLE(sigaltstack, sigaltstack, 132, 2) +#endif +#ifndef OVERRIDE_TABLE_64_rt_sigsuspend +TRACE_SYSCALL_TABLE(rt_sigsuspend, rt_sigsuspend, 133, 2) +#endif +#ifndef OVERRIDE_TABLE_64_rt_sigaction +TRACE_SYSCALL_TABLE(rt_sigaction, rt_sigaction, 134, 4) +#endif +#ifndef OVERRIDE_TABLE_64_rt_sigprocmask +TRACE_SYSCALL_TABLE(rt_sigprocmask, rt_sigprocmask, 135, 4) +#endif +#ifndef OVERRIDE_TABLE_64_rt_sigpending +TRACE_SYSCALL_TABLE(rt_sigpending, rt_sigpending, 136, 2) +#endif +#ifndef OVERRIDE_TABLE_64_rt_sigtimedwait +TRACE_SYSCALL_TABLE(rt_sigtimedwait, rt_sigtimedwait, 137, 4) +#endif +#ifndef OVERRIDE_TABLE_64_rt_sigqueueinfo +TRACE_SYSCALL_TABLE(rt_sigqueueinfo, rt_sigqueueinfo, 138, 3) +#endif +#ifndef OVERRIDE_TABLE_64_reboot +TRACE_SYSCALL_TABLE(reboot, reboot, 142, 4) +#endif +#ifndef OVERRIDE_TABLE_64_getresuid +TRACE_SYSCALL_TABLE(getresuid, getresuid, 148, 3) +#endif +#ifndef OVERRIDE_TABLE_64_getresgid +TRACE_SYSCALL_TABLE(getresgid, getresgid, 150, 3) +#endif +#ifndef OVERRIDE_TABLE_64_times +TRACE_SYSCALL_TABLE(times, times, 153, 1) +#endif +#ifndef OVERRIDE_TABLE_64_getgroups +TRACE_SYSCALL_TABLE(getgroups, getgroups, 158, 2) +#endif +#ifndef OVERRIDE_TABLE_64_setgroups +TRACE_SYSCALL_TABLE(setgroups, setgroups, 159, 2) +#endif +#ifndef OVERRIDE_TABLE_64_newuname +TRACE_SYSCALL_TABLE(newuname, newuname, 160, 1) +#endif +#ifndef OVERRIDE_TABLE_64_sethostname +TRACE_SYSCALL_TABLE(sethostname, sethostname, 161, 2) +#endif +#ifndef OVERRIDE_TABLE_64_setdomainname +TRACE_SYSCALL_TABLE(setdomainname, setdomainname, 162, 2) +#endif +#ifndef OVERRIDE_TABLE_64_getrlimit +TRACE_SYSCALL_TABLE(getrlimit, getrlimit, 163, 2) +#endif +#ifndef OVERRIDE_TABLE_64_setrlimit +TRACE_SYSCALL_TABLE(setrlimit, setrlimit, 164, 2) +#endif +#ifndef OVERRIDE_TABLE_64_getrusage +TRACE_SYSCALL_TABLE(getrusage, getrusage, 165, 2) +#endif +#ifndef OVERRIDE_TABLE_64_getcpu +TRACE_SYSCALL_TABLE(getcpu, getcpu, 168, 3) +#endif +#ifndef OVERRIDE_TABLE_64_gettimeofday +TRACE_SYSCALL_TABLE(gettimeofday, gettimeofday, 169, 2) +#endif +#ifndef OVERRIDE_TABLE_64_settimeofday +TRACE_SYSCALL_TABLE(settimeofday, settimeofday, 170, 2) +#endif +#ifndef OVERRIDE_TABLE_64_adjtimex +TRACE_SYSCALL_TABLE(adjtimex, adjtimex, 171, 1) +#endif +#ifndef OVERRIDE_TABLE_64_sysinfo +TRACE_SYSCALL_TABLE(sysinfo, sysinfo, 179, 1) +#endif +#ifndef OVERRIDE_TABLE_64_mq_open +TRACE_SYSCALL_TABLE(mq_open, mq_open, 180, 4) +#endif +#ifndef OVERRIDE_TABLE_64_mq_unlink +TRACE_SYSCALL_TABLE(mq_unlink, mq_unlink, 181, 1) +#endif +#ifndef OVERRIDE_TABLE_64_mq_timedsend +TRACE_SYSCALL_TABLE(mq_timedsend, mq_timedsend, 182, 5) +#endif +#ifndef OVERRIDE_TABLE_64_mq_timedreceive +TRACE_SYSCALL_TABLE(mq_timedreceive, mq_timedreceive, 183, 5) +#endif +#ifndef OVERRIDE_TABLE_64_mq_notify +TRACE_SYSCALL_TABLE(mq_notify, mq_notify, 184, 2) +#endif +#ifndef OVERRIDE_TABLE_64_mq_getsetattr +TRACE_SYSCALL_TABLE(mq_getsetattr, mq_getsetattr, 185, 3) +#endif +#ifndef OVERRIDE_TABLE_64_msgctl +TRACE_SYSCALL_TABLE(msgctl, msgctl, 187, 3) +#endif +#ifndef OVERRIDE_TABLE_64_msgrcv +TRACE_SYSCALL_TABLE(msgrcv, msgrcv, 188, 5) +#endif +#ifndef OVERRIDE_TABLE_64_msgsnd +TRACE_SYSCALL_TABLE(msgsnd, msgsnd, 189, 4) +#endif +#ifndef OVERRIDE_TABLE_64_semtimedop +TRACE_SYSCALL_TABLE(semtimedop, semtimedop, 192, 4) +#endif +#ifndef OVERRIDE_TABLE_64_semop +TRACE_SYSCALL_TABLE(semop, semop, 193, 3) +#endif +#ifndef OVERRIDE_TABLE_64_shmctl +TRACE_SYSCALL_TABLE(shmctl, shmctl, 195, 3) +#endif +#ifndef OVERRIDE_TABLE_64_shmat +TRACE_SYSCALL_TABLE(shmat, shmat, 196, 3) +#endif +#ifndef OVERRIDE_TABLE_64_shmdt +TRACE_SYSCALL_TABLE(shmdt, shmdt, 197, 1) +#endif +#ifndef OVERRIDE_TABLE_64_socketpair +TRACE_SYSCALL_TABLE(socketpair, socketpair, 199, 4) +#endif +#ifndef OVERRIDE_TABLE_64_bind +TRACE_SYSCALL_TABLE(bind, bind, 200, 3) +#endif +#ifndef OVERRIDE_TABLE_64_accept +TRACE_SYSCALL_TABLE(accept, accept, 202, 3) +#endif +#ifndef OVERRIDE_TABLE_64_connect +TRACE_SYSCALL_TABLE(connect, connect, 203, 3) +#endif +#ifndef OVERRIDE_TABLE_64_getsockname +TRACE_SYSCALL_TABLE(getsockname, getsockname, 204, 3) +#endif +#ifndef OVERRIDE_TABLE_64_getpeername +TRACE_SYSCALL_TABLE(getpeername, getpeername, 205, 3) +#endif +#ifndef OVERRIDE_TABLE_64_sendto +TRACE_SYSCALL_TABLE(sendto, sendto, 206, 6) +#endif +#ifndef OVERRIDE_TABLE_64_recvfrom +TRACE_SYSCALL_TABLE(recvfrom, recvfrom, 207, 6) +#endif +#ifndef OVERRIDE_TABLE_64_setsockopt +TRACE_SYSCALL_TABLE(setsockopt, setsockopt, 208, 5) +#endif +#ifndef OVERRIDE_TABLE_64_getsockopt +TRACE_SYSCALL_TABLE(getsockopt, getsockopt, 209, 5) +#endif +#ifndef OVERRIDE_TABLE_64_sendmsg +TRACE_SYSCALL_TABLE(sendmsg, sendmsg, 211, 3) +#endif +#ifndef OVERRIDE_TABLE_64_recvmsg +TRACE_SYSCALL_TABLE(recvmsg, recvmsg, 212, 3) +#endif +#ifndef OVERRIDE_TABLE_64_add_key +TRACE_SYSCALL_TABLE(add_key, add_key, 217, 5) +#endif +#ifndef OVERRIDE_TABLE_64_request_key +TRACE_SYSCALL_TABLE(request_key, request_key, 218, 4) +#endif +#ifndef OVERRIDE_TABLE_64_execve +TRACE_SYSCALL_TABLE(execve, execve, 221, 3) +#endif +#ifndef OVERRIDE_TABLE_64_swapon +TRACE_SYSCALL_TABLE(swapon, swapon, 224, 2) +#endif +#ifndef OVERRIDE_TABLE_64_swapoff +TRACE_SYSCALL_TABLE(swapoff, swapoff, 225, 1) +#endif +#ifndef OVERRIDE_TABLE_64_mincore +TRACE_SYSCALL_TABLE(mincore, mincore, 232, 3) +#endif +#ifndef OVERRIDE_TABLE_64_rt_tgsigqueueinfo +TRACE_SYSCALL_TABLE(rt_tgsigqueueinfo, rt_tgsigqueueinfo, 240, 4) +#endif +#ifndef OVERRIDE_TABLE_64_perf_event_open +TRACE_SYSCALL_TABLE(perf_event_open, perf_event_open, 241, 5) +#endif +#ifndef OVERRIDE_TABLE_64_accept4 +TRACE_SYSCALL_TABLE(accept4, accept4, 242, 4) +#endif +#ifndef OVERRIDE_TABLE_64_recvmmsg +TRACE_SYSCALL_TABLE(recvmmsg, recvmmsg, 243, 5) +#endif +#ifndef OVERRIDE_TABLE_64_wait4 +TRACE_SYSCALL_TABLE(wait4, wait4, 260, 4) +#endif +#ifndef OVERRIDE_TABLE_64_prlimit64 +TRACE_SYSCALL_TABLE(prlimit64, prlimit64, 261, 4) +#endif +#ifndef OVERRIDE_TABLE_64_fanotify_mark +TRACE_SYSCALL_TABLE(fanotify_mark, fanotify_mark, 263, 5) +#endif +#ifndef OVERRIDE_TABLE_64_name_to_handle_at +TRACE_SYSCALL_TABLE(name_to_handle_at, name_to_handle_at, 264, 5) +#endif +#ifndef OVERRIDE_TABLE_64_open_by_handle_at +TRACE_SYSCALL_TABLE(open_by_handle_at, open_by_handle_at, 265, 3) +#endif +#ifndef OVERRIDE_TABLE_64_clock_adjtime +TRACE_SYSCALL_TABLE(clock_adjtime, clock_adjtime, 266, 2) +#endif +#ifndef OVERRIDE_TABLE_64_sendmmsg +TRACE_SYSCALL_TABLE(sendmmsg, sendmmsg, 269, 4) +#endif +#ifndef OVERRIDE_TABLE_64_process_vm_readv +TRACE_SYSCALL_TABLE(process_vm_readv, process_vm_readv, 270, 6) +#endif +#ifndef OVERRIDE_TABLE_64_process_vm_writev +TRACE_SYSCALL_TABLE(process_vm_writev, process_vm_writev, 271, 6) +#endif +#ifndef OVERRIDE_TABLE_64_finit_module +TRACE_SYSCALL_TABLE(finit_module, finit_module, 273, 3) +#endif +#ifndef OVERRIDE_TABLE_64_sched_setattr +TRACE_SYSCALL_TABLE(sched_setattr, sched_setattr, 274, 3) +#endif +#ifndef OVERRIDE_TABLE_64_sched_getattr +TRACE_SYSCALL_TABLE(sched_getattr, sched_getattr, 275, 4) +#endif +#ifndef OVERRIDE_TABLE_64_renameat2 +TRACE_SYSCALL_TABLE(renameat2, renameat2, 276, 5) +#endif +#ifndef OVERRIDE_TABLE_64_seccomp +TRACE_SYSCALL_TABLE(seccomp, seccomp, 277, 3) +#endif +#ifndef OVERRIDE_TABLE_64_getrandom +TRACE_SYSCALL_TABLE(getrandom, getrandom, 278, 3) +#endif +#ifndef OVERRIDE_TABLE_64_memfd_create +TRACE_SYSCALL_TABLE(memfd_create, memfd_create, 279, 2) +#endif +#ifndef OVERRIDE_TABLE_64_execveat +TRACE_SYSCALL_TABLE(execveat, execveat, 281, 5) +#endif + +#endif /* CREATE_SYSCALL_TABLE */ diff --git a/include/instrumentation/syscalls/headers/arm-64-syscalls_pointers_override.h b/include/instrumentation/syscalls/headers/arm-64-syscalls_pointers_override.h new file mode 100644 index 00000000..f35ce2f8 --- /dev/null +++ b/include/instrumentation/syscalls/headers/arm-64-syscalls_pointers_override.h @@ -0,0 +1,11 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ + +/* + * this is a place-holder for arm64 integer syscall definition override. + */ +#ifndef CREATE_SYSCALL_TABLE + +#else +#define OVERRIDE_TABLE_64_clone +TRACE_SYSCALL_TABLE(clone, clone, 220, 5) +#endif diff --git a/include/instrumentation/syscalls/headers/compat_syscalls_integers.h b/include/instrumentation/syscalls/headers/compat_syscalls_integers.h new file mode 100644 index 00000000..080a36a8 --- /dev/null +++ b/include/instrumentation/syscalls/headers/compat_syscalls_integers.h @@ -0,0 +1,13 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ + +#ifdef CONFIG_X86_64 +#include "x86-32-syscalls_integers.h" +#endif + +#ifdef CONFIG_ARM64 +#include "arm-32-syscalls_integers.h" +#endif + +#ifdef CONFIG_PPC64 +#include "powerpc-32-syscalls_integers.h" +#endif diff --git a/include/instrumentation/syscalls/headers/compat_syscalls_pointers.h b/include/instrumentation/syscalls/headers/compat_syscalls_pointers.h new file mode 100644 index 00000000..4d893862 --- /dev/null +++ b/include/instrumentation/syscalls/headers/compat_syscalls_pointers.h @@ -0,0 +1,13 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ + +#ifdef CONFIG_X86_64 +#include "x86-32-syscalls_pointers.h" +#endif + +#ifdef CONFIG_ARM64 +#include "arm-32-syscalls_pointers.h" +#endif + +#ifdef CONFIG_PPC64 +#include "powerpc-32-syscalls_pointers.h" +#endif diff --git a/include/instrumentation/syscalls/headers/mips-32-syscalls_integers.h b/include/instrumentation/syscalls/headers/mips-32-syscalls_integers.h new file mode 100644 index 00000000..cfaa1d88 --- /dev/null +++ b/include/instrumentation/syscalls/headers/mips-32-syscalls_integers.h @@ -0,0 +1,1114 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ + +/* THIS FILE IS AUTO-GENERATED. DO NOT EDIT */ + +/* Generated from mips-32-syscalls 3.18.0 */ + +#ifndef CREATE_SYSCALL_TABLE + +#if !defined(_TRACE_SYSCALLS_INTEGERS_H) || defined(TRACE_HEADER_MULTI_READ) +#define _TRACE_SYSCALLS_INTEGERS_H + +#include +#include +#include "mips-32-syscalls_integers_override.h" +#include "syscalls_integers_override.h" + +#ifdef SC_ENTER +SC_LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(syscalls_noargs, + TP_FIELDS() +) +#ifndef OVERRIDE_32_getpid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getpid) +#endif +#ifndef OVERRIDE_32_getuid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getuid) +#endif +#ifndef OVERRIDE_32_pause +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, pause) +#endif +#ifndef OVERRIDE_32_sync +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, sync) +#endif +#ifndef OVERRIDE_32_getgid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getgid) +#endif +#ifndef OVERRIDE_32_geteuid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, geteuid) +#endif +#ifndef OVERRIDE_32_getegid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getegid) +#endif +#ifndef OVERRIDE_32_getppid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getppid) +#endif +#ifndef OVERRIDE_32_getpgrp +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getpgrp) +#endif +#ifndef OVERRIDE_32_setsid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, setsid) +#endif +#ifndef OVERRIDE_32_vhangup +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, vhangup) +#endif +#ifndef OVERRIDE_32_munlockall +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, munlockall) +#endif +#ifndef OVERRIDE_32_sched_yield +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, sched_yield) +#endif +#ifndef OVERRIDE_32_gettid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, gettid) +#endif +#ifndef OVERRIDE_32_restart_syscall +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, restart_syscall) +#endif +#ifndef OVERRIDE_32_inotify_init +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, inotify_init) +#endif +#else /* #ifdef SC_ENTER */ +#ifndef OVERRIDE_32_getpid +SC_LTTNG_TRACEPOINT_EVENT(getpid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_getuid +SC_LTTNG_TRACEPOINT_EVENT(getuid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_pause +SC_LTTNG_TRACEPOINT_EVENT(pause, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_sync +SC_LTTNG_TRACEPOINT_EVENT(sync, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_getgid +SC_LTTNG_TRACEPOINT_EVENT(getgid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_geteuid +SC_LTTNG_TRACEPOINT_EVENT(geteuid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_getegid +SC_LTTNG_TRACEPOINT_EVENT(getegid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_getppid +SC_LTTNG_TRACEPOINT_EVENT(getppid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_getpgrp +SC_LTTNG_TRACEPOINT_EVENT(getpgrp, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_setsid +SC_LTTNG_TRACEPOINT_EVENT(setsid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_vhangup +SC_LTTNG_TRACEPOINT_EVENT(vhangup, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_munlockall +SC_LTTNG_TRACEPOINT_EVENT(munlockall, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_sched_yield +SC_LTTNG_TRACEPOINT_EVENT(sched_yield, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_gettid +SC_LTTNG_TRACEPOINT_EVENT(gettid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_restart_syscall +SC_LTTNG_TRACEPOINT_EVENT(restart_syscall, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_inotify_init +SC_LTTNG_TRACEPOINT_EVENT(inotify_init, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#endif /* else #ifdef SC_ENTER */ +#ifndef OVERRIDE_32_exit +SC_LTTNG_TRACEPOINT_EVENT(exit, + TP_PROTO(sc_exit(long ret,) int error_code), + TP_ARGS(sc_exit(ret,) error_code), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, error_code, error_code))) +) +#endif +#ifndef OVERRIDE_32_close +SC_LTTNG_TRACEPOINT_EVENT(close, + TP_PROTO(sc_exit(long ret,) unsigned int fd), + TP_ARGS(sc_exit(ret,) fd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) +) +#endif +#ifndef OVERRIDE_32_setuid +SC_LTTNG_TRACEPOINT_EVENT(setuid, + TP_PROTO(sc_exit(long ret,) uid_t uid), + TP_ARGS(sc_exit(ret,) uid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, uid, uid))) +) +#endif +#ifndef OVERRIDE_32_alarm +SC_LTTNG_TRACEPOINT_EVENT(alarm, + TP_PROTO(sc_exit(long ret,) unsigned int seconds), + TP_ARGS(sc_exit(ret,) seconds), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, seconds, seconds))) +) +#endif +#ifndef OVERRIDE_32_nice +SC_LTTNG_TRACEPOINT_EVENT(nice, + TP_PROTO(sc_exit(long ret,) int increment), + TP_ARGS(sc_exit(ret,) increment), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, increment, increment))) +) +#endif +#ifndef OVERRIDE_32_dup +SC_LTTNG_TRACEPOINT_EVENT(dup, + TP_PROTO(sc_exit(long ret,) unsigned int fildes), + TP_ARGS(sc_exit(ret,) fildes), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fildes, fildes))) +) +#endif +#ifndef OVERRIDE_32_brk +SC_LTTNG_TRACEPOINT_EVENT(brk, + TP_PROTO(sc_exit(long ret,) unsigned long brk), + TP_ARGS(sc_exit(ret,) brk), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, brk, brk))) +) +#endif +#ifndef OVERRIDE_32_setgid +SC_LTTNG_TRACEPOINT_EVENT(setgid, + TP_PROTO(sc_exit(long ret,) gid_t gid), + TP_ARGS(sc_exit(ret,) gid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, gid, gid))) +) +#endif +#ifndef OVERRIDE_32_umask +SC_LTTNG_TRACEPOINT_EVENT(umask, + TP_PROTO(sc_exit(long ret,) int mask), + TP_ARGS(sc_exit(ret,) mask), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, mask, mask))) +) +#endif +#ifndef OVERRIDE_32_fsync +SC_LTTNG_TRACEPOINT_EVENT(fsync, + TP_PROTO(sc_exit(long ret,) unsigned int fd), + TP_ARGS(sc_exit(ret,) fd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) +) +#endif +#ifndef OVERRIDE_32_getpgid +SC_LTTNG_TRACEPOINT_EVENT(getpgid, + TP_PROTO(sc_exit(long ret,) pid_t pid), + TP_ARGS(sc_exit(ret,) pid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid))) +) +#endif +#ifndef OVERRIDE_32_fchdir +SC_LTTNG_TRACEPOINT_EVENT(fchdir, + TP_PROTO(sc_exit(long ret,) unsigned int fd), + TP_ARGS(sc_exit(ret,) fd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) +) +#endif +#ifndef OVERRIDE_32_personality +SC_LTTNG_TRACEPOINT_EVENT(personality, + TP_PROTO(sc_exit(long ret,) unsigned int personality), + TP_ARGS(sc_exit(ret,) personality), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, personality, personality))) +) +#endif +#ifndef OVERRIDE_32_setfsuid +SC_LTTNG_TRACEPOINT_EVENT(setfsuid, + TP_PROTO(sc_exit(long ret,) uid_t uid), + TP_ARGS(sc_exit(ret,) uid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, uid, uid))) +) +#endif +#ifndef OVERRIDE_32_setfsgid +SC_LTTNG_TRACEPOINT_EVENT(setfsgid, + TP_PROTO(sc_exit(long ret,) gid_t gid), + TP_ARGS(sc_exit(ret,) gid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, gid, gid))) +) +#endif +#ifndef OVERRIDE_32_getsid +SC_LTTNG_TRACEPOINT_EVENT(getsid, + TP_PROTO(sc_exit(long ret,) pid_t pid), + TP_ARGS(sc_exit(ret,) pid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid))) +) +#endif +#ifndef OVERRIDE_32_fdatasync +SC_LTTNG_TRACEPOINT_EVENT(fdatasync, + TP_PROTO(sc_exit(long ret,) unsigned int fd), + TP_ARGS(sc_exit(ret,) fd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) +) +#endif +#ifndef OVERRIDE_32_mlockall +SC_LTTNG_TRACEPOINT_EVENT(mlockall, + TP_PROTO(sc_exit(long ret,) int flags), + TP_ARGS(sc_exit(ret,) flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_sched_getscheduler +SC_LTTNG_TRACEPOINT_EVENT(sched_getscheduler, + TP_PROTO(sc_exit(long ret,) pid_t pid), + TP_ARGS(sc_exit(ret,) pid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid))) +) +#endif +#ifndef OVERRIDE_32_sched_get_priority_max +SC_LTTNG_TRACEPOINT_EVENT(sched_get_priority_max, + TP_PROTO(sc_exit(long ret,) int policy), + TP_ARGS(sc_exit(ret,) policy), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, policy, policy))) +) +#endif +#ifndef OVERRIDE_32_sched_get_priority_min +SC_LTTNG_TRACEPOINT_EVENT(sched_get_priority_min, + TP_PROTO(sc_exit(long ret,) int policy), + TP_ARGS(sc_exit(ret,) policy), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, policy, policy))) +) +#endif +#ifndef OVERRIDE_32_io_destroy +SC_LTTNG_TRACEPOINT_EVENT(io_destroy, + TP_PROTO(sc_exit(long ret,) aio_context_t ctx), + TP_ARGS(sc_exit(ret,) ctx), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx, ctx))) +) +#endif +#ifndef OVERRIDE_32_exit_group +SC_LTTNG_TRACEPOINT_EVENT(exit_group, + TP_PROTO(sc_exit(long ret,) int error_code), + TP_ARGS(sc_exit(ret,) error_code), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, error_code, error_code))) +) +#endif +#ifndef OVERRIDE_32_epoll_create +SC_LTTNG_TRACEPOINT_EVENT(epoll_create, + TP_PROTO(sc_exit(long ret,) int size), + TP_ARGS(sc_exit(ret,) size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, size, size))) +) +#endif +#ifndef OVERRIDE_32_timer_getoverrun +SC_LTTNG_TRACEPOINT_EVENT(timer_getoverrun, + TP_PROTO(sc_exit(long ret,) timer_t timer_id), + TP_ARGS(sc_exit(ret,) timer_id), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id))) +) +#endif +#ifndef OVERRIDE_32_timer_delete +SC_LTTNG_TRACEPOINT_EVENT(timer_delete, + TP_PROTO(sc_exit(long ret,) timer_t timer_id), + TP_ARGS(sc_exit(ret,) timer_id), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id))) +) +#endif +#ifndef OVERRIDE_32_set_thread_area +SC_LTTNG_TRACEPOINT_EVENT(set_thread_area, + TP_PROTO(sc_exit(long ret,) unsigned long addr), + TP_ARGS(sc_exit(ret,) addr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned long, addr, addr))) +) +#endif +#ifndef OVERRIDE_32_unshare +SC_LTTNG_TRACEPOINT_EVENT(unshare, + TP_PROTO(sc_exit(long ret,) unsigned long unshare_flags), + TP_ARGS(sc_exit(ret,) unshare_flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, unshare_flags, unshare_flags))) +) +#endif +#ifndef OVERRIDE_32_eventfd +SC_LTTNG_TRACEPOINT_EVENT(eventfd, + TP_PROTO(sc_exit(long ret,) unsigned int count), + TP_ARGS(sc_exit(ret,) count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, count, count))) +) +#endif +#ifndef OVERRIDE_32_epoll_create1 +SC_LTTNG_TRACEPOINT_EVENT(epoll_create1, + TP_PROTO(sc_exit(long ret,) int flags), + TP_ARGS(sc_exit(ret,) flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_inotify_init1 +SC_LTTNG_TRACEPOINT_EVENT(inotify_init1, + TP_PROTO(sc_exit(long ret,) int flags), + TP_ARGS(sc_exit(ret,) flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_syncfs +SC_LTTNG_TRACEPOINT_EVENT(syncfs, + TP_PROTO(sc_exit(long ret,) int fd), + TP_ARGS(sc_exit(ret,) fd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd))) +) +#endif +#ifndef OVERRIDE_32_kill +SC_LTTNG_TRACEPOINT_EVENT(kill, + TP_PROTO(sc_exit(long ret,) pid_t pid, int sig), + TP_ARGS(sc_exit(ret,) pid, sig), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig))) +) +#endif +#ifndef OVERRIDE_32_setpgid +SC_LTTNG_TRACEPOINT_EVENT(setpgid, + TP_PROTO(sc_exit(long ret,) pid_t pid, pid_t pgid), + TP_ARGS(sc_exit(ret,) pid, pgid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(pid_t, pgid, pgid))) +) +#endif +#ifndef OVERRIDE_32_dup2 +SC_LTTNG_TRACEPOINT_EVENT(dup2, + TP_PROTO(sc_exit(long ret,) unsigned int oldfd, unsigned int newfd), + TP_ARGS(sc_exit(ret,) oldfd, newfd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, oldfd, oldfd)) sc_in(ctf_integer(unsigned int, newfd, newfd))) +) +#endif +#ifndef OVERRIDE_32_setreuid +SC_LTTNG_TRACEPOINT_EVENT(setreuid, + TP_PROTO(sc_exit(long ret,) uid_t ruid, uid_t euid), + TP_ARGS(sc_exit(ret,) ruid, euid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, ruid, ruid)) sc_in(ctf_integer(uid_t, euid, euid))) +) +#endif +#ifndef OVERRIDE_32_setregid +SC_LTTNG_TRACEPOINT_EVENT(setregid, + TP_PROTO(sc_exit(long ret,) gid_t rgid, gid_t egid), + TP_ARGS(sc_exit(ret,) rgid, egid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, rgid, rgid)) sc_in(ctf_integer(gid_t, egid, egid))) +) +#endif +#ifndef OVERRIDE_32_munmap +SC_LTTNG_TRACEPOINT_EVENT(munmap, + TP_PROTO(sc_exit(long ret,) unsigned long addr, size_t len), + TP_ARGS(sc_exit(ret,) addr, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, addr, addr)) sc_in(ctf_integer(size_t, len, len))) +) +#endif +#ifndef OVERRIDE_32_ftruncate +SC_LTTNG_TRACEPOINT_EVENT(ftruncate, + TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned long length), + TP_ARGS(sc_exit(ret,) fd, length), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned long, length, length))) +) +#endif +#ifndef OVERRIDE_32_fchmod +SC_LTTNG_TRACEPOINT_EVENT(fchmod, + TP_PROTO(sc_exit(long ret,) unsigned int fd, umode_t mode), + TP_ARGS(sc_exit(ret,) fd, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(umode_t, mode, mode))) +) +#endif +#ifndef OVERRIDE_32_getpriority +SC_LTTNG_TRACEPOINT_EVENT(getpriority, + TP_PROTO(sc_exit(long ret,) int which, int who), + TP_ARGS(sc_exit(ret,) which, who), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who))) +) +#endif +#ifndef OVERRIDE_32_bdflush +SC_LTTNG_TRACEPOINT_EVENT(bdflush, + TP_PROTO(sc_exit(long ret,) int func, long data), + TP_ARGS(sc_exit(ret,) func, data), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, func, func)) sc_inout(ctf_integer(long, data, data))) +) +#endif +#ifndef OVERRIDE_32_flock +SC_LTTNG_TRACEPOINT_EVENT(flock, + TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd), + TP_ARGS(sc_exit(ret,) fd, cmd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned int, cmd, cmd))) +) +#endif +#ifndef OVERRIDE_32_mlock +SC_LTTNG_TRACEPOINT_EVENT(mlock, + TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len), + TP_ARGS(sc_exit(ret,) start, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len))) +) +#endif +#ifndef OVERRIDE_32_munlock +SC_LTTNG_TRACEPOINT_EVENT(munlock, + TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len), + TP_ARGS(sc_exit(ret,) start, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len))) +) +#endif +#ifndef OVERRIDE_32_listen +SC_LTTNG_TRACEPOINT_EVENT(listen, + TP_PROTO(sc_exit(long ret,) int fd, int backlog), + TP_ARGS(sc_exit(ret,) fd, backlog), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, backlog, backlog))) +) +#endif +#ifndef OVERRIDE_32_shutdown +SC_LTTNG_TRACEPOINT_EVENT(shutdown, + TP_PROTO(sc_exit(long ret,) int fd, int how), + TP_ARGS(sc_exit(ret,) fd, how), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, how, how))) +) +#endif +#ifndef OVERRIDE_32_ftruncate64 +SC_LTTNG_TRACEPOINT_EVENT(ftruncate64, + TP_PROTO(sc_exit(long ret,) unsigned int fd, loff_t length), + TP_ARGS(sc_exit(ret,) fd, length), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, fd, fd)) sc_inout(ctf_integer(loff_t, length, length))) +) +#endif +#ifndef OVERRIDE_32_tkill +SC_LTTNG_TRACEPOINT_EVENT(tkill, + TP_PROTO(sc_exit(long ret,) pid_t pid, int sig), + TP_ARGS(sc_exit(ret,) pid, sig), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig))) +) +#endif +#ifndef OVERRIDE_32_inotify_rm_watch +SC_LTTNG_TRACEPOINT_EVENT(inotify_rm_watch, + TP_PROTO(sc_exit(long ret,) int fd, __s32 wd), + TP_ARGS(sc_exit(ret,) fd, wd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(__s32, wd, wd))) +) +#endif +#ifndef OVERRIDE_32_ioprio_get +SC_LTTNG_TRACEPOINT_EVENT(ioprio_get, + TP_PROTO(sc_exit(long ret,) int which, int who), + TP_ARGS(sc_exit(ret,) which, who), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who))) +) +#endif +#ifndef OVERRIDE_32_timerfd_create +SC_LTTNG_TRACEPOINT_EVENT(timerfd_create, + TP_PROTO(sc_exit(long ret,) int clockid, int flags), + TP_ARGS(sc_exit(ret,) clockid, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, clockid, clockid)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_eventfd2 +SC_LTTNG_TRACEPOINT_EVENT(eventfd2, + TP_PROTO(sc_exit(long ret,) unsigned int count, int flags), + TP_ARGS(sc_exit(ret,) count, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, count, count)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_setns +SC_LTTNG_TRACEPOINT_EVENT(setns, + TP_PROTO(sc_exit(long ret,) int fd, int nstype), + TP_ARGS(sc_exit(ret,) fd, nstype), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, nstype, nstype))) +) +#endif +#ifndef OVERRIDE_32_lseek +SC_LTTNG_TRACEPOINT_EVENT(lseek, + TP_PROTO(sc_exit(long ret,) unsigned int fd, off_t offset, unsigned int whence), + TP_ARGS(sc_exit(ret,) fd, offset, whence), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(off_t, offset, offset)) sc_in(ctf_integer(unsigned int, whence, whence))) +) +#endif +#ifndef OVERRIDE_32_ioctl +SC_LTTNG_TRACEPOINT_EVENT(ioctl, + TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd, unsigned long arg), + TP_ARGS(sc_exit(ret,) fd, cmd, arg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_inout(ctf_integer(unsigned long, arg, arg))) +) +#endif +#ifndef OVERRIDE_32_fcntl +SC_LTTNG_TRACEPOINT_EVENT(fcntl, + TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd, unsigned long arg), + TP_ARGS(sc_exit(ret,) fd, cmd, arg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_inout(ctf_integer(unsigned long, arg, arg))) +) +#endif +#ifndef OVERRIDE_32_fchown +SC_LTTNG_TRACEPOINT_EVENT(fchown, + TP_PROTO(sc_exit(long ret,) unsigned int fd, uid_t user, gid_t group), + TP_ARGS(sc_exit(ret,) fd, user, group), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group))) +) +#endif +#ifndef OVERRIDE_32_setpriority +SC_LTTNG_TRACEPOINT_EVENT(setpriority, + TP_PROTO(sc_exit(long ret,) int which, int who, int niceval), + TP_ARGS(sc_exit(ret,) which, who, niceval), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who)) sc_in(ctf_integer(int, niceval, niceval))) +) +#endif +#ifndef OVERRIDE_32_mprotect +SC_LTTNG_TRACEPOINT_EVENT(mprotect, + TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len, unsigned long prot), + TP_ARGS(sc_exit(ret,) start, len, prot), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned long, prot, prot))) +) +#endif +#ifndef OVERRIDE_32_msync +SC_LTTNG_TRACEPOINT_EVENT(msync, + TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len, int flags), + TP_ARGS(sc_exit(ret,) start, len, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_cacheflush +SC_LTTNG_TRACEPOINT_EVENT(cacheflush, + TP_PROTO(sc_exit(long ret,) unsigned long addr, unsigned long bytes, unsigned int cache), + TP_ARGS(sc_exit(ret,) addr, bytes, cache), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned long, addr, addr)) sc_inout(ctf_integer(unsigned long, bytes, bytes)) sc_inout(ctf_integer(unsigned int, cache, cache))) +) +#endif +#ifndef OVERRIDE_32_sysmips +SC_LTTNG_TRACEPOINT_EVENT(sysmips, + TP_PROTO(sc_exit(long ret,) long cmd, long arg1, long arg2), + TP_ARGS(sc_exit(ret,) cmd, arg1, arg2), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(long, cmd, cmd)) sc_inout(ctf_integer(long, arg1, arg1)) sc_inout(ctf_integer(long, arg2, arg2))) +) +#endif +#ifndef OVERRIDE_32_socket +SC_LTTNG_TRACEPOINT_EVENT(socket, + TP_PROTO(sc_exit(long ret,) int family, int type, int protocol), + TP_ARGS(sc_exit(ret,) family, type, protocol), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, family, family)) sc_in(ctf_integer(int, type, type)) sc_in(ctf_integer(int, protocol, protocol))) +) +#endif +#ifndef OVERRIDE_32_setresuid +SC_LTTNG_TRACEPOINT_EVENT(setresuid, + TP_PROTO(sc_exit(long ret,) uid_t ruid, uid_t euid, uid_t suid), + TP_ARGS(sc_exit(ret,) ruid, euid, suid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, ruid, ruid)) sc_in(ctf_integer(uid_t, euid, euid)) sc_in(ctf_integer(uid_t, suid, suid))) +) +#endif +#ifndef OVERRIDE_32_setresgid +SC_LTTNG_TRACEPOINT_EVENT(setresgid, + TP_PROTO(sc_exit(long ret,) gid_t rgid, gid_t egid, gid_t sgid), + TP_ARGS(sc_exit(ret,) rgid, egid, sgid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, rgid, rgid)) sc_in(ctf_integer(gid_t, egid, egid)) sc_in(ctf_integer(gid_t, sgid, sgid))) +) +#endif +#ifndef OVERRIDE_32_madvise +SC_LTTNG_TRACEPOINT_EVENT(madvise, + TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len_in, int behavior), + TP_ARGS(sc_exit(ret,) start, len_in, behavior), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len_in, len_in)) sc_in(ctf_integer(int, behavior, behavior))) +) +#endif +#ifndef OVERRIDE_32_fcntl64 +SC_LTTNG_TRACEPOINT_EVENT(fcntl64, + TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd, unsigned long arg), + TP_ARGS(sc_exit(ret,) fd, cmd, arg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, fd, fd)) sc_inout(ctf_integer(unsigned int, cmd, cmd)) sc_inout(ctf_integer(unsigned long, arg, arg))) +) +#endif +#ifndef OVERRIDE_32_readahead +SC_LTTNG_TRACEPOINT_EVENT(readahead, + TP_PROTO(sc_exit(long ret,) int fd, loff_t offset, size_t count), + TP_ARGS(sc_exit(ret,) fd, offset, count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(loff_t, offset, offset)) sc_in(ctf_integer(size_t, count, count))) +) +#endif +#ifndef OVERRIDE_32_tgkill +SC_LTTNG_TRACEPOINT_EVENT(tgkill, + TP_PROTO(sc_exit(long ret,) pid_t tgid, pid_t pid, int sig), + TP_ARGS(sc_exit(ret,) tgid, pid, sig), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, tgid, tgid)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig))) +) +#endif +#ifndef OVERRIDE_32_ioprio_set +SC_LTTNG_TRACEPOINT_EVENT(ioprio_set, + TP_PROTO(sc_exit(long ret,) int which, int who, int ioprio), + TP_ARGS(sc_exit(ret,) which, who, ioprio), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who)) sc_in(ctf_integer(int, ioprio, ioprio))) +) +#endif +#ifndef OVERRIDE_32_dup3 +SC_LTTNG_TRACEPOINT_EVENT(dup3, + TP_PROTO(sc_exit(long ret,) unsigned int oldfd, unsigned int newfd, int flags), + TP_ARGS(sc_exit(ret,) oldfd, newfd, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, oldfd, oldfd)) sc_in(ctf_integer(unsigned int, newfd, newfd)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_ptrace +SC_LTTNG_TRACEPOINT_EVENT(ptrace, + TP_PROTO(sc_exit(long ret,) long request, long pid, unsigned long addr, unsigned long data), + TP_ARGS(sc_exit(ret,) request, pid, addr, data), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(long, request, request)) sc_in(ctf_integer(long, pid, pid)) sc_inout(ctf_integer(unsigned long, addr, addr)) sc_inout(ctf_integer(unsigned long, data, data))) +) +#endif +#ifndef OVERRIDE_32_fadvise64_64 +SC_LTTNG_TRACEPOINT_EVENT(fadvise64_64, + TP_PROTO(sc_exit(long ret,) int fd, loff_t offset, loff_t len, int advice), + TP_ARGS(sc_exit(ret,) fd, offset, len, advice), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, fd, fd)) sc_inout(ctf_integer(loff_t, offset, offset)) sc_inout(ctf_integer(loff_t, len, len)) sc_inout(ctf_integer(int, advice, advice))) +) +#endif +#ifndef OVERRIDE_32_sync_file_range +SC_LTTNG_TRACEPOINT_EVENT(sync_file_range, + TP_PROTO(sc_exit(long ret,) int fd, loff_t offset, loff_t nbytes, unsigned int flags), + TP_ARGS(sc_exit(ret,) fd, offset, nbytes, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(loff_t, offset, offset)) sc_in(ctf_integer(loff_t, nbytes, nbytes)) sc_in(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_tee +SC_LTTNG_TRACEPOINT_EVENT(tee, + TP_PROTO(sc_exit(long ret,) int fdin, int fdout, size_t len, unsigned int flags), + TP_ARGS(sc_exit(ret,) fdin, fdout, len, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fdin, fdin)) sc_in(ctf_integer(int, fdout, fdout)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_fallocate +SC_LTTNG_TRACEPOINT_EVENT(fallocate, + TP_PROTO(sc_exit(long ret,) int fd, int mode, loff_t offset, loff_t len), + TP_ARGS(sc_exit(ret,) fd, mode, offset, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, mode, mode)) sc_in(ctf_integer(loff_t, offset, offset)) sc_in(ctf_integer(loff_t, len, len))) +) +#endif +#ifndef OVERRIDE_32_mremap +SC_LTTNG_TRACEPOINT_EVENT(mremap, + TP_PROTO(sc_exit(long ret,) unsigned long addr, unsigned long old_len, unsigned long new_len, unsigned long flags, unsigned long new_addr), + TP_ARGS(sc_exit(ret,) addr, old_len, new_len, flags, new_addr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, addr, addr)) sc_in(ctf_integer(unsigned long, old_len, old_len)) sc_in(ctf_integer(unsigned long, new_len, new_len)) sc_in(ctf_integer(unsigned long, flags, flags)) sc_in(ctf_integer(unsigned long, new_addr, new_addr))) +) +#endif +#ifndef OVERRIDE_32_prctl +SC_LTTNG_TRACEPOINT_EVENT(prctl, + TP_PROTO(sc_exit(long ret,) int option, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5), + TP_ARGS(sc_exit(ret,) option, arg2, arg3, arg4, arg5), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, option, option)) sc_inout(ctf_integer(unsigned long, arg2, arg2)) sc_in(ctf_integer(unsigned long, arg3, arg3)) sc_in(ctf_integer(unsigned long, arg4, arg4)) sc_in(ctf_integer(unsigned long, arg5, arg5))) +) +#endif +#ifndef OVERRIDE_32_remap_file_pages +SC_LTTNG_TRACEPOINT_EVENT(remap_file_pages, + TP_PROTO(sc_exit(long ret,) unsigned long start, unsigned long size, unsigned long prot, unsigned long pgoff, unsigned long flags), + TP_ARGS(sc_exit(ret,) start, size, prot, pgoff, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(unsigned long, size, size)) sc_in(ctf_integer(unsigned long, prot, prot)) sc_in(ctf_integer(unsigned long, pgoff, pgoff)) sc_in(ctf_integer(unsigned long, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_mmap +SC_LTTNG_TRACEPOINT_EVENT(mmap, + TP_PROTO(sc_exit(long ret,) unsigned long addr, unsigned long len, unsigned long prot, unsigned long flags, unsigned long fd, off_t offset), + TP_ARGS(sc_exit(ret,) addr, len, prot, flags, fd, offset), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, addr, addr)) sc_in(ctf_integer(unsigned long, len, len)) sc_in(ctf_integer(unsigned long, prot, prot)) sc_in(ctf_integer(unsigned long, flags, flags)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_in(ctf_integer(off_t, offset, offset))) +) +#endif +#ifndef OVERRIDE_32_mips_mmap2 +SC_LTTNG_TRACEPOINT_EVENT(mips_mmap2, + TP_PROTO(sc_exit(long ret,) unsigned long addr, unsigned long len, unsigned long prot, unsigned long flags, unsigned long fd, unsigned long pgoff), + TP_ARGS(sc_exit(ret,) addr, len, prot, flags, fd, pgoff), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned long, addr, addr)) sc_inout(ctf_integer(unsigned long, len, len)) sc_inout(ctf_integer(unsigned long, prot, prot)) sc_inout(ctf_integer(unsigned long, flags, flags)) sc_inout(ctf_integer(unsigned long, fd, fd)) sc_inout(ctf_integer(unsigned long, pgoff, pgoff))) +) +#endif + +#endif /* _TRACE_SYSCALLS_INTEGERS_H */ + +/* This part must be outside protection */ +#include + +#else /* CREATE_SYSCALL_TABLE */ + +#include "mips-32-syscalls_integers_override.h" +#include "syscalls_integers_override.h" + +#ifdef SC_ENTER +#ifndef OVERRIDE_TABLE_32_getpid +TRACE_SYSCALL_TABLE(syscalls_noargs, getpid, 4020, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getuid +TRACE_SYSCALL_TABLE(syscalls_noargs, getuid, 4024, 0) +#endif +#ifndef OVERRIDE_TABLE_32_pause +TRACE_SYSCALL_TABLE(syscalls_noargs, pause, 4029, 0) +#endif +#ifndef OVERRIDE_TABLE_32_sync +TRACE_SYSCALL_TABLE(syscalls_noargs, sync, 4036, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getgid +TRACE_SYSCALL_TABLE(syscalls_noargs, getgid, 4047, 0) +#endif +#ifndef OVERRIDE_TABLE_32_geteuid +TRACE_SYSCALL_TABLE(syscalls_noargs, geteuid, 4049, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getegid +TRACE_SYSCALL_TABLE(syscalls_noargs, getegid, 4050, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getppid +TRACE_SYSCALL_TABLE(syscalls_noargs, getppid, 4064, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getpgrp +TRACE_SYSCALL_TABLE(syscalls_noargs, getpgrp, 4065, 0) +#endif +#ifndef OVERRIDE_TABLE_32_setsid +TRACE_SYSCALL_TABLE(syscalls_noargs, setsid, 4066, 0) +#endif +#ifndef OVERRIDE_TABLE_32_vhangup +TRACE_SYSCALL_TABLE(syscalls_noargs, vhangup, 4111, 0) +#endif +#ifndef OVERRIDE_TABLE_32_munlockall +TRACE_SYSCALL_TABLE(syscalls_noargs, munlockall, 4157, 0) +#endif +#ifndef OVERRIDE_TABLE_32_sched_yield +TRACE_SYSCALL_TABLE(syscalls_noargs, sched_yield, 4162, 0) +#endif +#ifndef OVERRIDE_TABLE_32_gettid +TRACE_SYSCALL_TABLE(syscalls_noargs, gettid, 4222, 0) +#endif +#ifndef OVERRIDE_TABLE_32_restart_syscall +TRACE_SYSCALL_TABLE(syscalls_noargs, restart_syscall, 4253, 0) +#endif +#ifndef OVERRIDE_TABLE_32_inotify_init +TRACE_SYSCALL_TABLE(syscalls_noargs, inotify_init, 4284, 0) +#endif +#else /* #ifdef SC_ENTER */ +#ifndef OVERRIDE_TABLE_32_getpid +TRACE_SYSCALL_TABLE(getpid, getpid, 4020, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getuid +TRACE_SYSCALL_TABLE(getuid, getuid, 4024, 0) +#endif +#ifndef OVERRIDE_TABLE_32_pause +TRACE_SYSCALL_TABLE(pause, pause, 4029, 0) +#endif +#ifndef OVERRIDE_TABLE_32_sync +TRACE_SYSCALL_TABLE(sync, sync, 4036, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getgid +TRACE_SYSCALL_TABLE(getgid, getgid, 4047, 0) +#endif +#ifndef OVERRIDE_TABLE_32_geteuid +TRACE_SYSCALL_TABLE(geteuid, geteuid, 4049, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getegid +TRACE_SYSCALL_TABLE(getegid, getegid, 4050, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getppid +TRACE_SYSCALL_TABLE(getppid, getppid, 4064, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getpgrp +TRACE_SYSCALL_TABLE(getpgrp, getpgrp, 4065, 0) +#endif +#ifndef OVERRIDE_TABLE_32_setsid +TRACE_SYSCALL_TABLE(setsid, setsid, 4066, 0) +#endif +#ifndef OVERRIDE_TABLE_32_vhangup +TRACE_SYSCALL_TABLE(vhangup, vhangup, 4111, 0) +#endif +#ifndef OVERRIDE_TABLE_32_munlockall +TRACE_SYSCALL_TABLE(munlockall, munlockall, 4157, 0) +#endif +#ifndef OVERRIDE_TABLE_32_sched_yield +TRACE_SYSCALL_TABLE(sched_yield, sched_yield, 4162, 0) +#endif +#ifndef OVERRIDE_TABLE_32_gettid +TRACE_SYSCALL_TABLE(gettid, gettid, 4222, 0) +#endif +#ifndef OVERRIDE_TABLE_32_restart_syscall +TRACE_SYSCALL_TABLE(restart_syscall, restart_syscall, 4253, 0) +#endif +#ifndef OVERRIDE_TABLE_32_inotify_init +TRACE_SYSCALL_TABLE(inotify_init, inotify_init, 4284, 0) +#endif +#endif /* else #ifdef SC_ENTER */ +#ifndef OVERRIDE_TABLE_32_exit +TRACE_SYSCALL_TABLE(exit, exit, 4001, 1) +#endif +#ifndef OVERRIDE_TABLE_32_close +TRACE_SYSCALL_TABLE(close, close, 4006, 1) +#endif +#ifndef OVERRIDE_TABLE_32_lseek +TRACE_SYSCALL_TABLE(lseek, lseek, 4019, 3) +#endif +#ifndef OVERRIDE_TABLE_32_setuid +TRACE_SYSCALL_TABLE(setuid, setuid, 4023, 1) +#endif +#ifndef OVERRIDE_TABLE_32_ptrace +TRACE_SYSCALL_TABLE(ptrace, ptrace, 4026, 4) +#endif +#ifndef OVERRIDE_TABLE_32_alarm +TRACE_SYSCALL_TABLE(alarm, alarm, 4027, 1) +#endif +#ifndef OVERRIDE_TABLE_32_nice +TRACE_SYSCALL_TABLE(nice, nice, 4034, 1) +#endif +#ifndef OVERRIDE_TABLE_32_kill +TRACE_SYSCALL_TABLE(kill, kill, 4037, 2) +#endif +#ifndef OVERRIDE_TABLE_32_dup +TRACE_SYSCALL_TABLE(dup, dup, 4041, 1) +#endif +#ifndef OVERRIDE_TABLE_32_brk +TRACE_SYSCALL_TABLE(brk, brk, 4045, 1) +#endif +#ifndef OVERRIDE_TABLE_32_setgid +TRACE_SYSCALL_TABLE(setgid, setgid, 4046, 1) +#endif +#ifndef OVERRIDE_TABLE_32_ioctl +TRACE_SYSCALL_TABLE(ioctl, ioctl, 4054, 3) +#endif +#ifndef OVERRIDE_TABLE_32_fcntl +TRACE_SYSCALL_TABLE(fcntl, fcntl, 4055, 3) +#endif +#ifndef OVERRIDE_TABLE_32_setpgid +TRACE_SYSCALL_TABLE(setpgid, setpgid, 4057, 2) +#endif +#ifndef OVERRIDE_TABLE_32_umask +TRACE_SYSCALL_TABLE(umask, umask, 4060, 1) +#endif +#ifndef OVERRIDE_TABLE_32_dup2 +TRACE_SYSCALL_TABLE(dup2, dup2, 4063, 2) +#endif +#ifndef OVERRIDE_TABLE_32_setreuid +TRACE_SYSCALL_TABLE(setreuid, setreuid, 4070, 2) +#endif +#ifndef OVERRIDE_TABLE_32_setregid +TRACE_SYSCALL_TABLE(setregid, setregid, 4071, 2) +#endif +#ifndef OVERRIDE_TABLE_32_mmap +TRACE_SYSCALL_TABLE(mmap, mmap, 4090, 6) +#endif +#ifndef OVERRIDE_TABLE_32_munmap +TRACE_SYSCALL_TABLE(munmap, munmap, 4091, 2) +#endif +#ifndef OVERRIDE_TABLE_32_ftruncate +TRACE_SYSCALL_TABLE(ftruncate, ftruncate, 4093, 2) +#endif +#ifndef OVERRIDE_TABLE_32_fchmod +TRACE_SYSCALL_TABLE(fchmod, fchmod, 4094, 2) +#endif +#ifndef OVERRIDE_TABLE_32_fchown +TRACE_SYSCALL_TABLE(fchown, fchown, 4095, 3) +#endif +#ifndef OVERRIDE_TABLE_32_getpriority +TRACE_SYSCALL_TABLE(getpriority, getpriority, 4096, 2) +#endif +#ifndef OVERRIDE_TABLE_32_setpriority +TRACE_SYSCALL_TABLE(setpriority, setpriority, 4097, 3) +#endif +#ifndef OVERRIDE_TABLE_32_fsync +TRACE_SYSCALL_TABLE(fsync, fsync, 4118, 1) +#endif +#ifndef OVERRIDE_TABLE_32_mprotect +TRACE_SYSCALL_TABLE(mprotect, mprotect, 4125, 3) +#endif +#ifndef OVERRIDE_TABLE_32_getpgid +TRACE_SYSCALL_TABLE(getpgid, getpgid, 4132, 1) +#endif +#ifndef OVERRIDE_TABLE_32_fchdir +TRACE_SYSCALL_TABLE(fchdir, fchdir, 4133, 1) +#endif +#ifndef OVERRIDE_TABLE_32_bdflush +TRACE_SYSCALL_TABLE(bdflush, bdflush, 4134, 2) +#endif +#ifndef OVERRIDE_TABLE_32_personality +TRACE_SYSCALL_TABLE(personality, personality, 4136, 1) +#endif +#ifndef OVERRIDE_TABLE_32_setfsuid +TRACE_SYSCALL_TABLE(setfsuid, setfsuid, 4138, 1) +#endif +#ifndef OVERRIDE_TABLE_32_setfsgid +TRACE_SYSCALL_TABLE(setfsgid, setfsgid, 4139, 1) +#endif +#ifndef OVERRIDE_TABLE_32_flock +TRACE_SYSCALL_TABLE(flock, flock, 4143, 2) +#endif +#ifndef OVERRIDE_TABLE_32_msync +TRACE_SYSCALL_TABLE(msync, msync, 4144, 3) +#endif +#ifndef OVERRIDE_TABLE_32_cacheflush +TRACE_SYSCALL_TABLE(cacheflush, cacheflush, 4147, 3) +#endif +#ifndef OVERRIDE_TABLE_32_sysmips +TRACE_SYSCALL_TABLE(sysmips, sysmips, 4149, 3) +#endif +#ifndef OVERRIDE_TABLE_32_getsid +TRACE_SYSCALL_TABLE(getsid, getsid, 4151, 1) +#endif +#ifndef OVERRIDE_TABLE_32_fdatasync +TRACE_SYSCALL_TABLE(fdatasync, fdatasync, 4152, 1) +#endif +#ifndef OVERRIDE_TABLE_32_mlock +TRACE_SYSCALL_TABLE(mlock, mlock, 4154, 2) +#endif +#ifndef OVERRIDE_TABLE_32_munlock +TRACE_SYSCALL_TABLE(munlock, munlock, 4155, 2) +#endif +#ifndef OVERRIDE_TABLE_32_mlockall +TRACE_SYSCALL_TABLE(mlockall, mlockall, 4156, 1) +#endif +#ifndef OVERRIDE_TABLE_32_sched_getscheduler +TRACE_SYSCALL_TABLE(sched_getscheduler, sched_getscheduler, 4161, 1) +#endif +#ifndef OVERRIDE_TABLE_32_sched_get_priority_max +TRACE_SYSCALL_TABLE(sched_get_priority_max, sched_get_priority_max, 4163, 1) +#endif +#ifndef OVERRIDE_TABLE_32_sched_get_priority_min +TRACE_SYSCALL_TABLE(sched_get_priority_min, sched_get_priority_min, 4164, 1) +#endif +#ifndef OVERRIDE_TABLE_32_mremap +TRACE_SYSCALL_TABLE(mremap, mremap, 4167, 5) +#endif +#ifndef OVERRIDE_TABLE_32_listen +TRACE_SYSCALL_TABLE(listen, listen, 4174, 2) +#endif +#ifndef OVERRIDE_TABLE_32_shutdown +TRACE_SYSCALL_TABLE(shutdown, shutdown, 4182, 2) +#endif +#ifndef OVERRIDE_TABLE_32_socket +TRACE_SYSCALL_TABLE(socket, socket, 4183, 3) +#endif +#ifndef OVERRIDE_TABLE_32_setresuid +TRACE_SYSCALL_TABLE(setresuid, setresuid, 4185, 3) +#endif +#ifndef OVERRIDE_TABLE_32_setresgid +TRACE_SYSCALL_TABLE(setresgid, setresgid, 4190, 3) +#endif +#ifndef OVERRIDE_TABLE_32_prctl +TRACE_SYSCALL_TABLE(prctl, prctl, 4192, 5) +#endif +#ifndef OVERRIDE_TABLE_32_mips_mmap2 +TRACE_SYSCALL_TABLE(mips_mmap2, mips_mmap2, 4210, 6) +#endif +#ifndef OVERRIDE_TABLE_32_ftruncate64 +TRACE_SYSCALL_TABLE(ftruncate64, ftruncate64, 4212, 2) +#endif +#ifndef OVERRIDE_TABLE_32_madvise +TRACE_SYSCALL_TABLE(madvise, madvise, 4218, 3) +#endif +#ifndef OVERRIDE_TABLE_32_fcntl64 +TRACE_SYSCALL_TABLE(fcntl64, fcntl64, 4220, 3) +#endif +#ifndef OVERRIDE_TABLE_32_readahead +TRACE_SYSCALL_TABLE(readahead, readahead, 4223, 3) +#endif +#ifndef OVERRIDE_TABLE_32_tkill +TRACE_SYSCALL_TABLE(tkill, tkill, 4236, 2) +#endif +#ifndef OVERRIDE_TABLE_32_io_destroy +TRACE_SYSCALL_TABLE(io_destroy, io_destroy, 4242, 1) +#endif +#ifndef OVERRIDE_TABLE_32_exit_group +TRACE_SYSCALL_TABLE(exit_group, exit_group, 4246, 1) +#endif +#ifndef OVERRIDE_TABLE_32_epoll_create +TRACE_SYSCALL_TABLE(epoll_create, epoll_create, 4248, 1) +#endif +#ifndef OVERRIDE_TABLE_32_remap_file_pages +TRACE_SYSCALL_TABLE(remap_file_pages, remap_file_pages, 4251, 5) +#endif +#ifndef OVERRIDE_TABLE_32_fadvise64_64 +TRACE_SYSCALL_TABLE(fadvise64_64, fadvise64_64, 4254, 4) +#endif +#ifndef OVERRIDE_TABLE_32_timer_getoverrun +TRACE_SYSCALL_TABLE(timer_getoverrun, timer_getoverrun, 4260, 1) +#endif +#ifndef OVERRIDE_TABLE_32_timer_delete +TRACE_SYSCALL_TABLE(timer_delete, timer_delete, 4261, 1) +#endif +#ifndef OVERRIDE_TABLE_32_tgkill +TRACE_SYSCALL_TABLE(tgkill, tgkill, 4266, 3) +#endif +#ifndef OVERRIDE_TABLE_32_set_thread_area +TRACE_SYSCALL_TABLE(set_thread_area, set_thread_area, 4283, 1) +#endif +#ifndef OVERRIDE_TABLE_32_inotify_rm_watch +TRACE_SYSCALL_TABLE(inotify_rm_watch, inotify_rm_watch, 4286, 2) +#endif +#ifndef OVERRIDE_TABLE_32_unshare +TRACE_SYSCALL_TABLE(unshare, unshare, 4303, 1) +#endif +#ifndef OVERRIDE_TABLE_32_sync_file_range +TRACE_SYSCALL_TABLE(sync_file_range, sync_file_range, 4305, 4) +#endif +#ifndef OVERRIDE_TABLE_32_tee +TRACE_SYSCALL_TABLE(tee, tee, 4306, 4) +#endif +#ifndef OVERRIDE_TABLE_32_ioprio_set +TRACE_SYSCALL_TABLE(ioprio_set, ioprio_set, 4314, 3) +#endif +#ifndef OVERRIDE_TABLE_32_ioprio_get +TRACE_SYSCALL_TABLE(ioprio_get, ioprio_get, 4315, 2) +#endif +#ifndef OVERRIDE_TABLE_32_eventfd +TRACE_SYSCALL_TABLE(eventfd, eventfd, 4319, 1) +#endif +#ifndef OVERRIDE_TABLE_32_fallocate +TRACE_SYSCALL_TABLE(fallocate, fallocate, 4320, 4) +#endif +#ifndef OVERRIDE_TABLE_32_timerfd_create +TRACE_SYSCALL_TABLE(timerfd_create, timerfd_create, 4321, 2) +#endif +#ifndef OVERRIDE_TABLE_32_eventfd2 +TRACE_SYSCALL_TABLE(eventfd2, eventfd2, 4325, 2) +#endif +#ifndef OVERRIDE_TABLE_32_epoll_create1 +TRACE_SYSCALL_TABLE(epoll_create1, epoll_create1, 4326, 1) +#endif +#ifndef OVERRIDE_TABLE_32_dup3 +TRACE_SYSCALL_TABLE(dup3, dup3, 4327, 3) +#endif +#ifndef OVERRIDE_TABLE_32_inotify_init1 +TRACE_SYSCALL_TABLE(inotify_init1, inotify_init1, 4329, 1) +#endif +#ifndef OVERRIDE_TABLE_32_syncfs +TRACE_SYSCALL_TABLE(syncfs, syncfs, 4342, 1) +#endif +#ifndef OVERRIDE_TABLE_32_setns +TRACE_SYSCALL_TABLE(setns, setns, 4344, 2) +#endif + +#endif /* CREATE_SYSCALL_TABLE */ diff --git a/include/instrumentation/syscalls/headers/mips-32-syscalls_integers_override.h b/include/instrumentation/syscalls/headers/mips-32-syscalls_integers_override.h new file mode 100644 index 00000000..64021873 --- /dev/null +++ b/include/instrumentation/syscalls/headers/mips-32-syscalls_integers_override.h @@ -0,0 +1,5 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ + +/* + * this is a place-holder for MIPS integer syscall definition override. + */ diff --git a/include/instrumentation/syscalls/headers/mips-32-syscalls_pointers.h b/include/instrumentation/syscalls/headers/mips-32-syscalls_pointers.h new file mode 100644 index 00000000..e2cd9604 --- /dev/null +++ b/include/instrumentation/syscalls/headers/mips-32-syscalls_pointers.h @@ -0,0 +1,1899 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ + +/* THIS FILE IS AUTO-GENERATED. DO NOT EDIT */ + +/* Generated from mips-32-syscalls 3.18.0 */ + +#ifndef CREATE_SYSCALL_TABLE + +#if !defined(_TRACE_SYSCALLS_POINTERS_H) || defined(TRACE_HEADER_MULTI_READ) +#define _TRACE_SYSCALLS_POINTERS_H + +#include +#include +#include "mips-32-syscalls_pointers_override.h" +#include "syscalls_pointers_override.h" + +#ifndef OVERRIDE_32_unlink +SC_LTTNG_TRACEPOINT_EVENT(unlink, + TP_PROTO(sc_exit(long ret,) const char * pathname), + TP_ARGS(sc_exit(ret,) pathname), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname))) +) +#endif +#ifndef OVERRIDE_32_chdir +SC_LTTNG_TRACEPOINT_EVENT(chdir, + TP_PROTO(sc_exit(long ret,) const char * filename), + TP_ARGS(sc_exit(ret,) filename), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename))) +) +#endif +#ifndef OVERRIDE_32_time +SC_LTTNG_TRACEPOINT_EVENT(time, + TP_PROTO(sc_exit(long ret,) time_t * tloc), + TP_ARGS(sc_exit(ret,) tloc), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(time_t *, tloc, tloc))) +) +#endif +#ifndef OVERRIDE_32_oldumount +SC_LTTNG_TRACEPOINT_EVENT(oldumount, + TP_PROTO(sc_exit(long ret,) char * name), + TP_ARGS(sc_exit(ret,) name), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(name, name))) +) +#endif +#ifndef OVERRIDE_32_stime +SC_LTTNG_TRACEPOINT_EVENT(stime, + TP_PROTO(sc_exit(long ret,) time_t * tptr), + TP_ARGS(sc_exit(ret,) tptr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(time_t *, tptr, tptr))) +) +#endif +#ifndef OVERRIDE_32_rmdir +SC_LTTNG_TRACEPOINT_EVENT(rmdir, + TP_PROTO(sc_exit(long ret,) const char * pathname), + TP_ARGS(sc_exit(ret,) pathname), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname))) +) +#endif +#ifndef OVERRIDE_32_times +SC_LTTNG_TRACEPOINT_EVENT(times, + TP_PROTO(sc_exit(long ret,) struct tms * tbuf), + TP_ARGS(sc_exit(ret,) tbuf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct tms *, tbuf, tbuf))) +) +#endif +#ifndef OVERRIDE_32_olduname +SC_LTTNG_TRACEPOINT_EVENT(olduname, + TP_PROTO(sc_exit(long ret,) struct oldold_utsname * name), + TP_ARGS(sc_exit(ret,) name), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct oldold_utsname *, name, name))) +) +#endif +#ifndef OVERRIDE_32_chroot +SC_LTTNG_TRACEPOINT_EVENT(chroot, + TP_PROTO(sc_exit(long ret,) const char * filename), + TP_ARGS(sc_exit(ret,) filename), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename))) +) +#endif +#ifndef OVERRIDE_32_sigsuspend +SC_LTTNG_TRACEPOINT_EVENT(sigsuspend, + TP_PROTO(sc_exit(long ret,) sigset_t * uset), + TP_ARGS(sc_exit(ret,) uset), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(sigset_t *, uset, uset))) +) +#endif +#ifndef OVERRIDE_32_sigpending +SC_LTTNG_TRACEPOINT_EVENT(sigpending, + TP_PROTO(sc_exit(long ret,) old_sigset_t * set), + TP_ARGS(sc_exit(ret,) set), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(old_sigset_t *, set, set))) +) +#endif +#ifndef OVERRIDE_32_uname +SC_LTTNG_TRACEPOINT_EVENT(uname, + TP_PROTO(sc_exit(long ret,) struct old_utsname * name), + TP_ARGS(sc_exit(ret,) name), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct old_utsname *, name, name))) +) +#endif +#ifndef OVERRIDE_32_sysinfo +SC_LTTNG_TRACEPOINT_EVENT(sysinfo, + TP_PROTO(sc_exit(long ret,) struct sysinfo * info), + TP_ARGS(sc_exit(ret,) info), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct sysinfo *, info, info))) +) +#endif +#ifndef OVERRIDE_32_newuname +SC_LTTNG_TRACEPOINT_EVENT(newuname, + TP_PROTO(sc_exit(long ret,) struct new_utsname * name), + TP_ARGS(sc_exit(ret,) name), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct new_utsname *, name, name))) +) +#endif +#ifndef OVERRIDE_32_adjtimex +SC_LTTNG_TRACEPOINT_EVENT(adjtimex, + TP_PROTO(sc_exit(long ret,) struct timex * txc_p), + TP_ARGS(sc_exit(ret,) txc_p), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct timex *, txc_p, txc_p))) +) +#endif +#ifndef OVERRIDE_32_sysctl +SC_LTTNG_TRACEPOINT_EVENT(sysctl, + TP_PROTO(sc_exit(long ret,) struct __sysctl_args * args), + TP_ARGS(sc_exit(ret,) args), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct __sysctl_args *, args, args))) +) +#endif +#ifndef OVERRIDE_32_set_tid_address +SC_LTTNG_TRACEPOINT_EVENT(set_tid_address, + TP_PROTO(sc_exit(long ret,) int * tidptr), + TP_ARGS(sc_exit(ret,) tidptr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int *, tidptr, tidptr))) +) +#endif +#ifndef OVERRIDE_32_creat +SC_LTTNG_TRACEPOINT_EVENT(creat, + TP_PROTO(sc_exit(long ret,) const char * pathname, umode_t mode), + TP_ARGS(sc_exit(ret,) pathname, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(umode_t, mode, mode))) +) +#endif +#ifndef OVERRIDE_32_link +SC_LTTNG_TRACEPOINT_EVENT(link, + TP_PROTO(sc_exit(long ret,) const char * oldname, const char * newname), + TP_ARGS(sc_exit(ret,) oldname, newname), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_user_string(newname, newname))) +) +#endif +#ifndef OVERRIDE_32_chmod +SC_LTTNG_TRACEPOINT_EVENT(chmod, + TP_PROTO(sc_exit(long ret,) const char * filename, umode_t mode), + TP_ARGS(sc_exit(ret,) filename, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(umode_t, mode, mode))) +) +#endif +#ifndef OVERRIDE_32_utime +SC_LTTNG_TRACEPOINT_EVENT(utime, + TP_PROTO(sc_exit(long ret,) char * filename, struct utimbuf * times), + TP_ARGS(sc_exit(ret,) filename, times), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(struct utimbuf *, times, times))) +) +#endif +#ifndef OVERRIDE_32_access +SC_LTTNG_TRACEPOINT_EVENT(access, + TP_PROTO(sc_exit(long ret,) const char * filename, int mode), + TP_ARGS(sc_exit(ret,) filename, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, mode, mode))) +) +#endif +#ifndef OVERRIDE_32_rename +SC_LTTNG_TRACEPOINT_EVENT(rename, + TP_PROTO(sc_exit(long ret,) const char * oldname, const char * newname), + TP_ARGS(sc_exit(ret,) oldname, newname), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_user_string(newname, newname))) +) +#endif +#ifndef OVERRIDE_32_mkdir +SC_LTTNG_TRACEPOINT_EVENT(mkdir, + TP_PROTO(sc_exit(long ret,) const char * pathname, umode_t mode), + TP_ARGS(sc_exit(ret,) pathname, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(umode_t, mode, mode))) +) +#endif +#ifndef OVERRIDE_32_umount +SC_LTTNG_TRACEPOINT_EVENT(umount, + TP_PROTO(sc_exit(long ret,) char * name, int flags), + TP_ARGS(sc_exit(ret,) name, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_ustat +SC_LTTNG_TRACEPOINT_EVENT(ustat, + TP_PROTO(sc_exit(long ret,) unsigned dev, struct ustat * ubuf), + TP_ARGS(sc_exit(ret,) dev, ubuf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned, dev, dev)) sc_out(ctf_integer(struct ustat *, ubuf, ubuf))) +) +#endif +#ifndef OVERRIDE_32_sethostname +SC_LTTNG_TRACEPOINT_EVENT(sethostname, + TP_PROTO(sc_exit(long ret,) char * name, int len), + TP_ARGS(sc_exit(ret,) name, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(int, len, len))) +) +#endif +#ifndef OVERRIDE_32_setrlimit +SC_LTTNG_TRACEPOINT_EVENT(setrlimit, + TP_PROTO(sc_exit(long ret,) unsigned int resource, struct rlimit * rlim), + TP_ARGS(sc_exit(ret,) resource, rlim), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, resource, resource)) sc_in(ctf_integer(struct rlimit *, rlim, rlim))) +) +#endif +#ifndef OVERRIDE_32_getrlimit +SC_LTTNG_TRACEPOINT_EVENT(getrlimit, + TP_PROTO(sc_exit(long ret,) unsigned int resource, struct rlimit * rlim), + TP_ARGS(sc_exit(ret,) resource, rlim), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, resource, resource)) sc_out(ctf_integer(struct rlimit *, rlim, rlim))) +) +#endif +#ifndef OVERRIDE_32_getrusage +SC_LTTNG_TRACEPOINT_EVENT(getrusage, + TP_PROTO(sc_exit(long ret,) int who, struct rusage * ru), + TP_ARGS(sc_exit(ret,) who, ru), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, who, who)) sc_out(ctf_integer(struct rusage *, ru, ru))) +) +#endif +#ifndef OVERRIDE_32_gettimeofday +SC_LTTNG_TRACEPOINT_EVENT(gettimeofday, + TP_PROTO(sc_exit(long ret,) struct timeval * tv, struct timezone * tz), + TP_ARGS(sc_exit(ret,) tv, tz), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct timeval *, tv, tv)) sc_out(ctf_integer(struct timezone *, tz, tz))) +) +#endif +#ifndef OVERRIDE_32_settimeofday +SC_LTTNG_TRACEPOINT_EVENT(settimeofday, + TP_PROTO(sc_exit(long ret,) struct timeval * tv, struct timezone * tz), + TP_ARGS(sc_exit(ret,) tv, tz), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct timeval *, tv, tv)) sc_in(ctf_integer(struct timezone *, tz, tz))) +) +#endif +#ifndef OVERRIDE_32_getgroups +SC_LTTNG_TRACEPOINT_EVENT(getgroups, + TP_PROTO(sc_exit(long ret,) int gidsetsize, gid_t * grouplist), + TP_ARGS(sc_exit(ret,) gidsetsize, grouplist), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, gidsetsize, gidsetsize)) sc_out(ctf_integer(gid_t *, grouplist, grouplist))) +) +#endif +#ifndef OVERRIDE_32_setgroups +SC_LTTNG_TRACEPOINT_EVENT(setgroups, + TP_PROTO(sc_exit(long ret,) int gidsetsize, gid_t * grouplist), + TP_ARGS(sc_exit(ret,) gidsetsize, grouplist), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, gidsetsize, gidsetsize)) sc_in(ctf_integer(gid_t *, grouplist, grouplist))) +) +#endif +#ifndef OVERRIDE_32_symlink +SC_LTTNG_TRACEPOINT_EVENT(symlink, + TP_PROTO(sc_exit(long ret,) const char * oldname, const char * newname), + TP_ARGS(sc_exit(ret,) oldname, newname), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_user_string(newname, newname))) +) +#endif +#ifndef OVERRIDE_32_truncate +SC_LTTNG_TRACEPOINT_EVENT(truncate, + TP_PROTO(sc_exit(long ret,) const char * path, long length), + TP_ARGS(sc_exit(ret,) path, length), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(path, path)) sc_in(ctf_integer(long, length, length))) +) +#endif +#ifndef OVERRIDE_32_statfs +SC_LTTNG_TRACEPOINT_EVENT(statfs, + TP_PROTO(sc_exit(long ret,) const char * pathname, struct statfs * buf), + TP_ARGS(sc_exit(ret,) pathname, buf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(struct statfs *, buf, buf))) +) +#endif +#ifndef OVERRIDE_32_fstatfs +SC_LTTNG_TRACEPOINT_EVENT(fstatfs, + TP_PROTO(sc_exit(long ret,) unsigned int fd, struct statfs * buf), + TP_ARGS(sc_exit(ret,) fd, buf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct statfs *, buf, buf))) +) +#endif +#ifndef OVERRIDE_32_socketcall +SC_LTTNG_TRACEPOINT_EVENT(socketcall, + TP_PROTO(sc_exit(long ret,) int call, unsigned long * args), + TP_ARGS(sc_exit(ret,) call, args), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, call, call)) sc_inout(ctf_integer(unsigned long *, args, args))) +) +#endif +#ifndef OVERRIDE_32_getitimer +SC_LTTNG_TRACEPOINT_EVENT(getitimer, + TP_PROTO(sc_exit(long ret,) int which, struct itimerval * value), + TP_ARGS(sc_exit(ret,) which, value), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_out(ctf_integer(struct itimerval *, value, value))) +) +#endif +#ifndef OVERRIDE_32_newstat +SC_LTTNG_TRACEPOINT_EVENT(newstat, + TP_PROTO(sc_exit(long ret,) const char * filename, struct stat * statbuf), + TP_ARGS(sc_exit(ret,) filename, statbuf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_out(ctf_integer(struct stat *, statbuf, statbuf))) +) +#endif +#ifndef OVERRIDE_32_newlstat +SC_LTTNG_TRACEPOINT_EVENT(newlstat, + TP_PROTO(sc_exit(long ret,) const char * filename, struct stat * statbuf), + TP_ARGS(sc_exit(ret,) filename, statbuf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_out(ctf_integer(struct stat *, statbuf, statbuf))) +) +#endif +#ifndef OVERRIDE_32_newfstat +SC_LTTNG_TRACEPOINT_EVENT(newfstat, + TP_PROTO(sc_exit(long ret,) unsigned int fd, struct stat * statbuf), + TP_ARGS(sc_exit(ret,) fd, statbuf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct stat *, statbuf, statbuf))) +) +#endif +#ifndef OVERRIDE_32_setdomainname +SC_LTTNG_TRACEPOINT_EVENT(setdomainname, + TP_PROTO(sc_exit(long ret,) char * name, int len), + TP_ARGS(sc_exit(ret,) name, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(int, len, len))) +) +#endif +#ifndef OVERRIDE_32_delete_module +SC_LTTNG_TRACEPOINT_EVENT(delete_module, + TP_PROTO(sc_exit(long ret,) const char * name_user, unsigned int flags), + TP_ARGS(sc_exit(ret,) name_user, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name_user, name_user)) sc_in(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_sched_setparam +SC_LTTNG_TRACEPOINT_EVENT(sched_setparam, + TP_PROTO(sc_exit(long ret,) pid_t pid, struct sched_param * param), + TP_ARGS(sc_exit(ret,) pid, param), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(struct sched_param *, param, param))) +) +#endif +#ifndef OVERRIDE_32_sched_getparam +SC_LTTNG_TRACEPOINT_EVENT(sched_getparam, + TP_PROTO(sc_exit(long ret,) pid_t pid, struct sched_param * param), + TP_ARGS(sc_exit(ret,) pid, param), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_out(ctf_integer(struct sched_param *, param, param))) +) +#endif +#ifndef OVERRIDE_32_sched_rr_get_interval +SC_LTTNG_TRACEPOINT_EVENT(sched_rr_get_interval, + TP_PROTO(sc_exit(long ret,) pid_t pid, struct timespec * interval), + TP_ARGS(sc_exit(ret,) pid, interval), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_out(ctf_integer(struct timespec *, interval, interval))) +) +#endif +#ifndef OVERRIDE_32_nanosleep +SC_LTTNG_TRACEPOINT_EVENT(nanosleep, + TP_PROTO(sc_exit(long ret,) struct timespec * rqtp, struct timespec * rmtp), + TP_ARGS(sc_exit(ret,) rqtp, rmtp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct timespec *, rqtp, rqtp)) sc_out(ctf_integer(struct timespec *, rmtp, rmtp))) +) +#endif +#ifndef OVERRIDE_32_rt_sigpending +SC_LTTNG_TRACEPOINT_EVENT(rt_sigpending, + TP_PROTO(sc_exit(long ret,) sigset_t * uset, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) uset, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(sigset_t *, uset, uset)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) +) +#endif +#ifndef OVERRIDE_32_rt_sigsuspend +SC_LTTNG_TRACEPOINT_EVENT(rt_sigsuspend, + TP_PROTO(sc_exit(long ret,) sigset_t * unewset, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) unewset, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(sigset_t *, unewset, unewset)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) +) +#endif +#ifndef OVERRIDE_32_getcwd +SC_LTTNG_TRACEPOINT_EVENT(getcwd, + TP_PROTO(sc_exit(long ret,) char * buf, unsigned long size), + TP_ARGS(sc_exit(ret,) buf, size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(unsigned long, size, size))) +) +#endif +#ifndef OVERRIDE_32_sigaltstack +SC_LTTNG_TRACEPOINT_EVENT(sigaltstack, + TP_PROTO(sc_exit(long ret,) const stack_t * uss, stack_t * uoss), + TP_ARGS(sc_exit(ret,) uss, uoss), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const stack_t *, uss, uss)) sc_inout(ctf_integer(stack_t *, uoss, uoss))) +) +#endif +#ifndef OVERRIDE_32_truncate64 +SC_LTTNG_TRACEPOINT_EVENT(truncate64, + TP_PROTO(sc_exit(long ret,) const char * path, loff_t length), + TP_ARGS(sc_exit(ret,) path, length), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(path, path)) sc_inout(ctf_integer(loff_t, length, length))) +) +#endif +#ifndef OVERRIDE_32_stat64 +SC_LTTNG_TRACEPOINT_EVENT(stat64, + TP_PROTO(sc_exit(long ret,) const char * filename, struct stat64 * statbuf), + TP_ARGS(sc_exit(ret,) filename, statbuf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(filename, filename)) sc_inout(ctf_integer(struct stat64 *, statbuf, statbuf))) +) +#endif +#ifndef OVERRIDE_32_lstat64 +SC_LTTNG_TRACEPOINT_EVENT(lstat64, + TP_PROTO(sc_exit(long ret,) const char * filename, struct stat64 * statbuf), + TP_ARGS(sc_exit(ret,) filename, statbuf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(filename, filename)) sc_inout(ctf_integer(struct stat64 *, statbuf, statbuf))) +) +#endif +#ifndef OVERRIDE_32_fstat64 +SC_LTTNG_TRACEPOINT_EVENT(fstat64, + TP_PROTO(sc_exit(long ret,) unsigned long fd, struct stat64 * statbuf), + TP_ARGS(sc_exit(ret,) fd, statbuf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned long, fd, fd)) sc_inout(ctf_integer(struct stat64 *, statbuf, statbuf))) +) +#endif +#ifndef OVERRIDE_32_pivot_root +SC_LTTNG_TRACEPOINT_EVENT(pivot_root, + TP_PROTO(sc_exit(long ret,) const char * new_root, const char * put_old), + TP_ARGS(sc_exit(ret,) new_root, put_old), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(new_root, new_root)) sc_in(ctf_user_string(put_old, put_old))) +) +#endif +#ifndef OVERRIDE_32_removexattr +SC_LTTNG_TRACEPOINT_EVENT(removexattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name), + TP_ARGS(sc_exit(ret,) pathname, name), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name))) +) +#endif +#ifndef OVERRIDE_32_lremovexattr +SC_LTTNG_TRACEPOINT_EVENT(lremovexattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name), + TP_ARGS(sc_exit(ret,) pathname, name), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name))) +) +#endif +#ifndef OVERRIDE_32_fremovexattr +SC_LTTNG_TRACEPOINT_EVENT(fremovexattr, + TP_PROTO(sc_exit(long ret,) int fd, const char * name), + TP_ARGS(sc_exit(ret,) fd, name), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(name, name))) +) +#endif +#ifndef OVERRIDE_32_io_setup +SC_LTTNG_TRACEPOINT_EVENT(io_setup, + TP_PROTO(sc_exit(long ret,) unsigned nr_events, aio_context_t * ctxp), + TP_ARGS(sc_exit(ret,) nr_events, ctxp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned, nr_events, nr_events)) sc_in(ctf_integer(aio_context_t *, ctxp, ctxp))) +) +#endif +#ifndef OVERRIDE_32_timer_gettime +SC_LTTNG_TRACEPOINT_EVENT(timer_gettime, + TP_PROTO(sc_exit(long ret,) timer_t timer_id, struct itimerspec * setting), + TP_ARGS(sc_exit(ret,) timer_id, setting), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id)) sc_out(ctf_integer(struct itimerspec *, setting, setting))) +) +#endif +#ifndef OVERRIDE_32_clock_settime +SC_LTTNG_TRACEPOINT_EVENT(clock_settime, + TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, const struct timespec * tp), + TP_ARGS(sc_exit(ret,) which_clock, tp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_in(ctf_integer(const struct timespec *, tp, tp))) +) +#endif +#ifndef OVERRIDE_32_clock_gettime +SC_LTTNG_TRACEPOINT_EVENT(clock_gettime, + TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct timespec * tp), + TP_ARGS(sc_exit(ret,) which_clock, tp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_out(ctf_integer(struct timespec *, tp, tp))) +) +#endif +#ifndef OVERRIDE_32_clock_getres +SC_LTTNG_TRACEPOINT_EVENT(clock_getres, + TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct timespec * tp), + TP_ARGS(sc_exit(ret,) which_clock, tp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_out(ctf_integer(struct timespec *, tp, tp))) +) +#endif +#ifndef OVERRIDE_32_utimes +SC_LTTNG_TRACEPOINT_EVENT(utimes, + TP_PROTO(sc_exit(long ret,) char * filename, struct timeval * utimes), + TP_ARGS(sc_exit(ret,) filename, utimes), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(struct timeval *, utimes, utimes))) +) +#endif +#ifndef OVERRIDE_32_set_robust_list +SC_LTTNG_TRACEPOINT_EVENT(set_robust_list, + TP_PROTO(sc_exit(long ret,) struct robust_list_head * head, size_t len), + TP_ARGS(sc_exit(ret,) head, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct robust_list_head *, head, head)) sc_in(ctf_integer(size_t, len, len))) +) +#endif +#ifndef OVERRIDE_32_timerfd_gettime +SC_LTTNG_TRACEPOINT_EVENT(timerfd_gettime, + TP_PROTO(sc_exit(long ret,) int ufd, struct itimerspec * otmr), + TP_ARGS(sc_exit(ret,) ufd, otmr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_out(ctf_integer(struct itimerspec *, otmr, otmr))) +) +#endif +#ifndef OVERRIDE_32_pipe2 +SC_LTTNG_TRACEPOINT_EVENT(pipe2, + TP_PROTO(sc_exit(long ret,) int * fildes, int flags), + TP_ARGS(sc_exit(ret,) fildes, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(int *, fildes, fildes)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_clock_adjtime +SC_LTTNG_TRACEPOINT_EVENT(clock_adjtime, + TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct timex * utx), + TP_ARGS(sc_exit(ret,) which_clock, utx), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_inout(ctf_integer(struct timex *, utx, utx))) +) +#endif +#ifndef OVERRIDE_32_memfd_create +SC_LTTNG_TRACEPOINT_EVENT(memfd_create, + TP_PROTO(sc_exit(long ret,) const char * uname, unsigned int flags), + TP_ARGS(sc_exit(ret,) uname, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(uname, uname)) sc_inout(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_read +SC_LTTNG_TRACEPOINT_EVENT(read, + TP_PROTO(sc_exit(long ret,) unsigned int fd, char * buf, size_t count), + TP_ARGS(sc_exit(ret,) fd, buf, count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(size_t, count, count))) +) +#endif +#ifndef OVERRIDE_32_write +SC_LTTNG_TRACEPOINT_EVENT(write, + TP_PROTO(sc_exit(long ret,) unsigned int fd, const char * buf, size_t count), + TP_ARGS(sc_exit(ret,) fd, buf, count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(const char *, buf, buf)) sc_in(ctf_integer(size_t, count, count))) +) +#endif +#ifndef OVERRIDE_32_open +SC_LTTNG_TRACEPOINT_EVENT(open, + TP_PROTO(sc_exit(long ret,) const char * filename, int flags, umode_t mode), + TP_ARGS(sc_exit(ret,) filename, flags, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(umode_t, mode, mode))) +) +#endif +#ifndef OVERRIDE_32_waitpid +SC_LTTNG_TRACEPOINT_EVENT(waitpid, + TP_PROTO(sc_exit(long ret,) pid_t pid, int * stat_addr, int options), + TP_ARGS(sc_exit(ret,) pid, stat_addr, options), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(pid_t, pid, pid)) sc_inout(ctf_integer(int *, stat_addr, stat_addr)) sc_inout(ctf_integer(int, options, options))) +) +#endif +#ifndef OVERRIDE_32_execve +SC_LTTNG_TRACEPOINT_EVENT(execve, + TP_PROTO(sc_exit(long ret,) const char * filename, const char *const * argv, const char *const * envp), + TP_ARGS(sc_exit(ret,) filename, argv, envp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(filename, filename)) sc_inout(ctf_integer(const char *const *, argv, argv)) sc_inout(ctf_integer(const char *const *, envp, envp))) +) +#endif +#ifndef OVERRIDE_32_mknod +SC_LTTNG_TRACEPOINT_EVENT(mknod, + TP_PROTO(sc_exit(long ret,) const char * filename, umode_t mode, unsigned dev), + TP_ARGS(sc_exit(ret,) filename, mode, dev), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(umode_t, mode, mode)) sc_in(ctf_integer(unsigned, dev, dev))) +) +#endif +#ifndef OVERRIDE_32_lchown +SC_LTTNG_TRACEPOINT_EVENT(lchown, + TP_PROTO(sc_exit(long ret,) const char * filename, uid_t user, gid_t group), + TP_ARGS(sc_exit(ret,) filename, user, group), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group))) +) +#endif +#ifndef OVERRIDE_32_sigaction +SC_LTTNG_TRACEPOINT_EVENT(sigaction, + TP_PROTO(sc_exit(long ret,) int sig, const struct sigaction * act, struct sigaction * oact), + TP_ARGS(sc_exit(ret,) sig, act, oact), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, sig, sig)) sc_inout(ctf_integer(const struct sigaction *, act, act)) sc_inout(ctf_integer(struct sigaction *, oact, oact))) +) +#endif +#ifndef OVERRIDE_32_readlink +SC_LTTNG_TRACEPOINT_EVENT(readlink, + TP_PROTO(sc_exit(long ret,) const char * path, char * buf, int bufsiz), + TP_ARGS(sc_exit(ret,) path, buf, bufsiz), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(path, path)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(int, bufsiz, bufsiz))) +) +#endif +#ifndef OVERRIDE_32_old_readdir +SC_LTTNG_TRACEPOINT_EVENT(old_readdir, + TP_PROTO(sc_exit(long ret,) unsigned int fd, struct old_linux_dirent * dirent, unsigned int count), + TP_ARGS(sc_exit(ret,) fd, dirent, count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, fd, fd)) sc_inout(ctf_integer(struct old_linux_dirent *, dirent, dirent)) sc_inout(ctf_integer(unsigned int, count, count))) +) +#endif +#ifndef OVERRIDE_32_syslog +SC_LTTNG_TRACEPOINT_EVENT(syslog, + TP_PROTO(sc_exit(long ret,) int type, char * buf, int len), + TP_ARGS(sc_exit(ret,) type, buf, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, type, type)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(int, len, len))) +) +#endif +#ifndef OVERRIDE_32_setitimer +SC_LTTNG_TRACEPOINT_EVENT(setitimer, + TP_PROTO(sc_exit(long ret,) int which, struct itimerval * value, struct itimerval * ovalue), + TP_ARGS(sc_exit(ret,) which, value, ovalue), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(struct itimerval *, value, value)) sc_out(ctf_integer(struct itimerval *, ovalue, ovalue))) +) +#endif +#ifndef OVERRIDE_32_sigprocmask +SC_LTTNG_TRACEPOINT_EVENT(sigprocmask, + TP_PROTO(sc_exit(long ret,) int how, old_sigset_t * nset, old_sigset_t * oset), + TP_ARGS(sc_exit(ret,) how, nset, oset), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, how, how)) sc_inout(ctf_integer(old_sigset_t *, nset, nset)) sc_inout(ctf_integer(old_sigset_t *, oset, oset))) +) +#endif +#ifndef OVERRIDE_32_init_module +SC_LTTNG_TRACEPOINT_EVENT(init_module, + TP_PROTO(sc_exit(long ret,) void * umod, unsigned long len, const char * uargs), + TP_ARGS(sc_exit(ret,) umod, len, uargs), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(void *, umod, umod)) sc_in(ctf_integer(unsigned long, len, len)) sc_in(ctf_integer(const char *, uargs, uargs))) +) +#endif +#ifndef OVERRIDE_32_getdents +SC_LTTNG_TRACEPOINT_EVENT(getdents, + TP_PROTO(sc_exit(long ret,) unsigned int fd, struct linux_dirent * dirent, unsigned int count), + TP_ARGS(sc_exit(ret,) fd, dirent, count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct linux_dirent *, dirent, dirent)) sc_in(ctf_integer(unsigned int, count, count))) +) +#endif +#ifndef OVERRIDE_32_readv +SC_LTTNG_TRACEPOINT_EVENT(readv, + TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen), + TP_ARGS(sc_exit(ret,) fd, vec, vlen), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_inout(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen))) +) +#endif +#ifndef OVERRIDE_32_writev +SC_LTTNG_TRACEPOINT_EVENT(writev, + TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen), + TP_ARGS(sc_exit(ret,) fd, vec, vlen), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_inout(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen))) +) +#endif +#ifndef OVERRIDE_32_cachectl +SC_LTTNG_TRACEPOINT_EVENT(cachectl, + TP_PROTO(sc_exit(long ret,) char * addr, int nbytes, int op), + TP_ARGS(sc_exit(ret,) addr, nbytes, op), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(char *, addr, addr)) sc_inout(ctf_integer(int, nbytes, nbytes)) sc_inout(ctf_integer(int, op, op))) +) +#endif +#ifndef OVERRIDE_32_sched_setscheduler +SC_LTTNG_TRACEPOINT_EVENT(sched_setscheduler, + TP_PROTO(sc_exit(long ret,) pid_t pid, int policy, struct sched_param * param), + TP_ARGS(sc_exit(ret,) pid, policy, param), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, policy, policy)) sc_in(ctf_integer(struct sched_param *, param, param))) +) +#endif +#ifndef OVERRIDE_32_accept +SC_LTTNG_TRACEPOINT_EVENT(accept, + TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * upeer_sockaddr, int * upeer_addrlen), + TP_ARGS(sc_exit(ret,) fd, upeer_sockaddr, upeer_addrlen), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct sockaddr *, upeer_sockaddr, upeer_sockaddr)) sc_inout(ctf_integer(int *, upeer_addrlen, upeer_addrlen))) +) +#endif +#ifndef OVERRIDE_32_bind +SC_LTTNG_TRACEPOINT_EVENT(bind, + TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * umyaddr, int addrlen), + TP_ARGS(sc_exit(ret,) fd, umyaddr, addrlen), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct sockaddr *, umyaddr, umyaddr)) sc_in(ctf_integer(int, addrlen, addrlen))) +) +#endif +#ifndef OVERRIDE_32_connect +SC_LTTNG_TRACEPOINT_EVENT(connect, + TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * uservaddr, int addrlen), + TP_ARGS(sc_exit(ret,) fd, uservaddr, addrlen), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct sockaddr *, uservaddr, uservaddr)) sc_in(ctf_integer(int, addrlen, addrlen))) +) +#endif +#ifndef OVERRIDE_32_getpeername +SC_LTTNG_TRACEPOINT_EVENT(getpeername, + TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * usockaddr, int * usockaddr_len), + TP_ARGS(sc_exit(ret,) fd, usockaddr, usockaddr_len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct sockaddr *, usockaddr, usockaddr)) sc_inout(ctf_integer(int *, usockaddr_len, usockaddr_len))) +) +#endif +#ifndef OVERRIDE_32_getsockname +SC_LTTNG_TRACEPOINT_EVENT(getsockname, + TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * usockaddr, int * usockaddr_len), + TP_ARGS(sc_exit(ret,) fd, usockaddr, usockaddr_len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct sockaddr *, usockaddr, usockaddr)) sc_inout(ctf_integer(int *, usockaddr_len, usockaddr_len))) +) +#endif +#ifndef OVERRIDE_32_recvmsg +SC_LTTNG_TRACEPOINT_EVENT(recvmsg, + TP_PROTO(sc_exit(long ret,) int fd, struct msghdr * msg, unsigned int flags), + TP_ARGS(sc_exit(ret,) fd, msg, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_inout(ctf_integer(struct msghdr *, msg, msg)) sc_in(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_sendmsg +SC_LTTNG_TRACEPOINT_EVENT(sendmsg, + TP_PROTO(sc_exit(long ret,) int fd, struct msghdr * msg, unsigned int flags), + TP_ARGS(sc_exit(ret,) fd, msg, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct msghdr *, msg, msg)) sc_in(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_getresuid +SC_LTTNG_TRACEPOINT_EVENT(getresuid, + TP_PROTO(sc_exit(long ret,) uid_t * ruidp, uid_t * euidp, uid_t * suidp), + TP_ARGS(sc_exit(ret,) ruidp, euidp, suidp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(uid_t *, ruidp, ruidp)) sc_out(ctf_integer(uid_t *, euidp, euidp)) sc_out(ctf_integer(uid_t *, suidp, suidp))) +) +#endif +#ifndef OVERRIDE_32_poll +SC_LTTNG_TRACEPOINT_EVENT(poll, + TP_PROTO(sc_exit(long ret,) struct pollfd * ufds, unsigned int nfds, int timeout_msecs), + TP_ARGS(sc_exit(ret,) ufds, nfds, timeout_msecs), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct pollfd *, ufds, ufds)) sc_in(ctf_integer(unsigned int, nfds, nfds)) sc_in(ctf_integer(int, timeout_msecs, timeout_msecs))) +) +#endif +#ifndef OVERRIDE_32_getresgid +SC_LTTNG_TRACEPOINT_EVENT(getresgid, + TP_PROTO(sc_exit(long ret,) gid_t * rgidp, gid_t * egidp, gid_t * sgidp), + TP_ARGS(sc_exit(ret,) rgidp, egidp, sgidp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(gid_t *, rgidp, rgidp)) sc_out(ctf_integer(gid_t *, egidp, egidp)) sc_out(ctf_integer(gid_t *, sgidp, sgidp))) +) +#endif +#ifndef OVERRIDE_32_rt_sigqueueinfo +SC_LTTNG_TRACEPOINT_EVENT(rt_sigqueueinfo, + TP_PROTO(sc_exit(long ret,) pid_t pid, int sig, siginfo_t * uinfo), + TP_ARGS(sc_exit(ret,) pid, sig, uinfo), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig)) sc_in(ctf_integer(siginfo_t *, uinfo, uinfo))) +) +#endif +#ifndef OVERRIDE_32_chown +SC_LTTNG_TRACEPOINT_EVENT(chown, + TP_PROTO(sc_exit(long ret,) const char * filename, uid_t user, gid_t group), + TP_ARGS(sc_exit(ret,) filename, user, group), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group))) +) +#endif +#ifndef OVERRIDE_32_mincore +SC_LTTNG_TRACEPOINT_EVENT(mincore, + TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len, unsigned char * vec), + TP_ARGS(sc_exit(ret,) start, len, vec), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len)) sc_out(ctf_integer(unsigned char *, vec, vec))) +) +#endif +#ifndef OVERRIDE_32_getdents64 +SC_LTTNG_TRACEPOINT_EVENT(getdents64, + TP_PROTO(sc_exit(long ret,) unsigned int fd, struct linux_dirent64 * dirent, unsigned int count), + TP_ARGS(sc_exit(ret,) fd, dirent, count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct linux_dirent64 *, dirent, dirent)) sc_in(ctf_integer(unsigned int, count, count))) +) +#endif +#ifndef OVERRIDE_32_listxattr +SC_LTTNG_TRACEPOINT_EVENT(listxattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, char * list, size_t size), + TP_ARGS(sc_exit(ret,) pathname, list, size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(char *, list, list)) sc_in(ctf_integer(size_t, size, size))) +) +#endif +#ifndef OVERRIDE_32_llistxattr +SC_LTTNG_TRACEPOINT_EVENT(llistxattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, char * list, size_t size), + TP_ARGS(sc_exit(ret,) pathname, list, size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(char *, list, list)) sc_in(ctf_integer(size_t, size, size))) +) +#endif +#ifndef OVERRIDE_32_flistxattr +SC_LTTNG_TRACEPOINT_EVENT(flistxattr, + TP_PROTO(sc_exit(long ret,) int fd, char * list, size_t size), + TP_ARGS(sc_exit(ret,) fd, list, size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(char *, list, list)) sc_in(ctf_integer(size_t, size, size))) +) +#endif +#ifndef OVERRIDE_32_io_submit +SC_LTTNG_TRACEPOINT_EVENT(io_submit, + TP_PROTO(sc_exit(long ret,) aio_context_t ctx_id, long nr, struct iocb * * iocbpp), + TP_ARGS(sc_exit(ret,) ctx_id, nr, iocbpp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx_id, ctx_id)) sc_in(ctf_integer(long, nr, nr)) sc_in(ctf_integer(struct iocb * *, iocbpp, iocbpp))) +) +#endif +#ifndef OVERRIDE_32_io_cancel +SC_LTTNG_TRACEPOINT_EVENT(io_cancel, + TP_PROTO(sc_exit(long ret,) aio_context_t ctx_id, struct iocb * iocb, struct io_event * result), + TP_ARGS(sc_exit(ret,) ctx_id, iocb, result), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx_id, ctx_id)) sc_in(ctf_integer(struct iocb *, iocb, iocb)) sc_out(ctf_integer(struct io_event *, result, result))) +) +#endif +#ifndef OVERRIDE_32_statfs64 +SC_LTTNG_TRACEPOINT_EVENT(statfs64, + TP_PROTO(sc_exit(long ret,) const char * pathname, size_t sz, struct statfs64 * buf), + TP_ARGS(sc_exit(ret,) pathname, sz, buf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(pathname, pathname)) sc_inout(ctf_integer(size_t, sz, sz)) sc_inout(ctf_integer(struct statfs64 *, buf, buf))) +) +#endif +#ifndef OVERRIDE_32_fstatfs64 +SC_LTTNG_TRACEPOINT_EVENT(fstatfs64, + TP_PROTO(sc_exit(long ret,) unsigned int fd, size_t sz, struct statfs64 * buf), + TP_ARGS(sc_exit(ret,) fd, sz, buf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, fd, fd)) sc_inout(ctf_integer(size_t, sz, sz)) sc_inout(ctf_integer(struct statfs64 *, buf, buf))) +) +#endif +#ifndef OVERRIDE_32_timer_create +SC_LTTNG_TRACEPOINT_EVENT(timer_create, + TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct sigevent * timer_event_spec, timer_t * created_timer_id), + TP_ARGS(sc_exit(ret,) which_clock, timer_event_spec, created_timer_id), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_in(ctf_integer(struct sigevent *, timer_event_spec, timer_event_spec)) sc_out(ctf_integer(timer_t *, created_timer_id, created_timer_id))) +) +#endif +#ifndef OVERRIDE_32_inotify_add_watch +SC_LTTNG_TRACEPOINT_EVENT(inotify_add_watch, + TP_PROTO(sc_exit(long ret,) int fd, const char * pathname, u32 mask), + TP_ARGS(sc_exit(ret,) fd, pathname, mask), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(u32, mask, mask))) +) +#endif +#ifndef OVERRIDE_32_mkdirat +SC_LTTNG_TRACEPOINT_EVENT(mkdirat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * pathname, umode_t mode), + TP_ARGS(sc_exit(ret,) dfd, pathname, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(umode_t, mode, mode))) +) +#endif +#ifndef OVERRIDE_32_futimesat +SC_LTTNG_TRACEPOINT_EVENT(futimesat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, struct timeval * utimes), + TP_ARGS(sc_exit(ret,) dfd, filename, utimes), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(struct timeval *, utimes, utimes))) +) +#endif +#ifndef OVERRIDE_32_unlinkat +SC_LTTNG_TRACEPOINT_EVENT(unlinkat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * pathname, int flag), + TP_ARGS(sc_exit(ret,) dfd, pathname, flag), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(int, flag, flag))) +) +#endif +#ifndef OVERRIDE_32_symlinkat +SC_LTTNG_TRACEPOINT_EVENT(symlinkat, + TP_PROTO(sc_exit(long ret,) const char * oldname, int newdfd, const char * newname), + TP_ARGS(sc_exit(ret,) oldname, newdfd, newname), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_integer(int, newdfd, newdfd)) sc_in(ctf_user_string(newname, newname))) +) +#endif +#ifndef OVERRIDE_32_fchmodat +SC_LTTNG_TRACEPOINT_EVENT(fchmodat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, umode_t mode), + TP_ARGS(sc_exit(ret,) dfd, filename, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(umode_t, mode, mode))) +) +#endif +#ifndef OVERRIDE_32_faccessat +SC_LTTNG_TRACEPOINT_EVENT(faccessat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, int mode), + TP_ARGS(sc_exit(ret,) dfd, filename, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, mode, mode))) +) +#endif +#ifndef OVERRIDE_32_get_robust_list +SC_LTTNG_TRACEPOINT_EVENT(get_robust_list, + TP_PROTO(sc_exit(long ret,) int pid, struct robust_list_head * * head_ptr, size_t * len_ptr), + TP_ARGS(sc_exit(ret,) pid, head_ptr, len_ptr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, pid, pid)) sc_out(ctf_integer(struct robust_list_head * *, head_ptr, head_ptr)) sc_out(ctf_integer(size_t *, len_ptr, len_ptr))) +) +#endif +#ifndef OVERRIDE_32_getcpu +SC_LTTNG_TRACEPOINT_EVENT(getcpu, + TP_PROTO(sc_exit(long ret,) unsigned * cpup, unsigned * nodep, struct getcpu_cache * unused), + TP_ARGS(sc_exit(ret,) cpup, nodep, unused), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(unsigned *, cpup, cpup)) sc_out(ctf_integer(unsigned *, nodep, nodep)) sc_inout(ctf_integer(struct getcpu_cache *, unused, unused))) +) +#endif +#ifndef OVERRIDE_32_signalfd +SC_LTTNG_TRACEPOINT_EVENT(signalfd, + TP_PROTO(sc_exit(long ret,) int ufd, sigset_t * user_mask, size_t sizemask), + TP_ARGS(sc_exit(ret,) ufd, user_mask, sizemask), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_in(ctf_integer(sigset_t *, user_mask, user_mask)) sc_in(ctf_integer(size_t, sizemask, sizemask))) +) +#endif +#ifndef OVERRIDE_32_open_by_handle_at +SC_LTTNG_TRACEPOINT_EVENT(open_by_handle_at, + TP_PROTO(sc_exit(long ret,) int mountdirfd, struct file_handle * handle, int flags), + TP_ARGS(sc_exit(ret,) mountdirfd, handle, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, mountdirfd, mountdirfd)) sc_in(ctf_integer(struct file_handle *, handle, handle)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_finit_module +SC_LTTNG_TRACEPOINT_EVENT(finit_module, + TP_PROTO(sc_exit(long ret,) int fd, const char * uargs, int flags), + TP_ARGS(sc_exit(ret,) fd, uargs, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(const char *, uargs, uargs)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_sched_setattr +SC_LTTNG_TRACEPOINT_EVENT(sched_setattr, + TP_PROTO(sc_exit(long ret,) pid_t pid, struct sched_attr * uattr, unsigned int flags), + TP_ARGS(sc_exit(ret,) pid, uattr, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(pid_t, pid, pid)) sc_inout(ctf_integer(struct sched_attr *, uattr, uattr)) sc_inout(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_seccomp +SC_LTTNG_TRACEPOINT_EVENT(seccomp, + TP_PROTO(sc_exit(long ret,) unsigned int op, unsigned int flags, const char * uargs), + TP_ARGS(sc_exit(ret,) op, flags, uargs), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, op, op)) sc_inout(ctf_integer(unsigned int, flags, flags)) sc_inout(ctf_integer(const char *, uargs, uargs))) +) +#endif +#ifndef OVERRIDE_32_getrandom +SC_LTTNG_TRACEPOINT_EVENT(getrandom, + TP_PROTO(sc_exit(long ret,) char * buf, size_t count, unsigned int flags), + TP_ARGS(sc_exit(ret,) buf, count, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(char *, buf, buf)) sc_inout(ctf_integer(size_t, count, count)) sc_inout(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_reboot +SC_LTTNG_TRACEPOINT_EVENT(reboot, + TP_PROTO(sc_exit(long ret,) int magic1, int magic2, unsigned int cmd, void * arg), + TP_ARGS(sc_exit(ret,) magic1, magic2, cmd, arg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, magic1, magic1)) sc_in(ctf_integer(int, magic2, magic2)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_in(ctf_integer(void *, arg, arg))) +) +#endif +#ifndef OVERRIDE_32_wait4 +SC_LTTNG_TRACEPOINT_EVENT(wait4, + TP_PROTO(sc_exit(long ret,) pid_t upid, int * stat_addr, int options, struct rusage * ru), + TP_ARGS(sc_exit(ret,) upid, stat_addr, options, ru), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, upid, upid)) sc_out(ctf_integer(int *, stat_addr, stat_addr)) sc_in(ctf_integer(int, options, options)) sc_out(ctf_integer(struct rusage *, ru, ru))) +) +#endif +#ifndef OVERRIDE_32_recv +SC_LTTNG_TRACEPOINT_EVENT(recv, + TP_PROTO(sc_exit(long ret,) int fd, void * ubuf, size_t size, unsigned int flags), + TP_ARGS(sc_exit(ret,) fd, ubuf, size, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, fd, fd)) sc_inout(ctf_integer(void *, ubuf, ubuf)) sc_inout(ctf_integer(size_t, size, size)) sc_inout(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_send +SC_LTTNG_TRACEPOINT_EVENT(send, + TP_PROTO(sc_exit(long ret,) int fd, void * buff, size_t len, unsigned int flags), + TP_ARGS(sc_exit(ret,) fd, buff, len, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, fd, fd)) sc_inout(ctf_integer(void *, buff, buff)) sc_inout(ctf_integer(size_t, len, len)) sc_inout(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_socketpair +SC_LTTNG_TRACEPOINT_EVENT(socketpair, + TP_PROTO(sc_exit(long ret,) int family, int type, int protocol, int * usockvec), + TP_ARGS(sc_exit(ret,) family, type, protocol, usockvec), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, family, family)) sc_in(ctf_integer(int, type, type)) sc_in(ctf_integer(int, protocol, protocol)) sc_out(ctf_integer(int *, usockvec, usockvec))) +) +#endif +#ifndef OVERRIDE_32_rt_sigaction +SC_LTTNG_TRACEPOINT_EVENT(rt_sigaction, + TP_PROTO(sc_exit(long ret,) int sig, const struct sigaction * act, struct sigaction * oact, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) sig, act, oact, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, sig, sig)) sc_in(ctf_integer(const struct sigaction *, act, act)) sc_out(ctf_integer(struct sigaction *, oact, oact)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) +) +#endif +#ifndef OVERRIDE_32_rt_sigprocmask +SC_LTTNG_TRACEPOINT_EVENT(rt_sigprocmask, + TP_PROTO(sc_exit(long ret,) int how, sigset_t * nset, sigset_t * oset, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) how, nset, oset, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, how, how)) sc_in(ctf_integer(sigset_t *, nset, nset)) sc_out(ctf_integer(sigset_t *, oset, oset)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) +) +#endif +#ifndef OVERRIDE_32_rt_sigtimedwait +SC_LTTNG_TRACEPOINT_EVENT(rt_sigtimedwait, + TP_PROTO(sc_exit(long ret,) const sigset_t * uthese, siginfo_t * uinfo, const struct timespec * uts, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) uthese, uinfo, uts, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(const sigset_t *, uthese, uthese)) sc_out(ctf_integer(siginfo_t *, uinfo, uinfo)) sc_in(ctf_integer(const struct timespec *, uts, uts)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) +) +#endif +#ifndef OVERRIDE_32_pread64 +SC_LTTNG_TRACEPOINT_EVENT(pread64, + TP_PROTO(sc_exit(long ret,) unsigned int fd, char * buf, size_t count, loff_t pos), + TP_ARGS(sc_exit(ret,) fd, buf, count, pos), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(size_t, count, count)) sc_in(ctf_integer(loff_t, pos, pos))) +) +#endif +#ifndef OVERRIDE_32_pwrite64 +SC_LTTNG_TRACEPOINT_EVENT(pwrite64, + TP_PROTO(sc_exit(long ret,) unsigned int fd, const char * buf, size_t count, loff_t pos), + TP_ARGS(sc_exit(ret,) fd, buf, count, pos), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(const char *, buf, buf)) sc_in(ctf_integer(size_t, count, count)) sc_in(ctf_integer(loff_t, pos, pos))) +) +#endif +#ifndef OVERRIDE_32_sendfile +SC_LTTNG_TRACEPOINT_EVENT(sendfile, + TP_PROTO(sc_exit(long ret,) int out_fd, int in_fd, off_t * offset, size_t count), + TP_ARGS(sc_exit(ret,) out_fd, in_fd, offset, count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, out_fd, out_fd)) sc_inout(ctf_integer(int, in_fd, in_fd)) sc_inout(ctf_integer(off_t *, offset, offset)) sc_inout(ctf_integer(size_t, count, count))) +) +#endif +#ifndef OVERRIDE_32_getxattr +SC_LTTNG_TRACEPOINT_EVENT(getxattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, void * value, size_t size), + TP_ARGS(sc_exit(ret,) pathname, name, value, size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_out(ctf_integer(void *, value, value)) sc_in(ctf_integer(size_t, size, size))) +) +#endif +#ifndef OVERRIDE_32_lgetxattr +SC_LTTNG_TRACEPOINT_EVENT(lgetxattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, void * value, size_t size), + TP_ARGS(sc_exit(ret,) pathname, name, value, size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_out(ctf_integer(void *, value, value)) sc_in(ctf_integer(size_t, size, size))) +) +#endif +#ifndef OVERRIDE_32_fgetxattr +SC_LTTNG_TRACEPOINT_EVENT(fgetxattr, + TP_PROTO(sc_exit(long ret,) int fd, const char * name, void * value, size_t size), + TP_ARGS(sc_exit(ret,) fd, name, value, size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(name, name)) sc_out(ctf_integer(void *, value, value)) sc_in(ctf_integer(size_t, size, size))) +) +#endif +#ifndef OVERRIDE_32_sendfile64 +SC_LTTNG_TRACEPOINT_EVENT(sendfile64, + TP_PROTO(sc_exit(long ret,) int out_fd, int in_fd, loff_t * offset, size_t count), + TP_ARGS(sc_exit(ret,) out_fd, in_fd, offset, count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, out_fd, out_fd)) sc_in(ctf_integer(int, in_fd, in_fd)) sc_inout(ctf_integer(loff_t *, offset, offset)) sc_in(ctf_integer(size_t, count, count))) +) +#endif +#ifndef OVERRIDE_32_epoll_ctl +SC_LTTNG_TRACEPOINT_EVENT(epoll_ctl, + TP_PROTO(sc_exit(long ret,) int epfd, int op, int fd, struct epoll_event * event), + TP_ARGS(sc_exit(ret,) epfd, op, fd, event), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, epfd, epfd)) sc_in(ctf_integer(int, op, op)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct epoll_event *, event, event))) +) +#endif +#ifndef OVERRIDE_32_epoll_wait +SC_LTTNG_TRACEPOINT_EVENT(epoll_wait, + TP_PROTO(sc_exit(long ret,) int epfd, struct epoll_event * events, int maxevents, int timeout), + TP_ARGS(sc_exit(ret,) epfd, events, maxevents, timeout), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, epfd, epfd)) sc_out(ctf_integer(struct epoll_event *, events, events)) sc_in(ctf_integer(int, maxevents, maxevents)) sc_in(ctf_integer(int, timeout, timeout))) +) +#endif +#ifndef OVERRIDE_32_timer_settime +SC_LTTNG_TRACEPOINT_EVENT(timer_settime, + TP_PROTO(sc_exit(long ret,) timer_t timer_id, int flags, const struct itimerspec * new_setting, struct itimerspec * old_setting), + TP_ARGS(sc_exit(ret,) timer_id, flags, new_setting, old_setting), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(const struct itimerspec *, new_setting, new_setting)) sc_out(ctf_integer(struct itimerspec *, old_setting, old_setting))) +) +#endif +#ifndef OVERRIDE_32_clock_nanosleep +SC_LTTNG_TRACEPOINT_EVENT(clock_nanosleep, + TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, int flags, const struct timespec * rqtp, struct timespec * rmtp), + TP_ARGS(sc_exit(ret,) which_clock, flags, rqtp, rmtp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(const struct timespec *, rqtp, rqtp)) sc_out(ctf_integer(struct timespec *, rmtp, rmtp))) +) +#endif +#ifndef OVERRIDE_32_openat +SC_LTTNG_TRACEPOINT_EVENT(openat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, int flags, umode_t mode), + TP_ARGS(sc_exit(ret,) dfd, filename, flags, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(umode_t, mode, mode))) +) +#endif +#ifndef OVERRIDE_32_mknodat +SC_LTTNG_TRACEPOINT_EVENT(mknodat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, umode_t mode, unsigned dev), + TP_ARGS(sc_exit(ret,) dfd, filename, mode, dev), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(umode_t, mode, mode)) sc_in(ctf_integer(unsigned, dev, dev))) +) +#endif +#ifndef OVERRIDE_32_fstatat64 +SC_LTTNG_TRACEPOINT_EVENT(fstatat64, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, struct stat64 * statbuf, int flag), + TP_ARGS(sc_exit(ret,) dfd, filename, statbuf, flag), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, dfd, dfd)) sc_inout(ctf_user_string(filename, filename)) sc_inout(ctf_integer(struct stat64 *, statbuf, statbuf)) sc_inout(ctf_integer(int, flag, flag))) +) +#endif +#ifndef OVERRIDE_32_renameat +SC_LTTNG_TRACEPOINT_EVENT(renameat, + TP_PROTO(sc_exit(long ret,) int olddfd, const char * oldname, int newdfd, const char * newname), + TP_ARGS(sc_exit(ret,) olddfd, oldname, newdfd, newname), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, olddfd, olddfd)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_integer(int, newdfd, newdfd)) sc_in(ctf_user_string(newname, newname))) +) +#endif +#ifndef OVERRIDE_32_readlinkat +SC_LTTNG_TRACEPOINT_EVENT(readlinkat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * pathname, char * buf, int bufsiz), + TP_ARGS(sc_exit(ret,) dfd, pathname, buf, bufsiz), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(int, bufsiz, bufsiz))) +) +#endif +#ifndef OVERRIDE_32_vmsplice +SC_LTTNG_TRACEPOINT_EVENT(vmsplice, + TP_PROTO(sc_exit(long ret,) int fd, const struct iovec * iov, unsigned long nr_segs, unsigned int flags), + TP_ARGS(sc_exit(ret,) fd, iov, nr_segs, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(const struct iovec *, iov, iov)) sc_in(ctf_integer(unsigned long, nr_segs, nr_segs)) sc_in(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_utimensat +SC_LTTNG_TRACEPOINT_EVENT(utimensat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, struct timespec * utimes, int flags), + TP_ARGS(sc_exit(ret,) dfd, filename, utimes, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(struct timespec *, utimes, utimes)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_timerfd_settime +SC_LTTNG_TRACEPOINT_EVENT(timerfd_settime, + TP_PROTO(sc_exit(long ret,) int ufd, int flags, const struct itimerspec * utmr, struct itimerspec * otmr), + TP_ARGS(sc_exit(ret,) ufd, flags, utmr, otmr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(const struct itimerspec *, utmr, utmr)) sc_out(ctf_integer(struct itimerspec *, otmr, otmr))) +) +#endif +#ifndef OVERRIDE_32_signalfd4 +SC_LTTNG_TRACEPOINT_EVENT(signalfd4, + TP_PROTO(sc_exit(long ret,) int ufd, sigset_t * user_mask, size_t sizemask, int flags), + TP_ARGS(sc_exit(ret,) ufd, user_mask, sizemask, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_in(ctf_integer(sigset_t *, user_mask, user_mask)) sc_in(ctf_integer(size_t, sizemask, sizemask)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_rt_tgsigqueueinfo +SC_LTTNG_TRACEPOINT_EVENT(rt_tgsigqueueinfo, + TP_PROTO(sc_exit(long ret,) pid_t tgid, pid_t pid, int sig, siginfo_t * uinfo), + TP_ARGS(sc_exit(ret,) tgid, pid, sig, uinfo), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, tgid, tgid)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig)) sc_in(ctf_integer(siginfo_t *, uinfo, uinfo))) +) +#endif +#ifndef OVERRIDE_32_accept4 +SC_LTTNG_TRACEPOINT_EVENT(accept4, + TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * upeer_sockaddr, int * upeer_addrlen, int flags), + TP_ARGS(sc_exit(ret,) fd, upeer_sockaddr, upeer_addrlen, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct sockaddr *, upeer_sockaddr, upeer_sockaddr)) sc_inout(ctf_integer(int *, upeer_addrlen, upeer_addrlen)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_prlimit64 +SC_LTTNG_TRACEPOINT_EVENT(prlimit64, + TP_PROTO(sc_exit(long ret,) pid_t pid, unsigned int resource, const struct rlimit64 * new_rlim, struct rlimit64 * old_rlim), + TP_ARGS(sc_exit(ret,) pid, resource, new_rlim, old_rlim), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(unsigned int, resource, resource)) sc_in(ctf_integer(const struct rlimit64 *, new_rlim, new_rlim)) sc_out(ctf_integer(struct rlimit64 *, old_rlim, old_rlim))) +) +#endif +#ifndef OVERRIDE_32_sendmmsg +SC_LTTNG_TRACEPOINT_EVENT(sendmmsg, + TP_PROTO(sc_exit(long ret,) int fd, struct mmsghdr * mmsg, unsigned int vlen, unsigned int flags), + TP_ARGS(sc_exit(ret,) fd, mmsg, vlen, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct mmsghdr *, mmsg, mmsg)) sc_in(ctf_integer(unsigned int, vlen, vlen)) sc_in(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_sched_getattr +SC_LTTNG_TRACEPOINT_EVENT(sched_getattr, + TP_PROTO(sc_exit(long ret,) pid_t pid, struct sched_attr * uattr, unsigned int size, unsigned int flags), + TP_ARGS(sc_exit(ret,) pid, uattr, size, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(pid_t, pid, pid)) sc_inout(ctf_integer(struct sched_attr *, uattr, uattr)) sc_inout(ctf_integer(unsigned int, size, size)) sc_inout(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_mount +SC_LTTNG_TRACEPOINT_EVENT(mount, + TP_PROTO(sc_exit(long ret,) char * dev_name, char * dir_name, char * type, unsigned long flags, void * data), + TP_ARGS(sc_exit(ret,) dev_name, dir_name, type, flags, data), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(dev_name, dev_name)) sc_in(ctf_user_string(dir_name, dir_name)) sc_in(ctf_user_string(type, type)) sc_in(ctf_integer(unsigned long, flags, flags)) sc_in(ctf_integer(void *, data, data))) +) +#endif +#ifndef OVERRIDE_32_llseek +SC_LTTNG_TRACEPOINT_EVENT(llseek, + TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned long offset_high, unsigned long offset_low, loff_t * result, unsigned int whence), + TP_ARGS(sc_exit(ret,) fd, offset_high, offset_low, result, whence), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, fd, fd)) sc_inout(ctf_integer(unsigned long, offset_high, offset_high)) sc_inout(ctf_integer(unsigned long, offset_low, offset_low)) sc_inout(ctf_integer(loff_t *, result, result)) sc_inout(ctf_integer(unsigned int, whence, whence))) +) +#endif +#ifndef OVERRIDE_32_select +SC_LTTNG_TRACEPOINT_EVENT(select, + TP_PROTO(sc_exit(long ret,) int n, fd_set * inp, fd_set * outp, fd_set * exp, struct timeval * tvp), + TP_ARGS(sc_exit(ret,) n, inp, outp, exp, tvp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, n, n)) sc_inout(ctf_integer(fd_set *, inp, inp)) sc_inout(ctf_integer(fd_set *, outp, outp)) sc_inout(ctf_integer(fd_set *, exp, exp)) sc_inout(ctf_integer(struct timeval *, tvp, tvp))) +) +#endif +#ifndef OVERRIDE_32_getsockopt +SC_LTTNG_TRACEPOINT_EVENT(getsockopt, + TP_PROTO(sc_exit(long ret,) int fd, int level, int optname, char * optval, int * optlen), + TP_ARGS(sc_exit(ret,) fd, level, optname, optval, optlen), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, level, level)) sc_in(ctf_integer(int, optname, optname)) sc_out(ctf_integer(char *, optval, optval)) sc_inout(ctf_integer(int *, optlen, optlen))) +) +#endif +#ifndef OVERRIDE_32_setsockopt +SC_LTTNG_TRACEPOINT_EVENT(setsockopt, + TP_PROTO(sc_exit(long ret,) int fd, int level, int optname, char * optval, int optlen), + TP_ARGS(sc_exit(ret,) fd, level, optname, optval, optlen), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, level, level)) sc_in(ctf_integer(int, optname, optname)) sc_in(ctf_integer(char *, optval, optval)) sc_in(ctf_integer(int, optlen, optlen))) +) +#endif +#ifndef OVERRIDE_32_setxattr +SC_LTTNG_TRACEPOINT_EVENT(setxattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, const void * value, size_t size, int flags), + TP_ARGS(sc_exit(ret,) pathname, name, value, size, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(const void *, value, value)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_lsetxattr +SC_LTTNG_TRACEPOINT_EVENT(lsetxattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, const void * value, size_t size, int flags), + TP_ARGS(sc_exit(ret,) pathname, name, value, size, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(const void *, value, value)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_fsetxattr +SC_LTTNG_TRACEPOINT_EVENT(fsetxattr, + TP_PROTO(sc_exit(long ret,) int fd, const char * name, const void * value, size_t size, int flags), + TP_ARGS(sc_exit(ret,) fd, name, value, size, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(const void *, value, value)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_io_getevents +SC_LTTNG_TRACEPOINT_EVENT(io_getevents, + TP_PROTO(sc_exit(long ret,) aio_context_t ctx_id, long min_nr, long nr, struct io_event * events, struct timespec * timeout), + TP_ARGS(sc_exit(ret,) ctx_id, min_nr, nr, events, timeout), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx_id, ctx_id)) sc_in(ctf_integer(long, min_nr, min_nr)) sc_in(ctf_integer(long, nr, nr)) sc_out(ctf_integer(struct io_event *, events, events)) sc_inout(ctf_integer(struct timespec *, timeout, timeout))) +) +#endif +#ifndef OVERRIDE_32_waitid +SC_LTTNG_TRACEPOINT_EVENT(waitid, + TP_PROTO(sc_exit(long ret,) int which, pid_t upid, struct siginfo * infop, int options, struct rusage * ru), + TP_ARGS(sc_exit(ret,) which, upid, infop, options, ru), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(pid_t, upid, upid)) sc_out(ctf_integer(struct siginfo *, infop, infop)) sc_in(ctf_integer(int, options, options)) sc_out(ctf_integer(struct rusage *, ru, ru))) +) +#endif +#ifndef OVERRIDE_32_fchownat +SC_LTTNG_TRACEPOINT_EVENT(fchownat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, uid_t user, gid_t group, int flag), + TP_ARGS(sc_exit(ret,) dfd, filename, user, group, flag), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group)) sc_in(ctf_integer(int, flag, flag))) +) +#endif +#ifndef OVERRIDE_32_linkat +SC_LTTNG_TRACEPOINT_EVENT(linkat, + TP_PROTO(sc_exit(long ret,) int olddfd, const char * oldname, int newdfd, const char * newname, int flags), + TP_ARGS(sc_exit(ret,) olddfd, oldname, newdfd, newname, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, olddfd, olddfd)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_integer(int, newdfd, newdfd)) sc_in(ctf_user_string(newname, newname)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_ppoll +SC_LTTNG_TRACEPOINT_EVENT(ppoll, + TP_PROTO(sc_exit(long ret,) struct pollfd * ufds, unsigned int nfds, struct timespec * tsp, const sigset_t * sigmask, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) ufds, nfds, tsp, sigmask, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct pollfd *, ufds, ufds)) sc_in(ctf_integer(unsigned int, nfds, nfds)) sc_in(ctf_integer(struct timespec *, tsp, tsp)) sc_in(ctf_integer(const sigset_t *, sigmask, sigmask)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) +) +#endif +#ifndef OVERRIDE_32_preadv +SC_LTTNG_TRACEPOINT_EVENT(preadv, + TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen, unsigned long pos_l, unsigned long pos_h), + TP_ARGS(sc_exit(ret,) fd, vec, vlen, pos_l, pos_h), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_out(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen)) sc_in(ctf_integer(unsigned long, pos_l, pos_l)) sc_in(ctf_integer(unsigned long, pos_h, pos_h))) +) +#endif +#ifndef OVERRIDE_32_pwritev +SC_LTTNG_TRACEPOINT_EVENT(pwritev, + TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen, unsigned long pos_l, unsigned long pos_h), + TP_ARGS(sc_exit(ret,) fd, vec, vlen, pos_l, pos_h), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_in(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen)) sc_in(ctf_integer(unsigned long, pos_l, pos_l)) sc_in(ctf_integer(unsigned long, pos_h, pos_h))) +) +#endif +#ifndef OVERRIDE_32_perf_event_open +SC_LTTNG_TRACEPOINT_EVENT(perf_event_open, + TP_PROTO(sc_exit(long ret,) struct perf_event_attr * attr_uptr, pid_t pid, int cpu, int group_fd, unsigned long flags), + TP_ARGS(sc_exit(ret,) attr_uptr, pid, cpu, group_fd, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct perf_event_attr *, attr_uptr, attr_uptr)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, cpu, cpu)) sc_in(ctf_integer(int, group_fd, group_fd)) sc_in(ctf_integer(unsigned long, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_recvmmsg +SC_LTTNG_TRACEPOINT_EVENT(recvmmsg, + TP_PROTO(sc_exit(long ret,) int fd, struct mmsghdr * mmsg, unsigned int vlen, unsigned int flags, struct timespec * timeout), + TP_ARGS(sc_exit(ret,) fd, mmsg, vlen, flags, timeout), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct mmsghdr *, mmsg, mmsg)) sc_in(ctf_integer(unsigned int, vlen, vlen)) sc_in(ctf_integer(unsigned int, flags, flags)) sc_inout(ctf_integer(struct timespec *, timeout, timeout))) +) +#endif +#ifndef OVERRIDE_32_name_to_handle_at +SC_LTTNG_TRACEPOINT_EVENT(name_to_handle_at, + TP_PROTO(sc_exit(long ret,) int dfd, const char * name, struct file_handle * handle, int * mnt_id, int flag), + TP_ARGS(sc_exit(ret,) dfd, name, handle, mnt_id, flag), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(name, name)) sc_inout(ctf_integer(struct file_handle *, handle, handle)) sc_out(ctf_integer(int *, mnt_id, mnt_id)) sc_in(ctf_integer(int, flag, flag))) +) +#endif +#ifndef OVERRIDE_32_renameat2 +SC_LTTNG_TRACEPOINT_EVENT(renameat2, + TP_PROTO(sc_exit(long ret,) int olddfd, const char * oldname, int newdfd, const char * newname, unsigned int flags), + TP_ARGS(sc_exit(ret,) olddfd, oldname, newdfd, newname, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, olddfd, olddfd)) sc_inout(ctf_user_string(oldname, oldname)) sc_inout(ctf_integer(int, newdfd, newdfd)) sc_inout(ctf_user_string(newname, newname)) sc_inout(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_ipc +SC_LTTNG_TRACEPOINT_EVENT(ipc, + TP_PROTO(sc_exit(long ret,) unsigned int call, int first, unsigned long second, unsigned long third, void * ptr, long fifth), + TP_ARGS(sc_exit(ret,) call, first, second, third, ptr, fifth), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, call, call)) sc_inout(ctf_integer(int, first, first)) sc_inout(ctf_integer(unsigned long, second, second)) sc_inout(ctf_integer(unsigned long, third, third)) sc_inout(ctf_integer(void *, ptr, ptr)) sc_inout(ctf_integer(long, fifth, fifth))) +) +#endif +#ifndef OVERRIDE_32_recvfrom +SC_LTTNG_TRACEPOINT_EVENT(recvfrom, + TP_PROTO(sc_exit(long ret,) int fd, void * ubuf, size_t size, unsigned int flags, struct sockaddr * addr, int * addr_len), + TP_ARGS(sc_exit(ret,) fd, ubuf, size, flags, addr, addr_len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(void *, ubuf, ubuf)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(unsigned int, flags, flags)) sc_out(ctf_integer(struct sockaddr *, addr, addr)) sc_inout(ctf_integer(int *, addr_len, addr_len))) +) +#endif +#ifndef OVERRIDE_32_sendto +SC_LTTNG_TRACEPOINT_EVENT(sendto, + TP_PROTO(sc_exit(long ret,) int fd, void * buff, size_t len, unsigned int flags, struct sockaddr * addr, int addr_len), + TP_ARGS(sc_exit(ret,) fd, buff, len, flags, addr, addr_len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(void *, buff, buff)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned int, flags, flags)) sc_in(ctf_integer(struct sockaddr *, addr, addr)) sc_in(ctf_integer(int, addr_len, addr_len))) +) +#endif +#ifndef OVERRIDE_32_futex +SC_LTTNG_TRACEPOINT_EVENT(futex, + TP_PROTO(sc_exit(long ret,) u32 * uaddr, int op, u32 val, struct timespec * utime, u32 * uaddr2, u32 val3), + TP_ARGS(sc_exit(ret,) uaddr, op, val, utime, uaddr2, val3), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(u32 *, uaddr, uaddr)) sc_in(ctf_integer(int, op, op)) sc_in(ctf_integer(u32, val, val)) sc_in(ctf_integer(struct timespec *, utime, utime)) sc_inout(ctf_integer(u32 *, uaddr2, uaddr2)) sc_in(ctf_integer(u32, val3, val3))) +) +#endif +#ifndef OVERRIDE_32_pselect6 +SC_LTTNG_TRACEPOINT_EVENT(pselect6, + TP_PROTO(sc_exit(long ret,) int n, fd_set * inp, fd_set * outp, fd_set * exp, struct timespec * tsp, void * sig), + TP_ARGS(sc_exit(ret,) n, inp, outp, exp, tsp, sig), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, n, n)) sc_inout(ctf_integer(fd_set *, inp, inp)) sc_inout(ctf_integer(fd_set *, outp, outp)) sc_inout(ctf_integer(fd_set *, exp, exp)) sc_inout(ctf_integer(struct timespec *, tsp, tsp)) sc_in(ctf_integer(void *, sig, sig))) +) +#endif +#ifndef OVERRIDE_32_splice +SC_LTTNG_TRACEPOINT_EVENT(splice, + TP_PROTO(sc_exit(long ret,) int fd_in, loff_t * off_in, int fd_out, loff_t * off_out, size_t len, unsigned int flags), + TP_ARGS(sc_exit(ret,) fd_in, off_in, fd_out, off_out, len, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd_in, fd_in)) sc_in(ctf_integer(loff_t *, off_in, off_in)) sc_in(ctf_integer(int, fd_out, fd_out)) sc_in(ctf_integer(loff_t *, off_out, off_out)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_epoll_pwait +SC_LTTNG_TRACEPOINT_EVENT(epoll_pwait, + TP_PROTO(sc_exit(long ret,) int epfd, struct epoll_event * events, int maxevents, int timeout, const sigset_t * sigmask, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) epfd, events, maxevents, timeout, sigmask, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, epfd, epfd)) sc_out(ctf_integer(struct epoll_event *, events, events)) sc_in(ctf_integer(int, maxevents, maxevents)) sc_in(ctf_integer(int, timeout, timeout)) sc_in(ctf_integer(const sigset_t *, sigmask, sigmask)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) +) +#endif + +#endif /* _TRACE_SYSCALLS_POINTERS_H */ + +/* This part must be outside protection */ +#include + +#else /* CREATE_SYSCALL_TABLE */ + +#include "mips-32-syscalls_pointers_override.h" +#include "syscalls_pointers_override.h" + +#ifndef OVERRIDE_TABLE_32_read +TRACE_SYSCALL_TABLE(read, read, 4003, 3) +#endif +#ifndef OVERRIDE_TABLE_32_write +TRACE_SYSCALL_TABLE(write, write, 4004, 3) +#endif +#ifndef OVERRIDE_TABLE_32_open +TRACE_SYSCALL_TABLE(open, open, 4005, 3) +#endif +#ifndef OVERRIDE_TABLE_32_waitpid +TRACE_SYSCALL_TABLE(waitpid, waitpid, 4007, 3) +#endif +#ifndef OVERRIDE_TABLE_32_creat +TRACE_SYSCALL_TABLE(creat, creat, 4008, 2) +#endif +#ifndef OVERRIDE_TABLE_32_link +TRACE_SYSCALL_TABLE(link, link, 4009, 2) +#endif +#ifndef OVERRIDE_TABLE_32_unlink +TRACE_SYSCALL_TABLE(unlink, unlink, 4010, 1) +#endif +#ifndef OVERRIDE_TABLE_32_execve +TRACE_SYSCALL_TABLE(execve, execve, 4011, 3) +#endif +#ifndef OVERRIDE_TABLE_32_chdir +TRACE_SYSCALL_TABLE(chdir, chdir, 4012, 1) +#endif +#ifndef OVERRIDE_TABLE_32_time +TRACE_SYSCALL_TABLE(time, time, 4013, 1) +#endif +#ifndef OVERRIDE_TABLE_32_mknod +TRACE_SYSCALL_TABLE(mknod, mknod, 4014, 3) +#endif +#ifndef OVERRIDE_TABLE_32_chmod +TRACE_SYSCALL_TABLE(chmod, chmod, 4015, 2) +#endif +#ifndef OVERRIDE_TABLE_32_lchown +TRACE_SYSCALL_TABLE(lchown, lchown, 4016, 3) +#endif +#ifndef OVERRIDE_TABLE_32_mount +TRACE_SYSCALL_TABLE(mount, mount, 4021, 5) +#endif +#ifndef OVERRIDE_TABLE_32_oldumount +TRACE_SYSCALL_TABLE(oldumount, oldumount, 4022, 1) +#endif +#ifndef OVERRIDE_TABLE_32_stime +TRACE_SYSCALL_TABLE(stime, stime, 4025, 1) +#endif +#ifndef OVERRIDE_TABLE_32_utime +TRACE_SYSCALL_TABLE(utime, utime, 4030, 2) +#endif +#ifndef OVERRIDE_TABLE_32_access +TRACE_SYSCALL_TABLE(access, access, 4033, 2) +#endif +#ifndef OVERRIDE_TABLE_32_rename +TRACE_SYSCALL_TABLE(rename, rename, 4038, 2) +#endif +#ifndef OVERRIDE_TABLE_32_mkdir +TRACE_SYSCALL_TABLE(mkdir, mkdir, 4039, 2) +#endif +#ifndef OVERRIDE_TABLE_32_rmdir +TRACE_SYSCALL_TABLE(rmdir, rmdir, 4040, 1) +#endif +#ifndef OVERRIDE_TABLE_32_times +TRACE_SYSCALL_TABLE(times, times, 4043, 1) +#endif +#ifndef OVERRIDE_TABLE_32_umount +TRACE_SYSCALL_TABLE(umount, umount, 4052, 2) +#endif +#ifndef OVERRIDE_TABLE_32_olduname +TRACE_SYSCALL_TABLE(olduname, olduname, 4059, 1) +#endif +#ifndef OVERRIDE_TABLE_32_chroot +TRACE_SYSCALL_TABLE(chroot, chroot, 4061, 1) +#endif +#ifndef OVERRIDE_TABLE_32_ustat +TRACE_SYSCALL_TABLE(ustat, ustat, 4062, 2) +#endif +#ifndef OVERRIDE_TABLE_32_sigaction +TRACE_SYSCALL_TABLE(sigaction, sigaction, 4067, 3) +#endif +#ifndef OVERRIDE_TABLE_32_sigsuspend +TRACE_SYSCALL_TABLE(sigsuspend, sigsuspend, 4072, 1) +#endif +#ifndef OVERRIDE_TABLE_32_sigpending +TRACE_SYSCALL_TABLE(sigpending, sigpending, 4073, 1) +#endif +#ifndef OVERRIDE_TABLE_32_sethostname +TRACE_SYSCALL_TABLE(sethostname, sethostname, 4074, 2) +#endif +#ifndef OVERRIDE_TABLE_32_setrlimit +TRACE_SYSCALL_TABLE(setrlimit, setrlimit, 4075, 2) +#endif +#ifndef OVERRIDE_TABLE_32_getrlimit +TRACE_SYSCALL_TABLE(getrlimit, getrlimit, 4076, 2) +#endif +#ifndef OVERRIDE_TABLE_32_getrusage +TRACE_SYSCALL_TABLE(getrusage, getrusage, 4077, 2) +#endif +#ifndef OVERRIDE_TABLE_32_gettimeofday +TRACE_SYSCALL_TABLE(gettimeofday, gettimeofday, 4078, 2) +#endif +#ifndef OVERRIDE_TABLE_32_settimeofday +TRACE_SYSCALL_TABLE(settimeofday, settimeofday, 4079, 2) +#endif +#ifndef OVERRIDE_TABLE_32_getgroups +TRACE_SYSCALL_TABLE(getgroups, getgroups, 4080, 2) +#endif +#ifndef OVERRIDE_TABLE_32_setgroups +TRACE_SYSCALL_TABLE(setgroups, setgroups, 4081, 2) +#endif +#ifndef OVERRIDE_TABLE_32_symlink +TRACE_SYSCALL_TABLE(symlink, symlink, 4083, 2) +#endif +#ifndef OVERRIDE_TABLE_32_readlink +TRACE_SYSCALL_TABLE(readlink, readlink, 4085, 3) +#endif +#ifndef OVERRIDE_TABLE_32_reboot +TRACE_SYSCALL_TABLE(reboot, reboot, 4088, 4) +#endif +#ifndef OVERRIDE_TABLE_32_old_readdir +TRACE_SYSCALL_TABLE(old_readdir, old_readdir, 4089, 3) +#endif +#ifndef OVERRIDE_TABLE_32_truncate +TRACE_SYSCALL_TABLE(truncate, truncate, 4092, 2) +#endif +#ifndef OVERRIDE_TABLE_32_statfs +TRACE_SYSCALL_TABLE(statfs, statfs, 4099, 2) +#endif +#ifndef OVERRIDE_TABLE_32_fstatfs +TRACE_SYSCALL_TABLE(fstatfs, fstatfs, 4100, 2) +#endif +#ifndef OVERRIDE_TABLE_32_socketcall +TRACE_SYSCALL_TABLE(socketcall, socketcall, 4102, 2) +#endif +#ifndef OVERRIDE_TABLE_32_syslog +TRACE_SYSCALL_TABLE(syslog, syslog, 4103, 3) +#endif +#ifndef OVERRIDE_TABLE_32_setitimer +TRACE_SYSCALL_TABLE(setitimer, setitimer, 4104, 3) +#endif +#ifndef OVERRIDE_TABLE_32_getitimer +TRACE_SYSCALL_TABLE(getitimer, getitimer, 4105, 2) +#endif +#ifndef OVERRIDE_TABLE_32_newstat +TRACE_SYSCALL_TABLE(newstat, newstat, 4106, 2) +#endif +#ifndef OVERRIDE_TABLE_32_newlstat +TRACE_SYSCALL_TABLE(newlstat, newlstat, 4107, 2) +#endif +#ifndef OVERRIDE_TABLE_32_newfstat +TRACE_SYSCALL_TABLE(newfstat, newfstat, 4108, 2) +#endif +#ifndef OVERRIDE_TABLE_32_uname +TRACE_SYSCALL_TABLE(uname, uname, 4109, 1) +#endif +#ifndef OVERRIDE_TABLE_32_wait4 +TRACE_SYSCALL_TABLE(wait4, wait4, 4114, 4) +#endif +#ifndef OVERRIDE_TABLE_32_sysinfo +TRACE_SYSCALL_TABLE(sysinfo, sysinfo, 4116, 1) +#endif +#ifndef OVERRIDE_TABLE_32_ipc +TRACE_SYSCALL_TABLE(ipc, ipc, 4117, 6) +#endif +#ifndef OVERRIDE_TABLE_32_setdomainname +TRACE_SYSCALL_TABLE(setdomainname, setdomainname, 4121, 2) +#endif +#ifndef OVERRIDE_TABLE_32_newuname +TRACE_SYSCALL_TABLE(newuname, newuname, 4122, 1) +#endif +#ifndef OVERRIDE_TABLE_32_adjtimex +TRACE_SYSCALL_TABLE(adjtimex, adjtimex, 4124, 1) +#endif +#ifndef OVERRIDE_TABLE_32_sigprocmask +TRACE_SYSCALL_TABLE(sigprocmask, sigprocmask, 4126, 3) +#endif +#ifndef OVERRIDE_TABLE_32_init_module +TRACE_SYSCALL_TABLE(init_module, init_module, 4128, 3) +#endif +#ifndef OVERRIDE_TABLE_32_delete_module +TRACE_SYSCALL_TABLE(delete_module, delete_module, 4129, 2) +#endif +#ifndef OVERRIDE_TABLE_32_llseek +TRACE_SYSCALL_TABLE(llseek, llseek, 4140, 5) +#endif +#ifndef OVERRIDE_TABLE_32_getdents +TRACE_SYSCALL_TABLE(getdents, getdents, 4141, 3) +#endif +#ifndef OVERRIDE_TABLE_32_select +TRACE_SYSCALL_TABLE(select, select, 4142, 5) +#endif +#ifndef OVERRIDE_TABLE_32_readv +TRACE_SYSCALL_TABLE(readv, readv, 4145, 3) +#endif +#ifndef OVERRIDE_TABLE_32_writev +TRACE_SYSCALL_TABLE(writev, writev, 4146, 3) +#endif +#ifndef OVERRIDE_TABLE_32_cachectl +TRACE_SYSCALL_TABLE(cachectl, cachectl, 4148, 3) +#endif +#ifndef OVERRIDE_TABLE_32_sysctl +TRACE_SYSCALL_TABLE(sysctl, sysctl, 4153, 1) +#endif +#ifndef OVERRIDE_TABLE_32_sched_setparam +TRACE_SYSCALL_TABLE(sched_setparam, sched_setparam, 4158, 2) +#endif +#ifndef OVERRIDE_TABLE_32_sched_getparam +TRACE_SYSCALL_TABLE(sched_getparam, sched_getparam, 4159, 2) +#endif +#ifndef OVERRIDE_TABLE_32_sched_setscheduler +TRACE_SYSCALL_TABLE(sched_setscheduler, sched_setscheduler, 4160, 3) +#endif +#ifndef OVERRIDE_TABLE_32_sched_rr_get_interval +TRACE_SYSCALL_TABLE(sched_rr_get_interval, sched_rr_get_interval, 4165, 2) +#endif +#ifndef OVERRIDE_TABLE_32_nanosleep +TRACE_SYSCALL_TABLE(nanosleep, nanosleep, 4166, 2) +#endif +#ifndef OVERRIDE_TABLE_32_accept +TRACE_SYSCALL_TABLE(accept, accept, 4168, 3) +#endif +#ifndef OVERRIDE_TABLE_32_bind +TRACE_SYSCALL_TABLE(bind, bind, 4169, 3) +#endif +#ifndef OVERRIDE_TABLE_32_connect +TRACE_SYSCALL_TABLE(connect, connect, 4170, 3) +#endif +#ifndef OVERRIDE_TABLE_32_getpeername +TRACE_SYSCALL_TABLE(getpeername, getpeername, 4171, 3) +#endif +#ifndef OVERRIDE_TABLE_32_getsockname +TRACE_SYSCALL_TABLE(getsockname, getsockname, 4172, 3) +#endif +#ifndef OVERRIDE_TABLE_32_getsockopt +TRACE_SYSCALL_TABLE(getsockopt, getsockopt, 4173, 5) +#endif +#ifndef OVERRIDE_TABLE_32_recv +TRACE_SYSCALL_TABLE(recv, recv, 4175, 4) +#endif +#ifndef OVERRIDE_TABLE_32_recvfrom +TRACE_SYSCALL_TABLE(recvfrom, recvfrom, 4176, 6) +#endif +#ifndef OVERRIDE_TABLE_32_recvmsg +TRACE_SYSCALL_TABLE(recvmsg, recvmsg, 4177, 3) +#endif +#ifndef OVERRIDE_TABLE_32_send +TRACE_SYSCALL_TABLE(send, send, 4178, 4) +#endif +#ifndef OVERRIDE_TABLE_32_sendmsg +TRACE_SYSCALL_TABLE(sendmsg, sendmsg, 4179, 3) +#endif +#ifndef OVERRIDE_TABLE_32_sendto +TRACE_SYSCALL_TABLE(sendto, sendto, 4180, 6) +#endif +#ifndef OVERRIDE_TABLE_32_setsockopt +TRACE_SYSCALL_TABLE(setsockopt, setsockopt, 4181, 5) +#endif +#ifndef OVERRIDE_TABLE_32_socketpair +TRACE_SYSCALL_TABLE(socketpair, socketpair, 4184, 4) +#endif +#ifndef OVERRIDE_TABLE_32_getresuid +TRACE_SYSCALL_TABLE(getresuid, getresuid, 4186, 3) +#endif +#ifndef OVERRIDE_TABLE_32_poll +TRACE_SYSCALL_TABLE(poll, poll, 4188, 3) +#endif +#ifndef OVERRIDE_TABLE_32_getresgid +TRACE_SYSCALL_TABLE(getresgid, getresgid, 4191, 3) +#endif +#ifndef OVERRIDE_TABLE_32_rt_sigaction +TRACE_SYSCALL_TABLE(rt_sigaction, rt_sigaction, 4194, 4) +#endif +#ifndef OVERRIDE_TABLE_32_rt_sigprocmask +TRACE_SYSCALL_TABLE(rt_sigprocmask, rt_sigprocmask, 4195, 4) +#endif +#ifndef OVERRIDE_TABLE_32_rt_sigpending +TRACE_SYSCALL_TABLE(rt_sigpending, rt_sigpending, 4196, 2) +#endif +#ifndef OVERRIDE_TABLE_32_rt_sigtimedwait +TRACE_SYSCALL_TABLE(rt_sigtimedwait, rt_sigtimedwait, 4197, 4) +#endif +#ifndef OVERRIDE_TABLE_32_rt_sigqueueinfo +TRACE_SYSCALL_TABLE(rt_sigqueueinfo, rt_sigqueueinfo, 4198, 3) +#endif +#ifndef OVERRIDE_TABLE_32_rt_sigsuspend +TRACE_SYSCALL_TABLE(rt_sigsuspend, rt_sigsuspend, 4199, 2) +#endif +#ifndef OVERRIDE_TABLE_32_pread64 +TRACE_SYSCALL_TABLE(pread64, pread64, 4200, 4) +#endif +#ifndef OVERRIDE_TABLE_32_pwrite64 +TRACE_SYSCALL_TABLE(pwrite64, pwrite64, 4201, 4) +#endif +#ifndef OVERRIDE_TABLE_32_chown +TRACE_SYSCALL_TABLE(chown, chown, 4202, 3) +#endif +#ifndef OVERRIDE_TABLE_32_getcwd +TRACE_SYSCALL_TABLE(getcwd, getcwd, 4203, 2) +#endif +#ifndef OVERRIDE_TABLE_32_sigaltstack +TRACE_SYSCALL_TABLE(sigaltstack, sigaltstack, 4206, 2) +#endif +#ifndef OVERRIDE_TABLE_32_sendfile +TRACE_SYSCALL_TABLE(sendfile, sendfile, 4207, 4) +#endif +#ifndef OVERRIDE_TABLE_32_truncate64 +TRACE_SYSCALL_TABLE(truncate64, truncate64, 4211, 2) +#endif +#ifndef OVERRIDE_TABLE_32_stat64 +TRACE_SYSCALL_TABLE(stat64, stat64, 4213, 2) +#endif +#ifndef OVERRIDE_TABLE_32_lstat64 +TRACE_SYSCALL_TABLE(lstat64, lstat64, 4214, 2) +#endif +#ifndef OVERRIDE_TABLE_32_fstat64 +TRACE_SYSCALL_TABLE(fstat64, fstat64, 4215, 2) +#endif +#ifndef OVERRIDE_TABLE_32_pivot_root +TRACE_SYSCALL_TABLE(pivot_root, pivot_root, 4216, 2) +#endif +#ifndef OVERRIDE_TABLE_32_mincore +TRACE_SYSCALL_TABLE(mincore, mincore, 4217, 3) +#endif +#ifndef OVERRIDE_TABLE_32_getdents64 +TRACE_SYSCALL_TABLE(getdents64, getdents64, 4219, 3) +#endif +#ifndef OVERRIDE_TABLE_32_setxattr +TRACE_SYSCALL_TABLE(setxattr, setxattr, 4224, 5) +#endif +#ifndef OVERRIDE_TABLE_32_lsetxattr +TRACE_SYSCALL_TABLE(lsetxattr, lsetxattr, 4225, 5) +#endif +#ifndef OVERRIDE_TABLE_32_fsetxattr +TRACE_SYSCALL_TABLE(fsetxattr, fsetxattr, 4226, 5) +#endif +#ifndef OVERRIDE_TABLE_32_getxattr +TRACE_SYSCALL_TABLE(getxattr, getxattr, 4227, 4) +#endif +#ifndef OVERRIDE_TABLE_32_lgetxattr +TRACE_SYSCALL_TABLE(lgetxattr, lgetxattr, 4228, 4) +#endif +#ifndef OVERRIDE_TABLE_32_fgetxattr +TRACE_SYSCALL_TABLE(fgetxattr, fgetxattr, 4229, 4) +#endif +#ifndef OVERRIDE_TABLE_32_listxattr +TRACE_SYSCALL_TABLE(listxattr, listxattr, 4230, 3) +#endif +#ifndef OVERRIDE_TABLE_32_llistxattr +TRACE_SYSCALL_TABLE(llistxattr, llistxattr, 4231, 3) +#endif +#ifndef OVERRIDE_TABLE_32_flistxattr +TRACE_SYSCALL_TABLE(flistxattr, flistxattr, 4232, 3) +#endif +#ifndef OVERRIDE_TABLE_32_removexattr +TRACE_SYSCALL_TABLE(removexattr, removexattr, 4233, 2) +#endif +#ifndef OVERRIDE_TABLE_32_lremovexattr +TRACE_SYSCALL_TABLE(lremovexattr, lremovexattr, 4234, 2) +#endif +#ifndef OVERRIDE_TABLE_32_fremovexattr +TRACE_SYSCALL_TABLE(fremovexattr, fremovexattr, 4235, 2) +#endif +#ifndef OVERRIDE_TABLE_32_sendfile64 +TRACE_SYSCALL_TABLE(sendfile64, sendfile64, 4237, 4) +#endif +#ifndef OVERRIDE_TABLE_32_futex +TRACE_SYSCALL_TABLE(futex, futex, 4238, 6) +#endif +#ifndef OVERRIDE_TABLE_32_io_setup +TRACE_SYSCALL_TABLE(io_setup, io_setup, 4241, 2) +#endif +#ifndef OVERRIDE_TABLE_32_io_getevents +TRACE_SYSCALL_TABLE(io_getevents, io_getevents, 4243, 5) +#endif +#ifndef OVERRIDE_TABLE_32_io_submit +TRACE_SYSCALL_TABLE(io_submit, io_submit, 4244, 3) +#endif +#ifndef OVERRIDE_TABLE_32_io_cancel +TRACE_SYSCALL_TABLE(io_cancel, io_cancel, 4245, 3) +#endif +#ifndef OVERRIDE_TABLE_32_epoll_ctl +TRACE_SYSCALL_TABLE(epoll_ctl, epoll_ctl, 4249, 4) +#endif +#ifndef OVERRIDE_TABLE_32_epoll_wait +TRACE_SYSCALL_TABLE(epoll_wait, epoll_wait, 4250, 4) +#endif +#ifndef OVERRIDE_TABLE_32_set_tid_address +TRACE_SYSCALL_TABLE(set_tid_address, set_tid_address, 4252, 1) +#endif +#ifndef OVERRIDE_TABLE_32_statfs64 +TRACE_SYSCALL_TABLE(statfs64, statfs64, 4255, 3) +#endif +#ifndef OVERRIDE_TABLE_32_fstatfs64 +TRACE_SYSCALL_TABLE(fstatfs64, fstatfs64, 4256, 3) +#endif +#ifndef OVERRIDE_TABLE_32_timer_create +TRACE_SYSCALL_TABLE(timer_create, timer_create, 4257, 3) +#endif +#ifndef OVERRIDE_TABLE_32_timer_settime +TRACE_SYSCALL_TABLE(timer_settime, timer_settime, 4258, 4) +#endif +#ifndef OVERRIDE_TABLE_32_timer_gettime +TRACE_SYSCALL_TABLE(timer_gettime, timer_gettime, 4259, 2) +#endif +#ifndef OVERRIDE_TABLE_32_clock_settime +TRACE_SYSCALL_TABLE(clock_settime, clock_settime, 4262, 2) +#endif +#ifndef OVERRIDE_TABLE_32_clock_gettime +TRACE_SYSCALL_TABLE(clock_gettime, clock_gettime, 4263, 2) +#endif +#ifndef OVERRIDE_TABLE_32_clock_getres +TRACE_SYSCALL_TABLE(clock_getres, clock_getres, 4264, 2) +#endif +#ifndef OVERRIDE_TABLE_32_clock_nanosleep +TRACE_SYSCALL_TABLE(clock_nanosleep, clock_nanosleep, 4265, 4) +#endif +#ifndef OVERRIDE_TABLE_32_utimes +TRACE_SYSCALL_TABLE(utimes, utimes, 4267, 2) +#endif +#ifndef OVERRIDE_TABLE_32_waitid +TRACE_SYSCALL_TABLE(waitid, waitid, 4278, 5) +#endif +#ifndef OVERRIDE_TABLE_32_inotify_add_watch +TRACE_SYSCALL_TABLE(inotify_add_watch, inotify_add_watch, 4285, 3) +#endif +#ifndef OVERRIDE_TABLE_32_openat +TRACE_SYSCALL_TABLE(openat, openat, 4288, 4) +#endif +#ifndef OVERRIDE_TABLE_32_mkdirat +TRACE_SYSCALL_TABLE(mkdirat, mkdirat, 4289, 3) +#endif +#ifndef OVERRIDE_TABLE_32_mknodat +TRACE_SYSCALL_TABLE(mknodat, mknodat, 4290, 4) +#endif +#ifndef OVERRIDE_TABLE_32_fchownat +TRACE_SYSCALL_TABLE(fchownat, fchownat, 4291, 5) +#endif +#ifndef OVERRIDE_TABLE_32_futimesat +TRACE_SYSCALL_TABLE(futimesat, futimesat, 4292, 3) +#endif +#ifndef OVERRIDE_TABLE_32_fstatat64 +TRACE_SYSCALL_TABLE(fstatat64, fstatat64, 4293, 4) +#endif +#ifndef OVERRIDE_TABLE_32_unlinkat +TRACE_SYSCALL_TABLE(unlinkat, unlinkat, 4294, 3) +#endif +#ifndef OVERRIDE_TABLE_32_renameat +TRACE_SYSCALL_TABLE(renameat, renameat, 4295, 4) +#endif +#ifndef OVERRIDE_TABLE_32_linkat +TRACE_SYSCALL_TABLE(linkat, linkat, 4296, 5) +#endif +#ifndef OVERRIDE_TABLE_32_symlinkat +TRACE_SYSCALL_TABLE(symlinkat, symlinkat, 4297, 3) +#endif +#ifndef OVERRIDE_TABLE_32_readlinkat +TRACE_SYSCALL_TABLE(readlinkat, readlinkat, 4298, 4) +#endif +#ifndef OVERRIDE_TABLE_32_fchmodat +TRACE_SYSCALL_TABLE(fchmodat, fchmodat, 4299, 3) +#endif +#ifndef OVERRIDE_TABLE_32_faccessat +TRACE_SYSCALL_TABLE(faccessat, faccessat, 4300, 3) +#endif +#ifndef OVERRIDE_TABLE_32_pselect6 +TRACE_SYSCALL_TABLE(pselect6, pselect6, 4301, 6) +#endif +#ifndef OVERRIDE_TABLE_32_ppoll +TRACE_SYSCALL_TABLE(ppoll, ppoll, 4302, 5) +#endif +#ifndef OVERRIDE_TABLE_32_splice +TRACE_SYSCALL_TABLE(splice, splice, 4304, 6) +#endif +#ifndef OVERRIDE_TABLE_32_vmsplice +TRACE_SYSCALL_TABLE(vmsplice, vmsplice, 4307, 4) +#endif +#ifndef OVERRIDE_TABLE_32_set_robust_list +TRACE_SYSCALL_TABLE(set_robust_list, set_robust_list, 4309, 2) +#endif +#ifndef OVERRIDE_TABLE_32_get_robust_list +TRACE_SYSCALL_TABLE(get_robust_list, get_robust_list, 4310, 3) +#endif +#ifndef OVERRIDE_TABLE_32_getcpu +TRACE_SYSCALL_TABLE(getcpu, getcpu, 4312, 3) +#endif +#ifndef OVERRIDE_TABLE_32_epoll_pwait +TRACE_SYSCALL_TABLE(epoll_pwait, epoll_pwait, 4313, 6) +#endif +#ifndef OVERRIDE_TABLE_32_utimensat +TRACE_SYSCALL_TABLE(utimensat, utimensat, 4316, 4) +#endif +#ifndef OVERRIDE_TABLE_32_signalfd +TRACE_SYSCALL_TABLE(signalfd, signalfd, 4317, 3) +#endif +#ifndef OVERRIDE_TABLE_32_timerfd_gettime +TRACE_SYSCALL_TABLE(timerfd_gettime, timerfd_gettime, 4322, 2) +#endif +#ifndef OVERRIDE_TABLE_32_timerfd_settime +TRACE_SYSCALL_TABLE(timerfd_settime, timerfd_settime, 4323, 4) +#endif +#ifndef OVERRIDE_TABLE_32_signalfd4 +TRACE_SYSCALL_TABLE(signalfd4, signalfd4, 4324, 4) +#endif +#ifndef OVERRIDE_TABLE_32_pipe2 +TRACE_SYSCALL_TABLE(pipe2, pipe2, 4328, 2) +#endif +#ifndef OVERRIDE_TABLE_32_preadv +TRACE_SYSCALL_TABLE(preadv, preadv, 4330, 5) +#endif +#ifndef OVERRIDE_TABLE_32_pwritev +TRACE_SYSCALL_TABLE(pwritev, pwritev, 4331, 5) +#endif +#ifndef OVERRIDE_TABLE_32_rt_tgsigqueueinfo +TRACE_SYSCALL_TABLE(rt_tgsigqueueinfo, rt_tgsigqueueinfo, 4332, 4) +#endif +#ifndef OVERRIDE_TABLE_32_perf_event_open +TRACE_SYSCALL_TABLE(perf_event_open, perf_event_open, 4333, 5) +#endif +#ifndef OVERRIDE_TABLE_32_accept4 +TRACE_SYSCALL_TABLE(accept4, accept4, 4334, 4) +#endif +#ifndef OVERRIDE_TABLE_32_recvmmsg +TRACE_SYSCALL_TABLE(recvmmsg, recvmmsg, 4335, 5) +#endif +#ifndef OVERRIDE_TABLE_32_prlimit64 +TRACE_SYSCALL_TABLE(prlimit64, prlimit64, 4338, 4) +#endif +#ifndef OVERRIDE_TABLE_32_name_to_handle_at +TRACE_SYSCALL_TABLE(name_to_handle_at, name_to_handle_at, 4339, 5) +#endif +#ifndef OVERRIDE_TABLE_32_open_by_handle_at +TRACE_SYSCALL_TABLE(open_by_handle_at, open_by_handle_at, 4340, 3) +#endif +#ifndef OVERRIDE_TABLE_32_clock_adjtime +TRACE_SYSCALL_TABLE(clock_adjtime, clock_adjtime, 4341, 2) +#endif +#ifndef OVERRIDE_TABLE_32_sendmmsg +TRACE_SYSCALL_TABLE(sendmmsg, sendmmsg, 4343, 4) +#endif +#ifndef OVERRIDE_TABLE_32_finit_module +TRACE_SYSCALL_TABLE(finit_module, finit_module, 4348, 3) +#endif +#ifndef OVERRIDE_TABLE_32_sched_setattr +TRACE_SYSCALL_TABLE(sched_setattr, sched_setattr, 4349, 3) +#endif +#ifndef OVERRIDE_TABLE_32_sched_getattr +TRACE_SYSCALL_TABLE(sched_getattr, sched_getattr, 4350, 4) +#endif +#ifndef OVERRIDE_TABLE_32_renameat2 +TRACE_SYSCALL_TABLE(renameat2, renameat2, 4351, 5) +#endif +#ifndef OVERRIDE_TABLE_32_seccomp +TRACE_SYSCALL_TABLE(seccomp, seccomp, 4352, 3) +#endif +#ifndef OVERRIDE_TABLE_32_getrandom +TRACE_SYSCALL_TABLE(getrandom, getrandom, 4353, 3) +#endif +#ifndef OVERRIDE_TABLE_32_memfd_create +TRACE_SYSCALL_TABLE(memfd_create, memfd_create, 4354, 2) +#endif + +#endif /* CREATE_SYSCALL_TABLE */ diff --git a/include/instrumentation/syscalls/headers/mips-32-syscalls_pointers_override.h b/include/instrumentation/syscalls/headers/mips-32-syscalls_pointers_override.h new file mode 100644 index 00000000..9a38fb5a --- /dev/null +++ b/include/instrumentation/syscalls/headers/mips-32-syscalls_pointers_override.h @@ -0,0 +1,30 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ + +#ifndef CREATE_SYSCALL_TABLE + +#define OVERRIDE_32_sched_setaffinity +SC_LTTNG_TRACEPOINT_EVENT(sched_setaffinity, + TP_PROTO(sc_exit(long ret,) pid_t pid, unsigned int len, unsigned long * user_mask_ptr), + TP_ARGS(sc_exit(ret,) pid, len, user_mask_ptr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(unsigned int, len, len)) sc_in(ctf_integer(unsigned long *, user_mask_ptr, user_mask_ptr))) +) + +#define OVERRIDE_32_sched_getaffinity +SC_LTTNG_TRACEPOINT_EVENT(sched_getaffinity, + TP_PROTO(sc_exit(long ret,) pid_t pid, unsigned int len, unsigned long * user_mask_ptr), + TP_ARGS(sc_exit(ret,) pid, len, user_mask_ptr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(unsigned int, len, len)) sc_out(ctf_integer(unsigned long *, user_mask_ptr, user_mask_ptr))) +) + +#else /* CREATE_SYSCALL_TABLE */ + +#define OVERRIDE_TABLE_32_clone +TRACE_SYSCALL_TABLE(clone, clone, 4120, 0) + +#define OVERRIDE_TABLE_32_sys_sched_setaffinity +TRACE_SYSCALL_TABLE(sched_setaffinity, sched_setaffinity, 4239, 3) + +#define OVERRIDE_TABLE_32_sys_sched_getaffinity +TRACE_SYSCALL_TABLE(sched_getaffinity, sched_getaffinity, 4240, 3) + +#endif /* CREATE_SYSCALL_TABLE */ diff --git a/include/instrumentation/syscalls/headers/mips-64-syscalls_integers.h b/include/instrumentation/syscalls/headers/mips-64-syscalls_integers.h new file mode 100644 index 00000000..814ee3a6 --- /dev/null +++ b/include/instrumentation/syscalls/headers/mips-64-syscalls_integers.h @@ -0,0 +1,1170 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ + +/* THIS FILE IS AUTO-GENERATED. DO NOT EDIT */ + +/* Generated from mips-64-syscalls 3.5.0 */ + +#ifndef CREATE_SYSCALL_TABLE + +#if !defined(_TRACE_SYSCALLS_INTEGERS_H) || defined(TRACE_HEADER_MULTI_READ) +#define _TRACE_SYSCALLS_INTEGERS_H + +#include +#include +#include "mips-64-syscalls_integers_override.h" +#include "syscalls_integers_override.h" + +#ifdef SC_ENTER +SC_LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(syscalls_noargs, + TP_FIELDS() +) +#ifndef OVERRIDE_64_sgetmask +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, sgetmask) +#endif +#ifndef OVERRIDE_64_sched_yield +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, sched_yield) +#endif +#ifndef OVERRIDE_64_pause +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, pause) +#endif +#ifndef OVERRIDE_64_getpid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getpid) +#endif +#ifndef OVERRIDE_64_getuid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getuid) +#endif +#ifndef OVERRIDE_64_getgid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getgid) +#endif +#ifndef OVERRIDE_64_geteuid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, geteuid) +#endif +#ifndef OVERRIDE_64_getegid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getegid) +#endif +#ifndef OVERRIDE_64_getppid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getppid) +#endif +#ifndef OVERRIDE_64_getpgrp +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getpgrp) +#endif +#ifndef OVERRIDE_64_setsid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, setsid) +#endif +#ifndef OVERRIDE_64_munlockall +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, munlockall) +#endif +#ifndef OVERRIDE_64_vhangup +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, vhangup) +#endif +#ifndef OVERRIDE_64_sync +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, sync) +#endif +#ifndef OVERRIDE_64_gettid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, gettid) +#endif +#ifndef OVERRIDE_64_restart_syscall +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, restart_syscall) +#endif +#ifndef OVERRIDE_64_inotify_init +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, inotify_init) +#endif +#else /* #ifdef SC_ENTER */ +#ifndef OVERRIDE_64_sgetmask +SC_LTTNG_TRACEPOINT_EVENT(sgetmask, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_64_sched_yield +SC_LTTNG_TRACEPOINT_EVENT(sched_yield, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_64_pause +SC_LTTNG_TRACEPOINT_EVENT(pause, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_64_getpid +SC_LTTNG_TRACEPOINT_EVENT(getpid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_64_getuid +SC_LTTNG_TRACEPOINT_EVENT(getuid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_64_getgid +SC_LTTNG_TRACEPOINT_EVENT(getgid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_64_geteuid +SC_LTTNG_TRACEPOINT_EVENT(geteuid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_64_getegid +SC_LTTNG_TRACEPOINT_EVENT(getegid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_64_getppid +SC_LTTNG_TRACEPOINT_EVENT(getppid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_64_getpgrp +SC_LTTNG_TRACEPOINT_EVENT(getpgrp, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_64_setsid +SC_LTTNG_TRACEPOINT_EVENT(setsid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_64_munlockall +SC_LTTNG_TRACEPOINT_EVENT(munlockall, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_64_vhangup +SC_LTTNG_TRACEPOINT_EVENT(vhangup, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_64_sync +SC_LTTNG_TRACEPOINT_EVENT(sync, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_64_gettid +SC_LTTNG_TRACEPOINT_EVENT(gettid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_64_restart_syscall +SC_LTTNG_TRACEPOINT_EVENT(restart_syscall, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_64_inotify_init +SC_LTTNG_TRACEPOINT_EVENT(inotify_init, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#endif /* else #ifdef SC_ENTER */ +#ifndef OVERRIDE_64_nice +SC_LTTNG_TRACEPOINT_EVENT(nice, + TP_PROTO(sc_exit(long ret,) int increment), + TP_ARGS(sc_exit(ret,) increment), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, increment, increment))) +) +#endif +#ifndef OVERRIDE_64_ssetmask +SC_LTTNG_TRACEPOINT_EVENT(ssetmask, + TP_PROTO(sc_exit(long ret,) int newmask), + TP_ARGS(sc_exit(ret,) newmask), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, newmask, newmask))) +) +#endif +#ifndef OVERRIDE_64_personality +SC_LTTNG_TRACEPOINT_EVENT(personality, + TP_PROTO(sc_exit(long ret,) unsigned int personality), + TP_ARGS(sc_exit(ret,) personality), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, personality, personality))) +) +#endif +#ifndef OVERRIDE_64_close +SC_LTTNG_TRACEPOINT_EVENT(close, + TP_PROTO(sc_exit(long ret,) unsigned int fd), + TP_ARGS(sc_exit(ret,) fd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) +) +#endif +#ifndef OVERRIDE_64_brk +SC_LTTNG_TRACEPOINT_EVENT(brk, + TP_PROTO(sc_exit(long ret,) unsigned long brk), + TP_ARGS(sc_exit(ret,) brk), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, brk, brk))) +) +#endif +#ifndef OVERRIDE_64_dup +SC_LTTNG_TRACEPOINT_EVENT(dup, + TP_PROTO(sc_exit(long ret,) unsigned int fildes), + TP_ARGS(sc_exit(ret,) fildes), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fildes, fildes))) +) +#endif +#ifndef OVERRIDE_64_alarm +SC_LTTNG_TRACEPOINT_EVENT(alarm, + TP_PROTO(sc_exit(long ret,) unsigned int seconds), + TP_ARGS(sc_exit(ret,) seconds), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, seconds, seconds))) +) +#endif +#ifndef OVERRIDE_64_exit +SC_LTTNG_TRACEPOINT_EVENT(exit, + TP_PROTO(sc_exit(long ret,) int error_code), + TP_ARGS(sc_exit(ret,) error_code), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, error_code, error_code))) +) +#endif +#ifndef OVERRIDE_64_fsync +SC_LTTNG_TRACEPOINT_EVENT(fsync, + TP_PROTO(sc_exit(long ret,) unsigned int fd), + TP_ARGS(sc_exit(ret,) fd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) +) +#endif +#ifndef OVERRIDE_64_fdatasync +SC_LTTNG_TRACEPOINT_EVENT(fdatasync, + TP_PROTO(sc_exit(long ret,) unsigned int fd), + TP_ARGS(sc_exit(ret,) fd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) +) +#endif +#ifndef OVERRIDE_64_fchdir +SC_LTTNG_TRACEPOINT_EVENT(fchdir, + TP_PROTO(sc_exit(long ret,) unsigned int fd), + TP_ARGS(sc_exit(ret,) fd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) +) +#endif +#ifndef OVERRIDE_64_umask +SC_LTTNG_TRACEPOINT_EVENT(umask, + TP_PROTO(sc_exit(long ret,) int mask), + TP_ARGS(sc_exit(ret,) mask), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, mask, mask))) +) +#endif +#ifndef OVERRIDE_64_setuid +SC_LTTNG_TRACEPOINT_EVENT(setuid, + TP_PROTO(sc_exit(long ret,) uid_t uid), + TP_ARGS(sc_exit(ret,) uid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, uid, uid))) +) +#endif +#ifndef OVERRIDE_64_setgid +SC_LTTNG_TRACEPOINT_EVENT(setgid, + TP_PROTO(sc_exit(long ret,) gid_t gid), + TP_ARGS(sc_exit(ret,) gid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, gid, gid))) +) +#endif +#ifndef OVERRIDE_64_getpgid +SC_LTTNG_TRACEPOINT_EVENT(getpgid, + TP_PROTO(sc_exit(long ret,) pid_t pid), + TP_ARGS(sc_exit(ret,) pid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid))) +) +#endif +#ifndef OVERRIDE_64_setfsuid +SC_LTTNG_TRACEPOINT_EVENT(setfsuid, + TP_PROTO(sc_exit(long ret,) uid_t uid), + TP_ARGS(sc_exit(ret,) uid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, uid, uid))) +) +#endif +#ifndef OVERRIDE_64_setfsgid +SC_LTTNG_TRACEPOINT_EVENT(setfsgid, + TP_PROTO(sc_exit(long ret,) gid_t gid), + TP_ARGS(sc_exit(ret,) gid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, gid, gid))) +) +#endif +#ifndef OVERRIDE_64_getsid +SC_LTTNG_TRACEPOINT_EVENT(getsid, + TP_PROTO(sc_exit(long ret,) pid_t pid), + TP_ARGS(sc_exit(ret,) pid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid))) +) +#endif +#ifndef OVERRIDE_64_32_personality +SC_LTTNG_TRACEPOINT_EVENT(32_personality, + TP_PROTO(sc_exit(long ret,) unsigned long personality), + TP_ARGS(sc_exit(ret,) personality), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned long, personality, personality))) +) +#endif +#ifndef OVERRIDE_64_sched_getscheduler +SC_LTTNG_TRACEPOINT_EVENT(sched_getscheduler, + TP_PROTO(sc_exit(long ret,) pid_t pid), + TP_ARGS(sc_exit(ret,) pid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid))) +) +#endif +#ifndef OVERRIDE_64_sched_get_priority_max +SC_LTTNG_TRACEPOINT_EVENT(sched_get_priority_max, + TP_PROTO(sc_exit(long ret,) int policy), + TP_ARGS(sc_exit(ret,) policy), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, policy, policy))) +) +#endif +#ifndef OVERRIDE_64_sched_get_priority_min +SC_LTTNG_TRACEPOINT_EVENT(sched_get_priority_min, + TP_PROTO(sc_exit(long ret,) int policy), + TP_ARGS(sc_exit(ret,) policy), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, policy, policy))) +) +#endif +#ifndef OVERRIDE_64_mlockall +SC_LTTNG_TRACEPOINT_EVENT(mlockall, + TP_PROTO(sc_exit(long ret,) int flags), + TP_ARGS(sc_exit(ret,) flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_io_destroy +SC_LTTNG_TRACEPOINT_EVENT(io_destroy, + TP_PROTO(sc_exit(long ret,) aio_context_t ctx), + TP_ARGS(sc_exit(ret,) ctx), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx, ctx))) +) +#endif +#ifndef OVERRIDE_64_exit_group +SC_LTTNG_TRACEPOINT_EVENT(exit_group, + TP_PROTO(sc_exit(long ret,) int error_code), + TP_ARGS(sc_exit(ret,) error_code), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, error_code, error_code))) +) +#endif +#ifndef OVERRIDE_64_epoll_create +SC_LTTNG_TRACEPOINT_EVENT(epoll_create, + TP_PROTO(sc_exit(long ret,) int size), + TP_ARGS(sc_exit(ret,) size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, size, size))) +) +#endif +#ifndef OVERRIDE_64_timer_getoverrun +SC_LTTNG_TRACEPOINT_EVENT(timer_getoverrun, + TP_PROTO(sc_exit(long ret,) timer_t timer_id), + TP_ARGS(sc_exit(ret,) timer_id), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id))) +) +#endif +#ifndef OVERRIDE_64_timer_delete +SC_LTTNG_TRACEPOINT_EVENT(timer_delete, + TP_PROTO(sc_exit(long ret,) timer_t timer_id), + TP_ARGS(sc_exit(ret,) timer_id), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id))) +) +#endif +#ifndef OVERRIDE_64_set_thread_area +SC_LTTNG_TRACEPOINT_EVENT(set_thread_area, + TP_PROTO(sc_exit(long ret,) unsigned long addr), + TP_ARGS(sc_exit(ret,) addr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned long, addr, addr))) +) +#endif +#ifndef OVERRIDE_64_unshare +SC_LTTNG_TRACEPOINT_EVENT(unshare, + TP_PROTO(sc_exit(long ret,) unsigned long unshare_flags), + TP_ARGS(sc_exit(ret,) unshare_flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, unshare_flags, unshare_flags))) +) +#endif +#ifndef OVERRIDE_64_eventfd +SC_LTTNG_TRACEPOINT_EVENT(eventfd, + TP_PROTO(sc_exit(long ret,) unsigned int count), + TP_ARGS(sc_exit(ret,) count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, count, count))) +) +#endif +#ifndef OVERRIDE_64_epoll_create1 +SC_LTTNG_TRACEPOINT_EVENT(epoll_create1, + TP_PROTO(sc_exit(long ret,) int flags), + TP_ARGS(sc_exit(ret,) flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_inotify_init1 +SC_LTTNG_TRACEPOINT_EVENT(inotify_init1, + TP_PROTO(sc_exit(long ret,) int flags), + TP_ARGS(sc_exit(ret,) flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_syncfs +SC_LTTNG_TRACEPOINT_EVENT(syncfs, + TP_PROTO(sc_exit(long ret,) int fd), + TP_ARGS(sc_exit(ret,) fd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd))) +) +#endif +#ifndef OVERRIDE_64_bdflush +SC_LTTNG_TRACEPOINT_EVENT(bdflush, + TP_PROTO(sc_exit(long ret,) int func, long data), + TP_ARGS(sc_exit(ret,) func, data), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, func, func)) sc_inout(ctf_integer(long, data, data))) +) +#endif +#ifndef OVERRIDE_64_munmap +SC_LTTNG_TRACEPOINT_EVENT(munmap, + TP_PROTO(sc_exit(long ret,) unsigned long addr, size_t len), + TP_ARGS(sc_exit(ret,) addr, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, addr, addr)) sc_in(ctf_integer(size_t, len, len))) +) +#endif +#ifndef OVERRIDE_64_dup2 +SC_LTTNG_TRACEPOINT_EVENT(dup2, + TP_PROTO(sc_exit(long ret,) unsigned int oldfd, unsigned int newfd), + TP_ARGS(sc_exit(ret,) oldfd, newfd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, oldfd, oldfd)) sc_in(ctf_integer(unsigned int, newfd, newfd))) +) +#endif +#ifndef OVERRIDE_64_shutdown +SC_LTTNG_TRACEPOINT_EVENT(shutdown, + TP_PROTO(sc_exit(long ret,) int fd, int how), + TP_ARGS(sc_exit(ret,) fd, how), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, how, how))) +) +#endif +#ifndef OVERRIDE_64_listen +SC_LTTNG_TRACEPOINT_EVENT(listen, + TP_PROTO(sc_exit(long ret,) int fd, int backlog), + TP_ARGS(sc_exit(ret,) fd, backlog), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, backlog, backlog))) +) +#endif +#ifndef OVERRIDE_64_kill +SC_LTTNG_TRACEPOINT_EVENT(kill, + TP_PROTO(sc_exit(long ret,) pid_t pid, int sig), + TP_ARGS(sc_exit(ret,) pid, sig), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig))) +) +#endif +#ifndef OVERRIDE_64_msgget +SC_LTTNG_TRACEPOINT_EVENT(msgget, + TP_PROTO(sc_exit(long ret,) key_t key, int msgflg), + TP_ARGS(sc_exit(ret,) key, msgflg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(key_t, key, key)) sc_in(ctf_integer(int, msgflg, msgflg))) +) +#endif +#ifndef OVERRIDE_64_flock +SC_LTTNG_TRACEPOINT_EVENT(flock, + TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd), + TP_ARGS(sc_exit(ret,) fd, cmd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned int, cmd, cmd))) +) +#endif +#ifndef OVERRIDE_64_ftruncate +SC_LTTNG_TRACEPOINT_EVENT(ftruncate, + TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned long length), + TP_ARGS(sc_exit(ret,) fd, length), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned long, length, length))) +) +#endif +#ifndef OVERRIDE_64_fchmod +SC_LTTNG_TRACEPOINT_EVENT(fchmod, + TP_PROTO(sc_exit(long ret,) unsigned int fd, umode_t mode), + TP_ARGS(sc_exit(ret,) fd, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(umode_t, mode, mode))) +) +#endif +#ifndef OVERRIDE_64_setpgid +SC_LTTNG_TRACEPOINT_EVENT(setpgid, + TP_PROTO(sc_exit(long ret,) pid_t pid, pid_t pgid), + TP_ARGS(sc_exit(ret,) pid, pgid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(pid_t, pgid, pgid))) +) +#endif +#ifndef OVERRIDE_64_setreuid +SC_LTTNG_TRACEPOINT_EVENT(setreuid, + TP_PROTO(sc_exit(long ret,) uid_t ruid, uid_t euid), + TP_ARGS(sc_exit(ret,) ruid, euid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, ruid, ruid)) sc_in(ctf_integer(uid_t, euid, euid))) +) +#endif +#ifndef OVERRIDE_64_setregid +SC_LTTNG_TRACEPOINT_EVENT(setregid, + TP_PROTO(sc_exit(long ret,) gid_t rgid, gid_t egid), + TP_ARGS(sc_exit(ret,) rgid, egid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, rgid, rgid)) sc_in(ctf_integer(gid_t, egid, egid))) +) +#endif +#ifndef OVERRIDE_64_getpriority +SC_LTTNG_TRACEPOINT_EVENT(getpriority, + TP_PROTO(sc_exit(long ret,) int which, int who), + TP_ARGS(sc_exit(ret,) which, who), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who))) +) +#endif +#ifndef OVERRIDE_64_mlock +SC_LTTNG_TRACEPOINT_EVENT(mlock, + TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len), + TP_ARGS(sc_exit(ret,) start, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len))) +) +#endif +#ifndef OVERRIDE_64_munlock +SC_LTTNG_TRACEPOINT_EVENT(munlock, + TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len), + TP_ARGS(sc_exit(ret,) start, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len))) +) +#endif +#ifndef OVERRIDE_64_tkill +SC_LTTNG_TRACEPOINT_EVENT(tkill, + TP_PROTO(sc_exit(long ret,) pid_t pid, int sig), + TP_ARGS(sc_exit(ret,) pid, sig), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig))) +) +#endif +#ifndef OVERRIDE_64_inotify_rm_watch +SC_LTTNG_TRACEPOINT_EVENT(inotify_rm_watch, + TP_PROTO(sc_exit(long ret,) int fd, __s32 wd), + TP_ARGS(sc_exit(ret,) fd, wd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(__s32, wd, wd))) +) +#endif +#ifndef OVERRIDE_64_ioprio_get +SC_LTTNG_TRACEPOINT_EVENT(ioprio_get, + TP_PROTO(sc_exit(long ret,) int which, int who), + TP_ARGS(sc_exit(ret,) which, who), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who))) +) +#endif +#ifndef OVERRIDE_64_timerfd_create +SC_LTTNG_TRACEPOINT_EVENT(timerfd_create, + TP_PROTO(sc_exit(long ret,) int clockid, int flags), + TP_ARGS(sc_exit(ret,) clockid, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, clockid, clockid)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_eventfd2 +SC_LTTNG_TRACEPOINT_EVENT(eventfd2, + TP_PROTO(sc_exit(long ret,) unsigned int count, int flags), + TP_ARGS(sc_exit(ret,) count, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, count, count)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_setns +SC_LTTNG_TRACEPOINT_EVENT(setns, + TP_PROTO(sc_exit(long ret,) int fd, int nstype), + TP_ARGS(sc_exit(ret,) fd, nstype), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, nstype, nstype))) +) +#endif +#ifndef OVERRIDE_64_ioctl +SC_LTTNG_TRACEPOINT_EVENT(ioctl, + TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd, unsigned long arg), + TP_ARGS(sc_exit(ret,) fd, cmd, arg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_inout(ctf_integer(unsigned long, arg, arg))) +) +#endif +#ifndef OVERRIDE_64_fcntl +SC_LTTNG_TRACEPOINT_EVENT(fcntl, + TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd, unsigned long arg), + TP_ARGS(sc_exit(ret,) fd, cmd, arg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_inout(ctf_integer(unsigned long, arg, arg))) +) +#endif +#ifndef OVERRIDE_64_lseek +SC_LTTNG_TRACEPOINT_EVENT(lseek, + TP_PROTO(sc_exit(long ret,) unsigned int fd, off_t offset, unsigned int origin), + TP_ARGS(sc_exit(ret,) fd, offset, origin), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(off_t, offset, offset)) sc_in(ctf_integer(unsigned int, origin, origin))) +) +#endif +#ifndef OVERRIDE_64_mprotect +SC_LTTNG_TRACEPOINT_EVENT(mprotect, + TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len, unsigned long prot), + TP_ARGS(sc_exit(ret,) start, len, prot), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned long, prot, prot))) +) +#endif +#ifndef OVERRIDE_64_msync +SC_LTTNG_TRACEPOINT_EVENT(msync, + TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len, int flags), + TP_ARGS(sc_exit(ret,) start, len, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_madvise +SC_LTTNG_TRACEPOINT_EVENT(madvise, + TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len_in, int behavior), + TP_ARGS(sc_exit(ret,) start, len_in, behavior), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len_in, len_in)) sc_in(ctf_integer(int, behavior, behavior))) +) +#endif +#ifndef OVERRIDE_64_shmget +SC_LTTNG_TRACEPOINT_EVENT(shmget, + TP_PROTO(sc_exit(long ret,) key_t key, size_t size, int shmflg), + TP_ARGS(sc_exit(ret,) key, size, shmflg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(key_t, key, key)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(int, shmflg, shmflg))) +) +#endif +#ifndef OVERRIDE_64_socket +SC_LTTNG_TRACEPOINT_EVENT(socket, + TP_PROTO(sc_exit(long ret,) int family, int type, int protocol), + TP_ARGS(sc_exit(ret,) family, type, protocol), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, family, family)) sc_in(ctf_integer(int, type, type)) sc_in(ctf_integer(int, protocol, protocol))) +) +#endif +#ifndef OVERRIDE_64_semget +SC_LTTNG_TRACEPOINT_EVENT(semget, + TP_PROTO(sc_exit(long ret,) key_t key, int nsems, int semflg), + TP_ARGS(sc_exit(ret,) key, nsems, semflg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(key_t, key, key)) sc_in(ctf_integer(int, nsems, nsems)) sc_in(ctf_integer(int, semflg, semflg))) +) +#endif +#ifndef OVERRIDE_64_fchown +SC_LTTNG_TRACEPOINT_EVENT(fchown, + TP_PROTO(sc_exit(long ret,) unsigned int fd, uid_t user, gid_t group), + TP_ARGS(sc_exit(ret,) fd, user, group), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group))) +) +#endif +#ifndef OVERRIDE_64_setresuid +SC_LTTNG_TRACEPOINT_EVENT(setresuid, + TP_PROTO(sc_exit(long ret,) uid_t ruid, uid_t euid, uid_t suid), + TP_ARGS(sc_exit(ret,) ruid, euid, suid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, ruid, ruid)) sc_in(ctf_integer(uid_t, euid, euid)) sc_in(ctf_integer(uid_t, suid, suid))) +) +#endif +#ifndef OVERRIDE_64_setresgid +SC_LTTNG_TRACEPOINT_EVENT(setresgid, + TP_PROTO(sc_exit(long ret,) gid_t rgid, gid_t egid, gid_t sgid), + TP_ARGS(sc_exit(ret,) rgid, egid, sgid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, rgid, rgid)) sc_in(ctf_integer(gid_t, egid, egid)) sc_in(ctf_integer(gid_t, sgid, sgid))) +) +#endif +#ifndef OVERRIDE_64_sysfs +SC_LTTNG_TRACEPOINT_EVENT(sysfs, + TP_PROTO(sc_exit(long ret,) int option, unsigned long arg1, unsigned long arg2), + TP_ARGS(sc_exit(ret,) option, arg1, arg2), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, option, option)) sc_in(ctf_integer(unsigned long, arg1, arg1)) sc_in(ctf_integer(unsigned long, arg2, arg2))) +) +#endif +#ifndef OVERRIDE_64_setpriority +SC_LTTNG_TRACEPOINT_EVENT(setpriority, + TP_PROTO(sc_exit(long ret,) int which, int who, int niceval), + TP_ARGS(sc_exit(ret,) which, who, niceval), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who)) sc_in(ctf_integer(int, niceval, niceval))) +) +#endif +#ifndef OVERRIDE_64_cacheflush +SC_LTTNG_TRACEPOINT_EVENT(cacheflush, + TP_PROTO(sc_exit(long ret,) unsigned long addr, unsigned long bytes, unsigned int cache), + TP_ARGS(sc_exit(ret,) addr, bytes, cache), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned long, addr, addr)) sc_inout(ctf_integer(unsigned long, bytes, bytes)) sc_inout(ctf_integer(unsigned int, cache, cache))) +) +#endif +#ifndef OVERRIDE_64_tgkill +SC_LTTNG_TRACEPOINT_EVENT(tgkill, + TP_PROTO(sc_exit(long ret,) pid_t tgid, pid_t pid, int sig), + TP_ARGS(sc_exit(ret,) tgid, pid, sig), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, tgid, tgid)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig))) +) +#endif +#ifndef OVERRIDE_64_ioprio_set +SC_LTTNG_TRACEPOINT_EVENT(ioprio_set, + TP_PROTO(sc_exit(long ret,) int which, int who, int ioprio), + TP_ARGS(sc_exit(ret,) which, who, ioprio), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who)) sc_in(ctf_integer(int, ioprio, ioprio))) +) +#endif +#ifndef OVERRIDE_64_dup3 +SC_LTTNG_TRACEPOINT_EVENT(dup3, + TP_PROTO(sc_exit(long ret,) unsigned int oldfd, unsigned int newfd, int flags), + TP_ARGS(sc_exit(ret,) oldfd, newfd, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, oldfd, oldfd)) sc_in(ctf_integer(unsigned int, newfd, newfd)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_32_ftruncate64 +SC_LTTNG_TRACEPOINT_EVENT(32_ftruncate64, + TP_PROTO(sc_exit(long ret,) unsigned long fd, unsigned long __dummy, unsigned long a2, unsigned long a3), + TP_ARGS(sc_exit(ret,) fd, __dummy, a2, a3), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned long, fd, fd)) sc_inout(ctf_integer(unsigned long, __dummy, __dummy)) sc_inout(ctf_integer(unsigned long, a2, a2)) sc_inout(ctf_integer(unsigned long, a3, a3))) +) +#endif +#ifndef OVERRIDE_64_ptrace +SC_LTTNG_TRACEPOINT_EVENT(ptrace, + TP_PROTO(sc_exit(long ret,) long request, long pid, unsigned long addr, unsigned long data), + TP_ARGS(sc_exit(ret,) request, pid, addr, data), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(long, request, request)) sc_in(ctf_integer(long, pid, pid)) sc_inout(ctf_integer(unsigned long, addr, addr)) sc_inout(ctf_integer(unsigned long, data, data))) +) +#endif +#ifndef OVERRIDE_64_n32_semctl +SC_LTTNG_TRACEPOINT_EVENT(n32_semctl, + TP_PROTO(sc_exit(long ret,) int semid, int semnum, int cmd, u32 arg), + TP_ARGS(sc_exit(ret,) semid, semnum, cmd, arg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, semid, semid)) sc_inout(ctf_integer(int, semnum, semnum)) sc_inout(ctf_integer(int, cmd, cmd)) sc_inout(ctf_integer(u32, arg, arg))) +) +#endif +#ifndef OVERRIDE_64_n32_msgsnd +SC_LTTNG_TRACEPOINT_EVENT(n32_msgsnd, + TP_PROTO(sc_exit(long ret,) int msqid, u32 msgp, unsigned int msgsz, int msgflg), + TP_ARGS(sc_exit(ret,) msqid, msgp, msgsz, msgflg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, msqid, msqid)) sc_inout(ctf_integer(u32, msgp, msgp)) sc_inout(ctf_integer(unsigned int, msgsz, msgsz)) sc_inout(ctf_integer(int, msgflg, msgflg))) +) +#endif +#ifndef OVERRIDE_64_tee +SC_LTTNG_TRACEPOINT_EVENT(tee, + TP_PROTO(sc_exit(long ret,) int fdin, int fdout, size_t len, unsigned int flags), + TP_ARGS(sc_exit(ret,) fdin, fdout, len, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fdin, fdin)) sc_in(ctf_integer(int, fdout, fdout)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_mremap +SC_LTTNG_TRACEPOINT_EVENT(mremap, + TP_PROTO(sc_exit(long ret,) unsigned long addr, unsigned long old_len, unsigned long new_len, unsigned long flags, unsigned long new_addr), + TP_ARGS(sc_exit(ret,) addr, old_len, new_len, flags, new_addr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, addr, addr)) sc_in(ctf_integer(unsigned long, old_len, old_len)) sc_in(ctf_integer(unsigned long, new_len, new_len)) sc_in(ctf_integer(unsigned long, flags, flags)) sc_in(ctf_integer(unsigned long, new_addr, new_addr))) +) +#endif +#ifndef OVERRIDE_64_n32_msgrcv +SC_LTTNG_TRACEPOINT_EVENT(n32_msgrcv, + TP_PROTO(sc_exit(long ret,) int msqid, u32 msgp, size_t msgsz, int msgtyp, int msgflg), + TP_ARGS(sc_exit(ret,) msqid, msgp, msgsz, msgtyp, msgflg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, msqid, msqid)) sc_inout(ctf_integer(u32, msgp, msgp)) sc_inout(ctf_integer(size_t, msgsz, msgsz)) sc_inout(ctf_integer(int, msgtyp, msgtyp)) sc_inout(ctf_integer(int, msgflg, msgflg))) +) +#endif +#ifndef OVERRIDE_64_prctl +SC_LTTNG_TRACEPOINT_EVENT(prctl, + TP_PROTO(sc_exit(long ret,) int option, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5), + TP_ARGS(sc_exit(ret,) option, arg2, arg3, arg4, arg5), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, option, option)) sc_inout(ctf_integer(unsigned long, arg2, arg2)) sc_in(ctf_integer(unsigned long, arg3, arg3)) sc_in(ctf_integer(unsigned long, arg4, arg4)) sc_in(ctf_integer(unsigned long, arg5, arg5))) +) +#endif +#ifndef OVERRIDE_64_remap_file_pages +SC_LTTNG_TRACEPOINT_EVENT(remap_file_pages, + TP_PROTO(sc_exit(long ret,) unsigned long start, unsigned long size, unsigned long prot, unsigned long pgoff, unsigned long flags), + TP_ARGS(sc_exit(ret,) start, size, prot, pgoff, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(unsigned long, size, size)) sc_in(ctf_integer(unsigned long, prot, prot)) sc_in(ctf_integer(unsigned long, pgoff, pgoff)) sc_in(ctf_integer(unsigned long, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_32_ipc +SC_LTTNG_TRACEPOINT_EVENT(32_ipc, + TP_PROTO(sc_exit(long ret,) u32 call, long first, long second, long third, unsigned long ptr, unsigned long fifth), + TP_ARGS(sc_exit(ret,) call, first, second, third, ptr, fifth), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(u32, call, call)) sc_inout(ctf_integer(long, first, first)) sc_inout(ctf_integer(long, second, second)) sc_inout(ctf_integer(long, third, third)) sc_inout(ctf_integer(unsigned long, ptr, ptr)) sc_inout(ctf_integer(unsigned long, fifth, fifth))) +) +#endif +#ifndef OVERRIDE_64_mips_mmap2 +SC_LTTNG_TRACEPOINT_EVENT(mips_mmap2, + TP_PROTO(sc_exit(long ret,) unsigned long addr, unsigned long len, unsigned long prot, unsigned long flags, unsigned long fd, unsigned long pgoff), + TP_ARGS(sc_exit(ret,) addr, len, prot, flags, fd, pgoff), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned long, addr, addr)) sc_inout(ctf_integer(unsigned long, len, len)) sc_inout(ctf_integer(unsigned long, prot, prot)) sc_inout(ctf_integer(unsigned long, flags, flags)) sc_inout(ctf_integer(unsigned long, fd, fd)) sc_inout(ctf_integer(unsigned long, pgoff, pgoff))) +) +#endif +#ifndef OVERRIDE_64_mips_mmap +SC_LTTNG_TRACEPOINT_EVENT(mips_mmap, + TP_PROTO(sc_exit(long ret,) unsigned long addr, unsigned long len, unsigned long prot, unsigned long flags, unsigned long fd, off_t offset), + TP_ARGS(sc_exit(ret,) addr, len, prot, flags, fd, offset), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned long, addr, addr)) sc_inout(ctf_integer(unsigned long, len, len)) sc_inout(ctf_integer(unsigned long, prot, prot)) sc_inout(ctf_integer(unsigned long, flags, flags)) sc_inout(ctf_integer(unsigned long, fd, fd)) sc_inout(ctf_integer(off_t, offset, offset))) +) +#endif + +#endif /* _TRACE_SYSCALLS_INTEGERS_H */ + +/* This part must be outside protection */ +#include + +#else /* CREATE_SYSCALL_TABLE */ + +#include "mips-64-syscalls_integers_override.h" +#include "syscalls_integers_override.h" + +#ifdef SC_ENTER +#ifndef OVERRIDE_TABLE_64_sgetmask +TRACE_SYSCALL_TABLE(syscalls_noargs, sgetmask, 4068, 0) +#endif +#ifndef OVERRIDE_TABLE_64_sched_yield +TRACE_SYSCALL_TABLE(syscalls_noargs, sched_yield, 6023, 0) +#endif +#ifndef OVERRIDE_TABLE_64_pause +TRACE_SYSCALL_TABLE(syscalls_noargs, pause, 6033, 0) +#endif +#ifndef OVERRIDE_TABLE_64_getpid +TRACE_SYSCALL_TABLE(syscalls_noargs, getpid, 6038, 0) +#endif +#ifndef OVERRIDE_TABLE_64_getuid +TRACE_SYSCALL_TABLE(syscalls_noargs, getuid, 6100, 0) +#endif +#ifndef OVERRIDE_TABLE_64_getgid +TRACE_SYSCALL_TABLE(syscalls_noargs, getgid, 6102, 0) +#endif +#ifndef OVERRIDE_TABLE_64_geteuid +TRACE_SYSCALL_TABLE(syscalls_noargs, geteuid, 6105, 0) +#endif +#ifndef OVERRIDE_TABLE_64_getegid +TRACE_SYSCALL_TABLE(syscalls_noargs, getegid, 6106, 0) +#endif +#ifndef OVERRIDE_TABLE_64_getppid +TRACE_SYSCALL_TABLE(syscalls_noargs, getppid, 6108, 0) +#endif +#ifndef OVERRIDE_TABLE_64_getpgrp +TRACE_SYSCALL_TABLE(syscalls_noargs, getpgrp, 6109, 0) +#endif +#ifndef OVERRIDE_TABLE_64_setsid +TRACE_SYSCALL_TABLE(syscalls_noargs, setsid, 6110, 0) +#endif +#ifndef OVERRIDE_TABLE_64_munlockall +TRACE_SYSCALL_TABLE(syscalls_noargs, munlockall, 6149, 0) +#endif +#ifndef OVERRIDE_TABLE_64_vhangup +TRACE_SYSCALL_TABLE(syscalls_noargs, vhangup, 6150, 0) +#endif +#ifndef OVERRIDE_TABLE_64_sync +TRACE_SYSCALL_TABLE(syscalls_noargs, sync, 6157, 0) +#endif +#ifndef OVERRIDE_TABLE_64_gettid +TRACE_SYSCALL_TABLE(syscalls_noargs, gettid, 6178, 0) +#endif +#ifndef OVERRIDE_TABLE_64_restart_syscall +TRACE_SYSCALL_TABLE(syscalls_noargs, restart_syscall, 6214, 0) +#endif +#ifndef OVERRIDE_TABLE_64_inotify_init +TRACE_SYSCALL_TABLE(syscalls_noargs, inotify_init, 6247, 0) +#endif +#else /* #ifdef SC_ENTER */ +#ifndef OVERRIDE_TABLE_64_sgetmask +TRACE_SYSCALL_TABLE(sgetmask, sgetmask, 4068, 0) +#endif +#ifndef OVERRIDE_TABLE_64_sched_yield +TRACE_SYSCALL_TABLE(sched_yield, sched_yield, 6023, 0) +#endif +#ifndef OVERRIDE_TABLE_64_pause +TRACE_SYSCALL_TABLE(pause, pause, 6033, 0) +#endif +#ifndef OVERRIDE_TABLE_64_getpid +TRACE_SYSCALL_TABLE(getpid, getpid, 6038, 0) +#endif +#ifndef OVERRIDE_TABLE_64_getuid +TRACE_SYSCALL_TABLE(getuid, getuid, 6100, 0) +#endif +#ifndef OVERRIDE_TABLE_64_getgid +TRACE_SYSCALL_TABLE(getgid, getgid, 6102, 0) +#endif +#ifndef OVERRIDE_TABLE_64_geteuid +TRACE_SYSCALL_TABLE(geteuid, geteuid, 6105, 0) +#endif +#ifndef OVERRIDE_TABLE_64_getegid +TRACE_SYSCALL_TABLE(getegid, getegid, 6106, 0) +#endif +#ifndef OVERRIDE_TABLE_64_getppid +TRACE_SYSCALL_TABLE(getppid, getppid, 6108, 0) +#endif +#ifndef OVERRIDE_TABLE_64_getpgrp +TRACE_SYSCALL_TABLE(getpgrp, getpgrp, 6109, 0) +#endif +#ifndef OVERRIDE_TABLE_64_setsid +TRACE_SYSCALL_TABLE(setsid, setsid, 6110, 0) +#endif +#ifndef OVERRIDE_TABLE_64_munlockall +TRACE_SYSCALL_TABLE(munlockall, munlockall, 6149, 0) +#endif +#ifndef OVERRIDE_TABLE_64_vhangup +TRACE_SYSCALL_TABLE(vhangup, vhangup, 6150, 0) +#endif +#ifndef OVERRIDE_TABLE_64_sync +TRACE_SYSCALL_TABLE(sync, sync, 6157, 0) +#endif +#ifndef OVERRIDE_TABLE_64_gettid +TRACE_SYSCALL_TABLE(gettid, gettid, 6178, 0) +#endif +#ifndef OVERRIDE_TABLE_64_restart_syscall +TRACE_SYSCALL_TABLE(restart_syscall, restart_syscall, 6214, 0) +#endif +#ifndef OVERRIDE_TABLE_64_inotify_init +TRACE_SYSCALL_TABLE(inotify_init, inotify_init, 6247, 0) +#endif +#endif /* else #ifdef SC_ENTER */ +#ifndef OVERRIDE_TABLE_64_nice +TRACE_SYSCALL_TABLE(nice, nice, 4034, 1) +#endif +#ifndef OVERRIDE_TABLE_64_ssetmask +TRACE_SYSCALL_TABLE(ssetmask, ssetmask, 4069, 1) +#endif +#ifndef OVERRIDE_TABLE_64_32_ipc +TRACE_SYSCALL_TABLE(32_ipc, 32_ipc, 4117, 6) +#endif +#ifndef OVERRIDE_TABLE_64_bdflush +TRACE_SYSCALL_TABLE(bdflush, bdflush, 4134, 2) +#endif +#ifndef OVERRIDE_TABLE_64_mips_mmap2 +TRACE_SYSCALL_TABLE(mips_mmap2, mips_mmap2, 4210, 6) +#endif +#ifndef OVERRIDE_TABLE_64_32_ftruncate64 +TRACE_SYSCALL_TABLE(32_ftruncate64, 32_ftruncate64, 4212, 4) +#endif +#ifndef OVERRIDE_TABLE_64_ioctl +TRACE_SYSCALL_TABLE(ioctl, ioctl, 5015, 3) +#endif +#ifndef OVERRIDE_TABLE_64_fcntl +TRACE_SYSCALL_TABLE(fcntl, fcntl, 5070, 3) +#endif +#ifndef OVERRIDE_TABLE_64_ptrace +TRACE_SYSCALL_TABLE(ptrace, ptrace, 5099, 4) +#endif +#ifndef OVERRIDE_TABLE_64_personality +TRACE_SYSCALL_TABLE(personality, personality, 5132, 1) +#endif +#ifndef OVERRIDE_TABLE_64_close +TRACE_SYSCALL_TABLE(close, close, 6003, 1) +#endif +#ifndef OVERRIDE_TABLE_64_lseek +TRACE_SYSCALL_TABLE(lseek, lseek, 6008, 3) +#endif +#ifndef OVERRIDE_TABLE_64_mips_mmap +TRACE_SYSCALL_TABLE(mips_mmap, mips_mmap, 6009, 6) +#endif +#ifndef OVERRIDE_TABLE_64_mprotect +TRACE_SYSCALL_TABLE(mprotect, mprotect, 6010, 3) +#endif +#ifndef OVERRIDE_TABLE_64_munmap +TRACE_SYSCALL_TABLE(munmap, munmap, 6011, 2) +#endif +#ifndef OVERRIDE_TABLE_64_brk +TRACE_SYSCALL_TABLE(brk, brk, 6012, 1) +#endif +#ifndef OVERRIDE_TABLE_64_mremap +TRACE_SYSCALL_TABLE(mremap, mremap, 6024, 5) +#endif +#ifndef OVERRIDE_TABLE_64_msync +TRACE_SYSCALL_TABLE(msync, msync, 6025, 3) +#endif +#ifndef OVERRIDE_TABLE_64_madvise +TRACE_SYSCALL_TABLE(madvise, madvise, 6027, 3) +#endif +#ifndef OVERRIDE_TABLE_64_shmget +TRACE_SYSCALL_TABLE(shmget, shmget, 6028, 3) +#endif +#ifndef OVERRIDE_TABLE_64_dup +TRACE_SYSCALL_TABLE(dup, dup, 6031, 1) +#endif +#ifndef OVERRIDE_TABLE_64_dup2 +TRACE_SYSCALL_TABLE(dup2, dup2, 6032, 2) +#endif +#ifndef OVERRIDE_TABLE_64_alarm +TRACE_SYSCALL_TABLE(alarm, alarm, 6037, 1) +#endif +#ifndef OVERRIDE_TABLE_64_socket +TRACE_SYSCALL_TABLE(socket, socket, 6040, 3) +#endif +#ifndef OVERRIDE_TABLE_64_shutdown +TRACE_SYSCALL_TABLE(shutdown, shutdown, 6047, 2) +#endif +#ifndef OVERRIDE_TABLE_64_listen +TRACE_SYSCALL_TABLE(listen, listen, 6049, 2) +#endif +#ifndef OVERRIDE_TABLE_64_exit +TRACE_SYSCALL_TABLE(exit, exit, 6058, 1) +#endif +#ifndef OVERRIDE_TABLE_64_kill +TRACE_SYSCALL_TABLE(kill, kill, 6060, 2) +#endif +#ifndef OVERRIDE_TABLE_64_semget +TRACE_SYSCALL_TABLE(semget, semget, 6062, 3) +#endif +#ifndef OVERRIDE_TABLE_64_n32_semctl +TRACE_SYSCALL_TABLE(n32_semctl, n32_semctl, 6064, 4) +#endif +#ifndef OVERRIDE_TABLE_64_msgget +TRACE_SYSCALL_TABLE(msgget, msgget, 6066, 2) +#endif +#ifndef OVERRIDE_TABLE_64_n32_msgsnd +TRACE_SYSCALL_TABLE(n32_msgsnd, n32_msgsnd, 6067, 4) +#endif +#ifndef OVERRIDE_TABLE_64_n32_msgrcv +TRACE_SYSCALL_TABLE(n32_msgrcv, n32_msgrcv, 6068, 5) +#endif +#ifndef OVERRIDE_TABLE_64_flock +TRACE_SYSCALL_TABLE(flock, flock, 6071, 2) +#endif +#ifndef OVERRIDE_TABLE_64_fsync +TRACE_SYSCALL_TABLE(fsync, fsync, 6072, 1) +#endif +#ifndef OVERRIDE_TABLE_64_fdatasync +TRACE_SYSCALL_TABLE(fdatasync, fdatasync, 6073, 1) +#endif +#ifndef OVERRIDE_TABLE_64_ftruncate +TRACE_SYSCALL_TABLE(ftruncate, ftruncate, 6075, 2) +#endif +#ifndef OVERRIDE_TABLE_64_fchdir +TRACE_SYSCALL_TABLE(fchdir, fchdir, 6079, 1) +#endif +#ifndef OVERRIDE_TABLE_64_fchmod +TRACE_SYSCALL_TABLE(fchmod, fchmod, 6089, 2) +#endif +#ifndef OVERRIDE_TABLE_64_fchown +TRACE_SYSCALL_TABLE(fchown, fchown, 6091, 3) +#endif +#ifndef OVERRIDE_TABLE_64_umask +TRACE_SYSCALL_TABLE(umask, umask, 6093, 1) +#endif +#ifndef OVERRIDE_TABLE_64_setuid +TRACE_SYSCALL_TABLE(setuid, setuid, 6103, 1) +#endif +#ifndef OVERRIDE_TABLE_64_setgid +TRACE_SYSCALL_TABLE(setgid, setgid, 6104, 1) +#endif +#ifndef OVERRIDE_TABLE_64_setpgid +TRACE_SYSCALL_TABLE(setpgid, setpgid, 6107, 2) +#endif +#ifndef OVERRIDE_TABLE_64_setreuid +TRACE_SYSCALL_TABLE(setreuid, setreuid, 6111, 2) +#endif +#ifndef OVERRIDE_TABLE_64_setregid +TRACE_SYSCALL_TABLE(setregid, setregid, 6112, 2) +#endif +#ifndef OVERRIDE_TABLE_64_setresuid +TRACE_SYSCALL_TABLE(setresuid, setresuid, 6115, 3) +#endif +#ifndef OVERRIDE_TABLE_64_setresgid +TRACE_SYSCALL_TABLE(setresgid, setresgid, 6117, 3) +#endif +#ifndef OVERRIDE_TABLE_64_getpgid +TRACE_SYSCALL_TABLE(getpgid, getpgid, 6119, 1) +#endif +#ifndef OVERRIDE_TABLE_64_setfsuid +TRACE_SYSCALL_TABLE(setfsuid, setfsuid, 6120, 1) +#endif +#ifndef OVERRIDE_TABLE_64_setfsgid +TRACE_SYSCALL_TABLE(setfsgid, setfsgid, 6121, 1) +#endif +#ifndef OVERRIDE_TABLE_64_getsid +TRACE_SYSCALL_TABLE(getsid, getsid, 6122, 1) +#endif +#ifndef OVERRIDE_TABLE_64_32_personality +TRACE_SYSCALL_TABLE(32_personality, 32_personality, 6132, 1) +#endif +#ifndef OVERRIDE_TABLE_64_sysfs +TRACE_SYSCALL_TABLE(sysfs, sysfs, 6136, 3) +#endif +#ifndef OVERRIDE_TABLE_64_getpriority +TRACE_SYSCALL_TABLE(getpriority, getpriority, 6137, 2) +#endif +#ifndef OVERRIDE_TABLE_64_setpriority +TRACE_SYSCALL_TABLE(setpriority, setpriority, 6138, 3) +#endif +#ifndef OVERRIDE_TABLE_64_sched_getscheduler +TRACE_SYSCALL_TABLE(sched_getscheduler, sched_getscheduler, 6142, 1) +#endif +#ifndef OVERRIDE_TABLE_64_sched_get_priority_max +TRACE_SYSCALL_TABLE(sched_get_priority_max, sched_get_priority_max, 6143, 1) +#endif +#ifndef OVERRIDE_TABLE_64_sched_get_priority_min +TRACE_SYSCALL_TABLE(sched_get_priority_min, sched_get_priority_min, 6144, 1) +#endif +#ifndef OVERRIDE_TABLE_64_mlock +TRACE_SYSCALL_TABLE(mlock, mlock, 6146, 2) +#endif +#ifndef OVERRIDE_TABLE_64_munlock +TRACE_SYSCALL_TABLE(munlock, munlock, 6147, 2) +#endif +#ifndef OVERRIDE_TABLE_64_mlockall +TRACE_SYSCALL_TABLE(mlockall, mlockall, 6148, 1) +#endif +#ifndef OVERRIDE_TABLE_64_prctl +TRACE_SYSCALL_TABLE(prctl, prctl, 6153, 5) +#endif +#ifndef OVERRIDE_TABLE_64_tkill +TRACE_SYSCALL_TABLE(tkill, tkill, 6192, 2) +#endif +#ifndef OVERRIDE_TABLE_64_cacheflush +TRACE_SYSCALL_TABLE(cacheflush, cacheflush, 6197, 3) +#endif +#ifndef OVERRIDE_TABLE_64_io_destroy +TRACE_SYSCALL_TABLE(io_destroy, io_destroy, 6201, 1) +#endif +#ifndef OVERRIDE_TABLE_64_exit_group +TRACE_SYSCALL_TABLE(exit_group, exit_group, 6205, 1) +#endif +#ifndef OVERRIDE_TABLE_64_epoll_create +TRACE_SYSCALL_TABLE(epoll_create, epoll_create, 6207, 1) +#endif +#ifndef OVERRIDE_TABLE_64_remap_file_pages +TRACE_SYSCALL_TABLE(remap_file_pages, remap_file_pages, 6210, 5) +#endif +#ifndef OVERRIDE_TABLE_64_timer_getoverrun +TRACE_SYSCALL_TABLE(timer_getoverrun, timer_getoverrun, 6223, 1) +#endif +#ifndef OVERRIDE_TABLE_64_timer_delete +TRACE_SYSCALL_TABLE(timer_delete, timer_delete, 6224, 1) +#endif +#ifndef OVERRIDE_TABLE_64_tgkill +TRACE_SYSCALL_TABLE(tgkill, tgkill, 6229, 3) +#endif +#ifndef OVERRIDE_TABLE_64_set_thread_area +TRACE_SYSCALL_TABLE(set_thread_area, set_thread_area, 6246, 1) +#endif +#ifndef OVERRIDE_TABLE_64_inotify_rm_watch +TRACE_SYSCALL_TABLE(inotify_rm_watch, inotify_rm_watch, 6249, 2) +#endif +#ifndef OVERRIDE_TABLE_64_unshare +TRACE_SYSCALL_TABLE(unshare, unshare, 6266, 1) +#endif +#ifndef OVERRIDE_TABLE_64_tee +TRACE_SYSCALL_TABLE(tee, tee, 6269, 4) +#endif +#ifndef OVERRIDE_TABLE_64_ioprio_set +TRACE_SYSCALL_TABLE(ioprio_set, ioprio_set, 6277, 3) +#endif +#ifndef OVERRIDE_TABLE_64_ioprio_get +TRACE_SYSCALL_TABLE(ioprio_get, ioprio_get, 6278, 2) +#endif +#ifndef OVERRIDE_TABLE_64_eventfd +TRACE_SYSCALL_TABLE(eventfd, eventfd, 6282, 1) +#endif +#ifndef OVERRIDE_TABLE_64_timerfd_create +TRACE_SYSCALL_TABLE(timerfd_create, timerfd_create, 6284, 2) +#endif +#ifndef OVERRIDE_TABLE_64_eventfd2 +TRACE_SYSCALL_TABLE(eventfd2, eventfd2, 6288, 2) +#endif +#ifndef OVERRIDE_TABLE_64_epoll_create1 +TRACE_SYSCALL_TABLE(epoll_create1, epoll_create1, 6289, 1) +#endif +#ifndef OVERRIDE_TABLE_64_dup3 +TRACE_SYSCALL_TABLE(dup3, dup3, 6290, 3) +#endif +#ifndef OVERRIDE_TABLE_64_inotify_init1 +TRACE_SYSCALL_TABLE(inotify_init1, inotify_init1, 6292, 1) +#endif +#ifndef OVERRIDE_TABLE_64_syncfs +TRACE_SYSCALL_TABLE(syncfs, syncfs, 6306, 1) +#endif +#ifndef OVERRIDE_TABLE_64_setns +TRACE_SYSCALL_TABLE(setns, setns, 6308, 2) +#endif + +#endif /* CREATE_SYSCALL_TABLE */ diff --git a/include/instrumentation/syscalls/headers/mips-64-syscalls_integers_override.h b/include/instrumentation/syscalls/headers/mips-64-syscalls_integers_override.h new file mode 100644 index 00000000..64021873 --- /dev/null +++ b/include/instrumentation/syscalls/headers/mips-64-syscalls_integers_override.h @@ -0,0 +1,5 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ + +/* + * this is a place-holder for MIPS integer syscall definition override. + */ diff --git a/include/instrumentation/syscalls/headers/mips-64-syscalls_pointers.h b/include/instrumentation/syscalls/headers/mips-64-syscalls_pointers.h new file mode 100644 index 00000000..290f9c3e --- /dev/null +++ b/include/instrumentation/syscalls/headers/mips-64-syscalls_pointers.h @@ -0,0 +1,1869 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ + +/* THIS FILE IS AUTO-GENERATED. DO NOT EDIT */ + +/* Generated from mips-64-syscalls 3.5.0 */ + +#ifndef CREATE_SYSCALL_TABLE + +#if !defined(_TRACE_SYSCALLS_POINTERS_H) || defined(TRACE_HEADER_MULTI_READ) +#define _TRACE_SYSCALLS_POINTERS_H + +#include +#include +#include "mips-64-syscalls_pointers_override.h" +#include "syscalls_pointers_override.h" + +#ifndef OVERRIDE_64_oldumount +SC_LTTNG_TRACEPOINT_EVENT(oldumount, + TP_PROTO(sc_exit(long ret,) char * name), + TP_ARGS(sc_exit(ret,) name), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(name, name))) +) +#endif +#ifndef OVERRIDE_64_olduname +SC_LTTNG_TRACEPOINT_EVENT(olduname, + TP_PROTO(sc_exit(long ret,) struct oldold_utsname * name), + TP_ARGS(sc_exit(ret,) name), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct oldold_utsname *, name, name))) +) +#endif +#ifndef OVERRIDE_64_uselib +SC_LTTNG_TRACEPOINT_EVENT(uselib, + TP_PROTO(sc_exit(long ret,) const char * library), + TP_ARGS(sc_exit(ret,) library), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(const char *, library, library))) +) +#endif +#ifndef OVERRIDE_64_uname +SC_LTTNG_TRACEPOINT_EVENT(uname, + TP_PROTO(sc_exit(long ret,) struct old_utsname * name), + TP_ARGS(sc_exit(ret,) name), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct old_utsname *, name, name))) +) +#endif +#ifndef OVERRIDE_64_sysinfo +SC_LTTNG_TRACEPOINT_EVENT(sysinfo, + TP_PROTO(sc_exit(long ret,) struct sysinfo * info), + TP_ARGS(sc_exit(ret,) info), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct sysinfo *, info, info))) +) +#endif +#ifndef OVERRIDE_64_times +SC_LTTNG_TRACEPOINT_EVENT(times, + TP_PROTO(sc_exit(long ret,) struct tms * tbuf), + TP_ARGS(sc_exit(ret,) tbuf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct tms *, tbuf, tbuf))) +) +#endif +#ifndef OVERRIDE_64_sysctl +SC_LTTNG_TRACEPOINT_EVENT(sysctl, + TP_PROTO(sc_exit(long ret,) struct __sysctl_args * args), + TP_ARGS(sc_exit(ret,) args), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct __sysctl_args *, args, args))) +) +#endif +#ifndef OVERRIDE_64_adjtimex +SC_LTTNG_TRACEPOINT_EVENT(adjtimex, + TP_PROTO(sc_exit(long ret,) struct timex * txc_p), + TP_ARGS(sc_exit(ret,) txc_p), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct timex *, txc_p, txc_p))) +) +#endif +#ifndef OVERRIDE_64_newuname +SC_LTTNG_TRACEPOINT_EVENT(newuname, + TP_PROTO(sc_exit(long ret,) struct new_utsname * name), + TP_ARGS(sc_exit(ret,) name), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct new_utsname *, name, name))) +) +#endif +#ifndef OVERRIDE_64_shmdt +SC_LTTNG_TRACEPOINT_EVENT(shmdt, + TP_PROTO(sc_exit(long ret,) char * shmaddr), + TP_ARGS(sc_exit(ret,) shmaddr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(char *, shmaddr, shmaddr))) +) +#endif +#ifndef OVERRIDE_64_chdir +SC_LTTNG_TRACEPOINT_EVENT(chdir, + TP_PROTO(sc_exit(long ret,) const char * filename), + TP_ARGS(sc_exit(ret,) filename), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename))) +) +#endif +#ifndef OVERRIDE_64_rmdir +SC_LTTNG_TRACEPOINT_EVENT(rmdir, + TP_PROTO(sc_exit(long ret,) const char * pathname), + TP_ARGS(sc_exit(ret,) pathname), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname))) +) +#endif +#ifndef OVERRIDE_64_unlink +SC_LTTNG_TRACEPOINT_EVENT(unlink, + TP_PROTO(sc_exit(long ret,) const char * pathname), + TP_ARGS(sc_exit(ret,) pathname), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname))) +) +#endif +#ifndef OVERRIDE_64_chroot +SC_LTTNG_TRACEPOINT_EVENT(chroot, + TP_PROTO(sc_exit(long ret,) const char * filename), + TP_ARGS(sc_exit(ret,) filename), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename))) +) +#endif +#ifndef OVERRIDE_64_swapoff +SC_LTTNG_TRACEPOINT_EVENT(swapoff, + TP_PROTO(sc_exit(long ret,) const char * specialfile), + TP_ARGS(sc_exit(ret,) specialfile), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(specialfile, specialfile))) +) +#endif +#ifndef OVERRIDE_64_set_tid_address +SC_LTTNG_TRACEPOINT_EVENT(set_tid_address, + TP_PROTO(sc_exit(long ret,) int * tidptr), + TP_ARGS(sc_exit(ret,) tidptr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int *, tidptr, tidptr))) +) +#endif +#ifndef OVERRIDE_64_nanosleep +SC_LTTNG_TRACEPOINT_EVENT(nanosleep, + TP_PROTO(sc_exit(long ret,) struct timespec * rqtp, struct timespec * rmtp), + TP_ARGS(sc_exit(ret,) rqtp, rmtp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct timespec *, rqtp, rqtp)) sc_out(ctf_integer(struct timespec *, rmtp, rmtp))) +) +#endif +#ifndef OVERRIDE_64_getitimer +SC_LTTNG_TRACEPOINT_EVENT(getitimer, + TP_PROTO(sc_exit(long ret,) int which, struct itimerval * value), + TP_ARGS(sc_exit(ret,) which, value), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_out(ctf_integer(struct itimerval *, value, value))) +) +#endif +#ifndef OVERRIDE_64_gettimeofday +SC_LTTNG_TRACEPOINT_EVENT(gettimeofday, + TP_PROTO(sc_exit(long ret,) struct timeval * tv, struct timezone * tz), + TP_ARGS(sc_exit(ret,) tv, tz), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct timeval *, tv, tv)) sc_out(ctf_integer(struct timezone *, tz, tz))) +) +#endif +#ifndef OVERRIDE_64_getrlimit +SC_LTTNG_TRACEPOINT_EVENT(getrlimit, + TP_PROTO(sc_exit(long ret,) unsigned int resource, struct rlimit * rlim), + TP_ARGS(sc_exit(ret,) resource, rlim), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, resource, resource)) sc_out(ctf_integer(struct rlimit *, rlim, rlim))) +) +#endif +#ifndef OVERRIDE_64_getrusage +SC_LTTNG_TRACEPOINT_EVENT(getrusage, + TP_PROTO(sc_exit(long ret,) int who, struct rusage * ru), + TP_ARGS(sc_exit(ret,) who, ru), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, who, who)) sc_out(ctf_integer(struct rusage *, ru, ru))) +) +#endif +#ifndef OVERRIDE_64_rt_sigpending +SC_LTTNG_TRACEPOINT_EVENT(rt_sigpending, + TP_PROTO(sc_exit(long ret,) sigset_t * set, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) set, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(sigset_t *, set, set)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) +) +#endif +#ifndef OVERRIDE_64_utime +SC_LTTNG_TRACEPOINT_EVENT(utime, + TP_PROTO(sc_exit(long ret,) char * filename, struct utimbuf * times), + TP_ARGS(sc_exit(ret,) filename, times), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(struct utimbuf *, times, times))) +) +#endif +#ifndef OVERRIDE_64_ustat +SC_LTTNG_TRACEPOINT_EVENT(ustat, + TP_PROTO(sc_exit(long ret,) unsigned dev, struct ustat * ubuf), + TP_ARGS(sc_exit(ret,) dev, ubuf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned, dev, dev)) sc_out(ctf_integer(struct ustat *, ubuf, ubuf))) +) +#endif +#ifndef OVERRIDE_64_statfs +SC_LTTNG_TRACEPOINT_EVENT(statfs, + TP_PROTO(sc_exit(long ret,) const char * pathname, struct statfs * buf), + TP_ARGS(sc_exit(ret,) pathname, buf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(struct statfs *, buf, buf))) +) +#endif +#ifndef OVERRIDE_64_fstatfs +SC_LTTNG_TRACEPOINT_EVENT(fstatfs, + TP_PROTO(sc_exit(long ret,) unsigned int fd, struct statfs * buf), + TP_ARGS(sc_exit(ret,) fd, buf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct statfs *, buf, buf))) +) +#endif +#ifndef OVERRIDE_64_sched_rr_get_interval +SC_LTTNG_TRACEPOINT_EVENT(sched_rr_get_interval, + TP_PROTO(sc_exit(long ret,) pid_t pid, struct timespec * interval), + TP_ARGS(sc_exit(ret,) pid, interval), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_out(ctf_integer(struct timespec *, interval, interval))) +) +#endif +#ifndef OVERRIDE_64_setrlimit +SC_LTTNG_TRACEPOINT_EVENT(setrlimit, + TP_PROTO(sc_exit(long ret,) unsigned int resource, struct rlimit * rlim), + TP_ARGS(sc_exit(ret,) resource, rlim), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, resource, resource)) sc_in(ctf_integer(struct rlimit *, rlim, rlim))) +) +#endif +#ifndef OVERRIDE_64_settimeofday +SC_LTTNG_TRACEPOINT_EVENT(settimeofday, + TP_PROTO(sc_exit(long ret,) struct timeval * tv, struct timezone * tz), + TP_ARGS(sc_exit(ret,) tv, tz), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct timeval *, tv, tv)) sc_in(ctf_integer(struct timezone *, tz, tz))) +) +#endif +#ifndef OVERRIDE_64_io_setup +SC_LTTNG_TRACEPOINT_EVENT(io_setup, + TP_PROTO(sc_exit(long ret,) unsigned nr_events, aio_context_t * ctxp), + TP_ARGS(sc_exit(ret,) nr_events, ctxp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned, nr_events, nr_events)) sc_in(ctf_integer(aio_context_t *, ctxp, ctxp))) +) +#endif +#ifndef OVERRIDE_64_timer_gettime +SC_LTTNG_TRACEPOINT_EVENT(timer_gettime, + TP_PROTO(sc_exit(long ret,) timer_t timer_id, struct itimerspec * setting), + TP_ARGS(sc_exit(ret,) timer_id, setting), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id)) sc_out(ctf_integer(struct itimerspec *, setting, setting))) +) +#endif +#ifndef OVERRIDE_64_clock_settime +SC_LTTNG_TRACEPOINT_EVENT(clock_settime, + TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, const struct timespec * tp), + TP_ARGS(sc_exit(ret,) which_clock, tp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_in(ctf_integer(const struct timespec *, tp, tp))) +) +#endif +#ifndef OVERRIDE_64_clock_gettime +SC_LTTNG_TRACEPOINT_EVENT(clock_gettime, + TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct timespec * tp), + TP_ARGS(sc_exit(ret,) which_clock, tp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_out(ctf_integer(struct timespec *, tp, tp))) +) +#endif +#ifndef OVERRIDE_64_clock_getres +SC_LTTNG_TRACEPOINT_EVENT(clock_getres, + TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct timespec * tp), + TP_ARGS(sc_exit(ret,) which_clock, tp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_out(ctf_integer(struct timespec *, tp, tp))) +) +#endif +#ifndef OVERRIDE_64_utimes +SC_LTTNG_TRACEPOINT_EVENT(utimes, + TP_PROTO(sc_exit(long ret,) char * filename, struct timeval * utimes), + TP_ARGS(sc_exit(ret,) filename, utimes), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(struct timeval *, utimes, utimes))) +) +#endif +#ifndef OVERRIDE_64_set_robust_list +SC_LTTNG_TRACEPOINT_EVENT(set_robust_list, + TP_PROTO(sc_exit(long ret,) struct robust_list_head * head, size_t len), + TP_ARGS(sc_exit(ret,) head, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct robust_list_head *, head, head)) sc_in(ctf_integer(size_t, len, len))) +) +#endif +#ifndef OVERRIDE_64_timerfd_gettime +SC_LTTNG_TRACEPOINT_EVENT(timerfd_gettime, + TP_PROTO(sc_exit(long ret,) int ufd, struct itimerspec * otmr), + TP_ARGS(sc_exit(ret,) ufd, otmr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_out(ctf_integer(struct itimerspec *, otmr, otmr))) +) +#endif +#ifndef OVERRIDE_64_clock_adjtime +SC_LTTNG_TRACEPOINT_EVENT(clock_adjtime, + TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct timex * utx), + TP_ARGS(sc_exit(ret,) which_clock, utx), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_inout(ctf_integer(struct timex *, utx, utx))) +) +#endif +#ifndef OVERRIDE_64_newstat +SC_LTTNG_TRACEPOINT_EVENT(newstat, + TP_PROTO(sc_exit(long ret,) const char * filename, struct stat * statbuf), + TP_ARGS(sc_exit(ret,) filename, statbuf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_out(ctf_integer(struct stat *, statbuf, statbuf))) +) +#endif +#ifndef OVERRIDE_64_newfstat +SC_LTTNG_TRACEPOINT_EVENT(newfstat, + TP_PROTO(sc_exit(long ret,) unsigned int fd, struct stat * statbuf), + TP_ARGS(sc_exit(ret,) fd, statbuf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct stat *, statbuf, statbuf))) +) +#endif +#ifndef OVERRIDE_64_newlstat +SC_LTTNG_TRACEPOINT_EVENT(newlstat, + TP_PROTO(sc_exit(long ret,) const char * filename, struct stat * statbuf), + TP_ARGS(sc_exit(ret,) filename, statbuf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_out(ctf_integer(struct stat *, statbuf, statbuf))) +) +#endif +#ifndef OVERRIDE_64_access +SC_LTTNG_TRACEPOINT_EVENT(access, + TP_PROTO(sc_exit(long ret,) const char * filename, int mode), + TP_ARGS(sc_exit(ret,) filename, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, mode, mode))) +) +#endif +#ifndef OVERRIDE_64_truncate +SC_LTTNG_TRACEPOINT_EVENT(truncate, + TP_PROTO(sc_exit(long ret,) const char * path, long length), + TP_ARGS(sc_exit(ret,) path, length), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(path, path)) sc_in(ctf_integer(long, length, length))) +) +#endif +#ifndef OVERRIDE_64_getcwd +SC_LTTNG_TRACEPOINT_EVENT(getcwd, + TP_PROTO(sc_exit(long ret,) char * buf, unsigned long size), + TP_ARGS(sc_exit(ret,) buf, size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(unsigned long, size, size))) +) +#endif +#ifndef OVERRIDE_64_rename +SC_LTTNG_TRACEPOINT_EVENT(rename, + TP_PROTO(sc_exit(long ret,) const char * oldname, const char * newname), + TP_ARGS(sc_exit(ret,) oldname, newname), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_user_string(newname, newname))) +) +#endif +#ifndef OVERRIDE_64_mkdir +SC_LTTNG_TRACEPOINT_EVENT(mkdir, + TP_PROTO(sc_exit(long ret,) const char * pathname, umode_t mode), + TP_ARGS(sc_exit(ret,) pathname, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(umode_t, mode, mode))) +) +#endif +#ifndef OVERRIDE_64_creat +SC_LTTNG_TRACEPOINT_EVENT(creat, + TP_PROTO(sc_exit(long ret,) const char * pathname, umode_t mode), + TP_ARGS(sc_exit(ret,) pathname, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(umode_t, mode, mode))) +) +#endif +#ifndef OVERRIDE_64_link +SC_LTTNG_TRACEPOINT_EVENT(link, + TP_PROTO(sc_exit(long ret,) const char * oldname, const char * newname), + TP_ARGS(sc_exit(ret,) oldname, newname), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_user_string(newname, newname))) +) +#endif +#ifndef OVERRIDE_64_symlink +SC_LTTNG_TRACEPOINT_EVENT(symlink, + TP_PROTO(sc_exit(long ret,) const char * oldname, const char * newname), + TP_ARGS(sc_exit(ret,) oldname, newname), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_user_string(newname, newname))) +) +#endif +#ifndef OVERRIDE_64_chmod +SC_LTTNG_TRACEPOINT_EVENT(chmod, + TP_PROTO(sc_exit(long ret,) const char * filename, umode_t mode), + TP_ARGS(sc_exit(ret,) filename, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(umode_t, mode, mode))) +) +#endif +#ifndef OVERRIDE_64_getgroups +SC_LTTNG_TRACEPOINT_EVENT(getgroups, + TP_PROTO(sc_exit(long ret,) int gidsetsize, gid_t * grouplist), + TP_ARGS(sc_exit(ret,) gidsetsize, grouplist), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, gidsetsize, gidsetsize)) sc_out(ctf_integer(gid_t *, grouplist, grouplist))) +) +#endif +#ifndef OVERRIDE_64_setgroups +SC_LTTNG_TRACEPOINT_EVENT(setgroups, + TP_PROTO(sc_exit(long ret,) int gidsetsize, gid_t * grouplist), + TP_ARGS(sc_exit(ret,) gidsetsize, grouplist), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, gidsetsize, gidsetsize)) sc_in(ctf_integer(gid_t *, grouplist, grouplist))) +) +#endif +#ifndef OVERRIDE_64_32_rt_sigpending +SC_LTTNG_TRACEPOINT_EVENT(32_rt_sigpending, + TP_PROTO(sc_exit(long ret,) compat_sigset_t * uset, unsigned int sigsetsize), + TP_ARGS(sc_exit(ret,) uset, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(compat_sigset_t *, uset, uset)) sc_inout(ctf_integer(unsigned int, sigsetsize, sigsetsize))) +) +#endif +#ifndef OVERRIDE_64_sched_setparam +SC_LTTNG_TRACEPOINT_EVENT(sched_setparam, + TP_PROTO(sc_exit(long ret,) pid_t pid, struct sched_param * param), + TP_ARGS(sc_exit(ret,) pid, param), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(struct sched_param *, param, param))) +) +#endif +#ifndef OVERRIDE_64_sched_getparam +SC_LTTNG_TRACEPOINT_EVENT(sched_getparam, + TP_PROTO(sc_exit(long ret,) pid_t pid, struct sched_param * param), + TP_ARGS(sc_exit(ret,) pid, param), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_out(ctf_integer(struct sched_param *, param, param))) +) +#endif +#ifndef OVERRIDE_64_32_sched_rr_get_interval +SC_LTTNG_TRACEPOINT_EVENT(32_sched_rr_get_interval, + TP_PROTO(sc_exit(long ret,) compat_pid_t pid, struct compat_timespec * interval), + TP_ARGS(sc_exit(ret,) pid, interval), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(compat_pid_t, pid, pid)) sc_inout(ctf_integer(struct compat_timespec *, interval, interval))) +) +#endif +#ifndef OVERRIDE_64_pivot_root +SC_LTTNG_TRACEPOINT_EVENT(pivot_root, + TP_PROTO(sc_exit(long ret,) const char * new_root, const char * put_old), + TP_ARGS(sc_exit(ret,) new_root, put_old), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(new_root, new_root)) sc_in(ctf_user_string(put_old, put_old))) +) +#endif +#ifndef OVERRIDE_64_umount +SC_LTTNG_TRACEPOINT_EVENT(umount, + TP_PROTO(sc_exit(long ret,) char * name, int flags), + TP_ARGS(sc_exit(ret,) name, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_swapon +SC_LTTNG_TRACEPOINT_EVENT(swapon, + TP_PROTO(sc_exit(long ret,) const char * specialfile, int swap_flags), + TP_ARGS(sc_exit(ret,) specialfile, swap_flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(specialfile, specialfile)) sc_in(ctf_integer(int, swap_flags, swap_flags))) +) +#endif +#ifndef OVERRIDE_64_sethostname +SC_LTTNG_TRACEPOINT_EVENT(sethostname, + TP_PROTO(sc_exit(long ret,) char * name, int len), + TP_ARGS(sc_exit(ret,) name, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(int, len, len))) +) +#endif +#ifndef OVERRIDE_64_setdomainname +SC_LTTNG_TRACEPOINT_EVENT(setdomainname, + TP_PROTO(sc_exit(long ret,) char * name, int len), + TP_ARGS(sc_exit(ret,) name, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(int, len, len))) +) +#endif +#ifndef OVERRIDE_64_delete_module +SC_LTTNG_TRACEPOINT_EVENT(delete_module, + TP_PROTO(sc_exit(long ret,) const char * name_user, unsigned int flags), + TP_ARGS(sc_exit(ret,) name_user, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name_user, name_user)) sc_in(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_removexattr +SC_LTTNG_TRACEPOINT_EVENT(removexattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name), + TP_ARGS(sc_exit(ret,) pathname, name), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name))) +) +#endif +#ifndef OVERRIDE_64_lremovexattr +SC_LTTNG_TRACEPOINT_EVENT(lremovexattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name), + TP_ARGS(sc_exit(ret,) pathname, name), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name))) +) +#endif +#ifndef OVERRIDE_64_fremovexattr +SC_LTTNG_TRACEPOINT_EVENT(fremovexattr, + TP_PROTO(sc_exit(long ret,) int fd, const char * name), + TP_ARGS(sc_exit(ret,) fd, name), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(name, name))) +) +#endif +#ifndef OVERRIDE_64_pipe2 +SC_LTTNG_TRACEPOINT_EVENT(pipe2, + TP_PROTO(sc_exit(long ret,) int * fildes, int flags), + TP_ARGS(sc_exit(ret,) fildes, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(int *, fildes, fildes)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_waitpid +SC_LTTNG_TRACEPOINT_EVENT(waitpid, + TP_PROTO(sc_exit(long ret,) pid_t pid, int * stat_addr, int options), + TP_ARGS(sc_exit(ret,) pid, stat_addr, options), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(pid_t, pid, pid)) sc_inout(ctf_integer(int *, stat_addr, stat_addr)) sc_inout(ctf_integer(int, options, options))) +) +#endif +#ifndef OVERRIDE_64_32_sigaction +SC_LTTNG_TRACEPOINT_EVENT(32_sigaction, + TP_PROTO(sc_exit(long ret,) long sig, const struct sigaction32 * act, struct sigaction32 * oact), + TP_ARGS(sc_exit(ret,) sig, act, oact), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(long, sig, sig)) sc_inout(ctf_integer(const struct sigaction32 *, act, act)) sc_inout(ctf_integer(struct sigaction32 *, oact, oact))) +) +#endif +#ifndef OVERRIDE_64_readv +SC_LTTNG_TRACEPOINT_EVENT(readv, + TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen), + TP_ARGS(sc_exit(ret,) fd, vec, vlen), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_inout(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen))) +) +#endif +#ifndef OVERRIDE_64_writev +SC_LTTNG_TRACEPOINT_EVENT(writev, + TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen), + TP_ARGS(sc_exit(ret,) fd, vec, vlen), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_inout(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen))) +) +#endif +#ifndef OVERRIDE_64_shmctl +SC_LTTNG_TRACEPOINT_EVENT(shmctl, + TP_PROTO(sc_exit(long ret,) int shmid, int cmd, struct shmid_ds * buf), + TP_ARGS(sc_exit(ret,) shmid, cmd, buf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, shmid, shmid)) sc_in(ctf_integer(int, cmd, cmd)) sc_inout(ctf_integer(struct shmid_ds *, buf, buf))) +) +#endif +#ifndef OVERRIDE_64_setitimer +SC_LTTNG_TRACEPOINT_EVENT(setitimer, + TP_PROTO(sc_exit(long ret,) int which, struct itimerval * value, struct itimerval * ovalue), + TP_ARGS(sc_exit(ret,) which, value, ovalue), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(struct itimerval *, value, value)) sc_out(ctf_integer(struct itimerval *, ovalue, ovalue))) +) +#endif +#ifndef OVERRIDE_64_sendmsg +SC_LTTNG_TRACEPOINT_EVENT(sendmsg, + TP_PROTO(sc_exit(long ret,) int fd, struct msghdr * msg, unsigned int flags), + TP_ARGS(sc_exit(ret,) fd, msg, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct msghdr *, msg, msg)) sc_in(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_recvmsg +SC_LTTNG_TRACEPOINT_EVENT(recvmsg, + TP_PROTO(sc_exit(long ret,) int fd, struct msghdr * msg, unsigned int flags), + TP_ARGS(sc_exit(ret,) fd, msg, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_inout(ctf_integer(struct msghdr *, msg, msg)) sc_in(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_msgctl +SC_LTTNG_TRACEPOINT_EVENT(msgctl, + TP_PROTO(sc_exit(long ret,) int msqid, int cmd, struct msqid_ds * buf), + TP_ARGS(sc_exit(ret,) msqid, cmd, buf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, msqid, msqid)) sc_in(ctf_integer(int, cmd, cmd)) sc_inout(ctf_integer(struct msqid_ds *, buf, buf))) +) +#endif +#ifndef OVERRIDE_64_getdents +SC_LTTNG_TRACEPOINT_EVENT(getdents, + TP_PROTO(sc_exit(long ret,) unsigned int fd, struct linux_dirent * dirent, unsigned int count), + TP_ARGS(sc_exit(ret,) fd, dirent, count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct linux_dirent *, dirent, dirent)) sc_in(ctf_integer(unsigned int, count, count))) +) +#endif +#ifndef OVERRIDE_64_rt_sigqueueinfo +SC_LTTNG_TRACEPOINT_EVENT(rt_sigqueueinfo, + TP_PROTO(sc_exit(long ret,) pid_t pid, int sig, siginfo_t * uinfo), + TP_ARGS(sc_exit(ret,) pid, sig, uinfo), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig)) sc_in(ctf_integer(siginfo_t *, uinfo, uinfo))) +) +#endif +#ifndef OVERRIDE_64_sched_setaffinity +SC_LTTNG_TRACEPOINT_EVENT(sched_setaffinity, + TP_PROTO(sc_exit(long ret,) pid_t pid, unsigned int len, unsigned long * user_mask_ptr), + TP_ARGS(sc_exit(ret,) pid, len, user_mask_ptr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(unsigned int, len, len)) sc_in(ctf_integer(unsigned long *, user_mask_ptr, user_mask_ptr))) +) +#endif +#ifndef OVERRIDE_64_sched_getaffinity +SC_LTTNG_TRACEPOINT_EVENT(sched_getaffinity, + TP_PROTO(sc_exit(long ret,) pid_t pid, unsigned int len, unsigned long * user_mask_ptr), + TP_ARGS(sc_exit(ret,) pid, len, user_mask_ptr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(unsigned int, len, len)) sc_out(ctf_integer(unsigned long *, user_mask_ptr, user_mask_ptr))) +) +#endif +#ifndef OVERRIDE_64_io_submit +SC_LTTNG_TRACEPOINT_EVENT(io_submit, + TP_PROTO(sc_exit(long ret,) aio_context_t ctx_id, long nr, struct iocb * * iocbpp), + TP_ARGS(sc_exit(ret,) ctx_id, nr, iocbpp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx_id, ctx_id)) sc_in(ctf_integer(long, nr, nr)) sc_in(ctf_integer(struct iocb * *, iocbpp, iocbpp))) +) +#endif +#ifndef OVERRIDE_64_timer_create +SC_LTTNG_TRACEPOINT_EVENT(timer_create, + TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct sigevent * timer_event_spec, timer_t * created_timer_id), + TP_ARGS(sc_exit(ret,) which_clock, timer_event_spec, created_timer_id), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_in(ctf_integer(struct sigevent *, timer_event_spec, timer_event_spec)) sc_out(ctf_integer(timer_t *, created_timer_id, created_timer_id))) +) +#endif +#ifndef OVERRIDE_64_futimesat +SC_LTTNG_TRACEPOINT_EVENT(futimesat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, struct timeval * utimes), + TP_ARGS(sc_exit(ret,) dfd, filename, utimes), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(struct timeval *, utimes, utimes))) +) +#endif +#ifndef OVERRIDE_64_get_robust_list +SC_LTTNG_TRACEPOINT_EVENT(get_robust_list, + TP_PROTO(sc_exit(long ret,) int pid, struct robust_list_head * * head_ptr, size_t * len_ptr), + TP_ARGS(sc_exit(ret,) pid, head_ptr, len_ptr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, pid, pid)) sc_out(ctf_integer(struct robust_list_head * *, head_ptr, head_ptr)) sc_out(ctf_integer(size_t *, len_ptr, len_ptr))) +) +#endif +#ifndef OVERRIDE_64_signalfd +SC_LTTNG_TRACEPOINT_EVENT(signalfd, + TP_PROTO(sc_exit(long ret,) int ufd, sigset_t * user_mask, size_t sizemask), + TP_ARGS(sc_exit(ret,) ufd, user_mask, sizemask), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_in(ctf_integer(sigset_t *, user_mask, user_mask)) sc_in(ctf_integer(size_t, sizemask, sizemask))) +) +#endif +#ifndef OVERRIDE_64_read +SC_LTTNG_TRACEPOINT_EVENT(read, + TP_PROTO(sc_exit(long ret,) unsigned int fd, char * buf, size_t count), + TP_ARGS(sc_exit(ret,) fd, buf, count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(size_t, count, count))) +) +#endif +#ifndef OVERRIDE_64_write +SC_LTTNG_TRACEPOINT_EVENT(write, + TP_PROTO(sc_exit(long ret,) unsigned int fd, const char * buf, size_t count), + TP_ARGS(sc_exit(ret,) fd, buf, count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(const char *, buf, buf)) sc_in(ctf_integer(size_t, count, count))) +) +#endif +#ifndef OVERRIDE_64_open +SC_LTTNG_TRACEPOINT_EVENT(open, + TP_PROTO(sc_exit(long ret,) const char * filename, int flags, umode_t mode), + TP_ARGS(sc_exit(ret,) filename, flags, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(umode_t, mode, mode))) +) +#endif +#ifndef OVERRIDE_64_poll +SC_LTTNG_TRACEPOINT_EVENT(poll, + TP_PROTO(sc_exit(long ret,) struct pollfd * ufds, unsigned int nfds, int timeout_msecs), + TP_ARGS(sc_exit(ret,) ufds, nfds, timeout_msecs), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct pollfd *, ufds, ufds)) sc_in(ctf_integer(unsigned int, nfds, nfds)) sc_in(ctf_integer(int, timeout_msecs, timeout_msecs))) +) +#endif +#ifndef OVERRIDE_64_mincore +SC_LTTNG_TRACEPOINT_EVENT(mincore, + TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len, unsigned char * vec), + TP_ARGS(sc_exit(ret,) start, len, vec), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len)) sc_out(ctf_integer(unsigned char *, vec, vec))) +) +#endif +#ifndef OVERRIDE_64_shmat +SC_LTTNG_TRACEPOINT_EVENT(shmat, + TP_PROTO(sc_exit(long ret,) int shmid, char * shmaddr, int shmflg), + TP_ARGS(sc_exit(ret,) shmid, shmaddr, shmflg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, shmid, shmid)) sc_in(ctf_integer(char *, shmaddr, shmaddr)) sc_in(ctf_integer(int, shmflg, shmflg))) +) +#endif +#ifndef OVERRIDE_64_connect +SC_LTTNG_TRACEPOINT_EVENT(connect, + TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * uservaddr, int addrlen), + TP_ARGS(sc_exit(ret,) fd, uservaddr, addrlen), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct sockaddr *, uservaddr, uservaddr)) sc_in(ctf_integer(int, addrlen, addrlen))) +) +#endif +#ifndef OVERRIDE_64_accept +SC_LTTNG_TRACEPOINT_EVENT(accept, + TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * upeer_sockaddr, int * upeer_addrlen), + TP_ARGS(sc_exit(ret,) fd, upeer_sockaddr, upeer_addrlen), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct sockaddr *, upeer_sockaddr, upeer_sockaddr)) sc_inout(ctf_integer(int *, upeer_addrlen, upeer_addrlen))) +) +#endif +#ifndef OVERRIDE_64_bind +SC_LTTNG_TRACEPOINT_EVENT(bind, + TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * umyaddr, int addrlen), + TP_ARGS(sc_exit(ret,) fd, umyaddr, addrlen), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct sockaddr *, umyaddr, umyaddr)) sc_in(ctf_integer(int, addrlen, addrlen))) +) +#endif +#ifndef OVERRIDE_64_getsockname +SC_LTTNG_TRACEPOINT_EVENT(getsockname, + TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * usockaddr, int * usockaddr_len), + TP_ARGS(sc_exit(ret,) fd, usockaddr, usockaddr_len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct sockaddr *, usockaddr, usockaddr)) sc_inout(ctf_integer(int *, usockaddr_len, usockaddr_len))) +) +#endif +#ifndef OVERRIDE_64_getpeername +SC_LTTNG_TRACEPOINT_EVENT(getpeername, + TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * usockaddr, int * usockaddr_len), + TP_ARGS(sc_exit(ret,) fd, usockaddr, usockaddr_len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct sockaddr *, usockaddr, usockaddr)) sc_inout(ctf_integer(int *, usockaddr_len, usockaddr_len))) +) +#endif +#ifndef OVERRIDE_64_semop +SC_LTTNG_TRACEPOINT_EVENT(semop, + TP_PROTO(sc_exit(long ret,) int semid, struct sembuf * tsops, unsigned nsops), + TP_ARGS(sc_exit(ret,) semid, tsops, nsops), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, semid, semid)) sc_in(ctf_integer(struct sembuf *, tsops, tsops)) sc_in(ctf_integer(unsigned, nsops, nsops))) +) +#endif +#ifndef OVERRIDE_64_readlink +SC_LTTNG_TRACEPOINT_EVENT(readlink, + TP_PROTO(sc_exit(long ret,) const char * path, char * buf, int bufsiz), + TP_ARGS(sc_exit(ret,) path, buf, bufsiz), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(path, path)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(int, bufsiz, bufsiz))) +) +#endif +#ifndef OVERRIDE_64_chown +SC_LTTNG_TRACEPOINT_EVENT(chown, + TP_PROTO(sc_exit(long ret,) const char * filename, uid_t user, gid_t group), + TP_ARGS(sc_exit(ret,) filename, user, group), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group))) +) +#endif +#ifndef OVERRIDE_64_lchown +SC_LTTNG_TRACEPOINT_EVENT(lchown, + TP_PROTO(sc_exit(long ret,) const char * filename, uid_t user, gid_t group), + TP_ARGS(sc_exit(ret,) filename, user, group), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group))) +) +#endif +#ifndef OVERRIDE_64_syslog +SC_LTTNG_TRACEPOINT_EVENT(syslog, + TP_PROTO(sc_exit(long ret,) int type, char * buf, int len), + TP_ARGS(sc_exit(ret,) type, buf, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, type, type)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(int, len, len))) +) +#endif +#ifndef OVERRIDE_64_getresuid +SC_LTTNG_TRACEPOINT_EVENT(getresuid, + TP_PROTO(sc_exit(long ret,) uid_t * ruidp, uid_t * euidp, uid_t * suidp), + TP_ARGS(sc_exit(ret,) ruidp, euidp, suidp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(uid_t *, ruidp, ruidp)) sc_out(ctf_integer(uid_t *, euidp, euidp)) sc_out(ctf_integer(uid_t *, suidp, suidp))) +) +#endif +#ifndef OVERRIDE_64_getresgid +SC_LTTNG_TRACEPOINT_EVENT(getresgid, + TP_PROTO(sc_exit(long ret,) gid_t * rgidp, gid_t * egidp, gid_t * sgidp), + TP_ARGS(sc_exit(ret,) rgidp, egidp, sgidp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(gid_t *, rgidp, rgidp)) sc_out(ctf_integer(gid_t *, egidp, egidp)) sc_out(ctf_integer(gid_t *, sgidp, sgidp))) +) +#endif +#ifndef OVERRIDE_64_32_rt_sigqueueinfo +SC_LTTNG_TRACEPOINT_EVENT(32_rt_sigqueueinfo, + TP_PROTO(sc_exit(long ret,) int pid, int sig, compat_siginfo_t * uinfo), + TP_ARGS(sc_exit(ret,) pid, sig, uinfo), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, pid, pid)) sc_inout(ctf_integer(int, sig, sig)) sc_inout(ctf_integer(compat_siginfo_t *, uinfo, uinfo))) +) +#endif +#ifndef OVERRIDE_64_mknod +SC_LTTNG_TRACEPOINT_EVENT(mknod, + TP_PROTO(sc_exit(long ret,) const char * filename, umode_t mode, unsigned dev), + TP_ARGS(sc_exit(ret,) filename, mode, dev), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(umode_t, mode, mode)) sc_in(ctf_integer(unsigned, dev, dev))) +) +#endif +#ifndef OVERRIDE_64_sched_setscheduler +SC_LTTNG_TRACEPOINT_EVENT(sched_setscheduler, + TP_PROTO(sc_exit(long ret,) pid_t pid, int policy, struct sched_param * param), + TP_ARGS(sc_exit(ret,) pid, policy, param), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, policy, policy)) sc_in(ctf_integer(struct sched_param *, param, param))) +) +#endif +#ifndef OVERRIDE_64_init_module +SC_LTTNG_TRACEPOINT_EVENT(init_module, + TP_PROTO(sc_exit(long ret,) void * umod, unsigned long len, const char * uargs), + TP_ARGS(sc_exit(ret,) umod, len, uargs), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(void *, umod, umod)) sc_in(ctf_integer(unsigned long, len, len)) sc_in(ctf_integer(const char *, uargs, uargs))) +) +#endif +#ifndef OVERRIDE_64_listxattr +SC_LTTNG_TRACEPOINT_EVENT(listxattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, char * list, size_t size), + TP_ARGS(sc_exit(ret,) pathname, list, size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(char *, list, list)) sc_in(ctf_integer(size_t, size, size))) +) +#endif +#ifndef OVERRIDE_64_llistxattr +SC_LTTNG_TRACEPOINT_EVENT(llistxattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, char * list, size_t size), + TP_ARGS(sc_exit(ret,) pathname, list, size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(char *, list, list)) sc_in(ctf_integer(size_t, size, size))) +) +#endif +#ifndef OVERRIDE_64_flistxattr +SC_LTTNG_TRACEPOINT_EVENT(flistxattr, + TP_PROTO(sc_exit(long ret,) int fd, char * list, size_t size), + TP_ARGS(sc_exit(ret,) fd, list, size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(char *, list, list)) sc_in(ctf_integer(size_t, size, size))) +) +#endif +#ifndef OVERRIDE_64_cachectl +SC_LTTNG_TRACEPOINT_EVENT(cachectl, + TP_PROTO(sc_exit(long ret,) char * addr, int nbytes, int op), + TP_ARGS(sc_exit(ret,) addr, nbytes, op), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(char *, addr, addr)) sc_inout(ctf_integer(int, nbytes, nbytes)) sc_inout(ctf_integer(int, op, op))) +) +#endif +#ifndef OVERRIDE_64_io_cancel +SC_LTTNG_TRACEPOINT_EVENT(io_cancel, + TP_PROTO(sc_exit(long ret,) aio_context_t ctx_id, struct iocb * iocb, struct io_event * result), + TP_ARGS(sc_exit(ret,) ctx_id, iocb, result), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx_id, ctx_id)) sc_in(ctf_integer(struct iocb *, iocb, iocb)) sc_out(ctf_integer(struct io_event *, result, result))) +) +#endif +#ifndef OVERRIDE_64_inotify_add_watch +SC_LTTNG_TRACEPOINT_EVENT(inotify_add_watch, + TP_PROTO(sc_exit(long ret,) int fd, const char * pathname, u32 mask), + TP_ARGS(sc_exit(ret,) fd, pathname, mask), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(u32, mask, mask))) +) +#endif +#ifndef OVERRIDE_64_mkdirat +SC_LTTNG_TRACEPOINT_EVENT(mkdirat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * pathname, umode_t mode), + TP_ARGS(sc_exit(ret,) dfd, pathname, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(umode_t, mode, mode))) +) +#endif +#ifndef OVERRIDE_64_unlinkat +SC_LTTNG_TRACEPOINT_EVENT(unlinkat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * pathname, int flag), + TP_ARGS(sc_exit(ret,) dfd, pathname, flag), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(int, flag, flag))) +) +#endif +#ifndef OVERRIDE_64_symlinkat +SC_LTTNG_TRACEPOINT_EVENT(symlinkat, + TP_PROTO(sc_exit(long ret,) const char * oldname, int newdfd, const char * newname), + TP_ARGS(sc_exit(ret,) oldname, newdfd, newname), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_integer(int, newdfd, newdfd)) sc_in(ctf_user_string(newname, newname))) +) +#endif +#ifndef OVERRIDE_64_fchmodat +SC_LTTNG_TRACEPOINT_EVENT(fchmodat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, umode_t mode), + TP_ARGS(sc_exit(ret,) dfd, filename, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(umode_t, mode, mode))) +) +#endif +#ifndef OVERRIDE_64_faccessat +SC_LTTNG_TRACEPOINT_EVENT(faccessat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, int mode), + TP_ARGS(sc_exit(ret,) dfd, filename, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, mode, mode))) +) +#endif +#ifndef OVERRIDE_64_getcpu +SC_LTTNG_TRACEPOINT_EVENT(getcpu, + TP_PROTO(sc_exit(long ret,) unsigned * cpup, unsigned * nodep, struct getcpu_cache * unused), + TP_ARGS(sc_exit(ret,) cpup, nodep, unused), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(unsigned *, cpup, cpup)) sc_out(ctf_integer(unsigned *, nodep, nodep)) sc_inout(ctf_integer(struct getcpu_cache *, unused, unused))) +) +#endif +#ifndef OVERRIDE_64_getdents64 +SC_LTTNG_TRACEPOINT_EVENT(getdents64, + TP_PROTO(sc_exit(long ret,) unsigned int fd, struct linux_dirent64 * dirent, unsigned int count), + TP_ARGS(sc_exit(ret,) fd, dirent, count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct linux_dirent64 *, dirent, dirent)) sc_in(ctf_integer(unsigned int, count, count))) +) +#endif +#ifndef OVERRIDE_64_send +SC_LTTNG_TRACEPOINT_EVENT(send, + TP_PROTO(sc_exit(long ret,) int fd, void * buff, size_t len, unsigned int flags), + TP_ARGS(sc_exit(ret,) fd, buff, len, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, fd, fd)) sc_inout(ctf_integer(void *, buff, buff)) sc_inout(ctf_integer(size_t, len, len)) sc_inout(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_32_truncate64 +SC_LTTNG_TRACEPOINT_EVENT(32_truncate64, + TP_PROTO(sc_exit(long ret,) const char * path, unsigned long __dummy, unsigned long a2, unsigned long a3), + TP_ARGS(sc_exit(ret,) path, __dummy, a2, a3), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(path, path)) sc_inout(ctf_integer(unsigned long, __dummy, __dummy)) sc_inout(ctf_integer(unsigned long, a2, a2)) sc_inout(ctf_integer(unsigned long, a3, a3))) +) +#endif +#ifndef OVERRIDE_64_rt_sigaction +SC_LTTNG_TRACEPOINT_EVENT(rt_sigaction, + TP_PROTO(sc_exit(long ret,) int sig, const struct sigaction * act, struct sigaction * oact, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) sig, act, oact, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, sig, sig)) sc_in(ctf_integer(const struct sigaction *, act, act)) sc_out(ctf_integer(struct sigaction *, oact, oact)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) +) +#endif +#ifndef OVERRIDE_64_rt_sigprocmask +SC_LTTNG_TRACEPOINT_EVENT(rt_sigprocmask, + TP_PROTO(sc_exit(long ret,) int how, sigset_t * nset, sigset_t * oset, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) how, nset, oset, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, how, how)) sc_in(ctf_integer(sigset_t *, nset, nset)) sc_out(ctf_integer(sigset_t *, oset, oset)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) +) +#endif +#ifndef OVERRIDE_64_wait4 +SC_LTTNG_TRACEPOINT_EVENT(wait4, + TP_PROTO(sc_exit(long ret,) pid_t upid, int * stat_addr, int options, struct rusage * ru), + TP_ARGS(sc_exit(ret,) upid, stat_addr, options, ru), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, upid, upid)) sc_out(ctf_integer(int *, stat_addr, stat_addr)) sc_in(ctf_integer(int, options, options)) sc_out(ctf_integer(struct rusage *, ru, ru))) +) +#endif +#ifndef OVERRIDE_64_msgsnd +SC_LTTNG_TRACEPOINT_EVENT(msgsnd, + TP_PROTO(sc_exit(long ret,) int msqid, struct msgbuf * msgp, size_t msgsz, int msgflg), + TP_ARGS(sc_exit(ret,) msqid, msgp, msgsz, msgflg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, msqid, msqid)) sc_in(ctf_integer(struct msgbuf *, msgp, msgp)) sc_in(ctf_integer(size_t, msgsz, msgsz)) sc_in(ctf_integer(int, msgflg, msgflg))) +) +#endif +#ifndef OVERRIDE_64_rt_sigtimedwait +SC_LTTNG_TRACEPOINT_EVENT(rt_sigtimedwait, + TP_PROTO(sc_exit(long ret,) const sigset_t * uthese, siginfo_t * uinfo, const struct timespec * uts, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) uthese, uinfo, uts, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(const sigset_t *, uthese, uthese)) sc_out(ctf_integer(siginfo_t *, uinfo, uinfo)) sc_in(ctf_integer(const struct timespec *, uts, uts)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) +) +#endif +#ifndef OVERRIDE_64_semtimedop +SC_LTTNG_TRACEPOINT_EVENT(semtimedop, + TP_PROTO(sc_exit(long ret,) int semid, struct sembuf * tsops, unsigned nsops, const struct timespec * timeout), + TP_ARGS(sc_exit(ret,) semid, tsops, nsops, timeout), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, semid, semid)) sc_in(ctf_integer(struct sembuf *, tsops, tsops)) sc_in(ctf_integer(unsigned, nsops, nsops)) sc_inout(ctf_integer(const struct timespec *, timeout, timeout))) +) +#endif +#ifndef OVERRIDE_64_timer_settime +SC_LTTNG_TRACEPOINT_EVENT(timer_settime, + TP_PROTO(sc_exit(long ret,) timer_t timer_id, int flags, const struct itimerspec * new_setting, struct itimerspec * old_setting), + TP_ARGS(sc_exit(ret,) timer_id, flags, new_setting, old_setting), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(const struct itimerspec *, new_setting, new_setting)) sc_out(ctf_integer(struct itimerspec *, old_setting, old_setting))) +) +#endif +#ifndef OVERRIDE_64_clock_nanosleep +SC_LTTNG_TRACEPOINT_EVENT(clock_nanosleep, + TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, int flags, const struct timespec * rqtp, struct timespec * rmtp), + TP_ARGS(sc_exit(ret,) which_clock, flags, rqtp, rmtp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(const struct timespec *, rqtp, rqtp)) sc_out(ctf_integer(struct timespec *, rmtp, rmtp))) +) +#endif +#ifndef OVERRIDE_64_vmsplice +SC_LTTNG_TRACEPOINT_EVENT(vmsplice, + TP_PROTO(sc_exit(long ret,) int fd, const struct iovec * iov, unsigned long nr_segs, unsigned int flags), + TP_ARGS(sc_exit(ret,) fd, iov, nr_segs, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(const struct iovec *, iov, iov)) sc_in(ctf_integer(unsigned long, nr_segs, nr_segs)) sc_in(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_utimensat +SC_LTTNG_TRACEPOINT_EVENT(utimensat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, struct timespec * utimes, int flags), + TP_ARGS(sc_exit(ret,) dfd, filename, utimes, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(struct timespec *, utimes, utimes)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_timerfd_settime +SC_LTTNG_TRACEPOINT_EVENT(timerfd_settime, + TP_PROTO(sc_exit(long ret,) int ufd, int flags, const struct itimerspec * utmr, struct itimerspec * otmr), + TP_ARGS(sc_exit(ret,) ufd, flags, utmr, otmr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(const struct itimerspec *, utmr, utmr)) sc_out(ctf_integer(struct itimerspec *, otmr, otmr))) +) +#endif +#ifndef OVERRIDE_64_rt_tgsigqueueinfo +SC_LTTNG_TRACEPOINT_EVENT(rt_tgsigqueueinfo, + TP_PROTO(sc_exit(long ret,) pid_t tgid, pid_t pid, int sig, siginfo_t * uinfo), + TP_ARGS(sc_exit(ret,) tgid, pid, sig, uinfo), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, tgid, tgid)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig)) sc_in(ctf_integer(siginfo_t *, uinfo, uinfo))) +) +#endif +#ifndef OVERRIDE_64_sendmmsg +SC_LTTNG_TRACEPOINT_EVENT(sendmmsg, + TP_PROTO(sc_exit(long ret,) int fd, struct mmsghdr * mmsg, unsigned int vlen, unsigned int flags), + TP_ARGS(sc_exit(ret,) fd, mmsg, vlen, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct mmsghdr *, mmsg, mmsg)) sc_in(ctf_integer(unsigned int, vlen, vlen)) sc_in(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_32_rt_sigaction +SC_LTTNG_TRACEPOINT_EVENT(32_rt_sigaction, + TP_PROTO(sc_exit(long ret,) int sig, const struct sigaction32 * act, struct sigaction32 * oact, unsigned int sigsetsize), + TP_ARGS(sc_exit(ret,) sig, act, oact, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, sig, sig)) sc_inout(ctf_integer(const struct sigaction32 *, act, act)) sc_inout(ctf_integer(struct sigaction32 *, oact, oact)) sc_inout(ctf_integer(unsigned int, sigsetsize, sigsetsize))) +) +#endif +#ifndef OVERRIDE_64_32_rt_sigprocmask +SC_LTTNG_TRACEPOINT_EVENT(32_rt_sigprocmask, + TP_PROTO(sc_exit(long ret,) int how, compat_sigset_t * set, compat_sigset_t * oset, unsigned int sigsetsize), + TP_ARGS(sc_exit(ret,) how, set, oset, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, how, how)) sc_inout(ctf_integer(compat_sigset_t *, set, set)) sc_inout(ctf_integer(compat_sigset_t *, oset, oset)) sc_inout(ctf_integer(unsigned int, sigsetsize, sigsetsize))) +) +#endif +#ifndef OVERRIDE_64_32_sendfile +SC_LTTNG_TRACEPOINT_EVENT(32_sendfile, + TP_PROTO(sc_exit(long ret,) long out_fd, long in_fd, compat_off_t * offset, s32 count), + TP_ARGS(sc_exit(ret,) out_fd, in_fd, offset, count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(long, out_fd, out_fd)) sc_inout(ctf_integer(long, in_fd, in_fd)) sc_inout(ctf_integer(compat_off_t *, offset, offset)) sc_inout(ctf_integer(s32, count, count))) +) +#endif +#ifndef OVERRIDE_64_socketpair +SC_LTTNG_TRACEPOINT_EVENT(socketpair, + TP_PROTO(sc_exit(long ret,) int family, int type, int protocol, int * usockvec), + TP_ARGS(sc_exit(ret,) family, type, protocol, usockvec), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, family, family)) sc_in(ctf_integer(int, type, type)) sc_in(ctf_integer(int, protocol, protocol)) sc_out(ctf_integer(int *, usockvec, usockvec))) +) +#endif +#ifndef OVERRIDE_64_reboot +SC_LTTNG_TRACEPOINT_EVENT(reboot, + TP_PROTO(sc_exit(long ret,) int magic1, int magic2, unsigned int cmd, void * arg), + TP_ARGS(sc_exit(ret,) magic1, magic2, cmd, arg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, magic1, magic1)) sc_in(ctf_integer(int, magic2, magic2)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_in(ctf_integer(void *, arg, arg))) +) +#endif +#ifndef OVERRIDE_64_quotactl +SC_LTTNG_TRACEPOINT_EVENT(quotactl, + TP_PROTO(sc_exit(long ret,) unsigned int cmd, const char * special, qid_t id, void * addr), + TP_ARGS(sc_exit(ret,) cmd, special, id, addr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_in(ctf_integer(const char *, special, special)) sc_in(ctf_integer(qid_t, id, id)) sc_inout(ctf_integer(void *, addr, addr))) +) +#endif +#ifndef OVERRIDE_64_getxattr +SC_LTTNG_TRACEPOINT_EVENT(getxattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, void * value, size_t size), + TP_ARGS(sc_exit(ret,) pathname, name, value, size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_out(ctf_integer(void *, value, value)) sc_in(ctf_integer(size_t, size, size))) +) +#endif +#ifndef OVERRIDE_64_lgetxattr +SC_LTTNG_TRACEPOINT_EVENT(lgetxattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, void * value, size_t size), + TP_ARGS(sc_exit(ret,) pathname, name, value, size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_out(ctf_integer(void *, value, value)) sc_in(ctf_integer(size_t, size, size))) +) +#endif +#ifndef OVERRIDE_64_fgetxattr +SC_LTTNG_TRACEPOINT_EVENT(fgetxattr, + TP_PROTO(sc_exit(long ret,) int fd, const char * name, void * value, size_t size), + TP_ARGS(sc_exit(ret,) fd, name, value, size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(name, name)) sc_out(ctf_integer(void *, value, value)) sc_in(ctf_integer(size_t, size, size))) +) +#endif +#ifndef OVERRIDE_64_epoll_ctl +SC_LTTNG_TRACEPOINT_EVENT(epoll_ctl, + TP_PROTO(sc_exit(long ret,) int epfd, int op, int fd, struct epoll_event * event), + TP_ARGS(sc_exit(ret,) epfd, op, fd, event), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, epfd, epfd)) sc_in(ctf_integer(int, op, op)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct epoll_event *, event, event))) +) +#endif +#ifndef OVERRIDE_64_epoll_wait +SC_LTTNG_TRACEPOINT_EVENT(epoll_wait, + TP_PROTO(sc_exit(long ret,) int epfd, struct epoll_event * events, int maxevents, int timeout), + TP_ARGS(sc_exit(ret,) epfd, events, maxevents, timeout), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, epfd, epfd)) sc_out(ctf_integer(struct epoll_event *, events, events)) sc_in(ctf_integer(int, maxevents, maxevents)) sc_in(ctf_integer(int, timeout, timeout))) +) +#endif +#ifndef OVERRIDE_64_sendfile64 +SC_LTTNG_TRACEPOINT_EVENT(sendfile64, + TP_PROTO(sc_exit(long ret,) int out_fd, int in_fd, loff_t * offset, size_t count), + TP_ARGS(sc_exit(ret,) out_fd, in_fd, offset, count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, out_fd, out_fd)) sc_in(ctf_integer(int, in_fd, in_fd)) sc_inout(ctf_integer(loff_t *, offset, offset)) sc_in(ctf_integer(size_t, count, count))) +) +#endif +#ifndef OVERRIDE_64_openat +SC_LTTNG_TRACEPOINT_EVENT(openat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, int flags, umode_t mode), + TP_ARGS(sc_exit(ret,) dfd, filename, flags, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(umode_t, mode, mode))) +) +#endif +#ifndef OVERRIDE_64_mknodat +SC_LTTNG_TRACEPOINT_EVENT(mknodat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, umode_t mode, unsigned dev), + TP_ARGS(sc_exit(ret,) dfd, filename, mode, dev), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(umode_t, mode, mode)) sc_in(ctf_integer(unsigned, dev, dev))) +) +#endif +#ifndef OVERRIDE_64_newfstatat +SC_LTTNG_TRACEPOINT_EVENT(newfstatat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, struct stat * statbuf, int flag), + TP_ARGS(sc_exit(ret,) dfd, filename, statbuf, flag), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_out(ctf_integer(struct stat *, statbuf, statbuf)) sc_in(ctf_integer(int, flag, flag))) +) +#endif +#ifndef OVERRIDE_64_renameat +SC_LTTNG_TRACEPOINT_EVENT(renameat, + TP_PROTO(sc_exit(long ret,) int olddfd, const char * oldname, int newdfd, const char * newname), + TP_ARGS(sc_exit(ret,) olddfd, oldname, newdfd, newname), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, olddfd, olddfd)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_integer(int, newdfd, newdfd)) sc_in(ctf_user_string(newname, newname))) +) +#endif +#ifndef OVERRIDE_64_readlinkat +SC_LTTNG_TRACEPOINT_EVENT(readlinkat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * pathname, char * buf, int bufsiz), + TP_ARGS(sc_exit(ret,) dfd, pathname, buf, bufsiz), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(int, bufsiz, bufsiz))) +) +#endif +#ifndef OVERRIDE_64_signalfd4 +SC_LTTNG_TRACEPOINT_EVENT(signalfd4, + TP_PROTO(sc_exit(long ret,) int ufd, sigset_t * user_mask, size_t sizemask, int flags), + TP_ARGS(sc_exit(ret,) ufd, user_mask, sizemask, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_in(ctf_integer(sigset_t *, user_mask, user_mask)) sc_in(ctf_integer(size_t, sizemask, sizemask)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_accept4 +SC_LTTNG_TRACEPOINT_EVENT(accept4, + TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * upeer_sockaddr, int * upeer_addrlen, int flags), + TP_ARGS(sc_exit(ret,) fd, upeer_sockaddr, upeer_addrlen, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct sockaddr *, upeer_sockaddr, upeer_sockaddr)) sc_inout(ctf_integer(int *, upeer_addrlen, upeer_addrlen)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_prlimit64 +SC_LTTNG_TRACEPOINT_EVENT(prlimit64, + TP_PROTO(sc_exit(long ret,) pid_t pid, unsigned int resource, const struct rlimit64 * new_rlim, struct rlimit64 * old_rlim), + TP_ARGS(sc_exit(ret,) pid, resource, new_rlim, old_rlim), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(unsigned int, resource, resource)) sc_in(ctf_integer(const struct rlimit64 *, new_rlim, new_rlim)) sc_out(ctf_integer(struct rlimit64 *, old_rlim, old_rlim))) +) +#endif +#ifndef OVERRIDE_64_32_llseek +SC_LTTNG_TRACEPOINT_EVENT(32_llseek, + TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int offset_high, unsigned int offset_low, loff_t * result, unsigned int origin), + TP_ARGS(sc_exit(ret,) fd, offset_high, offset_low, result, origin), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, fd, fd)) sc_inout(ctf_integer(unsigned int, offset_high, offset_high)) sc_inout(ctf_integer(unsigned int, offset_low, offset_low)) sc_inout(ctf_integer(loff_t *, result, result)) sc_inout(ctf_integer(unsigned int, origin, origin))) +) +#endif +#ifndef OVERRIDE_64_32_waitid +SC_LTTNG_TRACEPOINT_EVENT(32_waitid, + TP_PROTO(sc_exit(long ret,) int which, compat_pid_t pid, compat_siginfo_t * uinfo, int options, struct compat_rusage * uru), + TP_ARGS(sc_exit(ret,) which, pid, uinfo, options, uru), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, which, which)) sc_inout(ctf_integer(compat_pid_t, pid, pid)) sc_inout(ctf_integer(compat_siginfo_t *, uinfo, uinfo)) sc_inout(ctf_integer(int, options, options)) sc_inout(ctf_integer(struct compat_rusage *, uru, uru))) +) +#endif +#ifndef OVERRIDE_64_select +SC_LTTNG_TRACEPOINT_EVENT(select, + TP_PROTO(sc_exit(long ret,) int n, fd_set * inp, fd_set * outp, fd_set * exp, struct timeval * tvp), + TP_ARGS(sc_exit(ret,) n, inp, outp, exp, tvp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, n, n)) sc_inout(ctf_integer(fd_set *, inp, inp)) sc_inout(ctf_integer(fd_set *, outp, outp)) sc_inout(ctf_integer(fd_set *, exp, exp)) sc_inout(ctf_integer(struct timeval *, tvp, tvp))) +) +#endif +#ifndef OVERRIDE_64_setsockopt +SC_LTTNG_TRACEPOINT_EVENT(setsockopt, + TP_PROTO(sc_exit(long ret,) int fd, int level, int optname, char * optval, int optlen), + TP_ARGS(sc_exit(ret,) fd, level, optname, optval, optlen), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, level, level)) sc_in(ctf_integer(int, optname, optname)) sc_in(ctf_integer(char *, optval, optval)) sc_in(ctf_integer(int, optlen, optlen))) +) +#endif +#ifndef OVERRIDE_64_msgrcv +SC_LTTNG_TRACEPOINT_EVENT(msgrcv, + TP_PROTO(sc_exit(long ret,) int msqid, struct msgbuf * msgp, size_t msgsz, long msgtyp, int msgflg), + TP_ARGS(sc_exit(ret,) msqid, msgp, msgsz, msgtyp, msgflg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, msqid, msqid)) sc_out(ctf_integer(struct msgbuf *, msgp, msgp)) sc_in(ctf_integer(size_t, msgsz, msgsz)) sc_in(ctf_integer(long, msgtyp, msgtyp)) sc_in(ctf_integer(int, msgflg, msgflg))) +) +#endif +#ifndef OVERRIDE_64_mount +SC_LTTNG_TRACEPOINT_EVENT(mount, + TP_PROTO(sc_exit(long ret,) char * dev_name, char * dir_name, char * type, unsigned long flags, void * data), + TP_ARGS(sc_exit(ret,) dev_name, dir_name, type, flags, data), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(dev_name, dev_name)) sc_in(ctf_user_string(dir_name, dir_name)) sc_in(ctf_user_string(type, type)) sc_in(ctf_integer(unsigned long, flags, flags)) sc_in(ctf_integer(void *, data, data))) +) +#endif +#ifndef OVERRIDE_64_io_getevents +SC_LTTNG_TRACEPOINT_EVENT(io_getevents, + TP_PROTO(sc_exit(long ret,) aio_context_t ctx_id, long min_nr, long nr, struct io_event * events, struct timespec * timeout), + TP_ARGS(sc_exit(ret,) ctx_id, min_nr, nr, events, timeout), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx_id, ctx_id)) sc_in(ctf_integer(long, min_nr, min_nr)) sc_in(ctf_integer(long, nr, nr)) sc_out(ctf_integer(struct io_event *, events, events)) sc_inout(ctf_integer(struct timespec *, timeout, timeout))) +) +#endif +#ifndef OVERRIDE_64_waitid +SC_LTTNG_TRACEPOINT_EVENT(waitid, + TP_PROTO(sc_exit(long ret,) int which, pid_t upid, struct siginfo * infop, int options, struct rusage * ru), + TP_ARGS(sc_exit(ret,) which, upid, infop, options, ru), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(pid_t, upid, upid)) sc_out(ctf_integer(struct siginfo *, infop, infop)) sc_in(ctf_integer(int, options, options)) sc_out(ctf_integer(struct rusage *, ru, ru))) +) +#endif +#ifndef OVERRIDE_64_ppoll +SC_LTTNG_TRACEPOINT_EVENT(ppoll, + TP_PROTO(sc_exit(long ret,) struct pollfd * ufds, unsigned int nfds, struct timespec * tsp, const sigset_t * sigmask, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) ufds, nfds, tsp, sigmask, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct pollfd *, ufds, ufds)) sc_in(ctf_integer(unsigned int, nfds, nfds)) sc_in(ctf_integer(struct timespec *, tsp, tsp)) sc_in(ctf_integer(const sigset_t *, sigmask, sigmask)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) +) +#endif +#ifndef OVERRIDE_64_recvmmsg +SC_LTTNG_TRACEPOINT_EVENT(recvmmsg, + TP_PROTO(sc_exit(long ret,) int fd, struct mmsghdr * mmsg, unsigned int vlen, unsigned int flags, struct timespec * timeout), + TP_ARGS(sc_exit(ret,) fd, mmsg, vlen, flags, timeout), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct mmsghdr *, mmsg, mmsg)) sc_in(ctf_integer(unsigned int, vlen, vlen)) sc_in(ctf_integer(unsigned int, flags, flags)) sc_inout(ctf_integer(struct timespec *, timeout, timeout))) +) +#endif +#ifndef OVERRIDE_64_getsockopt +SC_LTTNG_TRACEPOINT_EVENT(getsockopt, + TP_PROTO(sc_exit(long ret,) int fd, int level, int optname, char * optval, int * optlen), + TP_ARGS(sc_exit(ret,) fd, level, optname, optval, optlen), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, level, level)) sc_in(ctf_integer(int, optname, optname)) sc_out(ctf_integer(char *, optval, optval)) sc_inout(ctf_integer(int *, optlen, optlen))) +) +#endif +#ifndef OVERRIDE_64_setxattr +SC_LTTNG_TRACEPOINT_EVENT(setxattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, const void * value, size_t size, int flags), + TP_ARGS(sc_exit(ret,) pathname, name, value, size, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(const void *, value, value)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_lsetxattr +SC_LTTNG_TRACEPOINT_EVENT(lsetxattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, const void * value, size_t size, int flags), + TP_ARGS(sc_exit(ret,) pathname, name, value, size, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(const void *, value, value)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_fsetxattr +SC_LTTNG_TRACEPOINT_EVENT(fsetxattr, + TP_PROTO(sc_exit(long ret,) int fd, const char * name, const void * value, size_t size, int flags), + TP_ARGS(sc_exit(ret,) fd, name, value, size, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(const void *, value, value)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_fchownat +SC_LTTNG_TRACEPOINT_EVENT(fchownat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, uid_t user, gid_t group, int flag), + TP_ARGS(sc_exit(ret,) dfd, filename, user, group, flag), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group)) sc_in(ctf_integer(int, flag, flag))) +) +#endif +#ifndef OVERRIDE_64_linkat +SC_LTTNG_TRACEPOINT_EVENT(linkat, + TP_PROTO(sc_exit(long ret,) int olddfd, const char * oldname, int newdfd, const char * newname, int flags), + TP_ARGS(sc_exit(ret,) olddfd, oldname, newdfd, newname, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, olddfd, olddfd)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_integer(int, newdfd, newdfd)) sc_in(ctf_user_string(newname, newname)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_preadv +SC_LTTNG_TRACEPOINT_EVENT(preadv, + TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen, unsigned long pos_l, unsigned long pos_h), + TP_ARGS(sc_exit(ret,) fd, vec, vlen, pos_l, pos_h), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_out(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen)) sc_in(ctf_integer(unsigned long, pos_l, pos_l)) sc_in(ctf_integer(unsigned long, pos_h, pos_h))) +) +#endif +#ifndef OVERRIDE_64_pwritev +SC_LTTNG_TRACEPOINT_EVENT(pwritev, + TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen, unsigned long pos_l, unsigned long pos_h), + TP_ARGS(sc_exit(ret,) fd, vec, vlen, pos_l, pos_h), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_in(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen)) sc_in(ctf_integer(unsigned long, pos_l, pos_l)) sc_in(ctf_integer(unsigned long, pos_h, pos_h))) +) +#endif +#ifndef OVERRIDE_64_32_pread +SC_LTTNG_TRACEPOINT_EVENT(32_pread, + TP_PROTO(sc_exit(long ret,) unsigned long fd, char * buf, size_t count, unsigned long unused, unsigned long a4, unsigned long a5), + TP_ARGS(sc_exit(ret,) fd, buf, count, unused, a4, a5), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned long, fd, fd)) sc_inout(ctf_integer(char *, buf, buf)) sc_inout(ctf_integer(size_t, count, count)) sc_inout(ctf_integer(unsigned long, unused, unused)) sc_inout(ctf_integer(unsigned long, a4, a4)) sc_inout(ctf_integer(unsigned long, a5, a5))) +) +#endif +#ifndef OVERRIDE_64_32_pwrite +SC_LTTNG_TRACEPOINT_EVENT(32_pwrite, + TP_PROTO(sc_exit(long ret,) unsigned int fd, const char * buf, size_t count, u32 unused, u64 a4, u64 a5), + TP_ARGS(sc_exit(ret,) fd, buf, count, unused, a4, a5), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, fd, fd)) sc_inout(ctf_integer(const char *, buf, buf)) sc_inout(ctf_integer(size_t, count, count)) sc_inout(ctf_integer(u32, unused, unused)) sc_inout(ctf_integer(u64, a4, a4)) sc_inout(ctf_integer(u64, a5, a5))) +) +#endif +#ifndef OVERRIDE_64_32_fanotify_mark +SC_LTTNG_TRACEPOINT_EVENT(32_fanotify_mark, + TP_PROTO(sc_exit(long ret,) int fanotify_fd, unsigned int flags, u64 a3, u64 a4, int dfd, const char * pathname), + TP_ARGS(sc_exit(ret,) fanotify_fd, flags, a3, a4, dfd, pathname), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, fanotify_fd, fanotify_fd)) sc_inout(ctf_integer(unsigned int, flags, flags)) sc_inout(ctf_integer(u64, a3, a3)) sc_inout(ctf_integer(u64, a4, a4)) sc_inout(ctf_integer(int, dfd, dfd)) sc_inout(ctf_user_string(pathname, pathname))) +) +#endif +#ifndef OVERRIDE_64_recvfrom +SC_LTTNG_TRACEPOINT_EVENT(recvfrom, + TP_PROTO(sc_exit(long ret,) int fd, void * ubuf, size_t size, unsigned int flags, struct sockaddr * addr, int * addr_len), + TP_ARGS(sc_exit(ret,) fd, ubuf, size, flags, addr, addr_len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(void *, ubuf, ubuf)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(unsigned int, flags, flags)) sc_out(ctf_integer(struct sockaddr *, addr, addr)) sc_inout(ctf_integer(int *, addr_len, addr_len))) +) +#endif +#ifndef OVERRIDE_64_futex +SC_LTTNG_TRACEPOINT_EVENT(futex, + TP_PROTO(sc_exit(long ret,) u32 * uaddr, int op, u32 val, struct timespec * utime, u32 * uaddr2, u32 val3), + TP_ARGS(sc_exit(ret,) uaddr, op, val, utime, uaddr2, val3), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(u32 *, uaddr, uaddr)) sc_in(ctf_integer(int, op, op)) sc_in(ctf_integer(u32, val, val)) sc_in(ctf_integer(struct timespec *, utime, utime)) sc_inout(ctf_integer(u32 *, uaddr2, uaddr2)) sc_in(ctf_integer(u32, val3, val3))) +) +#endif +#ifndef OVERRIDE_64_pselect6 +SC_LTTNG_TRACEPOINT_EVENT(pselect6, + TP_PROTO(sc_exit(long ret,) int n, fd_set * inp, fd_set * outp, fd_set * exp, struct timespec * tsp, void * sig), + TP_ARGS(sc_exit(ret,) n, inp, outp, exp, tsp, sig), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, n, n)) sc_inout(ctf_integer(fd_set *, inp, inp)) sc_inout(ctf_integer(fd_set *, outp, outp)) sc_inout(ctf_integer(fd_set *, exp, exp)) sc_inout(ctf_integer(struct timespec *, tsp, tsp)) sc_in(ctf_integer(void *, sig, sig))) +) +#endif +#ifndef OVERRIDE_64_epoll_pwait +SC_LTTNG_TRACEPOINT_EVENT(epoll_pwait, + TP_PROTO(sc_exit(long ret,) int epfd, struct epoll_event * events, int maxevents, int timeout, const sigset_t * sigmask, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) epfd, events, maxevents, timeout, sigmask, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, epfd, epfd)) sc_out(ctf_integer(struct epoll_event *, events, events)) sc_in(ctf_integer(int, maxevents, maxevents)) sc_in(ctf_integer(int, timeout, timeout)) sc_in(ctf_integer(const sigset_t *, sigmask, sigmask)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) +) +#endif +#ifndef OVERRIDE_64_process_vm_readv +SC_LTTNG_TRACEPOINT_EVENT(process_vm_readv, + TP_PROTO(sc_exit(long ret,) pid_t pid, const struct iovec * lvec, unsigned long liovcnt, const struct iovec * rvec, unsigned long riovcnt, unsigned long flags), + TP_ARGS(sc_exit(ret,) pid, lvec, liovcnt, rvec, riovcnt, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_out(ctf_integer(const struct iovec *, lvec, lvec)) sc_in(ctf_integer(unsigned long, liovcnt, liovcnt)) sc_in(ctf_integer(const struct iovec *, rvec, rvec)) sc_in(ctf_integer(unsigned long, riovcnt, riovcnt)) sc_in(ctf_integer(unsigned long, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_process_vm_writev +SC_LTTNG_TRACEPOINT_EVENT(process_vm_writev, + TP_PROTO(sc_exit(long ret,) pid_t pid, const struct iovec * lvec, unsigned long liovcnt, const struct iovec * rvec, unsigned long riovcnt, unsigned long flags), + TP_ARGS(sc_exit(ret,) pid, lvec, liovcnt, rvec, riovcnt, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(const struct iovec *, lvec, lvec)) sc_in(ctf_integer(unsigned long, liovcnt, liovcnt)) sc_in(ctf_integer(const struct iovec *, rvec, rvec)) sc_in(ctf_integer(unsigned long, riovcnt, riovcnt)) sc_in(ctf_integer(unsigned long, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_sendto +SC_LTTNG_TRACEPOINT_EVENT(sendto, + TP_PROTO(sc_exit(long ret,) int fd, void * buff, size_t len, unsigned int flags, struct sockaddr * addr, int addr_len), + TP_ARGS(sc_exit(ret,) fd, buff, len, flags, addr, addr_len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(void *, buff, buff)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned int, flags, flags)) sc_in(ctf_integer(struct sockaddr *, addr, addr)) sc_in(ctf_integer(int, addr_len, addr_len))) +) +#endif +#ifndef OVERRIDE_64_32_futex +SC_LTTNG_TRACEPOINT_EVENT(32_futex, + TP_PROTO(sc_exit(long ret,) u32 * uaddr, int op, u32 val, struct compat_timespec * utime, u32 * uaddr2, u32 val3), + TP_ARGS(sc_exit(ret,) uaddr, op, val, utime, uaddr2, val3), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(u32 *, uaddr, uaddr)) sc_inout(ctf_integer(int, op, op)) sc_inout(ctf_integer(u32, val, val)) sc_inout(ctf_integer(struct compat_timespec *, utime, utime)) sc_inout(ctf_integer(u32 *, uaddr2, uaddr2)) sc_inout(ctf_integer(u32, val3, val3))) +) +#endif +#ifndef OVERRIDE_64_splice +SC_LTTNG_TRACEPOINT_EVENT(splice, + TP_PROTO(sc_exit(long ret,) int fd_in, loff_t * off_in, int fd_out, loff_t * off_out, size_t len, unsigned int flags), + TP_ARGS(sc_exit(ret,) fd_in, off_in, fd_out, off_out, len, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd_in, fd_in)) sc_in(ctf_integer(loff_t *, off_in, off_in)) sc_in(ctf_integer(int, fd_out, fd_out)) sc_in(ctf_integer(loff_t *, off_out, off_out)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned int, flags, flags))) +) +#endif + +#endif /* _TRACE_SYSCALLS_POINTERS_H */ + +/* This part must be outside protection */ +#include + +#else /* CREATE_SYSCALL_TABLE */ + +#include "mips-64-syscalls_pointers_override.h" +#include "syscalls_pointers_override.h" + +#ifndef OVERRIDE_TABLE_64_waitpid +TRACE_SYSCALL_TABLE(waitpid, waitpid, 4007, 3) +#endif +#ifndef OVERRIDE_TABLE_64_oldumount +TRACE_SYSCALL_TABLE(oldumount, oldumount, 4022, 1) +#endif +#ifndef OVERRIDE_TABLE_64_olduname +TRACE_SYSCALL_TABLE(olduname, olduname, 4059, 1) +#endif +#ifndef OVERRIDE_TABLE_64_32_sigaction +TRACE_SYSCALL_TABLE(32_sigaction, 32_sigaction, 4067, 3) +#endif +#ifndef OVERRIDE_TABLE_64_uselib +TRACE_SYSCALL_TABLE(uselib, uselib, 4086, 1) +#endif +#ifndef OVERRIDE_TABLE_64_uname +TRACE_SYSCALL_TABLE(uname, uname, 4109, 1) +#endif +#ifndef OVERRIDE_TABLE_64_32_llseek +TRACE_SYSCALL_TABLE(32_llseek, 32_llseek, 4140, 5) +#endif +#ifndef OVERRIDE_TABLE_64_send +TRACE_SYSCALL_TABLE(send, send, 4178, 4) +#endif +#ifndef OVERRIDE_TABLE_64_32_pread +TRACE_SYSCALL_TABLE(32_pread, 32_pread, 4200, 6) +#endif +#ifndef OVERRIDE_TABLE_64_32_pwrite +TRACE_SYSCALL_TABLE(32_pwrite, 32_pwrite, 4201, 6) +#endif +#ifndef OVERRIDE_TABLE_64_32_truncate64 +TRACE_SYSCALL_TABLE(32_truncate64, 32_truncate64, 4211, 4) +#endif +#ifndef OVERRIDE_TABLE_64_32_waitid +TRACE_SYSCALL_TABLE(32_waitid, 32_waitid, 4278, 5) +#endif +#ifndef OVERRIDE_TABLE_64_32_fanotify_mark +TRACE_SYSCALL_TABLE(32_fanotify_mark, 32_fanotify_mark, 4337, 6) +#endif +#ifndef OVERRIDE_TABLE_64_rt_sigaction +TRACE_SYSCALL_TABLE(rt_sigaction, rt_sigaction, 5013, 4) +#endif +#ifndef OVERRIDE_TABLE_64_rt_sigprocmask +TRACE_SYSCALL_TABLE(rt_sigprocmask, rt_sigprocmask, 5014, 4) +#endif +#ifndef OVERRIDE_TABLE_64_readv +TRACE_SYSCALL_TABLE(readv, readv, 5018, 3) +#endif +#ifndef OVERRIDE_TABLE_64_writev +TRACE_SYSCALL_TABLE(writev, writev, 5019, 3) +#endif +#ifndef OVERRIDE_TABLE_64_select +TRACE_SYSCALL_TABLE(select, select, 5022, 5) +#endif +#ifndef OVERRIDE_TABLE_64_shmctl +TRACE_SYSCALL_TABLE(shmctl, shmctl, 5030, 3) +#endif +#ifndef OVERRIDE_TABLE_64_nanosleep +TRACE_SYSCALL_TABLE(nanosleep, nanosleep, 5034, 2) +#endif +#ifndef OVERRIDE_TABLE_64_getitimer +TRACE_SYSCALL_TABLE(getitimer, getitimer, 5035, 2) +#endif +#ifndef OVERRIDE_TABLE_64_setitimer +TRACE_SYSCALL_TABLE(setitimer, setitimer, 5036, 3) +#endif +#ifndef OVERRIDE_TABLE_64_recvfrom +TRACE_SYSCALL_TABLE(recvfrom, recvfrom, 5044, 6) +#endif +#ifndef OVERRIDE_TABLE_64_sendmsg +TRACE_SYSCALL_TABLE(sendmsg, sendmsg, 5045, 3) +#endif +#ifndef OVERRIDE_TABLE_64_recvmsg +TRACE_SYSCALL_TABLE(recvmsg, recvmsg, 5046, 3) +#endif +#ifndef OVERRIDE_TABLE_64_setsockopt +TRACE_SYSCALL_TABLE(setsockopt, setsockopt, 5053, 5) +#endif +#ifndef OVERRIDE_TABLE_64_wait4 +TRACE_SYSCALL_TABLE(wait4, wait4, 5059, 4) +#endif +#ifndef OVERRIDE_TABLE_64_msgsnd +TRACE_SYSCALL_TABLE(msgsnd, msgsnd, 5067, 4) +#endif +#ifndef OVERRIDE_TABLE_64_msgrcv +TRACE_SYSCALL_TABLE(msgrcv, msgrcv, 5068, 5) +#endif +#ifndef OVERRIDE_TABLE_64_msgctl +TRACE_SYSCALL_TABLE(msgctl, msgctl, 5069, 3) +#endif +#ifndef OVERRIDE_TABLE_64_getdents +TRACE_SYSCALL_TABLE(getdents, getdents, 5076, 3) +#endif +#ifndef OVERRIDE_TABLE_64_gettimeofday +TRACE_SYSCALL_TABLE(gettimeofday, gettimeofday, 5094, 2) +#endif +#ifndef OVERRIDE_TABLE_64_getrlimit +TRACE_SYSCALL_TABLE(getrlimit, getrlimit, 5095, 2) +#endif +#ifndef OVERRIDE_TABLE_64_getrusage +TRACE_SYSCALL_TABLE(getrusage, getrusage, 5096, 2) +#endif +#ifndef OVERRIDE_TABLE_64_sysinfo +TRACE_SYSCALL_TABLE(sysinfo, sysinfo, 5097, 1) +#endif +#ifndef OVERRIDE_TABLE_64_times +TRACE_SYSCALL_TABLE(times, times, 5098, 1) +#endif +#ifndef OVERRIDE_TABLE_64_rt_sigpending +TRACE_SYSCALL_TABLE(rt_sigpending, rt_sigpending, 5125, 2) +#endif +#ifndef OVERRIDE_TABLE_64_rt_sigtimedwait +TRACE_SYSCALL_TABLE(rt_sigtimedwait, rt_sigtimedwait, 5126, 4) +#endif +#ifndef OVERRIDE_TABLE_64_rt_sigqueueinfo +TRACE_SYSCALL_TABLE(rt_sigqueueinfo, rt_sigqueueinfo, 5127, 3) +#endif +#ifndef OVERRIDE_TABLE_64_utime +TRACE_SYSCALL_TABLE(utime, utime, 5130, 2) +#endif +#ifndef OVERRIDE_TABLE_64_ustat +TRACE_SYSCALL_TABLE(ustat, ustat, 5133, 2) +#endif +#ifndef OVERRIDE_TABLE_64_statfs +TRACE_SYSCALL_TABLE(statfs, statfs, 5134, 2) +#endif +#ifndef OVERRIDE_TABLE_64_fstatfs +TRACE_SYSCALL_TABLE(fstatfs, fstatfs, 5135, 2) +#endif +#ifndef OVERRIDE_TABLE_64_sched_rr_get_interval +TRACE_SYSCALL_TABLE(sched_rr_get_interval, sched_rr_get_interval, 5145, 2) +#endif +#ifndef OVERRIDE_TABLE_64_sysctl +TRACE_SYSCALL_TABLE(sysctl, sysctl, 5152, 1) +#endif +#ifndef OVERRIDE_TABLE_64_adjtimex +TRACE_SYSCALL_TABLE(adjtimex, adjtimex, 5154, 1) +#endif +#ifndef OVERRIDE_TABLE_64_setrlimit +TRACE_SYSCALL_TABLE(setrlimit, setrlimit, 5155, 2) +#endif +#ifndef OVERRIDE_TABLE_64_settimeofday +TRACE_SYSCALL_TABLE(settimeofday, settimeofday, 5159, 2) +#endif +#ifndef OVERRIDE_TABLE_64_mount +TRACE_SYSCALL_TABLE(mount, mount, 5160, 5) +#endif +#ifndef OVERRIDE_TABLE_64_futex +TRACE_SYSCALL_TABLE(futex, futex, 5194, 6) +#endif +#ifndef OVERRIDE_TABLE_64_sched_setaffinity +TRACE_SYSCALL_TABLE(sched_setaffinity, sched_setaffinity, 5195, 3) +#endif +#ifndef OVERRIDE_TABLE_64_sched_getaffinity +TRACE_SYSCALL_TABLE(sched_getaffinity, sched_getaffinity, 5196, 3) +#endif +#ifndef OVERRIDE_TABLE_64_io_setup +TRACE_SYSCALL_TABLE(io_setup, io_setup, 5200, 2) +#endif +#ifndef OVERRIDE_TABLE_64_io_getevents +TRACE_SYSCALL_TABLE(io_getevents, io_getevents, 5202, 5) +#endif +#ifndef OVERRIDE_TABLE_64_io_submit +TRACE_SYSCALL_TABLE(io_submit, io_submit, 5203, 3) +#endif +#ifndef OVERRIDE_TABLE_64_semtimedop +TRACE_SYSCALL_TABLE(semtimedop, semtimedop, 5214, 4) +#endif +#ifndef OVERRIDE_TABLE_64_timer_create +TRACE_SYSCALL_TABLE(timer_create, timer_create, 5216, 3) +#endif +#ifndef OVERRIDE_TABLE_64_timer_settime +TRACE_SYSCALL_TABLE(timer_settime, timer_settime, 5217, 4) +#endif +#ifndef OVERRIDE_TABLE_64_timer_gettime +TRACE_SYSCALL_TABLE(timer_gettime, timer_gettime, 5218, 2) +#endif +#ifndef OVERRIDE_TABLE_64_clock_settime +TRACE_SYSCALL_TABLE(clock_settime, clock_settime, 5221, 2) +#endif +#ifndef OVERRIDE_TABLE_64_clock_gettime +TRACE_SYSCALL_TABLE(clock_gettime, clock_gettime, 5222, 2) +#endif +#ifndef OVERRIDE_TABLE_64_clock_getres +TRACE_SYSCALL_TABLE(clock_getres, clock_getres, 5223, 2) +#endif +#ifndef OVERRIDE_TABLE_64_clock_nanosleep +TRACE_SYSCALL_TABLE(clock_nanosleep, clock_nanosleep, 5224, 4) +#endif +#ifndef OVERRIDE_TABLE_64_utimes +TRACE_SYSCALL_TABLE(utimes, utimes, 5226, 2) +#endif +#ifndef OVERRIDE_TABLE_64_waitid +TRACE_SYSCALL_TABLE(waitid, waitid, 5237, 5) +#endif +#ifndef OVERRIDE_TABLE_64_futimesat +TRACE_SYSCALL_TABLE(futimesat, futimesat, 5251, 3) +#endif +#ifndef OVERRIDE_TABLE_64_pselect6 +TRACE_SYSCALL_TABLE(pselect6, pselect6, 5260, 6) +#endif +#ifndef OVERRIDE_TABLE_64_ppoll +TRACE_SYSCALL_TABLE(ppoll, ppoll, 5261, 5) +#endif +#ifndef OVERRIDE_TABLE_64_vmsplice +TRACE_SYSCALL_TABLE(vmsplice, vmsplice, 5266, 4) +#endif +#ifndef OVERRIDE_TABLE_64_set_robust_list +TRACE_SYSCALL_TABLE(set_robust_list, set_robust_list, 5268, 2) +#endif +#ifndef OVERRIDE_TABLE_64_get_robust_list +TRACE_SYSCALL_TABLE(get_robust_list, get_robust_list, 5269, 3) +#endif +#ifndef OVERRIDE_TABLE_64_epoll_pwait +TRACE_SYSCALL_TABLE(epoll_pwait, epoll_pwait, 5272, 6) +#endif +#ifndef OVERRIDE_TABLE_64_utimensat +TRACE_SYSCALL_TABLE(utimensat, utimensat, 5275, 4) +#endif +#ifndef OVERRIDE_TABLE_64_signalfd +TRACE_SYSCALL_TABLE(signalfd, signalfd, 5276, 3) +#endif +#ifndef OVERRIDE_TABLE_64_timerfd_gettime +TRACE_SYSCALL_TABLE(timerfd_gettime, timerfd_gettime, 5281, 2) +#endif +#ifndef OVERRIDE_TABLE_64_timerfd_settime +TRACE_SYSCALL_TABLE(timerfd_settime, timerfd_settime, 5282, 4) +#endif +#ifndef OVERRIDE_TABLE_64_rt_tgsigqueueinfo +TRACE_SYSCALL_TABLE(rt_tgsigqueueinfo, rt_tgsigqueueinfo, 5291, 4) +#endif +#ifndef OVERRIDE_TABLE_64_recvmmsg +TRACE_SYSCALL_TABLE(recvmmsg, recvmmsg, 5294, 5) +#endif +#ifndef OVERRIDE_TABLE_64_clock_adjtime +TRACE_SYSCALL_TABLE(clock_adjtime, clock_adjtime, 5300, 2) +#endif +#ifndef OVERRIDE_TABLE_64_sendmmsg +TRACE_SYSCALL_TABLE(sendmmsg, sendmmsg, 5302, 4) +#endif +#ifndef OVERRIDE_TABLE_64_process_vm_readv +TRACE_SYSCALL_TABLE(process_vm_readv, process_vm_readv, 5304, 6) +#endif +#ifndef OVERRIDE_TABLE_64_process_vm_writev +TRACE_SYSCALL_TABLE(process_vm_writev, process_vm_writev, 5305, 6) +#endif +#ifndef OVERRIDE_TABLE_64_read +TRACE_SYSCALL_TABLE(read, read, 6000, 3) +#endif +#ifndef OVERRIDE_TABLE_64_write +TRACE_SYSCALL_TABLE(write, write, 6001, 3) +#endif +#ifndef OVERRIDE_TABLE_64_open +TRACE_SYSCALL_TABLE(open, open, 6002, 3) +#endif +#ifndef OVERRIDE_TABLE_64_newstat +TRACE_SYSCALL_TABLE(newstat, newstat, 6004, 2) +#endif +#ifndef OVERRIDE_TABLE_64_newfstat +TRACE_SYSCALL_TABLE(newfstat, newfstat, 6005, 2) +#endif +#ifndef OVERRIDE_TABLE_64_newlstat +TRACE_SYSCALL_TABLE(newlstat, newlstat, 6006, 2) +#endif +#ifndef OVERRIDE_TABLE_64_poll +TRACE_SYSCALL_TABLE(poll, poll, 6007, 3) +#endif +#ifndef OVERRIDE_TABLE_64_32_rt_sigaction +TRACE_SYSCALL_TABLE(32_rt_sigaction, 32_rt_sigaction, 6013, 4) +#endif +#ifndef OVERRIDE_TABLE_64_32_rt_sigprocmask +TRACE_SYSCALL_TABLE(32_rt_sigprocmask, 32_rt_sigprocmask, 6014, 4) +#endif +#ifndef OVERRIDE_TABLE_64_access +TRACE_SYSCALL_TABLE(access, access, 6020, 2) +#endif +#ifndef OVERRIDE_TABLE_64_mincore +TRACE_SYSCALL_TABLE(mincore, mincore, 6026, 3) +#endif +#ifndef OVERRIDE_TABLE_64_shmat +TRACE_SYSCALL_TABLE(shmat, shmat, 6029, 3) +#endif +#ifndef OVERRIDE_TABLE_64_32_sendfile +TRACE_SYSCALL_TABLE(32_sendfile, 32_sendfile, 6039, 4) +#endif +#ifndef OVERRIDE_TABLE_64_connect +TRACE_SYSCALL_TABLE(connect, connect, 6041, 3) +#endif +#ifndef OVERRIDE_TABLE_64_accept +TRACE_SYSCALL_TABLE(accept, accept, 6042, 3) +#endif +#ifndef OVERRIDE_TABLE_64_sendto +TRACE_SYSCALL_TABLE(sendto, sendto, 6043, 6) +#endif +#ifndef OVERRIDE_TABLE_64_bind +TRACE_SYSCALL_TABLE(bind, bind, 6048, 3) +#endif +#ifndef OVERRIDE_TABLE_64_getsockname +TRACE_SYSCALL_TABLE(getsockname, getsockname, 6050, 3) +#endif +#ifndef OVERRIDE_TABLE_64_getpeername +TRACE_SYSCALL_TABLE(getpeername, getpeername, 6051, 3) +#endif +#ifndef OVERRIDE_TABLE_64_socketpair +TRACE_SYSCALL_TABLE(socketpair, socketpair, 6052, 4) +#endif +#ifndef OVERRIDE_TABLE_64_getsockopt +TRACE_SYSCALL_TABLE(getsockopt, getsockopt, 6054, 5) +#endif +#ifndef OVERRIDE_TABLE_64_newuname +TRACE_SYSCALL_TABLE(newuname, newuname, 6061, 1) +#endif +#ifndef OVERRIDE_TABLE_64_semop +TRACE_SYSCALL_TABLE(semop, semop, 6063, 3) +#endif +#ifndef OVERRIDE_TABLE_64_shmdt +TRACE_SYSCALL_TABLE(shmdt, shmdt, 6065, 1) +#endif +#ifndef OVERRIDE_TABLE_64_truncate +TRACE_SYSCALL_TABLE(truncate, truncate, 6074, 2) +#endif +#ifndef OVERRIDE_TABLE_64_getcwd +TRACE_SYSCALL_TABLE(getcwd, getcwd, 6077, 2) +#endif +#ifndef OVERRIDE_TABLE_64_chdir +TRACE_SYSCALL_TABLE(chdir, chdir, 6078, 1) +#endif +#ifndef OVERRIDE_TABLE_64_rename +TRACE_SYSCALL_TABLE(rename, rename, 6080, 2) +#endif +#ifndef OVERRIDE_TABLE_64_mkdir +TRACE_SYSCALL_TABLE(mkdir, mkdir, 6081, 2) +#endif +#ifndef OVERRIDE_TABLE_64_rmdir +TRACE_SYSCALL_TABLE(rmdir, rmdir, 6082, 1) +#endif +#ifndef OVERRIDE_TABLE_64_creat +TRACE_SYSCALL_TABLE(creat, creat, 6083, 2) +#endif +#ifndef OVERRIDE_TABLE_64_link +TRACE_SYSCALL_TABLE(link, link, 6084, 2) +#endif +#ifndef OVERRIDE_TABLE_64_unlink +TRACE_SYSCALL_TABLE(unlink, unlink, 6085, 1) +#endif +#ifndef OVERRIDE_TABLE_64_symlink +TRACE_SYSCALL_TABLE(symlink, symlink, 6086, 2) +#endif +#ifndef OVERRIDE_TABLE_64_readlink +TRACE_SYSCALL_TABLE(readlink, readlink, 6087, 3) +#endif +#ifndef OVERRIDE_TABLE_64_chmod +TRACE_SYSCALL_TABLE(chmod, chmod, 6088, 2) +#endif +#ifndef OVERRIDE_TABLE_64_chown +TRACE_SYSCALL_TABLE(chown, chown, 6090, 3) +#endif +#ifndef OVERRIDE_TABLE_64_lchown +TRACE_SYSCALL_TABLE(lchown, lchown, 6092, 3) +#endif +#ifndef OVERRIDE_TABLE_64_syslog +TRACE_SYSCALL_TABLE(syslog, syslog, 6101, 3) +#endif +#ifndef OVERRIDE_TABLE_64_getgroups +TRACE_SYSCALL_TABLE(getgroups, getgroups, 6113, 2) +#endif +#ifndef OVERRIDE_TABLE_64_setgroups +TRACE_SYSCALL_TABLE(setgroups, setgroups, 6114, 2) +#endif +#ifndef OVERRIDE_TABLE_64_getresuid +TRACE_SYSCALL_TABLE(getresuid, getresuid, 6116, 3) +#endif +#ifndef OVERRIDE_TABLE_64_getresgid +TRACE_SYSCALL_TABLE(getresgid, getresgid, 6118, 3) +#endif +#ifndef OVERRIDE_TABLE_64_32_rt_sigpending +TRACE_SYSCALL_TABLE(32_rt_sigpending, 32_rt_sigpending, 6125, 2) +#endif +#ifndef OVERRIDE_TABLE_64_32_rt_sigqueueinfo +TRACE_SYSCALL_TABLE(32_rt_sigqueueinfo, 32_rt_sigqueueinfo, 6127, 3) +#endif +#ifndef OVERRIDE_TABLE_64_mknod +TRACE_SYSCALL_TABLE(mknod, mknod, 6131, 3) +#endif +#ifndef OVERRIDE_TABLE_64_sched_setparam +TRACE_SYSCALL_TABLE(sched_setparam, sched_setparam, 6139, 2) +#endif +#ifndef OVERRIDE_TABLE_64_sched_getparam +TRACE_SYSCALL_TABLE(sched_getparam, sched_getparam, 6140, 2) +#endif +#ifndef OVERRIDE_TABLE_64_sched_setscheduler +TRACE_SYSCALL_TABLE(sched_setscheduler, sched_setscheduler, 6141, 3) +#endif +#ifndef OVERRIDE_TABLE_64_32_sched_rr_get_interval +TRACE_SYSCALL_TABLE(32_sched_rr_get_interval, 32_sched_rr_get_interval, 6145, 2) +#endif +#ifndef OVERRIDE_TABLE_64_pivot_root +TRACE_SYSCALL_TABLE(pivot_root, pivot_root, 6151, 2) +#endif +#ifndef OVERRIDE_TABLE_64_chroot +TRACE_SYSCALL_TABLE(chroot, chroot, 6156, 1) +#endif +#ifndef OVERRIDE_TABLE_64_umount +TRACE_SYSCALL_TABLE(umount, umount, 6161, 2) +#endif +#ifndef OVERRIDE_TABLE_64_swapon +TRACE_SYSCALL_TABLE(swapon, swapon, 6162, 2) +#endif +#ifndef OVERRIDE_TABLE_64_swapoff +TRACE_SYSCALL_TABLE(swapoff, swapoff, 6163, 1) +#endif +#ifndef OVERRIDE_TABLE_64_reboot +TRACE_SYSCALL_TABLE(reboot, reboot, 6164, 4) +#endif +#ifndef OVERRIDE_TABLE_64_sethostname +TRACE_SYSCALL_TABLE(sethostname, sethostname, 6165, 2) +#endif +#ifndef OVERRIDE_TABLE_64_setdomainname +TRACE_SYSCALL_TABLE(setdomainname, setdomainname, 6166, 2) +#endif +#ifndef OVERRIDE_TABLE_64_init_module +TRACE_SYSCALL_TABLE(init_module, init_module, 6168, 3) +#endif +#ifndef OVERRIDE_TABLE_64_delete_module +TRACE_SYSCALL_TABLE(delete_module, delete_module, 6169, 2) +#endif +#ifndef OVERRIDE_TABLE_64_quotactl +TRACE_SYSCALL_TABLE(quotactl, quotactl, 6172, 4) +#endif +#ifndef OVERRIDE_TABLE_64_setxattr +TRACE_SYSCALL_TABLE(setxattr, setxattr, 6180, 5) +#endif +#ifndef OVERRIDE_TABLE_64_lsetxattr +TRACE_SYSCALL_TABLE(lsetxattr, lsetxattr, 6181, 5) +#endif +#ifndef OVERRIDE_TABLE_64_fsetxattr +TRACE_SYSCALL_TABLE(fsetxattr, fsetxattr, 6182, 5) +#endif +#ifndef OVERRIDE_TABLE_64_getxattr +TRACE_SYSCALL_TABLE(getxattr, getxattr, 6183, 4) +#endif +#ifndef OVERRIDE_TABLE_64_lgetxattr +TRACE_SYSCALL_TABLE(lgetxattr, lgetxattr, 6184, 4) +#endif +#ifndef OVERRIDE_TABLE_64_fgetxattr +TRACE_SYSCALL_TABLE(fgetxattr, fgetxattr, 6185, 4) +#endif +#ifndef OVERRIDE_TABLE_64_listxattr +TRACE_SYSCALL_TABLE(listxattr, listxattr, 6186, 3) +#endif +#ifndef OVERRIDE_TABLE_64_llistxattr +TRACE_SYSCALL_TABLE(llistxattr, llistxattr, 6187, 3) +#endif +#ifndef OVERRIDE_TABLE_64_flistxattr +TRACE_SYSCALL_TABLE(flistxattr, flistxattr, 6188, 3) +#endif +#ifndef OVERRIDE_TABLE_64_removexattr +TRACE_SYSCALL_TABLE(removexattr, removexattr, 6189, 2) +#endif +#ifndef OVERRIDE_TABLE_64_lremovexattr +TRACE_SYSCALL_TABLE(lremovexattr, lremovexattr, 6190, 2) +#endif +#ifndef OVERRIDE_TABLE_64_fremovexattr +TRACE_SYSCALL_TABLE(fremovexattr, fremovexattr, 6191, 2) +#endif +#ifndef OVERRIDE_TABLE_64_32_futex +TRACE_SYSCALL_TABLE(32_futex, 32_futex, 6194, 6) +#endif +#ifndef OVERRIDE_TABLE_64_cachectl +TRACE_SYSCALL_TABLE(cachectl, cachectl, 6198, 3) +#endif +#ifndef OVERRIDE_TABLE_64_io_cancel +TRACE_SYSCALL_TABLE(io_cancel, io_cancel, 6204, 3) +#endif +#ifndef OVERRIDE_TABLE_64_epoll_ctl +TRACE_SYSCALL_TABLE(epoll_ctl, epoll_ctl, 6208, 4) +#endif +#ifndef OVERRIDE_TABLE_64_epoll_wait +TRACE_SYSCALL_TABLE(epoll_wait, epoll_wait, 6209, 4) +#endif +#ifndef OVERRIDE_TABLE_64_set_tid_address +TRACE_SYSCALL_TABLE(set_tid_address, set_tid_address, 6213, 1) +#endif +#ifndef OVERRIDE_TABLE_64_sendfile64 +TRACE_SYSCALL_TABLE(sendfile64, sendfile64, 6219, 4) +#endif +#ifndef OVERRIDE_TABLE_64_inotify_add_watch +TRACE_SYSCALL_TABLE(inotify_add_watch, inotify_add_watch, 6248, 3) +#endif +#ifndef OVERRIDE_TABLE_64_openat +TRACE_SYSCALL_TABLE(openat, openat, 6251, 4) +#endif +#ifndef OVERRIDE_TABLE_64_mkdirat +TRACE_SYSCALL_TABLE(mkdirat, mkdirat, 6252, 3) +#endif +#ifndef OVERRIDE_TABLE_64_mknodat +TRACE_SYSCALL_TABLE(mknodat, mknodat, 6253, 4) +#endif +#ifndef OVERRIDE_TABLE_64_fchownat +TRACE_SYSCALL_TABLE(fchownat, fchownat, 6254, 5) +#endif +#ifndef OVERRIDE_TABLE_64_newfstatat +TRACE_SYSCALL_TABLE(newfstatat, newfstatat, 6256, 4) +#endif +#ifndef OVERRIDE_TABLE_64_unlinkat +TRACE_SYSCALL_TABLE(unlinkat, unlinkat, 6257, 3) +#endif +#ifndef OVERRIDE_TABLE_64_renameat +TRACE_SYSCALL_TABLE(renameat, renameat, 6258, 4) +#endif +#ifndef OVERRIDE_TABLE_64_linkat +TRACE_SYSCALL_TABLE(linkat, linkat, 6259, 5) +#endif +#ifndef OVERRIDE_TABLE_64_symlinkat +TRACE_SYSCALL_TABLE(symlinkat, symlinkat, 6260, 3) +#endif +#ifndef OVERRIDE_TABLE_64_readlinkat +TRACE_SYSCALL_TABLE(readlinkat, readlinkat, 6261, 4) +#endif +#ifndef OVERRIDE_TABLE_64_fchmodat +TRACE_SYSCALL_TABLE(fchmodat, fchmodat, 6262, 3) +#endif +#ifndef OVERRIDE_TABLE_64_faccessat +TRACE_SYSCALL_TABLE(faccessat, faccessat, 6263, 3) +#endif +#ifndef OVERRIDE_TABLE_64_splice +TRACE_SYSCALL_TABLE(splice, splice, 6267, 6) +#endif +#ifndef OVERRIDE_TABLE_64_getcpu +TRACE_SYSCALL_TABLE(getcpu, getcpu, 6275, 3) +#endif +#ifndef OVERRIDE_TABLE_64_signalfd4 +TRACE_SYSCALL_TABLE(signalfd4, signalfd4, 6287, 4) +#endif +#ifndef OVERRIDE_TABLE_64_pipe2 +TRACE_SYSCALL_TABLE(pipe2, pipe2, 6291, 2) +#endif +#ifndef OVERRIDE_TABLE_64_preadv +TRACE_SYSCALL_TABLE(preadv, preadv, 6293, 5) +#endif +#ifndef OVERRIDE_TABLE_64_pwritev +TRACE_SYSCALL_TABLE(pwritev, pwritev, 6294, 5) +#endif +#ifndef OVERRIDE_TABLE_64_accept4 +TRACE_SYSCALL_TABLE(accept4, accept4, 6297, 4) +#endif +#ifndef OVERRIDE_TABLE_64_getdents64 +TRACE_SYSCALL_TABLE(getdents64, getdents64, 6299, 3) +#endif +#ifndef OVERRIDE_TABLE_64_prlimit64 +TRACE_SYSCALL_TABLE(prlimit64, prlimit64, 6302, 4) +#endif + +#endif /* CREATE_SYSCALL_TABLE */ diff --git a/include/instrumentation/syscalls/headers/mips-64-syscalls_pointers_override.h b/include/instrumentation/syscalls/headers/mips-64-syscalls_pointers_override.h new file mode 100644 index 00000000..eb2b48cf --- /dev/null +++ b/include/instrumentation/syscalls/headers/mips-64-syscalls_pointers_override.h @@ -0,0 +1,10 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ + +#ifndef CREATE_SYSCALL_TABLE + +#else /* CREATE_SYSCALL_TABLE */ + +#define OVERRIDE_TABLE_64_sys_clone +TRACE_SYSCALL_TABLE(clone, clone, 5055, 0) + +#endif /* CREATE_SYSCALL_TABLE */ diff --git a/include/instrumentation/syscalls/headers/powerpc-32-syscalls_integers.h b/include/instrumentation/syscalls/headers/powerpc-32-syscalls_integers.h new file mode 100644 index 00000000..d84916af --- /dev/null +++ b/include/instrumentation/syscalls/headers/powerpc-32-syscalls_integers.h @@ -0,0 +1,1070 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ + +/* THIS FILE IS AUTO-GENERATED. DO NOT EDIT */ + +/* Generated from powerpc-32-syscalls 3.0.34 */ + +#ifndef CREATE_SYSCALL_TABLE + +#if !defined(_TRACE_SYSCALLS_INTEGERS_H) || defined(TRACE_HEADER_MULTI_READ) +#define _TRACE_SYSCALLS_INTEGERS_H + +#include +#include +#include "powerpc-32-syscalls_integers_override.h" +#include "syscalls_integers_override.h" + +#ifdef SC_ENTER +SC_LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(syscalls_noargs, + TP_FIELDS() +) +#ifndef OVERRIDE_32_restart_syscall +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, restart_syscall) +#endif +#ifndef OVERRIDE_32_getpid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getpid) +#endif +#ifndef OVERRIDE_32_getuid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getuid) +#endif +#ifndef OVERRIDE_32_pause +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, pause) +#endif +#ifndef OVERRIDE_32_sync +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, sync) +#endif +#ifndef OVERRIDE_32_getgid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getgid) +#endif +#ifndef OVERRIDE_32_geteuid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, geteuid) +#endif +#ifndef OVERRIDE_32_getegid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getegid) +#endif +#ifndef OVERRIDE_32_getppid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getppid) +#endif +#ifndef OVERRIDE_32_getpgrp +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getpgrp) +#endif +#ifndef OVERRIDE_32_setsid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, setsid) +#endif +#ifndef OVERRIDE_32_sgetmask +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, sgetmask) +#endif +#ifndef OVERRIDE_32_vhangup +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, vhangup) +#endif +#ifndef OVERRIDE_32_munlockall +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, munlockall) +#endif +#ifndef OVERRIDE_32_sched_yield +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, sched_yield) +#endif +#ifndef OVERRIDE_32_gettid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, gettid) +#endif +#ifndef OVERRIDE_32_inotify_init +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, inotify_init) +#endif +#else /* #ifdef SC_ENTER */ +#ifndef OVERRIDE_32_restart_syscall +SC_LTTNG_TRACEPOINT_EVENT(restart_syscall, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_getpid +SC_LTTNG_TRACEPOINT_EVENT(getpid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_getuid +SC_LTTNG_TRACEPOINT_EVENT(getuid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_pause +SC_LTTNG_TRACEPOINT_EVENT(pause, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_sync +SC_LTTNG_TRACEPOINT_EVENT(sync, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_getgid +SC_LTTNG_TRACEPOINT_EVENT(getgid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_geteuid +SC_LTTNG_TRACEPOINT_EVENT(geteuid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_getegid +SC_LTTNG_TRACEPOINT_EVENT(getegid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_getppid +SC_LTTNG_TRACEPOINT_EVENT(getppid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_getpgrp +SC_LTTNG_TRACEPOINT_EVENT(getpgrp, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_setsid +SC_LTTNG_TRACEPOINT_EVENT(setsid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_sgetmask +SC_LTTNG_TRACEPOINT_EVENT(sgetmask, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_vhangup +SC_LTTNG_TRACEPOINT_EVENT(vhangup, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_munlockall +SC_LTTNG_TRACEPOINT_EVENT(munlockall, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_sched_yield +SC_LTTNG_TRACEPOINT_EVENT(sched_yield, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_gettid +SC_LTTNG_TRACEPOINT_EVENT(gettid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_inotify_init +SC_LTTNG_TRACEPOINT_EVENT(inotify_init, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#endif /* else #ifdef SC_ENTER */ +#ifndef OVERRIDE_32_exit +SC_LTTNG_TRACEPOINT_EVENT(exit, + TP_PROTO(sc_exit(long ret,) int error_code), + TP_ARGS(sc_exit(ret,) error_code), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, error_code, error_code))) +) +#endif +#ifndef OVERRIDE_32_close +SC_LTTNG_TRACEPOINT_EVENT(close, + TP_PROTO(sc_exit(long ret,) unsigned int fd), + TP_ARGS(sc_exit(ret,) fd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) +) +#endif +#ifndef OVERRIDE_32_setuid +SC_LTTNG_TRACEPOINT_EVENT(setuid, + TP_PROTO(sc_exit(long ret,) uid_t uid), + TP_ARGS(sc_exit(ret,) uid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, uid, uid))) +) +#endif +#ifndef OVERRIDE_32_alarm +SC_LTTNG_TRACEPOINT_EVENT(alarm, + TP_PROTO(sc_exit(long ret,) unsigned int seconds), + TP_ARGS(sc_exit(ret,) seconds), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, seconds, seconds))) +) +#endif +#ifndef OVERRIDE_32_nice +SC_LTTNG_TRACEPOINT_EVENT(nice, + TP_PROTO(sc_exit(long ret,) int increment), + TP_ARGS(sc_exit(ret,) increment), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, increment, increment))) +) +#endif +#ifndef OVERRIDE_32_dup +SC_LTTNG_TRACEPOINT_EVENT(dup, + TP_PROTO(sc_exit(long ret,) unsigned int fildes), + TP_ARGS(sc_exit(ret,) fildes), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fildes, fildes))) +) +#endif +#ifndef OVERRIDE_32_brk +SC_LTTNG_TRACEPOINT_EVENT(brk, + TP_PROTO(sc_exit(long ret,) unsigned long brk), + TP_ARGS(sc_exit(ret,) brk), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, brk, brk))) +) +#endif +#ifndef OVERRIDE_32_setgid +SC_LTTNG_TRACEPOINT_EVENT(setgid, + TP_PROTO(sc_exit(long ret,) gid_t gid), + TP_ARGS(sc_exit(ret,) gid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, gid, gid))) +) +#endif +#ifndef OVERRIDE_32_umask +SC_LTTNG_TRACEPOINT_EVENT(umask, + TP_PROTO(sc_exit(long ret,) int mask), + TP_ARGS(sc_exit(ret,) mask), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, mask, mask))) +) +#endif +#ifndef OVERRIDE_32_ssetmask +SC_LTTNG_TRACEPOINT_EVENT(ssetmask, + TP_PROTO(sc_exit(long ret,) int newmask), + TP_ARGS(sc_exit(ret,) newmask), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, newmask, newmask))) +) +#endif +#ifndef OVERRIDE_32_fsync +SC_LTTNG_TRACEPOINT_EVENT(fsync, + TP_PROTO(sc_exit(long ret,) unsigned int fd), + TP_ARGS(sc_exit(ret,) fd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) +) +#endif +#ifndef OVERRIDE_32_getpgid +SC_LTTNG_TRACEPOINT_EVENT(getpgid, + TP_PROTO(sc_exit(long ret,) pid_t pid), + TP_ARGS(sc_exit(ret,) pid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid))) +) +#endif +#ifndef OVERRIDE_32_fchdir +SC_LTTNG_TRACEPOINT_EVENT(fchdir, + TP_PROTO(sc_exit(long ret,) unsigned int fd), + TP_ARGS(sc_exit(ret,) fd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) +) +#endif +#ifndef OVERRIDE_32_personality +SC_LTTNG_TRACEPOINT_EVENT(personality, + TP_PROTO(sc_exit(long ret,) unsigned int personality), + TP_ARGS(sc_exit(ret,) personality), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, personality, personality))) +) +#endif +#ifndef OVERRIDE_32_setfsuid +SC_LTTNG_TRACEPOINT_EVENT(setfsuid, + TP_PROTO(sc_exit(long ret,) uid_t uid), + TP_ARGS(sc_exit(ret,) uid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, uid, uid))) +) +#endif +#ifndef OVERRIDE_32_setfsgid +SC_LTTNG_TRACEPOINT_EVENT(setfsgid, + TP_PROTO(sc_exit(long ret,) gid_t gid), + TP_ARGS(sc_exit(ret,) gid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, gid, gid))) +) +#endif +#ifndef OVERRIDE_32_getsid +SC_LTTNG_TRACEPOINT_EVENT(getsid, + TP_PROTO(sc_exit(long ret,) pid_t pid), + TP_ARGS(sc_exit(ret,) pid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid))) +) +#endif +#ifndef OVERRIDE_32_fdatasync +SC_LTTNG_TRACEPOINT_EVENT(fdatasync, + TP_PROTO(sc_exit(long ret,) unsigned int fd), + TP_ARGS(sc_exit(ret,) fd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) +) +#endif +#ifndef OVERRIDE_32_mlockall +SC_LTTNG_TRACEPOINT_EVENT(mlockall, + TP_PROTO(sc_exit(long ret,) int flags), + TP_ARGS(sc_exit(ret,) flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_sched_getscheduler +SC_LTTNG_TRACEPOINT_EVENT(sched_getscheduler, + TP_PROTO(sc_exit(long ret,) pid_t pid), + TP_ARGS(sc_exit(ret,) pid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid))) +) +#endif +#ifndef OVERRIDE_32_sched_get_priority_max +SC_LTTNG_TRACEPOINT_EVENT(sched_get_priority_max, + TP_PROTO(sc_exit(long ret,) int policy), + TP_ARGS(sc_exit(ret,) policy), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, policy, policy))) +) +#endif +#ifndef OVERRIDE_32_sched_get_priority_min +SC_LTTNG_TRACEPOINT_EVENT(sched_get_priority_min, + TP_PROTO(sc_exit(long ret,) int policy), + TP_ARGS(sc_exit(ret,) policy), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, policy, policy))) +) +#endif +#ifndef OVERRIDE_32_io_destroy +SC_LTTNG_TRACEPOINT_EVENT(io_destroy, + TP_PROTO(sc_exit(long ret,) aio_context_t ctx), + TP_ARGS(sc_exit(ret,) ctx), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx, ctx))) +) +#endif +#ifndef OVERRIDE_32_exit_group +SC_LTTNG_TRACEPOINT_EVENT(exit_group, + TP_PROTO(sc_exit(long ret,) int error_code), + TP_ARGS(sc_exit(ret,) error_code), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, error_code, error_code))) +) +#endif +#ifndef OVERRIDE_32_epoll_create +SC_LTTNG_TRACEPOINT_EVENT(epoll_create, + TP_PROTO(sc_exit(long ret,) int size), + TP_ARGS(sc_exit(ret,) size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, size, size))) +) +#endif +#ifndef OVERRIDE_32_timer_getoverrun +SC_LTTNG_TRACEPOINT_EVENT(timer_getoverrun, + TP_PROTO(sc_exit(long ret,) timer_t timer_id), + TP_ARGS(sc_exit(ret,) timer_id), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id))) +) +#endif +#ifndef OVERRIDE_32_timer_delete +SC_LTTNG_TRACEPOINT_EVENT(timer_delete, + TP_PROTO(sc_exit(long ret,) timer_t timer_id), + TP_ARGS(sc_exit(ret,) timer_id), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id))) +) +#endif +#ifndef OVERRIDE_32_unshare +SC_LTTNG_TRACEPOINT_EVENT(unshare, + TP_PROTO(sc_exit(long ret,) unsigned long unshare_flags), + TP_ARGS(sc_exit(ret,) unshare_flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, unshare_flags, unshare_flags))) +) +#endif +#ifndef OVERRIDE_32_eventfd +SC_LTTNG_TRACEPOINT_EVENT(eventfd, + TP_PROTO(sc_exit(long ret,) unsigned int count), + TP_ARGS(sc_exit(ret,) count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, count, count))) +) +#endif +#ifndef OVERRIDE_32_epoll_create1 +SC_LTTNG_TRACEPOINT_EVENT(epoll_create1, + TP_PROTO(sc_exit(long ret,) int flags), + TP_ARGS(sc_exit(ret,) flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_inotify_init1 +SC_LTTNG_TRACEPOINT_EVENT(inotify_init1, + TP_PROTO(sc_exit(long ret,) int flags), + TP_ARGS(sc_exit(ret,) flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_syncfs +SC_LTTNG_TRACEPOINT_EVENT(syncfs, + TP_PROTO(sc_exit(long ret,) int fd), + TP_ARGS(sc_exit(ret,) fd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd))) +) +#endif +#ifndef OVERRIDE_32_kill +SC_LTTNG_TRACEPOINT_EVENT(kill, + TP_PROTO(sc_exit(long ret,) pid_t pid, int sig), + TP_ARGS(sc_exit(ret,) pid, sig), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig))) +) +#endif +#ifndef OVERRIDE_32_signal +SC_LTTNG_TRACEPOINT_EVENT(signal, + TP_PROTO(sc_exit(long ret,) int sig, __sighandler_t handler), + TP_ARGS(sc_exit(ret,) sig, handler), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, sig, sig)) sc_inout(ctf_integer(__sighandler_t, handler, handler))) +) +#endif +#ifndef OVERRIDE_32_setpgid +SC_LTTNG_TRACEPOINT_EVENT(setpgid, + TP_PROTO(sc_exit(long ret,) pid_t pid, pid_t pgid), + TP_ARGS(sc_exit(ret,) pid, pgid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(pid_t, pgid, pgid))) +) +#endif +#ifndef OVERRIDE_32_dup2 +SC_LTTNG_TRACEPOINT_EVENT(dup2, + TP_PROTO(sc_exit(long ret,) unsigned int oldfd, unsigned int newfd), + TP_ARGS(sc_exit(ret,) oldfd, newfd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, oldfd, oldfd)) sc_in(ctf_integer(unsigned int, newfd, newfd))) +) +#endif +#ifndef OVERRIDE_32_setreuid +SC_LTTNG_TRACEPOINT_EVENT(setreuid, + TP_PROTO(sc_exit(long ret,) uid_t ruid, uid_t euid), + TP_ARGS(sc_exit(ret,) ruid, euid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, ruid, ruid)) sc_in(ctf_integer(uid_t, euid, euid))) +) +#endif +#ifndef OVERRIDE_32_setregid +SC_LTTNG_TRACEPOINT_EVENT(setregid, + TP_PROTO(sc_exit(long ret,) gid_t rgid, gid_t egid), + TP_ARGS(sc_exit(ret,) rgid, egid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, rgid, rgid)) sc_in(ctf_integer(gid_t, egid, egid))) +) +#endif +#ifndef OVERRIDE_32_munmap +SC_LTTNG_TRACEPOINT_EVENT(munmap, + TP_PROTO(sc_exit(long ret,) unsigned long addr, size_t len), + TP_ARGS(sc_exit(ret,) addr, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, addr, addr)) sc_in(ctf_integer(size_t, len, len))) +) +#endif +#ifndef OVERRIDE_32_ftruncate +SC_LTTNG_TRACEPOINT_EVENT(ftruncate, + TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned long length), + TP_ARGS(sc_exit(ret,) fd, length), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned long, length, length))) +) +#endif +#ifndef OVERRIDE_32_fchmod +SC_LTTNG_TRACEPOINT_EVENT(fchmod, + TP_PROTO(sc_exit(long ret,) unsigned int fd, mode_t mode), + TP_ARGS(sc_exit(ret,) fd, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(mode_t, mode, mode))) +) +#endif +#ifndef OVERRIDE_32_getpriority +SC_LTTNG_TRACEPOINT_EVENT(getpriority, + TP_PROTO(sc_exit(long ret,) int which, int who), + TP_ARGS(sc_exit(ret,) which, who), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who))) +) +#endif +#ifndef OVERRIDE_32_bdflush +SC_LTTNG_TRACEPOINT_EVENT(bdflush, + TP_PROTO(sc_exit(long ret,) int func, long data), + TP_ARGS(sc_exit(ret,) func, data), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, func, func)) sc_inout(ctf_integer(long, data, data))) +) +#endif +#ifndef OVERRIDE_32_flock +SC_LTTNG_TRACEPOINT_EVENT(flock, + TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd), + TP_ARGS(sc_exit(ret,) fd, cmd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned int, cmd, cmd))) +) +#endif +#ifndef OVERRIDE_32_mlock +SC_LTTNG_TRACEPOINT_EVENT(mlock, + TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len), + TP_ARGS(sc_exit(ret,) start, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len))) +) +#endif +#ifndef OVERRIDE_32_munlock +SC_LTTNG_TRACEPOINT_EVENT(munlock, + TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len), + TP_ARGS(sc_exit(ret,) start, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len))) +) +#endif +#ifndef OVERRIDE_32_tkill +SC_LTTNG_TRACEPOINT_EVENT(tkill, + TP_PROTO(sc_exit(long ret,) pid_t pid, int sig), + TP_ARGS(sc_exit(ret,) pid, sig), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig))) +) +#endif +#ifndef OVERRIDE_32_ioprio_get +SC_LTTNG_TRACEPOINT_EVENT(ioprio_get, + TP_PROTO(sc_exit(long ret,) int which, int who), + TP_ARGS(sc_exit(ret,) which, who), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who))) +) +#endif +#ifndef OVERRIDE_32_inotify_rm_watch +SC_LTTNG_TRACEPOINT_EVENT(inotify_rm_watch, + TP_PROTO(sc_exit(long ret,) int fd, __s32 wd), + TP_ARGS(sc_exit(ret,) fd, wd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(__s32, wd, wd))) +) +#endif +#ifndef OVERRIDE_32_timerfd_create +SC_LTTNG_TRACEPOINT_EVENT(timerfd_create, + TP_PROTO(sc_exit(long ret,) int clockid, int flags), + TP_ARGS(sc_exit(ret,) clockid, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, clockid, clockid)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_eventfd2 +SC_LTTNG_TRACEPOINT_EVENT(eventfd2, + TP_PROTO(sc_exit(long ret,) unsigned int count, int flags), + TP_ARGS(sc_exit(ret,) count, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, count, count)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_listen +SC_LTTNG_TRACEPOINT_EVENT(listen, + TP_PROTO(sc_exit(long ret,) int fd, int backlog), + TP_ARGS(sc_exit(ret,) fd, backlog), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, backlog, backlog))) +) +#endif +#ifndef OVERRIDE_32_shutdown +SC_LTTNG_TRACEPOINT_EVENT(shutdown, + TP_PROTO(sc_exit(long ret,) int fd, int how), + TP_ARGS(sc_exit(ret,) fd, how), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, how, how))) +) +#endif +#ifndef OVERRIDE_32_setns +SC_LTTNG_TRACEPOINT_EVENT(setns, + TP_PROTO(sc_exit(long ret,) int fd, int nstype), + TP_ARGS(sc_exit(ret,) fd, nstype), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, nstype, nstype))) +) +#endif +#ifndef OVERRIDE_32_lseek +SC_LTTNG_TRACEPOINT_EVENT(lseek, + TP_PROTO(sc_exit(long ret,) unsigned int fd, off_t offset, unsigned int origin), + TP_ARGS(sc_exit(ret,) fd, offset, origin), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(off_t, offset, offset)) sc_in(ctf_integer(unsigned int, origin, origin))) +) +#endif +#ifndef OVERRIDE_32_ioctl +SC_LTTNG_TRACEPOINT_EVENT(ioctl, + TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd, unsigned long arg), + TP_ARGS(sc_exit(ret,) fd, cmd, arg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_inout(ctf_integer(unsigned long, arg, arg))) +) +#endif +#ifndef OVERRIDE_32_fcntl +SC_LTTNG_TRACEPOINT_EVENT(fcntl, + TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd, unsigned long arg), + TP_ARGS(sc_exit(ret,) fd, cmd, arg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_inout(ctf_integer(unsigned long, arg, arg))) +) +#endif +#ifndef OVERRIDE_32_fchown +SC_LTTNG_TRACEPOINT_EVENT(fchown, + TP_PROTO(sc_exit(long ret,) unsigned int fd, uid_t user, gid_t group), + TP_ARGS(sc_exit(ret,) fd, user, group), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group))) +) +#endif +#ifndef OVERRIDE_32_setpriority +SC_LTTNG_TRACEPOINT_EVENT(setpriority, + TP_PROTO(sc_exit(long ret,) int which, int who, int niceval), + TP_ARGS(sc_exit(ret,) which, who, niceval), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who)) sc_in(ctf_integer(int, niceval, niceval))) +) +#endif +#ifndef OVERRIDE_32_mprotect +SC_LTTNG_TRACEPOINT_EVENT(mprotect, + TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len, unsigned long prot), + TP_ARGS(sc_exit(ret,) start, len, prot), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned long, prot, prot))) +) +#endif +#ifndef OVERRIDE_32_sysfs +SC_LTTNG_TRACEPOINT_EVENT(sysfs, + TP_PROTO(sc_exit(long ret,) int option, unsigned long arg1, unsigned long arg2), + TP_ARGS(sc_exit(ret,) option, arg1, arg2), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, option, option)) sc_in(ctf_integer(unsigned long, arg1, arg1)) sc_in(ctf_integer(unsigned long, arg2, arg2))) +) +#endif +#ifndef OVERRIDE_32_msync +SC_LTTNG_TRACEPOINT_EVENT(msync, + TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len, int flags), + TP_ARGS(sc_exit(ret,) start, len, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_setresuid +SC_LTTNG_TRACEPOINT_EVENT(setresuid, + TP_PROTO(sc_exit(long ret,) uid_t ruid, uid_t euid, uid_t suid), + TP_ARGS(sc_exit(ret,) ruid, euid, suid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, ruid, ruid)) sc_in(ctf_integer(uid_t, euid, euid)) sc_in(ctf_integer(uid_t, suid, suid))) +) +#endif +#ifndef OVERRIDE_32_setresgid +SC_LTTNG_TRACEPOINT_EVENT(setresgid, + TP_PROTO(sc_exit(long ret,) gid_t rgid, gid_t egid, gid_t sgid), + TP_ARGS(sc_exit(ret,) rgid, egid, sgid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, rgid, rgid)) sc_in(ctf_integer(gid_t, egid, egid)) sc_in(ctf_integer(gid_t, sgid, sgid))) +) +#endif +#ifndef OVERRIDE_32_fcntl64 +SC_LTTNG_TRACEPOINT_EVENT(fcntl64, + TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd, unsigned long arg), + TP_ARGS(sc_exit(ret,) fd, cmd, arg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, fd, fd)) sc_inout(ctf_integer(unsigned int, cmd, cmd)) sc_inout(ctf_integer(unsigned long, arg, arg))) +) +#endif +#ifndef OVERRIDE_32_madvise +SC_LTTNG_TRACEPOINT_EVENT(madvise, + TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len_in, int behavior), + TP_ARGS(sc_exit(ret,) start, len_in, behavior), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len_in, len_in)) sc_in(ctf_integer(int, behavior, behavior))) +) +#endif +#ifndef OVERRIDE_32_tgkill +SC_LTTNG_TRACEPOINT_EVENT(tgkill, + TP_PROTO(sc_exit(long ret,) pid_t tgid, pid_t pid, int sig), + TP_ARGS(sc_exit(ret,) tgid, pid, sig), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, tgid, tgid)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig))) +) +#endif +#ifndef OVERRIDE_32_ioprio_set +SC_LTTNG_TRACEPOINT_EVENT(ioprio_set, + TP_PROTO(sc_exit(long ret,) int which, int who, int ioprio), + TP_ARGS(sc_exit(ret,) which, who, ioprio), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who)) sc_in(ctf_integer(int, ioprio, ioprio))) +) +#endif +#ifndef OVERRIDE_32_dup3 +SC_LTTNG_TRACEPOINT_EVENT(dup3, + TP_PROTO(sc_exit(long ret,) unsigned int oldfd, unsigned int newfd, int flags), + TP_ARGS(sc_exit(ret,) oldfd, newfd, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, oldfd, oldfd)) sc_in(ctf_integer(unsigned int, newfd, newfd)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_socket +SC_LTTNG_TRACEPOINT_EVENT(socket, + TP_PROTO(sc_exit(long ret,) int family, int type, int protocol), + TP_ARGS(sc_exit(ret,) family, type, protocol), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, family, family)) sc_in(ctf_integer(int, type, type)) sc_in(ctf_integer(int, protocol, protocol))) +) +#endif +#ifndef OVERRIDE_32_ptrace +SC_LTTNG_TRACEPOINT_EVENT(ptrace, + TP_PROTO(sc_exit(long ret,) long request, long pid, unsigned long addr, unsigned long data), + TP_ARGS(sc_exit(ret,) request, pid, addr, data), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(long, request, request)) sc_in(ctf_integer(long, pid, pid)) sc_inout(ctf_integer(unsigned long, addr, addr)) sc_inout(ctf_integer(unsigned long, data, data))) +) +#endif +#ifndef OVERRIDE_32_tee +SC_LTTNG_TRACEPOINT_EVENT(tee, + TP_PROTO(sc_exit(long ret,) int fdin, int fdout, size_t len, unsigned int flags), + TP_ARGS(sc_exit(ret,) fdin, fdout, len, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fdin, fdin)) sc_in(ctf_integer(int, fdout, fdout)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_mremap +SC_LTTNG_TRACEPOINT_EVENT(mremap, + TP_PROTO(sc_exit(long ret,) unsigned long addr, unsigned long old_len, unsigned long new_len, unsigned long flags, unsigned long new_addr), + TP_ARGS(sc_exit(ret,) addr, old_len, new_len, flags, new_addr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, addr, addr)) sc_in(ctf_integer(unsigned long, old_len, old_len)) sc_in(ctf_integer(unsigned long, new_len, new_len)) sc_in(ctf_integer(unsigned long, flags, flags)) sc_in(ctf_integer(unsigned long, new_addr, new_addr))) +) +#endif +#ifndef OVERRIDE_32_prctl +SC_LTTNG_TRACEPOINT_EVENT(prctl, + TP_PROTO(sc_exit(long ret,) int option, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5), + TP_ARGS(sc_exit(ret,) option, arg2, arg3, arg4, arg5), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, option, option)) sc_inout(ctf_integer(unsigned long, arg2, arg2)) sc_in(ctf_integer(unsigned long, arg3, arg3)) sc_in(ctf_integer(unsigned long, arg4, arg4)) sc_in(ctf_integer(unsigned long, arg5, arg5))) +) +#endif +#ifndef OVERRIDE_32_remap_file_pages +SC_LTTNG_TRACEPOINT_EVENT(remap_file_pages, + TP_PROTO(sc_exit(long ret,) unsigned long start, unsigned long size, unsigned long prot, unsigned long pgoff, unsigned long flags), + TP_ARGS(sc_exit(ret,) start, size, prot, pgoff, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(unsigned long, size, size)) sc_in(ctf_integer(unsigned long, prot, prot)) sc_in(ctf_integer(unsigned long, pgoff, pgoff)) sc_in(ctf_integer(unsigned long, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_keyctl +SC_LTTNG_TRACEPOINT_EVENT(keyctl, + TP_PROTO(sc_exit(long ret,) int option, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5), + TP_ARGS(sc_exit(ret,) option, arg2, arg3, arg4, arg5), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, option, option)) sc_inout(ctf_integer(unsigned long, arg2, arg2)) sc_inout(ctf_integer(unsigned long, arg3, arg3)) sc_inout(ctf_integer(unsigned long, arg4, arg4)) sc_inout(ctf_integer(unsigned long, arg5, arg5))) +) +#endif + +#endif /* _TRACE_SYSCALLS_INTEGERS_H */ + +/* This part must be outside protection */ +#include + +#else /* CREATE_SYSCALL_TABLE */ + +#include "powerpc-32-syscalls_integers_override.h" +#include "syscalls_integers_override.h" + +#ifdef SC_ENTER +#ifndef OVERRIDE_TABLE_32_restart_syscall +TRACE_SYSCALL_TABLE(syscalls_noargs, restart_syscall, 0, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getpid +TRACE_SYSCALL_TABLE(syscalls_noargs, getpid, 20, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getuid +TRACE_SYSCALL_TABLE(syscalls_noargs, getuid, 24, 0) +#endif +#ifndef OVERRIDE_TABLE_32_pause +TRACE_SYSCALL_TABLE(syscalls_noargs, pause, 29, 0) +#endif +#ifndef OVERRIDE_TABLE_32_sync +TRACE_SYSCALL_TABLE(syscalls_noargs, sync, 36, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getgid +TRACE_SYSCALL_TABLE(syscalls_noargs, getgid, 47, 0) +#endif +#ifndef OVERRIDE_TABLE_32_geteuid +TRACE_SYSCALL_TABLE(syscalls_noargs, geteuid, 49, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getegid +TRACE_SYSCALL_TABLE(syscalls_noargs, getegid, 50, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getppid +TRACE_SYSCALL_TABLE(syscalls_noargs, getppid, 64, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getpgrp +TRACE_SYSCALL_TABLE(syscalls_noargs, getpgrp, 65, 0) +#endif +#ifndef OVERRIDE_TABLE_32_setsid +TRACE_SYSCALL_TABLE(syscalls_noargs, setsid, 66, 0) +#endif +#ifndef OVERRIDE_TABLE_32_sgetmask +TRACE_SYSCALL_TABLE(syscalls_noargs, sgetmask, 68, 0) +#endif +#ifndef OVERRIDE_TABLE_32_vhangup +TRACE_SYSCALL_TABLE(syscalls_noargs, vhangup, 111, 0) +#endif +#ifndef OVERRIDE_TABLE_32_munlockall +TRACE_SYSCALL_TABLE(syscalls_noargs, munlockall, 153, 0) +#endif +#ifndef OVERRIDE_TABLE_32_sched_yield +TRACE_SYSCALL_TABLE(syscalls_noargs, sched_yield, 158, 0) +#endif +#ifndef OVERRIDE_TABLE_32_gettid +TRACE_SYSCALL_TABLE(syscalls_noargs, gettid, 207, 0) +#endif +#ifndef OVERRIDE_TABLE_32_inotify_init +TRACE_SYSCALL_TABLE(syscalls_noargs, inotify_init, 275, 0) +#endif +#else /* #ifdef SC_ENTER */ +#ifndef OVERRIDE_TABLE_32_restart_syscall +TRACE_SYSCALL_TABLE(restart_syscall, restart_syscall, 0, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getpid +TRACE_SYSCALL_TABLE(getpid, getpid, 20, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getuid +TRACE_SYSCALL_TABLE(getuid, getuid, 24, 0) +#endif +#ifndef OVERRIDE_TABLE_32_pause +TRACE_SYSCALL_TABLE(pause, pause, 29, 0) +#endif +#ifndef OVERRIDE_TABLE_32_sync +TRACE_SYSCALL_TABLE(sync, sync, 36, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getgid +TRACE_SYSCALL_TABLE(getgid, getgid, 47, 0) +#endif +#ifndef OVERRIDE_TABLE_32_geteuid +TRACE_SYSCALL_TABLE(geteuid, geteuid, 49, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getegid +TRACE_SYSCALL_TABLE(getegid, getegid, 50, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getppid +TRACE_SYSCALL_TABLE(getppid, getppid, 64, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getpgrp +TRACE_SYSCALL_TABLE(getpgrp, getpgrp, 65, 0) +#endif +#ifndef OVERRIDE_TABLE_32_setsid +TRACE_SYSCALL_TABLE(setsid, setsid, 66, 0) +#endif +#ifndef OVERRIDE_TABLE_32_sgetmask +TRACE_SYSCALL_TABLE(sgetmask, sgetmask, 68, 0) +#endif +#ifndef OVERRIDE_TABLE_32_vhangup +TRACE_SYSCALL_TABLE(vhangup, vhangup, 111, 0) +#endif +#ifndef OVERRIDE_TABLE_32_munlockall +TRACE_SYSCALL_TABLE(munlockall, munlockall, 153, 0) +#endif +#ifndef OVERRIDE_TABLE_32_sched_yield +TRACE_SYSCALL_TABLE(sched_yield, sched_yield, 158, 0) +#endif +#ifndef OVERRIDE_TABLE_32_gettid +TRACE_SYSCALL_TABLE(gettid, gettid, 207, 0) +#endif +#ifndef OVERRIDE_TABLE_32_inotify_init +TRACE_SYSCALL_TABLE(inotify_init, inotify_init, 275, 0) +#endif +#endif /* else #ifdef SC_ENTER */ +#ifndef OVERRIDE_TABLE_32_exit +TRACE_SYSCALL_TABLE(exit, exit, 1, 1) +#endif +#ifndef OVERRIDE_TABLE_32_close +TRACE_SYSCALL_TABLE(close, close, 6, 1) +#endif +#ifndef OVERRIDE_TABLE_32_lseek +TRACE_SYSCALL_TABLE(lseek, lseek, 19, 3) +#endif +#ifndef OVERRIDE_TABLE_32_setuid +TRACE_SYSCALL_TABLE(setuid, setuid, 23, 1) +#endif +#ifndef OVERRIDE_TABLE_32_ptrace +TRACE_SYSCALL_TABLE(ptrace, ptrace, 26, 4) +#endif +#ifndef OVERRIDE_TABLE_32_alarm +TRACE_SYSCALL_TABLE(alarm, alarm, 27, 1) +#endif +#ifndef OVERRIDE_TABLE_32_nice +TRACE_SYSCALL_TABLE(nice, nice, 34, 1) +#endif +#ifndef OVERRIDE_TABLE_32_kill +TRACE_SYSCALL_TABLE(kill, kill, 37, 2) +#endif +#ifndef OVERRIDE_TABLE_32_dup +TRACE_SYSCALL_TABLE(dup, dup, 41, 1) +#endif +#ifndef OVERRIDE_TABLE_32_brk +TRACE_SYSCALL_TABLE(brk, brk, 45, 1) +#endif +#ifndef OVERRIDE_TABLE_32_setgid +TRACE_SYSCALL_TABLE(setgid, setgid, 46, 1) +#endif +#ifndef OVERRIDE_TABLE_32_signal +TRACE_SYSCALL_TABLE(signal, signal, 48, 2) +#endif +#ifndef OVERRIDE_TABLE_32_ioctl +TRACE_SYSCALL_TABLE(ioctl, ioctl, 54, 3) +#endif +#ifndef OVERRIDE_TABLE_32_fcntl +TRACE_SYSCALL_TABLE(fcntl, fcntl, 55, 3) +#endif +#ifndef OVERRIDE_TABLE_32_setpgid +TRACE_SYSCALL_TABLE(setpgid, setpgid, 57, 2) +#endif +#ifndef OVERRIDE_TABLE_32_umask +TRACE_SYSCALL_TABLE(umask, umask, 60, 1) +#endif +#ifndef OVERRIDE_TABLE_32_dup2 +TRACE_SYSCALL_TABLE(dup2, dup2, 63, 2) +#endif +#ifndef OVERRIDE_TABLE_32_ssetmask +TRACE_SYSCALL_TABLE(ssetmask, ssetmask, 69, 1) +#endif +#ifndef OVERRIDE_TABLE_32_setreuid +TRACE_SYSCALL_TABLE(setreuid, setreuid, 70, 2) +#endif +#ifndef OVERRIDE_TABLE_32_setregid +TRACE_SYSCALL_TABLE(setregid, setregid, 71, 2) +#endif +#ifndef OVERRIDE_TABLE_32_munmap +TRACE_SYSCALL_TABLE(munmap, munmap, 91, 2) +#endif +#ifndef OVERRIDE_TABLE_32_ftruncate +TRACE_SYSCALL_TABLE(ftruncate, ftruncate, 93, 2) +#endif +#ifndef OVERRIDE_TABLE_32_fchmod +TRACE_SYSCALL_TABLE(fchmod, fchmod, 94, 2) +#endif +#ifndef OVERRIDE_TABLE_32_fchown +TRACE_SYSCALL_TABLE(fchown, fchown, 95, 3) +#endif +#ifndef OVERRIDE_TABLE_32_getpriority +TRACE_SYSCALL_TABLE(getpriority, getpriority, 96, 2) +#endif +#ifndef OVERRIDE_TABLE_32_setpriority +TRACE_SYSCALL_TABLE(setpriority, setpriority, 97, 3) +#endif +#ifndef OVERRIDE_TABLE_32_fsync +TRACE_SYSCALL_TABLE(fsync, fsync, 118, 1) +#endif +#ifndef OVERRIDE_TABLE_32_mprotect +TRACE_SYSCALL_TABLE(mprotect, mprotect, 125, 3) +#endif +#ifndef OVERRIDE_TABLE_32_getpgid +TRACE_SYSCALL_TABLE(getpgid, getpgid, 132, 1) +#endif +#ifndef OVERRIDE_TABLE_32_fchdir +TRACE_SYSCALL_TABLE(fchdir, fchdir, 133, 1) +#endif +#ifndef OVERRIDE_TABLE_32_bdflush +TRACE_SYSCALL_TABLE(bdflush, bdflush, 134, 2) +#endif +#ifndef OVERRIDE_TABLE_32_sysfs +TRACE_SYSCALL_TABLE(sysfs, sysfs, 135, 3) +#endif +#ifndef OVERRIDE_TABLE_32_personality +TRACE_SYSCALL_TABLE(personality, personality, 136, 1) +#endif +#ifndef OVERRIDE_TABLE_32_setfsuid +TRACE_SYSCALL_TABLE(setfsuid, setfsuid, 138, 1) +#endif +#ifndef OVERRIDE_TABLE_32_setfsgid +TRACE_SYSCALL_TABLE(setfsgid, setfsgid, 139, 1) +#endif +#ifndef OVERRIDE_TABLE_32_flock +TRACE_SYSCALL_TABLE(flock, flock, 143, 2) +#endif +#ifndef OVERRIDE_TABLE_32_msync +TRACE_SYSCALL_TABLE(msync, msync, 144, 3) +#endif +#ifndef OVERRIDE_TABLE_32_getsid +TRACE_SYSCALL_TABLE(getsid, getsid, 147, 1) +#endif +#ifndef OVERRIDE_TABLE_32_fdatasync +TRACE_SYSCALL_TABLE(fdatasync, fdatasync, 148, 1) +#endif +#ifndef OVERRIDE_TABLE_32_mlock +TRACE_SYSCALL_TABLE(mlock, mlock, 150, 2) +#endif +#ifndef OVERRIDE_TABLE_32_munlock +TRACE_SYSCALL_TABLE(munlock, munlock, 151, 2) +#endif +#ifndef OVERRIDE_TABLE_32_mlockall +TRACE_SYSCALL_TABLE(mlockall, mlockall, 152, 1) +#endif +#ifndef OVERRIDE_TABLE_32_sched_getscheduler +TRACE_SYSCALL_TABLE(sched_getscheduler, sched_getscheduler, 157, 1) +#endif +#ifndef OVERRIDE_TABLE_32_sched_get_priority_max +TRACE_SYSCALL_TABLE(sched_get_priority_max, sched_get_priority_max, 159, 1) +#endif +#ifndef OVERRIDE_TABLE_32_sched_get_priority_min +TRACE_SYSCALL_TABLE(sched_get_priority_min, sched_get_priority_min, 160, 1) +#endif +#ifndef OVERRIDE_TABLE_32_mremap +TRACE_SYSCALL_TABLE(mremap, mremap, 163, 5) +#endif +#ifndef OVERRIDE_TABLE_32_setresuid +TRACE_SYSCALL_TABLE(setresuid, setresuid, 164, 3) +#endif +#ifndef OVERRIDE_TABLE_32_setresgid +TRACE_SYSCALL_TABLE(setresgid, setresgid, 169, 3) +#endif +#ifndef OVERRIDE_TABLE_32_prctl +TRACE_SYSCALL_TABLE(prctl, prctl, 171, 5) +#endif +#ifndef OVERRIDE_TABLE_32_fcntl64 +TRACE_SYSCALL_TABLE(fcntl64, fcntl64, 204, 3) +#endif +#ifndef OVERRIDE_TABLE_32_madvise +TRACE_SYSCALL_TABLE(madvise, madvise, 205, 3) +#endif +#ifndef OVERRIDE_TABLE_32_tkill +TRACE_SYSCALL_TABLE(tkill, tkill, 208, 2) +#endif +#ifndef OVERRIDE_TABLE_32_io_destroy +TRACE_SYSCALL_TABLE(io_destroy, io_destroy, 228, 1) +#endif +#ifndef OVERRIDE_TABLE_32_exit_group +TRACE_SYSCALL_TABLE(exit_group, exit_group, 234, 1) +#endif +#ifndef OVERRIDE_TABLE_32_epoll_create +TRACE_SYSCALL_TABLE(epoll_create, epoll_create, 236, 1) +#endif +#ifndef OVERRIDE_TABLE_32_remap_file_pages +TRACE_SYSCALL_TABLE(remap_file_pages, remap_file_pages, 239, 5) +#endif +#ifndef OVERRIDE_TABLE_32_timer_getoverrun +TRACE_SYSCALL_TABLE(timer_getoverrun, timer_getoverrun, 243, 1) +#endif +#ifndef OVERRIDE_TABLE_32_timer_delete +TRACE_SYSCALL_TABLE(timer_delete, timer_delete, 244, 1) +#endif +#ifndef OVERRIDE_TABLE_32_tgkill +TRACE_SYSCALL_TABLE(tgkill, tgkill, 250, 3) +#endif +#ifndef OVERRIDE_TABLE_32_keyctl +TRACE_SYSCALL_TABLE(keyctl, keyctl, 271, 5) +#endif +#ifndef OVERRIDE_TABLE_32_ioprio_set +TRACE_SYSCALL_TABLE(ioprio_set, ioprio_set, 273, 3) +#endif +#ifndef OVERRIDE_TABLE_32_ioprio_get +TRACE_SYSCALL_TABLE(ioprio_get, ioprio_get, 274, 2) +#endif +#ifndef OVERRIDE_TABLE_32_inotify_rm_watch +TRACE_SYSCALL_TABLE(inotify_rm_watch, inotify_rm_watch, 277, 2) +#endif +#ifndef OVERRIDE_TABLE_32_unshare +TRACE_SYSCALL_TABLE(unshare, unshare, 282, 1) +#endif +#ifndef OVERRIDE_TABLE_32_tee +TRACE_SYSCALL_TABLE(tee, tee, 284, 4) +#endif +#ifndef OVERRIDE_TABLE_32_timerfd_create +TRACE_SYSCALL_TABLE(timerfd_create, timerfd_create, 306, 2) +#endif +#ifndef OVERRIDE_TABLE_32_eventfd +TRACE_SYSCALL_TABLE(eventfd, eventfd, 307, 1) +#endif +#ifndef OVERRIDE_TABLE_32_eventfd2 +TRACE_SYSCALL_TABLE(eventfd2, eventfd2, 314, 2) +#endif +#ifndef OVERRIDE_TABLE_32_epoll_create1 +TRACE_SYSCALL_TABLE(epoll_create1, epoll_create1, 315, 1) +#endif +#ifndef OVERRIDE_TABLE_32_dup3 +TRACE_SYSCALL_TABLE(dup3, dup3, 316, 3) +#endif +#ifndef OVERRIDE_TABLE_32_inotify_init1 +TRACE_SYSCALL_TABLE(inotify_init1, inotify_init1, 318, 1) +#endif +#ifndef OVERRIDE_TABLE_32_socket +TRACE_SYSCALL_TABLE(socket, socket, 326, 3) +#endif +#ifndef OVERRIDE_TABLE_32_listen +TRACE_SYSCALL_TABLE(listen, listen, 329, 2) +#endif +#ifndef OVERRIDE_TABLE_32_shutdown +TRACE_SYSCALL_TABLE(shutdown, shutdown, 338, 2) +#endif +#ifndef OVERRIDE_TABLE_32_syncfs +TRACE_SYSCALL_TABLE(syncfs, syncfs, 348, 1) +#endif +#ifndef OVERRIDE_TABLE_32_setns +TRACE_SYSCALL_TABLE(setns, setns, 350, 2) +#endif + +#endif /* CREATE_SYSCALL_TABLE */ diff --git a/include/instrumentation/syscalls/headers/powerpc-32-syscalls_integers_override.h b/include/instrumentation/syscalls/headers/powerpc-32-syscalls_integers_override.h new file mode 100644 index 00000000..529a4927 --- /dev/null +++ b/include/instrumentation/syscalls/headers/powerpc-32-syscalls_integers_override.h @@ -0,0 +1,74 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ + +#ifndef CREATE_SYSCALL_TABLE + +#define OVERRIDE_32_mmap2 +SC_LTTNG_TRACEPOINT_EVENT(mmap2, + TP_PROTO(sc_exit(unsigned long ret,) + unsigned long addr, unsigned long len, + unsigned long prot, unsigned long flags, + unsigned long fd, unsigned long pgoff), + TP_ARGS(sc_exit(ret,) addr, len, prot, flags, fd, pgoff), + TP_FIELDS(sc_exit(ctf_integer_hex(unsigned long, ret, ret)) + sc_in(ctf_integer_hex(unsigned long, addr, addr)) + sc_in(ctf_integer(size_t, len, len)) + sc_in(ctf_integer(int, prot, prot)) + sc_in(ctf_integer(int, flags, flags)) + sc_in(ctf_integer(int, fd, fd)) + sc_in(ctf_integer(off_t, pgoff, pgoff)) + ) +) + +#if (__BYTE_ORDER == __LITTLE_ENDIAN) + +#define OVERRIDE_32_sync_file_range2 +SC_LTTNG_TRACEPOINT_EVENT(sync_file_range2, + TP_PROTO(sc_exit(long ret,) int fd, + unsigned int flags, + int32_t offset_low, int32_t offset_high, + int32_t nbytes_low, int32_t nbytes_high), + TP_ARGS(sc_exit(ret,) fd, flags, offset_low, offset_high, + nbytes_low, nbytes_high), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) + sc_in(ctf_integer(int, fd, fd)) + sc_in(ctf_integer(unsigned int, flags, flags)) + sc_in(ctf_integer(loff_t, offset, + ((loff_t) offset_high << 32) | offset_low)) + sc_in(ctf_integer(loff_t, nbytes, + ((loff_t) nbytes_high << 32) | nbytes_low)) + ) +) + +#else /* __BIG_ENDIAN */ + +#define OVERRIDE_32_sync_file_range2 +SC_LTTNG_TRACEPOINT_EVENT(sync_file_range2, + TP_PROTO(sc_exit(long ret,) int fd, + unsigned int flags, + int32_t offset_high, int32_t offset_low, + int32_t nbytes_high, int32_t nbytes_low), + TP_ARGS(sc_exit(ret,) fd, flags, offset_high, offset_low, + nbytes_high, nbytes_low), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) + sc_in(ctf_integer(int, fd, fd)) + sc_in(ctf_integer(unsigned int, flags, flags)) + sc_in(ctf_integer(loff_t, offset, + ((loff_t) offset_high << 32) | offset_low)) + sc_in(ctf_integer(loff_t, nbytes, + ((loff_t) nbytes_high << 32) | nbytes_low)) + ) +) + +#endif + +#else /* CREATE_SYSCALL_TABLE */ + +#define OVERRIDE_TABLE_32_mmap +TRACE_SYSCALL_TABLE(mmap, mmap, 90, 6) +#define OVERRIDE_TABLE_32_mmap2 +TRACE_SYSCALL_TABLE(mmap2, mmap2, 192, 6) +#define OVERRIDE_TABLE_32_sync_file_range2 +TRACE_SYSCALL_TABLE(sync_file_range2, sync_file_range2, 308, 6) + +#endif /* CREATE_SYSCALL_TABLE */ + diff --git a/include/instrumentation/syscalls/headers/powerpc-32-syscalls_pointers.h b/include/instrumentation/syscalls/headers/powerpc-32-syscalls_pointers.h new file mode 100644 index 00000000..2fcf12cd --- /dev/null +++ b/include/instrumentation/syscalls/headers/powerpc-32-syscalls_pointers.h @@ -0,0 +1,1939 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ + +/* THIS FILE IS AUTO-GENERATED. DO NOT EDIT */ + +/* Generated from powerpc-32-syscalls 3.0.34 */ + +#ifndef CREATE_SYSCALL_TABLE + +#if !defined(_TRACE_SYSCALLS_POINTERS_H) || defined(TRACE_HEADER_MULTI_READ) +#define _TRACE_SYSCALLS_POINTERS_H + +#include +#include +#include "powerpc-32-syscalls_pointers_override.h" +#include "syscalls_pointers_override.h" + +#ifndef OVERRIDE_32_unlink +SC_LTTNG_TRACEPOINT_EVENT(unlink, + TP_PROTO(sc_exit(long ret,) const char * pathname), + TP_ARGS(sc_exit(ret,) pathname), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname))) +) +#endif +#ifndef OVERRIDE_32_chdir +SC_LTTNG_TRACEPOINT_EVENT(chdir, + TP_PROTO(sc_exit(long ret,) const char * filename), + TP_ARGS(sc_exit(ret,) filename), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename))) +) +#endif +#ifndef OVERRIDE_32_time +SC_LTTNG_TRACEPOINT_EVENT(time, + TP_PROTO(sc_exit(long ret,) time_t * tloc), + TP_ARGS(sc_exit(ret,) tloc), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(time_t *, tloc, tloc))) +) +#endif +#ifndef OVERRIDE_32_oldumount +SC_LTTNG_TRACEPOINT_EVENT(oldumount, + TP_PROTO(sc_exit(long ret,) char * name), + TP_ARGS(sc_exit(ret,) name), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(name, name))) +) +#endif +#ifndef OVERRIDE_32_stime +SC_LTTNG_TRACEPOINT_EVENT(stime, + TP_PROTO(sc_exit(long ret,) time_t * tptr), + TP_ARGS(sc_exit(ret,) tptr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(time_t *, tptr, tptr))) +) +#endif +#ifndef OVERRIDE_32_rmdir +SC_LTTNG_TRACEPOINT_EVENT(rmdir, + TP_PROTO(sc_exit(long ret,) const char * pathname), + TP_ARGS(sc_exit(ret,) pathname), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname))) +) +#endif +#ifndef OVERRIDE_32_pipe +SC_LTTNG_TRACEPOINT_EVENT(pipe, + TP_PROTO(sc_exit(long ret,) int * fildes), + TP_ARGS(sc_exit(ret,) fildes), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(int *, fildes, fildes))) +) +#endif +#ifndef OVERRIDE_32_times +SC_LTTNG_TRACEPOINT_EVENT(times, + TP_PROTO(sc_exit(long ret,) struct tms * tbuf), + TP_ARGS(sc_exit(ret,) tbuf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct tms *, tbuf, tbuf))) +) +#endif +#ifndef OVERRIDE_32_acct +SC_LTTNG_TRACEPOINT_EVENT(acct, + TP_PROTO(sc_exit(long ret,) const char * name), + TP_ARGS(sc_exit(ret,) name), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name))) +) +#endif +#ifndef OVERRIDE_32_olduname +SC_LTTNG_TRACEPOINT_EVENT(olduname, + TP_PROTO(sc_exit(long ret,) struct oldold_utsname * name), + TP_ARGS(sc_exit(ret,) name), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct oldold_utsname *, name, name))) +) +#endif +#ifndef OVERRIDE_32_chroot +SC_LTTNG_TRACEPOINT_EVENT(chroot, + TP_PROTO(sc_exit(long ret,) const char * filename), + TP_ARGS(sc_exit(ret,) filename), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename))) +) +#endif +#ifndef OVERRIDE_32_sigpending +SC_LTTNG_TRACEPOINT_EVENT(sigpending, + TP_PROTO(sc_exit(long ret,) old_sigset_t * set), + TP_ARGS(sc_exit(ret,) set), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(old_sigset_t *, set, set))) +) +#endif +#ifndef OVERRIDE_32_uselib +SC_LTTNG_TRACEPOINT_EVENT(uselib, + TP_PROTO(sc_exit(long ret,) const char * library), + TP_ARGS(sc_exit(ret,) library), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(const char *, library, library))) +) +#endif +#ifndef OVERRIDE_32_uname +SC_LTTNG_TRACEPOINT_EVENT(uname, + TP_PROTO(sc_exit(long ret,) struct old_utsname * name), + TP_ARGS(sc_exit(ret,) name), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct old_utsname *, name, name))) +) +#endif +#ifndef OVERRIDE_32_swapoff +SC_LTTNG_TRACEPOINT_EVENT(swapoff, + TP_PROTO(sc_exit(long ret,) const char * specialfile), + TP_ARGS(sc_exit(ret,) specialfile), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(specialfile, specialfile))) +) +#endif +#ifndef OVERRIDE_32_sysinfo +SC_LTTNG_TRACEPOINT_EVENT(sysinfo, + TP_PROTO(sc_exit(long ret,) struct sysinfo * info), + TP_ARGS(sc_exit(ret,) info), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct sysinfo *, info, info))) +) +#endif +#ifndef OVERRIDE_32_newuname +SC_LTTNG_TRACEPOINT_EVENT(newuname, + TP_PROTO(sc_exit(long ret,) struct new_utsname * name), + TP_ARGS(sc_exit(ret,) name), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct new_utsname *, name, name))) +) +#endif +#ifndef OVERRIDE_32_adjtimex +SC_LTTNG_TRACEPOINT_EVENT(adjtimex, + TP_PROTO(sc_exit(long ret,) struct timex * txc_p), + TP_ARGS(sc_exit(ret,) txc_p), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct timex *, txc_p, txc_p))) +) +#endif +#ifndef OVERRIDE_32_sysctl +SC_LTTNG_TRACEPOINT_EVENT(sysctl, + TP_PROTO(sc_exit(long ret,) struct __sysctl_args * args), + TP_ARGS(sc_exit(ret,) args), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct __sysctl_args *, args, args))) +) +#endif +#ifndef OVERRIDE_32_set_tid_address +SC_LTTNG_TRACEPOINT_EVENT(set_tid_address, + TP_PROTO(sc_exit(long ret,) int * tidptr), + TP_ARGS(sc_exit(ret,) tidptr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int *, tidptr, tidptr))) +) +#endif +#ifndef OVERRIDE_32_mq_unlink +SC_LTTNG_TRACEPOINT_EVENT(mq_unlink, + TP_PROTO(sc_exit(long ret,) const char * u_name), + TP_ARGS(sc_exit(ret,) u_name), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(u_name, u_name))) +) +#endif +#ifndef OVERRIDE_32_creat +SC_LTTNG_TRACEPOINT_EVENT(creat, + TP_PROTO(sc_exit(long ret,) const char * pathname, int mode), + TP_ARGS(sc_exit(ret,) pathname, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(int, mode, mode))) +) +#endif +#ifndef OVERRIDE_32_link +SC_LTTNG_TRACEPOINT_EVENT(link, + TP_PROTO(sc_exit(long ret,) const char * oldname, const char * newname), + TP_ARGS(sc_exit(ret,) oldname, newname), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_user_string(newname, newname))) +) +#endif +#ifndef OVERRIDE_32_chmod +SC_LTTNG_TRACEPOINT_EVENT(chmod, + TP_PROTO(sc_exit(long ret,) const char * filename, mode_t mode), + TP_ARGS(sc_exit(ret,) filename, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(mode_t, mode, mode))) +) +#endif +#ifndef OVERRIDE_32_stat +SC_LTTNG_TRACEPOINT_EVENT(stat, + TP_PROTO(sc_exit(long ret,) const char * filename, struct __old_kernel_stat * statbuf), + TP_ARGS(sc_exit(ret,) filename, statbuf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(filename, filename)) sc_inout(ctf_integer(struct __old_kernel_stat *, statbuf, statbuf))) +) +#endif +#ifndef OVERRIDE_32_fstat +SC_LTTNG_TRACEPOINT_EVENT(fstat, + TP_PROTO(sc_exit(long ret,) unsigned int fd, struct __old_kernel_stat * statbuf), + TP_ARGS(sc_exit(ret,) fd, statbuf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, fd, fd)) sc_inout(ctf_integer(struct __old_kernel_stat *, statbuf, statbuf))) +) +#endif +#ifndef OVERRIDE_32_utime +SC_LTTNG_TRACEPOINT_EVENT(utime, + TP_PROTO(sc_exit(long ret,) char * filename, struct utimbuf * times), + TP_ARGS(sc_exit(ret,) filename, times), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(struct utimbuf *, times, times))) +) +#endif +#ifndef OVERRIDE_32_access +SC_LTTNG_TRACEPOINT_EVENT(access, + TP_PROTO(sc_exit(long ret,) const char * filename, int mode), + TP_ARGS(sc_exit(ret,) filename, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, mode, mode))) +) +#endif +#ifndef OVERRIDE_32_rename +SC_LTTNG_TRACEPOINT_EVENT(rename, + TP_PROTO(sc_exit(long ret,) const char * oldname, const char * newname), + TP_ARGS(sc_exit(ret,) oldname, newname), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_user_string(newname, newname))) +) +#endif +#ifndef OVERRIDE_32_mkdir +SC_LTTNG_TRACEPOINT_EVENT(mkdir, + TP_PROTO(sc_exit(long ret,) const char * pathname, int mode), + TP_ARGS(sc_exit(ret,) pathname, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(int, mode, mode))) +) +#endif +#ifndef OVERRIDE_32_umount +SC_LTTNG_TRACEPOINT_EVENT(umount, + TP_PROTO(sc_exit(long ret,) char * name, int flags), + TP_ARGS(sc_exit(ret,) name, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_ustat +SC_LTTNG_TRACEPOINT_EVENT(ustat, + TP_PROTO(sc_exit(long ret,) unsigned dev, struct ustat * ubuf), + TP_ARGS(sc_exit(ret,) dev, ubuf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned, dev, dev)) sc_out(ctf_integer(struct ustat *, ubuf, ubuf))) +) +#endif +#ifndef OVERRIDE_32_sethostname +SC_LTTNG_TRACEPOINT_EVENT(sethostname, + TP_PROTO(sc_exit(long ret,) char * name, int len), + TP_ARGS(sc_exit(ret,) name, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(int, len, len))) +) +#endif +#ifndef OVERRIDE_32_setrlimit +SC_LTTNG_TRACEPOINT_EVENT(setrlimit, + TP_PROTO(sc_exit(long ret,) unsigned int resource, struct rlimit * rlim), + TP_ARGS(sc_exit(ret,) resource, rlim), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, resource, resource)) sc_in(ctf_integer(struct rlimit *, rlim, rlim))) +) +#endif +#ifndef OVERRIDE_32_old_getrlimit +SC_LTTNG_TRACEPOINT_EVENT(old_getrlimit, + TP_PROTO(sc_exit(long ret,) unsigned int resource, struct rlimit * rlim), + TP_ARGS(sc_exit(ret,) resource, rlim), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, resource, resource)) sc_inout(ctf_integer(struct rlimit *, rlim, rlim))) +) +#endif +#ifndef OVERRIDE_32_getrusage +SC_LTTNG_TRACEPOINT_EVENT(getrusage, + TP_PROTO(sc_exit(long ret,) int who, struct rusage * ru), + TP_ARGS(sc_exit(ret,) who, ru), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, who, who)) sc_out(ctf_integer(struct rusage *, ru, ru))) +) +#endif +#ifndef OVERRIDE_32_gettimeofday +SC_LTTNG_TRACEPOINT_EVENT(gettimeofday, + TP_PROTO(sc_exit(long ret,) struct timeval * tv, struct timezone * tz), + TP_ARGS(sc_exit(ret,) tv, tz), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct timeval *, tv, tv)) sc_out(ctf_integer(struct timezone *, tz, tz))) +) +#endif +#ifndef OVERRIDE_32_settimeofday +SC_LTTNG_TRACEPOINT_EVENT(settimeofday, + TP_PROTO(sc_exit(long ret,) struct timeval * tv, struct timezone * tz), + TP_ARGS(sc_exit(ret,) tv, tz), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct timeval *, tv, tv)) sc_in(ctf_integer(struct timezone *, tz, tz))) +) +#endif +#ifndef OVERRIDE_32_getgroups +SC_LTTNG_TRACEPOINT_EVENT(getgroups, + TP_PROTO(sc_exit(long ret,) int gidsetsize, gid_t * grouplist), + TP_ARGS(sc_exit(ret,) gidsetsize, grouplist), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, gidsetsize, gidsetsize)) sc_out(ctf_integer(gid_t *, grouplist, grouplist))) +) +#endif +#ifndef OVERRIDE_32_setgroups +SC_LTTNG_TRACEPOINT_EVENT(setgroups, + TP_PROTO(sc_exit(long ret,) int gidsetsize, gid_t * grouplist), + TP_ARGS(sc_exit(ret,) gidsetsize, grouplist), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, gidsetsize, gidsetsize)) sc_in(ctf_integer(gid_t *, grouplist, grouplist))) +) +#endif +#ifndef OVERRIDE_32_symlink +SC_LTTNG_TRACEPOINT_EVENT(symlink, + TP_PROTO(sc_exit(long ret,) const char * oldname, const char * newname), + TP_ARGS(sc_exit(ret,) oldname, newname), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_user_string(newname, newname))) +) +#endif +#ifndef OVERRIDE_32_lstat +SC_LTTNG_TRACEPOINT_EVENT(lstat, + TP_PROTO(sc_exit(long ret,) const char * filename, struct __old_kernel_stat * statbuf), + TP_ARGS(sc_exit(ret,) filename, statbuf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(filename, filename)) sc_inout(ctf_integer(struct __old_kernel_stat *, statbuf, statbuf))) +) +#endif +#ifndef OVERRIDE_32_swapon +SC_LTTNG_TRACEPOINT_EVENT(swapon, + TP_PROTO(sc_exit(long ret,) const char * specialfile, int swap_flags), + TP_ARGS(sc_exit(ret,) specialfile, swap_flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(specialfile, specialfile)) sc_in(ctf_integer(int, swap_flags, swap_flags))) +) +#endif +#ifndef OVERRIDE_32_truncate +SC_LTTNG_TRACEPOINT_EVENT(truncate, + TP_PROTO(sc_exit(long ret,) const char * path, long length), + TP_ARGS(sc_exit(ret,) path, length), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(path, path)) sc_in(ctf_integer(long, length, length))) +) +#endif +#ifndef OVERRIDE_32_statfs +SC_LTTNG_TRACEPOINT_EVENT(statfs, + TP_PROTO(sc_exit(long ret,) const char * pathname, struct statfs * buf), + TP_ARGS(sc_exit(ret,) pathname, buf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(struct statfs *, buf, buf))) +) +#endif +#ifndef OVERRIDE_32_fstatfs +SC_LTTNG_TRACEPOINT_EVENT(fstatfs, + TP_PROTO(sc_exit(long ret,) unsigned int fd, struct statfs * buf), + TP_ARGS(sc_exit(ret,) fd, buf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct statfs *, buf, buf))) +) +#endif +#ifndef OVERRIDE_32_socketcall +SC_LTTNG_TRACEPOINT_EVENT(socketcall, + TP_PROTO(sc_exit(long ret,) int call, unsigned long * args), + TP_ARGS(sc_exit(ret,) call, args), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, call, call)) sc_inout(ctf_integer(unsigned long *, args, args))) +) +#endif +#ifndef OVERRIDE_32_getitimer +SC_LTTNG_TRACEPOINT_EVENT(getitimer, + TP_PROTO(sc_exit(long ret,) int which, struct itimerval * value), + TP_ARGS(sc_exit(ret,) which, value), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_out(ctf_integer(struct itimerval *, value, value))) +) +#endif +#ifndef OVERRIDE_32_newstat +SC_LTTNG_TRACEPOINT_EVENT(newstat, + TP_PROTO(sc_exit(long ret,) const char * filename, struct stat * statbuf), + TP_ARGS(sc_exit(ret,) filename, statbuf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_out(ctf_integer(struct stat *, statbuf, statbuf))) +) +#endif +#ifndef OVERRIDE_32_newlstat +SC_LTTNG_TRACEPOINT_EVENT(newlstat, + TP_PROTO(sc_exit(long ret,) const char * filename, struct stat * statbuf), + TP_ARGS(sc_exit(ret,) filename, statbuf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_out(ctf_integer(struct stat *, statbuf, statbuf))) +) +#endif +#ifndef OVERRIDE_32_newfstat +SC_LTTNG_TRACEPOINT_EVENT(newfstat, + TP_PROTO(sc_exit(long ret,) unsigned int fd, struct stat * statbuf), + TP_ARGS(sc_exit(ret,) fd, statbuf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct stat *, statbuf, statbuf))) +) +#endif +#ifndef OVERRIDE_32_setdomainname +SC_LTTNG_TRACEPOINT_EVENT(setdomainname, + TP_PROTO(sc_exit(long ret,) char * name, int len), + TP_ARGS(sc_exit(ret,) name, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(int, len, len))) +) +#endif +#ifndef OVERRIDE_32_delete_module +SC_LTTNG_TRACEPOINT_EVENT(delete_module, + TP_PROTO(sc_exit(long ret,) const char * name_user, unsigned int flags), + TP_ARGS(sc_exit(ret,) name_user, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name_user, name_user)) sc_in(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_sched_setparam +SC_LTTNG_TRACEPOINT_EVENT(sched_setparam, + TP_PROTO(sc_exit(long ret,) pid_t pid, struct sched_param * param), + TP_ARGS(sc_exit(ret,) pid, param), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(struct sched_param *, param, param))) +) +#endif +#ifndef OVERRIDE_32_sched_getparam +SC_LTTNG_TRACEPOINT_EVENT(sched_getparam, + TP_PROTO(sc_exit(long ret,) pid_t pid, struct sched_param * param), + TP_ARGS(sc_exit(ret,) pid, param), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_out(ctf_integer(struct sched_param *, param, param))) +) +#endif +#ifndef OVERRIDE_32_sched_rr_get_interval +SC_LTTNG_TRACEPOINT_EVENT(sched_rr_get_interval, + TP_PROTO(sc_exit(long ret,) pid_t pid, struct timespec * interval), + TP_ARGS(sc_exit(ret,) pid, interval), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_out(ctf_integer(struct timespec *, interval, interval))) +) +#endif +#ifndef OVERRIDE_32_nanosleep +SC_LTTNG_TRACEPOINT_EVENT(nanosleep, + TP_PROTO(sc_exit(long ret,) struct timespec * rqtp, struct timespec * rmtp), + TP_ARGS(sc_exit(ret,) rqtp, rmtp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct timespec *, rqtp, rqtp)) sc_out(ctf_integer(struct timespec *, rmtp, rmtp))) +) +#endif +#ifndef OVERRIDE_32_rt_sigpending +SC_LTTNG_TRACEPOINT_EVENT(rt_sigpending, + TP_PROTO(sc_exit(long ret,) sigset_t * set, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) set, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(sigset_t *, set, set)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) +) +#endif +#ifndef OVERRIDE_32_rt_sigsuspend +SC_LTTNG_TRACEPOINT_EVENT(rt_sigsuspend, + TP_PROTO(sc_exit(long ret,) sigset_t * unewset, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) unewset, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(sigset_t *, unewset, unewset)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) +) +#endif +#ifndef OVERRIDE_32_getcwd +SC_LTTNG_TRACEPOINT_EVENT(getcwd, + TP_PROTO(sc_exit(long ret,) char * buf, unsigned long size), + TP_ARGS(sc_exit(ret,) buf, size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(unsigned long, size, size))) +) +#endif +#ifndef OVERRIDE_32_getrlimit +SC_LTTNG_TRACEPOINT_EVENT(getrlimit, + TP_PROTO(sc_exit(long ret,) unsigned int resource, struct rlimit * rlim), + TP_ARGS(sc_exit(ret,) resource, rlim), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, resource, resource)) sc_out(ctf_integer(struct rlimit *, rlim, rlim))) +) +#endif +#ifndef OVERRIDE_32_stat64 +SC_LTTNG_TRACEPOINT_EVENT(stat64, + TP_PROTO(sc_exit(long ret,) const char * filename, struct stat64 * statbuf), + TP_ARGS(sc_exit(ret,) filename, statbuf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(filename, filename)) sc_inout(ctf_integer(struct stat64 *, statbuf, statbuf))) +) +#endif +#ifndef OVERRIDE_32_lstat64 +SC_LTTNG_TRACEPOINT_EVENT(lstat64, + TP_PROTO(sc_exit(long ret,) const char * filename, struct stat64 * statbuf), + TP_ARGS(sc_exit(ret,) filename, statbuf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(filename, filename)) sc_inout(ctf_integer(struct stat64 *, statbuf, statbuf))) +) +#endif +#ifndef OVERRIDE_32_fstat64 +SC_LTTNG_TRACEPOINT_EVENT(fstat64, + TP_PROTO(sc_exit(long ret,) unsigned long fd, struct stat64 * statbuf), + TP_ARGS(sc_exit(ret,) fd, statbuf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned long, fd, fd)) sc_inout(ctf_integer(struct stat64 *, statbuf, statbuf))) +) +#endif +#ifndef OVERRIDE_32_pivot_root +SC_LTTNG_TRACEPOINT_EVENT(pivot_root, + TP_PROTO(sc_exit(long ret,) const char * new_root, const char * put_old), + TP_ARGS(sc_exit(ret,) new_root, put_old), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(new_root, new_root)) sc_in(ctf_user_string(put_old, put_old))) +) +#endif +#ifndef OVERRIDE_32_removexattr +SC_LTTNG_TRACEPOINT_EVENT(removexattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name), + TP_ARGS(sc_exit(ret,) pathname, name), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name))) +) +#endif +#ifndef OVERRIDE_32_lremovexattr +SC_LTTNG_TRACEPOINT_EVENT(lremovexattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name), + TP_ARGS(sc_exit(ret,) pathname, name), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name))) +) +#endif +#ifndef OVERRIDE_32_fremovexattr +SC_LTTNG_TRACEPOINT_EVENT(fremovexattr, + TP_PROTO(sc_exit(long ret,) int fd, const char * name), + TP_ARGS(sc_exit(ret,) fd, name), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(name, name))) +) +#endif +#ifndef OVERRIDE_32_io_setup +SC_LTTNG_TRACEPOINT_EVENT(io_setup, + TP_PROTO(sc_exit(long ret,) unsigned nr_events, aio_context_t * ctxp), + TP_ARGS(sc_exit(ret,) nr_events, ctxp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned, nr_events, nr_events)) sc_in(ctf_integer(aio_context_t *, ctxp, ctxp))) +) +#endif +#ifndef OVERRIDE_32_timer_gettime +SC_LTTNG_TRACEPOINT_EVENT(timer_gettime, + TP_PROTO(sc_exit(long ret,) timer_t timer_id, struct itimerspec * setting), + TP_ARGS(sc_exit(ret,) timer_id, setting), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id)) sc_out(ctf_integer(struct itimerspec *, setting, setting))) +) +#endif +#ifndef OVERRIDE_32_clock_settime +SC_LTTNG_TRACEPOINT_EVENT(clock_settime, + TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, const struct timespec * tp), + TP_ARGS(sc_exit(ret,) which_clock, tp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_in(ctf_integer(const struct timespec *, tp, tp))) +) +#endif +#ifndef OVERRIDE_32_clock_gettime +SC_LTTNG_TRACEPOINT_EVENT(clock_gettime, + TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct timespec * tp), + TP_ARGS(sc_exit(ret,) which_clock, tp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_out(ctf_integer(struct timespec *, tp, tp))) +) +#endif +#ifndef OVERRIDE_32_clock_getres +SC_LTTNG_TRACEPOINT_EVENT(clock_getres, + TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct timespec * tp), + TP_ARGS(sc_exit(ret,) which_clock, tp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_out(ctf_integer(struct timespec *, tp, tp))) +) +#endif +#ifndef OVERRIDE_32_utimes +SC_LTTNG_TRACEPOINT_EVENT(utimes, + TP_PROTO(sc_exit(long ret,) char * filename, struct timeval * utimes), + TP_ARGS(sc_exit(ret,) filename, utimes), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(struct timeval *, utimes, utimes))) +) +#endif +#ifndef OVERRIDE_32_mq_notify +SC_LTTNG_TRACEPOINT_EVENT(mq_notify, + TP_PROTO(sc_exit(long ret,) mqd_t mqdes, const struct sigevent * u_notification), + TP_ARGS(sc_exit(ret,) mqdes, u_notification), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(mqd_t, mqdes, mqdes)) sc_in(ctf_integer(const struct sigevent *, u_notification, u_notification))) +) +#endif +#ifndef OVERRIDE_32_set_robust_list +SC_LTTNG_TRACEPOINT_EVENT(set_robust_list, + TP_PROTO(sc_exit(long ret,) struct robust_list_head * head, size_t len), + TP_ARGS(sc_exit(ret,) head, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct robust_list_head *, head, head)) sc_in(ctf_integer(size_t, len, len))) +) +#endif +#ifndef OVERRIDE_32_timerfd_gettime +SC_LTTNG_TRACEPOINT_EVENT(timerfd_gettime, + TP_PROTO(sc_exit(long ret,) int ufd, struct itimerspec * otmr), + TP_ARGS(sc_exit(ret,) ufd, otmr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_out(ctf_integer(struct itimerspec *, otmr, otmr))) +) +#endif +#ifndef OVERRIDE_32_pipe2 +SC_LTTNG_TRACEPOINT_EVENT(pipe2, + TP_PROTO(sc_exit(long ret,) int * fildes, int flags), + TP_ARGS(sc_exit(ret,) fildes, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(int *, fildes, fildes)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_clock_adjtime +SC_LTTNG_TRACEPOINT_EVENT(clock_adjtime, + TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct timex * utx), + TP_ARGS(sc_exit(ret,) which_clock, utx), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_inout(ctf_integer(struct timex *, utx, utx))) +) +#endif +#ifndef OVERRIDE_32_read +SC_LTTNG_TRACEPOINT_EVENT(read, + TP_PROTO(sc_exit(long ret,) unsigned int fd, char * buf, size_t count), + TP_ARGS(sc_exit(ret,) fd, buf, count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(size_t, count, count))) +) +#endif +#ifndef OVERRIDE_32_write +SC_LTTNG_TRACEPOINT_EVENT(write, + TP_PROTO(sc_exit(long ret,) unsigned int fd, const char * buf, size_t count), + TP_ARGS(sc_exit(ret,) fd, buf, count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(const char *, buf, buf)) sc_in(ctf_integer(size_t, count, count))) +) +#endif +#ifndef OVERRIDE_32_open +SC_LTTNG_TRACEPOINT_EVENT(open, + TP_PROTO(sc_exit(long ret,) const char * filename, int flags, int mode), + TP_ARGS(sc_exit(ret,) filename, flags, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(int, mode, mode))) +) +#endif +#ifndef OVERRIDE_32_waitpid +SC_LTTNG_TRACEPOINT_EVENT(waitpid, + TP_PROTO(sc_exit(long ret,) pid_t pid, int * stat_addr, int options), + TP_ARGS(sc_exit(ret,) pid, stat_addr, options), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(pid_t, pid, pid)) sc_inout(ctf_integer(int *, stat_addr, stat_addr)) sc_inout(ctf_integer(int, options, options))) +) +#endif +#ifndef OVERRIDE_32_mknod +SC_LTTNG_TRACEPOINT_EVENT(mknod, + TP_PROTO(sc_exit(long ret,) const char * filename, int mode, unsigned dev), + TP_ARGS(sc_exit(ret,) filename, mode, dev), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, mode, mode)) sc_in(ctf_integer(unsigned, dev, dev))) +) +#endif +#ifndef OVERRIDE_32_lchown +SC_LTTNG_TRACEPOINT_EVENT(lchown, + TP_PROTO(sc_exit(long ret,) const char * filename, uid_t user, gid_t group), + TP_ARGS(sc_exit(ret,) filename, user, group), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group))) +) +#endif +#ifndef OVERRIDE_32_readlink +SC_LTTNG_TRACEPOINT_EVENT(readlink, + TP_PROTO(sc_exit(long ret,) const char * path, char * buf, int bufsiz), + TP_ARGS(sc_exit(ret,) path, buf, bufsiz), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(path, path)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(int, bufsiz, bufsiz))) +) +#endif +#ifndef OVERRIDE_32_old_readdir +SC_LTTNG_TRACEPOINT_EVENT(old_readdir, + TP_PROTO(sc_exit(long ret,) unsigned int fd, struct old_linux_dirent * dirent, unsigned int count), + TP_ARGS(sc_exit(ret,) fd, dirent, count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, fd, fd)) sc_inout(ctf_integer(struct old_linux_dirent *, dirent, dirent)) sc_inout(ctf_integer(unsigned int, count, count))) +) +#endif +#ifndef OVERRIDE_32_syslog +SC_LTTNG_TRACEPOINT_EVENT(syslog, + TP_PROTO(sc_exit(long ret,) int type, char * buf, int len), + TP_ARGS(sc_exit(ret,) type, buf, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, type, type)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(int, len, len))) +) +#endif +#ifndef OVERRIDE_32_setitimer +SC_LTTNG_TRACEPOINT_EVENT(setitimer, + TP_PROTO(sc_exit(long ret,) int which, struct itimerval * value, struct itimerval * ovalue), + TP_ARGS(sc_exit(ret,) which, value, ovalue), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(struct itimerval *, value, value)) sc_out(ctf_integer(struct itimerval *, ovalue, ovalue))) +) +#endif +#ifndef OVERRIDE_32_sigprocmask +SC_LTTNG_TRACEPOINT_EVENT(sigprocmask, + TP_PROTO(sc_exit(long ret,) int how, old_sigset_t * nset, old_sigset_t * oset), + TP_ARGS(sc_exit(ret,) how, nset, oset), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, how, how)) sc_inout(ctf_integer(old_sigset_t *, nset, nset)) sc_inout(ctf_integer(old_sigset_t *, oset, oset))) +) +#endif +#ifndef OVERRIDE_32_init_module +SC_LTTNG_TRACEPOINT_EVENT(init_module, + TP_PROTO(sc_exit(long ret,) void * umod, unsigned long len, const char * uargs), + TP_ARGS(sc_exit(ret,) umod, len, uargs), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(void *, umod, umod)) sc_in(ctf_integer(unsigned long, len, len)) sc_in(ctf_integer(const char *, uargs, uargs))) +) +#endif +#ifndef OVERRIDE_32_getdents +SC_LTTNG_TRACEPOINT_EVENT(getdents, + TP_PROTO(sc_exit(long ret,) unsigned int fd, struct linux_dirent * dirent, unsigned int count), + TP_ARGS(sc_exit(ret,) fd, dirent, count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct linux_dirent *, dirent, dirent)) sc_in(ctf_integer(unsigned int, count, count))) +) +#endif +#ifndef OVERRIDE_32_readv +SC_LTTNG_TRACEPOINT_EVENT(readv, + TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen), + TP_ARGS(sc_exit(ret,) fd, vec, vlen), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_inout(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen))) +) +#endif +#ifndef OVERRIDE_32_writev +SC_LTTNG_TRACEPOINT_EVENT(writev, + TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen), + TP_ARGS(sc_exit(ret,) fd, vec, vlen), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_inout(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen))) +) +#endif +#ifndef OVERRIDE_32_sched_setscheduler +SC_LTTNG_TRACEPOINT_EVENT(sched_setscheduler, + TP_PROTO(sc_exit(long ret,) pid_t pid, int policy, struct sched_param * param), + TP_ARGS(sc_exit(ret,) pid, policy, param), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, policy, policy)) sc_in(ctf_integer(struct sched_param *, param, param))) +) +#endif +#ifndef OVERRIDE_32_getresuid +SC_LTTNG_TRACEPOINT_EVENT(getresuid, + TP_PROTO(sc_exit(long ret,) uid_t * ruid, uid_t * euid, uid_t * suid), + TP_ARGS(sc_exit(ret,) ruid, euid, suid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(uid_t *, ruid, ruid)) sc_out(ctf_integer(uid_t *, euid, euid)) sc_out(ctf_integer(uid_t *, suid, suid))) +) +#endif +#ifndef OVERRIDE_32_poll +SC_LTTNG_TRACEPOINT_EVENT(poll, + TP_PROTO(sc_exit(long ret,) struct pollfd * ufds, unsigned int nfds, long timeout_msecs), + TP_ARGS(sc_exit(ret,) ufds, nfds, timeout_msecs), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct pollfd *, ufds, ufds)) sc_in(ctf_integer(unsigned int, nfds, nfds)) sc_in(ctf_integer(long, timeout_msecs, timeout_msecs))) +) +#endif +#ifndef OVERRIDE_32_nfsservctl +SC_LTTNG_TRACEPOINT_EVENT(nfsservctl, + TP_PROTO(sc_exit(long ret,) int cmd, struct nfsctl_arg * arg, void * res), + TP_ARGS(sc_exit(ret,) cmd, arg, res), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, cmd, cmd)) sc_inout(ctf_integer(struct nfsctl_arg *, arg, arg)) sc_inout(ctf_integer(void *, res, res))) +) +#endif +#ifndef OVERRIDE_32_getresgid +SC_LTTNG_TRACEPOINT_EVENT(getresgid, + TP_PROTO(sc_exit(long ret,) gid_t * rgid, gid_t * egid, gid_t * sgid), + TP_ARGS(sc_exit(ret,) rgid, egid, sgid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(gid_t *, rgid, rgid)) sc_out(ctf_integer(gid_t *, egid, egid)) sc_out(ctf_integer(gid_t *, sgid, sgid))) +) +#endif +#ifndef OVERRIDE_32_rt_sigqueueinfo +SC_LTTNG_TRACEPOINT_EVENT(rt_sigqueueinfo, + TP_PROTO(sc_exit(long ret,) pid_t pid, int sig, siginfo_t * uinfo), + TP_ARGS(sc_exit(ret,) pid, sig, uinfo), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig)) sc_in(ctf_integer(siginfo_t *, uinfo, uinfo))) +) +#endif +#ifndef OVERRIDE_32_chown +SC_LTTNG_TRACEPOINT_EVENT(chown, + TP_PROTO(sc_exit(long ret,) const char * filename, uid_t user, gid_t group), + TP_ARGS(sc_exit(ret,) filename, user, group), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group))) +) +#endif +#ifndef OVERRIDE_32_getdents64 +SC_LTTNG_TRACEPOINT_EVENT(getdents64, + TP_PROTO(sc_exit(long ret,) unsigned int fd, struct linux_dirent64 * dirent, unsigned int count), + TP_ARGS(sc_exit(ret,) fd, dirent, count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct linux_dirent64 *, dirent, dirent)) sc_in(ctf_integer(unsigned int, count, count))) +) +#endif +#ifndef OVERRIDE_32_mincore +SC_LTTNG_TRACEPOINT_EVENT(mincore, + TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len, unsigned char * vec), + TP_ARGS(sc_exit(ret,) start, len, vec), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len)) sc_out(ctf_integer(unsigned char *, vec, vec))) +) +#endif +#ifndef OVERRIDE_32_listxattr +SC_LTTNG_TRACEPOINT_EVENT(listxattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, char * list, size_t size), + TP_ARGS(sc_exit(ret,) pathname, list, size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(char *, list, list)) sc_in(ctf_integer(size_t, size, size))) +) +#endif +#ifndef OVERRIDE_32_llistxattr +SC_LTTNG_TRACEPOINT_EVENT(llistxattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, char * list, size_t size), + TP_ARGS(sc_exit(ret,) pathname, list, size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(char *, list, list)) sc_in(ctf_integer(size_t, size, size))) +) +#endif +#ifndef OVERRIDE_32_flistxattr +SC_LTTNG_TRACEPOINT_EVENT(flistxattr, + TP_PROTO(sc_exit(long ret,) int fd, char * list, size_t size), + TP_ARGS(sc_exit(ret,) fd, list, size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(char *, list, list)) sc_in(ctf_integer(size_t, size, size))) +) +#endif +#ifndef OVERRIDE_32_sched_setaffinity +SC_LTTNG_TRACEPOINT_EVENT(sched_setaffinity, + TP_PROTO(sc_exit(long ret,) pid_t pid, unsigned int len, unsigned long * user_mask_ptr), + TP_ARGS(sc_exit(ret,) pid, len, user_mask_ptr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(unsigned int, len, len)) sc_in(ctf_integer(unsigned long *, user_mask_ptr, user_mask_ptr))) +) +#endif +#ifndef OVERRIDE_32_sched_getaffinity +SC_LTTNG_TRACEPOINT_EVENT(sched_getaffinity, + TP_PROTO(sc_exit(long ret,) pid_t pid, unsigned int len, unsigned long * user_mask_ptr), + TP_ARGS(sc_exit(ret,) pid, len, user_mask_ptr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(unsigned int, len, len)) sc_out(ctf_integer(unsigned long *, user_mask_ptr, user_mask_ptr))) +) +#endif +#ifndef OVERRIDE_32_io_submit +SC_LTTNG_TRACEPOINT_EVENT(io_submit, + TP_PROTO(sc_exit(long ret,) aio_context_t ctx_id, long nr, struct iocb * * iocbpp), + TP_ARGS(sc_exit(ret,) ctx_id, nr, iocbpp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx_id, ctx_id)) sc_in(ctf_integer(long, nr, nr)) sc_in(ctf_integer(struct iocb * *, iocbpp, iocbpp))) +) +#endif +#ifndef OVERRIDE_32_io_cancel +SC_LTTNG_TRACEPOINT_EVENT(io_cancel, + TP_PROTO(sc_exit(long ret,) aio_context_t ctx_id, struct iocb * iocb, struct io_event * result), + TP_ARGS(sc_exit(ret,) ctx_id, iocb, result), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx_id, ctx_id)) sc_in(ctf_integer(struct iocb *, iocb, iocb)) sc_out(ctf_integer(struct io_event *, result, result))) +) +#endif +#ifndef OVERRIDE_32_timer_create +SC_LTTNG_TRACEPOINT_EVENT(timer_create, + TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct sigevent * timer_event_spec, timer_t * created_timer_id), + TP_ARGS(sc_exit(ret,) which_clock, timer_event_spec, created_timer_id), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_in(ctf_integer(struct sigevent *, timer_event_spec, timer_event_spec)) sc_out(ctf_integer(timer_t *, created_timer_id, created_timer_id))) +) +#endif +#ifndef OVERRIDE_32_statfs64 +SC_LTTNG_TRACEPOINT_EVENT(statfs64, + TP_PROTO(sc_exit(long ret,) const char * pathname, size_t sz, struct statfs64 * buf), + TP_ARGS(sc_exit(ret,) pathname, sz, buf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(pathname, pathname)) sc_inout(ctf_integer(size_t, sz, sz)) sc_inout(ctf_integer(struct statfs64 *, buf, buf))) +) +#endif +#ifndef OVERRIDE_32_fstatfs64 +SC_LTTNG_TRACEPOINT_EVENT(fstatfs64, + TP_PROTO(sc_exit(long ret,) unsigned int fd, size_t sz, struct statfs64 * buf), + TP_ARGS(sc_exit(ret,) fd, sz, buf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, fd, fd)) sc_inout(ctf_integer(size_t, sz, sz)) sc_inout(ctf_integer(struct statfs64 *, buf, buf))) +) +#endif +#ifndef OVERRIDE_32_mq_getsetattr +SC_LTTNG_TRACEPOINT_EVENT(mq_getsetattr, + TP_PROTO(sc_exit(long ret,) mqd_t mqdes, const struct mq_attr * u_mqstat, struct mq_attr * u_omqstat), + TP_ARGS(sc_exit(ret,) mqdes, u_mqstat, u_omqstat), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(mqd_t, mqdes, mqdes)) sc_in(ctf_integer(const struct mq_attr *, u_mqstat, u_mqstat)) sc_out(ctf_integer(struct mq_attr *, u_omqstat, u_omqstat))) +) +#endif +#ifndef OVERRIDE_32_inotify_add_watch +SC_LTTNG_TRACEPOINT_EVENT(inotify_add_watch, + TP_PROTO(sc_exit(long ret,) int fd, const char * pathname, u32 mask), + TP_ARGS(sc_exit(ret,) fd, pathname, mask), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(u32, mask, mask))) +) +#endif +#ifndef OVERRIDE_32_mkdirat +SC_LTTNG_TRACEPOINT_EVENT(mkdirat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * pathname, int mode), + TP_ARGS(sc_exit(ret,) dfd, pathname, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(int, mode, mode))) +) +#endif +#ifndef OVERRIDE_32_futimesat +SC_LTTNG_TRACEPOINT_EVENT(futimesat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, struct timeval * utimes), + TP_ARGS(sc_exit(ret,) dfd, filename, utimes), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(struct timeval *, utimes, utimes))) +) +#endif +#ifndef OVERRIDE_32_unlinkat +SC_LTTNG_TRACEPOINT_EVENT(unlinkat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * pathname, int flag), + TP_ARGS(sc_exit(ret,) dfd, pathname, flag), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(int, flag, flag))) +) +#endif +#ifndef OVERRIDE_32_symlinkat +SC_LTTNG_TRACEPOINT_EVENT(symlinkat, + TP_PROTO(sc_exit(long ret,) const char * oldname, int newdfd, const char * newname), + TP_ARGS(sc_exit(ret,) oldname, newdfd, newname), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_integer(int, newdfd, newdfd)) sc_in(ctf_user_string(newname, newname))) +) +#endif +#ifndef OVERRIDE_32_fchmodat +SC_LTTNG_TRACEPOINT_EVENT(fchmodat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, mode_t mode), + TP_ARGS(sc_exit(ret,) dfd, filename, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(mode_t, mode, mode))) +) +#endif +#ifndef OVERRIDE_32_faccessat +SC_LTTNG_TRACEPOINT_EVENT(faccessat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, int mode), + TP_ARGS(sc_exit(ret,) dfd, filename, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, mode, mode))) +) +#endif +#ifndef OVERRIDE_32_get_robust_list +SC_LTTNG_TRACEPOINT_EVENT(get_robust_list, + TP_PROTO(sc_exit(long ret,) int pid, struct robust_list_head * * head_ptr, size_t * len_ptr), + TP_ARGS(sc_exit(ret,) pid, head_ptr, len_ptr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, pid, pid)) sc_out(ctf_integer(struct robust_list_head * *, head_ptr, head_ptr)) sc_out(ctf_integer(size_t *, len_ptr, len_ptr))) +) +#endif +#ifndef OVERRIDE_32_getcpu +SC_LTTNG_TRACEPOINT_EVENT(getcpu, + TP_PROTO(sc_exit(long ret,) unsigned * cpup, unsigned * nodep, struct getcpu_cache * unused), + TP_ARGS(sc_exit(ret,) cpup, nodep, unused), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(unsigned *, cpup, cpup)) sc_out(ctf_integer(unsigned *, nodep, nodep)) sc_inout(ctf_integer(struct getcpu_cache *, unused, unused))) +) +#endif +#ifndef OVERRIDE_32_signalfd +SC_LTTNG_TRACEPOINT_EVENT(signalfd, + TP_PROTO(sc_exit(long ret,) int ufd, sigset_t * user_mask, size_t sizemask), + TP_ARGS(sc_exit(ret,) ufd, user_mask, sizemask), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_in(ctf_integer(sigset_t *, user_mask, user_mask)) sc_in(ctf_integer(size_t, sizemask, sizemask))) +) +#endif +#ifndef OVERRIDE_32_bind +SC_LTTNG_TRACEPOINT_EVENT(bind, + TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * umyaddr, int addrlen), + TP_ARGS(sc_exit(ret,) fd, umyaddr, addrlen), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct sockaddr *, umyaddr, umyaddr)) sc_in(ctf_integer(int, addrlen, addrlen))) +) +#endif +#ifndef OVERRIDE_32_connect +SC_LTTNG_TRACEPOINT_EVENT(connect, + TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * uservaddr, int addrlen), + TP_ARGS(sc_exit(ret,) fd, uservaddr, addrlen), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct sockaddr *, uservaddr, uservaddr)) sc_in(ctf_integer(int, addrlen, addrlen))) +) +#endif +#ifndef OVERRIDE_32_accept +SC_LTTNG_TRACEPOINT_EVENT(accept, + TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * upeer_sockaddr, int * upeer_addrlen), + TP_ARGS(sc_exit(ret,) fd, upeer_sockaddr, upeer_addrlen), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct sockaddr *, upeer_sockaddr, upeer_sockaddr)) sc_inout(ctf_integer(int *, upeer_addrlen, upeer_addrlen))) +) +#endif +#ifndef OVERRIDE_32_getsockname +SC_LTTNG_TRACEPOINT_EVENT(getsockname, + TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * usockaddr, int * usockaddr_len), + TP_ARGS(sc_exit(ret,) fd, usockaddr, usockaddr_len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct sockaddr *, usockaddr, usockaddr)) sc_inout(ctf_integer(int *, usockaddr_len, usockaddr_len))) +) +#endif +#ifndef OVERRIDE_32_getpeername +SC_LTTNG_TRACEPOINT_EVENT(getpeername, + TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * usockaddr, int * usockaddr_len), + TP_ARGS(sc_exit(ret,) fd, usockaddr, usockaddr_len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct sockaddr *, usockaddr, usockaddr)) sc_inout(ctf_integer(int *, usockaddr_len, usockaddr_len))) +) +#endif +#ifndef OVERRIDE_32_sendmsg +SC_LTTNG_TRACEPOINT_EVENT(sendmsg, + TP_PROTO(sc_exit(long ret,) int fd, struct msghdr * msg, unsigned flags), + TP_ARGS(sc_exit(ret,) fd, msg, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct msghdr *, msg, msg)) sc_in(ctf_integer(unsigned, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_recvmsg +SC_LTTNG_TRACEPOINT_EVENT(recvmsg, + TP_PROTO(sc_exit(long ret,) int fd, struct msghdr * msg, unsigned int flags), + TP_ARGS(sc_exit(ret,) fd, msg, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_inout(ctf_integer(struct msghdr *, msg, msg)) sc_in(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_reboot +SC_LTTNG_TRACEPOINT_EVENT(reboot, + TP_PROTO(sc_exit(long ret,) int magic1, int magic2, unsigned int cmd, void * arg), + TP_ARGS(sc_exit(ret,) magic1, magic2, cmd, arg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, magic1, magic1)) sc_in(ctf_integer(int, magic2, magic2)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_in(ctf_integer(void *, arg, arg))) +) +#endif +#ifndef OVERRIDE_32_wait4 +SC_LTTNG_TRACEPOINT_EVENT(wait4, + TP_PROTO(sc_exit(long ret,) pid_t upid, int * stat_addr, int options, struct rusage * ru), + TP_ARGS(sc_exit(ret,) upid, stat_addr, options, ru), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, upid, upid)) sc_out(ctf_integer(int *, stat_addr, stat_addr)) sc_in(ctf_integer(int, options, options)) sc_out(ctf_integer(struct rusage *, ru, ru))) +) +#endif +#ifndef OVERRIDE_32_rt_sigaction +SC_LTTNG_TRACEPOINT_EVENT(rt_sigaction, + TP_PROTO(sc_exit(long ret,) int sig, const struct sigaction * act, struct sigaction * oact, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) sig, act, oact, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, sig, sig)) sc_in(ctf_integer(const struct sigaction *, act, act)) sc_out(ctf_integer(struct sigaction *, oact, oact)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) +) +#endif +#ifndef OVERRIDE_32_rt_sigprocmask +SC_LTTNG_TRACEPOINT_EVENT(rt_sigprocmask, + TP_PROTO(sc_exit(long ret,) int how, sigset_t * nset, sigset_t * oset, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) how, nset, oset, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, how, how)) sc_in(ctf_integer(sigset_t *, nset, nset)) sc_out(ctf_integer(sigset_t *, oset, oset)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) +) +#endif +#ifndef OVERRIDE_32_rt_sigtimedwait +SC_LTTNG_TRACEPOINT_EVENT(rt_sigtimedwait, + TP_PROTO(sc_exit(long ret,) const sigset_t * uthese, siginfo_t * uinfo, const struct timespec * uts, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) uthese, uinfo, uts, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(const sigset_t *, uthese, uthese)) sc_out(ctf_integer(siginfo_t *, uinfo, uinfo)) sc_in(ctf_integer(const struct timespec *, uts, uts)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) +) +#endif +#ifndef OVERRIDE_32_sendfile +SC_LTTNG_TRACEPOINT_EVENT(sendfile, + TP_PROTO(sc_exit(long ret,) int out_fd, int in_fd, off_t * offset, size_t count), + TP_ARGS(sc_exit(ret,) out_fd, in_fd, offset, count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, out_fd, out_fd)) sc_inout(ctf_integer(int, in_fd, in_fd)) sc_inout(ctf_integer(off_t *, offset, offset)) sc_inout(ctf_integer(size_t, count, count))) +) +#endif +#ifndef OVERRIDE_32_getxattr +SC_LTTNG_TRACEPOINT_EVENT(getxattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, void * value, size_t size), + TP_ARGS(sc_exit(ret,) pathname, name, value, size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_out(ctf_integer(void *, value, value)) sc_in(ctf_integer(size_t, size, size))) +) +#endif +#ifndef OVERRIDE_32_lgetxattr +SC_LTTNG_TRACEPOINT_EVENT(lgetxattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, void * value, size_t size), + TP_ARGS(sc_exit(ret,) pathname, name, value, size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_out(ctf_integer(void *, value, value)) sc_in(ctf_integer(size_t, size, size))) +) +#endif +#ifndef OVERRIDE_32_fgetxattr +SC_LTTNG_TRACEPOINT_EVENT(fgetxattr, + TP_PROTO(sc_exit(long ret,) int fd, const char * name, void * value, size_t size), + TP_ARGS(sc_exit(ret,) fd, name, value, size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(name, name)) sc_out(ctf_integer(void *, value, value)) sc_in(ctf_integer(size_t, size, size))) +) +#endif +#ifndef OVERRIDE_32_sendfile64 +SC_LTTNG_TRACEPOINT_EVENT(sendfile64, + TP_PROTO(sc_exit(long ret,) int out_fd, int in_fd, loff_t * offset, size_t count), + TP_ARGS(sc_exit(ret,) out_fd, in_fd, offset, count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, out_fd, out_fd)) sc_in(ctf_integer(int, in_fd, in_fd)) sc_inout(ctf_integer(loff_t *, offset, offset)) sc_in(ctf_integer(size_t, count, count))) +) +#endif +#ifndef OVERRIDE_32_epoll_ctl +SC_LTTNG_TRACEPOINT_EVENT(epoll_ctl, + TP_PROTO(sc_exit(long ret,) int epfd, int op, int fd, struct epoll_event * event), + TP_ARGS(sc_exit(ret,) epfd, op, fd, event), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, epfd, epfd)) sc_in(ctf_integer(int, op, op)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct epoll_event *, event, event))) +) +#endif +#ifndef OVERRIDE_32_epoll_wait +SC_LTTNG_TRACEPOINT_EVENT(epoll_wait, + TP_PROTO(sc_exit(long ret,) int epfd, struct epoll_event * events, int maxevents, int timeout), + TP_ARGS(sc_exit(ret,) epfd, events, maxevents, timeout), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, epfd, epfd)) sc_out(ctf_integer(struct epoll_event *, events, events)) sc_in(ctf_integer(int, maxevents, maxevents)) sc_in(ctf_integer(int, timeout, timeout))) +) +#endif +#ifndef OVERRIDE_32_timer_settime +SC_LTTNG_TRACEPOINT_EVENT(timer_settime, + TP_PROTO(sc_exit(long ret,) timer_t timer_id, int flags, const struct itimerspec * new_setting, struct itimerspec * old_setting), + TP_ARGS(sc_exit(ret,) timer_id, flags, new_setting, old_setting), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(const struct itimerspec *, new_setting, new_setting)) sc_out(ctf_integer(struct itimerspec *, old_setting, old_setting))) +) +#endif +#ifndef OVERRIDE_32_clock_nanosleep +SC_LTTNG_TRACEPOINT_EVENT(clock_nanosleep, + TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, int flags, const struct timespec * rqtp, struct timespec * rmtp), + TP_ARGS(sc_exit(ret,) which_clock, flags, rqtp, rmtp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(const struct timespec *, rqtp, rqtp)) sc_out(ctf_integer(struct timespec *, rmtp, rmtp))) +) +#endif +#ifndef OVERRIDE_32_mq_open +SC_LTTNG_TRACEPOINT_EVENT(mq_open, + TP_PROTO(sc_exit(long ret,) const char * u_name, int oflag, mode_t mode, struct mq_attr * u_attr), + TP_ARGS(sc_exit(ret,) u_name, oflag, mode, u_attr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(u_name, u_name)) sc_in(ctf_integer(int, oflag, oflag)) sc_in(ctf_integer(mode_t, mode, mode)) sc_in(ctf_integer(struct mq_attr *, u_attr, u_attr))) +) +#endif +#ifndef OVERRIDE_32_request_key +SC_LTTNG_TRACEPOINT_EVENT(request_key, + TP_PROTO(sc_exit(long ret,) const char * _type, const char * _description, const char * _callout_info, key_serial_t destringid), + TP_ARGS(sc_exit(ret,) _type, _description, _callout_info, destringid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(_type, _type)) sc_in(ctf_integer(const char *, _description, _description)) sc_in(ctf_integer(const char *, _callout_info, _callout_info)) sc_in(ctf_integer(key_serial_t, destringid, destringid))) +) +#endif +#ifndef OVERRIDE_32_vmsplice +SC_LTTNG_TRACEPOINT_EVENT(vmsplice, + TP_PROTO(sc_exit(long ret,) int fd, const struct iovec * iov, unsigned long nr_segs, unsigned int flags), + TP_ARGS(sc_exit(ret,) fd, iov, nr_segs, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(const struct iovec *, iov, iov)) sc_in(ctf_integer(unsigned long, nr_segs, nr_segs)) sc_in(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_openat +SC_LTTNG_TRACEPOINT_EVENT(openat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, int flags, int mode), + TP_ARGS(sc_exit(ret,) dfd, filename, flags, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(int, mode, mode))) +) +#endif +#ifndef OVERRIDE_32_mknodat +SC_LTTNG_TRACEPOINT_EVENT(mknodat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, int mode, unsigned dev), + TP_ARGS(sc_exit(ret,) dfd, filename, mode, dev), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, mode, mode)) sc_in(ctf_integer(unsigned, dev, dev))) +) +#endif +#ifndef OVERRIDE_32_fstatat64 +SC_LTTNG_TRACEPOINT_EVENT(fstatat64, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, struct stat64 * statbuf, int flag), + TP_ARGS(sc_exit(ret,) dfd, filename, statbuf, flag), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, dfd, dfd)) sc_inout(ctf_user_string(filename, filename)) sc_inout(ctf_integer(struct stat64 *, statbuf, statbuf)) sc_inout(ctf_integer(int, flag, flag))) +) +#endif +#ifndef OVERRIDE_32_renameat +SC_LTTNG_TRACEPOINT_EVENT(renameat, + TP_PROTO(sc_exit(long ret,) int olddfd, const char * oldname, int newdfd, const char * newname), + TP_ARGS(sc_exit(ret,) olddfd, oldname, newdfd, newname), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, olddfd, olddfd)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_integer(int, newdfd, newdfd)) sc_in(ctf_user_string(newname, newname))) +) +#endif +#ifndef OVERRIDE_32_readlinkat +SC_LTTNG_TRACEPOINT_EVENT(readlinkat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * pathname, char * buf, int bufsiz), + TP_ARGS(sc_exit(ret,) dfd, pathname, buf, bufsiz), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(int, bufsiz, bufsiz))) +) +#endif +#ifndef OVERRIDE_32_utimensat +SC_LTTNG_TRACEPOINT_EVENT(utimensat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, struct timespec * utimes, int flags), + TP_ARGS(sc_exit(ret,) dfd, filename, utimes, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(struct timespec *, utimes, utimes)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_timerfd_settime +SC_LTTNG_TRACEPOINT_EVENT(timerfd_settime, + TP_PROTO(sc_exit(long ret,) int ufd, int flags, const struct itimerspec * utmr, struct itimerspec * otmr), + TP_ARGS(sc_exit(ret,) ufd, flags, utmr, otmr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(const struct itimerspec *, utmr, utmr)) sc_out(ctf_integer(struct itimerspec *, otmr, otmr))) +) +#endif +#ifndef OVERRIDE_32_signalfd4 +SC_LTTNG_TRACEPOINT_EVENT(signalfd4, + TP_PROTO(sc_exit(long ret,) int ufd, sigset_t * user_mask, size_t sizemask, int flags), + TP_ARGS(sc_exit(ret,) ufd, user_mask, sizemask, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_in(ctf_integer(sigset_t *, user_mask, user_mask)) sc_in(ctf_integer(size_t, sizemask, sizemask)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_rt_tgsigqueueinfo +SC_LTTNG_TRACEPOINT_EVENT(rt_tgsigqueueinfo, + TP_PROTO(sc_exit(long ret,) pid_t tgid, pid_t pid, int sig, siginfo_t * uinfo), + TP_ARGS(sc_exit(ret,) tgid, pid, sig, uinfo), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, tgid, tgid)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig)) sc_in(ctf_integer(siginfo_t *, uinfo, uinfo))) +) +#endif +#ifndef OVERRIDE_32_prlimit64 +SC_LTTNG_TRACEPOINT_EVENT(prlimit64, + TP_PROTO(sc_exit(long ret,) pid_t pid, unsigned int resource, const struct rlimit64 * new_rlim, struct rlimit64 * old_rlim), + TP_ARGS(sc_exit(ret,) pid, resource, new_rlim, old_rlim), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(unsigned int, resource, resource)) sc_in(ctf_integer(const struct rlimit64 *, new_rlim, new_rlim)) sc_out(ctf_integer(struct rlimit64 *, old_rlim, old_rlim))) +) +#endif +#ifndef OVERRIDE_32_socketpair +SC_LTTNG_TRACEPOINT_EVENT(socketpair, + TP_PROTO(sc_exit(long ret,) int family, int type, int protocol, int * usockvec), + TP_ARGS(sc_exit(ret,) family, type, protocol, usockvec), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, family, family)) sc_in(ctf_integer(int, type, type)) sc_in(ctf_integer(int, protocol, protocol)) sc_out(ctf_integer(int *, usockvec, usockvec))) +) +#endif +#ifndef OVERRIDE_32_send +SC_LTTNG_TRACEPOINT_EVENT(send, + TP_PROTO(sc_exit(long ret,) int fd, void * buff, size_t len, unsigned flags), + TP_ARGS(sc_exit(ret,) fd, buff, len, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, fd, fd)) sc_inout(ctf_integer(void *, buff, buff)) sc_inout(ctf_integer(size_t, len, len)) sc_inout(ctf_integer(unsigned, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_accept4 +SC_LTTNG_TRACEPOINT_EVENT(accept4, + TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * upeer_sockaddr, int * upeer_addrlen, int flags), + TP_ARGS(sc_exit(ret,) fd, upeer_sockaddr, upeer_addrlen, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct sockaddr *, upeer_sockaddr, upeer_sockaddr)) sc_inout(ctf_integer(int *, upeer_addrlen, upeer_addrlen)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_sendmmsg +SC_LTTNG_TRACEPOINT_EVENT(sendmmsg, + TP_PROTO(sc_exit(long ret,) int fd, struct mmsghdr * mmsg, unsigned int vlen, unsigned int flags), + TP_ARGS(sc_exit(ret,) fd, mmsg, vlen, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct mmsghdr *, mmsg, mmsg)) sc_in(ctf_integer(unsigned int, vlen, vlen)) sc_in(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_mount +SC_LTTNG_TRACEPOINT_EVENT(mount, + TP_PROTO(sc_exit(long ret,) char * dev_name, char * dir_name, char * type, unsigned long flags, void * data), + TP_ARGS(sc_exit(ret,) dev_name, dir_name, type, flags, data), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(dev_name, dev_name)) sc_in(ctf_user_string(dir_name, dir_name)) sc_in(ctf_user_string(type, type)) sc_in(ctf_integer(unsigned long, flags, flags)) sc_in(ctf_integer(void *, data, data))) +) +#endif +#ifndef OVERRIDE_32_llseek +SC_LTTNG_TRACEPOINT_EVENT(llseek, + TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned long offset_high, unsigned long offset_low, loff_t * result, unsigned int origin), + TP_ARGS(sc_exit(ret,) fd, offset_high, offset_low, result, origin), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, fd, fd)) sc_inout(ctf_integer(unsigned long, offset_high, offset_high)) sc_inout(ctf_integer(unsigned long, offset_low, offset_low)) sc_inout(ctf_integer(loff_t *, result, result)) sc_inout(ctf_integer(unsigned int, origin, origin))) +) +#endif +#ifndef OVERRIDE_32_select +SC_LTTNG_TRACEPOINT_EVENT(select, + TP_PROTO(sc_exit(long ret,) int n, fd_set * inp, fd_set * outp, fd_set * exp, struct timeval * tvp), + TP_ARGS(sc_exit(ret,) n, inp, outp, exp, tvp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, n, n)) sc_inout(ctf_integer(fd_set *, inp, inp)) sc_inout(ctf_integer(fd_set *, outp, outp)) sc_inout(ctf_integer(fd_set *, exp, exp)) sc_inout(ctf_integer(struct timeval *, tvp, tvp))) +) +#endif +#ifndef OVERRIDE_32_pciconfig_read +SC_LTTNG_TRACEPOINT_EVENT(pciconfig_read, + TP_PROTO(sc_exit(long ret,) unsigned long bus, unsigned long dfn, unsigned long off, unsigned long len, void * buf), + TP_ARGS(sc_exit(ret,) bus, dfn, off, len, buf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned long, bus, bus)) sc_inout(ctf_integer(unsigned long, dfn, dfn)) sc_inout(ctf_integer(unsigned long, off, off)) sc_inout(ctf_integer(unsigned long, len, len)) sc_inout(ctf_integer(void *, buf, buf))) +) +#endif +#ifndef OVERRIDE_32_pciconfig_write +SC_LTTNG_TRACEPOINT_EVENT(pciconfig_write, + TP_PROTO(sc_exit(long ret,) unsigned long bus, unsigned long dfn, unsigned long off, unsigned long len, void * buf), + TP_ARGS(sc_exit(ret,) bus, dfn, off, len, buf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned long, bus, bus)) sc_inout(ctf_integer(unsigned long, dfn, dfn)) sc_inout(ctf_integer(unsigned long, off, off)) sc_inout(ctf_integer(unsigned long, len, len)) sc_inout(ctf_integer(void *, buf, buf))) +) +#endif +#ifndef OVERRIDE_32_setxattr +SC_LTTNG_TRACEPOINT_EVENT(setxattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, const void * value, size_t size, int flags), + TP_ARGS(sc_exit(ret,) pathname, name, value, size, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(const void *, value, value)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_lsetxattr +SC_LTTNG_TRACEPOINT_EVENT(lsetxattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, const void * value, size_t size, int flags), + TP_ARGS(sc_exit(ret,) pathname, name, value, size, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(const void *, value, value)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_fsetxattr +SC_LTTNG_TRACEPOINT_EVENT(fsetxattr, + TP_PROTO(sc_exit(long ret,) int fd, const char * name, const void * value, size_t size, int flags), + TP_ARGS(sc_exit(ret,) fd, name, value, size, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(const void *, value, value)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_io_getevents +SC_LTTNG_TRACEPOINT_EVENT(io_getevents, + TP_PROTO(sc_exit(long ret,) aio_context_t ctx_id, long min_nr, long nr, struct io_event * events, struct timespec * timeout), + TP_ARGS(sc_exit(ret,) ctx_id, min_nr, nr, events, timeout), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx_id, ctx_id)) sc_in(ctf_integer(long, min_nr, min_nr)) sc_in(ctf_integer(long, nr, nr)) sc_out(ctf_integer(struct io_event *, events, events)) sc_inout(ctf_integer(struct timespec *, timeout, timeout))) +) +#endif +#ifndef OVERRIDE_32_mq_timedsend +SC_LTTNG_TRACEPOINT_EVENT(mq_timedsend, + TP_PROTO(sc_exit(long ret,) mqd_t mqdes, const char * u_msg_ptr, size_t msg_len, unsigned int msg_prio, const struct timespec * u_abs_timeout), + TP_ARGS(sc_exit(ret,) mqdes, u_msg_ptr, msg_len, msg_prio, u_abs_timeout), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(mqd_t, mqdes, mqdes)) sc_in(ctf_integer(const char *, u_msg_ptr, u_msg_ptr)) sc_in(ctf_integer(size_t, msg_len, msg_len)) sc_in(ctf_integer(unsigned int, msg_prio, msg_prio)) sc_in(ctf_integer(const struct timespec *, u_abs_timeout, u_abs_timeout))) +) +#endif +#ifndef OVERRIDE_32_mq_timedreceive +SC_LTTNG_TRACEPOINT_EVENT(mq_timedreceive, + TP_PROTO(sc_exit(long ret,) mqd_t mqdes, char * u_msg_ptr, size_t msg_len, unsigned int * u_msg_prio, const struct timespec * u_abs_timeout), + TP_ARGS(sc_exit(ret,) mqdes, u_msg_ptr, msg_len, u_msg_prio, u_abs_timeout), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(mqd_t, mqdes, mqdes)) sc_out(ctf_integer(char *, u_msg_ptr, u_msg_ptr)) sc_in(ctf_integer(size_t, msg_len, msg_len)) sc_out(ctf_integer(unsigned int *, u_msg_prio, u_msg_prio)) sc_in(ctf_integer(const struct timespec *, u_abs_timeout, u_abs_timeout))) +) +#endif +#ifndef OVERRIDE_32_add_key +SC_LTTNG_TRACEPOINT_EVENT(add_key, + TP_PROTO(sc_exit(long ret,) const char * _type, const char * _description, const void * _payload, size_t plen, key_serial_t ringid), + TP_ARGS(sc_exit(ret,) _type, _description, _payload, plen, ringid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(_type, _type)) sc_in(ctf_integer(const char *, _description, _description)) sc_in(ctf_integer(const void *, _payload, _payload)) sc_in(ctf_integer(size_t, plen, plen)) sc_in(ctf_integer(key_serial_t, ringid, ringid))) +) +#endif +#ifndef OVERRIDE_32_waitid +SC_LTTNG_TRACEPOINT_EVENT(waitid, + TP_PROTO(sc_exit(long ret,) int which, pid_t upid, struct siginfo * infop, int options, struct rusage * ru), + TP_ARGS(sc_exit(ret,) which, upid, infop, options, ru), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(pid_t, upid, upid)) sc_out(ctf_integer(struct siginfo *, infop, infop)) sc_in(ctf_integer(int, options, options)) sc_out(ctf_integer(struct rusage *, ru, ru))) +) +#endif +#ifndef OVERRIDE_32_ppoll +SC_LTTNG_TRACEPOINT_EVENT(ppoll, + TP_PROTO(sc_exit(long ret,) struct pollfd * ufds, unsigned int nfds, struct timespec * tsp, const sigset_t * sigmask, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) ufds, nfds, tsp, sigmask, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct pollfd *, ufds, ufds)) sc_in(ctf_integer(unsigned int, nfds, nfds)) sc_in(ctf_integer(struct timespec *, tsp, tsp)) sc_in(ctf_integer(const sigset_t *, sigmask, sigmask)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) +) +#endif +#ifndef OVERRIDE_32_fchownat +SC_LTTNG_TRACEPOINT_EVENT(fchownat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, uid_t user, gid_t group, int flag), + TP_ARGS(sc_exit(ret,) dfd, filename, user, group, flag), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group)) sc_in(ctf_integer(int, flag, flag))) +) +#endif +#ifndef OVERRIDE_32_linkat +SC_LTTNG_TRACEPOINT_EVENT(linkat, + TP_PROTO(sc_exit(long ret,) int olddfd, const char * oldname, int newdfd, const char * newname, int flags), + TP_ARGS(sc_exit(ret,) olddfd, oldname, newdfd, newname, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, olddfd, olddfd)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_integer(int, newdfd, newdfd)) sc_in(ctf_user_string(newname, newname)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_perf_event_open +SC_LTTNG_TRACEPOINT_EVENT(perf_event_open, + TP_PROTO(sc_exit(long ret,) struct perf_event_attr * attr_uptr, pid_t pid, int cpu, int group_fd, unsigned long flags), + TP_ARGS(sc_exit(ret,) attr_uptr, pid, cpu, group_fd, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct perf_event_attr *, attr_uptr, attr_uptr)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, cpu, cpu)) sc_in(ctf_integer(int, group_fd, group_fd)) sc_in(ctf_integer(unsigned long, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_preadv +SC_LTTNG_TRACEPOINT_EVENT(preadv, + TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen, unsigned long pos_l, unsigned long pos_h), + TP_ARGS(sc_exit(ret,) fd, vec, vlen, pos_l, pos_h), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_out(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen)) sc_in(ctf_integer(unsigned long, pos_l, pos_l)) sc_in(ctf_integer(unsigned long, pos_h, pos_h))) +) +#endif +#ifndef OVERRIDE_32_pwritev +SC_LTTNG_TRACEPOINT_EVENT(pwritev, + TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen, unsigned long pos_l, unsigned long pos_h), + TP_ARGS(sc_exit(ret,) fd, vec, vlen, pos_l, pos_h), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_in(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen)) sc_in(ctf_integer(unsigned long, pos_l, pos_l)) sc_in(ctf_integer(unsigned long, pos_h, pos_h))) +) +#endif +#ifndef OVERRIDE_32_setsockopt +SC_LTTNG_TRACEPOINT_EVENT(setsockopt, + TP_PROTO(sc_exit(long ret,) int fd, int level, int optname, char * optval, int optlen), + TP_ARGS(sc_exit(ret,) fd, level, optname, optval, optlen), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, level, level)) sc_in(ctf_integer(int, optname, optname)) sc_in(ctf_integer(char *, optval, optval)) sc_in(ctf_integer(int, optlen, optlen))) +) +#endif +#ifndef OVERRIDE_32_getsockopt +SC_LTTNG_TRACEPOINT_EVENT(getsockopt, + TP_PROTO(sc_exit(long ret,) int fd, int level, int optname, char * optval, int * optlen), + TP_ARGS(sc_exit(ret,) fd, level, optname, optval, optlen), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, level, level)) sc_in(ctf_integer(int, optname, optname)) sc_out(ctf_integer(char *, optval, optval)) sc_inout(ctf_integer(int *, optlen, optlen))) +) +#endif +#ifndef OVERRIDE_32_recvmmsg +SC_LTTNG_TRACEPOINT_EVENT(recvmmsg, + TP_PROTO(sc_exit(long ret,) int fd, struct mmsghdr * mmsg, unsigned int vlen, unsigned int flags, struct timespec * timeout), + TP_ARGS(sc_exit(ret,) fd, mmsg, vlen, flags, timeout), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct mmsghdr *, mmsg, mmsg)) sc_in(ctf_integer(unsigned int, vlen, vlen)) sc_in(ctf_integer(unsigned int, flags, flags)) sc_inout(ctf_integer(struct timespec *, timeout, timeout))) +) +#endif +#ifndef OVERRIDE_32_ipc +SC_LTTNG_TRACEPOINT_EVENT(ipc, + TP_PROTO(sc_exit(long ret,) unsigned int call, int first, unsigned long second, unsigned long third, void * ptr, long fifth), + TP_ARGS(sc_exit(ret,) call, first, second, third, ptr, fifth), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, call, call)) sc_inout(ctf_integer(int, first, first)) sc_inout(ctf_integer(unsigned long, second, second)) sc_inout(ctf_integer(unsigned long, third, third)) sc_inout(ctf_integer(void *, ptr, ptr)) sc_inout(ctf_integer(long, fifth, fifth))) +) +#endif +#ifndef OVERRIDE_32_futex +SC_LTTNG_TRACEPOINT_EVENT(futex, + TP_PROTO(sc_exit(long ret,) u32 * uaddr, int op, u32 val, struct timespec * utime, u32 * uaddr2, u32 val3), + TP_ARGS(sc_exit(ret,) uaddr, op, val, utime, uaddr2, val3), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(u32 *, uaddr, uaddr)) sc_in(ctf_integer(int, op, op)) sc_in(ctf_integer(u32, val, val)) sc_in(ctf_integer(struct timespec *, utime, utime)) sc_inout(ctf_integer(u32 *, uaddr2, uaddr2)) sc_in(ctf_integer(u32, val3, val3))) +) +#endif +#ifndef OVERRIDE_32_pselect6 +SC_LTTNG_TRACEPOINT_EVENT(pselect6, + TP_PROTO(sc_exit(long ret,) int n, fd_set * inp, fd_set * outp, fd_set * exp, struct timespec * tsp, void * sig), + TP_ARGS(sc_exit(ret,) n, inp, outp, exp, tsp, sig), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, n, n)) sc_inout(ctf_integer(fd_set *, inp, inp)) sc_inout(ctf_integer(fd_set *, outp, outp)) sc_inout(ctf_integer(fd_set *, exp, exp)) sc_inout(ctf_integer(struct timespec *, tsp, tsp)) sc_in(ctf_integer(void *, sig, sig))) +) +#endif +#ifndef OVERRIDE_32_splice +SC_LTTNG_TRACEPOINT_EVENT(splice, + TP_PROTO(sc_exit(long ret,) int fd_in, loff_t * off_in, int fd_out, loff_t * off_out, size_t len, unsigned int flags), + TP_ARGS(sc_exit(ret,) fd_in, off_in, fd_out, off_out, len, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd_in, fd_in)) sc_in(ctf_integer(loff_t *, off_in, off_in)) sc_in(ctf_integer(int, fd_out, fd_out)) sc_in(ctf_integer(loff_t *, off_out, off_out)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_epoll_pwait +SC_LTTNG_TRACEPOINT_EVENT(epoll_pwait, + TP_PROTO(sc_exit(long ret,) int epfd, struct epoll_event * events, int maxevents, int timeout, const sigset_t * sigmask, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) epfd, events, maxevents, timeout, sigmask, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, epfd, epfd)) sc_out(ctf_integer(struct epoll_event *, events, events)) sc_in(ctf_integer(int, maxevents, maxevents)) sc_in(ctf_integer(int, timeout, timeout)) sc_in(ctf_integer(const sigset_t *, sigmask, sigmask)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) +) +#endif +#ifndef OVERRIDE_32_sendto +SC_LTTNG_TRACEPOINT_EVENT(sendto, + TP_PROTO(sc_exit(long ret,) int fd, void * buff, size_t len, unsigned flags, struct sockaddr * addr, int addr_len), + TP_ARGS(sc_exit(ret,) fd, buff, len, flags, addr, addr_len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(void *, buff, buff)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned, flags, flags)) sc_in(ctf_integer(struct sockaddr *, addr, addr)) sc_in(ctf_integer(int, addr_len, addr_len))) +) +#endif +#ifndef OVERRIDE_32_recvfrom +SC_LTTNG_TRACEPOINT_EVENT(recvfrom, + TP_PROTO(sc_exit(long ret,) int fd, void * ubuf, size_t size, unsigned flags, struct sockaddr * addr, int * addr_len), + TP_ARGS(sc_exit(ret,) fd, ubuf, size, flags, addr, addr_len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(void *, ubuf, ubuf)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(unsigned, flags, flags)) sc_out(ctf_integer(struct sockaddr *, addr, addr)) sc_inout(ctf_integer(int *, addr_len, addr_len))) +) +#endif + +#endif /* _TRACE_SYSCALLS_POINTERS_H */ + +/* This part must be outside protection */ +#include + +#else /* CREATE_SYSCALL_TABLE */ + +#include "powerpc-32-syscalls_pointers_override.h" +#include "syscalls_pointers_override.h" + +#ifndef OVERRIDE_TABLE_32_read +TRACE_SYSCALL_TABLE(read, read, 3, 3) +#endif +#ifndef OVERRIDE_TABLE_32_write +TRACE_SYSCALL_TABLE(write, write, 4, 3) +#endif +#ifndef OVERRIDE_TABLE_32_open +TRACE_SYSCALL_TABLE(open, open, 5, 3) +#endif +#ifndef OVERRIDE_TABLE_32_waitpid +TRACE_SYSCALL_TABLE(waitpid, waitpid, 7, 3) +#endif +#ifndef OVERRIDE_TABLE_32_creat +TRACE_SYSCALL_TABLE(creat, creat, 8, 2) +#endif +#ifndef OVERRIDE_TABLE_32_link +TRACE_SYSCALL_TABLE(link, link, 9, 2) +#endif +#ifndef OVERRIDE_TABLE_32_unlink +TRACE_SYSCALL_TABLE(unlink, unlink, 10, 1) +#endif +#ifndef OVERRIDE_TABLE_32_chdir +TRACE_SYSCALL_TABLE(chdir, chdir, 12, 1) +#endif +#ifndef OVERRIDE_TABLE_32_time +TRACE_SYSCALL_TABLE(time, time, 13, 1) +#endif +#ifndef OVERRIDE_TABLE_32_mknod +TRACE_SYSCALL_TABLE(mknod, mknod, 14, 3) +#endif +#ifndef OVERRIDE_TABLE_32_chmod +TRACE_SYSCALL_TABLE(chmod, chmod, 15, 2) +#endif +#ifndef OVERRIDE_TABLE_32_lchown +TRACE_SYSCALL_TABLE(lchown, lchown, 16, 3) +#endif +#ifndef OVERRIDE_TABLE_32_stat +TRACE_SYSCALL_TABLE(stat, stat, 18, 2) +#endif +#ifndef OVERRIDE_TABLE_32_mount +TRACE_SYSCALL_TABLE(mount, mount, 21, 5) +#endif +#ifndef OVERRIDE_TABLE_32_oldumount +TRACE_SYSCALL_TABLE(oldumount, oldumount, 22, 1) +#endif +#ifndef OVERRIDE_TABLE_32_stime +TRACE_SYSCALL_TABLE(stime, stime, 25, 1) +#endif +#ifndef OVERRIDE_TABLE_32_fstat +TRACE_SYSCALL_TABLE(fstat, fstat, 28, 2) +#endif +#ifndef OVERRIDE_TABLE_32_utime +TRACE_SYSCALL_TABLE(utime, utime, 30, 2) +#endif +#ifndef OVERRIDE_TABLE_32_access +TRACE_SYSCALL_TABLE(access, access, 33, 2) +#endif +#ifndef OVERRIDE_TABLE_32_rename +TRACE_SYSCALL_TABLE(rename, rename, 38, 2) +#endif +#ifndef OVERRIDE_TABLE_32_mkdir +TRACE_SYSCALL_TABLE(mkdir, mkdir, 39, 2) +#endif +#ifndef OVERRIDE_TABLE_32_rmdir +TRACE_SYSCALL_TABLE(rmdir, rmdir, 40, 1) +#endif +#ifndef OVERRIDE_TABLE_32_pipe +TRACE_SYSCALL_TABLE(pipe, pipe, 42, 1) +#endif +#ifndef OVERRIDE_TABLE_32_times +TRACE_SYSCALL_TABLE(times, times, 43, 1) +#endif +#ifndef OVERRIDE_TABLE_32_acct +TRACE_SYSCALL_TABLE(acct, acct, 51, 1) +#endif +#ifndef OVERRIDE_TABLE_32_umount +TRACE_SYSCALL_TABLE(umount, umount, 52, 2) +#endif +#ifndef OVERRIDE_TABLE_32_olduname +TRACE_SYSCALL_TABLE(olduname, olduname, 59, 1) +#endif +#ifndef OVERRIDE_TABLE_32_chroot +TRACE_SYSCALL_TABLE(chroot, chroot, 61, 1) +#endif +#ifndef OVERRIDE_TABLE_32_ustat +TRACE_SYSCALL_TABLE(ustat, ustat, 62, 2) +#endif +#ifndef OVERRIDE_TABLE_32_sigpending +TRACE_SYSCALL_TABLE(sigpending, sigpending, 73, 1) +#endif +#ifndef OVERRIDE_TABLE_32_sethostname +TRACE_SYSCALL_TABLE(sethostname, sethostname, 74, 2) +#endif +#ifndef OVERRIDE_TABLE_32_setrlimit +TRACE_SYSCALL_TABLE(setrlimit, setrlimit, 75, 2) +#endif +#ifndef OVERRIDE_TABLE_32_old_getrlimit +TRACE_SYSCALL_TABLE(old_getrlimit, old_getrlimit, 76, 2) +#endif +#ifndef OVERRIDE_TABLE_32_getrusage +TRACE_SYSCALL_TABLE(getrusage, getrusage, 77, 2) +#endif +#ifndef OVERRIDE_TABLE_32_gettimeofday +TRACE_SYSCALL_TABLE(gettimeofday, gettimeofday, 78, 2) +#endif +#ifndef OVERRIDE_TABLE_32_settimeofday +TRACE_SYSCALL_TABLE(settimeofday, settimeofday, 79, 2) +#endif +#ifndef OVERRIDE_TABLE_32_getgroups +TRACE_SYSCALL_TABLE(getgroups, getgroups, 80, 2) +#endif +#ifndef OVERRIDE_TABLE_32_setgroups +TRACE_SYSCALL_TABLE(setgroups, setgroups, 81, 2) +#endif +#ifndef OVERRIDE_TABLE_32_symlink +TRACE_SYSCALL_TABLE(symlink, symlink, 83, 2) +#endif +#ifndef OVERRIDE_TABLE_32_lstat +TRACE_SYSCALL_TABLE(lstat, lstat, 84, 2) +#endif +#ifndef OVERRIDE_TABLE_32_readlink +TRACE_SYSCALL_TABLE(readlink, readlink, 85, 3) +#endif +#ifndef OVERRIDE_TABLE_32_uselib +TRACE_SYSCALL_TABLE(uselib, uselib, 86, 1) +#endif +#ifndef OVERRIDE_TABLE_32_swapon +TRACE_SYSCALL_TABLE(swapon, swapon, 87, 2) +#endif +#ifndef OVERRIDE_TABLE_32_reboot +TRACE_SYSCALL_TABLE(reboot, reboot, 88, 4) +#endif +#ifndef OVERRIDE_TABLE_32_old_readdir +TRACE_SYSCALL_TABLE(old_readdir, old_readdir, 89, 3) +#endif +#ifndef OVERRIDE_TABLE_32_truncate +TRACE_SYSCALL_TABLE(truncate, truncate, 92, 2) +#endif +#ifndef OVERRIDE_TABLE_32_statfs +TRACE_SYSCALL_TABLE(statfs, statfs, 99, 2) +#endif +#ifndef OVERRIDE_TABLE_32_fstatfs +TRACE_SYSCALL_TABLE(fstatfs, fstatfs, 100, 2) +#endif +#ifndef OVERRIDE_TABLE_32_socketcall +TRACE_SYSCALL_TABLE(socketcall, socketcall, 102, 2) +#endif +#ifndef OVERRIDE_TABLE_32_syslog +TRACE_SYSCALL_TABLE(syslog, syslog, 103, 3) +#endif +#ifndef OVERRIDE_TABLE_32_setitimer +TRACE_SYSCALL_TABLE(setitimer, setitimer, 104, 3) +#endif +#ifndef OVERRIDE_TABLE_32_getitimer +TRACE_SYSCALL_TABLE(getitimer, getitimer, 105, 2) +#endif +#ifndef OVERRIDE_TABLE_32_newstat +TRACE_SYSCALL_TABLE(newstat, newstat, 106, 2) +#endif +#ifndef OVERRIDE_TABLE_32_newlstat +TRACE_SYSCALL_TABLE(newlstat, newlstat, 107, 2) +#endif +#ifndef OVERRIDE_TABLE_32_newfstat +TRACE_SYSCALL_TABLE(newfstat, newfstat, 108, 2) +#endif +#ifndef OVERRIDE_TABLE_32_uname +TRACE_SYSCALL_TABLE(uname, uname, 109, 1) +#endif +#ifndef OVERRIDE_TABLE_32_wait4 +TRACE_SYSCALL_TABLE(wait4, wait4, 114, 4) +#endif +#ifndef OVERRIDE_TABLE_32_swapoff +TRACE_SYSCALL_TABLE(swapoff, swapoff, 115, 1) +#endif +#ifndef OVERRIDE_TABLE_32_sysinfo +TRACE_SYSCALL_TABLE(sysinfo, sysinfo, 116, 1) +#endif +#ifndef OVERRIDE_TABLE_32_ipc +TRACE_SYSCALL_TABLE(ipc, ipc, 117, 6) +#endif +#ifndef OVERRIDE_TABLE_32_setdomainname +TRACE_SYSCALL_TABLE(setdomainname, setdomainname, 121, 2) +#endif +#ifndef OVERRIDE_TABLE_32_newuname +TRACE_SYSCALL_TABLE(newuname, newuname, 122, 1) +#endif +#ifndef OVERRIDE_TABLE_32_adjtimex +TRACE_SYSCALL_TABLE(adjtimex, adjtimex, 124, 1) +#endif +#ifndef OVERRIDE_TABLE_32_sigprocmask +TRACE_SYSCALL_TABLE(sigprocmask, sigprocmask, 126, 3) +#endif +#ifndef OVERRIDE_TABLE_32_init_module +TRACE_SYSCALL_TABLE(init_module, init_module, 128, 3) +#endif +#ifndef OVERRIDE_TABLE_32_delete_module +TRACE_SYSCALL_TABLE(delete_module, delete_module, 129, 2) +#endif +#ifndef OVERRIDE_TABLE_32_llseek +TRACE_SYSCALL_TABLE(llseek, llseek, 140, 5) +#endif +#ifndef OVERRIDE_TABLE_32_getdents +TRACE_SYSCALL_TABLE(getdents, getdents, 141, 3) +#endif +#ifndef OVERRIDE_TABLE_32_select +TRACE_SYSCALL_TABLE(select, select, 142, 5) +#endif +#ifndef OVERRIDE_TABLE_32_readv +TRACE_SYSCALL_TABLE(readv, readv, 145, 3) +#endif +#ifndef OVERRIDE_TABLE_32_writev +TRACE_SYSCALL_TABLE(writev, writev, 146, 3) +#endif +#ifndef OVERRIDE_TABLE_32_sysctl +TRACE_SYSCALL_TABLE(sysctl, sysctl, 149, 1) +#endif +#ifndef OVERRIDE_TABLE_32_sched_setparam +TRACE_SYSCALL_TABLE(sched_setparam, sched_setparam, 154, 2) +#endif +#ifndef OVERRIDE_TABLE_32_sched_getparam +TRACE_SYSCALL_TABLE(sched_getparam, sched_getparam, 155, 2) +#endif +#ifndef OVERRIDE_TABLE_32_sched_setscheduler +TRACE_SYSCALL_TABLE(sched_setscheduler, sched_setscheduler, 156, 3) +#endif +#ifndef OVERRIDE_TABLE_32_sched_rr_get_interval +TRACE_SYSCALL_TABLE(sched_rr_get_interval, sched_rr_get_interval, 161, 2) +#endif +#ifndef OVERRIDE_TABLE_32_nanosleep +TRACE_SYSCALL_TABLE(nanosleep, nanosleep, 162, 2) +#endif +#ifndef OVERRIDE_TABLE_32_getresuid +TRACE_SYSCALL_TABLE(getresuid, getresuid, 165, 3) +#endif +#ifndef OVERRIDE_TABLE_32_poll +TRACE_SYSCALL_TABLE(poll, poll, 167, 3) +#endif +#ifndef OVERRIDE_TABLE_32_nfsservctl +TRACE_SYSCALL_TABLE(nfsservctl, nfsservctl, 168, 3) +#endif +#ifndef OVERRIDE_TABLE_32_getresgid +TRACE_SYSCALL_TABLE(getresgid, getresgid, 170, 3) +#endif +#ifndef OVERRIDE_TABLE_32_rt_sigaction +TRACE_SYSCALL_TABLE(rt_sigaction, rt_sigaction, 173, 4) +#endif +#ifndef OVERRIDE_TABLE_32_rt_sigprocmask +TRACE_SYSCALL_TABLE(rt_sigprocmask, rt_sigprocmask, 174, 4) +#endif +#ifndef OVERRIDE_TABLE_32_rt_sigpending +TRACE_SYSCALL_TABLE(rt_sigpending, rt_sigpending, 175, 2) +#endif +#ifndef OVERRIDE_TABLE_32_rt_sigtimedwait +TRACE_SYSCALL_TABLE(rt_sigtimedwait, rt_sigtimedwait, 176, 4) +#endif +#ifndef OVERRIDE_TABLE_32_rt_sigqueueinfo +TRACE_SYSCALL_TABLE(rt_sigqueueinfo, rt_sigqueueinfo, 177, 3) +#endif +#ifndef OVERRIDE_TABLE_32_rt_sigsuspend +TRACE_SYSCALL_TABLE(rt_sigsuspend, rt_sigsuspend, 178, 2) +#endif +#ifndef OVERRIDE_TABLE_32_chown +TRACE_SYSCALL_TABLE(chown, chown, 181, 3) +#endif +#ifndef OVERRIDE_TABLE_32_getcwd +TRACE_SYSCALL_TABLE(getcwd, getcwd, 182, 2) +#endif +#ifndef OVERRIDE_TABLE_32_sendfile +TRACE_SYSCALL_TABLE(sendfile, sendfile, 186, 4) +#endif +#ifndef OVERRIDE_TABLE_32_getrlimit +TRACE_SYSCALL_TABLE(getrlimit, getrlimit, 190, 2) +#endif +#ifndef OVERRIDE_TABLE_32_stat64 +TRACE_SYSCALL_TABLE(stat64, stat64, 195, 2) +#endif +#ifndef OVERRIDE_TABLE_32_lstat64 +TRACE_SYSCALL_TABLE(lstat64, lstat64, 196, 2) +#endif +#ifndef OVERRIDE_TABLE_32_fstat64 +TRACE_SYSCALL_TABLE(fstat64, fstat64, 197, 2) +#endif +#ifndef OVERRIDE_TABLE_32_pciconfig_read +TRACE_SYSCALL_TABLE(pciconfig_read, pciconfig_read, 198, 5) +#endif +#ifndef OVERRIDE_TABLE_32_pciconfig_write +TRACE_SYSCALL_TABLE(pciconfig_write, pciconfig_write, 199, 5) +#endif +#ifndef OVERRIDE_TABLE_32_getdents64 +TRACE_SYSCALL_TABLE(getdents64, getdents64, 202, 3) +#endif +#ifndef OVERRIDE_TABLE_32_pivot_root +TRACE_SYSCALL_TABLE(pivot_root, pivot_root, 203, 2) +#endif +#ifndef OVERRIDE_TABLE_32_mincore +TRACE_SYSCALL_TABLE(mincore, mincore, 206, 3) +#endif +#ifndef OVERRIDE_TABLE_32_setxattr +TRACE_SYSCALL_TABLE(setxattr, setxattr, 209, 5) +#endif +#ifndef OVERRIDE_TABLE_32_lsetxattr +TRACE_SYSCALL_TABLE(lsetxattr, lsetxattr, 210, 5) +#endif +#ifndef OVERRIDE_TABLE_32_fsetxattr +TRACE_SYSCALL_TABLE(fsetxattr, fsetxattr, 211, 5) +#endif +#ifndef OVERRIDE_TABLE_32_getxattr +TRACE_SYSCALL_TABLE(getxattr, getxattr, 212, 4) +#endif +#ifndef OVERRIDE_TABLE_32_lgetxattr +TRACE_SYSCALL_TABLE(lgetxattr, lgetxattr, 213, 4) +#endif +#ifndef OVERRIDE_TABLE_32_fgetxattr +TRACE_SYSCALL_TABLE(fgetxattr, fgetxattr, 214, 4) +#endif +#ifndef OVERRIDE_TABLE_32_listxattr +TRACE_SYSCALL_TABLE(listxattr, listxattr, 215, 3) +#endif +#ifndef OVERRIDE_TABLE_32_llistxattr +TRACE_SYSCALL_TABLE(llistxattr, llistxattr, 216, 3) +#endif +#ifndef OVERRIDE_TABLE_32_flistxattr +TRACE_SYSCALL_TABLE(flistxattr, flistxattr, 217, 3) +#endif +#ifndef OVERRIDE_TABLE_32_removexattr +TRACE_SYSCALL_TABLE(removexattr, removexattr, 218, 2) +#endif +#ifndef OVERRIDE_TABLE_32_lremovexattr +TRACE_SYSCALL_TABLE(lremovexattr, lremovexattr, 219, 2) +#endif +#ifndef OVERRIDE_TABLE_32_fremovexattr +TRACE_SYSCALL_TABLE(fremovexattr, fremovexattr, 220, 2) +#endif +#ifndef OVERRIDE_TABLE_32_futex +TRACE_SYSCALL_TABLE(futex, futex, 221, 6) +#endif +#ifndef OVERRIDE_TABLE_32_sched_setaffinity +TRACE_SYSCALL_TABLE(sched_setaffinity, sched_setaffinity, 222, 3) +#endif +#ifndef OVERRIDE_TABLE_32_sched_getaffinity +TRACE_SYSCALL_TABLE(sched_getaffinity, sched_getaffinity, 223, 3) +#endif +#ifndef OVERRIDE_TABLE_32_sendfile64 +TRACE_SYSCALL_TABLE(sendfile64, sendfile64, 226, 4) +#endif +#ifndef OVERRIDE_TABLE_32_io_setup +TRACE_SYSCALL_TABLE(io_setup, io_setup, 227, 2) +#endif +#ifndef OVERRIDE_TABLE_32_io_getevents +TRACE_SYSCALL_TABLE(io_getevents, io_getevents, 229, 5) +#endif +#ifndef OVERRIDE_TABLE_32_io_submit +TRACE_SYSCALL_TABLE(io_submit, io_submit, 230, 3) +#endif +#ifndef OVERRIDE_TABLE_32_io_cancel +TRACE_SYSCALL_TABLE(io_cancel, io_cancel, 231, 3) +#endif +#ifndef OVERRIDE_TABLE_32_set_tid_address +TRACE_SYSCALL_TABLE(set_tid_address, set_tid_address, 232, 1) +#endif +#ifndef OVERRIDE_TABLE_32_epoll_ctl +TRACE_SYSCALL_TABLE(epoll_ctl, epoll_ctl, 237, 4) +#endif +#ifndef OVERRIDE_TABLE_32_epoll_wait +TRACE_SYSCALL_TABLE(epoll_wait, epoll_wait, 238, 4) +#endif +#ifndef OVERRIDE_TABLE_32_timer_create +TRACE_SYSCALL_TABLE(timer_create, timer_create, 240, 3) +#endif +#ifndef OVERRIDE_TABLE_32_timer_settime +TRACE_SYSCALL_TABLE(timer_settime, timer_settime, 241, 4) +#endif +#ifndef OVERRIDE_TABLE_32_timer_gettime +TRACE_SYSCALL_TABLE(timer_gettime, timer_gettime, 242, 2) +#endif +#ifndef OVERRIDE_TABLE_32_clock_settime +TRACE_SYSCALL_TABLE(clock_settime, clock_settime, 245, 2) +#endif +#ifndef OVERRIDE_TABLE_32_clock_gettime +TRACE_SYSCALL_TABLE(clock_gettime, clock_gettime, 246, 2) +#endif +#ifndef OVERRIDE_TABLE_32_clock_getres +TRACE_SYSCALL_TABLE(clock_getres, clock_getres, 247, 2) +#endif +#ifndef OVERRIDE_TABLE_32_clock_nanosleep +TRACE_SYSCALL_TABLE(clock_nanosleep, clock_nanosleep, 248, 4) +#endif +#ifndef OVERRIDE_TABLE_32_utimes +TRACE_SYSCALL_TABLE(utimes, utimes, 251, 2) +#endif +#ifndef OVERRIDE_TABLE_32_statfs64 +TRACE_SYSCALL_TABLE(statfs64, statfs64, 252, 3) +#endif +#ifndef OVERRIDE_TABLE_32_fstatfs64 +TRACE_SYSCALL_TABLE(fstatfs64, fstatfs64, 253, 3) +#endif +#ifndef OVERRIDE_TABLE_32_mq_open +TRACE_SYSCALL_TABLE(mq_open, mq_open, 262, 4) +#endif +#ifndef OVERRIDE_TABLE_32_mq_unlink +TRACE_SYSCALL_TABLE(mq_unlink, mq_unlink, 263, 1) +#endif +#ifndef OVERRIDE_TABLE_32_mq_timedsend +TRACE_SYSCALL_TABLE(mq_timedsend, mq_timedsend, 264, 5) +#endif +#ifndef OVERRIDE_TABLE_32_mq_timedreceive +TRACE_SYSCALL_TABLE(mq_timedreceive, mq_timedreceive, 265, 5) +#endif +#ifndef OVERRIDE_TABLE_32_mq_notify +TRACE_SYSCALL_TABLE(mq_notify, mq_notify, 266, 2) +#endif +#ifndef OVERRIDE_TABLE_32_mq_getsetattr +TRACE_SYSCALL_TABLE(mq_getsetattr, mq_getsetattr, 267, 3) +#endif +#ifndef OVERRIDE_TABLE_32_add_key +TRACE_SYSCALL_TABLE(add_key, add_key, 269, 5) +#endif +#ifndef OVERRIDE_TABLE_32_request_key +TRACE_SYSCALL_TABLE(request_key, request_key, 270, 4) +#endif +#ifndef OVERRIDE_TABLE_32_waitid +TRACE_SYSCALL_TABLE(waitid, waitid, 272, 5) +#endif +#ifndef OVERRIDE_TABLE_32_inotify_add_watch +TRACE_SYSCALL_TABLE(inotify_add_watch, inotify_add_watch, 276, 3) +#endif +#ifndef OVERRIDE_TABLE_32_pselect6 +TRACE_SYSCALL_TABLE(pselect6, pselect6, 280, 6) +#endif +#ifndef OVERRIDE_TABLE_32_ppoll +TRACE_SYSCALL_TABLE(ppoll, ppoll, 281, 5) +#endif +#ifndef OVERRIDE_TABLE_32_splice +TRACE_SYSCALL_TABLE(splice, splice, 283, 6) +#endif +#ifndef OVERRIDE_TABLE_32_vmsplice +TRACE_SYSCALL_TABLE(vmsplice, vmsplice, 285, 4) +#endif +#ifndef OVERRIDE_TABLE_32_openat +TRACE_SYSCALL_TABLE(openat, openat, 286, 4) +#endif +#ifndef OVERRIDE_TABLE_32_mkdirat +TRACE_SYSCALL_TABLE(mkdirat, mkdirat, 287, 3) +#endif +#ifndef OVERRIDE_TABLE_32_mknodat +TRACE_SYSCALL_TABLE(mknodat, mknodat, 288, 4) +#endif +#ifndef OVERRIDE_TABLE_32_fchownat +TRACE_SYSCALL_TABLE(fchownat, fchownat, 289, 5) +#endif +#ifndef OVERRIDE_TABLE_32_futimesat +TRACE_SYSCALL_TABLE(futimesat, futimesat, 290, 3) +#endif +#ifndef OVERRIDE_TABLE_32_fstatat64 +TRACE_SYSCALL_TABLE(fstatat64, fstatat64, 291, 4) +#endif +#ifndef OVERRIDE_TABLE_32_unlinkat +TRACE_SYSCALL_TABLE(unlinkat, unlinkat, 292, 3) +#endif +#ifndef OVERRIDE_TABLE_32_renameat +TRACE_SYSCALL_TABLE(renameat, renameat, 293, 4) +#endif +#ifndef OVERRIDE_TABLE_32_linkat +TRACE_SYSCALL_TABLE(linkat, linkat, 294, 5) +#endif +#ifndef OVERRIDE_TABLE_32_symlinkat +TRACE_SYSCALL_TABLE(symlinkat, symlinkat, 295, 3) +#endif +#ifndef OVERRIDE_TABLE_32_readlinkat +TRACE_SYSCALL_TABLE(readlinkat, readlinkat, 296, 4) +#endif +#ifndef OVERRIDE_TABLE_32_fchmodat +TRACE_SYSCALL_TABLE(fchmodat, fchmodat, 297, 3) +#endif +#ifndef OVERRIDE_TABLE_32_faccessat +TRACE_SYSCALL_TABLE(faccessat, faccessat, 298, 3) +#endif +#ifndef OVERRIDE_TABLE_32_get_robust_list +TRACE_SYSCALL_TABLE(get_robust_list, get_robust_list, 299, 3) +#endif +#ifndef OVERRIDE_TABLE_32_set_robust_list +TRACE_SYSCALL_TABLE(set_robust_list, set_robust_list, 300, 2) +#endif +#ifndef OVERRIDE_TABLE_32_getcpu +TRACE_SYSCALL_TABLE(getcpu, getcpu, 302, 3) +#endif +#ifndef OVERRIDE_TABLE_32_epoll_pwait +TRACE_SYSCALL_TABLE(epoll_pwait, epoll_pwait, 303, 6) +#endif +#ifndef OVERRIDE_TABLE_32_utimensat +TRACE_SYSCALL_TABLE(utimensat, utimensat, 304, 4) +#endif +#ifndef OVERRIDE_TABLE_32_signalfd +TRACE_SYSCALL_TABLE(signalfd, signalfd, 305, 3) +#endif +#ifndef OVERRIDE_TABLE_32_timerfd_settime +TRACE_SYSCALL_TABLE(timerfd_settime, timerfd_settime, 311, 4) +#endif +#ifndef OVERRIDE_TABLE_32_timerfd_gettime +TRACE_SYSCALL_TABLE(timerfd_gettime, timerfd_gettime, 312, 2) +#endif +#ifndef OVERRIDE_TABLE_32_signalfd4 +TRACE_SYSCALL_TABLE(signalfd4, signalfd4, 313, 4) +#endif +#ifndef OVERRIDE_TABLE_32_pipe2 +TRACE_SYSCALL_TABLE(pipe2, pipe2, 317, 2) +#endif +#ifndef OVERRIDE_TABLE_32_perf_event_open +TRACE_SYSCALL_TABLE(perf_event_open, perf_event_open, 319, 5) +#endif +#ifndef OVERRIDE_TABLE_32_preadv +TRACE_SYSCALL_TABLE(preadv, preadv, 320, 5) +#endif +#ifndef OVERRIDE_TABLE_32_pwritev +TRACE_SYSCALL_TABLE(pwritev, pwritev, 321, 5) +#endif +#ifndef OVERRIDE_TABLE_32_rt_tgsigqueueinfo +TRACE_SYSCALL_TABLE(rt_tgsigqueueinfo, rt_tgsigqueueinfo, 322, 4) +#endif +#ifndef OVERRIDE_TABLE_32_prlimit64 +TRACE_SYSCALL_TABLE(prlimit64, prlimit64, 325, 4) +#endif +#ifndef OVERRIDE_TABLE_32_bind +TRACE_SYSCALL_TABLE(bind, bind, 327, 3) +#endif +#ifndef OVERRIDE_TABLE_32_connect +TRACE_SYSCALL_TABLE(connect, connect, 328, 3) +#endif +#ifndef OVERRIDE_TABLE_32_accept +TRACE_SYSCALL_TABLE(accept, accept, 330, 3) +#endif +#ifndef OVERRIDE_TABLE_32_getsockname +TRACE_SYSCALL_TABLE(getsockname, getsockname, 331, 3) +#endif +#ifndef OVERRIDE_TABLE_32_getpeername +TRACE_SYSCALL_TABLE(getpeername, getpeername, 332, 3) +#endif +#ifndef OVERRIDE_TABLE_32_socketpair +TRACE_SYSCALL_TABLE(socketpair, socketpair, 333, 4) +#endif +#ifndef OVERRIDE_TABLE_32_send +TRACE_SYSCALL_TABLE(send, send, 334, 4) +#endif +#ifndef OVERRIDE_TABLE_32_sendto +TRACE_SYSCALL_TABLE(sendto, sendto, 335, 6) +#endif +#ifndef OVERRIDE_TABLE_32_recvfrom +TRACE_SYSCALL_TABLE(recvfrom, recvfrom, 337, 6) +#endif +#ifndef OVERRIDE_TABLE_32_setsockopt +TRACE_SYSCALL_TABLE(setsockopt, setsockopt, 339, 5) +#endif +#ifndef OVERRIDE_TABLE_32_getsockopt +TRACE_SYSCALL_TABLE(getsockopt, getsockopt, 340, 5) +#endif +#ifndef OVERRIDE_TABLE_32_sendmsg +TRACE_SYSCALL_TABLE(sendmsg, sendmsg, 341, 3) +#endif +#ifndef OVERRIDE_TABLE_32_recvmsg +TRACE_SYSCALL_TABLE(recvmsg, recvmsg, 342, 3) +#endif +#ifndef OVERRIDE_TABLE_32_recvmmsg +TRACE_SYSCALL_TABLE(recvmmsg, recvmmsg, 343, 5) +#endif +#ifndef OVERRIDE_TABLE_32_accept4 +TRACE_SYSCALL_TABLE(accept4, accept4, 344, 4) +#endif +#ifndef OVERRIDE_TABLE_32_clock_adjtime +TRACE_SYSCALL_TABLE(clock_adjtime, clock_adjtime, 347, 2) +#endif +#ifndef OVERRIDE_TABLE_32_sendmmsg +TRACE_SYSCALL_TABLE(sendmmsg, sendmmsg, 349, 4) +#endif + +#endif /* CREATE_SYSCALL_TABLE */ diff --git a/include/instrumentation/syscalls/headers/powerpc-32-syscalls_pointers_override.h b/include/instrumentation/syscalls/headers/powerpc-32-syscalls_pointers_override.h new file mode 100644 index 00000000..fde30d27 --- /dev/null +++ b/include/instrumentation/syscalls/headers/powerpc-32-syscalls_pointers_override.h @@ -0,0 +1,24 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ + +#define OVERRIDE_TABLE_32_mmap2 + +#ifndef CREATE_SYSCALL_TABLE + +#define OVERRIDE_32_pipe +SC_LTTNG_TRACEPOINT_EVENT(pipe, + TP_PROTO(sc_exit(long ret,) int * fildes), + TP_ARGS(sc_exit(ret,) fildes), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) + sc_out(ctf_user_array(int, fildes, fildes, 2)) + ) +) + +#else /* CREATE_SYSCALL_TABLE */ + +#define OVERRIDE_TABLE_32_execve +TRACE_SYSCALL_TABLE(execve, execve, 11, 3) +#define OVERRIDE_TABLE_32_clone +TRACE_SYSCALL_TABLE(clone, clone, 120, 5) + +#endif /* CREATE_SYSCALL_TABLE */ + diff --git a/include/instrumentation/syscalls/headers/syscalls_integers.h b/include/instrumentation/syscalls/headers/syscalls_integers.h new file mode 100644 index 00000000..ea8e29bc --- /dev/null +++ b/include/instrumentation/syscalls/headers/syscalls_integers.h @@ -0,0 +1,25 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ + +#ifdef CONFIG_X86_64 +#include "x86-64-syscalls_integers.h" +#endif + +#ifdef CONFIG_X86_32 +#include "x86-32-syscalls_integers.h" +#endif + +#ifdef CONFIG_ARM +#include "arm-32-syscalls_integers.h" +#endif + +#ifdef CONFIG_PPC +#include "powerpc-32-syscalls_integers.h" +#endif + +#ifdef CONFIG_CPU_MIPS32 +#include "mips-32-syscalls_integers.h" +#endif + +#ifdef CONFIG_ARM64 +#include "arm-64-syscalls_integers.h" +#endif diff --git a/include/instrumentation/syscalls/headers/syscalls_integers_override.h b/include/instrumentation/syscalls/headers/syscalls_integers_override.h new file mode 100644 index 00000000..2866fdce --- /dev/null +++ b/include/instrumentation/syscalls/headers/syscalls_integers_override.h @@ -0,0 +1,78 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ + +#ifndef CREATE_SYSCALL_TABLE + +#define OVERRIDE_32_mmap +#define OVERRIDE_64_mmap +SC_LTTNG_TRACEPOINT_EVENT(mmap, + TP_PROTO(sc_exit(unsigned long ret,) + unsigned long addr, unsigned long len, + unsigned long prot, unsigned long flags, + unsigned long fd, unsigned long off), + TP_ARGS(sc_exit(ret,) addr, len, prot, flags, fd, off), + TP_FIELDS(sc_exit(ctf_integer_hex(unsigned long, ret, ret)) + sc_in(ctf_integer_hex(unsigned long, addr, addr)) + sc_in(ctf_integer(size_t, len, len)) + sc_in(ctf_integer(int, prot, prot)) + sc_in(ctf_integer(int, flags, flags)) + sc_in(ctf_integer(int, fd, fd)) + sc_in(ctf_integer(off_t, offset, off)) + ) +) + +/* + * Enumeration of the open flags, as described in the 'open' + * system call man page. + */ +SC_LTTNG_TRACEPOINT_ENUM(lttng_fcntl_cmd_flags, + TP_ENUM_VALUES( + ctf_enum_value("F_DUPFD", F_DUPFD) + ctf_enum_value("F_GETFD", F_GETFD) + ctf_enum_value("F_SETFD", F_SETFD) + ctf_enum_value("F_GETFL", F_GETFL) + ctf_enum_value("F_SETFL", F_SETFL) + ctf_enum_value("F_GETLK", F_GETLK) + ctf_enum_value("F_SETLK", F_SETLK) + ctf_enum_value("F_SETLKW", F_SETLKW) + ctf_enum_value("F_SETOWN", F_SETOWN) + ctf_enum_value("F_GETOWN", F_GETOWN) + ctf_enum_value("F_SETSIG", F_SETSIG) + ctf_enum_value("F_GETSIG", F_GETSIG) + ctf_enum_value("F_GETLK64", F_GETLK64) + ctf_enum_value("F_SETLK64", F_SETLK64) + ctf_enum_value("F_SETLKW64", F_SETLKW64) + ctf_enum_value("F_SETOWN_EX", F_SETOWN_EX) + ctf_enum_value("F_GETOWN_EX", F_GETOWN_EX) + ctf_enum_value("F_GETOWNER_UIDS", F_GETOWNER_UIDS) + ctf_enum_value("F_OFD_GETLK", F_OFD_GETLK) + ctf_enum_value("F_OFD_SETLK", F_OFD_SETLK) + ctf_enum_value("F_OFD_SETLKW", F_OFD_SETLKW) + ctf_enum_value("F_SETLEASE", F_SETLEASE) + ctf_enum_value("F_GETLEASE", F_GETLEASE) + ctf_enum_value("F_NOTIFY", F_NOTIFY) + ctf_enum_value("F_CANCELLK", F_CANCELLK) + ctf_enum_value("F_DUPFD_CLOEXEC", F_DUPFD_CLOEXEC) + ctf_enum_value("F_SETPIPE_SZ", F_SETPIPE_SZ) + ctf_enum_value("F_GETPIPE_SZ", F_GETPIPE_SZ) + ctf_enum_value("F_ADD_SEALS", F_ADD_SEALS) + ctf_enum_value("F_GET_SEALS", F_GET_SEALS) + ctf_enum_value("F_GET_RW_HINT", F_GET_RW_HINT) + ctf_enum_value("F_SET_RW_HINT", F_SET_RW_HINT) + ctf_enum_value("F_GET_FILE_RW_HINT", F_GET_FILE_RW_HINT) + ctf_enum_value("F_SET_FILE_RW_HINT", F_SET_FILE_RW_HINT) + ) +) + +#define OVERRIDE_32_fcntl +#define OVERRIDE_64_fcntl +SC_LTTNG_TRACEPOINT_EVENT(fcntl, + TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd, unsigned long arg), + TP_ARGS(sc_exit(ret,) fd, cmd, arg), + TP_FIELDS( + sc_exit(ctf_integer(long, ret, ret)) + sc_in(ctf_integer(unsigned int, fd, fd)) + sc_in(ctf_enum(lttng_fcntl_cmd_flags, unsigned int, cmd, cmd)) + sc_inout(ctf_integer(unsigned long, arg, arg))) +) + +#endif /* CREATE_SYSCALL_TABLE */ diff --git a/include/instrumentation/syscalls/headers/syscalls_pointers.h b/include/instrumentation/syscalls/headers/syscalls_pointers.h new file mode 100644 index 00000000..a2ee3127 --- /dev/null +++ b/include/instrumentation/syscalls/headers/syscalls_pointers.h @@ -0,0 +1,25 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ + +#ifdef CONFIG_X86_64 +#include "x86-64-syscalls_pointers.h" +#endif + +#ifdef CONFIG_X86_32 +#include "x86-32-syscalls_pointers.h" +#endif + +#ifdef CONFIG_ARM +#include "arm-32-syscalls_pointers.h" +#endif + +#ifdef CONFIG_PPC +#include "powerpc-32-syscalls_pointers.h" +#endif + +#ifdef CONFIG_CPU_MIPS32 +#include "mips-32-syscalls_pointers.h" +#endif + +#ifdef CONFIG_ARM64 +#include "arm-64-syscalls_pointers.h" +#endif diff --git a/include/instrumentation/syscalls/headers/syscalls_pointers_override.h b/include/instrumentation/syscalls/headers/syscalls_pointers_override.h new file mode 100644 index 00000000..341e93b6 --- /dev/null +++ b/include/instrumentation/syscalls/headers/syscalls_pointers_override.h @@ -0,0 +1,1004 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ + +#ifndef CREATE_SYSCALL_TABLE + +#define OVERRIDE_32_execve +#define OVERRIDE_64_execve +SC_LTTNG_TRACEPOINT_EVENT(execve, + TP_PROTO(sc_exit(long ret,) const char *filename, char *const *argv, char *const *envp), + TP_ARGS(sc_exit(ret,) filename, argv, envp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) + sc_in(ctf_user_string(filename, filename)) + sc_in(ctf_integer_hex(char *const *, argv, argv)) + sc_in(ctf_integer_hex(char *const *, envp, envp)) + ) +) + +#define OVERRIDE_32_clone +#define OVERRIDE_64_clone +SC_LTTNG_TRACEPOINT_EVENT(clone, + TP_PROTO(sc_exit(long ret,) unsigned long clone_flags, unsigned long newsp, + void __user *parent_tid, + void __user *child_tid), + TP_ARGS(sc_exit(ret,) clone_flags, newsp, parent_tid, child_tid), + TP_FIELDS( + sc_exit(ctf_integer(long, ret, ret)) + sc_in(ctf_integer_hex(unsigned long, clone_flags, clone_flags)) + sc_in(ctf_integer_hex(unsigned long, newsp, newsp)) + sc_in(ctf_integer_hex(void *, parent_tid, parent_tid)) + sc_in(ctf_integer_hex(void *, child_tid, child_tid)) + ) +) + +/* present in 32, missing in 64 due to old kernel headers */ +#define OVERRIDE_32_getcpu +#define OVERRIDE_64_getcpu +SC_LTTNG_TRACEPOINT_EVENT(getcpu, + TP_PROTO(sc_exit(long ret,) unsigned __user *cpup, unsigned __user *nodep, void *tcache), + TP_ARGS(sc_exit(ret,) cpup, nodep, tcache), + TP_FIELDS( + sc_exit(ctf_integer(long, ret, ret)) + sc_out(ctf_integer_hex(unsigned *, cpup, cpup)) + sc_out(ctf_integer_hex(unsigned *, nodep, nodep)) + sc_inout(ctf_integer_hex(void *, tcache, tcache)) + ) +) + +#define OVERRIDE_32_pipe2 +#define OVERRIDE_64_pipe2 +SC_LTTNG_TRACEPOINT_EVENT(pipe2, + TP_PROTO(sc_exit(long ret,) int * fildes, int flags), + TP_ARGS(sc_exit(ret,) fildes, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) + sc_out(ctf_user_array(int, fildes, fildes, 2)) + sc_in(ctf_integer(int, flags, flags)) + ) +) + +#define LTTNG_SYSCALL_SELECT_locvar \ + unsigned long *fds_in, *fds_out, *fds_ex; \ + unsigned long nr_bytes, nr_ulong; \ + uint8_t overflow; + +#define LTTNG_SYSCALL_SELECT_code_pre \ + sc_inout( \ + { \ + int err; \ + unsigned int n_in_bytes; \ + \ + tp_locvar->fds_in = NULL; \ + tp_locvar->fds_out = NULL; \ + tp_locvar->fds_ex = NULL; \ + tp_locvar->overflow = 0; \ + \ + sc_out( \ + if (ret <= 0) \ + goto error; \ + ) \ + \ + if (n <= 0) \ + goto error; \ + \ + /* On error or bogus input, don't copy anything. */ \ + if (n >__FD_SETSIZE) \ + goto error; \ + \ + n_in_bytes = DIV_ROUND_UP((unsigned int) n, BITS_PER_BYTE); \ + \ + /* \ + * Limit atomic memory allocation to one page, since n \ + * is limited to 1024 and the smallest page size on Linux \ + * is 4k, this should not happen, don't try to make it work. \ + */ \ + if (n_in_bytes > PAGE_SIZE) { \ + WARN_ON_ONCE(1); \ + /* Inform the user that we did not output everything. */ \ + tp_locvar->overflow = 1; \ + goto error; \ + } else { \ + tp_locvar->nr_bytes = n_in_bytes; \ + tp_locvar->nr_ulong = DIV_ROUND_UP(n_in_bytes, \ + sizeof(unsigned long)); \ + } \ + \ + if (inp) { \ + tp_locvar->fds_in = lttng_tp_mempool_alloc( \ + tp_locvar->nr_ulong * sizeof(unsigned long)); \ + if (!tp_locvar->fds_in) \ + goto error; \ + \ + err = lib_ring_buffer_copy_from_user_check_nofault( \ + tp_locvar->fds_in, inp, \ + tp_locvar->nr_ulong * sizeof(unsigned long)); \ + if (err != 0) \ + goto error; \ + } \ + if (outp) { \ + tp_locvar->fds_out = lttng_tp_mempool_alloc( \ + tp_locvar->nr_ulong * sizeof(unsigned long)); \ + if (!tp_locvar->fds_out) \ + goto error; \ + \ + err = lib_ring_buffer_copy_from_user_check_nofault( \ + tp_locvar->fds_out, outp, \ + tp_locvar->nr_ulong * sizeof(unsigned long)); \ + if (err != 0) \ + goto error; \ + } \ + if (exp) { \ + tp_locvar->fds_ex = lttng_tp_mempool_alloc( \ + tp_locvar->nr_ulong * sizeof(unsigned long)); \ + if (!tp_locvar->fds_ex) \ + goto error; \ + \ + err = lib_ring_buffer_copy_from_user_check_nofault( \ + tp_locvar->fds_ex, exp, \ + tp_locvar->nr_ulong * sizeof(unsigned long)); \ + if (err != 0) \ + goto error; \ + } \ + goto end; \ + \ +error: \ + tp_locvar->nr_bytes = 0; \ + tp_locvar->nr_ulong = 0; \ +end: ; /* Label at end of compound statement. */ \ + } \ + ) + +#define LTTNG_SYSCALL_SELECT_fds_field_LE(name, input) \ + ctf_custom_field( \ + ctf_custom_type( \ + __type_integer(uint8_t, 0, 0, 0, __BYTE_ORDER, 10, none) \ + ), \ + _ ## name ## _length, \ + ctf_custom_code( \ + if (input) { \ + ctf_integer_type(uint8_t, tp_locvar->nr_bytes) \ + ctf_align(uint8_t) \ + } else { \ + ctf_integer_type(uint8_t, 0) \ + ctf_align(uint8_t) \ + } \ + ) \ + ) \ + ctf_custom_field( \ + ctf_custom_type( \ + { \ + .atype = atype_sequence_nestable, \ + .u.sequence_nestable.length_name = "_" #name "_length", \ + .u.sequence_nestable.elem_type = __LTTNG_COMPOUND_LITERAL(struct lttng_type, \ + __type_integer(uint8_t, 0, 0, 0, __BYTE_ORDER, 16, none)), \ + .u.sequence_nestable.alignment = 0, \ + } \ + ), \ + name, \ + ctf_custom_code( \ + unsigned int src; \ + unsigned int nr_bytes_out = 0; \ + \ + if (!input) \ + goto skip_##name; \ + \ + for (src = 0; src < tp_locvar->nr_ulong; src++) { \ + int dst; \ + for (dst = 0; dst < sizeof(long); dst++) { \ + if (nr_bytes_out++ >= tp_locvar->nr_bytes) { \ + goto skip_##name; \ + } \ + ctf_user_integer_type(uint8_t, \ + ((uint8_t __user *) (input->fds_bits + src))[dst]); \ + } \ + } \ + skip_##name: ; \ + ) \ + ) + +#define LTTNG_SYSCALL_SELECT_fds_field_BE(name, input) \ + ctf_custom_field( \ + ctf_custom_type( \ + __type_integer(uint8_t, 0, 0, 0, __BYTE_ORDER, 10, none) \ + ), \ + _ ## name ## _length, \ + ctf_custom_code( \ + if (input) { \ + ctf_integer_type(uint8_t, tp_locvar->nr_bytes) \ + ctf_align(uint8_t) \ + } else { \ + ctf_integer_type(uint8_t, 0) \ + ctf_align(uint8_t) \ + } \ + ) \ + ) \ + ctf_custom_field( \ + ctf_custom_type( \ + { \ + .atype = atype_sequence_nestable, \ + .u.sequence_nestable.elem_type = __LTTNG_COMPOUND_LITERAL(struct lttng_type, \ + __type_integer(uint8_t, 0, 0, 0, __BYTE_ORDER, 16, none)), \ + .u.sequence_nestable.alignment = 0, \ + } \ + ), \ + name, \ + ctf_custom_code( \ + unsigned int src, nr_bytes_out = 0; \ + \ + if (!input) \ + goto skip_##name; \ + \ + for (src = 0; src < tp_locvar->nr_ulong; src++) { \ + int dst; \ + for (dst = sizeof(long); dst >= 0; dst--) { \ + if (nr_bytes_out++ >= tp_locvar->nr_bytes) { \ + goto skip_##name; \ + } \ + ctf_user_integer_type(uint8_t, \ + ((uint8_t __user *) (input->fds_bits + src))[dst]); \ + } \ + } \ + skip_##name: ; \ + ) \ + ) + +#define LTTNG_SYSCALL_SELECT_code_post \ + lttng_tp_mempool_free(tp_locvar->fds_in); \ + lttng_tp_mempool_free(tp_locvar->fds_out); \ + lttng_tp_mempool_free(tp_locvar->fds_ex); + +#if defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM) +#define OVERRIDE_32_select +#define OVERRIDE_64_select +SC_LTTNG_TRACEPOINT_EVENT_CODE(select, + TP_PROTO(sc_exit(long ret,) int n, fd_set __user *inp, fd_set __user *outp, + fd_set __user *exp, struct timeval *tvp), + TP_ARGS(sc_exit(ret,) n, inp, outp, exp, tvp), + TP_locvar( + LTTNG_SYSCALL_SELECT_locvar + ), + TP_code_pre( + LTTNG_SYSCALL_SELECT_code_pre + ), + TP_FIELDS( + sc_exit(ctf_integer(long, ret, ret)) + sc_in(ctf_integer(int, n, n)) + sc_inout(ctf_integer(uint8_t, overflow, tp_locvar->overflow)) + sc_inout(ctf_integer(struct timeval *, tvp, tvp)) + + sc_inout( +#if (__BYTE_ORDER == __LITTLE_ENDIAN) + LTTNG_SYSCALL_SELECT_fds_field_LE(readfds, inp) + LTTNG_SYSCALL_SELECT_fds_field_LE(writefds, outp) + LTTNG_SYSCALL_SELECT_fds_field_LE(exceptfds, exp) +#else + LTTNG_SYSCALL_SELECT_fds_field_BE(readfds, inp) + LTTNG_SYSCALL_SELECT_fds_field_BE(writefds, outp) + LTTNG_SYSCALL_SELECT_fds_field_BE(exceptfds, exp) +#endif + ) + ), + TP_code_post( + LTTNG_SYSCALL_SELECT_code_post + ) +) +#endif /* defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM) */ + +#if defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM) +#define OVERRIDE_32_pselect6 +#define OVERRIDE_64_pselect6 +SC_LTTNG_TRACEPOINT_EVENT_CODE(pselect6, + TP_PROTO(sc_exit(long ret,) int n, fd_set __user * inp, fd_set __user * outp, + fd_set __user * exp, struct timeval __user * tvp, void __user * sig), + TP_ARGS(sc_exit(ret,) n, inp, outp, exp, tvp, sig), + TP_locvar( + LTTNG_SYSCALL_SELECT_locvar + ), + TP_code_pre( + LTTNG_SYSCALL_SELECT_code_pre + ), + TP_FIELDS( + sc_exit(ctf_integer(long, ret, ret)) + sc_in(ctf_integer(int, n, n)) + sc_inout(ctf_integer(uint8_t, overflow, tp_locvar->overflow)) + sc_inout(ctf_integer(struct timeval *, tvp, tvp)) + sc_in(ctf_integer_hex(void *, sig, sig)) + + sc_inout( +#if (__BYTE_ORDER == __LITTLE_ENDIAN) + LTTNG_SYSCALL_SELECT_fds_field_LE(readfds, inp) + LTTNG_SYSCALL_SELECT_fds_field_LE(writefds, outp) + LTTNG_SYSCALL_SELECT_fds_field_LE(exceptfds, exp) +#else + LTTNG_SYSCALL_SELECT_fds_field_BE(readfds, inp) + LTTNG_SYSCALL_SELECT_fds_field_BE(writefds, outp) + LTTNG_SYSCALL_SELECT_fds_field_BE(exceptfds, exp) +#endif + ) + ), + TP_code_post( + LTTNG_SYSCALL_SELECT_code_post + ) +) +#endif /* defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM) */ + +#ifndef ONCE_LTTNG_TRACE_POLL_H +#define ONCE_LTTNG_TRACE_POLL_H + +#define LTTNG_POLL_NRFLAGS (POLLNVAL + 1) +#define POLL_FLAGS_PADDING_SIZE (sizeof(uint8_t) * BITS_PER_BYTE) - \ + ilog2(LTTNG_POLL_NRFLAGS - 1) + +/* + * Only extract the values specified by iBCS2 for now. + */ +static struct lttng_event_field lttng_pollfd_flag_fields[] = { + [ilog2(POLLIN)] = { + .name = "POLLIN", + .type = __type_integer(int, 1, 1, 0, __LITTLE_ENDIAN, 10, none), + }, + [ilog2(POLLPRI)] = { + .name = "POLLPRI", + .type = __type_integer(int, 1, 1, 0, __LITTLE_ENDIAN, 10, none), + }, + [ilog2(POLLOUT)] = { + .name = "POLLOUT", + .type = __type_integer(int, 1, 1, 0, __LITTLE_ENDIAN, 10, none), + }, + [ilog2(POLLERR)] = { + .name = "POLLERR", + .type = __type_integer(int, 1, 1, 0, __LITTLE_ENDIAN, 10, none), + }, + [ilog2(POLLHUP)] = { + .name = "POLLHUP", + .type = __type_integer(int, 1, 1, 0, __LITTLE_ENDIAN, 10, none), + }, + [ilog2(POLLNVAL)] = { + .name = "POLLNVAL", + .type = __type_integer(int, 1, 1, 0, __LITTLE_ENDIAN, 10, none), + }, + [ilog2(LTTNG_POLL_NRFLAGS)] = { + .name = "padding", + .type = __type_integer(int, POLL_FLAGS_PADDING_SIZE, 1, 0, + __LITTLE_ENDIAN, 10, none), + }, +}; + +static struct lttng_event_field lttng_pollfd_fields[] = { + [0] = { + .name = "fd", + .type = __type_integer(int, 0, 0, 0, __BYTE_ORDER, 10, none), + }, + [1] = { + .name = "raw_events", + .type = __type_integer(short, 0, 0, 0, __BYTE_ORDER, 16, none), + }, + [2] = { + .name = "events", + .type = { + .atype = atype_struct_nestable, + .u.struct_nestable.nr_fields = ARRAY_SIZE(lttng_pollfd_flag_fields), + .u.struct_nestable.fields = lttng_pollfd_flag_fields, + .u.struct_nestable.alignment = 0, + } + }, +}; + +static struct lttng_type lttng_pollfd_elem = { + .atype = atype_struct_nestable, + .u.struct_nestable.nr_fields = ARRAY_SIZE(lttng_pollfd_fields), + .u.struct_nestable.fields = lttng_pollfd_fields, + .u.struct_nestable.alignment = 0, +}; +#endif /* ONCE_LTTNG_TRACE_POLL_H */ + +#define LTTNG_SYSCALL_POLL_locvar \ + unsigned int fds_length, fds_max_len, alloc_fds; \ + struct pollfd *fds; \ + uint8_t overflow; + +#define LTTNG_SYSCALL_POLL_code_pre \ + BUILD_BUG_ON(((ARRAY_SIZE(lttng_pollfd_flag_fields) - 1) + \ + POLL_FLAGS_PADDING_SIZE) != \ + sizeof(uint8_t) * BITS_PER_BYTE); \ + tp_locvar->fds = NULL; \ + tp_locvar->overflow = 0; \ + \ + sc_in( \ + if (nfds > PAGE_SIZE / sizeof(struct pollfd)) { \ + tp_locvar->fds_length = PAGE_SIZE / sizeof(struct pollfd); \ + tp_locvar->fds_max_len = PAGE_SIZE / sizeof(struct pollfd); \ + tp_locvar->overflow = 1; \ + } else { \ + tp_locvar->fds_length = nfds; \ + tp_locvar->fds_max_len = nfds; \ + } \ + tp_locvar->alloc_fds = tp_locvar->fds_length * sizeof(struct pollfd); \ + ) \ + /* \ + * On exit, the number of active FDs is determined by ret, \ + * nfds stays the same as the entry, but we only want to \ + * output the FDs that are relevant. \ + */ \ + sc_out( \ + if (ret <= 0 || ret > nfds) \ + goto error; \ + \ + if (nfds > PAGE_SIZE / sizeof(struct pollfd)) { \ + tp_locvar->fds_length = PAGE_SIZE / sizeof(struct pollfd); \ + tp_locvar->fds_max_len = PAGE_SIZE / sizeof(struct pollfd); \ + tp_locvar->overflow = 1; \ + } else { \ + tp_locvar->fds_length = ret; \ + tp_locvar->fds_max_len = nfds; \ + } \ + tp_locvar->alloc_fds = tp_locvar->fds_max_len * sizeof(struct pollfd); \ + ) \ + { \ + int err; \ + \ + tp_locvar->fds = lttng_tp_mempool_alloc(tp_locvar->alloc_fds); \ + if (!tp_locvar->fds) \ + goto error; \ + err = lib_ring_buffer_copy_from_user_check_nofault( \ + tp_locvar->fds, ufds, tp_locvar->alloc_fds); \ + if (err != 0) \ + goto error; \ + } \ + goto end; \ + \ +error: \ + tp_locvar->fds_length = 0; \ + tp_locvar->fds_max_len = 0; \ +end: \ + ; + +#define LTTNG_SYSCALL_POLL_fds_field \ + sc_in( \ + ctf_custom_field( \ + ctf_custom_type( \ + { \ + .atype = atype_sequence_nestable, \ + .u.sequence_nestable.length_name = "fds_length", \ + .u.sequence_nestable.elem_type = <tng_pollfd_elem, \ + } \ + ), \ + fds, \ + ctf_custom_code( \ + uint32_t i; \ + \ + ctf_align(int) /* Align on largest field in struct. */ \ + for (i = 0; i < tp_locvar->fds_length; i++) { \ + ctf_integer_type(int, tp_locvar->fds[i].fd) \ + ctf_integer_type(short, tp_locvar->fds[i].events) \ + ctf_integer_bitfield_type(uint8_t, \ + (uint8_t) tp_locvar->fds[i].events) \ + } \ + ) \ + ) \ + ) \ + sc_out( \ + ctf_custom_field( \ + ctf_custom_type( \ + { \ + .atype = atype_sequence_nestable, \ + .u.sequence_nestable.length_name = "fds_length", \ + .u.sequence_nestable.elem_type = <tng_pollfd_elem, \ + } \ + ), \ + fds, \ + ctf_custom_code( \ + unsigned int i, nr = 0; \ + \ + ctf_align(int) /* Align on largest field in struct. */ \ + /* \ + * Iterate over the complete array, but only output \ + * "ret" active FDs. \ + */ \ + for (i = 0; i < tp_locvar->fds_max_len; i++) { \ + if (!tp_locvar->fds[i].revents) \ + continue; \ + if (nr++ >= tp_locvar->fds_length) \ + break; \ + ctf_integer_type(int, tp_locvar->fds[i].fd) \ + ctf_integer_type(short, tp_locvar->fds[i].revents) \ + ctf_integer_bitfield_type(uint8_t, \ + (uint8_t) tp_locvar->fds[i].revents) \ + } \ + /* \ + * If there is a discrepancy between ret and the \ + * content of revents (e.g. caused by userspace corrupting \ + * the array from a concurrent thread), we have to output \ + * zeros to keep the trace readable. \ + */ \ + for (i = nr; i < tp_locvar->fds_length; i++) { \ + ctf_integer_type(int, 0) \ + ctf_integer_type(short, 0) \ + ctf_integer_bitfield_type(uint8_t, 0) \ + } \ + ) \ + ) \ + ) + +#define LTTNG_SYSCALL_POLL_code_post \ + lttng_tp_mempool_free(tp_locvar->fds); + +#if defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM) +#define OVERRIDE_32_poll +#define OVERRIDE_64_poll +SC_LTTNG_TRACEPOINT_EVENT_CODE(poll, + TP_PROTO(sc_exit(long ret,) struct pollfd __user * ufds, + unsigned int nfds, int timeout_msecs), + TP_ARGS(sc_exit(ret,) ufds, nfds, timeout_msecs), + TP_locvar( + LTTNG_SYSCALL_POLL_locvar + ), + TP_code_pre( + LTTNG_SYSCALL_POLL_code_pre + ), + TP_FIELDS( + sc_exit(ctf_integer(long, ret, ret)) + sc_in(ctf_integer(int, timeout_msecs, timeout_msecs)) + sc_inout(ctf_integer(unsigned int, nfds, nfds)) + sc_inout(ctf_integer(unsigned int, fds_length, tp_locvar->fds_length)) + sc_in(ctf_integer(uint8_t, overflow, tp_locvar->overflow)) + LTTNG_SYSCALL_POLL_fds_field + ), + TP_code_post( + LTTNG_SYSCALL_POLL_code_post + ) +) +#endif /* defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM) */ + +#if defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM) +#define OVERRIDE_32_ppoll +#define OVERRIDE_64_ppoll +SC_LTTNG_TRACEPOINT_EVENT_CODE(ppoll, + TP_PROTO(sc_exit(long ret,) struct pollfd __user * ufds, + unsigned int nfds, struct timespec * tsp, const sigset_t * sigmask, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) ufds, nfds, tsp, sigmask, sigsetsize), + TP_locvar( + LTTNG_SYSCALL_POLL_locvar + ), + TP_code_pre( + LTTNG_SYSCALL_POLL_code_pre + ), + TP_FIELDS( + sc_exit(ctf_integer(long, ret, ret)) + sc_in(ctf_integer(struct timespec *, tsp, tsp)) + sc_in(ctf_integer(const sigset_t *, sigmask, sigmask)) + sc_in(ctf_integer(size_t, sigsetsize, sigsetsize)) + sc_inout(ctf_integer(unsigned int, nfds, nfds)) + sc_inout(ctf_integer(unsigned int, fds_length, tp_locvar->fds_length)) + sc_inout(ctf_integer(uint8_t, overflow, tp_locvar->overflow)) + LTTNG_SYSCALL_POLL_fds_field + ), + TP_code_post( + LTTNG_SYSCALL_POLL_code_post + ) +) +#endif /* defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM) */ + +#include + +SC_LTTNG_TRACEPOINT_ENUM(lttng_epoll_op, + TP_ENUM_VALUES( + ctf_enum_value("EPOLL_CTL_ADD", EPOLL_CTL_ADD) + ctf_enum_value("EPOLL_CTL_DEL", EPOLL_CTL_DEL) + ctf_enum_value("EPOLL_CTL_MOD", EPOLL_CTL_MOD) + ) +) + +#ifndef ONCE_LTTNG_TRACE_EPOLL_CTL_H +#define ONCE_LTTNG_TRACE_EPOLL_CTL_H + +#define LTTNG_EPOLL_NRFLAGS (POLLHUP + 1) +#define EPOLL_FLAGS_PADDING_SIZE (sizeof(uint8_t) * BITS_PER_BYTE) - \ + ilog2(LTTNG_EPOLL_NRFLAGS - 1) + +/* + * Only extract the values specified by iBCS2 for now. + */ +static struct lttng_event_field lttng_epoll_ctl_events_fields[] = { + /* 0x0001 */ + [ilog2(POLLIN)] = { + .name = "EPOLLIN", + .type = __type_integer(int, 1, 1, 0, __LITTLE_ENDIAN, 10, none), + }, + /* 0x0002 */ + [ilog2(POLLPRI)] = { + .name = "EPOLLPRI", + .type = __type_integer(int, 1, 1, 0, __LITTLE_ENDIAN, 10, none), + }, + /* 0x0004 */ + [ilog2(POLLOUT)] = { + .name = "EPOLLOUT", + .type = __type_integer(int, 1, 1, 0, __LITTLE_ENDIAN, 10, none), + }, + /* 0x0008 */ + [ilog2(POLLERR)] = { + .name = "EPOLLERR", + .type = __type_integer(int, 1, 1, 0, __LITTLE_ENDIAN, 10, none), + }, + /* 0x0010 */ + [ilog2(POLLHUP)] = { + .name = "EPOLLHUP", + .type = __type_integer(int, 1, 1, 0, __LITTLE_ENDIAN, 10, none), + }, + [ilog2(LTTNG_EPOLL_NRFLAGS)] = { + .name = "padding", + .type = __type_integer(int, EPOLL_FLAGS_PADDING_SIZE, 1, 0, + __LITTLE_ENDIAN, 10, none), + }, + +}; + +static struct lttng_event_field lttng_epoll_data_fields[] = { + [0] = { + .name = "u64", + .type = __type_integer(uint64_t, 0, 0, 0, __BYTE_ORDER, 16, none), + }, + [1] = { + .name = "fd", + .type = __type_integer(int, 0, 0, 0, __BYTE_ORDER, 10, none), + }, +}; + +static struct lttng_event_field epoll_ctl_fields[] = { + [0] = { + .name = "data_union", + .type = { + .atype = atype_struct_nestable, + .u.struct_nestable.nr_fields = ARRAY_SIZE(lttng_epoll_data_fields), + .u.struct_nestable.fields = lttng_epoll_data_fields, + .u.struct_nestable.alignment = 0, + } + }, + [1] = { + .name = "raw_events", + .type = __type_integer(uint32_t, 0, 0, 0, __BYTE_ORDER, 16, none), + }, + [2] = { + .name = "events", + .type = { + .atype = atype_struct_nestable, + .u.struct_nestable.nr_fields = ARRAY_SIZE(lttng_epoll_ctl_events_fields), + .u.struct_nestable.fields = lttng_epoll_ctl_events_fields, + .u.struct_nestable.alignment = 0, + } + }, +}; +#endif /* ONCE_LTTNG_TRACE_EPOLL_CTL_H */ + +#if defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM) +#define OVERRIDE_32_epoll_ctl +#define OVERRIDE_64_epoll_ctl +SC_LTTNG_TRACEPOINT_EVENT_CODE(epoll_ctl, + TP_PROTO(sc_exit(long ret,) int epfd, int op, int fd, + struct epoll_event __user * uevent), + TP_ARGS(sc_exit(ret,) epfd, op, fd, uevent), + TP_locvar( + struct epoll_event event; + int err; + ), + TP_code_pre( + tp_locvar->err = lib_ring_buffer_copy_from_user_check_nofault( + &tp_locvar->event, uevent, sizeof(struct epoll_event)); + ), + TP_FIELDS( + sc_exit(ctf_integer(long, ret, ret)) + sc_in(ctf_integer(int, epfd, epfd)) + sc_in(ctf_enum(lttng_epoll_op, int, op_enum, op)) + sc_in(ctf_integer(int, fd, fd)) + sc_in( + ctf_custom_field( + ctf_custom_type( + { + .atype = atype_struct_nestable, + .u.struct_nestable.nr_fields = ARRAY_SIZE(epoll_ctl_fields), + .u.struct_nestable.fields = epoll_ctl_fields, + .u.struct_nestable.alignment = 0, + } + ), + event, + ctf_custom_code( + ctf_align(uint64_t) + if (!tp_locvar->err) { + ctf_integer_type(uint64_t, tp_locvar->event.data) + ctf_integer_type(int, tp_locvar->event.data) + ctf_integer_bitfield_type(uint32_t, + tp_locvar->event.events) + ctf_integer_bitfield_type(uint8_t, + (uint8_t) tp_locvar->event.events) + } else { + ctf_integer_type(uint64_t, 0) + ctf_integer_type(int, 0) + ctf_integer_bitfield_type(uint32_t, 0) + ctf_integer_bitfield_type(uint8_t, 0) + } + ) + ) + ) + ), + TP_code_post() +) +#endif /* defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM) */ + +#ifndef ONCE_LTTNG_TRACE_EPOLL_H +#define ONCE_LTTNG_TRACE_EPOLL_H + +static struct lttng_event_field lttng_epoll_wait_fields[] = { + [0] = { + .name = "data_union", + .type = { + .atype = atype_struct_nestable, + .u.struct_nestable.nr_fields = ARRAY_SIZE(lttng_epoll_data_fields), + .u.struct_nestable.fields = lttng_epoll_data_fields, + .u.struct_nestable.alignment = 0, + } + }, + [1] = { + .name = "raw_events", + .type = __type_integer(uint32_t, 0, 0, 0, __BYTE_ORDER, 16, none), + }, + [2] = { + .name = "events", + .type = { + .atype = atype_struct_nestable, + .u.struct_nestable.nr_fields = ARRAY_SIZE(lttng_epoll_ctl_events_fields), + .u.struct_nestable.fields = lttng_epoll_ctl_events_fields, + .u.struct_nestable.alignment = 0, + } + }, +}; + +static struct lttng_type lttng_epoll_wait_elem = { + .atype = atype_struct_nestable, + .u.struct_nestable.nr_fields = ARRAY_SIZE(lttng_epoll_wait_fields), + .u.struct_nestable.fields = lttng_epoll_wait_fields, + .u.struct_nestable.alignment = 0, +}; + +#endif /* ONCE_LTTNG_TRACE_EPOLL_H */ + +#define LTTNG_SYSCALL_EPOLL_WAIT_locvar \ + sc_out( \ + unsigned int fds_length; \ + uint8_t overflow; \ + struct epoll_event *events; \ + ) + +#define LTTNG_SYSCALL_EPOLL_WAIT_code_pre \ + BUILD_BUG_ON(((ARRAY_SIZE(lttng_epoll_ctl_events_fields) - 1) + \ + EPOLL_FLAGS_PADDING_SIZE) != \ + sizeof(uint8_t) * BITS_PER_BYTE); \ + sc_out({ \ + int err; \ + unsigned long maxalloc; \ + \ + tp_locvar->fds_length = 0; \ + tp_locvar->events = NULL; \ + tp_locvar->overflow = 0; \ + \ + if (maxevents <= 0 || ret <= 0 || ret > maxevents) \ + goto skip_code; \ + \ + if (maxevents > PAGE_SIZE / sizeof(struct epoll_event)) { \ + maxalloc = PAGE_SIZE / sizeof(struct epoll_event); \ + } else { \ + maxalloc = maxevents; \ + } \ + \ + if (ret > maxalloc) { \ + tp_locvar->fds_length = maxalloc; \ + tp_locvar->overflow = 1; \ + } else { \ + tp_locvar->fds_length = ret; \ + } \ + \ + tp_locvar->events = lttng_tp_mempool_alloc( \ + maxalloc * sizeof(struct epoll_event)); \ + if (!tp_locvar->events) { \ + tp_locvar->fds_length = 0; \ + goto skip_code; \ + } \ + \ + err = lib_ring_buffer_copy_from_user_check_nofault( \ + tp_locvar->events, uevents, \ + maxalloc * sizeof(struct epoll_event)); \ + if (err != 0) \ + tp_locvar->fds_length = 0; \ + } \ + skip_code: \ + ) + +#define LTTNG_SYSCALL_EPOLL_WAIT_fds_field \ + ctf_custom_field( \ + ctf_custom_type( \ + { \ + .atype = atype_sequence_nestable, \ + .u.sequence_nestable.length_name = \ + "fds_length", \ + .u.sequence_nestable.elem_type = \ + <tng_epoll_wait_elem, \ + } \ + ), \ + fds, \ + ctf_custom_code( \ + uint32_t i; \ + \ + ctf_align(uint64_t) \ + for (i = 0; i < tp_locvar->fds_length; i++) { \ + ctf_integer_type(uint64_t, tp_locvar->events[i].data) \ + ctf_integer_type(int, tp_locvar->events[i].data) \ + ctf_integer_bitfield_type(uint32_t, \ + tp_locvar->events[i].events) \ + ctf_integer_bitfield_type(uint8_t, \ + (uint8_t) tp_locvar->events[i].events) \ + } \ + ) \ + ) + +#define LTTNG_SYSCALL_EPOLL_WAIT_code_post \ + sc_out( \ + lttng_tp_mempool_free(tp_locvar->events); \ + ) + + +#if defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM) +#define OVERRIDE_32_epoll_wait +#define OVERRIDE_64_epoll_wait +SC_LTTNG_TRACEPOINT_EVENT_CODE(epoll_wait, + TP_PROTO(sc_exit(long ret,) int epfd, struct epoll_event __user * uevents, + int maxevents, int timeout), + TP_ARGS(sc_exit(ret,) epfd, uevents, maxevents, timeout), + TP_locvar( + LTTNG_SYSCALL_EPOLL_WAIT_locvar + ), + TP_code_pre( + LTTNG_SYSCALL_EPOLL_WAIT_code_pre + ), + TP_FIELDS( + sc_exit(ctf_integer(long, ret, ret)) + sc_in(ctf_integer(int, epfd, epfd)) + sc_in(ctf_integer(int, maxevents, maxevents)) + sc_in(ctf_integer(int, timeout, timeout)) + sc_out(ctf_integer(unsigned int, fds_length, tp_locvar->fds_length)) + sc_out(ctf_integer(uint8_t, overflow, tp_locvar->overflow)) + sc_out( + LTTNG_SYSCALL_EPOLL_WAIT_fds_field + ) + ), + TP_code_post( + LTTNG_SYSCALL_EPOLL_WAIT_code_post + ) +) +#endif /* defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM) */ + +#if defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM) +#define OVERRIDE_32_epoll_pwait +#define OVERRIDE_64_epoll_pwait +SC_LTTNG_TRACEPOINT_EVENT_CODE(epoll_pwait, + TP_PROTO(sc_exit(long ret,) int epfd, struct epoll_event __user * uevents, + int maxevents, int timeout, const sigset_t __user * sigmask, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) epfd, uevents, maxevents, timeout, sigmask, sigsetsize), + TP_locvar( + LTTNG_SYSCALL_EPOLL_WAIT_locvar + ), + TP_code_pre( + LTTNG_SYSCALL_EPOLL_WAIT_code_pre + ), + TP_FIELDS( + sc_exit(ctf_integer(long, ret, ret)) + sc_in(ctf_integer(int, epfd, epfd)) + sc_in(ctf_integer(int, maxevents, maxevents)) + sc_in(ctf_integer(int, timeout, timeout)) + sc_in(ctf_integer_hex(const sigset_t *, sigmask, sigmask)) + sc_in(ctf_integer(size_t, sigsetsize, sigsetsize)) + sc_out(ctf_integer(unsigned int, fds_length, tp_locvar->fds_length)) + sc_out(ctf_integer(uint8_t, overflow, tp_locvar->overflow)) + sc_out( + LTTNG_SYSCALL_EPOLL_WAIT_fds_field + ) + ), + TP_code_post( + LTTNG_SYSCALL_EPOLL_WAIT_code_post + ) +) +#endif /* defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM) */ + +#if (defined(CONFIG_X86_64) && !defined(LTTNG_SC_COMPAT)) || defined(CONFIG_ARM64) || defined(CONFIG_ARM) +#define OVERRIDE_32_socketpair +#define OVERRIDE_64_socketpair +SC_LTTNG_TRACEPOINT_EVENT(socketpair, + TP_PROTO(sc_exit(long ret,) int family, int type, int protocol, int *usockvec), + TP_ARGS(sc_exit(ret,) family, type, protocol, usockvec), + TP_FIELDS( + sc_exit(ctf_integer(long, ret, ret)) + sc_in(ctf_integer(int, family, family)) + sc_in(ctf_integer(int, type, type)) + sc_in(ctf_integer(int, protocol, protocol)) + sc_out(ctf_user_array(int, socket, usockvec, 2)) + ) +) +#endif /* (defined(CONFIG_X86_64) && !defined(LTTNG_SC_COMPAT)) || defined(CONFIG_ARM64) || defined(CONFIG_ARM) */ + +/* + * Enumeration of the open flags, as described in the 'open' + * system call man page. + */ +SC_LTTNG_TRACEPOINT_ENUM(lttng_file_status_flags, + TP_ENUM_VALUES( + ctf_enum_value("O_RDONLY", O_RDONLY) + ctf_enum_value("O_WRONLY", O_WRONLY) + ctf_enum_value("O_RDWR", O_RDWR) + ctf_enum_value("O_CREAT", O_CREAT) + ctf_enum_value("O_EXCL", O_EXCL) + ctf_enum_value("O_NOCTTY", O_NOCTTY) + ctf_enum_value("O_TRUNC", O_TRUNC) + ctf_enum_value("O_APPEND", O_APPEND) + ctf_enum_value("O_NONBLOCK", O_NONBLOCK) + ctf_enum_value("O_DSYNC", O_DSYNC) + ctf_enum_value("FASYNC", FASYNC) + ctf_enum_value("O_DIRECT", O_DIRECT) + ctf_enum_value("O_LARGEFILE", O_LARGEFILE) + ctf_enum_value("O_DIRECTORY", O_DIRECTORY) + ctf_enum_value("O_NOFOLLOW", O_NOFOLLOW) + ctf_enum_value("O_NOATIME", O_NOATIME) + ctf_enum_value("O_CLOEXEC", O_CLOEXEC) + ctf_enum_value("O_SYNC", __O_SYNC) + ctf_enum_value("O_PATH", O_PATH) + ctf_enum_value("O_TMPFILE", __O_TMPFILE) + ) +) + +/* + * Enumeration of the open flags, as described in the 'open' + * system call man page. + */ +SC_LTTNG_TRACEPOINT_ENUM(lttng_file_mode, + TP_ENUM_VALUES( + ctf_enum_value("S_IRWXU", S_IRWXU) + ctf_enum_value("S_IRUSR", S_IRUSR) + ctf_enum_value("S_IWUSR", S_IWUSR) + ctf_enum_value("S_IXUSR", S_IXUSR) + ctf_enum_value("S_IRWXG", S_IRWXG) + ctf_enum_value("S_IRGRP", S_IRGRP) + ctf_enum_value("S_IWGRP", S_IWGRP) + ctf_enum_value("S_IXGRP", S_IXGRP) + ctf_enum_value("S_IRWXO", S_IRWXO) + ctf_enum_value("S_IROTH", S_IROTH) + ctf_enum_value("S_IWOTH", S_IWOTH) + ctf_enum_value("S_IXOTH", S_IXOTH) + ctf_enum_value("S_ISUID", S_ISUID) + ctf_enum_value("S_ISGID", S_ISGID) + ctf_enum_value("S_ISVTX", S_ISVTX) + ) +) + +#define OVERRIDE_32_openat +#define OVERRIDE_64_openat +SC_LTTNG_TRACEPOINT_EVENT(openat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, int flags, umode_t mode), + TP_ARGS(sc_exit(ret,) dfd, filename, flags, mode), + TP_FIELDS( + sc_exit(ctf_integer(long, ret, ret)) + sc_in(ctf_integer(int, dfd, dfd)) + sc_in(ctf_user_string(filename, filename)) + sc_in(ctf_enum(lttng_file_status_flags, int, flags, flags)) + sc_in(ctf_enum(lttng_file_mode, umode_t, mode, mode)) + ) +) + +#define OVERRIDE_32_open +#define OVERRIDE_64_open +SC_LTTNG_TRACEPOINT_EVENT(open, + TP_PROTO(sc_exit(long ret,) const char * filename, int flags, umode_t mode), + TP_ARGS(sc_exit(ret,) filename, flags, mode), + TP_FIELDS( + sc_exit(ctf_integer(long, ret, ret)) + sc_in(ctf_user_string(filename, filename)) + sc_in(ctf_enum(lttng_file_status_flags, int, flags, flags)) + sc_in(ctf_enum(lttng_file_mode, umode_t, mode, mode)) + ) +) + +#endif /* CREATE_SYSCALL_TABLE */ diff --git a/include/instrumentation/syscalls/headers/syscalls_unknown.h b/include/instrumentation/syscalls/headers/syscalls_unknown.h new file mode 100644 index 00000000..4e9d8608 --- /dev/null +++ b/include/instrumentation/syscalls/headers/syscalls_unknown.h @@ -0,0 +1,55 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ + +#if !defined(_TRACE_SYSCALLS_UNKNOWN_H) || defined(TRACE_HEADER_MULTI_READ) +#define _TRACE_SYSCALLS_UNKNOWN_H + +#include +#include + +#define UNKNOWN_SYSCALL_NRARGS 6 + +#undef TP_PROBE_CB +#define TP_PROBE_CB(_template) &syscall_entry_probe + +LTTNG_TRACEPOINT_EVENT(syscall_entry_unknown, + TP_PROTO(int id, unsigned long *args), + TP_ARGS(id, args), + TP_FIELDS( + ctf_integer(int, id, id) + ctf_array(unsigned long, args, args, UNKNOWN_SYSCALL_NRARGS) + ) +) +LTTNG_TRACEPOINT_EVENT(compat_syscall_entry_unknown, + TP_PROTO(int id, unsigned long *args), + TP_ARGS(id, args), + TP_FIELDS( + ctf_integer(int, id, id) + ctf_array(unsigned long, args, args, UNKNOWN_SYSCALL_NRARGS) + ) +) + +#undef TP_PROBE_CB +#define TP_PROBE_CB(_template) &syscall_exit_probe + +LTTNG_TRACEPOINT_EVENT(syscall_exit_unknown, + TP_PROTO(int id, long ret, unsigned long *args), + TP_ARGS(id, ret, args), + TP_FIELDS( + ctf_integer(int, id, id) + ctf_integer(long, ret, ret) + ctf_array(unsigned long, args, args, UNKNOWN_SYSCALL_NRARGS) + ) +) +LTTNG_TRACEPOINT_EVENT(compat_syscall_exit_unknown, + TP_PROTO(int id, long ret, unsigned long *args), + TP_ARGS(id, ret, args), + TP_FIELDS( + ctf_integer(int, id, id) + ctf_integer(long, ret, ret) + ctf_array(unsigned long, args, args, UNKNOWN_SYSCALL_NRARGS) + ) +) +#endif /* _TRACE_SYSCALLS_UNKNOWN_H */ + +/* This part must be outside protection */ +#include diff --git a/include/instrumentation/syscalls/headers/x86-32-syscalls_integers.h b/include/instrumentation/syscalls/headers/x86-32-syscalls_integers.h new file mode 100644 index 00000000..4b1a5040 --- /dev/null +++ b/include/instrumentation/syscalls/headers/x86-32-syscalls_integers.h @@ -0,0 +1,1214 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ + +/* THIS FILE IS AUTO-GENERATED. DO NOT EDIT */ + +/* Generated from x86-32-syscalls 3.1.0-rc6 */ + +#ifndef CREATE_SYSCALL_TABLE + +#if !defined(_TRACE_SYSCALLS_INTEGERS_H) || defined(TRACE_HEADER_MULTI_READ) +#define _TRACE_SYSCALLS_INTEGERS_H + +#include +#include +#include "x86-32-syscalls_integers_override.h" +#include "syscalls_integers_override.h" + +#ifdef SC_ENTER +SC_LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(syscalls_noargs, + TP_FIELDS() +) +#ifndef OVERRIDE_32_restart_syscall +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, restart_syscall) +#endif +#ifndef OVERRIDE_32_getpid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getpid) +#endif +#ifndef OVERRIDE_32_getuid16 +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getuid16) +#endif +#ifndef OVERRIDE_32_pause +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, pause) +#endif +#ifndef OVERRIDE_32_sync +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, sync) +#endif +#ifndef OVERRIDE_32_getgid16 +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getgid16) +#endif +#ifndef OVERRIDE_32_geteuid16 +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, geteuid16) +#endif +#ifndef OVERRIDE_32_getegid16 +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getegid16) +#endif +#ifndef OVERRIDE_32_getppid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getppid) +#endif +#ifndef OVERRIDE_32_getpgrp +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getpgrp) +#endif +#ifndef OVERRIDE_32_setsid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, setsid) +#endif +#ifndef OVERRIDE_32_sgetmask +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, sgetmask) +#endif +#ifndef OVERRIDE_32_vhangup +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, vhangup) +#endif +#ifndef OVERRIDE_32_munlockall +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, munlockall) +#endif +#ifndef OVERRIDE_32_sched_yield +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, sched_yield) +#endif +#ifndef OVERRIDE_32_getuid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getuid) +#endif +#ifndef OVERRIDE_32_getgid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getgid) +#endif +#ifndef OVERRIDE_32_geteuid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, geteuid) +#endif +#ifndef OVERRIDE_32_getegid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getegid) +#endif +#ifndef OVERRIDE_32_gettid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, gettid) +#endif +#ifndef OVERRIDE_32_inotify_init +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, inotify_init) +#endif +#else /* #ifdef SC_ENTER */ +#ifndef OVERRIDE_32_restart_syscall +SC_LTTNG_TRACEPOINT_EVENT(restart_syscall, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_getpid +SC_LTTNG_TRACEPOINT_EVENT(getpid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_getuid16 +SC_LTTNG_TRACEPOINT_EVENT(getuid16, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_pause +SC_LTTNG_TRACEPOINT_EVENT(pause, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_sync +SC_LTTNG_TRACEPOINT_EVENT(sync, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_getgid16 +SC_LTTNG_TRACEPOINT_EVENT(getgid16, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_geteuid16 +SC_LTTNG_TRACEPOINT_EVENT(geteuid16, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_getegid16 +SC_LTTNG_TRACEPOINT_EVENT(getegid16, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_getppid +SC_LTTNG_TRACEPOINT_EVENT(getppid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_getpgrp +SC_LTTNG_TRACEPOINT_EVENT(getpgrp, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_setsid +SC_LTTNG_TRACEPOINT_EVENT(setsid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_sgetmask +SC_LTTNG_TRACEPOINT_EVENT(sgetmask, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_vhangup +SC_LTTNG_TRACEPOINT_EVENT(vhangup, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_munlockall +SC_LTTNG_TRACEPOINT_EVENT(munlockall, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_sched_yield +SC_LTTNG_TRACEPOINT_EVENT(sched_yield, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_getuid +SC_LTTNG_TRACEPOINT_EVENT(getuid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_getgid +SC_LTTNG_TRACEPOINT_EVENT(getgid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_geteuid +SC_LTTNG_TRACEPOINT_EVENT(geteuid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_getegid +SC_LTTNG_TRACEPOINT_EVENT(getegid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_gettid +SC_LTTNG_TRACEPOINT_EVENT(gettid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_32_inotify_init +SC_LTTNG_TRACEPOINT_EVENT(inotify_init, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#endif /* else #ifdef SC_ENTER */ +#ifndef OVERRIDE_32_exit +SC_LTTNG_TRACEPOINT_EVENT(exit, + TP_PROTO(sc_exit(long ret,) int error_code), + TP_ARGS(sc_exit(ret,) error_code), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, error_code, error_code))) +) +#endif +#ifndef OVERRIDE_32_close +SC_LTTNG_TRACEPOINT_EVENT(close, + TP_PROTO(sc_exit(long ret,) unsigned int fd), + TP_ARGS(sc_exit(ret,) fd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) +) +#endif +#ifndef OVERRIDE_32_setuid16 +SC_LTTNG_TRACEPOINT_EVENT(setuid16, + TP_PROTO(sc_exit(long ret,) old_uid_t uid), + TP_ARGS(sc_exit(ret,) uid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(old_uid_t, uid, uid))) +) +#endif +#ifndef OVERRIDE_32_alarm +SC_LTTNG_TRACEPOINT_EVENT(alarm, + TP_PROTO(sc_exit(long ret,) unsigned int seconds), + TP_ARGS(sc_exit(ret,) seconds), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, seconds, seconds))) +) +#endif +#ifndef OVERRIDE_32_nice +SC_LTTNG_TRACEPOINT_EVENT(nice, + TP_PROTO(sc_exit(long ret,) int increment), + TP_ARGS(sc_exit(ret,) increment), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, increment, increment))) +) +#endif +#ifndef OVERRIDE_32_dup +SC_LTTNG_TRACEPOINT_EVENT(dup, + TP_PROTO(sc_exit(long ret,) unsigned int fildes), + TP_ARGS(sc_exit(ret,) fildes), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fildes, fildes))) +) +#endif +#ifndef OVERRIDE_32_brk +SC_LTTNG_TRACEPOINT_EVENT(brk, + TP_PROTO(sc_exit(long ret,) unsigned long brk), + TP_ARGS(sc_exit(ret,) brk), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, brk, brk))) +) +#endif +#ifndef OVERRIDE_32_setgid16 +SC_LTTNG_TRACEPOINT_EVENT(setgid16, + TP_PROTO(sc_exit(long ret,) old_gid_t gid), + TP_ARGS(sc_exit(ret,) gid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(old_gid_t, gid, gid))) +) +#endif +#ifndef OVERRIDE_32_umask +SC_LTTNG_TRACEPOINT_EVENT(umask, + TP_PROTO(sc_exit(long ret,) int mask), + TP_ARGS(sc_exit(ret,) mask), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, mask, mask))) +) +#endif +#ifndef OVERRIDE_32_ssetmask +SC_LTTNG_TRACEPOINT_EVENT(ssetmask, + TP_PROTO(sc_exit(long ret,) int newmask), + TP_ARGS(sc_exit(ret,) newmask), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, newmask, newmask))) +) +#endif +#ifndef OVERRIDE_32_fsync +SC_LTTNG_TRACEPOINT_EVENT(fsync, + TP_PROTO(sc_exit(long ret,) unsigned int fd), + TP_ARGS(sc_exit(ret,) fd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) +) +#endif +#ifndef OVERRIDE_32_getpgid +SC_LTTNG_TRACEPOINT_EVENT(getpgid, + TP_PROTO(sc_exit(long ret,) pid_t pid), + TP_ARGS(sc_exit(ret,) pid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid))) +) +#endif +#ifndef OVERRIDE_32_fchdir +SC_LTTNG_TRACEPOINT_EVENT(fchdir, + TP_PROTO(sc_exit(long ret,) unsigned int fd), + TP_ARGS(sc_exit(ret,) fd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) +) +#endif +#ifndef OVERRIDE_32_personality +SC_LTTNG_TRACEPOINT_EVENT(personality, + TP_PROTO(sc_exit(long ret,) unsigned int personality), + TP_ARGS(sc_exit(ret,) personality), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, personality, personality))) +) +#endif +#ifndef OVERRIDE_32_setfsuid16 +SC_LTTNG_TRACEPOINT_EVENT(setfsuid16, + TP_PROTO(sc_exit(long ret,) old_uid_t uid), + TP_ARGS(sc_exit(ret,) uid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(old_uid_t, uid, uid))) +) +#endif +#ifndef OVERRIDE_32_setfsgid16 +SC_LTTNG_TRACEPOINT_EVENT(setfsgid16, + TP_PROTO(sc_exit(long ret,) old_gid_t gid), + TP_ARGS(sc_exit(ret,) gid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(old_gid_t, gid, gid))) +) +#endif +#ifndef OVERRIDE_32_getsid +SC_LTTNG_TRACEPOINT_EVENT(getsid, + TP_PROTO(sc_exit(long ret,) pid_t pid), + TP_ARGS(sc_exit(ret,) pid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid))) +) +#endif +#ifndef OVERRIDE_32_fdatasync +SC_LTTNG_TRACEPOINT_EVENT(fdatasync, + TP_PROTO(sc_exit(long ret,) unsigned int fd), + TP_ARGS(sc_exit(ret,) fd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) +) +#endif +#ifndef OVERRIDE_32_mlockall +SC_LTTNG_TRACEPOINT_EVENT(mlockall, + TP_PROTO(sc_exit(long ret,) int flags), + TP_ARGS(sc_exit(ret,) flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_sched_getscheduler +SC_LTTNG_TRACEPOINT_EVENT(sched_getscheduler, + TP_PROTO(sc_exit(long ret,) pid_t pid), + TP_ARGS(sc_exit(ret,) pid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid))) +) +#endif +#ifndef OVERRIDE_32_sched_get_priority_max +SC_LTTNG_TRACEPOINT_EVENT(sched_get_priority_max, + TP_PROTO(sc_exit(long ret,) int policy), + TP_ARGS(sc_exit(ret,) policy), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, policy, policy))) +) +#endif +#ifndef OVERRIDE_32_sched_get_priority_min +SC_LTTNG_TRACEPOINT_EVENT(sched_get_priority_min, + TP_PROTO(sc_exit(long ret,) int policy), + TP_ARGS(sc_exit(ret,) policy), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, policy, policy))) +) +#endif +#ifndef OVERRIDE_32_setuid +SC_LTTNG_TRACEPOINT_EVENT(setuid, + TP_PROTO(sc_exit(long ret,) uid_t uid), + TP_ARGS(sc_exit(ret,) uid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, uid, uid))) +) +#endif +#ifndef OVERRIDE_32_setgid +SC_LTTNG_TRACEPOINT_EVENT(setgid, + TP_PROTO(sc_exit(long ret,) gid_t gid), + TP_ARGS(sc_exit(ret,) gid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, gid, gid))) +) +#endif +#ifndef OVERRIDE_32_setfsuid +SC_LTTNG_TRACEPOINT_EVENT(setfsuid, + TP_PROTO(sc_exit(long ret,) uid_t uid), + TP_ARGS(sc_exit(ret,) uid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, uid, uid))) +) +#endif +#ifndef OVERRIDE_32_setfsgid +SC_LTTNG_TRACEPOINT_EVENT(setfsgid, + TP_PROTO(sc_exit(long ret,) gid_t gid), + TP_ARGS(sc_exit(ret,) gid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, gid, gid))) +) +#endif +#ifndef OVERRIDE_32_io_destroy +SC_LTTNG_TRACEPOINT_EVENT(io_destroy, + TP_PROTO(sc_exit(long ret,) aio_context_t ctx), + TP_ARGS(sc_exit(ret,) ctx), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx, ctx))) +) +#endif +#ifndef OVERRIDE_32_exit_group +SC_LTTNG_TRACEPOINT_EVENT(exit_group, + TP_PROTO(sc_exit(long ret,) int error_code), + TP_ARGS(sc_exit(ret,) error_code), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, error_code, error_code))) +) +#endif +#ifndef OVERRIDE_32_epoll_create +SC_LTTNG_TRACEPOINT_EVENT(epoll_create, + TP_PROTO(sc_exit(long ret,) int size), + TP_ARGS(sc_exit(ret,) size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, size, size))) +) +#endif +#ifndef OVERRIDE_32_timer_getoverrun +SC_LTTNG_TRACEPOINT_EVENT(timer_getoverrun, + TP_PROTO(sc_exit(long ret,) timer_t timer_id), + TP_ARGS(sc_exit(ret,) timer_id), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id))) +) +#endif +#ifndef OVERRIDE_32_timer_delete +SC_LTTNG_TRACEPOINT_EVENT(timer_delete, + TP_PROTO(sc_exit(long ret,) timer_t timer_id), + TP_ARGS(sc_exit(ret,) timer_id), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id))) +) +#endif +#ifndef OVERRIDE_32_unshare +SC_LTTNG_TRACEPOINT_EVENT(unshare, + TP_PROTO(sc_exit(long ret,) unsigned long unshare_flags), + TP_ARGS(sc_exit(ret,) unshare_flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, unshare_flags, unshare_flags))) +) +#endif +#ifndef OVERRIDE_32_eventfd +SC_LTTNG_TRACEPOINT_EVENT(eventfd, + TP_PROTO(sc_exit(long ret,) unsigned int count), + TP_ARGS(sc_exit(ret,) count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, count, count))) +) +#endif +#ifndef OVERRIDE_32_epoll_create1 +SC_LTTNG_TRACEPOINT_EVENT(epoll_create1, + TP_PROTO(sc_exit(long ret,) int flags), + TP_ARGS(sc_exit(ret,) flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_inotify_init1 +SC_LTTNG_TRACEPOINT_EVENT(inotify_init1, + TP_PROTO(sc_exit(long ret,) int flags), + TP_ARGS(sc_exit(ret,) flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_syncfs +SC_LTTNG_TRACEPOINT_EVENT(syncfs, + TP_PROTO(sc_exit(long ret,) int fd), + TP_ARGS(sc_exit(ret,) fd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd))) +) +#endif +#ifndef OVERRIDE_32_kill +SC_LTTNG_TRACEPOINT_EVENT(kill, + TP_PROTO(sc_exit(long ret,) pid_t pid, int sig), + TP_ARGS(sc_exit(ret,) pid, sig), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig))) +) +#endif +#ifndef OVERRIDE_32_signal +SC_LTTNG_TRACEPOINT_EVENT(signal, + TP_PROTO(sc_exit(long ret,) int sig, __sighandler_t handler), + TP_ARGS(sc_exit(ret,) sig, handler), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, sig, sig)) sc_inout(ctf_integer(__sighandler_t, handler, handler))) +) +#endif +#ifndef OVERRIDE_32_setpgid +SC_LTTNG_TRACEPOINT_EVENT(setpgid, + TP_PROTO(sc_exit(long ret,) pid_t pid, pid_t pgid), + TP_ARGS(sc_exit(ret,) pid, pgid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(pid_t, pgid, pgid))) +) +#endif +#ifndef OVERRIDE_32_dup2 +SC_LTTNG_TRACEPOINT_EVENT(dup2, + TP_PROTO(sc_exit(long ret,) unsigned int oldfd, unsigned int newfd), + TP_ARGS(sc_exit(ret,) oldfd, newfd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, oldfd, oldfd)) sc_in(ctf_integer(unsigned int, newfd, newfd))) +) +#endif +#ifndef OVERRIDE_32_setreuid16 +SC_LTTNG_TRACEPOINT_EVENT(setreuid16, + TP_PROTO(sc_exit(long ret,) old_uid_t ruid, old_uid_t euid), + TP_ARGS(sc_exit(ret,) ruid, euid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(old_uid_t, ruid, ruid)) sc_inout(ctf_integer(old_uid_t, euid, euid))) +) +#endif +#ifndef OVERRIDE_32_setregid16 +SC_LTTNG_TRACEPOINT_EVENT(setregid16, + TP_PROTO(sc_exit(long ret,) old_gid_t rgid, old_gid_t egid), + TP_ARGS(sc_exit(ret,) rgid, egid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(old_gid_t, rgid, rgid)) sc_inout(ctf_integer(old_gid_t, egid, egid))) +) +#endif +#ifndef OVERRIDE_32_munmap +SC_LTTNG_TRACEPOINT_EVENT(munmap, + TP_PROTO(sc_exit(long ret,) unsigned long addr, size_t len), + TP_ARGS(sc_exit(ret,) addr, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, addr, addr)) sc_in(ctf_integer(size_t, len, len))) +) +#endif +#ifndef OVERRIDE_32_ftruncate +SC_LTTNG_TRACEPOINT_EVENT(ftruncate, + TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned long length), + TP_ARGS(sc_exit(ret,) fd, length), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned long, length, length))) +) +#endif +#ifndef OVERRIDE_32_fchmod +SC_LTTNG_TRACEPOINT_EVENT(fchmod, + TP_PROTO(sc_exit(long ret,) unsigned int fd, mode_t mode), + TP_ARGS(sc_exit(ret,) fd, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(mode_t, mode, mode))) +) +#endif +#ifndef OVERRIDE_32_getpriority +SC_LTTNG_TRACEPOINT_EVENT(getpriority, + TP_PROTO(sc_exit(long ret,) int which, int who), + TP_ARGS(sc_exit(ret,) which, who), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who))) +) +#endif +#ifndef OVERRIDE_32_bdflush +SC_LTTNG_TRACEPOINT_EVENT(bdflush, + TP_PROTO(sc_exit(long ret,) int func, long data), + TP_ARGS(sc_exit(ret,) func, data), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, func, func)) sc_inout(ctf_integer(long, data, data))) +) +#endif +#ifndef OVERRIDE_32_flock +SC_LTTNG_TRACEPOINT_EVENT(flock, + TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd), + TP_ARGS(sc_exit(ret,) fd, cmd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned int, cmd, cmd))) +) +#endif +#ifndef OVERRIDE_32_mlock +SC_LTTNG_TRACEPOINT_EVENT(mlock, + TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len), + TP_ARGS(sc_exit(ret,) start, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len))) +) +#endif +#ifndef OVERRIDE_32_munlock +SC_LTTNG_TRACEPOINT_EVENT(munlock, + TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len), + TP_ARGS(sc_exit(ret,) start, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len))) +) +#endif +#ifndef OVERRIDE_32_setreuid +SC_LTTNG_TRACEPOINT_EVENT(setreuid, + TP_PROTO(sc_exit(long ret,) uid_t ruid, uid_t euid), + TP_ARGS(sc_exit(ret,) ruid, euid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, ruid, ruid)) sc_in(ctf_integer(uid_t, euid, euid))) +) +#endif +#ifndef OVERRIDE_32_setregid +SC_LTTNG_TRACEPOINT_EVENT(setregid, + TP_PROTO(sc_exit(long ret,) gid_t rgid, gid_t egid), + TP_ARGS(sc_exit(ret,) rgid, egid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, rgid, rgid)) sc_in(ctf_integer(gid_t, egid, egid))) +) +#endif +#ifndef OVERRIDE_32_tkill +SC_LTTNG_TRACEPOINT_EVENT(tkill, + TP_PROTO(sc_exit(long ret,) pid_t pid, int sig), + TP_ARGS(sc_exit(ret,) pid, sig), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig))) +) +#endif +#ifndef OVERRIDE_32_ioprio_get +SC_LTTNG_TRACEPOINT_EVENT(ioprio_get, + TP_PROTO(sc_exit(long ret,) int which, int who), + TP_ARGS(sc_exit(ret,) which, who), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who))) +) +#endif +#ifndef OVERRIDE_32_inotify_rm_watch +SC_LTTNG_TRACEPOINT_EVENT(inotify_rm_watch, + TP_PROTO(sc_exit(long ret,) int fd, __s32 wd), + TP_ARGS(sc_exit(ret,) fd, wd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(__s32, wd, wd))) +) +#endif +#ifndef OVERRIDE_32_timerfd_create +SC_LTTNG_TRACEPOINT_EVENT(timerfd_create, + TP_PROTO(sc_exit(long ret,) int clockid, int flags), + TP_ARGS(sc_exit(ret,) clockid, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, clockid, clockid)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_eventfd2 +SC_LTTNG_TRACEPOINT_EVENT(eventfd2, + TP_PROTO(sc_exit(long ret,) unsigned int count, int flags), + TP_ARGS(sc_exit(ret,) count, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, count, count)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_fanotify_init +SC_LTTNG_TRACEPOINT_EVENT(fanotify_init, + TP_PROTO(sc_exit(long ret,) unsigned int flags, unsigned int event_f_flags), + TP_ARGS(sc_exit(ret,) flags, event_f_flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, flags, flags)) sc_in(ctf_integer(unsigned int, event_f_flags, event_f_flags))) +) +#endif +#ifndef OVERRIDE_32_setns +SC_LTTNG_TRACEPOINT_EVENT(setns, + TP_PROTO(sc_exit(long ret,) int fd, int nstype), + TP_ARGS(sc_exit(ret,) fd, nstype), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, nstype, nstype))) +) +#endif +#ifndef OVERRIDE_32_lseek +SC_LTTNG_TRACEPOINT_EVENT(lseek, + TP_PROTO(sc_exit(long ret,) unsigned int fd, off_t offset, unsigned int origin), + TP_ARGS(sc_exit(ret,) fd, offset, origin), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(off_t, offset, offset)) sc_in(ctf_integer(unsigned int, origin, origin))) +) +#endif +#ifndef OVERRIDE_32_ioctl +SC_LTTNG_TRACEPOINT_EVENT(ioctl, + TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd, unsigned long arg), + TP_ARGS(sc_exit(ret,) fd, cmd, arg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_inout(ctf_integer(unsigned long, arg, arg))) +) +#endif +#ifndef OVERRIDE_32_fcntl +SC_LTTNG_TRACEPOINT_EVENT(fcntl, + TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd, unsigned long arg), + TP_ARGS(sc_exit(ret,) fd, cmd, arg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_inout(ctf_integer(unsigned long, arg, arg))) +) +#endif +#ifndef OVERRIDE_32_fchown16 +SC_LTTNG_TRACEPOINT_EVENT(fchown16, + TP_PROTO(sc_exit(long ret,) unsigned int fd, old_uid_t user, old_gid_t group), + TP_ARGS(sc_exit(ret,) fd, user, group), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, fd, fd)) sc_inout(ctf_integer(old_uid_t, user, user)) sc_inout(ctf_integer(old_gid_t, group, group))) +) +#endif +#ifndef OVERRIDE_32_setpriority +SC_LTTNG_TRACEPOINT_EVENT(setpriority, + TP_PROTO(sc_exit(long ret,) int which, int who, int niceval), + TP_ARGS(sc_exit(ret,) which, who, niceval), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who)) sc_in(ctf_integer(int, niceval, niceval))) +) +#endif +#ifndef OVERRIDE_32_mprotect +SC_LTTNG_TRACEPOINT_EVENT(mprotect, + TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len, unsigned long prot), + TP_ARGS(sc_exit(ret,) start, len, prot), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned long, prot, prot))) +) +#endif +#ifndef OVERRIDE_32_sysfs +SC_LTTNG_TRACEPOINT_EVENT(sysfs, + TP_PROTO(sc_exit(long ret,) int option, unsigned long arg1, unsigned long arg2), + TP_ARGS(sc_exit(ret,) option, arg1, arg2), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, option, option)) sc_in(ctf_integer(unsigned long, arg1, arg1)) sc_in(ctf_integer(unsigned long, arg2, arg2))) +) +#endif +#ifndef OVERRIDE_32_msync +SC_LTTNG_TRACEPOINT_EVENT(msync, + TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len, int flags), + TP_ARGS(sc_exit(ret,) start, len, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_setresuid16 +SC_LTTNG_TRACEPOINT_EVENT(setresuid16, + TP_PROTO(sc_exit(long ret,) old_uid_t ruid, old_uid_t euid, old_uid_t suid), + TP_ARGS(sc_exit(ret,) ruid, euid, suid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(old_uid_t, ruid, ruid)) sc_inout(ctf_integer(old_uid_t, euid, euid)) sc_inout(ctf_integer(old_uid_t, suid, suid))) +) +#endif +#ifndef OVERRIDE_32_setresgid16 +SC_LTTNG_TRACEPOINT_EVENT(setresgid16, + TP_PROTO(sc_exit(long ret,) old_gid_t rgid, old_gid_t egid, old_gid_t sgid), + TP_ARGS(sc_exit(ret,) rgid, egid, sgid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(old_gid_t, rgid, rgid)) sc_inout(ctf_integer(old_gid_t, egid, egid)) sc_inout(ctf_integer(old_gid_t, sgid, sgid))) +) +#endif +#ifndef OVERRIDE_32_fchown +SC_LTTNG_TRACEPOINT_EVENT(fchown, + TP_PROTO(sc_exit(long ret,) unsigned int fd, uid_t user, gid_t group), + TP_ARGS(sc_exit(ret,) fd, user, group), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group))) +) +#endif +#ifndef OVERRIDE_32_setresuid +SC_LTTNG_TRACEPOINT_EVENT(setresuid, + TP_PROTO(sc_exit(long ret,) uid_t ruid, uid_t euid, uid_t suid), + TP_ARGS(sc_exit(ret,) ruid, euid, suid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, ruid, ruid)) sc_in(ctf_integer(uid_t, euid, euid)) sc_in(ctf_integer(uid_t, suid, suid))) +) +#endif +#ifndef OVERRIDE_32_setresgid +SC_LTTNG_TRACEPOINT_EVENT(setresgid, + TP_PROTO(sc_exit(long ret,) gid_t rgid, gid_t egid, gid_t sgid), + TP_ARGS(sc_exit(ret,) rgid, egid, sgid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, rgid, rgid)) sc_in(ctf_integer(gid_t, egid, egid)) sc_in(ctf_integer(gid_t, sgid, sgid))) +) +#endif +#ifndef OVERRIDE_32_madvise +SC_LTTNG_TRACEPOINT_EVENT(madvise, + TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len_in, int behavior), + TP_ARGS(sc_exit(ret,) start, len_in, behavior), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len_in, len_in)) sc_in(ctf_integer(int, behavior, behavior))) +) +#endif +#ifndef OVERRIDE_32_fcntl64 +SC_LTTNG_TRACEPOINT_EVENT(fcntl64, + TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd, unsigned long arg), + TP_ARGS(sc_exit(ret,) fd, cmd, arg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, fd, fd)) sc_inout(ctf_integer(unsigned int, cmd, cmd)) sc_inout(ctf_integer(unsigned long, arg, arg))) +) +#endif +#ifndef OVERRIDE_32_tgkill +SC_LTTNG_TRACEPOINT_EVENT(tgkill, + TP_PROTO(sc_exit(long ret,) pid_t tgid, pid_t pid, int sig), + TP_ARGS(sc_exit(ret,) tgid, pid, sig), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, tgid, tgid)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig))) +) +#endif +#ifndef OVERRIDE_32_ioprio_set +SC_LTTNG_TRACEPOINT_EVENT(ioprio_set, + TP_PROTO(sc_exit(long ret,) int which, int who, int ioprio), + TP_ARGS(sc_exit(ret,) which, who, ioprio), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who)) sc_in(ctf_integer(int, ioprio, ioprio))) +) +#endif +#ifndef OVERRIDE_32_dup3 +SC_LTTNG_TRACEPOINT_EVENT(dup3, + TP_PROTO(sc_exit(long ret,) unsigned int oldfd, unsigned int newfd, int flags), + TP_ARGS(sc_exit(ret,) oldfd, newfd, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, oldfd, oldfd)) sc_in(ctf_integer(unsigned int, newfd, newfd)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_ptrace +SC_LTTNG_TRACEPOINT_EVENT(ptrace, + TP_PROTO(sc_exit(long ret,) long request, long pid, unsigned long addr, unsigned long data), + TP_ARGS(sc_exit(ret,) request, pid, addr, data), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(long, request, request)) sc_in(ctf_integer(long, pid, pid)) sc_inout(ctf_integer(unsigned long, addr, addr)) sc_inout(ctf_integer(unsigned long, data, data))) +) +#endif +#ifndef OVERRIDE_32_tee +SC_LTTNG_TRACEPOINT_EVENT(tee, + TP_PROTO(sc_exit(long ret,) int fdin, int fdout, size_t len, unsigned int flags), + TP_ARGS(sc_exit(ret,) fdin, fdout, len, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fdin, fdin)) sc_in(ctf_integer(int, fdout, fdout)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_mremap +SC_LTTNG_TRACEPOINT_EVENT(mremap, + TP_PROTO(sc_exit(long ret,) unsigned long addr, unsigned long old_len, unsigned long new_len, unsigned long flags, unsigned long new_addr), + TP_ARGS(sc_exit(ret,) addr, old_len, new_len, flags, new_addr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, addr, addr)) sc_in(ctf_integer(unsigned long, old_len, old_len)) sc_in(ctf_integer(unsigned long, new_len, new_len)) sc_in(ctf_integer(unsigned long, flags, flags)) sc_in(ctf_integer(unsigned long, new_addr, new_addr))) +) +#endif +#ifndef OVERRIDE_32_prctl +SC_LTTNG_TRACEPOINT_EVENT(prctl, + TP_PROTO(sc_exit(long ret,) int option, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5), + TP_ARGS(sc_exit(ret,) option, arg2, arg3, arg4, arg5), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, option, option)) sc_inout(ctf_integer(unsigned long, arg2, arg2)) sc_in(ctf_integer(unsigned long, arg3, arg3)) sc_in(ctf_integer(unsigned long, arg4, arg4)) sc_in(ctf_integer(unsigned long, arg5, arg5))) +) +#endif +#ifndef OVERRIDE_32_remap_file_pages +SC_LTTNG_TRACEPOINT_EVENT(remap_file_pages, + TP_PROTO(sc_exit(long ret,) unsigned long start, unsigned long size, unsigned long prot, unsigned long pgoff, unsigned long flags), + TP_ARGS(sc_exit(ret,) start, size, prot, pgoff, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(unsigned long, size, size)) sc_in(ctf_integer(unsigned long, prot, prot)) sc_in(ctf_integer(unsigned long, pgoff, pgoff)) sc_in(ctf_integer(unsigned long, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_keyctl +SC_LTTNG_TRACEPOINT_EVENT(keyctl, + TP_PROTO(sc_exit(long ret,) int option, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5), + TP_ARGS(sc_exit(ret,) option, arg2, arg3, arg4, arg5), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, option, option)) sc_inout(ctf_integer(unsigned long, arg2, arg2)) sc_inout(ctf_integer(unsigned long, arg3, arg3)) sc_inout(ctf_integer(unsigned long, arg4, arg4)) sc_inout(ctf_integer(unsigned long, arg5, arg5))) +) +#endif +#ifndef OVERRIDE_32_mmap_pgoff +SC_LTTNG_TRACEPOINT_EVENT(mmap_pgoff, + TP_PROTO(sc_exit(long ret,) unsigned long addr, unsigned long len, unsigned long prot, unsigned long flags, unsigned long fd, unsigned long pgoff), + TP_ARGS(sc_exit(ret,) addr, len, prot, flags, fd, pgoff), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned long, addr, addr)) sc_inout(ctf_integer(unsigned long, len, len)) sc_inout(ctf_integer(unsigned long, prot, prot)) sc_inout(ctf_integer(unsigned long, flags, flags)) sc_inout(ctf_integer(unsigned long, fd, fd)) sc_inout(ctf_integer(unsigned long, pgoff, pgoff))) +) +#endif + +#endif /* _TRACE_SYSCALLS_INTEGERS_H */ + +/* This part must be outside protection */ +#include + +#else /* CREATE_SYSCALL_TABLE */ + +#include "x86-32-syscalls_integers_override.h" +#include "syscalls_integers_override.h" + +#ifdef SC_ENTER +#ifndef OVERRIDE_TABLE_32_restart_syscall +TRACE_SYSCALL_TABLE(syscalls_noargs, restart_syscall, 0, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getpid +TRACE_SYSCALL_TABLE(syscalls_noargs, getpid, 20, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getuid16 +TRACE_SYSCALL_TABLE(syscalls_noargs, getuid16, 24, 0) +#endif +#ifndef OVERRIDE_TABLE_32_pause +TRACE_SYSCALL_TABLE(syscalls_noargs, pause, 29, 0) +#endif +#ifndef OVERRIDE_TABLE_32_sync +TRACE_SYSCALL_TABLE(syscalls_noargs, sync, 36, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getgid16 +TRACE_SYSCALL_TABLE(syscalls_noargs, getgid16, 47, 0) +#endif +#ifndef OVERRIDE_TABLE_32_geteuid16 +TRACE_SYSCALL_TABLE(syscalls_noargs, geteuid16, 49, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getegid16 +TRACE_SYSCALL_TABLE(syscalls_noargs, getegid16, 50, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getppid +TRACE_SYSCALL_TABLE(syscalls_noargs, getppid, 64, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getpgrp +TRACE_SYSCALL_TABLE(syscalls_noargs, getpgrp, 65, 0) +#endif +#ifndef OVERRIDE_TABLE_32_setsid +TRACE_SYSCALL_TABLE(syscalls_noargs, setsid, 66, 0) +#endif +#ifndef OVERRIDE_TABLE_32_sgetmask +TRACE_SYSCALL_TABLE(syscalls_noargs, sgetmask, 68, 0) +#endif +#ifndef OVERRIDE_TABLE_32_vhangup +TRACE_SYSCALL_TABLE(syscalls_noargs, vhangup, 111, 0) +#endif +#ifndef OVERRIDE_TABLE_32_munlockall +TRACE_SYSCALL_TABLE(syscalls_noargs, munlockall, 153, 0) +#endif +#ifndef OVERRIDE_TABLE_32_sched_yield +TRACE_SYSCALL_TABLE(syscalls_noargs, sched_yield, 158, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getuid +TRACE_SYSCALL_TABLE(syscalls_noargs, getuid, 199, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getgid +TRACE_SYSCALL_TABLE(syscalls_noargs, getgid, 200, 0) +#endif +#ifndef OVERRIDE_TABLE_32_geteuid +TRACE_SYSCALL_TABLE(syscalls_noargs, geteuid, 201, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getegid +TRACE_SYSCALL_TABLE(syscalls_noargs, getegid, 202, 0) +#endif +#ifndef OVERRIDE_TABLE_32_gettid +TRACE_SYSCALL_TABLE(syscalls_noargs, gettid, 224, 0) +#endif +#ifndef OVERRIDE_TABLE_32_inotify_init +TRACE_SYSCALL_TABLE(syscalls_noargs, inotify_init, 291, 0) +#endif +#else /* #ifdef SC_ENTER */ +#ifndef OVERRIDE_TABLE_32_restart_syscall +TRACE_SYSCALL_TABLE(restart_syscall, restart_syscall, 0, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getpid +TRACE_SYSCALL_TABLE(getpid, getpid, 20, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getuid16 +TRACE_SYSCALL_TABLE(getuid16, getuid16, 24, 0) +#endif +#ifndef OVERRIDE_TABLE_32_pause +TRACE_SYSCALL_TABLE(pause, pause, 29, 0) +#endif +#ifndef OVERRIDE_TABLE_32_sync +TRACE_SYSCALL_TABLE(sync, sync, 36, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getgid16 +TRACE_SYSCALL_TABLE(getgid16, getgid16, 47, 0) +#endif +#ifndef OVERRIDE_TABLE_32_geteuid16 +TRACE_SYSCALL_TABLE(geteuid16, geteuid16, 49, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getegid16 +TRACE_SYSCALL_TABLE(getegid16, getegid16, 50, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getppid +TRACE_SYSCALL_TABLE(getppid, getppid, 64, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getpgrp +TRACE_SYSCALL_TABLE(getpgrp, getpgrp, 65, 0) +#endif +#ifndef OVERRIDE_TABLE_32_setsid +TRACE_SYSCALL_TABLE(setsid, setsid, 66, 0) +#endif +#ifndef OVERRIDE_TABLE_32_sgetmask +TRACE_SYSCALL_TABLE(sgetmask, sgetmask, 68, 0) +#endif +#ifndef OVERRIDE_TABLE_32_vhangup +TRACE_SYSCALL_TABLE(vhangup, vhangup, 111, 0) +#endif +#ifndef OVERRIDE_TABLE_32_munlockall +TRACE_SYSCALL_TABLE(munlockall, munlockall, 153, 0) +#endif +#ifndef OVERRIDE_TABLE_32_sched_yield +TRACE_SYSCALL_TABLE(sched_yield, sched_yield, 158, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getuid +TRACE_SYSCALL_TABLE(getuid, getuid, 199, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getgid +TRACE_SYSCALL_TABLE(getgid, getgid, 200, 0) +#endif +#ifndef OVERRIDE_TABLE_32_geteuid +TRACE_SYSCALL_TABLE(geteuid, geteuid, 201, 0) +#endif +#ifndef OVERRIDE_TABLE_32_getegid +TRACE_SYSCALL_TABLE(getegid, getegid, 202, 0) +#endif +#ifndef OVERRIDE_TABLE_32_gettid +TRACE_SYSCALL_TABLE(gettid, gettid, 224, 0) +#endif +#ifndef OVERRIDE_TABLE_32_inotify_init +TRACE_SYSCALL_TABLE(inotify_init, inotify_init, 291, 0) +#endif +#endif /* else #ifdef SC_ENTER */ +#ifndef OVERRIDE_TABLE_32_exit +TRACE_SYSCALL_TABLE(exit, exit, 1, 1) +#endif +#ifndef OVERRIDE_TABLE_32_close +TRACE_SYSCALL_TABLE(close, close, 6, 1) +#endif +#ifndef OVERRIDE_TABLE_32_lseek +TRACE_SYSCALL_TABLE(lseek, lseek, 19, 3) +#endif +#ifndef OVERRIDE_TABLE_32_setuid16 +TRACE_SYSCALL_TABLE(setuid16, setuid16, 23, 1) +#endif +#ifndef OVERRIDE_TABLE_32_ptrace +TRACE_SYSCALL_TABLE(ptrace, ptrace, 26, 4) +#endif +#ifndef OVERRIDE_TABLE_32_alarm +TRACE_SYSCALL_TABLE(alarm, alarm, 27, 1) +#endif +#ifndef OVERRIDE_TABLE_32_nice +TRACE_SYSCALL_TABLE(nice, nice, 34, 1) +#endif +#ifndef OVERRIDE_TABLE_32_kill +TRACE_SYSCALL_TABLE(kill, kill, 37, 2) +#endif +#ifndef OVERRIDE_TABLE_32_dup +TRACE_SYSCALL_TABLE(dup, dup, 41, 1) +#endif +#ifndef OVERRIDE_TABLE_32_brk +TRACE_SYSCALL_TABLE(brk, brk, 45, 1) +#endif +#ifndef OVERRIDE_TABLE_32_setgid16 +TRACE_SYSCALL_TABLE(setgid16, setgid16, 46, 1) +#endif +#ifndef OVERRIDE_TABLE_32_signal +TRACE_SYSCALL_TABLE(signal, signal, 48, 2) +#endif +#ifndef OVERRIDE_TABLE_32_ioctl +TRACE_SYSCALL_TABLE(ioctl, ioctl, 54, 3) +#endif +#ifndef OVERRIDE_TABLE_32_fcntl +TRACE_SYSCALL_TABLE(fcntl, fcntl, 55, 3) +#endif +#ifndef OVERRIDE_TABLE_32_setpgid +TRACE_SYSCALL_TABLE(setpgid, setpgid, 57, 2) +#endif +#ifndef OVERRIDE_TABLE_32_umask +TRACE_SYSCALL_TABLE(umask, umask, 60, 1) +#endif +#ifndef OVERRIDE_TABLE_32_dup2 +TRACE_SYSCALL_TABLE(dup2, dup2, 63, 2) +#endif +#ifndef OVERRIDE_TABLE_32_ssetmask +TRACE_SYSCALL_TABLE(ssetmask, ssetmask, 69, 1) +#endif +#ifndef OVERRIDE_TABLE_32_setreuid16 +TRACE_SYSCALL_TABLE(setreuid16, setreuid16, 70, 2) +#endif +#ifndef OVERRIDE_TABLE_32_setregid16 +TRACE_SYSCALL_TABLE(setregid16, setregid16, 71, 2) +#endif +#ifndef OVERRIDE_TABLE_32_munmap +TRACE_SYSCALL_TABLE(munmap, munmap, 91, 2) +#endif +#ifndef OVERRIDE_TABLE_32_ftruncate +TRACE_SYSCALL_TABLE(ftruncate, ftruncate, 93, 2) +#endif +#ifndef OVERRIDE_TABLE_32_fchmod +TRACE_SYSCALL_TABLE(fchmod, fchmod, 94, 2) +#endif +#ifndef OVERRIDE_TABLE_32_fchown16 +TRACE_SYSCALL_TABLE(fchown16, fchown16, 95, 3) +#endif +#ifndef OVERRIDE_TABLE_32_getpriority +TRACE_SYSCALL_TABLE(getpriority, getpriority, 96, 2) +#endif +#ifndef OVERRIDE_TABLE_32_setpriority +TRACE_SYSCALL_TABLE(setpriority, setpriority, 97, 3) +#endif +#ifndef OVERRIDE_TABLE_32_fsync +TRACE_SYSCALL_TABLE(fsync, fsync, 118, 1) +#endif +#ifndef OVERRIDE_TABLE_32_mprotect +TRACE_SYSCALL_TABLE(mprotect, mprotect, 125, 3) +#endif +#ifndef OVERRIDE_TABLE_32_getpgid +TRACE_SYSCALL_TABLE(getpgid, getpgid, 132, 1) +#endif +#ifndef OVERRIDE_TABLE_32_fchdir +TRACE_SYSCALL_TABLE(fchdir, fchdir, 133, 1) +#endif +#ifndef OVERRIDE_TABLE_32_bdflush +TRACE_SYSCALL_TABLE(bdflush, bdflush, 134, 2) +#endif +#ifndef OVERRIDE_TABLE_32_sysfs +TRACE_SYSCALL_TABLE(sysfs, sysfs, 135, 3) +#endif +#ifndef OVERRIDE_TABLE_32_personality +TRACE_SYSCALL_TABLE(personality, personality, 136, 1) +#endif +#ifndef OVERRIDE_TABLE_32_setfsuid16 +TRACE_SYSCALL_TABLE(setfsuid16, setfsuid16, 138, 1) +#endif +#ifndef OVERRIDE_TABLE_32_setfsgid16 +TRACE_SYSCALL_TABLE(setfsgid16, setfsgid16, 139, 1) +#endif +#ifndef OVERRIDE_TABLE_32_flock +TRACE_SYSCALL_TABLE(flock, flock, 143, 2) +#endif +#ifndef OVERRIDE_TABLE_32_msync +TRACE_SYSCALL_TABLE(msync, msync, 144, 3) +#endif +#ifndef OVERRIDE_TABLE_32_getsid +TRACE_SYSCALL_TABLE(getsid, getsid, 147, 1) +#endif +#ifndef OVERRIDE_TABLE_32_fdatasync +TRACE_SYSCALL_TABLE(fdatasync, fdatasync, 148, 1) +#endif +#ifndef OVERRIDE_TABLE_32_mlock +TRACE_SYSCALL_TABLE(mlock, mlock, 150, 2) +#endif +#ifndef OVERRIDE_TABLE_32_munlock +TRACE_SYSCALL_TABLE(munlock, munlock, 151, 2) +#endif +#ifndef OVERRIDE_TABLE_32_mlockall +TRACE_SYSCALL_TABLE(mlockall, mlockall, 152, 1) +#endif +#ifndef OVERRIDE_TABLE_32_sched_getscheduler +TRACE_SYSCALL_TABLE(sched_getscheduler, sched_getscheduler, 157, 1) +#endif +#ifndef OVERRIDE_TABLE_32_sched_get_priority_max +TRACE_SYSCALL_TABLE(sched_get_priority_max, sched_get_priority_max, 159, 1) +#endif +#ifndef OVERRIDE_TABLE_32_sched_get_priority_min +TRACE_SYSCALL_TABLE(sched_get_priority_min, sched_get_priority_min, 160, 1) +#endif +#ifndef OVERRIDE_TABLE_32_mremap +TRACE_SYSCALL_TABLE(mremap, mremap, 163, 5) +#endif +#ifndef OVERRIDE_TABLE_32_setresuid16 +TRACE_SYSCALL_TABLE(setresuid16, setresuid16, 164, 3) +#endif +#ifndef OVERRIDE_TABLE_32_setresgid16 +TRACE_SYSCALL_TABLE(setresgid16, setresgid16, 170, 3) +#endif +#ifndef OVERRIDE_TABLE_32_prctl +TRACE_SYSCALL_TABLE(prctl, prctl, 172, 5) +#endif +#ifndef OVERRIDE_TABLE_32_mmap_pgoff +TRACE_SYSCALL_TABLE(mmap_pgoff, mmap_pgoff, 192, 6) +#endif +#ifndef OVERRIDE_TABLE_32_setreuid +TRACE_SYSCALL_TABLE(setreuid, setreuid, 203, 2) +#endif +#ifndef OVERRIDE_TABLE_32_setregid +TRACE_SYSCALL_TABLE(setregid, setregid, 204, 2) +#endif +#ifndef OVERRIDE_TABLE_32_fchown +TRACE_SYSCALL_TABLE(fchown, fchown, 207, 3) +#endif +#ifndef OVERRIDE_TABLE_32_setresuid +TRACE_SYSCALL_TABLE(setresuid, setresuid, 208, 3) +#endif +#ifndef OVERRIDE_TABLE_32_setresgid +TRACE_SYSCALL_TABLE(setresgid, setresgid, 210, 3) +#endif +#ifndef OVERRIDE_TABLE_32_setuid +TRACE_SYSCALL_TABLE(setuid, setuid, 213, 1) +#endif +#ifndef OVERRIDE_TABLE_32_setgid +TRACE_SYSCALL_TABLE(setgid, setgid, 214, 1) +#endif +#ifndef OVERRIDE_TABLE_32_setfsuid +TRACE_SYSCALL_TABLE(setfsuid, setfsuid, 215, 1) +#endif +#ifndef OVERRIDE_TABLE_32_setfsgid +TRACE_SYSCALL_TABLE(setfsgid, setfsgid, 216, 1) +#endif +#ifndef OVERRIDE_TABLE_32_madvise +TRACE_SYSCALL_TABLE(madvise, madvise, 219, 3) +#endif +#ifndef OVERRIDE_TABLE_32_fcntl64 +TRACE_SYSCALL_TABLE(fcntl64, fcntl64, 221, 3) +#endif +#ifndef OVERRIDE_TABLE_32_tkill +TRACE_SYSCALL_TABLE(tkill, tkill, 238, 2) +#endif +#ifndef OVERRIDE_TABLE_32_io_destroy +TRACE_SYSCALL_TABLE(io_destroy, io_destroy, 246, 1) +#endif +#ifndef OVERRIDE_TABLE_32_exit_group +TRACE_SYSCALL_TABLE(exit_group, exit_group, 252, 1) +#endif +#ifndef OVERRIDE_TABLE_32_epoll_create +TRACE_SYSCALL_TABLE(epoll_create, epoll_create, 254, 1) +#endif +#ifndef OVERRIDE_TABLE_32_remap_file_pages +TRACE_SYSCALL_TABLE(remap_file_pages, remap_file_pages, 257, 5) +#endif +#ifndef OVERRIDE_TABLE_32_timer_getoverrun +TRACE_SYSCALL_TABLE(timer_getoverrun, timer_getoverrun, 262, 1) +#endif +#ifndef OVERRIDE_TABLE_32_timer_delete +TRACE_SYSCALL_TABLE(timer_delete, timer_delete, 263, 1) +#endif +#ifndef OVERRIDE_TABLE_32_tgkill +TRACE_SYSCALL_TABLE(tgkill, tgkill, 270, 3) +#endif +#ifndef OVERRIDE_TABLE_32_keyctl +TRACE_SYSCALL_TABLE(keyctl, keyctl, 288, 5) +#endif +#ifndef OVERRIDE_TABLE_32_ioprio_set +TRACE_SYSCALL_TABLE(ioprio_set, ioprio_set, 289, 3) +#endif +#ifndef OVERRIDE_TABLE_32_ioprio_get +TRACE_SYSCALL_TABLE(ioprio_get, ioprio_get, 290, 2) +#endif +#ifndef OVERRIDE_TABLE_32_inotify_rm_watch +TRACE_SYSCALL_TABLE(inotify_rm_watch, inotify_rm_watch, 293, 2) +#endif +#ifndef OVERRIDE_TABLE_32_unshare +TRACE_SYSCALL_TABLE(unshare, unshare, 310, 1) +#endif +#ifndef OVERRIDE_TABLE_32_tee +TRACE_SYSCALL_TABLE(tee, tee, 315, 4) +#endif +#ifndef OVERRIDE_TABLE_32_timerfd_create +TRACE_SYSCALL_TABLE(timerfd_create, timerfd_create, 322, 2) +#endif +#ifndef OVERRIDE_TABLE_32_eventfd +TRACE_SYSCALL_TABLE(eventfd, eventfd, 323, 1) +#endif +#ifndef OVERRIDE_TABLE_32_eventfd2 +TRACE_SYSCALL_TABLE(eventfd2, eventfd2, 328, 2) +#endif +#ifndef OVERRIDE_TABLE_32_epoll_create1 +TRACE_SYSCALL_TABLE(epoll_create1, epoll_create1, 329, 1) +#endif +#ifndef OVERRIDE_TABLE_32_dup3 +TRACE_SYSCALL_TABLE(dup3, dup3, 330, 3) +#endif +#ifndef OVERRIDE_TABLE_32_inotify_init1 +TRACE_SYSCALL_TABLE(inotify_init1, inotify_init1, 332, 1) +#endif +#ifndef OVERRIDE_TABLE_32_fanotify_init +TRACE_SYSCALL_TABLE(fanotify_init, fanotify_init, 338, 2) +#endif +#ifndef OVERRIDE_TABLE_32_syncfs +TRACE_SYSCALL_TABLE(syncfs, syncfs, 344, 1) +#endif +#ifndef OVERRIDE_TABLE_32_setns +TRACE_SYSCALL_TABLE(setns, setns, 346, 2) +#endif + +#endif /* CREATE_SYSCALL_TABLE */ diff --git a/include/instrumentation/syscalls/headers/x86-32-syscalls_integers_override.h b/include/instrumentation/syscalls/headers/x86-32-syscalls_integers_override.h new file mode 100644 index 00000000..3d933ad3 --- /dev/null +++ b/include/instrumentation/syscalls/headers/x86-32-syscalls_integers_override.h @@ -0,0 +1,87 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ + +#ifndef CONFIG_UID16 + +#define OVERRIDE_32_getuid16 +#define OVERRIDE_32_getgid16 +#define OVERRIDE_32_geteuid16 +#define OVERRIDE_32_getegid16 +#define OVERRIDE_32_setuid16 +#define OVERRIDE_32_setgid16 +#define OVERRIDE_32_setfsuid16 +#define OVERRIDE_32_setfsgid16 +#define OVERRIDE_32_setreuid16 +#define OVERRIDE_32_setregid16 +#define OVERRIDE_32_fchown16 +#define OVERRIDE_32_setresuid16 +#define OVERRIDE_32_setresgid16 + +#define OVERRIDE_TABLE_32_getuid16 +#define OVERRIDE_TABLE_32_getgid16 +#define OVERRIDE_TABLE_32_geteuid16 +#define OVERRIDE_TABLE_32_getegid16 +#define OVERRIDE_TABLE_32_setuid16 +#define OVERRIDE_TABLE_32_setgid16 +#define OVERRIDE_TABLE_32_setreuid16 +#define OVERRIDE_TABLE_32_setregid16 +#define OVERRIDE_TABLE_32_fchown16 +#define OVERRIDE_TABLE_32_setfsuid16 +#define OVERRIDE_TABLE_32_setfsgid16 +#define OVERRIDE_TABLE_32_setresuid16 +#define OVERRIDE_TABLE_32_setresgid16 + +#endif + +#ifndef CREATE_SYSCALL_TABLE + +/* mmap_pgoff is kernel internal. mmap2 is exposed in unistd.h. */ +#define OVERRIDE_32_mmap_pgoff +#define OVERRIDE_32_mmap2 +SC_LTTNG_TRACEPOINT_EVENT(mmap2, + TP_PROTO(sc_exit(unsigned long ret,) + unsigned long addr, unsigned long len, + unsigned long prot, unsigned long flags, + unsigned long fd, unsigned long pgoff), + TP_ARGS(sc_exit(ret,) addr, len, prot, flags, fd, pgoff), + TP_FIELDS(sc_exit(ctf_integer_hex(unsigned long, ret, ret)) + sc_in(ctf_integer_hex(unsigned long, addr, addr)) + sc_in(ctf_integer(size_t, len, len)) + sc_in(ctf_integer(int, prot, prot)) + sc_in(ctf_integer(int, flags, flags)) + sc_in(ctf_integer(int, fd, fd)) + sc_in(ctf_integer(off_t, pgoff, pgoff)) + ) +) + +#define OVERRIDE_32_sync_file_range +SC_LTTNG_TRACEPOINT_EVENT(sync_file_range, + TP_PROTO(sc_exit(long ret,) int fd, + int32_t offset_low, int32_t offset_high, + int32_t nbytes_low, int32_t nbytes_high, + unsigned int flags), + TP_ARGS(sc_exit(ret,) fd, offset_low, offset_high, + nbytes_low, nbytes_high, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) + sc_in(ctf_integer(int, fd, fd)) + sc_in(ctf_integer(loff_t, offset, + ((loff_t) offset_high << 32) | offset_low)) + sc_in(ctf_integer(loff_t, nbytes, + ((loff_t) nbytes_high << 32) | nbytes_low)) + sc_in(ctf_integer(unsigned int, flags, flags)) + ) +) + +#else /* #ifndef CREATE_SYSCALL_TABLE */ + +#define OVERRIDE_TABLE_32_mmap +TRACE_SYSCALL_TABLE(mmap, mmap, 90, 6) + +/* mmap_pgoff is kernel internal. mmap2 is exposed in unistd.h. */ +#define OVERRIDE_TABLE_32_mmap_pgoff +#define OVERRIDE_TABLE_32_mmap2 +TRACE_SYSCALL_TABLE(mmap2, mmap2, 192, 6) + +#define OVERRIDE_TABLE_32_sync_file_range +TRACE_SYSCALL_TABLE(sync_file_range, sync_file_range, 314, 6) + +#endif /* #else #ifndef CREATE_SYSCALL_TABLE */ diff --git a/include/instrumentation/syscalls/headers/x86-32-syscalls_pointers.h b/include/instrumentation/syscalls/headers/x86-32-syscalls_pointers.h new file mode 100644 index 00000000..34ea4d0d --- /dev/null +++ b/include/instrumentation/syscalls/headers/x86-32-syscalls_pointers.h @@ -0,0 +1,1869 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ + +/* THIS FILE IS AUTO-GENERATED. DO NOT EDIT */ + +/* Generated from x86-32-syscalls 3.1.0-rc6 */ + +#ifndef CREATE_SYSCALL_TABLE + +#if !defined(_TRACE_SYSCALLS_POINTERS_H) || defined(TRACE_HEADER_MULTI_READ) +#define _TRACE_SYSCALLS_POINTERS_H + +#include +#include +#include "x86-32-syscalls_pointers_override.h" +#include "syscalls_pointers_override.h" + +#ifndef OVERRIDE_32_unlink +SC_LTTNG_TRACEPOINT_EVENT(unlink, + TP_PROTO(sc_exit(long ret,) const char * pathname), + TP_ARGS(sc_exit(ret,) pathname), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname))) +) +#endif +#ifndef OVERRIDE_32_chdir +SC_LTTNG_TRACEPOINT_EVENT(chdir, + TP_PROTO(sc_exit(long ret,) const char * filename), + TP_ARGS(sc_exit(ret,) filename), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename))) +) +#endif +#ifndef OVERRIDE_32_time +SC_LTTNG_TRACEPOINT_EVENT(time, + TP_PROTO(sc_exit(long ret,) time_t * tloc), + TP_ARGS(sc_exit(ret,) tloc), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(time_t *, tloc, tloc))) +) +#endif +#ifndef OVERRIDE_32_oldumount +SC_LTTNG_TRACEPOINT_EVENT(oldumount, + TP_PROTO(sc_exit(long ret,) char * name), + TP_ARGS(sc_exit(ret,) name), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(name, name))) +) +#endif +#ifndef OVERRIDE_32_stime +SC_LTTNG_TRACEPOINT_EVENT(stime, + TP_PROTO(sc_exit(long ret,) time_t * tptr), + TP_ARGS(sc_exit(ret,) tptr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(time_t *, tptr, tptr))) +) +#endif +#ifndef OVERRIDE_32_rmdir +SC_LTTNG_TRACEPOINT_EVENT(rmdir, + TP_PROTO(sc_exit(long ret,) const char * pathname), + TP_ARGS(sc_exit(ret,) pathname), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname))) +) +#endif +#ifndef OVERRIDE_32_pipe +SC_LTTNG_TRACEPOINT_EVENT(pipe, + TP_PROTO(sc_exit(long ret,) int * fildes), + TP_ARGS(sc_exit(ret,) fildes), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(int *, fildes, fildes))) +) +#endif +#ifndef OVERRIDE_32_times +SC_LTTNG_TRACEPOINT_EVENT(times, + TP_PROTO(sc_exit(long ret,) struct tms * tbuf), + TP_ARGS(sc_exit(ret,) tbuf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct tms *, tbuf, tbuf))) +) +#endif +#ifndef OVERRIDE_32_acct +SC_LTTNG_TRACEPOINT_EVENT(acct, + TP_PROTO(sc_exit(long ret,) const char * name), + TP_ARGS(sc_exit(ret,) name), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name))) +) +#endif +#ifndef OVERRIDE_32_olduname +SC_LTTNG_TRACEPOINT_EVENT(olduname, + TP_PROTO(sc_exit(long ret,) struct oldold_utsname * name), + TP_ARGS(sc_exit(ret,) name), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct oldold_utsname *, name, name))) +) +#endif +#ifndef OVERRIDE_32_chroot +SC_LTTNG_TRACEPOINT_EVENT(chroot, + TP_PROTO(sc_exit(long ret,) const char * filename), + TP_ARGS(sc_exit(ret,) filename), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename))) +) +#endif +#ifndef OVERRIDE_32_sigpending +SC_LTTNG_TRACEPOINT_EVENT(sigpending, + TP_PROTO(sc_exit(long ret,) old_sigset_t * set), + TP_ARGS(sc_exit(ret,) set), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(old_sigset_t *, set, set))) +) +#endif +#ifndef OVERRIDE_32_old_select +SC_LTTNG_TRACEPOINT_EVENT(old_select, + TP_PROTO(sc_exit(long ret,) struct sel_arg_struct * arg), + TP_ARGS(sc_exit(ret,) arg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct sel_arg_struct *, arg, arg))) +) +#endif +#ifndef OVERRIDE_32_uselib +SC_LTTNG_TRACEPOINT_EVENT(uselib, + TP_PROTO(sc_exit(long ret,) const char * library), + TP_ARGS(sc_exit(ret,) library), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(const char *, library, library))) +) +#endif +#ifndef OVERRIDE_32_old_mmap +SC_LTTNG_TRACEPOINT_EVENT(old_mmap, + TP_PROTO(sc_exit(long ret,) struct mmap_arg_struct * arg), + TP_ARGS(sc_exit(ret,) arg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct mmap_arg_struct *, arg, arg))) +) +#endif +#ifndef OVERRIDE_32_uname +SC_LTTNG_TRACEPOINT_EVENT(uname, + TP_PROTO(sc_exit(long ret,) struct old_utsname * name), + TP_ARGS(sc_exit(ret,) name), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct old_utsname *, name, name))) +) +#endif +#ifndef OVERRIDE_32_swapoff +SC_LTTNG_TRACEPOINT_EVENT(swapoff, + TP_PROTO(sc_exit(long ret,) const char * specialfile), + TP_ARGS(sc_exit(ret,) specialfile), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(specialfile, specialfile))) +) +#endif +#ifndef OVERRIDE_32_sysinfo +SC_LTTNG_TRACEPOINT_EVENT(sysinfo, + TP_PROTO(sc_exit(long ret,) struct sysinfo * info), + TP_ARGS(sc_exit(ret,) info), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct sysinfo *, info, info))) +) +#endif +#ifndef OVERRIDE_32_newuname +SC_LTTNG_TRACEPOINT_EVENT(newuname, + TP_PROTO(sc_exit(long ret,) struct new_utsname * name), + TP_ARGS(sc_exit(ret,) name), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct new_utsname *, name, name))) +) +#endif +#ifndef OVERRIDE_32_adjtimex +SC_LTTNG_TRACEPOINT_EVENT(adjtimex, + TP_PROTO(sc_exit(long ret,) struct timex * txc_p), + TP_ARGS(sc_exit(ret,) txc_p), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct timex *, txc_p, txc_p))) +) +#endif +#ifndef OVERRIDE_32_sysctl +SC_LTTNG_TRACEPOINT_EVENT(sysctl, + TP_PROTO(sc_exit(long ret,) struct __sysctl_args * args), + TP_ARGS(sc_exit(ret,) args), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct __sysctl_args *, args, args))) +) +#endif +#ifndef OVERRIDE_32_set_tid_address +SC_LTTNG_TRACEPOINT_EVENT(set_tid_address, + TP_PROTO(sc_exit(long ret,) int * tidptr), + TP_ARGS(sc_exit(ret,) tidptr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int *, tidptr, tidptr))) +) +#endif +#ifndef OVERRIDE_32_mq_unlink +SC_LTTNG_TRACEPOINT_EVENT(mq_unlink, + TP_PROTO(sc_exit(long ret,) const char * u_name), + TP_ARGS(sc_exit(ret,) u_name), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(u_name, u_name))) +) +#endif +#ifndef OVERRIDE_32_creat +SC_LTTNG_TRACEPOINT_EVENT(creat, + TP_PROTO(sc_exit(long ret,) const char * pathname, int mode), + TP_ARGS(sc_exit(ret,) pathname, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(int, mode, mode))) +) +#endif +#ifndef OVERRIDE_32_link +SC_LTTNG_TRACEPOINT_EVENT(link, + TP_PROTO(sc_exit(long ret,) const char * oldname, const char * newname), + TP_ARGS(sc_exit(ret,) oldname, newname), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_user_string(newname, newname))) +) +#endif +#ifndef OVERRIDE_32_chmod +SC_LTTNG_TRACEPOINT_EVENT(chmod, + TP_PROTO(sc_exit(long ret,) const char * filename, mode_t mode), + TP_ARGS(sc_exit(ret,) filename, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(mode_t, mode, mode))) +) +#endif +#ifndef OVERRIDE_32_stat +SC_LTTNG_TRACEPOINT_EVENT(stat, + TP_PROTO(sc_exit(long ret,) const char * filename, struct __old_kernel_stat * statbuf), + TP_ARGS(sc_exit(ret,) filename, statbuf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(filename, filename)) sc_inout(ctf_integer(struct __old_kernel_stat *, statbuf, statbuf))) +) +#endif +#ifndef OVERRIDE_32_fstat +SC_LTTNG_TRACEPOINT_EVENT(fstat, + TP_PROTO(sc_exit(long ret,) unsigned int fd, struct __old_kernel_stat * statbuf), + TP_ARGS(sc_exit(ret,) fd, statbuf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, fd, fd)) sc_inout(ctf_integer(struct __old_kernel_stat *, statbuf, statbuf))) +) +#endif +#ifndef OVERRIDE_32_utime +SC_LTTNG_TRACEPOINT_EVENT(utime, + TP_PROTO(sc_exit(long ret,) char * filename, struct utimbuf * times), + TP_ARGS(sc_exit(ret,) filename, times), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(struct utimbuf *, times, times))) +) +#endif +#ifndef OVERRIDE_32_access +SC_LTTNG_TRACEPOINT_EVENT(access, + TP_PROTO(sc_exit(long ret,) const char * filename, int mode), + TP_ARGS(sc_exit(ret,) filename, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, mode, mode))) +) +#endif +#ifndef OVERRIDE_32_rename +SC_LTTNG_TRACEPOINT_EVENT(rename, + TP_PROTO(sc_exit(long ret,) const char * oldname, const char * newname), + TP_ARGS(sc_exit(ret,) oldname, newname), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_user_string(newname, newname))) +) +#endif +#ifndef OVERRIDE_32_mkdir +SC_LTTNG_TRACEPOINT_EVENT(mkdir, + TP_PROTO(sc_exit(long ret,) const char * pathname, int mode), + TP_ARGS(sc_exit(ret,) pathname, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(int, mode, mode))) +) +#endif +#ifndef OVERRIDE_32_umount +SC_LTTNG_TRACEPOINT_EVENT(umount, + TP_PROTO(sc_exit(long ret,) char * name, int flags), + TP_ARGS(sc_exit(ret,) name, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_ustat +SC_LTTNG_TRACEPOINT_EVENT(ustat, + TP_PROTO(sc_exit(long ret,) unsigned dev, struct ustat * ubuf), + TP_ARGS(sc_exit(ret,) dev, ubuf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned, dev, dev)) sc_out(ctf_integer(struct ustat *, ubuf, ubuf))) +) +#endif +#ifndef OVERRIDE_32_sethostname +SC_LTTNG_TRACEPOINT_EVENT(sethostname, + TP_PROTO(sc_exit(long ret,) char * name, int len), + TP_ARGS(sc_exit(ret,) name, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(int, len, len))) +) +#endif +#ifndef OVERRIDE_32_setrlimit +SC_LTTNG_TRACEPOINT_EVENT(setrlimit, + TP_PROTO(sc_exit(long ret,) unsigned int resource, struct rlimit * rlim), + TP_ARGS(sc_exit(ret,) resource, rlim), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, resource, resource)) sc_in(ctf_integer(struct rlimit *, rlim, rlim))) +) +#endif +#ifndef OVERRIDE_32_old_getrlimit +SC_LTTNG_TRACEPOINT_EVENT(old_getrlimit, + TP_PROTO(sc_exit(long ret,) unsigned int resource, struct rlimit * rlim), + TP_ARGS(sc_exit(ret,) resource, rlim), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, resource, resource)) sc_inout(ctf_integer(struct rlimit *, rlim, rlim))) +) +#endif +#ifndef OVERRIDE_32_getrusage +SC_LTTNG_TRACEPOINT_EVENT(getrusage, + TP_PROTO(sc_exit(long ret,) int who, struct rusage * ru), + TP_ARGS(sc_exit(ret,) who, ru), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, who, who)) sc_out(ctf_integer(struct rusage *, ru, ru))) +) +#endif +#ifndef OVERRIDE_32_gettimeofday +SC_LTTNG_TRACEPOINT_EVENT(gettimeofday, + TP_PROTO(sc_exit(long ret,) struct timeval * tv, struct timezone * tz), + TP_ARGS(sc_exit(ret,) tv, tz), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct timeval *, tv, tv)) sc_out(ctf_integer(struct timezone *, tz, tz))) +) +#endif +#ifndef OVERRIDE_32_settimeofday +SC_LTTNG_TRACEPOINT_EVENT(settimeofday, + TP_PROTO(sc_exit(long ret,) struct timeval * tv, struct timezone * tz), + TP_ARGS(sc_exit(ret,) tv, tz), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct timeval *, tv, tv)) sc_in(ctf_integer(struct timezone *, tz, tz))) +) +#endif +#ifndef OVERRIDE_32_getgroups16 +SC_LTTNG_TRACEPOINT_EVENT(getgroups16, + TP_PROTO(sc_exit(long ret,) int gidsetsize, old_gid_t * grouplist), + TP_ARGS(sc_exit(ret,) gidsetsize, grouplist), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, gidsetsize, gidsetsize)) sc_inout(ctf_integer(old_gid_t *, grouplist, grouplist))) +) +#endif +#ifndef OVERRIDE_32_setgroups16 +SC_LTTNG_TRACEPOINT_EVENT(setgroups16, + TP_PROTO(sc_exit(long ret,) int gidsetsize, old_gid_t * grouplist), + TP_ARGS(sc_exit(ret,) gidsetsize, grouplist), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, gidsetsize, gidsetsize)) sc_inout(ctf_integer(old_gid_t *, grouplist, grouplist))) +) +#endif +#ifndef OVERRIDE_32_symlink +SC_LTTNG_TRACEPOINT_EVENT(symlink, + TP_PROTO(sc_exit(long ret,) const char * oldname, const char * newname), + TP_ARGS(sc_exit(ret,) oldname, newname), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_user_string(newname, newname))) +) +#endif +#ifndef OVERRIDE_32_lstat +SC_LTTNG_TRACEPOINT_EVENT(lstat, + TP_PROTO(sc_exit(long ret,) const char * filename, struct __old_kernel_stat * statbuf), + TP_ARGS(sc_exit(ret,) filename, statbuf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(filename, filename)) sc_inout(ctf_integer(struct __old_kernel_stat *, statbuf, statbuf))) +) +#endif +#ifndef OVERRIDE_32_swapon +SC_LTTNG_TRACEPOINT_EVENT(swapon, + TP_PROTO(sc_exit(long ret,) const char * specialfile, int swap_flags), + TP_ARGS(sc_exit(ret,) specialfile, swap_flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(specialfile, specialfile)) sc_in(ctf_integer(int, swap_flags, swap_flags))) +) +#endif +#ifndef OVERRIDE_32_truncate +SC_LTTNG_TRACEPOINT_EVENT(truncate, + TP_PROTO(sc_exit(long ret,) const char * path, long length), + TP_ARGS(sc_exit(ret,) path, length), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(path, path)) sc_in(ctf_integer(long, length, length))) +) +#endif +#ifndef OVERRIDE_32_statfs +SC_LTTNG_TRACEPOINT_EVENT(statfs, + TP_PROTO(sc_exit(long ret,) const char * pathname, struct statfs * buf), + TP_ARGS(sc_exit(ret,) pathname, buf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(struct statfs *, buf, buf))) +) +#endif +#ifndef OVERRIDE_32_fstatfs +SC_LTTNG_TRACEPOINT_EVENT(fstatfs, + TP_PROTO(sc_exit(long ret,) unsigned int fd, struct statfs * buf), + TP_ARGS(sc_exit(ret,) fd, buf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct statfs *, buf, buf))) +) +#endif +#ifndef OVERRIDE_32_socketcall +SC_LTTNG_TRACEPOINT_EVENT(socketcall, + TP_PROTO(sc_exit(long ret,) int call, unsigned long * args), + TP_ARGS(sc_exit(ret,) call, args), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, call, call)) sc_inout(ctf_integer(unsigned long *, args, args))) +) +#endif +#ifndef OVERRIDE_32_getitimer +SC_LTTNG_TRACEPOINT_EVENT(getitimer, + TP_PROTO(sc_exit(long ret,) int which, struct itimerval * value), + TP_ARGS(sc_exit(ret,) which, value), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_out(ctf_integer(struct itimerval *, value, value))) +) +#endif +#ifndef OVERRIDE_32_newstat +SC_LTTNG_TRACEPOINT_EVENT(newstat, + TP_PROTO(sc_exit(long ret,) const char * filename, struct stat * statbuf), + TP_ARGS(sc_exit(ret,) filename, statbuf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_out(ctf_integer(struct stat *, statbuf, statbuf))) +) +#endif +#ifndef OVERRIDE_32_newlstat +SC_LTTNG_TRACEPOINT_EVENT(newlstat, + TP_PROTO(sc_exit(long ret,) const char * filename, struct stat * statbuf), + TP_ARGS(sc_exit(ret,) filename, statbuf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_out(ctf_integer(struct stat *, statbuf, statbuf))) +) +#endif +#ifndef OVERRIDE_32_newfstat +SC_LTTNG_TRACEPOINT_EVENT(newfstat, + TP_PROTO(sc_exit(long ret,) unsigned int fd, struct stat * statbuf), + TP_ARGS(sc_exit(ret,) fd, statbuf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct stat *, statbuf, statbuf))) +) +#endif +#ifndef OVERRIDE_32_setdomainname +SC_LTTNG_TRACEPOINT_EVENT(setdomainname, + TP_PROTO(sc_exit(long ret,) char * name, int len), + TP_ARGS(sc_exit(ret,) name, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(int, len, len))) +) +#endif +#ifndef OVERRIDE_32_delete_module +SC_LTTNG_TRACEPOINT_EVENT(delete_module, + TP_PROTO(sc_exit(long ret,) const char * name_user, unsigned int flags), + TP_ARGS(sc_exit(ret,) name_user, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name_user, name_user)) sc_in(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_sched_setparam +SC_LTTNG_TRACEPOINT_EVENT(sched_setparam, + TP_PROTO(sc_exit(long ret,) pid_t pid, struct sched_param * param), + TP_ARGS(sc_exit(ret,) pid, param), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(struct sched_param *, param, param))) +) +#endif +#ifndef OVERRIDE_32_sched_getparam +SC_LTTNG_TRACEPOINT_EVENT(sched_getparam, + TP_PROTO(sc_exit(long ret,) pid_t pid, struct sched_param * param), + TP_ARGS(sc_exit(ret,) pid, param), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_out(ctf_integer(struct sched_param *, param, param))) +) +#endif +#ifndef OVERRIDE_32_sched_rr_get_interval +SC_LTTNG_TRACEPOINT_EVENT(sched_rr_get_interval, + TP_PROTO(sc_exit(long ret,) pid_t pid, struct timespec * interval), + TP_ARGS(sc_exit(ret,) pid, interval), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_out(ctf_integer(struct timespec *, interval, interval))) +) +#endif +#ifndef OVERRIDE_32_nanosleep +SC_LTTNG_TRACEPOINT_EVENT(nanosleep, + TP_PROTO(sc_exit(long ret,) struct timespec * rqtp, struct timespec * rmtp), + TP_ARGS(sc_exit(ret,) rqtp, rmtp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct timespec *, rqtp, rqtp)) sc_out(ctf_integer(struct timespec *, rmtp, rmtp))) +) +#endif +#ifndef OVERRIDE_32_rt_sigpending +SC_LTTNG_TRACEPOINT_EVENT(rt_sigpending, + TP_PROTO(sc_exit(long ret,) sigset_t * set, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) set, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(sigset_t *, set, set)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) +) +#endif +#ifndef OVERRIDE_32_rt_sigsuspend +SC_LTTNG_TRACEPOINT_EVENT(rt_sigsuspend, + TP_PROTO(sc_exit(long ret,) sigset_t * unewset, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) unewset, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(sigset_t *, unewset, unewset)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) +) +#endif +#ifndef OVERRIDE_32_getcwd +SC_LTTNG_TRACEPOINT_EVENT(getcwd, + TP_PROTO(sc_exit(long ret,) char * buf, unsigned long size), + TP_ARGS(sc_exit(ret,) buf, size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(unsigned long, size, size))) +) +#endif +#ifndef OVERRIDE_32_getrlimit +SC_LTTNG_TRACEPOINT_EVENT(getrlimit, + TP_PROTO(sc_exit(long ret,) unsigned int resource, struct rlimit * rlim), + TP_ARGS(sc_exit(ret,) resource, rlim), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, resource, resource)) sc_out(ctf_integer(struct rlimit *, rlim, rlim))) +) +#endif +#ifndef OVERRIDE_32_stat64 +SC_LTTNG_TRACEPOINT_EVENT(stat64, + TP_PROTO(sc_exit(long ret,) const char * filename, struct stat64 * statbuf), + TP_ARGS(sc_exit(ret,) filename, statbuf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(filename, filename)) sc_inout(ctf_integer(struct stat64 *, statbuf, statbuf))) +) +#endif +#ifndef OVERRIDE_32_lstat64 +SC_LTTNG_TRACEPOINT_EVENT(lstat64, + TP_PROTO(sc_exit(long ret,) const char * filename, struct stat64 * statbuf), + TP_ARGS(sc_exit(ret,) filename, statbuf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(filename, filename)) sc_inout(ctf_integer(struct stat64 *, statbuf, statbuf))) +) +#endif +#ifndef OVERRIDE_32_fstat64 +SC_LTTNG_TRACEPOINT_EVENT(fstat64, + TP_PROTO(sc_exit(long ret,) unsigned long fd, struct stat64 * statbuf), + TP_ARGS(sc_exit(ret,) fd, statbuf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned long, fd, fd)) sc_inout(ctf_integer(struct stat64 *, statbuf, statbuf))) +) +#endif +#ifndef OVERRIDE_32_getgroups +SC_LTTNG_TRACEPOINT_EVENT(getgroups, + TP_PROTO(sc_exit(long ret,) int gidsetsize, gid_t * grouplist), + TP_ARGS(sc_exit(ret,) gidsetsize, grouplist), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, gidsetsize, gidsetsize)) sc_out(ctf_integer(gid_t *, grouplist, grouplist))) +) +#endif +#ifndef OVERRIDE_32_setgroups +SC_LTTNG_TRACEPOINT_EVENT(setgroups, + TP_PROTO(sc_exit(long ret,) int gidsetsize, gid_t * grouplist), + TP_ARGS(sc_exit(ret,) gidsetsize, grouplist), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, gidsetsize, gidsetsize)) sc_in(ctf_integer(gid_t *, grouplist, grouplist))) +) +#endif +#ifndef OVERRIDE_32_pivot_root +SC_LTTNG_TRACEPOINT_EVENT(pivot_root, + TP_PROTO(sc_exit(long ret,) const char * new_root, const char * put_old), + TP_ARGS(sc_exit(ret,) new_root, put_old), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(new_root, new_root)) sc_in(ctf_user_string(put_old, put_old))) +) +#endif +#ifndef OVERRIDE_32_removexattr +SC_LTTNG_TRACEPOINT_EVENT(removexattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name), + TP_ARGS(sc_exit(ret,) pathname, name), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name))) +) +#endif +#ifndef OVERRIDE_32_lremovexattr +SC_LTTNG_TRACEPOINT_EVENT(lremovexattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name), + TP_ARGS(sc_exit(ret,) pathname, name), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name))) +) +#endif +#ifndef OVERRIDE_32_fremovexattr +SC_LTTNG_TRACEPOINT_EVENT(fremovexattr, + TP_PROTO(sc_exit(long ret,) int fd, const char * name), + TP_ARGS(sc_exit(ret,) fd, name), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(name, name))) +) +#endif +#ifndef OVERRIDE_32_io_setup +SC_LTTNG_TRACEPOINT_EVENT(io_setup, + TP_PROTO(sc_exit(long ret,) unsigned nr_events, aio_context_t * ctxp), + TP_ARGS(sc_exit(ret,) nr_events, ctxp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned, nr_events, nr_events)) sc_in(ctf_integer(aio_context_t *, ctxp, ctxp))) +) +#endif +#ifndef OVERRIDE_32_timer_gettime +SC_LTTNG_TRACEPOINT_EVENT(timer_gettime, + TP_PROTO(sc_exit(long ret,) timer_t timer_id, struct itimerspec * setting), + TP_ARGS(sc_exit(ret,) timer_id, setting), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id)) sc_out(ctf_integer(struct itimerspec *, setting, setting))) +) +#endif +#ifndef OVERRIDE_32_clock_settime +SC_LTTNG_TRACEPOINT_EVENT(clock_settime, + TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, const struct timespec * tp), + TP_ARGS(sc_exit(ret,) which_clock, tp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_in(ctf_integer(const struct timespec *, tp, tp))) +) +#endif +#ifndef OVERRIDE_32_clock_gettime +SC_LTTNG_TRACEPOINT_EVENT(clock_gettime, + TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct timespec * tp), + TP_ARGS(sc_exit(ret,) which_clock, tp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_out(ctf_integer(struct timespec *, tp, tp))) +) +#endif +#ifndef OVERRIDE_32_clock_getres +SC_LTTNG_TRACEPOINT_EVENT(clock_getres, + TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct timespec * tp), + TP_ARGS(sc_exit(ret,) which_clock, tp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_out(ctf_integer(struct timespec *, tp, tp))) +) +#endif +#ifndef OVERRIDE_32_utimes +SC_LTTNG_TRACEPOINT_EVENT(utimes, + TP_PROTO(sc_exit(long ret,) char * filename, struct timeval * utimes), + TP_ARGS(sc_exit(ret,) filename, utimes), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(struct timeval *, utimes, utimes))) +) +#endif +#ifndef OVERRIDE_32_mq_notify +SC_LTTNG_TRACEPOINT_EVENT(mq_notify, + TP_PROTO(sc_exit(long ret,) mqd_t mqdes, const struct sigevent * u_notification), + TP_ARGS(sc_exit(ret,) mqdes, u_notification), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(mqd_t, mqdes, mqdes)) sc_in(ctf_integer(const struct sigevent *, u_notification, u_notification))) +) +#endif +#ifndef OVERRIDE_32_set_robust_list +SC_LTTNG_TRACEPOINT_EVENT(set_robust_list, + TP_PROTO(sc_exit(long ret,) struct robust_list_head * head, size_t len), + TP_ARGS(sc_exit(ret,) head, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct robust_list_head *, head, head)) sc_in(ctf_integer(size_t, len, len))) +) +#endif +#ifndef OVERRIDE_32_timerfd_gettime +SC_LTTNG_TRACEPOINT_EVENT(timerfd_gettime, + TP_PROTO(sc_exit(long ret,) int ufd, struct itimerspec * otmr), + TP_ARGS(sc_exit(ret,) ufd, otmr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_out(ctf_integer(struct itimerspec *, otmr, otmr))) +) +#endif +#ifndef OVERRIDE_32_pipe2 +SC_LTTNG_TRACEPOINT_EVENT(pipe2, + TP_PROTO(sc_exit(long ret,) int * fildes, int flags), + TP_ARGS(sc_exit(ret,) fildes, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(int *, fildes, fildes)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_clock_adjtime +SC_LTTNG_TRACEPOINT_EVENT(clock_adjtime, + TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct timex * utx), + TP_ARGS(sc_exit(ret,) which_clock, utx), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_inout(ctf_integer(struct timex *, utx, utx))) +) +#endif +#ifndef OVERRIDE_32_read +SC_LTTNG_TRACEPOINT_EVENT(read, + TP_PROTO(sc_exit(long ret,) unsigned int fd, char * buf, size_t count), + TP_ARGS(sc_exit(ret,) fd, buf, count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(size_t, count, count))) +) +#endif +#ifndef OVERRIDE_32_write +SC_LTTNG_TRACEPOINT_EVENT(write, + TP_PROTO(sc_exit(long ret,) unsigned int fd, const char * buf, size_t count), + TP_ARGS(sc_exit(ret,) fd, buf, count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(const char *, buf, buf)) sc_in(ctf_integer(size_t, count, count))) +) +#endif +#ifndef OVERRIDE_32_open +SC_LTTNG_TRACEPOINT_EVENT(open, + TP_PROTO(sc_exit(long ret,) const char * filename, int flags, int mode), + TP_ARGS(sc_exit(ret,) filename, flags, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(int, mode, mode))) +) +#endif +#ifndef OVERRIDE_32_waitpid +SC_LTTNG_TRACEPOINT_EVENT(waitpid, + TP_PROTO(sc_exit(long ret,) pid_t pid, int * stat_addr, int options), + TP_ARGS(sc_exit(ret,) pid, stat_addr, options), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(pid_t, pid, pid)) sc_inout(ctf_integer(int *, stat_addr, stat_addr)) sc_inout(ctf_integer(int, options, options))) +) +#endif +#ifndef OVERRIDE_32_mknod +SC_LTTNG_TRACEPOINT_EVENT(mknod, + TP_PROTO(sc_exit(long ret,) const char * filename, int mode, unsigned dev), + TP_ARGS(sc_exit(ret,) filename, mode, dev), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, mode, mode)) sc_in(ctf_integer(unsigned, dev, dev))) +) +#endif +#ifndef OVERRIDE_32_lchown16 +SC_LTTNG_TRACEPOINT_EVENT(lchown16, + TP_PROTO(sc_exit(long ret,) const char * filename, old_uid_t user, old_gid_t group), + TP_ARGS(sc_exit(ret,) filename, user, group), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(filename, filename)) sc_inout(ctf_integer(old_uid_t, user, user)) sc_inout(ctf_integer(old_gid_t, group, group))) +) +#endif +#ifndef OVERRIDE_32_readlink +SC_LTTNG_TRACEPOINT_EVENT(readlink, + TP_PROTO(sc_exit(long ret,) const char * path, char * buf, int bufsiz), + TP_ARGS(sc_exit(ret,) path, buf, bufsiz), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(path, path)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(int, bufsiz, bufsiz))) +) +#endif +#ifndef OVERRIDE_32_old_readdir +SC_LTTNG_TRACEPOINT_EVENT(old_readdir, + TP_PROTO(sc_exit(long ret,) unsigned int fd, struct old_linux_dirent * dirent, unsigned int count), + TP_ARGS(sc_exit(ret,) fd, dirent, count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, fd, fd)) sc_inout(ctf_integer(struct old_linux_dirent *, dirent, dirent)) sc_inout(ctf_integer(unsigned int, count, count))) +) +#endif +#ifndef OVERRIDE_32_syslog +SC_LTTNG_TRACEPOINT_EVENT(syslog, + TP_PROTO(sc_exit(long ret,) int type, char * buf, int len), + TP_ARGS(sc_exit(ret,) type, buf, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, type, type)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(int, len, len))) +) +#endif +#ifndef OVERRIDE_32_setitimer +SC_LTTNG_TRACEPOINT_EVENT(setitimer, + TP_PROTO(sc_exit(long ret,) int which, struct itimerval * value, struct itimerval * ovalue), + TP_ARGS(sc_exit(ret,) which, value, ovalue), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(struct itimerval *, value, value)) sc_out(ctf_integer(struct itimerval *, ovalue, ovalue))) +) +#endif +#ifndef OVERRIDE_32_sigprocmask +SC_LTTNG_TRACEPOINT_EVENT(sigprocmask, + TP_PROTO(sc_exit(long ret,) int how, old_sigset_t * nset, old_sigset_t * oset), + TP_ARGS(sc_exit(ret,) how, nset, oset), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, how, how)) sc_inout(ctf_integer(old_sigset_t *, nset, nset)) sc_inout(ctf_integer(old_sigset_t *, oset, oset))) +) +#endif +#ifndef OVERRIDE_32_init_module +SC_LTTNG_TRACEPOINT_EVENT(init_module, + TP_PROTO(sc_exit(long ret,) void * umod, unsigned long len, const char * uargs), + TP_ARGS(sc_exit(ret,) umod, len, uargs), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(void *, umod, umod)) sc_in(ctf_integer(unsigned long, len, len)) sc_in(ctf_integer(const char *, uargs, uargs))) +) +#endif +#ifndef OVERRIDE_32_getdents +SC_LTTNG_TRACEPOINT_EVENT(getdents, + TP_PROTO(sc_exit(long ret,) unsigned int fd, struct linux_dirent * dirent, unsigned int count), + TP_ARGS(sc_exit(ret,) fd, dirent, count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct linux_dirent *, dirent, dirent)) sc_in(ctf_integer(unsigned int, count, count))) +) +#endif +#ifndef OVERRIDE_32_readv +SC_LTTNG_TRACEPOINT_EVENT(readv, + TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen), + TP_ARGS(sc_exit(ret,) fd, vec, vlen), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_inout(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen))) +) +#endif +#ifndef OVERRIDE_32_writev +SC_LTTNG_TRACEPOINT_EVENT(writev, + TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen), + TP_ARGS(sc_exit(ret,) fd, vec, vlen), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_inout(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen))) +) +#endif +#ifndef OVERRIDE_32_sched_setscheduler +SC_LTTNG_TRACEPOINT_EVENT(sched_setscheduler, + TP_PROTO(sc_exit(long ret,) pid_t pid, int policy, struct sched_param * param), + TP_ARGS(sc_exit(ret,) pid, policy, param), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, policy, policy)) sc_in(ctf_integer(struct sched_param *, param, param))) +) +#endif +#ifndef OVERRIDE_32_getresuid16 +SC_LTTNG_TRACEPOINT_EVENT(getresuid16, + TP_PROTO(sc_exit(long ret,) old_uid_t * ruid, old_uid_t * euid, old_uid_t * suid), + TP_ARGS(sc_exit(ret,) ruid, euid, suid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(old_uid_t *, ruid, ruid)) sc_inout(ctf_integer(old_uid_t *, euid, euid)) sc_inout(ctf_integer(old_uid_t *, suid, suid))) +) +#endif +#ifndef OVERRIDE_32_poll +SC_LTTNG_TRACEPOINT_EVENT(poll, + TP_PROTO(sc_exit(long ret,) struct pollfd * ufds, unsigned int nfds, long timeout_msecs), + TP_ARGS(sc_exit(ret,) ufds, nfds, timeout_msecs), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct pollfd *, ufds, ufds)) sc_in(ctf_integer(unsigned int, nfds, nfds)) sc_in(ctf_integer(long, timeout_msecs, timeout_msecs))) +) +#endif +#ifndef OVERRIDE_32_getresgid16 +SC_LTTNG_TRACEPOINT_EVENT(getresgid16, + TP_PROTO(sc_exit(long ret,) old_gid_t * rgid, old_gid_t * egid, old_gid_t * sgid), + TP_ARGS(sc_exit(ret,) rgid, egid, sgid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(old_gid_t *, rgid, rgid)) sc_inout(ctf_integer(old_gid_t *, egid, egid)) sc_inout(ctf_integer(old_gid_t *, sgid, sgid))) +) +#endif +#ifndef OVERRIDE_32_rt_sigqueueinfo +SC_LTTNG_TRACEPOINT_EVENT(rt_sigqueueinfo, + TP_PROTO(sc_exit(long ret,) pid_t pid, int sig, siginfo_t * uinfo), + TP_ARGS(sc_exit(ret,) pid, sig, uinfo), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig)) sc_in(ctf_integer(siginfo_t *, uinfo, uinfo))) +) +#endif +#ifndef OVERRIDE_32_chown16 +SC_LTTNG_TRACEPOINT_EVENT(chown16, + TP_PROTO(sc_exit(long ret,) const char * filename, old_uid_t user, old_gid_t group), + TP_ARGS(sc_exit(ret,) filename, user, group), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(filename, filename)) sc_inout(ctf_integer(old_uid_t, user, user)) sc_inout(ctf_integer(old_gid_t, group, group))) +) +#endif +#ifndef OVERRIDE_32_lchown +SC_LTTNG_TRACEPOINT_EVENT(lchown, + TP_PROTO(sc_exit(long ret,) const char * filename, uid_t user, gid_t group), + TP_ARGS(sc_exit(ret,) filename, user, group), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group))) +) +#endif +#ifndef OVERRIDE_32_getresuid +SC_LTTNG_TRACEPOINT_EVENT(getresuid, + TP_PROTO(sc_exit(long ret,) uid_t * ruid, uid_t * euid, uid_t * suid), + TP_ARGS(sc_exit(ret,) ruid, euid, suid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(uid_t *, ruid, ruid)) sc_out(ctf_integer(uid_t *, euid, euid)) sc_out(ctf_integer(uid_t *, suid, suid))) +) +#endif +#ifndef OVERRIDE_32_getresgid +SC_LTTNG_TRACEPOINT_EVENT(getresgid, + TP_PROTO(sc_exit(long ret,) gid_t * rgid, gid_t * egid, gid_t * sgid), + TP_ARGS(sc_exit(ret,) rgid, egid, sgid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(gid_t *, rgid, rgid)) sc_out(ctf_integer(gid_t *, egid, egid)) sc_out(ctf_integer(gid_t *, sgid, sgid))) +) +#endif +#ifndef OVERRIDE_32_chown +SC_LTTNG_TRACEPOINT_EVENT(chown, + TP_PROTO(sc_exit(long ret,) const char * filename, uid_t user, gid_t group), + TP_ARGS(sc_exit(ret,) filename, user, group), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group))) +) +#endif +#ifndef OVERRIDE_32_mincore +SC_LTTNG_TRACEPOINT_EVENT(mincore, + TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len, unsigned char * vec), + TP_ARGS(sc_exit(ret,) start, len, vec), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len)) sc_out(ctf_integer(unsigned char *, vec, vec))) +) +#endif +#ifndef OVERRIDE_32_getdents64 +SC_LTTNG_TRACEPOINT_EVENT(getdents64, + TP_PROTO(sc_exit(long ret,) unsigned int fd, struct linux_dirent64 * dirent, unsigned int count), + TP_ARGS(sc_exit(ret,) fd, dirent, count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct linux_dirent64 *, dirent, dirent)) sc_in(ctf_integer(unsigned int, count, count))) +) +#endif +#ifndef OVERRIDE_32_listxattr +SC_LTTNG_TRACEPOINT_EVENT(listxattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, char * list, size_t size), + TP_ARGS(sc_exit(ret,) pathname, list, size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(char *, list, list)) sc_in(ctf_integer(size_t, size, size))) +) +#endif +#ifndef OVERRIDE_32_llistxattr +SC_LTTNG_TRACEPOINT_EVENT(llistxattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, char * list, size_t size), + TP_ARGS(sc_exit(ret,) pathname, list, size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(char *, list, list)) sc_in(ctf_integer(size_t, size, size))) +) +#endif +#ifndef OVERRIDE_32_flistxattr +SC_LTTNG_TRACEPOINT_EVENT(flistxattr, + TP_PROTO(sc_exit(long ret,) int fd, char * list, size_t size), + TP_ARGS(sc_exit(ret,) fd, list, size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(char *, list, list)) sc_in(ctf_integer(size_t, size, size))) +) +#endif +#ifndef OVERRIDE_32_sched_setaffinity +SC_LTTNG_TRACEPOINT_EVENT(sched_setaffinity, + TP_PROTO(sc_exit(long ret,) pid_t pid, unsigned int len, unsigned long * user_mask_ptr), + TP_ARGS(sc_exit(ret,) pid, len, user_mask_ptr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(unsigned int, len, len)) sc_in(ctf_integer(unsigned long *, user_mask_ptr, user_mask_ptr))) +) +#endif +#ifndef OVERRIDE_32_sched_getaffinity +SC_LTTNG_TRACEPOINT_EVENT(sched_getaffinity, + TP_PROTO(sc_exit(long ret,) pid_t pid, unsigned int len, unsigned long * user_mask_ptr), + TP_ARGS(sc_exit(ret,) pid, len, user_mask_ptr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(unsigned int, len, len)) sc_out(ctf_integer(unsigned long *, user_mask_ptr, user_mask_ptr))) +) +#endif +#ifndef OVERRIDE_32_io_submit +SC_LTTNG_TRACEPOINT_EVENT(io_submit, + TP_PROTO(sc_exit(long ret,) aio_context_t ctx_id, long nr, struct iocb * * iocbpp), + TP_ARGS(sc_exit(ret,) ctx_id, nr, iocbpp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx_id, ctx_id)) sc_in(ctf_integer(long, nr, nr)) sc_in(ctf_integer(struct iocb * *, iocbpp, iocbpp))) +) +#endif +#ifndef OVERRIDE_32_io_cancel +SC_LTTNG_TRACEPOINT_EVENT(io_cancel, + TP_PROTO(sc_exit(long ret,) aio_context_t ctx_id, struct iocb * iocb, struct io_event * result), + TP_ARGS(sc_exit(ret,) ctx_id, iocb, result), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx_id, ctx_id)) sc_in(ctf_integer(struct iocb *, iocb, iocb)) sc_out(ctf_integer(struct io_event *, result, result))) +) +#endif +#ifndef OVERRIDE_32_timer_create +SC_LTTNG_TRACEPOINT_EVENT(timer_create, + TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct sigevent * timer_event_spec, timer_t * created_timer_id), + TP_ARGS(sc_exit(ret,) which_clock, timer_event_spec, created_timer_id), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_in(ctf_integer(struct sigevent *, timer_event_spec, timer_event_spec)) sc_out(ctf_integer(timer_t *, created_timer_id, created_timer_id))) +) +#endif +#ifndef OVERRIDE_32_statfs64 +SC_LTTNG_TRACEPOINT_EVENT(statfs64, + TP_PROTO(sc_exit(long ret,) const char * pathname, size_t sz, struct statfs64 * buf), + TP_ARGS(sc_exit(ret,) pathname, sz, buf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(pathname, pathname)) sc_inout(ctf_integer(size_t, sz, sz)) sc_inout(ctf_integer(struct statfs64 *, buf, buf))) +) +#endif +#ifndef OVERRIDE_32_fstatfs64 +SC_LTTNG_TRACEPOINT_EVENT(fstatfs64, + TP_PROTO(sc_exit(long ret,) unsigned int fd, size_t sz, struct statfs64 * buf), + TP_ARGS(sc_exit(ret,) fd, sz, buf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, fd, fd)) sc_inout(ctf_integer(size_t, sz, sz)) sc_inout(ctf_integer(struct statfs64 *, buf, buf))) +) +#endif +#ifndef OVERRIDE_32_mq_getsetattr +SC_LTTNG_TRACEPOINT_EVENT(mq_getsetattr, + TP_PROTO(sc_exit(long ret,) mqd_t mqdes, const struct mq_attr * u_mqstat, struct mq_attr * u_omqstat), + TP_ARGS(sc_exit(ret,) mqdes, u_mqstat, u_omqstat), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(mqd_t, mqdes, mqdes)) sc_in(ctf_integer(const struct mq_attr *, u_mqstat, u_mqstat)) sc_out(ctf_integer(struct mq_attr *, u_omqstat, u_omqstat))) +) +#endif +#ifndef OVERRIDE_32_inotify_add_watch +SC_LTTNG_TRACEPOINT_EVENT(inotify_add_watch, + TP_PROTO(sc_exit(long ret,) int fd, const char * pathname, u32 mask), + TP_ARGS(sc_exit(ret,) fd, pathname, mask), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(u32, mask, mask))) +) +#endif +#ifndef OVERRIDE_32_mkdirat +SC_LTTNG_TRACEPOINT_EVENT(mkdirat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * pathname, int mode), + TP_ARGS(sc_exit(ret,) dfd, pathname, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(int, mode, mode))) +) +#endif +#ifndef OVERRIDE_32_futimesat +SC_LTTNG_TRACEPOINT_EVENT(futimesat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, struct timeval * utimes), + TP_ARGS(sc_exit(ret,) dfd, filename, utimes), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(struct timeval *, utimes, utimes))) +) +#endif +#ifndef OVERRIDE_32_unlinkat +SC_LTTNG_TRACEPOINT_EVENT(unlinkat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * pathname, int flag), + TP_ARGS(sc_exit(ret,) dfd, pathname, flag), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(int, flag, flag))) +) +#endif +#ifndef OVERRIDE_32_symlinkat +SC_LTTNG_TRACEPOINT_EVENT(symlinkat, + TP_PROTO(sc_exit(long ret,) const char * oldname, int newdfd, const char * newname), + TP_ARGS(sc_exit(ret,) oldname, newdfd, newname), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_integer(int, newdfd, newdfd)) sc_in(ctf_user_string(newname, newname))) +) +#endif +#ifndef OVERRIDE_32_fchmodat +SC_LTTNG_TRACEPOINT_EVENT(fchmodat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, mode_t mode), + TP_ARGS(sc_exit(ret,) dfd, filename, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(mode_t, mode, mode))) +) +#endif +#ifndef OVERRIDE_32_faccessat +SC_LTTNG_TRACEPOINT_EVENT(faccessat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, int mode), + TP_ARGS(sc_exit(ret,) dfd, filename, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, mode, mode))) +) +#endif +#ifndef OVERRIDE_32_get_robust_list +SC_LTTNG_TRACEPOINT_EVENT(get_robust_list, + TP_PROTO(sc_exit(long ret,) int pid, struct robust_list_head * * head_ptr, size_t * len_ptr), + TP_ARGS(sc_exit(ret,) pid, head_ptr, len_ptr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, pid, pid)) sc_out(ctf_integer(struct robust_list_head * *, head_ptr, head_ptr)) sc_out(ctf_integer(size_t *, len_ptr, len_ptr))) +) +#endif +#ifndef OVERRIDE_32_getcpu +SC_LTTNG_TRACEPOINT_EVENT(getcpu, + TP_PROTO(sc_exit(long ret,) unsigned * cpup, unsigned * nodep, struct getcpu_cache * unused), + TP_ARGS(sc_exit(ret,) cpup, nodep, unused), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(unsigned *, cpup, cpup)) sc_out(ctf_integer(unsigned *, nodep, nodep)) sc_inout(ctf_integer(struct getcpu_cache *, unused, unused))) +) +#endif +#ifndef OVERRIDE_32_signalfd +SC_LTTNG_TRACEPOINT_EVENT(signalfd, + TP_PROTO(sc_exit(long ret,) int ufd, sigset_t * user_mask, size_t sizemask), + TP_ARGS(sc_exit(ret,) ufd, user_mask, sizemask), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_in(ctf_integer(sigset_t *, user_mask, user_mask)) sc_in(ctf_integer(size_t, sizemask, sizemask))) +) +#endif +#ifndef OVERRIDE_32_reboot +SC_LTTNG_TRACEPOINT_EVENT(reboot, + TP_PROTO(sc_exit(long ret,) int magic1, int magic2, unsigned int cmd, void * arg), + TP_ARGS(sc_exit(ret,) magic1, magic2, cmd, arg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, magic1, magic1)) sc_in(ctf_integer(int, magic2, magic2)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_in(ctf_integer(void *, arg, arg))) +) +#endif +#ifndef OVERRIDE_32_wait4 +SC_LTTNG_TRACEPOINT_EVENT(wait4, + TP_PROTO(sc_exit(long ret,) pid_t upid, int * stat_addr, int options, struct rusage * ru), + TP_ARGS(sc_exit(ret,) upid, stat_addr, options, ru), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, upid, upid)) sc_out(ctf_integer(int *, stat_addr, stat_addr)) sc_in(ctf_integer(int, options, options)) sc_out(ctf_integer(struct rusage *, ru, ru))) +) +#endif +#ifndef OVERRIDE_32_quotactl +SC_LTTNG_TRACEPOINT_EVENT(quotactl, + TP_PROTO(sc_exit(long ret,) unsigned int cmd, const char * special, qid_t id, void * addr), + TP_ARGS(sc_exit(ret,) cmd, special, id, addr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_in(ctf_integer(const char *, special, special)) sc_in(ctf_integer(qid_t, id, id)) sc_inout(ctf_integer(void *, addr, addr))) +) +#endif +#ifndef OVERRIDE_32_rt_sigaction +SC_LTTNG_TRACEPOINT_EVENT(rt_sigaction, + TP_PROTO(sc_exit(long ret,) int sig, const struct sigaction * act, struct sigaction * oact, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) sig, act, oact, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, sig, sig)) sc_in(ctf_integer(const struct sigaction *, act, act)) sc_out(ctf_integer(struct sigaction *, oact, oact)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) +) +#endif +#ifndef OVERRIDE_32_rt_sigprocmask +SC_LTTNG_TRACEPOINT_EVENT(rt_sigprocmask, + TP_PROTO(sc_exit(long ret,) int how, sigset_t * nset, sigset_t * oset, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) how, nset, oset, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, how, how)) sc_in(ctf_integer(sigset_t *, nset, nset)) sc_out(ctf_integer(sigset_t *, oset, oset)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) +) +#endif +#ifndef OVERRIDE_32_rt_sigtimedwait +SC_LTTNG_TRACEPOINT_EVENT(rt_sigtimedwait, + TP_PROTO(sc_exit(long ret,) const sigset_t * uthese, siginfo_t * uinfo, const struct timespec * uts, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) uthese, uinfo, uts, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(const sigset_t *, uthese, uthese)) sc_out(ctf_integer(siginfo_t *, uinfo, uinfo)) sc_in(ctf_integer(const struct timespec *, uts, uts)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) +) +#endif +#ifndef OVERRIDE_32_sendfile +SC_LTTNG_TRACEPOINT_EVENT(sendfile, + TP_PROTO(sc_exit(long ret,) int out_fd, int in_fd, off_t * offset, size_t count), + TP_ARGS(sc_exit(ret,) out_fd, in_fd, offset, count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, out_fd, out_fd)) sc_inout(ctf_integer(int, in_fd, in_fd)) sc_inout(ctf_integer(off_t *, offset, offset)) sc_inout(ctf_integer(size_t, count, count))) +) +#endif +#ifndef OVERRIDE_32_getxattr +SC_LTTNG_TRACEPOINT_EVENT(getxattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, void * value, size_t size), + TP_ARGS(sc_exit(ret,) pathname, name, value, size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_out(ctf_integer(void *, value, value)) sc_in(ctf_integer(size_t, size, size))) +) +#endif +#ifndef OVERRIDE_32_lgetxattr +SC_LTTNG_TRACEPOINT_EVENT(lgetxattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, void * value, size_t size), + TP_ARGS(sc_exit(ret,) pathname, name, value, size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_out(ctf_integer(void *, value, value)) sc_in(ctf_integer(size_t, size, size))) +) +#endif +#ifndef OVERRIDE_32_fgetxattr +SC_LTTNG_TRACEPOINT_EVENT(fgetxattr, + TP_PROTO(sc_exit(long ret,) int fd, const char * name, void * value, size_t size), + TP_ARGS(sc_exit(ret,) fd, name, value, size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(name, name)) sc_out(ctf_integer(void *, value, value)) sc_in(ctf_integer(size_t, size, size))) +) +#endif +#ifndef OVERRIDE_32_sendfile64 +SC_LTTNG_TRACEPOINT_EVENT(sendfile64, + TP_PROTO(sc_exit(long ret,) int out_fd, int in_fd, loff_t * offset, size_t count), + TP_ARGS(sc_exit(ret,) out_fd, in_fd, offset, count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, out_fd, out_fd)) sc_in(ctf_integer(int, in_fd, in_fd)) sc_inout(ctf_integer(loff_t *, offset, offset)) sc_in(ctf_integer(size_t, count, count))) +) +#endif +#ifndef OVERRIDE_32_epoll_ctl +SC_LTTNG_TRACEPOINT_EVENT(epoll_ctl, + TP_PROTO(sc_exit(long ret,) int epfd, int op, int fd, struct epoll_event * event), + TP_ARGS(sc_exit(ret,) epfd, op, fd, event), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, epfd, epfd)) sc_in(ctf_integer(int, op, op)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct epoll_event *, event, event))) +) +#endif +#ifndef OVERRIDE_32_epoll_wait +SC_LTTNG_TRACEPOINT_EVENT(epoll_wait, + TP_PROTO(sc_exit(long ret,) int epfd, struct epoll_event * events, int maxevents, int timeout), + TP_ARGS(sc_exit(ret,) epfd, events, maxevents, timeout), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, epfd, epfd)) sc_out(ctf_integer(struct epoll_event *, events, events)) sc_in(ctf_integer(int, maxevents, maxevents)) sc_in(ctf_integer(int, timeout, timeout))) +) +#endif +#ifndef OVERRIDE_32_timer_settime +SC_LTTNG_TRACEPOINT_EVENT(timer_settime, + TP_PROTO(sc_exit(long ret,) timer_t timer_id, int flags, const struct itimerspec * new_setting, struct itimerspec * old_setting), + TP_ARGS(sc_exit(ret,) timer_id, flags, new_setting, old_setting), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(const struct itimerspec *, new_setting, new_setting)) sc_out(ctf_integer(struct itimerspec *, old_setting, old_setting))) +) +#endif +#ifndef OVERRIDE_32_clock_nanosleep +SC_LTTNG_TRACEPOINT_EVENT(clock_nanosleep, + TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, int flags, const struct timespec * rqtp, struct timespec * rmtp), + TP_ARGS(sc_exit(ret,) which_clock, flags, rqtp, rmtp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(const struct timespec *, rqtp, rqtp)) sc_out(ctf_integer(struct timespec *, rmtp, rmtp))) +) +#endif +#ifndef OVERRIDE_32_mq_open +SC_LTTNG_TRACEPOINT_EVENT(mq_open, + TP_PROTO(sc_exit(long ret,) const char * u_name, int oflag, mode_t mode, struct mq_attr * u_attr), + TP_ARGS(sc_exit(ret,) u_name, oflag, mode, u_attr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(u_name, u_name)) sc_in(ctf_integer(int, oflag, oflag)) sc_in(ctf_integer(mode_t, mode, mode)) sc_in(ctf_integer(struct mq_attr *, u_attr, u_attr))) +) +#endif +#ifndef OVERRIDE_32_kexec_load +SC_LTTNG_TRACEPOINT_EVENT(kexec_load, + TP_PROTO(sc_exit(long ret,) unsigned long entry, unsigned long nr_segments, struct kexec_segment * segments, unsigned long flags), + TP_ARGS(sc_exit(ret,) entry, nr_segments, segments, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, entry, entry)) sc_in(ctf_integer(unsigned long, nr_segments, nr_segments)) sc_in(ctf_integer(struct kexec_segment *, segments, segments)) sc_in(ctf_integer(unsigned long, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_request_key +SC_LTTNG_TRACEPOINT_EVENT(request_key, + TP_PROTO(sc_exit(long ret,) const char * _type, const char * _description, const char * _callout_info, key_serial_t destringid), + TP_ARGS(sc_exit(ret,) _type, _description, _callout_info, destringid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(_type, _type)) sc_in(ctf_integer(const char *, _description, _description)) sc_in(ctf_integer(const char *, _callout_info, _callout_info)) sc_in(ctf_integer(key_serial_t, destringid, destringid))) +) +#endif +#ifndef OVERRIDE_32_openat +SC_LTTNG_TRACEPOINT_EVENT(openat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, int flags, int mode), + TP_ARGS(sc_exit(ret,) dfd, filename, flags, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(int, mode, mode))) +) +#endif +#ifndef OVERRIDE_32_mknodat +SC_LTTNG_TRACEPOINT_EVENT(mknodat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, int mode, unsigned dev), + TP_ARGS(sc_exit(ret,) dfd, filename, mode, dev), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, mode, mode)) sc_in(ctf_integer(unsigned, dev, dev))) +) +#endif +#ifndef OVERRIDE_32_fstatat64 +SC_LTTNG_TRACEPOINT_EVENT(fstatat64, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, struct stat64 * statbuf, int flag), + TP_ARGS(sc_exit(ret,) dfd, filename, statbuf, flag), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, dfd, dfd)) sc_inout(ctf_user_string(filename, filename)) sc_inout(ctf_integer(struct stat64 *, statbuf, statbuf)) sc_inout(ctf_integer(int, flag, flag))) +) +#endif +#ifndef OVERRIDE_32_renameat +SC_LTTNG_TRACEPOINT_EVENT(renameat, + TP_PROTO(sc_exit(long ret,) int olddfd, const char * oldname, int newdfd, const char * newname), + TP_ARGS(sc_exit(ret,) olddfd, oldname, newdfd, newname), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, olddfd, olddfd)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_integer(int, newdfd, newdfd)) sc_in(ctf_user_string(newname, newname))) +) +#endif +#ifndef OVERRIDE_32_readlinkat +SC_LTTNG_TRACEPOINT_EVENT(readlinkat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * pathname, char * buf, int bufsiz), + TP_ARGS(sc_exit(ret,) dfd, pathname, buf, bufsiz), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(int, bufsiz, bufsiz))) +) +#endif +#ifndef OVERRIDE_32_vmsplice +SC_LTTNG_TRACEPOINT_EVENT(vmsplice, + TP_PROTO(sc_exit(long ret,) int fd, const struct iovec * iov, unsigned long nr_segs, unsigned int flags), + TP_ARGS(sc_exit(ret,) fd, iov, nr_segs, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(const struct iovec *, iov, iov)) sc_in(ctf_integer(unsigned long, nr_segs, nr_segs)) sc_in(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_utimensat +SC_LTTNG_TRACEPOINT_EVENT(utimensat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, struct timespec * utimes, int flags), + TP_ARGS(sc_exit(ret,) dfd, filename, utimes, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(struct timespec *, utimes, utimes)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_timerfd_settime +SC_LTTNG_TRACEPOINT_EVENT(timerfd_settime, + TP_PROTO(sc_exit(long ret,) int ufd, int flags, const struct itimerspec * utmr, struct itimerspec * otmr), + TP_ARGS(sc_exit(ret,) ufd, flags, utmr, otmr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(const struct itimerspec *, utmr, utmr)) sc_out(ctf_integer(struct itimerspec *, otmr, otmr))) +) +#endif +#ifndef OVERRIDE_32_signalfd4 +SC_LTTNG_TRACEPOINT_EVENT(signalfd4, + TP_PROTO(sc_exit(long ret,) int ufd, sigset_t * user_mask, size_t sizemask, int flags), + TP_ARGS(sc_exit(ret,) ufd, user_mask, sizemask, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_in(ctf_integer(sigset_t *, user_mask, user_mask)) sc_in(ctf_integer(size_t, sizemask, sizemask)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_rt_tgsigqueueinfo +SC_LTTNG_TRACEPOINT_EVENT(rt_tgsigqueueinfo, + TP_PROTO(sc_exit(long ret,) pid_t tgid, pid_t pid, int sig, siginfo_t * uinfo), + TP_ARGS(sc_exit(ret,) tgid, pid, sig, uinfo), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, tgid, tgid)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig)) sc_in(ctf_integer(siginfo_t *, uinfo, uinfo))) +) +#endif +#ifndef OVERRIDE_32_prlimit64 +SC_LTTNG_TRACEPOINT_EVENT(prlimit64, + TP_PROTO(sc_exit(long ret,) pid_t pid, unsigned int resource, const struct rlimit64 * new_rlim, struct rlimit64 * old_rlim), + TP_ARGS(sc_exit(ret,) pid, resource, new_rlim, old_rlim), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(unsigned int, resource, resource)) sc_in(ctf_integer(const struct rlimit64 *, new_rlim, new_rlim)) sc_out(ctf_integer(struct rlimit64 *, old_rlim, old_rlim))) +) +#endif +#ifndef OVERRIDE_32_sendmmsg +SC_LTTNG_TRACEPOINT_EVENT(sendmmsg, + TP_PROTO(sc_exit(long ret,) int fd, struct mmsghdr * mmsg, unsigned int vlen, unsigned int flags), + TP_ARGS(sc_exit(ret,) fd, mmsg, vlen, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct mmsghdr *, mmsg, mmsg)) sc_in(ctf_integer(unsigned int, vlen, vlen)) sc_in(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_mount +SC_LTTNG_TRACEPOINT_EVENT(mount, + TP_PROTO(sc_exit(long ret,) char * dev_name, char * dir_name, char * type, unsigned long flags, void * data), + TP_ARGS(sc_exit(ret,) dev_name, dir_name, type, flags, data), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(dev_name, dev_name)) sc_in(ctf_user_string(dir_name, dir_name)) sc_in(ctf_user_string(type, type)) sc_in(ctf_integer(unsigned long, flags, flags)) sc_in(ctf_integer(void *, data, data))) +) +#endif +#ifndef OVERRIDE_32_llseek +SC_LTTNG_TRACEPOINT_EVENT(llseek, + TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned long offset_high, unsigned long offset_low, loff_t * result, unsigned int origin), + TP_ARGS(sc_exit(ret,) fd, offset_high, offset_low, result, origin), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, fd, fd)) sc_inout(ctf_integer(unsigned long, offset_high, offset_high)) sc_inout(ctf_integer(unsigned long, offset_low, offset_low)) sc_inout(ctf_integer(loff_t *, result, result)) sc_inout(ctf_integer(unsigned int, origin, origin))) +) +#endif +#ifndef OVERRIDE_32_select +SC_LTTNG_TRACEPOINT_EVENT(select, + TP_PROTO(sc_exit(long ret,) int n, fd_set * inp, fd_set * outp, fd_set * exp, struct timeval * tvp), + TP_ARGS(sc_exit(ret,) n, inp, outp, exp, tvp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, n, n)) sc_inout(ctf_integer(fd_set *, inp, inp)) sc_inout(ctf_integer(fd_set *, outp, outp)) sc_inout(ctf_integer(fd_set *, exp, exp)) sc_inout(ctf_integer(struct timeval *, tvp, tvp))) +) +#endif +#ifndef OVERRIDE_32_setxattr +SC_LTTNG_TRACEPOINT_EVENT(setxattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, const void * value, size_t size, int flags), + TP_ARGS(sc_exit(ret,) pathname, name, value, size, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(const void *, value, value)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_lsetxattr +SC_LTTNG_TRACEPOINT_EVENT(lsetxattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, const void * value, size_t size, int flags), + TP_ARGS(sc_exit(ret,) pathname, name, value, size, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(const void *, value, value)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_fsetxattr +SC_LTTNG_TRACEPOINT_EVENT(fsetxattr, + TP_PROTO(sc_exit(long ret,) int fd, const char * name, const void * value, size_t size, int flags), + TP_ARGS(sc_exit(ret,) fd, name, value, size, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(const void *, value, value)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_io_getevents +SC_LTTNG_TRACEPOINT_EVENT(io_getevents, + TP_PROTO(sc_exit(long ret,) aio_context_t ctx_id, long min_nr, long nr, struct io_event * events, struct timespec * timeout), + TP_ARGS(sc_exit(ret,) ctx_id, min_nr, nr, events, timeout), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx_id, ctx_id)) sc_in(ctf_integer(long, min_nr, min_nr)) sc_in(ctf_integer(long, nr, nr)) sc_out(ctf_integer(struct io_event *, events, events)) sc_inout(ctf_integer(struct timespec *, timeout, timeout))) +) +#endif +#ifndef OVERRIDE_32_mq_timedsend +SC_LTTNG_TRACEPOINT_EVENT(mq_timedsend, + TP_PROTO(sc_exit(long ret,) mqd_t mqdes, const char * u_msg_ptr, size_t msg_len, unsigned int msg_prio, const struct timespec * u_abs_timeout), + TP_ARGS(sc_exit(ret,) mqdes, u_msg_ptr, msg_len, msg_prio, u_abs_timeout), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(mqd_t, mqdes, mqdes)) sc_in(ctf_integer(const char *, u_msg_ptr, u_msg_ptr)) sc_in(ctf_integer(size_t, msg_len, msg_len)) sc_in(ctf_integer(unsigned int, msg_prio, msg_prio)) sc_in(ctf_integer(const struct timespec *, u_abs_timeout, u_abs_timeout))) +) +#endif +#ifndef OVERRIDE_32_mq_timedreceive +SC_LTTNG_TRACEPOINT_EVENT(mq_timedreceive, + TP_PROTO(sc_exit(long ret,) mqd_t mqdes, char * u_msg_ptr, size_t msg_len, unsigned int * u_msg_prio, const struct timespec * u_abs_timeout), + TP_ARGS(sc_exit(ret,) mqdes, u_msg_ptr, msg_len, u_msg_prio, u_abs_timeout), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(mqd_t, mqdes, mqdes)) sc_out(ctf_integer(char *, u_msg_ptr, u_msg_ptr)) sc_in(ctf_integer(size_t, msg_len, msg_len)) sc_out(ctf_integer(unsigned int *, u_msg_prio, u_msg_prio)) sc_in(ctf_integer(const struct timespec *, u_abs_timeout, u_abs_timeout))) +) +#endif +#ifndef OVERRIDE_32_waitid +SC_LTTNG_TRACEPOINT_EVENT(waitid, + TP_PROTO(sc_exit(long ret,) int which, pid_t upid, struct siginfo * infop, int options, struct rusage * ru), + TP_ARGS(sc_exit(ret,) which, upid, infop, options, ru), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(pid_t, upid, upid)) sc_out(ctf_integer(struct siginfo *, infop, infop)) sc_in(ctf_integer(int, options, options)) sc_out(ctf_integer(struct rusage *, ru, ru))) +) +#endif +#ifndef OVERRIDE_32_add_key +SC_LTTNG_TRACEPOINT_EVENT(add_key, + TP_PROTO(sc_exit(long ret,) const char * _type, const char * _description, const void * _payload, size_t plen, key_serial_t ringid), + TP_ARGS(sc_exit(ret,) _type, _description, _payload, plen, ringid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(_type, _type)) sc_in(ctf_integer(const char *, _description, _description)) sc_in(ctf_integer(const void *, _payload, _payload)) sc_in(ctf_integer(size_t, plen, plen)) sc_in(ctf_integer(key_serial_t, ringid, ringid))) +) +#endif +#ifndef OVERRIDE_32_fchownat +SC_LTTNG_TRACEPOINT_EVENT(fchownat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, uid_t user, gid_t group, int flag), + TP_ARGS(sc_exit(ret,) dfd, filename, user, group, flag), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group)) sc_in(ctf_integer(int, flag, flag))) +) +#endif +#ifndef OVERRIDE_32_linkat +SC_LTTNG_TRACEPOINT_EVENT(linkat, + TP_PROTO(sc_exit(long ret,) int olddfd, const char * oldname, int newdfd, const char * newname, int flags), + TP_ARGS(sc_exit(ret,) olddfd, oldname, newdfd, newname, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, olddfd, olddfd)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_integer(int, newdfd, newdfd)) sc_in(ctf_user_string(newname, newname)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_ppoll +SC_LTTNG_TRACEPOINT_EVENT(ppoll, + TP_PROTO(sc_exit(long ret,) struct pollfd * ufds, unsigned int nfds, struct timespec * tsp, const sigset_t * sigmask, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) ufds, nfds, tsp, sigmask, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct pollfd *, ufds, ufds)) sc_in(ctf_integer(unsigned int, nfds, nfds)) sc_in(ctf_integer(struct timespec *, tsp, tsp)) sc_in(ctf_integer(const sigset_t *, sigmask, sigmask)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) +) +#endif +#ifndef OVERRIDE_32_preadv +SC_LTTNG_TRACEPOINT_EVENT(preadv, + TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen, unsigned long pos_l, unsigned long pos_h), + TP_ARGS(sc_exit(ret,) fd, vec, vlen, pos_l, pos_h), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_out(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen)) sc_in(ctf_integer(unsigned long, pos_l, pos_l)) sc_in(ctf_integer(unsigned long, pos_h, pos_h))) +) +#endif +#ifndef OVERRIDE_32_pwritev +SC_LTTNG_TRACEPOINT_EVENT(pwritev, + TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen, unsigned long pos_l, unsigned long pos_h), + TP_ARGS(sc_exit(ret,) fd, vec, vlen, pos_l, pos_h), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_in(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen)) sc_in(ctf_integer(unsigned long, pos_l, pos_l)) sc_in(ctf_integer(unsigned long, pos_h, pos_h))) +) +#endif +#ifndef OVERRIDE_32_perf_event_open +SC_LTTNG_TRACEPOINT_EVENT(perf_event_open, + TP_PROTO(sc_exit(long ret,) struct perf_event_attr * attr_uptr, pid_t pid, int cpu, int group_fd, unsigned long flags), + TP_ARGS(sc_exit(ret,) attr_uptr, pid, cpu, group_fd, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct perf_event_attr *, attr_uptr, attr_uptr)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, cpu, cpu)) sc_in(ctf_integer(int, group_fd, group_fd)) sc_in(ctf_integer(unsigned long, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_recvmmsg +SC_LTTNG_TRACEPOINT_EVENT(recvmmsg, + TP_PROTO(sc_exit(long ret,) int fd, struct mmsghdr * mmsg, unsigned int vlen, unsigned int flags, struct timespec * timeout), + TP_ARGS(sc_exit(ret,) fd, mmsg, vlen, flags, timeout), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct mmsghdr *, mmsg, mmsg)) sc_in(ctf_integer(unsigned int, vlen, vlen)) sc_in(ctf_integer(unsigned int, flags, flags)) sc_inout(ctf_integer(struct timespec *, timeout, timeout))) +) +#endif +#ifndef OVERRIDE_32_ipc +SC_LTTNG_TRACEPOINT_EVENT(ipc, + TP_PROTO(sc_exit(long ret,) unsigned int call, int first, unsigned long second, unsigned long third, void * ptr, long fifth), + TP_ARGS(sc_exit(ret,) call, first, second, third, ptr, fifth), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, call, call)) sc_inout(ctf_integer(int, first, first)) sc_inout(ctf_integer(unsigned long, second, second)) sc_inout(ctf_integer(unsigned long, third, third)) sc_inout(ctf_integer(void *, ptr, ptr)) sc_inout(ctf_integer(long, fifth, fifth))) +) +#endif +#ifndef OVERRIDE_32_futex +SC_LTTNG_TRACEPOINT_EVENT(futex, + TP_PROTO(sc_exit(long ret,) u32 * uaddr, int op, u32 val, struct timespec * utime, u32 * uaddr2, u32 val3), + TP_ARGS(sc_exit(ret,) uaddr, op, val, utime, uaddr2, val3), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(u32 *, uaddr, uaddr)) sc_in(ctf_integer(int, op, op)) sc_in(ctf_integer(u32, val, val)) sc_in(ctf_integer(struct timespec *, utime, utime)) sc_inout(ctf_integer(u32 *, uaddr2, uaddr2)) sc_in(ctf_integer(u32, val3, val3))) +) +#endif +#ifndef OVERRIDE_32_pselect6 +SC_LTTNG_TRACEPOINT_EVENT(pselect6, + TP_PROTO(sc_exit(long ret,) int n, fd_set * inp, fd_set * outp, fd_set * exp, struct timespec * tsp, void * sig), + TP_ARGS(sc_exit(ret,) n, inp, outp, exp, tsp, sig), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, n, n)) sc_inout(ctf_integer(fd_set *, inp, inp)) sc_inout(ctf_integer(fd_set *, outp, outp)) sc_inout(ctf_integer(fd_set *, exp, exp)) sc_inout(ctf_integer(struct timespec *, tsp, tsp)) sc_in(ctf_integer(void *, sig, sig))) +) +#endif +#ifndef OVERRIDE_32_splice +SC_LTTNG_TRACEPOINT_EVENT(splice, + TP_PROTO(sc_exit(long ret,) int fd_in, loff_t * off_in, int fd_out, loff_t * off_out, size_t len, unsigned int flags), + TP_ARGS(sc_exit(ret,) fd_in, off_in, fd_out, off_out, len, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd_in, fd_in)) sc_in(ctf_integer(loff_t *, off_in, off_in)) sc_in(ctf_integer(int, fd_out, fd_out)) sc_in(ctf_integer(loff_t *, off_out, off_out)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_32_epoll_pwait +SC_LTTNG_TRACEPOINT_EVENT(epoll_pwait, + TP_PROTO(sc_exit(long ret,) int epfd, struct epoll_event * events, int maxevents, int timeout, const sigset_t * sigmask, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) epfd, events, maxevents, timeout, sigmask, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, epfd, epfd)) sc_out(ctf_integer(struct epoll_event *, events, events)) sc_in(ctf_integer(int, maxevents, maxevents)) sc_in(ctf_integer(int, timeout, timeout)) sc_in(ctf_integer(const sigset_t *, sigmask, sigmask)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) +) +#endif + +#endif /* _TRACE_SYSCALLS_POINTERS_H */ + +/* This part must be outside protection */ +#include + +#else /* CREATE_SYSCALL_TABLE */ + +#include "x86-32-syscalls_pointers_override.h" +#include "syscalls_pointers_override.h" + +#ifndef OVERRIDE_TABLE_32_read +TRACE_SYSCALL_TABLE(read, read, 3, 3) +#endif +#ifndef OVERRIDE_TABLE_32_write +TRACE_SYSCALL_TABLE(write, write, 4, 3) +#endif +#ifndef OVERRIDE_TABLE_32_open +TRACE_SYSCALL_TABLE(open, open, 5, 3) +#endif +#ifndef OVERRIDE_TABLE_32_waitpid +TRACE_SYSCALL_TABLE(waitpid, waitpid, 7, 3) +#endif +#ifndef OVERRIDE_TABLE_32_creat +TRACE_SYSCALL_TABLE(creat, creat, 8, 2) +#endif +#ifndef OVERRIDE_TABLE_32_link +TRACE_SYSCALL_TABLE(link, link, 9, 2) +#endif +#ifndef OVERRIDE_TABLE_32_unlink +TRACE_SYSCALL_TABLE(unlink, unlink, 10, 1) +#endif +#ifndef OVERRIDE_TABLE_32_chdir +TRACE_SYSCALL_TABLE(chdir, chdir, 12, 1) +#endif +#ifndef OVERRIDE_TABLE_32_time +TRACE_SYSCALL_TABLE(time, time, 13, 1) +#endif +#ifndef OVERRIDE_TABLE_32_mknod +TRACE_SYSCALL_TABLE(mknod, mknod, 14, 3) +#endif +#ifndef OVERRIDE_TABLE_32_chmod +TRACE_SYSCALL_TABLE(chmod, chmod, 15, 2) +#endif +#ifndef OVERRIDE_TABLE_32_lchown16 +TRACE_SYSCALL_TABLE(lchown16, lchown16, 16, 3) +#endif +#ifndef OVERRIDE_TABLE_32_stat +TRACE_SYSCALL_TABLE(stat, stat, 18, 2) +#endif +#ifndef OVERRIDE_TABLE_32_mount +TRACE_SYSCALL_TABLE(mount, mount, 21, 5) +#endif +#ifndef OVERRIDE_TABLE_32_oldumount +TRACE_SYSCALL_TABLE(oldumount, oldumount, 22, 1) +#endif +#ifndef OVERRIDE_TABLE_32_stime +TRACE_SYSCALL_TABLE(stime, stime, 25, 1) +#endif +#ifndef OVERRIDE_TABLE_32_fstat +TRACE_SYSCALL_TABLE(fstat, fstat, 28, 2) +#endif +#ifndef OVERRIDE_TABLE_32_utime +TRACE_SYSCALL_TABLE(utime, utime, 30, 2) +#endif +#ifndef OVERRIDE_TABLE_32_access +TRACE_SYSCALL_TABLE(access, access, 33, 2) +#endif +#ifndef OVERRIDE_TABLE_32_rename +TRACE_SYSCALL_TABLE(rename, rename, 38, 2) +#endif +#ifndef OVERRIDE_TABLE_32_mkdir +TRACE_SYSCALL_TABLE(mkdir, mkdir, 39, 2) +#endif +#ifndef OVERRIDE_TABLE_32_rmdir +TRACE_SYSCALL_TABLE(rmdir, rmdir, 40, 1) +#endif +#ifndef OVERRIDE_TABLE_32_pipe +TRACE_SYSCALL_TABLE(pipe, pipe, 42, 1) +#endif +#ifndef OVERRIDE_TABLE_32_times +TRACE_SYSCALL_TABLE(times, times, 43, 1) +#endif +#ifndef OVERRIDE_TABLE_32_acct +TRACE_SYSCALL_TABLE(acct, acct, 51, 1) +#endif +#ifndef OVERRIDE_TABLE_32_umount +TRACE_SYSCALL_TABLE(umount, umount, 52, 2) +#endif +#ifndef OVERRIDE_TABLE_32_olduname +TRACE_SYSCALL_TABLE(olduname, olduname, 59, 1) +#endif +#ifndef OVERRIDE_TABLE_32_chroot +TRACE_SYSCALL_TABLE(chroot, chroot, 61, 1) +#endif +#ifndef OVERRIDE_TABLE_32_ustat +TRACE_SYSCALL_TABLE(ustat, ustat, 62, 2) +#endif +#ifndef OVERRIDE_TABLE_32_sigpending +TRACE_SYSCALL_TABLE(sigpending, sigpending, 73, 1) +#endif +#ifndef OVERRIDE_TABLE_32_sethostname +TRACE_SYSCALL_TABLE(sethostname, sethostname, 74, 2) +#endif +#ifndef OVERRIDE_TABLE_32_setrlimit +TRACE_SYSCALL_TABLE(setrlimit, setrlimit, 75, 2) +#endif +#ifndef OVERRIDE_TABLE_32_old_getrlimit +TRACE_SYSCALL_TABLE(old_getrlimit, old_getrlimit, 76, 2) +#endif +#ifndef OVERRIDE_TABLE_32_getrusage +TRACE_SYSCALL_TABLE(getrusage, getrusage, 77, 2) +#endif +#ifndef OVERRIDE_TABLE_32_gettimeofday +TRACE_SYSCALL_TABLE(gettimeofday, gettimeofday, 78, 2) +#endif +#ifndef OVERRIDE_TABLE_32_settimeofday +TRACE_SYSCALL_TABLE(settimeofday, settimeofday, 79, 2) +#endif +#ifndef OVERRIDE_TABLE_32_getgroups16 +TRACE_SYSCALL_TABLE(getgroups16, getgroups16, 80, 2) +#endif +#ifndef OVERRIDE_TABLE_32_setgroups16 +TRACE_SYSCALL_TABLE(setgroups16, setgroups16, 81, 2) +#endif +#ifndef OVERRIDE_TABLE_32_old_select +TRACE_SYSCALL_TABLE(old_select, old_select, 82, 1) +#endif +#ifndef OVERRIDE_TABLE_32_symlink +TRACE_SYSCALL_TABLE(symlink, symlink, 83, 2) +#endif +#ifndef OVERRIDE_TABLE_32_lstat +TRACE_SYSCALL_TABLE(lstat, lstat, 84, 2) +#endif +#ifndef OVERRIDE_TABLE_32_readlink +TRACE_SYSCALL_TABLE(readlink, readlink, 85, 3) +#endif +#ifndef OVERRIDE_TABLE_32_uselib +TRACE_SYSCALL_TABLE(uselib, uselib, 86, 1) +#endif +#ifndef OVERRIDE_TABLE_32_swapon +TRACE_SYSCALL_TABLE(swapon, swapon, 87, 2) +#endif +#ifndef OVERRIDE_TABLE_32_reboot +TRACE_SYSCALL_TABLE(reboot, reboot, 88, 4) +#endif +#ifndef OVERRIDE_TABLE_32_old_readdir +TRACE_SYSCALL_TABLE(old_readdir, old_readdir, 89, 3) +#endif +#ifndef OVERRIDE_TABLE_32_old_mmap +TRACE_SYSCALL_TABLE(old_mmap, old_mmap, 90, 1) +#endif +#ifndef OVERRIDE_TABLE_32_truncate +TRACE_SYSCALL_TABLE(truncate, truncate, 92, 2) +#endif +#ifndef OVERRIDE_TABLE_32_statfs +TRACE_SYSCALL_TABLE(statfs, statfs, 99, 2) +#endif +#ifndef OVERRIDE_TABLE_32_fstatfs +TRACE_SYSCALL_TABLE(fstatfs, fstatfs, 100, 2) +#endif +#ifndef OVERRIDE_TABLE_32_socketcall +TRACE_SYSCALL_TABLE(socketcall, socketcall, 102, 2) +#endif +#ifndef OVERRIDE_TABLE_32_syslog +TRACE_SYSCALL_TABLE(syslog, syslog, 103, 3) +#endif +#ifndef OVERRIDE_TABLE_32_setitimer +TRACE_SYSCALL_TABLE(setitimer, setitimer, 104, 3) +#endif +#ifndef OVERRIDE_TABLE_32_getitimer +TRACE_SYSCALL_TABLE(getitimer, getitimer, 105, 2) +#endif +#ifndef OVERRIDE_TABLE_32_newstat +TRACE_SYSCALL_TABLE(newstat, newstat, 106, 2) +#endif +#ifndef OVERRIDE_TABLE_32_newlstat +TRACE_SYSCALL_TABLE(newlstat, newlstat, 107, 2) +#endif +#ifndef OVERRIDE_TABLE_32_newfstat +TRACE_SYSCALL_TABLE(newfstat, newfstat, 108, 2) +#endif +#ifndef OVERRIDE_TABLE_32_uname +TRACE_SYSCALL_TABLE(uname, uname, 109, 1) +#endif +#ifndef OVERRIDE_TABLE_32_wait4 +TRACE_SYSCALL_TABLE(wait4, wait4, 114, 4) +#endif +#ifndef OVERRIDE_TABLE_32_swapoff +TRACE_SYSCALL_TABLE(swapoff, swapoff, 115, 1) +#endif +#ifndef OVERRIDE_TABLE_32_sysinfo +TRACE_SYSCALL_TABLE(sysinfo, sysinfo, 116, 1) +#endif +#ifndef OVERRIDE_TABLE_32_ipc +TRACE_SYSCALL_TABLE(ipc, ipc, 117, 6) +#endif +#ifndef OVERRIDE_TABLE_32_setdomainname +TRACE_SYSCALL_TABLE(setdomainname, setdomainname, 121, 2) +#endif +#ifndef OVERRIDE_TABLE_32_newuname +TRACE_SYSCALL_TABLE(newuname, newuname, 122, 1) +#endif +#ifndef OVERRIDE_TABLE_32_adjtimex +TRACE_SYSCALL_TABLE(adjtimex, adjtimex, 124, 1) +#endif +#ifndef OVERRIDE_TABLE_32_sigprocmask +TRACE_SYSCALL_TABLE(sigprocmask, sigprocmask, 126, 3) +#endif +#ifndef OVERRIDE_TABLE_32_init_module +TRACE_SYSCALL_TABLE(init_module, init_module, 128, 3) +#endif +#ifndef OVERRIDE_TABLE_32_delete_module +TRACE_SYSCALL_TABLE(delete_module, delete_module, 129, 2) +#endif +#ifndef OVERRIDE_TABLE_32_quotactl +TRACE_SYSCALL_TABLE(quotactl, quotactl, 131, 4) +#endif +#ifndef OVERRIDE_TABLE_32_llseek +TRACE_SYSCALL_TABLE(llseek, llseek, 140, 5) +#endif +#ifndef OVERRIDE_TABLE_32_getdents +TRACE_SYSCALL_TABLE(getdents, getdents, 141, 3) +#endif +#ifndef OVERRIDE_TABLE_32_select +TRACE_SYSCALL_TABLE(select, select, 142, 5) +#endif +#ifndef OVERRIDE_TABLE_32_readv +TRACE_SYSCALL_TABLE(readv, readv, 145, 3) +#endif +#ifndef OVERRIDE_TABLE_32_writev +TRACE_SYSCALL_TABLE(writev, writev, 146, 3) +#endif +#ifndef OVERRIDE_TABLE_32_sysctl +TRACE_SYSCALL_TABLE(sysctl, sysctl, 149, 1) +#endif +#ifndef OVERRIDE_TABLE_32_sched_setparam +TRACE_SYSCALL_TABLE(sched_setparam, sched_setparam, 154, 2) +#endif +#ifndef OVERRIDE_TABLE_32_sched_getparam +TRACE_SYSCALL_TABLE(sched_getparam, sched_getparam, 155, 2) +#endif +#ifndef OVERRIDE_TABLE_32_sched_setscheduler +TRACE_SYSCALL_TABLE(sched_setscheduler, sched_setscheduler, 156, 3) +#endif +#ifndef OVERRIDE_TABLE_32_sched_rr_get_interval +TRACE_SYSCALL_TABLE(sched_rr_get_interval, sched_rr_get_interval, 161, 2) +#endif +#ifndef OVERRIDE_TABLE_32_nanosleep +TRACE_SYSCALL_TABLE(nanosleep, nanosleep, 162, 2) +#endif +#ifndef OVERRIDE_TABLE_32_getresuid16 +TRACE_SYSCALL_TABLE(getresuid16, getresuid16, 165, 3) +#endif +#ifndef OVERRIDE_TABLE_32_poll +TRACE_SYSCALL_TABLE(poll, poll, 168, 3) +#endif +#ifndef OVERRIDE_TABLE_32_getresgid16 +TRACE_SYSCALL_TABLE(getresgid16, getresgid16, 171, 3) +#endif +#ifndef OVERRIDE_TABLE_32_rt_sigaction +TRACE_SYSCALL_TABLE(rt_sigaction, rt_sigaction, 174, 4) +#endif +#ifndef OVERRIDE_TABLE_32_rt_sigprocmask +TRACE_SYSCALL_TABLE(rt_sigprocmask, rt_sigprocmask, 175, 4) +#endif +#ifndef OVERRIDE_TABLE_32_rt_sigpending +TRACE_SYSCALL_TABLE(rt_sigpending, rt_sigpending, 176, 2) +#endif +#ifndef OVERRIDE_TABLE_32_rt_sigtimedwait +TRACE_SYSCALL_TABLE(rt_sigtimedwait, rt_sigtimedwait, 177, 4) +#endif +#ifndef OVERRIDE_TABLE_32_rt_sigqueueinfo +TRACE_SYSCALL_TABLE(rt_sigqueueinfo, rt_sigqueueinfo, 178, 3) +#endif +#ifndef OVERRIDE_TABLE_32_rt_sigsuspend +TRACE_SYSCALL_TABLE(rt_sigsuspend, rt_sigsuspend, 179, 2) +#endif +#ifndef OVERRIDE_TABLE_32_chown16 +TRACE_SYSCALL_TABLE(chown16, chown16, 182, 3) +#endif +#ifndef OVERRIDE_TABLE_32_getcwd +TRACE_SYSCALL_TABLE(getcwd, getcwd, 183, 2) +#endif +#ifndef OVERRIDE_TABLE_32_sendfile +TRACE_SYSCALL_TABLE(sendfile, sendfile, 187, 4) +#endif +#ifndef OVERRIDE_TABLE_32_getrlimit +TRACE_SYSCALL_TABLE(getrlimit, getrlimit, 191, 2) +#endif +#ifndef OVERRIDE_TABLE_32_stat64 +TRACE_SYSCALL_TABLE(stat64, stat64, 195, 2) +#endif +#ifndef OVERRIDE_TABLE_32_lstat64 +TRACE_SYSCALL_TABLE(lstat64, lstat64, 196, 2) +#endif +#ifndef OVERRIDE_TABLE_32_fstat64 +TRACE_SYSCALL_TABLE(fstat64, fstat64, 197, 2) +#endif +#ifndef OVERRIDE_TABLE_32_lchown +TRACE_SYSCALL_TABLE(lchown, lchown, 198, 3) +#endif +#ifndef OVERRIDE_TABLE_32_getgroups +TRACE_SYSCALL_TABLE(getgroups, getgroups, 205, 2) +#endif +#ifndef OVERRIDE_TABLE_32_setgroups +TRACE_SYSCALL_TABLE(setgroups, setgroups, 206, 2) +#endif +#ifndef OVERRIDE_TABLE_32_getresuid +TRACE_SYSCALL_TABLE(getresuid, getresuid, 209, 3) +#endif +#ifndef OVERRIDE_TABLE_32_getresgid +TRACE_SYSCALL_TABLE(getresgid, getresgid, 211, 3) +#endif +#ifndef OVERRIDE_TABLE_32_chown +TRACE_SYSCALL_TABLE(chown, chown, 212, 3) +#endif +#ifndef OVERRIDE_TABLE_32_pivot_root +TRACE_SYSCALL_TABLE(pivot_root, pivot_root, 217, 2) +#endif +#ifndef OVERRIDE_TABLE_32_mincore +TRACE_SYSCALL_TABLE(mincore, mincore, 218, 3) +#endif +#ifndef OVERRIDE_TABLE_32_getdents64 +TRACE_SYSCALL_TABLE(getdents64, getdents64, 220, 3) +#endif +#ifndef OVERRIDE_TABLE_32_setxattr +TRACE_SYSCALL_TABLE(setxattr, setxattr, 226, 5) +#endif +#ifndef OVERRIDE_TABLE_32_lsetxattr +TRACE_SYSCALL_TABLE(lsetxattr, lsetxattr, 227, 5) +#endif +#ifndef OVERRIDE_TABLE_32_fsetxattr +TRACE_SYSCALL_TABLE(fsetxattr, fsetxattr, 228, 5) +#endif +#ifndef OVERRIDE_TABLE_32_getxattr +TRACE_SYSCALL_TABLE(getxattr, getxattr, 229, 4) +#endif +#ifndef OVERRIDE_TABLE_32_lgetxattr +TRACE_SYSCALL_TABLE(lgetxattr, lgetxattr, 230, 4) +#endif +#ifndef OVERRIDE_TABLE_32_fgetxattr +TRACE_SYSCALL_TABLE(fgetxattr, fgetxattr, 231, 4) +#endif +#ifndef OVERRIDE_TABLE_32_listxattr +TRACE_SYSCALL_TABLE(listxattr, listxattr, 232, 3) +#endif +#ifndef OVERRIDE_TABLE_32_llistxattr +TRACE_SYSCALL_TABLE(llistxattr, llistxattr, 233, 3) +#endif +#ifndef OVERRIDE_TABLE_32_flistxattr +TRACE_SYSCALL_TABLE(flistxattr, flistxattr, 234, 3) +#endif +#ifndef OVERRIDE_TABLE_32_removexattr +TRACE_SYSCALL_TABLE(removexattr, removexattr, 235, 2) +#endif +#ifndef OVERRIDE_TABLE_32_lremovexattr +TRACE_SYSCALL_TABLE(lremovexattr, lremovexattr, 236, 2) +#endif +#ifndef OVERRIDE_TABLE_32_fremovexattr +TRACE_SYSCALL_TABLE(fremovexattr, fremovexattr, 237, 2) +#endif +#ifndef OVERRIDE_TABLE_32_sendfile64 +TRACE_SYSCALL_TABLE(sendfile64, sendfile64, 239, 4) +#endif +#ifndef OVERRIDE_TABLE_32_futex +TRACE_SYSCALL_TABLE(futex, futex, 240, 6) +#endif +#ifndef OVERRIDE_TABLE_32_sched_setaffinity +TRACE_SYSCALL_TABLE(sched_setaffinity, sched_setaffinity, 241, 3) +#endif +#ifndef OVERRIDE_TABLE_32_sched_getaffinity +TRACE_SYSCALL_TABLE(sched_getaffinity, sched_getaffinity, 242, 3) +#endif +#ifndef OVERRIDE_TABLE_32_io_setup +TRACE_SYSCALL_TABLE(io_setup, io_setup, 245, 2) +#endif +#ifndef OVERRIDE_TABLE_32_io_getevents +TRACE_SYSCALL_TABLE(io_getevents, io_getevents, 247, 5) +#endif +#ifndef OVERRIDE_TABLE_32_io_submit +TRACE_SYSCALL_TABLE(io_submit, io_submit, 248, 3) +#endif +#ifndef OVERRIDE_TABLE_32_io_cancel +TRACE_SYSCALL_TABLE(io_cancel, io_cancel, 249, 3) +#endif +#ifndef OVERRIDE_TABLE_32_epoll_ctl +TRACE_SYSCALL_TABLE(epoll_ctl, epoll_ctl, 255, 4) +#endif +#ifndef OVERRIDE_TABLE_32_epoll_wait +TRACE_SYSCALL_TABLE(epoll_wait, epoll_wait, 256, 4) +#endif +#ifndef OVERRIDE_TABLE_32_set_tid_address +TRACE_SYSCALL_TABLE(set_tid_address, set_tid_address, 258, 1) +#endif +#ifndef OVERRIDE_TABLE_32_timer_create +TRACE_SYSCALL_TABLE(timer_create, timer_create, 259, 3) +#endif +#ifndef OVERRIDE_TABLE_32_timer_settime +TRACE_SYSCALL_TABLE(timer_settime, timer_settime, 260, 4) +#endif +#ifndef OVERRIDE_TABLE_32_timer_gettime +TRACE_SYSCALL_TABLE(timer_gettime, timer_gettime, 261, 2) +#endif +#ifndef OVERRIDE_TABLE_32_clock_settime +TRACE_SYSCALL_TABLE(clock_settime, clock_settime, 264, 2) +#endif +#ifndef OVERRIDE_TABLE_32_clock_gettime +TRACE_SYSCALL_TABLE(clock_gettime, clock_gettime, 265, 2) +#endif +#ifndef OVERRIDE_TABLE_32_clock_getres +TRACE_SYSCALL_TABLE(clock_getres, clock_getres, 266, 2) +#endif +#ifndef OVERRIDE_TABLE_32_clock_nanosleep +TRACE_SYSCALL_TABLE(clock_nanosleep, clock_nanosleep, 267, 4) +#endif +#ifndef OVERRIDE_TABLE_32_statfs64 +TRACE_SYSCALL_TABLE(statfs64, statfs64, 268, 3) +#endif +#ifndef OVERRIDE_TABLE_32_fstatfs64 +TRACE_SYSCALL_TABLE(fstatfs64, fstatfs64, 269, 3) +#endif +#ifndef OVERRIDE_TABLE_32_utimes +TRACE_SYSCALL_TABLE(utimes, utimes, 271, 2) +#endif +#ifndef OVERRIDE_TABLE_32_mq_open +TRACE_SYSCALL_TABLE(mq_open, mq_open, 277, 4) +#endif +#ifndef OVERRIDE_TABLE_32_mq_unlink +TRACE_SYSCALL_TABLE(mq_unlink, mq_unlink, 278, 1) +#endif +#ifndef OVERRIDE_TABLE_32_mq_timedsend +TRACE_SYSCALL_TABLE(mq_timedsend, mq_timedsend, 279, 5) +#endif +#ifndef OVERRIDE_TABLE_32_mq_timedreceive +TRACE_SYSCALL_TABLE(mq_timedreceive, mq_timedreceive, 280, 5) +#endif +#ifndef OVERRIDE_TABLE_32_mq_notify +TRACE_SYSCALL_TABLE(mq_notify, mq_notify, 281, 2) +#endif +#ifndef OVERRIDE_TABLE_32_mq_getsetattr +TRACE_SYSCALL_TABLE(mq_getsetattr, mq_getsetattr, 282, 3) +#endif +#ifndef OVERRIDE_TABLE_32_kexec_load +TRACE_SYSCALL_TABLE(kexec_load, kexec_load, 283, 4) +#endif +#ifndef OVERRIDE_TABLE_32_waitid +TRACE_SYSCALL_TABLE(waitid, waitid, 284, 5) +#endif +#ifndef OVERRIDE_TABLE_32_add_key +TRACE_SYSCALL_TABLE(add_key, add_key, 286, 5) +#endif +#ifndef OVERRIDE_TABLE_32_request_key +TRACE_SYSCALL_TABLE(request_key, request_key, 287, 4) +#endif +#ifndef OVERRIDE_TABLE_32_inotify_add_watch +TRACE_SYSCALL_TABLE(inotify_add_watch, inotify_add_watch, 292, 3) +#endif +#ifndef OVERRIDE_TABLE_32_openat +TRACE_SYSCALL_TABLE(openat, openat, 295, 4) +#endif +#ifndef OVERRIDE_TABLE_32_mkdirat +TRACE_SYSCALL_TABLE(mkdirat, mkdirat, 296, 3) +#endif +#ifndef OVERRIDE_TABLE_32_mknodat +TRACE_SYSCALL_TABLE(mknodat, mknodat, 297, 4) +#endif +#ifndef OVERRIDE_TABLE_32_fchownat +TRACE_SYSCALL_TABLE(fchownat, fchownat, 298, 5) +#endif +#ifndef OVERRIDE_TABLE_32_futimesat +TRACE_SYSCALL_TABLE(futimesat, futimesat, 299, 3) +#endif +#ifndef OVERRIDE_TABLE_32_fstatat64 +TRACE_SYSCALL_TABLE(fstatat64, fstatat64, 300, 4) +#endif +#ifndef OVERRIDE_TABLE_32_unlinkat +TRACE_SYSCALL_TABLE(unlinkat, unlinkat, 301, 3) +#endif +#ifndef OVERRIDE_TABLE_32_renameat +TRACE_SYSCALL_TABLE(renameat, renameat, 302, 4) +#endif +#ifndef OVERRIDE_TABLE_32_linkat +TRACE_SYSCALL_TABLE(linkat, linkat, 303, 5) +#endif +#ifndef OVERRIDE_TABLE_32_symlinkat +TRACE_SYSCALL_TABLE(symlinkat, symlinkat, 304, 3) +#endif +#ifndef OVERRIDE_TABLE_32_readlinkat +TRACE_SYSCALL_TABLE(readlinkat, readlinkat, 305, 4) +#endif +#ifndef OVERRIDE_TABLE_32_fchmodat +TRACE_SYSCALL_TABLE(fchmodat, fchmodat, 306, 3) +#endif +#ifndef OVERRIDE_TABLE_32_faccessat +TRACE_SYSCALL_TABLE(faccessat, faccessat, 307, 3) +#endif +#ifndef OVERRIDE_TABLE_32_pselect6 +TRACE_SYSCALL_TABLE(pselect6, pselect6, 308, 6) +#endif +#ifndef OVERRIDE_TABLE_32_ppoll +TRACE_SYSCALL_TABLE(ppoll, ppoll, 309, 5) +#endif +#ifndef OVERRIDE_TABLE_32_set_robust_list +TRACE_SYSCALL_TABLE(set_robust_list, set_robust_list, 311, 2) +#endif +#ifndef OVERRIDE_TABLE_32_get_robust_list +TRACE_SYSCALL_TABLE(get_robust_list, get_robust_list, 312, 3) +#endif +#ifndef OVERRIDE_TABLE_32_splice +TRACE_SYSCALL_TABLE(splice, splice, 313, 6) +#endif +#ifndef OVERRIDE_TABLE_32_vmsplice +TRACE_SYSCALL_TABLE(vmsplice, vmsplice, 316, 4) +#endif +#ifndef OVERRIDE_TABLE_32_getcpu +TRACE_SYSCALL_TABLE(getcpu, getcpu, 318, 3) +#endif +#ifndef OVERRIDE_TABLE_32_epoll_pwait +TRACE_SYSCALL_TABLE(epoll_pwait, epoll_pwait, 319, 6) +#endif +#ifndef OVERRIDE_TABLE_32_utimensat +TRACE_SYSCALL_TABLE(utimensat, utimensat, 320, 4) +#endif +#ifndef OVERRIDE_TABLE_32_signalfd +TRACE_SYSCALL_TABLE(signalfd, signalfd, 321, 3) +#endif +#ifndef OVERRIDE_TABLE_32_timerfd_settime +TRACE_SYSCALL_TABLE(timerfd_settime, timerfd_settime, 325, 4) +#endif +#ifndef OVERRIDE_TABLE_32_timerfd_gettime +TRACE_SYSCALL_TABLE(timerfd_gettime, timerfd_gettime, 326, 2) +#endif +#ifndef OVERRIDE_TABLE_32_signalfd4 +TRACE_SYSCALL_TABLE(signalfd4, signalfd4, 327, 4) +#endif +#ifndef OVERRIDE_TABLE_32_pipe2 +TRACE_SYSCALL_TABLE(pipe2, pipe2, 331, 2) +#endif +#ifndef OVERRIDE_TABLE_32_preadv +TRACE_SYSCALL_TABLE(preadv, preadv, 333, 5) +#endif +#ifndef OVERRIDE_TABLE_32_pwritev +TRACE_SYSCALL_TABLE(pwritev, pwritev, 334, 5) +#endif +#ifndef OVERRIDE_TABLE_32_rt_tgsigqueueinfo +TRACE_SYSCALL_TABLE(rt_tgsigqueueinfo, rt_tgsigqueueinfo, 335, 4) +#endif +#ifndef OVERRIDE_TABLE_32_perf_event_open +TRACE_SYSCALL_TABLE(perf_event_open, perf_event_open, 336, 5) +#endif +#ifndef OVERRIDE_TABLE_32_recvmmsg +TRACE_SYSCALL_TABLE(recvmmsg, recvmmsg, 337, 5) +#endif +#ifndef OVERRIDE_TABLE_32_prlimit64 +TRACE_SYSCALL_TABLE(prlimit64, prlimit64, 340, 4) +#endif +#ifndef OVERRIDE_TABLE_32_clock_adjtime +TRACE_SYSCALL_TABLE(clock_adjtime, clock_adjtime, 343, 2) +#endif +#ifndef OVERRIDE_TABLE_32_sendmmsg +TRACE_SYSCALL_TABLE(sendmmsg, sendmmsg, 345, 4) +#endif + +#endif /* CREATE_SYSCALL_TABLE */ diff --git a/include/instrumentation/syscalls/headers/x86-32-syscalls_pointers_override.h b/include/instrumentation/syscalls/headers/x86-32-syscalls_pointers_override.h new file mode 100644 index 00000000..e93213f6 --- /dev/null +++ b/include/instrumentation/syscalls/headers/x86-32-syscalls_pointers_override.h @@ -0,0 +1,44 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ + +#ifndef CREATE_SYSCALL_TABLE + +# ifndef CONFIG_UID16 +# define OVERRIDE_32_getgroups16 +# define OVERRIDE_32_setgroups16 +# define OVERRIDE_32_lchown16 +# define OVERRIDE_32_getresuid16 +# define OVERRIDE_32_getresgid16 +# define OVERRIDE_32_chown16 +# endif + +#define OVERRIDE_32_pipe +#define OVERRIDE_64_pipe +SC_LTTNG_TRACEPOINT_EVENT(pipe, + TP_PROTO(sc_exit(long ret,) int * fildes), + TP_ARGS(sc_exit(ret,) fildes), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) + sc_out(ctf_user_array(int, fildes, fildes, 2)) + ) +) + +#else /* CREATE_SYSCALL_TABLE */ + +# ifndef CONFIG_UID16 +# define OVERRIDE_TABLE_32_getgroups16 +# define OVERRIDE_TABLE_32_setgroups16 +# define OVERRIDE_TABLE_32_lchown16 +# define OVERRIDE_TABLE_32_getresuid16 +# define OVERRIDE_TABLE_32_getresgid16 +# define OVERRIDE_TABLE_32_chown16 +# endif + +#define OVERRIDE_TABLE_32_execve +TRACE_SYSCALL_TABLE(execve, execve, 11, 3) +#define OVERRIDE_TABLE_32_clone +TRACE_SYSCALL_TABLE(clone, clone, 120, 5) +#define OVERRIDE_TABLE_32_getcpu +TRACE_SYSCALL_TABLE(getcpu, getcpu, 318, 3) + +#endif /* CREATE_SYSCALL_TABLE */ + + diff --git a/include/instrumentation/syscalls/headers/x86-64-syscalls_integers.h b/include/instrumentation/syscalls/headers/x86-64-syscalls_integers.h new file mode 100644 index 00000000..3fa8fbff --- /dev/null +++ b/include/instrumentation/syscalls/headers/x86-64-syscalls_integers.h @@ -0,0 +1,1104 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ + +/* THIS FILE IS AUTO-GENERATED. DO NOT EDIT */ + +/* Generated from x86-64-syscalls 3.10.0-rc7 */ + +#ifndef CREATE_SYSCALL_TABLE + +#if !defined(_TRACE_SYSCALLS_INTEGERS_H) || defined(TRACE_HEADER_MULTI_READ) +#define _TRACE_SYSCALLS_INTEGERS_H + +#include +#include +#include "x86-64-syscalls_integers_override.h" +#include "syscalls_integers_override.h" + +#ifdef SC_ENTER +SC_LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(syscalls_noargs, + TP_FIELDS() +) +#ifndef OVERRIDE_64_sched_yield +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, sched_yield) +#endif +#ifndef OVERRIDE_64_pause +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, pause) +#endif +#ifndef OVERRIDE_64_getpid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getpid) +#endif +#ifndef OVERRIDE_64_getuid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getuid) +#endif +#ifndef OVERRIDE_64_getgid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getgid) +#endif +#ifndef OVERRIDE_64_geteuid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, geteuid) +#endif +#ifndef OVERRIDE_64_getegid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getegid) +#endif +#ifndef OVERRIDE_64_getppid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getppid) +#endif +#ifndef OVERRIDE_64_getpgrp +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getpgrp) +#endif +#ifndef OVERRIDE_64_setsid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, setsid) +#endif +#ifndef OVERRIDE_64_munlockall +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, munlockall) +#endif +#ifndef OVERRIDE_64_vhangup +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, vhangup) +#endif +#ifndef OVERRIDE_64_sync +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, sync) +#endif +#ifndef OVERRIDE_64_gettid +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, gettid) +#endif +#ifndef OVERRIDE_64_restart_syscall +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, restart_syscall) +#endif +#ifndef OVERRIDE_64_inotify_init +SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, inotify_init) +#endif +#else /* #ifdef SC_ENTER */ +#ifndef OVERRIDE_64_sched_yield +SC_LTTNG_TRACEPOINT_EVENT(sched_yield, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_64_pause +SC_LTTNG_TRACEPOINT_EVENT(pause, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_64_getpid +SC_LTTNG_TRACEPOINT_EVENT(getpid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_64_getuid +SC_LTTNG_TRACEPOINT_EVENT(getuid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_64_getgid +SC_LTTNG_TRACEPOINT_EVENT(getgid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_64_geteuid +SC_LTTNG_TRACEPOINT_EVENT(geteuid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_64_getegid +SC_LTTNG_TRACEPOINT_EVENT(getegid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_64_getppid +SC_LTTNG_TRACEPOINT_EVENT(getppid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_64_getpgrp +SC_LTTNG_TRACEPOINT_EVENT(getpgrp, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_64_setsid +SC_LTTNG_TRACEPOINT_EVENT(setsid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_64_munlockall +SC_LTTNG_TRACEPOINT_EVENT(munlockall, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_64_vhangup +SC_LTTNG_TRACEPOINT_EVENT(vhangup, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_64_sync +SC_LTTNG_TRACEPOINT_EVENT(sync, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_64_gettid +SC_LTTNG_TRACEPOINT_EVENT(gettid, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_64_restart_syscall +SC_LTTNG_TRACEPOINT_EVENT(restart_syscall, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#ifndef OVERRIDE_64_inotify_init +SC_LTTNG_TRACEPOINT_EVENT(inotify_init, + TP_PROTO(sc_exit(long ret)), + TP_ARGS(sc_exit(ret)), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) +) +#endif +#endif /* else #ifdef SC_ENTER */ +#ifndef OVERRIDE_64_close +SC_LTTNG_TRACEPOINT_EVENT(close, + TP_PROTO(sc_exit(long ret,) unsigned int fd), + TP_ARGS(sc_exit(ret,) fd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) +) +#endif +#ifndef OVERRIDE_64_brk +SC_LTTNG_TRACEPOINT_EVENT(brk, + TP_PROTO(sc_exit(long ret,) unsigned long brk), + TP_ARGS(sc_exit(ret,) brk), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, brk, brk))) +) +#endif +#ifndef OVERRIDE_64_dup +SC_LTTNG_TRACEPOINT_EVENT(dup, + TP_PROTO(sc_exit(long ret,) unsigned int fildes), + TP_ARGS(sc_exit(ret,) fildes), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fildes, fildes))) +) +#endif +#ifndef OVERRIDE_64_alarm +SC_LTTNG_TRACEPOINT_EVENT(alarm, + TP_PROTO(sc_exit(long ret,) unsigned int seconds), + TP_ARGS(sc_exit(ret,) seconds), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, seconds, seconds))) +) +#endif +#ifndef OVERRIDE_64_exit +SC_LTTNG_TRACEPOINT_EVENT(exit, + TP_PROTO(sc_exit(long ret,) int error_code), + TP_ARGS(sc_exit(ret,) error_code), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, error_code, error_code))) +) +#endif +#ifndef OVERRIDE_64_fsync +SC_LTTNG_TRACEPOINT_EVENT(fsync, + TP_PROTO(sc_exit(long ret,) unsigned int fd), + TP_ARGS(sc_exit(ret,) fd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) +) +#endif +#ifndef OVERRIDE_64_fdatasync +SC_LTTNG_TRACEPOINT_EVENT(fdatasync, + TP_PROTO(sc_exit(long ret,) unsigned int fd), + TP_ARGS(sc_exit(ret,) fd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) +) +#endif +#ifndef OVERRIDE_64_fchdir +SC_LTTNG_TRACEPOINT_EVENT(fchdir, + TP_PROTO(sc_exit(long ret,) unsigned int fd), + TP_ARGS(sc_exit(ret,) fd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) +) +#endif +#ifndef OVERRIDE_64_umask +SC_LTTNG_TRACEPOINT_EVENT(umask, + TP_PROTO(sc_exit(long ret,) int mask), + TP_ARGS(sc_exit(ret,) mask), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, mask, mask))) +) +#endif +#ifndef OVERRIDE_64_setuid +SC_LTTNG_TRACEPOINT_EVENT(setuid, + TP_PROTO(sc_exit(long ret,) uid_t uid), + TP_ARGS(sc_exit(ret,) uid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, uid, uid))) +) +#endif +#ifndef OVERRIDE_64_setgid +SC_LTTNG_TRACEPOINT_EVENT(setgid, + TP_PROTO(sc_exit(long ret,) gid_t gid), + TP_ARGS(sc_exit(ret,) gid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, gid, gid))) +) +#endif +#ifndef OVERRIDE_64_getpgid +SC_LTTNG_TRACEPOINT_EVENT(getpgid, + TP_PROTO(sc_exit(long ret,) pid_t pid), + TP_ARGS(sc_exit(ret,) pid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid))) +) +#endif +#ifndef OVERRIDE_64_setfsuid +SC_LTTNG_TRACEPOINT_EVENT(setfsuid, + TP_PROTO(sc_exit(long ret,) uid_t uid), + TP_ARGS(sc_exit(ret,) uid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, uid, uid))) +) +#endif +#ifndef OVERRIDE_64_setfsgid +SC_LTTNG_TRACEPOINT_EVENT(setfsgid, + TP_PROTO(sc_exit(long ret,) gid_t gid), + TP_ARGS(sc_exit(ret,) gid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, gid, gid))) +) +#endif +#ifndef OVERRIDE_64_getsid +SC_LTTNG_TRACEPOINT_EVENT(getsid, + TP_PROTO(sc_exit(long ret,) pid_t pid), + TP_ARGS(sc_exit(ret,) pid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid))) +) +#endif +#ifndef OVERRIDE_64_personality +SC_LTTNG_TRACEPOINT_EVENT(personality, + TP_PROTO(sc_exit(long ret,) unsigned int personality), + TP_ARGS(sc_exit(ret,) personality), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, personality, personality))) +) +#endif +#ifndef OVERRIDE_64_sched_getscheduler +SC_LTTNG_TRACEPOINT_EVENT(sched_getscheduler, + TP_PROTO(sc_exit(long ret,) pid_t pid), + TP_ARGS(sc_exit(ret,) pid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid))) +) +#endif +#ifndef OVERRIDE_64_sched_get_priority_max +SC_LTTNG_TRACEPOINT_EVENT(sched_get_priority_max, + TP_PROTO(sc_exit(long ret,) int policy), + TP_ARGS(sc_exit(ret,) policy), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, policy, policy))) +) +#endif +#ifndef OVERRIDE_64_sched_get_priority_min +SC_LTTNG_TRACEPOINT_EVENT(sched_get_priority_min, + TP_PROTO(sc_exit(long ret,) int policy), + TP_ARGS(sc_exit(ret,) policy), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, policy, policy))) +) +#endif +#ifndef OVERRIDE_64_mlockall +SC_LTTNG_TRACEPOINT_EVENT(mlockall, + TP_PROTO(sc_exit(long ret,) int flags), + TP_ARGS(sc_exit(ret,) flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_io_destroy +SC_LTTNG_TRACEPOINT_EVENT(io_destroy, + TP_PROTO(sc_exit(long ret,) aio_context_t ctx), + TP_ARGS(sc_exit(ret,) ctx), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx, ctx))) +) +#endif +#ifndef OVERRIDE_64_epoll_create +SC_LTTNG_TRACEPOINT_EVENT(epoll_create, + TP_PROTO(sc_exit(long ret,) int size), + TP_ARGS(sc_exit(ret,) size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, size, size))) +) +#endif +#ifndef OVERRIDE_64_timer_getoverrun +SC_LTTNG_TRACEPOINT_EVENT(timer_getoverrun, + TP_PROTO(sc_exit(long ret,) timer_t timer_id), + TP_ARGS(sc_exit(ret,) timer_id), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id))) +) +#endif +#ifndef OVERRIDE_64_timer_delete +SC_LTTNG_TRACEPOINT_EVENT(timer_delete, + TP_PROTO(sc_exit(long ret,) timer_t timer_id), + TP_ARGS(sc_exit(ret,) timer_id), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id))) +) +#endif +#ifndef OVERRIDE_64_exit_group +SC_LTTNG_TRACEPOINT_EVENT(exit_group, + TP_PROTO(sc_exit(long ret,) int error_code), + TP_ARGS(sc_exit(ret,) error_code), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, error_code, error_code))) +) +#endif +#ifndef OVERRIDE_64_unshare +SC_LTTNG_TRACEPOINT_EVENT(unshare, + TP_PROTO(sc_exit(long ret,) unsigned long unshare_flags), + TP_ARGS(sc_exit(ret,) unshare_flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, unshare_flags, unshare_flags))) +) +#endif +#ifndef OVERRIDE_64_eventfd +SC_LTTNG_TRACEPOINT_EVENT(eventfd, + TP_PROTO(sc_exit(long ret,) unsigned int count), + TP_ARGS(sc_exit(ret,) count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, count, count))) +) +#endif +#ifndef OVERRIDE_64_epoll_create1 +SC_LTTNG_TRACEPOINT_EVENT(epoll_create1, + TP_PROTO(sc_exit(long ret,) int flags), + TP_ARGS(sc_exit(ret,) flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_inotify_init1 +SC_LTTNG_TRACEPOINT_EVENT(inotify_init1, + TP_PROTO(sc_exit(long ret,) int flags), + TP_ARGS(sc_exit(ret,) flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_syncfs +SC_LTTNG_TRACEPOINT_EVENT(syncfs, + TP_PROTO(sc_exit(long ret,) int fd), + TP_ARGS(sc_exit(ret,) fd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd))) +) +#endif +#ifndef OVERRIDE_64_munmap +SC_LTTNG_TRACEPOINT_EVENT(munmap, + TP_PROTO(sc_exit(long ret,) unsigned long addr, size_t len), + TP_ARGS(sc_exit(ret,) addr, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, addr, addr)) sc_in(ctf_integer(size_t, len, len))) +) +#endif +#ifndef OVERRIDE_64_dup2 +SC_LTTNG_TRACEPOINT_EVENT(dup2, + TP_PROTO(sc_exit(long ret,) unsigned int oldfd, unsigned int newfd), + TP_ARGS(sc_exit(ret,) oldfd, newfd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, oldfd, oldfd)) sc_in(ctf_integer(unsigned int, newfd, newfd))) +) +#endif +#ifndef OVERRIDE_64_shutdown +SC_LTTNG_TRACEPOINT_EVENT(shutdown, + TP_PROTO(sc_exit(long ret,) int fd, int how), + TP_ARGS(sc_exit(ret,) fd, how), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, how, how))) +) +#endif +#ifndef OVERRIDE_64_listen +SC_LTTNG_TRACEPOINT_EVENT(listen, + TP_PROTO(sc_exit(long ret,) int fd, int backlog), + TP_ARGS(sc_exit(ret,) fd, backlog), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, backlog, backlog))) +) +#endif +#ifndef OVERRIDE_64_kill +SC_LTTNG_TRACEPOINT_EVENT(kill, + TP_PROTO(sc_exit(long ret,) pid_t pid, int sig), + TP_ARGS(sc_exit(ret,) pid, sig), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig))) +) +#endif +#ifndef OVERRIDE_64_msgget +SC_LTTNG_TRACEPOINT_EVENT(msgget, + TP_PROTO(sc_exit(long ret,) key_t key, int msgflg), + TP_ARGS(sc_exit(ret,) key, msgflg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(key_t, key, key)) sc_in(ctf_integer(int, msgflg, msgflg))) +) +#endif +#ifndef OVERRIDE_64_flock +SC_LTTNG_TRACEPOINT_EVENT(flock, + TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd), + TP_ARGS(sc_exit(ret,) fd, cmd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned int, cmd, cmd))) +) +#endif +#ifndef OVERRIDE_64_ftruncate +SC_LTTNG_TRACEPOINT_EVENT(ftruncate, + TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned long length), + TP_ARGS(sc_exit(ret,) fd, length), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned long, length, length))) +) +#endif +#ifndef OVERRIDE_64_fchmod +SC_LTTNG_TRACEPOINT_EVENT(fchmod, + TP_PROTO(sc_exit(long ret,) unsigned int fd, umode_t mode), + TP_ARGS(sc_exit(ret,) fd, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(umode_t, mode, mode))) +) +#endif +#ifndef OVERRIDE_64_setpgid +SC_LTTNG_TRACEPOINT_EVENT(setpgid, + TP_PROTO(sc_exit(long ret,) pid_t pid, pid_t pgid), + TP_ARGS(sc_exit(ret,) pid, pgid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(pid_t, pgid, pgid))) +) +#endif +#ifndef OVERRIDE_64_setreuid +SC_LTTNG_TRACEPOINT_EVENT(setreuid, + TP_PROTO(sc_exit(long ret,) uid_t ruid, uid_t euid), + TP_ARGS(sc_exit(ret,) ruid, euid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, ruid, ruid)) sc_in(ctf_integer(uid_t, euid, euid))) +) +#endif +#ifndef OVERRIDE_64_setregid +SC_LTTNG_TRACEPOINT_EVENT(setregid, + TP_PROTO(sc_exit(long ret,) gid_t rgid, gid_t egid), + TP_ARGS(sc_exit(ret,) rgid, egid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, rgid, rgid)) sc_in(ctf_integer(gid_t, egid, egid))) +) +#endif +#ifndef OVERRIDE_64_getpriority +SC_LTTNG_TRACEPOINT_EVENT(getpriority, + TP_PROTO(sc_exit(long ret,) int which, int who), + TP_ARGS(sc_exit(ret,) which, who), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who))) +) +#endif +#ifndef OVERRIDE_64_mlock +SC_LTTNG_TRACEPOINT_EVENT(mlock, + TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len), + TP_ARGS(sc_exit(ret,) start, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len))) +) +#endif +#ifndef OVERRIDE_64_munlock +SC_LTTNG_TRACEPOINT_EVENT(munlock, + TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len), + TP_ARGS(sc_exit(ret,) start, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len))) +) +#endif +#ifndef OVERRIDE_64_tkill +SC_LTTNG_TRACEPOINT_EVENT(tkill, + TP_PROTO(sc_exit(long ret,) pid_t pid, int sig), + TP_ARGS(sc_exit(ret,) pid, sig), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig))) +) +#endif +#ifndef OVERRIDE_64_ioprio_get +SC_LTTNG_TRACEPOINT_EVENT(ioprio_get, + TP_PROTO(sc_exit(long ret,) int which, int who), + TP_ARGS(sc_exit(ret,) which, who), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who))) +) +#endif +#ifndef OVERRIDE_64_inotify_rm_watch +SC_LTTNG_TRACEPOINT_EVENT(inotify_rm_watch, + TP_PROTO(sc_exit(long ret,) int fd, __s32 wd), + TP_ARGS(sc_exit(ret,) fd, wd), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(__s32, wd, wd))) +) +#endif +#ifndef OVERRIDE_64_timerfd_create +SC_LTTNG_TRACEPOINT_EVENT(timerfd_create, + TP_PROTO(sc_exit(long ret,) int clockid, int flags), + TP_ARGS(sc_exit(ret,) clockid, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, clockid, clockid)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_eventfd2 +SC_LTTNG_TRACEPOINT_EVENT(eventfd2, + TP_PROTO(sc_exit(long ret,) unsigned int count, int flags), + TP_ARGS(sc_exit(ret,) count, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, count, count)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_fanotify_init +SC_LTTNG_TRACEPOINT_EVENT(fanotify_init, + TP_PROTO(sc_exit(long ret,) unsigned int flags, unsigned int event_f_flags), + TP_ARGS(sc_exit(ret,) flags, event_f_flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, flags, flags)) sc_in(ctf_integer(unsigned int, event_f_flags, event_f_flags))) +) +#endif +#ifndef OVERRIDE_64_setns +SC_LTTNG_TRACEPOINT_EVENT(setns, + TP_PROTO(sc_exit(long ret,) int fd, int nstype), + TP_ARGS(sc_exit(ret,) fd, nstype), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, nstype, nstype))) +) +#endif +#ifndef OVERRIDE_64_lseek +SC_LTTNG_TRACEPOINT_EVENT(lseek, + TP_PROTO(sc_exit(long ret,) unsigned int fd, off_t offset, unsigned int whence), + TP_ARGS(sc_exit(ret,) fd, offset, whence), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(off_t, offset, offset)) sc_in(ctf_integer(unsigned int, whence, whence))) +) +#endif +#ifndef OVERRIDE_64_mprotect +SC_LTTNG_TRACEPOINT_EVENT(mprotect, + TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len, unsigned long prot), + TP_ARGS(sc_exit(ret,) start, len, prot), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned long, prot, prot))) +) +#endif +#ifndef OVERRIDE_64_ioctl +SC_LTTNG_TRACEPOINT_EVENT(ioctl, + TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd, unsigned long arg), + TP_ARGS(sc_exit(ret,) fd, cmd, arg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_inout(ctf_integer(unsigned long, arg, arg))) +) +#endif +#ifndef OVERRIDE_64_msync +SC_LTTNG_TRACEPOINT_EVENT(msync, + TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len, int flags), + TP_ARGS(sc_exit(ret,) start, len, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_madvise +SC_LTTNG_TRACEPOINT_EVENT(madvise, + TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len_in, int behavior), + TP_ARGS(sc_exit(ret,) start, len_in, behavior), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len_in, len_in)) sc_in(ctf_integer(int, behavior, behavior))) +) +#endif +#ifndef OVERRIDE_64_shmget +SC_LTTNG_TRACEPOINT_EVENT(shmget, + TP_PROTO(sc_exit(long ret,) key_t key, size_t size, int shmflg), + TP_ARGS(sc_exit(ret,) key, size, shmflg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(key_t, key, key)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(int, shmflg, shmflg))) +) +#endif +#ifndef OVERRIDE_64_socket +SC_LTTNG_TRACEPOINT_EVENT(socket, + TP_PROTO(sc_exit(long ret,) int family, int type, int protocol), + TP_ARGS(sc_exit(ret,) family, type, protocol), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, family, family)) sc_in(ctf_integer(int, type, type)) sc_in(ctf_integer(int, protocol, protocol))) +) +#endif +#ifndef OVERRIDE_64_semget +SC_LTTNG_TRACEPOINT_EVENT(semget, + TP_PROTO(sc_exit(long ret,) key_t key, int nsems, int semflg), + TP_ARGS(sc_exit(ret,) key, nsems, semflg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(key_t, key, key)) sc_in(ctf_integer(int, nsems, nsems)) sc_in(ctf_integer(int, semflg, semflg))) +) +#endif +#ifndef OVERRIDE_64_fcntl +SC_LTTNG_TRACEPOINT_EVENT(fcntl, + TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd, unsigned long arg), + TP_ARGS(sc_exit(ret,) fd, cmd, arg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_inout(ctf_integer(unsigned long, arg, arg))) +) +#endif +#ifndef OVERRIDE_64_fchown +SC_LTTNG_TRACEPOINT_EVENT(fchown, + TP_PROTO(sc_exit(long ret,) unsigned int fd, uid_t user, gid_t group), + TP_ARGS(sc_exit(ret,) fd, user, group), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group))) +) +#endif +#ifndef OVERRIDE_64_setresuid +SC_LTTNG_TRACEPOINT_EVENT(setresuid, + TP_PROTO(sc_exit(long ret,) uid_t ruid, uid_t euid, uid_t suid), + TP_ARGS(sc_exit(ret,) ruid, euid, suid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, ruid, ruid)) sc_in(ctf_integer(uid_t, euid, euid)) sc_in(ctf_integer(uid_t, suid, suid))) +) +#endif +#ifndef OVERRIDE_64_setresgid +SC_LTTNG_TRACEPOINT_EVENT(setresgid, + TP_PROTO(sc_exit(long ret,) gid_t rgid, gid_t egid, gid_t sgid), + TP_ARGS(sc_exit(ret,) rgid, egid, sgid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, rgid, rgid)) sc_in(ctf_integer(gid_t, egid, egid)) sc_in(ctf_integer(gid_t, sgid, sgid))) +) +#endif +#ifndef OVERRIDE_64_sysfs +SC_LTTNG_TRACEPOINT_EVENT(sysfs, + TP_PROTO(sc_exit(long ret,) int option, unsigned long arg1, unsigned long arg2), + TP_ARGS(sc_exit(ret,) option, arg1, arg2), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, option, option)) sc_in(ctf_integer(unsigned long, arg1, arg1)) sc_in(ctf_integer(unsigned long, arg2, arg2))) +) +#endif +#ifndef OVERRIDE_64_setpriority +SC_LTTNG_TRACEPOINT_EVENT(setpriority, + TP_PROTO(sc_exit(long ret,) int which, int who, int niceval), + TP_ARGS(sc_exit(ret,) which, who, niceval), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who)) sc_in(ctf_integer(int, niceval, niceval))) +) +#endif +#ifndef OVERRIDE_64_readahead +SC_LTTNG_TRACEPOINT_EVENT(readahead, + TP_PROTO(sc_exit(long ret,) int fd, loff_t offset, size_t count), + TP_ARGS(sc_exit(ret,) fd, offset, count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(loff_t, offset, offset)) sc_in(ctf_integer(size_t, count, count))) +) +#endif +#ifndef OVERRIDE_64_tgkill +SC_LTTNG_TRACEPOINT_EVENT(tgkill, + TP_PROTO(sc_exit(long ret,) pid_t tgid, pid_t pid, int sig), + TP_ARGS(sc_exit(ret,) tgid, pid, sig), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, tgid, tgid)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig))) +) +#endif +#ifndef OVERRIDE_64_ioprio_set +SC_LTTNG_TRACEPOINT_EVENT(ioprio_set, + TP_PROTO(sc_exit(long ret,) int which, int who, int ioprio), + TP_ARGS(sc_exit(ret,) which, who, ioprio), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who)) sc_in(ctf_integer(int, ioprio, ioprio))) +) +#endif +#ifndef OVERRIDE_64_dup3 +SC_LTTNG_TRACEPOINT_EVENT(dup3, + TP_PROTO(sc_exit(long ret,) unsigned int oldfd, unsigned int newfd, int flags), + TP_ARGS(sc_exit(ret,) oldfd, newfd, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, oldfd, oldfd)) sc_in(ctf_integer(unsigned int, newfd, newfd)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_semctl +SC_LTTNG_TRACEPOINT_EVENT(semctl, + TP_PROTO(sc_exit(long ret,) int semid, int semnum, int cmd, unsigned long arg), + TP_ARGS(sc_exit(ret,) semid, semnum, cmd, arg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, semid, semid)) sc_in(ctf_integer(int, semnum, semnum)) sc_in(ctf_integer(int, cmd, cmd)) sc_inout(ctf_integer(unsigned long, arg, arg))) +) +#endif +#ifndef OVERRIDE_64_ptrace +SC_LTTNG_TRACEPOINT_EVENT(ptrace, + TP_PROTO(sc_exit(long ret,) long request, long pid, unsigned long addr, unsigned long data), + TP_ARGS(sc_exit(ret,) request, pid, addr, data), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(long, request, request)) sc_in(ctf_integer(long, pid, pid)) sc_inout(ctf_integer(unsigned long, addr, addr)) sc_inout(ctf_integer(unsigned long, data, data))) +) +#endif +#ifndef OVERRIDE_64_fadvise64 +SC_LTTNG_TRACEPOINT_EVENT(fadvise64, + TP_PROTO(sc_exit(long ret,) int fd, loff_t offset, size_t len, int advice), + TP_ARGS(sc_exit(ret,) fd, offset, len, advice), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(loff_t, offset, offset)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(int, advice, advice))) +) +#endif +#ifndef OVERRIDE_64_tee +SC_LTTNG_TRACEPOINT_EVENT(tee, + TP_PROTO(sc_exit(long ret,) int fdin, int fdout, size_t len, unsigned int flags), + TP_ARGS(sc_exit(ret,) fdin, fdout, len, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fdin, fdin)) sc_in(ctf_integer(int, fdout, fdout)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_sync_file_range +SC_LTTNG_TRACEPOINT_EVENT(sync_file_range, + TP_PROTO(sc_exit(long ret,) int fd, loff_t offset, loff_t nbytes, unsigned int flags), + TP_ARGS(sc_exit(ret,) fd, offset, nbytes, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(loff_t, offset, offset)) sc_in(ctf_integer(loff_t, nbytes, nbytes)) sc_in(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_fallocate +SC_LTTNG_TRACEPOINT_EVENT(fallocate, + TP_PROTO(sc_exit(long ret,) int fd, int mode, loff_t offset, loff_t len), + TP_ARGS(sc_exit(ret,) fd, mode, offset, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, mode, mode)) sc_in(ctf_integer(loff_t, offset, offset)) sc_in(ctf_integer(loff_t, len, len))) +) +#endif +#ifndef OVERRIDE_64_mremap +SC_LTTNG_TRACEPOINT_EVENT(mremap, + TP_PROTO(sc_exit(long ret,) unsigned long addr, unsigned long old_len, unsigned long new_len, unsigned long flags, unsigned long new_addr), + TP_ARGS(sc_exit(ret,) addr, old_len, new_len, flags, new_addr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, addr, addr)) sc_in(ctf_integer(unsigned long, old_len, old_len)) sc_in(ctf_integer(unsigned long, new_len, new_len)) sc_in(ctf_integer(unsigned long, flags, flags)) sc_in(ctf_integer(unsigned long, new_addr, new_addr))) +) +#endif +#ifndef OVERRIDE_64_prctl +SC_LTTNG_TRACEPOINT_EVENT(prctl, + TP_PROTO(sc_exit(long ret,) int option, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5), + TP_ARGS(sc_exit(ret,) option, arg2, arg3, arg4, arg5), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, option, option)) sc_inout(ctf_integer(unsigned long, arg2, arg2)) sc_in(ctf_integer(unsigned long, arg3, arg3)) sc_in(ctf_integer(unsigned long, arg4, arg4)) sc_in(ctf_integer(unsigned long, arg5, arg5))) +) +#endif +#ifndef OVERRIDE_64_remap_file_pages +SC_LTTNG_TRACEPOINT_EVENT(remap_file_pages, + TP_PROTO(sc_exit(long ret,) unsigned long start, unsigned long size, unsigned long prot, unsigned long pgoff, unsigned long flags), + TP_ARGS(sc_exit(ret,) start, size, prot, pgoff, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(unsigned long, size, size)) sc_in(ctf_integer(unsigned long, prot, prot)) sc_in(ctf_integer(unsigned long, pgoff, pgoff)) sc_in(ctf_integer(unsigned long, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_keyctl +SC_LTTNG_TRACEPOINT_EVENT(keyctl, + TP_PROTO(sc_exit(long ret,) int option, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5), + TP_ARGS(sc_exit(ret,) option, arg2, arg3, arg4, arg5), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, option, option)) sc_inout(ctf_integer(unsigned long, arg2, arg2)) sc_inout(ctf_integer(unsigned long, arg3, arg3)) sc_inout(ctf_integer(unsigned long, arg4, arg4)) sc_inout(ctf_integer(unsigned long, arg5, arg5))) +) +#endif +#ifndef OVERRIDE_64_mmap +SC_LTTNG_TRACEPOINT_EVENT(mmap, + TP_PROTO(sc_exit(long ret,) unsigned long addr, unsigned long len, unsigned long prot, unsigned long flags, unsigned long fd, unsigned long off), + TP_ARGS(sc_exit(ret,) addr, len, prot, flags, fd, off), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, addr, addr)) sc_in(ctf_integer(unsigned long, len, len)) sc_in(ctf_integer(unsigned long, prot, prot)) sc_in(ctf_integer(unsigned long, flags, flags)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_in(ctf_integer(unsigned long, off, off))) +) +#endif + +#endif /* _TRACE_SYSCALLS_INTEGERS_H */ + +/* This part must be outside protection */ +#include + +#else /* CREATE_SYSCALL_TABLE */ + +#include "x86-64-syscalls_integers_override.h" +#include "syscalls_integers_override.h" + +#ifdef SC_ENTER +#ifndef OVERRIDE_TABLE_64_sched_yield +TRACE_SYSCALL_TABLE(syscalls_noargs, sched_yield, 24, 0) +#endif +#ifndef OVERRIDE_TABLE_64_pause +TRACE_SYSCALL_TABLE(syscalls_noargs, pause, 34, 0) +#endif +#ifndef OVERRIDE_TABLE_64_getpid +TRACE_SYSCALL_TABLE(syscalls_noargs, getpid, 39, 0) +#endif +#ifndef OVERRIDE_TABLE_64_getuid +TRACE_SYSCALL_TABLE(syscalls_noargs, getuid, 102, 0) +#endif +#ifndef OVERRIDE_TABLE_64_getgid +TRACE_SYSCALL_TABLE(syscalls_noargs, getgid, 104, 0) +#endif +#ifndef OVERRIDE_TABLE_64_geteuid +TRACE_SYSCALL_TABLE(syscalls_noargs, geteuid, 107, 0) +#endif +#ifndef OVERRIDE_TABLE_64_getegid +TRACE_SYSCALL_TABLE(syscalls_noargs, getegid, 108, 0) +#endif +#ifndef OVERRIDE_TABLE_64_getppid +TRACE_SYSCALL_TABLE(syscalls_noargs, getppid, 110, 0) +#endif +#ifndef OVERRIDE_TABLE_64_getpgrp +TRACE_SYSCALL_TABLE(syscalls_noargs, getpgrp, 111, 0) +#endif +#ifndef OVERRIDE_TABLE_64_setsid +TRACE_SYSCALL_TABLE(syscalls_noargs, setsid, 112, 0) +#endif +#ifndef OVERRIDE_TABLE_64_munlockall +TRACE_SYSCALL_TABLE(syscalls_noargs, munlockall, 152, 0) +#endif +#ifndef OVERRIDE_TABLE_64_vhangup +TRACE_SYSCALL_TABLE(syscalls_noargs, vhangup, 153, 0) +#endif +#ifndef OVERRIDE_TABLE_64_sync +TRACE_SYSCALL_TABLE(syscalls_noargs, sync, 162, 0) +#endif +#ifndef OVERRIDE_TABLE_64_gettid +TRACE_SYSCALL_TABLE(syscalls_noargs, gettid, 186, 0) +#endif +#ifndef OVERRIDE_TABLE_64_restart_syscall +TRACE_SYSCALL_TABLE(syscalls_noargs, restart_syscall, 219, 0) +#endif +#ifndef OVERRIDE_TABLE_64_inotify_init +TRACE_SYSCALL_TABLE(syscalls_noargs, inotify_init, 253, 0) +#endif +#else /* #ifdef SC_ENTER */ +#ifndef OVERRIDE_TABLE_64_sched_yield +TRACE_SYSCALL_TABLE(sched_yield, sched_yield, 24, 0) +#endif +#ifndef OVERRIDE_TABLE_64_pause +TRACE_SYSCALL_TABLE(pause, pause, 34, 0) +#endif +#ifndef OVERRIDE_TABLE_64_getpid +TRACE_SYSCALL_TABLE(getpid, getpid, 39, 0) +#endif +#ifndef OVERRIDE_TABLE_64_getuid +TRACE_SYSCALL_TABLE(getuid, getuid, 102, 0) +#endif +#ifndef OVERRIDE_TABLE_64_getgid +TRACE_SYSCALL_TABLE(getgid, getgid, 104, 0) +#endif +#ifndef OVERRIDE_TABLE_64_geteuid +TRACE_SYSCALL_TABLE(geteuid, geteuid, 107, 0) +#endif +#ifndef OVERRIDE_TABLE_64_getegid +TRACE_SYSCALL_TABLE(getegid, getegid, 108, 0) +#endif +#ifndef OVERRIDE_TABLE_64_getppid +TRACE_SYSCALL_TABLE(getppid, getppid, 110, 0) +#endif +#ifndef OVERRIDE_TABLE_64_getpgrp +TRACE_SYSCALL_TABLE(getpgrp, getpgrp, 111, 0) +#endif +#ifndef OVERRIDE_TABLE_64_setsid +TRACE_SYSCALL_TABLE(setsid, setsid, 112, 0) +#endif +#ifndef OVERRIDE_TABLE_64_munlockall +TRACE_SYSCALL_TABLE(munlockall, munlockall, 152, 0) +#endif +#ifndef OVERRIDE_TABLE_64_vhangup +TRACE_SYSCALL_TABLE(vhangup, vhangup, 153, 0) +#endif +#ifndef OVERRIDE_TABLE_64_sync +TRACE_SYSCALL_TABLE(sync, sync, 162, 0) +#endif +#ifndef OVERRIDE_TABLE_64_gettid +TRACE_SYSCALL_TABLE(gettid, gettid, 186, 0) +#endif +#ifndef OVERRIDE_TABLE_64_restart_syscall +TRACE_SYSCALL_TABLE(restart_syscall, restart_syscall, 219, 0) +#endif +#ifndef OVERRIDE_TABLE_64_inotify_init +TRACE_SYSCALL_TABLE(inotify_init, inotify_init, 253, 0) +#endif +#endif /* else #ifdef SC_ENTER */ +#ifndef OVERRIDE_TABLE_64_close +TRACE_SYSCALL_TABLE(close, close, 3, 1) +#endif +#ifndef OVERRIDE_TABLE_64_lseek +TRACE_SYSCALL_TABLE(lseek, lseek, 8, 3) +#endif +#ifndef OVERRIDE_TABLE_64_mmap +TRACE_SYSCALL_TABLE(mmap, mmap, 9, 6) +#endif +#ifndef OVERRIDE_TABLE_64_mprotect +TRACE_SYSCALL_TABLE(mprotect, mprotect, 10, 3) +#endif +#ifndef OVERRIDE_TABLE_64_munmap +TRACE_SYSCALL_TABLE(munmap, munmap, 11, 2) +#endif +#ifndef OVERRIDE_TABLE_64_brk +TRACE_SYSCALL_TABLE(brk, brk, 12, 1) +#endif +#ifndef OVERRIDE_TABLE_64_ioctl +TRACE_SYSCALL_TABLE(ioctl, ioctl, 16, 3) +#endif +#ifndef OVERRIDE_TABLE_64_mremap +TRACE_SYSCALL_TABLE(mremap, mremap, 25, 5) +#endif +#ifndef OVERRIDE_TABLE_64_msync +TRACE_SYSCALL_TABLE(msync, msync, 26, 3) +#endif +#ifndef OVERRIDE_TABLE_64_madvise +TRACE_SYSCALL_TABLE(madvise, madvise, 28, 3) +#endif +#ifndef OVERRIDE_TABLE_64_shmget +TRACE_SYSCALL_TABLE(shmget, shmget, 29, 3) +#endif +#ifndef OVERRIDE_TABLE_64_dup +TRACE_SYSCALL_TABLE(dup, dup, 32, 1) +#endif +#ifndef OVERRIDE_TABLE_64_dup2 +TRACE_SYSCALL_TABLE(dup2, dup2, 33, 2) +#endif +#ifndef OVERRIDE_TABLE_64_alarm +TRACE_SYSCALL_TABLE(alarm, alarm, 37, 1) +#endif +#ifndef OVERRIDE_TABLE_64_socket +TRACE_SYSCALL_TABLE(socket, socket, 41, 3) +#endif +#ifndef OVERRIDE_TABLE_64_shutdown +TRACE_SYSCALL_TABLE(shutdown, shutdown, 48, 2) +#endif +#ifndef OVERRIDE_TABLE_64_listen +TRACE_SYSCALL_TABLE(listen, listen, 50, 2) +#endif +#ifndef OVERRIDE_TABLE_64_exit +TRACE_SYSCALL_TABLE(exit, exit, 60, 1) +#endif +#ifndef OVERRIDE_TABLE_64_kill +TRACE_SYSCALL_TABLE(kill, kill, 62, 2) +#endif +#ifndef OVERRIDE_TABLE_64_semget +TRACE_SYSCALL_TABLE(semget, semget, 64, 3) +#endif +#ifndef OVERRIDE_TABLE_64_semctl +TRACE_SYSCALL_TABLE(semctl, semctl, 66, 4) +#endif +#ifndef OVERRIDE_TABLE_64_msgget +TRACE_SYSCALL_TABLE(msgget, msgget, 68, 2) +#endif +#ifndef OVERRIDE_TABLE_64_fcntl +TRACE_SYSCALL_TABLE(fcntl, fcntl, 72, 3) +#endif +#ifndef OVERRIDE_TABLE_64_flock +TRACE_SYSCALL_TABLE(flock, flock, 73, 2) +#endif +#ifndef OVERRIDE_TABLE_64_fsync +TRACE_SYSCALL_TABLE(fsync, fsync, 74, 1) +#endif +#ifndef OVERRIDE_TABLE_64_fdatasync +TRACE_SYSCALL_TABLE(fdatasync, fdatasync, 75, 1) +#endif +#ifndef OVERRIDE_TABLE_64_ftruncate +TRACE_SYSCALL_TABLE(ftruncate, ftruncate, 77, 2) +#endif +#ifndef OVERRIDE_TABLE_64_fchdir +TRACE_SYSCALL_TABLE(fchdir, fchdir, 81, 1) +#endif +#ifndef OVERRIDE_TABLE_64_fchmod +TRACE_SYSCALL_TABLE(fchmod, fchmod, 91, 2) +#endif +#ifndef OVERRIDE_TABLE_64_fchown +TRACE_SYSCALL_TABLE(fchown, fchown, 93, 3) +#endif +#ifndef OVERRIDE_TABLE_64_umask +TRACE_SYSCALL_TABLE(umask, umask, 95, 1) +#endif +#ifndef OVERRIDE_TABLE_64_ptrace +TRACE_SYSCALL_TABLE(ptrace, ptrace, 101, 4) +#endif +#ifndef OVERRIDE_TABLE_64_setuid +TRACE_SYSCALL_TABLE(setuid, setuid, 105, 1) +#endif +#ifndef OVERRIDE_TABLE_64_setgid +TRACE_SYSCALL_TABLE(setgid, setgid, 106, 1) +#endif +#ifndef OVERRIDE_TABLE_64_setpgid +TRACE_SYSCALL_TABLE(setpgid, setpgid, 109, 2) +#endif +#ifndef OVERRIDE_TABLE_64_setreuid +TRACE_SYSCALL_TABLE(setreuid, setreuid, 113, 2) +#endif +#ifndef OVERRIDE_TABLE_64_setregid +TRACE_SYSCALL_TABLE(setregid, setregid, 114, 2) +#endif +#ifndef OVERRIDE_TABLE_64_setresuid +TRACE_SYSCALL_TABLE(setresuid, setresuid, 117, 3) +#endif +#ifndef OVERRIDE_TABLE_64_setresgid +TRACE_SYSCALL_TABLE(setresgid, setresgid, 119, 3) +#endif +#ifndef OVERRIDE_TABLE_64_getpgid +TRACE_SYSCALL_TABLE(getpgid, getpgid, 121, 1) +#endif +#ifndef OVERRIDE_TABLE_64_setfsuid +TRACE_SYSCALL_TABLE(setfsuid, setfsuid, 122, 1) +#endif +#ifndef OVERRIDE_TABLE_64_setfsgid +TRACE_SYSCALL_TABLE(setfsgid, setfsgid, 123, 1) +#endif +#ifndef OVERRIDE_TABLE_64_getsid +TRACE_SYSCALL_TABLE(getsid, getsid, 124, 1) +#endif +#ifndef OVERRIDE_TABLE_64_personality +TRACE_SYSCALL_TABLE(personality, personality, 135, 1) +#endif +#ifndef OVERRIDE_TABLE_64_sysfs +TRACE_SYSCALL_TABLE(sysfs, sysfs, 139, 3) +#endif +#ifndef OVERRIDE_TABLE_64_getpriority +TRACE_SYSCALL_TABLE(getpriority, getpriority, 140, 2) +#endif +#ifndef OVERRIDE_TABLE_64_setpriority +TRACE_SYSCALL_TABLE(setpriority, setpriority, 141, 3) +#endif +#ifndef OVERRIDE_TABLE_64_sched_getscheduler +TRACE_SYSCALL_TABLE(sched_getscheduler, sched_getscheduler, 145, 1) +#endif +#ifndef OVERRIDE_TABLE_64_sched_get_priority_max +TRACE_SYSCALL_TABLE(sched_get_priority_max, sched_get_priority_max, 146, 1) +#endif +#ifndef OVERRIDE_TABLE_64_sched_get_priority_min +TRACE_SYSCALL_TABLE(sched_get_priority_min, sched_get_priority_min, 147, 1) +#endif +#ifndef OVERRIDE_TABLE_64_mlock +TRACE_SYSCALL_TABLE(mlock, mlock, 149, 2) +#endif +#ifndef OVERRIDE_TABLE_64_munlock +TRACE_SYSCALL_TABLE(munlock, munlock, 150, 2) +#endif +#ifndef OVERRIDE_TABLE_64_mlockall +TRACE_SYSCALL_TABLE(mlockall, mlockall, 151, 1) +#endif +#ifndef OVERRIDE_TABLE_64_prctl +TRACE_SYSCALL_TABLE(prctl, prctl, 157, 5) +#endif +#ifndef OVERRIDE_TABLE_64_readahead +TRACE_SYSCALL_TABLE(readahead, readahead, 187, 3) +#endif +#ifndef OVERRIDE_TABLE_64_tkill +TRACE_SYSCALL_TABLE(tkill, tkill, 200, 2) +#endif +#ifndef OVERRIDE_TABLE_64_io_destroy +TRACE_SYSCALL_TABLE(io_destroy, io_destroy, 207, 1) +#endif +#ifndef OVERRIDE_TABLE_64_epoll_create +TRACE_SYSCALL_TABLE(epoll_create, epoll_create, 213, 1) +#endif +#ifndef OVERRIDE_TABLE_64_remap_file_pages +TRACE_SYSCALL_TABLE(remap_file_pages, remap_file_pages, 216, 5) +#endif +#ifndef OVERRIDE_TABLE_64_fadvise64 +TRACE_SYSCALL_TABLE(fadvise64, fadvise64, 221, 4) +#endif +#ifndef OVERRIDE_TABLE_64_timer_getoverrun +TRACE_SYSCALL_TABLE(timer_getoverrun, timer_getoverrun, 225, 1) +#endif +#ifndef OVERRIDE_TABLE_64_timer_delete +TRACE_SYSCALL_TABLE(timer_delete, timer_delete, 226, 1) +#endif +#ifndef OVERRIDE_TABLE_64_exit_group +TRACE_SYSCALL_TABLE(exit_group, exit_group, 231, 1) +#endif +#ifndef OVERRIDE_TABLE_64_tgkill +TRACE_SYSCALL_TABLE(tgkill, tgkill, 234, 3) +#endif +#ifndef OVERRIDE_TABLE_64_keyctl +TRACE_SYSCALL_TABLE(keyctl, keyctl, 250, 5) +#endif +#ifndef OVERRIDE_TABLE_64_ioprio_set +TRACE_SYSCALL_TABLE(ioprio_set, ioprio_set, 251, 3) +#endif +#ifndef OVERRIDE_TABLE_64_ioprio_get +TRACE_SYSCALL_TABLE(ioprio_get, ioprio_get, 252, 2) +#endif +#ifndef OVERRIDE_TABLE_64_inotify_rm_watch +TRACE_SYSCALL_TABLE(inotify_rm_watch, inotify_rm_watch, 255, 2) +#endif +#ifndef OVERRIDE_TABLE_64_unshare +TRACE_SYSCALL_TABLE(unshare, unshare, 272, 1) +#endif +#ifndef OVERRIDE_TABLE_64_tee +TRACE_SYSCALL_TABLE(tee, tee, 276, 4) +#endif +#ifndef OVERRIDE_TABLE_64_sync_file_range +TRACE_SYSCALL_TABLE(sync_file_range, sync_file_range, 277, 4) +#endif +#ifndef OVERRIDE_TABLE_64_timerfd_create +TRACE_SYSCALL_TABLE(timerfd_create, timerfd_create, 283, 2) +#endif +#ifndef OVERRIDE_TABLE_64_eventfd +TRACE_SYSCALL_TABLE(eventfd, eventfd, 284, 1) +#endif +#ifndef OVERRIDE_TABLE_64_fallocate +TRACE_SYSCALL_TABLE(fallocate, fallocate, 285, 4) +#endif +#ifndef OVERRIDE_TABLE_64_eventfd2 +TRACE_SYSCALL_TABLE(eventfd2, eventfd2, 290, 2) +#endif +#ifndef OVERRIDE_TABLE_64_epoll_create1 +TRACE_SYSCALL_TABLE(epoll_create1, epoll_create1, 291, 1) +#endif +#ifndef OVERRIDE_TABLE_64_dup3 +TRACE_SYSCALL_TABLE(dup3, dup3, 292, 3) +#endif +#ifndef OVERRIDE_TABLE_64_inotify_init1 +TRACE_SYSCALL_TABLE(inotify_init1, inotify_init1, 294, 1) +#endif +#ifndef OVERRIDE_TABLE_64_fanotify_init +TRACE_SYSCALL_TABLE(fanotify_init, fanotify_init, 300, 2) +#endif +#ifndef OVERRIDE_TABLE_64_syncfs +TRACE_SYSCALL_TABLE(syncfs, syncfs, 306, 1) +#endif +#ifndef OVERRIDE_TABLE_64_setns +TRACE_SYSCALL_TABLE(setns, setns, 308, 2) +#endif + +#endif /* CREATE_SYSCALL_TABLE */ diff --git a/include/instrumentation/syscalls/headers/x86-64-syscalls_integers_override.h b/include/instrumentation/syscalls/headers/x86-64-syscalls_integers_override.h new file mode 100644 index 00000000..a241399b --- /dev/null +++ b/include/instrumentation/syscalls/headers/x86-64-syscalls_integers_override.h @@ -0,0 +1,5 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ + +/* + * this is a place-holder for x86_64 integer syscall definition override. + */ diff --git a/include/instrumentation/syscalls/headers/x86-64-syscalls_pointers.h b/include/instrumentation/syscalls/headers/x86-64-syscalls_pointers.h new file mode 100644 index 00000000..e57a83a0 --- /dev/null +++ b/include/instrumentation/syscalls/headers/x86-64-syscalls_pointers.h @@ -0,0 +1,1929 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ + +/* THIS FILE IS AUTO-GENERATED. DO NOT EDIT */ + +/* Generated from x86-64-syscalls 3.10.0-rc7 */ + +#ifndef CREATE_SYSCALL_TABLE + +#if !defined(_TRACE_SYSCALLS_POINTERS_H) || defined(TRACE_HEADER_MULTI_READ) +#define _TRACE_SYSCALLS_POINTERS_H + +#include +#include +#include "x86-64-syscalls_pointers_override.h" +#include "syscalls_pointers_override.h" + +#ifndef OVERRIDE_64_pipe +SC_LTTNG_TRACEPOINT_EVENT(pipe, + TP_PROTO(sc_exit(long ret,) int * fildes), + TP_ARGS(sc_exit(ret,) fildes), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(int *, fildes, fildes))) +) +#endif +#ifndef OVERRIDE_64_newuname +SC_LTTNG_TRACEPOINT_EVENT(newuname, + TP_PROTO(sc_exit(long ret,) struct new_utsname * name), + TP_ARGS(sc_exit(ret,) name), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct new_utsname *, name, name))) +) +#endif +#ifndef OVERRIDE_64_shmdt +SC_LTTNG_TRACEPOINT_EVENT(shmdt, + TP_PROTO(sc_exit(long ret,) char * shmaddr), + TP_ARGS(sc_exit(ret,) shmaddr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(char *, shmaddr, shmaddr))) +) +#endif +#ifndef OVERRIDE_64_chdir +SC_LTTNG_TRACEPOINT_EVENT(chdir, + TP_PROTO(sc_exit(long ret,) const char * filename), + TP_ARGS(sc_exit(ret,) filename), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename))) +) +#endif +#ifndef OVERRIDE_64_rmdir +SC_LTTNG_TRACEPOINT_EVENT(rmdir, + TP_PROTO(sc_exit(long ret,) const char * pathname), + TP_ARGS(sc_exit(ret,) pathname), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname))) +) +#endif +#ifndef OVERRIDE_64_unlink +SC_LTTNG_TRACEPOINT_EVENT(unlink, + TP_PROTO(sc_exit(long ret,) const char * pathname), + TP_ARGS(sc_exit(ret,) pathname), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname))) +) +#endif +#ifndef OVERRIDE_64_sysinfo +SC_LTTNG_TRACEPOINT_EVENT(sysinfo, + TP_PROTO(sc_exit(long ret,) struct sysinfo * info), + TP_ARGS(sc_exit(ret,) info), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct sysinfo *, info, info))) +) +#endif +#ifndef OVERRIDE_64_times +SC_LTTNG_TRACEPOINT_EVENT(times, + TP_PROTO(sc_exit(long ret,) struct tms * tbuf), + TP_ARGS(sc_exit(ret,) tbuf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct tms *, tbuf, tbuf))) +) +#endif +#ifndef OVERRIDE_64_sysctl +SC_LTTNG_TRACEPOINT_EVENT(sysctl, + TP_PROTO(sc_exit(long ret,) struct __sysctl_args * args), + TP_ARGS(sc_exit(ret,) args), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct __sysctl_args *, args, args))) +) +#endif +#ifndef OVERRIDE_64_adjtimex +SC_LTTNG_TRACEPOINT_EVENT(adjtimex, + TP_PROTO(sc_exit(long ret,) struct timex * txc_p), + TP_ARGS(sc_exit(ret,) txc_p), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct timex *, txc_p, txc_p))) +) +#endif +#ifndef OVERRIDE_64_chroot +SC_LTTNG_TRACEPOINT_EVENT(chroot, + TP_PROTO(sc_exit(long ret,) const char * filename), + TP_ARGS(sc_exit(ret,) filename), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename))) +) +#endif +#ifndef OVERRIDE_64_acct +SC_LTTNG_TRACEPOINT_EVENT(acct, + TP_PROTO(sc_exit(long ret,) const char * name), + TP_ARGS(sc_exit(ret,) name), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name))) +) +#endif +#ifndef OVERRIDE_64_swapoff +SC_LTTNG_TRACEPOINT_EVENT(swapoff, + TP_PROTO(sc_exit(long ret,) const char * specialfile), + TP_ARGS(sc_exit(ret,) specialfile), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(specialfile, specialfile))) +) +#endif +#ifndef OVERRIDE_64_time +SC_LTTNG_TRACEPOINT_EVENT(time, + TP_PROTO(sc_exit(long ret,) time_t * tloc), + TP_ARGS(sc_exit(ret,) tloc), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(time_t *, tloc, tloc))) +) +#endif +#ifndef OVERRIDE_64_set_tid_address +SC_LTTNG_TRACEPOINT_EVENT(set_tid_address, + TP_PROTO(sc_exit(long ret,) int * tidptr), + TP_ARGS(sc_exit(ret,) tidptr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int *, tidptr, tidptr))) +) +#endif +#ifndef OVERRIDE_64_mq_unlink +SC_LTTNG_TRACEPOINT_EVENT(mq_unlink, + TP_PROTO(sc_exit(long ret,) const char * u_name), + TP_ARGS(sc_exit(ret,) u_name), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(u_name, u_name))) +) +#endif +#ifndef OVERRIDE_64_newstat +SC_LTTNG_TRACEPOINT_EVENT(newstat, + TP_PROTO(sc_exit(long ret,) const char * filename, struct stat * statbuf), + TP_ARGS(sc_exit(ret,) filename, statbuf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_out(ctf_integer(struct stat *, statbuf, statbuf))) +) +#endif +#ifndef OVERRIDE_64_newfstat +SC_LTTNG_TRACEPOINT_EVENT(newfstat, + TP_PROTO(sc_exit(long ret,) unsigned int fd, struct stat * statbuf), + TP_ARGS(sc_exit(ret,) fd, statbuf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct stat *, statbuf, statbuf))) +) +#endif +#ifndef OVERRIDE_64_newlstat +SC_LTTNG_TRACEPOINT_EVENT(newlstat, + TP_PROTO(sc_exit(long ret,) const char * filename, struct stat * statbuf), + TP_ARGS(sc_exit(ret,) filename, statbuf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_out(ctf_integer(struct stat *, statbuf, statbuf))) +) +#endif +#ifndef OVERRIDE_64_access +SC_LTTNG_TRACEPOINT_EVENT(access, + TP_PROTO(sc_exit(long ret,) const char * filename, int mode), + TP_ARGS(sc_exit(ret,) filename, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, mode, mode))) +) +#endif +#ifndef OVERRIDE_64_nanosleep +SC_LTTNG_TRACEPOINT_EVENT(nanosleep, + TP_PROTO(sc_exit(long ret,) struct timespec * rqtp, struct timespec * rmtp), + TP_ARGS(sc_exit(ret,) rqtp, rmtp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct timespec *, rqtp, rqtp)) sc_out(ctf_integer(struct timespec *, rmtp, rmtp))) +) +#endif +#ifndef OVERRIDE_64_getitimer +SC_LTTNG_TRACEPOINT_EVENT(getitimer, + TP_PROTO(sc_exit(long ret,) int which, struct itimerval * value), + TP_ARGS(sc_exit(ret,) which, value), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_out(ctf_integer(struct itimerval *, value, value))) +) +#endif +#ifndef OVERRIDE_64_truncate +SC_LTTNG_TRACEPOINT_EVENT(truncate, + TP_PROTO(sc_exit(long ret,) const char * path, long length), + TP_ARGS(sc_exit(ret,) path, length), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(path, path)) sc_in(ctf_integer(long, length, length))) +) +#endif +#ifndef OVERRIDE_64_getcwd +SC_LTTNG_TRACEPOINT_EVENT(getcwd, + TP_PROTO(sc_exit(long ret,) char * buf, unsigned long size), + TP_ARGS(sc_exit(ret,) buf, size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(unsigned long, size, size))) +) +#endif +#ifndef OVERRIDE_64_rename +SC_LTTNG_TRACEPOINT_EVENT(rename, + TP_PROTO(sc_exit(long ret,) const char * oldname, const char * newname), + TP_ARGS(sc_exit(ret,) oldname, newname), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_user_string(newname, newname))) +) +#endif +#ifndef OVERRIDE_64_mkdir +SC_LTTNG_TRACEPOINT_EVENT(mkdir, + TP_PROTO(sc_exit(long ret,) const char * pathname, umode_t mode), + TP_ARGS(sc_exit(ret,) pathname, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(umode_t, mode, mode))) +) +#endif +#ifndef OVERRIDE_64_creat +SC_LTTNG_TRACEPOINT_EVENT(creat, + TP_PROTO(sc_exit(long ret,) const char * pathname, umode_t mode), + TP_ARGS(sc_exit(ret,) pathname, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(umode_t, mode, mode))) +) +#endif +#ifndef OVERRIDE_64_link +SC_LTTNG_TRACEPOINT_EVENT(link, + TP_PROTO(sc_exit(long ret,) const char * oldname, const char * newname), + TP_ARGS(sc_exit(ret,) oldname, newname), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_user_string(newname, newname))) +) +#endif +#ifndef OVERRIDE_64_symlink +SC_LTTNG_TRACEPOINT_EVENT(symlink, + TP_PROTO(sc_exit(long ret,) const char * oldname, const char * newname), + TP_ARGS(sc_exit(ret,) oldname, newname), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_user_string(newname, newname))) +) +#endif +#ifndef OVERRIDE_64_chmod +SC_LTTNG_TRACEPOINT_EVENT(chmod, + TP_PROTO(sc_exit(long ret,) const char * filename, umode_t mode), + TP_ARGS(sc_exit(ret,) filename, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(umode_t, mode, mode))) +) +#endif +#ifndef OVERRIDE_64_gettimeofday +SC_LTTNG_TRACEPOINT_EVENT(gettimeofday, + TP_PROTO(sc_exit(long ret,) struct timeval * tv, struct timezone * tz), + TP_ARGS(sc_exit(ret,) tv, tz), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct timeval *, tv, tv)) sc_out(ctf_integer(struct timezone *, tz, tz))) +) +#endif +#ifndef OVERRIDE_64_getrlimit +SC_LTTNG_TRACEPOINT_EVENT(getrlimit, + TP_PROTO(sc_exit(long ret,) unsigned int resource, struct rlimit * rlim), + TP_ARGS(sc_exit(ret,) resource, rlim), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, resource, resource)) sc_out(ctf_integer(struct rlimit *, rlim, rlim))) +) +#endif +#ifndef OVERRIDE_64_getrusage +SC_LTTNG_TRACEPOINT_EVENT(getrusage, + TP_PROTO(sc_exit(long ret,) int who, struct rusage * ru), + TP_ARGS(sc_exit(ret,) who, ru), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, who, who)) sc_out(ctf_integer(struct rusage *, ru, ru))) +) +#endif +#ifndef OVERRIDE_64_getgroups +SC_LTTNG_TRACEPOINT_EVENT(getgroups, + TP_PROTO(sc_exit(long ret,) int gidsetsize, gid_t * grouplist), + TP_ARGS(sc_exit(ret,) gidsetsize, grouplist), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, gidsetsize, gidsetsize)) sc_out(ctf_integer(gid_t *, grouplist, grouplist))) +) +#endif +#ifndef OVERRIDE_64_setgroups +SC_LTTNG_TRACEPOINT_EVENT(setgroups, + TP_PROTO(sc_exit(long ret,) int gidsetsize, gid_t * grouplist), + TP_ARGS(sc_exit(ret,) gidsetsize, grouplist), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, gidsetsize, gidsetsize)) sc_in(ctf_integer(gid_t *, grouplist, grouplist))) +) +#endif +#ifndef OVERRIDE_64_rt_sigpending +SC_LTTNG_TRACEPOINT_EVENT(rt_sigpending, + TP_PROTO(sc_exit(long ret,) sigset_t * uset, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) uset, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(sigset_t *, uset, uset)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) +) +#endif +#ifndef OVERRIDE_64_rt_sigsuspend +SC_LTTNG_TRACEPOINT_EVENT(rt_sigsuspend, + TP_PROTO(sc_exit(long ret,) sigset_t * unewset, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) unewset, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(sigset_t *, unewset, unewset)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) +) +#endif +#ifndef OVERRIDE_64_sigaltstack +SC_LTTNG_TRACEPOINT_EVENT(sigaltstack, + TP_PROTO(sc_exit(long ret,) const stack_t * uss, stack_t * uoss), + TP_ARGS(sc_exit(ret,) uss, uoss), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const stack_t *, uss, uss)) sc_inout(ctf_integer(stack_t *, uoss, uoss))) +) +#endif +#ifndef OVERRIDE_64_utime +SC_LTTNG_TRACEPOINT_EVENT(utime, + TP_PROTO(sc_exit(long ret,) char * filename, struct utimbuf * times), + TP_ARGS(sc_exit(ret,) filename, times), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(struct utimbuf *, times, times))) +) +#endif +#ifndef OVERRIDE_64_ustat +SC_LTTNG_TRACEPOINT_EVENT(ustat, + TP_PROTO(sc_exit(long ret,) unsigned dev, struct ustat * ubuf), + TP_ARGS(sc_exit(ret,) dev, ubuf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned, dev, dev)) sc_out(ctf_integer(struct ustat *, ubuf, ubuf))) +) +#endif +#ifndef OVERRIDE_64_statfs +SC_LTTNG_TRACEPOINT_EVENT(statfs, + TP_PROTO(sc_exit(long ret,) const char * pathname, struct statfs * buf), + TP_ARGS(sc_exit(ret,) pathname, buf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(struct statfs *, buf, buf))) +) +#endif +#ifndef OVERRIDE_64_fstatfs +SC_LTTNG_TRACEPOINT_EVENT(fstatfs, + TP_PROTO(sc_exit(long ret,) unsigned int fd, struct statfs * buf), + TP_ARGS(sc_exit(ret,) fd, buf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct statfs *, buf, buf))) +) +#endif +#ifndef OVERRIDE_64_sched_setparam +SC_LTTNG_TRACEPOINT_EVENT(sched_setparam, + TP_PROTO(sc_exit(long ret,) pid_t pid, struct sched_param * param), + TP_ARGS(sc_exit(ret,) pid, param), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(struct sched_param *, param, param))) +) +#endif +#ifndef OVERRIDE_64_sched_getparam +SC_LTTNG_TRACEPOINT_EVENT(sched_getparam, + TP_PROTO(sc_exit(long ret,) pid_t pid, struct sched_param * param), + TP_ARGS(sc_exit(ret,) pid, param), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_out(ctf_integer(struct sched_param *, param, param))) +) +#endif +#ifndef OVERRIDE_64_sched_rr_get_interval +SC_LTTNG_TRACEPOINT_EVENT(sched_rr_get_interval, + TP_PROTO(sc_exit(long ret,) pid_t pid, struct timespec * interval), + TP_ARGS(sc_exit(ret,) pid, interval), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_out(ctf_integer(struct timespec *, interval, interval))) +) +#endif +#ifndef OVERRIDE_64_pivot_root +SC_LTTNG_TRACEPOINT_EVENT(pivot_root, + TP_PROTO(sc_exit(long ret,) const char * new_root, const char * put_old), + TP_ARGS(sc_exit(ret,) new_root, put_old), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(new_root, new_root)) sc_in(ctf_user_string(put_old, put_old))) +) +#endif +#ifndef OVERRIDE_64_setrlimit +SC_LTTNG_TRACEPOINT_EVENT(setrlimit, + TP_PROTO(sc_exit(long ret,) unsigned int resource, struct rlimit * rlim), + TP_ARGS(sc_exit(ret,) resource, rlim), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, resource, resource)) sc_in(ctf_integer(struct rlimit *, rlim, rlim))) +) +#endif +#ifndef OVERRIDE_64_settimeofday +SC_LTTNG_TRACEPOINT_EVENT(settimeofday, + TP_PROTO(sc_exit(long ret,) struct timeval * tv, struct timezone * tz), + TP_ARGS(sc_exit(ret,) tv, tz), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct timeval *, tv, tv)) sc_in(ctf_integer(struct timezone *, tz, tz))) +) +#endif +#ifndef OVERRIDE_64_umount +SC_LTTNG_TRACEPOINT_EVENT(umount, + TP_PROTO(sc_exit(long ret,) char * name, int flags), + TP_ARGS(sc_exit(ret,) name, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_swapon +SC_LTTNG_TRACEPOINT_EVENT(swapon, + TP_PROTO(sc_exit(long ret,) const char * specialfile, int swap_flags), + TP_ARGS(sc_exit(ret,) specialfile, swap_flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(specialfile, specialfile)) sc_in(ctf_integer(int, swap_flags, swap_flags))) +) +#endif +#ifndef OVERRIDE_64_sethostname +SC_LTTNG_TRACEPOINT_EVENT(sethostname, + TP_PROTO(sc_exit(long ret,) char * name, int len), + TP_ARGS(sc_exit(ret,) name, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(int, len, len))) +) +#endif +#ifndef OVERRIDE_64_setdomainname +SC_LTTNG_TRACEPOINT_EVENT(setdomainname, + TP_PROTO(sc_exit(long ret,) char * name, int len), + TP_ARGS(sc_exit(ret,) name, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(int, len, len))) +) +#endif +#ifndef OVERRIDE_64_delete_module +SC_LTTNG_TRACEPOINT_EVENT(delete_module, + TP_PROTO(sc_exit(long ret,) const char * name_user, unsigned int flags), + TP_ARGS(sc_exit(ret,) name_user, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name_user, name_user)) sc_in(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_removexattr +SC_LTTNG_TRACEPOINT_EVENT(removexattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name), + TP_ARGS(sc_exit(ret,) pathname, name), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name))) +) +#endif +#ifndef OVERRIDE_64_lremovexattr +SC_LTTNG_TRACEPOINT_EVENT(lremovexattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name), + TP_ARGS(sc_exit(ret,) pathname, name), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name))) +) +#endif +#ifndef OVERRIDE_64_fremovexattr +SC_LTTNG_TRACEPOINT_EVENT(fremovexattr, + TP_PROTO(sc_exit(long ret,) int fd, const char * name), + TP_ARGS(sc_exit(ret,) fd, name), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(name, name))) +) +#endif +#ifndef OVERRIDE_64_io_setup +SC_LTTNG_TRACEPOINT_EVENT(io_setup, + TP_PROTO(sc_exit(long ret,) unsigned nr_events, aio_context_t * ctxp), + TP_ARGS(sc_exit(ret,) nr_events, ctxp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned, nr_events, nr_events)) sc_in(ctf_integer(aio_context_t *, ctxp, ctxp))) +) +#endif +#ifndef OVERRIDE_64_timer_gettime +SC_LTTNG_TRACEPOINT_EVENT(timer_gettime, + TP_PROTO(sc_exit(long ret,) timer_t timer_id, struct itimerspec * setting), + TP_ARGS(sc_exit(ret,) timer_id, setting), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id)) sc_out(ctf_integer(struct itimerspec *, setting, setting))) +) +#endif +#ifndef OVERRIDE_64_clock_settime +SC_LTTNG_TRACEPOINT_EVENT(clock_settime, + TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, const struct timespec * tp), + TP_ARGS(sc_exit(ret,) which_clock, tp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_in(ctf_integer(const struct timespec *, tp, tp))) +) +#endif +#ifndef OVERRIDE_64_clock_gettime +SC_LTTNG_TRACEPOINT_EVENT(clock_gettime, + TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct timespec * tp), + TP_ARGS(sc_exit(ret,) which_clock, tp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_out(ctf_integer(struct timespec *, tp, tp))) +) +#endif +#ifndef OVERRIDE_64_clock_getres +SC_LTTNG_TRACEPOINT_EVENT(clock_getres, + TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct timespec * tp), + TP_ARGS(sc_exit(ret,) which_clock, tp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_out(ctf_integer(struct timespec *, tp, tp))) +) +#endif +#ifndef OVERRIDE_64_utimes +SC_LTTNG_TRACEPOINT_EVENT(utimes, + TP_PROTO(sc_exit(long ret,) char * filename, struct timeval * utimes), + TP_ARGS(sc_exit(ret,) filename, utimes), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(struct timeval *, utimes, utimes))) +) +#endif +#ifndef OVERRIDE_64_mq_notify +SC_LTTNG_TRACEPOINT_EVENT(mq_notify, + TP_PROTO(sc_exit(long ret,) mqd_t mqdes, const struct sigevent * u_notification), + TP_ARGS(sc_exit(ret,) mqdes, u_notification), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(mqd_t, mqdes, mqdes)) sc_in(ctf_integer(const struct sigevent *, u_notification, u_notification))) +) +#endif +#ifndef OVERRIDE_64_set_robust_list +SC_LTTNG_TRACEPOINT_EVENT(set_robust_list, + TP_PROTO(sc_exit(long ret,) struct robust_list_head * head, size_t len), + TP_ARGS(sc_exit(ret,) head, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct robust_list_head *, head, head)) sc_in(ctf_integer(size_t, len, len))) +) +#endif +#ifndef OVERRIDE_64_timerfd_gettime +SC_LTTNG_TRACEPOINT_EVENT(timerfd_gettime, + TP_PROTO(sc_exit(long ret,) int ufd, struct itimerspec * otmr), + TP_ARGS(sc_exit(ret,) ufd, otmr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_out(ctf_integer(struct itimerspec *, otmr, otmr))) +) +#endif +#ifndef OVERRIDE_64_pipe2 +SC_LTTNG_TRACEPOINT_EVENT(pipe2, + TP_PROTO(sc_exit(long ret,) int * fildes, int flags), + TP_ARGS(sc_exit(ret,) fildes, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(int *, fildes, fildes)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_clock_adjtime +SC_LTTNG_TRACEPOINT_EVENT(clock_adjtime, + TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct timex * utx), + TP_ARGS(sc_exit(ret,) which_clock, utx), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_inout(ctf_integer(struct timex *, utx, utx))) +) +#endif +#ifndef OVERRIDE_64_read +SC_LTTNG_TRACEPOINT_EVENT(read, + TP_PROTO(sc_exit(long ret,) unsigned int fd, char * buf, size_t count), + TP_ARGS(sc_exit(ret,) fd, buf, count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(size_t, count, count))) +) +#endif +#ifndef OVERRIDE_64_write +SC_LTTNG_TRACEPOINT_EVENT(write, + TP_PROTO(sc_exit(long ret,) unsigned int fd, const char * buf, size_t count), + TP_ARGS(sc_exit(ret,) fd, buf, count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(const char *, buf, buf)) sc_in(ctf_integer(size_t, count, count))) +) +#endif +#ifndef OVERRIDE_64_open +SC_LTTNG_TRACEPOINT_EVENT(open, + TP_PROTO(sc_exit(long ret,) const char * filename, int flags, umode_t mode), + TP_ARGS(sc_exit(ret,) filename, flags, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(umode_t, mode, mode))) +) +#endif +#ifndef OVERRIDE_64_poll +SC_LTTNG_TRACEPOINT_EVENT(poll, + TP_PROTO(sc_exit(long ret,) struct pollfd * ufds, unsigned int nfds, int timeout_msecs), + TP_ARGS(sc_exit(ret,) ufds, nfds, timeout_msecs), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct pollfd *, ufds, ufds)) sc_in(ctf_integer(unsigned int, nfds, nfds)) sc_in(ctf_integer(int, timeout_msecs, timeout_msecs))) +) +#endif +#ifndef OVERRIDE_64_readv +SC_LTTNG_TRACEPOINT_EVENT(readv, + TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen), + TP_ARGS(sc_exit(ret,) fd, vec, vlen), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_inout(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen))) +) +#endif +#ifndef OVERRIDE_64_writev +SC_LTTNG_TRACEPOINT_EVENT(writev, + TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen), + TP_ARGS(sc_exit(ret,) fd, vec, vlen), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_inout(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen))) +) +#endif +#ifndef OVERRIDE_64_mincore +SC_LTTNG_TRACEPOINT_EVENT(mincore, + TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len, unsigned char * vec), + TP_ARGS(sc_exit(ret,) start, len, vec), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len)) sc_out(ctf_integer(unsigned char *, vec, vec))) +) +#endif +#ifndef OVERRIDE_64_shmat +SC_LTTNG_TRACEPOINT_EVENT(shmat, + TP_PROTO(sc_exit(long ret,) int shmid, char * shmaddr, int shmflg), + TP_ARGS(sc_exit(ret,) shmid, shmaddr, shmflg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, shmid, shmid)) sc_in(ctf_integer(char *, shmaddr, shmaddr)) sc_in(ctf_integer(int, shmflg, shmflg))) +) +#endif +#ifndef OVERRIDE_64_shmctl +SC_LTTNG_TRACEPOINT_EVENT(shmctl, + TP_PROTO(sc_exit(long ret,) int shmid, int cmd, struct shmid_ds * buf), + TP_ARGS(sc_exit(ret,) shmid, cmd, buf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, shmid, shmid)) sc_in(ctf_integer(int, cmd, cmd)) sc_inout(ctf_integer(struct shmid_ds *, buf, buf))) +) +#endif +#ifndef OVERRIDE_64_setitimer +SC_LTTNG_TRACEPOINT_EVENT(setitimer, + TP_PROTO(sc_exit(long ret,) int which, struct itimerval * value, struct itimerval * ovalue), + TP_ARGS(sc_exit(ret,) which, value, ovalue), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(struct itimerval *, value, value)) sc_out(ctf_integer(struct itimerval *, ovalue, ovalue))) +) +#endif +#ifndef OVERRIDE_64_connect +SC_LTTNG_TRACEPOINT_EVENT(connect, + TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * uservaddr, int addrlen), + TP_ARGS(sc_exit(ret,) fd, uservaddr, addrlen), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct sockaddr *, uservaddr, uservaddr)) sc_in(ctf_integer(int, addrlen, addrlen))) +) +#endif +#ifndef OVERRIDE_64_accept +SC_LTTNG_TRACEPOINT_EVENT(accept, + TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * upeer_sockaddr, int * upeer_addrlen), + TP_ARGS(sc_exit(ret,) fd, upeer_sockaddr, upeer_addrlen), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct sockaddr *, upeer_sockaddr, upeer_sockaddr)) sc_inout(ctf_integer(int *, upeer_addrlen, upeer_addrlen))) +) +#endif +#ifndef OVERRIDE_64_sendmsg +SC_LTTNG_TRACEPOINT_EVENT(sendmsg, + TP_PROTO(sc_exit(long ret,) int fd, struct msghdr * msg, unsigned int flags), + TP_ARGS(sc_exit(ret,) fd, msg, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct msghdr *, msg, msg)) sc_in(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_recvmsg +SC_LTTNG_TRACEPOINT_EVENT(recvmsg, + TP_PROTO(sc_exit(long ret,) int fd, struct msghdr * msg, unsigned int flags), + TP_ARGS(sc_exit(ret,) fd, msg, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_inout(ctf_integer(struct msghdr *, msg, msg)) sc_in(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_bind +SC_LTTNG_TRACEPOINT_EVENT(bind, + TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * umyaddr, int addrlen), + TP_ARGS(sc_exit(ret,) fd, umyaddr, addrlen), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct sockaddr *, umyaddr, umyaddr)) sc_in(ctf_integer(int, addrlen, addrlen))) +) +#endif +#ifndef OVERRIDE_64_getsockname +SC_LTTNG_TRACEPOINT_EVENT(getsockname, + TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * usockaddr, int * usockaddr_len), + TP_ARGS(sc_exit(ret,) fd, usockaddr, usockaddr_len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct sockaddr *, usockaddr, usockaddr)) sc_inout(ctf_integer(int *, usockaddr_len, usockaddr_len))) +) +#endif +#ifndef OVERRIDE_64_getpeername +SC_LTTNG_TRACEPOINT_EVENT(getpeername, + TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * usockaddr, int * usockaddr_len), + TP_ARGS(sc_exit(ret,) fd, usockaddr, usockaddr_len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct sockaddr *, usockaddr, usockaddr)) sc_inout(ctf_integer(int *, usockaddr_len, usockaddr_len))) +) +#endif +#ifndef OVERRIDE_64_semop +SC_LTTNG_TRACEPOINT_EVENT(semop, + TP_PROTO(sc_exit(long ret,) int semid, struct sembuf * tsops, unsigned nsops), + TP_ARGS(sc_exit(ret,) semid, tsops, nsops), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, semid, semid)) sc_in(ctf_integer(struct sembuf *, tsops, tsops)) sc_in(ctf_integer(unsigned, nsops, nsops))) +) +#endif +#ifndef OVERRIDE_64_msgctl +SC_LTTNG_TRACEPOINT_EVENT(msgctl, + TP_PROTO(sc_exit(long ret,) int msqid, int cmd, struct msqid_ds * buf), + TP_ARGS(sc_exit(ret,) msqid, cmd, buf), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, msqid, msqid)) sc_in(ctf_integer(int, cmd, cmd)) sc_inout(ctf_integer(struct msqid_ds *, buf, buf))) +) +#endif +#ifndef OVERRIDE_64_getdents +SC_LTTNG_TRACEPOINT_EVENT(getdents, + TP_PROTO(sc_exit(long ret,) unsigned int fd, struct linux_dirent * dirent, unsigned int count), + TP_ARGS(sc_exit(ret,) fd, dirent, count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct linux_dirent *, dirent, dirent)) sc_in(ctf_integer(unsigned int, count, count))) +) +#endif +#ifndef OVERRIDE_64_readlink +SC_LTTNG_TRACEPOINT_EVENT(readlink, + TP_PROTO(sc_exit(long ret,) const char * path, char * buf, int bufsiz), + TP_ARGS(sc_exit(ret,) path, buf, bufsiz), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(path, path)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(int, bufsiz, bufsiz))) +) +#endif +#ifndef OVERRIDE_64_chown +SC_LTTNG_TRACEPOINT_EVENT(chown, + TP_PROTO(sc_exit(long ret,) const char * filename, uid_t user, gid_t group), + TP_ARGS(sc_exit(ret,) filename, user, group), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group))) +) +#endif +#ifndef OVERRIDE_64_lchown +SC_LTTNG_TRACEPOINT_EVENT(lchown, + TP_PROTO(sc_exit(long ret,) const char * filename, uid_t user, gid_t group), + TP_ARGS(sc_exit(ret,) filename, user, group), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group))) +) +#endif +#ifndef OVERRIDE_64_syslog +SC_LTTNG_TRACEPOINT_EVENT(syslog, + TP_PROTO(sc_exit(long ret,) int type, char * buf, int len), + TP_ARGS(sc_exit(ret,) type, buf, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, type, type)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(int, len, len))) +) +#endif +#ifndef OVERRIDE_64_getresuid +SC_LTTNG_TRACEPOINT_EVENT(getresuid, + TP_PROTO(sc_exit(long ret,) uid_t * ruidp, uid_t * euidp, uid_t * suidp), + TP_ARGS(sc_exit(ret,) ruidp, euidp, suidp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(uid_t *, ruidp, ruidp)) sc_out(ctf_integer(uid_t *, euidp, euidp)) sc_out(ctf_integer(uid_t *, suidp, suidp))) +) +#endif +#ifndef OVERRIDE_64_getresgid +SC_LTTNG_TRACEPOINT_EVENT(getresgid, + TP_PROTO(sc_exit(long ret,) gid_t * rgidp, gid_t * egidp, gid_t * sgidp), + TP_ARGS(sc_exit(ret,) rgidp, egidp, sgidp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(gid_t *, rgidp, rgidp)) sc_out(ctf_integer(gid_t *, egidp, egidp)) sc_out(ctf_integer(gid_t *, sgidp, sgidp))) +) +#endif +#ifndef OVERRIDE_64_rt_sigqueueinfo +SC_LTTNG_TRACEPOINT_EVENT(rt_sigqueueinfo, + TP_PROTO(sc_exit(long ret,) pid_t pid, int sig, siginfo_t * uinfo), + TP_ARGS(sc_exit(ret,) pid, sig, uinfo), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig)) sc_in(ctf_integer(siginfo_t *, uinfo, uinfo))) +) +#endif +#ifndef OVERRIDE_64_mknod +SC_LTTNG_TRACEPOINT_EVENT(mknod, + TP_PROTO(sc_exit(long ret,) const char * filename, umode_t mode, unsigned dev), + TP_ARGS(sc_exit(ret,) filename, mode, dev), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(umode_t, mode, mode)) sc_in(ctf_integer(unsigned, dev, dev))) +) +#endif +#ifndef OVERRIDE_64_sched_setscheduler +SC_LTTNG_TRACEPOINT_EVENT(sched_setscheduler, + TP_PROTO(sc_exit(long ret,) pid_t pid, int policy, struct sched_param * param), + TP_ARGS(sc_exit(ret,) pid, policy, param), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, policy, policy)) sc_in(ctf_integer(struct sched_param *, param, param))) +) +#endif +#ifndef OVERRIDE_64_init_module +SC_LTTNG_TRACEPOINT_EVENT(init_module, + TP_PROTO(sc_exit(long ret,) void * umod, unsigned long len, const char * uargs), + TP_ARGS(sc_exit(ret,) umod, len, uargs), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(void *, umod, umod)) sc_in(ctf_integer(unsigned long, len, len)) sc_in(ctf_integer(const char *, uargs, uargs))) +) +#endif +#ifndef OVERRIDE_64_listxattr +SC_LTTNG_TRACEPOINT_EVENT(listxattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, char * list, size_t size), + TP_ARGS(sc_exit(ret,) pathname, list, size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(char *, list, list)) sc_in(ctf_integer(size_t, size, size))) +) +#endif +#ifndef OVERRIDE_64_llistxattr +SC_LTTNG_TRACEPOINT_EVENT(llistxattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, char * list, size_t size), + TP_ARGS(sc_exit(ret,) pathname, list, size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(char *, list, list)) sc_in(ctf_integer(size_t, size, size))) +) +#endif +#ifndef OVERRIDE_64_flistxattr +SC_LTTNG_TRACEPOINT_EVENT(flistxattr, + TP_PROTO(sc_exit(long ret,) int fd, char * list, size_t size), + TP_ARGS(sc_exit(ret,) fd, list, size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(char *, list, list)) sc_in(ctf_integer(size_t, size, size))) +) +#endif +#ifndef OVERRIDE_64_sched_setaffinity +SC_LTTNG_TRACEPOINT_EVENT(sched_setaffinity, + TP_PROTO(sc_exit(long ret,) pid_t pid, unsigned int len, unsigned long * user_mask_ptr), + TP_ARGS(sc_exit(ret,) pid, len, user_mask_ptr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(unsigned int, len, len)) sc_in(ctf_integer(unsigned long *, user_mask_ptr, user_mask_ptr))) +) +#endif +#ifndef OVERRIDE_64_sched_getaffinity +SC_LTTNG_TRACEPOINT_EVENT(sched_getaffinity, + TP_PROTO(sc_exit(long ret,) pid_t pid, unsigned int len, unsigned long * user_mask_ptr), + TP_ARGS(sc_exit(ret,) pid, len, user_mask_ptr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(unsigned int, len, len)) sc_out(ctf_integer(unsigned long *, user_mask_ptr, user_mask_ptr))) +) +#endif +#ifndef OVERRIDE_64_io_submit +SC_LTTNG_TRACEPOINT_EVENT(io_submit, + TP_PROTO(sc_exit(long ret,) aio_context_t ctx_id, long nr, struct iocb * * iocbpp), + TP_ARGS(sc_exit(ret,) ctx_id, nr, iocbpp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx_id, ctx_id)) sc_in(ctf_integer(long, nr, nr)) sc_in(ctf_integer(struct iocb * *, iocbpp, iocbpp))) +) +#endif +#ifndef OVERRIDE_64_io_cancel +SC_LTTNG_TRACEPOINT_EVENT(io_cancel, + TP_PROTO(sc_exit(long ret,) aio_context_t ctx_id, struct iocb * iocb, struct io_event * result), + TP_ARGS(sc_exit(ret,) ctx_id, iocb, result), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx_id, ctx_id)) sc_in(ctf_integer(struct iocb *, iocb, iocb)) sc_out(ctf_integer(struct io_event *, result, result))) +) +#endif +#ifndef OVERRIDE_64_lookup_dcookie +SC_LTTNG_TRACEPOINT_EVENT(lookup_dcookie, + TP_PROTO(sc_exit(long ret,) u64 cookie64, char * buf, size_t len), + TP_ARGS(sc_exit(ret,) cookie64, buf, len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(u64, cookie64, cookie64)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(size_t, len, len))) +) +#endif +#ifndef OVERRIDE_64_getdents64 +SC_LTTNG_TRACEPOINT_EVENT(getdents64, + TP_PROTO(sc_exit(long ret,) unsigned int fd, struct linux_dirent64 * dirent, unsigned int count), + TP_ARGS(sc_exit(ret,) fd, dirent, count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct linux_dirent64 *, dirent, dirent)) sc_in(ctf_integer(unsigned int, count, count))) +) +#endif +#ifndef OVERRIDE_64_timer_create +SC_LTTNG_TRACEPOINT_EVENT(timer_create, + TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct sigevent * timer_event_spec, timer_t * created_timer_id), + TP_ARGS(sc_exit(ret,) which_clock, timer_event_spec, created_timer_id), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_in(ctf_integer(struct sigevent *, timer_event_spec, timer_event_spec)) sc_out(ctf_integer(timer_t *, created_timer_id, created_timer_id))) +) +#endif +#ifndef OVERRIDE_64_set_mempolicy +SC_LTTNG_TRACEPOINT_EVENT(set_mempolicy, + TP_PROTO(sc_exit(long ret,) int mode, unsigned long * nmask, unsigned long maxnode), + TP_ARGS(sc_exit(ret,) mode, nmask, maxnode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, mode, mode)) sc_in(ctf_integer(unsigned long *, nmask, nmask)) sc_in(ctf_integer(unsigned long, maxnode, maxnode))) +) +#endif +#ifndef OVERRIDE_64_mq_getsetattr +SC_LTTNG_TRACEPOINT_EVENT(mq_getsetattr, + TP_PROTO(sc_exit(long ret,) mqd_t mqdes, const struct mq_attr * u_mqstat, struct mq_attr * u_omqstat), + TP_ARGS(sc_exit(ret,) mqdes, u_mqstat, u_omqstat), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(mqd_t, mqdes, mqdes)) sc_in(ctf_integer(const struct mq_attr *, u_mqstat, u_mqstat)) sc_out(ctf_integer(struct mq_attr *, u_omqstat, u_omqstat))) +) +#endif +#ifndef OVERRIDE_64_inotify_add_watch +SC_LTTNG_TRACEPOINT_EVENT(inotify_add_watch, + TP_PROTO(sc_exit(long ret,) int fd, const char * pathname, u32 mask), + TP_ARGS(sc_exit(ret,) fd, pathname, mask), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(u32, mask, mask))) +) +#endif +#ifndef OVERRIDE_64_mkdirat +SC_LTTNG_TRACEPOINT_EVENT(mkdirat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * pathname, umode_t mode), + TP_ARGS(sc_exit(ret,) dfd, pathname, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(umode_t, mode, mode))) +) +#endif +#ifndef OVERRIDE_64_futimesat +SC_LTTNG_TRACEPOINT_EVENT(futimesat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, struct timeval * utimes), + TP_ARGS(sc_exit(ret,) dfd, filename, utimes), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(struct timeval *, utimes, utimes))) +) +#endif +#ifndef OVERRIDE_64_unlinkat +SC_LTTNG_TRACEPOINT_EVENT(unlinkat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * pathname, int flag), + TP_ARGS(sc_exit(ret,) dfd, pathname, flag), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(int, flag, flag))) +) +#endif +#ifndef OVERRIDE_64_symlinkat +SC_LTTNG_TRACEPOINT_EVENT(symlinkat, + TP_PROTO(sc_exit(long ret,) const char * oldname, int newdfd, const char * newname), + TP_ARGS(sc_exit(ret,) oldname, newdfd, newname), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_integer(int, newdfd, newdfd)) sc_in(ctf_user_string(newname, newname))) +) +#endif +#ifndef OVERRIDE_64_fchmodat +SC_LTTNG_TRACEPOINT_EVENT(fchmodat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, umode_t mode), + TP_ARGS(sc_exit(ret,) dfd, filename, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(umode_t, mode, mode))) +) +#endif +#ifndef OVERRIDE_64_faccessat +SC_LTTNG_TRACEPOINT_EVENT(faccessat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, int mode), + TP_ARGS(sc_exit(ret,) dfd, filename, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, mode, mode))) +) +#endif +#ifndef OVERRIDE_64_get_robust_list +SC_LTTNG_TRACEPOINT_EVENT(get_robust_list, + TP_PROTO(sc_exit(long ret,) int pid, struct robust_list_head * * head_ptr, size_t * len_ptr), + TP_ARGS(sc_exit(ret,) pid, head_ptr, len_ptr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, pid, pid)) sc_out(ctf_integer(struct robust_list_head * *, head_ptr, head_ptr)) sc_out(ctf_integer(size_t *, len_ptr, len_ptr))) +) +#endif +#ifndef OVERRIDE_64_signalfd +SC_LTTNG_TRACEPOINT_EVENT(signalfd, + TP_PROTO(sc_exit(long ret,) int ufd, sigset_t * user_mask, size_t sizemask), + TP_ARGS(sc_exit(ret,) ufd, user_mask, sizemask), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_in(ctf_integer(sigset_t *, user_mask, user_mask)) sc_in(ctf_integer(size_t, sizemask, sizemask))) +) +#endif +#ifndef OVERRIDE_64_open_by_handle_at +SC_LTTNG_TRACEPOINT_EVENT(open_by_handle_at, + TP_PROTO(sc_exit(long ret,) int mountdirfd, struct file_handle * handle, int flags), + TP_ARGS(sc_exit(ret,) mountdirfd, handle, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, mountdirfd, mountdirfd)) sc_in(ctf_integer(struct file_handle *, handle, handle)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_getcpu +SC_LTTNG_TRACEPOINT_EVENT(getcpu, + TP_PROTO(sc_exit(long ret,) unsigned * cpup, unsigned * nodep, struct getcpu_cache * unused), + TP_ARGS(sc_exit(ret,) cpup, nodep, unused), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(unsigned *, cpup, cpup)) sc_out(ctf_integer(unsigned *, nodep, nodep)) sc_inout(ctf_integer(struct getcpu_cache *, unused, unused))) +) +#endif +#ifndef OVERRIDE_64_finit_module +SC_LTTNG_TRACEPOINT_EVENT(finit_module, + TP_PROTO(sc_exit(long ret,) int fd, const char * uargs, int flags), + TP_ARGS(sc_exit(ret,) fd, uargs, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(const char *, uargs, uargs)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_rt_sigaction +SC_LTTNG_TRACEPOINT_EVENT(rt_sigaction, + TP_PROTO(sc_exit(long ret,) int sig, const struct sigaction * act, struct sigaction * oact, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) sig, act, oact, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, sig, sig)) sc_in(ctf_integer(const struct sigaction *, act, act)) sc_out(ctf_integer(struct sigaction *, oact, oact)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) +) +#endif +#ifndef OVERRIDE_64_rt_sigprocmask +SC_LTTNG_TRACEPOINT_EVENT(rt_sigprocmask, + TP_PROTO(sc_exit(long ret,) int how, sigset_t * nset, sigset_t * oset, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) how, nset, oset, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, how, how)) sc_in(ctf_integer(sigset_t *, nset, nset)) sc_out(ctf_integer(sigset_t *, oset, oset)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) +) +#endif +#ifndef OVERRIDE_64_pread64 +SC_LTTNG_TRACEPOINT_EVENT(pread64, + TP_PROTO(sc_exit(long ret,) unsigned int fd, char * buf, size_t count, loff_t pos), + TP_ARGS(sc_exit(ret,) fd, buf, count, pos), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(size_t, count, count)) sc_in(ctf_integer(loff_t, pos, pos))) +) +#endif +#ifndef OVERRIDE_64_pwrite64 +SC_LTTNG_TRACEPOINT_EVENT(pwrite64, + TP_PROTO(sc_exit(long ret,) unsigned int fd, const char * buf, size_t count, loff_t pos), + TP_ARGS(sc_exit(ret,) fd, buf, count, pos), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(const char *, buf, buf)) sc_in(ctf_integer(size_t, count, count)) sc_in(ctf_integer(loff_t, pos, pos))) +) +#endif +#ifndef OVERRIDE_64_sendfile64 +SC_LTTNG_TRACEPOINT_EVENT(sendfile64, + TP_PROTO(sc_exit(long ret,) int out_fd, int in_fd, loff_t * offset, size_t count), + TP_ARGS(sc_exit(ret,) out_fd, in_fd, offset, count), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, out_fd, out_fd)) sc_in(ctf_integer(int, in_fd, in_fd)) sc_inout(ctf_integer(loff_t *, offset, offset)) sc_in(ctf_integer(size_t, count, count))) +) +#endif +#ifndef OVERRIDE_64_socketpair +SC_LTTNG_TRACEPOINT_EVENT(socketpair, + TP_PROTO(sc_exit(long ret,) int family, int type, int protocol, int * usockvec), + TP_ARGS(sc_exit(ret,) family, type, protocol, usockvec), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, family, family)) sc_in(ctf_integer(int, type, type)) sc_in(ctf_integer(int, protocol, protocol)) sc_out(ctf_integer(int *, usockvec, usockvec))) +) +#endif +#ifndef OVERRIDE_64_wait4 +SC_LTTNG_TRACEPOINT_EVENT(wait4, + TP_PROTO(sc_exit(long ret,) pid_t upid, int * stat_addr, int options, struct rusage * ru), + TP_ARGS(sc_exit(ret,) upid, stat_addr, options, ru), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, upid, upid)) sc_out(ctf_integer(int *, stat_addr, stat_addr)) sc_in(ctf_integer(int, options, options)) sc_out(ctf_integer(struct rusage *, ru, ru))) +) +#endif +#ifndef OVERRIDE_64_msgsnd +SC_LTTNG_TRACEPOINT_EVENT(msgsnd, + TP_PROTO(sc_exit(long ret,) int msqid, struct msgbuf * msgp, size_t msgsz, int msgflg), + TP_ARGS(sc_exit(ret,) msqid, msgp, msgsz, msgflg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, msqid, msqid)) sc_in(ctf_integer(struct msgbuf *, msgp, msgp)) sc_in(ctf_integer(size_t, msgsz, msgsz)) sc_in(ctf_integer(int, msgflg, msgflg))) +) +#endif +#ifndef OVERRIDE_64_rt_sigtimedwait +SC_LTTNG_TRACEPOINT_EVENT(rt_sigtimedwait, + TP_PROTO(sc_exit(long ret,) const sigset_t * uthese, siginfo_t * uinfo, const struct timespec * uts, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) uthese, uinfo, uts, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(const sigset_t *, uthese, uthese)) sc_out(ctf_integer(siginfo_t *, uinfo, uinfo)) sc_in(ctf_integer(const struct timespec *, uts, uts)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) +) +#endif +#ifndef OVERRIDE_64_reboot +SC_LTTNG_TRACEPOINT_EVENT(reboot, + TP_PROTO(sc_exit(long ret,) int magic1, int magic2, unsigned int cmd, void * arg), + TP_ARGS(sc_exit(ret,) magic1, magic2, cmd, arg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, magic1, magic1)) sc_in(ctf_integer(int, magic2, magic2)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_in(ctf_integer(void *, arg, arg))) +) +#endif +#ifndef OVERRIDE_64_quotactl +SC_LTTNG_TRACEPOINT_EVENT(quotactl, + TP_PROTO(sc_exit(long ret,) unsigned int cmd, const char * special, qid_t id, void * addr), + TP_ARGS(sc_exit(ret,) cmd, special, id, addr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_in(ctf_integer(const char *, special, special)) sc_in(ctf_integer(qid_t, id, id)) sc_inout(ctf_integer(void *, addr, addr))) +) +#endif +#ifndef OVERRIDE_64_getxattr +SC_LTTNG_TRACEPOINT_EVENT(getxattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, void * value, size_t size), + TP_ARGS(sc_exit(ret,) pathname, name, value, size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_out(ctf_integer(void *, value, value)) sc_in(ctf_integer(size_t, size, size))) +) +#endif +#ifndef OVERRIDE_64_lgetxattr +SC_LTTNG_TRACEPOINT_EVENT(lgetxattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, void * value, size_t size), + TP_ARGS(sc_exit(ret,) pathname, name, value, size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_out(ctf_integer(void *, value, value)) sc_in(ctf_integer(size_t, size, size))) +) +#endif +#ifndef OVERRIDE_64_fgetxattr +SC_LTTNG_TRACEPOINT_EVENT(fgetxattr, + TP_PROTO(sc_exit(long ret,) int fd, const char * name, void * value, size_t size), + TP_ARGS(sc_exit(ret,) fd, name, value, size), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(name, name)) sc_out(ctf_integer(void *, value, value)) sc_in(ctf_integer(size_t, size, size))) +) +#endif +#ifndef OVERRIDE_64_semtimedop +SC_LTTNG_TRACEPOINT_EVENT(semtimedop, + TP_PROTO(sc_exit(long ret,) int semid, struct sembuf * tsops, unsigned nsops, const struct timespec * timeout), + TP_ARGS(sc_exit(ret,) semid, tsops, nsops, timeout), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, semid, semid)) sc_in(ctf_integer(struct sembuf *, tsops, tsops)) sc_in(ctf_integer(unsigned, nsops, nsops)) sc_inout(ctf_integer(const struct timespec *, timeout, timeout))) +) +#endif +#ifndef OVERRIDE_64_timer_settime +SC_LTTNG_TRACEPOINT_EVENT(timer_settime, + TP_PROTO(sc_exit(long ret,) timer_t timer_id, int flags, const struct itimerspec * new_setting, struct itimerspec * old_setting), + TP_ARGS(sc_exit(ret,) timer_id, flags, new_setting, old_setting), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(const struct itimerspec *, new_setting, new_setting)) sc_out(ctf_integer(struct itimerspec *, old_setting, old_setting))) +) +#endif +#ifndef OVERRIDE_64_clock_nanosleep +SC_LTTNG_TRACEPOINT_EVENT(clock_nanosleep, + TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, int flags, const struct timespec * rqtp, struct timespec * rmtp), + TP_ARGS(sc_exit(ret,) which_clock, flags, rqtp, rmtp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(const struct timespec *, rqtp, rqtp)) sc_out(ctf_integer(struct timespec *, rmtp, rmtp))) +) +#endif +#ifndef OVERRIDE_64_epoll_wait +SC_LTTNG_TRACEPOINT_EVENT(epoll_wait, + TP_PROTO(sc_exit(long ret,) int epfd, struct epoll_event * events, int maxevents, int timeout), + TP_ARGS(sc_exit(ret,) epfd, events, maxevents, timeout), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, epfd, epfd)) sc_out(ctf_integer(struct epoll_event *, events, events)) sc_in(ctf_integer(int, maxevents, maxevents)) sc_in(ctf_integer(int, timeout, timeout))) +) +#endif +#ifndef OVERRIDE_64_epoll_ctl +SC_LTTNG_TRACEPOINT_EVENT(epoll_ctl, + TP_PROTO(sc_exit(long ret,) int epfd, int op, int fd, struct epoll_event * event), + TP_ARGS(sc_exit(ret,) epfd, op, fd, event), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, epfd, epfd)) sc_in(ctf_integer(int, op, op)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct epoll_event *, event, event))) +) +#endif +#ifndef OVERRIDE_64_mq_open +SC_LTTNG_TRACEPOINT_EVENT(mq_open, + TP_PROTO(sc_exit(long ret,) const char * u_name, int oflag, umode_t mode, struct mq_attr * u_attr), + TP_ARGS(sc_exit(ret,) u_name, oflag, mode, u_attr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(u_name, u_name)) sc_in(ctf_integer(int, oflag, oflag)) sc_in(ctf_integer(umode_t, mode, mode)) sc_in(ctf_integer(struct mq_attr *, u_attr, u_attr))) +) +#endif +#ifndef OVERRIDE_64_kexec_load +SC_LTTNG_TRACEPOINT_EVENT(kexec_load, + TP_PROTO(sc_exit(long ret,) unsigned long entry, unsigned long nr_segments, struct kexec_segment * segments, unsigned long flags), + TP_ARGS(sc_exit(ret,) entry, nr_segments, segments, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, entry, entry)) sc_in(ctf_integer(unsigned long, nr_segments, nr_segments)) sc_in(ctf_integer(struct kexec_segment *, segments, segments)) sc_in(ctf_integer(unsigned long, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_request_key +SC_LTTNG_TRACEPOINT_EVENT(request_key, + TP_PROTO(sc_exit(long ret,) const char * _type, const char * _description, const char * _callout_info, key_serial_t destringid), + TP_ARGS(sc_exit(ret,) _type, _description, _callout_info, destringid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(_type, _type)) sc_in(ctf_integer(const char *, _description, _description)) sc_in(ctf_integer(const char *, _callout_info, _callout_info)) sc_in(ctf_integer(key_serial_t, destringid, destringid))) +) +#endif +#ifndef OVERRIDE_64_migrate_pages +SC_LTTNG_TRACEPOINT_EVENT(migrate_pages, + TP_PROTO(sc_exit(long ret,) pid_t pid, unsigned long maxnode, const unsigned long * old_nodes, const unsigned long * new_nodes), + TP_ARGS(sc_exit(ret,) pid, maxnode, old_nodes, new_nodes), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(unsigned long, maxnode, maxnode)) sc_in(ctf_integer(const unsigned long *, old_nodes, old_nodes)) sc_in(ctf_integer(const unsigned long *, new_nodes, new_nodes))) +) +#endif +#ifndef OVERRIDE_64_openat +SC_LTTNG_TRACEPOINT_EVENT(openat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, int flags, umode_t mode), + TP_ARGS(sc_exit(ret,) dfd, filename, flags, mode), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(umode_t, mode, mode))) +) +#endif +#ifndef OVERRIDE_64_mknodat +SC_LTTNG_TRACEPOINT_EVENT(mknodat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, umode_t mode, unsigned dev), + TP_ARGS(sc_exit(ret,) dfd, filename, mode, dev), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(umode_t, mode, mode)) sc_in(ctf_integer(unsigned, dev, dev))) +) +#endif +#ifndef OVERRIDE_64_newfstatat +SC_LTTNG_TRACEPOINT_EVENT(newfstatat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, struct stat * statbuf, int flag), + TP_ARGS(sc_exit(ret,) dfd, filename, statbuf, flag), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_out(ctf_integer(struct stat *, statbuf, statbuf)) sc_in(ctf_integer(int, flag, flag))) +) +#endif +#ifndef OVERRIDE_64_renameat +SC_LTTNG_TRACEPOINT_EVENT(renameat, + TP_PROTO(sc_exit(long ret,) int olddfd, const char * oldname, int newdfd, const char * newname), + TP_ARGS(sc_exit(ret,) olddfd, oldname, newdfd, newname), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, olddfd, olddfd)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_integer(int, newdfd, newdfd)) sc_in(ctf_user_string(newname, newname))) +) +#endif +#ifndef OVERRIDE_64_readlinkat +SC_LTTNG_TRACEPOINT_EVENT(readlinkat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * pathname, char * buf, int bufsiz), + TP_ARGS(sc_exit(ret,) dfd, pathname, buf, bufsiz), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(int, bufsiz, bufsiz))) +) +#endif +#ifndef OVERRIDE_64_vmsplice +SC_LTTNG_TRACEPOINT_EVENT(vmsplice, + TP_PROTO(sc_exit(long ret,) int fd, const struct iovec * iov, unsigned long nr_segs, unsigned int flags), + TP_ARGS(sc_exit(ret,) fd, iov, nr_segs, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(const struct iovec *, iov, iov)) sc_in(ctf_integer(unsigned long, nr_segs, nr_segs)) sc_in(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_utimensat +SC_LTTNG_TRACEPOINT_EVENT(utimensat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, struct timespec * utimes, int flags), + TP_ARGS(sc_exit(ret,) dfd, filename, utimes, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(struct timespec *, utimes, utimes)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_timerfd_settime +SC_LTTNG_TRACEPOINT_EVENT(timerfd_settime, + TP_PROTO(sc_exit(long ret,) int ufd, int flags, const struct itimerspec * utmr, struct itimerspec * otmr), + TP_ARGS(sc_exit(ret,) ufd, flags, utmr, otmr), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(const struct itimerspec *, utmr, utmr)) sc_out(ctf_integer(struct itimerspec *, otmr, otmr))) +) +#endif +#ifndef OVERRIDE_64_accept4 +SC_LTTNG_TRACEPOINT_EVENT(accept4, + TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * upeer_sockaddr, int * upeer_addrlen, int flags), + TP_ARGS(sc_exit(ret,) fd, upeer_sockaddr, upeer_addrlen, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct sockaddr *, upeer_sockaddr, upeer_sockaddr)) sc_inout(ctf_integer(int *, upeer_addrlen, upeer_addrlen)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_signalfd4 +SC_LTTNG_TRACEPOINT_EVENT(signalfd4, + TP_PROTO(sc_exit(long ret,) int ufd, sigset_t * user_mask, size_t sizemask, int flags), + TP_ARGS(sc_exit(ret,) ufd, user_mask, sizemask, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_in(ctf_integer(sigset_t *, user_mask, user_mask)) sc_in(ctf_integer(size_t, sizemask, sizemask)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_rt_tgsigqueueinfo +SC_LTTNG_TRACEPOINT_EVENT(rt_tgsigqueueinfo, + TP_PROTO(sc_exit(long ret,) pid_t tgid, pid_t pid, int sig, siginfo_t * uinfo), + TP_ARGS(sc_exit(ret,) tgid, pid, sig, uinfo), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, tgid, tgid)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig)) sc_in(ctf_integer(siginfo_t *, uinfo, uinfo))) +) +#endif +#ifndef OVERRIDE_64_prlimit64 +SC_LTTNG_TRACEPOINT_EVENT(prlimit64, + TP_PROTO(sc_exit(long ret,) pid_t pid, unsigned int resource, const struct rlimit64 * new_rlim, struct rlimit64 * old_rlim), + TP_ARGS(sc_exit(ret,) pid, resource, new_rlim, old_rlim), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(unsigned int, resource, resource)) sc_in(ctf_integer(const struct rlimit64 *, new_rlim, new_rlim)) sc_out(ctf_integer(struct rlimit64 *, old_rlim, old_rlim))) +) +#endif +#ifndef OVERRIDE_64_sendmmsg +SC_LTTNG_TRACEPOINT_EVENT(sendmmsg, + TP_PROTO(sc_exit(long ret,) int fd, struct mmsghdr * mmsg, unsigned int vlen, unsigned int flags), + TP_ARGS(sc_exit(ret,) fd, mmsg, vlen, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct mmsghdr *, mmsg, mmsg)) sc_in(ctf_integer(unsigned int, vlen, vlen)) sc_in(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_select +SC_LTTNG_TRACEPOINT_EVENT(select, + TP_PROTO(sc_exit(long ret,) int n, fd_set * inp, fd_set * outp, fd_set * exp, struct timeval * tvp), + TP_ARGS(sc_exit(ret,) n, inp, outp, exp, tvp), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, n, n)) sc_inout(ctf_integer(fd_set *, inp, inp)) sc_inout(ctf_integer(fd_set *, outp, outp)) sc_inout(ctf_integer(fd_set *, exp, exp)) sc_inout(ctf_integer(struct timeval *, tvp, tvp))) +) +#endif +#ifndef OVERRIDE_64_setsockopt +SC_LTTNG_TRACEPOINT_EVENT(setsockopt, + TP_PROTO(sc_exit(long ret,) int fd, int level, int optname, char * optval, int optlen), + TP_ARGS(sc_exit(ret,) fd, level, optname, optval, optlen), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, level, level)) sc_in(ctf_integer(int, optname, optname)) sc_in(ctf_integer(char *, optval, optval)) sc_in(ctf_integer(int, optlen, optlen))) +) +#endif +#ifndef OVERRIDE_64_getsockopt +SC_LTTNG_TRACEPOINT_EVENT(getsockopt, + TP_PROTO(sc_exit(long ret,) int fd, int level, int optname, char * optval, int * optlen), + TP_ARGS(sc_exit(ret,) fd, level, optname, optval, optlen), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, level, level)) sc_in(ctf_integer(int, optname, optname)) sc_out(ctf_integer(char *, optval, optval)) sc_inout(ctf_integer(int *, optlen, optlen))) +) +#endif +#ifndef OVERRIDE_64_msgrcv +SC_LTTNG_TRACEPOINT_EVENT(msgrcv, + TP_PROTO(sc_exit(long ret,) int msqid, struct msgbuf * msgp, size_t msgsz, long msgtyp, int msgflg), + TP_ARGS(sc_exit(ret,) msqid, msgp, msgsz, msgtyp, msgflg), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, msqid, msqid)) sc_out(ctf_integer(struct msgbuf *, msgp, msgp)) sc_in(ctf_integer(size_t, msgsz, msgsz)) sc_in(ctf_integer(long, msgtyp, msgtyp)) sc_in(ctf_integer(int, msgflg, msgflg))) +) +#endif +#ifndef OVERRIDE_64_mount +SC_LTTNG_TRACEPOINT_EVENT(mount, + TP_PROTO(sc_exit(long ret,) char * dev_name, char * dir_name, char * type, unsigned long flags, void * data), + TP_ARGS(sc_exit(ret,) dev_name, dir_name, type, flags, data), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(dev_name, dev_name)) sc_in(ctf_user_string(dir_name, dir_name)) sc_in(ctf_user_string(type, type)) sc_in(ctf_integer(unsigned long, flags, flags)) sc_in(ctf_integer(void *, data, data))) +) +#endif +#ifndef OVERRIDE_64_setxattr +SC_LTTNG_TRACEPOINT_EVENT(setxattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, const void * value, size_t size, int flags), + TP_ARGS(sc_exit(ret,) pathname, name, value, size, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(const void *, value, value)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_lsetxattr +SC_LTTNG_TRACEPOINT_EVENT(lsetxattr, + TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, const void * value, size_t size, int flags), + TP_ARGS(sc_exit(ret,) pathname, name, value, size, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(const void *, value, value)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_fsetxattr +SC_LTTNG_TRACEPOINT_EVENT(fsetxattr, + TP_PROTO(sc_exit(long ret,) int fd, const char * name, const void * value, size_t size, int flags), + TP_ARGS(sc_exit(ret,) fd, name, value, size, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(const void *, value, value)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_io_getevents +SC_LTTNG_TRACEPOINT_EVENT(io_getevents, + TP_PROTO(sc_exit(long ret,) aio_context_t ctx_id, long min_nr, long nr, struct io_event * events, struct timespec * timeout), + TP_ARGS(sc_exit(ret,) ctx_id, min_nr, nr, events, timeout), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx_id, ctx_id)) sc_in(ctf_integer(long, min_nr, min_nr)) sc_in(ctf_integer(long, nr, nr)) sc_out(ctf_integer(struct io_event *, events, events)) sc_inout(ctf_integer(struct timespec *, timeout, timeout))) +) +#endif +#ifndef OVERRIDE_64_get_mempolicy +SC_LTTNG_TRACEPOINT_EVENT(get_mempolicy, + TP_PROTO(sc_exit(long ret,) int * policy, unsigned long * nmask, unsigned long maxnode, unsigned long addr, unsigned long flags), + TP_ARGS(sc_exit(ret,) policy, nmask, maxnode, addr, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(int *, policy, policy)) sc_out(ctf_integer(unsigned long *, nmask, nmask)) sc_in(ctf_integer(unsigned long, maxnode, maxnode)) sc_in(ctf_integer(unsigned long, addr, addr)) sc_in(ctf_integer(unsigned long, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_mq_timedsend +SC_LTTNG_TRACEPOINT_EVENT(mq_timedsend, + TP_PROTO(sc_exit(long ret,) mqd_t mqdes, const char * u_msg_ptr, size_t msg_len, unsigned int msg_prio, const struct timespec * u_abs_timeout), + TP_ARGS(sc_exit(ret,) mqdes, u_msg_ptr, msg_len, msg_prio, u_abs_timeout), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(mqd_t, mqdes, mqdes)) sc_in(ctf_integer(const char *, u_msg_ptr, u_msg_ptr)) sc_in(ctf_integer(size_t, msg_len, msg_len)) sc_in(ctf_integer(unsigned int, msg_prio, msg_prio)) sc_in(ctf_integer(const struct timespec *, u_abs_timeout, u_abs_timeout))) +) +#endif +#ifndef OVERRIDE_64_mq_timedreceive +SC_LTTNG_TRACEPOINT_EVENT(mq_timedreceive, + TP_PROTO(sc_exit(long ret,) mqd_t mqdes, char * u_msg_ptr, size_t msg_len, unsigned int * u_msg_prio, const struct timespec * u_abs_timeout), + TP_ARGS(sc_exit(ret,) mqdes, u_msg_ptr, msg_len, u_msg_prio, u_abs_timeout), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(mqd_t, mqdes, mqdes)) sc_out(ctf_integer(char *, u_msg_ptr, u_msg_ptr)) sc_in(ctf_integer(size_t, msg_len, msg_len)) sc_out(ctf_integer(unsigned int *, u_msg_prio, u_msg_prio)) sc_in(ctf_integer(const struct timespec *, u_abs_timeout, u_abs_timeout))) +) +#endif +#ifndef OVERRIDE_64_waitid +SC_LTTNG_TRACEPOINT_EVENT(waitid, + TP_PROTO(sc_exit(long ret,) int which, pid_t upid, struct siginfo * infop, int options, struct rusage * ru), + TP_ARGS(sc_exit(ret,) which, upid, infop, options, ru), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(pid_t, upid, upid)) sc_out(ctf_integer(struct siginfo *, infop, infop)) sc_in(ctf_integer(int, options, options)) sc_out(ctf_integer(struct rusage *, ru, ru))) +) +#endif +#ifndef OVERRIDE_64_add_key +SC_LTTNG_TRACEPOINT_EVENT(add_key, + TP_PROTO(sc_exit(long ret,) const char * _type, const char * _description, const void * _payload, size_t plen, key_serial_t ringid), + TP_ARGS(sc_exit(ret,) _type, _description, _payload, plen, ringid), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(_type, _type)) sc_in(ctf_integer(const char *, _description, _description)) sc_in(ctf_integer(const void *, _payload, _payload)) sc_in(ctf_integer(size_t, plen, plen)) sc_in(ctf_integer(key_serial_t, ringid, ringid))) +) +#endif +#ifndef OVERRIDE_64_fchownat +SC_LTTNG_TRACEPOINT_EVENT(fchownat, + TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, uid_t user, gid_t group, int flag), + TP_ARGS(sc_exit(ret,) dfd, filename, user, group, flag), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group)) sc_in(ctf_integer(int, flag, flag))) +) +#endif +#ifndef OVERRIDE_64_linkat +SC_LTTNG_TRACEPOINT_EVENT(linkat, + TP_PROTO(sc_exit(long ret,) int olddfd, const char * oldname, int newdfd, const char * newname, int flags), + TP_ARGS(sc_exit(ret,) olddfd, oldname, newdfd, newname, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, olddfd, olddfd)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_integer(int, newdfd, newdfd)) sc_in(ctf_user_string(newname, newname)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_ppoll +SC_LTTNG_TRACEPOINT_EVENT(ppoll, + TP_PROTO(sc_exit(long ret,) struct pollfd * ufds, unsigned int nfds, struct timespec * tsp, const sigset_t * sigmask, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) ufds, nfds, tsp, sigmask, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct pollfd *, ufds, ufds)) sc_in(ctf_integer(unsigned int, nfds, nfds)) sc_in(ctf_integer(struct timespec *, tsp, tsp)) sc_in(ctf_integer(const sigset_t *, sigmask, sigmask)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) +) +#endif +#ifndef OVERRIDE_64_preadv +SC_LTTNG_TRACEPOINT_EVENT(preadv, + TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen, unsigned long pos_l, unsigned long pos_h), + TP_ARGS(sc_exit(ret,) fd, vec, vlen, pos_l, pos_h), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_out(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen)) sc_in(ctf_integer(unsigned long, pos_l, pos_l)) sc_in(ctf_integer(unsigned long, pos_h, pos_h))) +) +#endif +#ifndef OVERRIDE_64_pwritev +SC_LTTNG_TRACEPOINT_EVENT(pwritev, + TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen, unsigned long pos_l, unsigned long pos_h), + TP_ARGS(sc_exit(ret,) fd, vec, vlen, pos_l, pos_h), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_in(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen)) sc_in(ctf_integer(unsigned long, pos_l, pos_l)) sc_in(ctf_integer(unsigned long, pos_h, pos_h))) +) +#endif +#ifndef OVERRIDE_64_perf_event_open +SC_LTTNG_TRACEPOINT_EVENT(perf_event_open, + TP_PROTO(sc_exit(long ret,) struct perf_event_attr * attr_uptr, pid_t pid, int cpu, int group_fd, unsigned long flags), + TP_ARGS(sc_exit(ret,) attr_uptr, pid, cpu, group_fd, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct perf_event_attr *, attr_uptr, attr_uptr)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, cpu, cpu)) sc_in(ctf_integer(int, group_fd, group_fd)) sc_in(ctf_integer(unsigned long, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_recvmmsg +SC_LTTNG_TRACEPOINT_EVENT(recvmmsg, + TP_PROTO(sc_exit(long ret,) int fd, struct mmsghdr * mmsg, unsigned int vlen, unsigned int flags, struct timespec * timeout), + TP_ARGS(sc_exit(ret,) fd, mmsg, vlen, flags, timeout), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct mmsghdr *, mmsg, mmsg)) sc_in(ctf_integer(unsigned int, vlen, vlen)) sc_in(ctf_integer(unsigned int, flags, flags)) sc_inout(ctf_integer(struct timespec *, timeout, timeout))) +) +#endif +#ifndef OVERRIDE_64_fanotify_mark +SC_LTTNG_TRACEPOINT_EVENT(fanotify_mark, + TP_PROTO(sc_exit(long ret,) int fanotify_fd, unsigned int flags, __u64 mask, int dfd, const char * pathname), + TP_ARGS(sc_exit(ret,) fanotify_fd, flags, mask, dfd, pathname), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fanotify_fd, fanotify_fd)) sc_in(ctf_integer(unsigned int, flags, flags)) sc_in(ctf_integer(__u64, mask, mask)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(pathname, pathname))) +) +#endif +#ifndef OVERRIDE_64_name_to_handle_at +SC_LTTNG_TRACEPOINT_EVENT(name_to_handle_at, + TP_PROTO(sc_exit(long ret,) int dfd, const char * name, struct file_handle * handle, int * mnt_id, int flag), + TP_ARGS(sc_exit(ret,) dfd, name, handle, mnt_id, flag), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(name, name)) sc_inout(ctf_integer(struct file_handle *, handle, handle)) sc_out(ctf_integer(int *, mnt_id, mnt_id)) sc_in(ctf_integer(int, flag, flag))) +) +#endif +#ifndef OVERRIDE_64_sendto +SC_LTTNG_TRACEPOINT_EVENT(sendto, + TP_PROTO(sc_exit(long ret,) int fd, void * buff, size_t len, unsigned int flags, struct sockaddr * addr, int addr_len), + TP_ARGS(sc_exit(ret,) fd, buff, len, flags, addr, addr_len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(void *, buff, buff)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned int, flags, flags)) sc_in(ctf_integer(struct sockaddr *, addr, addr)) sc_in(ctf_integer(int, addr_len, addr_len))) +) +#endif +#ifndef OVERRIDE_64_recvfrom +SC_LTTNG_TRACEPOINT_EVENT(recvfrom, + TP_PROTO(sc_exit(long ret,) int fd, void * ubuf, size_t size, unsigned int flags, struct sockaddr * addr, int * addr_len), + TP_ARGS(sc_exit(ret,) fd, ubuf, size, flags, addr, addr_len), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(void *, ubuf, ubuf)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(unsigned int, flags, flags)) sc_out(ctf_integer(struct sockaddr *, addr, addr)) sc_inout(ctf_integer(int *, addr_len, addr_len))) +) +#endif +#ifndef OVERRIDE_64_futex +SC_LTTNG_TRACEPOINT_EVENT(futex, + TP_PROTO(sc_exit(long ret,) u32 * uaddr, int op, u32 val, struct timespec * utime, u32 * uaddr2, u32 val3), + TP_ARGS(sc_exit(ret,) uaddr, op, val, utime, uaddr2, val3), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(u32 *, uaddr, uaddr)) sc_in(ctf_integer(int, op, op)) sc_in(ctf_integer(u32, val, val)) sc_in(ctf_integer(struct timespec *, utime, utime)) sc_inout(ctf_integer(u32 *, uaddr2, uaddr2)) sc_in(ctf_integer(u32, val3, val3))) +) +#endif +#ifndef OVERRIDE_64_mbind +SC_LTTNG_TRACEPOINT_EVENT(mbind, + TP_PROTO(sc_exit(long ret,) unsigned long start, unsigned long len, unsigned long mode, unsigned long * nmask, unsigned long maxnode, unsigned flags), + TP_ARGS(sc_exit(ret,) start, len, mode, nmask, maxnode, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(unsigned long, len, len)) sc_in(ctf_integer(unsigned long, mode, mode)) sc_in(ctf_integer(unsigned long *, nmask, nmask)) sc_in(ctf_integer(unsigned long, maxnode, maxnode)) sc_in(ctf_integer(unsigned, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_pselect6 +SC_LTTNG_TRACEPOINT_EVENT(pselect6, + TP_PROTO(sc_exit(long ret,) int n, fd_set * inp, fd_set * outp, fd_set * exp, struct timespec * tsp, void * sig), + TP_ARGS(sc_exit(ret,) n, inp, outp, exp, tsp, sig), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, n, n)) sc_inout(ctf_integer(fd_set *, inp, inp)) sc_inout(ctf_integer(fd_set *, outp, outp)) sc_inout(ctf_integer(fd_set *, exp, exp)) sc_inout(ctf_integer(struct timespec *, tsp, tsp)) sc_in(ctf_integer(void *, sig, sig))) +) +#endif +#ifndef OVERRIDE_64_splice +SC_LTTNG_TRACEPOINT_EVENT(splice, + TP_PROTO(sc_exit(long ret,) int fd_in, loff_t * off_in, int fd_out, loff_t * off_out, size_t len, unsigned int flags), + TP_ARGS(sc_exit(ret,) fd_in, off_in, fd_out, off_out, len, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd_in, fd_in)) sc_in(ctf_integer(loff_t *, off_in, off_in)) sc_in(ctf_integer(int, fd_out, fd_out)) sc_in(ctf_integer(loff_t *, off_out, off_out)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_move_pages +SC_LTTNG_TRACEPOINT_EVENT(move_pages, + TP_PROTO(sc_exit(long ret,) pid_t pid, unsigned long nr_pages, const void * * pages, const int * nodes, int * status, int flags), + TP_ARGS(sc_exit(ret,) pid, nr_pages, pages, nodes, status, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(unsigned long, nr_pages, nr_pages)) sc_in(ctf_integer(const void * *, pages, pages)) sc_in(ctf_integer(const int *, nodes, nodes)) sc_out(ctf_integer(int *, status, status)) sc_in(ctf_integer(int, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_epoll_pwait +SC_LTTNG_TRACEPOINT_EVENT(epoll_pwait, + TP_PROTO(sc_exit(long ret,) int epfd, struct epoll_event * events, int maxevents, int timeout, const sigset_t * sigmask, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) epfd, events, maxevents, timeout, sigmask, sigsetsize), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, epfd, epfd)) sc_out(ctf_integer(struct epoll_event *, events, events)) sc_in(ctf_integer(int, maxevents, maxevents)) sc_in(ctf_integer(int, timeout, timeout)) sc_in(ctf_integer(const sigset_t *, sigmask, sigmask)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) +) +#endif +#ifndef OVERRIDE_64_process_vm_readv +SC_LTTNG_TRACEPOINT_EVENT(process_vm_readv, + TP_PROTO(sc_exit(long ret,) pid_t pid, const struct iovec * lvec, unsigned long liovcnt, const struct iovec * rvec, unsigned long riovcnt, unsigned long flags), + TP_ARGS(sc_exit(ret,) pid, lvec, liovcnt, rvec, riovcnt, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_out(ctf_integer(const struct iovec *, lvec, lvec)) sc_in(ctf_integer(unsigned long, liovcnt, liovcnt)) sc_in(ctf_integer(const struct iovec *, rvec, rvec)) sc_in(ctf_integer(unsigned long, riovcnt, riovcnt)) sc_in(ctf_integer(unsigned long, flags, flags))) +) +#endif +#ifndef OVERRIDE_64_process_vm_writev +SC_LTTNG_TRACEPOINT_EVENT(process_vm_writev, + TP_PROTO(sc_exit(long ret,) pid_t pid, const struct iovec * lvec, unsigned long liovcnt, const struct iovec * rvec, unsigned long riovcnt, unsigned long flags), + TP_ARGS(sc_exit(ret,) pid, lvec, liovcnt, rvec, riovcnt, flags), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(const struct iovec *, lvec, lvec)) sc_in(ctf_integer(unsigned long, liovcnt, liovcnt)) sc_in(ctf_integer(const struct iovec *, rvec, rvec)) sc_in(ctf_integer(unsigned long, riovcnt, riovcnt)) sc_in(ctf_integer(unsigned long, flags, flags))) +) +#endif + +#endif /* _TRACE_SYSCALLS_POINTERS_H */ + +/* This part must be outside protection */ +#include + +#else /* CREATE_SYSCALL_TABLE */ + +#include "x86-64-syscalls_pointers_override.h" +#include "syscalls_pointers_override.h" + +#ifndef OVERRIDE_TABLE_64_read +TRACE_SYSCALL_TABLE(read, read, 0, 3) +#endif +#ifndef OVERRIDE_TABLE_64_write +TRACE_SYSCALL_TABLE(write, write, 1, 3) +#endif +#ifndef OVERRIDE_TABLE_64_open +TRACE_SYSCALL_TABLE(open, open, 2, 3) +#endif +#ifndef OVERRIDE_TABLE_64_newstat +TRACE_SYSCALL_TABLE(newstat, newstat, 4, 2) +#endif +#ifndef OVERRIDE_TABLE_64_newfstat +TRACE_SYSCALL_TABLE(newfstat, newfstat, 5, 2) +#endif +#ifndef OVERRIDE_TABLE_64_newlstat +TRACE_SYSCALL_TABLE(newlstat, newlstat, 6, 2) +#endif +#ifndef OVERRIDE_TABLE_64_poll +TRACE_SYSCALL_TABLE(poll, poll, 7, 3) +#endif +#ifndef OVERRIDE_TABLE_64_rt_sigaction +TRACE_SYSCALL_TABLE(rt_sigaction, rt_sigaction, 13, 4) +#endif +#ifndef OVERRIDE_TABLE_64_rt_sigprocmask +TRACE_SYSCALL_TABLE(rt_sigprocmask, rt_sigprocmask, 14, 4) +#endif +#ifndef OVERRIDE_TABLE_64_pread64 +TRACE_SYSCALL_TABLE(pread64, pread64, 17, 4) +#endif +#ifndef OVERRIDE_TABLE_64_pwrite64 +TRACE_SYSCALL_TABLE(pwrite64, pwrite64, 18, 4) +#endif +#ifndef OVERRIDE_TABLE_64_readv +TRACE_SYSCALL_TABLE(readv, readv, 19, 3) +#endif +#ifndef OVERRIDE_TABLE_64_writev +TRACE_SYSCALL_TABLE(writev, writev, 20, 3) +#endif +#ifndef OVERRIDE_TABLE_64_access +TRACE_SYSCALL_TABLE(access, access, 21, 2) +#endif +#ifndef OVERRIDE_TABLE_64_pipe +TRACE_SYSCALL_TABLE(pipe, pipe, 22, 1) +#endif +#ifndef OVERRIDE_TABLE_64_select +TRACE_SYSCALL_TABLE(select, select, 23, 5) +#endif +#ifndef OVERRIDE_TABLE_64_mincore +TRACE_SYSCALL_TABLE(mincore, mincore, 27, 3) +#endif +#ifndef OVERRIDE_TABLE_64_shmat +TRACE_SYSCALL_TABLE(shmat, shmat, 30, 3) +#endif +#ifndef OVERRIDE_TABLE_64_shmctl +TRACE_SYSCALL_TABLE(shmctl, shmctl, 31, 3) +#endif +#ifndef OVERRIDE_TABLE_64_nanosleep +TRACE_SYSCALL_TABLE(nanosleep, nanosleep, 35, 2) +#endif +#ifndef OVERRIDE_TABLE_64_getitimer +TRACE_SYSCALL_TABLE(getitimer, getitimer, 36, 2) +#endif +#ifndef OVERRIDE_TABLE_64_setitimer +TRACE_SYSCALL_TABLE(setitimer, setitimer, 38, 3) +#endif +#ifndef OVERRIDE_TABLE_64_sendfile64 +TRACE_SYSCALL_TABLE(sendfile64, sendfile64, 40, 4) +#endif +#ifndef OVERRIDE_TABLE_64_connect +TRACE_SYSCALL_TABLE(connect, connect, 42, 3) +#endif +#ifndef OVERRIDE_TABLE_64_accept +TRACE_SYSCALL_TABLE(accept, accept, 43, 3) +#endif +#ifndef OVERRIDE_TABLE_64_sendto +TRACE_SYSCALL_TABLE(sendto, sendto, 44, 6) +#endif +#ifndef OVERRIDE_TABLE_64_recvfrom +TRACE_SYSCALL_TABLE(recvfrom, recvfrom, 45, 6) +#endif +#ifndef OVERRIDE_TABLE_64_sendmsg +TRACE_SYSCALL_TABLE(sendmsg, sendmsg, 46, 3) +#endif +#ifndef OVERRIDE_TABLE_64_recvmsg +TRACE_SYSCALL_TABLE(recvmsg, recvmsg, 47, 3) +#endif +#ifndef OVERRIDE_TABLE_64_bind +TRACE_SYSCALL_TABLE(bind, bind, 49, 3) +#endif +#ifndef OVERRIDE_TABLE_64_getsockname +TRACE_SYSCALL_TABLE(getsockname, getsockname, 51, 3) +#endif +#ifndef OVERRIDE_TABLE_64_getpeername +TRACE_SYSCALL_TABLE(getpeername, getpeername, 52, 3) +#endif +#ifndef OVERRIDE_TABLE_64_socketpair +TRACE_SYSCALL_TABLE(socketpair, socketpair, 53, 4) +#endif +#ifndef OVERRIDE_TABLE_64_setsockopt +TRACE_SYSCALL_TABLE(setsockopt, setsockopt, 54, 5) +#endif +#ifndef OVERRIDE_TABLE_64_getsockopt +TRACE_SYSCALL_TABLE(getsockopt, getsockopt, 55, 5) +#endif +#ifndef OVERRIDE_TABLE_64_wait4 +TRACE_SYSCALL_TABLE(wait4, wait4, 61, 4) +#endif +#ifndef OVERRIDE_TABLE_64_newuname +TRACE_SYSCALL_TABLE(newuname, newuname, 63, 1) +#endif +#ifndef OVERRIDE_TABLE_64_semop +TRACE_SYSCALL_TABLE(semop, semop, 65, 3) +#endif +#ifndef OVERRIDE_TABLE_64_shmdt +TRACE_SYSCALL_TABLE(shmdt, shmdt, 67, 1) +#endif +#ifndef OVERRIDE_TABLE_64_msgsnd +TRACE_SYSCALL_TABLE(msgsnd, msgsnd, 69, 4) +#endif +#ifndef OVERRIDE_TABLE_64_msgrcv +TRACE_SYSCALL_TABLE(msgrcv, msgrcv, 70, 5) +#endif +#ifndef OVERRIDE_TABLE_64_msgctl +TRACE_SYSCALL_TABLE(msgctl, msgctl, 71, 3) +#endif +#ifndef OVERRIDE_TABLE_64_truncate +TRACE_SYSCALL_TABLE(truncate, truncate, 76, 2) +#endif +#ifndef OVERRIDE_TABLE_64_getdents +TRACE_SYSCALL_TABLE(getdents, getdents, 78, 3) +#endif +#ifndef OVERRIDE_TABLE_64_getcwd +TRACE_SYSCALL_TABLE(getcwd, getcwd, 79, 2) +#endif +#ifndef OVERRIDE_TABLE_64_chdir +TRACE_SYSCALL_TABLE(chdir, chdir, 80, 1) +#endif +#ifndef OVERRIDE_TABLE_64_rename +TRACE_SYSCALL_TABLE(rename, rename, 82, 2) +#endif +#ifndef OVERRIDE_TABLE_64_mkdir +TRACE_SYSCALL_TABLE(mkdir, mkdir, 83, 2) +#endif +#ifndef OVERRIDE_TABLE_64_rmdir +TRACE_SYSCALL_TABLE(rmdir, rmdir, 84, 1) +#endif +#ifndef OVERRIDE_TABLE_64_creat +TRACE_SYSCALL_TABLE(creat, creat, 85, 2) +#endif +#ifndef OVERRIDE_TABLE_64_link +TRACE_SYSCALL_TABLE(link, link, 86, 2) +#endif +#ifndef OVERRIDE_TABLE_64_unlink +TRACE_SYSCALL_TABLE(unlink, unlink, 87, 1) +#endif +#ifndef OVERRIDE_TABLE_64_symlink +TRACE_SYSCALL_TABLE(symlink, symlink, 88, 2) +#endif +#ifndef OVERRIDE_TABLE_64_readlink +TRACE_SYSCALL_TABLE(readlink, readlink, 89, 3) +#endif +#ifndef OVERRIDE_TABLE_64_chmod +TRACE_SYSCALL_TABLE(chmod, chmod, 90, 2) +#endif +#ifndef OVERRIDE_TABLE_64_chown +TRACE_SYSCALL_TABLE(chown, chown, 92, 3) +#endif +#ifndef OVERRIDE_TABLE_64_lchown +TRACE_SYSCALL_TABLE(lchown, lchown, 94, 3) +#endif +#ifndef OVERRIDE_TABLE_64_gettimeofday +TRACE_SYSCALL_TABLE(gettimeofday, gettimeofday, 96, 2) +#endif +#ifndef OVERRIDE_TABLE_64_getrlimit +TRACE_SYSCALL_TABLE(getrlimit, getrlimit, 97, 2) +#endif +#ifndef OVERRIDE_TABLE_64_getrusage +TRACE_SYSCALL_TABLE(getrusage, getrusage, 98, 2) +#endif +#ifndef OVERRIDE_TABLE_64_sysinfo +TRACE_SYSCALL_TABLE(sysinfo, sysinfo, 99, 1) +#endif +#ifndef OVERRIDE_TABLE_64_times +TRACE_SYSCALL_TABLE(times, times, 100, 1) +#endif +#ifndef OVERRIDE_TABLE_64_syslog +TRACE_SYSCALL_TABLE(syslog, syslog, 103, 3) +#endif +#ifndef OVERRIDE_TABLE_64_getgroups +TRACE_SYSCALL_TABLE(getgroups, getgroups, 115, 2) +#endif +#ifndef OVERRIDE_TABLE_64_setgroups +TRACE_SYSCALL_TABLE(setgroups, setgroups, 116, 2) +#endif +#ifndef OVERRIDE_TABLE_64_getresuid +TRACE_SYSCALL_TABLE(getresuid, getresuid, 118, 3) +#endif +#ifndef OVERRIDE_TABLE_64_getresgid +TRACE_SYSCALL_TABLE(getresgid, getresgid, 120, 3) +#endif +#ifndef OVERRIDE_TABLE_64_rt_sigpending +TRACE_SYSCALL_TABLE(rt_sigpending, rt_sigpending, 127, 2) +#endif +#ifndef OVERRIDE_TABLE_64_rt_sigtimedwait +TRACE_SYSCALL_TABLE(rt_sigtimedwait, rt_sigtimedwait, 128, 4) +#endif +#ifndef OVERRIDE_TABLE_64_rt_sigqueueinfo +TRACE_SYSCALL_TABLE(rt_sigqueueinfo, rt_sigqueueinfo, 129, 3) +#endif +#ifndef OVERRIDE_TABLE_64_rt_sigsuspend +TRACE_SYSCALL_TABLE(rt_sigsuspend, rt_sigsuspend, 130, 2) +#endif +#ifndef OVERRIDE_TABLE_64_sigaltstack +TRACE_SYSCALL_TABLE(sigaltstack, sigaltstack, 131, 2) +#endif +#ifndef OVERRIDE_TABLE_64_utime +TRACE_SYSCALL_TABLE(utime, utime, 132, 2) +#endif +#ifndef OVERRIDE_TABLE_64_mknod +TRACE_SYSCALL_TABLE(mknod, mknod, 133, 3) +#endif +#ifndef OVERRIDE_TABLE_64_ustat +TRACE_SYSCALL_TABLE(ustat, ustat, 136, 2) +#endif +#ifndef OVERRIDE_TABLE_64_statfs +TRACE_SYSCALL_TABLE(statfs, statfs, 137, 2) +#endif +#ifndef OVERRIDE_TABLE_64_fstatfs +TRACE_SYSCALL_TABLE(fstatfs, fstatfs, 138, 2) +#endif +#ifndef OVERRIDE_TABLE_64_sched_setparam +TRACE_SYSCALL_TABLE(sched_setparam, sched_setparam, 142, 2) +#endif +#ifndef OVERRIDE_TABLE_64_sched_getparam +TRACE_SYSCALL_TABLE(sched_getparam, sched_getparam, 143, 2) +#endif +#ifndef OVERRIDE_TABLE_64_sched_setscheduler +TRACE_SYSCALL_TABLE(sched_setscheduler, sched_setscheduler, 144, 3) +#endif +#ifndef OVERRIDE_TABLE_64_sched_rr_get_interval +TRACE_SYSCALL_TABLE(sched_rr_get_interval, sched_rr_get_interval, 148, 2) +#endif +#ifndef OVERRIDE_TABLE_64_pivot_root +TRACE_SYSCALL_TABLE(pivot_root, pivot_root, 155, 2) +#endif +#ifndef OVERRIDE_TABLE_64_sysctl +TRACE_SYSCALL_TABLE(sysctl, sysctl, 156, 1) +#endif +#ifndef OVERRIDE_TABLE_64_adjtimex +TRACE_SYSCALL_TABLE(adjtimex, adjtimex, 159, 1) +#endif +#ifndef OVERRIDE_TABLE_64_setrlimit +TRACE_SYSCALL_TABLE(setrlimit, setrlimit, 160, 2) +#endif +#ifndef OVERRIDE_TABLE_64_chroot +TRACE_SYSCALL_TABLE(chroot, chroot, 161, 1) +#endif +#ifndef OVERRIDE_TABLE_64_acct +TRACE_SYSCALL_TABLE(acct, acct, 163, 1) +#endif +#ifndef OVERRIDE_TABLE_64_settimeofday +TRACE_SYSCALL_TABLE(settimeofday, settimeofday, 164, 2) +#endif +#ifndef OVERRIDE_TABLE_64_mount +TRACE_SYSCALL_TABLE(mount, mount, 165, 5) +#endif +#ifndef OVERRIDE_TABLE_64_umount +TRACE_SYSCALL_TABLE(umount, umount, 166, 2) +#endif +#ifndef OVERRIDE_TABLE_64_swapon +TRACE_SYSCALL_TABLE(swapon, swapon, 167, 2) +#endif +#ifndef OVERRIDE_TABLE_64_swapoff +TRACE_SYSCALL_TABLE(swapoff, swapoff, 168, 1) +#endif +#ifndef OVERRIDE_TABLE_64_reboot +TRACE_SYSCALL_TABLE(reboot, reboot, 169, 4) +#endif +#ifndef OVERRIDE_TABLE_64_sethostname +TRACE_SYSCALL_TABLE(sethostname, sethostname, 170, 2) +#endif +#ifndef OVERRIDE_TABLE_64_setdomainname +TRACE_SYSCALL_TABLE(setdomainname, setdomainname, 171, 2) +#endif +#ifndef OVERRIDE_TABLE_64_init_module +TRACE_SYSCALL_TABLE(init_module, init_module, 175, 3) +#endif +#ifndef OVERRIDE_TABLE_64_delete_module +TRACE_SYSCALL_TABLE(delete_module, delete_module, 176, 2) +#endif +#ifndef OVERRIDE_TABLE_64_quotactl +TRACE_SYSCALL_TABLE(quotactl, quotactl, 179, 4) +#endif +#ifndef OVERRIDE_TABLE_64_setxattr +TRACE_SYSCALL_TABLE(setxattr, setxattr, 188, 5) +#endif +#ifndef OVERRIDE_TABLE_64_lsetxattr +TRACE_SYSCALL_TABLE(lsetxattr, lsetxattr, 189, 5) +#endif +#ifndef OVERRIDE_TABLE_64_fsetxattr +TRACE_SYSCALL_TABLE(fsetxattr, fsetxattr, 190, 5) +#endif +#ifndef OVERRIDE_TABLE_64_getxattr +TRACE_SYSCALL_TABLE(getxattr, getxattr, 191, 4) +#endif +#ifndef OVERRIDE_TABLE_64_lgetxattr +TRACE_SYSCALL_TABLE(lgetxattr, lgetxattr, 192, 4) +#endif +#ifndef OVERRIDE_TABLE_64_fgetxattr +TRACE_SYSCALL_TABLE(fgetxattr, fgetxattr, 193, 4) +#endif +#ifndef OVERRIDE_TABLE_64_listxattr +TRACE_SYSCALL_TABLE(listxattr, listxattr, 194, 3) +#endif +#ifndef OVERRIDE_TABLE_64_llistxattr +TRACE_SYSCALL_TABLE(llistxattr, llistxattr, 195, 3) +#endif +#ifndef OVERRIDE_TABLE_64_flistxattr +TRACE_SYSCALL_TABLE(flistxattr, flistxattr, 196, 3) +#endif +#ifndef OVERRIDE_TABLE_64_removexattr +TRACE_SYSCALL_TABLE(removexattr, removexattr, 197, 2) +#endif +#ifndef OVERRIDE_TABLE_64_lremovexattr +TRACE_SYSCALL_TABLE(lremovexattr, lremovexattr, 198, 2) +#endif +#ifndef OVERRIDE_TABLE_64_fremovexattr +TRACE_SYSCALL_TABLE(fremovexattr, fremovexattr, 199, 2) +#endif +#ifndef OVERRIDE_TABLE_64_time +TRACE_SYSCALL_TABLE(time, time, 201, 1) +#endif +#ifndef OVERRIDE_TABLE_64_futex +TRACE_SYSCALL_TABLE(futex, futex, 202, 6) +#endif +#ifndef OVERRIDE_TABLE_64_sched_setaffinity +TRACE_SYSCALL_TABLE(sched_setaffinity, sched_setaffinity, 203, 3) +#endif +#ifndef OVERRIDE_TABLE_64_sched_getaffinity +TRACE_SYSCALL_TABLE(sched_getaffinity, sched_getaffinity, 204, 3) +#endif +#ifndef OVERRIDE_TABLE_64_io_setup +TRACE_SYSCALL_TABLE(io_setup, io_setup, 206, 2) +#endif +#ifndef OVERRIDE_TABLE_64_io_getevents +TRACE_SYSCALL_TABLE(io_getevents, io_getevents, 208, 5) +#endif +#ifndef OVERRIDE_TABLE_64_io_submit +TRACE_SYSCALL_TABLE(io_submit, io_submit, 209, 3) +#endif +#ifndef OVERRIDE_TABLE_64_io_cancel +TRACE_SYSCALL_TABLE(io_cancel, io_cancel, 210, 3) +#endif +#ifndef OVERRIDE_TABLE_64_lookup_dcookie +TRACE_SYSCALL_TABLE(lookup_dcookie, lookup_dcookie, 212, 3) +#endif +#ifndef OVERRIDE_TABLE_64_getdents64 +TRACE_SYSCALL_TABLE(getdents64, getdents64, 217, 3) +#endif +#ifndef OVERRIDE_TABLE_64_set_tid_address +TRACE_SYSCALL_TABLE(set_tid_address, set_tid_address, 218, 1) +#endif +#ifndef OVERRIDE_TABLE_64_semtimedop +TRACE_SYSCALL_TABLE(semtimedop, semtimedop, 220, 4) +#endif +#ifndef OVERRIDE_TABLE_64_timer_create +TRACE_SYSCALL_TABLE(timer_create, timer_create, 222, 3) +#endif +#ifndef OVERRIDE_TABLE_64_timer_settime +TRACE_SYSCALL_TABLE(timer_settime, timer_settime, 223, 4) +#endif +#ifndef OVERRIDE_TABLE_64_timer_gettime +TRACE_SYSCALL_TABLE(timer_gettime, timer_gettime, 224, 2) +#endif +#ifndef OVERRIDE_TABLE_64_clock_settime +TRACE_SYSCALL_TABLE(clock_settime, clock_settime, 227, 2) +#endif +#ifndef OVERRIDE_TABLE_64_clock_gettime +TRACE_SYSCALL_TABLE(clock_gettime, clock_gettime, 228, 2) +#endif +#ifndef OVERRIDE_TABLE_64_clock_getres +TRACE_SYSCALL_TABLE(clock_getres, clock_getres, 229, 2) +#endif +#ifndef OVERRIDE_TABLE_64_clock_nanosleep +TRACE_SYSCALL_TABLE(clock_nanosleep, clock_nanosleep, 230, 4) +#endif +#ifndef OVERRIDE_TABLE_64_epoll_wait +TRACE_SYSCALL_TABLE(epoll_wait, epoll_wait, 232, 4) +#endif +#ifndef OVERRIDE_TABLE_64_epoll_ctl +TRACE_SYSCALL_TABLE(epoll_ctl, epoll_ctl, 233, 4) +#endif +#ifndef OVERRIDE_TABLE_64_utimes +TRACE_SYSCALL_TABLE(utimes, utimes, 235, 2) +#endif +#ifndef OVERRIDE_TABLE_64_mbind +TRACE_SYSCALL_TABLE(mbind, mbind, 237, 6) +#endif +#ifndef OVERRIDE_TABLE_64_set_mempolicy +TRACE_SYSCALL_TABLE(set_mempolicy, set_mempolicy, 238, 3) +#endif +#ifndef OVERRIDE_TABLE_64_get_mempolicy +TRACE_SYSCALL_TABLE(get_mempolicy, get_mempolicy, 239, 5) +#endif +#ifndef OVERRIDE_TABLE_64_mq_open +TRACE_SYSCALL_TABLE(mq_open, mq_open, 240, 4) +#endif +#ifndef OVERRIDE_TABLE_64_mq_unlink +TRACE_SYSCALL_TABLE(mq_unlink, mq_unlink, 241, 1) +#endif +#ifndef OVERRIDE_TABLE_64_mq_timedsend +TRACE_SYSCALL_TABLE(mq_timedsend, mq_timedsend, 242, 5) +#endif +#ifndef OVERRIDE_TABLE_64_mq_timedreceive +TRACE_SYSCALL_TABLE(mq_timedreceive, mq_timedreceive, 243, 5) +#endif +#ifndef OVERRIDE_TABLE_64_mq_notify +TRACE_SYSCALL_TABLE(mq_notify, mq_notify, 244, 2) +#endif +#ifndef OVERRIDE_TABLE_64_mq_getsetattr +TRACE_SYSCALL_TABLE(mq_getsetattr, mq_getsetattr, 245, 3) +#endif +#ifndef OVERRIDE_TABLE_64_kexec_load +TRACE_SYSCALL_TABLE(kexec_load, kexec_load, 246, 4) +#endif +#ifndef OVERRIDE_TABLE_64_waitid +TRACE_SYSCALL_TABLE(waitid, waitid, 247, 5) +#endif +#ifndef OVERRIDE_TABLE_64_add_key +TRACE_SYSCALL_TABLE(add_key, add_key, 248, 5) +#endif +#ifndef OVERRIDE_TABLE_64_request_key +TRACE_SYSCALL_TABLE(request_key, request_key, 249, 4) +#endif +#ifndef OVERRIDE_TABLE_64_inotify_add_watch +TRACE_SYSCALL_TABLE(inotify_add_watch, inotify_add_watch, 254, 3) +#endif +#ifndef OVERRIDE_TABLE_64_migrate_pages +TRACE_SYSCALL_TABLE(migrate_pages, migrate_pages, 256, 4) +#endif +#ifndef OVERRIDE_TABLE_64_openat +TRACE_SYSCALL_TABLE(openat, openat, 257, 4) +#endif +#ifndef OVERRIDE_TABLE_64_mkdirat +TRACE_SYSCALL_TABLE(mkdirat, mkdirat, 258, 3) +#endif +#ifndef OVERRIDE_TABLE_64_mknodat +TRACE_SYSCALL_TABLE(mknodat, mknodat, 259, 4) +#endif +#ifndef OVERRIDE_TABLE_64_fchownat +TRACE_SYSCALL_TABLE(fchownat, fchownat, 260, 5) +#endif +#ifndef OVERRIDE_TABLE_64_futimesat +TRACE_SYSCALL_TABLE(futimesat, futimesat, 261, 3) +#endif +#ifndef OVERRIDE_TABLE_64_newfstatat +TRACE_SYSCALL_TABLE(newfstatat, newfstatat, 262, 4) +#endif +#ifndef OVERRIDE_TABLE_64_unlinkat +TRACE_SYSCALL_TABLE(unlinkat, unlinkat, 263, 3) +#endif +#ifndef OVERRIDE_TABLE_64_renameat +TRACE_SYSCALL_TABLE(renameat, renameat, 264, 4) +#endif +#ifndef OVERRIDE_TABLE_64_linkat +TRACE_SYSCALL_TABLE(linkat, linkat, 265, 5) +#endif +#ifndef OVERRIDE_TABLE_64_symlinkat +TRACE_SYSCALL_TABLE(symlinkat, symlinkat, 266, 3) +#endif +#ifndef OVERRIDE_TABLE_64_readlinkat +TRACE_SYSCALL_TABLE(readlinkat, readlinkat, 267, 4) +#endif +#ifndef OVERRIDE_TABLE_64_fchmodat +TRACE_SYSCALL_TABLE(fchmodat, fchmodat, 268, 3) +#endif +#ifndef OVERRIDE_TABLE_64_faccessat +TRACE_SYSCALL_TABLE(faccessat, faccessat, 269, 3) +#endif +#ifndef OVERRIDE_TABLE_64_pselect6 +TRACE_SYSCALL_TABLE(pselect6, pselect6, 270, 6) +#endif +#ifndef OVERRIDE_TABLE_64_ppoll +TRACE_SYSCALL_TABLE(ppoll, ppoll, 271, 5) +#endif +#ifndef OVERRIDE_TABLE_64_set_robust_list +TRACE_SYSCALL_TABLE(set_robust_list, set_robust_list, 273, 2) +#endif +#ifndef OVERRIDE_TABLE_64_get_robust_list +TRACE_SYSCALL_TABLE(get_robust_list, get_robust_list, 274, 3) +#endif +#ifndef OVERRIDE_TABLE_64_splice +TRACE_SYSCALL_TABLE(splice, splice, 275, 6) +#endif +#ifndef OVERRIDE_TABLE_64_vmsplice +TRACE_SYSCALL_TABLE(vmsplice, vmsplice, 278, 4) +#endif +#ifndef OVERRIDE_TABLE_64_move_pages +TRACE_SYSCALL_TABLE(move_pages, move_pages, 279, 6) +#endif +#ifndef OVERRIDE_TABLE_64_utimensat +TRACE_SYSCALL_TABLE(utimensat, utimensat, 280, 4) +#endif +#ifndef OVERRIDE_TABLE_64_epoll_pwait +TRACE_SYSCALL_TABLE(epoll_pwait, epoll_pwait, 281, 6) +#endif +#ifndef OVERRIDE_TABLE_64_signalfd +TRACE_SYSCALL_TABLE(signalfd, signalfd, 282, 3) +#endif +#ifndef OVERRIDE_TABLE_64_timerfd_settime +TRACE_SYSCALL_TABLE(timerfd_settime, timerfd_settime, 286, 4) +#endif +#ifndef OVERRIDE_TABLE_64_timerfd_gettime +TRACE_SYSCALL_TABLE(timerfd_gettime, timerfd_gettime, 287, 2) +#endif +#ifndef OVERRIDE_TABLE_64_accept4 +TRACE_SYSCALL_TABLE(accept4, accept4, 288, 4) +#endif +#ifndef OVERRIDE_TABLE_64_signalfd4 +TRACE_SYSCALL_TABLE(signalfd4, signalfd4, 289, 4) +#endif +#ifndef OVERRIDE_TABLE_64_pipe2 +TRACE_SYSCALL_TABLE(pipe2, pipe2, 293, 2) +#endif +#ifndef OVERRIDE_TABLE_64_preadv +TRACE_SYSCALL_TABLE(preadv, preadv, 295, 5) +#endif +#ifndef OVERRIDE_TABLE_64_pwritev +TRACE_SYSCALL_TABLE(pwritev, pwritev, 296, 5) +#endif +#ifndef OVERRIDE_TABLE_64_rt_tgsigqueueinfo +TRACE_SYSCALL_TABLE(rt_tgsigqueueinfo, rt_tgsigqueueinfo, 297, 4) +#endif +#ifndef OVERRIDE_TABLE_64_perf_event_open +TRACE_SYSCALL_TABLE(perf_event_open, perf_event_open, 298, 5) +#endif +#ifndef OVERRIDE_TABLE_64_recvmmsg +TRACE_SYSCALL_TABLE(recvmmsg, recvmmsg, 299, 5) +#endif +#ifndef OVERRIDE_TABLE_64_fanotify_mark +TRACE_SYSCALL_TABLE(fanotify_mark, fanotify_mark, 301, 5) +#endif +#ifndef OVERRIDE_TABLE_64_prlimit64 +TRACE_SYSCALL_TABLE(prlimit64, prlimit64, 302, 4) +#endif +#ifndef OVERRIDE_TABLE_64_name_to_handle_at +TRACE_SYSCALL_TABLE(name_to_handle_at, name_to_handle_at, 303, 5) +#endif +#ifndef OVERRIDE_TABLE_64_open_by_handle_at +TRACE_SYSCALL_TABLE(open_by_handle_at, open_by_handle_at, 304, 3) +#endif +#ifndef OVERRIDE_TABLE_64_clock_adjtime +TRACE_SYSCALL_TABLE(clock_adjtime, clock_adjtime, 305, 2) +#endif +#ifndef OVERRIDE_TABLE_64_sendmmsg +TRACE_SYSCALL_TABLE(sendmmsg, sendmmsg, 307, 4) +#endif +#ifndef OVERRIDE_TABLE_64_getcpu +TRACE_SYSCALL_TABLE(getcpu, getcpu, 309, 3) +#endif +#ifndef OVERRIDE_TABLE_64_process_vm_readv +TRACE_SYSCALL_TABLE(process_vm_readv, process_vm_readv, 310, 6) +#endif +#ifndef OVERRIDE_TABLE_64_process_vm_writev +TRACE_SYSCALL_TABLE(process_vm_writev, process_vm_writev, 311, 6) +#endif +#ifndef OVERRIDE_TABLE_64_finit_module +TRACE_SYSCALL_TABLE(finit_module, finit_module, 313, 3) +#endif + +#endif /* CREATE_SYSCALL_TABLE */ diff --git a/include/instrumentation/syscalls/headers/x86-64-syscalls_pointers_override.h b/include/instrumentation/syscalls/headers/x86-64-syscalls_pointers_override.h new file mode 100644 index 00000000..bd889451 --- /dev/null +++ b/include/instrumentation/syscalls/headers/x86-64-syscalls_pointers_override.h @@ -0,0 +1,176 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ + +#ifndef CREATE_SYSCALL_TABLE + +#define OVERRIDE_64_connect +SC_LTTNG_TRACEPOINT_EVENT_CODE(connect, + TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr __user * uservaddr, int addrlen), + TP_ARGS(sc_exit(ret,) fd, uservaddr, addrlen), + TP_locvar( + __typeof__(uservaddr->sa_family) sa_family; + uint16_t dport; + uint32_t v4addr; + uint16_t v6addr[8]; + unsigned int v4addr_len, v6addr_len; + ), + TP_code_pre( + sc_in( + memset(tp_locvar, 0, sizeof(*tp_locvar)); + if (addrlen < sizeof(tp_locvar->sa_family)) + goto skip_code; + (void) lib_ring_buffer_copy_from_user_check_nofault(&tp_locvar->sa_family, + &uservaddr->sa_family, sizeof(tp_locvar->sa_family)); + switch (tp_locvar->sa_family) { + case AF_INET: + if (addrlen < sizeof(struct sockaddr_in)) + goto skip_code; + (void) lib_ring_buffer_copy_from_user_check_nofault(&tp_locvar->dport, + &((struct sockaddr_in __user *) uservaddr)->sin_port, + sizeof(tp_locvar->dport)); + (void) lib_ring_buffer_copy_from_user_check_nofault(&tp_locvar->v4addr, + &((struct sockaddr_in __user *) uservaddr)->sin_addr.s_addr, + sizeof(tp_locvar->v4addr)); + tp_locvar->v4addr_len = 4; + break; + case AF_INET6: + if (addrlen < sizeof(struct sockaddr_in6)) + goto skip_code; + (void) lib_ring_buffer_copy_from_user_check_nofault(&tp_locvar->dport, + &((struct sockaddr_in6 __user *) uservaddr)->sin6_port, + sizeof(tp_locvar->dport)); + if (lib_ring_buffer_copy_from_user_check_nofault(tp_locvar->v6addr, + &((struct sockaddr_in6 __user *) uservaddr)->sin6_addr.in6_u.u6_addr8, + sizeof(tp_locvar->v6addr))) + memset(tp_locvar->v6addr, 0, sizeof(tp_locvar->v6addr)); + tp_locvar->v6addr_len = 8; + break; + } + skip_code: + ) + ), + TP_FIELDS( + sc_exit(ctf_integer(long, ret, ret)) + sc_in(ctf_integer(int, fd, fd)) + sc_in(ctf_integer_hex(struct sockaddr *, uservaddr, uservaddr)) + sc_in(ctf_integer_hex(int, addrlen, addrlen)) + sc_in(ctf_integer(unsigned short, family, tp_locvar->sa_family)) + sc_in(ctf_integer_network(uint16_t, dport, tp_locvar->dport)) + sc_in(ctf_sequence_network(uint8_t, v4addr, &tp_locvar->v4addr, unsigned int, tp_locvar->v4addr_len)) + sc_in(ctf_sequence_network(uint16_t, v6addr, &tp_locvar->v6addr, unsigned int, tp_locvar->v6addr_len)) + ), + TP_code_post() +) + +#define LTTNG_SYSCALL_ACCEPT_locvar \ + __typeof__(upeer_sockaddr->sa_family) sa_family;\ + uint16_t sport; \ + uint32_t v4addr; \ + uint16_t v6addr[8]; \ + int v4addr_len, v6addr_len; \ + int uaddr_len; + +#define LTTNG_SYSCALL_ACCEPT_code_pre \ + sc_inout( \ + memset(tp_locvar, 0, sizeof(*tp_locvar)); \ + (void) lib_ring_buffer_copy_from_user_check_nofault(&tp_locvar->uaddr_len, \ + upeer_addrlen, sizeof(tp_locvar->uaddr_len)); \ + ) \ + sc_out( \ + if (tp_locvar->uaddr_len < sizeof(tp_locvar->sa_family)) \ + goto skip_code; \ + (void) lib_ring_buffer_copy_from_user_check_nofault(&tp_locvar->sa_family, \ + &upeer_sockaddr->sa_family, sizeof(tp_locvar->sa_family)); \ + switch (tp_locvar->sa_family) { \ + case AF_INET: \ + if (tp_locvar->uaddr_len < sizeof(struct sockaddr_in)) \ + goto skip_code; \ + (void) lib_ring_buffer_copy_from_user_check_nofault(&tp_locvar->sport, \ + &((struct sockaddr_in __user *) upeer_sockaddr)->sin_port, \ + sizeof(tp_locvar->sport)); \ + (void) lib_ring_buffer_copy_from_user_check_nofault(&tp_locvar->v4addr, \ + &((struct sockaddr_in __user *) upeer_sockaddr)->sin_addr.s_addr, \ + sizeof(tp_locvar->v4addr)); \ + tp_locvar->v4addr_len = 4; \ + break; \ + case AF_INET6: \ + if (tp_locvar->uaddr_len < sizeof(struct sockaddr_in6)) \ + goto skip_code; \ + (void) lib_ring_buffer_copy_from_user_check_nofault(&tp_locvar->sport, \ + &((struct sockaddr_in6 __user *) upeer_sockaddr)->sin6_port, \ + sizeof(tp_locvar->sport)); \ + if (lib_ring_buffer_copy_from_user_check_nofault(tp_locvar->v6addr, \ + &((struct sockaddr_in6 __user *) upeer_sockaddr)->sin6_addr.in6_u.u6_addr8, \ + sizeof(tp_locvar->v6addr))) \ + memset(tp_locvar->v6addr, 0, sizeof(tp_locvar->v6addr)); \ + tp_locvar->v6addr_len = 8; \ + break; \ + } \ + skip_code: \ + ) + +#define OVERRIDE_64_accept +SC_LTTNG_TRACEPOINT_EVENT_CODE(accept, + TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr __user * upeer_sockaddr, int __user * upeer_addrlen), + TP_ARGS(sc_exit(ret,) fd, upeer_sockaddr, upeer_addrlen), + TP_locvar( + LTTNG_SYSCALL_ACCEPT_locvar + ), + TP_code_pre( + LTTNG_SYSCALL_ACCEPT_code_pre + ), + TP_FIELDS( + sc_exit(ctf_integer(long, ret, ret)) + sc_in(ctf_integer(int, fd, fd)) + sc_in(ctf_integer_hex(struct sockaddr *, upeer_sockaddr, upeer_sockaddr)) + sc_inout(ctf_integer(int, upeer_addrlen, tp_locvar->uaddr_len)) + sc_out(ctf_integer(unsigned short, family, tp_locvar->sa_family)) + sc_out(ctf_integer_network(uint16_t, sport, tp_locvar->sport)) + sc_out(ctf_sequence_network(uint8_t, v4addr, &tp_locvar->v4addr, unsigned int, tp_locvar->v4addr_len)) + sc_out(ctf_sequence_network(uint16_t, v6addr, &tp_locvar->v6addr, unsigned int, tp_locvar->v6addr_len)) + ), + TP_code_post() +) + +#define OVERRIDE_64_accept4 +SC_LTTNG_TRACEPOINT_EVENT_CODE(accept4, + TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr __user * upeer_sockaddr, int __user * upeer_addrlen, int flags), + TP_ARGS(sc_exit(ret,) fd, upeer_sockaddr, upeer_addrlen, flags), + TP_locvar( + LTTNG_SYSCALL_ACCEPT_locvar + ), + TP_code_pre( + LTTNG_SYSCALL_ACCEPT_code_pre + ), + TP_FIELDS( + sc_exit(ctf_integer(long, ret, ret)) + sc_in(ctf_integer(int, fd, fd)) + sc_in(ctf_integer_hex(struct sockaddr *, upeer_sockaddr, upeer_sockaddr)) + sc_inout(ctf_integer(int, upeer_addrlen, tp_locvar->uaddr_len)) + sc_in(ctf_integer_hex(int, flags, flags)) + sc_out(ctf_integer(unsigned short, family, tp_locvar->sa_family)) + sc_out(ctf_integer_network(uint16_t, sport, tp_locvar->sport)) + sc_out(ctf_sequence_network(uint8_t, v4addr, &tp_locvar->v4addr, unsigned int, tp_locvar->v4addr_len)) + sc_out(ctf_sequence_network(uint16_t, v6addr, &tp_locvar->v6addr, unsigned int, tp_locvar->v6addr_len)) + ), + TP_code_post() +) + +#define OVERRIDE_64_pipe +SC_LTTNG_TRACEPOINT_EVENT(pipe, + TP_PROTO(sc_exit(long ret,) int * fildes), + TP_ARGS(sc_exit(ret,) fildes), + TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) + sc_out(ctf_user_array(int, fildes, fildes, 2)) + ) +) + +#else /* CREATE_SYSCALL_TABLE */ + +#define OVERRIDE_TABLE_64_clone +TRACE_SYSCALL_TABLE(clone, clone, 56, 5) +#define OVERRIDE_TABLE_64_execve +TRACE_SYSCALL_TABLE(execve, execve, 59, 3) +#define OVERRIDE_TABLE_64_getcpu +TRACE_SYSCALL_TABLE(getcpu, getcpu, 309, 3) + +#endif /* CREATE_SYSCALL_TABLE */ diff --git a/include/instrumentation/syscalls/lttng-get-syscall-inout.sh b/include/instrumentation/syscalls/lttng-get-syscall-inout.sh new file mode 100755 index 00000000..8ddaad8d --- /dev/null +++ b/include/instrumentation/syscalls/lttng-get-syscall-inout.sh @@ -0,0 +1,95 @@ +#!/bin/bash +# SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) + +# example usage: +# lttng-get-syscall-inout.sh table-syscall-inout.txt select 1 + +FILENAME=$1 +SYSCALL_NAME=$2 +ARG_NR=$3 +TMPFILE=$(mktemp) + +# Delete temp file on exit +trap 'rm -f "$TMPFILE"' EXIT + + +if [ x"${FILENAME}" = x"" ]; then + echo "Error: Please specify input file name as first argument" >&2 + exit 1 +fi + +if [ x"${SYSCALL_NAME}" = x"" ]; then + echo "Error: Please specify system call name as second argument" >&2 + exit 1 +fi + +if [[ x"${ARG_NR}" = x"" || ${ARG_NR} == 0 ]]; then + echo "Error: Please specify argument number larger than 0 as third argument" >&2 + exit 1 +fi + +# Abort on error and undefined variable +set -eu + +# Get the required syscall +grep "syscall ${SYSCALL_NAME} " "${FILENAME}" > "${TMPFILE}" || true + +# Error out if we got more than one syscall +NR_MATCH=$(wc -l < "${TMPFILE}") +if [ "${NR_MATCH}" -gt 1 ]; then + echo "Error: more than one system call match" >&2 + exit 1 +fi + +# Default to sc_inout for unknown syscalls +if [ "${NR_MATCH}" -eq 0 ]; then + echo "Warning: no match for syscall '${SYSCALL_NAME}', set to 'inout'" >&2 + # no match, default to inout + echo "sc_inout" + exit 0 +fi + +# Get the number of argument +SC_ARGS=$(sed 's/^syscall \([^ ]*\) nbargs \([^ ]*\) .*/\2/g' "${TMPFILE}") + +if [ "${ARG_NR}" -gt "${SC_ARGS}" ]; then + echo "Error: argument number (${ARG_NR}) is larger than number of syscall arguments (${SC_ARGS})" >&2 + exit 1 +fi + +if [ "${ARG_NR}" == 1 ]; then + SC_ARG_TYPE=$(sed 's/^syscall \([^ ]*\) nbargs \([^ ]*\) rw: (\([^,)]*\).*/\3/g' "${TMPFILE}") +fi + +if [ "${ARG_NR}" == 2 ]; then + SC_ARG_TYPE=$(sed 's/^syscall \([^ ]*\) nbargs \([^ ]*\) rw: ([^,]*, \([^,)]*\).*/\3/g' "${TMPFILE}") +fi + +if [ "${ARG_NR}" == 3 ]; then + SC_ARG_TYPE=$(sed 's/^syscall \([^ ]*\) nbargs \([^ ]*\) rw: ([^,]*, [^,]*, \([^,)]*\).*/\3/g' "${TMPFILE}") +fi + +if [ "${ARG_NR}" == 4 ]; then + SC_ARG_TYPE=$(sed 's/^syscall \([^ ]*\) nbargs \([^ ]*\) rw: ([^,]*, [^,]*, [^,]*, \([^,)]*\).*/\3/g' "${TMPFILE}") +fi + +if [ "${ARG_NR}" == 5 ]; then + SC_ARG_TYPE=$(sed 's/^syscall \([^ ]*\) nbargs \([^ ]*\) rw: ([^,]*, [^,]*, [^,]*, [^,]*, \([^,)]*\).*/\3/g' "${TMPFILE}") +fi + +if [ "${ARG_NR}" == 6 ]; then + SC_ARG_TYPE=$(sed 's/^syscall \([^ ]*\) nbargs \([^ ]*\) rw: ([^,]*, [^,]*, [^,]*, [^,]*, [^,]*, \([^,)]*\).*/\3/g' "${TMPFILE}") +fi + + +if [ "${SC_ARG_TYPE}" = "r" ]; then + echo "sc_in" +fi +if [ "${SC_ARG_TYPE}" = "w" ]; then + echo "sc_out" +fi +if [ "${SC_ARG_TYPE}" = "rw" ]; then + echo "sc_inout" +fi + +# EOF diff --git a/include/instrumentation/syscalls/lttng-syscalls-extract.sh b/include/instrumentation/syscalls/lttng-syscalls-extract.sh new file mode 100755 index 00000000..d68baa96 --- /dev/null +++ b/include/instrumentation/syscalls/lttng-syscalls-extract.sh @@ -0,0 +1,37 @@ +#!/bin/bash +# SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) + +set -eu + +outfile="${1:-}" + +if [ "x$outfile" = "x" ]; then + echo "Specify an output file as first argument, it will be overwritten." + exit 1 +fi + +cd lttng-syscalls-extractor || exit 1 +make +cd - || exit 1 + +# Generate a random string to use as an identifier +ident=$(tr -dc 'a-zA-Z0-9' < /dev/urandom | fold -w 8 | head -n1) + +sudo insmod ./lttng-syscalls-extractor/lttng-syscalls-extractor.ko ident="$ident" || true + +sudo dmesg | sed -n -e 's/\(\[.*\] \)\?'"$ident"'//p' > "$outfile" + +# Make sure we have both the start and end markers +if grep -q -- '---START---' "$outfile"; then + sed -i '/^---START---/d' "$outfile" +else + echo "Error: Start marker missing from dmesg output, your kernel log buffer is probably too small, set CONFIG_LOG_BUF_SHIFT to a bigger value." + exit 1 +fi + +if grep -q -- '---END---' "$outfile"; then + sed -i '/^---END---/d' "$outfile" +else + echo "Error: End marker missing from dmesg output, something went wrong." + exit 1 +fi diff --git a/include/instrumentation/syscalls/lttng-syscalls-extractor/Makefile b/include/instrumentation/syscalls/lttng-syscalls-extractor/Makefile new file mode 100644 index 00000000..b3e9c431 --- /dev/null +++ b/include/instrumentation/syscalls/lttng-syscalls-extractor/Makefile @@ -0,0 +1,31 @@ +# SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) + +ifneq ($(KERNELRELEASE),) + + # This part of the Makefile is used when called by the kernel build system + # and defines the modules to be built. + + obj-m += lttng-syscalls-extractor.o + +else # KERNELRELEASE + +# This part of the Makefile is used when the 'make' command is runned in the +# base directory of the lttng-modules sources. It sets some environment and +# calls the kernel build system to build the actual modules. + +KERNELDIR ?= /lib/modules/$(shell uname -r)/build +PWD := $(shell pwd) +CFLAGS = $(EXTCFLAGS) + +default: modules + +modules: + $(MAKE) -C $(KERNELDIR) M=$(PWD) modules + +clean: + $(MAKE) -C $(KERNELDIR) M=$(PWD) clean + +%.i: %.c + $(MAKE) -C $(KERNELDIR) M=$(PWD) $@ + +endif # KERNELRELEASE diff --git a/include/instrumentation/syscalls/lttng-syscalls-extractor/linux-link-trace-syscalls-as-data.patch b/include/instrumentation/syscalls/lttng-syscalls-extractor/linux-link-trace-syscalls-as-data.patch new file mode 100644 index 00000000..5269071f --- /dev/null +++ b/include/instrumentation/syscalls/lttng-syscalls-extractor/linux-link-trace-syscalls-as-data.patch @@ -0,0 +1,26 @@ +Linux: link syscalls metadata as data (for LTTng syscall extraction) + +* NOT for mainline * + +Signed-off-by: Mathieu Desnoyers + +diff --git a/include/asm-generic/vmlinux.lds.h b/include/asm-generic/vmlinux.lds.h +index e00f41aa8ec4..13f51fa7c3f3 100644 +--- a/include/asm-generic/vmlinux.lds.h ++++ b/include/asm-generic/vmlinux.lds.h +@@ -318,6 +318,7 @@ + __end_once = .; \ + STRUCT_ALIGN(); \ + *(__tracepoints) \ ++ TRACE_SYSCALLS() \ + /* implement dynamic printk debug */ \ + . = ALIGN(8); \ + __start___verbose = .; \ +@@ -650,7 +651,6 @@ + MCOUNT_REC() \ + *(.init.rodata .init.rodata.*) \ + FTRACE_EVENTS() \ +- TRACE_SYSCALLS() \ + KPROBE_BLACKLIST() \ + ERROR_INJECT_WHITELIST() \ + MEM_DISCARD(init.rodata) \ diff --git a/include/instrumentation/syscalls/lttng-syscalls-extractor/lttng-syscalls-extractor.c b/include/instrumentation/syscalls/lttng-syscalls-extractor/lttng-syscalls-extractor.c new file mode 100644 index 00000000..0f683750 --- /dev/null +++ b/include/instrumentation/syscalls/lttng-syscalls-extractor/lttng-syscalls-extractor.c @@ -0,0 +1,98 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) + * + * lttng-syscalls-extractor.c + * + * Dump syscall metadata to console. + * + * Copyright 2011 Mathieu Desnoyers + * Copyright 2011 Julien Desfossez + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifndef CONFIG_FTRACE_SYSCALLS +#error "You need to set CONFIG_FTRACE_SYSCALLS=y" +#endif + +#ifndef CONFIG_KALLSYMS_ALL +#error "You need to set CONFIG_KALLSYMS_ALL=y" +#endif + +/* + * The 'ident' parameter is prepended to each printk line to help + * extract the proper lines from dmesg. + */ +static char *ident = ""; +module_param(ident, charp, 0); + +static struct syscall_metadata **__start_syscalls_metadata; +static struct syscall_metadata **__stop_syscalls_metadata; + +static __init +struct syscall_metadata *find_syscall_meta(unsigned long syscall) +{ + struct syscall_metadata **iter; + + for (iter = __start_syscalls_metadata; + iter < __stop_syscalls_metadata; iter++) { + if ((*iter)->syscall_nr == syscall) + return (*iter); + } + return NULL; +} + +int init_module(void) +{ + struct syscall_metadata *meta; + int i; + + __start_syscalls_metadata = (void *) kallsyms_lookup_name("__start_syscalls_metadata"); + __stop_syscalls_metadata = (void *) kallsyms_lookup_name("__stop_syscalls_metadata"); + + printk("%s---START---\n", ident); + for (i = 0; i < NR_syscalls; i++) { + int j; + + meta = find_syscall_meta(i); + if (!meta) + continue; + printk("%ssyscall %s nr %d nbargs %d ", + ident, meta->name, meta->syscall_nr, meta->nb_args); + printk(KERN_CONT "types: ("); + for (j = 0; j < meta->nb_args; j++) { + if (j > 0) + printk(KERN_CONT ", "); + printk(KERN_CONT "%s", meta->types[j]); + } + printk(KERN_CONT ") "); + printk(KERN_CONT "args: ("); + for (j = 0; j < meta->nb_args; j++) { + if (j > 0) + printk(KERN_CONT ", "); + printk(KERN_CONT "%s", meta->args[j]); + } + printk(KERN_CONT ")\n"); + } + printk("%s---END---\n", ident); + + /* + * This module always fails to load. + */ + return -1; +} + +void cleanup_module(void) +{ +} + +MODULE_LICENSE("GPL"); diff --git a/include/instrumentation/syscalls/lttng-syscalls-generate-headers.sh b/include/instrumentation/syscalls/lttng-syscalls-generate-headers.sh new file mode 100755 index 00000000..4216dbd1 --- /dev/null +++ b/include/instrumentation/syscalls/lttng-syscalls-generate-headers.sh @@ -0,0 +1,351 @@ +#!/bin/bash + +# Generate system call probe description macros from syscall metadata dump file. +# The resulting header will be written in the headers subdirectory, in a file name +# based on the name of the input file. +# +# example usage: +# +# lttng-syscalls-generate-headers.sh +# lttng-syscalls-generate-headers.sh integers 3.0.4 x86-64-syscalls 64 +# lttng-syscalls-generate-headers.sh pointers 3.0.4 x86-64-syscalls 64 + +CLASS=$1 +VERSIONDIR=$2 +INPUTFILE=$3 +BITNESS=$4 +INPUT=${VERSIONDIR}/${INPUTFILE} +HEADER=headers/${INPUTFILE}_${CLASS}.h + +if [ x"$VERSIONDIR" = x"" ]; then + echo "Error: Please specify input directory as second argument" >&2 + exit 1 +fi + +if [ x"$INPUTFILE" = x"" ]; then + echo "Error: Please specify input file as third argument" >&2 + exit 1 +fi + +if [ x"$BITNESS" != x"32" ] && [ x"$BITNESS" != x"64" ]; then + echo "Error: Please specify bitness as fourth argument (\"32\" or \"64\")" >&2 + exit 1 +fi + +# Abort on error and undefined variable +set -eu + +# Create temp files +SRCFILE=$(mktemp) +TMPFILE=$(mktemp) + +# Delete temp files on exit +trap 'rm -f "${SRCFILE}" "${TMPFILE}"' EXIT + +cp "${INPUT}" "${SRCFILE}" + +## Cleanup the input file +# Remove the dmesg timestamp if present +perl -pi -e 's/^\[.*\] //g' "${SRCFILE}" +# Remove the 'sys_' prefix from syscall names +perl -pi -e 's/^syscall sys_([^ ]*)/syscall $1/g' "${SRCFILE}" +# Remove the user attribute from arguments +sed -i 's/ __attribute__((user))//g' "${SRCFILE}" + +#Filter + +if [ "$CLASS" = integers ]; then + #select integers and no-args. + CLASSCAP=INTEGERS + grep -v "\\*\|cap_user_header_t" "${SRCFILE}" > "${TMPFILE}" + mv "${TMPFILE}" "${SRCFILE}" +elif [ "$CLASS" = pointers ]; then + #select system calls using pointers. + CLASSCAP=POINTERS + grep "\\*\|cap_#user_header_t" "${SRCFILE}" > "${TMPFILE}" + mv "${TMPFILE}" "${SRCFILE}" +else + echo "Error: Please specify \"integers\" or \"pointers\" as first argument" >&2 + exit 1 +fi + + +echo "/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ + +/* THIS FILE IS AUTO-GENERATED. DO NOT EDIT */ + +/* Generated from ${INPUTFILE} ${VERSIONDIR} */ + +#ifndef CREATE_SYSCALL_TABLE + +#if !defined(_TRACE_SYSCALLS_${CLASSCAP}_H) || defined(TRACE_HEADER_MULTI_READ) +#define _TRACE_SYSCALLS_${CLASSCAP}_H + +#include +#include +#include \"${INPUTFILE}_${CLASS}_override.h\" +#include \"syscalls_${CLASS}_override.h\" +" > "${HEADER}" + +if [ "$CLASS" = integers ]; then + + NRARGS=0 + + # shellcheck disable=SC2129 + printf \ +'#ifdef SC_ENTER +SC_LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(syscalls_noargs, + TP_FIELDS() +) +' >> "${HEADER}" + + # shellcheck disable=SC2026 + grep "^syscall [^ ]* nr [^ ]* nbargs ${NRARGS} " "${SRCFILE}" | \ + perl -p -e 's/^syscall ([^ ]*) nr ([^ ]*) nbargs ([^ ]*) '\ +'types: \(([^)]*)\) '\ +'args: \(([^)]*)\)/'\ +'#ifndef OVERRIDE_'"${BITNESS}"'_$1\n'\ +'SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, $1)\n'\ +'#endif/g' >> "${HEADER}" + + printf '#else /* #ifdef SC_ENTER */\n' >> "${HEADER}" + + # shellcheck disable=SC2026 + grep "^syscall [^ ]* nr [^ ]* nbargs ${NRARGS} " "${SRCFILE}" | \ + perl -p -e 's/^syscall ([^ ]*) nr ([^ ]*) nbargs ([^ ]*) '\ +'types: \(([^)]*)\) '\ +'args: \(([^)]*)\)/'\ +'#ifndef OVERRIDE_'"${BITNESS}"'_$1\n'\ +'SC_LTTNG_TRACEPOINT_EVENT($1,\n'\ +' TP_PROTO(sc_exit(long ret)),\n'\ +' TP_ARGS(sc_exit(ret)),\n'\ +' TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)))\n'\ +')\n'\ +'#endif/g' >> "${HEADER}" + + printf '#endif /* else #ifdef SC_ENTER */\n' >> "${HEADER}" + +fi + + +# types: 4 +# args 5 + +NRARGS=1 +grep "^syscall [^ ]* nr [^ ]* nbargs ${NRARGS} " "${SRCFILE}" | while read -r LINE; do + SC_NAME=$(echo "${LINE}" | perl -p -e 's/^syscall ([^ ]*) .*/$1/g') + ARG1=$(./lttng-get-syscall-inout.sh table-syscall-inout.txt "${SC_NAME}" 1) + + echo Syscall: "${SC_NAME}" "${ARG1}" + + # shellcheck disable=SC2026 + echo "${LINE}" | perl -p -e 's/^syscall ([^ ]*) nr ([^ ]*) nbargs ([^ ]*) '\ +'types: \(([^)]*)\) '\ +'args: \(([^)]*)\)/'\ +'#ifndef OVERRIDE_'"${BITNESS}"'_$1\n'\ +'SC_LTTNG_TRACEPOINT_EVENT($1,\n'\ +' TP_PROTO(sc_exit(long ret,) $4 $5),\n'\ +' TP_ARGS(sc_exit(ret,) $5),\n'\ +' TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) '"${ARG1}"'(ctf_integer($4, $5, $5)))\n'\ +')\n'\ +'#endif/g' >> "${HEADER}" +done + +# types: 4 5 +# args 6 7 + +NRARGS=2 +grep "^syscall [^ ]* nr [^ ]* nbargs ${NRARGS} " "${SRCFILE}" | while read -r LINE; do + SC_NAME=$(echo "${LINE}" | perl -p -e 's/^syscall ([^ ]*) .*/$1/g') + ARG1=$(./lttng-get-syscall-inout.sh table-syscall-inout.txt "${SC_NAME}" 1) + ARG2=$(./lttng-get-syscall-inout.sh table-syscall-inout.txt "${SC_NAME}" 2) + + echo Syscall: "${SC_NAME}" "${ARG1}" "${ARG2}" + + # shellcheck disable=SC2026 + echo "${LINE}" | perl -p -e 's/^syscall ([^ ]*) nr ([^ ]*) nbargs ([^ ]*) '\ +'types: \(([^,]*), ([^)]*)\) '\ +'args: \(([^,]*), ([^)]*)\)/'\ +'#ifndef OVERRIDE_'"${BITNESS}"'_$1\n'\ +'SC_LTTNG_TRACEPOINT_EVENT($1,\n'\ +' TP_PROTO(sc_exit(long ret,) $4 $6, $5 $7),\n'\ +' TP_ARGS(sc_exit(ret,) $6, $7),\n'\ +' TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) '"${ARG1}"'(ctf_integer($4, $6, $6)) '"${ARG2}"'(ctf_integer($5, $7, $7)))\n'\ +')\n'\ +'#endif/g' >> "${HEADER}" +done + +# types: 4 5 6 +# args 7 8 9 + +NRARGS=3 +grep "^syscall [^ ]* nr [^ ]* nbargs ${NRARGS} " "${SRCFILE}" | while read -r LINE; do + SC_NAME=$(echo "${LINE}" | perl -p -e 's/^syscall ([^ ]*) .*/$1/g') + ARG1=$(./lttng-get-syscall-inout.sh table-syscall-inout.txt "${SC_NAME}" 1) + ARG2=$(./lttng-get-syscall-inout.sh table-syscall-inout.txt "${SC_NAME}" 2) + ARG3=$(./lttng-get-syscall-inout.sh table-syscall-inout.txt "${SC_NAME}" 3) + + echo Syscall: "${SC_NAME}" "${ARG1}" "${ARG2}" "${ARG3}" + + # shellcheck disable=SC2026 + echo "${LINE}" | perl -p -e 's/^syscall ([^ ]*) nr ([^ ]*) nbargs ([^ ]*) '\ +'types: \(([^,]*), ([^,]*), ([^)]*)\) '\ +'args: \(([^,]*), ([^,]*), ([^)]*)\)/'\ +'#ifndef OVERRIDE_'"${BITNESS}"'_$1\n'\ +'SC_LTTNG_TRACEPOINT_EVENT($1,\n'\ +' TP_PROTO(sc_exit(long ret,) $4 $7, $5 $8, $6 $9),\n'\ +' TP_ARGS(sc_exit(ret,) $7, $8, $9),\n'\ +' TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) '"${ARG1}"'(ctf_integer($4, $7, $7)) '"${ARG2}"'(ctf_integer($5, $8, $8)) '"${ARG3}"'(ctf_integer($6, $9, $9)))\n'\ +')\n'\ +'#endif/g' >> "${HEADER}" +done + + +# types: 4 5 6 7 +# args 8 9 10 11 + +NRARGS=4 +grep "^syscall [^ ]* nr [^ ]* nbargs ${NRARGS} " "${SRCFILE}" | while read -r LINE; do + SC_NAME=$(echo "${LINE}" | perl -p -e 's/^syscall ([^ ]*) .*/$1/g') + ARG1=$(./lttng-get-syscall-inout.sh table-syscall-inout.txt "${SC_NAME}" 1) + ARG2=$(./lttng-get-syscall-inout.sh table-syscall-inout.txt "${SC_NAME}" 2) + ARG3=$(./lttng-get-syscall-inout.sh table-syscall-inout.txt "${SC_NAME}" 3) + ARG4=$(./lttng-get-syscall-inout.sh table-syscall-inout.txt "${SC_NAME}" 4) + + echo Syscall: "${SC_NAME}" "${ARG1}" "${ARG2}" "${ARG3}" "${ARG4}" + + # shellcheck disable=SC2026 + echo "${LINE}" | perl -p -e 's/^syscall ([^ ]*) nr ([^ ]*) nbargs ([^ ]*) '\ +'types: \(([^,]*), ([^,]*), ([^,]*), ([^)]*)\) '\ +'args: \(([^,]*), ([^,]*), ([^,]*), ([^)]*)\)/'\ +'#ifndef OVERRIDE_'"${BITNESS}"'_$1\n'\ +'SC_LTTNG_TRACEPOINT_EVENT($1,\n'\ +' TP_PROTO(sc_exit(long ret,) $4 $8, $5 $9, $6 $10, $7 $11),\n'\ +' TP_ARGS(sc_exit(ret,) $8, $9, $10, $11),\n'\ +' TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) '"${ARG1}"'(ctf_integer($4, $8, $8)) '"${ARG2}"'(ctf_integer($5, $9, $9)) '"${ARG3}"'(ctf_integer($6, $10, $10)) '"${ARG4}"'(ctf_integer($7, $11, $11)))\n'\ +')\n'\ +'#endif/g' >> "${HEADER}" +done + +# types: 4 5 6 7 8 +# args 9 10 11 12 13 + +NRARGS=5 +grep "^syscall [^ ]* nr [^ ]* nbargs ${NRARGS} " "${SRCFILE}" | while read -r LINE; do + SC_NAME=$(echo "${LINE}" | perl -p -e 's/^syscall ([^ ]*) .*/$1/g') + ARG1=$(./lttng-get-syscall-inout.sh table-syscall-inout.txt "${SC_NAME}" 1) + ARG2=$(./lttng-get-syscall-inout.sh table-syscall-inout.txt "${SC_NAME}" 2) + ARG3=$(./lttng-get-syscall-inout.sh table-syscall-inout.txt "${SC_NAME}" 3) + ARG4=$(./lttng-get-syscall-inout.sh table-syscall-inout.txt "${SC_NAME}" 4) + ARG5=$(./lttng-get-syscall-inout.sh table-syscall-inout.txt "${SC_NAME}" 5) + + echo Syscall: "${SC_NAME}" "${ARG1}" "${ARG2}" "${ARG3}" "${ARG4}" "${ARG5}" + + # shellcheck disable=SC2026 + echo "${LINE}" | perl -p -e 's/^syscall ([^ ]*) nr ([^ ]*) nbargs ([^ ]*) '\ +'types: \(([^,]*), ([^,]*), ([^,]*), ([^,]*), ([^)]*)\) '\ +'args: \(([^,]*), ([^,]*), ([^,]*), ([^,]*), ([^)]*)\)/'\ +'#ifndef OVERRIDE_'"${BITNESS}"'_$1\n'\ +'SC_LTTNG_TRACEPOINT_EVENT($1,\n'\ +' TP_PROTO(sc_exit(long ret,) $4 $9, $5 $10, $6 $11, $7 $12, $8 $13),\n'\ +' TP_ARGS(sc_exit(ret,) $9, $10, $11, $12, $13),\n'\ +' TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) '"${ARG1}"'(ctf_integer($4, $9, $9)) '"${ARG2}"'(ctf_integer($5, $10, $10)) '"${ARG3}"'(ctf_integer($6, $11, $11)) '"${ARG4}"'(ctf_integer($7, $12, $12)) '"${ARG5}"'(ctf_integer($8, $13, $13)))\n'\ +')\n'\ +'#endif/g' >> "${HEADER}" +done + + +# types: 4 5 6 7 8 9 +# args 10 11 12 13 14 15 + +NRARGS=6 +grep "^syscall [^ ]* nr [^ ]* nbargs ${NRARGS} " "${SRCFILE}" | while read -r LINE; do + SC_NAME=$(echo "${LINE}" | perl -p -e 's/^syscall ([^ ]*) .*/$1/g') + ARG1=$(./lttng-get-syscall-inout.sh table-syscall-inout.txt "${SC_NAME}" 1) + ARG2=$(./lttng-get-syscall-inout.sh table-syscall-inout.txt "${SC_NAME}" 2) + ARG3=$(./lttng-get-syscall-inout.sh table-syscall-inout.txt "${SC_NAME}" 3) + ARG4=$(./lttng-get-syscall-inout.sh table-syscall-inout.txt "${SC_NAME}" 4) + ARG5=$(./lttng-get-syscall-inout.sh table-syscall-inout.txt "${SC_NAME}" 5) + ARG6=$(./lttng-get-syscall-inout.sh table-syscall-inout.txt "${SC_NAME}" 6) + + echo Syscall: "${SC_NAME}" "${ARG1}" "${ARG2}" "${ARG3}" "${ARG4}" "${ARG5}" "${ARG6}" + + # shellcheck disable=SC2026 + echo "${LINE}" | perl -p -e 's/^syscall ([^ ]*) nr ([^ ]*) nbargs ([^ ]*) '\ +'types: \(([^,]*), ([^,]*), ([^,]*), ([^,]*), ([^,]*), ([^\)]*)\) '\ +'args: \(([^,]*), ([^,]*), ([^,]*), ([^,]*), ([^,]*), ([^\)]*)\)/'\ +'#ifndef OVERRIDE_'"${BITNESS}"'_$1\n'\ +'SC_LTTNG_TRACEPOINT_EVENT($1,\n'\ +' TP_PROTO(sc_exit(long ret,) $4 $10, $5 $11, $6 $12, $7 $13, $8 $14, $9 $15),\n'\ +' TP_ARGS(sc_exit(ret,) $10, $11, $12, $13, $14, $15),\n'\ +' TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) '"${ARG1}"'(ctf_integer($4, $10, $10)) '"${ARG2}"'(ctf_integer($5, $11, $11)) '"${ARG3}"'(ctf_integer($6, $12, $12)) '"${ARG4}"'(ctf_integer($7, $13, $13)) '"${ARG5}"'(ctf_integer($8, $14, $14)) '"${ARG6}"'(ctf_integer($9, $15, $15)))\n'\ +')\n'\ +'#endif/g' >> "${HEADER}" +done + +# Macro for tracing syscall table + +echo \ +" +#endif /* _TRACE_SYSCALLS_${CLASSCAP}_H */ + +/* This part must be outside protection */ +#include + +#else /* CREATE_SYSCALL_TABLE */ + +#include \"${INPUTFILE}_${CLASS}_override.h\" +#include \"syscalls_${CLASS}_override.h\" +" >> "${HEADER}" + +NRARGS=0 + +if [ "$CLASS" = integers ]; then + #noargs + + # shellcheck disable=SC2129 + printf '#ifdef SC_ENTER\n' >> "${HEADER}" + + # shellcheck disable=SC2026 + grep "^syscall [^ ]* nr [^ ]* nbargs ${NRARGS} " "${SRCFILE}" | \ + perl -p -e 's/^syscall ([^ ]*) nr ([^ ]*) nbargs ([^ ]*) .*$/'\ +'#ifndef OVERRIDE_TABLE_'"${BITNESS}"'_$1\n'\ +'TRACE_SYSCALL_TABLE\(syscalls_noargs, $1, $2, $3\)\n'\ +'#endif/g' >> "${HEADER}" + + printf '#else /* #ifdef SC_ENTER */\n' >> "${HEADER}" + + # shellcheck disable=SC2026 + grep "^syscall [^ ]* nr [^ ]* nbargs ${NRARGS} " "${SRCFILE}" | \ + perl -p -e 's/^syscall ([^ ]*) nr ([^ ]*) nbargs ([^ ]*) .*$/'\ +'#ifndef OVERRIDE_TABLE_'"${BITNESS}"'_$1\n'\ +'TRACE_SYSCALL_TABLE($1, $1, $2, $3)\n'\ +'#endif/g' >> "${HEADER}" + + printf '#endif /* else #ifdef SC_ENTER */\n' >> "${HEADER}" +fi + +#others. +# shellcheck disable=SC2026 +grep -v "^syscall [^ ]* nr [^ ]* nbargs ${NRARGS} " "${SRCFILE}" | \ + perl -p -e 's/^syscall ([^ ]*) nr ([^ ]*) nbargs ([^ ]*) .*$/'\ +'#ifndef OVERRIDE_TABLE_'"${BITNESS}"'_$1\n'\ +'TRACE_SYSCALL_TABLE($1, $1, $2, $3)\n'\ +'#endif/g' >> "${HEADER}" + +printf '\n#endif /* CREATE_SYSCALL_TABLE */\n' >> "${HEADER}" + +#fields names: ...char * type with *name* or *file* or *path* or *root* +# or *put_old* or *type* +perl -pi -e 's/ctf_integer\(([^,)]*char \*), ([^\)]*)(name|file|path|root|put_old|type)([^\)]*)\)/ctf_user_string($2$3$4)/g' \ + "${HEADER}" + +#prettify addresses heuristics. +#field names with addr or ptr +perl -pi -e 's/ctf_integer\(([^,)]*), ([^,)]*addr|[^,)]*ptr)([^),]*)\)/ctf_integer_hex($1, $2$3, $2$3)/g' \ + "${HEADER}" + +#field types ending with '*' +perl -pi -e 's/ctf_integer\(([^,)]*\*), ([^),]*)\)/ctf_integer_hex($1, $2, $2)/g' "${HEADER}" + +# EOF diff --git a/include/instrumentation/syscalls/table-syscall-inout.txt b/include/instrumentation/syscalls/table-syscall-inout.txt new file mode 100644 index 00000000..cb835a52 --- /dev/null +++ b/include/instrumentation/syscalls/table-syscall-inout.txt @@ -0,0 +1,289 @@ +syscall read nbargs 3 rw: (r, w, r) +syscall write nbargs 3 rw: (r, r, r) +syscall open nbargs 3 rw: (r, r, r) +syscall close nbargs 1 rw: (r) +syscall newstat nbargs 2 rw: (r, w) +syscall newfstat nbargs 2 rw: (r, w) +syscall newlstat nbargs 2 rw: (r, w) +syscall poll nbargs 3 rw: (rw, r, r) +syscall lseek nbargs 3 rw: (r, r, r) +syscall mmap nbargs 6 rw: (r, r, r, r, r, r) +syscall mprotect nbargs 3 rw: (r, r, r) +syscall munmap nbargs 2 rw: (r, r) +syscall brk nbargs 1 rw: (r) +syscall rt_sigaction nbargs 4 rw: (r, r, w, r) +syscall rt_sigprocmask nbargs 4 rw: (r, r, w, r) +syscall ioctl nbargs 3 rw: (r, r, rw) +syscall pread64 nbargs 4 rw: (r, w, r, r) +syscall pwrite64 nbargs 4 rw: (r, r, r, r) +syscall readv nbargs 3 rw: (r, rw, r) +syscall writev nbargs 3 rw: (r, rw, r) +syscall access nbargs 2 rw: (r, r) +syscall pipe nbargs 1 rw: (w) +syscall select nbargs 5 rw: (r, rw, rw, rw, rw) +syscall sched_yield nbargs 0 +syscall mremap nbargs 5 rw: (r, r, r, r, r) +syscall msync nbargs 3 rw: (r, r, r) +syscall mincore nbargs 3 rw: (r, r, w) +syscall madvise nbargs 3 rw: (r, r, r) +syscall shmget nbargs 3 rw: (r, r, r) +syscall shmat nbargs 3 rw: (r, r, r) +syscall shmctl nbargs 3 rw: (r, r, rw) +syscall dup nbargs 1 rw: (r) +syscall dup2 nbargs 2 rw: (r, r) +syscall pause nbargs 0 +syscall nanosleep nbargs 2 rw: (r, w) +syscall getitimer nbargs 2 rw: (r, w) +syscall alarm nbargs 1 rw: (r) +syscall setitimer nbargs 3 rw: (r, r, w) +syscall getpid nbargs 0 +syscall sendfile64 nbargs 4 rw: (r, r, rw, r) +syscall socket nbargs 3 rw: (r, r, r) +syscall connect nbargs 3 rw: (r, r, r) +syscall accept nbargs 3 rw: (r, w, rw) +syscall sendto nbargs 6 rw: (r, r, r, r, r, r) +syscall recvfrom nbargs 6 rw: (r, w, r, r, w, rw) +syscall sendmsg nbargs 3 rw: (r, r, r) +syscall recvmsg nbargs 3 rw: (r, rw, r) +syscall shutdown nbargs 2 rw: (r, r) +syscall bind nbargs 3 rw: (r, r, r) +syscall listen nbargs 2 rw: (r, r) +syscall getsockname nbargs 3 rw: (r, w, rw) +syscall getpeername nbargs 3 rw: (r, w, rw) +syscall socketpair nbargs 4 rw: (r, r, r, w) +syscall setsockopt nbargs 5 rw: (r, r, r, r, r) +syscall getsockopt nbargs 5 rw: (r, r, r, w, rw) +syscall exit nbargs 1 rw: (r) +syscall wait4 nbargs 4 rw: (r, w, r, w) +syscall kill nbargs 2 rw: (r, r) +syscall newuname nbargs 1 rw: (w) +syscall semget nbargs 3 rw: (r, r, r) +syscall semop nbargs 3 rw: (r, r, r) +syscall semctl nbargs 4 rw: (r, r, r, rw) +syscall shmdt nbargs 1 rw: (r) +syscall msgget nbargs 2 rw: (r, r) +syscall msgsnd nbargs 4 rw: (r, r, r, r) +syscall msgrcv nbargs 5 rw: (r, w, r, r, r) +syscall msgctl nbargs 3 rw: (r, r, rw) +syscall fcntl nbargs 3 rw: (r, r, rw) +syscall flock nbargs 2 rw: (r, r) +syscall fsync nbargs 1 rw: (r) +syscall fdatasync nbargs 1 rw: (r) +syscall truncate nbargs 2 rw: (r, r) +syscall ftruncate nbargs 2 rw: (r, r) +syscall getdents nbargs 3 rw: (r, w, r) +syscall getcwd nbargs 2 rw: (w, r) +syscall chdir nbargs 1 rw: (r) +syscall fchdir nbargs 1 rw: (r) +syscall rename nbargs 2 rw: (r, r) +syscall mkdir nbargs 2 rw: (r, r) +syscall rmdir nbargs 1 rw: (r) +syscall creat nbargs 2 rw: (r, r) +syscall link nbargs 2 rw: (r, r) +syscall unlink nbargs 1 rw: (r) +syscall symlink nbargs 2 rw: (r, r) +syscall readlink nbargs 3 rw: (r, w, r) +syscall chmod nbargs 2 rw: (r, r) +syscall fchmod nbargs 2 rw: (r, r) +syscall chown nbargs 3 rw: (r, r, r) +syscall fchown nbargs 3 rw: (r, r, r) +syscall lchown nbargs 3 rw: (r, r, r) +syscall umask nbargs 1 rw: (r) +syscall gettimeofday nbargs 2 rw: (w, w) +syscall getrlimit nbargs 2 rw: (r, w) +syscall getrusage nbargs 2 rw: (r, w) +syscall sysinfo nbargs 1 rw: (w) +syscall times nbargs 1 rw: (w) +syscall ptrace nbargs 4 rw: (r, r, rw, rw) +syscall getuid nbargs 0 +syscall syslog nbargs 3 rw: (r, w, r) +syscall getgid nbargs 0 +syscall setuid nbargs 1 rw: (r) +syscall setgid nbargs 1 rw: (r) +syscall geteuid nbargs 0 +syscall getegid nbargs 0 +syscall setpgid nbargs 2 rw: (r, r) +syscall getppid nbargs 0 +syscall getpgrp nbargs 0 +syscall setsid nbargs 0 +syscall setreuid nbargs 2 rw: (r, r) +syscall setregid nbargs 2 rw: (r, r) +syscall getgroups nbargs 2 rw: (r, w) +syscall setgroups nbargs 2 rw: (r, r) +syscall setresuid nbargs 3 rw: (r, r, r) +syscall getresuid nbargs 3 rw: (w, w, w) +syscall setresgid nbargs 3 rw: (r, r, r) +syscall getresgid nbargs 3 rw: (w, w, w) +syscall getpgid nbargs 1 rw: (r) +syscall setfsuid nbargs 1 rw: (r) +syscall setfsgid nbargs 1 rw: (r) +syscall getsid nbargs 1 rw: (r) +syscall capget nbargs 2 rw: (r, w) +syscall capset nbargs 2 rw: (r, r) +syscall rt_sigpending nbargs 2 rw: (w, r) +syscall rt_sigtimedwait nbargs 4 rw: (w, w, r, r) +syscall rt_sigqueueinfo nbargs 3 rw: (r, r, r) +syscall rt_sigsuspend nbargs 2 rw: (r, r) +syscall sigaltstack nbargs 2 rw: (r, rw) +syscall utime nbargs 2 rw: (r, r) +syscall mknod nbargs 3 rw: (r, r, r) +syscall personality nbargs 1 rw: (r) +syscall ustat nbargs 2 rw: (r, w) +syscall statfs nbargs 2 rw: (r, w) +syscall fstatfs nbargs 2 rw: (r, w) +syscall sysfs nbargs 3 rw: (r, r, r) +syscall getpriority nbargs 2 rw: (r, r) +syscall setpriority nbargs 3 rw: (r, r, r) +syscall sched_setparam nbargs 2 rw: (r, r) +syscall sched_getparam nbargs 2 rw: (r, w) +syscall sched_setscheduler nbargs 3 rw: (r, r, r) +syscall sched_getscheduler nbargs 1 rw: (r) +syscall sched_get_priority_max nbargs 1 rw: (r) +syscall sched_get_priority_min nbargs 1 rw: (r) +syscall sched_rr_get_interval nbargs 2 rw: (r, w) +syscall mlock nbargs 2 rw: (r, r) +syscall munlock nbargs 2 rw: (r, r) +syscall mlockall nbargs 1 rw: (r) +syscall munlockall nbargs 0 +syscall vhangup nbargs 0 +syscall pivot_root nbargs 2 rw: (r, r) +syscall sysctl nbargs 1 rw: (rw) +syscall prctl nbargs 5 rw: (r, rw, r, r, r) +syscall adjtimex nbargs 1 rw: (rw) +syscall setrlimit nbargs 2 rw: (r, r) +syscall chroot nbargs 1 rw: (r) +syscall sync nbargs 0 +syscall acct nbargs 1 rw: (r) +syscall settimeofday nbargs 2 rw: (r, r) +syscall mount nbargs 5 rw: (r, r, r, r, r) +syscall umount nbargs 2 rw: (r, r) +syscall swapon nbargs 2 rw: (r, r) +syscall swapoff nbargs 1 rw: (r) +syscall reboot nbargs 4 rw: (r, r, r, r) +syscall sethostname nbargs 2 rw: (r, r) +syscall setdomainname nbargs 2 rw: (r, r) +syscall init_module nbargs 3 rw: (r, r, r) +syscall delete_module nbargs 2 rw: (r, r) +syscall quotactl nbargs 4 rw: (r, r, r, rw) +syscall gettid nbargs 0 +syscall readahead nbargs 3 rw: (r, r, r) +syscall setxattr nbargs 5 rw: (r, r, r, r, r) +syscall lsetxattr nbargs 5 rw: (r, r, r, r, r) +syscall fsetxattr nbargs 5 rw: (r, r, r, r, r) +syscall getxattr nbargs 4 rw: (r, r, w, r) +syscall lgetxattr nbargs 4 rw: (r, r, w, r) +syscall fgetxattr nbargs 4 rw: (r, r, w, r) +syscall listxattr nbargs 3 rw: (r, w, r) +syscall llistxattr nbargs 3 rw: (r, w, r) +syscall flistxattr nbargs 3 rw: (r, w, r) +syscall removexattr nbargs 2 rw: (r, r) +syscall lremovexattr nbargs 2 rw: (r, r) +syscall fremovexattr nbargs 2 rw: (r, r) +syscall tkill nbargs 2 rw: (r, r) +syscall time nbargs 1 rw: (w) +syscall futex nbargs 6 rw: (rw, r, r, r, rw, r) +syscall sched_setaffinity nbargs 3 rw: (r, r, r) +syscall sched_getaffinity nbargs 3 rw: (r, r, w) +syscall io_setup nbargs 2 rw: (r, r) +syscall io_destroy nbargs 1 rw: (r) +syscall io_getevents nbargs 5 rw: (r, r, r, w, rw) +syscall io_submit nbargs 3 rw: (r, r, r) +syscall io_cancel nbargs 3 rw: (r, r, w) +syscall lookup_dcookie nbargs 3 rw: (r, w, r) +syscall epoll_create nbargs 1 rw: (r) +syscall remap_file_pages nbargs 5 rw: (r, r, r, r, r) +syscall getdents64 nbargs 3 rw: (r, w, r) +syscall set_tid_address nbargs 1 rw: (r) +syscall restart_syscall nbargs 0 +syscall semtimedop nbargs 4 rw: (r, r, r, rw) +syscall fadvise64 nbargs 4 rw: (r, r, r, r) +syscall timer_create nbargs 3 rw: (r, r, w) +syscall timer_settime nbargs 4 rw: (r, r, r, w) +syscall timer_gettime nbargs 2 rw: (r, w) +syscall timer_getoverrun nbargs 1 rw: (r) +syscall timer_delete nbargs 1 rw: (r) +syscall clock_settime nbargs 2 rw: (r, r) +syscall clock_gettime nbargs 2 rw: (r, w) +syscall clock_getres nbargs 2 rw: (r, w) +syscall clock_nanosleep nbargs 4 rw: (r, r, r, w) +syscall exit_group nbargs 1 rw: (r) +syscall epoll_wait nbargs 4 rw: (r, w, r, r) +syscall epoll_ctl nbargs 4 rw: (r, r, r, r) +syscall tgkill nbargs 3 rw: (r, r, r) +syscall utimes nbargs 2 rw: (r, r) +syscall mbind nbargs 6 rw: (r, r, r, r, r, r) +syscall set_mempolicy nbargs 3 rw: (r, r, r) +syscall get_mempolicy nbargs 5 rw: (w, w, r, r, r) +syscall mq_open nbargs 4 rw: (r, r, r, r) +syscall mq_unlink nbargs 1 rw: (r) +syscall mq_timedsend nbargs 5 rw: (r, r, r, r, r) +syscall mq_timedreceive nbargs 5 rw: (r, w, r, w, r) +syscall mq_notify nbargs 2 rw: (r, r) +syscall mq_getsetattr nbargs 3 rw: (r, r, w) +syscall kexec_load nbargs 4 rw: (r, r, r, r) +syscall waitid nbargs 5 rw: (r, r, w, r, w) +syscall add_key nbargs 5 rw: (r, r, r, r, r) +syscall request_key nbargs 4 rw: (r, r, r, r) +syscall keyctl nbargs 5 rw: (r, rw, rw, rw, rw) +syscall ioprio_set nbargs 3 rw: (r, r, r) +syscall ioprio_get nbargs 2 rw: (r, r) +syscall inotify_init nbargs 0 +syscall inotify_add_watch nbargs 3 rw: (r, r, r) +syscall inotify_rm_watch nbargs 2 rw: (r, r) +syscall migrate_pages nbargs 4 rw: (r, r, r, r) +syscall openat nbargs 4 rw: (r, r, r, r) +syscall mkdirat nbargs 3 rw: (r, r, r) +syscall mknodat nbargs 4 rw: (r, r, r, r) +syscall fchownat nbargs 5 rw: (r, r, r, r, r) +syscall futimesat nbargs 3 rw: (r, r, r) +syscall newfstatat nbargs 4 rw: (r, r, w, r) +syscall unlinkat nbargs 3 rw: (r, r, r) +syscall renameat nbargs 4 rw: (r, r, r, r) +syscall linkat nbargs 5 rw: (r, r, r, r, r) +syscall symlinkat nbargs 3 rw: (r, r, r) +syscall readlinkat nbargs 4 rw: (r, r, w, r) +syscall fchmodat nbargs 3 rw: (r, r, r) +syscall faccessat nbargs 3 rw: (r, r, r) +syscall pselect6 nbargs 6 rw: (r, rw, rw, rw, rw, r) +syscall ppoll nbargs 5 rw: (rw, r, r, r, r) +syscall unshare nbargs 1 rw: (r) +syscall set_robust_list nbargs 2 rw: (r, r) +syscall get_robust_list nbargs 3 rw: (r, w, w) +syscall splice nbargs 6 rw: (r, r, r, r, r, r) +syscall tee nbargs 4 rw: (r, r, r, r) +syscall sync_file_range nbargs 4 rw: (r, r, r, r) +syscall vmsplice nbargs 4 rw: (r, r, r, r) +syscall move_pages nbargs 6 rw: (r, r, r, r, w, r) +syscall utimensat nbargs 4 rw: (r, r, r, r) +syscall epoll_pwait nbargs 6 rw: (r, w, r, r, r, r) +syscall signalfd nbargs 3 rw: (r, r, r) +syscall timerfd_create nbargs 2 rw: (r, r) +syscall eventfd nbargs 1 rw: (r) +syscall fallocate nbargs 4 rw: (r, r, r, r) +syscall timerfd_settime nbargs 4 rw: (r, r, r, w) +syscall timerfd_gettime nbargs 2 rw: (r, w) +syscall accept4 nbargs 4 rw: (r, w, rw, r) +syscall signalfd4 nbargs 4 rw: (r, r, r, r) +syscall eventfd2 nbargs 2 rw: (r, r) +syscall epoll_create1 nbargs 1 rw: (r) +syscall dup3 nbargs 3 rw: (r, r, r) +syscall pipe2 nbargs 2 rw: (w, r) +syscall inotify_init1 nbargs 1 rw: (r) +syscall preadv nbargs 5 rw: (r, w, r, r, r) +syscall pwritev nbargs 5 rw: (r, r, r, r, r) +syscall rt_tgsigqueueinfo nbargs 4 rw: (r, r, r, r) +syscall perf_event_open nbargs 5 rw: (r, r, r, r, r) +syscall recvmmsg nbargs 5 rw: (r, w, r, r, rw) +syscall fanotify_init nbargs 2 rw: (r, r) +syscall fanotify_mark nbargs 5 rw: (r, r, r, r, r) +syscall prlimit64 nbargs 4 rw: (r, r, r, w) +syscall name_to_handle_at nbargs 5 rw: (r, r, rw, w, r) +syscall open_by_handle_at nbargs 3 rw: (r, r, r) +syscall clock_adjtime nbargs 2 rw: (r, rw) +syscall syncfs nbargs 1 rw: (r) +syscall sendmmsg nbargs 4 rw: (r, r, r, r) +syscall setns nbargs 2 rw: (r, r) +syscall getcpu nbargs 3 rw: (w, w, rw) +syscall process_vm_readv nbargs 6 rw: (r, w, r, r, r, r) +syscall process_vm_writev nbargs 6 rw: (r, r, r, r, r, r) +syscall finit_module nbargs 3 rw: (r, r, r) diff --git a/include/lttng/align.h b/include/lttng/align.h new file mode 100644 index 00000000..964ed1a8 --- /dev/null +++ b/include/lttng/align.h @@ -0,0 +1,60 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) + * + * lttng/align.h + * + * Copyright (C) 2010-2012 Mathieu Desnoyers + */ + +#ifndef _LTTNG_ALIGN_H +#define _LTTNG_ALIGN_H + +#ifdef __KERNEL__ + +#include +#include + +#define ALIGN_FLOOR(x, a) __ALIGN_FLOOR_MASK(x, (typeof(x)) (a) - 1) +#define __ALIGN_FLOOR_MASK(x, mask) ((x) & ~(mask)) +#define PTR_ALIGN_FLOOR(p, a) \ + ((typeof(p)) ALIGN_FLOOR((unsigned long) (p), a)) + +/* + * Align pointer on natural object alignment. + */ +#define object_align(obj) PTR_ALIGN(obj, __alignof__(*(obj))) +#define object_align_floor(obj) PTR_ALIGN_FLOOR(obj, __alignof__(*(obj))) + +/** + * offset_align - Calculate the offset needed to align an object on its natural + * alignment towards higher addresses. + * @align_drift: object offset from an "alignment"-aligned address. + * @alignment: natural object alignment. Must be non-zero, power of 2. + * + * Returns the offset that must be added to align towards higher + * addresses. + */ +#define offset_align(align_drift, alignment) \ + ({ \ + BUILD_RUNTIME_BUG_ON((alignment) == 0 \ + || ((alignment) & ((alignment) - 1))); \ + (((alignment) - (align_drift)) & ((alignment) - 1)); \ + }) + +/** + * offset_align_floor - Calculate the offset needed to align an object + * on its natural alignment towards lower addresses. + * @align_drift: object offset from an "alignment"-aligned address. + * @alignment: natural object alignment. Must be non-zero, power of 2. + * + * Returns the offset that must be substracted to align towards lower addresses. + */ +#define offset_align_floor(align_drift, alignment) \ + ({ \ + BUILD_RUNTIME_BUG_ON((alignment) == 0 \ + || ((alignment) & ((alignment) - 1))); \ + (((align_drift) - (alignment)) & ((alignment) - 1)); \ + }) + +#endif /* __KERNEL__ */ + +#endif diff --git a/include/lttng/bitfield.h b/include/lttng/bitfield.h new file mode 100644 index 00000000..b0fcbd25 --- /dev/null +++ b/include/lttng/bitfield.h @@ -0,0 +1,543 @@ +/* SPDX-License-Identifier: MIT + * + * Copyright 2010-2019 - Mathieu Desnoyers + */ + +#ifndef _BABELTRACE_BITFIELD_H +#define _BABELTRACE_BITFIELD_H + +#include +#include + +#ifndef CHAR_BIT +#define CHAR_BIT 8 +#endif + +/* + * This header strictly follows the C99 standard, except for use of the + * compiler-specific __typeof__. + */ + +/* + * This bitfield header requires the compiler representation of signed + * integers to be two's complement. + */ +#if (-1 != ~0) +#error "bitfield.h requires the compiler representation of signed integers to be two's complement." +#endif + +/* + * _bt_is_signed_type() willingly generates comparison of unsigned + * expression < 0, which is always false. Silence compiler warnings. + * GCC versions lower than 4.6.0 do not accept diagnostic pragma inside + * functions. + */ +#if defined(__GNUC__) && (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) >= 40600 +# define _BT_DIAG_PUSH _Pragma("GCC diagnostic push") +# define _BT_DIAG_POP _Pragma("GCC diagnostic pop") + +# define _BT_DIAG_STRINGIFY_1(x) #x +# define _BT_DIAG_STRINGIFY(x) _BT_DIAG_STRINGIFY_1(x) + +# define _BT_DIAG_IGNORE(option) \ + _Pragma(_BT_DIAG_STRINGIFY(GCC diagnostic ignored option)) +# define _BT_DIAG_IGNORE_TYPE_LIMITS _BT_DIAG_IGNORE("-Wtype-limits") +#else +# define _BT_DIAG_PUSH +# define _BT_DIAG_POP +# define _BT_DIAG_IGNORE +# define _BT_DIAG_IGNORE_TYPE_LIMITS +#endif + +#define _bt_is_signed_type(type) ((type) -1 < (type) 0) + +/* + * Produce a build-time error if the condition `cond` is non-zero. + * Evaluates as a size_t expression. + */ +#ifdef __cplusplus +#define _BT_BUILD_ASSERT(cond) ([]{static_assert((cond), "");}, 0) +#else +#define _BT_BUILD_ASSERT(cond) \ + sizeof(struct { int f:(2 * !!(cond) - 1); }) +#endif + +/* + * Cast value `v` to an unsigned integer of the same size as `v`. + */ +#define _bt_cast_value_to_unsigned(v) \ + (sizeof(v) == sizeof(uint8_t) ? (uint8_t) (v) : \ + sizeof(v) == sizeof(uint16_t) ? (uint16_t) (v) : \ + sizeof(v) == sizeof(uint32_t) ? (uint32_t) (v) : \ + sizeof(v) == sizeof(uint64_t) ? (uint64_t) (v) : \ + _BT_BUILD_ASSERT(sizeof(v) <= sizeof(uint64_t))) + +/* + * Cast value `v` to an unsigned integer type of the size of type `type` + * *without* sign-extension. + * + * The unsigned cast ensures that we're not shifting a negative value, + * which is undefined in C. However, this limits the maximum type size + * of `type` to 64-bit. Generate a compile-time error if the size of + * `type` is larger than 64-bit. + */ +#define _bt_cast_value_to_unsigned_type(type, v) \ + (sizeof(type) == sizeof(uint8_t) ? \ + (uint8_t) _bt_cast_value_to_unsigned(v) : \ + sizeof(type) == sizeof(uint16_t) ? \ + (uint16_t) _bt_cast_value_to_unsigned(v) : \ + sizeof(type) == sizeof(uint32_t) ? \ + (uint32_t) _bt_cast_value_to_unsigned(v) : \ + sizeof(type) == sizeof(uint64_t) ? \ + (uint64_t) _bt_cast_value_to_unsigned(v) : \ + _BT_BUILD_ASSERT(sizeof(v) <= sizeof(uint64_t))) + +/* + * _bt_fill_mask evaluates to a "type" integer with all bits set. + */ +#define _bt_fill_mask(type) ((type) ~(type) 0) + +/* + * Left shift a value `v` of `shift` bits. + * + * The type of `v` can be signed or unsigned integer. + * The value of `shift` must be less than the size of `v` (in bits), + * otherwise the behavior is undefined. + * Evaluates to the result of the shift operation. + * + * According to the C99 standard, left shift of a left hand-side signed + * type is undefined if it has a negative value or if the result cannot + * be represented in the result type. This bitfield header discards the + * bits that are left-shifted beyond the result type representation, + * which is the behavior of an unsigned type left shift operation. + * Therefore, always perform left shift on an unsigned type. + * + * This macro should not be used if `shift` can be greater or equal than + * the bitwidth of `v`. See `_bt_safe_lshift`. + */ +#define _bt_lshift(v, shift) \ + ((__typeof__(v)) (_bt_cast_value_to_unsigned(v) << (shift))) + +/* + * Generate a mask of type `type` with the `length` least significant bits + * cleared, and the most significant bits set. + */ +#define _bt_make_mask_complement(type, length) \ + _bt_lshift(_bt_fill_mask(type), length) + +/* + * Generate a mask of type `type` with the `length` least significant bits + * set, and the most significant bits cleared. + */ +#define _bt_make_mask(type, length) \ + ((type) ~_bt_make_mask_complement(type, length)) + +/* + * Right shift a value `v` of `shift` bits. + * + * The type of `v` can be signed or unsigned integer. + * The value of `shift` must be less than the size of `v` (in bits), + * otherwise the behavior is undefined. + * Evaluates to the result of the shift operation. + * + * According to the C99 standard, right shift of a left hand-side signed + * type which has a negative value is implementation defined. This + * bitfield header relies on the right shift implementation carrying the + * sign bit. If the compiler implementation has a different behavior, + * emulate carrying the sign bit. + * + * This macro should not be used if `shift` can be greater or equal than + * the bitwidth of `v`. See `_bt_safe_rshift`. + */ +#if ((-1 >> 1) == -1) +#define _bt_rshift(v, shift) ((v) >> (shift)) +#else +#define _bt_rshift(v, shift) \ + ((__typeof__(v)) ((_bt_cast_value_to_unsigned(v) >> (shift)) | \ + ((v) < 0 ? _bt_make_mask_complement(__typeof__(v), \ + sizeof(v) * CHAR_BIT - (shift)) : 0))) +#endif + +/* + * Right shift a signed or unsigned integer with `shift` value being an + * arbitrary number of bits. `v` is modified by this macro. The shift + * is transformed into a sequence of `_nr_partial_shifts` consecutive + * shift operations, each of a number of bits smaller than the bitwidth + * of `v`, ending with a shift of the number of left over bits. + */ +#define _bt_safe_rshift(v, shift) \ +do { \ + unsigned long _nr_partial_shifts = (shift) / (sizeof(v) * CHAR_BIT - 1); \ + unsigned long _leftover_bits = (shift) % (sizeof(v) * CHAR_BIT - 1); \ + \ + for (; _nr_partial_shifts; _nr_partial_shifts--) \ + (v) = _bt_rshift(v, sizeof(v) * CHAR_BIT - 1); \ + (v) = _bt_rshift(v, _leftover_bits); \ +} while (0) + +/* + * Left shift a signed or unsigned integer with `shift` value being an + * arbitrary number of bits. `v` is modified by this macro. The shift + * is transformed into a sequence of `_nr_partial_shifts` consecutive + * shift operations, each of a number of bits smaller than the bitwidth + * of `v`, ending with a shift of the number of left over bits. + */ +#define _bt_safe_lshift(v, shift) \ +do { \ + unsigned long _nr_partial_shifts = (shift) / (sizeof(v) * CHAR_BIT - 1); \ + unsigned long _leftover_bits = (shift) % (sizeof(v) * CHAR_BIT - 1); \ + \ + for (; _nr_partial_shifts; _nr_partial_shifts--) \ + (v) = _bt_lshift(v, sizeof(v) * CHAR_BIT - 1); \ + (v) = _bt_lshift(v, _leftover_bits); \ +} while (0) + +/* + * bt_bitfield_write - write integer to a bitfield in native endianness + * + * Save integer to the bitfield, which starts at the "start" bit, has "len" + * bits. + * The inside of a bitfield is from high bits to low bits. + * Uses native endianness. + * For unsigned "v", pad MSB with 0 if bitfield is larger than v. + * For signed "v", sign-extend v if bitfield is larger than v. + * + * On little endian, bytes are placed from the less significant to the most + * significant. Also, consecutive bitfields are placed from lower bits to higher + * bits. + * + * On big endian, bytes are places from most significant to less significant. + * Also, consecutive bitfields are placed from higher to lower bits. + */ + +#define _bt_bitfield_write_le(ptr, type, start, length, v) \ +do { \ + __typeof__(v) _v = (v); \ + type *_ptr = (void *) (ptr); \ + unsigned long _start = (start), _length = (length); \ + type _mask, _cmask; \ + unsigned long _ts = sizeof(type) * CHAR_BIT; /* type size */ \ + unsigned long _start_unit, _end_unit, _this_unit; \ + unsigned long _end, _cshift; /* _cshift is "complement shift" */ \ + \ + if (!_length) \ + break; \ + \ + _end = _start + _length; \ + _start_unit = _start / _ts; \ + _end_unit = (_end + (_ts - 1)) / _ts; \ + \ + /* Trim v high bits */ \ + if (_length < sizeof(_v) * CHAR_BIT) \ + _v &= _bt_make_mask(__typeof__(_v), _length); \ + \ + /* We can now append v with a simple "or", shift it piece-wise */ \ + _this_unit = _start_unit; \ + if (_start_unit == _end_unit - 1) { \ + _mask = _bt_make_mask(type, _start % _ts); \ + if (_end % _ts) \ + _mask |= _bt_make_mask_complement(type, _end % _ts); \ + _cmask = _bt_lshift((type) (_v), _start % _ts); \ + _cmask &= ~_mask; \ + _ptr[_this_unit] &= _mask; \ + _ptr[_this_unit] |= _cmask; \ + break; \ + } \ + if (_start % _ts) { \ + _cshift = _start % _ts; \ + _mask = _bt_make_mask(type, _cshift); \ + _cmask = _bt_lshift((type) (_v), _cshift); \ + _cmask &= ~_mask; \ + _ptr[_this_unit] &= _mask; \ + _ptr[_this_unit] |= _cmask; \ + _bt_safe_rshift(_v, _ts - _cshift); \ + _start += _ts - _cshift; \ + _this_unit++; \ + } \ + for (; _this_unit < _end_unit - 1; _this_unit++) { \ + _ptr[_this_unit] = (type) _v; \ + _bt_safe_rshift(_v, _ts); \ + _start += _ts; \ + } \ + if (_end % _ts) { \ + _mask = _bt_make_mask_complement(type, _end % _ts); \ + _cmask = (type) _v; \ + _cmask &= ~_mask; \ + _ptr[_this_unit] &= _mask; \ + _ptr[_this_unit] |= _cmask; \ + } else \ + _ptr[_this_unit] = (type) _v; \ +} while (0) + +#define _bt_bitfield_write_be(ptr, type, start, length, v) \ +do { \ + __typeof__(v) _v = (v); \ + type *_ptr = (void *) (ptr); \ + unsigned long _start = (start), _length = (length); \ + type _mask, _cmask; \ + unsigned long _ts = sizeof(type) * CHAR_BIT; /* type size */ \ + unsigned long _start_unit, _end_unit, _this_unit; \ + unsigned long _end, _cshift; /* _cshift is "complement shift" */ \ + \ + if (!_length) \ + break; \ + \ + _end = _start + _length; \ + _start_unit = _start / _ts; \ + _end_unit = (_end + (_ts - 1)) / _ts; \ + \ + /* Trim v high bits */ \ + if (_length < sizeof(_v) * CHAR_BIT) \ + _v &= _bt_make_mask(__typeof__(_v), _length); \ + \ + /* We can now append v with a simple "or", shift it piece-wise */ \ + _this_unit = _end_unit - 1; \ + if (_start_unit == _end_unit - 1) { \ + _mask = _bt_make_mask(type, (_ts - (_end % _ts)) % _ts); \ + if (_start % _ts) \ + _mask |= _bt_make_mask_complement(type, _ts - (_start % _ts)); \ + _cmask = _bt_lshift((type) (_v), (_ts - (_end % _ts)) % _ts); \ + _cmask &= ~_mask; \ + _ptr[_this_unit] &= _mask; \ + _ptr[_this_unit] |= _cmask; \ + break; \ + } \ + if (_end % _ts) { \ + _cshift = _end % _ts; \ + _mask = _bt_make_mask(type, _ts - _cshift); \ + _cmask = _bt_lshift((type) (_v), _ts - _cshift); \ + _cmask &= ~_mask; \ + _ptr[_this_unit] &= _mask; \ + _ptr[_this_unit] |= _cmask; \ + _bt_safe_rshift(_v, _cshift); \ + _end -= _cshift; \ + _this_unit--; \ + } \ + for (; (long) _this_unit >= (long) _start_unit + 1; _this_unit--) { \ + _ptr[_this_unit] = (type) _v; \ + _bt_safe_rshift(_v, _ts); \ + _end -= _ts; \ + } \ + if (_start % _ts) { \ + _mask = _bt_make_mask_complement(type, _ts - (_start % _ts)); \ + _cmask = (type) _v; \ + _cmask &= ~_mask; \ + _ptr[_this_unit] &= _mask; \ + _ptr[_this_unit] |= _cmask; \ + } else \ + _ptr[_this_unit] = (type) _v; \ +} while (0) + +/* + * bt_bitfield_write - write integer to a bitfield in native endianness + * bt_bitfield_write_le - write integer to a bitfield in little endian + * bt_bitfield_write_be - write integer to a bitfield in big endian + */ + +#if (__BYTE_ORDER == __LITTLE_ENDIAN) + +#define bt_bitfield_write(ptr, type, start, length, v) \ + _bt_bitfield_write_le(ptr, type, start, length, v) + +#define bt_bitfield_write_le(ptr, type, start, length, v) \ + _bt_bitfield_write_le(ptr, type, start, length, v) + +#define bt_bitfield_write_be(ptr, type, start, length, v) \ + _bt_bitfield_write_be(ptr, unsigned char, start, length, v) + +#elif (__BYTE_ORDER == __BIG_ENDIAN) + +#define bt_bitfield_write(ptr, type, start, length, v) \ + _bt_bitfield_write_be(ptr, type, start, length, v) + +#define bt_bitfield_write_le(ptr, type, start, length, v) \ + _bt_bitfield_write_le(ptr, unsigned char, start, length, v) + +#define bt_bitfield_write_be(ptr, type, start, length, v) \ + _bt_bitfield_write_be(ptr, type, start, length, v) + +#else /* (__BYTE_ORDER == __PDP_ENDIAN) */ + +#error "Byte order not supported" + +#endif + +#define _bt_bitfield_read_le(ptr, type, start, length, vptr) \ +do { \ + __typeof__(*(vptr)) *_vptr = (vptr); \ + __typeof__(*_vptr) _v; \ + type *_ptr = (type *) (ptr); \ + unsigned long _start = (start), _length = (length); \ + type _mask, _cmask; \ + unsigned long _ts = sizeof(type) * CHAR_BIT; /* type size */ \ + unsigned long _start_unit, _end_unit, _this_unit; \ + unsigned long _end, _cshift; /* _cshift is "complement shift" */ \ + bool _is_signed_type; \ + \ + if (!_length) { \ + *_vptr = 0; \ + break; \ + } \ + \ + _end = _start + _length; \ + _start_unit = _start / _ts; \ + _end_unit = (_end + (_ts - 1)) / _ts; \ + \ + _this_unit = _end_unit - 1; \ + _BT_DIAG_PUSH \ + _BT_DIAG_IGNORE_TYPE_LIMITS \ + _is_signed_type = _bt_is_signed_type(__typeof__(_v)); \ + _BT_DIAG_POP \ + if (_is_signed_type \ + && (_ptr[_this_unit] & _bt_lshift((type) 1, (_end % _ts ? _end % _ts : _ts) - 1))) \ + _v = ~(__typeof__(_v)) 0; \ + else \ + _v = 0; \ + if (_start_unit == _end_unit - 1) { \ + _cmask = _ptr[_this_unit]; \ + _cmask = _bt_rshift(_cmask, _start % _ts); \ + if ((_end - _start) % _ts) { \ + _mask = _bt_make_mask(type, _end - _start); \ + _cmask &= _mask; \ + } \ + _bt_safe_lshift(_v, _end - _start); \ + _v |= _bt_cast_value_to_unsigned_type(__typeof__(_v), _cmask); \ + *_vptr = _v; \ + break; \ + } \ + if (_end % _ts) { \ + _cshift = _end % _ts; \ + _mask = _bt_make_mask(type, _cshift); \ + _cmask = _ptr[_this_unit]; \ + _cmask &= _mask; \ + _bt_safe_lshift(_v, _cshift); \ + _v |= _bt_cast_value_to_unsigned_type(__typeof__(_v), _cmask); \ + _end -= _cshift; \ + _this_unit--; \ + } \ + for (; (long) _this_unit >= (long) _start_unit + 1; _this_unit--) { \ + _bt_safe_lshift(_v, _ts); \ + _v |= _bt_cast_value_to_unsigned_type(__typeof__(_v), _ptr[_this_unit]); \ + _end -= _ts; \ + } \ + if (_start % _ts) { \ + _mask = _bt_make_mask(type, _ts - (_start % _ts)); \ + _cmask = _ptr[_this_unit]; \ + _cmask = _bt_rshift(_cmask, _start % _ts); \ + _cmask &= _mask; \ + _bt_safe_lshift(_v, _ts - (_start % _ts)); \ + _v |= _bt_cast_value_to_unsigned_type(__typeof__(_v), _cmask); \ + } else { \ + _bt_safe_lshift(_v, _ts); \ + _v |= _bt_cast_value_to_unsigned_type(__typeof__(_v), _ptr[_this_unit]); \ + } \ + *_vptr = _v; \ +} while (0) + +#define _bt_bitfield_read_be(ptr, type, start, length, vptr) \ +do { \ + __typeof__(*(vptr)) *_vptr = (vptr); \ + __typeof__(*_vptr) _v; \ + type *_ptr = (void *) (ptr); \ + unsigned long _start = (start), _length = (length); \ + type _mask, _cmask; \ + unsigned long _ts = sizeof(type) * CHAR_BIT; /* type size */ \ + unsigned long _start_unit, _end_unit, _this_unit; \ + unsigned long _end, _cshift; /* _cshift is "complement shift" */ \ + bool _is_signed_type; \ + \ + if (!_length) { \ + *_vptr = 0; \ + break; \ + } \ + \ + _end = _start + _length; \ + _start_unit = _start / _ts; \ + _end_unit = (_end + (_ts - 1)) / _ts; \ + \ + _this_unit = _start_unit; \ + _BT_DIAG_PUSH \ + _BT_DIAG_IGNORE_TYPE_LIMITS \ + _is_signed_type = _bt_is_signed_type(__typeof__(_v)); \ + _BT_DIAG_POP \ + if (_is_signed_type \ + && (_ptr[_this_unit] & _bt_lshift((type) 1, _ts - (_start % _ts) - 1))) \ + _v = ~(__typeof__(_v)) 0; \ + else \ + _v = 0; \ + if (_start_unit == _end_unit - 1) { \ + _cmask = _ptr[_this_unit]; \ + _cmask = _bt_rshift(_cmask, (_ts - (_end % _ts)) % _ts); \ + if ((_end - _start) % _ts) { \ + _mask = _bt_make_mask(type, _end - _start); \ + _cmask &= _mask; \ + } \ + _bt_safe_lshift(_v, _end - _start); \ + _v |= _bt_cast_value_to_unsigned_type(__typeof__(_v), _cmask); \ + *_vptr = _v; \ + break; \ + } \ + if (_start % _ts) { \ + _cshift = _start % _ts; \ + _mask = _bt_make_mask(type, _ts - _cshift); \ + _cmask = _ptr[_this_unit]; \ + _cmask &= _mask; \ + _bt_safe_lshift(_v, _ts - _cshift); \ + _v |= _bt_cast_value_to_unsigned_type(__typeof__(_v), _cmask); \ + _start += _ts - _cshift; \ + _this_unit++; \ + } \ + for (; _this_unit < _end_unit - 1; _this_unit++) { \ + _bt_safe_lshift(_v, _ts); \ + _v |= _bt_cast_value_to_unsigned_type(__typeof__(_v), _ptr[_this_unit]); \ + _start += _ts; \ + } \ + if (_end % _ts) { \ + _mask = _bt_make_mask(type, _end % _ts); \ + _cmask = _ptr[_this_unit]; \ + _cmask = _bt_rshift(_cmask, _ts - (_end % _ts)); \ + _cmask &= _mask; \ + _bt_safe_lshift(_v, _end % _ts); \ + _v |= _bt_cast_value_to_unsigned_type(__typeof__(_v), _cmask); \ + } else { \ + _bt_safe_lshift(_v, _ts); \ + _v |= _bt_cast_value_to_unsigned_type(__typeof__(_v), _ptr[_this_unit]); \ + } \ + *_vptr = _v; \ +} while (0) + +/* + * bt_bitfield_read - read integer from a bitfield in native endianness + * bt_bitfield_read_le - read integer from a bitfield in little endian + * bt_bitfield_read_be - read integer from a bitfield in big endian + */ + +#if (__BYTE_ORDER == __LITTLE_ENDIAN) + +#define bt_bitfield_read(ptr, type, start, length, vptr) \ + _bt_bitfield_read_le(ptr, type, start, length, vptr) + +#define bt_bitfield_read_le(ptr, type, start, length, vptr) \ + _bt_bitfield_read_le(ptr, type, start, length, vptr) + +#define bt_bitfield_read_be(ptr, type, start, length, vptr) \ + _bt_bitfield_read_be(ptr, unsigned char, start, length, vptr) + +#elif (__BYTE_ORDER == __BIG_ENDIAN) + +#define bt_bitfield_read(ptr, type, start, length, vptr) \ + _bt_bitfield_read_be(ptr, type, start, length, vptr) + +#define bt_bitfield_read_le(ptr, type, start, length, vptr) \ + _bt_bitfield_read_le(ptr, unsigned char, start, length, vptr) + +#define bt_bitfield_read_be(ptr, type, start, length, vptr) \ + _bt_bitfield_read_be(ptr, type, start, length, vptr) + +#else /* (__BYTE_ORDER == __PDP_ENDIAN) */ + +#error "Byte order not supported" + +#endif + +#endif /* _BABELTRACE_BITFIELD_H */ diff --git a/include/lttng/bug.h b/include/lttng/bug.h new file mode 100644 index 00000000..0a2c5e4b --- /dev/null +++ b/include/lttng/bug.h @@ -0,0 +1,28 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) + * + * lttng/bug.h + * + * Copyright (C) 2010-2012 Mathieu Desnoyers + */ + +#ifndef _LTTNG_BUG_H +#define _LTTNG_BUG_H + +/** + * BUILD_RUNTIME_BUG_ON - check condition at build (if constant) or runtime + * @condition: the condition which should be false. + * + * If the condition is a constant and true, the compiler will generate a build + * error. If the condition is not constant, a BUG will be triggered at runtime + * if the condition is ever true. If the condition is constant and false, no + * code is emitted. + */ +#define BUILD_RUNTIME_BUG_ON(condition) \ + do { \ + if (__builtin_constant_p(condition)) \ + BUILD_BUG_ON(condition); \ + else \ + BUG_ON(condition); \ + } while (0) + +#endif diff --git a/include/lttng/define_trace.h b/include/lttng/define_trace.h new file mode 100644 index 00000000..a97a66ab --- /dev/null +++ b/include/lttng/define_trace.h @@ -0,0 +1,121 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) + * + * define_trace.h + * + * Copyright (C) 2009 Steven Rostedt + * Copyright (C) 2010-2012 Mathieu Desnoyers + */ + +/* + * Trace files that want to automate creationg of all tracepoints defined + * in their file should include this file. The following are macros that the + * trace file may define: + * + * TRACE_SYSTEM defines the system the tracepoint is for + * + * TRACE_INCLUDE_FILE if the file name is something other than TRACE_SYSTEM.h + * This macro may be defined to tell define_trace.h what file to include. + * Note, leave off the ".h". + * + * TRACE_INCLUDE_PATH if the path is something other than core kernel include/trace + * then this macro can define the path to use. Note, the path is relative to + * define_trace.h, not the file including it. Full path names for out of tree + * modules must be used. + */ + +#ifdef CREATE_TRACE_POINTS + +/* Prevent recursion */ +#undef CREATE_TRACE_POINTS + +#include + +#undef LTTNG_TRACEPOINT_EVENT_MAP +#define LTTNG_TRACEPOINT_EVENT_MAP(name, map, proto, args, fields) + +#undef LTTNG_TRACEPOINT_EVENT_MAP_NOARGS +#define LTTNG_TRACEPOINT_EVENT_MAP_NOARGS(name, map, fields) + +#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP +#define LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(template, name, map, proto, args) + +#undef LTTNG_TRACEPOINT_EVENT +#define LTTNG_TRACEPOINT_EVENT(name, proto, args, fields) + +#undef LTTNG_TRACEPOINT_EVENT_CODE +#define LTTNG_TRACEPOINT_EVENT_CODE(name, proto, args, _locvar, _code_pre, fields, _code_post) + +#undef LTTNG_TRACEPOINT_EVENT_CODE_MAP +#define LTTNG_TRACEPOINT_EVENT_CODE_MAP(name, map, proto, args, _locvar, _code_pre, fields, _code_post) + +#undef LTTNG_TRACEPOINT_EVENT_INSTANCE +#define LTTNG_TRACEPOINT_EVENT_INSTANCE(template, name, proto, args) + +#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS +#define LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(template, name) + +#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS +#define LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS(template, name, map) + +#undef TRACE_INCLUDE +#undef __TRACE_INCLUDE + +#ifndef TRACE_INCLUDE_FILE +# define TRACE_INCLUDE_FILE TRACE_SYSTEM +# define UNDEF_TRACE_INCLUDE_FILE +#endif + +#ifndef TRACE_INCLUDE_PATH +# define __TRACE_INCLUDE(system) +# define UNDEF_TRACE_INCLUDE_PATH +#else +# define __TRACE_INCLUDE(system) __stringify(TRACE_INCLUDE_PATH/system.h) +#endif + +# define TRACE_INCLUDE(system) __TRACE_INCLUDE(system) + +/* Let the trace headers be reread */ +#define TRACE_HEADER_MULTI_READ + +#include TRACE_INCLUDE(TRACE_INCLUDE_FILE) + +/* Make all open coded DECLARE_TRACE nops */ +#undef DECLARE_TRACE +#define DECLARE_TRACE(name, proto, args) + +#ifdef LTTNG_PACKAGE_BUILD +#include +#endif + +#undef LTTNG_TRACEPOINT_EVENT +#undef LTTNG_TRACEPOINT_EVENT_INSTANCE +#undef LTTNG_TRACEPOINT_EVENT_MAP +#undef LTTNG_TRACEPOINT_EVENT_CLASS +#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP +#undef LTTNG_TRACEPOINT_EVENT_CODE_MAP +#undef LTTNG_TRACEPOINT_EVENT_CODE +#undef LTTNG_TRACEPOINT_EVENT_MAP_NOARGS +#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS +#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS +#undef TRACE_HEADER_MULTI_READ + +/* Only undef what we defined in this file */ +#ifdef UNDEF_TRACE_INCLUDE_FILE +# undef TRACE_INCLUDE_FILE +# undef UNDEF_TRACE_INCLUDE_FILE +#endif + +#ifdef UNDEF_TRACE_INCLUDE_PATH +# undef TRACE_INCLUDE_PATH +# undef UNDEF_TRACE_INCLUDE_PATH +#endif + +/* + * We want to re-include lttng-tracepoint-event.h for a following probe. + */ +#undef LTTNG_TRACEPOINT_EVENT_H + +/* We may be processing more files */ +#define CREATE_TRACE_POINTS + +#endif /* CREATE_TRACE_POINTS */ diff --git a/include/lttng/filter-bytecode.h b/include/lttng/filter-bytecode.h new file mode 100644 index 00000000..65d34f02 --- /dev/null +++ b/include/lttng/filter-bytecode.h @@ -0,0 +1,225 @@ +/* SPDX-License-Identifier: MIT + * + * filter-bytecode.h + * + * LTTng filter bytecode + * + * Copyright 2012-2016 - Mathieu Desnoyers + */ + +#ifndef _FILTER_BYTECODE_H +#define _FILTER_BYTECODE_H + +/* + * offsets are absolute from start of bytecode. + */ + +struct field_ref { + /* Initially, symbol offset. After link, field offset. */ + uint16_t offset; +} __attribute__((packed)); + +struct get_symbol { + /* Symbol offset. */ + uint16_t offset; +} __attribute__((packed)); + +struct get_index_u16 { + uint16_t index; +} __attribute__((packed)); + +struct get_index_u64 { + uint64_t index; +} __attribute__((packed)); + +struct literal_numeric { + int64_t v; +} __attribute__((packed)); + +struct literal_double { + double v; +} __attribute__((packed)); + +struct literal_string { + char string[0]; +} __attribute__((packed)); + +enum filter_op { + FILTER_OP_UNKNOWN = 0, + + FILTER_OP_RETURN = 1, + + /* binary */ + FILTER_OP_MUL = 2, + FILTER_OP_DIV = 3, + FILTER_OP_MOD = 4, + FILTER_OP_PLUS = 5, + FILTER_OP_MINUS = 6, + FILTER_OP_BIT_RSHIFT = 7, + FILTER_OP_BIT_LSHIFT = 8, + FILTER_OP_BIT_AND = 9, + FILTER_OP_BIT_OR = 10, + FILTER_OP_BIT_XOR = 11, + + /* binary comparators */ + FILTER_OP_EQ = 12, + FILTER_OP_NE = 13, + FILTER_OP_GT = 14, + FILTER_OP_LT = 15, + FILTER_OP_GE = 16, + FILTER_OP_LE = 17, + + /* string binary comparator: apply to */ + FILTER_OP_EQ_STRING = 18, + FILTER_OP_NE_STRING = 19, + FILTER_OP_GT_STRING = 20, + FILTER_OP_LT_STRING = 21, + FILTER_OP_GE_STRING = 22, + FILTER_OP_LE_STRING = 23, + + /* s64 binary comparator */ + FILTER_OP_EQ_S64 = 24, + FILTER_OP_NE_S64 = 25, + FILTER_OP_GT_S64 = 26, + FILTER_OP_LT_S64 = 27, + FILTER_OP_GE_S64 = 28, + FILTER_OP_LE_S64 = 29, + + /* double binary comparator */ + FILTER_OP_EQ_DOUBLE = 30, + FILTER_OP_NE_DOUBLE = 31, + FILTER_OP_GT_DOUBLE = 32, + FILTER_OP_LT_DOUBLE = 33, + FILTER_OP_GE_DOUBLE = 34, + FILTER_OP_LE_DOUBLE = 35, + + /* Mixed S64-double binary comparators */ + FILTER_OP_EQ_DOUBLE_S64 = 36, + FILTER_OP_NE_DOUBLE_S64 = 37, + FILTER_OP_GT_DOUBLE_S64 = 38, + FILTER_OP_LT_DOUBLE_S64 = 39, + FILTER_OP_GE_DOUBLE_S64 = 40, + FILTER_OP_LE_DOUBLE_S64 = 41, + + FILTER_OP_EQ_S64_DOUBLE = 42, + FILTER_OP_NE_S64_DOUBLE = 43, + FILTER_OP_GT_S64_DOUBLE = 44, + FILTER_OP_LT_S64_DOUBLE = 45, + FILTER_OP_GE_S64_DOUBLE = 46, + FILTER_OP_LE_S64_DOUBLE = 47, + + /* unary */ + FILTER_OP_UNARY_PLUS = 48, + FILTER_OP_UNARY_MINUS = 49, + FILTER_OP_UNARY_NOT = 50, + FILTER_OP_UNARY_PLUS_S64 = 51, + FILTER_OP_UNARY_MINUS_S64 = 52, + FILTER_OP_UNARY_NOT_S64 = 53, + FILTER_OP_UNARY_PLUS_DOUBLE = 54, + FILTER_OP_UNARY_MINUS_DOUBLE = 55, + FILTER_OP_UNARY_NOT_DOUBLE = 56, + + /* logical */ + FILTER_OP_AND = 57, + FILTER_OP_OR = 58, + + /* load field ref */ + FILTER_OP_LOAD_FIELD_REF = 59, + FILTER_OP_LOAD_FIELD_REF_STRING = 60, + FILTER_OP_LOAD_FIELD_REF_SEQUENCE = 61, + FILTER_OP_LOAD_FIELD_REF_S64 = 62, + FILTER_OP_LOAD_FIELD_REF_DOUBLE = 63, + + /* load immediate from operand */ + FILTER_OP_LOAD_STRING = 64, + FILTER_OP_LOAD_S64 = 65, + FILTER_OP_LOAD_DOUBLE = 66, + + /* cast */ + FILTER_OP_CAST_TO_S64 = 67, + FILTER_OP_CAST_DOUBLE_TO_S64 = 68, + FILTER_OP_CAST_NOP = 69, + + /* get context ref */ + FILTER_OP_GET_CONTEXT_REF = 70, + FILTER_OP_GET_CONTEXT_REF_STRING = 71, + FILTER_OP_GET_CONTEXT_REF_S64 = 72, + FILTER_OP_GET_CONTEXT_REF_DOUBLE = 73, + + /* load userspace field ref */ + FILTER_OP_LOAD_FIELD_REF_USER_STRING = 74, + FILTER_OP_LOAD_FIELD_REF_USER_SEQUENCE = 75, + + /* + * load immediate star globbing pattern (literal string) + * from immediate + */ + FILTER_OP_LOAD_STAR_GLOB_STRING = 76, + + /* globbing pattern binary operator: apply to */ + FILTER_OP_EQ_STAR_GLOB_STRING = 77, + FILTER_OP_NE_STAR_GLOB_STRING = 78, + + /* + * Instructions for recursive traversal through composed types. + */ + FILTER_OP_GET_CONTEXT_ROOT = 79, + FILTER_OP_GET_APP_CONTEXT_ROOT = 80, + FILTER_OP_GET_PAYLOAD_ROOT = 81, + + FILTER_OP_GET_SYMBOL = 82, + FILTER_OP_GET_SYMBOL_FIELD = 83, + FILTER_OP_GET_INDEX_U16 = 84, + FILTER_OP_GET_INDEX_U64 = 85, + + FILTER_OP_LOAD_FIELD = 86, + FILTER_OP_LOAD_FIELD_S8 = 87, + FILTER_OP_LOAD_FIELD_S16 = 88, + FILTER_OP_LOAD_FIELD_S32 = 89, + FILTER_OP_LOAD_FIELD_S64 = 90, + FILTER_OP_LOAD_FIELD_U8 = 91, + FILTER_OP_LOAD_FIELD_U16 = 92, + FILTER_OP_LOAD_FIELD_U32 = 93, + FILTER_OP_LOAD_FIELD_U64 = 94, + FILTER_OP_LOAD_FIELD_STRING = 95, + FILTER_OP_LOAD_FIELD_SEQUENCE = 96, + FILTER_OP_LOAD_FIELD_DOUBLE = 97, + + FILTER_OP_UNARY_BIT_NOT = 98, + + FILTER_OP_RETURN_S64 = 99, + + NR_FILTER_OPS, +}; + +typedef uint8_t filter_opcode_t; + +struct load_op { + filter_opcode_t op; + char data[0]; + /* data to load. Size known by enum filter_opcode and null-term char. */ +} __attribute__((packed)); + +struct binary_op { + filter_opcode_t op; +} __attribute__((packed)); + +struct unary_op { + filter_opcode_t op; +} __attribute__((packed)); + +/* skip_offset is absolute from start of bytecode */ +struct logical_op { + filter_opcode_t op; + uint16_t skip_offset; /* bytecode insn, if skip second test */ +} __attribute__((packed)); + +struct cast_op { + filter_opcode_t op; +} __attribute__((packed)); + +struct return_op { + filter_opcode_t op; +} __attribute__((packed)); + +#endif /* _FILTER_BYTECODE_H */ diff --git a/include/lttng/lttng-abi-old.h b/include/lttng/lttng-abi-old.h new file mode 100644 index 00000000..2444ca5b --- /dev/null +++ b/include/lttng/lttng-abi-old.h @@ -0,0 +1,128 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) + * + * lttng-abi-old.h + * + * LTTng old ABI header (without support for compat 32/64 bits) + * + * Copyright (C) 2010-2012 Mathieu Desnoyers + */ + +#ifndef _LTTNG_ABI_OLD_H +#define _LTTNG_ABI_OLD_H + +#include +#include + +/* + * LTTng DebugFS ABI structures. + */ +#define LTTNG_KERNEL_OLD_CHANNEL_PADDING LTTNG_KERNEL_SYM_NAME_LEN + 32 +struct lttng_kernel_old_channel { + int overwrite; /* 1: overwrite, 0: discard */ + uint64_t subbuf_size; /* in bytes */ + uint64_t num_subbuf; + unsigned int switch_timer_interval; /* usecs */ + unsigned int read_timer_interval; /* usecs */ + enum lttng_kernel_output output; /* splice, mmap */ + char padding[LTTNG_KERNEL_OLD_CHANNEL_PADDING]; +}; + +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]; +}; + +struct lttng_kernel_old_function_tracer { + char symbol_name[LTTNG_KERNEL_SYM_NAME_LEN]; +}; + +/* + * For syscall tracing, name = '\0' means "enable all". + */ +#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]; /* event name */ + 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_tracer 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) */ +}; + +struct lttng_kernel_old_perf_counter_ctx { + uint32_t type; + uint64_t config; + char name[LTTNG_KERNEL_SYM_NAME_LEN]; +}; + +#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; +}; + +/* 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) + +/* 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) + +#endif /* _LTTNG_ABI_OLD_H */ diff --git a/include/lttng/lttng-abi.h b/include/lttng/lttng-abi.h new file mode 100644 index 00000000..a26c7ee0 --- /dev/null +++ b/include/lttng/lttng-abi.h @@ -0,0 +1,354 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) + * + * lttng-abi.h + * + * LTTng ABI header + * + * Copyright (C) 2010-2012 Mathieu Desnoyers + */ + +#ifndef _LTTNG_ABI_H +#define _LTTNG_ABI_H + +#include + +/* + * Major/minor version of ABI exposed to lttng tools. Major number + * should be increased when an incompatible ABI change is done. + */ +#define LTTNG_MODULES_ABI_MAJOR_VERSION 2 +#define LTTNG_MODULES_ABI_MINOR_VERSION 5 + +#define LTTNG_KERNEL_SYM_NAME_LEN 256 +#define LTTNG_KERNEL_SESSION_NAME_LEN 256 +#define LTTNG_KERNEL_SESSION_CREATION_TIME_ISO8601_LEN 26 + +enum lttng_kernel_instrumentation { + LTTNG_KERNEL_TRACEPOINT = 0, + LTTNG_KERNEL_KPROBE = 1, + LTTNG_KERNEL_FUNCTION = 2, + LTTNG_KERNEL_KRETPROBE = 3, + LTTNG_KERNEL_NOOP = 4, /* not hooked */ + LTTNG_KERNEL_SYSCALL = 5, + LTTNG_KERNEL_UPROBE = 6, +}; + +/* + * LTTng consumer mode + */ +enum lttng_kernel_output { + LTTNG_KERNEL_SPLICE = 0, + LTTNG_KERNEL_MMAP = 1, +}; + +/* + * LTTng DebugFS ABI structures. + */ +#define LTTNG_KERNEL_CHANNEL_PADDING LTTNG_KERNEL_SYM_NAME_LEN + 32 +struct lttng_kernel_channel { + uint64_t subbuf_size; /* in bytes */ + uint64_t num_subbuf; + unsigned int switch_timer_interval; /* usecs */ + unsigned int read_timer_interval; /* usecs */ + enum lttng_kernel_output output; /* splice, mmap */ + int overwrite; /* 1: overwrite, 0: discard */ + char padding[LTTNG_KERNEL_CHANNEL_PADDING]; +} __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. + */ +struct lttng_kernel_kprobe { + uint64_t addr; + + uint64_t offset; + char symbol_name[LTTNG_KERNEL_SYM_NAME_LEN]; +} __attribute__((packed)); + +struct lttng_kernel_function_tracer { + char symbol_name[LTTNG_KERNEL_SYM_NAME_LEN]; +} __attribute__((packed)); + +struct lttng_kernel_uprobe { + int fd; +} __attribute__((packed)); + +struct lttng_kernel_event_callsite_uprobe { + uint64_t offset; +} __attribute__((packed)); + +struct lttng_kernel_event_callsite { + union { + struct lttng_kernel_event_callsite_uprobe uprobe; + } u; +} __attribute__((packed)); + +/* + * For syscall tracing, name = "*" means "enable all". + */ +#define LTTNG_KERNEL_EVENT_PADDING1 16 +#define LTTNG_KERNEL_EVENT_PADDING2 LTTNG_KERNEL_SYM_NAME_LEN + 32 +struct lttng_kernel_event { + char name[LTTNG_KERNEL_SYM_NAME_LEN]; /* event name */ + enum lttng_kernel_instrumentation instrumentation; + char padding[LTTNG_KERNEL_EVENT_PADDING1]; + + /* Per instrumentation type configuration */ + union { + struct lttng_kernel_kretprobe kretprobe; + struct lttng_kernel_kprobe kprobe; + struct lttng_kernel_function_tracer ftrace; + struct lttng_kernel_uprobe uprobe; + 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)); + +struct lttng_kernel_tracer_abi_version { + uint32_t major; + uint32_t minor; +} __attribute__((packed)); + +struct lttng_kernel_session_name { + char name[LTTNG_KERNEL_SESSION_NAME_LEN]; +} __attribute__((packed)); + +struct lttng_kernel_session_creation_time { + char iso8601[LTTNG_KERNEL_SESSION_CREATION_TIME_ISO8601_LEN]; +} __attribute__((packed)); + +enum lttng_kernel_calibrate_type { + LTTNG_KERNEL_CALIBRATE_KRETPROBE, +}; + +struct lttng_kernel_calibrate { + enum lttng_kernel_calibrate_type type; /* type (input) */ +} __attribute__((packed)); + +struct lttng_kernel_syscall_mask { + uint32_t len; /* in bits */ + char mask[]; +} __attribute__((packed)); + +enum lttng_kernel_context_type { + LTTNG_KERNEL_CONTEXT_PID = 0, + LTTNG_KERNEL_CONTEXT_PERF_COUNTER = 1, + LTTNG_KERNEL_CONTEXT_PROCNAME = 2, + LTTNG_KERNEL_CONTEXT_PRIO = 3, + LTTNG_KERNEL_CONTEXT_NICE = 4, + LTTNG_KERNEL_CONTEXT_VPID = 5, + LTTNG_KERNEL_CONTEXT_TID = 6, + LTTNG_KERNEL_CONTEXT_VTID = 7, + LTTNG_KERNEL_CONTEXT_PPID = 8, + LTTNG_KERNEL_CONTEXT_VPPID = 9, + LTTNG_KERNEL_CONTEXT_HOSTNAME = 10, + LTTNG_KERNEL_CONTEXT_CPU_ID = 11, + LTTNG_KERNEL_CONTEXT_INTERRUPTIBLE = 12, + LTTNG_KERNEL_CONTEXT_PREEMPTIBLE = 13, + LTTNG_KERNEL_CONTEXT_NEED_RESCHEDULE = 14, + LTTNG_KERNEL_CONTEXT_MIGRATABLE = 15, + LTTNG_KERNEL_CONTEXT_CALLSTACK_KERNEL = 16, + LTTNG_KERNEL_CONTEXT_CALLSTACK_USER = 17, + LTTNG_KERNEL_CONTEXT_CGROUP_NS = 18, + LTTNG_KERNEL_CONTEXT_IPC_NS = 19, + LTTNG_KERNEL_CONTEXT_MNT_NS = 20, + LTTNG_KERNEL_CONTEXT_NET_NS = 21, + LTTNG_KERNEL_CONTEXT_PID_NS = 22, + LTTNG_KERNEL_CONTEXT_USER_NS = 23, + LTTNG_KERNEL_CONTEXT_UTS_NS = 24, + LTTNG_KERNEL_CONTEXT_UID = 25, + LTTNG_KERNEL_CONTEXT_EUID = 26, + LTTNG_KERNEL_CONTEXT_SUID = 27, + LTTNG_KERNEL_CONTEXT_GID = 28, + LTTNG_KERNEL_CONTEXT_EGID = 29, + LTTNG_KERNEL_CONTEXT_SGID = 30, + LTTNG_KERNEL_CONTEXT_VUID = 31, + LTTNG_KERNEL_CONTEXT_VEUID = 32, + LTTNG_KERNEL_CONTEXT_VSUID = 33, + LTTNG_KERNEL_CONTEXT_VGID = 34, + LTTNG_KERNEL_CONTEXT_VEGID = 35, + LTTNG_KERNEL_CONTEXT_VSGID = 36, +}; + +struct lttng_kernel_perf_counter_ctx { + uint32_t type; + uint64_t config; + char name[LTTNG_KERNEL_SYM_NAME_LEN]; +} __attribute__((packed)); + +#define LTTNG_KERNEL_CONTEXT_PADDING1 16 +#define LTTNG_KERNEL_CONTEXT_PADDING2 LTTNG_KERNEL_SYM_NAME_LEN + 32 +struct lttng_kernel_context { + enum lttng_kernel_context_type ctx; + char padding[LTTNG_KERNEL_CONTEXT_PADDING1]; + + union { + struct lttng_kernel_perf_counter_ctx perf_counter; + char padding[LTTNG_KERNEL_CONTEXT_PADDING2]; + } u; +} __attribute__((packed)); + +#define LTTNG_KERNEL_FILTER_BYTECODE_MAX_LEN 65536 +struct lttng_kernel_filter_bytecode { + uint32_t len; + uint32_t reloc_offset; + uint64_t seqnum; + char data[0]; +} __attribute__((packed)); + +enum lttng_kernel_tracker_type { + LTTNG_KERNEL_TRACKER_UNKNOWN = -1, + + LTTNG_KERNEL_TRACKER_PID = 0, + LTTNG_KERNEL_TRACKER_VPID = 1, + LTTNG_KERNEL_TRACKER_UID = 2, + LTTNG_KERNEL_TRACKER_VUID = 3, + LTTNG_KERNEL_TRACKER_GID = 4, + LTTNG_KERNEL_TRACKER_VGID = 5, +}; + +struct lttng_kernel_tracker_args { + enum lttng_kernel_tracker_type type; + int32_t id; +}; + +/* LTTng file descriptor ioctl */ +/* lttng-abi-old.h reserve 0x40, 0x41, 0x42, 0x43, and 0x44. */ +#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, 0x49, struct lttng_kernel_calibrate) +#define LTTNG_KERNEL_SYSCALL_LIST _IO(0xF6, 0x4A) +#define LTTNG_KERNEL_TRACER_ABI_VERSION \ + _IOR(0xF6, 0x4B, struct lttng_kernel_tracer_abi_version) + +/* Session FD ioctl */ +/* lttng-abi-old.h reserve 0x50, 0x51, 0x52, and 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) +#define LTTNG_KERNEL_SESSION_TRACK_PID \ + _IOR(0xF6, 0x58, int32_t) +#define LTTNG_KERNEL_SESSION_UNTRACK_PID \ + _IOR(0xF6, 0x59, int32_t) + +/* + * ioctl 0x58 and 0x59 are duplicated here. It works, since _IOR vs _IO + * are generating two different ioctl numbers, but this was not done on + * purpose. We should generally try to avoid those duplications. + */ +#define LTTNG_KERNEL_SESSION_LIST_TRACKER_PIDS _IO(0xF6, 0x58) +#define LTTNG_KERNEL_SESSION_METADATA_REGEN _IO(0xF6, 0x59) + +/* lttng-abi-old.h reserve 0x5A and 0x5B. */ +#define LTTNG_KERNEL_SESSION_STATEDUMP _IO(0xF6, 0x5C) +#define LTTNG_KERNEL_SESSION_SET_NAME \ + _IOR(0xF6, 0x5D, struct lttng_kernel_session_name) +#define LTTNG_KERNEL_SESSION_SET_CREATION_TIME \ + _IOR(0xF6, 0x5E, struct lttng_kernel_session_creation_time) + +/* Channel FD ioctl */ +/* lttng-abi-old.h reserve 0x60 and 0x61. */ +#define LTTNG_KERNEL_STREAM _IO(0xF6, 0x62) +#define LTTNG_KERNEL_EVENT \ + _IOW(0xF6, 0x63, struct lttng_kernel_event) +#define LTTNG_KERNEL_SYSCALL_MASK \ + _IOWR(0xF6, 0x64, struct lttng_kernel_syscall_mask) + +/* Event and Channel FD ioctl */ +/* lttng-abi-old.h reserve 0x70. */ +#define LTTNG_KERNEL_CONTEXT \ + _IOW(0xF6, 0x71, struct lttng_kernel_context) + +/* Event, Channel and Session ioctl */ +/* lttng-abi-old.h reserve 0x80 and 0x81. */ +#define LTTNG_KERNEL_ENABLE _IO(0xF6, 0x82) +#define LTTNG_KERNEL_DISABLE _IO(0xF6, 0x83) + +/* Event FD ioctl */ +#define LTTNG_KERNEL_FILTER _IO(0xF6, 0x90) +#define LTTNG_KERNEL_ADD_CALLSITE _IO(0xF6, 0x91) + +/* Session FD ioctl (continued) */ +#define LTTNG_KERNEL_SESSION_LIST_TRACKER_IDS \ + _IOR(0xF6, 0xA0, struct lttng_kernel_tracker_args) +#define LTTNG_KERNEL_SESSION_TRACK_ID \ + _IOR(0xF6, 0xA1, struct lttng_kernel_tracker_args) +#define LTTNG_KERNEL_SESSION_UNTRACK_ID \ + _IOR(0xF6, 0xA2, struct lttng_kernel_tracker_args) + +/* + * LTTng-specific ioctls for the lib ringbuffer. + * + * Operations applying to the current sub-buffer need to occur between + * a get/put or get_next/put_next ioctl pair. + */ + +/* returns the timestamp begin of the current sub-buffer */ +#define LTTNG_RING_BUFFER_GET_TIMESTAMP_BEGIN _IOR(0xF6, 0x20, uint64_t) +/* returns the timestamp end of the current sub-buffer */ +#define LTTNG_RING_BUFFER_GET_TIMESTAMP_END _IOR(0xF6, 0x21, uint64_t) +/* returns the number of events discarded of the current sub-buffer */ +#define LTTNG_RING_BUFFER_GET_EVENTS_DISCARDED _IOR(0xF6, 0x22, uint64_t) +/* returns the packet payload size of the current sub-buffer */ +#define LTTNG_RING_BUFFER_GET_CONTENT_SIZE _IOR(0xF6, 0x23, uint64_t) +/* returns the packet size of the current sub-buffer*/ +#define LTTNG_RING_BUFFER_GET_PACKET_SIZE _IOR(0xF6, 0x24, uint64_t) +/* returns the stream id (invariant for the stream) */ +#define LTTNG_RING_BUFFER_GET_STREAM_ID _IOR(0xF6, 0x25, uint64_t) +/* returns the current timestamp as perceived from the tracer */ +#define LTTNG_RING_BUFFER_GET_CURRENT_TIMESTAMP _IOR(0xF6, 0x26, uint64_t) +/* returns the packet sequence number of the current sub-buffer */ +#define LTTNG_RING_BUFFER_GET_SEQ_NUM _IOR(0xF6, 0x27, uint64_t) +/* returns the stream instance id (invariant for the stream) */ +#define LTTNG_RING_BUFFER_INSTANCE_ID _IOR(0xF6, 0x28, uint64_t) + +#ifdef CONFIG_COMPAT +/* returns the timestamp begin of the current sub-buffer */ +#define LTTNG_RING_BUFFER_COMPAT_GET_TIMESTAMP_BEGIN \ + LTTNG_RING_BUFFER_GET_TIMESTAMP_BEGIN +/* returns the timestamp end of the current sub-buffer */ +#define LTTNG_RING_BUFFER_COMPAT_GET_TIMESTAMP_END \ + LTTNG_RING_BUFFER_GET_TIMESTAMP_END +/* returns the number of events discarded of the current sub-buffer */ +#define LTTNG_RING_BUFFER_COMPAT_GET_EVENTS_DISCARDED \ + LTTNG_RING_BUFFER_GET_EVENTS_DISCARDED +/* returns the packet payload size of the current sub-buffer */ +#define LTTNG_RING_BUFFER_COMPAT_GET_CONTENT_SIZE \ + LTTNG_RING_BUFFER_GET_CONTENT_SIZE +/* returns the packet size of the current sub-buffer */ +#define LTTNG_RING_BUFFER_COMPAT_GET_PACKET_SIZE \ + LTTNG_RING_BUFFER_GET_PACKET_SIZE +/* returns the stream id (invariant for the stream) */ +#define LTTNG_RING_BUFFER_COMPAT_GET_STREAM_ID \ + LTTNG_RING_BUFFER_GET_STREAM_ID +/* returns the current timestamp as perceived from the tracer */ +#define LTTNG_RING_BUFFER_COMPAT_GET_CURRENT_TIMESTAMP \ + LTTNG_RING_BUFFER_GET_CURRENT_TIMESTAMP +/* returns the packet sequence number of the current sub-buffer */ +#define LTTNG_RING_BUFFER_COMPAT_GET_SEQ_NUM \ + LTTNG_RING_BUFFER_GET_SEQ_NUM +/* returns the stream instance id (invariant for the stream) */ +#define LTTNG_RING_BUFFER_COMPAT_INSTANCE_ID \ + LTTNG_RING_BUFFER_INSTANCE_ID +#endif /* CONFIG_COMPAT */ + +#endif /* _LTTNG_ABI_H */ diff --git a/include/lttng/lttng-clock.h b/include/lttng/lttng-clock.h new file mode 100644 index 00000000..cac3c72e --- /dev/null +++ b/include/lttng/lttng-clock.h @@ -0,0 +1,28 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) + * + * lttng-clock.h + * + * Copyright (C) 2014 Mathieu Desnoyers + */ + +#ifndef _LTTNG_CLOCK_H +#define _LTTNG_CLOCK_H + +#include + +#define LTTNG_MODULES_UUID_STR_LEN 37 + +struct lttng_trace_clock { + u64 (*read64)(void); + u64 (*freq)(void); + int (*uuid)(char *uuid); + const char *(*name)(void); + const char *(*description)(void); +}; + +int lttng_clock_register_plugin(struct lttng_trace_clock *ltc, + struct module *mod); +void lttng_clock_unregister_plugin(struct lttng_trace_clock *ltc, + struct module *mod); + +#endif /* _LTTNG_TRACE_CLOCK_H */ diff --git a/include/lttng/lttng-cpuhotplug.h b/include/lttng/lttng-cpuhotplug.h new file mode 100644 index 00000000..0de6f88f --- /dev/null +++ b/include/lttng/lttng-cpuhotplug.h @@ -0,0 +1,48 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) + * + * lttng-cpuhotplug.h + * + * Copyright (C) 2016 Mathieu Desnoyers + */ + +#ifndef LTTNG_CPUHOTPLUG_H +#define LTTNG_CPUHOTPLUG_H + +struct lttng_cpuhp_node; + +#include + +enum lttng_cpuhp_component { + LTTNG_RING_BUFFER_FRONTEND, + LTTNG_RING_BUFFER_BACKEND, + LTTNG_RING_BUFFER_ITER, + LTTNG_CONTEXT_PERF_COUNTERS, +}; + +struct lttng_cpuhp_node { + enum lttng_cpuhp_component component; + struct hlist_node node; +}; + +extern enum cpuhp_state lttng_hp_prepare; +extern enum cpuhp_state lttng_hp_online; + +int lttng_cpuhp_rb_backend_prepare(unsigned int cpu, + struct lttng_cpuhp_node *node); +int lttng_cpuhp_rb_frontend_dead(unsigned int cpu, + struct lttng_cpuhp_node *node); +int lttng_cpuhp_rb_frontend_online(unsigned int cpu, + struct lttng_cpuhp_node *node); +int lttng_cpuhp_rb_frontend_offline(unsigned int cpu, + struct lttng_cpuhp_node *node); +int lttng_cpuhp_rb_iter_online(unsigned int cpu, + struct lttng_cpuhp_node *node); + +/* Ring buffer is a separate library. */ +void lttng_rb_set_hp_prepare(enum cpuhp_state val); +void lttng_rb_set_hp_online(enum cpuhp_state val); + +extern enum cpuhp_state lttng_rb_hp_prepare; +extern enum cpuhp_state lttng_rb_hp_online; + +#endif /* LTTNG_CPUHOTPLUG_H */ diff --git a/include/lttng/lttng-endian.h b/include/lttng/lttng-endian.h new file mode 100644 index 00000000..12f55d17 --- /dev/null +++ b/include/lttng/lttng-endian.h @@ -0,0 +1,30 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ +#ifndef _LTTNG_ENDIAN_H +#define _LTTNG_ENDIAN_H + +/* + * lttng-endian.h + * + * Copyright (C) 2010-2012 Mathieu Desnoyers + */ + +#ifdef __KERNEL__ +# include +# ifdef __BIG_ENDIAN +# define __BYTE_ORDER __BIG_ENDIAN +# elif defined(__LITTLE_ENDIAN) +# define __BYTE_ORDER __LITTLE_ENDIAN +# else +# error "unknown endianness" +# endif +#ifndef __BIG_ENDIAN +# define __BIG_ENDIAN 4321 +#endif +#ifndef __LITTLE_ENDIAN +# define __LITTLE_ENDIAN 1234 +#endif +#else +# include +#endif + +#endif /* _LTTNG_ENDIAN_H */ diff --git a/include/lttng/lttng-events-nowrite.h b/include/lttng/lttng-events-nowrite.h new file mode 100644 index 00000000..5f6b64c7 --- /dev/null +++ b/include/lttng/lttng-events-nowrite.h @@ -0,0 +1,137 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) + * + * lttng-events-write.h + * + * Copyright (C) 2014 Mathieu Desnoyers + */ + +#undef ctf_integer_nowrite +#define ctf_integer_nowrite(_type, _item, _user_src) \ + _ctf_integer_ext(_type, _item, _user_src, __BYTE_ORDER, 10, 0, 1) + +#undef ctf_integer_hex_nowrite +#define ctf_integer_hex_nowrite(_type, _item, _user_src) \ + _ctf_integer_ext(_type, _item, _user_src, __BYTE_ORDER, 16, 0, 1) + +#undef ctf_integer_oct_nowrite +#define ctf_integer_oct_nowrite(_type, _item, _user_src) \ + _ctf_integer_ext(_type, _item, _user_src, __BYTE_ORDER, 8, 0, 1) + +#undef ctf_integer_network_nowrite +#define ctf_integer_network_nowrite(_type, _item, _user_src) \ + _ctf_integer_ext(_type, _item, _user_src, __BIG_ENDIAN, 10, 0, 1) + +#undef ctf_integer_network_hex_nowrite +#define ctf_integer_network_hex_nowrite(_type, _item, _user_src) \ + _ctf_integer_ext(_type, _item, _user_src, __BIG_ENDIAN, 16, 0, 1) + +#undef ctf_array_nowrite +#define ctf_array_nowrite(_type, _item, _src, _length) \ + _ctf_array_encoded(_type, _item, _src, \ + _length, none, __BYTE_ORDER, 10, 0, 1) + +#undef ctf_array_network_nowrite +#define ctf_array_network_nowrite(_type, _item, _src, _length) \ + _ctf_array_encoded(_type, _item, _src, \ + _length, none, __BIG_ENDIAN, 10, 0, 1) + +#undef ctf_array_text_nowrite +#define ctf_array_text_nowrite(_type, _item, _src, _length) \ + _ctf_array_encoded(_type, _item, _src, \ + _length, UTF8, __BYTE_ORDER, 10, 0, 1) + +#undef ctf_array_bitfield_nowrite +#define ctf_array_bitfield_nowrite(_type, _item, _src, _length) \ + _ctf_array_bitfield(_type, _item, _src, _length, 0, 1) + +#undef ctf_sequence_nowrite +#define ctf_sequence_nowrite(_type, _item, _user_src, _length_type, _user_src_length) \ + _ctf_sequence_encoded(_type, _item, _user_src, \ + _length_type, _user_src_length, none, __BYTE_ORDER, 10, 0, 1) + +#undef ctf_sequence_network_nowrite +#define ctf_sequence_network_nowrite(_type, _item, _user_src, _length_type, _user_src_length) \ + _ctf_sequence_encoded(_type, _item, _user_src, \ + _length_type, _user_src_length, none, __BIG_ENDIAN, 10, 0, 1) + +#undef ctf_sequence_text_nowrite +#define ctf_sequence_text_nowrite(_type, _item, _user_src, _length_type, _user_src_length) \ + _ctf_sequence_encoded(_type, _item, _user_src, \ + _length_type, _user_src_length, UTF8, __BYTE_ORDER, 10, 0, 1) + +#undef ctf_sequence_bitfield_nowrite +#define ctf_sequence_bitfield_nowrite(_type, _item, _src, _length_type, _src_length) \ + _ctf_sequence_bitfield(_type, _item, _src, \ + _length_type, _src_length, 0, 1) + +#undef ctf_string_nowrite +#define ctf_string_nowrite(_item, _user_src) \ + _ctf_string(_item, _user_src, 0, 1) + +#undef ctf_enum_nowrite +#define ctf_enum_nowrite(_name, _type, _item, _src) \ + _ctf_enum(_name, _type, _item, _src, 0, 1) + +/* user src */ +#undef ctf_user_integer_nowrite +#define ctf_user_integer_nowrite(_type, _item, _user_src) \ + _ctf_integer_ext(_type, _item, _user_src, __BYTE_ORDER, 10, 1, 1) + +#undef ctf_user_integer_hex_nowrite +#define ctf_user_integer_hex_nowrite(_type, _item, _user_src) \ + _ctf_integer_ext(_type, _item, _user_src, __BYTE_ORDER, 16, 1, 1) + +#undef ctf_user_integer_network_nowrite +#define ctf_user_integer_network_nowrite(_type, _item, _user_src) \ + _ctf_integer_ext(_type, _item, _user_src, __BIG_ENDIAN, 10, 1, 1) + +#undef ctf_user_integer_network_hex_nowrite +#define ctf_user_integer_network_hex_nowrite(_type, _item, _user_src) \ + _ctf_integer_ext(_type, _item, _user_src, __BIG_ENDIAN, 16, 1, 1) + +#undef ctf_user_array_nowrite +#define ctf_user_array_nowrite(_type, _item, _src, _length) \ + _ctf_array_encoded(_type, _item, _src, \ + _length, none, __BYTE_ORDER, 10, 1, 1) + +#undef ctf_user_array_network_nowrite +#define ctf_user_array_network_nowrite(_type, _item, _src, _length) \ + _ctf_array_encoded(_type, _item, _src, \ + _length, none, __BIG_ENDIAN, 10, 1, 1) + +#undef ctf_user_array_text_nowrite +#define ctf_user_array_text_nowrite(_type, _item, _src, _length) \ + _ctf_array_encoded(_type, _item, _src, \ + _length, UTF8, __BYTE_ORDER, 10, 1, 1) + +#undef ctf_user_array_bitfield_nowrite +#define ctf_user_array_bitfield_nowrite(_type, _item, _src, _length) \ + _ctf_array_bitfield(_type, _item, _src, _length, 1, 1) + +#undef ctf_user_sequence_nowrite +#define ctf_user_sequence_nowrite(_type, _item, _user_src, _length_type, _user_src_length) \ + _ctf_sequence_encoded(_type, _item, _user_src, \ + _length_type, _user_src_length, none, __BYTE_ORDER, 10, 1, 1) + +#undef ctf_user_sequence_network_nowrite +#define ctf_user_sequence_network_nowrite(_type, _item, _user_src, _length_type, _user_src_length) \ + _ctf_sequence_encoded(_type, _item, _user_src, \ + _length_type, _user_src_length, none, __BIG_ENDIAN, 10, 1, 1) + +#undef ctf_user_sequence_text_nowrite +#define ctf_user_sequence_text_nowrite(_type, _item, _user_src, _length_type, _user_src_length) \ + _ctf_sequence_encoded(_type, _item, _user_src, \ + _length_type, _user_src_length, UTF8, __BYTE_ORDER, 10, 1, 1) + +#undef ctf_user_sequence_bitfield_nowrite +#define ctf_user_sequence_bitfield_nowrite(_type, _item, _src, _length_type, _src_length) \ + _ctf_sequence_bitfield(_type, _item, _src, \ + _length_type, _src_length, 1, 1) + +#undef ctf_user_string_nowrite +#define ctf_user_string_nowrite(_item, _user_src) \ + _ctf_string(_item, _user_src, 1, 1) + +#undef ctf_user_enum_nowrite +#define ctf_user_enum_nowrite(_name, _type, _item, _src) \ + _ctf_enum(_name, _type, _item, _src, 1, 1) diff --git a/include/lttng/lttng-events-reset.h b/include/lttng/lttng-events-reset.h new file mode 100644 index 00000000..91ddab48 --- /dev/null +++ b/include/lttng/lttng-events-reset.h @@ -0,0 +1,283 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) + * + * lttng-events-reset.h + * + * Copyright (C) 2010-2012 Mathieu Desnoyers + */ + +/* Reset macros used within LTTNG_TRACEPOINT_EVENT to "nothing" */ + +#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE +#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE(_name, _proto, _args, _locvar, _code_pre, _fields, _code_post) + +#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS +#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS(_name, _locvar, _code_pre, _fields, _code_post) + +#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP +#define LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(_template, _name, _map, _proto, _args) + +#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS +#define LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS(_template, _name, _map) + +#undef LTTNG_TRACEPOINT_ENUM +#define LTTNG_TRACEPOINT_ENUM(_name, _values) + +#undef TP_PROTO +#define TP_PROTO(args...) + +#undef TP_ARGS +#define TP_ARGS(args...) + +#undef TP_locvar +#define TP_locvar(...) + +#undef TP_code_pre +#define TP_code_pre(...) + +#undef TP_code_post +#define TP_code_post(...) + +#undef TP_FIELDS +#define TP_FIELDS(args...) + +#undef _ctf_integer_ext +#define _ctf_integer_ext(_type, _item, _src, _byte_order, _base, \ + _user, _nowrite) + +#undef _ctf_integer_ext_isuser0 +#define _ctf_integer_ext_isuser0(_type, _item, _src, _byte_order, _base, \ + _nowrite) + +#undef _ctf_integer_ext_isuser1 +#define _ctf_integer_ext_isuser1(_type, _item, _src, _byte_order, _base, \ + _nowrite) + +#undef _ctf_integer_ext_fetched +#define _ctf_integer_ext_fetched(_type, _item, _src, _byte_order, _base, \ + _nowrite) + +#undef _ctf_array_encoded +#define _ctf_array_encoded(_type, _item, _src, _length, _encoding, \ + _byte_order, _base, _user, _nowrite) + +#undef _ctf_array_bitfield +#define _ctf_array_bitfield(_type, _item, _src, _length, _user, _nowrite) + +#undef _ctf_sequence_encoded +#define _ctf_sequence_encoded(_type, _item, _src, _length_type, \ + _src_length, _encoding, _byte_order, _base, _user, _nowrite) + +#undef _ctf_sequence_bitfield +#define _ctf_sequence_bitfield(_type, _item, _src, _length_type, \ + _src_length, _byte_order, _user, _nowrite) + +#undef _ctf_string +#define _ctf_string(_item, _src, _user, _nowrite) + +#undef _ctf_enum +#define _ctf_enum(_name, _type, _item, _src, _nowrite) + +/* "write" */ +#undef ctf_integer +#define ctf_integer(_type, _item, _src) + +#undef ctf_integer_hex +#define ctf_integer_hex(_type, _item, _src) + +#undef ctf_integer_oct +#define ctf_integer_oct(_type, _item, _src) + +#undef ctf_integer_network +#define ctf_integer_network(_type, _item, _src) + +#undef ctf_integer_network_hex +#define ctf_integer_network_hex(_type, _item, _src) + +#undef ctf_float +#define ctf_float(_type, _item, _src) + +#undef ctf_array +#define ctf_array(_type, _item, _src, _length) + +#undef ctf_array_hex +#define ctf_array_hex(_type, _item, _src, _length) + +#undef ctf_array_network +#define ctf_array_network(_type, _item, _src, _length) + +#undef ctf_array_network_hex +#define ctf_array_network_hex(_type, _item, _src, _length) + +#undef ctf_array_text +#define ctf_array_text(_type, _item, _src, _length) + +#undef ctf_array_bitfield +#define ctf_array_bitfield(_type, _item, _src, _length) + +#undef ctf_sequence +#define ctf_sequence(_type, _item, _src, _length_type, _src_length) + +#undef ctf_sequence_hex +#define ctf_sequence_hex(_type, _item, _src, _length_type, _src_length) + +#undef ctf_sequence_network +#define ctf_sequence_network(_type, _item, _src, _length_type, _src_length) + +#undef ctf_sequence_network_hex +#define ctf_sequence_network_hex(_type, _item, _src, _length_type, _src_length) + +#undef ctf_sequence_text +#define ctf_sequence_text(_type, _item, _src, _length_type, _src_length) + +#undef ctf_sequence_bitfield +#define ctf_sequence_bitfield(_type, _item, _src, _length_type, _src_length) + +#undef ctf_string +#define ctf_string(_item, _src) + +#undef ctf_enum +#define ctf_enum(_name, _type, _item, _src) + +#undef ctf_custom_field +#define ctf_custom_field(_type, _item, _code) + +#undef ctf_custom_type +#define ctf_custom_type(...) + +#undef ctf_custom_code +#define ctf_custom_code(...) + +#undef ctf_align +#define ctf_align(_type) + +/* "nowrite" */ +#undef ctf_integer_nowrite +#define ctf_integer_nowrite(_type, _item, _src) + +#undef ctf_float_nowrite +#define ctf_float_nowrite(_type, _item, _src) + +#undef ctf_array_nowrite +#define ctf_array_nowrite(_type, _item, _src, _length) + +#undef ctf_array_network_nowrite +#define ctf_array_network_nowrite(_type, _item, _src, _length) + +#undef ctf_array_text_nowrite +#define ctf_array_text_nowrite(_type, _item, _src, _length) + +#undef ctf_array_bitfield_nowrite +#define ctf_array_bitfield_nowrite(_type, _item, _src, _length) + +#undef ctf_sequence_nowrite +#define ctf_sequence_nowrite(_type, _item, _src, _length_type, _src_length) + +#undef ctf_sequence_network_nowrite +#define ctf_sequence_network_nowrite(_type, _item, _src, _length_type, _src_length) + +#undef ctf_sequence_text_nowrite +#define ctf_sequence_text_nowrite(_type, _item, _src, _length_type, _src_length) + +#undef ctf_sequence_bitfield_nowrite +#define ctf_sequence_bitfield_nowrite(_type, _item, _src, _length_type, _src_length) + +#undef ctf_string_nowrite +#define ctf_string_nowrite(_item, _src) + +#undef ctf_enum_nowrite +#define ctf_enum_nowrite(_name, _type, _item, _src) + +/* "user" - "write" */ +#undef ctf_user_integer +#define ctf_user_integer(_type, _item, _user_src) + +#undef ctf_user_integer_hex +#define ctf_user_integer_hex(_type, _item, _user_src) + +#undef ctf_user_integer_network +#define ctf_user_integer_network(_type, _item, _user_src) + +#undef ctf_user_integer_network_hex +#define ctf_user_integer_network_hex(_type, _item, _user_src) + +#undef ctf_user_float +#define ctf_user_float(_type, _item, _user_src) + +#undef ctf_user_array +#define ctf_user_array(_type, _item, _user_src, _length) + +#undef ctf_user_array_hex +#define ctf_user_array_hex(_type, _item, _user_src, _length) + +#undef ctf_user_array_network +#define ctf_user_array_network(_type, _item, _user_src, _length) + +#undef ctf_user_array_network_hex +#define ctf_user_array_network_hex(_type, _item, _user_src, _length) + +#undef ctf_user_array_text +#define ctf_user_array_text(_type, _item, _user_src, _length) + +#undef ctf_user_array_bitfield +#define ctf_user_array_bitfield(_type, _item, _src, _length) + +#undef ctf_user_sequence +#define ctf_user_sequence(_type, _item, _user_src, _length_type, _user_src_length) + +#undef ctf_user_sequence_hex +#define ctf_user_sequence_hex(_type, _item, _user_src, _length_type, _user_src_length) + +#undef ctf_user_sequence_network +#define ctf_user_sequence_network(_type, _item, _user_src, _length_type, _user_src_length) + +#undef ctf_user_sequence_network_hex +#define ctf_user_sequence_network_hex(_type, _item, _user_src, _length_type, _user_src_length) + +#undef ctf_user_sequence_text +#define ctf_user_sequence_text(_type, _item, _user_src, _length_type, _user_src_length) + +#undef ctf_user_sequence_bitfield +#define ctf_user_sequence_bitfield(_type, _item, _src, _length_type, _src_length) + +#undef ctf_user_string +#define ctf_user_string(_item, _user_src) + +#undef ctf_user_enum +#define ctf_user_enum(_name, _type, _item, _src) + +/* "user" - "nowrite" */ +#undef ctf_user_integer_nowrite +#define ctf_user_integer_nowrite(_type, _item, _user_src) + +#undef ctf_user_float_nowrite +#define ctf_user_float_nowrite(_type, _item, _user_src) + +#undef ctf_user_array_nowrite +#define ctf_user_array_nowrite(_type, _item, _user_src, _length) + +#undef ctf_user_array_network_nowrite +#define ctf_user_array_network_nowrite(_type, _item, _user_src, _length) + +#undef ctf_user_array_text_nowrite +#define ctf_user_array_text_nowrite(_type, _item, _user_src, _length) + +#undef ctf_user_array_bitfield_nowrite +#define ctf_user_array_bitfield_nowrite(_type, _item, _src, _length) + +#undef ctf_user_sequence_nowrite +#define ctf_user_sequence_nowrite(_type, _item, _user_src, _length_type, _user_src_length) + +#undef ctf_user_sequence_network_nowrite +#define ctf_user_sequence_network_nowrite(_type, _item, _user_src, _length_type, _user_src_length) + +#undef ctf_user_sequence_text_nowrite +#define ctf_user_sequence_text_nowrite(_type, _item, _user_src, _length_type, _user_src_length) + +#undef ctf_user_sequence_bitfield_nowrite +#define ctf_user_sequence_bitfield_nowrite(_type, _item, _src, _length_type, _src_length) + +#undef ctf_user_string_nowrite +#define ctf_user_string_nowrite(_item, _user_src) + +#undef ctf_user_enum_nowrite +#define ctf_user_enum_nowrite(_name, _type, _item, _src) diff --git a/include/lttng/lttng-events-write.h b/include/lttng/lttng-events-write.h new file mode 100644 index 00000000..c0732a54 --- /dev/null +++ b/include/lttng/lttng-events-write.h @@ -0,0 +1,339 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) + * + * lttng-events-write.h + * + * Copyright (C) 2014 Mathieu Desnoyers + */ + +#undef ctf_integer +#define ctf_integer(_type, _item, _src) \ + _ctf_integer_ext(_type, _item, _src, __BYTE_ORDER, 10, 0, 0) + +#undef ctf_integer_bitfield +#define ctf_integer_bitfield(_type, _item, _src) \ + _ctf_integer_ext(_type, _item, _src, __LITTLE_ENDIAN, 10, 0, 0) + +#undef ctf_integer_hex +#define ctf_integer_hex(_type, _item, _src) \ + _ctf_integer_ext(_type, _item, _src, __BYTE_ORDER, 16, 0, 0) + +#undef ctf_integer_oct +#define ctf_integer_oct(_type, _item, _src) \ + _ctf_integer_ext(_type, _item, _src, __BYTE_ORDER, 8, 0, 0) + +#undef ctf_integer_network +#define ctf_integer_network(_type, _item, _src) \ + _ctf_integer_ext(_type, _item, _src, __BIG_ENDIAN, 10, 0, 0) + +#undef ctf_integer_network_hex +#define ctf_integer_network_hex(_type, _item, _src) \ + _ctf_integer_ext(_type, _item, _src, __BIG_ENDIAN, 16, 0, 0) + +#undef ctf_array +#define ctf_array(_type, _item, _src, _length) \ + _ctf_array_encoded(_type, _item, _src, \ + _length, none, __BYTE_ORDER, 10, 0, 0) + +#undef ctf_array_hex +#define ctf_array_hex(_type, _item, _src, _length) \ + _ctf_array_encoded(_type, _item, _src, \ + _length, none, __BYTE_ORDER, 16, 0, 0) + +#undef ctf_array_network +#define ctf_array_network(_type, _item, _src, _length) \ + _ctf_array_encoded(_type, _item, _src, \ + _length, none, __BIG_ENDIAN, 10, 0, 0) + +#undef ctf_array_network_hex +#define ctf_array_network_hex(_type, _item, _src, _length) \ + _ctf_array_encoded(_type, _item, _src, \ + _length, none, __BIG_ENDIAN, 16, 0, 0) + +#undef ctf_array_text +#define ctf_array_text(_type, _item, _src, _length) \ + _ctf_array_encoded(_type, _item, _src, \ + _length, UTF8, __BYTE_ORDER, 10, 0, 0) + +#undef ctf_array_bitfield +#define ctf_array_bitfield(_type, _item, _src, _length) \ + _ctf_array_bitfield(_type, _item, _src, _length, 0, 0) + +#undef ctf_sequence +#define ctf_sequence(_type, _item, _src, _length_type, _src_length) \ + _ctf_sequence_encoded(_type, _item, _src, \ + _length_type, _src_length, none, __BYTE_ORDER, 10, 0, 0) + +#undef ctf_sequence_hex +#define ctf_sequence_hex(_type, _item, _src, _length_type, _src_length) \ + _ctf_sequence_encoded(_type, _item, _src, \ + _length_type, _src_length, none, __BYTE_ORDER, 16, 0, 0) + +#undef ctf_sequence_network +#define ctf_sequence_network(_type, _item, _src, _length_type, _src_length) \ + _ctf_sequence_encoded(_type, _item, _src, \ + _length_type, _src_length, none, __BIG_ENDIAN, 10, 0, 0) + +#undef ctf_sequence_network_hex +#define ctf_sequence_network_hex(_type, _item, _src, _length_type, _src_length) \ + _ctf_sequence_encoded(_type, _item, _src, \ + _length_type, _src_length, none, __BIG_ENDIAN, 16, 0, 0) + +#undef ctf_sequence_text +#define ctf_sequence_text(_type, _item, _src, _length_type, _src_length) \ + _ctf_sequence_encoded(_type, _item, _src, \ + _length_type, _src_length, UTF8, __BYTE_ORDER, 10, 0, 0) + +#undef ctf_sequence_bitfield +#define ctf_sequence_bitfield(_type, _item, _src, _length_type, _src_length) \ + _ctf_sequence_bitfield(_type, _item, _src, \ + _length_type, _src_length, 0, 0) + +#undef ctf_string +#define ctf_string(_item, _src) \ + _ctf_string(_item, _src, 0, 0) + +#undef ctf_enum +#define ctf_enum(_name, _type, _item, _src) \ + _ctf_enum(_name, _type, _item, _src, 0, 0) + +/* user src */ +#undef ctf_user_integer +#define ctf_user_integer(_type, _item, _src) \ + _ctf_integer_ext(_type, _item, _src, __BYTE_ORDER, 10, 1, 0) + +#undef ctf_user_integer_hex +#define ctf_user_integer_hex(_type, _item, _src) \ + _ctf_integer_ext(_type, _item, _src, __BYTE_ORDER, 16, 1, 0) + +#undef ctf_user_integer_network +#define ctf_user_integer_network(_type, _item, _src) \ + _ctf_integer_ext(_type, _item, _src, __BIG_ENDIAN, 10, 1, 0) + +#undef ctf_user_integer_network_hex +#define ctf_user_integer_network_hex(_type, _item, _src) \ + _ctf_integer_ext(_type, _item, _src, __BIG_ENDIAN, 16, 1, 0) + +#undef ctf_user_array +#define ctf_user_array(_type, _item, _src, _length) \ + _ctf_array_encoded(_type, _item, _src, \ + _length, none, __BYTE_ORDER, 10, 1, 0) + +#undef ctf_user_array_hex +#define ctf_user_array_hex(_type, _item, _src, _length) \ + _ctf_array_encoded(_type, _item, _src, \ + _length, none, __BYTE_ORDER, 16, 1, 0) + +#undef ctf_user_array_network +#define ctf_user_array_network(_type, _item, _src, _length) \ + _ctf_array_encoded(_type, _item, _src, \ + _length, none, __BIG_ENDIAN, 10, 1, 0) + +#undef ctf_user_array_network_hex +#define ctf_user_array_network_hex(_type, _item, _src, _length) \ + _ctf_array_encoded(_type, _item, _src, \ + _length, none, __BIG_ENDIAN, 16, 1, 0) + +#undef ctf_user_array_text +#define ctf_user_array_text(_type, _item, _src, _length) \ + _ctf_array_encoded(_type, _item, _src, \ + _length, UTF8, __BYTE_ORDER, 10, 1, 0) + +#undef ctf_user_array_bitfield +#define ctf_user_array_bitfield(_type, _item, _src, _length) \ + _ctf_array_bitfield(_type, _item, _src, _length, 1, 0) + +#undef ctf_user_sequence +#define ctf_user_sequence(_type, _item, _src, _length_type, _src_length) \ + _ctf_sequence_encoded(_type, _item, _src, \ + _length_type, _src_length, none, __BYTE_ORDER, 10, 1, 0) + +#undef ctf_user_sequence_hex +#define ctf_user_sequence_hex(_type, _item, _src, _length_type, _src_length) \ + _ctf_sequence_encoded(_type, _item, _src, \ + _length_type, _src_length, none, __BYTE_ORDER, 16, 1, 0) + +#undef ctf_user_sequence_network +#define ctf_user_sequence_network(_type, _item, _src, _length_type, _src_length) \ + _ctf_sequence_encoded(_type, _item, _src, \ + _length_type, _src_length, none, __BIG_ENDIAN, 10, 1, 0) + +#undef ctf_user_sequence_network_hex +#define ctf_user_sequence_network_hex(_type, _item, _src, _length_type, _src_length) \ + _ctf_sequence_encoded(_type, _item, _src, \ + _length_type, _src_length, none, __BIG_ENDIAN, 16, 1, 0) + +#undef ctf_user_sequence_text +#define ctf_user_sequence_text(_type, _item, _src, _length_type, _src_length) \ + _ctf_sequence_encoded(_type, _item, _src, \ + _length_type, _src_length, UTF8, __BYTE_ORDER, 10, 1, 0) + +#undef ctf_user_sequence_bitfield +#define ctf_user_sequence_bitfield(_type, _item, _src, _length_type, _src_length) \ + _ctf_sequence_bitfield(_type, _item, _src, \ + _length_type, _src_length, 1, 0) + +#undef ctf_user_string +#define ctf_user_string(_item, _src) \ + _ctf_string(_item, _src, 1, 0) + +#undef ctf_user_enum +#define ctf_user_enum(_name, _type, _item, _src) \ + _ctf_enum(_name, _type, _item, _src, 1, 0) + +/* types */ +#undef ctf_integer_type +#define ctf_integer_type(_type, _src) \ + ctf_integer(_type, unused, _src) + +#undef ctf_integer_bitfield_type +#define ctf_integer_bitfield_type(_type, _src) \ + ctf_integer_bitfield(_type, unused, _src) + +#undef ctf_integer_hex_type +#define ctf_integer_hex_type(_type, _src) \ + ctf_integer_hex(_type, unused, _src) + +#undef ctf_integer_oct_type +#define ctf_integer_oct_type(_type, _item, _src) \ + ctf_integer_oct(_type, unused, _src) + +#undef ctf_integer_network_type +#define ctf_integer_network_type(_type, _src) \ + ctf_integer_network(_type, unused, _src) + +#undef ctf_integer_network_hex_type +#define ctf_integer_network_hex_type(_type, _src) \ + ctf_integer_network_hex(_type, unused, _src) + +#undef ctf_array_type +#define ctf_array_type(_type, _src, _length) \ + ctf_array(_type, unused, _src, _length) + +#undef ctf_array_hex_type +#define ctf_array_hex_type(_type, _src, _length) \ + ctf_array_hex(_type, unused, _src, _length) + +#undef ctf_array_network_type +#define ctf_array_network_type(_type, _src, _length) \ + ctf_array_network(_type, unused, _src, _length) + +#undef ctf_array_network_hex_type +#define ctf_array_network_hex_type(_type, _src, _length) \ + ctf_array_network_hex(_type, unused, _src, _length) + +#undef ctf_array_text_type +#define ctf_array_text_type(_type, _src, _length) \ + ctf_array_text(_type, unused, _src, _length) + +#undef ctf_array_bitfield_type +#define ctf_array_bitfield_type(_type, _src, _length) \ + ctf_array_bitfield(_type, unused, _src, _length) + +#undef ctf_sequence_type +#define ctf_sequence_type(_type, _src, _length_type, _src_length) \ + ctf_sequence(_type, unused, _src, _length_type, _src_length) + +#undef ctf_sequence_hex_type +#define ctf_sequence_hex_type(_type, _src, _length_type, _src_length) \ + ctf_sequence_hex(_type, unused, _src, _length_type, _src_length) + +#undef ctf_sequence_network_type +#define ctf_sequence_network_type(_type, _src, _length_type, _src_length) \ + ctf_sequence_network(_type, unused, _src, _length_type, _src_length) + +#undef ctf_sequence_network_hex_type +#define ctf_sequence_network_hex_type(_type, _src, _length_type, _src_length) \ + ctf_sequence_network_hex(_type, unused, _src, _length_type, _src_length) + +#undef ctf_sequence_text_type +#define ctf_sequence_text_type(_type, _src, _length_type, _src_length) \ + ctf_sequence_text(_type, unused, _src, _length_type, _src_length) + +#undef ctf_sequence_bitfield_type +#define ctf_sequence_bitfield_type(_type, _src, _length_type, _src_length) \ + ctf_sequence_bitfield(_type, unused, _src, _length_type, _src_length) + +#undef ctf_string_type +#define ctf_string_type(_src) \ + ctf_string(unused, _src) + +#undef ctf_enum_type +#define ctf_enum_type(_name, _type, _src) \ + ctf_enum(_name, _type, unused, _src) + +/* user src types */ +#undef ctf_user_integer_type +#define ctf_user_integer_type(_type, _src) \ + ctf_user_integer(_type, unused, _src) + +#undef ctf_user_integer_hex_type +#define ctf_user_integer_hex_type(_type, _src) \ + ctf_user_integer_hex(_type, unused, _src) + +#undef ctf_user_integer_oct_type +#define ctf_user_integer_oct_type(_type, _item, _src) \ + ctf_user_integer_oct(_type, unused, _src) + +#undef ctf_user_integer_network_type +#define ctf_user_integer_network_type(_type, _src) \ + ctf_user_integer_network(_type, unused, _src) + +#undef ctf_user_integer_network_hex_type +#define ctf_user_integer_network_hex_type(_type, _src) \ + ctf_user_integer_network_hex(_type, unused, _src) + +#undef ctf_user_array_type +#define ctf_user_array_type(_type, _src, _length) \ + ctf_user_array(_type, unused, _src, _length) + +#undef ctf_user_array_hex_type +#define ctf_user_array_hex_type(_type, _src, _length) \ + ctf_user_array_hex(_type, unused, _src, _length) + +#undef ctf_user_array_network_type +#define ctf_user_array_network_type(_type, _src, _length) \ + ctf_user_array_network(_type, unused, _src, _length) + +#undef ctf_user_array_network_hex_type +#define ctf_user_array_network_hex_type(_type, _src, _length) \ + ctf_user_array_network_hex(_type, unused, _src, _length) + +#undef ctf_user_array_text_type +#define ctf_user_array_text_type(_type, _src, _length) \ + ctf_user_array_text(_type, unused, _src, _length) + +#undef ctf_user_array_bitfield_type +#define ctf_user_array_bitfield_type(_type, _src, _length) \ + ctf_user_array_bitfield(_type, unused, _src, _length) + +#undef ctf_user_sequence_type +#define ctf_user_sequence_type(_type, _src, _length_type, _src_length) \ + ctf_user_sequence(_type, unused, _src, _length_type, _src_length) + +#undef ctf_user_sequence_hex_type +#define ctf_user_sequence_hex_type(_type, _src, _length_type, _src_length) \ + ctf_user_sequence_hex(_type, unused, _src, _length_type, _src_length) + +#undef ctf_user_sequence_network_type +#define ctf_user_sequence_network_type(_type, _src, _length_type, _src_length) \ + ctf_user_sequence_network(_type, unused, _src, _length_type, _src_length) + +#undef ctf_user_sequence_network_hex_type +#define ctf_user_sequence_network_hex_type(_type, _src, _length_type, _src_length) \ + ctf_user_sequence_network_hex(_type, unused, _src, _length_type, _src_length) + +#undef ctf_user_sequence_text_type +#define ctf_user_sequence_text_type(_type, _src, _length_type, _src_length) \ + ctf_user_sequence_text(_type, unused, _src, _length_type, _src_length) + +#undef ctf_user_sequence_bitfield_type +#define ctf_user_sequence_bitfield_type(_type, _src, _length_type, _src_length) \ + ctf_user_sequence_bitfield(_type, unused, _src, _length_type, _src_length) + +#undef ctf_user_string_type +#define ctf_user_string_type(_src) \ + ctf_user_string(unused, _src) + +#undef ctf_user_enum_type +#define ctf_user_enum_type(_name, _type, _src) \ + ctf_user_enum(_name, _type, unused, _src) diff --git a/include/lttng/lttng-events.h b/include/lttng/lttng-events.h new file mode 100644 index 00000000..026e4461 --- /dev/null +++ b/include/lttng/lttng-events.h @@ -0,0 +1,969 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) + * + * lttng-events.h + * + * Holds LTTng per-session event registry. + * + * Copyright (C) 2010-2012 Mathieu Desnoyers + */ + +#ifndef _LTTNG_EVENTS_H +#define _LTTNG_EVENTS_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define lttng_is_signed_type(type) (((type)(-1)) < 0) + +struct lttng_channel; +struct lttng_session; +struct lttng_metadata_cache; +struct lib_ring_buffer_ctx; +struct perf_event; +struct perf_event_attr; +struct lib_ring_buffer_config; + +/* Type description */ + +enum abstract_types { + atype_integer, + atype_string, + atype_enum_nestable, + atype_array_nestable, + atype_sequence_nestable, + atype_struct_nestable, + atype_variant_nestable, + NR_ABSTRACT_TYPES, +}; + +enum lttng_string_encodings { + lttng_encode_none = 0, + lttng_encode_UTF8 = 1, + lttng_encode_ASCII = 2, + NR_STRING_ENCODINGS, +}; + +enum channel_type { + PER_CPU_CHANNEL, + METADATA_CHANNEL, +}; + +struct lttng_enum_value { + unsigned long long value; + unsigned int signedness:1; +}; + +struct lttng_enum_entry { + struct lttng_enum_value start, end; /* start and end are inclusive */ + const char *string; + struct { + unsigned int is_auto:1; + } options; +}; + +#define __type_integer(_type, _size, _alignment, _signedness, \ + _byte_order, _base, _encoding) \ + { \ + .atype = atype_integer, \ + .u.integer = \ + { \ + .size = (_size) ? : sizeof(_type) * CHAR_BIT, \ + .alignment = (_alignment) ? : lttng_alignof(_type) * CHAR_BIT, \ + .signedness = (_signedness) >= 0 ? (_signedness) : lttng_is_signed_type(_type), \ + .reverse_byte_order = _byte_order != __BYTE_ORDER, \ + .base = _base, \ + .encoding = lttng_encode_##_encoding, \ + }, \ + } \ + +struct lttng_integer_type { + unsigned int size; /* in bits */ + unsigned short alignment; /* in bits */ + unsigned int signedness:1, + reverse_byte_order:1; + unsigned int base; /* 2, 8, 10, 16, for pretty print */ + enum lttng_string_encodings encoding; +}; + +struct lttng_type { + enum abstract_types atype; + union { + struct lttng_integer_type integer; + struct { + enum lttng_string_encodings encoding; + } string; + struct { + const struct lttng_enum_desc *desc; /* Enumeration mapping */ + const struct lttng_type *container_type; + } enum_nestable; + struct { + const struct lttng_type *elem_type; + unsigned int length; /* Num. elems. */ + unsigned int alignment; + } array_nestable; + struct { + const char *length_name; /* Length field name. */ + const struct lttng_type *elem_type; + unsigned int alignment; /* Alignment before elements. */ + } sequence_nestable; + struct { + unsigned int nr_fields; + const struct lttng_event_field *fields; /* Array of fields. */ + unsigned int alignment; + } struct_nestable; + struct { + const char *tag_name; + const struct lttng_event_field *choices; /* Array of fields. */ + unsigned int nr_choices; + unsigned int alignment; + } variant_nestable; + } u; +}; + +struct lttng_enum_desc { + const char *name; + const struct lttng_enum_entry *entries; + unsigned int nr_entries; +}; + +/* Event field description */ + +struct lttng_event_field { + const char *name; + struct lttng_type type; + unsigned int nowrite:1, /* do not write into trace */ + user:1, /* fetch from user-space */ + nofilter:1; /* do not consider for filter */ +}; + +union lttng_ctx_value { + int64_t s64; + const char *str; + double d; +}; + +/* + * We need to keep this perf counter field separately from struct + * lttng_ctx_field because cpu hotplug needs fixed-location addresses. + */ +struct lttng_perf_counter_field { + struct lttng_cpuhp_node cpuhp_prepare; + struct lttng_cpuhp_node cpuhp_online; + struct perf_event_attr *attr; + struct perf_event **e; /* per-cpu array */ +}; + +struct lttng_probe_ctx { + struct lttng_event *event; + uint8_t interruptible; +}; + +struct lttng_ctx_field { + struct lttng_event_field event_field; + size_t (*get_size)(size_t offset); + size_t (*get_size_arg)(size_t offset, struct lttng_ctx_field *field, + struct lib_ring_buffer_ctx *ctx, + struct lttng_channel *chan); + void (*record)(struct lttng_ctx_field *field, + struct lib_ring_buffer_ctx *ctx, + struct lttng_channel *chan); + void (*get_value)(struct lttng_ctx_field *field, + struct lttng_probe_ctx *lttng_probe_ctx, + union lttng_ctx_value *value); + union { + struct lttng_perf_counter_field *perf_counter; + } u; + void (*destroy)(struct lttng_ctx_field *field); + /* + * Private data to keep state between get_size and record. + * User must perform its own synchronization to protect against + * concurrent and reentrant contexts. + */ + void *priv; +}; + +struct lttng_ctx { + struct lttng_ctx_field *fields; + unsigned int nr_fields; + unsigned int allocated_fields; + size_t largest_align; /* in bytes */ +}; + +struct lttng_event_desc { + const char *name; /* lttng-modules name */ + const char *kname; /* Linux kernel name (tracepoints) */ + void *probe_callback; + const struct lttng_event_ctx *ctx; /* context */ + const struct lttng_event_field *fields; /* event payload */ + unsigned int nr_fields; + struct module *owner; +}; + +struct lttng_probe_desc { + const char *provider; + const struct lttng_event_desc **event_desc; + unsigned int nr_events; + struct list_head head; /* chain registered probes */ + struct list_head lazy_init_head; + int lazy; /* lazy registration */ +}; + +struct lttng_krp; /* Kretprobe handling */ + +enum lttng_event_type { + LTTNG_TYPE_EVENT = 0, + LTTNG_TYPE_ENABLER = 1, +}; + +struct lttng_filter_bytecode_node { + struct list_head node; + struct lttng_enabler *enabler; + /* + * struct lttng_kernel_filter_bytecode has var. sized array, must be + * last field. + */ + struct lttng_kernel_filter_bytecode bc; +}; + +/* + * Filter return value masks. + */ +enum lttng_filter_ret { + LTTNG_FILTER_DISCARD = 0, + LTTNG_FILTER_RECORD_FLAG = (1ULL << 0), + /* Other bits are kept for future use. */ +}; + +struct lttng_bytecode_runtime { + /* Associated bytecode */ + struct lttng_filter_bytecode_node *bc; + uint64_t (*filter)(void *filter_data, struct lttng_probe_ctx *lttng_probe_ctx, + const char *filter_stack_data); + int link_failed; + struct list_head node; /* list of bytecode runtime in event */ + struct lttng_event *event; +}; + +/* + * Objects in a linked-list of enablers, owned by an event. + */ +struct lttng_enabler_ref { + struct list_head node; /* enabler ref list */ + struct lttng_enabler *ref; /* backward ref */ +}; + +struct lttng_uprobe_handler { + struct lttng_event *event; + loff_t offset; + struct uprobe_consumer up_consumer; + struct list_head node; +}; + +/* + * lttng_event structure is referred to by the tracing fast path. It must be + * kept small. + */ +struct lttng_event { + enum lttng_event_type evtype; /* First field. */ + unsigned int id; + struct lttng_channel *chan; + int enabled; + const struct lttng_event_desc *desc; + void *filter; + struct lttng_ctx *ctx; + enum lttng_kernel_instrumentation instrumentation; + union { + struct { + struct kprobe kp; + char *symbol_name; + } kprobe; + struct { + struct lttng_krp *lttng_krp; + char *symbol_name; + } kretprobe; + struct { + struct inode *inode; + struct list_head head; + } uprobe; + } u; + struct list_head list; /* Event list in session */ + unsigned int metadata_dumped:1; + + /* Backward references: list of lttng_enabler_ref (ref to enablers) */ + struct list_head enablers_ref_head; + struct hlist_node hlist; /* session ht of events */ + int registered; /* has reg'd tracepoint probe */ + /* list of struct lttng_bytecode_runtime, sorted by seqnum */ + struct list_head bytecode_runtime_head; + int has_enablers_without_bytecode; +}; + +enum lttng_enabler_type { + LTTNG_ENABLER_STAR_GLOB, + LTTNG_ENABLER_NAME, +}; + +/* + * Enabler field, within whatever object is enabling an event. Target of + * backward reference. + */ +struct lttng_enabler { + enum lttng_event_type evtype; /* First field. */ + + enum lttng_enabler_type type; + + struct list_head node; /* per-session list of enablers */ + /* head list of struct lttng_ust_filter_bytecode_node */ + struct list_head filter_bytecode_head; + + struct lttng_kernel_event event_param; + struct lttng_channel *chan; + struct lttng_ctx *ctx; + unsigned int enabled:1; +}; + +struct lttng_channel_ops { + struct channel *(*channel_create)(const char *name, + struct lttng_channel *lttng_chan, + void *buf_addr, + size_t subbuf_size, size_t num_subbuf, + unsigned int switch_timer_interval, + unsigned int read_timer_interval); + void (*channel_destroy)(struct channel *chan); + struct lib_ring_buffer *(*buffer_read_open)(struct channel *chan); + int (*buffer_has_read_closed_stream)(struct channel *chan); + void (*buffer_read_close)(struct lib_ring_buffer *buf); + int (*event_reserve)(struct lib_ring_buffer_ctx *ctx, + uint32_t event_id); + void (*event_commit)(struct lib_ring_buffer_ctx *ctx); + void (*event_write)(struct lib_ring_buffer_ctx *ctx, const void *src, + size_t len); + void (*event_write_from_user)(struct lib_ring_buffer_ctx *ctx, + const void *src, size_t len); + void (*event_memset)(struct lib_ring_buffer_ctx *ctx, + int c, size_t len); + void (*event_strcpy)(struct lib_ring_buffer_ctx *ctx, const char *src, + size_t len); + void (*event_strcpy_from_user)(struct lib_ring_buffer_ctx *ctx, + const char __user *src, size_t len); + /* + * packet_avail_size returns the available size in the current + * packet. Note that the size returned is only a hint, since it + * may change due to concurrent writes. + */ + size_t (*packet_avail_size)(struct channel *chan); + wait_queue_head_t *(*get_writer_buf_wait_queue)(struct channel *chan, int cpu); + wait_queue_head_t *(*get_hp_wait_queue)(struct channel *chan); + int (*is_finalized)(struct channel *chan); + int (*is_disabled)(struct channel *chan); + int (*timestamp_begin) (const struct lib_ring_buffer_config *config, + struct lib_ring_buffer *bufb, + uint64_t *timestamp_begin); + int (*timestamp_end) (const struct lib_ring_buffer_config *config, + struct lib_ring_buffer *bufb, + uint64_t *timestamp_end); + int (*events_discarded) (const struct lib_ring_buffer_config *config, + struct lib_ring_buffer *bufb, + uint64_t *events_discarded); + int (*content_size) (const struct lib_ring_buffer_config *config, + struct lib_ring_buffer *bufb, + uint64_t *content_size); + int (*packet_size) (const struct lib_ring_buffer_config *config, + struct lib_ring_buffer *bufb, + uint64_t *packet_size); + int (*stream_id) (const struct lib_ring_buffer_config *config, + struct lib_ring_buffer *bufb, + uint64_t *stream_id); + int (*current_timestamp) (const struct lib_ring_buffer_config *config, + struct lib_ring_buffer *bufb, + uint64_t *ts); + int (*sequence_number) (const struct lib_ring_buffer_config *config, + struct lib_ring_buffer *bufb, + uint64_t *seq); + int (*instance_id) (const struct lib_ring_buffer_config *config, + struct lib_ring_buffer *bufb, + uint64_t *id); +}; + +struct lttng_transport { + char *name; + struct module *owner; + struct list_head node; + struct lttng_channel_ops ops; +}; + +struct lttng_syscall_filter; + +#define LTTNG_EVENT_HT_BITS 12 +#define LTTNG_EVENT_HT_SIZE (1U << LTTNG_EVENT_HT_BITS) + +struct lttng_event_ht { + struct hlist_head table[LTTNG_EVENT_HT_SIZE]; +}; + +struct lttng_channel { + unsigned int id; + struct channel *chan; /* Channel buffers */ + int enabled; + struct lttng_ctx *ctx; + /* Event ID management */ + struct lttng_session *session; + struct file *file; /* File associated to channel */ + unsigned int free_event_id; /* Next event ID to allocate */ + struct list_head list; /* Channel list */ + struct lttng_channel_ops *ops; + struct lttng_transport *transport; + struct lttng_event **sc_table; /* for syscall tracing */ + struct lttng_event **compat_sc_table; + struct lttng_event **sc_exit_table; /* for syscall exit tracing */ + struct lttng_event **compat_sc_exit_table; + struct lttng_event *sc_unknown; /* for unknown syscalls */ + struct lttng_event *sc_compat_unknown; + struct lttng_event *sc_exit_unknown; + struct lttng_event *compat_sc_exit_unknown; + struct lttng_syscall_filter *sc_filter; + int header_type; /* 0: unset, 1: compact, 2: large */ + enum channel_type channel_type; + unsigned int metadata_dumped:1, + sys_enter_registered:1, + sys_exit_registered:1, + syscall_all:1, + tstate:1; /* Transient enable state */ +}; + +struct lttng_metadata_stream { + void *priv; /* Ring buffer private data */ + struct lttng_metadata_cache *metadata_cache; + unsigned int metadata_in; /* Bytes read from the cache */ + unsigned int metadata_out; /* Bytes consumed from stream */ + int finalized; /* Has channel been finalized */ + wait_queue_head_t read_wait; /* Reader buffer-level wait queue */ + struct list_head list; /* Stream list */ + struct lttng_transport *transport; + uint64_t version; /* Current version of the metadata cache */ +}; + +#define LTTNG_DYNAMIC_LEN_STACK_SIZE 128 + +struct lttng_dynamic_len_stack { + size_t stack[LTTNG_DYNAMIC_LEN_STACK_SIZE]; + size_t offset; +}; + +DECLARE_PER_CPU(struct lttng_dynamic_len_stack, lttng_dynamic_len_stack); + +/* + * struct lttng_id_tracker declared in header due to deferencing of *v + * in RCU_INITIALIZER(v). + */ +#define LTTNG_ID_HASH_BITS 6 +#define LTTNG_ID_TABLE_SIZE (1 << LTTNG_ID_HASH_BITS) + +enum tracker_type { + TRACKER_PID, + TRACKER_VPID, + TRACKER_UID, + TRACKER_VUID, + TRACKER_GID, + TRACKER_VGID, + + TRACKER_UNKNOWN, +}; + +struct lttng_id_tracker_rcu { + struct hlist_head id_hash[LTTNG_ID_TABLE_SIZE]; +}; + +struct lttng_id_tracker { + struct lttng_session *session; + enum tracker_type tracker_type; + struct lttng_id_tracker_rcu *p; /* RCU dereferenced. */ +}; + +struct lttng_id_hash_node { + struct hlist_node hlist; + int id; +}; + +struct lttng_session { + int active; /* Is trace session active ? */ + int been_active; /* Has trace session been active ? */ + struct file *file; /* File associated to session */ + struct list_head chan; /* Channel list head */ + struct list_head events; /* Event list head */ + struct list_head list; /* Session list */ + unsigned int free_chan_id; /* Next chan ID to allocate */ + uuid_le uuid; /* Trace session unique ID */ + struct lttng_metadata_cache *metadata_cache; + struct lttng_id_tracker pid_tracker; + struct lttng_id_tracker vpid_tracker; + struct lttng_id_tracker uid_tracker; + struct lttng_id_tracker vuid_tracker; + struct lttng_id_tracker gid_tracker; + struct lttng_id_tracker vgid_tracker; + unsigned int metadata_dumped:1, + tstate:1; /* Transient enable state */ + /* List of enablers */ + struct list_head enablers_head; + /* Hash table of events */ + struct lttng_event_ht events_ht; + char name[LTTNG_KERNEL_SESSION_NAME_LEN]; + char creation_time[LTTNG_KERNEL_SESSION_CREATION_TIME_ISO8601_LEN]; +}; + +struct lttng_metadata_cache { + char *data; /* Metadata cache */ + unsigned int cache_alloc; /* Metadata allocated size (bytes) */ + unsigned int metadata_written; /* Number of bytes written in metadata cache */ + struct kref refcount; /* Metadata cache usage */ + struct list_head metadata_stream; /* Metadata stream list */ + uuid_le uuid; /* Trace session unique ID (copy) */ + struct mutex lock; /* Produce/consume lock */ + uint64_t version; /* Current version of the metadata */ +}; + +void lttng_lock_sessions(void); +void lttng_unlock_sessions(void); + +struct list_head *lttng_get_probe_list_head(void); + +struct lttng_enabler *lttng_enabler_create(enum lttng_enabler_type type, + struct lttng_kernel_event *event_param, + struct lttng_channel *chan); + +int lttng_enabler_enable(struct lttng_enabler *enabler); +int lttng_enabler_disable(struct lttng_enabler *enabler); +int lttng_fix_pending_events(void); +int lttng_session_active(void); + +struct lttng_session *lttng_session_create(void); +int lttng_session_enable(struct lttng_session *session); +int lttng_session_disable(struct lttng_session *session); +void lttng_session_destroy(struct lttng_session *session); +int lttng_session_metadata_regenerate(struct lttng_session *session); +int lttng_session_statedump(struct lttng_session *session); +void metadata_cache_destroy(struct kref *kref); + +struct lttng_channel *lttng_channel_create(struct lttng_session *session, + const char *transport_name, + void *buf_addr, + size_t subbuf_size, size_t num_subbuf, + unsigned int switch_timer_interval, + unsigned int read_timer_interval, + enum channel_type channel_type); +struct lttng_channel *lttng_global_channel_create(struct lttng_session *session, + int overwrite, void *buf_addr, + size_t subbuf_size, size_t num_subbuf, + unsigned int switch_timer_interval, + unsigned int read_timer_interval); + +void lttng_metadata_channel_destroy(struct lttng_channel *chan); +struct lttng_event *lttng_event_create(struct lttng_channel *chan, + struct lttng_kernel_event *event_param, + void *filter, + const struct lttng_event_desc *event_desc, + enum lttng_kernel_instrumentation itype); +struct lttng_event *_lttng_event_create(struct lttng_channel *chan, + struct lttng_kernel_event *event_param, + void *filter, + const struct lttng_event_desc *event_desc, + enum lttng_kernel_instrumentation itype); +struct lttng_event *lttng_event_compat_old_create(struct lttng_channel *chan, + struct lttng_kernel_old_event *old_event_param, + void *filter, + const struct lttng_event_desc *internal_desc); + +int lttng_channel_enable(struct lttng_channel *channel); +int lttng_channel_disable(struct lttng_channel *channel); +int lttng_event_enable(struct lttng_event *event); +int lttng_event_disable(struct lttng_event *event); + +void lttng_transport_register(struct lttng_transport *transport); +void lttng_transport_unregister(struct lttng_transport *transport); + +void synchronize_trace(void); +int lttng_abi_init(void); +int lttng_abi_compat_old_init(void); +void lttng_abi_exit(void); +void lttng_abi_compat_old_exit(void); + +int lttng_probe_register(struct lttng_probe_desc *desc); +void lttng_probe_unregister(struct lttng_probe_desc *desc); +const struct lttng_event_desc *lttng_event_get(const char *name); +void lttng_event_put(const struct lttng_event_desc *desc); +int lttng_probes_init(void); +void lttng_probes_exit(void); + +int lttng_metadata_output_channel(struct lttng_metadata_stream *stream, + struct channel *chan); + +int lttng_id_tracker_get_node_id(const struct lttng_id_hash_node *node); +int lttng_id_tracker_empty_set(struct lttng_id_tracker *lf); +void lttng_id_tracker_destroy(struct lttng_id_tracker *lf, bool rcu); +bool lttng_id_tracker_lookup(struct lttng_id_tracker_rcu *p, int id); +int lttng_id_tracker_add(struct lttng_id_tracker *lf, int id); +int lttng_id_tracker_del(struct lttng_id_tracker *lf, int id); + +int lttng_session_track_id(struct lttng_session *session, + enum tracker_type tracker_type, int id); +int lttng_session_untrack_id(struct lttng_session *session, + enum tracker_type tracker_type, int id); + +int lttng_session_list_tracker_ids(struct lttng_session *session, + enum tracker_type tracker_type); + +void lttng_clock_ref(void); +void lttng_clock_unref(void); + +#if defined(CONFIG_HAVE_SYSCALL_TRACEPOINTS) +int lttng_syscalls_register(struct lttng_channel *chan, void *filter); +int lttng_syscalls_unregister(struct lttng_channel *chan); +int lttng_syscall_filter_enable(struct lttng_channel *chan, + const char *name); +int lttng_syscall_filter_disable(struct lttng_channel *chan, + const char *name); +long lttng_channel_syscall_mask(struct lttng_channel *channel, + struct lttng_kernel_syscall_mask __user *usyscall_mask); +#else +static inline int lttng_syscalls_register(struct lttng_channel *chan, void *filter) +{ + return -ENOSYS; +} + +static inline int lttng_syscalls_unregister(struct lttng_channel *chan) +{ + return 0; +} + +static inline int lttng_syscall_filter_enable(struct lttng_channel *chan, + const char *name) +{ + return -ENOSYS; +} + +static inline int lttng_syscall_filter_disable(struct lttng_channel *chan, + const char *name) +{ + return -ENOSYS; +} + +static inline long lttng_channel_syscall_mask(struct lttng_channel *channel, + struct lttng_kernel_syscall_mask __user *usyscall_mask) +{ + return -ENOSYS; +} +#endif + +void lttng_filter_sync_state(struct lttng_bytecode_runtime *runtime); +int lttng_enabler_attach_bytecode(struct lttng_enabler *enabler, + struct lttng_kernel_filter_bytecode __user *bytecode); +void lttng_enabler_event_link_bytecode(struct lttng_event *event, + struct lttng_enabler *enabler); + +int lttng_probes_init(void); + +extern struct lttng_ctx *lttng_static_ctx; + +int lttng_context_init(void); +void lttng_context_exit(void); +struct lttng_ctx_field *lttng_append_context(struct lttng_ctx **ctx); +void lttng_context_update(struct lttng_ctx *ctx); +int lttng_find_context(struct lttng_ctx *ctx, const char *name); +int lttng_get_context_index(struct lttng_ctx *ctx, const char *name); +void lttng_remove_context_field(struct lttng_ctx **ctx, + struct lttng_ctx_field *field); +void lttng_destroy_context(struct lttng_ctx *ctx); +int lttng_add_pid_to_ctx(struct lttng_ctx **ctx); +int lttng_add_cpu_id_to_ctx(struct lttng_ctx **ctx); +int lttng_add_procname_to_ctx(struct lttng_ctx **ctx); +int lttng_add_prio_to_ctx(struct lttng_ctx **ctx); +int lttng_add_nice_to_ctx(struct lttng_ctx **ctx); +int lttng_add_vpid_to_ctx(struct lttng_ctx **ctx); +int lttng_add_tid_to_ctx(struct lttng_ctx **ctx); +int lttng_add_vtid_to_ctx(struct lttng_ctx **ctx); +int lttng_add_ppid_to_ctx(struct lttng_ctx **ctx); +int lttng_add_vppid_to_ctx(struct lttng_ctx **ctx); +int lttng_add_hostname_to_ctx(struct lttng_ctx **ctx); +int lttng_add_interruptible_to_ctx(struct lttng_ctx **ctx); +int lttng_add_need_reschedule_to_ctx(struct lttng_ctx **ctx); +#if defined(CONFIG_PREEMPT_RT_FULL) || defined(CONFIG_PREEMPT) +int lttng_add_preemptible_to_ctx(struct lttng_ctx **ctx); +#else +static inline +int lttng_add_preemptible_to_ctx(struct lttng_ctx **ctx) +{ + return -ENOSYS; +} +#endif +#ifdef CONFIG_PREEMPT_RT_FULL +int lttng_add_migratable_to_ctx(struct lttng_ctx **ctx); +#else +static inline +int lttng_add_migratable_to_ctx(struct lttng_ctx **ctx) +{ + return -ENOSYS; +} +#endif + +int lttng_add_callstack_to_ctx(struct lttng_ctx **ctx, int type); + +#if defined(CONFIG_CGROUPS) +int lttng_add_cgroup_ns_to_ctx(struct lttng_ctx **ctx); +#else +static inline +int lttng_add_cgroup_ns_to_ctx(struct lttng_ctx **ctx) +{ + return -ENOSYS; +} +#endif + +#if defined(CONFIG_IPC_NS) +int lttng_add_ipc_ns_to_ctx(struct lttng_ctx **ctx); +#else +static inline +int lttng_add_ipc_ns_to_ctx(struct lttng_ctx **ctx) +{ + return -ENOSYS; +} +#endif + +#if !defined(LTTNG_MNT_NS_MISSING_HEADER) +int lttng_add_mnt_ns_to_ctx(struct lttng_ctx **ctx); +#else +static inline +int lttng_add_mnt_ns_to_ctx(struct lttng_ctx **ctx) +{ + return -ENOSYS; +} +#endif + +#if defined(CONFIG_NET_NS) +int lttng_add_net_ns_to_ctx(struct lttng_ctx **ctx); +#else +static inline +int lttng_add_net_ns_to_ctx(struct lttng_ctx **ctx) +{ + return -ENOSYS; +} +#endif + +#if defined(CONFIG_PID_NS) +int lttng_add_pid_ns_to_ctx(struct lttng_ctx **ctx); +#else +static inline +int lttng_add_pid_ns_to_ctx(struct lttng_ctx **ctx) +{ + return -ENOSYS; +} +#endif + +#if defined(CONFIG_USER_NS) +int lttng_add_user_ns_to_ctx(struct lttng_ctx **ctx); +#else +static inline +int lttng_add_user_ns_to_ctx(struct lttng_ctx **ctx) +{ + return -ENOSYS; +} +#endif + +#if defined(CONFIG_UTS_NS) +int lttng_add_uts_ns_to_ctx(struct lttng_ctx **ctx); +#else +static inline +int lttng_add_uts_ns_to_ctx(struct lttng_ctx **ctx) +{ + return -ENOSYS; +} +#endif + +int lttng_add_uid_to_ctx(struct lttng_ctx **ctx); +int lttng_add_euid_to_ctx(struct lttng_ctx **ctx); +int lttng_add_suid_to_ctx(struct lttng_ctx **ctx); +int lttng_add_gid_to_ctx(struct lttng_ctx **ctx); +int lttng_add_egid_to_ctx(struct lttng_ctx **ctx); +int lttng_add_sgid_to_ctx(struct lttng_ctx **ctx); +int lttng_add_vuid_to_ctx(struct lttng_ctx **ctx); +int lttng_add_veuid_to_ctx(struct lttng_ctx **ctx); +int lttng_add_vsuid_to_ctx(struct lttng_ctx **ctx); +int lttng_add_vgid_to_ctx(struct lttng_ctx **ctx); +int lttng_add_vegid_to_ctx(struct lttng_ctx **ctx); +int lttng_add_vsgid_to_ctx(struct lttng_ctx **ctx); + +#if defined(CONFIG_PERF_EVENTS) +int lttng_add_perf_counter_to_ctx(uint32_t type, + uint64_t config, + const char *name, + struct lttng_ctx **ctx); +int lttng_cpuhp_perf_counter_online(unsigned int cpu, + struct lttng_cpuhp_node *node); +int lttng_cpuhp_perf_counter_dead(unsigned int cpu, + struct lttng_cpuhp_node *node); +#else +static inline +int lttng_add_perf_counter_to_ctx(uint32_t type, + uint64_t config, + const char *name, + struct lttng_ctx **ctx) +{ + return -ENOSYS; +} +static inline +int lttng_cpuhp_perf_counter_online(unsigned int cpu, + struct lttng_cpuhp_node *node) +{ + return 0; +} +static inline +int lttng_cpuhp_perf_counter_dead(unsigned int cpu, + struct lttng_cpuhp_node *node) +{ + return 0; +} +#endif + +int lttng_logger_init(void); +void lttng_logger_exit(void); + +extern int lttng_statedump_start(struct lttng_session *session); + +#ifdef CONFIG_KPROBES +int lttng_kprobes_register(const char *name, + const char *symbol_name, + uint64_t offset, + uint64_t addr, + struct lttng_event *event); +void lttng_kprobes_unregister(struct lttng_event *event); +void lttng_kprobes_destroy_private(struct lttng_event *event); +#else +static inline +int lttng_kprobes_register(const char *name, + const char *symbol_name, + uint64_t offset, + uint64_t addr, + struct lttng_event *event) +{ + return -ENOSYS; +} + +static inline +void lttng_kprobes_unregister(struct lttng_event *event) +{ +} + +static inline +void lttng_kprobes_destroy_private(struct lttng_event *event) +{ +} +#endif + +int lttng_event_add_callsite(struct lttng_event *event, + struct lttng_kernel_event_callsite *callsite); + +#ifdef CONFIG_UPROBES +int lttng_uprobes_register(const char *name, + int fd, struct lttng_event *event); +int lttng_uprobes_add_callsite(struct lttng_event *event, + struct lttng_kernel_event_callsite *callsite); +void lttng_uprobes_unregister(struct lttng_event *event); +void lttng_uprobes_destroy_private(struct lttng_event *event); +#else +static inline +int lttng_uprobes_register(const char *name, + int fd, struct lttng_event *event) +{ + return -ENOSYS; +} + +static inline +int lttng_uprobes_add_callsite(struct lttng_event *event, + struct lttng_kernel_event_callsite *callsite) +{ + return -ENOSYS; +} + +static inline +void lttng_uprobes_unregister(struct lttng_event *event) +{ +} + +static inline +void lttng_uprobes_destroy_private(struct lttng_event *event) +{ +} +#endif + +#ifdef CONFIG_KRETPROBES +int lttng_kretprobes_register(const char *name, + const char *symbol_name, + uint64_t offset, + uint64_t addr, + struct lttng_event *event_entry, + struct lttng_event *event_exit); +void lttng_kretprobes_unregister(struct lttng_event *event); +void lttng_kretprobes_destroy_private(struct lttng_event *event); +int lttng_kretprobes_event_enable_state(struct lttng_event *event, + int enable); +#else +static inline +int lttng_kretprobes_register(const char *name, + const char *symbol_name, + uint64_t offset, + uint64_t addr, + struct lttng_event *event_entry, + struct lttng_event *event_exit) +{ + return -ENOSYS; +} + +static inline +void lttng_kretprobes_unregister(struct lttng_event *event) +{ +} + +static inline +void lttng_kretprobes_destroy_private(struct lttng_event *event) +{ +} + +static inline +int lttng_kretprobes_event_enable_state(struct lttng_event *event, + int enable) +{ + return -ENOSYS; +} +#endif + +int lttng_calibrate(struct lttng_kernel_calibrate *calibrate); + +extern const struct file_operations lttng_tracepoint_list_fops; +extern const struct file_operations lttng_syscall_list_fops; + +#define TRACEPOINT_HAS_DATA_ARG + +static inline bool lttng_is_bytewise_integer(const struct lttng_type *type) +{ + if (type->atype != atype_integer) + return false; + switch (type->u.integer.size) { + case 8: /* Fall-through. */ + case 16: /* Fall-through. */ + case 32: /* Fall-through. */ + case 64: + break; + default: + return false; + } + return true; +} + +#endif /* _LTTNG_EVENTS_H */ diff --git a/include/lttng/lttng-filter.h b/include/lttng/lttng-filter.h new file mode 100644 index 00000000..d3b9aacd --- /dev/null +++ b/include/lttng/lttng-filter.h @@ -0,0 +1,248 @@ +/* SPDX-License-Identifier: MIT + * + * lttng-filter.h + * + * LTTng modules filter header. + * + * Copyright (C) 2010-2016 Mathieu Desnoyers + */ + +#ifndef _LTTNG_FILTER_H +#define _LTTNG_FILTER_H + +#include + +#include +#include + +/* Filter stack length, in number of entries */ +#define FILTER_STACK_LEN 10 /* includes 2 dummy */ +#define FILTER_STACK_EMPTY 1 + +#define FILTER_MAX_DATA_LEN 65536 + +#ifdef DEBUG +#define dbg_printk(fmt, args...) \ + printk(KERN_DEBUG "[debug bytecode in %s:%s@%u] " fmt, \ + __FILE__, __func__, __LINE__, ## args) +#else +#define dbg_printk(fmt, args...) \ +do { \ + /* do nothing but check printf format */ \ + if (0) \ + printk(KERN_DEBUG "[debug bytecode in %s:%s@%u] " fmt, \ + __FILE__, __func__, __LINE__, ## args); \ +} while (0) +#endif + +/* Linked bytecode. Child of struct lttng_bytecode_runtime. */ +struct bytecode_runtime { + struct lttng_bytecode_runtime p; + size_t data_len; + size_t data_alloc_len; + char *data; + uint16_t len; + char code[0]; +}; + +enum entry_type { + REG_S64, + REG_DOUBLE, + REG_STRING, + REG_STAR_GLOB_STRING, + REG_TYPE_UNKNOWN, + REG_PTR, +}; + +enum load_type { + LOAD_ROOT_CONTEXT, + LOAD_ROOT_APP_CONTEXT, + LOAD_ROOT_PAYLOAD, + LOAD_OBJECT, +}; + +enum object_type { + OBJECT_TYPE_S8, + OBJECT_TYPE_S16, + OBJECT_TYPE_S32, + OBJECT_TYPE_S64, + OBJECT_TYPE_U8, + OBJECT_TYPE_U16, + OBJECT_TYPE_U32, + OBJECT_TYPE_U64, + + OBJECT_TYPE_DOUBLE, + OBJECT_TYPE_STRING, + OBJECT_TYPE_STRING_SEQUENCE, + + OBJECT_TYPE_SEQUENCE, + OBJECT_TYPE_ARRAY, + OBJECT_TYPE_STRUCT, + OBJECT_TYPE_VARIANT, + + OBJECT_TYPE_DYNAMIC, +}; + +struct filter_get_index_data { + uint64_t offset; /* in bytes */ + size_t ctx_index; + size_t array_len; + struct { + size_t len; + enum object_type type; + bool rev_bo; /* reverse byte order */ + } elem; +}; + +/* Validation stack */ +struct vstack_load { + enum load_type type; + enum object_type object_type; + const struct lttng_event_field *field; + bool rev_bo; /* reverse byte order */ +}; + +struct vstack_entry { + enum entry_type type; + struct vstack_load load; +}; + +struct vstack { + int top; /* top of stack */ + struct vstack_entry e[FILTER_STACK_LEN]; +}; + +static inline +void vstack_init(struct vstack *stack) +{ + stack->top = -1; +} + +static inline +struct vstack_entry *vstack_ax(struct vstack *stack) +{ + if (unlikely(stack->top < 0)) + return NULL; + return &stack->e[stack->top]; +} + +static inline +struct vstack_entry *vstack_bx(struct vstack *stack) +{ + if (unlikely(stack->top < 1)) + return NULL; + return &stack->e[stack->top - 1]; +} + +static inline +int vstack_push(struct vstack *stack) +{ + if (stack->top >= FILTER_STACK_LEN - 1) { + printk(KERN_WARNING "Stack full\n"); + return -EINVAL; + } + ++stack->top; + return 0; +} + +static inline +int vstack_pop(struct vstack *stack) +{ + if (unlikely(stack->top < 0)) { + printk(KERN_WARNING "Stack empty\n"); + return -EINVAL; + } + stack->top--; + return 0; +} + +/* Execution stack */ +enum estack_string_literal_type { + ESTACK_STRING_LITERAL_TYPE_NONE, + ESTACK_STRING_LITERAL_TYPE_PLAIN, + ESTACK_STRING_LITERAL_TYPE_STAR_GLOB, +}; + +struct load_ptr { + enum load_type type; + enum object_type object_type; + const void *ptr; + bool rev_bo; + /* Temporary place-holders for contexts. */ + union { + int64_t s64; + uint64_t u64; + double d; + } u; + /* + * "field" is only needed when nested under a variant, in which + * case we cannot specialize the nested operations. + */ + const struct lttng_event_field *field; +}; + +struct estack_entry { + union { + int64_t v; + + struct { + const char *str; + const char __user *user_str; + size_t seq_len; + enum estack_string_literal_type literal_type; + int user; /* is string from userspace ? */ + } s; + struct load_ptr ptr; + } u; +}; + +struct estack { + int top; /* top of stack */ + struct estack_entry e[FILTER_STACK_LEN]; +}; + +#define estack_ax_v ax +#define estack_bx_v bx + +#define estack_ax(stack, top) \ + ({ \ + BUG_ON((top) <= FILTER_STACK_EMPTY); \ + &(stack)->e[top]; \ + }) + +#define estack_bx(stack, top) \ + ({ \ + BUG_ON((top) <= FILTER_STACK_EMPTY + 1); \ + &(stack)->e[(top) - 1]; \ + }) + +#define estack_push(stack, top, ax, bx) \ + do { \ + BUG_ON((top) >= FILTER_STACK_LEN - 1); \ + (stack)->e[(top) - 1].u.v = (bx); \ + (bx) = (ax); \ + ++(top); \ + } while (0) + +#define estack_pop(stack, top, ax, bx) \ + do { \ + BUG_ON((top) <= FILTER_STACK_EMPTY); \ + (ax) = (bx); \ + (bx) = (stack)->e[(top) - 2].u.v; \ + (top)--; \ + } while (0) + +const char *lttng_filter_print_op(enum filter_op op); + +int lttng_filter_validate_bytecode(struct bytecode_runtime *bytecode); +int lttng_filter_specialize_bytecode(struct lttng_event *event, + struct bytecode_runtime *bytecode); + +uint64_t lttng_filter_false(void *filter_data, + struct lttng_probe_ctx *lttng_probe_ctx, + const char *filter_stack_data); +uint64_t lttng_filter_interpret_bytecode(void *filter_data, + struct lttng_probe_ctx *lttng_probe_ctx, + const char *filter_stack_data); + +#endif /* _LTTNG_FILTER_H */ diff --git a/include/lttng/lttng-kernel-version.h b/include/lttng/lttng-kernel-version.h new file mode 100644 index 00000000..cb96a325 --- /dev/null +++ b/include/lttng/lttng-kernel-version.h @@ -0,0 +1,138 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) + * + * lttng-kernel-version.h + * + * Contains helpers to check more complex kernel version conditions. + * + * Copyright (C) 2012 Mathieu Desnoyers + */ + +#ifndef _LTTNG_KERNEL_VERSION_H +#define _LTTNG_KERNEL_VERSION_H + +#include +#include + +/* + * This macro checks if the kernel version is between the two specified + * versions (lower limit inclusive, upper limit exclusive). + */ +#define LTTNG_KERNEL_RANGE(a_low, b_low, c_low, a_high, b_high, c_high) \ + (LINUX_VERSION_CODE >= KERNEL_VERSION(a_low, b_low, c_low) && \ + LINUX_VERSION_CODE < KERNEL_VERSION(a_high, b_high, c_high)) + +/* Ubuntu */ + +#define LTTNG_UBUNTU_KERNEL_VERSION(a, b, c, d) \ + (((a) << 24) + ((b) << 16) + ((c) << 8) + (d)) + +#ifdef UTS_UBUNTU_RELEASE_ABI +#define LTTNG_UBUNTU_VERSION_CODE \ + ((LINUX_VERSION_CODE << 8) + UTS_UBUNTU_RELEASE_ABI) +#else +#define LTTNG_UBUNTU_VERSION_CODE 0 +#endif + +#define LTTNG_UBUNTU_KERNEL_RANGE(a_low, b_low, c_low, d_low, \ + a_high, b_high, c_high, d_high) \ + (LTTNG_UBUNTU_VERSION_CODE >= \ + LTTNG_UBUNTU_KERNEL_VERSION(a_low, b_low, c_low, d_low) && \ + LTTNG_UBUNTU_VERSION_CODE < \ + LTTNG_UBUNTU_KERNEL_VERSION(a_high, b_high, c_high, d_high)) + +/* Debian */ + +#define LTTNG_DEBIAN_KERNEL_VERSION(a, b, c, d, e, f) \ + (((((a) << 16) + ((b) << 8) + (c)) * 1000000ULL) + ((d) * 10000) + ((e) * 100) + (f)) + +#ifdef DEBIAN_API_VERSION +#define LTTNG_DEBIAN_VERSION_CODE \ + ((LINUX_VERSION_CODE * 1000000ULL) + DEBIAN_API_VERSION) +#else +#define LTTNG_DEBIAN_VERSION_CODE 0 +#endif + +#define LTTNG_DEBIAN_KERNEL_RANGE(a_low, b_low, c_low, d_low, e_low, f_low, \ + a_high, b_high, c_high, d_high, e_high, f_high) \ + (LTTNG_DEBIAN_VERSION_CODE >= \ + LTTNG_DEBIAN_KERNEL_VERSION(a_low, b_low, c_low, d_low, e_low, f_low) && \ + LTTNG_DEBIAN_VERSION_CODE < \ + LTTNG_DEBIAN_KERNEL_VERSION(a_high, b_high, c_high, d_high, e_high, f_high)) + +#define LTTNG_RHEL_KERNEL_VERSION(a, b, c, d, e, f) \ + (((((a) << 16) + ((b) << 8) + (c)) * 10000000ULL) + ((d) * 10000) + ((e) * 100) + (f)) + +/* RHEL */ + +#ifdef RHEL_API_VERSION +#define LTTNG_RHEL_VERSION_CODE \ + ((LINUX_VERSION_CODE * 10000000ULL) + RHEL_API_VERSION) +#else +#define LTTNG_RHEL_VERSION_CODE 0 +#endif + +#define LTTNG_RHEL_KERNEL_RANGE(a_low, b_low, c_low, d_low, e_low, f_low, \ + a_high, b_high, c_high, d_high, e_high, f_high) \ + (LTTNG_RHEL_VERSION_CODE >= \ + LTTNG_RHEL_KERNEL_VERSION(a_low, b_low, c_low, d_low, e_low, f_low) && \ + LTTNG_RHEL_VERSION_CODE < \ + LTTNG_RHEL_KERNEL_VERSION(a_high, b_high, c_high, d_high, e_high, f_high)) + +/* SUSE Linux enterprise */ + +#define LTTNG_SLE_KERNEL_VERSION(a, b, c, d, e, f) \ + (((((a) << 16) + ((b) << 8) + (c)) * 10000000ULL) + ((d) * 10000) + ((e) * 100) + (f)) + +#ifdef SLE_API_VERSION +#define LTTNG_SLE_VERSION_CODE \ + ((LINUX_VERSION_CODE * 10000000ULL) + SLE_API_VERSION) +#else +#define LTTNG_SLE_VERSION_CODE 0 +#endif + +#define LTTNG_SLE_KERNEL_RANGE(a_low, b_low, c_low, d_low, e_low, f_low, \ + a_high, b_high, c_high, d_high, e_high, f_high) \ + (LTTNG_SLE_VERSION_CODE >= \ + LTTNG_SLE_KERNEL_VERSION(a_low, b_low, c_low, d_low, e_low, f_low) && \ + LTTNG_SLE_VERSION_CODE < \ + LTTNG_SLE_KERNEL_VERSION(a_high, b_high, c_high, d_high, e_high, f_high)) + +/* Fedora */ + +#define LTTNG_FEDORA_KERNEL_VERSION(a, b, c, d) \ + (((((a) << 16) + ((b) << 8) + (c)) * 10000ULL) + (d)) + +#ifdef FEDORA_REVISION_VERSION +#define LTTNG_FEDORA_VERSION_CODE \ + ((LINUX_VERSION_CODE * 10000ULL) + FEDORA_REVISION_VERSION) +#else +#define LTTNG_FEDORA_VERSION_CODE 0 +#endif + +#define LTTNG_FEDORA_KERNEL_RANGE(a_low, b_low, c_low, d_low, \ + a_high, b_high, c_high, d_high) \ + (LTTNG_FEDORA_VERSION_CODE >= \ + LTTNG_FEDORA_KERNEL_VERSION(a_low, b_low, c_low, d_low) && \ + LTTNG_FEDORA_VERSION_CODE < \ + LTTNG_FEDORA_KERNEL_VERSION(a_high, b_high, c_high, d_high)) + +/* RT patch */ + +#define LTTNG_RT_KERNEL_VERSION(a, b, c, d) \ + (((a) << 24) + ((b) << 16) + ((c) << 8) + (d)) + +#ifdef RT_PATCH_VERSION +#define LTTNG_RT_VERSION_CODE \ + ((LINUX_VERSION_CODE << 8) + RT_PATCH_VERSION) +#else +#define LTTNG_RT_VERSION_CODE 0 +#endif + +#define LTTNG_RT_KERNEL_RANGE(a_low, b_low, c_low, d_low, \ + a_high, b_high, c_high, d_high) \ + (LTTNG_RT_VERSION_CODE >= \ + LTTNG_RT_KERNEL_VERSION(a_low, b_low, c_low, d_low) && \ + LTTNG_RT_VERSION_CODE < \ + LTTNG_RT_KERNEL_VERSION(a_high, b_high, c_high, d_high)) + +#endif /* _LTTNG_KERNEL_VERSION_H */ diff --git a/include/lttng/lttng-probe-user.h b/include/lttng/lttng-probe-user.h new file mode 100644 index 00000000..d85bb6f7 --- /dev/null +++ b/include/lttng/lttng-probe-user.h @@ -0,0 +1,17 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) + * + * lttng-probe-user.h + * + * Copyright (C) 2012 Mathieu Desnoyers + */ + +#ifndef _LTTNG_PROBE_USER_H +#define _LTTNG_PROBE_USER_H + +/* + * Calculate string length. Include final null terminating character if there is + * one, or ends at first fault. + */ +long lttng_strlen_user_inatomic(const char *addr); + +#endif /* _LTTNG_PROBE_USER_H */ diff --git a/include/lttng/lttng-string-utils.h b/include/lttng/lttng-string-utils.h new file mode 100644 index 00000000..3e7267e9 --- /dev/null +++ b/include/lttng/lttng-string-utils.h @@ -0,0 +1,23 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ +#ifndef _LTTNG_STRING_UTILS_H +#define _LTTNG_STRING_UTILS_H + +/* + * Copyright (C) 2017 Philippe Proulx + */ + +#include + +typedef char (*strutils_get_char_at_cb)(size_t, void *); + +bool strutils_is_star_glob_pattern(const char *pattern); +bool strutils_is_star_at_the_end_only_glob_pattern(const char *pattern); +bool strutils_star_glob_match(const char *pattern, size_t pattern_len, + const char *candidate, size_t candidate_len); +bool strutils_star_glob_match_char_cb( + strutils_get_char_at_cb pattern_get_char_at_cb, + void *pattern_get_char_at_cb_data, + strutils_get_char_at_cb candidate_get_char_at_cb, + void *candidate_get_char_at_cb_data); + +#endif /* _LTTNG_STRING_UTILS_H */ diff --git a/include/lttng/lttng-tp-mempool.h b/include/lttng/lttng-tp-mempool.h new file mode 100644 index 00000000..f925efa9 --- /dev/null +++ b/include/lttng/lttng-tp-mempool.h @@ -0,0 +1,50 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) + * + * lttng-tp-mempool.h + * + * Copyright (C) 2018 Julien Desfossez + */ + +#ifndef LTTNG_TP_MEMPOOL_H +#define LTTNG_TP_MEMPOOL_H + +#include + +#define LTTNG_TP_MEMPOOL_NR_BUF_PER_CPU 4 +#define LTTNG_TP_MEMPOOL_BUF_SIZE 4096 + +/* + * Initialize the pool, only performed once. The pool is a set of + * LTTNG_TP_MEMPOOL_NR_BUF_PER_CPU buffers of size LTTNG_TP_MEMPOOL_BUF_SIZE + * per-cpu. + * + * Returns 0 on success, a negative value on error. + */ +int lttng_tp_mempool_init(void); + +/* + * Destroy the pool and free all the memory allocated. + */ +void lttng_tp_mempool_destroy(void); + +/* + * Ask for a buffer on the current cpu. + * + * The pool is per-cpu, but there is no exclusive access guarantee on the + * per-cpu free-list, the caller needs to ensure it cannot get preempted or + * interrupted while performing the allocation. + * + * The maximum size that can be allocated is LTTNG_TP_MEMPOOL_BUF_SIZE, and the + * maximum number of buffers allocated simultaneously on the same CPU is + * LTTNG_TP_MEMPOOL_NR_BUF_PER_CPU. + * + * Return a pointer to a buffer on success, NULL on error. + */ +void *lttng_tp_mempool_alloc(size_t size); + +/* + * Release the memory reserved. Same concurrency limitations as the allocation. + */ +void lttng_tp_mempool_free(void *ptr); + +#endif /* LTTNG_TP_MEMPOOL_H */ diff --git a/include/lttng/lttng-tracepoint-event-impl.h b/include/lttng/lttng-tracepoint-event-impl.h new file mode 100644 index 00000000..5779bac0 --- /dev/null +++ b/include/lttng/lttng-tracepoint-event-impl.h @@ -0,0 +1,1438 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) + * + * lttng-tracepoint-event-impl.h + * + * Copyright (C) 2009 Steven Rostedt + * Copyright (C) 2009-2014 Mathieu Desnoyers + */ + +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#define __LTTNG_NULL_STRING "(null)" + +#undef PARAMS +#define PARAMS(args...) args + +/* + * Macro declarations used for all stages. + */ + +/* + * LTTng name mapping macros. LTTng remaps some of the kernel events to + * enforce name-spacing. + */ +#undef LTTNG_TRACEPOINT_EVENT_MAP +#define LTTNG_TRACEPOINT_EVENT_MAP(name, map, proto, args, fields) \ + LTTNG_TRACEPOINT_EVENT_CLASS(map, \ + PARAMS(proto), \ + PARAMS(args), \ + PARAMS(fields)) \ + LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(map, name, map, PARAMS(proto), PARAMS(args)) + +#undef LTTNG_TRACEPOINT_EVENT_MAP_NOARGS +#define LTTNG_TRACEPOINT_EVENT_MAP_NOARGS(name, map, fields) \ + LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(map, \ + PARAMS(fields)) \ + LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS(map, name, map) + +#undef LTTNG_TRACEPOINT_EVENT_CODE_MAP +#define LTTNG_TRACEPOINT_EVENT_CODE_MAP(name, map, proto, args, _locvar, _code_pre, fields, _code_post) \ + LTTNG_TRACEPOINT_EVENT_CLASS_CODE(map, \ + PARAMS(proto), \ + PARAMS(args), \ + PARAMS(_locvar), \ + PARAMS(_code_pre), \ + PARAMS(fields), \ + PARAMS(_code_post)) \ + LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(map, name, map, PARAMS(proto), PARAMS(args)) + +#undef LTTNG_TRACEPOINT_EVENT_CODE +#define LTTNG_TRACEPOINT_EVENT_CODE(name, proto, args, _locvar, _code_pre, fields, _code_post) \ + LTTNG_TRACEPOINT_EVENT_CODE_MAP(name, name, \ + PARAMS(proto), \ + PARAMS(args), \ + PARAMS(_locvar), \ + PARAMS(_code_pre), \ + PARAMS(fields), \ + PARAMS(_code_post)) + +/* + * LTTNG_TRACEPOINT_EVENT_CLASS can be used to add a generic function + * handlers for events. That is, if all events have the same parameters + * and just have distinct trace points. Each tracepoint can be defined + * with LTTNG_TRACEPOINT_EVENT_INSTANCE and that will map the + * LTTNG_TRACEPOINT_EVENT_CLASS to the tracepoint. + * + * LTTNG_TRACEPOINT_EVENT is a one to one mapping between tracepoint and + * template. + */ + +#undef LTTNG_TRACEPOINT_EVENT +#define LTTNG_TRACEPOINT_EVENT(name, proto, args, fields) \ + LTTNG_TRACEPOINT_EVENT_MAP(name, name, \ + PARAMS(proto), \ + PARAMS(args), \ + PARAMS(fields)) + +#undef LTTNG_TRACEPOINT_EVENT_NOARGS +#define LTTNG_TRACEPOINT_EVENT_NOARGS(name, fields) \ + LTTNG_TRACEPOINT_EVENT_MAP_NOARGS(name, name, PARAMS(fields)) + +#undef LTTNG_TRACEPOINT_EVENT_INSTANCE +#define LTTNG_TRACEPOINT_EVENT_INSTANCE(template, name, proto, args) \ + LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(template, name, name, PARAMS(proto), PARAMS(args)) + +#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS +#define LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(template, name) \ + LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS(template, name, name) + +#undef LTTNG_TRACEPOINT_EVENT_CLASS +#define LTTNG_TRACEPOINT_EVENT_CLASS(_name, _proto, _args, _fields) \ + LTTNG_TRACEPOINT_EVENT_CLASS_CODE(_name, PARAMS(_proto), PARAMS(_args), , , \ + PARAMS(_fields), ) + +#undef LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS +#define LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(_name, _fields) \ + LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS(_name, , , PARAMS(_fields), ) + + +/* + * Stage 1 of the trace events. + * + * Create dummy trace calls for each events, verifying that the LTTng module + * instrumentation headers match the kernel arguments. Will be optimized + * out by the compiler. + */ + +/* Reset all macros within TRACEPOINT_EVENT */ +#include + +#undef TP_PROTO +#define TP_PROTO(...) __VA_ARGS__ + +#undef TP_ARGS +#define TP_ARGS(...) __VA_ARGS__ + +#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP +#define LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(_template, _name, _map, _proto, _args) \ +void trace_##_name(_proto); + +#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS +#define LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS(_template, _name, _map) \ +void trace_##_name(void); + +#include TRACE_INCLUDE(TRACE_INCLUDE_FILE) + +/* + * Stage 1.1 of the trace events. + * + * Create dummy trace prototypes for each event class, and for each used + * template. This will allow checking whether the prototypes from the + * class and the instance using the class actually match. + */ + +#include /* Reset all macros within TRACE_EVENT */ + +#undef TP_PROTO +#define TP_PROTO(...) __VA_ARGS__ + +#undef TP_ARGS +#define TP_ARGS(...) __VA_ARGS__ + +#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP +#define LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(_template, _name, _map, _proto, _args) \ +void __event_template_proto___##_template(_proto); + +#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS +#define LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS(_template, _name, _map) \ +void __event_template_proto___##_template(void); + +#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE +#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE(_name, _proto, _args, _locvar, _code_pre, _fields, _code_post) \ +void __event_template_proto___##_name(_proto); + +#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS +#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS(_name, _locvar, _code_pre, _fields, _code_post) \ +void __event_template_proto___##_name(void); + +#include TRACE_INCLUDE(TRACE_INCLUDE_FILE) + +/* + * Stage 1.2 of tracepoint event generation + * + * Unfolding the enums + */ +#include /* Reset all macros within TRACE_EVENT */ + +/* Enumeration entry (single value) */ +#undef ctf_enum_value +#define ctf_enum_value(_string, _value) \ + { \ + .start = { \ + .signedness = lttng_is_signed_type(__typeof__(_value)), \ + .value = lttng_is_signed_type(__typeof__(_value)) ? \ + (long long) (_value) : (_value), \ + }, \ + .end = { \ + .signedness = lttng_is_signed_type(__typeof__(_value)), \ + .value = lttng_is_signed_type(__typeof__(_value)) ? \ + (long long) (_value) : (_value), \ + }, \ + .string = (_string), \ + }, + +/* Enumeration entry (range) */ +#undef ctf_enum_range +#define ctf_enum_range(_string, _range_start, _range_end) \ + { \ + .start = { \ + .signedness = lttng_is_signed_type(__typeof__(_range_start)), \ + .value = lttng_is_signed_type(__typeof__(_range_start)) ? \ + (long long) (_range_start) : (_range_start), \ + }, \ + .end = { \ + .signedness = lttng_is_signed_type(__typeof__(_range_end)), \ + .value = lttng_is_signed_type(__typeof__(_range_end)) ? \ + (long long) (_range_end) : (_range_end), \ + }, \ + .string = (_string), \ + }, + +/* Enumeration entry (automatic value; follows the rules of CTF) */ +#undef ctf_enum_auto +#define ctf_enum_auto(_string) \ + { \ + .start = { \ + .signedness = -1, \ + .value = -1, \ + }, \ + .end = { \ + .signedness = -1, \ + .value = -1, \ + }, \ + .string = (_string), \ + .options = { \ + .is_auto = 1, \ + } \ + }, + +#undef TP_ENUM_VALUES +#define TP_ENUM_VALUES(...) \ + __VA_ARGS__ + +#undef LTTNG_TRACEPOINT_ENUM +#define LTTNG_TRACEPOINT_ENUM(_name, _values) \ + const struct lttng_enum_entry __enum_values__##_name[] = { \ + _values \ + }; + +#include TRACE_INCLUDE(TRACE_INCLUDE_FILE) + +/* + * Stage 2 of the trace events. + * + * Create event field type metadata section. + * Each event produce an array of fields. + */ + +/* Reset all macros within TRACEPOINT_EVENT */ +#include +#include +#include + +#undef _ctf_integer_ext +#define _ctf_integer_ext(_type, _item, _src, _byte_order, _base, _user, _nowrite) \ + { \ + .name = #_item, \ + .type = __type_integer(_type, 0, 0, -1, _byte_order, _base, none), \ + .nowrite = _nowrite, \ + .user = _user, \ + .nofilter = 0, \ + }, + +#undef _ctf_array_encoded +#define _ctf_array_encoded(_type, _item, _src, _length, \ + _encoding, _byte_order, _elem_type_base, _user, _nowrite) \ + { \ + .name = #_item, \ + .type = \ + { \ + .atype = atype_array_nestable, \ + .u = \ + { \ + .array_nestable = \ + { \ + .elem_type = __LTTNG_COMPOUND_LITERAL(struct lttng_type, \ + __type_integer(_type, 0, 0, -1, _byte_order, _elem_type_base, _encoding)), \ + .length = _length, \ + .alignment = 0, \ + } \ + } \ + }, \ + .nowrite = _nowrite, \ + .user = _user, \ + .nofilter = 0, \ + }, + +#undef _ctf_array_bitfield +#define _ctf_array_bitfield(_type, _item, _src, _length, _user, _nowrite) \ + { \ + .name = #_item, \ + .type = \ + { \ + .atype = atype_array_nestable, \ + .u = \ + { \ + .array_nestable = \ + { \ + .elem_type = __LTTNG_COMPOUND_LITERAL(struct lttng_type, \ + __type_integer(_type, 1, 1, 0, __LITTLE_ENDIAN, 10, none)), \ + .length = (_length) * sizeof(_type) * CHAR_BIT, \ + .alignment = lttng_alignof(_type), \ + } \ + } \ + }, \ + .nowrite = _nowrite, \ + .user = _user, \ + .nofilter = 0, \ + }, + + +#undef _ctf_sequence_encoded +#define _ctf_sequence_encoded(_type, _item, _src, \ + _length_type, _src_length, _encoding, \ + _byte_order, _elem_type_base, _user, _nowrite) \ + { \ + .name = "_" #_item "_length", \ + .type = __type_integer(_length_type, 0, 0, -1, __BYTE_ORDER, 10, none), \ + .nowrite = _nowrite, \ + .nofilter = 1, \ + }, \ + { \ + .name = #_item, \ + .type = \ + { \ + .atype = atype_sequence_nestable, \ + .u = \ + { \ + .sequence_nestable = \ + { \ + .length_name = "_" #_item "_length", \ + .elem_type = __LTTNG_COMPOUND_LITERAL(struct lttng_type, \ + __type_integer(_type, 0, 0, -1, _byte_order, _elem_type_base, _encoding)), \ + .alignment = 0, \ + }, \ + }, \ + }, \ + .nowrite = _nowrite, \ + .user = _user, \ + .nofilter = 0, \ + }, + +#undef _ctf_sequence_bitfield +#define _ctf_sequence_bitfield(_type, _item, _src, \ + _length_type, _src_length, \ + _user, _nowrite) \ + { \ + .name = "_" #_item "_length", \ + .type = __type_integer(_length_type, 0, 0, -1, __BYTE_ORDER, 10, none), \ + .nowrite = _nowrite, \ + .nofilter = 1, \ + }, \ + { \ + .name = #_item, \ + .type = \ + { \ + .atype = atype_sequence_nestable, \ + .u = \ + { \ + .sequence_nestable = \ + { \ + .length_name = "_" #_item "_length", \ + .elem_type = __LTTNG_COMPOUND_LITERAL(struct lttng_type, \ + __type_integer(_type, 1, 1, 0, __LITTLE_ENDIAN, 10, none)), \ + .alignment = lttng_alignof(_type), \ + }, \ + }, \ + }, \ + .nowrite = _nowrite, \ + .user = _user, \ + .nofilter = 0, \ + }, + +#undef _ctf_string +#define _ctf_string(_item, _src, _user, _nowrite) \ + { \ + .name = #_item, \ + .type = \ + { \ + .atype = atype_string, \ + .u = \ + { \ + .string = { .encoding = lttng_encode_UTF8 }, \ + }, \ + }, \ + .nowrite = _nowrite, \ + .user = _user, \ + .nofilter = 0, \ + }, + +#undef _ctf_enum +#define _ctf_enum(_name, _type, _item, _src, _user, _nowrite) \ + { \ + .name = #_item, \ + .type = { \ + .atype = atype_enum_nestable, \ + .u = { \ + .enum_nestable = { \ + .desc = &__enum_##_name, \ + .container_type = __LTTNG_COMPOUND_LITERAL(struct lttng_type, \ + __type_integer(_type, 0, 0, -1, __BYTE_ORDER, 10, none)), \ + }, \ + }, \ + }, \ + .nowrite = _nowrite, \ + .user = _user, \ + .nofilter = 0, \ + }, + +#undef ctf_custom_field +#define ctf_custom_field(_type, _item, _code) \ + { \ + .name = #_item, \ + .type = _type, \ + .nowrite = 0, \ + .user = 0, \ + .nofilter = 1, \ + }, + +#undef ctf_custom_type +#define ctf_custom_type(...) __VA_ARGS__ + +#undef TP_FIELDS +#define TP_FIELDS(...) __VA_ARGS__ /* Only one used in this phase */ + +#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS +#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS(_name, _locvar, _code_pre, _fields, _code_post) \ + static const struct lttng_event_field __event_fields___##_name[] = { \ + _fields \ + }; + +#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE +#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE(_name, _proto, _args, _locvar, _code_pre, _fields, _code_post) \ + LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS(_name, _locvar, _code_pre, PARAMS(_fields), _code_post) + +#undef LTTNG_TRACEPOINT_ENUM +#define LTTNG_TRACEPOINT_ENUM(_name, _values) \ + static const struct lttng_enum_desc __enum_##_name = { \ + .name = #_name, \ + .entries = __enum_values__##_name, \ + .nr_entries = ARRAY_SIZE(__enum_values__##_name), \ + }; + +#include TRACE_INCLUDE(TRACE_INCLUDE_FILE) + +/* + * Stage 3 of the trace events. + * + * Create probe callback prototypes. + */ + +/* Reset all macros within TRACEPOINT_EVENT */ +#include + +#undef TP_PROTO +#define TP_PROTO(...) __VA_ARGS__ + +#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE +#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE(_name, _proto, _args, _locvar, _code_pre, _fields, _code_post) \ +static void __event_probe__##_name(void *__data, _proto); + +#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS +#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS(_name, _locvar, _code_pre, _fields, _code_post) \ +static void __event_probe__##_name(void *__data); + +#include TRACE_INCLUDE(TRACE_INCLUDE_FILE) + +/* + * Stage 4 of the trace events. + * + * Create static inline function that calculates event size. + */ + +/* Reset all macros within TRACEPOINT_EVENT */ +#include +#include + +#undef _ctf_integer_ext +#define _ctf_integer_ext(_type, _item, _src, _byte_order, _base, _user, _nowrite) \ + __event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_type)); \ + __event_len += sizeof(_type); + +#undef _ctf_array_encoded +#define _ctf_array_encoded(_type, _item, _src, _length, _encoding, _byte_order, _base, _user, _nowrite) \ + __event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_type)); \ + __event_len += sizeof(_type) * (_length); + +#undef _ctf_array_bitfield +#define _ctf_array_bitfield(_type, _item, _src, _length, _user, _nowrite) \ + _ctf_array_encoded(_type, _item, _src, _length, none, __LITTLE_ENDIAN, 0, _user, _nowrite) + +#undef _ctf_sequence_encoded +#define _ctf_sequence_encoded(_type, _item, _src, _length_type, \ + _src_length, _encoding, _byte_order, _base, _user, _nowrite) \ + __event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_length_type)); \ + __event_len += sizeof(_length_type); \ + __event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_type)); \ + { \ + size_t __seqlen = (_src_length); \ + \ + if (unlikely(++this_cpu_ptr(<tng_dynamic_len_stack)->offset >= LTTNG_DYNAMIC_LEN_STACK_SIZE)) \ + goto error; \ + barrier(); /* reserve before use. */ \ + this_cpu_ptr(<tng_dynamic_len_stack)->stack[this_cpu_ptr(<tng_dynamic_len_stack)->offset - 1] = __seqlen; \ + __event_len += sizeof(_type) * __seqlen; \ + } + +#undef _ctf_sequence_bitfield +#define _ctf_sequence_bitfield(_type, _item, _src, \ + _length_type, _src_length, \ + _user, _nowrite) \ + _ctf_sequence_encoded(_type, _item, _src, _length_type, _src_length, \ + none, __LITTLE_ENDIAN, 10, _user, _nowrite) + +/* + * ctf_user_string includes \0. If returns 0, it faulted, so we set size to + * 1 (\0 only). + */ +#undef _ctf_string +#define _ctf_string(_item, _src, _user, _nowrite) \ + if (unlikely(++this_cpu_ptr(<tng_dynamic_len_stack)->offset >= LTTNG_DYNAMIC_LEN_STACK_SIZE)) \ + goto error; \ + barrier(); /* reserve before use. */ \ + if (_user) { \ + __event_len += this_cpu_ptr(<tng_dynamic_len_stack)->stack[this_cpu_ptr(<tng_dynamic_len_stack)->offset - 1] = \ + max_t(size_t, lttng_strlen_user_inatomic(_src), 1); \ + } else { \ + __event_len += this_cpu_ptr(<tng_dynamic_len_stack)->stack[this_cpu_ptr(<tng_dynamic_len_stack)->offset - 1] = \ + strlen((_src) ? (_src) : __LTTNG_NULL_STRING) + 1; \ + } + +#undef _ctf_enum +#define _ctf_enum(_name, _type, _item, _src, _user, _nowrite) \ + _ctf_integer_ext(_type, _item, _src, __BYTE_ORDER, 10, _user, _nowrite) + +#undef ctf_align +#define ctf_align(_type) \ + __event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_type)); + +#undef ctf_custom_field +#define ctf_custom_field(_type, _item, _code) \ + { \ + _code \ + } + +#undef ctf_custom_code +#define ctf_custom_code(...) __VA_ARGS__ + +#undef TP_PROTO +#define TP_PROTO(...) __VA_ARGS__ + +#undef TP_FIELDS +#define TP_FIELDS(...) __VA_ARGS__ + +#undef TP_locvar +#define TP_locvar(...) __VA_ARGS__ + +#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE +#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE(_name, _proto, _args, _locvar, _code_pre, _fields, _code_post) \ +static inline ssize_t __event_get_size__##_name(void *__tp_locvar, _proto) \ +{ \ + size_t __event_len = 0; \ + unsigned int __dynamic_len_idx __attribute__((unused)) = 0; \ + struct { _locvar } *tp_locvar __attribute__((unused)) = __tp_locvar; \ + \ + _fields \ + return __event_len; \ + \ +error: \ + __attribute__((unused)); \ + return -1; \ +} + +#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS +#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS(_name, _locvar, _code_pre, _fields, _code_post) \ +static inline ssize_t __event_get_size__##_name(void *__tp_locvar) \ +{ \ + size_t __event_len = 0; \ + unsigned int __dynamic_len_idx __attribute__((unused)) = 0; \ + struct { _locvar } *tp_locvar __attribute__((unused)) = __tp_locvar; \ + \ + _fields \ + return __event_len; \ + \ +error: \ + __attribute__((unused)); \ + return -1; \ +} + +#include TRACE_INCLUDE(TRACE_INCLUDE_FILE) + + +/* + * Stage 4.1 of tracepoint event generation. + * + * Create static inline function that layout the filter stack data. + * We make both write and nowrite data available to the filter. + */ + +/* Reset all macros within TRACEPOINT_EVENT */ +#include +#include +#include + +#undef _ctf_integer_ext_fetched +#define _ctf_integer_ext_fetched(_type, _item, _src, _byte_order, _base, _nowrite) \ + if (lttng_is_signed_type(_type)) { \ + int64_t __ctf_tmp_int64; \ + switch (sizeof(_type)) { \ + case 1: \ + { \ + union { _type t; int8_t v; } __tmp = { (_type) (_src) }; \ + __ctf_tmp_int64 = (int64_t) __tmp.v; \ + break; \ + } \ + case 2: \ + { \ + union { _type t; int16_t v; } __tmp = { (_type) (_src) }; \ + if (_byte_order != __BYTE_ORDER) \ + __swab16s(&__tmp.v); \ + __ctf_tmp_int64 = (int64_t) __tmp.v; \ + break; \ + } \ + case 4: \ + { \ + union { _type t; int32_t v; } __tmp = { (_type) (_src) }; \ + if (_byte_order != __BYTE_ORDER) \ + __swab32s(&__tmp.v); \ + __ctf_tmp_int64 = (int64_t) __tmp.v; \ + break; \ + } \ + case 8: \ + { \ + union { _type t; int64_t v; } __tmp = { (_type) (_src) }; \ + if (_byte_order != __BYTE_ORDER) \ + __swab64s(&__tmp.v); \ + __ctf_tmp_int64 = (int64_t) __tmp.v; \ + break; \ + } \ + default: \ + BUG_ON(1); \ + }; \ + memcpy(__stack_data, &__ctf_tmp_int64, sizeof(int64_t)); \ + } else { \ + uint64_t __ctf_tmp_uint64; \ + switch (sizeof(_type)) { \ + case 1: \ + { \ + union { _type t; uint8_t v; } __tmp = { (_type) (_src) }; \ + __ctf_tmp_uint64 = (uint64_t) __tmp.v; \ + break; \ + } \ + case 2: \ + { \ + union { _type t; uint16_t v; } __tmp = { (_type) (_src) }; \ + if (_byte_order != __BYTE_ORDER) \ + __swab16s(&__tmp.v); \ + __ctf_tmp_uint64 = (uint64_t) __tmp.v; \ + break; \ + } \ + case 4: \ + { \ + union { _type t; uint32_t v; } __tmp = { (_type) (_src) }; \ + if (_byte_order != __BYTE_ORDER) \ + __swab32s(&__tmp.v); \ + __ctf_tmp_uint64 = (uint64_t) __tmp.v; \ + break; \ + } \ + case 8: \ + { \ + union { _type t; uint64_t v; } __tmp = { (_type) (_src) }; \ + if (_byte_order != __BYTE_ORDER) \ + __swab64s(&__tmp.v); \ + __ctf_tmp_uint64 = (uint64_t) __tmp.v; \ + break; \ + } \ + default: \ + BUG_ON(1); \ + }; \ + memcpy(__stack_data, &__ctf_tmp_uint64, sizeof(uint64_t)); \ + } \ + __stack_data += sizeof(int64_t); + +#undef _ctf_integer_ext_isuser0 +#define _ctf_integer_ext_isuser0(_type, _item, _src, _byte_order, _base, _nowrite) \ + _ctf_integer_ext_fetched(_type, _item, _src, _byte_order, _base, _nowrite) + +#undef _ctf_integer_ext_isuser1 +#define _ctf_integer_ext_isuser1(_type, _item, _user_src, _byte_order, _base, _nowrite) \ +{ \ + union { \ + char __array[sizeof(_user_src)]; \ + __typeof__(_user_src) __v; \ + } __tmp_fetch; \ + if (lib_ring_buffer_copy_from_user_check_nofault(__tmp_fetch.__array, \ + &(_user_src), sizeof(_user_src))) \ + memset(__tmp_fetch.__array, 0, sizeof(__tmp_fetch.__array)); \ + _ctf_integer_ext_fetched(_type, _item, __tmp_fetch.__v, _byte_order, _base, _nowrite) \ +} + +#undef _ctf_integer_ext +#define _ctf_integer_ext(_type, _item, _user_src, _byte_order, _base, _user, _nowrite) \ + _ctf_integer_ext_isuser##_user(_type, _item, _user_src, _byte_order, _base, _nowrite) + +#undef _ctf_array_encoded +#define _ctf_array_encoded(_type, _item, _src, _length, _encoding, _byte_order, _base, _user, _nowrite) \ + { \ + unsigned long __ctf_tmp_ulong = (unsigned long) (_length); \ + const void *__ctf_tmp_ptr = (_src); \ + memcpy(__stack_data, &__ctf_tmp_ulong, sizeof(unsigned long)); \ + __stack_data += sizeof(unsigned long); \ + memcpy(__stack_data, &__ctf_tmp_ptr, sizeof(void *)); \ + __stack_data += sizeof(void *); \ + } + +#undef _ctf_array_bitfield +#define _ctf_array_bitfield(_type, _item, _src, _length, _user, _nowrite) \ + _ctf_array_encoded(_type, _item, _src, _length, none, __LITTLE_ENDIAN, 0, _user, _nowrite) + +#undef _ctf_sequence_encoded +#define _ctf_sequence_encoded(_type, _item, _src, _length_type, \ + _src_length, _encoding, _byte_order, _base, _user, _nowrite) \ + { \ + unsigned long __ctf_tmp_ulong = (unsigned long) (_src_length); \ + const void *__ctf_tmp_ptr = (_src); \ + memcpy(__stack_data, &__ctf_tmp_ulong, sizeof(unsigned long)); \ + __stack_data += sizeof(unsigned long); \ + memcpy(__stack_data, &__ctf_tmp_ptr, sizeof(void *)); \ + __stack_data += sizeof(void *); \ + } + +#undef _ctf_sequence_bitfield +#define _ctf_sequence_bitfield(_type, _item, _src, \ + _length_type, _src_length, \ + _user, _nowrite) \ + _ctf_sequence_encoded(_type, _item, _src, _length_type, _src_length, \ + none, __LITTLE_ENDIAN, 10, _user, _nowrite) + +#undef _ctf_string +#define _ctf_string(_item, _src, _user, _nowrite) \ + { \ + const void *__ctf_tmp_ptr = \ + ((_src) ? (_src) : __LTTNG_NULL_STRING); \ + memcpy(__stack_data, &__ctf_tmp_ptr, sizeof(void *)); \ + __stack_data += sizeof(void *); \ + } + +#undef _ctf_enum +#define _ctf_enum(_name, _type, _item, _src, _user, _nowrite) \ + _ctf_integer_ext(_type, _item, _src, __BYTE_ORDER, 10, _user, _nowrite) + +#undef TP_PROTO +#define TP_PROTO(...) __VA_ARGS__ + +#undef TP_FIELDS +#define TP_FIELDS(...) __VA_ARGS__ + +#undef TP_locvar +#define TP_locvar(...) __VA_ARGS__ + +#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS +#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS(_name, _locvar, _code_pre, _fields, _code_post) \ +static inline \ +void __event_prepare_filter_stack__##_name(char *__stack_data, \ + void *__tp_locvar) \ +{ \ + struct { _locvar } *tp_locvar __attribute__((unused)) = __tp_locvar; \ + \ + _fields \ +} + +#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE +#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE(_name, _proto, _args, _locvar, _code_pre, _fields, _code_post) \ +static inline \ +void __event_prepare_filter_stack__##_name(char *__stack_data, \ + void *__tp_locvar, _proto) \ +{ \ + struct { _locvar } *tp_locvar __attribute__((unused)) = __tp_locvar; \ + \ + _fields \ +} + +#include TRACE_INCLUDE(TRACE_INCLUDE_FILE) + +/* + * Stage 5 of the trace events. + * + * Create static inline function that calculates event payload alignment. + */ + +/* Reset all macros within TRACEPOINT_EVENT */ +#include +#include + +#undef _ctf_integer_ext +#define _ctf_integer_ext(_type, _item, _src, _byte_order, _base, _user, _nowrite) \ + __event_align = max_t(size_t, __event_align, lttng_alignof(_type)); + +#undef _ctf_array_encoded +#define _ctf_array_encoded(_type, _item, _src, _length, _encoding, _byte_order, _base, _user, _nowrite) \ + __event_align = max_t(size_t, __event_align, lttng_alignof(_type)); + +#undef _ctf_array_bitfield +#define _ctf_array_bitfield(_type, _item, _src, _length, _user, _nowrite) \ + _ctf_array_encoded(_type, _item, _src, _length, none, __LITTLE_ENDIAN, 0, _user, _nowrite) + +#undef _ctf_sequence_encoded +#define _ctf_sequence_encoded(_type, _item, _src, _length_type, \ + _src_length, _encoding, _byte_order, _base, _user, _nowrite) \ + __event_align = max_t(size_t, __event_align, lttng_alignof(_length_type)); \ + __event_align = max_t(size_t, __event_align, lttng_alignof(_type)); + +#undef _ctf_sequence_bitfield +#define _ctf_sequence_bitfield(_type, _item, _src, \ + _length_type, _src_length, \ + _user, _nowrite) \ + _ctf_sequence_encoded(_type, _item, _src, _length_type, _src_length, \ + none, __LITTLE_ENDIAN, 10, _user, _nowrite) + +#undef _ctf_string +#define _ctf_string(_item, _src, _user, _nowrite) + +#undef _ctf_enum +#define _ctf_enum(_name, _type, _item, _src, _user, _nowrite) \ + _ctf_integer_ext(_type, _item, _src, __BYTE_ORDER, 10, _user, _nowrite) + +#undef ctf_align +#define ctf_align(_type) \ + __event_align = max_t(size_t, __event_align, lttng_alignof(_type)); + +#undef TP_PROTO +#define TP_PROTO(...) __VA_ARGS__ + +#undef TP_FIELDS +#define TP_FIELDS(...) __VA_ARGS__ + +#undef TP_locvar +#define TP_locvar(...) __VA_ARGS__ + +#undef ctf_custom_field +#define ctf_custom_field(_type, _item, _code) _code + +#undef ctf_custom_code +#define ctf_custom_code(...) \ + { \ + __VA_ARGS__ \ + } + +#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE +#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE(_name, _proto, _args, _locvar, _code_pre, _fields, _code_post) \ +static inline size_t __event_get_align__##_name(void *__tp_locvar, _proto) \ +{ \ + size_t __event_align = 1; \ + struct { _locvar } *tp_locvar __attribute__((unused)) = __tp_locvar; \ + \ + _fields \ + return __event_align; \ +} + +#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS +#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS(_name, _locvar, _code_pre, _fields, _code_post) \ +static inline size_t __event_get_align__##_name(void *__tp_locvar) \ +{ \ + size_t __event_align = 1; \ + struct { _locvar } *tp_locvar __attribute__((unused)) = __tp_locvar; \ + \ + _fields \ + return __event_align; \ +} + +#include TRACE_INCLUDE(TRACE_INCLUDE_FILE) + +/* + * Stage 6 of tracepoint event generation. + * + * Create the probe function. This function calls event size calculation + * and writes event data into the buffer. + */ + +/* Reset all macros within TRACEPOINT_EVENT */ +#include +#include + +#undef _ctf_integer_ext_fetched +#define _ctf_integer_ext_fetched(_type, _item, _src, _byte_order, _base, _nowrite) \ + { \ + _type __tmp = _src; \ + lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(__tmp));\ + __chan->ops->event_write(&__ctx, &__tmp, sizeof(__tmp));\ + } + +#undef _ctf_integer_ext_isuser0 +#define _ctf_integer_ext_isuser0(_type, _item, _src, _byte_order, _base, _nowrite) \ + _ctf_integer_ext_fetched(_type, _item, _src, _byte_order, _base, _nowrite) + +#undef _ctf_integer_ext_isuser1 +#define _ctf_integer_ext_isuser1(_type, _item, _user_src, _byte_order, _base, _nowrite) \ +{ \ + union { \ + char __array[sizeof(_user_src)]; \ + __typeof__(_user_src) __v; \ + } __tmp_fetch; \ + if (lib_ring_buffer_copy_from_user_check_nofault(__tmp_fetch.__array, \ + &(_user_src), sizeof(_user_src))) \ + memset(__tmp_fetch.__array, 0, sizeof(__tmp_fetch.__array)); \ + _ctf_integer_ext_fetched(_type, _item, __tmp_fetch.__v, _byte_order, _base, _nowrite) \ +} + +#undef _ctf_integer_ext +#define _ctf_integer_ext(_type, _item, _user_src, _byte_order, _base, _user, _nowrite) \ + _ctf_integer_ext_isuser##_user(_type, _item, _user_src, _byte_order, _base, _nowrite) + +#undef _ctf_array_encoded +#define _ctf_array_encoded(_type, _item, _src, _length, _encoding, _byte_order, _base, _user, _nowrite) \ + lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(_type)); \ + if (_user) { \ + __chan->ops->event_write_from_user(&__ctx, _src, sizeof(_type) * (_length)); \ + } else { \ + __chan->ops->event_write(&__ctx, _src, sizeof(_type) * (_length)); \ + } + +#if (__BYTE_ORDER == __LITTLE_ENDIAN) +#undef _ctf_array_bitfield +#define _ctf_array_bitfield(_type, _item, _src, _length, _user, _nowrite) \ + lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(_type)); \ + if (_user) { \ + __chan->ops->event_write_from_user(&__ctx, _src, sizeof(_type) * (_length)); \ + } else { \ + __chan->ops->event_write(&__ctx, _src, sizeof(_type) * (_length)); \ + } +#else /* #if (__BYTE_ORDER == __LITTLE_ENDIAN) */ +/* + * For big endian, we need to byteswap into little endian. + */ +#undef _ctf_array_bitfield +#define _ctf_array_bitfield(_type, _item, _src, _length, _user, _nowrite) \ + lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(_type)); \ + { \ + size_t _i; \ + \ + for (_i = 0; _i < (_length); _i++) { \ + _type _tmp; \ + \ + if (_user) { \ + if (get_user(_tmp, (_type *) _src + _i)) \ + _tmp = 0; \ + } else { \ + _tmp = ((_type *) _src)[_i]; \ + } \ + switch (sizeof(_type)) { \ + case 1: \ + break; \ + case 2: \ + _tmp = cpu_to_le16(_tmp); \ + break; \ + case 4: \ + _tmp = cpu_to_le32(_tmp); \ + break; \ + case 8: \ + _tmp = cpu_to_le64(_tmp); \ + break; \ + default: \ + BUG_ON(1); \ + } \ + __chan->ops->event_write(&__ctx, &_tmp, sizeof(_type)); \ + } \ + } +#endif /* #else #if (__BYTE_ORDER == __LITTLE_ENDIAN) */ + +#undef _ctf_sequence_encoded +#define _ctf_sequence_encoded(_type, _item, _src, _length_type, \ + _src_length, _encoding, _byte_order, _base, _user, _nowrite) \ + { \ + _length_type __tmpl = this_cpu_ptr(<tng_dynamic_len_stack)->stack[__dynamic_len_idx]; \ + lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(_length_type));\ + __chan->ops->event_write(&__ctx, &__tmpl, sizeof(_length_type));\ + } \ + lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(_type)); \ + if (_user) { \ + __chan->ops->event_write_from_user(&__ctx, _src, \ + sizeof(_type) * __get_dynamic_len(dest)); \ + } else { \ + __chan->ops->event_write(&__ctx, _src, \ + sizeof(_type) * __get_dynamic_len(dest)); \ + } + +#if (__BYTE_ORDER == __LITTLE_ENDIAN) +#undef _ctf_sequence_bitfield +#define _ctf_sequence_bitfield(_type, _item, _src, \ + _length_type, _src_length, \ + _user, _nowrite) \ + { \ + _length_type __tmpl = this_cpu_ptr(<tng_dynamic_len_stack)->stack[__dynamic_len_idx] * sizeof(_type) * CHAR_BIT; \ + lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(_length_type));\ + __chan->ops->event_write(&__ctx, &__tmpl, sizeof(_length_type));\ + } \ + lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(_type)); \ + if (_user) { \ + __chan->ops->event_write_from_user(&__ctx, _src, \ + sizeof(_type) * __get_dynamic_len(dest)); \ + } else { \ + __chan->ops->event_write(&__ctx, _src, \ + sizeof(_type) * __get_dynamic_len(dest)); \ + } +#else /* #if (__BYTE_ORDER == __LITTLE_ENDIAN) */ +/* + * For big endian, we need to byteswap into little endian. + */ +#undef _ctf_sequence_bitfield +#define _ctf_sequence_bitfield(_type, _item, _src, \ + _length_type, _src_length, \ + _user, _nowrite) \ + { \ + _length_type __tmpl = this_cpu_ptr(<tng_dynamic_len_stack)->stack[__dynamic_len_idx] * sizeof(_type) * CHAR_BIT; \ + lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(_length_type));\ + __chan->ops->event_write(&__ctx, &__tmpl, sizeof(_length_type));\ + } \ + lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(_type)); \ + { \ + size_t _i, _length; \ + \ + _length = __get_dynamic_len(dest); \ + for (_i = 0; _i < _length; _i++) { \ + _type _tmp; \ + \ + if (_user) { \ + if (get_user(_tmp, (_type *) _src + _i)) \ + _tmp = 0; \ + } else { \ + _tmp = ((_type *) _src)[_i]; \ + } \ + switch (sizeof(_type)) { \ + case 1: \ + break; \ + case 2: \ + _tmp = cpu_to_le16(_tmp); \ + break; \ + case 4: \ + _tmp = cpu_to_le32(_tmp); \ + break; \ + case 8: \ + _tmp = cpu_to_le64(_tmp); \ + break; \ + default: \ + BUG_ON(1); \ + } \ + __chan->ops->event_write(&__ctx, &_tmp, sizeof(_type)); \ + } \ + } +#endif /* #else #if (__BYTE_ORDER == __LITTLE_ENDIAN) */ + +#undef _ctf_string +#define _ctf_string(_item, _src, _user, _nowrite) \ + if (_user) { \ + lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(*(_src))); \ + __chan->ops->event_strcpy_from_user(&__ctx, _src, \ + __get_dynamic_len(dest)); \ + } else { \ + const char *__ctf_tmp_string = \ + ((_src) ? (_src) : __LTTNG_NULL_STRING); \ + lib_ring_buffer_align_ctx(&__ctx, \ + lttng_alignof(*__ctf_tmp_string)); \ + __chan->ops->event_strcpy(&__ctx, __ctf_tmp_string, \ + __get_dynamic_len(dest)); \ + } + +#undef _ctf_enum +#define _ctf_enum(_name, _type, _item, _src, _user, _nowrite) \ + _ctf_integer_ext(_type, _item, _src, __BYTE_ORDER, 10, _user, _nowrite) + +#undef ctf_align +#define ctf_align(_type) \ + lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(_type)); + +#undef ctf_custom_field +#define ctf_custom_field(_type, _item, _code) _code + +#undef ctf_custom_code +#define ctf_custom_code(...) \ + { \ + __VA_ARGS__ \ + } + +/* Beware: this get len actually consumes the len value */ +#undef __get_dynamic_len +#define __get_dynamic_len(field) this_cpu_ptr(<tng_dynamic_len_stack)->stack[__dynamic_len_idx++] + +#undef TP_PROTO +#define TP_PROTO(...) __VA_ARGS__ + +#undef TP_ARGS +#define TP_ARGS(...) __VA_ARGS__ + +#undef TP_FIELDS +#define TP_FIELDS(...) __VA_ARGS__ + +#undef TP_locvar +#define TP_locvar(...) __VA_ARGS__ + +#undef TP_code_pre +#define TP_code_pre(...) __VA_ARGS__ + +#undef TP_code_post +#define TP_code_post(...) __VA_ARGS__ + +/* + * For state dump, check that "session" argument (mandatory) matches the + * session this event belongs to. Ensures that we write state dump data only + * into the started session, not into all sessions. + */ +#ifdef TP_SESSION_CHECK +#define _TP_SESSION_CHECK(session, csession) (session == csession) +#else /* TP_SESSION_CHECK */ +#define _TP_SESSION_CHECK(session, csession) 1 +#endif /* TP_SESSION_CHECK */ + +/* + * Using twice size for filter stack data to hold size and pointer for + * each field (worse case). For integers, max size required is 64-bit. + * Same for double-precision floats. Those fit within + * 2*sizeof(unsigned long) for all supported architectures. + * Perform UNION (||) of filter runtime list. + */ +#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE +#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE(_name, _proto, _args, _locvar, _code_pre, _fields, _code_post) \ +static void __event_probe__##_name(void *__data, _proto) \ +{ \ + struct probe_local_vars { _locvar }; \ + struct lttng_event *__event = __data; \ + struct lttng_probe_ctx __lttng_probe_ctx = { \ + .event = __event, \ + .interruptible = !irqs_disabled(), \ + }; \ + struct lttng_channel *__chan = __event->chan; \ + struct lttng_session *__session = __chan->session; \ + struct lib_ring_buffer_ctx __ctx; \ + ssize_t __event_len; \ + size_t __event_align; \ + size_t __orig_dynamic_len_offset, __dynamic_len_idx __attribute__((unused)); \ + union { \ + size_t __dynamic_len_removed[ARRAY_SIZE(__event_fields___##_name)]; \ + char __filter_stack_data[2 * sizeof(unsigned long) * ARRAY_SIZE(__event_fields___##_name)]; \ + } __stackvar; \ + int __ret; \ + struct probe_local_vars __tp_locvar; \ + struct probe_local_vars *tp_locvar __attribute__((unused)) = \ + &__tp_locvar; \ + struct lttng_id_tracker_rcu *__lf; \ + \ + if (!_TP_SESSION_CHECK(session, __session)) \ + return; \ + if (unlikely(!READ_ONCE(__session->active))) \ + return; \ + if (unlikely(!READ_ONCE(__chan->enabled))) \ + return; \ + if (unlikely(!READ_ONCE(__event->enabled))) \ + return; \ + __lf = rcu_dereference_raw_check(__session->pid_tracker.p); \ + if (__lf && likely(!lttng_id_tracker_lookup(__lf, current->tgid))) \ + return; \ + __lf = rcu_dereference_raw_check(__session->vpid_tracker.p); \ + if (__lf && likely(!lttng_id_tracker_lookup(__lf, task_tgid_vnr(current)))) \ + return; \ + __lf = rcu_dereference_raw_check(__session->uid_tracker.p); \ + if (__lf && likely(!lttng_id_tracker_lookup(__lf, \ + lttng_current_uid()))) \ + return; \ + __lf = rcu_dereference_raw_check(__session->vuid_tracker.p); \ + if (__lf && likely(!lttng_id_tracker_lookup(__lf, \ + lttng_current_vuid()))) \ + return; \ + __lf = rcu_dereference_raw_check(__session->gid_tracker.p); \ + if (__lf && likely(!lttng_id_tracker_lookup(__lf, \ + lttng_current_gid()))) \ + return; \ + __lf = rcu_dereference_raw_check(__session->vgid_tracker.p); \ + if (__lf && likely(!lttng_id_tracker_lookup(__lf, \ + lttng_current_vgid()))) \ + return; \ + __orig_dynamic_len_offset = this_cpu_ptr(<tng_dynamic_len_stack)->offset; \ + __dynamic_len_idx = __orig_dynamic_len_offset; \ + _code_pre \ + if (unlikely(!list_empty(&__event->bytecode_runtime_head))) { \ + struct lttng_bytecode_runtime *bc_runtime; \ + int __filter_record = __event->has_enablers_without_bytecode; \ + \ + __event_prepare_filter_stack__##_name(__stackvar.__filter_stack_data, \ + tp_locvar, _args); \ + list_for_each_entry_rcu_notrace(bc_runtime, &__event->bytecode_runtime_head, node) { \ + if (unlikely(bc_runtime->filter(bc_runtime, &__lttng_probe_ctx, \ + __stackvar.__filter_stack_data) & LTTNG_FILTER_RECORD_FLAG)) { \ + __filter_record = 1; \ + break; \ + } \ + } \ + if (likely(!__filter_record)) \ + goto __post; \ + } \ + __event_len = __event_get_size__##_name(tp_locvar, _args); \ + if (unlikely(__event_len < 0)) { \ + lib_ring_buffer_lost_event_too_big(__chan->chan); \ + goto __post; \ + } \ + __event_align = __event_get_align__##_name(tp_locvar, _args); \ + lib_ring_buffer_ctx_init(&__ctx, __chan->chan, &__lttng_probe_ctx, __event_len, \ + __event_align, -1); \ + __ret = __chan->ops->event_reserve(&__ctx, __event->id); \ + if (__ret < 0) \ + goto __post; \ + _fields \ + __chan->ops->event_commit(&__ctx); \ +__post: \ + _code_post \ + barrier(); /* use before un-reserve. */ \ + this_cpu_ptr(<tng_dynamic_len_stack)->offset = __orig_dynamic_len_offset; \ + return; \ +} + +#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS +#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS(_name, _locvar, _code_pre, _fields, _code_post) \ +static void __event_probe__##_name(void *__data) \ +{ \ + struct probe_local_vars { _locvar }; \ + struct lttng_event *__event = __data; \ + struct lttng_probe_ctx __lttng_probe_ctx = { \ + .event = __event, \ + .interruptible = !irqs_disabled(), \ + }; \ + struct lttng_channel *__chan = __event->chan; \ + struct lttng_session *__session = __chan->session; \ + struct lib_ring_buffer_ctx __ctx; \ + ssize_t __event_len; \ + size_t __event_align; \ + size_t __orig_dynamic_len_offset, __dynamic_len_idx __attribute__((unused)); \ + union { \ + size_t __dynamic_len_removed[ARRAY_SIZE(__event_fields___##_name)]; \ + char __filter_stack_data[2 * sizeof(unsigned long) * ARRAY_SIZE(__event_fields___##_name)]; \ + } __stackvar; \ + int __ret; \ + struct probe_local_vars __tp_locvar; \ + struct probe_local_vars *tp_locvar __attribute__((unused)) = \ + &__tp_locvar; \ + struct lttng_id_tracker_rcu *__lf; \ + \ + if (!_TP_SESSION_CHECK(session, __session)) \ + return; \ + if (unlikely(!READ_ONCE(__session->active))) \ + return; \ + if (unlikely(!READ_ONCE(__chan->enabled))) \ + return; \ + if (unlikely(!READ_ONCE(__event->enabled))) \ + return; \ + __lf = rcu_dereference_raw_check(__session->pid_tracker.p); \ + if (__lf && likely(!lttng_id_tracker_lookup(__lf, current->tgid))) \ + return; \ + __lf = rcu_dereference_raw_check(__session->vpid_tracker.p); \ + if (__lf && likely(!lttng_id_tracker_lookup(__lf, task_tgid_vnr(current)))) \ + return; \ + __lf = rcu_dereference_raw_check(__session->uid_tracker.p); \ + if (__lf && likely(!lttng_id_tracker_lookup(__lf, \ + lttng_current_uid()))) \ + return; \ + __lf = rcu_dereference_raw_check(__session->vuid_tracker.p); \ + if (__lf && likely(!lttng_id_tracker_lookup(__lf, \ + lttng_current_vuid()))) \ + return; \ + __lf = rcu_dereference_raw_check(__session->gid_tracker.p); \ + if (__lf && likely(!lttng_id_tracker_lookup(__lf, \ + lttng_current_gid()))) \ + return; \ + __lf = rcu_dereference_raw_check(__session->vgid_tracker.p); \ + if (__lf && likely(!lttng_id_tracker_lookup(__lf, \ + lttng_current_vgid()))) \ + return; \ + __orig_dynamic_len_offset = this_cpu_ptr(<tng_dynamic_len_stack)->offset; \ + __dynamic_len_idx = __orig_dynamic_len_offset; \ + _code_pre \ + if (unlikely(!list_empty(&__event->bytecode_runtime_head))) { \ + struct lttng_bytecode_runtime *bc_runtime; \ + int __filter_record = __event->has_enablers_without_bytecode; \ + \ + __event_prepare_filter_stack__##_name(__stackvar.__filter_stack_data, \ + tp_locvar); \ + list_for_each_entry_rcu_notrace(bc_runtime, &__event->bytecode_runtime_head, node) { \ + if (unlikely(bc_runtime->filter(bc_runtime, &__lttng_probe_ctx, \ + __stackvar.__filter_stack_data) & LTTNG_FILTER_RECORD_FLAG)) { \ + __filter_record = 1; \ + break; \ + } \ + } \ + if (likely(!__filter_record)) \ + goto __post; \ + } \ + __event_len = __event_get_size__##_name(tp_locvar); \ + if (unlikely(__event_len < 0)) { \ + lib_ring_buffer_lost_event_too_big(__chan->chan); \ + goto __post; \ + } \ + __event_align = __event_get_align__##_name(tp_locvar); \ + lib_ring_buffer_ctx_init(&__ctx, __chan->chan, &__lttng_probe_ctx, __event_len, \ + __event_align, -1); \ + __ret = __chan->ops->event_reserve(&__ctx, __event->id); \ + if (__ret < 0) \ + goto __post; \ + _fields \ + __chan->ops->event_commit(&__ctx); \ +__post: \ + _code_post \ + barrier(); /* use before un-reserve. */ \ + this_cpu_ptr(<tng_dynamic_len_stack)->offset = __orig_dynamic_len_offset; \ + return; \ +} + +#include TRACE_INCLUDE(TRACE_INCLUDE_FILE) + +#undef __get_dynamic_len + +/* + * Stage 7 of the trace events. + * + * Create event descriptions. + */ + +/* Named field types must be defined in lttng-types.h */ + +#include /* Reset all macros within LTTNG_TRACEPOINT_EVENT */ + +#ifndef TP_PROBE_CB +#define TP_PROBE_CB(_template) &__event_probe__##_template +#endif + +#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS +#define LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS(_template, _name, _map) \ +static const struct lttng_event_desc __event_desc___##_map = { \ + .fields = __event_fields___##_template, \ + .name = #_map, \ + .kname = #_name, \ + .probe_callback = (void *) TP_PROBE_CB(_template), \ + .nr_fields = ARRAY_SIZE(__event_fields___##_template), \ + .owner = THIS_MODULE, \ +}; + +#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP +#define LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(_template, _name, _map, _proto, _args) \ + LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS(_template, _name, _map) + +#include TRACE_INCLUDE(TRACE_INCLUDE_FILE) + +/* + * Stage 8 of the trace events. + * + * Create an array of event description pointers. + */ + +#include /* Reset all macros within LTTNG_TRACEPOINT_EVENT */ + +#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS +#define LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS(_template, _name, _map) \ + &__event_desc___##_map, + +#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP +#define LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(_template, _name, _map, _proto, _args) \ + LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS(_template, _name, _map) + +#define TP_ID1(_token, _system) _token##_system +#define TP_ID(_token, _system) TP_ID1(_token, _system) + +static const struct lttng_event_desc *TP_ID(__event_desc___, TRACE_SYSTEM)[] = { +#include TRACE_INCLUDE(TRACE_INCLUDE_FILE) +}; + +#undef TP_ID1 +#undef TP_ID + +/* + * Stage 9 of the trace events. + * + * Create a toplevel descriptor for the whole probe. + */ + +#define TP_ID1(_token, _system) _token##_system +#define TP_ID(_token, _system) TP_ID1(_token, _system) + +/* non-const because list head will be modified when registered. */ +static __used struct lttng_probe_desc TP_ID(__probe_desc___, TRACE_SYSTEM) = { + .provider = __stringify(TRACE_SYSTEM), + .event_desc = TP_ID(__event_desc___, TRACE_SYSTEM), + .nr_events = ARRAY_SIZE(TP_ID(__event_desc___, TRACE_SYSTEM)), + .head = { NULL, NULL }, + .lazy_init_head = { NULL, NULL }, + .lazy = 0, +}; + +#undef TP_ID1 +#undef TP_ID + +/* + * Stage 10 of the trace events. + * + * Register/unregister probes at module load/unload. + */ + +#include /* Reset all macros within LTTNG_TRACEPOINT_EVENT */ + +#define TP_ID1(_token, _system) _token##_system +#define TP_ID(_token, _system) TP_ID1(_token, _system) +#define module_init_eval1(_token, _system) module_init(_token##_system) +#define module_init_eval(_token, _system) module_init_eval1(_token, _system) +#define module_exit_eval1(_token, _system) module_exit(_token##_system) +#define module_exit_eval(_token, _system) module_exit_eval1(_token, _system) + +#ifndef TP_MODULE_NOINIT +static int TP_ID(__lttng_events_init__, TRACE_SYSTEM)(void) +{ + return lttng_probe_register(&TP_ID(__probe_desc___, TRACE_SYSTEM)); +} + +static void TP_ID(__lttng_events_exit__, TRACE_SYSTEM)(void) +{ + lttng_probe_unregister(&TP_ID(__probe_desc___, TRACE_SYSTEM)); +} + +#ifndef TP_MODULE_NOAUTOLOAD +module_init_eval(__lttng_events_init__, TRACE_SYSTEM); +module_exit_eval(__lttng_events_exit__, TRACE_SYSTEM); +#endif + +#endif + +#undef module_init_eval +#undef module_exit_eval +#undef TP_ID1 +#undef TP_ID + +#undef TP_PROTO +#undef TP_ARGS diff --git a/include/lttng/lttng-tracepoint-event.h b/include/lttng/lttng-tracepoint-event.h new file mode 100644 index 00000000..1a66245e --- /dev/null +++ b/include/lttng/lttng-tracepoint-event.h @@ -0,0 +1,51 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) + * + * lttng-tracepoint-event.h + * + * Copyright (C) 2014 Mathieu Desnoyers + */ + +#ifndef LTTNG_TRACEPOINT_EVENT_H +#define LTTNG_TRACEPOINT_EVENT_H + +#include + +/* + * If code defines LTTNG_INSTRUMENTATION before including the instrumentation + * header, generate the instrumentation static inlines. Else, it means + * we are a probe for the Linux kernel, and it is the probe responsibility + * to have already included the Linux kernel instrumentation header. + */ +#ifdef LTTNG_INSTRUMENTATION +#define _LTTNG_INSTRUMENTATION(...) __VA_ARGS__ +#else +#define _LTTNG_INSTRUMENTATION(...) +#endif + +#define LTTNG_TRACEPOINT_EVENT(name, proto, args, fields) \ + _LTTNG_INSTRUMENTATION(DECLARE_TRACE(name, PARAMS(proto), PARAMS(args))) +#define LTTNG_TRACEPOINT_EVENT_CODE(name, proto, args, _locvar, _code_pre, fields, _code_post) \ + _LTTNG_INSTRUMENTATION(DECLARE_TRACE(name, PARAMS(proto), PARAMS(args))) +#define LTTNG_TRACEPOINT_EVENT_CODE_MAP(name, map, proto, args, _locvar, _code_pre, fields, _code_post) \ + _LTTNG_INSTRUMENTATION(DECLARE_TRACE(name, PARAMS(proto), PARAMS(args))) +#define LTTNG_TRACEPOINT_EVENT_MAP(name, map, proto, args, fields) \ + _LTTNG_INSTRUMENTATION(DECLARE_TRACE(name, PARAMS(proto), PARAMS(args))) +#define LTTNG_TRACEPOINT_EVENT_MAP_NOARGS(name, map, fields) \ + _LTTNG_INSTRUMENTATION(DECLARE_TRACE_NOARGS(name)) + +#define LTTNG_TRACEPOINT_EVENT_CLASS(name, proto, args, fields) +#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE(_name, _proto, _args, _locvar, _code_pre, _fields, _code_post) +#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS(_name, _locvar, _code_pre, _fields, _code_post) + +#define LTTNG_TRACEPOINT_EVENT_INSTANCE(template, name, proto, args) \ + _LTTNG_INSTRUMENTATION(DECLARE_TRACE(name, PARAMS(proto), PARAMS(args))) +#define LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(template, name) \ + _LTTNG_INSTRUMENTATION(DECLARE_TRACE_NOARGS(name)) +#define LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(_template, _name, _map, _proto, _args) \ + _LTTNG_INSTRUMENTATION(DECLARE_TRACE(name, PARAMS(proto), PARAMS(args))) +#define LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS(_template, _name, _map) \ + _LTTNG_INSTRUMENTATION(DECLARE_TRACE_NOARGS(name)) + +#define LTTNG_TRACEPOINT_ENUM(_name, _values) + +#endif /* LTTNG_TRACEPOINT_EVENT_H */ diff --git a/include/lttng/lttng-tracepoint.h b/include/lttng/lttng-tracepoint.h new file mode 100644 index 00000000..12cc5954 --- /dev/null +++ b/include/lttng/lttng-tracepoint.h @@ -0,0 +1,18 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) + * + * lttng-tracepoint.h + * + * LTTng adaptation layer for Linux kernel 3.15+ tracepoints. + * + * Copyright (C) 2014 Mathieu Desnoyers + */ + +#ifndef _LTTNG_TRACEPOINT_H +#define _LTTNG_TRACEPOINT_H + +int lttng_tracepoint_probe_register(const char *name, void *probe, void *data); +int lttng_tracepoint_probe_unregister(const char *name, void *probe, void *data); +int lttng_tracepoint_init(void); +void lttng_tracepoint_exit(void); + +#endif /* _LTTNG_TRACEPOINT_H */ diff --git a/include/lttng/lttng-tracer-core.h b/include/lttng/lttng-tracer-core.h new file mode 100644 index 00000000..18716738 --- /dev/null +++ b/include/lttng/lttng-tracer-core.h @@ -0,0 +1,28 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) + * + * lttng-tracer-core.h + * + * This contains the core definitions for the Linux Trace Toolkit Next + * Generation tracer. + * + * Copyright (C) 2005-2012 Mathieu Desnoyers + */ + +#ifndef LTTNG_TRACER_CORE_H +#define LTTNG_TRACER_CORE_H + +#include +#include + +#ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS +/* Align data on its natural alignment */ +#define RING_BUFFER_ALIGN +#endif + +#include + +struct lttng_session; +struct lttng_channel; +struct lttng_event; + +#endif /* LTTNG_TRACER_CORE_H */ diff --git a/include/lttng/lttng-tracer.h b/include/lttng/lttng-tracer.h new file mode 100644 index 00000000..322b93e2 --- /dev/null +++ b/include/lttng/lttng-tracer.h @@ -0,0 +1,69 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ +#ifndef _LTTNG_TRACER_H +#define _LTTNG_TRACER_H + +/* + * lttng-tracer.h + * + * This contains the definitions for the Linux Trace Toolkit Next + * Generation tracer. + * + * Copyright (C) 2005-2012 Mathieu Desnoyers + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#define LTTNG_MODULES_MAJOR_VERSION 2 +#define LTTNG_MODULES_MINOR_VERSION 12 +#define LTTNG_MODULES_PATCHLEVEL_VERSION 0 +#define LTTNG_MODULES_EXTRAVERSION "-rc1" + +#define LTTNG_VERSION_NAME "(Ta) Meilleure" +#define LTTNG_VERSION_DESCRIPTION "Ta Meilleure is a Northeast IPA beer brewed by Lagabière. Translating to \"Your best one\", this beer gives out strong aromas of passion fruit, lemon, and peaches. Tastewise, expect a lot of fruit, a creamy texture, and a smooth lingering hop bitterness." + +#ifndef CHAR_BIT +#define CHAR_BIT 8 +#endif + +/* Number of bytes to log with a read/write event */ +#define LTTNG_LOG_RW_SIZE 32L +#define LTTNG_MAX_SMALL_SIZE 0xFFFFU + +#ifdef RING_BUFFER_ALIGN +#define lttng_alignof(type) __alignof__(type) +#else +#define lttng_alignof(type) 1 +#endif + +/* Tracer properties */ +#define CTF_MAGIC_NUMBER 0xC1FC1FC1 +#define TSDL_MAGIC_NUMBER 0x75D11D57 + +/* CTF specification version followed */ +#define CTF_SPEC_MAJOR 1 +#define CTF_SPEC_MINOR 8 + +/* + * Number of milliseconds to retry before failing metadata writes on buffer full + * condition. (10 seconds) + */ +#define LTTNG_METADATA_TIMEOUT_MSEC 10000 + +#define LTTNG_RFLAG_EXTENDED RING_BUFFER_RFLAG_END +#define LTTNG_RFLAG_END (LTTNG_RFLAG_EXTENDED << 1) + +#define __LTTNG_COMPOUND_LITERAL(type, ...) (type[]) { __VA_ARGS__ } + +#endif /* _LTTNG_TRACER_H */ diff --git a/include/lttng/lttng-types.h b/include/lttng/lttng-types.h new file mode 100644 index 00000000..2de88735 --- /dev/null +++ b/include/lttng/lttng-types.h @@ -0,0 +1,73 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) + * + * lttng/lttng-types.h + * + * LTTng types. + * + * Copyright (C) 2010-2012 Mathieu Desnoyers + */ + +/* + * Protect against multiple inclusion of structure declarations, but run the + * stages below each time. + */ +#ifndef _LTTNG_PROBES_LTTNG_TYPES_H +#define _LTTNG_PROBES_LTTNG_TYPES_H + +#include +#include +#include +#include + +#endif /* _LTTNG_PROBES_LTTNG_TYPES_H */ + +#undef PARAMS +#define PARAMS(args...) args + +/* Export enumerations */ + +#ifdef STAGE_EXPORT_ENUMS + +#undef TRACE_EVENT_TYPE +#define TRACE_EVENT_TYPE(_name, _abstract_type, args...) + +#undef TRACE_EVENT_ENUM +#define TRACE_EVENT_ENUM(_name, _entries...) \ + const struct lttng_enum_entry __trace_event_enum_##_name[] = { \ + PARAMS(_entries) \ + }; + +/* Enumeration entry (single value) */ +#undef V +#define V(_string) { _string, _string, #_string} + +/* Enumeration entry (range) */ +#undef R +#define R(_string, _range_start, _range_end) \ + { _range_start, _range_end, #_string } + +#endif /* STAGE_EXPORT_ENUMS */ + + +/* Export named types */ + +#ifdef STAGE_EXPORT_TYPES + +#undef TRACE_EVENT_TYPE___enum +#define TRACE_EVENT_TYPE___enum(_name, _container_type) \ + { \ + .name = #_name, \ + .container_type = __type_integer(_container_type, 0, 0, -1, __BYTE_ORDER, 10, none), \ + .entries = __trace_event_enum_##_name, \ + .len = ARRAY_SIZE(__trace_event_enum_##_name), \ + }, + +/* Local declaration */ +#undef TRACE_EVENT_TYPE +#define TRACE_EVENT_TYPE(_name, _abstract_type, args...) \ + TRACE_EVENT_TYPE___##_abstract_type(_name, args) + +#undef TRACE_EVENT_ENUM +#define TRACE_EVENT_ENUM(_name, _entries...) + +#endif /* STAGE_EXPORT_TYPES */ diff --git a/include/lttng/lttng_prio_heap.h b/include/lttng/lttng_prio_heap.h new file mode 100644 index 00000000..f97f33f3 --- /dev/null +++ b/include/lttng/lttng_prio_heap.h @@ -0,0 +1,108 @@ +/* SPDX-License-Identifier: MIT + * + * lttng_prio_heap.h + * + * Priority heap containing pointers. Based on CLRS, chapter 6. + * + * Copyright 2011 - Mathieu Desnoyers + */ + +#ifndef _LTTNG_PRIO_HEAP_H +#define _LTTNG_PRIO_HEAP_H + +#include + +struct lttng_ptr_heap { + size_t len, alloc_len; + void **ptrs; + int (*gt)(void *a, void *b); + gfp_t gfpmask; +}; + +#ifdef DEBUG_HEAP +void lttng_check_heap(const struct lttng_ptr_heap *heap); +#else +static inline +void lttng_check_heap(const struct lttng_ptr_heap *heap) +{ +} +#endif + +/** + * lttng_heap_maximum - return the largest element in the heap + * @heap: the heap to be operated on + * + * Returns the largest element in the heap, without performing any modification + * to the heap structure. Returns NULL if the heap is empty. + */ +static inline void *lttng_heap_maximum(const struct lttng_ptr_heap *heap) +{ + lttng_check_heap(heap); + return heap->len ? heap->ptrs[0] : NULL; +} + +/** + * lttng_heap_init - initialize the heap + * @heap: the heap to initialize + * @alloc_len: number of elements initially allocated + * @gfp: allocation flags + * @gt: function to compare the elements + * + * Returns -ENOMEM if out of memory. + */ +extern int lttng_heap_init(struct lttng_ptr_heap *heap, + size_t alloc_len, gfp_t gfpmask, + int gt(void *a, void *b)); + +/** + * lttng_heap_free - free the heap + * @heap: the heap to free + */ +extern void lttng_heap_free(struct lttng_ptr_heap *heap); + +/** + * lttng_heap_insert - insert an element into the heap + * @heap: the heap to be operated on + * @p: the element to add + * + * Insert an element into the heap. + * + * Returns -ENOMEM if out of memory. + */ +extern int lttng_heap_insert(struct lttng_ptr_heap *heap, void *p); + +/** + * lttng_heap_remove - remove the largest element from the heap + * @heap: the heap to be operated on + * + * Returns the largest element in the heap. It removes this element from the + * heap. Returns NULL if the heap is empty. + */ +extern void *lttng_heap_remove(struct lttng_ptr_heap *heap); + +/** + * lttng_heap_cherrypick - remove a given element from the heap + * @heap: the heap to be operated on + * @p: the element + * + * Remove the given element from the heap. Return the element if present, else + * return NULL. This algorithm has a complexity of O(n), which is higher than + * O(log(n)) provided by the rest of this API. + */ +extern void *lttng_heap_cherrypick(struct lttng_ptr_heap *heap, void *p); + +/** + * lttng_heap_replace_max - replace the the largest element from the heap + * @heap: the heap to be operated on + * @p: the pointer to be inserted as topmost element replacement + * + * Returns the largest element in the heap. It removes this element from the + * heap. The heap is rebalanced only once after the insertion. Returns NULL if + * the heap is empty. + * + * This is the equivalent of calling heap_remove() and then heap_insert(), but + * it only rebalances the heap once. It never allocates memory. + */ +extern void *lttng_heap_replace_max(struct lttng_ptr_heap *heap, void *p); + +#endif /* _LTTNG_PRIO_HEAP_H */ diff --git a/include/ringbuffer/api.h b/include/ringbuffer/api.h index 73aa8746..3cd9f29a 100644 --- a/include/ringbuffer/api.h +++ b/include/ringbuffer/api.h @@ -1,2 +1,24 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ -#include +/* SPDX-License-Identifier: (GPL-2.0-only OR LGPL-2.1-only) + * + * lib/ringbuffer/api.h + * + * Ring Buffer API. + * + * Copyright (C) 2010-2012 Mathieu Desnoyers + */ + +#ifndef _LIB_RING_BUFFER_API_H +#define _LIB_RING_BUFFER_API_H + +#include +#include +#include + +/* + * ring_buffer_frontend_api.h contains static inline functions that depend on + * client static inlines. Hence the inclusion of this >api> header only + * within the client. + */ +#include + +#endif /* _LIB_RING_BUFFER_API_H */ diff --git a/include/ringbuffer/backend.h b/include/ringbuffer/backend.h index 48641606..d01400da 100644 --- a/include/ringbuffer/backend.h +++ b/include/ringbuffer/backend.h @@ -1,2 +1,463 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ -#include +/* SPDX-License-Identifier: (GPL-2.0-only OR LGPL-2.1-only) + * + * lib/ringbuffer/backend.h + * + * Ring buffer backend (API). + * + * Copyright (C) 2010-2012 Mathieu Desnoyers + * + * Credits to Steven Rostedt for proposing to use an extra-subbuffer owned by + * the reader in flight recorder mode. + */ + +#ifndef _LIB_RING_BUFFER_BACKEND_H +#define _LIB_RING_BUFFER_BACKEND_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* Internal helpers */ +#include +#include + +/* Ring buffer backend API */ + +/* Ring buffer backend access (read/write) */ + +extern size_t lib_ring_buffer_read(struct lib_ring_buffer_backend *bufb, + size_t offset, void *dest, size_t len); + +extern int __lib_ring_buffer_copy_to_user(struct lib_ring_buffer_backend *bufb, + size_t offset, void __user *dest, + size_t len); + +extern int lib_ring_buffer_read_cstr(struct lib_ring_buffer_backend *bufb, + size_t offset, void *dest, size_t len); + +extern unsigned long * +lib_ring_buffer_read_get_pfn(struct lib_ring_buffer_backend *bufb, size_t offset, + void ***virt); + +/* + * Return the address where a given offset is located. + * Should be used to get the current subbuffer header pointer. Given we know + * it's never on a page boundary, it's safe to write directly to this address, + * as long as the write is never bigger than a page size. + */ +extern void * +lib_ring_buffer_offset_address(struct lib_ring_buffer_backend *bufb, + size_t offset); +extern void * +lib_ring_buffer_read_offset_address(struct lib_ring_buffer_backend *bufb, + size_t offset); + +/** + * lib_ring_buffer_write - write data to a buffer backend + * @config : ring buffer instance configuration + * @ctx: ring buffer context. (input arguments only) + * @src : source pointer to copy from + * @len : length of data to copy + * + * This function copies "len" bytes of data from a source pointer to a buffer + * backend, at the current context offset. This is more or less a buffer + * backend-specific memcpy() operation. Calls the slow path (_ring_buffer_write) + * if copy is crossing a page boundary. + */ +static inline __attribute__((always_inline)) +void lib_ring_buffer_write(const struct lib_ring_buffer_config *config, + struct lib_ring_buffer_ctx *ctx, + const void *src, size_t len) +{ + struct lib_ring_buffer_backend *bufb = &ctx->buf->backend; + struct channel_backend *chanb = &ctx->chan->backend; + size_t index, pagecpy; + size_t offset = ctx->buf_offset; + struct lib_ring_buffer_backend_pages *backend_pages; + + if (unlikely(!len)) + return; + backend_pages = + lib_ring_buffer_get_backend_pages_from_ctx(config, ctx); + offset &= chanb->buf_size - 1; + index = (offset & (chanb->subbuf_size - 1)) >> PAGE_SHIFT; + pagecpy = min_t(size_t, len, (-offset) & ~PAGE_MASK); + if (likely(pagecpy == len)) + lib_ring_buffer_do_copy(config, + backend_pages->p[index].virt + + (offset & ~PAGE_MASK), + src, len); + else + _lib_ring_buffer_write(bufb, offset, src, len, 0); + ctx->buf_offset += len; +} + +/** + * lib_ring_buffer_memset - write len bytes of c to a buffer backend + * @config : ring buffer instance configuration + * @bufb : ring buffer backend + * @offset : offset within the buffer + * @c : the byte to copy + * @len : number of bytes to copy + * + * This function writes "len" bytes of "c" to a buffer backend, at a specific + * offset. This is more or less a buffer backend-specific memset() operation. + * Calls the slow path (_ring_buffer_memset) if write is crossing a page + * boundary. + */ +static inline +void lib_ring_buffer_memset(const struct lib_ring_buffer_config *config, + struct lib_ring_buffer_ctx *ctx, int c, size_t len) +{ + + struct lib_ring_buffer_backend *bufb = &ctx->buf->backend; + struct channel_backend *chanb = &ctx->chan->backend; + size_t index, pagecpy; + size_t offset = ctx->buf_offset; + struct lib_ring_buffer_backend_pages *backend_pages; + + if (unlikely(!len)) + return; + backend_pages = + lib_ring_buffer_get_backend_pages_from_ctx(config, ctx); + offset &= chanb->buf_size - 1; + index = (offset & (chanb->subbuf_size - 1)) >> PAGE_SHIFT; + pagecpy = min_t(size_t, len, (-offset) & ~PAGE_MASK); + if (likely(pagecpy == len)) + lib_ring_buffer_do_memset(backend_pages->p[index].virt + + (offset & ~PAGE_MASK), + c, len); + else + _lib_ring_buffer_memset(bufb, offset, c, len, 0); + ctx->buf_offset += len; +} + +/* + * Copy up to @len string bytes from @src to @dest. Stop whenever a NULL + * terminating character is found in @src. Returns the number of bytes + * copied. Does *not* terminate @dest with NULL terminating character. + */ +static inline __attribute__((always_inline)) +size_t lib_ring_buffer_do_strcpy(const struct lib_ring_buffer_config *config, + char *dest, const char *src, size_t len) +{ + size_t count; + + for (count = 0; count < len; count++) { + char c; + + /* + * Only read source character once, in case it is + * modified concurrently. + */ + c = READ_ONCE(src[count]); + if (!c) + break; + lib_ring_buffer_do_copy(config, &dest[count], &c, 1); + } + return count; +} + +/* + * Copy up to @len string bytes from @src to @dest. Stop whenever a NULL + * terminating character is found in @src, or when a fault occurs. + * Returns the number of bytes copied. Does *not* terminate @dest with + * NULL terminating character. + * + * This function deals with userspace pointers, it should never be called + * directly without having the src pointer checked with access_ok() + * previously. + */ +static inline __attribute__((always_inline)) +size_t lib_ring_buffer_do_strcpy_from_user_inatomic(const struct lib_ring_buffer_config *config, + char *dest, const char __user *src, size_t len) +{ + size_t count; + + for (count = 0; count < len; count++) { + int ret; + char c; + + ret = __copy_from_user_inatomic(&c, src + count, 1); + if (ret || !c) + break; + lib_ring_buffer_do_copy(config, &dest[count], &c, 1); + } + return count; +} + +/** + * lib_ring_buffer_strcpy - write string data to a buffer backend + * @config : ring buffer instance configuration + * @ctx: ring buffer context. (input arguments only) + * @src : source pointer to copy from + * @len : length of data to copy + * @pad : character to use for padding + * + * This function copies @len - 1 bytes of string data from a source + * pointer to a buffer backend, followed by a terminating '\0' + * character, at the current context offset. This is more or less a + * buffer backend-specific strncpy() operation. If a terminating '\0' + * character is found in @src before @len - 1 characters are copied, pad + * the buffer with @pad characters (e.g. '#'). Calls the slow path + * (_ring_buffer_strcpy) if copy is crossing a page boundary. + */ +static inline +void lib_ring_buffer_strcpy(const struct lib_ring_buffer_config *config, + struct lib_ring_buffer_ctx *ctx, + const char *src, size_t len, int pad) +{ + struct lib_ring_buffer_backend *bufb = &ctx->buf->backend; + struct channel_backend *chanb = &ctx->chan->backend; + size_t index, pagecpy; + size_t offset = ctx->buf_offset; + struct lib_ring_buffer_backend_pages *backend_pages; + + if (unlikely(!len)) + return; + backend_pages = + lib_ring_buffer_get_backend_pages_from_ctx(config, ctx); + offset &= chanb->buf_size - 1; + index = (offset & (chanb->subbuf_size - 1)) >> PAGE_SHIFT; + pagecpy = min_t(size_t, len, (-offset) & ~PAGE_MASK); + if (likely(pagecpy == len)) { + size_t count; + + count = lib_ring_buffer_do_strcpy(config, + backend_pages->p[index].virt + + (offset & ~PAGE_MASK), + src, len - 1); + offset += count; + /* Padding */ + if (unlikely(count < len - 1)) { + size_t pad_len = len - 1 - count; + + lib_ring_buffer_do_memset(backend_pages->p[index].virt + + (offset & ~PAGE_MASK), + pad, pad_len); + offset += pad_len; + } + /* Ending '\0' */ + lib_ring_buffer_do_memset(backend_pages->p[index].virt + + (offset & ~PAGE_MASK), + '\0', 1); + } else { + _lib_ring_buffer_strcpy(bufb, offset, src, len, 0, pad); + } + ctx->buf_offset += len; +} + +/** + * lib_ring_buffer_copy_from_user_inatomic - write userspace data to a buffer backend + * @config : ring buffer instance configuration + * @ctx: ring buffer context. (input arguments only) + * @src : userspace source pointer to copy from + * @len : length of data to copy + * + * This function copies "len" bytes of data from a userspace pointer to a + * buffer backend, at the current context offset. This is more or less a buffer + * backend-specific memcpy() operation. Calls the slow path + * (_ring_buffer_write_from_user_inatomic) if copy is crossing a page boundary. + * Disable the page fault handler to ensure we never try to take the mmap_sem. + */ +static inline __attribute__((always_inline)) +void lib_ring_buffer_copy_from_user_inatomic(const struct lib_ring_buffer_config *config, + struct lib_ring_buffer_ctx *ctx, + const void __user *src, size_t len) +{ + struct lib_ring_buffer_backend *bufb = &ctx->buf->backend; + struct channel_backend *chanb = &ctx->chan->backend; + size_t index, pagecpy; + size_t offset = ctx->buf_offset; + struct lib_ring_buffer_backend_pages *backend_pages; + unsigned long ret; + mm_segment_t old_fs = get_fs(); + + if (unlikely(!len)) + return; + backend_pages = + lib_ring_buffer_get_backend_pages_from_ctx(config, ctx); + offset &= chanb->buf_size - 1; + index = (offset & (chanb->subbuf_size - 1)) >> PAGE_SHIFT; + pagecpy = min_t(size_t, len, (-offset) & ~PAGE_MASK); + + set_fs(KERNEL_DS); + pagefault_disable(); + if (unlikely(!access_ok(src, len))) + goto fill_buffer; + + if (likely(pagecpy == len)) { + ret = lib_ring_buffer_do_copy_from_user_inatomic( + backend_pages->p[index].virt + (offset & ~PAGE_MASK), + src, len); + if (unlikely(ret > 0)) { + /* Copy failed. */ + goto fill_buffer; + } + } else { + _lib_ring_buffer_copy_from_user_inatomic(bufb, offset, src, len, 0); + } + pagefault_enable(); + set_fs(old_fs); + ctx->buf_offset += len; + + return; + +fill_buffer: + pagefault_enable(); + set_fs(old_fs); + /* + * In the error path we call the slow path version to avoid + * the pollution of static inline code. + */ + _lib_ring_buffer_memset(bufb, offset, 0, len, 0); +} + +/** + * lib_ring_buffer_strcpy_from_user_inatomic - write userspace string data to a buffer backend + * @config : ring buffer instance configuration + * @ctx: ring buffer context (input arguments only) + * @src : userspace source pointer to copy from + * @len : length of data to copy + * @pad : character to use for padding + * + * This function copies @len - 1 bytes of string data from a userspace + * source pointer to a buffer backend, followed by a terminating '\0' + * character, at the current context offset. This is more or less a + * buffer backend-specific strncpy() operation. If a terminating '\0' + * character is found in @src before @len - 1 characters are copied, pad + * the buffer with @pad characters (e.g. '#'). Calls the slow path + * (_ring_buffer_strcpy_from_user_inatomic) if copy is crossing a page + * boundary. Disable the page fault handler to ensure we never try to + * take the mmap_sem. + */ +static inline +void lib_ring_buffer_strcpy_from_user_inatomic(const struct lib_ring_buffer_config *config, + struct lib_ring_buffer_ctx *ctx, + const void __user *src, size_t len, int pad) +{ + struct lib_ring_buffer_backend *bufb = &ctx->buf->backend; + struct channel_backend *chanb = &ctx->chan->backend; + size_t index, pagecpy; + size_t offset = ctx->buf_offset; + struct lib_ring_buffer_backend_pages *backend_pages; + mm_segment_t old_fs = get_fs(); + + if (unlikely(!len)) + return; + backend_pages = + lib_ring_buffer_get_backend_pages_from_ctx(config, ctx); + offset &= chanb->buf_size - 1; + index = (offset & (chanb->subbuf_size - 1)) >> PAGE_SHIFT; + pagecpy = min_t(size_t, len, (-offset) & ~PAGE_MASK); + + set_fs(KERNEL_DS); + pagefault_disable(); + if (unlikely(!access_ok(src, len))) + goto fill_buffer; + + if (likely(pagecpy == len)) { + size_t count; + + count = lib_ring_buffer_do_strcpy_from_user_inatomic(config, + backend_pages->p[index].virt + + (offset & ~PAGE_MASK), + src, len - 1); + offset += count; + /* Padding */ + if (unlikely(count < len - 1)) { + size_t pad_len = len - 1 - count; + + lib_ring_buffer_do_memset(backend_pages->p[index].virt + + (offset & ~PAGE_MASK), + pad, pad_len); + offset += pad_len; + } + /* Ending '\0' */ + lib_ring_buffer_do_memset(backend_pages->p[index].virt + + (offset & ~PAGE_MASK), + '\0', 1); + } else { + _lib_ring_buffer_strcpy_from_user_inatomic(bufb, offset, src, + len, 0, pad); + } + pagefault_enable(); + set_fs(old_fs); + ctx->buf_offset += len; + + return; + +fill_buffer: + pagefault_enable(); + set_fs(old_fs); + /* + * In the error path we call the slow path version to avoid + * the pollution of static inline code. + */ + _lib_ring_buffer_memset(bufb, offset, pad, len - 1, 0); + offset += len - 1; + _lib_ring_buffer_memset(bufb, offset, '\0', 1, 0); +} + +/* + * This accessor counts the number of unread records in a buffer. + * It only provides a consistent value if no reads not writes are performed + * concurrently. + */ +static inline +unsigned long lib_ring_buffer_get_records_unread( + const struct lib_ring_buffer_config *config, + struct lib_ring_buffer *buf) +{ + struct lib_ring_buffer_backend *bufb = &buf->backend; + struct lib_ring_buffer_backend_pages *pages; + unsigned long records_unread = 0, sb_bindex, id; + unsigned int i; + + for (i = 0; i < bufb->chan->backend.num_subbuf; i++) { + id = bufb->buf_wsb[i].id; + sb_bindex = subbuffer_id_get_index(config, id); + pages = bufb->array[sb_bindex]; + records_unread += v_read(config, &pages->records_unread); + } + if (config->mode == RING_BUFFER_OVERWRITE) { + id = bufb->buf_rsb.id; + sb_bindex = subbuffer_id_get_index(config, id); + pages = bufb->array[sb_bindex]; + records_unread += v_read(config, &pages->records_unread); + } + return records_unread; +} + +/* + * We use __copy_from_user_inatomic to copy userspace data after + * checking with access_ok() and disabling page faults. + * + * Return 0 if OK, nonzero on error. + */ +static inline +unsigned long lib_ring_buffer_copy_from_user_check_nofault(void *dest, + const void __user *src, + unsigned long len) +{ + unsigned long ret; + mm_segment_t old_fs; + + if (!access_ok(src, len)) + return 1; + old_fs = get_fs(); + set_fs(KERNEL_DS); + pagefault_disable(); + ret = __copy_from_user_inatomic(dest, src, len); + pagefault_enable(); + set_fs(old_fs); + return ret; +} + +#endif /* _LIB_RING_BUFFER_BACKEND_H */ diff --git a/include/ringbuffer/backend_internal.h b/include/ringbuffer/backend_internal.h index 3bb1586e..895dbd9b 100644 --- a/include/ringbuffer/backend_internal.h +++ b/include/ringbuffer/backend_internal.h @@ -1,2 +1,531 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ -#include +/* SPDX-License-Identifier: (GPL-2.0-only OR LGPL-2.1-only) + * + * lib/ringbuffer/backend_internal.h + * + * Ring buffer backend (internal helpers). + * + * Copyright (C) 2008-2012 Mathieu Desnoyers + */ + +#ifndef _LIB_RING_BUFFER_BACKEND_INTERNAL_H +#define _LIB_RING_BUFFER_BACKEND_INTERNAL_H + +#include +#include +#include +#include +#include + +/* Ring buffer backend API presented to the frontend */ + +/* Ring buffer and channel backend create/free */ + +int lib_ring_buffer_backend_create(struct lib_ring_buffer_backend *bufb, + struct channel_backend *chan, int cpu); +void channel_backend_unregister_notifiers(struct channel_backend *chanb); +void lib_ring_buffer_backend_free(struct lib_ring_buffer_backend *bufb); +int channel_backend_init(struct channel_backend *chanb, + const char *name, + const struct lib_ring_buffer_config *config, + void *priv, size_t subbuf_size, + size_t num_subbuf); +void channel_backend_free(struct channel_backend *chanb); + +void lib_ring_buffer_backend_reset(struct lib_ring_buffer_backend *bufb); +void channel_backend_reset(struct channel_backend *chanb); + +int lib_ring_buffer_backend_init(void); +void lib_ring_buffer_backend_exit(void); + +extern void _lib_ring_buffer_write(struct lib_ring_buffer_backend *bufb, + size_t offset, const void *src, size_t len, + size_t pagecpy); +extern void _lib_ring_buffer_memset(struct lib_ring_buffer_backend *bufb, + size_t offset, int c, size_t len, + size_t pagecpy); +extern void _lib_ring_buffer_strcpy(struct lib_ring_buffer_backend *bufb, + size_t offset, const char *src, size_t len, + size_t pagecpy, int pad); +extern void _lib_ring_buffer_copy_from_user_inatomic(struct lib_ring_buffer_backend *bufb, + size_t offset, const void *src, + size_t len, size_t pagecpy); +extern void _lib_ring_buffer_strcpy_from_user_inatomic(struct lib_ring_buffer_backend *bufb, + size_t offset, const char __user *src, size_t len, + size_t pagecpy, int pad); + +/* + * Subbuffer ID bits for overwrite mode. Need to fit within a single word to be + * exchanged atomically. + * + * Top half word, except lowest bit, belongs to "offset", which is used to keep + * to count the produced buffers. For overwrite mode, this provides the + * consumer with the capacity to read subbuffers in order, handling the + * situation where producers would write up to 2^15 buffers (or 2^31 for 64-bit + * systems) concurrently with a single execution of get_subbuf (between offset + * sampling and subbuffer ID exchange). + */ + +#define HALF_ULONG_BITS (BITS_PER_LONG >> 1) + +#define SB_ID_OFFSET_SHIFT (HALF_ULONG_BITS + 1) +#define SB_ID_OFFSET_COUNT (1UL << SB_ID_OFFSET_SHIFT) +#define SB_ID_OFFSET_MASK (~(SB_ID_OFFSET_COUNT - 1)) +/* + * Lowest bit of top word half belongs to noref. Used only for overwrite mode. + */ +#define SB_ID_NOREF_SHIFT (SB_ID_OFFSET_SHIFT - 1) +#define SB_ID_NOREF_COUNT (1UL << SB_ID_NOREF_SHIFT) +#define SB_ID_NOREF_MASK SB_ID_NOREF_COUNT +/* + * In overwrite mode: lowest half of word is used for index. + * Limit of 2^16 subbuffers per buffer on 32-bit, 2^32 on 64-bit. + * In producer-consumer mode: whole word used for index. + */ +#define SB_ID_INDEX_SHIFT 0 +#define SB_ID_INDEX_COUNT (1UL << SB_ID_INDEX_SHIFT) +#define SB_ID_INDEX_MASK (SB_ID_NOREF_COUNT - 1) + +/* + * Construct the subbuffer id from offset, index and noref. Use only the index + * for producer-consumer mode (offset and noref are only used in overwrite + * mode). + */ +static inline +unsigned long subbuffer_id(const struct lib_ring_buffer_config *config, + unsigned long offset, unsigned long noref, + unsigned long index) +{ + if (config->mode == RING_BUFFER_OVERWRITE) + return (offset << SB_ID_OFFSET_SHIFT) + | (noref << SB_ID_NOREF_SHIFT) + | index; + else + return index; +} + +/* + * Compare offset with the offset contained within id. Return 1 if the offset + * bits are identical, else 0. + */ +static inline +int subbuffer_id_compare_offset(const struct lib_ring_buffer_config *config, + unsigned long id, unsigned long offset) +{ + return (id & SB_ID_OFFSET_MASK) == (offset << SB_ID_OFFSET_SHIFT); +} + +static inline +unsigned long subbuffer_id_get_index(const struct lib_ring_buffer_config *config, + unsigned long id) +{ + if (config->mode == RING_BUFFER_OVERWRITE) + return id & SB_ID_INDEX_MASK; + else + return id; +} + +static inline +unsigned long subbuffer_id_is_noref(const struct lib_ring_buffer_config *config, + unsigned long id) +{ + if (config->mode == RING_BUFFER_OVERWRITE) + return !!(id & SB_ID_NOREF_MASK); + else + return 1; +} + +/* + * Only used by reader on subbuffer ID it has exclusive access to. No volatile + * needed. + */ +static inline +void subbuffer_id_set_noref(const struct lib_ring_buffer_config *config, + unsigned long *id) +{ + if (config->mode == RING_BUFFER_OVERWRITE) + *id |= SB_ID_NOREF_MASK; +} + +static inline +void subbuffer_id_set_noref_offset(const struct lib_ring_buffer_config *config, + unsigned long *id, unsigned long offset) +{ + unsigned long tmp; + + if (config->mode == RING_BUFFER_OVERWRITE) { + tmp = *id; + tmp &= ~SB_ID_OFFSET_MASK; + tmp |= offset << SB_ID_OFFSET_SHIFT; + tmp |= SB_ID_NOREF_MASK; + /* Volatile store, read concurrently by readers. */ + WRITE_ONCE(*id, tmp); + } +} + +/* No volatile access, since already used locally */ +static inline +void subbuffer_id_clear_noref(const struct lib_ring_buffer_config *config, + unsigned long *id) +{ + if (config->mode == RING_BUFFER_OVERWRITE) + *id &= ~SB_ID_NOREF_MASK; +} + +/* + * For overwrite mode, cap the number of subbuffers per buffer to: + * 2^16 on 32-bit architectures + * 2^32 on 64-bit architectures + * This is required to fit in the index part of the ID. Return 0 on success, + * -EPERM on failure. + */ +static inline +int subbuffer_id_check_index(const struct lib_ring_buffer_config *config, + unsigned long num_subbuf) +{ + if (config->mode == RING_BUFFER_OVERWRITE) + return (num_subbuf > (1UL << HALF_ULONG_BITS)) ? -EPERM : 0; + else + return 0; +} + +static inline +void lib_ring_buffer_backend_get_pages(const struct lib_ring_buffer_config *config, + struct lib_ring_buffer_ctx *ctx, + struct lib_ring_buffer_backend_pages **backend_pages) +{ + struct lib_ring_buffer_backend *bufb = &ctx->buf->backend; + struct channel_backend *chanb = &ctx->chan->backend; + size_t sbidx, offset = ctx->buf_offset; + unsigned long sb_bindex, id; + struct lib_ring_buffer_backend_pages *rpages; + + offset &= chanb->buf_size - 1; + sbidx = offset >> chanb->subbuf_size_order; + id = bufb->buf_wsb[sbidx].id; + sb_bindex = subbuffer_id_get_index(config, id); + rpages = bufb->array[sb_bindex]; + CHAN_WARN_ON(ctx->chan, + config->mode == RING_BUFFER_OVERWRITE + && subbuffer_id_is_noref(config, id)); + *backend_pages = rpages; +} + +/* Get backend pages from cache. */ +static inline +struct lib_ring_buffer_backend_pages * + lib_ring_buffer_get_backend_pages_from_ctx(const struct lib_ring_buffer_config *config, + struct lib_ring_buffer_ctx *ctx) +{ + return ctx->backend_pages; +} + +/* + * The ring buffer can count events recorded and overwritten per buffer, + * but it is disabled by default due to its performance overhead. + */ +#ifdef LTTNG_RING_BUFFER_COUNT_EVENTS +static inline +void subbuffer_count_record(const struct lib_ring_buffer_config *config, + struct lib_ring_buffer_backend *bufb, + unsigned long idx) +{ + unsigned long sb_bindex; + + sb_bindex = subbuffer_id_get_index(config, bufb->buf_wsb[idx].id); + v_inc(config, &bufb->array[sb_bindex]->records_commit); +} +#else /* LTTNG_RING_BUFFER_COUNT_EVENTS */ +static inline +void subbuffer_count_record(const struct lib_ring_buffer_config *config, + struct lib_ring_buffer_backend *bufb, + unsigned long idx) +{ +} +#endif /* #else LTTNG_RING_BUFFER_COUNT_EVENTS */ + +/* + * Reader has exclusive subbuffer access for record consumption. No need to + * perform the decrement atomically. + */ +static inline +void subbuffer_consume_record(const struct lib_ring_buffer_config *config, + struct lib_ring_buffer_backend *bufb) +{ + unsigned long sb_bindex; + + sb_bindex = subbuffer_id_get_index(config, bufb->buf_rsb.id); + CHAN_WARN_ON(bufb->chan, + !v_read(config, &bufb->array[sb_bindex]->records_unread)); + /* Non-atomic decrement protected by exclusive subbuffer access */ + _v_dec(config, &bufb->array[sb_bindex]->records_unread); + v_inc(config, &bufb->records_read); +} + +static inline +unsigned long subbuffer_get_records_count( + const struct lib_ring_buffer_config *config, + struct lib_ring_buffer_backend *bufb, + unsigned long idx) +{ + unsigned long sb_bindex; + + sb_bindex = subbuffer_id_get_index(config, bufb->buf_wsb[idx].id); + return v_read(config, &bufb->array[sb_bindex]->records_commit); +} + +/* + * Must be executed at subbuffer delivery when the writer has _exclusive_ + * subbuffer access. See lib_ring_buffer_check_deliver() for details. + * lib_ring_buffer_get_records_count() must be called to get the records + * count before this function, because it resets the records_commit + * count. + */ +static inline +unsigned long subbuffer_count_records_overrun( + const struct lib_ring_buffer_config *config, + struct lib_ring_buffer_backend *bufb, + unsigned long idx) +{ + struct lib_ring_buffer_backend_pages *pages; + unsigned long overruns, sb_bindex; + + sb_bindex = subbuffer_id_get_index(config, bufb->buf_wsb[idx].id); + pages = bufb->array[sb_bindex]; + overruns = v_read(config, &pages->records_unread); + v_set(config, &pages->records_unread, + v_read(config, &pages->records_commit)); + v_set(config, &pages->records_commit, 0); + + return overruns; +} + +static inline +void subbuffer_set_data_size(const struct lib_ring_buffer_config *config, + struct lib_ring_buffer_backend *bufb, + unsigned long idx, + unsigned long data_size) +{ + struct lib_ring_buffer_backend_pages *pages; + unsigned long sb_bindex; + + sb_bindex = subbuffer_id_get_index(config, bufb->buf_wsb[idx].id); + pages = bufb->array[sb_bindex]; + pages->data_size = data_size; +} + +static inline +unsigned long subbuffer_get_read_data_size( + const struct lib_ring_buffer_config *config, + struct lib_ring_buffer_backend *bufb) +{ + struct lib_ring_buffer_backend_pages *pages; + unsigned long sb_bindex; + + sb_bindex = subbuffer_id_get_index(config, bufb->buf_rsb.id); + pages = bufb->array[sb_bindex]; + return pages->data_size; +} + +static inline +unsigned long subbuffer_get_data_size( + const struct lib_ring_buffer_config *config, + struct lib_ring_buffer_backend *bufb, + unsigned long idx) +{ + struct lib_ring_buffer_backend_pages *pages; + unsigned long sb_bindex; + + sb_bindex = subbuffer_id_get_index(config, bufb->buf_wsb[idx].id); + pages = bufb->array[sb_bindex]; + return pages->data_size; +} + +static inline +void subbuffer_inc_packet_count(const struct lib_ring_buffer_config *config, + struct lib_ring_buffer_backend *bufb, + unsigned long idx) +{ + bufb->buf_cnt[idx].seq_cnt++; +} + +/** + * lib_ring_buffer_clear_noref - Clear the noref subbuffer flag, called by + * writer. + */ +static inline +void lib_ring_buffer_clear_noref(const struct lib_ring_buffer_config *config, + struct lib_ring_buffer_backend *bufb, + unsigned long idx) +{ + unsigned long id, new_id; + + if (config->mode != RING_BUFFER_OVERWRITE) + return; + + /* + * Performing a volatile access to read the sb_pages, because we want to + * read a coherent version of the pointer and the associated noref flag. + */ + id = READ_ONCE(bufb->buf_wsb[idx].id); + for (;;) { + /* This check is called on the fast path for each record. */ + if (likely(!subbuffer_id_is_noref(config, id))) { + /* + * Store after load dependency ordering the writes to + * the subbuffer after load and test of the noref flag + * matches the memory barrier implied by the cmpxchg() + * in update_read_sb_index(). + */ + return; /* Already writing to this buffer */ + } + new_id = id; + subbuffer_id_clear_noref(config, &new_id); + new_id = cmpxchg(&bufb->buf_wsb[idx].id, id, new_id); + if (likely(new_id == id)) + break; + id = new_id; + } +} + +/** + * lib_ring_buffer_set_noref_offset - Set the noref subbuffer flag and offset, + * called by writer. + */ +static inline +void lib_ring_buffer_set_noref_offset(const struct lib_ring_buffer_config *config, + struct lib_ring_buffer_backend *bufb, + unsigned long idx, unsigned long offset) +{ + if (config->mode != RING_BUFFER_OVERWRITE) + return; + + /* + * Because ring_buffer_set_noref() is only called by a single thread + * (the one which updated the cc_sb value), there are no concurrent + * updates to take care of: other writers have not updated cc_sb, so + * they cannot set the noref flag, and concurrent readers cannot modify + * the pointer because the noref flag is not set yet. + * The smp_wmb() in ring_buffer_commit() takes care of ordering writes + * to the subbuffer before this set noref operation. + * subbuffer_set_noref() uses a volatile store to deal with concurrent + * readers of the noref flag. + */ + CHAN_WARN_ON(bufb->chan, + subbuffer_id_is_noref(config, bufb->buf_wsb[idx].id)); + /* + * Memory barrier that ensures counter stores are ordered before set + * noref and offset. + */ + smp_mb(); + subbuffer_id_set_noref_offset(config, &bufb->buf_wsb[idx].id, offset); +} + +/** + * update_read_sb_index - Read-side subbuffer index update. + */ +static inline +int update_read_sb_index(const struct lib_ring_buffer_config *config, + struct lib_ring_buffer_backend *bufb, + struct channel_backend *chanb, + unsigned long consumed_idx, + unsigned long consumed_count) +{ + unsigned long old_id, new_id; + + if (config->mode == RING_BUFFER_OVERWRITE) { + /* + * Exchange the target writer subbuffer with our own unused + * subbuffer. No need to use READ_ONCE() here to read the + * old_wpage, because the value read will be confirmed by the + * following cmpxchg(). + */ + old_id = bufb->buf_wsb[consumed_idx].id; + if (unlikely(!subbuffer_id_is_noref(config, old_id))) + return -EAGAIN; + /* + * Make sure the offset count we are expecting matches the one + * indicated by the writer. + */ + if (unlikely(!subbuffer_id_compare_offset(config, old_id, + consumed_count))) + return -EAGAIN; + CHAN_WARN_ON(bufb->chan, + !subbuffer_id_is_noref(config, bufb->buf_rsb.id)); + subbuffer_id_set_noref_offset(config, &bufb->buf_rsb.id, + consumed_count); + new_id = cmpxchg(&bufb->buf_wsb[consumed_idx].id, old_id, + bufb->buf_rsb.id); + if (unlikely(old_id != new_id)) + return -EAGAIN; + bufb->buf_rsb.id = new_id; + } else { + /* No page exchange, use the writer page directly */ + bufb->buf_rsb.id = bufb->buf_wsb[consumed_idx].id; + } + return 0; +} + +static inline __attribute__((always_inline)) +void lttng_inline_memcpy(void *dest, const void *src, + unsigned long len) +{ + switch (len) { + case 1: + *(uint8_t *) dest = *(const uint8_t *) src; + break; + case 2: + *(uint16_t *) dest = *(const uint16_t *) src; + break; + case 4: + *(uint32_t *) dest = *(const uint32_t *) src; + break; + case 8: + *(uint64_t *) dest = *(const uint64_t *) src; + break; + default: + memcpy(dest, src, len); + } +} + +/* + * Use the architecture-specific memcpy implementation for constant-sized + * inputs, but rely on an inline memcpy for length statically unknown. + * The function call to memcpy is just way too expensive for a fast path. + */ +#define lib_ring_buffer_do_copy(config, dest, src, len) \ +do { \ + size_t __len = (len); \ + if (__builtin_constant_p(len)) \ + memcpy(dest, src, __len); \ + else \ + lttng_inline_memcpy(dest, src, __len); \ +} while (0) + +/* + * We use __copy_from_user_inatomic to copy userspace data since we already + * did the access_ok for the whole range. + * + * Return 0 if OK, nonzero on error. + */ +static inline +unsigned long lib_ring_buffer_do_copy_from_user_inatomic(void *dest, + const void __user *src, + unsigned long len) +{ + return __copy_from_user_inatomic(dest, src, len); +} + +/* + * write len bytes to dest with c + */ +static inline +void lib_ring_buffer_do_memset(char *dest, int c, + unsigned long len) +{ + unsigned long i; + + for (i = 0; i < len; i++) + dest[i] = c; +} + +#endif /* _LIB_RING_BUFFER_BACKEND_INTERNAL_H */ diff --git a/include/ringbuffer/backend_types.h b/include/ringbuffer/backend_types.h index ff237c03..f1b3ee27 100644 --- a/include/ringbuffer/backend_types.h +++ b/include/ringbuffer/backend_types.h @@ -1,2 +1,100 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ -#include +/* SPDX-License-Identifier: (GPL-2.0-only OR LGPL-2.1-only) + * + * lib/ringbuffer/backend_types.h + * + * Ring buffer backend (types). + * + * Copyright (C) 2008-2012 Mathieu Desnoyers + */ + +#ifndef _LIB_RING_BUFFER_BACKEND_TYPES_H +#define _LIB_RING_BUFFER_BACKEND_TYPES_H + +#include +#include +#include +#include + +struct lib_ring_buffer_backend_page { + void *virt; /* page virtual address (cached) */ + unsigned long pfn; /* page frame number */ +}; + +struct lib_ring_buffer_backend_pages { + unsigned long mmap_offset; /* offset of the subbuffer in mmap */ + union v_atomic records_commit; /* current records committed count */ + union v_atomic records_unread; /* records to read */ + unsigned long data_size; /* Amount of data to read from subbuf */ + struct lib_ring_buffer_backend_page p[]; +}; + +struct lib_ring_buffer_backend_subbuffer { + /* Identifier for subbuf backend pages. Exchanged atomically. */ + unsigned long id; /* backend subbuffer identifier */ +}; + +struct lib_ring_buffer_backend_counts { + /* + * Counter specific to the sub-buffer location within the ring buffer. + * The actual sequence number of the packet within the entire ring + * buffer can be derived from the formula nr_subbuffers * seq_cnt + + * subbuf_idx. + */ + uint64_t seq_cnt; /* packet sequence number */ +}; + +/* + * Forward declaration of frontend-specific channel and ring_buffer. + */ +struct channel; +struct lib_ring_buffer; + +struct lib_ring_buffer_backend { + /* Array of ring_buffer_backend_subbuffer for writer */ + struct lib_ring_buffer_backend_subbuffer *buf_wsb; + /* ring_buffer_backend_subbuffer for reader */ + struct lib_ring_buffer_backend_subbuffer buf_rsb; + /* Array of lib_ring_buffer_backend_counts for the packet counter */ + struct lib_ring_buffer_backend_counts *buf_cnt; + /* + * Pointer array of backend pages, for whole buffer. + * Indexed by ring_buffer_backend_subbuffer identifier (id) index. + */ + struct lib_ring_buffer_backend_pages **array; + unsigned int num_pages_per_subbuf; + + struct channel *chan; /* Associated channel */ + int cpu; /* This buffer's cpu. -1 if global. */ + union v_atomic records_read; /* Number of records read */ + unsigned int allocated:1; /* is buffer allocated ? */ +}; + +struct channel_backend { + unsigned long buf_size; /* Size of the buffer */ + unsigned long subbuf_size; /* Sub-buffer size */ + unsigned int subbuf_size_order; /* Order of sub-buffer size */ + unsigned int num_subbuf_order; /* + * Order of number of sub-buffers/buffer + * for writer. + */ + unsigned int buf_size_order; /* Order of buffer size */ + unsigned int extra_reader_sb:1; /* has extra reader subbuffer ? */ + struct lib_ring_buffer *buf; /* Channel per-cpu buffers */ + + unsigned long num_subbuf; /* Number of sub-buffers for writer */ + u64 start_tsc; /* Channel creation TSC value */ + void *priv; /* Client-specific information */ + void *priv_ops; /* Client-specific ops pointer */ + void (*release_priv_ops)(void *priv_ops); + struct lttng_cpuhp_node cpuhp_prepare; /* CPU hotplug prepare */ + /* + * We need to copy config because the module containing the + * source config can vanish before the last reference to this + * channel's streams is released. + */ + struct lib_ring_buffer_config config; /* Ring buffer configuration */ + cpumask_var_t cpumask; /* Allocated per-cpu buffers cpumask */ + char name[NAME_MAX]; /* Channel name */ +}; + +#endif /* _LIB_RING_BUFFER_BACKEND_TYPES_H */ diff --git a/include/ringbuffer/config.h b/include/ringbuffer/config.h index e1f0a965..df7c335d 100644 --- a/include/ringbuffer/config.h +++ b/include/ringbuffer/config.h @@ -1,2 +1,306 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ -#include +/* SPDX-License-Identifier: (GPL-2.0-only OR LGPL-2.1-only) + * + * lib/ringbuffer/config.h + * + * Ring buffer configuration header. Note: after declaring the standard inline + * functions, clients should also include linux/ringbuffer/api.h. + * + * Copyright (C) 2010-2012 Mathieu Desnoyers + */ + +#ifndef _LIB_RING_BUFFER_CONFIG_H +#define _LIB_RING_BUFFER_CONFIG_H + +#include +#include +#include +#include + +struct lib_ring_buffer; +struct channel; +struct lib_ring_buffer_config; +struct lib_ring_buffer_ctx; + +/* + * Ring buffer client callbacks. Only used by slow path, never on fast path. + * For the fast path, record_header_size(), ring_buffer_clock_read() should be + * provided as inline functions too. These may simply return 0 if not used by + * the client. + */ +struct lib_ring_buffer_client_cb { + /* Mandatory callbacks */ + + /* A static inline version is also required for fast path */ + u64 (*ring_buffer_clock_read) (struct channel *chan); + size_t (*record_header_size) (const struct lib_ring_buffer_config *config, + struct channel *chan, size_t offset, + size_t *pre_header_padding, + struct lib_ring_buffer_ctx *ctx, + void *client_ctx); + + /* Slow path only, at subbuffer switch */ + size_t (*subbuffer_header_size) (void); + void (*buffer_begin) (struct lib_ring_buffer *buf, u64 tsc, + unsigned int subbuf_idx); + void (*buffer_end) (struct lib_ring_buffer *buf, u64 tsc, + unsigned int subbuf_idx, unsigned long data_size); + + /* Optional callbacks (can be set to NULL) */ + + /* Called at buffer creation/finalize */ + int (*buffer_create) (struct lib_ring_buffer *buf, void *priv, + int cpu, const char *name); + /* + * Clients should guarantee that no new reader handle can be opened + * after finalize. + */ + void (*buffer_finalize) (struct lib_ring_buffer *buf, void *priv, int cpu); + + /* + * Extract header length, payload length and timestamp from event + * record. Used by buffer iterators. Timestamp is only used by channel + * iterator. + */ + void (*record_get) (const struct lib_ring_buffer_config *config, + struct channel *chan, struct lib_ring_buffer *buf, + size_t offset, size_t *header_len, + size_t *payload_len, u64 *timestamp); +}; + +/* + * Ring buffer instance configuration. + * + * Declare as "static const" within the client object to ensure the inline fast + * paths can be optimized. + * + * alloc/sync pairs: + * + * RING_BUFFER_ALLOC_PER_CPU and RING_BUFFER_SYNC_PER_CPU : + * Per-cpu buffers with per-cpu synchronization. Tracing must be performed + * with preemption disabled (lib_ring_buffer_get_cpu() and + * lib_ring_buffer_put_cpu()). + * + * RING_BUFFER_ALLOC_PER_CPU and RING_BUFFER_SYNC_GLOBAL : + * Per-cpu buffer with global synchronization. Tracing can be performed with + * preemption enabled, statistically stays on the local buffers. + * + * RING_BUFFER_ALLOC_GLOBAL and RING_BUFFER_SYNC_PER_CPU : + * Should only be used for buffers belonging to a single thread or protected + * by mutual exclusion by the client. Note that periodical sub-buffer switch + * should be disabled in this kind of configuration. + * + * RING_BUFFER_ALLOC_GLOBAL and RING_BUFFER_SYNC_GLOBAL : + * Global shared buffer with global synchronization. + * + * wakeup: + * + * RING_BUFFER_WAKEUP_BY_TIMER uses per-cpu timers to poll the + * buffers and wake up readers if data is ready. Mainly useful for tracers which + * don't want to call into the wakeup code on the tracing path. Use in + * combination with "read_timer_interval" channel_create() argument. + * + * RING_BUFFER_WAKEUP_BY_WRITER directly wakes up readers when a subbuffer is + * ready to read. Lower latencies before the reader is woken up. Mainly suitable + * for drivers. + * + * RING_BUFFER_WAKEUP_NONE does not perform any wakeup whatsoever. The client + * has the responsibility to perform wakeups. + */ +struct lib_ring_buffer_config { + enum { + RING_BUFFER_ALLOC_PER_CPU, + RING_BUFFER_ALLOC_GLOBAL, + } alloc; + enum { + RING_BUFFER_SYNC_PER_CPU, /* Wait-free */ + RING_BUFFER_SYNC_GLOBAL, /* Lock-free */ + } sync; + enum { + RING_BUFFER_OVERWRITE, /* Overwrite when buffer full */ + RING_BUFFER_DISCARD, /* Discard when buffer full */ + } mode; + enum { + RING_BUFFER_SPLICE, + RING_BUFFER_MMAP, + RING_BUFFER_READ, /* TODO */ + RING_BUFFER_ITERATOR, + RING_BUFFER_NONE, + } output; + enum { + RING_BUFFER_PAGE, + RING_BUFFER_VMAP, /* TODO */ + RING_BUFFER_STATIC, /* TODO */ + } backend; + enum { + RING_BUFFER_NO_OOPS_CONSISTENCY, + RING_BUFFER_OOPS_CONSISTENCY, + } oops; + enum { + RING_BUFFER_IPI_BARRIER, + RING_BUFFER_NO_IPI_BARRIER, + } ipi; + enum { + RING_BUFFER_WAKEUP_BY_TIMER, /* wake up performed by timer */ + RING_BUFFER_WAKEUP_BY_WRITER, /* + * writer wakes up reader, + * not lock-free + * (takes spinlock). + */ + } wakeup; + /* + * tsc_bits: timestamp bits saved at each record. + * 0 and 64 disable the timestamp compression scheme. + */ + unsigned int tsc_bits; + struct lib_ring_buffer_client_cb cb; +}; + +/* + * ring buffer context + * + * Context passed to lib_ring_buffer_reserve(), lib_ring_buffer_commit(), + * lib_ring_buffer_try_discard_reserve(), lib_ring_buffer_align_ctx() and + * lib_ring_buffer_write(). + */ +struct lib_ring_buffer_ctx { + /* input received by lib_ring_buffer_reserve(), saved here. */ + struct channel *chan; /* channel */ + void *priv; /* client private data */ + size_t data_size; /* size of payload */ + int largest_align; /* + * alignment of the largest element + * in the payload + */ + int cpu; /* processor id */ + + /* output from lib_ring_buffer_reserve() */ + struct lib_ring_buffer *buf; /* + * buffer corresponding to processor id + * for this channel + */ + size_t slot_size; /* size of the reserved slot */ + unsigned long buf_offset; /* offset following the record header */ + unsigned long pre_offset; /* + * Initial offset position _before_ + * the record is written. Positioned + * prior to record header alignment + * padding. + */ + u64 tsc; /* time-stamp counter value */ + unsigned int rflags; /* reservation flags */ + /* Cache backend pages pointer chasing. */ + struct lib_ring_buffer_backend_pages *backend_pages; +}; + +/** + * lib_ring_buffer_ctx_init - initialize ring buffer context + * @ctx: ring buffer context to initialize + * @chan: channel + * @priv: client private data + * @data_size: size of record data payload. It must be greater than 0. + * @largest_align: largest alignment within data payload types + * @cpu: processor id + */ +static inline +void lib_ring_buffer_ctx_init(struct lib_ring_buffer_ctx *ctx, + struct channel *chan, void *priv, + size_t data_size, int largest_align, + int cpu) +{ + ctx->chan = chan; + ctx->priv = priv; + ctx->data_size = data_size; + ctx->largest_align = largest_align; + ctx->cpu = cpu; + ctx->rflags = 0; + ctx->backend_pages = NULL; +} + +/* + * Reservation flags. + * + * RING_BUFFER_RFLAG_FULL_TSC + * + * This flag is passed to record_header_size() and to the primitive used to + * write the record header. It indicates that the full 64-bit time value is + * needed in the record header. If this flag is not set, the record header needs + * only to contain "tsc_bits" bit of time value. + * + * Reservation flags can be added by the client, starting from + * "(RING_BUFFER_FLAGS_END << 0)". It can be used to pass information from + * record_header_size() to lib_ring_buffer_write_record_header(). + */ +#define RING_BUFFER_RFLAG_FULL_TSC (1U << 0) +#define RING_BUFFER_RFLAG_END (1U << 1) + +#ifndef LTTNG_TRACER_CORE_H +#error "lttng-tracer-core.h is needed for RING_BUFFER_ALIGN define" +#endif + +/* + * We need to define RING_BUFFER_ALIGN_ATTR so it is known early at + * compile-time. We have to duplicate the "config->align" information and the + * definition here because config->align is used both in the slow and fast + * paths, but RING_BUFFER_ALIGN_ATTR is only available for the client code. + */ +#ifdef RING_BUFFER_ALIGN + +# define RING_BUFFER_ALIGN_ATTR /* Default arch alignment */ + +/* + * Calculate the offset needed to align the type. + * size_of_type must be non-zero. + */ +static inline +unsigned int lib_ring_buffer_align(size_t align_drift, size_t size_of_type) +{ + return offset_align(align_drift, size_of_type); +} + +#else + +# define RING_BUFFER_ALIGN_ATTR __attribute__((packed)) + +/* + * Calculate the offset needed to align the type. + * size_of_type must be non-zero. + */ +static inline +unsigned int lib_ring_buffer_align(size_t align_drift, size_t size_of_type) +{ + return 0; +} + +#endif + +/** + * lib_ring_buffer_align_ctx - Align context offset on "alignment" + * @ctx: ring buffer context. + */ +static inline +void lib_ring_buffer_align_ctx(struct lib_ring_buffer_ctx *ctx, + size_t alignment) +{ + ctx->buf_offset += lib_ring_buffer_align(ctx->buf_offset, + alignment); +} + +/* + * lib_ring_buffer_check_config() returns 0 on success. + * Used internally to check for valid configurations at channel creation. + */ +static inline +int lib_ring_buffer_check_config(const struct lib_ring_buffer_config *config, + unsigned int switch_timer_interval, + unsigned int read_timer_interval) +{ + if (config->alloc == RING_BUFFER_ALLOC_GLOBAL + && config->sync == RING_BUFFER_SYNC_PER_CPU + && switch_timer_interval) + return -EINVAL; + return 0; +} + +#include + +#endif /* _LIB_RING_BUFFER_CONFIG_H */ diff --git a/include/ringbuffer/frontend.h b/include/ringbuffer/frontend.h index 35421581..a15b658b 100644 --- a/include/ringbuffer/frontend.h +++ b/include/ringbuffer/frontend.h @@ -1,2 +1,234 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ -#include +/* SPDX-License-Identifier: (GPL-2.0-only OR LGPL-2.1-only) + * + * lib/ringbuffer/frontend.h + * + * Ring Buffer Library Synchronization Header (API). + * + * Copyright (C) 2005-2012 Mathieu Desnoyers + * + * See ring_buffer_frontend.c for more information on wait-free algorithms. + */ + +#ifndef _LIB_RING_BUFFER_FRONTEND_H +#define _LIB_RING_BUFFER_FRONTEND_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +/* Internal helpers */ +#include + +/* Max ring buffer nesting count, see lib_ring_buffer_get_cpu(). */ +#define RING_BUFFER_MAX_NESTING 4 + +/* Buffer creation/removal and setup operations */ + +/* + * switch_timer_interval is the time interval (in us) to fill sub-buffers with + * padding to let readers get those sub-buffers. Used for live streaming. + * + * read_timer_interval is the time interval (in us) to wake up pending readers. + * + * buf_addr is a pointer the the beginning of the preallocated buffer contiguous + * address mapping. It is used only by RING_BUFFER_STATIC configuration. It can + * be set to NULL for other backends. + */ + +extern +struct channel *channel_create(const struct lib_ring_buffer_config *config, + const char *name, void *priv, + void *buf_addr, + size_t subbuf_size, size_t num_subbuf, + unsigned int switch_timer_interval, + unsigned int read_timer_interval); + +/* + * channel_destroy returns the private data pointer. It finalizes all channel's + * buffers, waits for readers to release all references, and destroys the + * channel. + */ +extern +void *channel_destroy(struct channel *chan); + + +/* Buffer read operations */ + +/* + * Iteration on channel cpumask needs to issue a read barrier to match the write + * barrier in cpu hotplug. It orders the cpumask read before read of per-cpu + * buffer data. The per-cpu buffer is never removed by cpu hotplug; teardown is + * only performed at channel destruction. + */ +#define for_each_channel_cpu(cpu, chan) \ + for ((cpu) = -1; \ + ({ (cpu) = cpumask_next(cpu, (chan)->backend.cpumask); \ + smp_read_barrier_depends(); (cpu) < nr_cpu_ids; });) + +extern struct lib_ring_buffer *channel_get_ring_buffer( + const struct lib_ring_buffer_config *config, + struct channel *chan, int cpu); +extern int lib_ring_buffer_open_read(struct lib_ring_buffer *buf); +extern void lib_ring_buffer_release_read(struct lib_ring_buffer *buf); + +/* + * Read sequence: snapshot, many get_subbuf/put_subbuf, move_consumer. + */ +extern int lib_ring_buffer_snapshot(struct lib_ring_buffer *buf, + unsigned long *consumed, + unsigned long *produced); +extern int lib_ring_buffer_snapshot_sample_positions( + struct lib_ring_buffer *buf, + unsigned long *consumed, + unsigned long *produced); +extern void lib_ring_buffer_move_consumer(struct lib_ring_buffer *buf, + unsigned long consumed_new); + +extern int lib_ring_buffer_get_subbuf(struct lib_ring_buffer *buf, + unsigned long consumed); +extern void lib_ring_buffer_put_subbuf(struct lib_ring_buffer *buf); + +void lib_ring_buffer_set_quiescent_channel(struct channel *chan); +void lib_ring_buffer_clear_quiescent_channel(struct channel *chan); + +/* + * lib_ring_buffer_get_next_subbuf/lib_ring_buffer_put_next_subbuf are helpers + * to read sub-buffers sequentially. + */ +static inline int lib_ring_buffer_get_next_subbuf(struct lib_ring_buffer *buf) +{ + int ret; + + ret = lib_ring_buffer_snapshot(buf, &buf->cons_snapshot, + &buf->prod_snapshot); + if (ret) + return ret; + ret = lib_ring_buffer_get_subbuf(buf, buf->cons_snapshot); + return ret; +} + +static inline void lib_ring_buffer_put_next_subbuf(struct lib_ring_buffer *buf) +{ + lib_ring_buffer_put_subbuf(buf); + lib_ring_buffer_move_consumer(buf, subbuf_align(buf->cons_snapshot, + buf->backend.chan)); +} + +extern void channel_reset(struct channel *chan); +extern void lib_ring_buffer_reset(struct lib_ring_buffer *buf); + +static inline +unsigned long lib_ring_buffer_get_offset(const struct lib_ring_buffer_config *config, + struct lib_ring_buffer *buf) +{ + return v_read(config, &buf->offset); +} + +static inline +unsigned long lib_ring_buffer_get_consumed(const struct lib_ring_buffer_config *config, + struct lib_ring_buffer *buf) +{ + return atomic_long_read(&buf->consumed); +} + +/* + * Must call lib_ring_buffer_is_finalized before reading counters (memory + * ordering enforced with respect to trace teardown). + */ +static inline +int lib_ring_buffer_is_finalized(const struct lib_ring_buffer_config *config, + struct lib_ring_buffer *buf) +{ + int finalized = READ_ONCE(buf->finalized); + /* + * Read finalized before counters. + */ + smp_rmb(); + return finalized; +} + +static inline +int lib_ring_buffer_channel_is_finalized(const struct channel *chan) +{ + return chan->finalized; +} + +static inline +int lib_ring_buffer_channel_is_disabled(const struct channel *chan) +{ + return atomic_read(&chan->record_disabled); +} + +static inline +unsigned long lib_ring_buffer_get_read_data_size( + const struct lib_ring_buffer_config *config, + struct lib_ring_buffer *buf) +{ + return subbuffer_get_read_data_size(config, &buf->backend); +} + +static inline +unsigned long lib_ring_buffer_get_records_count( + const struct lib_ring_buffer_config *config, + struct lib_ring_buffer *buf) +{ + return v_read(config, &buf->records_count); +} + +static inline +unsigned long lib_ring_buffer_get_records_overrun( + const struct lib_ring_buffer_config *config, + struct lib_ring_buffer *buf) +{ + return v_read(config, &buf->records_overrun); +} + +static inline +unsigned long lib_ring_buffer_get_records_lost_full( + const struct lib_ring_buffer_config *config, + struct lib_ring_buffer *buf) +{ + return v_read(config, &buf->records_lost_full); +} + +static inline +unsigned long lib_ring_buffer_get_records_lost_wrap( + const struct lib_ring_buffer_config *config, + struct lib_ring_buffer *buf) +{ + return v_read(config, &buf->records_lost_wrap); +} + +static inline +unsigned long lib_ring_buffer_get_records_lost_big( + const struct lib_ring_buffer_config *config, + struct lib_ring_buffer *buf) +{ + return v_read(config, &buf->records_lost_big); +} + +static inline +unsigned long lib_ring_buffer_get_records_read( + const struct lib_ring_buffer_config *config, + struct lib_ring_buffer *buf) +{ + return v_read(config, &buf->backend.records_read); +} + +#endif /* _LIB_RING_BUFFER_FRONTEND_H */ diff --git a/include/ringbuffer/frontend_api.h b/include/ringbuffer/frontend_api.h index 53187bf5..bd43bfb7 100644 --- a/include/ringbuffer/frontend_api.h +++ b/include/ringbuffer/frontend_api.h @@ -1,2 +1,358 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ -#include +/* SPDX-License-Identifier: (GPL-2.0-only OR LGPL-2.1-only) + * + * lib/ringbuffer/frontend_api.h + * + * Ring Buffer Library Synchronization Header (buffer write API). + * + * Copyright (C) 2005-2012 Mathieu Desnoyers + * + * See ring_buffer_frontend.c for more information on wait-free algorithms. + * See linux/ringbuffer/frontend.h for channel allocation and read-side API. + */ + +#ifndef _LIB_RING_BUFFER_FRONTEND_API_H +#define _LIB_RING_BUFFER_FRONTEND_API_H + +#include +#include +#include +#include + +/** + * lib_ring_buffer_get_cpu - Precedes ring buffer reserve/commit. + * + * Disables preemption (acts as a RCU read-side critical section) and keeps a + * ring buffer nesting count as supplementary safety net to ensure tracer client + * code will never trigger an endless recursion. Returns the processor ID on + * success, -EPERM on failure (nesting count too high). + * + * asm volatile and "memory" clobber prevent the compiler from moving + * instructions out of the ring buffer nesting count. This is required to ensure + * that probe side-effects which can cause recursion (e.g. unforeseen traps, + * divisions by 0, ...) are triggered within the incremented nesting count + * section. + */ +static inline +int lib_ring_buffer_get_cpu(const struct lib_ring_buffer_config *config) +{ + int cpu, nesting; + + rcu_read_lock_sched_notrace(); + cpu = smp_processor_id(); + nesting = ++per_cpu(lib_ring_buffer_nesting, cpu); + barrier(); + + if (unlikely(nesting > RING_BUFFER_MAX_NESTING)) { + WARN_ON_ONCE(1); + per_cpu(lib_ring_buffer_nesting, cpu)--; + rcu_read_unlock_sched_notrace(); + return -EPERM; + } else + return cpu; +} + +/** + * lib_ring_buffer_put_cpu - Follows ring buffer reserve/commit. + */ +static inline +void lib_ring_buffer_put_cpu(const struct lib_ring_buffer_config *config) +{ + barrier(); + (*this_cpu_ptr(&lib_ring_buffer_nesting))--; + rcu_read_unlock_sched_notrace(); +} + +/* + * lib_ring_buffer_try_reserve is called by lib_ring_buffer_reserve(). It is not + * part of the API per se. + * + * returns 0 if reserve ok, or 1 if the slow path must be taken. + */ +static inline +int lib_ring_buffer_try_reserve(const struct lib_ring_buffer_config *config, + struct lib_ring_buffer_ctx *ctx, + void *client_ctx, + unsigned long *o_begin, unsigned long *o_end, + unsigned long *o_old, size_t *before_hdr_pad) +{ + struct channel *chan = ctx->chan; + struct lib_ring_buffer *buf = ctx->buf; + *o_begin = v_read(config, &buf->offset); + *o_old = *o_begin; + + ctx->tsc = lib_ring_buffer_clock_read(chan); + if ((int64_t) ctx->tsc == -EIO) + return 1; + + /* + * Prefetch cacheline for read because we have to read the previous + * commit counter to increment it and commit seq value to compare it to + * the commit counter. + */ + prefetch(&buf->commit_hot[subbuf_index(*o_begin, chan)]); + + if (last_tsc_overflow(config, buf, ctx->tsc)) + ctx->rflags |= RING_BUFFER_RFLAG_FULL_TSC; + + if (unlikely(subbuf_offset(*o_begin, chan) == 0)) + return 1; + + ctx->slot_size = record_header_size(config, chan, *o_begin, + before_hdr_pad, ctx, client_ctx); + ctx->slot_size += + lib_ring_buffer_align(*o_begin + ctx->slot_size, + ctx->largest_align) + ctx->data_size; + if (unlikely((subbuf_offset(*o_begin, chan) + ctx->slot_size) + > chan->backend.subbuf_size)) + return 1; + + /* + * Record fits in the current buffer and we are not on a switch + * boundary. It's safe to write. + */ + *o_end = *o_begin + ctx->slot_size; + + if (unlikely((subbuf_offset(*o_end, chan)) == 0)) + /* + * The offset_end will fall at the very beginning of the next + * subbuffer. + */ + return 1; + + return 0; +} + +/** + * lib_ring_buffer_reserve - Reserve space in a ring buffer. + * @config: ring buffer instance configuration. + * @ctx: ring buffer context. (input and output) Must be already initialized. + * + * Atomic wait-free slot reservation. The reserved space starts at the context + * "pre_offset". Its length is "slot_size". The associated time-stamp is "tsc". + * + * Return : + * 0 on success. + * -EAGAIN if channel is disabled. + * -ENOSPC if event size is too large for packet. + * -ENOBUFS if there is currently not enough space in buffer for the event. + * -EIO if data cannot be written into the buffer for any other reason. + */ + +static inline +int lib_ring_buffer_reserve(const struct lib_ring_buffer_config *config, + struct lib_ring_buffer_ctx *ctx, + void *client_ctx) +{ + struct channel *chan = ctx->chan; + struct lib_ring_buffer *buf; + unsigned long o_begin, o_end, o_old; + size_t before_hdr_pad = 0; + + if (unlikely(atomic_read(&chan->record_disabled))) + return -EAGAIN; + + if (config->alloc == RING_BUFFER_ALLOC_PER_CPU) + buf = per_cpu_ptr(chan->backend.buf, ctx->cpu); + else + buf = chan->backend.buf; + if (unlikely(atomic_read(&buf->record_disabled))) + return -EAGAIN; + ctx->buf = buf; + + /* + * Perform retryable operations. + */ + if (unlikely(lib_ring_buffer_try_reserve(config, ctx, client_ctx, &o_begin, + &o_end, &o_old, &before_hdr_pad))) + goto slow_path; + + if (unlikely(v_cmpxchg(config, &ctx->buf->offset, o_old, o_end) + != o_old)) + goto slow_path; + + /* + * Atomically update last_tsc. This update races against concurrent + * atomic updates, but the race will always cause supplementary full TSC + * record headers, never the opposite (missing a full TSC record header + * when it would be needed). + */ + save_last_tsc(config, ctx->buf, ctx->tsc); + + /* + * Push the reader if necessary + */ + lib_ring_buffer_reserve_push_reader(ctx->buf, chan, o_end - 1); + + /* + * Clear noref flag for this subbuffer. + */ + lib_ring_buffer_clear_noref(config, &ctx->buf->backend, + subbuf_index(o_end - 1, chan)); + + ctx->pre_offset = o_begin; + ctx->buf_offset = o_begin + before_hdr_pad; + return 0; +slow_path: + return lib_ring_buffer_reserve_slow(ctx, client_ctx); +} + +/** + * lib_ring_buffer_switch - Perform a sub-buffer switch for a per-cpu buffer. + * @config: ring buffer instance configuration. + * @buf: buffer + * @mode: buffer switch mode (SWITCH_ACTIVE or SWITCH_FLUSH) + * + * This operation is completely reentrant : can be called while tracing is + * active with absolutely no lock held. + * + * Note, however, that as a v_cmpxchg is used for some atomic operations and + * requires to be executed locally for per-CPU buffers, this function must be + * called from the CPU which owns the buffer for a ACTIVE flush, with preemption + * disabled, for RING_BUFFER_SYNC_PER_CPU configuration. + */ +static inline +void lib_ring_buffer_switch(const struct lib_ring_buffer_config *config, + struct lib_ring_buffer *buf, enum switch_mode mode) +{ + lib_ring_buffer_switch_slow(buf, mode); +} + +/* See ring_buffer_frontend_api.h for lib_ring_buffer_reserve(). */ + +/** + * lib_ring_buffer_commit - Commit an record. + * @config: ring buffer instance configuration. + * @ctx: ring buffer context. (input arguments only) + * + * Atomic unordered slot commit. Increments the commit count in the + * specified sub-buffer, and delivers it if necessary. + */ +static inline +void lib_ring_buffer_commit(const struct lib_ring_buffer_config *config, + const struct lib_ring_buffer_ctx *ctx) +{ + struct channel *chan = ctx->chan; + struct lib_ring_buffer *buf = ctx->buf; + unsigned long offset_end = ctx->buf_offset; + unsigned long endidx = subbuf_index(offset_end - 1, chan); + unsigned long commit_count; + struct commit_counters_hot *cc_hot = &buf->commit_hot[endidx]; + + /* + * Must count record before incrementing the commit count. + */ + subbuffer_count_record(config, &buf->backend, endidx); + + /* + * Order all writes to buffer before the commit count update that will + * determine that the subbuffer is full. + */ + if (config->ipi == RING_BUFFER_IPI_BARRIER) { + /* + * Must write slot data before incrementing commit count. This + * compiler barrier is upgraded into a smp_mb() by the IPI sent + * by get_subbuf(). + */ + barrier(); + } else + smp_wmb(); + + v_add(config, ctx->slot_size, &cc_hot->cc); + + /* + * commit count read can race with concurrent OOO commit count updates. + * This is only needed for lib_ring_buffer_check_deliver (for + * non-polling delivery only) and for + * lib_ring_buffer_write_commit_counter. The race can only cause the + * counter to be read with the same value more than once, which could + * cause : + * - Multiple delivery for the same sub-buffer (which is handled + * gracefully by the reader code) if the value is for a full + * sub-buffer. It's important that we can never miss a sub-buffer + * delivery. Re-reading the value after the v_add ensures this. + * - Reading a commit_count with a higher value that what was actually + * added to it for the lib_ring_buffer_write_commit_counter call + * (again caused by a concurrent committer). It does not matter, + * because this function is interested in the fact that the commit + * count reaches back the reserve offset for a specific sub-buffer, + * which is completely independent of the order. + */ + commit_count = v_read(config, &cc_hot->cc); + + lib_ring_buffer_check_deliver(config, buf, chan, offset_end - 1, + commit_count, endidx, ctx->tsc); + /* + * Update used size at each commit. It's needed only for extracting + * ring_buffer buffers from vmcore, after crash. + */ + lib_ring_buffer_write_commit_counter(config, buf, chan, + offset_end, commit_count, cc_hot); +} + +/** + * lib_ring_buffer_try_discard_reserve - Try discarding a record. + * @config: ring buffer instance configuration. + * @ctx: ring buffer context. (input arguments only) + * + * Only succeeds if no other record has been written after the record to + * discard. If discard fails, the record must be committed to the buffer. + * + * Returns 0 upon success, -EPERM if the record cannot be discarded. + */ +static inline +int lib_ring_buffer_try_discard_reserve(const struct lib_ring_buffer_config *config, + const struct lib_ring_buffer_ctx *ctx) +{ + struct lib_ring_buffer *buf = ctx->buf; + unsigned long end_offset = ctx->pre_offset + ctx->slot_size; + + /* + * We need to ensure that if the cmpxchg succeeds and discards the + * record, the next record will record a full TSC, because it cannot + * rely on the last_tsc associated with the discarded record to detect + * overflows. The only way to ensure this is to set the last_tsc to 0 + * (assuming no 64-bit TSC overflow), which forces to write a 64-bit + * timestamp in the next record. + * + * Note: if discard fails, we must leave the TSC in the record header. + * It is needed to keep track of TSC overflows for the following + * records. + */ + save_last_tsc(config, buf, 0ULL); + + if (likely(v_cmpxchg(config, &buf->offset, end_offset, ctx->pre_offset) + != end_offset)) + return -EPERM; + else + return 0; +} + +static inline +void channel_record_disable(const struct lib_ring_buffer_config *config, + struct channel *chan) +{ + atomic_inc(&chan->record_disabled); +} + +static inline +void channel_record_enable(const struct lib_ring_buffer_config *config, + struct channel *chan) +{ + atomic_dec(&chan->record_disabled); +} + +static inline +void lib_ring_buffer_record_disable(const struct lib_ring_buffer_config *config, + struct lib_ring_buffer *buf) +{ + atomic_inc(&buf->record_disabled); +} + +static inline +void lib_ring_buffer_record_enable(const struct lib_ring_buffer_config *config, + struct lib_ring_buffer *buf) +{ + atomic_dec(&buf->record_disabled); +} + +#endif /* _LIB_RING_BUFFER_FRONTEND_API_H */ diff --git a/include/ringbuffer/frontend_internal.h b/include/ringbuffer/frontend_internal.h index c14757aa..7c7c0014 100644 --- a/include/ringbuffer/frontend_internal.h +++ b/include/ringbuffer/frontend_internal.h @@ -1,2 +1,334 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ -#include +/* SPDX-License-Identifier: (GPL-2.0-only OR LGPL-2.1-only) + * + * linux/ringbuffer/frontend_internal.h + * + * Ring Buffer Library Synchronization Header (internal helpers). + * + * Copyright (C) 2005-2012 Mathieu Desnoyers + * + * See ring_buffer_frontend.c for more information on wait-free algorithms. + */ + +#ifndef _LIB_RING_BUFFER_FRONTEND_INTERNAL_H +#define _LIB_RING_BUFFER_FRONTEND_INTERNAL_H + +#include +#include +#include +#include /* For per-CPU read-side iterator */ + +/* Buffer offset macros */ + +/* buf_trunc mask selects only the buffer number. */ +static inline +unsigned long buf_trunc(unsigned long offset, struct channel *chan) +{ + return offset & ~(chan->backend.buf_size - 1); + +} + +/* Select the buffer number value (counter). */ +static inline +unsigned long buf_trunc_val(unsigned long offset, struct channel *chan) +{ + return buf_trunc(offset, chan) >> chan->backend.buf_size_order; +} + +/* buf_offset mask selects only the offset within the current buffer. */ +static inline +unsigned long buf_offset(unsigned long offset, struct channel *chan) +{ + return offset & (chan->backend.buf_size - 1); +} + +/* subbuf_offset mask selects the offset within the current subbuffer. */ +static inline +unsigned long subbuf_offset(unsigned long offset, struct channel *chan) +{ + return offset & (chan->backend.subbuf_size - 1); +} + +/* subbuf_trunc mask selects the subbuffer number. */ +static inline +unsigned long subbuf_trunc(unsigned long offset, struct channel *chan) +{ + return offset & ~(chan->backend.subbuf_size - 1); +} + +/* subbuf_align aligns the offset to the next subbuffer. */ +static inline +unsigned long subbuf_align(unsigned long offset, struct channel *chan) +{ + return (offset + chan->backend.subbuf_size) + & ~(chan->backend.subbuf_size - 1); +} + +/* subbuf_index returns the index of the current subbuffer within the buffer. */ +static inline +unsigned long subbuf_index(unsigned long offset, struct channel *chan) +{ + return buf_offset(offset, chan) >> chan->backend.subbuf_size_order; +} + +/* + * Last TSC comparison functions. Check if the current TSC overflows tsc_bits + * bits from the last TSC read. When overflows are detected, the full 64-bit + * timestamp counter should be written in the record header. Reads and writes + * last_tsc atomically. + */ + +#if (BITS_PER_LONG == 32) +static inline +void save_last_tsc(const struct lib_ring_buffer_config *config, + struct lib_ring_buffer *buf, u64 tsc) +{ + if (config->tsc_bits == 0 || config->tsc_bits == 64) + return; + + /* + * Ensure the compiler performs this update in a single instruction. + */ + v_set(config, &buf->last_tsc, (unsigned long)(tsc >> config->tsc_bits)); +} + +static inline +int last_tsc_overflow(const struct lib_ring_buffer_config *config, + struct lib_ring_buffer *buf, u64 tsc) +{ + unsigned long tsc_shifted; + + if (config->tsc_bits == 0 || config->tsc_bits == 64) + return 0; + + tsc_shifted = (unsigned long)(tsc >> config->tsc_bits); + if (unlikely(tsc_shifted + - (unsigned long)v_read(config, &buf->last_tsc))) + return 1; + else + return 0; +} +#else +static inline +void save_last_tsc(const struct lib_ring_buffer_config *config, + struct lib_ring_buffer *buf, u64 tsc) +{ + if (config->tsc_bits == 0 || config->tsc_bits == 64) + return; + + v_set(config, &buf->last_tsc, (unsigned long)tsc); +} + +static inline +int last_tsc_overflow(const struct lib_ring_buffer_config *config, + struct lib_ring_buffer *buf, u64 tsc) +{ + if (config->tsc_bits == 0 || config->tsc_bits == 64) + return 0; + + if (unlikely((tsc - v_read(config, &buf->last_tsc)) + >> config->tsc_bits)) + return 1; + else + return 0; +} +#endif + +extern +int lib_ring_buffer_reserve_slow(struct lib_ring_buffer_ctx *ctx, + void *client_ctx); + +extern +void lib_ring_buffer_switch_slow(struct lib_ring_buffer *buf, + enum switch_mode mode); + +extern +void lib_ring_buffer_check_deliver_slow(const struct lib_ring_buffer_config *config, + struct lib_ring_buffer *buf, + struct channel *chan, + unsigned long offset, + unsigned long commit_count, + unsigned long idx, + u64 tsc); + +extern +void lib_ring_buffer_switch_remote(struct lib_ring_buffer *buf); +extern +void lib_ring_buffer_switch_remote_empty(struct lib_ring_buffer *buf); +extern +void lib_ring_buffer_clear(struct lib_ring_buffer *buf); + +/* Buffer write helpers */ + +static inline +void lib_ring_buffer_reserve_push_reader(struct lib_ring_buffer *buf, + struct channel *chan, + unsigned long offset) +{ + unsigned long consumed_old, consumed_new; + + do { + consumed_old = atomic_long_read(&buf->consumed); + /* + * If buffer is in overwrite mode, push the reader consumed + * count if the write position has reached it and we are not + * at the first iteration (don't push the reader farther than + * the writer). This operation can be done concurrently by many + * writers in the same buffer, the writer being at the farthest + * write position sub-buffer index in the buffer being the one + * which will win this loop. + */ + if (unlikely(subbuf_trunc(offset, chan) + - subbuf_trunc(consumed_old, chan) + >= chan->backend.buf_size)) + consumed_new = subbuf_align(consumed_old, chan); + else + return; + } while (unlikely(atomic_long_cmpxchg(&buf->consumed, consumed_old, + consumed_new) != consumed_old)); +} + +/* + * Move consumed position to the beginning of subbuffer in which the + * write offset is. Should only be used on ring buffers that are not + * actively being written into, because clear_reader does not take into + * account the commit counters when moving the consumed position, which + * can make concurrent trace producers or consumers observe consumed + * position further than the write offset, which breaks ring buffer + * algorithm guarantees. + */ +static inline +void lib_ring_buffer_clear_reader(struct lib_ring_buffer *buf, + struct channel *chan) +{ + const struct lib_ring_buffer_config *config = &chan->backend.config; + unsigned long offset, consumed_old, consumed_new; + + do { + offset = v_read(config, &buf->offset); + consumed_old = atomic_long_read(&buf->consumed); + CHAN_WARN_ON(chan, (long) (subbuf_trunc(offset, chan) + - subbuf_trunc(consumed_old, chan)) + < 0); + consumed_new = subbuf_trunc(offset, chan); + } while (unlikely(atomic_long_cmpxchg(&buf->consumed, consumed_old, + consumed_new) != consumed_old)); +} + +static inline +int lib_ring_buffer_pending_data(const struct lib_ring_buffer_config *config, + struct lib_ring_buffer *buf, + struct channel *chan) +{ + return !!subbuf_offset(v_read(config, &buf->offset), chan); +} + +static inline +unsigned long lib_ring_buffer_get_data_size(const struct lib_ring_buffer_config *config, + struct lib_ring_buffer *buf, + unsigned long idx) +{ + return subbuffer_get_data_size(config, &buf->backend, idx); +} + +/* + * Check if all space reservation in a buffer have been committed. This helps + * knowing if an execution context is nested (for per-cpu buffers only). + * This is a very specific ftrace use-case, so we keep this as "internal" API. + */ +static inline +int lib_ring_buffer_reserve_committed(const struct lib_ring_buffer_config *config, + struct lib_ring_buffer *buf, + struct channel *chan) +{ + unsigned long offset, idx, commit_count; + + CHAN_WARN_ON(chan, config->alloc != RING_BUFFER_ALLOC_PER_CPU); + CHAN_WARN_ON(chan, config->sync != RING_BUFFER_SYNC_PER_CPU); + + /* + * Read offset and commit count in a loop so they are both read + * atomically wrt interrupts. By deal with interrupt concurrency by + * restarting both reads if the offset has been pushed. Note that given + * we only have to deal with interrupt concurrency here, an interrupt + * modifying the commit count will also modify "offset", so it is safe + * to only check for offset modifications. + */ + do { + offset = v_read(config, &buf->offset); + idx = subbuf_index(offset, chan); + commit_count = v_read(config, &buf->commit_hot[idx].cc); + } while (offset != v_read(config, &buf->offset)); + + return ((buf_trunc(offset, chan) >> chan->backend.num_subbuf_order) + - (commit_count & chan->commit_count_mask) == 0); +} + +/* + * Receive end of subbuffer TSC as parameter. It has been read in the + * space reservation loop of either reserve or switch, which ensures it + * progresses monotonically with event records in the buffer. Therefore, + * it ensures that the end timestamp of a subbuffer is <= begin + * timestamp of the following subbuffers. + */ +static inline +void lib_ring_buffer_check_deliver(const struct lib_ring_buffer_config *config, + struct lib_ring_buffer *buf, + struct channel *chan, + unsigned long offset, + unsigned long commit_count, + unsigned long idx, + u64 tsc) +{ + unsigned long old_commit_count = commit_count + - chan->backend.subbuf_size; + + /* Check if all commits have been done */ + if (unlikely((buf_trunc(offset, chan) >> chan->backend.num_subbuf_order) + - (old_commit_count & chan->commit_count_mask) == 0)) + lib_ring_buffer_check_deliver_slow(config, buf, chan, offset, + commit_count, idx, tsc); +} + +/* + * lib_ring_buffer_write_commit_counter + * + * For flight recording. must be called after commit. + * This function increments the subbuffer's commit_seq counter each time the + * commit count reaches back the reserve offset (modulo subbuffer size). It is + * useful for crash dump. + */ +static inline +void lib_ring_buffer_write_commit_counter(const struct lib_ring_buffer_config *config, + struct lib_ring_buffer *buf, + struct channel *chan, + unsigned long buf_offset, + unsigned long commit_count, + struct commit_counters_hot *cc_hot) +{ + unsigned long commit_seq_old; + + if (config->oops != RING_BUFFER_OOPS_CONSISTENCY) + return; + + /* + * subbuf_offset includes commit_count_mask. We can simply + * compare the offsets within the subbuffer without caring about + * buffer full/empty mismatch because offset is never zero here + * (subbuffer header and record headers have non-zero length). + */ + if (unlikely(subbuf_offset(buf_offset - commit_count, chan))) + return; + + commit_seq_old = v_read(config, &cc_hot->seq); + if (likely((long) (commit_seq_old - commit_count) < 0)) + v_set(config, &cc_hot->seq, commit_count); +} + +extern int lib_ring_buffer_create(struct lib_ring_buffer *buf, + struct channel_backend *chanb, int cpu); +extern void lib_ring_buffer_free(struct lib_ring_buffer *buf); + +/* Keep track of trap nesting inside ring buffer code */ +DECLARE_PER_CPU(unsigned int, lib_ring_buffer_nesting); + +#endif /* _LIB_RING_BUFFER_FRONTEND_INTERNAL_H */ diff --git a/include/ringbuffer/frontend_types.h b/include/ringbuffer/frontend_types.h index 8f6b72f2..7c209169 100644 --- a/include/ringbuffer/frontend_types.h +++ b/include/ringbuffer/frontend_types.h @@ -1,2 +1,188 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ -#include +/* SPDX-License-Identifier: (GPL-2.0-only OR LGPL-2.1-only) + * + * lib/ringbuffer/frontend_types.h + * + * Ring Buffer Library Synchronization Header (types). + * + * Copyright (C) 2010-2012 Mathieu Desnoyers + * + * See ring_buffer_frontend.c for more information on wait-free algorithms. + */ + +#ifndef _LIB_RING_BUFFER_FRONTEND_TYPES_H +#define _LIB_RING_BUFFER_FRONTEND_TYPES_H + +#include +#include +#include +#include /* For per-CPU read-side iterator */ +#include + +/* + * A switch is done during tracing or as a final flush after tracing (so it + * won't write in the new sub-buffer). + */ +enum switch_mode { SWITCH_ACTIVE, SWITCH_FLUSH }; + +/* channel-level read-side iterator */ +struct channel_iter { + /* Prio heap of buffers. Lowest timestamps at the top. */ + struct lttng_ptr_heap heap; /* Heap of struct lib_ring_buffer ptrs */ + struct list_head empty_head; /* Empty buffers linked-list head */ + int read_open; /* Opened for reading ? */ + u64 last_qs; /* Last quiescent state timestamp */ + u64 last_timestamp; /* Last timestamp (for WARN_ON) */ + int last_cpu; /* Last timestamp cpu */ + /* + * read() file operation state. + */ + unsigned long len_left; +}; + +/* channel: collection of per-cpu ring buffers. */ +struct channel { + atomic_t record_disabled; + unsigned long commit_count_mask; /* + * Commit count mask, removing + * the MSBs corresponding to + * bits used to represent the + * subbuffer index. + */ + + struct channel_backend backend; /* Associated backend */ + + unsigned long switch_timer_interval; /* Buffer flush (jiffies) */ + unsigned long read_timer_interval; /* Reader wakeup (jiffies) */ + struct lttng_cpuhp_node cpuhp_prepare; + struct lttng_cpuhp_node cpuhp_online; + struct lttng_cpuhp_node cpuhp_iter_online; + struct notifier_block tick_nohz_notifier; /* CPU nohz notifier */ + wait_queue_head_t read_wait; /* reader wait queue */ + wait_queue_head_t hp_wait; /* CPU hotplug wait queue */ + int finalized; /* Has channel been finalized */ + struct channel_iter iter; /* Channel read-side iterator */ + struct kref ref; /* Reference count */ +}; + +/* Per-subbuffer commit counters used on the hot path */ +struct commit_counters_hot { + union v_atomic cc; /* Commit counter */ + union v_atomic seq; /* Consecutive commits */ +}; + +/* Per-subbuffer commit counters used only on cold paths */ +struct commit_counters_cold { + union v_atomic cc_sb; /* Incremented _once_ at sb switch */ +}; + +/* Per-buffer read iterator */ +struct lib_ring_buffer_iter { + u64 timestamp; /* Current record timestamp */ + size_t header_len; /* Current record header length */ + size_t payload_len; /* Current record payload length */ + + struct list_head empty_node; /* Linked list of empty buffers */ + unsigned long consumed, read_offset, data_size; + enum { + ITER_GET_SUBBUF = 0, + ITER_TEST_RECORD, + ITER_NEXT_RECORD, + ITER_PUT_SUBBUF, + } state; + unsigned int allocated:1; + unsigned int read_open:1; /* Opened for reading ? */ +}; + +/* ring buffer state */ +struct lib_ring_buffer { + /* First 32 bytes cache-hot cacheline */ + union v_atomic offset; /* Current offset in the buffer */ + struct commit_counters_hot *commit_hot; + /* Commit count per sub-buffer */ + atomic_long_t consumed; /* + * Current offset in the buffer + * standard atomic access (shared) + */ + atomic_t record_disabled; + /* End of first 32 bytes cacheline */ + union v_atomic last_tsc; /* + * Last timestamp written in the buffer. + */ + + struct lib_ring_buffer_backend backend; /* Associated backend */ + + struct commit_counters_cold *commit_cold; + /* Commit count per sub-buffer */ + u64 *ts_end; /* + * timestamp_end per sub-buffer. + * Time is sampled by the + * switch_*_end() callbacks which + * are the last space reservation + * performed in the sub-buffer + * before it can be fully + * committed and delivered. This + * time value is then read by + * the deliver callback, + * performed by the last commit + * before the buffer becomes + * readable. + */ + atomic_long_t active_readers; /* + * Active readers count + * standard atomic access (shared) + */ + /* Dropped records */ + union v_atomic records_lost_full; /* Buffer full */ + union v_atomic records_lost_wrap; /* Nested wrap-around */ + union v_atomic records_lost_big; /* Events too big */ + union v_atomic records_count; /* Number of records written */ + union v_atomic records_overrun; /* Number of overwritten records */ + wait_queue_head_t read_wait; /* reader buffer-level wait queue */ + wait_queue_head_t write_wait; /* writer buffer-level wait queue (for metadata only) */ + int finalized; /* buffer has been finalized */ + struct timer_list switch_timer; /* timer for periodical switch */ + struct timer_list read_timer; /* timer for read poll */ + raw_spinlock_t raw_tick_nohz_spinlock; /* nohz entry lock/trylock */ + struct lib_ring_buffer_iter iter; /* read-side iterator */ + unsigned long get_subbuf_consumed; /* Read-side consumed */ + unsigned long prod_snapshot; /* Producer count snapshot */ + unsigned long cons_snapshot; /* Consumer count snapshot */ + unsigned int get_subbuf:1, /* Sub-buffer being held by reader */ + switch_timer_enabled:1, /* Protected by ring_buffer_nohz_lock */ + read_timer_enabled:1, /* Protected by ring_buffer_nohz_lock */ + quiescent:1; +}; + +static inline +void *channel_get_private(struct channel *chan) +{ + return chan->backend.priv; +} + +void lib_ring_buffer_lost_event_too_big(struct channel *chan); + +/* + * Issue warnings and disable channels upon internal error. + * Can receive struct lib_ring_buffer or struct lib_ring_buffer_backend + * parameters. + */ +#define CHAN_WARN_ON(c, cond) \ + ({ \ + struct channel *__chan; \ + int _____ret = unlikely(cond); \ + if (_____ret) { \ + if (__same_type(*(c), struct channel_backend)) \ + __chan = container_of((void *) (c), \ + struct channel, \ + backend); \ + else if (__same_type(*(c), struct channel)) \ + __chan = (void *) (c); \ + else \ + BUG_ON(1); \ + atomic_inc(&__chan->record_disabled); \ + WARN_ON(1); \ + } \ + _____ret; \ + }) + +#endif /* _LIB_RING_BUFFER_FRONTEND_TYPES_H */ diff --git a/include/ringbuffer/iterator.h b/include/ringbuffer/iterator.h index 08586d33..6640e695 100644 --- a/include/ringbuffer/iterator.h +++ b/include/ringbuffer/iterator.h @@ -1,2 +1,67 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ -#include +/* SPDX-License-Identifier: (GPL-2.0-only OR LGPL-2.1-only) + * + * lib/ringbuffer/iterator.h + * + * Ring buffer and channel iterators. + * + * Copyright (C) 2010-2012 Mathieu Desnoyers + */ + +#ifndef _LIB_RING_BUFFER_ITERATOR_H +#define _LIB_RING_BUFFER_ITERATOR_H + +#include +#include +#include + +/* + * lib_ring_buffer_get_next_record advances the buffer read position to the next + * record. It returns either the size of the next record, -EAGAIN if there is + * currently no data available, or -ENODATA if no data is available and buffer + * is finalized. + */ +extern ssize_t lib_ring_buffer_get_next_record(struct channel *chan, + struct lib_ring_buffer *buf); + +/* + * channel_get_next_record advances the buffer read position to the next record. + * It returns either the size of the next record, -EAGAIN if there is currently + * no data available, or -ENODATA if no data is available and buffer is + * finalized. + * Returns the current buffer in ret_buf. + */ +extern ssize_t channel_get_next_record(struct channel *chan, + struct lib_ring_buffer **ret_buf); + +/** + * read_current_record - copy the buffer current record into dest. + * @buf: ring buffer + * @dest: destination where the record should be copied + * + * dest should be large enough to contain the record. Returns the number of + * bytes copied. + */ +static inline size_t read_current_record(struct lib_ring_buffer *buf, void *dest) +{ + return lib_ring_buffer_read(&buf->backend, buf->iter.read_offset, + dest, buf->iter.payload_len); +} + +extern int lib_ring_buffer_iterator_open(struct lib_ring_buffer *buf); +extern void lib_ring_buffer_iterator_release(struct lib_ring_buffer *buf); +extern int channel_iterator_open(struct channel *chan); +extern void channel_iterator_release(struct channel *chan); + +extern const struct file_operations channel_payload_file_operations; +extern const struct file_operations lib_ring_buffer_payload_file_operations; + +/* + * Used internally. + */ +int channel_iterator_init(struct channel *chan); +void channel_iterator_unregister_notifiers(struct channel *chan); +void channel_iterator_free(struct channel *chan); +void channel_iterator_reset(struct channel *chan); +void lib_ring_buffer_iterator_reset(struct lib_ring_buffer *buf); + +#endif /* _LIB_RING_BUFFER_ITERATOR_H */ diff --git a/include/ringbuffer/nohz.h b/include/ringbuffer/nohz.h index 33568ed5..1d28d279 100644 --- a/include/ringbuffer/nohz.h +++ b/include/ringbuffer/nohz.h @@ -1,2 +1,29 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ -#include +/* SPDX-License-Identifier: (GPL-2.0-only OR LGPL-2.1-only) + * + * lib/ringbuffer/nohz.h + * + * Copyright (C) 2011-2012 Mathieu Desnoyers + */ + +#ifndef _LIB_RING_BUFFER_NOHZ_H +#define _LIB_RING_BUFFER_NOHZ_H + +#ifdef CONFIG_LIB_RING_BUFFER +void lib_ring_buffer_tick_nohz_flush(void); +void lib_ring_buffer_tick_nohz_stop(void); +void lib_ring_buffer_tick_nohz_restart(void); +#else +static inline void lib_ring_buffer_tick_nohz_flush(void) +{ +} + +static inline void lib_ring_buffer_tick_nohz_stop(void) +{ +} + +static inline void lib_ring_buffer_tick_nohz_restart(void) +{ +} +#endif + +#endif /* _LIB_RING_BUFFER_NOHZ_H */ diff --git a/include/ringbuffer/vatomic.h b/include/ringbuffer/vatomic.h index a5e8c76a..6fdc4d1b 100644 --- a/include/ringbuffer/vatomic.h +++ b/include/ringbuffer/vatomic.h @@ -1,2 +1,84 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ -#include +/* SPDX-License-Identifier: (GPL-2.0-only OR LGPL-2.1-only) + * + * lib/ringbuffer/vatomic.h + * + * Copyright (C) 2010-2012 Mathieu Desnoyers + */ + +#ifndef _LIB_RING_BUFFER_VATOMIC_H +#define _LIB_RING_BUFFER_VATOMIC_H + +#include +#include + +/* + * Same data type (long) accessed differently depending on configuration. + * v field is for non-atomic access (protected by mutual exclusion). + * In the fast-path, the ring_buffer_config structure is constant, so the + * compiler can statically select the appropriate branch. + * local_t is used for per-cpu and per-thread buffers. + * atomic_long_t is used for globally shared buffers. + */ +union v_atomic { + local_t l; + atomic_long_t a; + long v; +}; + +static inline +long v_read(const struct lib_ring_buffer_config *config, union v_atomic *v_a) +{ + if (config->sync == RING_BUFFER_SYNC_PER_CPU) + return local_read(&v_a->l); + else + return atomic_long_read(&v_a->a); +} + +static inline +void v_set(const struct lib_ring_buffer_config *config, union v_atomic *v_a, + long v) +{ + if (config->sync == RING_BUFFER_SYNC_PER_CPU) + local_set(&v_a->l, v); + else + atomic_long_set(&v_a->a, v); +} + +static inline +void v_add(const struct lib_ring_buffer_config *config, long v, union v_atomic *v_a) +{ + if (config->sync == RING_BUFFER_SYNC_PER_CPU) + local_add(v, &v_a->l); + else + atomic_long_add(v, &v_a->a); +} + +static inline +void v_inc(const struct lib_ring_buffer_config *config, union v_atomic *v_a) +{ + if (config->sync == RING_BUFFER_SYNC_PER_CPU) + local_inc(&v_a->l); + else + atomic_long_inc(&v_a->a); +} + +/* + * Non-atomic decrement. Only used by reader, apply to reader-owned subbuffer. + */ +static inline +void _v_dec(const struct lib_ring_buffer_config *config, union v_atomic *v_a) +{ + --v_a->v; +} + +static inline +long v_cmpxchg(const struct lib_ring_buffer_config *config, union v_atomic *v_a, + long old, long _new) +{ + if (config->sync == RING_BUFFER_SYNC_PER_CPU) + return local_cmpxchg(&v_a->l, old, _new); + else + return atomic_long_cmpxchg(&v_a->a, old, _new); +} + +#endif /* _LIB_RING_BUFFER_VATOMIC_H */ diff --git a/include/ringbuffer/vfs.h b/include/ringbuffer/vfs.h index 65918408..ee23a624 100644 --- a/include/ringbuffer/vfs.h +++ b/include/ringbuffer/vfs.h @@ -1,2 +1,166 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ -#include +/* SPDX-License-Identifier: (GPL-2.0-only OR LGPL-2.1-only) + * + * lib/ringbuffer/vfs.h + * + * Wait-free ring buffer VFS file operations. + * + * Copyright (C) 2005-2012 Mathieu Desnoyers + */ + +#ifndef _LIB_RING_BUFFER_VFS_H +#define _LIB_RING_BUFFER_VFS_H + +#include +#include + +/* VFS API */ + +extern const struct file_operations lib_ring_buffer_file_operations; + +/* + * Internal file operations. + */ + +struct lib_ring_buffer; + +int lib_ring_buffer_open(struct inode *inode, struct file *file, + struct lib_ring_buffer *buf); +int lib_ring_buffer_release(struct inode *inode, struct file *file, + struct lib_ring_buffer *buf); +unsigned int lib_ring_buffer_poll(struct file *filp, poll_table *wait, + struct lib_ring_buffer *buf); +ssize_t lib_ring_buffer_splice_read(struct file *in, loff_t *ppos, + struct pipe_inode_info *pipe, size_t len, + unsigned int flags, struct lib_ring_buffer *buf); +int lib_ring_buffer_mmap(struct file *filp, struct vm_area_struct *vma, + struct lib_ring_buffer *buf); + +/* Ring Buffer ioctl() and ioctl numbers */ +long lib_ring_buffer_ioctl(struct file *filp, unsigned int cmd, + unsigned long arg, struct lib_ring_buffer *buf); +#ifdef CONFIG_COMPAT +long lib_ring_buffer_compat_ioctl(struct file *filp, unsigned int cmd, + unsigned long arg, struct lib_ring_buffer *buf); +#endif + +ssize_t vfs_lib_ring_buffer_file_splice_read(struct file *in, loff_t *ppos, + struct pipe_inode_info *pipe, size_t len, unsigned int flags); +loff_t vfs_lib_ring_buffer_no_llseek(struct file *file, loff_t offset, + int origin); +int vfs_lib_ring_buffer_mmap(struct file *filp, struct vm_area_struct *vma); +ssize_t vfs_lib_ring_buffer_splice_read(struct file *in, loff_t *ppos, + struct pipe_inode_info *pipe, size_t len, + unsigned int flags); + +/* + * Use RING_BUFFER_GET_NEXT_SUBBUF / RING_BUFFER_PUT_NEXT_SUBBUF to read and + * consume sub-buffers sequentially. + * + * Reading sub-buffers without consuming them can be performed with: + * + * RING_BUFFER_SNAPSHOT + * RING_BUFFER_SNAPSHOT_GET_CONSUMED + * RING_BUFFER_SNAPSHOT_GET_PRODUCED + * + * to get the offset range to consume, and then by passing each sub-buffer + * offset to RING_BUFFER_GET_SUBBUF, read the sub-buffer, and then release it + * with RING_BUFFER_PUT_SUBBUF. + * + * Note that the "snapshot" API can be used to read the sub-buffer in reverse + * order, which is useful for flight recorder snapshots. + */ + +/* Get a snapshot of the current ring buffer producer and consumer positions */ +#define RING_BUFFER_SNAPSHOT _IO(0xF6, 0x00) +/* Get the consumer position (iteration start) */ +#define RING_BUFFER_SNAPSHOT_GET_CONSUMED _IOR(0xF6, 0x01, unsigned long) +/* Get the producer position (iteration end) */ +#define RING_BUFFER_SNAPSHOT_GET_PRODUCED _IOR(0xF6, 0x02, unsigned long) +/* Get exclusive read access to the specified sub-buffer position */ +#define RING_BUFFER_GET_SUBBUF _IOW(0xF6, 0x03, unsigned long) +/* Release exclusive sub-buffer access */ +#define RING_BUFFER_PUT_SUBBUF _IO(0xF6, 0x04) + +/* Get exclusive read access to the next sub-buffer that can be read. */ +#define RING_BUFFER_GET_NEXT_SUBBUF _IO(0xF6, 0x05) +/* Release exclusive sub-buffer access, move consumer forward. */ +#define RING_BUFFER_PUT_NEXT_SUBBUF _IO(0xF6, 0x06) +/* returns the size of the current sub-buffer, without padding (for mmap). */ +#define RING_BUFFER_GET_SUBBUF_SIZE _IOR(0xF6, 0x07, unsigned long) +/* returns the size of the current sub-buffer, with padding (for splice). */ +#define RING_BUFFER_GET_PADDED_SUBBUF_SIZE _IOR(0xF6, 0x08, unsigned long) +/* returns the maximum size for sub-buffers. */ +#define RING_BUFFER_GET_MAX_SUBBUF_SIZE _IOR(0xF6, 0x09, unsigned long) +/* returns the length to mmap. */ +#define RING_BUFFER_GET_MMAP_LEN _IOR(0xF6, 0x0A, unsigned long) +/* returns the offset of the subbuffer belonging to the mmap reader. */ +#define RING_BUFFER_GET_MMAP_READ_OFFSET _IOR(0xF6, 0x0B, unsigned long) +/* Flush the current sub-buffer, if non-empty. */ +#define RING_BUFFER_FLUSH _IO(0xF6, 0x0C) +/* Get the current version of the metadata cache (after a get_next). */ +#define RING_BUFFER_GET_METADATA_VERSION _IOR(0xF6, 0x0D, uint64_t) +/* + * Get a snapshot of the current ring buffer producer and consumer positions, + * regardless of whether or not the two positions are contained within the same + * sub-buffer. + */ +#define RING_BUFFER_SNAPSHOT_SAMPLE_POSITIONS _IO(0xF6, 0x0E) +/* Flush the current sub-buffer, even if empty. */ +#define RING_BUFFER_FLUSH_EMPTY _IO(0xF6, 0x0F) +/* + * Reset the position of what has been consumed from the metadata cache to 0 + * so it can be read again. + */ +#define RING_BUFFER_METADATA_CACHE_DUMP _IO(0xF6, 0x10) +/* Clear ring buffer content. */ +#define RING_BUFFER_CLEAR _IO(0xF6, 0x11) + +#ifdef CONFIG_COMPAT +/* Get a snapshot of the current ring buffer producer and consumer positions */ +#define RING_BUFFER_COMPAT_SNAPSHOT RING_BUFFER_SNAPSHOT +/* Get the consumer position (iteration start) */ +#define RING_BUFFER_COMPAT_SNAPSHOT_GET_CONSUMED \ + _IOR(0xF6, 0x01, compat_ulong_t) +/* Get the producer position (iteration end) */ +#define RING_BUFFER_COMPAT_SNAPSHOT_GET_PRODUCED \ + _IOR(0xF6, 0x02, compat_ulong_t) +/* Get exclusive read access to the specified sub-buffer position */ +#define RING_BUFFER_COMPAT_GET_SUBBUF _IOW(0xF6, 0x03, compat_ulong_t) +/* Release exclusive sub-buffer access */ +#define RING_BUFFER_COMPAT_PUT_SUBBUF RING_BUFFER_PUT_SUBBUF + +/* Get exclusive read access to the next sub-buffer that can be read. */ +#define RING_BUFFER_COMPAT_GET_NEXT_SUBBUF RING_BUFFER_GET_NEXT_SUBBUF +/* Release exclusive sub-buffer access, move consumer forward. */ +#define RING_BUFFER_COMPAT_PUT_NEXT_SUBBUF RING_BUFFER_PUT_NEXT_SUBBUF +/* returns the size of the current sub-buffer, without padding (for mmap). */ +#define RING_BUFFER_COMPAT_GET_SUBBUF_SIZE _IOR(0xF6, 0x07, compat_ulong_t) +/* returns the size of the current sub-buffer, with padding (for splice). */ +#define RING_BUFFER_COMPAT_GET_PADDED_SUBBUF_SIZE \ + _IOR(0xF6, 0x08, compat_ulong_t) +/* returns the maximum size for sub-buffers. */ +#define RING_BUFFER_COMPAT_GET_MAX_SUBBUF_SIZE _IOR(0xF6, 0x09, compat_ulong_t) +/* returns the length to mmap. */ +#define RING_BUFFER_COMPAT_GET_MMAP_LEN _IOR(0xF6, 0x0A, compat_ulong_t) +/* returns the offset of the subbuffer belonging to the mmap reader. */ +#define RING_BUFFER_COMPAT_GET_MMAP_READ_OFFSET _IOR(0xF6, 0x0B, compat_ulong_t) +/* Flush the current sub-buffer, if non-empty. */ +#define RING_BUFFER_COMPAT_FLUSH RING_BUFFER_FLUSH +/* Get the current version of the metadata cache (after a get_next). */ +#define RING_BUFFER_COMPAT_GET_METADATA_VERSION RING_BUFFER_GET_METADATA_VERSION +/* + * Get a snapshot of the current ring buffer producer and consumer positions, + * regardless of whether or not the two positions are contained within the same + * sub-buffer. + */ +#define RING_BUFFER_COMPAT_SNAPSHOT_SAMPLE_POSITIONS \ + RING_BUFFER_SNAPSHOT_SAMPLE_POSITIONS +/* Flush the current sub-buffer, even if empty. */ +#define RING_BUFFER_COMPAT_FLUSH_EMPTY \ + RING_BUFFER_FLUSH_EMPTY +/* Clear ring buffer content. */ +#define RING_BUFFER_COMPAT_CLEAR \ + RING_BUFFER_CLEAR +#endif /* CONFIG_COMPAT */ + +#endif /* _LIB_RING_BUFFER_VFS_H */ diff --git a/include/wrapper/irqflags.h b/include/wrapper/irqflags.h new file mode 100644 index 00000000..3037eaea --- /dev/null +++ b/include/wrapper/irqflags.h @@ -0,0 +1,40 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) + * + * wrapper/irqflags.h + * + * wrapper around IRQ flags. + * + * Copyright (C) 2015 Mathieu Desnoyers + */ + +#ifndef _LTTNG_WRAPPER_IRQFLAGS_H +#define _LTTNG_WRAPPER_IRQFLAGS_H + +#include +#include + +#ifdef CONFIG_X86 + +static inline +int lttng_regs_irqs_disabled(struct pt_regs *regs) +{ + unsigned long flags = regs->flags; + + return raw_irqs_disabled_flags(flags); +} + +#else +/* + * lttng_regs_irqs_disabled() returns -1 if irqoff state is unknown. + * TODO: should implement lttng_regs_irqs_disabled for each architecture + * to add interruptible context for kprobes and kretprobes. + */ + +static inline +int lttng_regs_irqs_disabled(struct pt_regs *regs) +{ + return -1; +} +#endif + +#endif /* _LTTNG_WRAPPER_IRQFLAGS_H */ diff --git a/include/wrapper/trace-clock.h b/include/wrapper/trace-clock.h new file mode 100644 index 00000000..223de5c8 --- /dev/null +++ b/include/wrapper/trace-clock.h @@ -0,0 +1,212 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) + * + * wrapper/trace-clock.h + * + * Contains LTTng trace clock mapping to LTTng trace clock or mainline monotonic + * clock. This wrapper depends on CONFIG_HIGH_RES_TIMERS=y. + * + * Copyright (C) 2011-2012 Mathieu Desnoyers + */ + +#ifndef _LTTNG_TRACE_CLOCK_H +#define _LTTNG_TRACE_CLOCK_H + +#ifdef CONFIG_HAVE_TRACE_CLOCK +#include +#else /* CONFIG_HAVE_TRACE_CLOCK */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +extern struct lttng_trace_clock *lttng_trace_clock; + +/* + * We need clock values to be monotonically increasing per-cpu, which is + * not strictly guaranteed by ktime_get_mono_fast_ns(). It is + * straightforward to do on architectures with a 64-bit cmpxchg(), but + * not so on architectures without 64-bit cmpxchg. For now, only enable + * this feature on 64-bit architectures. + */ + +#if BITS_PER_LONG == 64 +#define LTTNG_USE_NMI_SAFE_CLOCK +#endif + +#ifdef LTTNG_USE_NMI_SAFE_CLOCK + +DECLARE_PER_CPU(u64, lttng_last_tsc); + +/* + * Sometimes called with preemption enabled. Can be interrupted. + */ +static inline u64 trace_clock_monotonic_wrapper(void) +{ + u64 now, last, result; + u64 *last_tsc_ptr; + + /* Use fast nmi-safe monotonic clock provided by the Linux kernel. */ + preempt_disable(); + last_tsc_ptr = this_cpu_ptr(<tng_last_tsc); + last = *last_tsc_ptr; + /* + * Read "last" before "now". It is not strictly required, but it ensures + * that an interrupt coming in won't artificially trigger a case where + * "now" < "last". This kind of situation should only happen if the + * mono_fast time source goes slightly backwards. + */ + barrier(); + now = ktime_get_mono_fast_ns(); + if (U64_MAX / 2 < now - last) + now = last; + result = cmpxchg64_local(last_tsc_ptr, last, now); + preempt_enable(); + if (result == last) { + /* Update done. */ + return now; + } else { + /* + * Update not done, due to concurrent update. We can use + * "result", since it has been sampled concurrently with our + * time read, so it should not be far from "now". + */ + return result; + } +} + +#else /* #ifdef LTTNG_USE_NMI_SAFE_CLOCK */ +static inline u64 trace_clock_monotonic_wrapper(void) +{ + ktime_t ktime; + + /* + * Refuse to trace from NMIs with this wrapper, because an NMI could + * nest over the xtime write seqlock and deadlock. + */ + if (in_nmi()) + return (u64) -EIO; + + ktime = ktime_get(); + return ktime_to_ns(ktime); +} +#endif /* #else #ifdef LTTNG_USE_NMI_SAFE_CLOCK */ + +static inline u64 trace_clock_read64_monotonic(void) +{ + return (u64) trace_clock_monotonic_wrapper(); +} + +static inline u64 trace_clock_freq_monotonic(void) +{ + return (u64) NSEC_PER_SEC; +} + +static inline int trace_clock_uuid_monotonic(char *uuid) +{ + unsigned char *boot_id; + + boot_id = get_kernel_boot_id(); + sprintf(uuid, "%pU", boot_id); + return 0; +} + +static inline const char *trace_clock_name_monotonic(void) +{ + return "monotonic"; +} + +static inline const char *trace_clock_description_monotonic(void) +{ + return "Monotonic Clock"; +} + +#ifdef LTTNG_USE_NMI_SAFE_CLOCK +static inline int get_trace_clock(void) +{ + printk_once(KERN_WARNING "LTTng: Using mainline kernel monotonic fast clock, which is NMI-safe.\n"); + return 0; +} +#else /* #ifdef LTTNG_USE_NMI_SAFE_CLOCK */ +static inline int get_trace_clock(void) +{ + printk_once(KERN_WARNING "LTTng: Using mainline kernel monotonic clock. NMIs will not be traced.\n"); + return 0; +} +#endif /* #else #ifdef LTTNG_USE_NMI_SAFE_CLOCK */ + +static inline void put_trace_clock(void) +{ +} + +static inline u64 trace_clock_read64(void) +{ + struct lttng_trace_clock *ltc = READ_ONCE(lttng_trace_clock); + + if (likely(!ltc)) { + return trace_clock_read64_monotonic(); + } else { + read_barrier_depends(); /* load ltc before content */ + return ltc->read64(); + } +} + +static inline u64 trace_clock_freq(void) +{ + struct lttng_trace_clock *ltc = READ_ONCE(lttng_trace_clock); + + if (!ltc) { + return trace_clock_freq_monotonic(); + } else { + read_barrier_depends(); /* load ltc before content */ + return ltc->freq(); + } +} + +static inline int trace_clock_uuid(char *uuid) +{ + struct lttng_trace_clock *ltc = READ_ONCE(lttng_trace_clock); + + read_barrier_depends(); /* load ltc before content */ + /* Use default UUID cb when NULL */ + if (!ltc || !ltc->uuid) { + return trace_clock_uuid_monotonic(uuid); + } else { + return ltc->uuid(uuid); + } +} + +static inline const char *trace_clock_name(void) +{ + struct lttng_trace_clock *ltc = READ_ONCE(lttng_trace_clock); + + if (!ltc) { + return trace_clock_name_monotonic(); + } else { + read_barrier_depends(); /* load ltc before content */ + return ltc->name(); + } +} + +static inline const char *trace_clock_description(void) +{ + struct lttng_trace_clock *ltc = READ_ONCE(lttng_trace_clock); + + if (!ltc) { + return trace_clock_description_monotonic(); + } else { + read_barrier_depends(); /* load ltc before content */ + return ltc->description(); + } +} + +#endif /* CONFIG_HAVE_TRACE_CLOCK */ + +#endif /* _LTTNG_TRACE_CLOCK_H */ diff --git a/include/wrapper/user_namespace.h b/include/wrapper/user_namespace.h new file mode 100644 index 00000000..8cc60207 --- /dev/null +++ b/include/wrapper/user_namespace.h @@ -0,0 +1,70 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) + * + * wrapper/user_namespace.h + * + * Copyright (C) 2019 Michael Jeanson + * + */ + +#ifndef _LTTNG_WRAPPER_USER_NAMESPACE_H +#define _LTTNG_WRAPPER_USER_NAMESPACE_H + +#include +#include + + +#define lttng_current_xxuid(xxx) \ + (from_kuid_munged(&init_user_ns, current_##xxx())) + +#define lttng_current_vxxuid(xxx) \ + (from_kuid_munged(current_user_ns(), current_##xxx())) + +#define lttng_current_xxgid(xxx) \ + (from_kgid_munged(&init_user_ns, current_##xxx())) + +#define lttng_current_vxxgid(xxx) \ + (from_kgid_munged(current_user_ns(), current_##xxx())) + +static inline +uid_t lttng_task_vuid(struct task_struct *p, struct user_namespace *ns) +{ + uid_t uid; + kuid_t kuid; + + kuid = task_cred_xxx(p, uid); + uid = from_kuid_munged(ns, kuid); + + return uid; +} + +static inline +gid_t lttng_task_vgid(struct task_struct *p, struct user_namespace *ns) +{ + gid_t gid; + kgid_t kgid; + + kgid = task_cred_xxx(p, gid); + gid = from_kgid_munged(ns, kgid); + + return gid; +} + +#define lttng_current_uid() (lttng_current_xxuid(uid)) +#define lttng_current_euid() (lttng_current_xxuid(euid)) +#define lttng_current_suid() (lttng_current_xxuid(suid)) +#define lttng_current_fsuid() (lttng_current_xxuid(fsuid)) +#define lttng_current_gid() (lttng_current_xxgid(gid)) +#define lttng_current_egid() (lttng_current_xxgid(egid)) +#define lttng_current_sgid() (lttng_current_xxgid(sgid)) +#define lttng_current_fsgid() (lttng_current_xxgid(fsgid)) + +#define lttng_current_vuid() (lttng_current_vxxuid(uid)) +#define lttng_current_veuid() (lttng_current_vxxuid(euid)) +#define lttng_current_vsuid() (lttng_current_vxxuid(suid)) +#define lttng_current_vfsuid() (lttng_current_vxxuid(fsuid)) +#define lttng_current_vgid() (lttng_current_vxxgid(gid)) +#define lttng_current_vegid() (lttng_current_vxxgid(egid)) +#define lttng_current_vsgid() (lttng_current_vxxgid(sgid)) +#define lttng_current_vfsgid() (lttng_current_vxxgid(fsgid)) + +#endif /* _LTTNG_WRAPPER_USER_NAMESPACE_H */ diff --git a/instrumentation/events/README b/instrumentation/events/README deleted file mode 100644 index fc3cd6e2..00000000 --- a/instrumentation/events/README +++ /dev/null @@ -1,24 +0,0 @@ -* Workflow for updating patches from newer kernel: - -Pull the new headers from mainline kernel to lttng-modules/. -Update those headers to fix the lttng-modules instrumentation style. - - -* Workflow to add new Tracepoint instrumentation to newer kernel, - and add support for it into LTTng: - -a) instrument the kernel with new trace events headers. If you want that - instrumentation distributed, you will have to push those changes into - the upstream Linux kernel first, -b) copy those headers into lttng-modules/ directory, -c) look at a diff from other headers between mainline kernel version and - lttng-modules/, and use that as a recipe to alter the new - lttng-modules/ headers. -d) create a new file in probes/ for the new trace event header you added, -e) add it to probes/Makefile, -f) build, make modules_install, -g) don't forget to load that new module too. - -Currently, LTTng policy is to only accept headers derived from trace -event headers accepted into the Linux kernel upstream for tracepoints -related to upstream kernel instrumentation. diff --git a/instrumentation/events/lttng-module/9p.h b/instrumentation/events/lttng-module/9p.h deleted file mode 100644 index aa7da309..00000000 --- a/instrumentation/events/lttng-module/9p.h +++ /dev/null @@ -1,54 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -#undef TRACE_SYSTEM -#define TRACE_SYSTEM 9p - -#if !defined(LTTNG_TRACE_9P_H) || defined(TRACE_HEADER_MULTI_READ) -#define LTTNG_TRACE_9P_H - -#include - -LTTNG_TRACEPOINT_EVENT(9p_client_req, - - TP_PROTO(struct p9_client *clnt, int8_t type, int tag), - - TP_ARGS(clnt, type, tag), - - TP_FIELDS( - ctf_integer_hex(void *, clnt, clnt) - ctf_integer(u8, type, type) - ctf_integer(u32, tag, tag) - ) -) - -LTTNG_TRACEPOINT_EVENT(9p_client_res, - - TP_PROTO(struct p9_client *clnt, int8_t type, int tag, int err), - - TP_ARGS(clnt, type, tag, err), - - TP_FIELDS( - ctf_integer_hex(void *, clnt, clnt) - ctf_integer(u8, type, type) - ctf_integer(u32, tag, tag) - ctf_integer(u32, err, err) - ) -) - -LTTNG_TRACEPOINT_EVENT(9p_protocol_dump, - - TP_PROTO(struct p9_client *clnt, struct p9_fcall *pdu), - - TP_ARGS(clnt, pdu), - - TP_FIELDS( - ctf_integer_hex(void *, clnt, clnt) - ctf_integer(u8, type, pdu->id) - ctf_integer(u16, tag, pdu->tag) - ctf_array(unsigned char, line, pdu->sdata, P9_PROTO_DUMP_SZ) - ) -) - -#endif /* LTTNG_TRACE_9P_H */ - -/* This part must be outside protection */ -#include diff --git a/instrumentation/events/lttng-module/arch/x86/exceptions.h b/instrumentation/events/lttng-module/arch/x86/exceptions.h deleted file mode 100644 index ec34d35b..00000000 --- a/instrumentation/events/lttng-module/arch/x86/exceptions.h +++ /dev/null @@ -1,53 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -#if !defined(LTTNG_TRACE_EXCEPTIONS_H) || defined(TRACE_HEADER_MULTI_READ) -#define LTTNG_TRACE_EXCEPTIONS_H - -#include -#include - -#undef TRACE_SYSTEM -#define TRACE_SYSTEM x86_exceptions - -LTTNG_TRACEPOINT_EVENT_CLASS(x86_exceptions_class, - - TP_PROTO(unsigned long address, struct pt_regs *regs, - unsigned long error_code), - - TP_ARGS(address, regs, error_code), - - TP_FIELDS( - ctf_integer_hex(unsigned long, address, address) - ctf_integer_hex(unsigned long, ip, regs->ip) - /* - * Note: we cast error_code from unsigned long - * to unsigned char to save space in the trace. - * Currently, only 5 low bits are used. Should be made - * larger if error codes are added to the kernel. - */ - ctf_integer_hex(unsigned char, error_code, error_code) - ) -) - -#define LTTNG_EXCEPTIONS_TRACEPOINT_EVENT_INSTANCE_MAP(name, map) \ -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(x86_exceptions_class, \ - name, \ - map, \ - TP_PROTO(unsigned long address, struct pt_regs *regs, \ - unsigned long error_code), \ - TP_ARGS(address, regs, error_code) \ -) - -LTTNG_EXCEPTIONS_TRACEPOINT_EVENT_INSTANCE_MAP(page_fault_user, - x86_exceptions_page_fault_user) -LTTNG_EXCEPTIONS_TRACEPOINT_EVENT_INSTANCE_MAP(page_fault_kernel, - x86_exceptions_page_fault_kernel) - -#endif /* LTTNG_TRACE_EXCEPTIONS_H */ - -#undef TRACE_INCLUDE_PATH -#define TRACE_INCLUDE_PATH instrumentation/events/lttng-module/arch/x86 -#undef TRACE_INCLUDE_FILE -#define TRACE_INCLUDE_FILE exceptions - -/* This part must be outside protection */ -#include diff --git a/instrumentation/events/lttng-module/arch/x86/irq_vectors.h b/instrumentation/events/lttng-module/arch/x86/irq_vectors.h deleted file mode 100644 index aa0d6d71..00000000 --- a/instrumentation/events/lttng-module/arch/x86/irq_vectors.h +++ /dev/null @@ -1,116 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -#if !defined(LTTNG_TRACE_IRQ_VECTORS_H) || defined(TRACE_HEADER_MULTI_READ) -#define LTTNG_TRACE_IRQ_VECTORS_H - -#include -#include - -#undef TRACE_SYSTEM -#define TRACE_SYSTEM x86_irq_vectors - -LTTNG_TRACEPOINT_EVENT_CLASS(x86_irq_vectors_vector_class, - TP_PROTO(int vector), - TP_ARGS(vector), - - TP_FIELDS( - ctf_integer(int, vector, vector) - ) -) - -#define LTTNG_IRQ_VECTOR_TRACEPOINT_EVENT_INSTANCE_MAP(name, map) \ -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(x86_irq_vectors_vector_class, \ - name##_entry, \ - map##_entry, \ - TP_PROTO(int vector), \ - TP_ARGS(vector) \ -) \ -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(x86_irq_vectors_vector_class, \ - name##_exit, \ - map##_exit, \ - TP_PROTO(int vector), \ - TP_ARGS(vector) \ -) - -/* - * local_timer - called when entering/exiting a local timer interrupt - * vector handler - */ -LTTNG_IRQ_VECTOR_TRACEPOINT_EVENT_INSTANCE_MAP(local_timer, - x86_irq_vectors_local_timer) - -/* - * reschedule - called when entering/exiting a reschedule vector handler - */ -LTTNG_IRQ_VECTOR_TRACEPOINT_EVENT_INSTANCE_MAP(reschedule, - x86_irq_vectors_reschedule) - -/* - * spurious_apic - called when entering/exiting a spurious apic vector handler - */ -LTTNG_IRQ_VECTOR_TRACEPOINT_EVENT_INSTANCE_MAP(spurious_apic, - x86_irq_vectors_spurious_apic) - -/* - * error_apic - called when entering/exiting an error apic vector handler - */ -LTTNG_IRQ_VECTOR_TRACEPOINT_EVENT_INSTANCE_MAP(error_apic, - x86_irq_vectors_error_apic) - -/* - * x86_platform_ipi - called when entering/exiting a x86 platform ipi interrupt - * vector handler - */ -LTTNG_IRQ_VECTOR_TRACEPOINT_EVENT_INSTANCE_MAP(x86_platform_ipi, - x86_irq_vectors_ipi) - -/* - * irq_work - called when entering/exiting a irq work interrupt - * vector handler - */ -LTTNG_IRQ_VECTOR_TRACEPOINT_EVENT_INSTANCE_MAP(irq_work, - x86_irq_vectors_irq_work) - -/* - * call_function - called when entering/exiting a call function interrupt - * vector handler - */ -LTTNG_IRQ_VECTOR_TRACEPOINT_EVENT_INSTANCE_MAP(call_function, - x86_irq_vectors_call_function) - -/* - * call_function_single - called when entering/exiting a call function - * single interrupt vector handler - */ -LTTNG_IRQ_VECTOR_TRACEPOINT_EVENT_INSTANCE_MAP(call_function_single, - x86_irq_vectors_call_function_single) - -/* - * threshold_apic - called when entering/exiting a threshold apic interrupt - * vector handler - */ -LTTNG_IRQ_VECTOR_TRACEPOINT_EVENT_INSTANCE_MAP(threshold_apic, - x86_irq_vectors_threshold_apic) - -/* - * deferred_error_apic - called when entering/exiting a deferred apic interrupt - * vector handler - */ -LTTNG_IRQ_VECTOR_TRACEPOINT_EVENT_INSTANCE_MAP(deferred_error_apic, - x86_irq_vectors_deferred_error_apic) - -/* - * thermal_apic - called when entering/exiting a thermal apic interrupt - * vector handler - */ -LTTNG_IRQ_VECTOR_TRACEPOINT_EVENT_INSTANCE_MAP(thermal_apic, - x86_irq_vectors_thermal_apic) - -#endif /* LTTNG_TRACE_IRQ_VECTORS_H */ - -#undef TRACE_INCLUDE_PATH -#define TRACE_INCLUDE_PATH instrumentation/events/lttng-module/arch/x86 -#undef TRACE_INCLUDE_FILE -#define TRACE_INCLUDE_FILE irq_vectors - -/* This part must be outside protection */ -#include diff --git a/instrumentation/events/lttng-module/arch/x86/kvm/mmutrace.h b/instrumentation/events/lttng-module/arch/x86/kvm/mmutrace.h deleted file mode 100644 index 9f210284..00000000 --- a/instrumentation/events/lttng-module/arch/x86/kvm/mmutrace.h +++ /dev/null @@ -1,180 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -#if !defined(LTTNG_TRACE_KVM_MMU_H) || defined(TRACE_HEADER_MULTI_READ) -#define LTTNG_TRACE_KVM_MMU_H - -#include - -#include - -#undef TRACE_SYSTEM -#define TRACE_SYSTEM kvm_mmu - -#define LTTNG_KVM_MMU_PAGE_FIELDS \ - ctf_integer(__u64, gfn, (sp)->gfn) \ - ctf_integer(__u32, role, (sp)->role.word) \ - ctf_integer(__u32, root_count, (sp)->root_count) \ - ctf_integer(bool, unsync, (sp)->unsync) - -/* - * A pagetable walk has started - */ -LTTNG_TRACEPOINT_EVENT( - kvm_mmu_pagetable_walk, - TP_PROTO(u64 addr, u32 pferr), - TP_ARGS(addr, pferr), - - TP_FIELDS( - ctf_integer_hex(__u64, addr, addr) - ctf_integer(__u32, pferr, pferr) - ) -) - -/* We just walked a paging element */ -LTTNG_TRACEPOINT_EVENT( - kvm_mmu_paging_element, - TP_PROTO(u64 pte, int level), - TP_ARGS(pte, level), - - TP_FIELDS( - ctf_integer(__u64, pte, pte) - ctf_integer(__u32, level, level) - ) -) - -LTTNG_TRACEPOINT_EVENT_CLASS(kvm_mmu_set_bit_class, - - TP_PROTO(unsigned long table_gfn, unsigned index, unsigned size), - - TP_ARGS(table_gfn, index, size), - - TP_FIELDS( - ctf_integer(__u64, gpa, - ((u64)table_gfn << PAGE_SHIFT) + index * size) - ) -) - -/* We set a pte accessed bit */ -LTTNG_TRACEPOINT_EVENT_INSTANCE(kvm_mmu_set_bit_class, kvm_mmu_set_accessed_bit, - - TP_PROTO(unsigned long table_gfn, unsigned index, unsigned size), - - TP_ARGS(table_gfn, index, size) -) - -/* We set a pte dirty bit */ -LTTNG_TRACEPOINT_EVENT_INSTANCE(kvm_mmu_set_bit_class, kvm_mmu_set_dirty_bit, - - TP_PROTO(unsigned long table_gfn, unsigned index, unsigned size), - - TP_ARGS(table_gfn, index, size) -) - -LTTNG_TRACEPOINT_EVENT( - kvm_mmu_walker_error, - TP_PROTO(u32 pferr), - TP_ARGS(pferr), - - TP_FIELDS( - ctf_integer(__u32, pferr, pferr) - ) -) - -LTTNG_TRACEPOINT_EVENT( - kvm_mmu_get_page, - TP_PROTO(struct kvm_mmu_page *sp, bool created), - TP_ARGS(sp, created), - - TP_FIELDS( - LTTNG_KVM_MMU_PAGE_FIELDS - ctf_integer(bool, created, created) - ) -) - -LTTNG_TRACEPOINT_EVENT_CLASS(kvm_mmu_page_class, - - TP_PROTO(struct kvm_mmu_page *sp), - TP_ARGS(sp), - - TP_FIELDS( - LTTNG_KVM_MMU_PAGE_FIELDS - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(kvm_mmu_page_class, kvm_mmu_sync_page, - TP_PROTO(struct kvm_mmu_page *sp), - - TP_ARGS(sp) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(kvm_mmu_page_class, kvm_mmu_unsync_page, - TP_PROTO(struct kvm_mmu_page *sp), - - TP_ARGS(sp) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(kvm_mmu_page_class, kvm_mmu_prepare_zap_page, - TP_PROTO(struct kvm_mmu_page *sp), - - TP_ARGS(sp) -) - -LTTNG_TRACEPOINT_EVENT_MAP( - mark_mmio_spte, - - kvm_mmu_mark_mmio_spte, - - TP_PROTO(u64 *sptep, gfn_t gfn, unsigned access, unsigned int gen), - TP_ARGS(sptep, gfn, access, gen), - - TP_FIELDS( - ctf_integer_hex(void *, sptep, sptep) - ctf_integer(gfn_t, gfn, gfn) - ctf_integer(unsigned, access, access) - ctf_integer(unsigned int, gen, gen) - ) -) - -LTTNG_TRACEPOINT_EVENT_MAP( - handle_mmio_page_fault, - - kvm_mmu_handle_mmio_page_fault, - - TP_PROTO(u64 addr, gfn_t gfn, unsigned access), - TP_ARGS(addr, gfn, access), - - TP_FIELDS( - ctf_integer_hex(u64, addr, addr) - ctf_integer(gfn_t, gfn, gfn) - ctf_integer(unsigned, access, access) - ) -) - -LTTNG_TRACEPOINT_EVENT_MAP( - fast_page_fault, - - kvm_mmu_fast_page_fault, - - TP_PROTO(struct kvm_vcpu *vcpu, gpa_t cr2_or_gpa, u32 error_code, - u64 *sptep, u64 old_spte, bool retry), - TP_ARGS(vcpu, cr2_or_gpa, error_code, sptep, old_spte, retry), - - TP_FIELDS( - ctf_integer(int, vcpu_id, vcpu->vcpu_id) - ctf_integer(gpa_t, cr2_or_gpa, cr2_or_gpa) - ctf_integer(u32, error_code, error_code) - ctf_integer_hex(u64 *, sptep, sptep) - ctf_integer(u64, old_spte, old_spte) - ctf_integer(u64, new_spte, *sptep) - ctf_integer(bool, retry, retry) - ) -) - -#endif /* LTTNG_TRACE_KVM_MMU_H */ - -#undef TRACE_INCLUDE_PATH -#define TRACE_INCLUDE_PATH instrumentation/events/lttng-module/arch/x86/kvm -#undef TRACE_INCLUDE_FILE -#define TRACE_INCLUDE_FILE mmutrace - -/* This part must be outside protection */ -#include diff --git a/instrumentation/events/lttng-module/arch/x86/kvm/trace.h b/instrumentation/events/lttng-module/arch/x86/kvm/trace.h deleted file mode 100644 index 19b1c086..00000000 --- a/instrumentation/events/lttng-module/arch/x86/kvm/trace.h +++ /dev/null @@ -1,503 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -#if !defined(LTTNG_TRACE_KVM_H) || defined(TRACE_HEADER_MULTI_READ) -#define LTTNG_TRACE_KVM_H - -#include -#include -#include -#include -#include <../arch/x86/kvm/lapic.h> -#include <../arch/x86/kvm/kvm_cache_regs.h> - -#undef TRACE_SYSTEM -#define TRACE_SYSTEM kvm_x86 - -/* - * Tracepoint for guest mode entry. - */ -LTTNG_TRACEPOINT_EVENT_MAP(kvm_entry, kvm_x86_entry, - TP_PROTO(unsigned int vcpu_id), - TP_ARGS(vcpu_id), - - TP_FIELDS( - ctf_integer(unsigned int, vcpu_id, vcpu_id) - ) -) - -/* - * Tracepoint for hypercall. - */ -LTTNG_TRACEPOINT_EVENT_MAP(kvm_hypercall, kvm_x86_hypercall, - TP_PROTO(unsigned long nr, unsigned long a0, unsigned long a1, - unsigned long a2, unsigned long a3), - TP_ARGS(nr, a0, a1, a2, a3), - - TP_FIELDS( - ctf_integer(unsigned long, nr, nr) - ctf_integer(unsigned long, a0, a0) - ctf_integer(unsigned long, a1, a1) - ctf_integer(unsigned long, a2, a2) - ctf_integer(unsigned long, a3, a3) - ) -) - -/* - * Tracepoint for hypercall. - */ -LTTNG_TRACEPOINT_EVENT_MAP(kvm_hv_hypercall, kvm_x86_hv_hypercall, - TP_PROTO(__u16 code, bool fast, __u16 rep_cnt, __u16 rep_idx, - __u64 ingpa, __u64 outgpa), - TP_ARGS(code, fast, rep_cnt, rep_idx, ingpa, outgpa), - - TP_FIELDS( - ctf_integer(__u16, rep_cnt, rep_cnt) - ctf_integer(__u16, rep_idx, rep_idx) - ctf_integer(__u64, ingpa, ingpa) - ctf_integer(__u64, outgpa, outgpa) - ctf_integer(__u16, code, code) - ctf_integer(bool, fast, fast) - ) -) - -/* - * Tracepoint for PIO. - */ -LTTNG_TRACEPOINT_EVENT_MAP(kvm_pio, kvm_x86_pio, - TP_PROTO(unsigned int rw, unsigned int port, unsigned int size, - unsigned int count), - TP_ARGS(rw, port, size, count), - - TP_FIELDS( - ctf_integer(unsigned int, rw, rw) - ctf_integer(unsigned int, port, port) - ctf_integer(unsigned int, size, size) - ctf_integer(unsigned int, count, count) - ) -) - -/* - * Tracepoint for cpuid. - */ -LTTNG_TRACEPOINT_EVENT_MAP(kvm_cpuid, kvm_x86_cpuid, - TP_PROTO(unsigned int function, unsigned long rax, unsigned long rbx, - unsigned long rcx, unsigned long rdx), - TP_ARGS(function, rax, rbx, rcx, rdx), - - TP_FIELDS( - ctf_integer(unsigned int, function, function) - ctf_integer(unsigned long, rax, rax) - ctf_integer(unsigned long, rbx, rbx) - ctf_integer(unsigned long, rcx, rcx) - ctf_integer(unsigned long, rdx, rdx) - ) -) - -/* - * Tracepoint for apic access. - */ -LTTNG_TRACEPOINT_EVENT_MAP(kvm_apic, kvm_x86_apic, - TP_PROTO(unsigned int rw, unsigned int reg, unsigned int val), - TP_ARGS(rw, reg, val), - - TP_FIELDS( - ctf_integer(unsigned int, rw, rw) - ctf_integer(unsigned int, reg, reg) - ctf_integer(unsigned int, val, val) - ) -) - -#define trace_kvm_apic_read(reg, val) trace_kvm_apic(0, reg, val) -#define trace_kvm_apic_write(reg, val) trace_kvm_apic(1, reg, val) - -/* - * Tracepoint for kvm guest exit: - */ -LTTNG_TRACEPOINT_EVENT_CODE_MAP(kvm_exit, kvm_x86_exit, - TP_PROTO(unsigned int exit_reason, struct kvm_vcpu *vcpu, u32 isa), - TP_ARGS(exit_reason, vcpu, isa), - - TP_locvar( - u64 info1, info2; - ), - - TP_code_pre( - kvm_x86_ops.get_exit_info(vcpu, &tp_locvar->info1, - &tp_locvar->info2); - ), - - TP_FIELDS( - ctf_integer(unsigned int, exit_reason, exit_reason) - ctf_integer(unsigned long, guest_rip, kvm_rip_read(vcpu)) - ctf_integer(u32, isa, isa) - ctf_integer(u64, info1, tp_locvar->info1) - ctf_integer(u64, info2, tp_locvar->info2) - ), - - TP_code_post() -) - -/* - * Tracepoint for kvm interrupt injection: - */ -LTTNG_TRACEPOINT_EVENT_MAP(kvm_inj_virq, kvm_x86_inj_virq, - TP_PROTO(unsigned int irq), - TP_ARGS(irq), - - TP_FIELDS( - ctf_integer(unsigned int, irq, irq) - ) -) - -/* - * Tracepoint for kvm interrupt injection: - */ -LTTNG_TRACEPOINT_EVENT_MAP(kvm_inj_exception, kvm_x86_inj_exception, - TP_PROTO(unsigned exception, bool has_error, unsigned error_code), - TP_ARGS(exception, has_error, error_code), - - TP_FIELDS( - ctf_integer(u8, exception, exception) - ctf_integer(u8, has_error, has_error) - ctf_integer(u32, error_code, error_code) - ) -) - -/* - * Tracepoint for page fault. - */ -LTTNG_TRACEPOINT_EVENT_MAP(kvm_page_fault, kvm_x86_page_fault, - TP_PROTO(unsigned long fault_address, unsigned int error_code), - TP_ARGS(fault_address, error_code), - - TP_FIELDS( - ctf_integer_hex(unsigned long, fault_address, fault_address) - ctf_integer(unsigned int, error_code, error_code) - ) -) - -/* - * Tracepoint for guest MSR access. - */ -LTTNG_TRACEPOINT_EVENT_MAP(kvm_msr, kvm_x86_msr, - TP_PROTO(unsigned write, u32 ecx, u64 data, bool exception), - TP_ARGS(write, ecx, data, exception), - - TP_FIELDS( - ctf_integer(unsigned, write, write) - ctf_integer(u32, ecx, ecx) - ctf_integer(u64, data, data) - ctf_integer(u8, exception, exception) - ) -) - -#define trace_kvm_msr_read(ecx, data) trace_kvm_msr(0, ecx, data, false) -#define trace_kvm_msr_write(ecx, data) trace_kvm_msr(1, ecx, data, false) -#define trace_kvm_msr_read_ex(ecx) trace_kvm_msr(0, ecx, 0, true) -#define trace_kvm_msr_write_ex(ecx, data) trace_kvm_msr(1, ecx, data, true) - -/* - * Tracepoint for guest CR access. - */ -LTTNG_TRACEPOINT_EVENT_MAP(kvm_cr, kvm_x86_cr, - TP_PROTO(unsigned int rw, unsigned int cr, unsigned long val), - TP_ARGS(rw, cr, val), - - TP_FIELDS( - ctf_integer(unsigned int, rw, rw) - ctf_integer(unsigned int, cr, cr) - ctf_integer(unsigned long, val, val) - ) -) - -#define trace_kvm_cr_read(cr, val) trace_kvm_cr(0, cr, val) -#define trace_kvm_cr_write(cr, val) trace_kvm_cr(1, cr, val) - -LTTNG_TRACEPOINT_EVENT_MAP(kvm_pic_set_irq, kvm_x86_pic_set_irq, - TP_PROTO(__u8 chip, __u8 pin, __u8 elcr, __u8 imr, bool coalesced), - TP_ARGS(chip, pin, elcr, imr, coalesced), - - TP_FIELDS( - ctf_integer(__u8, chip, chip) - ctf_integer(__u8, pin, pin) - ctf_integer(__u8, elcr, elcr) - ctf_integer(__u8, imr, imr) - ctf_integer(bool, coalesced, coalesced) - ) -) - -LTTNG_TRACEPOINT_EVENT_MAP(kvm_apic_ipi, kvm_x86_apic_ipi, - TP_PROTO(__u32 icr_low, __u32 dest_id), - TP_ARGS(icr_low, dest_id), - - TP_FIELDS( - ctf_integer(__u32, icr_low, icr_low) - ctf_integer(__u32, dest_id, dest_id) - ) -) - -LTTNG_TRACEPOINT_EVENT_MAP(kvm_apic_accept_irq, kvm_x86_apic_accept_irq, - TP_PROTO(__u32 apicid, __u16 dm, __u8 tm, __u8 vec, bool coalesced), - TP_ARGS(apicid, dm, tm, vec, coalesced), - - TP_FIELDS( - ctf_integer(__u32, apicid, apicid) - ctf_integer(__u16, dm, dm) - ctf_integer(__u8, tm, tm) - ctf_integer(__u8, vec, vec) - ctf_integer(bool, coalesced, coalesced) - ) -) - -LTTNG_TRACEPOINT_EVENT_MAP(kvm_eoi, kvm_x86_eoi, - TP_PROTO(struct kvm_lapic *apic, int vector), - TP_ARGS(apic, vector), - - TP_FIELDS( - ctf_integer(__u32, apicid, apic->vcpu->vcpu_id) - ctf_integer(int, vector, vector) - ) -) - -LTTNG_TRACEPOINT_EVENT_MAP(kvm_pv_eoi, kvm_x86_pv_eoi, - TP_PROTO(struct kvm_lapic *apic, int vector), - TP_ARGS(apic, vector), - - TP_FIELDS( - ctf_integer(__u32, apicid, apic->vcpu->vcpu_id) - ctf_integer(int, vector, vector) - ) -) - -/* - * Tracepoint for nested VMRUN - */ -LTTNG_TRACEPOINT_EVENT_MAP(kvm_nested_vmrun, kvm_x86_nested_vmrun, - TP_PROTO(__u64 rip, __u64 vmcb, __u64 nested_rip, __u32 int_ctl, - __u32 event_inj, bool npt), - TP_ARGS(rip, vmcb, nested_rip, int_ctl, event_inj, npt), - - TP_FIELDS( - ctf_integer(__u64, rip, rip) - ctf_integer(__u64, vmcb, vmcb) - ctf_integer(__u64, nested_rip, nested_rip) - ctf_integer(__u32, int_ctl, int_ctl) - ctf_integer(__u32, event_inj, event_inj) - ctf_integer(bool, npt, npt) - ) -) - -LTTNG_TRACEPOINT_EVENT_MAP(kvm_nested_intercepts, kvm_x86_nested_intercepts, - TP_PROTO(__u16 cr_read, __u16 cr_write, __u32 exceptions, __u64 intercept), - TP_ARGS(cr_read, cr_write, exceptions, intercept), - - TP_FIELDS( - ctf_integer(__u16, cr_read, cr_read) - ctf_integer(__u16, cr_write, cr_write) - ctf_integer(__u32, exceptions, exceptions) - ctf_integer(__u64, intercept, intercept) - ) -) -/* - * Tracepoint for #VMEXIT while nested - */ -LTTNG_TRACEPOINT_EVENT_MAP(kvm_nested_vmexit, kvm_x86_nested_vmexit, - TP_PROTO(__u64 rip, __u32 exit_code, - __u64 exit_info1, __u64 exit_info2, - __u32 exit_int_info, __u32 exit_int_info_err, __u32 isa), - TP_ARGS(rip, exit_code, exit_info1, exit_info2, - exit_int_info, exit_int_info_err, isa), - - TP_FIELDS( - ctf_integer(__u64, rip, rip) - ctf_integer(__u32, exit_code, exit_code) - ctf_integer(__u64, exit_info1, exit_info1) - ctf_integer(__u64, exit_info2, exit_info2) - ctf_integer(__u32, exit_int_info, exit_int_info) - ctf_integer(__u32, exit_int_info_err, exit_int_info_err) - ctf_integer(__u32, isa, isa) - ) -) - -/* - * Tracepoint for #VMEXIT reinjected to the guest - */ -LTTNG_TRACEPOINT_EVENT_MAP(kvm_nested_vmexit_inject, kvm_x86_nested_vmexit_inject, - TP_PROTO(__u32 exit_code, - __u64 exit_info1, __u64 exit_info2, - __u32 exit_int_info, __u32 exit_int_info_err, __u32 isa), - TP_ARGS(exit_code, exit_info1, exit_info2, - exit_int_info, exit_int_info_err, isa), - - TP_FIELDS( - ctf_integer(__u32, exit_code, exit_code) - ctf_integer(__u64, exit_info1, exit_info1) - ctf_integer(__u64, exit_info2, exit_info2) - ctf_integer(__u32, exit_int_info, exit_int_info) - ctf_integer(__u32, exit_int_info_err, exit_int_info_err) - ctf_integer(__u32, isa, isa) - ) -) - -/* - * Tracepoint for nested #vmexit because of interrupt pending - */ -LTTNG_TRACEPOINT_EVENT_MAP(kvm_nested_intr_vmexit, kvm_x86_nested_intr_vmexit, - TP_PROTO(__u64 rip), - TP_ARGS(rip), - - TP_FIELDS( - ctf_integer(__u64, rip, rip) - ) -) - -/* - * Tracepoint for nested #vmexit because of interrupt pending - */ -LTTNG_TRACEPOINT_EVENT_MAP(kvm_invlpga, kvm_x86_invlpga, - TP_PROTO(__u64 rip, int asid, u64 address), - TP_ARGS(rip, asid, address), - - TP_FIELDS( - ctf_integer(__u64, rip, rip) - ctf_integer(int, asid, asid) - ctf_integer_hex(__u64, address, address) - ) -) - -/* - * Tracepoint for nested #vmexit because of interrupt pending - */ -LTTNG_TRACEPOINT_EVENT_MAP(kvm_skinit, kvm_x86_skinit, - TP_PROTO(__u64 rip, __u32 slb), - TP_ARGS(rip, slb), - - TP_FIELDS( - ctf_integer(__u64, rip, rip) - ctf_integer(__u32, slb, slb) - ) -) - -#define KVM_EMUL_INSN_F_CR0_PE (1 << 0) -#define KVM_EMUL_INSN_F_EFL_VM (1 << 1) -#define KVM_EMUL_INSN_F_CS_D (1 << 2) -#define KVM_EMUL_INSN_F_CS_L (1 << 3) - -#define kvm_trace_symbol_emul_flags \ - { 0, "real" }, \ - { KVM_EMUL_INSN_F_CR0_PE \ - | KVM_EMUL_INSN_F_EFL_VM, "vm16" }, \ - { KVM_EMUL_INSN_F_CR0_PE, "prot16" }, \ - { KVM_EMUL_INSN_F_CR0_PE \ - | KVM_EMUL_INSN_F_CS_D, "prot32" }, \ - { KVM_EMUL_INSN_F_CR0_PE \ - | KVM_EMUL_INSN_F_CS_L, "prot64" } - -#define kei_decode_mode(mode) ({ \ - u8 flags = 0xff; \ - switch (mode) { \ - case X86EMUL_MODE_REAL: \ - flags = 0; \ - break; \ - case X86EMUL_MODE_VM86: \ - flags = KVM_EMUL_INSN_F_EFL_VM; \ - break; \ - case X86EMUL_MODE_PROT16: \ - flags = KVM_EMUL_INSN_F_CR0_PE; \ - break; \ - case X86EMUL_MODE_PROT32: \ - flags = KVM_EMUL_INSN_F_CR0_PE \ - | KVM_EMUL_INSN_F_CS_D; \ - break; \ - case X86EMUL_MODE_PROT64: \ - flags = KVM_EMUL_INSN_F_CR0_PE \ - | KVM_EMUL_INSN_F_CS_L; \ - break; \ - } \ - flags; \ - }) - -LTTNG_TRACEPOINT_EVENT_MAP(kvm_emulate_insn, kvm_x86_emulate_insn, - TP_PROTO(struct kvm_vcpu *vcpu, __u8 failed), - TP_ARGS(vcpu, failed), - - TP_FIELDS( - ctf_integer(__u64, rip, vcpu->arch.emulate_ctxt->_eip - - (vcpu->arch.emulate_ctxt->fetch.ptr - - vcpu->arch.emulate_ctxt->fetch.data)) - ctf_integer(__u32, csbase, kvm_x86_ops.get_segment_base(vcpu, VCPU_SREG_CS)) - ctf_integer(__u8, len, vcpu->arch.emulate_ctxt->fetch.ptr - - vcpu->arch.emulate_ctxt->fetch.data) - ctf_array(__u8, insn, vcpu->arch.emulate_ctxt->fetch.data, 15) - ctf_integer(__u8, flags, kei_decode_mode(vcpu->arch.emulate_ctxt->mode)) - ctf_integer(__u8, failed, failed) - ) -) - -#define trace_kvm_emulate_insn_start(vcpu) trace_kvm_emulate_insn(vcpu, 0) -#define trace_kvm_emulate_insn_failed(vcpu) trace_kvm_emulate_insn(vcpu, 1) - -LTTNG_TRACEPOINT_EVENT_MAP( - vcpu_match_mmio, kvm_x86_vcpu_match_mmio, - TP_PROTO(gva_t gva, gpa_t gpa, bool write, bool gpa_match), - TP_ARGS(gva, gpa, write, gpa_match), - - TP_FIELDS( - ctf_integer(gva_t, gva, gva) - ctf_integer(gpa_t, gpa, gpa) - ctf_integer(bool, write, write) - ctf_integer(bool, gpa_match, gpa_match) - ) -) - -LTTNG_TRACEPOINT_EVENT_MAP(kvm_write_tsc_offset, kvm_x86_write_tsc_offset, - TP_PROTO(unsigned int vcpu_id, __u64 previous_tsc_offset, - __u64 next_tsc_offset), - TP_ARGS(vcpu_id, previous_tsc_offset, next_tsc_offset), - - TP_FIELDS( - ctf_integer(unsigned int, vcpu_id, vcpu_id) - ctf_integer(__u64, previous_tsc_offset, previous_tsc_offset) - ctf_integer(__u64, next_tsc_offset, next_tsc_offset) - ) -) - -#ifdef CONFIG_X86_64 - -LTTNG_TRACEPOINT_EVENT_MAP(kvm_update_master_clock, kvm_x86_update_master_clock, - TP_PROTO(bool use_master_clock, unsigned int host_clock, bool offset_matched), - TP_ARGS(use_master_clock, host_clock, offset_matched), - - TP_FIELDS( - ctf_integer(bool, use_master_clock, use_master_clock) - ctf_integer(unsigned int, host_clock, host_clock) - ctf_integer(bool, offset_matched, offset_matched) - ) -) - -LTTNG_TRACEPOINT_EVENT_MAP(kvm_track_tsc, kvm_x86_track_tsc, - TP_PROTO(unsigned int vcpu_id, unsigned int nr_matched, - unsigned int online_vcpus, bool use_master_clock, - unsigned int host_clock), - TP_ARGS(vcpu_id, nr_matched, online_vcpus, use_master_clock, - host_clock), - - TP_FIELDS( - ctf_integer(unsigned int, vcpu_id, vcpu_id) - ctf_integer(unsigned int, nr_vcpus_matched_tsc, nr_matched) - ctf_integer(unsigned int, online_vcpus, online_vcpus) - ctf_integer(bool, use_master_clock, use_master_clock) - ctf_integer(unsigned int, host_clock, host_clock) - ) -) - -#endif /* CONFIG_X86_64 */ - -#endif /* LTTNG_TRACE_KVM_H */ - -#undef TRACE_INCLUDE_PATH -#define TRACE_INCLUDE_PATH instrumentation/events/lttng-module/arch/x86/kvm -#undef TRACE_INCLUDE_FILE -#define TRACE_INCLUDE_FILE trace - -/* This part must be outside protection */ -#include diff --git a/instrumentation/events/lttng-module/block.h b/instrumentation/events/lttng-module/block.h deleted file mode 100644 index 3ca51369..00000000 --- a/instrumentation/events/lttng-module/block.h +++ /dev/null @@ -1,538 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -#undef TRACE_SYSTEM -#define TRACE_SYSTEM block - -#if !defined(LTTNG_TRACE_BLOCK_H) || defined(TRACE_HEADER_MULTI_READ) -#define LTTNG_TRACE_BLOCK_H - -#include -#include -#include -#include - -#include - -#ifndef _TRACE_BLOCK_DEF_ -#define _TRACE_BLOCK_DEF_ - -enum { - RWBS_FLAG_WRITE = (1 << 0), - RWBS_FLAG_DISCARD = (1 << 1), - RWBS_FLAG_READ = (1 << 2), - RWBS_FLAG_RAHEAD = (1 << 3), - RWBS_FLAG_BARRIER = (1 << 4), - RWBS_FLAG_SYNC = (1 << 5), - RWBS_FLAG_META = (1 << 6), - RWBS_FLAG_SECURE = (1 << 7), - RWBS_FLAG_FLUSH = (1 << 8), - RWBS_FLAG_FUA = (1 << 9), - RWBS_FLAG_PREFLUSH = (1 << 10), -}; - -#endif /* _TRACE_BLOCK_DEF_ */ - -LTTNG_TRACEPOINT_ENUM(block_rq_type, - TP_ENUM_VALUES( - ctf_enum_value("RWBS_FLAG_WRITE", RWBS_FLAG_WRITE) - ctf_enum_value("RWBS_FLAG_DISCARD", RWBS_FLAG_DISCARD) - ctf_enum_value("RWBS_FLAG_READ", RWBS_FLAG_READ) - ctf_enum_value("RWBS_FLAG_RAHEAD", RWBS_FLAG_RAHEAD) - ctf_enum_value("RWBS_FLAG_BARRIER", RWBS_FLAG_BARRIER) - ctf_enum_value("RWBS_FLAG_SYNC", RWBS_FLAG_SYNC) - ctf_enum_value("RWBS_FLAG_META", RWBS_FLAG_META) - ctf_enum_value("RWBS_FLAG_SECURE", RWBS_FLAG_SECURE) - ctf_enum_value("RWBS_FLAG_FLUSH", RWBS_FLAG_FLUSH) - ctf_enum_value("RWBS_FLAG_FUA", RWBS_FLAG_FUA) - ctf_enum_value("RWBS_FLAG_PREFLUSH", RWBS_FLAG_PREFLUSH) - ) -) - -#define lttng_req_op(rq) req_op(rq) -#define lttng_req_rw(rq) ((rq)->cmd_flags) -#define lttng_bio_op(bio) bio_op(bio) -#define lttng_bio_rw(bio) ((bio)->bi_opf) - -#define blk_rwbs_ctf_integer(type, rwbs, op, rw, bytes) \ - ctf_enum(block_rq_type, type, rwbs, \ - (((op) == REQ_OP_WRITE || (op) == REQ_OP_WRITE_SAME) ? RWBS_FLAG_WRITE : \ - ( (op) == REQ_OP_DISCARD ? RWBS_FLAG_DISCARD : \ - ( (op) == REQ_OP_SECURE_ERASE ? (RWBS_FLAG_DISCARD | RWBS_FLAG_SECURE) : \ - ( (op) == REQ_OP_FLUSH ? RWBS_FLAG_FLUSH : \ - ( (op) == REQ_OP_READ ? RWBS_FLAG_READ : \ - ( 0 )))))) \ - | ((rw) & REQ_RAHEAD ? RWBS_FLAG_RAHEAD : 0) \ - | ((rw) & REQ_SYNC ? RWBS_FLAG_SYNC : 0) \ - | ((rw) & REQ_META ? RWBS_FLAG_META : 0) \ - | ((rw) & REQ_PREFLUSH ? RWBS_FLAG_PREFLUSH : 0) \ - | ((rw) & REQ_FUA ? RWBS_FLAG_FUA : 0)) - -LTTNG_TRACEPOINT_EVENT_CLASS(block_buffer, - - TP_PROTO(struct buffer_head *bh), - - TP_ARGS(bh), - - TP_FIELDS ( - ctf_integer(dev_t, dev, bh->b_bdev->bd_dev) - ctf_integer(sector_t, sector, bh->b_blocknr) - ctf_integer(size_t, size, bh->b_size) - ) -) - -/** - * block_touch_buffer - mark a buffer accessed - * @bh: buffer_head being touched - * - * Called from touch_buffer(). - */ -LTTNG_TRACEPOINT_EVENT_INSTANCE(block_buffer, block_touch_buffer, - - TP_PROTO(struct buffer_head *bh), - - TP_ARGS(bh) -) - -/** - * block_dirty_buffer - mark a buffer dirty - * @bh: buffer_head being dirtied - * - * Called from mark_buffer_dirty(). - */ -LTTNG_TRACEPOINT_EVENT_INSTANCE(block_buffer, block_dirty_buffer, - - TP_PROTO(struct buffer_head *bh), - - TP_ARGS(bh) -) - -/** - * block_rq_requeue - place block IO request back on a queue - * @q: queue holding operation - * @rq: block IO operation request - * - * The block operation request @rq is being placed back into queue - * @q. For some reason the request was not completed and needs to be - * put back in the queue. - */ -LTTNG_TRACEPOINT_EVENT(block_rq_requeue, - - TP_PROTO(struct request_queue *q, struct request *rq), - - TP_ARGS(q, rq), - - TP_FIELDS( - ctf_integer(dev_t, dev, - rq->rq_disk ? disk_devt(rq->rq_disk) : 0) - ctf_integer(sector_t, sector, blk_rq_trace_sector(rq)) - ctf_integer(unsigned int, nr_sector, blk_rq_trace_nr_sectors(rq)) - blk_rwbs_ctf_integer(unsigned int, rwbs, - lttng_req_op(rq), lttng_req_rw(rq), blk_rq_bytes(rq)) - ) -) - -/** - * block_rq_complete - block IO operation completed by device driver - * @q: queue containing the block operation request - * @rq: block operations request - * @nr_bytes: number of completed bytes - * - * The block_rq_complete tracepoint event indicates that some portion - * of operation request has been completed by the device driver. If - * the @rq->bio is %NULL, then there is absolutely no additional work to - * do for the request. If @rq->bio is non-NULL then there is - * additional work required to complete the request. - */ -LTTNG_TRACEPOINT_EVENT(block_rq_complete, - - TP_PROTO(struct request *rq, int error, unsigned int nr_bytes), - - TP_ARGS(rq, error, nr_bytes), - - TP_FIELDS( - ctf_integer(dev_t, dev, - rq->rq_disk ? disk_devt(rq->rq_disk) : 0) - ctf_integer(sector_t, sector, blk_rq_pos(rq)) - ctf_integer(unsigned int, nr_sector, nr_bytes >> 9) - ctf_integer(int, error, error) - blk_rwbs_ctf_integer(unsigned int, rwbs, - lttng_req_op(rq), lttng_req_rw(rq), nr_bytes) - ) -) - -LTTNG_TRACEPOINT_EVENT_CLASS(block_rq, - - TP_PROTO(struct request_queue *q, struct request *rq), - - TP_ARGS(q, rq), - - TP_FIELDS( - ctf_integer(dev_t, dev, - rq->rq_disk ? disk_devt(rq->rq_disk) : 0) - ctf_integer(sector_t, sector, blk_rq_trace_sector(rq)) - ctf_integer(unsigned int, nr_sector, blk_rq_trace_nr_sectors(rq)) - ctf_integer(unsigned int, bytes, blk_rq_bytes(rq)) - ctf_integer(pid_t, tid, current->pid) - blk_rwbs_ctf_integer(unsigned int, rwbs, - lttng_req_op(rq), lttng_req_rw(rq), blk_rq_bytes(rq)) - ctf_array_text(char, comm, current->comm, TASK_COMM_LEN) - ) -) - -/** - * block_rq_insert - insert block operation request into queue - * @q: target queue - * @rq: block IO operation request - * - * Called immediately before block operation request @rq is inserted - * into queue @q. The fields in the operation request @rq struct can - * be examined to determine which device and sectors the pending - * operation would access. - */ -LTTNG_TRACEPOINT_EVENT_INSTANCE(block_rq, block_rq_insert, - - TP_PROTO(struct request_queue *q, struct request *rq), - - TP_ARGS(q, rq) -) - -/** - * block_rq_issue - issue pending block IO request operation to device driver - * @q: queue holding operation - * @rq: block IO operation operation request - * - * Called when block operation request @rq from queue @q is sent to a - * device driver for processing. - */ -LTTNG_TRACEPOINT_EVENT_INSTANCE(block_rq, block_rq_issue, - - TP_PROTO(struct request_queue *q, struct request *rq), - - TP_ARGS(q, rq) -) - -/** - * block_bio_bounce - used bounce buffer when processing block operation - * @q: queue holding the block operation - * @bio: block operation - * - * A bounce buffer was used to handle the block operation @bio in @q. - * This occurs when hardware limitations prevent a direct transfer of - * data between the @bio data memory area and the IO device. Use of a - * bounce buffer requires extra copying of data and decreases - * performance. - */ -LTTNG_TRACEPOINT_EVENT(block_bio_bounce, - - TP_PROTO(struct request_queue *q, struct bio *bio), - - TP_ARGS(q, bio), - - TP_FIELDS( - ctf_integer(dev_t, dev, bio_dev(bio)) - ctf_integer(sector_t, sector, bio->bi_iter.bi_sector) - ctf_integer(unsigned int, nr_sector, bio_sectors(bio)) - blk_rwbs_ctf_integer(unsigned int, rwbs, - lttng_bio_op(bio), lttng_bio_rw(bio), - bio->bi_iter.bi_size) - ctf_integer(pid_t, tid, current->pid) - ctf_array_text(char, comm, current->comm, TASK_COMM_LEN) - ) -) - -/** - * block_bio_complete - completed all work on the block operation - * @q: queue holding the block operation - * @bio: block operation completed - * @error: io error value - * - * This tracepoint indicates there is no further work to do on this - * block IO operation @bio. - */ -LTTNG_TRACEPOINT_EVENT(block_bio_complete, - - TP_PROTO(struct request_queue *q, struct bio *bio, int error), - - TP_ARGS(q, bio, error), - - TP_FIELDS( - ctf_integer(dev_t, dev, bio_dev(bio)) - ctf_integer(sector_t, sector, bio->bi_iter.bi_sector) - ctf_integer(unsigned int, nr_sector, bio_sectors(bio)) - ctf_integer(int, error, error) - blk_rwbs_ctf_integer(unsigned int, rwbs, - lttng_bio_op(bio), lttng_bio_rw(bio), - bio->bi_iter.bi_size) - ) -) - -LTTNG_TRACEPOINT_EVENT_CLASS(block_bio_merge, - - TP_PROTO(struct request_queue *q, struct request *rq, struct bio *bio), - - TP_ARGS(q, rq, bio), - - TP_FIELDS( - ctf_integer(dev_t, dev, bio_dev(bio)) - ctf_integer(sector_t, sector, bio->bi_iter.bi_sector) - ctf_integer(unsigned int, nr_sector, bio_sectors(bio)) - blk_rwbs_ctf_integer(unsigned int, rwbs, - lttng_bio_op(bio), lttng_bio_rw(bio), - bio->bi_iter.bi_size) - ctf_integer(pid_t, tid, current->pid) - ctf_array_text(char, comm, current->comm, TASK_COMM_LEN) - ) -) - -/** - * block_bio_backmerge - merging block operation to the end of an existing operation - * @q: queue holding operation - * @bio: new block operation to merge - * - * Merging block request @bio to the end of an existing block request - * in queue @q. - */ -LTTNG_TRACEPOINT_EVENT_INSTANCE(block_bio_merge, block_bio_backmerge, - - TP_PROTO(struct request_queue *q, struct request *rq, struct bio *bio), - - TP_ARGS(q, rq, bio) -) - -/** - * block_bio_frontmerge - merging block operation to the beginning of an existing operation - * @q: queue holding operation - * @bio: new block operation to merge - * - * Merging block IO operation @bio to the beginning of an existing block - * operation in queue @q. - */ -LTTNG_TRACEPOINT_EVENT_INSTANCE(block_bio_merge, block_bio_frontmerge, - - TP_PROTO(struct request_queue *q, struct request *rq, struct bio *bio), - - TP_ARGS(q, rq, bio) -) - -/** - * block_bio_queue - putting new block IO operation in queue - * @q: queue holding operation - * @bio: new block operation - * - * About to place the block IO operation @bio into queue @q. - */ -LTTNG_TRACEPOINT_EVENT(block_bio_queue, - - TP_PROTO(struct request_queue *q, struct bio *bio), - - TP_ARGS(q, bio), - - TP_FIELDS( - ctf_integer(dev_t, dev, bio_dev(bio)) - ctf_integer(sector_t, sector, bio->bi_iter.bi_sector) - ctf_integer(unsigned int, nr_sector, bio_sectors(bio)) - blk_rwbs_ctf_integer(unsigned int, rwbs, - lttng_bio_op(bio), lttng_bio_rw(bio), - bio->bi_iter.bi_size) - ctf_integer(pid_t, tid, current->pid) - ctf_array_text(char, comm, current->comm, TASK_COMM_LEN) - ) -) - -LTTNG_TRACEPOINT_EVENT_CLASS(block_get_rq, - - TP_PROTO(struct request_queue *q, struct bio *bio, int rw), - - TP_ARGS(q, bio, rw), - - TP_FIELDS( - ctf_integer(dev_t, dev, bio ? bio_dev(bio) : 0) - ctf_integer(sector_t, sector, bio ? bio->bi_iter.bi_sector : 0) - ctf_integer(unsigned int, nr_sector, - bio ? bio_sectors(bio) : 0) - blk_rwbs_ctf_integer(unsigned int, rwbs, - bio ? lttng_bio_op(bio) : 0, - bio ? lttng_bio_rw(bio) : 0, - bio ? bio->bi_iter.bi_size : 0) - ctf_integer(pid_t, tid, current->pid) - ctf_array_text(char, comm, current->comm, TASK_COMM_LEN) - ) -) - -/** - * block_getrq - get a free request entry in queue for block IO operations - * @q: queue for operations - * @bio: pending block IO operation (can be %NULL) - * @rw: low bit indicates a read (%0) or a write (%1) - * - * A request struct for queue @q has been allocated to handle the - * block IO operation @bio. - */ -LTTNG_TRACEPOINT_EVENT_INSTANCE(block_get_rq, block_getrq, - - TP_PROTO(struct request_queue *q, struct bio *bio, int rw), - - TP_ARGS(q, bio, rw) -) - -/** - * block_sleeprq - waiting to get a free request entry in queue for block IO operation - * @q: queue for operation - * @bio: pending block IO operation (can be %NULL) - * @rw: low bit indicates a read (%0) or a write (%1) - * - * In the case where a request struct cannot be provided for queue @q - * the process needs to wait for an request struct to become - * available. This tracepoint event is generated each time the - * process goes to sleep waiting for request struct become available. - */ -LTTNG_TRACEPOINT_EVENT_INSTANCE(block_get_rq, block_sleeprq, - - TP_PROTO(struct request_queue *q, struct bio *bio, int rw), - - TP_ARGS(q, bio, rw) -) - -/** - * block_plug - keep operations requests in request queue - * @q: request queue to plug - * - * Plug the request queue @q. Do not allow block operation requests - * to be sent to the device driver. Instead, accumulate requests in - * the queue to improve throughput performance of the block device. - */ -LTTNG_TRACEPOINT_EVENT(block_plug, - - TP_PROTO(struct request_queue *q), - - TP_ARGS(q), - - TP_FIELDS( - ctf_integer(pid_t, tid, current->pid) - ctf_array_text(char, comm, current->comm, TASK_COMM_LEN) - ) -) - -LTTNG_TRACEPOINT_EVENT_CLASS(block_unplug, - - TP_PROTO(struct request_queue *q, unsigned int depth, bool explicit), - - TP_ARGS(q, depth, explicit), - - TP_FIELDS( - ctf_integer(int, nr_rq, depth) - ctf_integer(pid_t, tid, current->pid) - ctf_array_text(char, comm, current->comm, TASK_COMM_LEN) - ) -) - -/** - * block_unplug - release of operations requests in request queue - * @q: request queue to unplug - * @depth: number of requests just added to the queue - * @explicit: whether this was an explicit unplug, or one from schedule() - * - * Unplug request queue @q because device driver is scheduled to work - * on elements in the request queue. - */ -LTTNG_TRACEPOINT_EVENT_INSTANCE(block_unplug, block_unplug, - - TP_PROTO(struct request_queue *q, unsigned int depth, bool explicit), - - TP_ARGS(q, depth, explicit) -) - -/** - * block_split - split a single bio struct into two bio structs - * @q: queue containing the bio - * @bio: block operation being split - * @new_sector: The starting sector for the new bio - * - * The bio request @bio in request queue @q needs to be split into two - * bio requests. The newly created @bio request starts at - * @new_sector. This split may be required due to hardware limitation - * such as operation crossing device boundaries in a RAID system. - */ -LTTNG_TRACEPOINT_EVENT(block_split, - - TP_PROTO(struct request_queue *q, struct bio *bio, - unsigned int new_sector), - - TP_ARGS(q, bio, new_sector), - - TP_FIELDS( - ctf_integer(dev_t, dev, bio_dev(bio)) - ctf_integer(sector_t, sector, bio->bi_iter.bi_sector) - blk_rwbs_ctf_integer(unsigned int, rwbs, - lttng_bio_op(bio), lttng_bio_rw(bio), - bio->bi_iter.bi_size) - ctf_integer(sector_t, new_sector, new_sector) - ctf_integer(pid_t, tid, current->pid) - ctf_array_text(char, comm, current->comm, TASK_COMM_LEN) - ) -) - -/** - * block_bio_remap - map request for a logical device to the raw device - * @q: queue holding the operation - * @bio: revised operation - * @dev: device for the operation - * @from: original sector for the operation - * - * An operation for a logical device has been mapped to the - * raw block device. - */ -LTTNG_TRACEPOINT_EVENT(block_bio_remap, - - TP_PROTO(struct request_queue *q, struct bio *bio, dev_t dev, - sector_t from), - - TP_ARGS(q, bio, dev, from), - - TP_FIELDS( - ctf_integer(dev_t, dev, bio_dev(bio)) - ctf_integer(sector_t, sector, bio->bi_iter.bi_sector) - ctf_integer(unsigned int, nr_sector, bio_sectors(bio)) - blk_rwbs_ctf_integer(unsigned int, rwbs, - lttng_bio_op(bio), lttng_bio_rw(bio), - bio->bi_iter.bi_size) - ctf_integer(dev_t, old_dev, dev) - ctf_integer(sector_t, old_sector, from) - ) -) - -/** - * block_rq_remap - map request for a block operation request - * @q: queue holding the operation - * @rq: block IO operation request - * @dev: device for the operation - * @from: original sector for the operation - * - * The block operation request @rq in @q has been remapped. The block - * operation request @rq holds the current information and @from hold - * the original sector. - */ -LTTNG_TRACEPOINT_EVENT(block_rq_remap, - - TP_PROTO(struct request_queue *q, struct request *rq, dev_t dev, - sector_t from), - - TP_ARGS(q, rq, dev, from), - - TP_FIELDS( - ctf_integer(dev_t, dev, disk_devt(rq->rq_disk)) - ctf_integer(sector_t, sector, blk_rq_pos(rq)) - ctf_integer(unsigned int, nr_sector, blk_rq_sectors(rq)) - ctf_integer(dev_t, old_dev, dev) - ctf_integer(sector_t, old_sector, from) - blk_rwbs_ctf_integer(unsigned int, rwbs, - lttng_req_op(rq), lttng_req_rw(rq), blk_rq_bytes(rq)) - ) -) - -#undef __print_rwbs_flags -#undef blk_fill_rwbs - -#endif /* LTTNG_TRACE_BLOCK_H */ - -/* This part must be outside protection */ -#include diff --git a/instrumentation/events/lttng-module/btrfs.h b/instrumentation/events/lttng-module/btrfs.h deleted file mode 100644 index f4fdebca..00000000 --- a/instrumentation/events/lttng-module/btrfs.h +++ /dev/null @@ -1,636 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -#undef TRACE_SYSTEM -#define TRACE_SYSTEM btrfs - -#if !defined(LTTNG_TRACE_BTRFS_H) || defined(TRACE_HEADER_MULTI_READ) -#define LTTNG_TRACE_BTRFS_H - -#include -#include - -#ifndef _TRACE_BTRFS_DEF_ -#define _TRACE_BTRFS_DEF_ -struct btrfs_root; -struct btrfs_fs_info; -struct btrfs_inode; -struct extent_map; -struct btrfs_ordered_extent; -struct btrfs_delayed_ref_node; -struct btrfs_delayed_tree_ref; -struct btrfs_delayed_data_ref; -struct btrfs_delayed_ref_head; -struct btrfs_block_group; -struct btrfs_free_cluster; -struct map_lookup; -struct extent_buffer; -struct extent_state; -#endif - -#define BTRFS_UUID_SIZE 16 - -#define lttng_fs_info_fsid fs_info->fs_devices->fsid - -LTTNG_TRACEPOINT_EVENT(btrfs_transaction_commit, - - TP_PROTO(const struct btrfs_root *root), - - TP_ARGS(root), - - TP_FIELDS( - ctf_integer(u64, generation, root->fs_info->generation) - ctf_integer(u64, root_objectid, root->root_key.objectid) - ) -) - -LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__inode, - - TP_PROTO(const struct inode *inode), - - TP_ARGS(inode), - - TP_FIELDS( - ctf_integer(ino_t, ino, inode->i_ino) - ctf_integer(blkcnt_t, blocks, inode->i_blocks) - ctf_integer(u64, disk_i_size, BTRFS_I(inode)->disk_i_size) - ctf_integer(u64, generation, BTRFS_I(inode)->generation) - ctf_integer(u64, last_trans, BTRFS_I(inode)->last_trans) - ctf_integer(u64, logged_trans, BTRFS_I(inode)->logged_trans) - ctf_integer(u64, root_objectid, - BTRFS_I(inode)->root->root_key.objectid) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__inode, btrfs_inode_new, - - TP_PROTO(const struct inode *inode), - - TP_ARGS(inode) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__inode, btrfs_inode_request, - - TP_PROTO(const struct inode *inode), - - TP_ARGS(inode) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__inode, btrfs_inode_evict, - - TP_PROTO(const struct inode *inode), - - TP_ARGS(inode) -) - -LTTNG_TRACEPOINT_EVENT(btrfs_get_extent, - - TP_PROTO(const struct btrfs_root *root, const struct btrfs_inode *inode, - const struct extent_map *map), - - TP_ARGS(root, inode, map), - - TP_FIELDS( - ctf_integer(u64, root_objectid, root->root_key.objectid) - ctf_integer(u64, ino, btrfs_ino(inode)) - ctf_integer(u64, start, map->start) - ctf_integer(u64, len, map->len) - ctf_integer(u64, orig_start, map->orig_start) - ctf_integer(u64, block_start, map->block_start) - ctf_integer(u64, block_len, map->block_len) - ctf_integer(unsigned long, flags, map->flags) - ctf_integer(int, refs, refcount_read(&map->refs)) - ctf_integer(unsigned int, compress_type, map->compress_type) - ) -) - -LTTNG_TRACEPOINT_EVENT(btrfs_handle_em_exist, - - TP_PROTO(const struct btrfs_fs_info *fs_info, - const struct extent_map *existing, const struct extent_map *map, - u64 start, u64 len), - - TP_ARGS(fs_info, existing, map, start, len), - - TP_FIELDS( - ctf_array(u8, fsid, lttng_fs_info_fsid, BTRFS_UUID_SIZE) - ctf_integer(u64, e_start, existing->start) - ctf_integer(u64, e_len, existing->len) - ctf_integer(u64, map_start, map->start) - ctf_integer(u64, map_len, map->len) - ctf_integer(u64, start, start) - ctf_integer(u64, len, len) - ) -) - -LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__ordered_extent, - - TP_PROTO(const struct inode *inode, - const struct btrfs_ordered_extent *ordered), - - TP_ARGS(inode, ordered), - - TP_FIELDS( - ctf_integer(ino_t, ino, inode->i_ino) - ctf_integer(u64, file_offset, ordered->file_offset) - ctf_integer(u64, start, ordered->disk_bytenr) - ctf_integer(u64, len, ordered->num_bytes) - ctf_integer(u64, disk_len, ordered->disk_num_bytes) - ctf_integer(u64, bytes_left, ordered->bytes_left) - ctf_integer(unsigned long, flags, ordered->flags) - ctf_integer(int, compress_type, ordered->compress_type) - ctf_integer(int, refs, refcount_read(&ordered->refs)) - ctf_integer(u64, root_objectid, - BTRFS_I(inode)->root->root_key.objectid) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__ordered_extent, btrfs_ordered_extent_add, - - TP_PROTO(const struct inode *inode, - const struct btrfs_ordered_extent *ordered), - - TP_ARGS(inode, ordered) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__ordered_extent, btrfs_ordered_extent_remove, - - TP_PROTO(const struct inode *inode, - const struct btrfs_ordered_extent *ordered), - - TP_ARGS(inode, ordered) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__ordered_extent, btrfs_ordered_extent_start, - - TP_PROTO(const struct inode *inode, - const struct btrfs_ordered_extent *ordered), - - TP_ARGS(inode, ordered) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__ordered_extent, btrfs_ordered_extent_put, - - TP_PROTO(const struct inode *inode, - const struct btrfs_ordered_extent *ordered), - - TP_ARGS(inode, ordered) -) - -LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__writepage, - - TP_PROTO(const struct page *page, const struct inode *inode, - const struct writeback_control *wbc), - - TP_ARGS(page, inode, wbc), - - TP_FIELDS( - ctf_integer(ino_t, ino, inode->i_ino) - ctf_integer(pgoff_t, index, page->index) - ctf_integer(long, nr_to_write, wbc->nr_to_write) - ctf_integer(long, pages_skipped, wbc->pages_skipped) - ctf_integer(loff_t, range_start, wbc->range_start) - ctf_integer(loff_t, range_end, wbc->range_end) - ctf_integer(char, for_kupdate, wbc->for_kupdate) - ctf_integer(char, for_reclaim, wbc->for_reclaim) - ctf_integer(char, range_cyclic, wbc->range_cyclic) - ctf_integer(pgoff_t, writeback_index, - inode->i_mapping->writeback_index) - ctf_integer(u64, root_objectid, - BTRFS_I(inode)->root->root_key.objectid) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(btrfs__writepage, - - __extent_writepage, - - btrfs__extent_writepage, - - TP_PROTO(const struct page *page, const struct inode *inode, - const struct writeback_control *wbc), - - TP_ARGS(page, inode, wbc) -) - -LTTNG_TRACEPOINT_EVENT(btrfs_writepage_end_io_hook, - - TP_PROTO(const struct page *page, u64 start, u64 end, int uptodate), - - TP_ARGS(page, start, end, uptodate), - - TP_FIELDS( - ctf_integer(ino_t, ino, page->mapping->host->i_ino) - ctf_integer(pgoff_t, index, page->index) - ctf_integer(u64, start, start) - ctf_integer(u64, end, end) - ctf_integer(int, uptodate, uptodate) - ctf_integer(u64, root_objectid, - BTRFS_I(page->mapping->host)->root->root_key.objectid) - ) -) - -LTTNG_TRACEPOINT_EVENT(btrfs_sync_file, - - TP_PROTO(const struct file *file, int datasync), - - TP_ARGS(file, datasync), - - TP_FIELDS( - ctf_integer(ino_t, ino, file->f_path.dentry->d_inode->i_ino) - ctf_integer(ino_t, parent, file->f_path.dentry->d_parent->d_inode->i_ino) - ctf_integer(int, datasync, datasync) - ctf_integer(u64, root_objectid, - BTRFS_I(file->f_path.dentry->d_inode)->root->root_key.objectid) - ) -) - -LTTNG_TRACEPOINT_EVENT(btrfs_sync_fs, - - TP_PROTO(const struct btrfs_fs_info *fs_info, int wait), - - TP_ARGS(fs_info, wait), - - TP_FIELDS( - ctf_integer(int, wait, wait) - ) -) - -LTTNG_TRACEPOINT_EVENT(btrfs_add_block_group, - - TP_PROTO(const struct btrfs_fs_info *fs_info, - const struct btrfs_block_group *block_group, int create), - - TP_ARGS(fs_info, block_group, create), - - TP_FIELDS( - ctf_array(u8, fsid, lttng_fs_info_fsid, BTRFS_UUID_SIZE) - ctf_integer(u64, offset, block_group->start) - ctf_integer(u64, size, block_group->length) - ctf_integer(u64, flags, block_group->flags) - ctf_integer(u64, bytes_used, block_group->used) - ctf_integer(u64, bytes_super, block_group->bytes_super) - ctf_integer(int, create, create) - ) -) - -LTTNG_TRACEPOINT_EVENT_CLASS(btrfs_delayed_tree_ref, - - TP_PROTO(const struct btrfs_fs_info *fs_info, - const struct btrfs_delayed_ref_node *ref, - const struct btrfs_delayed_tree_ref *full_ref, - int action), - - TP_ARGS(fs_info, ref, full_ref, action), - - TP_FIELDS( - ctf_array(u8, fsid, lttng_fs_info_fsid, BTRFS_UUID_SIZE) - ctf_integer(u64, bytenr, ref->bytenr) - ctf_integer(u64, num_bytes, ref->num_bytes) - ctf_integer(int, action, action) - ctf_integer(u64, parent, full_ref->parent) - ctf_integer(u64, ref_root, full_ref->root) - ctf_integer(int, level, full_ref->level) - ctf_integer(int, type, ref->type) - ctf_integer(u64, seq, ref->seq) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(btrfs_delayed_tree_ref, - - add_delayed_tree_ref, - - btrfs_add_delayed_tree_ref, - - TP_PROTO(const struct btrfs_fs_info *fs_info, - const struct btrfs_delayed_ref_node *ref, - const struct btrfs_delayed_tree_ref *full_ref, - int action), - - TP_ARGS(fs_info, ref, full_ref, action) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(btrfs_delayed_tree_ref, - - run_delayed_tree_ref, - - btrfs_run_delayed_tree_ref, - - TP_PROTO(const struct btrfs_fs_info *fs_info, - const struct btrfs_delayed_ref_node *ref, - const struct btrfs_delayed_tree_ref *full_ref, - int action), - - TP_ARGS(fs_info, ref, full_ref, action) -) - -LTTNG_TRACEPOINT_EVENT_CLASS(btrfs_delayed_data_ref, - - TP_PROTO(const struct btrfs_fs_info *fs_info, - const struct btrfs_delayed_ref_node *ref, - const struct btrfs_delayed_data_ref *full_ref, - int action), - - TP_ARGS(fs_info, ref, full_ref, action), - - TP_FIELDS( - ctf_array(u8, fsid, lttng_fs_info_fsid, BTRFS_UUID_SIZE) - ctf_integer(u64, bytenr, ref->bytenr) - ctf_integer(u64, num_bytes, ref->num_bytes) - ctf_integer(int, action, action) - ctf_integer(u64, parent, full_ref->parent) - ctf_integer(u64, ref_root, full_ref->root) - ctf_integer(u64, owner, full_ref->objectid) - ctf_integer(u64, offset, full_ref->offset) - ctf_integer(int, type, ref->type) - ctf_integer(u64, seq, ref->seq) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(btrfs_delayed_data_ref, - - add_delayed_data_ref, - - btrfs_add_delayed_data_ref, - - TP_PROTO(const struct btrfs_fs_info *fs_info, - const struct btrfs_delayed_ref_node *ref, - const struct btrfs_delayed_data_ref *full_ref, - int action), - - TP_ARGS(fs_info, ref, full_ref, action) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(btrfs_delayed_data_ref, - - run_delayed_data_ref, - - btrfs_run_delayed_data_ref, - - TP_PROTO(const struct btrfs_fs_info *fs_info, - const struct btrfs_delayed_ref_node *ref, - const struct btrfs_delayed_data_ref *full_ref, - int action), - - TP_ARGS(fs_info, ref, full_ref, action) -) - -LTTNG_TRACEPOINT_EVENT_CLASS(btrfs_delayed_ref_head, - - TP_PROTO(const struct btrfs_fs_info *fs_info, - const struct btrfs_delayed_ref_head *head_ref, - int action), - - TP_ARGS(fs_info, head_ref, action), - - TP_FIELDS( - ctf_integer(u64, bytenr, head_ref->bytenr) - ctf_integer(u64, num_bytes, head_ref->num_bytes) - ctf_integer(int, action, action) - ctf_integer(int, is_data, head_ref->is_data) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(btrfs_delayed_ref_head, - - add_delayed_ref_head, - - btrfs_add_delayed_ref_head, - - TP_PROTO(const struct btrfs_fs_info *fs_info, - const struct btrfs_delayed_ref_head *head_ref, - int action), - - TP_ARGS(fs_info, head_ref, action) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(btrfs_delayed_ref_head, - - run_delayed_ref_head, - - btrfs_run_delayed_ref_head, - - TP_PROTO(const struct btrfs_fs_info *fs_info, - const struct btrfs_delayed_ref_head *head_ref, - int action), - - TP_ARGS(fs_info, head_ref, action) -) - -LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__chunk, - - TP_PROTO(const struct btrfs_fs_info *fs_info, const struct map_lookup *map, - u64 offset, u64 size), - - TP_ARGS(fs_info, map, offset, size), - - TP_FIELDS( - ctf_integer(int, num_stripes, map->num_stripes) - ctf_integer(u64, type, map->type) - ctf_integer(int, sub_stripes, map->sub_stripes) - ctf_integer(u64, offset, offset) - ctf_integer(u64, size, size) - ctf_integer(u64, root_objectid, fs_info->chunk_root->root_key.objectid) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__chunk, btrfs_chunk_alloc, - - TP_PROTO(const struct btrfs_fs_info *fs_info, const struct map_lookup *map, - u64 offset, u64 size), - - TP_ARGS(fs_info, map, offset, size) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__chunk, btrfs_chunk_free, - - TP_PROTO(const struct btrfs_fs_info *fs_info, const struct map_lookup *map, - u64 offset, u64 size), - - TP_ARGS(fs_info, map, offset, size) -) - -LTTNG_TRACEPOINT_EVENT(btrfs_cow_block, - - TP_PROTO(const struct btrfs_root *root, const struct extent_buffer *buf, - const struct extent_buffer *cow), - - TP_ARGS(root, buf, cow), - - TP_FIELDS( - ctf_integer(u64, root_objectid, root->root_key.objectid) - ctf_integer(u64, buf_start, buf->start) - ctf_integer(int, refs, atomic_read(&buf->refs)) - ctf_integer(u64, cow_start, cow->start) - ctf_integer(int, buf_level, btrfs_header_level(buf)) - ctf_integer(int, cow_level, btrfs_header_level(cow)) - ) -) - -LTTNG_TRACEPOINT_EVENT(btrfs_space_reservation, - - TP_PROTO(const struct btrfs_fs_info *fs_info, const char *type, u64 val, - u64 bytes, int reserve), - - TP_ARGS(fs_info, type, val, bytes, reserve), - - TP_FIELDS( - ctf_array(u8, fsid, lttng_fs_info_fsid, BTRFS_UUID_SIZE) - ctf_string(type, type) - ctf_integer(u64, val, val) - ctf_integer(u64, bytes, bytes) - ctf_integer(int, reserve, reserve) - ) -) - -LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__reserved_extent, - - TP_PROTO(const struct btrfs_fs_info *fs_info, u64 start, u64 len), - - TP_ARGS(fs_info, start, len), - - TP_FIELDS( - ctf_integer(u64, start, start) - ctf_integer(u64, len, len) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserved_extent, btrfs_reserved_extent_alloc, - - TP_PROTO(const struct btrfs_fs_info *fs_info, u64 start, u64 len), - - TP_ARGS(fs_info, start, len) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserved_extent, btrfs_reserved_extent_free, - - TP_PROTO(const struct btrfs_fs_info *fs_info, u64 start, u64 len), - - TP_ARGS(fs_info, start, len) -) - -LTTNG_TRACEPOINT_EVENT_MAP(find_free_extent, - - btrfs_find_free_extent, - - TP_PROTO(const struct btrfs_fs_info *fs_info, u64 num_bytes, u64 empty_size, - u64 data), - - TP_ARGS(fs_info, num_bytes, empty_size, data), - - TP_FIELDS( - ctf_array(u8, fsid, lttng_fs_info_fsid, BTRFS_UUID_SIZE) - ctf_integer(u64, num_bytes, num_bytes) - ctf_integer(u64, empty_size, empty_size) - ctf_integer(u64, data, data) - ) -) - -LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__reserve_extent, - - TP_PROTO(const struct btrfs_block_group *block_group, u64 start, - u64 len), - - TP_ARGS(block_group, start, len), - - TP_FIELDS( - ctf_array(u8, fsid, block_group->lttng_fs_info_fsid, BTRFS_UUID_SIZE) - ctf_integer(u64, bg_objectid, block_group->start) - ctf_integer(u64, flags, block_group->flags) - ctf_integer(u64, start, start) - ctf_integer(u64, len, len) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserve_extent, btrfs_reserve_extent, - - TP_PROTO(const struct btrfs_block_group *block_group, u64 start, - u64 len), - - TP_ARGS(block_group, start, len) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserve_extent, btrfs_reserve_extent_cluster, - - TP_PROTO(const struct btrfs_block_group *block_group, u64 start, - u64 len), - - TP_ARGS(block_group, start, len) -) - -LTTNG_TRACEPOINT_EVENT(btrfs_find_cluster, - - TP_PROTO(const struct btrfs_block_group *block_group, u64 start, - u64 bytes, u64 empty_size, u64 min_bytes), - - TP_ARGS(block_group, start, bytes, empty_size, min_bytes), - - TP_FIELDS( - ctf_integer(u64, bg_objectid, block_group->start) - ctf_integer(u64, flags, block_group->flags) - ctf_integer(u64, start, start) - ctf_integer(u64, bytes, bytes) - ctf_integer(u64, empty_size, empty_size) - ctf_integer(u64, min_bytes, min_bytes) - ) -) - -LTTNG_TRACEPOINT_EVENT(btrfs_failed_cluster_setup, - - TP_PROTO(const struct btrfs_block_group *block_group), - - TP_ARGS(block_group), - - TP_FIELDS( - ctf_integer(u64, bg_objectid, block_group->start) - ) -) - -LTTNG_TRACEPOINT_EVENT(btrfs_setup_cluster, - - TP_PROTO(const struct btrfs_block_group *block_group, - const struct btrfs_free_cluster *cluster, u64 size, int bitmap), - - TP_ARGS(block_group, cluster, size, bitmap), - - TP_FIELDS( - ctf_integer(u64, bg_objectid, block_group->start) - ctf_integer(u64, flags, block_group->flags) - ctf_integer(u64, start, cluster->window_start) - ctf_integer(u64, max_size, cluster->max_size) - ctf_integer(u64, size, size) - ctf_integer(int, bitmap, bitmap) - ) -) - -LTTNG_TRACEPOINT_EVENT_MAP(alloc_extent_state, - - btrfs_alloc_extent_state, - - TP_PROTO(const struct extent_state *state, gfp_t mask, unsigned long IP), - - TP_ARGS(state, mask, IP), - - TP_FIELDS( - ctf_integer_hex(const struct extent_state *, state, state) - ctf_integer(gfp_t, mask, mask) - ctf_integer_hex(unsigned long, ip, IP) - ) -) - -LTTNG_TRACEPOINT_EVENT_MAP(free_extent_state, - - btrfs_free_extent_state, - - TP_PROTO(const struct extent_state *state, unsigned long IP), - - TP_ARGS(state, IP), - - TP_FIELDS( - ctf_integer_hex(const struct extent_state *, state, state) - ctf_integer_hex(unsigned long, ip, IP) - ) -) - -#endif /* LTTNG_TRACE_BTRFS_H */ - -/* This part must be outside protection */ -#include diff --git a/instrumentation/events/lttng-module/compaction.h b/instrumentation/events/lttng-module/compaction.h deleted file mode 100644 index 2fed7290..00000000 --- a/instrumentation/events/lttng-module/compaction.h +++ /dev/null @@ -1,95 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -#undef TRACE_SYSTEM -#define TRACE_SYSTEM compaction - -#if !defined(LTTNG_TRACE_COMPACTION_H) || defined(TRACE_HEADER_MULTI_READ) -#define LTTNG_TRACE_COMPACTION_H - -#include -#include - -LTTNG_TRACEPOINT_EVENT_CLASS(compaction_isolate_template, - - TP_PROTO(unsigned long start_pfn, - unsigned long end_pfn, - unsigned long nr_scanned, - unsigned long nr_taken), - - TP_ARGS(start_pfn, end_pfn, nr_scanned, nr_taken), - - TP_FIELDS( - ctf_integer(unsigned long, start_pfn, start_pfn) - ctf_integer(unsigned long, end_pfn, end_pfn) - ctf_integer(unsigned long, nr_scanned, nr_scanned) - ctf_integer(unsigned long, nr_taken, nr_taken) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(compaction_isolate_template, - - mm_compaction_isolate_migratepages, - - compaction_isolate_migratepages, - - TP_PROTO(unsigned long start_pfn, - unsigned long end_pfn, - unsigned long nr_scanned, - unsigned long nr_taken), - - TP_ARGS(start_pfn, end_pfn, nr_scanned, nr_taken) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(compaction_isolate_template, - - mm_compaction_isolate_freepages, - - compaction_isolate_freepages, - - TP_PROTO(unsigned long start_pfn, - unsigned long end_pfn, - unsigned long nr_scanned, - unsigned long nr_taken), - - TP_ARGS(start_pfn, end_pfn, nr_scanned, nr_taken) -) - -LTTNG_TRACEPOINT_EVENT_CODE_MAP(mm_compaction_migratepages, - - compaction_migratepages, - - TP_PROTO(unsigned long nr_all, - int migrate_rc, - struct list_head *migratepages), - - TP_ARGS(nr_all, migrate_rc, migratepages), - - TP_locvar( - unsigned long nr_failed; - ), - - TP_code_pre( - tp_locvar->nr_failed = 0; - - { - struct list_head *page_lru; - - if (migrate_rc >= 0) - tp_locvar->nr_failed = migrate_rc; - else - list_for_each(page_lru, migratepages) - tp_locvar->nr_failed++; - } - ), - - TP_FIELDS( - ctf_integer(unsigned long, nr_migrated, nr_all - tp_locvar->nr_failed) - ctf_integer(unsigned long, nr_failed, tp_locvar->nr_failed) - ), - - TP_code_post() -) - -#endif /* LTTNG_TRACE_COMPACTION_H */ - -/* This part must be outside protection */ -#include diff --git a/instrumentation/events/lttng-module/ext4.h b/instrumentation/events/lttng-module/ext4.h deleted file mode 100644 index b9586a75..00000000 --- a/instrumentation/events/lttng-module/ext4.h +++ /dev/null @@ -1,1211 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -#undef TRACE_SYSTEM -#define TRACE_SYSTEM ext4 - -#if !defined(LTTNG_TRACE_EXT4_H) || defined(TRACE_HEADER_MULTI_READ) -#define LTTNG_TRACE_EXT4_H - -#include -#include - -#ifndef _TRACE_EXT4_DEF_ -#define _TRACE_EXT4_DEF_ -struct ext4_allocation_context; -struct ext4_allocation_request; -struct ext4_prealloc_space; -struct ext4_inode_info; -struct mpage_da_data; -struct ext4_map_blocks; -struct ext4_extent; -#endif - -#define EXT4_I(inode) (container_of(inode, struct ext4_inode_info, vfs_inode)) -#define TP_MODE_T __u16 - -LTTNG_TRACEPOINT_EVENT(ext4_free_inode, - TP_PROTO(struct inode *inode), - - TP_ARGS(inode), - - TP_FIELDS( - ctf_integer(dev_t, dev, inode->i_sb->s_dev) - ctf_integer(ino_t, ino, inode->i_ino) - ctf_integer(uid_t, uid, i_uid_read(inode)) - ctf_integer(gid_t, gid, i_gid_read(inode)) - ctf_integer(__u64, blocks, inode->i_blocks) - ctf_integer(TP_MODE_T, mode, inode->i_mode) - ) -) - -LTTNG_TRACEPOINT_EVENT(ext4_request_inode, - TP_PROTO(struct inode *dir, int mode), - - TP_ARGS(dir, mode), - - TP_FIELDS( - ctf_integer(dev_t, dev, dir->i_sb->s_dev) - ctf_integer(ino_t, dir, dir->i_ino) - ctf_integer(TP_MODE_T, mode, mode) - ) -) - -LTTNG_TRACEPOINT_EVENT(ext4_allocate_inode, - TP_PROTO(struct inode *inode, struct inode *dir, int mode), - - TP_ARGS(inode, dir, mode), - - TP_FIELDS( - ctf_integer(dev_t, dev, inode->i_sb->s_dev) - ctf_integer(ino_t, ino, inode->i_ino) - ctf_integer(ino_t, dir, dir->i_ino) - ctf_integer(TP_MODE_T, mode, mode) - ) -) - -LTTNG_TRACEPOINT_EVENT(ext4_evict_inode, - TP_PROTO(struct inode *inode), - - TP_ARGS(inode), - - TP_FIELDS( - ctf_integer(dev_t, dev, inode->i_sb->s_dev) - ctf_integer(ino_t, ino, inode->i_ino) - ctf_integer(int, nlink, inode->i_nlink) - ) -) - -LTTNG_TRACEPOINT_EVENT(ext4_drop_inode, - TP_PROTO(struct inode *inode, int drop), - - TP_ARGS(inode, drop), - - TP_FIELDS( - ctf_integer(dev_t, dev, inode->i_sb->s_dev) - ctf_integer(ino_t, ino, inode->i_ino) - ctf_integer(int, drop, drop) - ) -) - -LTTNG_TRACEPOINT_EVENT(ext4_mark_inode_dirty, - TP_PROTO(struct inode *inode, unsigned long IP), - - TP_ARGS(inode, IP), - - TP_FIELDS( - ctf_integer(dev_t, dev, inode->i_sb->s_dev) - ctf_integer(ino_t, ino, inode->i_ino) - ctf_integer_hex(unsigned long, ip, IP) - ) -) - -LTTNG_TRACEPOINT_EVENT(ext4_begin_ordered_truncate, - TP_PROTO(struct inode *inode, loff_t new_size), - - TP_ARGS(inode, new_size), - - TP_FIELDS( - ctf_integer(dev_t, dev, inode->i_sb->s_dev) - ctf_integer(ino_t, ino, inode->i_ino) - ctf_integer(loff_t, new_size, new_size) - ) -) - -LTTNG_TRACEPOINT_EVENT_CLASS(ext4__write_begin, - - TP_PROTO(struct inode *inode, loff_t pos, unsigned int len, - unsigned int flags), - - TP_ARGS(inode, pos, len, flags), - - TP_FIELDS( - ctf_integer(dev_t, dev, inode->i_sb->s_dev) - ctf_integer(ino_t, ino, inode->i_ino) - ctf_integer(loff_t, pos, pos) - ctf_integer(unsigned int, len, len) - ctf_integer(unsigned int, flags, flags) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__write_begin, ext4_write_begin, - - TP_PROTO(struct inode *inode, loff_t pos, unsigned int len, - unsigned int flags), - - TP_ARGS(inode, pos, len, flags) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__write_begin, ext4_da_write_begin, - - TP_PROTO(struct inode *inode, loff_t pos, unsigned int len, - unsigned int flags), - - TP_ARGS(inode, pos, len, flags) -) - -LTTNG_TRACEPOINT_EVENT_CLASS(ext4__write_end, - TP_PROTO(struct inode *inode, loff_t pos, unsigned int len, - unsigned int copied), - - TP_ARGS(inode, pos, len, copied), - - TP_FIELDS( - ctf_integer(dev_t, dev, inode->i_sb->s_dev) - ctf_integer(ino_t, ino, inode->i_ino) - ctf_integer(loff_t, pos, pos) - ctf_integer(unsigned int, len, len) - ctf_integer(unsigned int, copied, copied) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__write_end, ext4_ordered_write_end, - - TP_PROTO(struct inode *inode, loff_t pos, unsigned int len, - unsigned int copied), - - TP_ARGS(inode, pos, len, copied) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__write_end, ext4_writeback_write_end, - - TP_PROTO(struct inode *inode, loff_t pos, unsigned int len, - unsigned int copied), - - TP_ARGS(inode, pos, len, copied) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__write_end, ext4_journalled_write_end, - - TP_PROTO(struct inode *inode, loff_t pos, unsigned int len, - unsigned int copied), - - TP_ARGS(inode, pos, len, copied) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__write_end, ext4_da_write_end, - - TP_PROTO(struct inode *inode, loff_t pos, unsigned int len, - unsigned int copied), - - TP_ARGS(inode, pos, len, copied) -) - -LTTNG_TRACEPOINT_EVENT(ext4_da_writepages, - TP_PROTO(struct inode *inode, struct writeback_control *wbc), - - TP_ARGS(inode, wbc), - - TP_FIELDS( - ctf_integer(dev_t, dev, inode->i_sb->s_dev) - ctf_integer(ino_t, ino, inode->i_ino) - ctf_integer(long, nr_to_write, wbc->nr_to_write) - ctf_integer(long, pages_skipped, wbc->pages_skipped) - ctf_integer(loff_t, range_start, wbc->range_start) - ctf_integer(loff_t, range_end, wbc->range_end) - ctf_integer(pgoff_t, writeback_index, inode->i_mapping->writeback_index) - ctf_integer(int, sync_mode, wbc->sync_mode) - ctf_integer(char, for_kupdate, wbc->for_kupdate) - ctf_integer(char, range_cyclic, wbc->range_cyclic) - ) -) - -LTTNG_TRACEPOINT_EVENT(ext4_da_write_pages, - TP_PROTO(struct inode *inode, pgoff_t first_page, - struct writeback_control *wbc), - - TP_ARGS(inode, first_page, wbc), - - TP_FIELDS( - ctf_integer(dev_t, dev, inode->i_sb->s_dev) - ctf_integer(ino_t, ino, inode->i_ino) - ctf_integer(pgoff_t, first_page, first_page) - ctf_integer(long, nr_to_write, wbc->nr_to_write) - ctf_integer(int, sync_mode, wbc->sync_mode) - ) -) - -LTTNG_TRACEPOINT_EVENT(ext4_da_write_pages_extent, - TP_PROTO(struct inode *inode, struct ext4_map_blocks *map), - - TP_ARGS(inode, map), - - TP_FIELDS( - ctf_integer(dev_t, dev, inode->i_sb->s_dev) - ctf_integer(ino_t, ino, inode->i_ino) - ctf_integer(__u64, lblk, map->m_lblk) - ctf_integer(__u32, len, map->m_len) - ctf_integer(__u32, flags, map->m_flags) - ) -) - -LTTNG_TRACEPOINT_EVENT(ext4_da_writepages_result, - TP_PROTO(struct inode *inode, struct writeback_control *wbc, - int ret, int pages_written), - - TP_ARGS(inode, wbc, ret, pages_written), - - TP_FIELDS( - ctf_integer(dev_t, dev, inode->i_sb->s_dev) - ctf_integer(ino_t, ino, inode->i_ino) - ctf_integer(int, ret, ret) - ctf_integer(int, pages_written, pages_written) - ctf_integer(long, pages_skipped, wbc->pages_skipped) - ctf_integer(pgoff_t, writeback_index, inode->i_mapping->writeback_index) - ctf_integer(int, sync_mode, wbc->sync_mode) - ) -) - -LTTNG_TRACEPOINT_EVENT_CLASS(ext4__page_op, - TP_PROTO(struct page *page), - - TP_ARGS(page), - - TP_FIELDS( - ctf_integer(dev_t, dev, page->mapping->host->i_sb->s_dev) - ctf_integer(ino_t, ino, page->mapping->host->i_ino) - ctf_integer(pgoff_t, index, page->index) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__page_op, ext4_writepage, - - TP_PROTO(struct page *page), - - TP_ARGS(page) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__page_op, ext4_readpage, - - TP_PROTO(struct page *page), - - TP_ARGS(page) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__page_op, ext4_releasepage, - - TP_PROTO(struct page *page), - - TP_ARGS(page) -) - -LTTNG_TRACEPOINT_EVENT_CLASS(ext4_invalidatepage_op, - TP_PROTO(struct page *page, unsigned int offset, unsigned int length), - - TP_ARGS(page, offset, length), - - TP_FIELDS( - ctf_integer(dev_t, dev, page->mapping->host->i_sb->s_dev) - ctf_integer(ino_t, ino, page->mapping->host->i_ino) - ctf_integer(pgoff_t, index, page->index) - ctf_integer(unsigned int, offset, offset) - ctf_integer(unsigned int, length, length) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4_invalidatepage_op, ext4_invalidatepage, - TP_PROTO(struct page *page, unsigned int offset, unsigned int length), - - TP_ARGS(page, offset, length) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4_invalidatepage_op, ext4_journalled_invalidatepage, - TP_PROTO(struct page *page, unsigned int offset, unsigned int length), - - TP_ARGS(page, offset, length) -) - -LTTNG_TRACEPOINT_EVENT(ext4_discard_blocks, - TP_PROTO(struct super_block *sb, unsigned long long blk, - unsigned long long count), - - TP_ARGS(sb, blk, count), - - TP_FIELDS( - ctf_integer(dev_t, dev, sb->s_dev) - ctf_integer(__u64, blk, blk) - ctf_integer(__u64, count, count) - ) -) - -LTTNG_TRACEPOINT_EVENT_CLASS(ext4__mb_new_pa, - TP_PROTO(struct ext4_allocation_context *ac, - struct ext4_prealloc_space *pa), - - TP_ARGS(ac, pa), - - TP_FIELDS( - ctf_integer(dev_t, dev, ac->ac_sb->s_dev) - ctf_integer(ino_t, ino, ac->ac_inode->i_ino) - ctf_integer(__u64, pa_pstart, pa->pa_pstart) - ctf_integer(__u64, pa_lstart, pa->pa_lstart) - ctf_integer(__u32, pa_len, pa->pa_len) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__mb_new_pa, ext4_mb_new_inode_pa, - - TP_PROTO(struct ext4_allocation_context *ac, - struct ext4_prealloc_space *pa), - - TP_ARGS(ac, pa) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__mb_new_pa, ext4_mb_new_group_pa, - - TP_PROTO(struct ext4_allocation_context *ac, - struct ext4_prealloc_space *pa), - - TP_ARGS(ac, pa) -) - -LTTNG_TRACEPOINT_EVENT(ext4_mb_release_inode_pa, - TP_PROTO( - struct ext4_prealloc_space *pa, - unsigned long long block, unsigned int count), - - TP_ARGS(pa, block, count), - - TP_FIELDS( - ctf_integer(dev_t, dev, pa->pa_inode->i_sb->s_dev) - ctf_integer(ino_t, ino, pa->pa_inode->i_ino) - ctf_integer(__u64, block, block) - ctf_integer(__u32, count, count) - ) -) - -LTTNG_TRACEPOINT_EVENT(ext4_mb_release_group_pa, - - TP_PROTO(struct super_block *sb, struct ext4_prealloc_space *pa), - - TP_ARGS(sb, pa), - - TP_FIELDS( - ctf_integer(dev_t, dev, sb->s_dev) - ctf_integer(__u64, pa_pstart, pa->pa_pstart) - ctf_integer(__u32, pa_len, pa->pa_len) - ) -) - -LTTNG_TRACEPOINT_EVENT(ext4_discard_preallocations, - TP_PROTO(struct inode *inode), - - TP_ARGS(inode), - - TP_FIELDS( - ctf_integer(dev_t, dev, inode->i_sb->s_dev) - ctf_integer(ino_t, ino, inode->i_ino) - ) -) - -LTTNG_TRACEPOINT_EVENT(ext4_mb_discard_preallocations, - TP_PROTO(struct super_block *sb, int needed), - - TP_ARGS(sb, needed), - - TP_FIELDS( - ctf_integer(dev_t, dev, sb->s_dev) - ctf_integer(int, needed, needed) - ) -) - -LTTNG_TRACEPOINT_EVENT(ext4_request_blocks, - TP_PROTO(struct ext4_allocation_request *ar), - - TP_ARGS(ar), - - TP_FIELDS( - ctf_integer(dev_t, dev, ar->inode->i_sb->s_dev) - ctf_integer(ino_t, ino, ar->inode->i_ino) - ctf_integer(unsigned int, len, ar->len) - ctf_integer(__u32, logical, ar->logical) - ctf_integer(__u32, lleft, ar->lleft) - ctf_integer(__u32, lright, ar->lright) - ctf_integer(__u64, goal, ar->goal) - ctf_integer(__u64, pleft, ar->pleft) - ctf_integer(__u64, pright, ar->pright) - ctf_integer(unsigned int, flags, ar->flags) - ) -) - -LTTNG_TRACEPOINT_EVENT(ext4_allocate_blocks, - TP_PROTO(struct ext4_allocation_request *ar, unsigned long long block), - - TP_ARGS(ar, block), - - TP_FIELDS( - ctf_integer(dev_t, dev, ar->inode->i_sb->s_dev) - ctf_integer(ino_t, ino, ar->inode->i_ino) - ctf_integer(__u64, block, block) - ctf_integer(unsigned int, len, ar->len) - ctf_integer(__u32, logical, ar->logical) - ctf_integer(__u32, lleft, ar->lleft) - ctf_integer(__u32, lright, ar->lright) - ctf_integer(__u64, goal, ar->goal) - ctf_integer(__u64, pleft, ar->pleft) - ctf_integer(__u64, pright, ar->pright) - ctf_integer(unsigned int, flags, ar->flags) - ) -) - -LTTNG_TRACEPOINT_EVENT(ext4_free_blocks, - TP_PROTO(struct inode *inode, __u64 block, unsigned long count, - int flags), - - TP_ARGS(inode, block, count, flags), - - TP_FIELDS( - ctf_integer(dev_t, dev, inode->i_sb->s_dev) - ctf_integer(ino_t, ino, inode->i_ino) - ctf_integer(__u64, block, block) - ctf_integer(unsigned long, count, count) - ctf_integer(int, flags, flags) - ctf_integer(TP_MODE_T, mode, inode->i_mode) - ) -) - -LTTNG_TRACEPOINT_EVENT(ext4_sync_file_enter, - TP_PROTO(struct file *file, int datasync), - - TP_ARGS(file, datasync), - - TP_FIELDS( - ctf_integer(dev_t, dev, file->f_path.dentry->d_inode->i_sb->s_dev) - ctf_integer(ino_t, ino, file->f_path.dentry->d_inode->i_ino) - ctf_integer(ino_t, parent, file->f_path.dentry->d_parent->d_inode->i_ino) - ctf_integer(int, datasync, datasync) - ) -) - -LTTNG_TRACEPOINT_EVENT(ext4_sync_file_exit, - TP_PROTO(struct inode *inode, int ret), - - TP_ARGS(inode, ret), - - TP_FIELDS( - ctf_integer(dev_t, dev, inode->i_sb->s_dev) - ctf_integer(ino_t, ino, inode->i_ino) - ctf_integer(int, ret, ret) - ) -) - -LTTNG_TRACEPOINT_EVENT(ext4_sync_fs, - TP_PROTO(struct super_block *sb, int wait), - - TP_ARGS(sb, wait), - - TP_FIELDS( - ctf_integer(dev_t, dev, sb->s_dev) - ctf_integer(int, wait, wait) - - ) -) - -LTTNG_TRACEPOINT_EVENT(ext4_alloc_da_blocks, - TP_PROTO(struct inode *inode), - - TP_ARGS(inode), - - TP_FIELDS( - ctf_integer(dev_t, dev, inode->i_sb->s_dev) - ctf_integer(ino_t, ino, inode->i_ino) - ctf_integer(unsigned int, data_blocks, EXT4_I(inode)->i_reserved_data_blocks) - ) -) - -LTTNG_TRACEPOINT_EVENT(ext4_mballoc_alloc, - TP_PROTO(struct ext4_allocation_context *ac), - - TP_ARGS(ac), - - TP_FIELDS( - ctf_integer(dev_t, dev, ac->ac_inode->i_sb->s_dev) - ctf_integer(ino_t, ino, ac->ac_inode->i_ino) - ctf_integer(__u32, orig_logical, ac->ac_o_ex.fe_logical) - ctf_integer(int, orig_start, ac->ac_o_ex.fe_start) - ctf_integer(__u32, orig_group, ac->ac_o_ex.fe_group) - ctf_integer(int, orig_len, ac->ac_o_ex.fe_len) - ctf_integer(__u32, goal_logical, ac->ac_g_ex.fe_logical) - ctf_integer(int, goal_start, ac->ac_g_ex.fe_start) - ctf_integer(__u32, goal_group, ac->ac_g_ex.fe_group) - ctf_integer(int, goal_len, ac->ac_g_ex.fe_len) - ctf_integer(__u32, result_logical, ac->ac_f_ex.fe_logical) - ctf_integer(int, result_start, ac->ac_f_ex.fe_start) - ctf_integer(__u32, result_group, ac->ac_f_ex.fe_group) - ctf_integer(int, result_len, ac->ac_f_ex.fe_len) - ctf_integer(__u16, found, ac->ac_found) - ctf_integer(__u16, groups, ac->ac_groups_scanned) - ctf_integer(__u16, buddy, ac->ac_buddy) - ctf_integer(__u16, flags, ac->ac_flags) - ctf_integer(__u16, tail, ac->ac_tail) - ctf_integer(__u8, cr, ac->ac_criteria) - ) -) - -LTTNG_TRACEPOINT_EVENT(ext4_mballoc_prealloc, - TP_PROTO(struct ext4_allocation_context *ac), - - TP_ARGS(ac), - - TP_FIELDS( - ctf_integer(dev_t, dev, ac->ac_inode->i_sb->s_dev) - ctf_integer(ino_t, ino, ac->ac_inode->i_ino) - ctf_integer(__u32, orig_logical, ac->ac_o_ex.fe_logical) - ctf_integer(int, orig_start, ac->ac_o_ex.fe_start) - ctf_integer(__u32, orig_group, ac->ac_o_ex.fe_group) - ctf_integer(int, orig_len, ac->ac_o_ex.fe_len) - ctf_integer(__u32, result_logical, ac->ac_b_ex.fe_logical) - ctf_integer(int, result_start, ac->ac_b_ex.fe_start) - ctf_integer(__u32, result_group, ac->ac_b_ex.fe_group) - ctf_integer(int, result_len, ac->ac_b_ex.fe_len) - ) -) - -LTTNG_TRACEPOINT_EVENT_CLASS(ext4__mballoc, - TP_PROTO(struct super_block *sb, - struct inode *inode, - ext4_group_t group, - ext4_grpblk_t start, - ext4_grpblk_t len), - - TP_ARGS(sb, inode, group, start, len), - - TP_FIELDS( - ctf_integer(dev_t, dev, sb->s_dev) - ctf_integer(ino_t, ino, inode ? inode->i_ino : 0) - ctf_integer(int, result_start, start) - ctf_integer(__u32, result_group, group) - ctf_integer(int, result_len, len) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__mballoc, ext4_mballoc_discard, - - TP_PROTO(struct super_block *sb, - struct inode *inode, - ext4_group_t group, - ext4_grpblk_t start, - ext4_grpblk_t len), - - TP_ARGS(sb, inode, group, start, len) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__mballoc, ext4_mballoc_free, - - TP_PROTO(struct super_block *sb, - struct inode *inode, - ext4_group_t group, - ext4_grpblk_t start, - ext4_grpblk_t len), - - TP_ARGS(sb, inode, group, start, len) -) - -LTTNG_TRACEPOINT_EVENT(ext4_forget, - TP_PROTO(struct inode *inode, int is_metadata, __u64 block), - - TP_ARGS(inode, is_metadata, block), - - TP_FIELDS( - ctf_integer(dev_t, dev, inode->i_sb->s_dev) - ctf_integer(ino_t, ino, inode->i_ino) - ctf_integer(__u64, block, block) - ctf_integer(int, is_metadata, is_metadata) - ctf_integer(TP_MODE_T, mode, inode->i_mode) - ) -) - -LTTNG_TRACEPOINT_EVENT(ext4_da_update_reserve_space, - TP_PROTO(struct inode *inode, int used_blocks, int quota_claim), - - TP_ARGS(inode, used_blocks, quota_claim), - - TP_FIELDS( - ctf_integer(dev_t, dev, inode->i_sb->s_dev) - ctf_integer(ino_t, ino, inode->i_ino) - ctf_integer(__u64, i_blocks, inode->i_blocks) - ctf_integer(int, used_blocks, used_blocks) - ctf_integer(int, reserved_data_blocks, - EXT4_I(inode)->i_reserved_data_blocks) - ctf_integer(int, quota_claim, quota_claim) - ctf_integer(TP_MODE_T, mode, inode->i_mode) - ) -) - -LTTNG_TRACEPOINT_EVENT(ext4_da_reserve_space, - TP_PROTO(struct inode *inode), - - TP_ARGS(inode), - - TP_FIELDS( - ctf_integer(dev_t, dev, inode->i_sb->s_dev) - ctf_integer(ino_t, ino, inode->i_ino) - ctf_integer(__u64, i_blocks, inode->i_blocks) - ctf_integer(int, reserved_data_blocks, - EXT4_I(inode)->i_reserved_data_blocks) - ctf_integer(TP_MODE_T, mode, inode->i_mode) - ) -) - -LTTNG_TRACEPOINT_EVENT(ext4_da_release_space, - TP_PROTO(struct inode *inode, int freed_blocks), - - TP_ARGS(inode, freed_blocks), - - TP_FIELDS( - ctf_integer(dev_t, dev, inode->i_sb->s_dev) - ctf_integer(ino_t, ino, inode->i_ino) - ctf_integer(__u64, i_blocks, inode->i_blocks) - ctf_integer(int, freed_blocks, freed_blocks) - ctf_integer(int, reserved_data_blocks, - EXT4_I(inode)->i_reserved_data_blocks) - ctf_integer(TP_MODE_T, mode, inode->i_mode) - ) -) - -LTTNG_TRACEPOINT_EVENT_CLASS(ext4__bitmap_load, - TP_PROTO(struct super_block *sb, unsigned long group), - - TP_ARGS(sb, group), - - TP_FIELDS( - ctf_integer(dev_t, dev, sb->s_dev) - ctf_integer(__u32, group, group) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__bitmap_load, ext4_mb_bitmap_load, - - TP_PROTO(struct super_block *sb, unsigned long group), - - TP_ARGS(sb, group) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__bitmap_load, ext4_mb_buddy_bitmap_load, - - TP_PROTO(struct super_block *sb, unsigned long group), - - TP_ARGS(sb, group) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__bitmap_load, ext4_read_block_bitmap_load, - - TP_PROTO(struct super_block *sb, unsigned long group), - - TP_ARGS(sb, group) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__bitmap_load, ext4_load_inode_bitmap, - - TP_PROTO(struct super_block *sb, unsigned long group), - - TP_ARGS(sb, group) -) - -LTTNG_TRACEPOINT_EVENT(ext4_direct_IO_enter, - TP_PROTO(struct inode *inode, loff_t offset, unsigned long len, int rw), - - TP_ARGS(inode, offset, len, rw), - - TP_FIELDS( - ctf_integer(dev_t, dev, inode->i_sb->s_dev) - ctf_integer(ino_t, ino, inode->i_ino) - ctf_integer(loff_t, pos, offset) - ctf_integer(unsigned long, len, len) - ctf_integer(int, rw, rw) - ) -) - -LTTNG_TRACEPOINT_EVENT(ext4_direct_IO_exit, - TP_PROTO(struct inode *inode, loff_t offset, unsigned long len, - int rw, int ret), - - TP_ARGS(inode, offset, len, rw, ret), - - TP_FIELDS( - ctf_integer(dev_t, dev, inode->i_sb->s_dev) - ctf_integer(ino_t, ino, inode->i_ino) - ctf_integer(loff_t, pos, offset) - ctf_integer(unsigned long, len, len) - ctf_integer(int, rw, rw) - ctf_integer(int, ret, ret) - ) -) - -LTTNG_TRACEPOINT_EVENT(ext4_fallocate_exit, - TP_PROTO(struct inode *inode, loff_t offset, - unsigned int max_blocks, int ret), - - TP_ARGS(inode, offset, max_blocks, ret), - - TP_FIELDS( - ctf_integer(dev_t, dev, inode->i_sb->s_dev) - ctf_integer(ino_t, ino, inode->i_ino) - ctf_integer(loff_t, pos, offset) - ctf_integer(unsigned int, blocks, max_blocks) - ctf_integer(int, ret, ret) - ) -) - -LTTNG_TRACEPOINT_EVENT_CLASS(ext4__fallocate_mode, - TP_PROTO(struct inode *inode, loff_t offset, loff_t len, int mode), - - TP_ARGS(inode, offset, len, mode), - - TP_FIELDS( - ctf_integer(dev_t, dev, inode->i_sb->s_dev) - ctf_integer(ino_t, ino, inode->i_ino) - ctf_integer(loff_t, pos, offset) - ctf_integer(loff_t, len, len) - ctf_integer(int, mode, mode) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__fallocate_mode, ext4_fallocate_enter, - - TP_PROTO(struct inode *inode, loff_t offset, loff_t len, int mode), - - TP_ARGS(inode, offset, len, mode) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__fallocate_mode, ext4_punch_hole, - - TP_PROTO(struct inode *inode, loff_t offset, loff_t len, int mode), - - TP_ARGS(inode, offset, len, mode) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__fallocate_mode, ext4_zero_range, - - TP_PROTO(struct inode *inode, loff_t offset, loff_t len, int mode), - - TP_ARGS(inode, offset, len, mode) -) - -LTTNG_TRACEPOINT_EVENT(ext4_unlink_enter, - TP_PROTO(struct inode *parent, struct dentry *dentry), - - TP_ARGS(parent, dentry), - - TP_FIELDS( - ctf_integer(dev_t, dev, dentry->d_inode->i_sb->s_dev) - ctf_integer(ino_t, ino, dentry->d_inode->i_ino) - ctf_integer(ino_t, parent, parent->i_ino) - ctf_integer(loff_t, size, dentry->d_inode->i_size) - ) -) - -LTTNG_TRACEPOINT_EVENT(ext4_unlink_exit, - TP_PROTO(struct dentry *dentry, int ret), - - TP_ARGS(dentry, ret), - - TP_FIELDS( - ctf_integer(dev_t, dev, dentry->d_inode->i_sb->s_dev) - ctf_integer(ino_t, ino, dentry->d_inode->i_ino) - ctf_integer(int, ret, ret) - ) -) - -LTTNG_TRACEPOINT_EVENT_CLASS(ext4__truncate, - TP_PROTO(struct inode *inode), - - TP_ARGS(inode), - - TP_FIELDS( - ctf_integer(dev_t, dev, inode->i_sb->s_dev) - ctf_integer(ino_t, ino, inode->i_ino) - ctf_integer(unsigned int, blocks, inode->i_blocks) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__truncate, ext4_truncate_enter, - - TP_PROTO(struct inode *inode), - - TP_ARGS(inode) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__truncate, ext4_truncate_exit, - - TP_PROTO(struct inode *inode), - - TP_ARGS(inode) -) - -/* 'ux' is the uninitialized extent. */ -LTTNG_TRACEPOINT_EVENT(ext4_ext_convert_to_initialized_enter, - TP_PROTO(struct inode *inode, struct ext4_map_blocks *map, - struct ext4_extent *ux), - - TP_ARGS(inode, map, ux), - - TP_FIELDS( - ctf_integer(dev_t, dev, inode->i_sb->s_dev) - ctf_integer(ino_t, ino, inode->i_ino) - ctf_integer(ext4_lblk_t, m_lblk, map->m_lblk) - ctf_integer(unsigned, m_len, map->m_len) - ctf_integer(ext4_lblk_t, u_lblk, le32_to_cpu(ux->ee_block)) - ctf_integer(unsigned, u_len, ext4_ext_get_actual_len(ux)) - ctf_integer(ext4_fsblk_t, u_pblk, ext4_ext_pblock(ux)) - ) -) - -/* - * 'ux' is the uninitialized extent. - * 'ix' is the initialized extent to which blocks are transferred. - */ -LTTNG_TRACEPOINT_EVENT(ext4_ext_convert_to_initialized_fastpath, - TP_PROTO(struct inode *inode, struct ext4_map_blocks *map, - struct ext4_extent *ux, struct ext4_extent *ix), - - TP_ARGS(inode, map, ux, ix), - - TP_FIELDS( - ctf_integer(dev_t, dev, inode->i_sb->s_dev) - ctf_integer(ino_t, ino, inode->i_ino) - ctf_integer(ext4_lblk_t, m_lblk, map->m_lblk) - ctf_integer(unsigned, m_len, map->m_len) - ctf_integer(ext4_lblk_t, u_lblk, le32_to_cpu(ux->ee_block)) - ctf_integer(unsigned, u_len, ext4_ext_get_actual_len(ux)) - ctf_integer(ext4_fsblk_t, u_pblk, ext4_ext_pblock(ux)) - ctf_integer(ext4_lblk_t, i_lblk, le32_to_cpu(ix->ee_block)) - ctf_integer(unsigned, i_len, ext4_ext_get_actual_len(ix)) - ctf_integer(ext4_fsblk_t, i_pblk, ext4_ext_pblock(ix)) - ) -) - -LTTNG_TRACEPOINT_EVENT_CLASS(ext4__map_blocks_enter, - TP_PROTO(struct inode *inode, ext4_lblk_t lblk, - unsigned int len, unsigned int flags), - - TP_ARGS(inode, lblk, len, flags), - - TP_FIELDS( - ctf_integer(dev_t, dev, inode->i_sb->s_dev) - ctf_integer(ino_t, ino, inode->i_ino) - ctf_integer(ext4_lblk_t, lblk, lblk) - ctf_integer(unsigned int, len, len) - ctf_integer(unsigned int, flags, flags) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__map_blocks_enter, ext4_ext_map_blocks_enter, - TP_PROTO(struct inode *inode, ext4_lblk_t lblk, - unsigned len, unsigned flags), - - TP_ARGS(inode, lblk, len, flags) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__map_blocks_enter, ext4_ind_map_blocks_enter, - TP_PROTO(struct inode *inode, ext4_lblk_t lblk, - unsigned len, unsigned flags), - - TP_ARGS(inode, lblk, len, flags) -) - -LTTNG_TRACEPOINT_EVENT_CLASS(ext4__map_blocks_exit, - TP_PROTO(struct inode *inode, unsigned flags, struct ext4_map_blocks *map, - int ret), - - TP_ARGS(inode, flags, map, ret), - - TP_FIELDS( - ctf_integer(dev_t, dev, inode->i_sb->s_dev) - ctf_integer(ino_t, ino, inode->i_ino) - ctf_integer(unsigned int, flags, flags) - ctf_integer(ext4_fsblk_t, pblk, map->m_pblk) - ctf_integer(ext4_lblk_t, lblk, map->m_lblk) - ctf_integer(unsigned int, len, map->m_len) - ctf_integer(unsigned int, mflags, map->m_flags) - ctf_integer(int, ret, ret) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__map_blocks_exit, ext4_ext_map_blocks_exit, - TP_PROTO(struct inode *inode, unsigned flags, - struct ext4_map_blocks *map, int ret), - - TP_ARGS(inode, flags, map, ret) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__map_blocks_exit, ext4_ind_map_blocks_exit, - TP_PROTO(struct inode *inode, unsigned flags, - struct ext4_map_blocks *map, int ret), - - TP_ARGS(inode, flags, map, ret) -) - -LTTNG_TRACEPOINT_EVENT(ext4_ext_load_extent, - TP_PROTO(struct inode *inode, ext4_lblk_t lblk, ext4_fsblk_t pblk), - - TP_ARGS(inode, lblk, pblk), - - TP_FIELDS( - ctf_integer(dev_t, dev, inode->i_sb->s_dev) - ctf_integer(ino_t, ino, inode->i_ino) - ctf_integer(ext4_fsblk_t, pblk, pblk) - ctf_integer(ext4_lblk_t, lblk, lblk) - ) -) - -LTTNG_TRACEPOINT_EVENT(ext4_load_inode, - TP_PROTO(struct inode *inode), - - TP_ARGS(inode), - - TP_FIELDS( - ctf_integer(dev_t, dev, inode->i_sb->s_dev) - ctf_integer(ino_t, ino, inode->i_ino) - ) -) - -LTTNG_TRACEPOINT_EVENT(ext4_journal_start, - TP_PROTO(struct super_block *sb, int blocks, int rsv_blocks, - int revoke_creds, unsigned long IP), - - TP_ARGS(sb, blocks, rsv_blocks, revoke_creds, IP), - - TP_FIELDS( - ctf_integer(dev_t, dev, sb->s_dev) - ctf_integer_hex(unsigned long, ip, IP) - ctf_integer(int, blocks, blocks) - ctf_integer(int, rsv_blocks, rsv_blocks) - ctf_integer(int, revoke_creds, revoke_creds) - ) -) - -LTTNG_TRACEPOINT_EVENT(ext4_journal_start_reserved, - TP_PROTO(struct super_block *sb, int blocks, unsigned long IP), - - TP_ARGS(sb, blocks, IP), - - TP_FIELDS( - ctf_integer(dev_t, dev, sb->s_dev) - ctf_integer_hex(unsigned long, ip, IP) - ctf_integer(int, blocks, blocks) - ) -) - -LTTNG_TRACEPOINT_EVENT(ext4_ext_handle_uninitialized_extents, - TP_PROTO(struct inode *inode, struct ext4_map_blocks *map, int flags, - unsigned int allocated, ext4_fsblk_t newblock), - - TP_ARGS(inode, map, flags, allocated, newblock), - - TP_FIELDS( - ctf_integer(dev_t, dev, inode->i_sb->s_dev) - ctf_integer(ino_t, ino, inode->i_ino) - ctf_integer(int, flags, flags) - ctf_integer(ext4_lblk_t, lblk, map->m_lblk) - ctf_integer(ext4_fsblk_t, pblk, map->m_pblk) - ctf_integer(unsigned int, len, map->m_len) - ctf_integer(unsigned int, allocated, allocated) - ctf_integer(ext4_fsblk_t, newblk, newblock) - ) -) - -LTTNG_TRACEPOINT_EVENT(ext4_get_implied_cluster_alloc_exit, - TP_PROTO(struct super_block *sb, struct ext4_map_blocks *map, int ret), - - TP_ARGS(sb, map, ret), - - TP_FIELDS( - ctf_integer(dev_t, dev, sb->s_dev) - ctf_integer(unsigned int, flags, map->m_flags) - ctf_integer(ext4_lblk_t, lblk, map->m_lblk) - ctf_integer(ext4_fsblk_t, pblk, map->m_pblk) - ctf_integer(unsigned int, len, map->m_len) - ctf_integer(int, ret, ret) - ) -) - -LTTNG_TRACEPOINT_EVENT(ext4_ext_put_in_cache, - TP_PROTO(struct inode *inode, ext4_lblk_t lblk, unsigned int len, - ext4_fsblk_t start), - - TP_ARGS(inode, lblk, len, start), - - TP_FIELDS( - ctf_integer(dev_t, dev, inode->i_sb->s_dev) - ctf_integer(ino_t, ino, inode->i_ino) - ctf_integer(ext4_lblk_t, lblk, lblk) - ctf_integer(unsigned int, len, len) - ctf_integer(ext4_fsblk_t, start, start) - ) -) - -LTTNG_TRACEPOINT_EVENT(ext4_ext_in_cache, - TP_PROTO(struct inode *inode, ext4_lblk_t lblk, int ret), - - TP_ARGS(inode, lblk, ret), - - TP_FIELDS( - ctf_integer(dev_t, dev, inode->i_sb->s_dev) - ctf_integer(ino_t, ino, inode->i_ino) - ctf_integer(ext4_lblk_t, lblk, lblk) - ctf_integer(int, ret, ret) - ) -) - -LTTNG_TRACEPOINT_EVENT(ext4_find_delalloc_range, - TP_PROTO(struct inode *inode, ext4_lblk_t from, ext4_lblk_t to, - int reverse, int found, ext4_lblk_t found_blk), - - TP_ARGS(inode, from, to, reverse, found, found_blk), - - TP_FIELDS( - ctf_integer(dev_t, dev, inode->i_sb->s_dev) - ctf_integer(ino_t, ino, inode->i_ino) - ctf_integer(ext4_lblk_t, from, from) - ctf_integer(ext4_lblk_t, to, to) - ctf_integer(int, reverse, reverse) - ctf_integer(int, found, found) - ctf_integer(ext4_lblk_t, found_blk, found_blk) - ) -) - -LTTNG_TRACEPOINT_EVENT(ext4_get_reserved_cluster_alloc, - TP_PROTO(struct inode *inode, ext4_lblk_t lblk, unsigned int len), - - TP_ARGS(inode, lblk, len), - - TP_FIELDS( - ctf_integer(dev_t, dev, inode->i_sb->s_dev) - ctf_integer(ino_t, ino, inode->i_ino) - ctf_integer(ext4_lblk_t, lblk, lblk) - ctf_integer(unsigned int, len, len) - ) -) - -LTTNG_TRACEPOINT_EVENT(ext4_ext_show_extent, - TP_PROTO(struct inode *inode, ext4_lblk_t lblk, ext4_fsblk_t pblk, - unsigned short len), - - TP_ARGS(inode, lblk, pblk, len), - - TP_FIELDS( - ctf_integer(dev_t, dev, inode->i_sb->s_dev) - ctf_integer(ino_t, ino, inode->i_ino) - ctf_integer(ext4_fsblk_t, pblk, pblk) - ctf_integer(ext4_lblk_t, lblk, lblk) - ctf_integer(unsigned short, len, len) - ) -) - -LTTNG_TRACEPOINT_EVENT(ext4_remove_blocks, - TP_PROTO(struct inode *inode, struct ext4_extent *ex, - ext4_lblk_t from, ext4_fsblk_t to, - struct partial_cluster *pc), - - TP_ARGS(inode, ex, from, to, pc), - - TP_FIELDS( - ctf_integer(dev_t, dev, inode->i_sb->s_dev) - ctf_integer(ino_t, ino, inode->i_ino) - ctf_integer(ext4_lblk_t, from, from) - ctf_integer(ext4_lblk_t, to, to) - ctf_integer(ext4_fsblk_t, ee_pblk, ext4_ext_pblock(ex)) - ctf_integer(ext4_lblk_t, ee_lblk, le32_to_cpu(ex->ee_block)) - ctf_integer(unsigned short, ee_len, ext4_ext_get_actual_len(ex)) - ctf_integer(ext4_fsblk_t, pc_pclu, pc->pclu) - ctf_integer(ext4_lblk_t, pc_lblk, pc->lblk) - ctf_integer(int, pc_state, pc->state) - ) -) - -LTTNG_TRACEPOINT_EVENT(ext4_ext_rm_leaf, - TP_PROTO(struct inode *inode, ext4_lblk_t start, - struct ext4_extent *ex, - struct partial_cluster *pc), - - TP_ARGS(inode, start, ex, pc), - - TP_FIELDS( - ctf_integer(dev_t, dev, inode->i_sb->s_dev) - ctf_integer(ino_t, ino, inode->i_ino) - ctf_integer(ext4_lblk_t, start, start) - ctf_integer(ext4_lblk_t, ee_lblk, le32_to_cpu(ex->ee_block)) - ctf_integer(ext4_fsblk_t, ee_pblk, ext4_ext_pblock(ex)) - ctf_integer(short, ee_len, ext4_ext_get_actual_len(ex)) - ctf_integer(ext4_fsblk_t, pc_pclu, pc->pclu) - ctf_integer(ext4_lblk_t, pc_lblk, pc->lblk) - ctf_integer(int, pc_state, pc->state) - ) -) - -LTTNG_TRACEPOINT_EVENT(ext4_ext_rm_idx, - TP_PROTO(struct inode *inode, ext4_fsblk_t pblk), - - TP_ARGS(inode, pblk), - - TP_FIELDS( - ctf_integer(dev_t, dev, inode->i_sb->s_dev) - ctf_integer(ino_t, ino, inode->i_ino) - ctf_integer(ext4_fsblk_t, pblk, pblk) - ) -) - -LTTNG_TRACEPOINT_EVENT(ext4_ext_remove_space, - TP_PROTO(struct inode *inode, ext4_lblk_t start, - ext4_lblk_t end, int depth), - - TP_ARGS(inode, start, end, depth), - - TP_FIELDS( - ctf_integer(dev_t, dev, inode->i_sb->s_dev) - ctf_integer(ino_t, ino, inode->i_ino) - ctf_integer(ext4_lblk_t, start, start) - ctf_integer(ext4_lblk_t, end, end) - ctf_integer(int, depth, depth) - ) -) - -LTTNG_TRACEPOINT_EVENT(ext4_ext_remove_space_done, - TP_PROTO(struct inode *inode, ext4_lblk_t start, ext4_lblk_t end, - int depth, struct partial_cluster *pc, __le16 eh_entries), - - TP_ARGS(inode, start, end, depth, pc, eh_entries), - - TP_FIELDS( - ctf_integer(dev_t, dev, inode->i_sb->s_dev) - ctf_integer(ino_t, ino, inode->i_ino) - ctf_integer(ext4_lblk_t, start, start) - ctf_integer(ext4_lblk_t, end, end) - ctf_integer(int, depth, depth) - ctf_integer(unsigned short, eh_entries, le16_to_cpu(eh_entries)) - ctf_integer(ext4_fsblk_t, pc_pclu, pc->pclu) - ctf_integer(ext4_lblk_t, pc_lblk, pc->lblk) - ctf_integer(int, pc_state, pc->state) - ) -) - -LTTNG_TRACEPOINT_EVENT_CLASS(ext4__es_extent, - TP_PROTO(struct inode *inode, struct extent_status *es), - - TP_ARGS(inode, es), - - TP_FIELDS( - ctf_integer(dev_t, dev, inode->i_sb->s_dev) - ctf_integer(ino_t, ino, inode->i_ino) - ctf_integer(ext4_lblk_t, lblk, es->es_lblk) - ctf_integer(ext4_lblk_t, len, es->es_len) - ctf_integer(ext4_fsblk_t, pblk, ext4_es_pblock(es)) - ctf_integer(char, status, ext4_es_status(es)) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__es_extent, ext4_es_insert_extent, - TP_PROTO(struct inode *inode, struct extent_status *es), - - TP_ARGS(inode, es) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__es_extent, ext4_es_cache_extent, - TP_PROTO(struct inode *inode, struct extent_status *es), - - TP_ARGS(inode, es) -) - -#endif /* LTTNG_TRACE_EXT4_H */ - -/* This part must be outside protection */ -#include diff --git a/instrumentation/events/lttng-module/gpio.h b/instrumentation/events/lttng-module/gpio.h deleted file mode 100644 index 7a9246e7..00000000 --- a/instrumentation/events/lttng-module/gpio.h +++ /dev/null @@ -1,39 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -#undef TRACE_SYSTEM -#define TRACE_SYSTEM gpio - -#if !defined(LTTNG_TRACE_GPIO_H) || defined(TRACE_HEADER_MULTI_READ) -#define LTTNG_TRACE_GPIO_H - -#include - -LTTNG_TRACEPOINT_EVENT(gpio_direction, - - TP_PROTO(unsigned gpio, int in, int err), - - TP_ARGS(gpio, in, err), - - TP_FIELDS( - ctf_integer(unsigned, gpio, gpio) - ctf_integer(int, in, in) - ctf_integer(int, err, err) - ) -) - -LTTNG_TRACEPOINT_EVENT(gpio_value, - - TP_PROTO(unsigned gpio, int get, int value), - - TP_ARGS(gpio, get, value), - - TP_FIELDS( - ctf_integer(unsigned, gpio, gpio) - ctf_integer(int, get, get) - ctf_integer(int, value, value) - ) -) - -#endif /* if !defined(LTTNG_TRACE_GPIO_H) || defined(TRACE_HEADER_MULTI_READ) */ - -/* This part must be outside protection */ -#include diff --git a/instrumentation/events/lttng-module/i2c.h b/instrumentation/events/lttng-module/i2c.h deleted file mode 100644 index 7fad2f7d..00000000 --- a/instrumentation/events/lttng-module/i2c.h +++ /dev/null @@ -1,120 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -#undef TRACE_SYSTEM -#define TRACE_SYSTEM i2c - -#if !defined(LTTNG_TRACE_I2C_H) || defined(TRACE_HEADER_MULTI_READ) -#define LTTNG_TRACE_I2C_H - -#include - -/* - * __i2c_transfer() write request - */ -LTTNG_TRACEPOINT_EVENT_CODE(i2c_write, - - TP_PROTO(const struct i2c_adapter *adap, const struct i2c_msg *msg, - int num), - - TP_ARGS(adap, msg, num), - - TP_locvar( - int extract_sensitive_payload; - ), - - TP_code_pre( - tp_locvar->extract_sensitive_payload = - READ_ONCE(extract_sensitive_payload); - ), - - TP_FIELDS( - ctf_integer(int, adapter_nr, adap->nr) - ctf_integer(__u16, msg_nr, num) - ctf_integer(__u16, addr, msg->addr) - ctf_integer(__u16, flags, msg->flags) - ctf_integer(__u16, len, msg->len) - ctf_sequence_hex(__u8, buf, - tp_locvar->extract_sensitive_payload ? - msg->buf : NULL, - __u16, - tp_locvar->extract_sensitive_payload ? - msg->len : 0) - ), - - TP_code_post() -) - -/* - * __i2c_transfer() read request - */ -LTTNG_TRACEPOINT_EVENT(i2c_read, - - TP_PROTO(const struct i2c_adapter *adap, const struct i2c_msg *msg, - int num), - - TP_ARGS(adap, msg, num), - - TP_FIELDS( - ctf_integer(int, adapter_nr, adap->nr) - ctf_integer(__u16, msg_nr, num) - ctf_integer(__u16, addr, msg->addr) - ctf_integer(__u16, flags, msg->flags) - ctf_integer(__u16, len, msg->len) - ) -) - -/* - * __i2c_transfer() read reply - */ -LTTNG_TRACEPOINT_EVENT_CODE(i2c_reply, - - TP_PROTO(const struct i2c_adapter *adap, const struct i2c_msg *msg, - int num), - - TP_ARGS(adap, msg, num), - - TP_locvar( - int extract_sensitive_payload; - ), - - TP_code_pre( - tp_locvar->extract_sensitive_payload = - READ_ONCE(extract_sensitive_payload); - ), - - TP_FIELDS( - ctf_integer(int, adapter_nr, adap->nr) - ctf_integer(__u16, msg_nr, num) - ctf_integer(__u16, addr, msg->addr) - ctf_integer(__u16, flags, msg->flags) - ctf_integer(__u16, len, msg->len) - ctf_sequence_hex(__u8, buf, - tp_locvar->extract_sensitive_payload ? - msg->buf : NULL, - __u16, - tp_locvar->extract_sensitive_payload ? - msg->len : 0) - ), - - TP_code_post() -) - -/* - * __i2c_transfer() result - */ -LTTNG_TRACEPOINT_EVENT(i2c_result, - - TP_PROTO(const struct i2c_adapter *adap, int num, int ret), - - TP_ARGS(adap, num, ret), - - TP_FIELDS( - ctf_integer(int, adapter_nr, adap->nr) - ctf_integer(__u16, nr_msgs, num) - ctf_integer(__s16, ret, ret) - ) -) - -#endif /* LTTNG_TRACE_I2C_H */ - -/* This part must be outside protection */ -#include diff --git a/instrumentation/events/lttng-module/irq.h b/instrumentation/events/lttng-module/irq.h deleted file mode 100644 index e1bbbafe..00000000 --- a/instrumentation/events/lttng-module/irq.h +++ /dev/null @@ -1,126 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -#undef TRACE_SYSTEM -#define TRACE_SYSTEM irq - -#if !defined(LTTNG_TRACE_IRQ_H) || defined(TRACE_HEADER_MULTI_READ) -#define LTTNG_TRACE_IRQ_H - -#include - -#ifndef _TRACE_IRQ_DEF_ -#define _TRACE_IRQ_DEF_ - -struct irqaction; -struct softirq_action; - -#endif /* _TRACE_IRQ_DEF_ */ - -/** - * irq_handler_entry - called immediately before the irq action handler - * @irq: irq number - * @action: pointer to struct irqaction - * - * The struct irqaction pointed to by @action contains various - * information about the handler, including the device name, - * @action->name, and the device id, @action->dev_id. When used in - * conjunction with the irq_handler_exit tracepoint, we can figure - * out irq handler latencies. - */ -LTTNG_TRACEPOINT_EVENT(irq_handler_entry, - - TP_PROTO(int irq, struct irqaction *action), - - TP_ARGS(irq, action), - - TP_FIELDS( - ctf_integer(int, irq, irq) - ctf_string(name, action->name) - ) -) - -/** - * irq_handler_exit - called immediately after the irq action handler returns - * @irq: irq number - * @action: pointer to struct irqaction - * @ret: return value - * - * If the @ret value is set to IRQ_HANDLED, then we know that the corresponding - * @action->handler scuccessully handled this irq. Otherwise, the irq might be - * a shared irq line, or the irq was not handled successfully. Can be used in - * conjunction with the irq_handler_entry to understand irq handler latencies. - */ -LTTNG_TRACEPOINT_EVENT(irq_handler_exit, - - TP_PROTO(int irq, struct irqaction *action, int ret), - - TP_ARGS(irq, action, ret), - - TP_FIELDS( - ctf_integer(int, irq, irq) - ctf_integer(int, ret, ret) - ) -) - -LTTNG_TRACEPOINT_EVENT_CLASS(irq_softirq, - - TP_PROTO(unsigned int vec_nr), - - TP_ARGS(vec_nr), - - TP_FIELDS( - ctf_integer(unsigned int, vec, vec_nr) - ) -) - -/** - * softirq_entry - called immediately before the softirq handler - * @vec_nr: softirq vector number - * - * When used in combination with the softirq_exit tracepoint - * we can determine the softirq handler runtine. - */ -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(irq_softirq, softirq_entry, - - irq_softirq_entry, - - TP_PROTO(unsigned int vec_nr), - - TP_ARGS(vec_nr) -) - -/** - * softirq_exit - called immediately after the softirq handler returns - * @vec_nr: softirq vector number - * - * When used in combination with the softirq_entry tracepoint - * we can determine the softirq handler runtine. - */ -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(irq_softirq, softirq_exit, - - irq_softirq_exit, - - TP_PROTO(unsigned int vec_nr), - - TP_ARGS(vec_nr) -) - -/** - * softirq_raise - called immediately when a softirq is raised - * @vec_nr: softirq vector number - * - * When used in combination with the softirq_entry tracepoint - * we can determine the softirq raise to run latency. - */ -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(irq_softirq, softirq_raise, - - irq_softirq_raise, - - TP_PROTO(unsigned int vec_nr), - - TP_ARGS(vec_nr) -) - -#endif /* LTTNG_TRACE_IRQ_H */ - -/* This part must be outside protection */ -#include diff --git a/instrumentation/events/lttng-module/jbd2.h b/instrumentation/events/lttng-module/jbd2.h deleted file mode 100644 index db2f0d5f..00000000 --- a/instrumentation/events/lttng-module/jbd2.h +++ /dev/null @@ -1,168 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -#undef TRACE_SYSTEM -#define TRACE_SYSTEM jbd2 - -#if !defined(LTTNG_TRACE_JBD2_H) || defined(TRACE_HEADER_MULTI_READ) -#define LTTNG_TRACE_JBD2_H - -#include -#include - -#ifndef _TRACE_JBD2_DEF -#define _TRACE_JBD2_DEF -struct transaction_chp_stats_s; -struct transaction_run_stats_s; -#endif - -LTTNG_TRACEPOINT_EVENT(jbd2_checkpoint, - - TP_PROTO(journal_t *journal, int result), - - TP_ARGS(journal, result), - - TP_FIELDS( - ctf_integer(dev_t, dev, journal->j_fs_dev->bd_dev) - ctf_integer(int, result, result) - ) -) - -LTTNG_TRACEPOINT_EVENT_CLASS(jbd2_commit, - - TP_PROTO(journal_t *journal, transaction_t *commit_transaction), - - TP_ARGS(journal, commit_transaction), - - TP_FIELDS( - ctf_integer(dev_t, dev, journal->j_fs_dev->bd_dev) - ctf_integer(char, sync_commit, commit_transaction->t_synchronous_commit) - ctf_integer(int, transaction, commit_transaction->t_tid) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(jbd2_commit, jbd2_start_commit, - - TP_PROTO(journal_t *journal, transaction_t *commit_transaction), - - TP_ARGS(journal, commit_transaction) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(jbd2_commit, jbd2_commit_locking, - - TP_PROTO(journal_t *journal, transaction_t *commit_transaction), - - TP_ARGS(journal, commit_transaction) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(jbd2_commit, jbd2_commit_flushing, - - TP_PROTO(journal_t *journal, transaction_t *commit_transaction), - - TP_ARGS(journal, commit_transaction) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(jbd2_commit, jbd2_commit_logging, - - TP_PROTO(journal_t *journal, transaction_t *commit_transaction), - - TP_ARGS(journal, commit_transaction) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(jbd2_commit, jbd2_drop_transaction, - - TP_PROTO(journal_t *journal, transaction_t *commit_transaction), - - TP_ARGS(journal, commit_transaction) -) - -LTTNG_TRACEPOINT_EVENT(jbd2_end_commit, - TP_PROTO(journal_t *journal, transaction_t *commit_transaction), - - TP_ARGS(journal, commit_transaction), - - TP_FIELDS( - ctf_integer(dev_t, dev, journal->j_fs_dev->bd_dev) - ctf_integer(char, sync_commit, commit_transaction->t_synchronous_commit) - ctf_integer(int, transaction, commit_transaction->t_tid) - ctf_integer(int, head, journal->j_tail_sequence) - ) -) - -LTTNG_TRACEPOINT_EVENT(jbd2_submit_inode_data, - TP_PROTO(struct inode *inode), - - TP_ARGS(inode), - - TP_FIELDS( - ctf_integer(dev_t, dev, inode->i_sb->s_dev) - ctf_integer(ino_t, ino, inode->i_ino) - ) -) - -LTTNG_TRACEPOINT_EVENT(jbd2_run_stats, - TP_PROTO(dev_t dev, unsigned long tid, - struct transaction_run_stats_s *stats), - - TP_ARGS(dev, tid, stats), - - TP_FIELDS( - ctf_integer(dev_t, dev, dev) - ctf_integer(unsigned long, tid, tid) - ctf_integer(unsigned long, wait, stats->rs_wait) - ctf_integer(unsigned long, running, stats->rs_running) - ctf_integer(unsigned long, locked, stats->rs_locked) - ctf_integer(unsigned long, flushing, stats->rs_flushing) - ctf_integer(unsigned long, logging, stats->rs_logging) - ctf_integer(__u32, handle_count, stats->rs_handle_count) - ctf_integer(__u32, blocks, stats->rs_blocks) - ctf_integer(__u32, blocks_logged, stats->rs_blocks_logged) - ) -) - -LTTNG_TRACEPOINT_EVENT(jbd2_checkpoint_stats, - TP_PROTO(dev_t dev, unsigned long tid, - struct transaction_chp_stats_s *stats), - - TP_ARGS(dev, tid, stats), - - TP_FIELDS( - ctf_integer(dev_t, dev, dev) - ctf_integer(unsigned long, tid, tid) - ctf_integer(unsigned long, chp_time, stats->cs_chp_time) - ctf_integer(__u32, forced_to_close, stats->cs_forced_to_close) - ctf_integer(__u32, written, stats->cs_written) - ctf_integer(__u32, dropped, stats->cs_dropped) - ) -) - -LTTNG_TRACEPOINT_EVENT(jbd2_update_log_tail, - - TP_PROTO(journal_t *journal, tid_t first_tid, - unsigned long block_nr, unsigned long freed), - - TP_ARGS(journal, first_tid, block_nr, freed), - - TP_FIELDS( - ctf_integer(dev_t, dev, journal->j_fs_dev->bd_dev) - ctf_integer(tid_t, tail_sequence, journal->j_tail_sequence) - ctf_integer(tid_t, first_tid, first_tid) - ctf_integer(unsigned long, block_nr, block_nr) - ctf_integer(unsigned long, freed, freed) - ) -) - -LTTNG_TRACEPOINT_EVENT(jbd2_write_superblock, - - TP_PROTO(journal_t *journal, int write_op), - - TP_ARGS(journal, write_op), - - TP_FIELDS( - ctf_integer(dev_t, dev, journal->j_fs_dev->bd_dev) - ctf_integer(int, write_op, write_op) - ) -) - -#endif /* LTTNG_TRACE_JBD2_H */ - -/* This part must be outside protection */ -#include diff --git a/instrumentation/events/lttng-module/kmem.h b/instrumentation/events/lttng-module/kmem.h deleted file mode 100644 index 479f0fef..00000000 --- a/instrumentation/events/lttng-module/kmem.h +++ /dev/null @@ -1,219 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -#undef TRACE_SYSTEM -#define TRACE_SYSTEM kmem - -#if !defined(LTTNG_TRACE_KMEM_H) || defined(TRACE_HEADER_MULTI_READ) -#define LTTNG_TRACE_KMEM_H - -#include -#include - -LTTNG_TRACEPOINT_EVENT_CLASS(kmem_alloc, - - TP_PROTO(unsigned long call_site, - const void *ptr, - size_t bytes_req, - size_t bytes_alloc, - gfp_t gfp_flags), - - TP_ARGS(call_site, ptr, bytes_req, bytes_alloc, gfp_flags), - - TP_FIELDS( - ctf_integer_hex(unsigned long, call_site, call_site) - ctf_integer_hex(const void *, ptr, ptr) - ctf_integer(size_t, bytes_req, bytes_req) - ctf_integer(size_t, bytes_alloc, bytes_alloc) - ctf_integer(gfp_t, gfp_flags, gfp_flags) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(kmem_alloc, kmalloc, - - kmem_kmalloc, - - TP_PROTO(unsigned long call_site, const void *ptr, - size_t bytes_req, size_t bytes_alloc, gfp_t gfp_flags), - - TP_ARGS(call_site, ptr, bytes_req, bytes_alloc, gfp_flags) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(kmem_alloc, kmem_cache_alloc, - - TP_PROTO(unsigned long call_site, const void *ptr, - size_t bytes_req, size_t bytes_alloc, gfp_t gfp_flags), - - TP_ARGS(call_site, ptr, bytes_req, bytes_alloc, gfp_flags) -) - -LTTNG_TRACEPOINT_EVENT_CLASS(kmem_alloc_node, - - TP_PROTO(unsigned long call_site, - const void *ptr, - size_t bytes_req, - size_t bytes_alloc, - gfp_t gfp_flags, - int node), - - TP_ARGS(call_site, ptr, bytes_req, bytes_alloc, gfp_flags, node), - - TP_FIELDS( - ctf_integer_hex(unsigned long, call_site, call_site) - ctf_integer_hex(const void *, ptr, ptr) - ctf_integer(size_t, bytes_req, bytes_req) - ctf_integer(size_t, bytes_alloc, bytes_alloc) - ctf_integer(gfp_t, gfp_flags, gfp_flags) - ctf_integer(int, node, node) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(kmem_alloc_node, kmalloc_node, - - kmem_kmalloc_node, - - TP_PROTO(unsigned long call_site, const void *ptr, - size_t bytes_req, size_t bytes_alloc, - gfp_t gfp_flags, int node), - - TP_ARGS(call_site, ptr, bytes_req, bytes_alloc, gfp_flags, node) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(kmem_alloc_node, kmem_cache_alloc_node, - - TP_PROTO(unsigned long call_site, const void *ptr, - size_t bytes_req, size_t bytes_alloc, - gfp_t gfp_flags, int node), - - TP_ARGS(call_site, ptr, bytes_req, bytes_alloc, gfp_flags, node) -) - -LTTNG_TRACEPOINT_EVENT_CLASS(kmem_free, - - TP_PROTO(unsigned long call_site, const void *ptr), - - TP_ARGS(call_site, ptr), - - TP_FIELDS( - ctf_integer_hex(unsigned long, call_site, call_site) - ctf_integer_hex(const void *, ptr, ptr) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(kmem_free, kfree, - - kmem_kfree, - - TP_PROTO(unsigned long call_site, const void *ptr), - - TP_ARGS(call_site, ptr) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(kmem_free, kmem_cache_free, - - TP_PROTO(unsigned long call_site, const void *ptr), - - TP_ARGS(call_site, ptr) -) - -LTTNG_TRACEPOINT_EVENT_MAP(mm_page_free, kmem_mm_page_free, - - TP_PROTO(struct page *page, unsigned int order), - - TP_ARGS(page, order), - - TP_FIELDS( - ctf_integer_hex(struct page *, page, page) - ctf_integer(unsigned long, pfn, page_to_pfn(page)) - ctf_integer(unsigned int, order, order) - ) -) - -LTTNG_TRACEPOINT_EVENT_MAP(mm_page_free_batched, kmem_mm_page_free_batched, - - TP_PROTO(struct page *page), - - TP_ARGS(page), - - TP_FIELDS( - ctf_integer_hex(struct page *, page, page) - ctf_integer(unsigned long, pfn, page_to_pfn(page)) - ) -) - -LTTNG_TRACEPOINT_EVENT_MAP(mm_page_alloc, kmem_mm_page_alloc, - - TP_PROTO(struct page *page, unsigned int order, - gfp_t gfp_flags, int migratetype), - - TP_ARGS(page, order, gfp_flags, migratetype), - - TP_FIELDS( - ctf_integer_hex(struct page *, page, page) - ctf_integer(unsigned long, pfn, - page ? page_to_pfn(page) : -1UL) - ctf_integer(unsigned int, order, order) - ctf_integer(gfp_t, gfp_flags, gfp_flags) - ctf_integer(int, migratetype, migratetype) - ) -) - -LTTNG_TRACEPOINT_EVENT_CLASS(kmem_mm_page, - - TP_PROTO(struct page *page, unsigned int order, int migratetype), - - TP_ARGS(page, order, migratetype), - - TP_FIELDS( - ctf_integer_hex(struct page *, page, page) - ctf_integer(unsigned long, pfn, - page ? page_to_pfn(page) : -1UL) - ctf_integer(unsigned int, order, order) - ctf_integer(int, migratetype, migratetype) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(kmem_mm_page, mm_page_alloc_zone_locked, - - kmem_mm_page_alloc_zone_locked, - - TP_PROTO(struct page *page, unsigned int order, int migratetype), - - TP_ARGS(page, order, migratetype) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(kmem_mm_page, mm_page_pcpu_drain, - - kmem_mm_page_pcpu_drain, - - TP_PROTO(struct page *page, unsigned int order, int migratetype), - - TP_ARGS(page, order, migratetype) -) - -LTTNG_TRACEPOINT_EVENT_MAP(mm_page_alloc_extfrag, - - kmem_mm_page_alloc_extfrag, - - TP_PROTO(struct page *page, - int alloc_order, int fallback_order, - int alloc_migratetype, int fallback_migratetype), - - TP_ARGS(page, - alloc_order, fallback_order, - alloc_migratetype, fallback_migratetype), - - TP_FIELDS( - ctf_integer_hex(struct page *, page, page) - ctf_integer(unsigned long, pfn, page_to_pfn(page)) - ctf_integer(int, alloc_order, alloc_order) - ctf_integer(int, fallback_order, fallback_order) - ctf_integer(int, alloc_migratetype, alloc_migratetype) - ctf_integer(int, fallback_migratetype, fallback_migratetype) - ctf_integer(int, change_ownership, - (alloc_migratetype == get_pageblock_migratetype(page))) - ) -) - -#endif /* LTTNG_TRACE_KMEM_H */ - -/* This part must be outside protection */ -#include diff --git a/instrumentation/events/lttng-module/kvm.h b/instrumentation/events/lttng-module/kvm.h deleted file mode 100644 index cdcc35b2..00000000 --- a/instrumentation/events/lttng-module/kvm.h +++ /dev/null @@ -1,185 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -#if !defined(LTTNG_TRACE_KVM_MAIN_H) || defined(TRACE_HEADER_MULTI_READ) -#define LTTNG_TRACE_KVM_MAIN_H - -#include - -#undef TRACE_SYSTEM -#define TRACE_SYSTEM kvm - -LTTNG_TRACEPOINT_EVENT(kvm_userspace_exit, - TP_PROTO(__u32 reason, int errno), - TP_ARGS(reason, errno), - - TP_FIELDS( - ctf_integer(__u32, reason, reason) - ctf_integer(int, errno, errno) - ) -) - -#if defined(__KVM_HAVE_IRQ_LINE) -LTTNG_TRACEPOINT_EVENT(kvm_set_irq, - TP_PROTO(unsigned int gsi, int level, int irq_source_id), - TP_ARGS(gsi, level, irq_source_id), - - TP_FIELDS( - ctf_integer(unsigned int, gsi, gsi) - ctf_integer(int, level, level) - ctf_integer(int, irq_source_id, irq_source_id) - ) -) -#endif - -#if defined(__KVM_HAVE_IOAPIC) - -LTTNG_TRACEPOINT_EVENT(kvm_ioapic_set_irq, - TP_PROTO(__u64 e, int pin, bool coalesced), - TP_ARGS(e, pin, coalesced), - - TP_FIELDS( - ctf_integer(__u64, e, e) - ctf_integer(int, pin, pin) - ctf_integer(bool, coalesced, coalesced) - ) -) - -LTTNG_TRACEPOINT_EVENT(kvm_msi_set_irq, - TP_PROTO(__u64 address, __u64 data), - TP_ARGS(address, data), - - TP_FIELDS( - ctf_integer_hex(__u64, address, address) - ctf_integer(__u64, data, data) - ) -) - -LTTNG_TRACEPOINT_EVENT(kvm_ack_irq, - TP_PROTO(unsigned int irqchip, unsigned int pin), - TP_ARGS(irqchip, pin), - - TP_FIELDS( - ctf_integer(unsigned int, irqchip, irqchip) - ctf_integer(unsigned int, pin, pin) - ) -) - -#endif /* defined(__KVM_HAVE_IOAPIC) */ - -#define KVM_TRACE_MMIO_READ_UNSATISFIED 0 -#define KVM_TRACE_MMIO_READ 1 -#define KVM_TRACE_MMIO_WRITE 2 - -#define kvm_trace_symbol_mmio \ - { KVM_TRACE_MMIO_READ_UNSATISFIED, "unsatisfied-read" }, \ - { KVM_TRACE_MMIO_READ, "read" }, \ - { KVM_TRACE_MMIO_WRITE, "write" } - - -LTTNG_TRACEPOINT_EVENT(kvm_mmio, - TP_PROTO(int type, int len, u64 gpa, void *val), - TP_ARGS(type, len, gpa, val), - - TP_FIELDS( - ctf_integer(u32, type, type) - ctf_integer(u32, len, len) - ctf_integer(u64, gpa, gpa) - ctf_sequence_hex(unsigned char, val, val, u32, len) - ) -) - -#define kvm_fpu_load_symbol \ - {0, "unload"}, \ - {1, "load"} - -LTTNG_TRACEPOINT_EVENT(kvm_fpu, - TP_PROTO(int load), - TP_ARGS(load), - - TP_FIELDS( - ctf_integer(u32, load, load) - ) -) - -LTTNG_TRACEPOINT_EVENT(kvm_age_page, - TP_PROTO(ulong gfn, int level, struct kvm_memory_slot *slot, int ref), - TP_ARGS(gfn, level, slot, ref), - - TP_FIELDS( - ctf_integer(u64, hva, - ((gfn - slot->base_gfn) << PAGE_SHIFT) + slot->userspace_addr) - ctf_integer(u64, gfn, gfn) - ctf_integer(u8, level, level) - ctf_integer(u8, referenced, ref) - ) -) - -#ifdef CONFIG_KVM_ASYNC_PF -LTTNG_TRACEPOINT_EVENT_CLASS(kvm_async_get_page_class, - - TP_PROTO(u64 gva, u64 gfn), - - TP_ARGS(gva, gfn), - - TP_FIELDS( - ctf_integer(__u64, gva, gva) - ctf_integer(u64, gfn, gfn) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(kvm_async_get_page_class, kvm_try_async_get_page, - - TP_PROTO(u64 gva, u64 gfn), - - TP_ARGS(gva, gfn) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(kvm_async_get_page_class, kvm_async_pf_doublefault, - - TP_PROTO(u64 gva, u64 gfn), - - TP_ARGS(gva, gfn) -) - -LTTNG_TRACEPOINT_EVENT_CLASS(kvm_async_pf_nopresent_ready, - - TP_PROTO(u64 token, u64 gva), - - TP_ARGS(token, gva), - - TP_FIELDS( - ctf_integer(__u64, token, token) - ctf_integer(__u64, gva, gva) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(kvm_async_pf_nopresent_ready, kvm_async_pf_not_present, - - TP_PROTO(u64 token, u64 gva), - - TP_ARGS(token, gva) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(kvm_async_pf_nopresent_ready, kvm_async_pf_ready, - - TP_PROTO(u64 token, u64 gva), - - TP_ARGS(token, gva) -) - -LTTNG_TRACEPOINT_EVENT( - kvm_async_pf_completed, - TP_PROTO(unsigned long address, u64 gva), - TP_ARGS(address, gva), - - TP_FIELDS( - ctf_integer_hex(unsigned long, address, address) - ctf_integer(u64, gva, gva) - ) -) - -#endif - -#endif /* LTTNG_TRACE_KVM_MAIN_H */ - -/* This part must be outside protection */ -#include diff --git a/instrumentation/events/lttng-module/lock.h b/instrumentation/events/lttng-module/lock.h deleted file mode 100644 index f384fd4a..00000000 --- a/instrumentation/events/lttng-module/lock.h +++ /dev/null @@ -1,71 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ - -#undef TRACE_SYSTEM -#define TRACE_SYSTEM lock - -#if !defined(LTTNG_TRACE_LOCK_H) || defined(TRACE_HEADER_MULTI_READ) -#define LTTNG_TRACE_LOCK_H - -#include -#include - -#ifdef CONFIG_LOCKDEP - -LTTNG_TRACEPOINT_EVENT(lock_acquire, - - TP_PROTO(struct lockdep_map *lock, unsigned int subclass, - int trylock, int read, int check, - struct lockdep_map *next_lock, unsigned long ip), - - TP_ARGS(lock, subclass, trylock, read, check, next_lock, ip), - - TP_FIELDS( - ctf_integer(unsigned int, flags, (trylock ? 1 : 0) | (read ? 2 : 0)) - ctf_string(name, lock->name) - ctf_integer_hex(void *, lockdep_addr, lock) - ) -) - -LTTNG_TRACEPOINT_EVENT_CLASS(lock, - - TP_PROTO(struct lockdep_map *lock, unsigned long ip), - - TP_ARGS(lock, ip), - - TP_FIELDS( - ctf_string(name, lock->name) - ctf_integer_hex(void *, lockdep_addr, lock) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(lock, lock_release, - - TP_PROTO(struct lockdep_map *lock, unsigned long ip), - - TP_ARGS(lock, ip) -) - -#ifdef CONFIG_LOCK_STAT - -LTTNG_TRACEPOINT_EVENT_INSTANCE(lock, lock_contended, - - TP_PROTO(struct lockdep_map *lock, unsigned long ip), - - TP_ARGS(lock, ip) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(lock, lock_acquired, - - TP_PROTO(struct lockdep_map *lock, unsigned long ip), - - TP_ARGS(lock, ip) -) - -#endif /* CONFIG_LOCK_STAT */ - -#endif /* CONFIG_LOCKDEP */ - -#endif /* LTTNG_TRACE_LOCK_H */ - -/* This part must be outside protection */ -#include diff --git a/instrumentation/events/lttng-module/lttng-statedump.h b/instrumentation/events/lttng-module/lttng-statedump.h deleted file mode 100644 index 7ca72ccd..00000000 --- a/instrumentation/events/lttng-module/lttng-statedump.h +++ /dev/null @@ -1,253 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -#undef TRACE_SYSTEM -#define TRACE_SYSTEM lttng_statedump - -#if !defined(LTTNG_TRACE_LTTNG_STATEDUMP_H) || defined(TRACE_HEADER_MULTI_READ) -#define LTTNG_TRACE_LTTNG_STATEDUMP_H - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#ifndef LTTNG_MNT_NS_MISSING_HEADER -# ifndef ONCE_LTTNG_FS_MOUNT_H -# define ONCE_LTTNG_FS_MOUNT_H -# include <../fs/mount.h> -# endif -#endif - -LTTNG_TRACEPOINT_EVENT(lttng_statedump_start, - TP_PROTO(struct lttng_session *session), - TP_ARGS(session), - TP_FIELDS() -) - -LTTNG_TRACEPOINT_EVENT(lttng_statedump_end, - TP_PROTO(struct lttng_session *session), - TP_ARGS(session), - TP_FIELDS() -) - -LTTNG_TRACEPOINT_EVENT(lttng_statedump_process_state, - TP_PROTO(struct lttng_session *session, - struct task_struct *p, - int type, int mode, int submode, int status, - struct files_struct *files), - TP_ARGS(session, p, type, mode, submode, status, files), - TP_FIELDS( - ctf_integer(pid_t, tid, p->pid) - ctf_integer(pid_t, pid, p->tgid) - ctf_integer(pid_t, ppid, - ({ - pid_t ret; - - rcu_read_lock(); - ret = task_tgid_nr(p->real_parent); - rcu_read_unlock(); - ret; - })) - ctf_array_text(char, name, p->comm, TASK_COMM_LEN) - ctf_integer(int, type, type) - ctf_integer(int, mode, mode) - ctf_integer(int, submode, submode) - ctf_integer(int, status, status) - ctf_integer(unsigned int, cpu, task_cpu(p)) - ctf_integer_hex(struct files_struct *, file_table_address, files) - ) -) - -LTTNG_TRACEPOINT_EVENT(lttng_statedump_process_cgroup_ns, - TP_PROTO(struct lttng_session *session, - struct task_struct *p, - struct cgroup_namespace *cgroup_ns), - TP_ARGS(session, p, cgroup_ns), - TP_FIELDS( - ctf_integer(pid_t, tid, p->pid) - ctf_integer(unsigned int, ns_inum, cgroup_ns ? cgroup_ns->ns.inum : 0) - ) -) - -LTTNG_TRACEPOINT_EVENT(lttng_statedump_process_ipc_ns, - TP_PROTO(struct lttng_session *session, - struct task_struct *p, - struct ipc_namespace *ipc_ns), - TP_ARGS(session, p, ipc_ns), - TP_FIELDS( - ctf_integer(pid_t, tid, p->pid) - ctf_integer(unsigned int, ns_inum, ipc_ns ? ipc_ns->ns.inum : 0) - ) -) - -#if !defined(LTTNG_MNT_NS_MISSING_HEADER) -LTTNG_TRACEPOINT_EVENT(lttng_statedump_process_mnt_ns, - TP_PROTO(struct lttng_session *session, - struct task_struct *p, - struct mnt_namespace *mnt_ns), - TP_ARGS(session, p, mnt_ns), - TP_FIELDS( - ctf_integer(pid_t, tid, p->pid) - ctf_integer(unsigned int, ns_inum, mnt_ns ? mnt_ns->ns.inum : 0) - ) -) -#endif - -LTTNG_TRACEPOINT_EVENT(lttng_statedump_process_net_ns, - TP_PROTO(struct lttng_session *session, - struct task_struct *p, - struct net *net_ns), - TP_ARGS(session, p, net_ns), - TP_FIELDS( - ctf_integer(pid_t, tid, p->pid) - ctf_integer(unsigned int, ns_inum, net_ns ? net_ns->ns.inum : 0) - ) -) - -LTTNG_TRACEPOINT_EVENT(lttng_statedump_process_pid_ns, - TP_PROTO(struct lttng_session *session, - struct task_struct *p, - struct pid_namespace *pid_ns), - TP_ARGS(session, p, pid_ns), - TP_FIELDS( - ctf_integer(pid_t, tid, p->pid) - ctf_integer(pid_t, vtid, pid_ns ? task_pid_nr_ns(p, pid_ns) : 0) - ctf_integer(pid_t, vpid, pid_ns ? task_tgid_nr_ns(p, pid_ns) : 0) - ctf_integer(pid_t, vppid, - ({ - struct task_struct *parent; - pid_t ret = 0; - - if (pid_ns) { - rcu_read_lock(); - parent = rcu_dereference(p->real_parent); - ret = task_tgid_nr_ns(parent, pid_ns); - rcu_read_unlock(); - } - ret; - })) - ctf_integer(int, ns_level, pid_ns ? pid_ns->level : 0) - ctf_integer(unsigned int, ns_inum, pid_ns ? pid_ns->ns.inum : 0) - ) -) - -LTTNG_TRACEPOINT_EVENT(lttng_statedump_process_user_ns, - TP_PROTO(struct lttng_session *session, - struct task_struct *p, - struct user_namespace *user_ns), - TP_ARGS(session, p, user_ns), - TP_FIELDS( - ctf_integer(pid_t, tid, p->pid) - ctf_integer(uid_t, vuid, user_ns ? lttng_task_vuid(p, user_ns) : 0) - ctf_integer(gid_t, vgid, user_ns ? lttng_task_vgid(p, user_ns) : 0) - ctf_integer(int, ns_level, user_ns ? user_ns->level : 0) - ctf_integer(unsigned int, ns_inum, user_ns ? user_ns->ns.inum : 0) - ) -) - -LTTNG_TRACEPOINT_EVENT(lttng_statedump_process_uts_ns, - TP_PROTO(struct lttng_session *session, - struct task_struct *p, - struct uts_namespace *uts_ns), - TP_ARGS(session, p, uts_ns), - TP_FIELDS( - ctf_integer(pid_t, tid, p->pid) - ctf_integer(unsigned int, ns_inum, uts_ns ? uts_ns->ns.inum : 0) - ) -) - -LTTNG_TRACEPOINT_EVENT(lttng_statedump_file_descriptor, - TP_PROTO(struct lttng_session *session, - struct files_struct *files, - int fd, const char *filename, - unsigned int flags, fmode_t fmode), - TP_ARGS(session, files, fd, filename, flags, fmode), - TP_FIELDS( - ctf_integer_hex(struct files_struct *, file_table_address, files) - ctf_integer(int, fd, fd) - ctf_integer_oct(unsigned int, flags, flags) - ctf_integer_hex(fmode_t, fmode, fmode) - ctf_string(filename, filename) - ) -) - -LTTNG_TRACEPOINT_EVENT(lttng_statedump_vm_map, - TP_PROTO(struct lttng_session *session, - struct task_struct *p, struct vm_area_struct *map, - unsigned long inode), - TP_ARGS(session, p, map, inode), - TP_FIELDS( - ctf_integer(pid_t, pid, p->tgid) - ctf_integer_hex(unsigned long, start, map->vm_start) - ctf_integer_hex(unsigned long, end, map->vm_end) - ctf_integer_hex(unsigned long, flags, map->vm_flags) - ctf_integer(unsigned long, inode, inode) - ctf_integer(unsigned long, pgoff, map->vm_pgoff << PAGE_SHIFT) - ) -) - -LTTNG_TRACEPOINT_EVENT(lttng_statedump_network_interface, - TP_PROTO(struct lttng_session *session, - struct net_device *dev, struct in_ifaddr *ifa), - TP_ARGS(session, dev, ifa), - TP_FIELDS( - ctf_string(name, dev->name) - ctf_integer_network_hex(uint32_t, address_ipv4, - ifa ? ifa->ifa_address : 0U) - ) -) - -LTTNG_TRACEPOINT_EVENT(lttng_statedump_block_device, - TP_PROTO(struct lttng_session *session, - dev_t dev, const char *diskname), - TP_ARGS(session, dev, diskname), - TP_FIELDS( - ctf_integer(dev_t, dev, dev) - ctf_string(diskname, diskname) - ) -) - -/* Called with desc->lock held */ -LTTNG_TRACEPOINT_EVENT(lttng_statedump_interrupt, - TP_PROTO(struct lttng_session *session, - unsigned int irq, const char *chip_name, - struct irqaction *action), - TP_ARGS(session, irq, chip_name, action), - TP_FIELDS( - ctf_integer(unsigned int, irq, irq) - ctf_string(name, chip_name) - ctf_string(action, action->name ? : "") - ctf_integer(pid_t, tid, action->thread ? action->thread->pid : 0) - ) -) - -#if defined(CONFIG_X86_32) || defined(CONFIG_X86_64) - -#define LTTNG_HAVE_STATEDUMP_CPU_TOPOLOGY - -LTTNG_TRACEPOINT_EVENT(lttng_statedump_cpu_topology, - TP_PROTO(struct lttng_session *session, struct cpuinfo_x86 *c), - TP_ARGS(session, c), - TP_FIELDS( - ctf_string(architecture, "x86") - ctf_integer(uint16_t, cpu_id, c->cpu_index) - ctf_string(vendor, c->x86_vendor_id[0] ? c->x86_vendor_id : "unknown") - ctf_integer(uint8_t, family, c->x86) - ctf_integer(uint8_t, model, c->x86_model) - ctf_string(model_name, c->x86_model_id[0] ? c->x86_model_id : "unknown") - ctf_integer(uint16_t, physical_id, c->phys_proc_id) - ctf_integer(uint16_t, core_id, c->cpu_core_id) - ctf_integer(uint16_t, cores, c->booted_cores) - ) -) -#endif /* CONFIG_X86_32 || CONFIG_X86_64 */ - -#endif /* LTTNG_TRACE_LTTNG_STATEDUMP_H */ - -/* This part must be outside protection */ -#include diff --git a/instrumentation/events/lttng-module/lttng-test.h b/instrumentation/events/lttng-module/lttng-test.h deleted file mode 100644 index 761fcf08..00000000 --- a/instrumentation/events/lttng-module/lttng-test.h +++ /dev/null @@ -1,57 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -#undef TRACE_SYSTEM -#define TRACE_SYSTEM lttng_test - -#if !defined(LTTNG_TRACE_LTTNG_TEST_H) || defined(TRACE_HEADER_MULTI_READ) -#define LTTNG_TRACE_LTTNG_TEST_H - -#include -#include - -LTTNG_TRACEPOINT_ENUM( - lttng_test_filter_event_enum, - TP_ENUM_VALUES( - ctf_enum_auto("AUTO: EXPECT 0") - ctf_enum_value("VALUE: 23", 23) - ctf_enum_value("VALUE: 27", 27) - ctf_enum_auto("AUTO: EXPECT 28") - ctf_enum_range("RANGE: 101 TO 303", 101, 303) - ctf_enum_auto("AUTO: EXPECT 304") - ) -) - -LTTNG_TRACEPOINT_EVENT(lttng_test_filter_event, - TP_PROTO(int anint, int netint, long *values, - char *text, size_t textlen, - char *etext, uint32_t * net_values), - TP_ARGS(anint, netint, values, text, textlen, etext, net_values), - TP_FIELDS( - ctf_integer(int, intfield, anint) - ctf_integer_hex(int, intfield2, anint) - ctf_integer(long, longfield, anint) - ctf_integer_network(int, netintfield, netint) - ctf_integer_network_hex(int, netintfieldhex, netint) - ctf_array(long, arrfield1, values, 3) - ctf_array_text(char, arrfield2, text, 10) - ctf_array_network(uint32_t, arrfield3, net_values, 3) - ctf_sequence(char, seqfield1, text, size_t, textlen) - ctf_sequence_text(char, seqfield2, text, size_t, textlen) - ctf_sequence_network(uint32_t, seqfield3, net_values, size_t, 3) - ctf_sequence(long, seqfield4, values, size_t, 3) - ctf_string(stringfield, text) - ctf_string(stringfield2, etext) - ctf_sequence_bitfield(long, bitfield_seq, values, uint8_t, 3) - ctf_array_bitfield(long, bitfield_array, values, 3) - ctf_enum(lttng_test_filter_event_enum, int, enum0, 0) - ctf_enum(lttng_test_filter_event_enum, int, enum23, 23) - ctf_enum(lttng_test_filter_event_enum, int, enum27, 27) - ctf_enum(lttng_test_filter_event_enum, int, enum28, 28) - ctf_enum(lttng_test_filter_event_enum, int, enum202, 202) - ctf_enum(lttng_test_filter_event_enum, int, enum304, 304) - ) -) - -#endif /* LTTNG_TRACE_LTTNG_TEST_H */ - -/* This part must be outside protection */ -#include diff --git a/instrumentation/events/lttng-module/lttng.h b/instrumentation/events/lttng-module/lttng.h deleted file mode 100644 index 376fd537..00000000 --- a/instrumentation/events/lttng-module/lttng.h +++ /dev/null @@ -1,21 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -#undef TRACE_SYSTEM -#define TRACE_SYSTEM lttng - -#if !defined(LTTNG_TRACE_LTTNG_H) || defined(TRACE_HEADER_MULTI_READ) -#define LTTNG_TRACE_LTTNG_H - -#include - -LTTNG_TRACEPOINT_EVENT(lttng_logger, - TP_PROTO(const char __user *text, size_t len), - TP_ARGS(text, len), - TP_FIELDS( - ctf_user_sequence_text(char, msg, text, size_t, len) - ) -) - -#endif /* LTTNG_TRACE_LTTNG_H */ - -/* This part must be outside protection */ -#include diff --git a/instrumentation/events/lttng-module/mm_vmscan.h b/instrumentation/events/lttng-module/mm_vmscan.h deleted file mode 100644 index a589eb65..00000000 --- a/instrumentation/events/lttng-module/mm_vmscan.h +++ /dev/null @@ -1,247 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -#undef TRACE_SYSTEM -#define TRACE_SYSTEM mm_vmscan - -#if !defined(LTTNG_TRACE_MM_VMSCAN_H) || defined(TRACE_HEADER_MULTI_READ) -#define LTTNG_TRACE_MM_VMSCAN_H - -#include -#include -#include -#include - -#ifndef _TRACE_VMSCAN_DEF -#define _TRACE_VMSCAN_DEF -#define RECLAIM_WB_ANON 0x0001u -#define RECLAIM_WB_FILE 0x0002u -#define RECLAIM_WB_MIXED 0x0010u -#define RECLAIM_WB_SYNC 0x0004u /* Unused, all reclaim async */ -#define RECLAIM_WB_ASYNC 0x0008u -#endif - -#include - -#define trace_reclaim_flags(file) ( \ - (file ? RECLAIM_WB_FILE : RECLAIM_WB_ANON) | \ - (RECLAIM_WB_ASYNC) \ - ) - -LTTNG_TRACEPOINT_EVENT(mm_vmscan_kswapd_sleep, - - TP_PROTO(int nid), - - TP_ARGS(nid), - - TP_FIELDS( - ctf_integer(int, nid, nid) - ) -) - -LTTNG_TRACEPOINT_EVENT(mm_vmscan_kswapd_wake, - - TP_PROTO(int nid, int zid, int order), - - TP_ARGS(nid, zid, order), - - TP_FIELDS( - ctf_integer(int, nid, nid) - ctf_integer(int, zid, zid) - ctf_integer(int, order, order) - ) -) - -LTTNG_TRACEPOINT_EVENT(mm_vmscan_wakeup_kswapd, - - TP_PROTO(int nid, int zid, int order, gfp_t gfp_flags), - - TP_ARGS(nid, zid, order, gfp_flags), - - TP_FIELDS( - ctf_integer(int, nid, nid) - ctf_integer(int, zid, zid) - ctf_integer(int, order, order) - ctf_integer(gfp_t, gfp_flags, gfp_flags) - ) -) - -LTTNG_TRACEPOINT_EVENT_CLASS(mm_vmscan_direct_reclaim_begin_template, - - TP_PROTO(int order, gfp_t gfp_flags), - - TP_ARGS(order, gfp_flags), - - TP_FIELDS( - ctf_integer(int, order, order) - ctf_integer(gfp_t, gfp_flags, gfp_flags) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(mm_vmscan_direct_reclaim_begin_template, mm_vmscan_direct_reclaim_begin, - - TP_PROTO(int order, gfp_t gfp_flags), - - TP_ARGS(order, gfp_flags) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(mm_vmscan_direct_reclaim_begin_template, mm_vmscan_memcg_reclaim_begin, - - TP_PROTO(int order, gfp_t gfp_flags), - - TP_ARGS(order, gfp_flags) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(mm_vmscan_direct_reclaim_begin_template, mm_vmscan_memcg_softlimit_reclaim_begin, - - TP_PROTO(int order, gfp_t gfp_flags), - - TP_ARGS(order, gfp_flags) -) - -LTTNG_TRACEPOINT_EVENT_CLASS(mm_vmscan_direct_reclaim_end_template, - - TP_PROTO(unsigned long nr_reclaimed), - - TP_ARGS(nr_reclaimed), - - TP_FIELDS( - ctf_integer(unsigned long, nr_reclaimed, nr_reclaimed) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(mm_vmscan_direct_reclaim_end_template, mm_vmscan_direct_reclaim_end, - - TP_PROTO(unsigned long nr_reclaimed), - - TP_ARGS(nr_reclaimed) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(mm_vmscan_direct_reclaim_end_template, mm_vmscan_memcg_reclaim_end, - - TP_PROTO(unsigned long nr_reclaimed), - - TP_ARGS(nr_reclaimed) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(mm_vmscan_direct_reclaim_end_template, mm_vmscan_memcg_softlimit_reclaim_end, - - TP_PROTO(unsigned long nr_reclaimed), - - TP_ARGS(nr_reclaimed) -) - -LTTNG_TRACEPOINT_EVENT_MAP(mm_shrink_slab_start, - - mm_vmscan_shrink_slab_start, - - TP_PROTO(struct shrinker *shr, struct shrink_control *sc, - long nr_objects_to_shrink, unsigned long cache_items, - unsigned long long delta, unsigned long total_scan, - int priority), - - TP_ARGS(shr, sc, nr_objects_to_shrink, cache_items, delta, total_scan, - priority), - - TP_FIELDS( - ctf_integer_hex(struct shrinker *, shr, shr) - ctf_integer_hex(void *, shrink, shr->scan_objects) - ctf_integer(int, nid, sc->nid) - ctf_integer(long, nr_objects_to_shrink, nr_objects_to_shrink) - ctf_integer(gfp_t, gfp_flags, sc->gfp_mask) - ctf_integer(unsigned long, cache_items, cache_items) - ctf_integer(unsigned long long, delta, delta) - ctf_integer(unsigned long, total_scan, total_scan) - ctf_integer(int, priority, priority) - ) -) - -LTTNG_TRACEPOINT_EVENT_MAP(mm_shrink_slab_end, - - mm_vmscan_shrink_slab_end, - - TP_PROTO(struct shrinker *shr, int nid, int shrinker_retval, - long unused_scan_cnt, long new_scan_cnt, long total_scan), - - TP_ARGS(shr, nid, shrinker_retval, unused_scan_cnt, new_scan_cnt, - total_scan), - - TP_FIELDS( - ctf_integer_hex(struct shrinker *, shr, shr) - ctf_integer(int, nid, nid) - ctf_integer_hex(void *, shrink, shr->scan_objects) - ctf_integer(long, unused_scan, unused_scan_cnt) - ctf_integer(long, new_scan, new_scan_cnt) - ctf_integer(int, retval, shrinker_retval) - ctf_integer(long, total_scan, total_scan) - ) -) - -LTTNG_TRACEPOINT_EVENT(mm_vmscan_lru_isolate, - - TP_PROTO(int classzone_idx, - int order, - unsigned long nr_requested, - unsigned long nr_scanned, - unsigned long nr_skipped, - unsigned long nr_taken, - isolate_mode_t isolate_mode, - int lru - ), - - TP_ARGS(classzone_idx, order, nr_requested, nr_scanned, nr_skipped, - nr_taken, isolate_mode, lru - ), - - TP_FIELDS( - ctf_integer(int, classzone_idx, classzone_idx) - ctf_integer(int, order, order) - ctf_integer(unsigned long, nr_requested, nr_requested) - ctf_integer(unsigned long, nr_scanned, nr_scanned) - ctf_integer(unsigned long, nr_skipped, nr_skipped) - ctf_integer(unsigned long, nr_taken, nr_taken) - ctf_integer(isolate_mode_t, isolate_mode, isolate_mode) - ctf_integer(int, lru, lru) - ) -) - -LTTNG_TRACEPOINT_EVENT(mm_vmscan_writepage, - - TP_PROTO(struct page *page), - - TP_ARGS(page), - - TP_FIELDS( - ctf_integer_hex(struct page *, page, page) - ctf_integer(int, reclaim_flags, trace_reclaim_flags( - page_is_file_lru(page))) - ) -) - -LTTNG_TRACEPOINT_EVENT(mm_vmscan_lru_shrink_inactive, - - TP_PROTO(int nid, - unsigned long nr_scanned, unsigned long nr_reclaimed, - struct reclaim_stat *stat, int priority, int file), - - TP_ARGS(nid, nr_scanned, nr_reclaimed, stat, priority, file), - - TP_FIELDS( - ctf_integer(int, nid, nid) - ctf_integer(unsigned long, nr_scanned, nr_scanned) - ctf_integer(unsigned long, nr_reclaimed, nr_reclaimed) - ctf_integer(unsigned long, nr_dirty, stat->nr_dirty) - ctf_integer(unsigned long, nr_writeback, stat->nr_writeback) - ctf_integer(unsigned long, nr_congested, stat->nr_congested) - ctf_integer(unsigned long, nr_immediate, stat->nr_immediate) - ctf_integer(unsigned long, nr_activate_anon, stat->nr_activate[0]) - ctf_integer(unsigned long, nr_activate_file, stat->nr_activate[1]) - ctf_integer(unsigned long, nr_ref_keep, stat->nr_ref_keep) - ctf_integer(unsigned long, nr_unmap_fail, stat->nr_unmap_fail) - ctf_integer(int, priority, priority) - ctf_integer(int, reclaim_flags, trace_reclaim_flags(file)) - ) -) - -#endif /* LTTNG_TRACE_MM_VMSCAN_H */ - -/* This part must be outside protection */ -#include diff --git a/instrumentation/events/lttng-module/module.h b/instrumentation/events/lttng-module/module.h deleted file mode 100644 index 5299e17f..00000000 --- a/instrumentation/events/lttng-module/module.h +++ /dev/null @@ -1,100 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -/* - * Because linux/module.h has tracepoints in the header, and ftrace.h - * eventually includes this file, define_trace.h includes linux/module.h - * But we do not want the module.h to override the TRACE_SYSTEM macro - * variable that define_trace.h is processing, so we only set it - * when module events are being processed, which would happen when - * CREATE_TRACE_POINTS is defined. - */ -#ifdef CREATE_TRACE_POINTS -#undef TRACE_SYSTEM -#define TRACE_SYSTEM module -#endif - -#if !defined(LTTNG_TRACE_MODULE_H) || defined(TRACE_HEADER_MULTI_READ) -#define LTTNG_TRACE_MODULE_H - -#include - -#ifdef CONFIG_MODULES - -#ifndef _TRACE_MODULE_DEF -#define _TRACE_MODULE_DEF -struct module; - -#endif - -LTTNG_TRACEPOINT_EVENT(module_load, - - TP_PROTO(struct module *mod), - - TP_ARGS(mod), - - TP_FIELDS( - ctf_integer(unsigned int, taints, mod->taints) - ctf_string(name, mod->name) - ) -) - -LTTNG_TRACEPOINT_EVENT(module_free, - - TP_PROTO(struct module *mod), - - TP_ARGS(mod), - - TP_FIELDS( - ctf_string(name, mod->name) - ) -) - -#ifdef CONFIG_MODULE_UNLOAD -/* trace_module_get/put are only used if CONFIG_MODULE_UNLOAD is defined */ - -LTTNG_TRACEPOINT_EVENT_CLASS(module_refcnt, - - TP_PROTO(struct module *mod, unsigned long ip), - - TP_ARGS(mod, ip), - - TP_FIELDS( - ctf_integer_hex(unsigned long, ip, ip) - ctf_integer(int, refcnt, atomic_read(&mod->refcnt)) - ctf_string(name, mod->name) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(module_refcnt, module_get, - - TP_PROTO(struct module *mod, unsigned long ip), - - TP_ARGS(mod, ip) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(module_refcnt, module_put, - - TP_PROTO(struct module *mod, unsigned long ip), - - TP_ARGS(mod, ip) -) -#endif /* CONFIG_MODULE_UNLOAD */ - -LTTNG_TRACEPOINT_EVENT(module_request, - - TP_PROTO(char *name, bool wait, unsigned long ip), - - TP_ARGS(name, wait, ip), - - TP_FIELDS( - ctf_integer_hex(unsigned long, ip, ip) - ctf_integer(bool, wait, wait) - ctf_string(name, name) - ) -) - -#endif /* CONFIG_MODULES */ - -#endif /* LTTNG_TRACE_MODULE_H */ - -/* This part must be outside protection */ -#include diff --git a/instrumentation/events/lttng-module/napi.h b/instrumentation/events/lttng-module/napi.h deleted file mode 100644 index 4bb76f7f..00000000 --- a/instrumentation/events/lttng-module/napi.h +++ /dev/null @@ -1,33 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -#undef TRACE_SYSTEM -#define TRACE_SYSTEM napi - -#if !defined(LTTNG_TRACE_NAPI_H) || defined(TRACE_HEADER_MULTI_READ) -#define LTTNG_TRACE_NAPI_H - -#include -#include -#include - -#define NO_DEV "(no_device)" - -LTTNG_TRACEPOINT_EVENT(napi_poll, - - TP_PROTO(struct napi_struct *napi, int work, int budget), - - TP_ARGS(napi, work, budget), - - TP_FIELDS( - ctf_integer_hex(struct napi_struct *, napi, napi) - ctf_string(dev_name, napi->dev ? napi->dev->name : NO_DEV) - ctf_integer(int, work, work) - ctf_integer(int, budget, budget) - ) -) - -#undef NO_DEV - -#endif /* LTTNG_TRACE_NAPI_H */ - -/* This part must be outside protection */ -#include diff --git a/instrumentation/events/lttng-module/net.h b/instrumentation/events/lttng-module/net.h deleted file mode 100644 index 40acebf8..00000000 --- a/instrumentation/events/lttng-module/net.h +++ /dev/null @@ -1,858 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -#undef TRACE_SYSTEM -#define TRACE_SYSTEM net - -#if !defined(LTTNG_TRACE_NET_H) || defined(TRACE_HEADER_MULTI_READ) -#define LTTNG_TRACE_NET_H - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#ifndef ONCE_LTTNG_NET_H -#define ONCE_LTTNG_NET_H - -static inline unsigned char __has_network_hdr(struct sk_buff *skb) -{ - /* - * If the header is not set yet, the network header will point - * to the head. - */ - return skb_network_header(skb) != skb->head; -} - -static struct lttng_event_field emptyfields[] = { -}; - -/* Structures for transport headers. */ - -static struct lttng_event_field tcpfields[] = { - [0] = { - .name = "source_port", - .type = __type_integer(uint16_t, 0, 0, 0, - __BIG_ENDIAN, 10, none), - }, - [1] = { - .name = "dest_port", - .type = __type_integer(uint16_t, 0, 0, 0, - __BIG_ENDIAN, 10, none), - }, - [2] = { - .name = "seq", - .type = __type_integer(uint32_t, 0, 0, 0, - __BIG_ENDIAN, 10, none), - }, - [3] = { - .name = "ack_seq", - .type = __type_integer(uint32_t, 0, 0, 0, - __BIG_ENDIAN, 10, none), - }, - [4] = { - .name = "data_offset", - .type = __type_integer(uint8_t, 4, 4, 0, - __BIG_ENDIAN, 10, none), - }, - [5] = { - .name = "reserved", - .type = __type_integer(uint8_t, 3, 1, 0, - __BIG_ENDIAN, 10, none), - }, - [6] = { - .name = "flags", - .type = __type_integer(uint8_t, 9, 1, 0, - __BIG_ENDIAN, 16, none), - }, - [7] = { - .name = "window_size", - .type = __type_integer(uint16_t, 0, 0, 0, - __BIG_ENDIAN, 10, none), - }, - [8] = { - .name = "checksum", - .type = __type_integer(uint16_t, 0, 0, 0, - __BIG_ENDIAN, 16, none), - }, - [9] = { - .name = "urg_ptr", - .type = __type_integer(uint16_t, 0, 0, 0, - __BIG_ENDIAN, 10, none), - }, -}; - -static struct lttng_event_field udpfields[] = { - [0] = { - .name = "source_port", - .type = __type_integer(uint16_t, 0, 0, 0, - __BIG_ENDIAN, 10, none), - }, - [1] = { - .name = "dest_port", - .type = __type_integer(uint16_t, 0, 0, 0, - __BIG_ENDIAN, 10, none), - }, - [2] = { - .name = "len", - .type = __type_integer(uint16_t, 0, 0, 0, - __BIG_ENDIAN, 10, none), - }, - [3] = { - .name = "check", - .type = __type_integer(uint16_t, 0, 0, 0, - __BIG_ENDIAN, 10, none), - }, -}; - -static struct lttng_event_field icmpfields[] = { - [0] = { - .name = "type", - .type = __type_integer(uint8_t, 0, 0, 0, - __BIG_ENDIAN, 10, none), - }, - [1] = { - .name = "code", - .type = __type_integer(uint8_t, 0, 0, 0, - __BIG_ENDIAN, 10, none), - }, - [2] = { - .name = "checksum", - .type = __type_integer(uint16_t, 0, 0, 0, - __BIG_ENDIAN, 10, none), - }, - [3] = { - .name = "gateway", - .type = __type_integer(uint32_t, 0, 0, 0, - __BIG_ENDIAN, 10, none), - }, -}; - - -static struct lttng_event_field transport_fields[] = { - [0] = { - .name = "unknown", - .type = { - .atype = atype_struct_nestable, - .u.struct_nestable.nr_fields = ARRAY_SIZE(emptyfields), - .u.struct_nestable.fields = emptyfields, - .u.struct_nestable.alignment = 0, - }, - .nofilter = 1, - }, - [1] = { - .name = "tcp", - .type = { - .atype = atype_struct_nestable, - .u.struct_nestable.nr_fields = ARRAY_SIZE(tcpfields), - .u.struct_nestable.fields = tcpfields, - .u.struct_nestable.alignment = 0, - }, - .nofilter = 1, - }, - [2] = { - .name = "udp", - .type = { - .atype = atype_struct_nestable, - .u.struct_nestable.nr_fields = ARRAY_SIZE(udpfields), - .u.struct_nestable.fields = udpfields, - .u.struct_nestable.alignment = 0, - }, - .nofilter = 1, - }, - [3] = { - .name = "icmp", - .type = { - .atype = atype_struct_nestable, - .u.struct_nestable.nr_fields = ARRAY_SIZE(icmpfields), - .u.struct_nestable.fields = icmpfields, - .u.struct_nestable.alignment = 0, - }, - .nofilter = 1, - }, -}; - -enum transport_header_types { - TH_NONE = 0, - TH_TCP = 1, - TH_UDP = 2, - TH_ICMP = 3, -}; - -static inline enum transport_header_types __get_transport_header_type_ip(struct sk_buff *skb) -{ - switch (ip_hdr(skb)->protocol) { - case IPPROTO_TCP: - return TH_TCP; - case IPPROTO_UDP: - return TH_UDP; - case IPPROTO_ICMP: - return TH_ICMP; - } - return TH_NONE; -} - -static inline enum transport_header_types __get_transport_header_type_ipv6(struct sk_buff *skb) -{ - switch (ipv6_hdr(skb)->nexthdr) { - case IPPROTO_TCP: - return TH_TCP; - case IPPROTO_UDP: - return TH_UDP; - case IPPROTO_ICMP: - return TH_ICMP; - } - return TH_NONE; -} - -static inline enum transport_header_types __get_transport_header_type(struct sk_buff *skb) -{ - if (__has_network_hdr(skb)) { - /* - * When both transport and network headers are set, - * transport header is greater than network header, - * otherwise it points to head. - */ - if (skb->transport_header > skb->network_header) { - /* - * Get the transport protocol from the network - * header's data. This method works both for - * sent and received packets. - */ - if (skb->protocol == htons(ETH_P_IP)) { - return __get_transport_header_type_ip(skb); - } else if(skb->protocol == htons(ETH_P_IPV6)) { - return __get_transport_header_type_ipv6(skb); - } - } - /* Fallthrough for other cases where header is not recognized. */ - } - return TH_NONE; -} - -static struct lttng_enum_entry proto_transport_enum_entries[] = { - [0] = { - .start = { .value = 0, .signedness = 0, }, - .end = { .value = IPPROTO_ICMP - 1, .signedness = 0, }, - .string = "_unknown", - }, - [1] = { - .start = { .value = IPPROTO_ICMP, .signedness = 0, }, - .end = { .value = IPPROTO_ICMP, .signedness = 0, }, - .string = "_icmp", - }, - [2] = { - .start = { .value = IPPROTO_ICMP + 1, .signedness = 0, }, - .end = { .value = IPPROTO_TCP - 1, .signedness = 0, }, - .string = "_unknown", - }, - [3] = { - .start = { .value = IPPROTO_TCP, .signedness = 0, }, - .end = { .value = IPPROTO_TCP, .signedness = 0, }, - .string = "_tcp", - }, - [4] = { - .start = { .value = IPPROTO_TCP + 1, .signedness = 0, }, - .end = { .value = IPPROTO_UDP - 1, .signedness = 0, }, - .string = "_unknown", - }, - [5] = { - .start = { .value = IPPROTO_UDP, .signedness = 0, }, - .end = { .value = IPPROTO_UDP, .signedness = 0, }, - .string = "_udp", - }, - [6] = { - .start = { .value = IPPROTO_UDP + 1, .signedness = 0, }, - .end = { .value = 255, .signedness = 0, }, - .string = "_unknown", - }, -}; - -static const struct lttng_enum_desc proto_transport_header_type = { - .name = "proto_transport_header_type", - .entries = proto_transport_enum_entries, - .nr_entries = ARRAY_SIZE(proto_transport_enum_entries), -}; - -static struct lttng_enum_entry transport_enum_entries[] = { - [0] = { - .start = { .value = TH_NONE, .signedness = 0, }, - .end = { .value = TH_NONE, .signedness = 0, }, - .string = "_unknown", - }, - [1] = { - .start = { .value = TH_TCP, .signedness = 0, }, - .end = { .value = TH_TCP, .signedness = 0, }, - .string = "_tcp", - }, - [2] = { - .start = { .value = TH_UDP, .signedness = 0, }, - .end = { .value = TH_UDP, .signedness = 0, }, - .string = "_udp", - }, - [3] = { - .start = { .value = TH_ICMP, .signedness = 0, }, - .end = { .value = TH_ICMP, .signedness = 0, }, - .string = "_icmp", - }, -}; - -static const struct lttng_enum_desc transport_header_type = { - .name = "transport_header_type", - .entries = transport_enum_entries, - .nr_entries = ARRAY_SIZE(transport_enum_entries), -}; - -/* Structures for network headers. */ - -static struct lttng_event_field ipv4fields[] = { - [0] = { - .name = "version", - .type = __type_integer(uint8_t, 4, 4, 0, - __BIG_ENDIAN, 10, none), - }, - [1] = { - .name = "ihl", - .type = __type_integer(uint8_t, 4, 4, 0, - __BIG_ENDIAN, 10, none), - }, - [2] = { - .name = "tos", - .type = __type_integer(uint8_t, 0, 0, 0, - __BIG_ENDIAN, 10, none), - }, - [3] = { - .name = "tot_len", - .type = __type_integer(uint16_t, 0, 0, 0, - __BIG_ENDIAN, 10, none), - }, - [4] = { - .name = "id", - .type = __type_integer(uint16_t, 0, 0, 0, - __BIG_ENDIAN, 16, none), - }, - [5] = { - .name = "frag_off", - .type = __type_integer(uint16_t, 0, 0, 0, - __BIG_ENDIAN, 10, none), - }, - [6] = { - .name = "ttl", - .type = __type_integer(uint8_t, 0, 0, 0, - __BIG_ENDIAN, 10, none), - }, - [7] = { - .name = "protocol", - .type = { - .atype = atype_enum_nestable, - .u.enum_nestable.desc = - &proto_transport_header_type, - .u.enum_nestable.container_type = - __LTTNG_COMPOUND_LITERAL(struct lttng_type, - __type_integer(uint8_t, 0, 0, -1, - __BIG_ENDIAN, 10, none)), - }, - }, - [8] = { - .name = "checksum", - .type = __type_integer(uint16_t, 0, 0, 0, - __BIG_ENDIAN, 16, none), - }, - [9] = { - .name = "saddr", - .type = { - .atype = atype_array_nestable, - .u.array_nestable.elem_type = - __LTTNG_COMPOUND_LITERAL(struct lttng_type, - __type_integer(uint8_t, 0, 0, 0, - __BIG_ENDIAN, 10, none)), - .u.array_nestable.length = 4, - .u.array_nestable.alignment = lttng_alignof(uint8_t), - }, - }, - [10] = { - .name = "daddr", - .type = { - .atype = atype_array_nestable, - .u.array_nestable.elem_type = - __LTTNG_COMPOUND_LITERAL(struct lttng_type, - __type_integer(uint8_t, 0, 0, 0, - __BIG_ENDIAN, 10, none)), - .u.array_nestable.length = 4, - .u.array_nestable.alignment = lttng_alignof(uint8_t), - }, - }, - [11] = { - .name = "transport_header_type", - .type = { - .atype = atype_enum_nestable, - .u.enum_nestable.desc = &transport_header_type, - .u.enum_nestable.container_type = - __LTTNG_COMPOUND_LITERAL(struct lttng_type, - __type_integer(uint8_t, 0, 0, -1, - __BYTE_ORDER, 10, none)), - }, - }, - [12] = { - .name = "transport_header", - .type = { - .atype = atype_variant_nestable, - .u.variant_nestable.tag_name = "transport_header_type", - .u.variant_nestable.choices = transport_fields, - .u.variant_nestable.nr_choices = ARRAY_SIZE(transport_fields), - .u.variant_nestable.alignment = 0, - }, - }, -}; - -static struct lttng_event_field ipv6fields[] = { - [0] = { - .name = "version", - .type = __type_integer(uint8_t, 4, 4, 0, - __BIG_ENDIAN, 10, none), - }, - [1] = { - .name = "prio", - .type = __type_integer(uint8_t, 4, 4, 0, - __BIG_ENDIAN, 10, none), - }, - [2] = { - .name = "flow_lbl", - .type = { - .atype = atype_array_nestable, - .u.array_nestable.elem_type = - __LTTNG_COMPOUND_LITERAL(struct lttng_type, - __type_integer(uint8_t, 0, 0, 0, - __BIG_ENDIAN, 16, none)), - .u.array_nestable.length = 3, - .u.array_nestable.alignment = lttng_alignof(uint8_t), - }, - }, - [3] = { - .name = "payload_len", - .type = __type_integer(uint16_t, 0, 0, 0, - __BIG_ENDIAN, 10, none), - }, - [4] = { - .name = "nexthdr", - .type = { - .atype = atype_enum_nestable, - .u.enum_nestable.desc = - &proto_transport_header_type, - .u.enum_nestable.container_type = - __LTTNG_COMPOUND_LITERAL(struct lttng_type, - __type_integer(uint8_t, 0, 0, -1, - __BIG_ENDIAN, 10, none)), - }, - }, - [5] = { - .name = "hop_limit", - .type = __type_integer(uint8_t, 0, 0, 0, - __BIG_ENDIAN, 10, none), - }, - [6] = { - .name = "saddr", - .type = { - .atype = atype_array_nestable, - .u.array_nestable.elem_type = - __LTTNG_COMPOUND_LITERAL(struct lttng_type, - __type_integer(uint16_t, 0, 0, 0, - __BIG_ENDIAN, 16, none)), - .u.array_nestable.length = 8, - .u.array_nestable.alignment = lttng_alignof(uint16_t), - }, - }, - [7] = { - .name = "daddr", - .type = { - .atype = atype_array_nestable, - .u.array_nestable.elem_type = - __LTTNG_COMPOUND_LITERAL(struct lttng_type, - __type_integer(uint16_t, 0, 0, 0, - __BIG_ENDIAN, 16, none)), - .u.array_nestable.length = 8, - .u.array_nestable.alignment = lttng_alignof(uint16_t), - }, - }, - [8] = { - .name = "transport_header_type", - .type = { - .atype = atype_enum_nestable, - .u.enum_nestable.desc = &transport_header_type, - .u.enum_nestable.container_type = - __LTTNG_COMPOUND_LITERAL(struct lttng_type, - __type_integer(uint8_t, 0, 0, -1, - __BYTE_ORDER, 10, none)), - }, - }, - [9] = { - .name = "transport_header", - .type = { - .atype = atype_variant_nestable, - .u.variant_nestable.tag_name = "transport_header_type", - .u.variant_nestable.choices = transport_fields, - .u.variant_nestable.nr_choices = ARRAY_SIZE(transport_fields), - .u.variant_nestable.alignment = 0, - }, - }, -}; - -static struct lttng_event_field network_fields[] = { - [0] = { - .name = "unknown", - .type = { - .atype = atype_struct_nestable, - .u.struct_nestable.nr_fields = 0, - .u.struct_nestable.fields = emptyfields, - .u.struct_nestable.alignment = 0, - }, - }, - [1] = { - .name = "ipv4", - .type = { - .atype = atype_struct_nestable, - .u.struct_nestable.nr_fields = ARRAY_SIZE(ipv4fields), - .u.struct_nestable.fields = ipv4fields, - .u.struct_nestable.alignment = 0, - }, - }, - [2] = { - .name = "ipv6", - .type = { - .atype = atype_struct_nestable, - .u.struct_nestable.nr_fields = ARRAY_SIZE(ipv6fields), - .u.struct_nestable.fields = ipv6fields, - .u.struct_nestable.alignment = 0, - }, - }, -}; - -enum network_header_types { - NH_NONE, - NH_IPV4, - NH_IPV6, -}; - -static inline unsigned char __get_network_header_type(struct sk_buff *skb) -{ - if (__has_network_hdr(skb)) { - if (skb->protocol == htons(ETH_P_IPV6)) - return NH_IPV6; - else if (skb->protocol == htons(ETH_P_IP)) - return NH_IPV4; - /* Fallthrough for other header types. */ - } - return NH_NONE; -} - -#endif - -LTTNG_TRACEPOINT_ENUM(net_network_header, - TP_ENUM_VALUES( - ctf_enum_value("_unknown", NH_NONE) - ctf_enum_value("_ipv4", NH_IPV4) - ctf_enum_value("_ipv6", NH_IPV6) - ) -) - -LTTNG_TRACEPOINT_EVENT(net_dev_xmit, - - TP_PROTO(struct sk_buff *skb, - int rc, - struct net_device *dev, - unsigned int skb_len), - - TP_ARGS(skb, rc, dev, skb_len), - - TP_FIELDS( - ctf_integer_hex(void *, skbaddr, skb) - ctf_integer(int, rc, rc) - ctf_integer(unsigned int, len, skb_len) - ctf_string(name, dev->name) - ) -) - -LTTNG_TRACEPOINT_EVENT_CLASS(net_dev_template, - - TP_PROTO(struct sk_buff *skb), - - TP_ARGS(skb), - - TP_FIELDS( - ctf_integer_hex(void *, skbaddr, skb) - ctf_integer(unsigned int, len, skb->len) - ctf_string(name, skb->dev->name) - ctf_enum(net_network_header, unsigned char, - network_header_type, __get_network_header_type(skb)) - ctf_custom_field( - ctf_custom_type( - { - .atype = atype_variant_nestable, - .u.variant_nestable.tag_name = "network_header_type", - .u.variant_nestable.choices = network_fields, - .u.variant_nestable.nr_choices = - ARRAY_SIZE(network_fields), - .u.variant_nestable.alignment = 0, - } - ), - network_header, - ctf_custom_code( - bool has_network_header = false; - - /* Copy the network header. */ - switch (__get_network_header_type(skb)) { - case NH_IPV4: { - ctf_align(uint16_t) - ctf_array_type(uint8_t, ip_hdr(skb), - sizeof(struct iphdr)) - has_network_header = true; - break; - } - case NH_IPV6: { - ctf_align(uint16_t) - ctf_array_type(uint8_t, ipv6_hdr(skb), - sizeof(struct ipv6hdr)) - has_network_header = true; - break; - } - default: - /* - * For any other network header - * type, there is nothing to do. - */ - break; - } - - if (has_network_header) { - enum transport_header_types th_type = - __get_transport_header_type(skb); - - /* Transport header type field. */ - ctf_integer_type(unsigned char, th_type) - - /* Copy the transport header. */ - switch (th_type) { - case TH_TCP: { - ctf_align(uint32_t) - ctf_array_type(uint8_t, tcp_hdr(skb), - sizeof(struct tcphdr)) - break; - } - case TH_UDP: { - ctf_align(uint32_t) - ctf_array_type(uint8_t, udp_hdr(skb), - sizeof(struct udphdr)) - break; - } - case TH_ICMP: { - ctf_align(uint32_t) - ctf_array_type(uint8_t, icmp_hdr(skb), - sizeof(struct icmphdr)) - break; - } - default: - /* - * For any other transport header type, - * there is nothing to do. - */ - break; - } - } - ) - ) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(net_dev_template, net_dev_queue, - - TP_PROTO(struct sk_buff *skb), - - TP_ARGS(skb) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_template, - - netif_receive_skb, - - net_if_receive_skb, - - TP_PROTO(struct sk_buff *skb), - - TP_ARGS(skb) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_template, - - netif_rx, - - net_if_rx, - - TP_PROTO(struct sk_buff *skb), - - TP_ARGS(skb) -) - -/* Trace events for the receive entry points */ -LTTNG_TRACEPOINT_EVENT_CLASS(net_dev_receive_entry_template, - - TP_PROTO(const struct sk_buff *skb), - - TP_ARGS(skb), - - TP_FIELDS( - ctf_integer_hex(const void *, skbaddr, skb) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_receive_entry_template, - - napi_gro_frags_entry, - - net_napi_gro_frags_entry, - - TP_PROTO(const struct sk_buff *skb), - - TP_ARGS(skb) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_receive_entry_template, - - napi_gro_receive_entry, - - net_napi_gro_receive_entry, - - TP_PROTO(const struct sk_buff *skb), - - TP_ARGS(skb) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_receive_entry_template, - - netif_receive_skb_entry, - - net_if_receive_skb_entry, - - TP_PROTO(const struct sk_buff *skb), - - TP_ARGS(skb) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_receive_entry_template, - - netif_rx_entry, - - net_if_rx_entry, - - TP_PROTO(const struct sk_buff *skb), - - TP_ARGS(skb) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_receive_entry_template, - - netif_rx_ni_entry, - - net_if_rx_ni_entry, - - TP_PROTO(const struct sk_buff *skb), - - TP_ARGS(skb) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_receive_entry_template, - - netif_receive_skb_list_entry, - - net_if_receive_skb_list_entry, - - TP_PROTO(const struct sk_buff *skb), - - TP_ARGS(skb) -) - -/* Trace events for the receive exit points */ -LTTNG_TRACEPOINT_EVENT_CLASS(net_dev_receive_exit_template, - - TP_PROTO(int ret), - - TP_ARGS(ret), - - TP_FIELDS( - ctf_integer(int, ret, ret) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_receive_exit_template, - - napi_gro_frags_exit, - - net_napi_gro_frags_exit, - - TP_PROTO(int ret), - - TP_ARGS(ret) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_receive_exit_template, - - napi_gro_receive_exit, - - net_napi_gro_receive_exit, - - TP_PROTO(int ret), - - TP_ARGS(ret) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_receive_exit_template, - - netif_receive_skb_exit, - - net_if_receive_skb_exit, - - TP_PROTO(int ret), - - TP_ARGS(ret) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_receive_exit_template, - - netif_rx_exit, - - net_if_rx_exit, - - TP_PROTO(int ret), - - TP_ARGS(ret) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_receive_exit_template, - - netif_rx_ni_exit, - - net_if_rx_ni_exit, - - TP_PROTO(int ret), - - TP_ARGS(ret) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_receive_exit_template, - - netif_receive_skb_list_exit, - - net_if_receive_skb_list_exit, - - TP_PROTO(int ret), - - TP_ARGS(ret) -) - -#endif /* LTTNG_TRACE_NET_H */ - -/* This part must be outside protection */ -#include diff --git a/instrumentation/events/lttng-module/power.h b/instrumentation/events/lttng-module/power.h deleted file mode 100644 index e9f56dc9..00000000 --- a/instrumentation/events/lttng-module/power.h +++ /dev/null @@ -1,161 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -#undef TRACE_SYSTEM -#define TRACE_SYSTEM power - -#if !defined(LTTNG_TRACE_POWER_H) || defined(TRACE_HEADER_MULTI_READ) -#define LTTNG_TRACE_POWER_H - -#include -#include - -LTTNG_TRACEPOINT_EVENT_CLASS(power_cpu, - - TP_PROTO(unsigned int state, unsigned int cpu_id), - - TP_ARGS(state, cpu_id), - - TP_FIELDS( - ctf_integer(u32, state, state) - ctf_integer(u32, cpu_id, cpu_id) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(power_cpu, cpu_idle, - - power_cpu_idle, - - TP_PROTO(unsigned int state, unsigned int cpu_id), - - TP_ARGS(state, cpu_id) -) - -/* This file can get included multiple times, TRACE_HEADER_MULTI_READ at top */ -#ifndef _PWR_EVENT_AVOID_DOUBLE_DEFINING -#define _PWR_EVENT_AVOID_DOUBLE_DEFINING - -#define PWR_EVENT_EXIT -1 -#endif - -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(power_cpu, cpu_frequency, - - power_cpu_frequency, - - TP_PROTO(unsigned int frequency, unsigned int cpu_id), - - TP_ARGS(frequency, cpu_id) -) - -LTTNG_TRACEPOINT_EVENT_MAP(machine_suspend, - - power_machine_suspend, - - TP_PROTO(unsigned int state), - - TP_ARGS(state), - - TP_FIELDS( - ctf_integer(u32, state, state) - ) -) - -LTTNG_TRACEPOINT_EVENT_CLASS(power_wakeup_source, - - TP_PROTO(const char *name, unsigned int state), - - TP_ARGS(name, state), - - TP_FIELDS( - ctf_string(name, name) - ctf_integer(u64, state, state) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(power_wakeup_source, wakeup_source_activate, - - power_wakeup_source_activate, - - TP_PROTO(const char *name, unsigned int state), - - TP_ARGS(name, state) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(power_wakeup_source, wakeup_source_deactivate, - - power_wakeup_source_deactivate, - - TP_PROTO(const char *name, unsigned int state), - - TP_ARGS(name, state) -) - -/* - * The clock events are used for clock enable/disable and for - * clock rate change - */ -LTTNG_TRACEPOINT_EVENT_CLASS(power_clock, - - TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id), - - TP_ARGS(name, state, cpu_id), - - TP_FIELDS( - ctf_string(name, name) - ctf_integer(u64, state, state) - ctf_integer(u64, cpu_id, cpu_id) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(power_clock, clock_enable, - - power_clock_enable, - - TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id), - - TP_ARGS(name, state, cpu_id) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(power_clock, clock_disable, - - power_clock_disable, - - TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id), - - TP_ARGS(name, state, cpu_id) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(power_clock, clock_set_rate, - - power_clock_set_rate, - - TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id), - - TP_ARGS(name, state, cpu_id) -) - -/* - * The power domain events are used for power domains transitions - */ -LTTNG_TRACEPOINT_EVENT_CLASS(power_domain, - - TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id), - - TP_ARGS(name, state, cpu_id), - - TP_FIELDS( - ctf_string(name, name) - ctf_integer(u64, state, state) - ctf_integer(u64, cpu_id, cpu_id) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(power_domain, power_domain_target, - - TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id), - - TP_ARGS(name, state, cpu_id) -) - -#endif /* LTTNG_TRACE_POWER_H */ - -/* This part must be outside protection */ -#include diff --git a/instrumentation/events/lttng-module/preemptirq.h b/instrumentation/events/lttng-module/preemptirq.h deleted file mode 100644 index b69868ed..00000000 --- a/instrumentation/events/lttng-module/preemptirq.h +++ /dev/null @@ -1,84 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -#ifdef CONFIG_PREEMPTIRQ_EVENTS - -#undef TRACE_SYSTEM -#define TRACE_SYSTEM preemptirq - -#if !defined(LTTNG_TRACE_PREEMPTIRQ_H) || defined(TRACE_HEADER_MULTI_READ) -#define LTTNG_TRACE_PREEMPTIRQ_H - -#include -#include -#include -#include - -/* - * The preemptirq probe is built when CONFIG_PREEMPTIRQ_EVENTS is defined. - */ - -LTTNG_TRACEPOINT_EVENT_CLASS(preemptirq_template, - - TP_PROTO(unsigned long ip, unsigned long parent_ip), - - TP_ARGS(ip, parent_ip), - - TP_FIELDS( - ctf_integer_hex(unsigned long, caller, ip) - ctf_integer_hex(unsigned long, parent, parent_ip) - ) -) - -#if defined(CONFIG_TRACE_IRQFLAGS) -#define LTTNG_TRACE_IRQ -#endif - -#ifdef LTTNG_TRACE_IRQ -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(preemptirq_template, irq_disable, - - preemptirq_irq_disable, - - TP_PROTO(unsigned long ip, unsigned long parent_ip), - - TP_ARGS(ip, parent_ip) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(preemptirq_template, irq_enable, - - preemptirq_irq_enable, - - TP_PROTO(unsigned long ip, unsigned long parent_ip), - - TP_ARGS(ip, parent_ip) -) -#endif /* LTTNG_TRACE_IRQ */ - -#if defined(CONFIG_TRACE_PREEMPT_TOGGLE) -#define LTTNG_TRACE_PREEMPT -#endif - -#ifdef LTTNG_TRACE_PREEMPT -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(preemptirq_template, preempt_disable, - - preemptirq_preempt_disable, - - TP_PROTO(unsigned long ip, unsigned long parent_ip), - - TP_ARGS(ip, parent_ip) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(preemptirq_template, preempt_enable, - - preemptirq_preempt_enable, - - TP_PROTO(unsigned long ip, unsigned long parent_ip), - - TP_ARGS(ip, parent_ip) -) -#endif /* LTTNG_TRACE_PREEMPT */ - -#endif /* LTTNG_TRACE_PREEMPTIRQ_H */ - -/* This part must be outside protection */ -#include - -#endif /* CONFIG_PREEMPTIRQ_EVENTS */ diff --git a/instrumentation/events/lttng-module/printk.h b/instrumentation/events/lttng-module/printk.h deleted file mode 100644 index 26b04a95..00000000 --- a/instrumentation/events/lttng-module/printk.h +++ /dev/null @@ -1,26 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -#undef TRACE_SYSTEM -#define TRACE_SYSTEM printk - -#if !defined(LTTNG_TRACE_PRINTK_H) || defined(TRACE_HEADER_MULTI_READ) -#define LTTNG_TRACE_PRINTK_H - -#include - -LTTNG_TRACEPOINT_EVENT_MAP(console, - - printk_console, - - TP_PROTO(const char *text, size_t len), - - TP_ARGS(text, len), - - TP_FIELDS( - ctf_sequence_text(char, msg, text, size_t, len) - ) -) - -#endif /* LTTNG_TRACE_PRINTK_H */ - -/* This part must be outside protection */ -#include diff --git a/instrumentation/events/lttng-module/random.h b/instrumentation/events/lttng-module/random.h deleted file mode 100644 index 3d980f90..00000000 --- a/instrumentation/events/lttng-module/random.h +++ /dev/null @@ -1,112 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -#undef TRACE_SYSTEM -#define TRACE_SYSTEM random - -#if !defined(LTTNG_TRACE_RANDOM_H) || defined(TRACE_HEADER_MULTI_READ) -#define LTTNG_TRACE_RANDOM_H - -#include -#include - -LTTNG_TRACEPOINT_EVENT_CLASS(random__mix_pool_bytes, - TP_PROTO(const char *pool_name, int bytes, unsigned long IP), - - TP_ARGS(pool_name, bytes, IP), - - TP_FIELDS( - ctf_string(pool_name, pool_name) - ctf_integer(int, bytes, bytes) - ctf_integer_hex(unsigned long, IP, IP) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(random__mix_pool_bytes, mix_pool_bytes, - - random_mix_pool_bytes, - - TP_PROTO(const char *pool_name, int bytes, unsigned long IP), - - TP_ARGS(pool_name, bytes, IP) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(random__mix_pool_bytes, mix_pool_bytes_nolock, - - random_mix_pool_bytes_nolock, - - TP_PROTO(const char *pool_name, int bytes, unsigned long IP), - - TP_ARGS(pool_name, bytes, IP) -) - -LTTNG_TRACEPOINT_EVENT_MAP(credit_entropy_bits, - - random_credit_entropy_bits, - - TP_PROTO(const char *pool_name, int bits, int entropy_count, - unsigned long IP), - - TP_ARGS(pool_name, bits, entropy_count, IP), - - TP_FIELDS( - ctf_string(pool_name, pool_name) - ctf_integer(int, bits, bits) - ctf_integer(int, entropy_count, entropy_count) - ctf_integer_hex(unsigned long, IP, IP) - ) -) - -LTTNG_TRACEPOINT_EVENT_MAP(get_random_bytes, - - random_get_random_bytes, - - TP_PROTO(int nbytes, unsigned long IP), - - TP_ARGS(nbytes, IP), - - TP_FIELDS( - ctf_integer(int, nbytes, nbytes) - ctf_integer_hex(unsigned long, IP, IP) - ) -) - -LTTNG_TRACEPOINT_EVENT_CLASS(random__extract_entropy, - TP_PROTO(const char *pool_name, int nbytes, int entropy_count, - unsigned long IP), - - TP_ARGS(pool_name, nbytes, entropy_count, IP), - - TP_FIELDS( - ctf_string(pool_name, pool_name) - ctf_integer(int, nbytes, nbytes) - ctf_integer(int, entropy_count, entropy_count) - ctf_integer_hex(unsigned long, IP, IP) - ) -) - - -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(random__extract_entropy, extract_entropy, - - random_extract_entropy, - - TP_PROTO(const char *pool_name, int nbytes, int entropy_count, - unsigned long IP), - - TP_ARGS(pool_name, nbytes, entropy_count, IP) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(random__extract_entropy, extract_entropy_user, - - random_extract_entropy_user, - - TP_PROTO(const char *pool_name, int nbytes, int entropy_count, - unsigned long IP), - - TP_ARGS(pool_name, nbytes, entropy_count, IP) -) - - - -#endif /* LTTNG_TRACE_RANDOM_H */ - -/* This part must be outside protection */ -#include diff --git a/instrumentation/events/lttng-module/rcu.h b/instrumentation/events/lttng-module/rcu.h deleted file mode 100644 index be4a074c..00000000 --- a/instrumentation/events/lttng-module/rcu.h +++ /dev/null @@ -1,445 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -#undef TRACE_SYSTEM -#define TRACE_SYSTEM rcu - -#if !defined(LTTNG_TRACE_RCU_H) || defined(TRACE_HEADER_MULTI_READ) -#define LTTNG_TRACE_RCU_H - -#include - -/* - * Tracepoint for start/end markers used for utilization calculations. - * By convention, the string is of the following forms: - * - * "Start " -- Mark the start of the specified activity, - * such as "context switch". Nesting is permitted. - * "End " -- Mark the end of the specified activity. - * - * An "@" character within "" is a comment character: Data - * reduction scripts will ignore the "@" and the remainder of the line. - */ -LTTNG_TRACEPOINT_EVENT(rcu_utilization, - - TP_PROTO(const char *s), - - TP_ARGS(s), - - TP_FIELDS( - ctf_string(s, s) - ) -) - -#ifdef CONFIG_RCU_TRACE - -#if defined(CONFIG_TREE_RCU) - -/* - * Tracepoint for grace-period events: starting and ending a grace - * period ("start" and "end", respectively), a CPU noting the start - * of a new grace period or the end of an old grace period ("cpustart" - * and "cpuend", respectively), a CPU passing through a quiescent - * state ("cpuqs"), a CPU coming online or going offline ("cpuonl" - * and "cpuofl", respectively), and a CPU being kicked for being too - * long in dyntick-idle mode ("kick"). - */ -LTTNG_TRACEPOINT_EVENT(rcu_grace_period, - - TP_PROTO(const char *rcuname, unsigned long gp_seq, const char *gpevent), - - TP_ARGS(rcuname, gp_seq, gpevent), - - TP_FIELDS( - ctf_string(rcuname, rcuname) - ctf_integer(unsigned long, gp_seq, gp_seq) - ctf_string(gpevent, gpevent) - ) -) - -/* - * Tracepoint for grace-period-initialization events. These are - * distinguished by the type of RCU, the new grace-period number, the - * rcu_node structure level, the starting and ending CPU covered by the - * rcu_node structure, and the mask of CPUs that will be waited for. - * All but the type of RCU are extracted from the rcu_node structure. - */ -LTTNG_TRACEPOINT_EVENT(rcu_grace_period_init, - - TP_PROTO(const char *rcuname, unsigned long gp_seq, u8 level, - int grplo, int grphi, unsigned long qsmask), - - TP_ARGS(rcuname, gp_seq, level, grplo, grphi, qsmask), - - TP_FIELDS( - ctf_string(rcuname, rcuname) - ctf_integer(unsigned long, gp_seq, gp_seq) - ctf_integer(u8, level, level) - ctf_integer(int, grplo, grplo) - ctf_integer(int, grphi, grphi) - ctf_integer(unsigned long, qsmask, qsmask) - ) -) - -/* - * Tracepoint for tasks blocking within preemptible-RCU read-side - * critical sections. Track the type of RCU (which one day might - * include SRCU), the grace-period number that the task is blocking - * (the current or the next), and the task's PID. - */ -LTTNG_TRACEPOINT_EVENT(rcu_preempt_task, - - TP_PROTO(const char *rcuname, int pid, unsigned long gp_seq), - - TP_ARGS(rcuname, pid, gp_seq), - - TP_FIELDS( - ctf_string(rcuname, rcuname) - ctf_integer(unsigned long, gp_seq, gp_seq) - ctf_integer(int, pid, pid) - ) -) - -/* - * Tracepoint for tasks that blocked within a given preemptible-RCU - * read-side critical section exiting that critical section. Track the - * type of RCU (which one day might include SRCU) and the task's PID. - */ -LTTNG_TRACEPOINT_EVENT(rcu_unlock_preempted_task, - - TP_PROTO(const char *rcuname, unsigned long gp_seq, int pid), - - TP_ARGS(rcuname, gp_seq, pid), - - TP_FIELDS( - ctf_string(rcuname, rcuname) - ctf_integer(unsigned long, gp_seq, gp_seq) - ctf_integer(int, pid, pid) - ) -) - -/* - * Tracepoint for quiescent-state-reporting events. These are - * distinguished by the type of RCU, the grace-period number, the - * mask of quiescent lower-level entities, the rcu_node structure level, - * the starting and ending CPU covered by the rcu_node structure, and - * whether there are any blocked tasks blocking the current grace period. - * All but the type of RCU are extracted from the rcu_node structure. - */ -LTTNG_TRACEPOINT_EVENT(rcu_quiescent_state_report, - - TP_PROTO(const char *rcuname, unsigned long gp_seq, - unsigned long mask, unsigned long qsmask, - u8 level, int grplo, int grphi, int gp_tasks), - - TP_ARGS(rcuname, gp_seq, mask, qsmask, level, grplo, grphi, gp_tasks), - - TP_FIELDS( - ctf_string(rcuname, rcuname) - ctf_integer(unsigned long, gp_seq, gp_seq) - ctf_integer(unsigned long, mask, mask) - ctf_integer(unsigned long, qsmask, qsmask) - ctf_integer(u8, level, level) - ctf_integer(int, grplo, grplo) - ctf_integer(int, grphi, grphi) - ctf_integer(u8, gp_tasks, gp_tasks) - ) -) - -/* - * Tracepoint for quiescent states detected by force_quiescent_state(). - * These trace events include the type of RCU, the grace-period number - * that was blocked by the CPU, the CPU itself, and the type of quiescent - * state, which can be "dti" for dyntick-idle mode, "ofl" for CPU offline, - * or "kick" when kicking a CPU that has been in dyntick-idle mode for - * too long. - */ -LTTNG_TRACEPOINT_EVENT(rcu_fqs, - - TP_PROTO(const char *rcuname, unsigned long gp_seq, int cpu, const char *qsevent), - - TP_ARGS(rcuname, gp_seq, cpu, qsevent), - - TP_FIELDS( - ctf_integer(unsigned long, gp_seq, gp_seq) - ctf_integer(int, cpu, cpu) - ctf_string(rcuname, rcuname) - ctf_string(qsevent, qsevent) - ) -) - -#endif - -/* - * Tracepoint for dyntick-idle entry/exit events. These take a string - * as argument: "Start" for entering dyntick-idle mode, "End" for - * leaving it, "--=" for events moving towards idle, and "++=" for events - * moving away from idle. "Error on entry: not idle task" and "Error on - * exit: not idle task" indicate that a non-idle task is erroneously - * toying with the idle loop. - * - * These events also take a pair of numbers, which indicate the nesting - * depth before and after the event of interest. Note that task-related - * events use the upper bits of each number, while interrupt-related - * events use the lower bits. - */ -LTTNG_TRACEPOINT_EVENT(rcu_dyntick, - - TP_PROTO(const char *polarity, long oldnesting, long newnesting, int dynticks), - - TP_ARGS(polarity, oldnesting, newnesting, dynticks), - - TP_FIELDS( - ctf_string(polarity, polarity) - ctf_integer(long, oldnesting, oldnesting) - ctf_integer(long, newnesting, newnesting) - ctf_integer(int, dynticks, dynticks) - ) -) - -/* - * Tracepoint for RCU preparation for idle, the goal being to get RCU - * processing done so that the current CPU can shut off its scheduling - * clock and enter dyntick-idle mode. One way to accomplish this is - * to drain all RCU callbacks from this CPU, and the other is to have - * done everything RCU requires for the current grace period. In this - * latter case, the CPU will be awakened at the end of the current grace - * period in order to process the remainder of its callbacks. - * - * These tracepoints take a string as argument: - * - * "No callbacks": Nothing to do, no callbacks on this CPU. - * "In holdoff": Nothing to do, holding off after unsuccessful attempt. - * "Begin holdoff": Attempt failed, don't retry until next jiffy. - * "Dyntick with callbacks": Entering dyntick-idle despite callbacks. - * "Dyntick with lazy callbacks": Entering dyntick-idle w/lazy callbacks. - * "More callbacks": Still more callbacks, try again to clear them out. - * "Callbacks drained": All callbacks processed, off to dyntick idle! - * "Timer": Timer fired to cause CPU to continue processing callbacks. - * "Demigrate": Timer fired on wrong CPU, woke up correct CPU. - * "Cleanup after idle": Idle exited, timer canceled. - */ -LTTNG_TRACEPOINT_EVENT(rcu_prep_idle, - - TP_PROTO(const char *reason), - - TP_ARGS(reason), - - TP_FIELDS( - ctf_string(reason, reason) - ) -) - -/* - * Tracepoint for the registration of a single RCU callback function. - * The first argument is the type of RCU, the second argument is - * a pointer to the RCU callback itself, the third element is the - * number of lazy callbacks queued, and the fourth element is the - * total number of callbacks queued. - */ -LTTNG_TRACEPOINT_EVENT(rcu_callback, - - TP_PROTO(const char *rcuname, struct rcu_head *rhp, long qlen), - - TP_ARGS(rcuname, rhp, qlen), - - TP_FIELDS( - ctf_string(rcuname, rcuname) - ctf_integer_hex(void *, rhp, rhp) - ctf_integer_hex(void *, func, rhp->func) - ctf_integer(long, qlen, qlen) - ) -) - -/* - * Tracepoint for the registration of a single RCU callback of the special - * kfree() form. The first argument is the RCU type, the second argument - * is a pointer to the RCU callback, the third argument is the offset - * of the callback within the enclosing RCU-protected data structure, - * the fourth argument is the number of lazy callbacks queued, and the - * fifth argument is the total number of callbacks queued. - */ -LTTNG_TRACEPOINT_EVENT(rcu_kfree_callback, - - TP_PROTO(const char *rcuname, struct rcu_head *rhp, unsigned long offset, - long qlen), - - TP_ARGS(rcuname, rhp, offset, qlen), - - TP_FIELDS( - ctf_string(rcuname, rcuname) - ctf_integer_hex(void *, rhp, rhp) - ctf_integer_hex(unsigned long, offset, offset) - ctf_integer(long, qlen, qlen) - ) -) - -/* - * Tracepoint for marking the beginning rcu_do_batch, performed to start - * RCU callback invocation. The first argument is the RCU flavor, - * the second is the number of lazy callbacks queued, the third is - * the total number of callbacks queued, and the fourth argument is - * the current RCU-callback batch limit. - */ -LTTNG_TRACEPOINT_EVENT(rcu_batch_start, - - TP_PROTO(const char *rcuname, long qlen, long blimit), - - TP_ARGS(rcuname, qlen, blimit), - - TP_FIELDS( - ctf_string(rcuname, rcuname) - ctf_integer(long, qlen, qlen) - ctf_integer(long, blimit, blimit) - ) -) - -/* - * Tracepoint for the invocation of a single RCU callback function. - * The first argument is the type of RCU, and the second argument is - * a pointer to the RCU callback itself. - */ -LTTNG_TRACEPOINT_EVENT(rcu_invoke_callback, - - TP_PROTO(const char *rcuname, struct rcu_head *rhp), - - TP_ARGS(rcuname, rhp), - - TP_FIELDS( - ctf_string(rcuname, rcuname) - ctf_integer_hex(void *, rhp, rhp) - ctf_integer_hex(void *, func, rhp->func) - ) -) - -/* - * Tracepoint for the invocation of a single RCU callback of the special - * kfree() form. The first argument is the RCU flavor, the second - * argument is a pointer to the RCU callback, and the third argument - * is the offset of the callback within the enclosing RCU-protected - * data structure. - */ -LTTNG_TRACEPOINT_EVENT(rcu_invoke_kfree_callback, - - TP_PROTO(const char *rcuname, struct rcu_head *rhp, unsigned long offset), - - TP_ARGS(rcuname, rhp, offset), - - TP_FIELDS( - ctf_string(rcuname, rcuname) - ctf_integer_hex(void *, rhp, rhp) - ctf_integer(unsigned long, offset, offset) - ) -) - -/* - * Tracepoint for exiting rcu_do_batch after RCU callbacks have been - * invoked. The first argument is the name of the RCU flavor, - * the second argument is number of callbacks actually invoked, - * the third argument (cb) is whether or not any of the callbacks that - * were ready to invoke at the beginning of this batch are still - * queued, the fourth argument (nr) is the return value of need_resched(), - * the fifth argument (iit) is 1 if the current task is the idle task, - * and the sixth argument (risk) is the return value from - * rcu_is_callbacks_kthread(). - */ -LTTNG_TRACEPOINT_EVENT(rcu_batch_end, - - TP_PROTO(const char *rcuname, int callbacks_invoked, - char cb, char nr, char iit, char risk), - - TP_ARGS(rcuname, callbacks_invoked, cb, nr, iit, risk), - - TP_FIELDS( - ctf_string(rcuname, rcuname) - ctf_integer(int, callbacks_invoked, callbacks_invoked) - ctf_integer(char, cb, cb) - ctf_integer(char, nr, nr) - ctf_integer(char, iit, iit) - ctf_integer(char, risk, risk) - ) -) - -/* - * Tracepoint for rcutorture readers. The first argument is the name - * of the RCU flavor from rcutorture's viewpoint and the second argument - * is the callback address. - */ -LTTNG_TRACEPOINT_EVENT(rcu_torture_read, - - TP_PROTO(const char *rcutorturename, struct rcu_head *rhp, - unsigned long secs, unsigned long c_old, unsigned long c), - - TP_ARGS(rcutorturename, rhp, secs, c_old, c), - - TP_FIELDS( - ctf_string(rcutorturename, rcutorturename) - ctf_integer_hex(struct rcu_head *, rhp, rhp) - ctf_integer(unsigned long, secs, secs) - ctf_integer(unsigned long, c_old, c_old) - ctf_integer(unsigned long, c, c) - ) -) - -/* - * Tracepoint for _rcu_barrier() execution. The string "s" describes - * the _rcu_barrier phase: - * "Begin": rcu_barrier_callback() started. - * "Check": rcu_barrier_callback() checking for piggybacking. - * "EarlyExit": rcu_barrier_callback() piggybacked, thus early exit. - * "Inc1": rcu_barrier_callback() piggyback check counter incremented. - * "Offline": rcu_barrier_callback() found offline CPU - * "OnlineQ": rcu_barrier_callback() found online CPU with callbacks. - * "OnlineNQ": rcu_barrier_callback() found online CPU, no callbacks. - * "IRQ": An rcu_barrier_callback() callback posted on remote CPU. - * "CB": An rcu_barrier_callback() invoked a callback, not the last. - * "LastCB": An rcu_barrier_callback() invoked the last callback. - * "Inc2": rcu_barrier_callback() piggyback check counter incremented. - * The "cpu" argument is the CPU or -1 if meaningless, the "cnt" argument - * is the count of remaining callbacks, and "done" is the piggybacking count. - */ -LTTNG_TRACEPOINT_EVENT(rcu_barrier, - - TP_PROTO(const char *rcuname, const char *s, int cpu, int cnt, unsigned long done), - - TP_ARGS(rcuname, s, cpu, cnt, done), - - TP_FIELDS( - ctf_string(rcuname, rcuname) - ctf_string(s, s) - ctf_integer(int, cpu, cpu) - ctf_integer(int, cnt, cnt) - ctf_integer(unsigned long, done, done) - ) -) - -#else /* #ifdef CONFIG_RCU_TRACE */ - -#define trace_rcu_grace_period(rcuname, gp_seq, gpevent) do { } while (0) -#define trace_rcu_grace_period_init(rcuname, gp_seq, level, grplo, grphi, \ - qsmask) do { } while (0) -#define trace_rcu_preempt_task(rcuname, pid, gp_seq) do { } while (0) -#define trace_rcu_unlock_preempted_task(rcuname, gp_seq, pid) do { } while (0) -#define trace_rcu_quiescent_state_report(rcuname, gp_seq, mask, qsmask, level, \ - grplo, grphi, gp_tasks) do { } \ - while (0) -#define trace_rcu_fqs(rcuname, gp_seq, cpu, qsevent) do { } while (0) - -#define trace_rcu_dyntick(polarity, oldnesting, newnesting, dyntick) do { } while (0) -#define trace_rcu_prep_idle(reason) do { } while (0) -#define trace_rcu_callback(rcuname, rhp, qlen_lazy, qlen) do { } while (0) -#define trace_rcu_kfree_callback(rcuname, rhp, offset, qlen_lazy, qlen) \ - do { } while (0) -#define trace_rcu_batch_start(rcuname, qlen_lazy, qlen, blimit) \ - do { } while (0) -#define trace_rcu_invoke_callback(rcuname, rhp) do { } while (0) -#define trace_rcu_invoke_kfree_callback(rcuname, rhp, offset) do { } while (0) -#define trace_rcu_batch_end(rcuname, callbacks_invoked, cb, nr, iit, risk) \ - do { } while (0) -#define trace_rcu_torture_read(rcutorturename, rhp, secs, c_old, c) \ - do { } while (0) -#define trace_rcu_barrier(name, s, cpu, cnt, done) do { } while (0) -#endif /* #else #ifdef CONFIG_RCU_TRACE */ - -#endif /* LTTNG_TRACE_RCU_H */ - -/* This part must be outside protection */ -#include diff --git a/instrumentation/events/lttng-module/regmap.h b/instrumentation/events/lttng-module/regmap.h deleted file mode 100644 index 1d7e954d..00000000 --- a/instrumentation/events/lttng-module/regmap.h +++ /dev/null @@ -1,144 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -#undef TRACE_SYSTEM -#define TRACE_SYSTEM regmap - -#if !defined(LTTNG_TRACE_REGMAP_H) || defined(TRACE_HEADER_MULTI_READ) -#define LTTNG_TRACE_REGMAP_H - -#include -#include - -#ifndef _TRACE_REGMAP_DEF_ -#define _TRACE_REGMAP_DEF_ -struct device; -struct regmap; -#endif - -/* - * Log register events - */ -LTTNG_TRACEPOINT_EVENT_CLASS(regmap_reg, - - TP_PROTO(struct regmap *map, unsigned int reg, - unsigned int val), - - TP_ARGS(map, reg, val), - - TP_FIELDS( - ctf_string(name, regmap_name(map)) - ctf_integer(unsigned int, reg, reg) - ctf_integer(unsigned int, val, val) - ) -) -LTTNG_TRACEPOINT_EVENT_INSTANCE(regmap_reg, regmap_reg_write, - - TP_PROTO(struct regmap *map, unsigned int reg, - unsigned int val), - - TP_ARGS(map, reg, val) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(regmap_reg, regmap_reg_read, - - TP_PROTO(struct regmap *map, unsigned int reg, - unsigned int val), - - TP_ARGS(map, reg, val) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(regmap_reg, regmap_reg_read_cache, - - TP_PROTO(struct regmap *map, unsigned int reg, - unsigned int val), - - TP_ARGS(map, reg, val) -) - -LTTNG_TRACEPOINT_EVENT_CLASS(regmap_block, - - TP_PROTO(struct regmap *map, unsigned int reg, int count), - - TP_ARGS(map, reg, count), - - TP_FIELDS( - ctf_string(name, regmap_name(map)) - ctf_integer(unsigned int, reg, reg) - ctf_integer(int, count, count) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(regmap_block, regmap_hw_read_start, - - TP_PROTO(struct regmap *map, unsigned int reg, int count), - - TP_ARGS(map, reg, count) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(regmap_block, regmap_hw_read_done, - - TP_PROTO(struct regmap *map, unsigned int reg, int count), - - TP_ARGS(map, reg, count) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(regmap_block, regmap_hw_write_start, - - TP_PROTO(struct regmap *map, unsigned int reg, int count), - - TP_ARGS(map, reg, count) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(regmap_block, regmap_hw_write_done, - - TP_PROTO(struct regmap *map, unsigned int reg, int count), - - TP_ARGS(map, reg, count) -) - -LTTNG_TRACEPOINT_EVENT_MAP(regcache_sync, - - regmap_regcache_sync, - - TP_PROTO(struct regmap *map, const char *type, - const char *status), - - TP_ARGS(map, type, status), - - TP_FIELDS( - ctf_string(name, regmap_name(map)) - ctf_string(status, status) - ctf_string(type, type) - ) -) - -LTTNG_TRACEPOINT_EVENT_CLASS(regmap_bool, - - TP_PROTO(struct regmap *map, bool flag), - - TP_ARGS(map, flag), - - TP_FIELDS( - ctf_string(name, regmap_name(map)) - ctf_integer(int, flag, flag) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(regmap_bool, regmap_cache_only, - - TP_PROTO(struct regmap *map, bool flag), - - TP_ARGS(map, flag) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(regmap_bool, regmap_cache_bypass, - - TP_PROTO(struct regmap *map, bool flag), - - TP_ARGS(map, flag) - -) - -#endif /* LTTNG_TRACE_REGMAP_H */ - -/* This part must be outside protection */ -#include diff --git a/instrumentation/events/lttng-module/regulator.h b/instrumentation/events/lttng-module/regulator.h deleted file mode 100644 index 46ad50d2..00000000 --- a/instrumentation/events/lttng-module/regulator.h +++ /dev/null @@ -1,118 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -#undef TRACE_SYSTEM -#define TRACE_SYSTEM regulator - -#if !defined(LTTNG_TRACE_REGULATOR_H) || defined(TRACE_HEADER_MULTI_READ) -#define LTTNG_TRACE_REGULATOR_H - -#include -#include - -/* - * Events which just log themselves and the regulator name for enable/disable - * type tracking. - */ -LTTNG_TRACEPOINT_EVENT_CLASS(regulator_basic, - - TP_PROTO(const char *name), - - TP_ARGS(name), - - TP_FIELDS( - ctf_string(name, name) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(regulator_basic, regulator_enable, - - TP_PROTO(const char *name), - - TP_ARGS(name) - -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(regulator_basic, regulator_enable_delay, - - TP_PROTO(const char *name), - - TP_ARGS(name) - -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(regulator_basic, regulator_enable_complete, - - TP_PROTO(const char *name), - - TP_ARGS(name) - -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(regulator_basic, regulator_disable, - - TP_PROTO(const char *name), - - TP_ARGS(name) - -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(regulator_basic, regulator_disable_complete, - - TP_PROTO(const char *name), - - TP_ARGS(name) - -) - -/* - * Events that take a range of numerical values, mostly for voltages - * and so on. - */ -LTTNG_TRACEPOINT_EVENT_CLASS(regulator_range, - - TP_PROTO(const char *name, int min, int max), - - TP_ARGS(name, min, max), - - TP_FIELDS( - ctf_string(name, name) - ctf_integer(int, min, min) - ctf_integer(int, max, max) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(regulator_range, regulator_set_voltage, - - TP_PROTO(const char *name, int min, int max), - - TP_ARGS(name, min, max) - -) - - -/* - * Events that take a single value, mostly for readback and refcounts. - */ -LTTNG_TRACEPOINT_EVENT_CLASS(regulator_value, - - TP_PROTO(const char *name, unsigned int val), - - TP_ARGS(name, val), - - TP_FIELDS( - ctf_string(name, name) - ctf_integer(unsigned int, val, val) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(regulator_value, regulator_set_voltage_complete, - - TP_PROTO(const char *name, unsigned int value), - - TP_ARGS(name, value) - -) - -#endif /* _TRACE_POWER_H */ - -/* This part must be outside protection */ -#include diff --git a/instrumentation/events/lttng-module/rpc.h b/instrumentation/events/lttng-module/rpc.h deleted file mode 100644 index 8b15cfab..00000000 --- a/instrumentation/events/lttng-module/rpc.h +++ /dev/null @@ -1,134 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -#undef TRACE_SYSTEM -#define TRACE_SYSTEM rpc - -#if !defined(LTTNG_TRACE_RPC_H) || defined(TRACE_HEADER_MULTI_READ) -#define LTTNG_TRACE_RPC_H - -#include -#include -#include - -#ifndef ONCE_LTTNG_RPC_H -#define ONCE_LTTNG_RPC_H - -static inline -int lttng_get_clid(const struct rpc_task *task) -{ - struct rpc_clnt *tk_client; - - tk_client = task->tk_client; - if (!tk_client) - return -1; - /* - * The cl_clid field is always initialized to positive signed - * integers. Negative signed integer values are treated as - * errors. - */ - return (int) tk_client->cl_clid; -} - -#endif /* ONCE_LTTNG_RPC_H */ - -LTTNG_TRACEPOINT_EVENT_CLASS(rpc_task_status, - - TP_PROTO(const struct rpc_task *task), - - TP_ARGS(task), - - TP_FIELDS( - ctf_integer(unsigned int, task_id, task->tk_pid) - ctf_integer(int, client_id, lttng_get_clid(task)) - ctf_integer(int, status, task->tk_status) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(rpc_task_status, rpc_call_status, - TP_PROTO(const struct rpc_task *task), - - TP_ARGS(task) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(rpc_task_status, rpc_bind_status, - TP_PROTO(const struct rpc_task *task), - - TP_ARGS(task) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(rpc_task_status, rpc_connect_status, - TP_PROTO(const struct rpc_task *task), - - TP_ARGS(task) -) - -LTTNG_TRACEPOINT_EVENT_CLASS(rpc_task_running, - - TP_PROTO(const struct rpc_task *task, const void *action), - - TP_ARGS(task, action), - - TP_FIELDS( - ctf_integer(unsigned int, task_id, task->tk_pid) - ctf_integer(int, client_id, lttng_get_clid(task)) - ctf_integer_hex(const void *, action, action) - ctf_integer(unsigned long, runstate, task->tk_runstate) - ctf_integer(int, status, task->tk_status) - ctf_integer(unsigned short, flags, task->tk_flags) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(rpc_task_running, rpc_task_begin, - - TP_PROTO(const struct rpc_task *task, const void *action), - - TP_ARGS(task, action) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(rpc_task_running, rpc_task_run_action, - - TP_PROTO(const struct rpc_task *task, const void *action), - - TP_ARGS(task, action) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(rpc_task_running, rpc_task_complete, - - TP_PROTO(const struct rpc_task *task, const void *action), - - TP_ARGS(task, action) -) - -LTTNG_TRACEPOINT_EVENT_CLASS(rpc_task_queued, - - TP_PROTO(const struct rpc_task *task, const struct rpc_wait_queue *q), - - TP_ARGS(task, q), - - TP_FIELDS( - ctf_integer(unsigned int, task_id, task->tk_pid) - ctf_integer(int, client_id, lttng_get_clid(task)) - ctf_integer(unsigned long, timeout, task->tk_timeout) - ctf_integer(unsigned long, runstate, task->tk_runstate) - ctf_integer(int, status, task->tk_status) - ctf_integer(unsigned short, flags, task->tk_flags) - ctf_string(q_name, rpc_qname(q)) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(rpc_task_queued, rpc_task_sleep, - - TP_PROTO(const struct rpc_task *task, const struct rpc_wait_queue *q), - - TP_ARGS(task, q) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(rpc_task_queued, rpc_task_wakeup, - - TP_PROTO(const struct rpc_task *task, const struct rpc_wait_queue *q), - - TP_ARGS(task, q) -) - -#endif /* LTTNG_TRACE_RPC_H */ - -#include diff --git a/instrumentation/events/lttng-module/rpm.h b/instrumentation/events/lttng-module/rpm.h deleted file mode 100644 index 7aa44d79..00000000 --- a/instrumentation/events/lttng-module/rpm.h +++ /dev/null @@ -1,73 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -#undef TRACE_SYSTEM -#define TRACE_SYSTEM rpm - -#if !defined(LTTNG_TRACE_RUNTIME_POWER_H) || defined(TRACE_HEADER_MULTI_READ) -#define LTTNG_TRACE_RUNTIME_POWER_H - -#include -#include - -#ifndef _TRACE_RPM_DEF_ -#define _TRACE_RPM_DEF_ -struct device; -#endif - -/* - * The rpm_internal events are used for tracing some important - * runtime pm internal functions. - */ -LTTNG_TRACEPOINT_EVENT_CLASS(rpm_internal, - - TP_PROTO(struct device *dev, int flags), - - TP_ARGS(dev, flags), - - TP_FIELDS( - ctf_string(name, dev_name(dev)) - ctf_integer(int, flags, flags) - ctf_integer(int, usage_count, atomic_read(&dev->power.usage_count)) - ctf_integer(int, disable_depth, dev->power.disable_depth) - ctf_integer(int, runtime_auto, dev->power.runtime_auto) - ctf_integer(int, request_pending, dev->power.request_pending) - ctf_integer(int, irq_safe, dev->power.irq_safe) - ctf_integer(int, child_count, atomic_read(&dev->power.child_count)) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(rpm_internal, rpm_suspend, - - TP_PROTO(struct device *dev, int flags), - - TP_ARGS(dev, flags) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(rpm_internal, rpm_resume, - - TP_PROTO(struct device *dev, int flags), - - TP_ARGS(dev, flags) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(rpm_internal, rpm_idle, - - TP_PROTO(struct device *dev, int flags), - - TP_ARGS(dev, flags) -) - -LTTNG_TRACEPOINT_EVENT(rpm_return_int, - TP_PROTO(struct device *dev, unsigned long ip, int ret), - TP_ARGS(dev, ip, ret), - - TP_FIELDS( - ctf_string(name, dev_name(dev)) - ctf_integer_hex(unsigned long, ip, ip) - ctf_integer(int, ret, ret) - ) -) - -#endif /* LTTNG_TRACE_RUNTIME_POWER_H */ - -/* This part must be outside protection */ -#include diff --git a/instrumentation/events/lttng-module/sched.h b/instrumentation/events/lttng-module/sched.h deleted file mode 100644 index 20890ac0..00000000 --- a/instrumentation/events/lttng-module/sched.h +++ /dev/null @@ -1,409 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -#undef TRACE_SYSTEM -#define TRACE_SYSTEM sched - -#if !defined(LTTNG_TRACE_SCHED_H) || defined(TRACE_HEADER_MULTI_READ) -#define LTTNG_TRACE_SCHED_H - -#include -#include -#include -#include -#include - -#define LTTNG_MAX_PID_NS_LEVEL 32 - -#ifndef _TRACE_SCHED_DEF_ -#define _TRACE_SCHED_DEF_ - -static inline long __trace_sched_switch_state(bool preempt, struct task_struct *p) -{ - unsigned int state; - -#ifdef CONFIG_SCHED_DEBUG - BUG_ON(p != current); -#endif /* CONFIG_SCHED_DEBUG */ - - /* - * Preemption ignores task state, therefore preempted tasks are always - * RUNNING (we will not have dequeued if state != RUNNING). - */ - if (preempt) - return TASK_REPORT_MAX; - - /* - * task_state_index() uses fls() and returns a value from 0-8 range. - * Decrement it by 1 (except TASK_RUNNING state i.e 0) before using - * it for left shift operation to get the correct task->state - * mapping. - */ - state = task_state_index(p); - - return state ? (1 << (state - 1)) : state; -} - -#endif /* _TRACE_SCHED_DEF_ */ - -/* - * Enumeration of the task state bitmask. - * Only bit flags are enumerated here, not composition of states. - */ -LTTNG_TRACEPOINT_ENUM(task_state, - TP_ENUM_VALUES( - ctf_enum_value("TASK_RUNNING", TASK_RUNNING) - ctf_enum_value("TASK_INTERRUPTIBLE", TASK_INTERRUPTIBLE) - ctf_enum_value("TASK_UNINTERRUPTIBLE", TASK_UNINTERRUPTIBLE) - ctf_enum_value("TASK_STOPPED", __TASK_STOPPED) - ctf_enum_value("TASK_TRACED", __TASK_TRACED) - ctf_enum_value("EXIT_DEAD", EXIT_DEAD) - ctf_enum_value("EXIT_ZOMBIE", EXIT_ZOMBIE) - ctf_enum_value("TASK_PARKED", TASK_PARKED) - ctf_enum_value("TASK_DEAD", TASK_DEAD) - ctf_enum_value("TASK_WAKEKILL", TASK_WAKEKILL) - ctf_enum_value("TASK_WAKING", TASK_WAKING) - ctf_enum_value("TASK_NOLOAD", TASK_NOLOAD) - ctf_enum_value("TASK_NEW", TASK_NEW) - ctf_enum_value("TASK_STATE_MAX", TASK_STATE_MAX) - ) -) - -/* - * Tracepoint for calling kthread_stop, performed to end a kthread: - */ -LTTNG_TRACEPOINT_EVENT(sched_kthread_stop, - - TP_PROTO(struct task_struct *t), - - TP_ARGS(t), - - TP_FIELDS( - ctf_array_text(char, comm, t->comm, TASK_COMM_LEN) - ctf_integer(pid_t, tid, t->pid) - ) -) - -/* - * Tracepoint for the return value of the kthread stopping: - */ -LTTNG_TRACEPOINT_EVENT(sched_kthread_stop_ret, - - TP_PROTO(int ret), - - TP_ARGS(ret), - - TP_FIELDS( - ctf_integer(int, ret, ret) - ) -) - -/* - * Tracepoint for waking up a task: - */ -LTTNG_TRACEPOINT_EVENT_CLASS(sched_wakeup_template, - - TP_PROTO(struct task_struct *p), - - TP_ARGS(p), - - TP_FIELDS( - ctf_array_text(char, comm, p->comm, TASK_COMM_LEN) - ctf_integer(pid_t, tid, p->pid) - ctf_integer(int, prio, p->prio - MAX_RT_PRIO) - ctf_integer(int, target_cpu, task_cpu(p)) - ) -) - -/* - * Tracepoint called when waking a task; this tracepoint is guaranteed to be - * called from the waking context. - */ -LTTNG_TRACEPOINT_EVENT_INSTANCE(sched_wakeup_template, sched_waking, - TP_PROTO(struct task_struct *p), - TP_ARGS(p)) - -/* - * Tracepoint called when the task is actually woken; p->state == TASK_RUNNNG. - * It it not always called from the waking context. - */ -LTTNG_TRACEPOINT_EVENT_INSTANCE(sched_wakeup_template, sched_wakeup, - TP_PROTO(struct task_struct *p), - TP_ARGS(p)) - -/* - * Tracepoint for waking up a new task: - */ -LTTNG_TRACEPOINT_EVENT_INSTANCE(sched_wakeup_template, sched_wakeup_new, - TP_PROTO(struct task_struct *p), - TP_ARGS(p)) - -/* - * Tracepoint for task switches, performed by the scheduler: - */ -LTTNG_TRACEPOINT_EVENT(sched_switch, - - TP_PROTO(bool preempt, - struct task_struct *prev, - struct task_struct *next), - - TP_ARGS(preempt, prev, next), - - TP_FIELDS( - ctf_array_text(char, prev_comm, prev->comm, TASK_COMM_LEN) - ctf_integer(pid_t, prev_tid, prev->pid) - ctf_integer(int, prev_prio, prev->prio - MAX_RT_PRIO) - ctf_enum(task_state, long, prev_state, __trace_sched_switch_state(preempt, prev)) - ctf_array_text(char, next_comm, next->comm, TASK_COMM_LEN) - ctf_integer(pid_t, next_tid, next->pid) - ctf_integer(int, next_prio, next->prio - MAX_RT_PRIO) - ) -) - -/* - * Tracepoint for a task being migrated: - */ -LTTNG_TRACEPOINT_EVENT(sched_migrate_task, - - TP_PROTO(struct task_struct *p, int dest_cpu), - - TP_ARGS(p, dest_cpu), - - TP_FIELDS( - ctf_array_text(char, comm, p->comm, TASK_COMM_LEN) - ctf_integer(pid_t, tid, p->pid) - ctf_integer(int, prio, p->prio - MAX_RT_PRIO) - ctf_integer(int, orig_cpu, task_cpu(p)) - ctf_integer(int, dest_cpu, dest_cpu) - ) -) - -LTTNG_TRACEPOINT_EVENT_CLASS(sched_process_template, - - TP_PROTO(struct task_struct *p), - - TP_ARGS(p), - - TP_FIELDS( - ctf_array_text(char, comm, p->comm, TASK_COMM_LEN) - ctf_integer(pid_t, tid, p->pid) - ctf_integer(int, prio, p->prio - MAX_RT_PRIO) - ) -) - -/* - * Tracepoint for freeing a task: - */ -LTTNG_TRACEPOINT_EVENT_INSTANCE(sched_process_template, sched_process_free, - TP_PROTO(struct task_struct *p), - TP_ARGS(p)) - - -/* - * Tracepoint for a task exiting: - */ -LTTNG_TRACEPOINT_EVENT_INSTANCE(sched_process_template, sched_process_exit, - TP_PROTO(struct task_struct *p), - TP_ARGS(p)) - -/* - * Tracepoint for waiting on task to unschedule: - */ -LTTNG_TRACEPOINT_EVENT_INSTANCE(sched_process_template, sched_wait_task, - TP_PROTO(struct task_struct *p), - TP_ARGS(p)) - -/* - * Tracepoint for a waiting task: - */ -LTTNG_TRACEPOINT_EVENT(sched_process_wait, - - TP_PROTO(struct pid *pid), - - TP_ARGS(pid), - - TP_FIELDS( - ctf_array_text(char, comm, current->comm, TASK_COMM_LEN) - ctf_integer(pid_t, tid, pid_nr(pid)) - ctf_integer(int, prio, current->prio - MAX_RT_PRIO) - ) -) - -/* - * Tracepoint for do_fork. - * Saving both TID and PID information, especially for the child, allows - * trace analyzers to distinguish between creation of a new process and - * creation of a new thread. Newly created processes will have child_tid - * == child_pid, while creation of a thread yields to child_tid != - * child_pid. - */ -LTTNG_TRACEPOINT_EVENT_CODE(sched_process_fork, - - TP_PROTO(struct task_struct *parent, struct task_struct *child), - - TP_ARGS(parent, child), - - TP_locvar( - pid_t vtids[LTTNG_MAX_PID_NS_LEVEL]; - unsigned int ns_level; - ), - - TP_code_pre( - if (child) { - struct pid *child_pid; - unsigned int i; - - child_pid = task_pid(child); - tp_locvar->ns_level = - min_t(unsigned int, child_pid->level + 1, - LTTNG_MAX_PID_NS_LEVEL); - for (i = 0; i < tp_locvar->ns_level; i++) - tp_locvar->vtids[i] = child_pid->numbers[i].nr; - } - ), - - TP_FIELDS( - ctf_array_text(char, parent_comm, parent->comm, TASK_COMM_LEN) - ctf_integer(pid_t, parent_tid, parent->pid) - ctf_integer(pid_t, parent_pid, parent->tgid) - ctf_integer(unsigned int, parent_ns_inum, - ({ - unsigned int parent_ns_inum = 0; - - if (parent) { - struct pid_namespace *pid_ns; - - pid_ns = task_active_pid_ns(parent); - if (pid_ns) - parent_ns_inum = - pid_ns->ns.inum; - } - parent_ns_inum; - })) - ctf_array_text(char, child_comm, child->comm, TASK_COMM_LEN) - ctf_integer(pid_t, child_tid, child->pid) - ctf_sequence(pid_t, vtids, tp_locvar->vtids, u8, tp_locvar->ns_level) - ctf_integer(pid_t, child_pid, child->tgid) - ctf_integer(unsigned int, child_ns_inum, - ({ - unsigned int child_ns_inum = 0; - - if (child) { - struct pid_namespace *pid_ns; - - pid_ns = task_active_pid_ns(child); - if (pid_ns) - child_ns_inum = - pid_ns->ns.inum; - } - child_ns_inum; - })) - ), - - TP_code_post() -) - -/* - * Tracepoint for exec: - */ -LTTNG_TRACEPOINT_EVENT(sched_process_exec, - - TP_PROTO(struct task_struct *p, pid_t old_pid, - struct linux_binprm *bprm), - - TP_ARGS(p, old_pid, bprm), - - TP_FIELDS( - ctf_string(filename, bprm->filename) - ctf_integer(pid_t, tid, p->pid) - ctf_integer(pid_t, old_tid, old_pid) - ) -) - -/* - * XXX the below sched_stat tracepoints only apply to SCHED_OTHER/BATCH/IDLE - * adding sched_stat support to SCHED_FIFO/RR would be welcome. - */ -LTTNG_TRACEPOINT_EVENT_CLASS(sched_stat_template, - - TP_PROTO(struct task_struct *tsk, u64 delay), - - TP_ARGS(tsk, delay), - - TP_FIELDS( - ctf_array_text(char, comm, tsk->comm, TASK_COMM_LEN) - ctf_integer(pid_t, tid, tsk->pid) - ctf_integer(u64, delay, delay) - ) -) - - -/* - * Tracepoint for accounting wait time (time the task is runnable - * but not actually running due to scheduler contention). - */ -LTTNG_TRACEPOINT_EVENT_INSTANCE(sched_stat_template, sched_stat_wait, - TP_PROTO(struct task_struct *tsk, u64 delay), - TP_ARGS(tsk, delay)) - -/* - * Tracepoint for accounting sleep time (time the task is not runnable, - * including iowait, see below). - */ -LTTNG_TRACEPOINT_EVENT_INSTANCE(sched_stat_template, sched_stat_sleep, - TP_PROTO(struct task_struct *tsk, u64 delay), - TP_ARGS(tsk, delay)) - -/* - * Tracepoint for accounting iowait time (time the task is not runnable - * due to waiting on IO to complete). - */ -LTTNG_TRACEPOINT_EVENT_INSTANCE(sched_stat_template, sched_stat_iowait, - TP_PROTO(struct task_struct *tsk, u64 delay), - TP_ARGS(tsk, delay)) - -/* - * Tracepoint for accounting blocked time (time the task is in uninterruptible). - */ -LTTNG_TRACEPOINT_EVENT_INSTANCE(sched_stat_template, sched_stat_blocked, - TP_PROTO(struct task_struct *tsk, u64 delay), - TP_ARGS(tsk, delay)) - -/* - * Tracepoint for accounting runtime (time the task is executing - * on a CPU). - */ -LTTNG_TRACEPOINT_EVENT(sched_stat_runtime, - - TP_PROTO(struct task_struct *tsk, u64 runtime, u64 vruntime), - - TP_ARGS(tsk, runtime, vruntime), - - TP_FIELDS( - ctf_array_text(char, comm, tsk->comm, TASK_COMM_LEN) - ctf_integer(pid_t, tid, tsk->pid) - ctf_integer(u64, runtime, runtime) - ctf_integer(u64, vruntime, vruntime) - ) -) - -/* - * Tracepoint for showing priority inheritance modifying a tasks - * priority. - */ -LTTNG_TRACEPOINT_EVENT(sched_pi_setprio, - - TP_PROTO(struct task_struct *tsk, struct task_struct *pi_task), - - TP_ARGS(tsk, pi_task), - - TP_FIELDS( - ctf_array_text(char, comm, tsk->comm, TASK_COMM_LEN) - ctf_integer(pid_t, tid, tsk->pid) - ctf_integer(int, oldprio, tsk->prio - MAX_RT_PRIO) - ctf_integer(int, newprio, pi_task ? pi_task->prio - MAX_RT_PRIO : tsk->prio - MAX_RT_PRIO) - ) -) - -#endif /* LTTNG_TRACE_SCHED_H */ - -/* This part must be outside protection */ -#include diff --git a/instrumentation/events/lttng-module/scsi.h b/instrumentation/events/lttng-module/scsi.h deleted file mode 100644 index 0a864d1a..00000000 --- a/instrumentation/events/lttng-module/scsi.h +++ /dev/null @@ -1,289 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -#undef TRACE_SYSTEM -#define TRACE_SYSTEM scsi - -#if !defined(LTTNG_TRACE_SCSI_H) || defined(TRACE_HEADER_MULTI_READ) -#define LTTNG_TRACE_SCSI_H - -#include -#include -#include -#include - -#ifndef _TRACE_SCSI_DEF -#define _TRACE_SCSI_DEF - -#define scsi_opcode_name(opcode) { opcode, #opcode } - -#define show_opcode_name(val) \ - __print_symbolic(val, \ - scsi_opcode_name(TEST_UNIT_READY), \ - scsi_opcode_name(REZERO_UNIT), \ - scsi_opcode_name(REQUEST_SENSE), \ - scsi_opcode_name(FORMAT_UNIT), \ - scsi_opcode_name(READ_BLOCK_LIMITS), \ - scsi_opcode_name(REASSIGN_BLOCKS), \ - scsi_opcode_name(INITIALIZE_ELEMENT_STATUS), \ - scsi_opcode_name(READ_6), \ - scsi_opcode_name(WRITE_6), \ - scsi_opcode_name(SEEK_6), \ - scsi_opcode_name(READ_REVERSE), \ - scsi_opcode_name(WRITE_FILEMARKS), \ - scsi_opcode_name(SPACE), \ - scsi_opcode_name(INQUIRY), \ - scsi_opcode_name(RECOVER_BUFFERED_DATA), \ - scsi_opcode_name(MODE_SELECT), \ - scsi_opcode_name(RESERVE), \ - scsi_opcode_name(RELEASE), \ - scsi_opcode_name(COPY), \ - scsi_opcode_name(ERASE), \ - scsi_opcode_name(MODE_SENSE), \ - scsi_opcode_name(START_STOP), \ - scsi_opcode_name(RECEIVE_DIAGNOSTIC), \ - scsi_opcode_name(SEND_DIAGNOSTIC), \ - scsi_opcode_name(ALLOW_MEDIUM_REMOVAL), \ - scsi_opcode_name(SET_WINDOW), \ - scsi_opcode_name(READ_CAPACITY), \ - scsi_opcode_name(READ_10), \ - scsi_opcode_name(WRITE_10), \ - scsi_opcode_name(SEEK_10), \ - scsi_opcode_name(POSITION_TO_ELEMENT), \ - scsi_opcode_name(WRITE_VERIFY), \ - scsi_opcode_name(VERIFY), \ - scsi_opcode_name(SEARCH_HIGH), \ - scsi_opcode_name(SEARCH_EQUAL), \ - scsi_opcode_name(SEARCH_LOW), \ - scsi_opcode_name(SET_LIMITS), \ - scsi_opcode_name(PRE_FETCH), \ - scsi_opcode_name(READ_POSITION), \ - scsi_opcode_name(SYNCHRONIZE_CACHE), \ - scsi_opcode_name(LOCK_UNLOCK_CACHE), \ - scsi_opcode_name(READ_DEFECT_DATA), \ - scsi_opcode_name(MEDIUM_SCAN), \ - scsi_opcode_name(COMPARE), \ - scsi_opcode_name(COPY_VERIFY), \ - scsi_opcode_name(WRITE_BUFFER), \ - scsi_opcode_name(READ_BUFFER), \ - scsi_opcode_name(UPDATE_BLOCK), \ - scsi_opcode_name(READ_LONG), \ - scsi_opcode_name(WRITE_LONG), \ - scsi_opcode_name(CHANGE_DEFINITION), \ - scsi_opcode_name(WRITE_SAME), \ - scsi_opcode_name(UNMAP), \ - scsi_opcode_name(READ_TOC), \ - scsi_opcode_name(LOG_SELECT), \ - scsi_opcode_name(LOG_SENSE), \ - scsi_opcode_name(XDWRITEREAD_10), \ - scsi_opcode_name(MODE_SELECT_10), \ - scsi_opcode_name(RESERVE_10), \ - scsi_opcode_name(RELEASE_10), \ - scsi_opcode_name(MODE_SENSE_10), \ - scsi_opcode_name(PERSISTENT_RESERVE_IN), \ - scsi_opcode_name(PERSISTENT_RESERVE_OUT), \ - scsi_opcode_name(VARIABLE_LENGTH_CMD), \ - scsi_opcode_name(REPORT_LUNS), \ - scsi_opcode_name(MAINTENANCE_IN), \ - scsi_opcode_name(MAINTENANCE_OUT), \ - scsi_opcode_name(MOVE_MEDIUM), \ - scsi_opcode_name(EXCHANGE_MEDIUM), \ - scsi_opcode_name(READ_12), \ - scsi_opcode_name(WRITE_12), \ - scsi_opcode_name(WRITE_VERIFY_12), \ - scsi_opcode_name(SEARCH_HIGH_12), \ - scsi_opcode_name(SEARCH_EQUAL_12), \ - scsi_opcode_name(SEARCH_LOW_12), \ - scsi_opcode_name(READ_ELEMENT_STATUS), \ - scsi_opcode_name(SEND_VOLUME_TAG), \ - scsi_opcode_name(WRITE_LONG_2), \ - scsi_opcode_name(READ_16), \ - scsi_opcode_name(WRITE_16), \ - scsi_opcode_name(VERIFY_16), \ - scsi_opcode_name(WRITE_SAME_16), \ - scsi_opcode_name(ZBC_OUT), \ - scsi_opcode_name(ZBC_IN), \ - scsi_opcode_name(SERVICE_ACTION_IN_16), \ - scsi_opcode_name(READ_32), \ - scsi_opcode_name(WRITE_32), \ - scsi_opcode_name(WRITE_SAME_32), \ - scsi_opcode_name(ATA_16), \ - scsi_opcode_name(ATA_12)) - -#define scsi_hostbyte_name(result) { result, #result } -#define show_hostbyte_name(val) \ - __print_symbolic(val, \ - scsi_hostbyte_name(DID_OK), \ - scsi_hostbyte_name(DID_NO_CONNECT), \ - scsi_hostbyte_name(DID_BUS_BUSY), \ - scsi_hostbyte_name(DID_TIME_OUT), \ - scsi_hostbyte_name(DID_BAD_TARGET), \ - scsi_hostbyte_name(DID_ABORT), \ - scsi_hostbyte_name(DID_PARITY), \ - scsi_hostbyte_name(DID_ERROR), \ - scsi_hostbyte_name(DID_RESET), \ - scsi_hostbyte_name(DID_BAD_INTR), \ - scsi_hostbyte_name(DID_PASSTHROUGH), \ - scsi_hostbyte_name(DID_SOFT_ERROR), \ - scsi_hostbyte_name(DID_IMM_RETRY), \ - scsi_hostbyte_name(DID_REQUEUE), \ - scsi_hostbyte_name(DID_TRANSPORT_DISRUPTED), \ - scsi_hostbyte_name(DID_TRANSPORT_FAILFAST)) - -#define scsi_driverbyte_name(result) { result, #result } -#define show_driverbyte_name(val) \ - __print_symbolic(val, \ - scsi_driverbyte_name(DRIVER_OK), \ - scsi_driverbyte_name(DRIVER_BUSY), \ - scsi_driverbyte_name(DRIVER_SOFT), \ - scsi_driverbyte_name(DRIVER_MEDIA), \ - scsi_driverbyte_name(DRIVER_ERROR), \ - scsi_driverbyte_name(DRIVER_INVALID), \ - scsi_driverbyte_name(DRIVER_TIMEOUT), \ - scsi_driverbyte_name(DRIVER_HARD), \ - scsi_driverbyte_name(DRIVER_SENSE)) - -#define scsi_msgbyte_name(result) { result, #result } -#define show_msgbyte_name(val) \ - __print_symbolic(val, \ - scsi_msgbyte_name(COMMAND_COMPLETE), \ - scsi_msgbyte_name(EXTENDED_MESSAGE), \ - scsi_msgbyte_name(SAVE_POINTERS), \ - scsi_msgbyte_name(RESTORE_POINTERS), \ - scsi_msgbyte_name(DISCONNECT), \ - scsi_msgbyte_name(INITIATOR_ERROR), \ - scsi_msgbyte_name(ABORT_TASK_SET), \ - scsi_msgbyte_name(MESSAGE_REJECT), \ - scsi_msgbyte_name(NOP), \ - scsi_msgbyte_name(MSG_PARITY_ERROR), \ - scsi_msgbyte_name(LINKED_CMD_COMPLETE), \ - scsi_msgbyte_name(LINKED_FLG_CMD_COMPLETE), \ - scsi_msgbyte_name(TARGET_RESET), \ - scsi_msgbyte_name(ABORT_TASK), \ - scsi_msgbyte_name(CLEAR_TASK_SET), \ - scsi_msgbyte_name(INITIATE_RECOVERY), \ - scsi_msgbyte_name(RELEASE_RECOVERY), \ - scsi_msgbyte_name(CLEAR_ACA), \ - scsi_msgbyte_name(LOGICAL_UNIT_RESET), \ - scsi_msgbyte_name(SIMPLE_QUEUE_TAG), \ - scsi_msgbyte_name(HEAD_OF_QUEUE_TAG), \ - scsi_msgbyte_name(ORDERED_QUEUE_TAG), \ - scsi_msgbyte_name(IGNORE_WIDE_RESIDUE), \ - scsi_msgbyte_name(ACA), \ - scsi_msgbyte_name(QAS_REQUEST), \ - scsi_msgbyte_name(BUS_DEVICE_RESET), \ - scsi_msgbyte_name(ABORT)) - -#define scsi_statusbyte_name(result) { result, #result } -#define show_statusbyte_name(val) \ - __print_symbolic(val, \ - scsi_statusbyte_name(SAM_STAT_GOOD), \ - scsi_statusbyte_name(SAM_STAT_CHECK_CONDITION), \ - scsi_statusbyte_name(SAM_STAT_CONDITION_MET), \ - scsi_statusbyte_name(SAM_STAT_BUSY), \ - scsi_statusbyte_name(SAM_STAT_INTERMEDIATE), \ - scsi_statusbyte_name(SAM_STAT_INTERMEDIATE_CONDITION_MET), \ - scsi_statusbyte_name(SAM_STAT_RESERVATION_CONFLICT), \ - scsi_statusbyte_name(SAM_STAT_COMMAND_TERMINATED), \ - scsi_statusbyte_name(SAM_STAT_TASK_SET_FULL), \ - scsi_statusbyte_name(SAM_STAT_ACA_ACTIVE), \ - scsi_statusbyte_name(SAM_STAT_TASK_ABORTED)) - -#define scsi_prot_op_name(result) { result, #result } -#define show_prot_op_name(val) \ - __print_symbolic(val, \ - scsi_prot_op_name(SCSI_PROT_NORMAL), \ - scsi_prot_op_name(SCSI_PROT_READ_INSERT), \ - scsi_prot_op_name(SCSI_PROT_WRITE_STRIP), \ - scsi_prot_op_name(SCSI_PROT_READ_STRIP), \ - scsi_prot_op_name(SCSI_PROT_WRITE_INSERT), \ - scsi_prot_op_name(SCSI_PROT_READ_PASS), \ - scsi_prot_op_name(SCSI_PROT_WRITE_PASS)) - -const char *scsi_trace_parse_cdb(struct trace_seq*, unsigned char*, int); -#define __parse_cdb(cdb, len) scsi_trace_parse_cdb(p, cdb, len) -#endif - -LTTNG_TRACEPOINT_EVENT(scsi_dispatch_cmd_start, - - TP_PROTO(struct scsi_cmnd *cmd), - - TP_ARGS(cmd), - - TP_FIELDS( - ctf_integer(unsigned int, host_no, cmd->device->host->host_no) - ctf_integer(unsigned int, channel, cmd->device->channel) - ctf_integer(unsigned int, id, cmd->device->id) - ctf_integer(unsigned int, lun, cmd->device->lun) - ctf_integer(unsigned int, opcode, cmd->cmnd[0]) - ctf_integer(unsigned int, cmd_len, cmd->cmd_len) - ctf_integer(unsigned int, data_sglen, scsi_sg_count(cmd)) - ctf_integer(unsigned int, prot_sglen, scsi_prot_sg_count(cmd)) - ctf_integer(unsigned char, prot_op, scsi_get_prot_op(cmd)) - ctf_sequence_hex(unsigned char, cmnd, cmd->cmnd, u32, cmd->cmd_len) - ) -) - -LTTNG_TRACEPOINT_EVENT(scsi_dispatch_cmd_error, - - TP_PROTO(struct scsi_cmnd *cmd, int rtn), - - TP_ARGS(cmd, rtn), - - TP_FIELDS( - ctf_integer(unsigned int, host_no, cmd->device->host->host_no) - ctf_integer(unsigned int, channel, cmd->device->channel) - ctf_integer(unsigned int, id, cmd->device->id) - ctf_integer(unsigned int, lun, cmd->device->lun) - ctf_integer(int, rtn, rtn) - ctf_integer(unsigned int, opcode, cmd->cmnd[0]) - ctf_integer(unsigned int, cmd_len, cmd->cmd_len) - ctf_integer(unsigned int, data_sglen, scsi_sg_count(cmd)) - ctf_integer(unsigned int, prot_sglen, scsi_prot_sg_count(cmd)) - ctf_integer(unsigned char, prot_op, scsi_get_prot_op(cmd)) - ctf_sequence_hex(unsigned char, cmnd, cmd->cmnd, u32, cmd->cmd_len) - ) -) - -LTTNG_TRACEPOINT_EVENT_CLASS(scsi_cmd_done_timeout_template, - - TP_PROTO(struct scsi_cmnd *cmd), - - TP_ARGS(cmd), - - TP_FIELDS( - ctf_integer(unsigned int, host_no, cmd->device->host->host_no) - ctf_integer(unsigned int, channel, cmd->device->channel) - ctf_integer(unsigned int, id, cmd->device->id) - ctf_integer(unsigned int, lun, cmd->device->lun) - ctf_integer(int, result, cmd->result) - ctf_integer(unsigned int, opcode, cmd->cmnd[0]) - ctf_integer(unsigned int, cmd_len, cmd->cmd_len) - ctf_integer(unsigned int, data_sglen, scsi_sg_count(cmd)) - ctf_integer(unsigned int, prot_sglen, scsi_prot_sg_count(cmd)) - ctf_integer(unsigned char, prot_op, scsi_get_prot_op(cmd)) - ctf_sequence_hex(unsigned char, cmnd, cmd->cmnd, u32, cmd->cmd_len) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(scsi_cmd_done_timeout_template, scsi_dispatch_cmd_done, - TP_PROTO(struct scsi_cmnd *cmd), - TP_ARGS(cmd)) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(scsi_cmd_done_timeout_template, scsi_dispatch_cmd_timeout, - TP_PROTO(struct scsi_cmnd *cmd), - TP_ARGS(cmd)) - -LTTNG_TRACEPOINT_EVENT(scsi_eh_wakeup, - - TP_PROTO(struct Scsi_Host *shost), - - TP_ARGS(shost), - - TP_FIELDS( - ctf_integer(unsigned int, host_no, shost->host_no) - ) -) - -#endif /* LTTNG_TRACE_SCSI_H */ - -/* This part must be outside protection */ -#include diff --git a/instrumentation/events/lttng-module/signal.h b/instrumentation/events/lttng-module/signal.h deleted file mode 100644 index 810dcbea..00000000 --- a/instrumentation/events/lttng-module/signal.h +++ /dev/null @@ -1,86 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -#undef TRACE_SYSTEM -#define TRACE_SYSTEM signal - -#if !defined(LTTNG_TRACE_SIGNAL_H) || defined(TRACE_HEADER_MULTI_READ) -#define LTTNG_TRACE_SIGNAL_H - -#include - -#ifndef _TRACE_SIGNAL_DEF -#define _TRACE_SIGNAL_DEF -#include -#include -#undef LTTNG_FIELDS_SIGINFO -#define LTTNG_FIELDS_SIGINFO(info) \ - ctf_integer(int, errno, \ - (info == SEND_SIG_NOINFO || info == SEND_SIG_PRIV) ? \ - 0 : \ - info->si_errno) \ - ctf_integer(int, code, \ - (info == SEND_SIG_NOINFO) ? \ - SI_USER : \ - ((info == SEND_SIG_PRIV) ? SI_KERNEL : info->si_code)) -#endif /* _TRACE_SIGNAL_DEF */ - -/** - * signal_generate - called when a signal is generated - * @sig: signal number - * @info: pointer to struct siginfo - * @task: pointer to struct task_struct - * - * Current process sends a 'sig' signal to 'task' process with - * 'info' siginfo. If 'info' is SEND_SIG_NOINFO or SEND_SIG_PRIV, - * 'info' is not a pointer and you can't access its field. Instead, - * SEND_SIG_NOINFO means that si_code is SI_USER, and SEND_SIG_PRIV - * means that si_code is SI_KERNEL. - */ -LTTNG_TRACEPOINT_EVENT(signal_generate, - - TP_PROTO(int sig, struct kernel_siginfo *info, struct task_struct *task, - int group, int result), - - TP_ARGS(sig, info, task, group, result), - - TP_FIELDS( - ctf_integer(int, sig, sig) - LTTNG_FIELDS_SIGINFO(info) - ctf_array_text(char, comm, task->comm, TASK_COMM_LEN) - ctf_integer(pid_t, pid, task->pid) - ctf_integer(int, group, group) - ctf_integer(int, result, result) - ) -) - -/** - * signal_deliver - called when a signal is delivered - * @sig: signal number - * @info: pointer to struct siginfo - * @ka: pointer to struct k_sigaction - * - * A 'sig' signal is delivered to current process with 'info' siginfo, - * and it will be handled by 'ka'. ka->sa.sa_handler can be SIG_IGN or - * SIG_DFL. - * Note that some signals reported by signal_generate tracepoint can be - * lost, ignored or modified (by debugger) before hitting this tracepoint. - * This means, this can show which signals are actually delivered, but - * matching generated signals and delivered signals may not be correct. - */ -LTTNG_TRACEPOINT_EVENT(signal_deliver, - - TP_PROTO(int sig, struct kernel_siginfo *info, struct k_sigaction *ka), - - TP_ARGS(sig, info, ka), - - TP_FIELDS( - ctf_integer(int, sig, sig) - LTTNG_FIELDS_SIGINFO(info) - ctf_integer(unsigned long, sa_handler, (unsigned long) ka->sa.sa_handler) - ctf_integer(unsigned long, sa_flags, ka->sa.sa_flags) - ) -) - -#endif /* LTTNG_TRACE_SIGNAL_H */ - -/* This part must be outside protection */ -#include diff --git a/instrumentation/events/lttng-module/skb.h b/instrumentation/events/lttng-module/skb.h deleted file mode 100644 index 5126b57d..00000000 --- a/instrumentation/events/lttng-module/skb.h +++ /dev/null @@ -1,58 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -#undef TRACE_SYSTEM -#define TRACE_SYSTEM skb - -#if !defined(LTTNG_TRACE_SKB_H) || defined(TRACE_HEADER_MULTI_READ) -#define LTTNG_TRACE_SKB_H - -#include -#include -#include - -/* - * Tracepoint for free an sk_buff: - */ -LTTNG_TRACEPOINT_EVENT_MAP(kfree_skb, - - skb_kfree, - - TP_PROTO(struct sk_buff *skb, void *location), - - TP_ARGS(skb, location), - - TP_FIELDS( - ctf_integer_hex(void *, skbaddr, skb) - ctf_integer_hex(void *, location, location) - ctf_integer_network(unsigned short, protocol, skb->protocol) - ) -) - -LTTNG_TRACEPOINT_EVENT_MAP(consume_skb, - - skb_consume, - - TP_PROTO(struct sk_buff *skb), - - TP_ARGS(skb), - - TP_FIELDS( - ctf_integer_hex(void *, skbaddr, skb) - ) -) - -LTTNG_TRACEPOINT_EVENT(skb_copy_datagram_iovec, - - TP_PROTO(const struct sk_buff *skb, int len), - - TP_ARGS(skb, len), - - TP_FIELDS( - ctf_integer_hex(const void *, skbaddr, skb) - ctf_integer(int, len, len) - ) -) - -#endif /* LTTNG_TRACE_SKB_H */ - -/* This part must be outside protection */ -#include diff --git a/instrumentation/events/lttng-module/sock.h b/instrumentation/events/lttng-module/sock.h deleted file mode 100644 index 43e12f3f..00000000 --- a/instrumentation/events/lttng-module/sock.h +++ /dev/null @@ -1,46 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -#undef TRACE_SYSTEM -#define TRACE_SYSTEM sock - -#if !defined(LTTNG_TRACE_SOCK_H) || defined(TRACE_HEADER_MULTI_READ) -#define LTTNG_TRACE_SOCK_H - -#include -#include - -LTTNG_TRACEPOINT_EVENT(sock_rcvqueue_full, - - TP_PROTO(struct sock *sk, struct sk_buff *skb), - - TP_ARGS(sk, skb), - - TP_FIELDS( - ctf_integer(int, rmem_alloc, atomic_read(&sk->sk_rmem_alloc)) - ctf_integer(unsigned int, truesize, skb->truesize) - ctf_integer(int, sk_rcvbuf, sk->sk_rcvbuf) - ) -) - -LTTNG_TRACEPOINT_EVENT(sock_exceed_buf_limit, - - TP_PROTO(struct sock *sk, struct proto *prot, long allocated, int kind), - - TP_ARGS(sk, prot, allocated, kind), - - TP_FIELDS( - ctf_string(name, prot->name) - ctf_array(long, sysctl_mem, prot->sysctl_mem, 3) - ctf_integer(long, allocated, allocated) - ctf_integer(int, sysctl_rmem, sk_get_rmem0(sk, prot)) - ctf_integer(int, rmem_alloc, atomic_read(&sk->sk_rmem_alloc)) - ctf_integer(int, sysctl_wmem, sk_get_wmem0(sk, prot)) - ctf_integer(int, wmem_alloc, refcount_read(&sk->sk_wmem_alloc)) - ctf_integer(int, wmem_queued, sk->sk_wmem_queued) - ctf_integer(int, kind, kind) - ) -) - -#endif /* LTTNG_TRACE_SOCK_H */ - -/* This part must be outside protection */ -#include diff --git a/instrumentation/events/lttng-module/timer.h b/instrumentation/events/lttng-module/timer.h deleted file mode 100644 index 263f6213..00000000 --- a/instrumentation/events/lttng-module/timer.h +++ /dev/null @@ -1,271 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -#undef TRACE_SYSTEM -#define TRACE_SYSTEM timer - -#if !defined(LTTNG_TRACE_TIMER_H) || defined(TRACE_HEADER_MULTI_READ) -#define LTTNG_TRACE_TIMER_H - -#include - -#ifndef _TRACE_TIMER_DEF_ -#define _TRACE_TIMER_DEF_ -#include -#include - -struct timer_list; - -#endif /* _TRACE_TIMER_DEF_ */ - -#define lttng_ktime_get_tv64(kt) (kt) - -LTTNG_TRACEPOINT_EVENT_CLASS(timer_class, - - TP_PROTO(struct timer_list *timer), - - TP_ARGS(timer), - - TP_FIELDS( - ctf_integer_hex(void *, timer, timer) - ) -) - -/** - * timer_init - called when the timer is initialized - * @timer: pointer to struct timer_list - */ -LTTNG_TRACEPOINT_EVENT_INSTANCE(timer_class, timer_init, - - TP_PROTO(struct timer_list *timer), - - TP_ARGS(timer) -) - -/** - * timer_start - called when the timer is started - * @timer: pointer to struct timer_list - * @expires: the timers expiry time - * @flags: the timers expiry time - */ -LTTNG_TRACEPOINT_EVENT(timer_start, - - TP_PROTO(struct timer_list *timer, unsigned long expires, - unsigned int flags), - - TP_ARGS(timer, expires, flags), - - TP_FIELDS( - ctf_integer_hex(void *, timer, timer) - ctf_integer_hex(void *, function, timer->function) - ctf_integer(unsigned long, expires, expires) - ctf_integer(unsigned long, now, jiffies) - ctf_integer(unsigned int, flags, flags) - ) -) - -/** - * timer_expire_entry - called immediately before the timer callback - * @timer: pointer to struct timer_list - * - * Allows to determine the timer latency. - */ -LTTNG_TRACEPOINT_EVENT(timer_expire_entry, - - TP_PROTO(struct timer_list *timer, unsigned long baseclk), - - TP_ARGS(timer, baseclk), - - TP_FIELDS( - ctf_integer_hex(void *, timer, timer) - ctf_integer(unsigned long, now, jiffies) - ctf_integer_hex(void *, function, timer->function) - ctf_integer(unsigned long, baseclk, baseclk) - ) -) - -/** - * timer_expire_exit - called immediately after the timer callback returns - * @timer: pointer to struct timer_list - * - * When used in combination with the timer_expire_entry tracepoint we can - * determine the runtime of the timer callback function. - * - * NOTE: Do NOT derefernce timer in TP_fast_assign. The pointer might - * be invalid. We solely track the pointer. - */ -LTTNG_TRACEPOINT_EVENT_INSTANCE(timer_class, timer_expire_exit, - - TP_PROTO(struct timer_list *timer), - - TP_ARGS(timer) -) - -/** - * timer_cancel - called when the timer is canceled - * @timer: pointer to struct timer_list - */ -LTTNG_TRACEPOINT_EVENT_INSTANCE(timer_class, timer_cancel, - - TP_PROTO(struct timer_list *timer), - - TP_ARGS(timer) -) - -/** - * hrtimer_init - called when the hrtimer is initialized - * @timer: pointer to struct hrtimer - * @clockid: the hrtimers clock - * @mode: the hrtimers mode - */ -LTTNG_TRACEPOINT_EVENT_MAP(hrtimer_init, - - timer_hrtimer_init, - - TP_PROTO(struct hrtimer *hrtimer, clockid_t clockid, - enum hrtimer_mode mode), - - TP_ARGS(hrtimer, clockid, mode), - - TP_FIELDS( - ctf_integer_hex(void *, hrtimer, hrtimer) - ctf_integer(clockid_t, clockid, clockid) - ctf_integer(enum hrtimer_mode, mode, mode) - ) -) - -/** - * hrtimer_start - called when the hrtimer is started - * @timer: pointer to struct hrtimer - */ -LTTNG_TRACEPOINT_EVENT_MAP(hrtimer_start, - - timer_hrtimer_start, - - TP_PROTO(struct hrtimer *hrtimer, enum hrtimer_mode mode), - - TP_ARGS(hrtimer, mode), - - TP_FIELDS( - ctf_integer_hex(void *, hrtimer, hrtimer) - ctf_integer_hex(void *, function, hrtimer->function) - ctf_integer(s64, expires, - lttng_ktime_get_tv64(hrtimer_get_expires(hrtimer))) - ctf_integer(s64, softexpires, - lttng_ktime_get_tv64(hrtimer_get_softexpires(hrtimer))) - ctf_integer(enum hrtimer_mode, mode, mode) - ) -) - -/** - * htimmer_expire_entry - called immediately before the hrtimer callback - * @timer: pointer to struct hrtimer - * @now: pointer to variable which contains current time of the - * timers base. - * - * Allows to determine the timer latency. - */ -LTTNG_TRACEPOINT_EVENT_MAP(hrtimer_expire_entry, - - timer_hrtimer_expire_entry, - - TP_PROTO(struct hrtimer *hrtimer, ktime_t *now), - - TP_ARGS(hrtimer, now), - - TP_FIELDS( - ctf_integer_hex(void *, hrtimer, hrtimer) - ctf_integer(s64, now, lttng_ktime_get_tv64(*now)) - ctf_integer_hex(void *, function, hrtimer->function) - ) -) - -LTTNG_TRACEPOINT_EVENT_CLASS(timer_hrtimer_class, - - TP_PROTO(struct hrtimer *hrtimer), - - TP_ARGS(hrtimer), - - TP_FIELDS( - ctf_integer_hex(void *, hrtimer, hrtimer) - ) -) - -/** - * hrtimer_expire_exit - called immediately after the hrtimer callback returns - * @timer: pointer to struct hrtimer - * - * When used in combination with the hrtimer_expire_entry tracepoint we can - * determine the runtime of the callback function. - */ -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(timer_hrtimer_class, hrtimer_expire_exit, - - timer_hrtimer_expire_exit, - - TP_PROTO(struct hrtimer *hrtimer), - - TP_ARGS(hrtimer) -) - -/** - * hrtimer_cancel - called when the hrtimer is canceled - * @hrtimer: pointer to struct hrtimer - */ -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(timer_hrtimer_class, hrtimer_cancel, - - timer_hrtimer_cancel, - - TP_PROTO(struct hrtimer *hrtimer), - - TP_ARGS(hrtimer) -) - -/** - * itimer_state - called when itimer is started or canceled - * @which: name of the interval timer - * @value: the itimers value, itimer is canceled if value->it_value is - * zero, otherwise it is started - * @expires: the itimers expiry time - */ -LTTNG_TRACEPOINT_EVENT_MAP(itimer_state, - - timer_itimer_state, - - TP_PROTO(int which, const struct itimerspec64 *const value, - unsigned long long expires), - - TP_ARGS(which, value, expires), - - TP_FIELDS( - ctf_integer(int, which, which) - ctf_integer(unsigned long long, expires, expires) - ctf_integer(long, value_sec, value->it_value.tv_sec) - ctf_integer(long, value_nsec, value->it_value.tv_nsec) - ctf_integer(long, interval_sec, value->it_interval.tv_sec) - ctf_integer(long, interval_nsec, value->it_interval.tv_nsec) - ) -) - -/** - * itimer_expire - called when itimer expires - * @which: type of the interval timer - * @pid: pid of the process which owns the timer - * @now: current time, used to calculate the latency of itimer - */ -LTTNG_TRACEPOINT_EVENT_MAP(itimer_expire, - - timer_itimer_expire, - - TP_PROTO(int which, struct pid *pid, unsigned long long now), - - TP_ARGS(which, pid, now), - - TP_FIELDS( - ctf_integer(int , which, which) - ctf_integer(pid_t, pid, pid_nr(pid)) - ctf_integer(unsigned long long, now, now) - ) -) - -#endif /* LTTNG_TRACE_TIMER_H */ - -/* This part must be outside protection */ -#include diff --git a/instrumentation/events/lttng-module/udp.h b/instrumentation/events/lttng-module/udp.h deleted file mode 100644 index 427fa006..00000000 --- a/instrumentation/events/lttng-module/udp.h +++ /dev/null @@ -1,26 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -#undef TRACE_SYSTEM -#define TRACE_SYSTEM udp - -#if !defined(LTTNG_TRACE_UDP_H) || defined(TRACE_HEADER_MULTI_READ) -#define LTTNG_TRACE_UDP_H - -#include -#include - -LTTNG_TRACEPOINT_EVENT(udp_fail_queue_rcv_skb, - - TP_PROTO(int rc, struct sock *sk), - - TP_ARGS(rc, sk), - - TP_FIELDS( - ctf_integer(int, rc, rc) - ctf_integer(__u16, lport, inet_sk(sk)->inet_num) - ) -) - -#endif /* LTTNG_TRACE_UDP_H */ - -/* This part must be outside protection */ -#include diff --git a/instrumentation/events/lttng-module/v4l2.h b/instrumentation/events/lttng-module/v4l2.h deleted file mode 100644 index 5e5bae16..00000000 --- a/instrumentation/events/lttng-module/v4l2.h +++ /dev/null @@ -1,55 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -#undef TRACE_SYSTEM -#define TRACE_SYSTEM v4l2 - -#if !defined(LTTNG_TRACE_V4L2_H) || defined(TRACE_HEADER_MULTI_READ) -#define LTTNG_TRACE_V4L2_H - -#include - -LTTNG_TRACEPOINT_EVENT_CLASS(v4l2_class, - - TP_PROTO(int minor, struct v4l2_buffer *buf), - - TP_ARGS(minor, buf), - - TP_FIELDS( - ctf_integer(int, minor, minor) - ctf_integer(u32, index, buf->index) - ctf_integer(u32, type, buf->type) - ctf_integer(u32, bytesused, buf->bytesused) - ctf_integer(u32, flags, buf->flags) - ctf_integer(u32, field, buf->field) - ctf_integer(s64, timestamp, v4l2_buffer_get_timestamp(buf)) - ctf_integer(u32, timecode_type, buf->timecode.type) - ctf_integer(u32, timecode_flags, buf->timecode.flags) - ctf_integer(u8, timecode_frames, buf->timecode.frames) - ctf_integer(u8, timecode_seconds, buf->timecode.seconds) - ctf_integer(u8, timecode_minutes, buf->timecode.minutes) - ctf_integer(u8, timecode_hours, buf->timecode.hours) - ctf_array(u8, timecode_userbits, buf->timecode.userbits, 4) - ctf_integer(u32, sequence, buf->sequence) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(v4l2_class, - v4l2_dqbuf, - - TP_PROTO(int minor, struct v4l2_buffer *buf), - - TP_ARGS(minor, buf) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(v4l2_class, - - v4l2_qbuf, - - TP_PROTO(int minor, struct v4l2_buffer *buf), - - TP_ARGS(minor, buf) -) - -#endif /* if !defined(LTTNG_TRACE_V4L2_H) || defined(TRACE_HEADER_MULTI_READ) */ - -/* This part must be outside protection */ -#include diff --git a/instrumentation/events/lttng-module/workqueue.h b/instrumentation/events/lttng-module/workqueue.h deleted file mode 100644 index c33dd3b1..00000000 --- a/instrumentation/events/lttng-module/workqueue.h +++ /dev/null @@ -1,109 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -#undef TRACE_SYSTEM -#define TRACE_SYSTEM workqueue - -#if !defined(LTTNG_TRACE_WORKQUEUE_H) || defined(TRACE_HEADER_MULTI_READ) -#define LTTNG_TRACE_WORKQUEUE_H - -#include -#include - -#ifndef _TRACE_WORKQUEUE_DEF_ -#define _TRACE_WORKQUEUE_DEF_ - -struct worker; -struct global_cwq; - -#endif - -LTTNG_TRACEPOINT_EVENT_CLASS(workqueue_work, - - TP_PROTO(struct work_struct *work), - - TP_ARGS(work), - - TP_FIELDS( - ctf_integer_hex(void *, work, work) - ) -) - -/** - * workqueue_queue_work - called when a work gets queued - * @req_cpu: the requested cpu - * @cwq: pointer to struct cpu_workqueue_struct - * @work: pointer to struct work_struct - * - * This event occurs when a work is queued immediately or once a - * delayed work is actually queued on a workqueue (ie: once the delay - * has been reached). - */ -LTTNG_TRACEPOINT_EVENT(workqueue_queue_work, - - TP_PROTO(unsigned int req_cpu, struct pool_workqueue *pwq, - struct work_struct *work), - - TP_ARGS(req_cpu, pwq, work), - - TP_FIELDS( - ctf_integer_hex(void *, work, work) - ctf_integer_hex(void *, function, work->func) - ctf_integer(unsigned int, req_cpu, req_cpu) - ) -) - -/** - * workqueue_activate_work - called when a work gets activated - * @work: pointer to struct work_struct - * - * This event occurs when a queued work is put on the active queue, - * which happens immediately after queueing unless @max_active limit - * is reached. - */ -LTTNG_TRACEPOINT_EVENT_INSTANCE(workqueue_work, workqueue_activate_work, - - TP_PROTO(struct work_struct *work), - - TP_ARGS(work) -) - -/** - * workqueue_execute_start - called immediately before the workqueue callback - * @work: pointer to struct work_struct - * - * Allows to track workqueue execution. - */ -LTTNG_TRACEPOINT_EVENT(workqueue_execute_start, - - TP_PROTO(struct work_struct *work), - - TP_ARGS(work), - - TP_FIELDS( - ctf_integer_hex(void *, work, work) - ctf_integer_hex(void *, function, work->func) - ) -) - -/** - * workqueue_execute_end - called immediately after the workqueue callback - * @work: pointer to struct work_struct - * @function: pointer to worker function - * - * Allows to track workqueue execution. - */ -LTTNG_TRACEPOINT_EVENT(workqueue_execute_end, - - TP_PROTO(struct work_struct *work, work_func_t function), - - TP_ARGS(work, function), - - TP_FIELDS( - ctf_integer_hex(void *, work, work) - ctf_integer_hex(void *, function, function) - ) -) - -#endif /* LTTNG_TRACE_WORKQUEUE_H */ - -/* This part must be outside protection */ -#include diff --git a/instrumentation/events/lttng-module/writeback.h b/instrumentation/events/lttng-module/writeback.h deleted file mode 100644 index 0bdd3c82..00000000 --- a/instrumentation/events/lttng-module/writeback.h +++ /dev/null @@ -1,359 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -#undef TRACE_SYSTEM -#define TRACE_SYSTEM writeback - -#if !defined(LTTNG_TRACE_WRITEBACK_H) || defined(TRACE_HEADER_MULTI_READ) -#define LTTNG_TRACE_WRITEBACK_H - -#include -#include -#include -#include - -#ifndef _TRACE_WRITEBACK_DEF_ -#define _TRACE_WRITEBACK_DEF_ - -static inline struct backing_dev_info *lttng_inode_to_bdi(struct inode *inode) -{ - return inode_to_bdi(inode); -} - -#endif - -#define show_inode_state(state) \ - __print_flags(state, "|", \ - {I_DIRTY_SYNC, "I_DIRTY_SYNC"}, \ - {I_DIRTY_DATASYNC, "I_DIRTY_DATASYNC"}, \ - {I_DIRTY_PAGES, "I_DIRTY_PAGES"}, \ - {I_NEW, "I_NEW"}, \ - {I_WILL_FREE, "I_WILL_FREE"}, \ - {I_FREEING, "I_FREEING"}, \ - {I_CLEAR, "I_CLEAR"}, \ - {I_SYNC, "I_SYNC"}, \ - {I_DIRTY_TIME, "I_DIRTY_TIME"}, \ - {I_DIRTY_TIME_EXPIRED, "I_DIRTY_TIME_EXPIRED"}, \ - {I_REFERENCED, "I_REFERENCED"} \ - ) - -LTTNG_TRACEPOINT_EVENT(writeback_dirty_page, - TP_PROTO(struct page *page, struct address_space *mapping), - TP_ARGS(page, mapping), - TP_FIELDS( - ctf_array_text(char, name, - mapping ? dev_name(lttng_inode_to_bdi(mapping->host)->dev) : "(unknown)", 32) - ctf_integer(unsigned long, ino, mapping ? mapping->host->i_ino : 0) - ctf_integer(pgoff_t, index, page->index) - ) -) - -LTTNG_TRACEPOINT_EVENT_CLASS(writeback_dirty_inode_template, - TP_PROTO(struct inode *inode, int flags), - TP_ARGS(inode, flags), - TP_FIELDS( - /* may be called for files on pseudo FSes w/ unregistered bdi */ - ctf_array_text(char, name, - lttng_inode_to_bdi(inode)->dev ? - dev_name(lttng_inode_to_bdi(inode)->dev) : "(unknown)", 32) - ctf_integer(unsigned long, ino, inode->i_ino) - ctf_integer(unsigned long, state, inode->i_state) - ctf_integer(unsigned long, flags, flags) - ) -) -#define LTTNG_TRACEPOINT_EVENT_WRITEBACK_DIRTY_INODE_TEMPLATE(name) \ -LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_dirty_inode_template, name, \ - TP_PROTO(struct inode *inode, int flags), \ - TP_ARGS(inode, flags)) -LTTNG_TRACEPOINT_EVENT_WRITEBACK_DIRTY_INODE_TEMPLATE(writeback_dirty_inode_start) -LTTNG_TRACEPOINT_EVENT_WRITEBACK_DIRTY_INODE_TEMPLATE(writeback_dirty_inode) -LTTNG_TRACEPOINT_EVENT_WRITEBACK_DIRTY_INODE_TEMPLATE(writeback_mark_inode_dirty) - -LTTNG_TRACEPOINT_EVENT_CLASS(writeback_write_inode_template, - TP_PROTO(struct inode *inode, struct writeback_control *wbc), - TP_ARGS(inode, wbc), - TP_FIELDS( - ctf_array_text(char, name, - dev_name(lttng_inode_to_bdi(inode)->dev), 32) - ctf_integer(unsigned long, ino, inode->i_ino) - ctf_integer(int, sync_mode, wbc->sync_mode) - ) -) - -#define LTTNG_TRACEPOINT_EVENT_WRITEBACK_WRITE_INODE(name) \ -LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_write_inode_template, name, \ - TP_PROTO(struct inode *inode, struct writeback_control *wbc), \ - TP_ARGS(inode, wbc)) -LTTNG_TRACEPOINT_EVENT_WRITEBACK_WRITE_INODE(writeback_write_inode_start) -LTTNG_TRACEPOINT_EVENT_WRITEBACK_WRITE_INODE(writeback_write_inode) - -LTTNG_TRACEPOINT_EVENT_CLASS(writeback_work_class, - TP_PROTO(struct bdi_writeback *wb, struct wb_writeback_work *work), - TP_ARGS(wb, work), - TP_FIELDS( - ctf_array_text(char, name, wb->bdi->dev ? dev_name(wb->bdi->dev) : - "(unknown)", 32) - ) -) - -#define LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(name) \ -LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_work_class, name, \ - TP_PROTO(struct bdi_writeback *wb, struct wb_writeback_work *work), \ - TP_ARGS(wb, work)) - -LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(writeback_nothread) -LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(writeback_queue) -LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(writeback_exec) -LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(writeback_start) -LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(writeback_written) -LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(writeback_wait) - -LTTNG_TRACEPOINT_EVENT(writeback_pages_written, - TP_PROTO(long pages_written), - TP_ARGS(pages_written), - TP_FIELDS( - ctf_integer(long, pages, pages_written) - ) -) - -LTTNG_TRACEPOINT_EVENT_CLASS(writeback_class, - TP_PROTO(struct bdi_writeback *wb), - TP_ARGS(wb), - TP_FIELDS( - ctf_array_text(char, name, - dev_name(wb->bdi->dev), 32) - ) -) - -#undef DEFINE_WRITEBACK_EVENT -#define DEFINE_WRITEBACK_EVENT(name) \ -LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_class, name, \ - TP_PROTO(struct bdi_writeback *wb), \ - TP_ARGS(wb)) - -#define DEFINE_WRITEBACK_EVENT_MAP(name, map) \ -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(writeback_class, name, map, \ - TP_PROTO(struct bdi_writeback *wb), \ - TP_ARGS(wb)) - -LTTNG_TRACEPOINT_EVENT(writeback_bdi_register, - TP_PROTO(struct backing_dev_info *bdi), - TP_ARGS(bdi), - TP_FIELDS( - ctf_array_text(char, name, - dev_name(bdi->dev), 32) - ) -) - -DEFINE_WRITEBACK_EVENT(writeback_nowork) -DEFINE_WRITEBACK_EVENT(writeback_wake_background) -DEFINE_WRITEBACK_EVENT(writeback_wake_thread) -DEFINE_WRITEBACK_EVENT(writeback_wake_forker_thread) -DEFINE_WRITEBACK_EVENT(writeback_bdi_unregister) -DEFINE_WRITEBACK_EVENT(writeback_thread_start) -DEFINE_WRITEBACK_EVENT(writeback_thread_stop) - -LTTNG_TRACEPOINT_EVENT_CLASS(writeback_wbc_class, - TP_PROTO(struct writeback_control *wbc, struct backing_dev_info *bdi), - TP_ARGS(wbc, bdi), - TP_FIELDS( - ctf_array_text(char, name, dev_name(bdi->dev), 32) - ctf_integer(long, nr_to_write, wbc->nr_to_write) - ctf_integer(long, pages_skipped, wbc->pages_skipped) - ctf_integer(int, sync_mode, wbc->sync_mode) - ctf_integer(int, for_kupdate, wbc->for_kupdate) - ctf_integer(int, for_background, wbc->for_background) - ctf_integer(int, for_reclaim, wbc->for_reclaim) - ctf_integer(int, range_cyclic, wbc->range_cyclic) - ctf_integer(long, range_start, (long) wbc->range_start) - ctf_integer(long, range_end, (long) wbc->range_end) - ) -) - -#undef DEFINE_WBC_EVENT -#define LTTNG_TRACEPOINT_EVENT_WBC_INSTANCE(name, map) \ -LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(writeback_wbc_class, name, map, \ - TP_PROTO(struct writeback_control *wbc, struct backing_dev_info *bdi), \ - TP_ARGS(wbc, bdi)) -LTTNG_TRACEPOINT_EVENT_WBC_INSTANCE(wbc_writepage, writeback_wbc_writepage) - -LTTNG_TRACEPOINT_EVENT(writeback_queue_io, - TP_PROTO(struct bdi_writeback *wb, - struct wb_writeback_work *work, - int moved), - TP_ARGS(wb, work, moved), - TP_FIELDS( - ctf_array_text(char, name, dev_name(wb->bdi->dev), 32) - ctf_integer(int, moved, moved) - ) -) - -LTTNG_TRACEPOINT_EVENT_MAP(global_dirty_state, - - writeback_global_dirty_state, - - TP_PROTO(struct wb_domain *domain, - unsigned long background_thresh, - unsigned long dirty_thresh - ), - - TP_ARGS(domain, - background_thresh, - dirty_thresh - ), - - TP_FIELDS( - ctf_integer(unsigned long, nr_dirty, global_node_page_state(NR_FILE_DIRTY)) - ctf_integer(unsigned long, nr_writeback, global_node_page_state(NR_WRITEBACK)) - ctf_integer(unsigned long, nr_unstable, global_node_page_state(NR_UNSTABLE_NFS)) - ctf_integer(unsigned long, nr_dirtied, global_node_page_state(NR_DIRTIED)) - ctf_integer(unsigned long, nr_written, global_node_page_state(NR_WRITTEN)) - ctf_integer(unsigned long, background_thresh, background_thresh) - ctf_integer(unsigned long, dirty_thresh, dirty_thresh) - ctf_integer(unsigned long, dirty_limit, domain->dirty_limit) - ) -) - -#define KBps(x) ((x) << (PAGE_SHIFT - 10)) - -LTTNG_TRACEPOINT_EVENT_MAP(bdi_dirty_ratelimit, - - writeback_bdi_dirty_ratelimit, - - TP_PROTO(struct bdi_writeback *wb, - unsigned long dirty_rate, - unsigned long task_ratelimit), - - TP_ARGS(wb, dirty_rate, task_ratelimit), - - TP_FIELDS( - ctf_array_text(char, bdi, dev_name(wb->bdi->dev), 32) - ctf_integer(unsigned long, write_bw, KBps(wb->bdi->wb.write_bandwidth)) - ctf_integer(unsigned long, avg_write_bw, KBps(wb->bdi->wb.avg_write_bandwidth)) - ctf_integer(unsigned long, dirty_rate, KBps(dirty_rate)) - ctf_integer(unsigned long, dirty_ratelimit, KBps(wb->bdi->wb.dirty_ratelimit)) - ctf_integer(unsigned long, task_ratelimit, KBps(task_ratelimit)) - ctf_integer(unsigned long, balanced_dirty_ratelimit, - KBps(wb->bdi->wb.balanced_dirty_ratelimit)) - ) -) - -LTTNG_TRACEPOINT_EVENT_MAP(balance_dirty_pages, - - writeback_balance_dirty_pages, - - TP_PROTO(struct wb_domain *domain, - struct bdi_writeback *wb, - struct dirty_throttle_control *sdtc, - unsigned long dirty_ratelimit, - unsigned long task_ratelimit, - unsigned long dirtied, - unsigned long period, - long pause, - unsigned long start_time), - - TP_ARGS(domain, wb, sdtc, - dirty_ratelimit, task_ratelimit, - dirtied, period, pause, start_time - ), - - TP_FIELDS( - ctf_array_text(char, bdi, dev_name(wb->bdi->dev), 32) - ctf_integer(unsigned long, limit, domain->dirty_limit) - ctf_integer(unsigned long, setpoint, - (domain->dirty_limit + (sdtc->thresh + sdtc->bg_thresh) / 2) / 2) - ctf_integer(unsigned long, dirty, sdtc->dirty) - ctf_integer(unsigned long, bdi_setpoint, - ((domain->dirty_limit + (sdtc->thresh + sdtc->bg_thresh) / 2) / 2) * - sdtc->wb_thresh / (sdtc->thresh + 1)) - ctf_integer(unsigned long, bdi_dirty, sdtc->wb_dirty) - ctf_integer(unsigned long, dirty_ratelimit, - KBps(dirty_ratelimit)) - ctf_integer(unsigned long, task_ratelimit, - KBps(task_ratelimit)) - ctf_integer(unsigned int, dirtied, dirtied) - ctf_integer(unsigned int, dirtied_pause, - current->nr_dirtied_pause) - ctf_integer(unsigned long, paused, - (jiffies - start_time) * 1000 / HZ) - ctf_integer(long, pause, pause * 1000 / HZ) - ctf_integer(unsigned long, period, - period * 1000 / HZ) - ctf_integer(long, think, - current->dirty_paused_when == 0 ? 0 : - (long)(jiffies - current->dirty_paused_when) * 1000/HZ) - ) -) - -LTTNG_TRACEPOINT_EVENT(writeback_sb_inodes_requeue, - - TP_PROTO(struct inode *inode), - TP_ARGS(inode), - - TP_FIELDS( - ctf_array_text(char, name, - dev_name(lttng_inode_to_bdi(inode)->dev), 32) - ctf_integer(unsigned long, ino, inode->i_ino) - ctf_integer(unsigned long, state, inode->i_state) - ctf_integer(unsigned long, dirtied_when, inode->dirtied_when) - ) -) - -LTTNG_TRACEPOINT_EVENT_CLASS(writeback_congest_waited_template, - - TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed), - - TP_ARGS(usec_timeout, usec_delayed), - - TP_FIELDS( - ctf_integer(unsigned int, usec_timeout, usec_timeout) - ctf_integer(unsigned int, usec_delayed, usec_delayed) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_congest_waited_template, writeback_congestion_wait, - - TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed), - - TP_ARGS(usec_timeout, usec_delayed) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_congest_waited_template, writeback_wait_iff_congested, - - TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed), - - TP_ARGS(usec_timeout, usec_delayed) -) - -LTTNG_TRACEPOINT_EVENT_CLASS(writeback_single_inode_template, - - TP_PROTO(struct inode *inode, - struct writeback_control *wbc, - unsigned long nr_to_write - ), - - TP_ARGS(inode, wbc, nr_to_write), - - TP_FIELDS( - ctf_array_text(char, name, - dev_name(lttng_inode_to_bdi(inode)->dev), 32) - ctf_integer(unsigned long, ino, inode->i_ino) - ctf_integer(unsigned long, state, inode->i_state) - ctf_integer(unsigned long, dirtied_when, inode->dirtied_when) - ctf_integer(unsigned long, writeback_index, - inode->i_mapping->writeback_index) - ctf_integer(long, nr_to_write, nr_to_write) - ctf_integer(unsigned long, wrote, - nr_to_write - wbc->nr_to_write) - ) -) - -LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_single_inode_template, writeback_single_inode, - TP_PROTO(struct inode *inode, - struct writeback_control *wbc, - unsigned long nr_to_write), - TP_ARGS(inode, wbc, nr_to_write) -) - -#endif /* LTTNG_TRACE_WRITEBACK_H */ - -/* This part must be outside protection */ -#include diff --git a/instrumentation/syscalls/3.0.34/powerpc-32-syscalls b/instrumentation/syscalls/3.0.34/powerpc-32-syscalls deleted file mode 100644 index f951c7ad..00000000 --- a/instrumentation/syscalls/3.0.34/powerpc-32-syscalls +++ /dev/null @@ -1,286 +0,0 @@ -syscall sys_restart_syscall nr 0 nbargs 0 types: () args: () -syscall sys_exit nr 1 nbargs 1 types: (int) args: (error_code) -syscall sys_read nr 3 nbargs 3 types: (unsigned int, char *, size_t) args: (fd, buf, count) -syscall sys_write nr 4 nbargs 3 types: (unsigned int, const char *, size_t) args: (fd, buf, count) -syscall sys_open nr 5 nbargs 3 types: (const char *, int, int) args: (filename, flags, mode) -syscall sys_close nr 6 nbargs 1 types: (unsigned int) args: (fd) -syscall sys_waitpid nr 7 nbargs 3 types: (pid_t, int *, int) args: (pid, stat_addr, options) -syscall sys_creat nr 8 nbargs 2 types: (const char *, int) args: (pathname, mode) -syscall sys_link nr 9 nbargs 2 types: (const char *, const char *) args: (oldname, newname) -syscall sys_unlink nr 10 nbargs 1 types: (const char *) args: (pathname) -syscall sys_chdir nr 12 nbargs 1 types: (const char *) args: (filename) -syscall sys_time nr 13 nbargs 1 types: (time_t *) args: (tloc) -syscall sys_mknod nr 14 nbargs 3 types: (const char *, int, unsigned) args: (filename, mode, dev) -syscall sys_chmod nr 15 nbargs 2 types: (const char *, mode_t) args: (filename, mode) -syscall sys_lchown nr 16 nbargs 3 types: (const char *, uid_t, gid_t) args: (filename, user, group) -syscall sys_stat nr 18 nbargs 2 types: (const char *, struct __old_kernel_stat *) args: (filename, statbuf) -syscall sys_lseek nr 19 nbargs 3 types: (unsigned int, off_t, unsigned int) args: (fd, offset, origin) -syscall sys_getpid nr 20 nbargs 0 types: () args: () -syscall sys_mount nr 21 nbargs 5 types: (char *, char *, char *, unsigned long, void *) args: (dev_name, dir_name, type, flags, data) -syscall sys_oldumount nr 22 nbargs 1 types: (char *) args: (name) -syscall sys_setuid nr 23 nbargs 1 types: (uid_t) args: (uid) -syscall sys_getuid nr 24 nbargs 0 types: () args: () -syscall sys_stime nr 25 nbargs 1 types: (time_t *) args: (tptr) -syscall sys_ptrace nr 26 nbargs 4 types: (long, long, unsigned long, unsigned long) args: (request, pid, addr, data) -syscall sys_alarm nr 27 nbargs 1 types: (unsigned int) args: (seconds) -syscall sys_fstat nr 28 nbargs 2 types: (unsigned int, struct __old_kernel_stat *) args: (fd, statbuf) -syscall sys_pause nr 29 nbargs 0 types: () args: () -syscall sys_utime nr 30 nbargs 2 types: (char *, struct utimbuf *) args: (filename, times) -syscall sys_access nr 33 nbargs 2 types: (const char *, int) args: (filename, mode) -syscall sys_nice nr 34 nbargs 1 types: (int) args: (increment) -syscall sys_sync nr 36 nbargs 0 types: () args: () -syscall sys_kill nr 37 nbargs 2 types: (pid_t, int) args: (pid, sig) -syscall sys_rename nr 38 nbargs 2 types: (const char *, const char *) args: (oldname, newname) -syscall sys_mkdir nr 39 nbargs 2 types: (const char *, int) args: (pathname, mode) -syscall sys_rmdir nr 40 nbargs 1 types: (const char *) args: (pathname) -syscall sys_dup nr 41 nbargs 1 types: (unsigned int) args: (fildes) -syscall sys_pipe nr 42 nbargs 1 types: (int *) args: (fildes) -syscall sys_times nr 43 nbargs 1 types: (struct tms *) args: (tbuf) -syscall sys_brk nr 45 nbargs 1 types: (unsigned long) args: (brk) -syscall sys_setgid nr 46 nbargs 1 types: (gid_t) args: (gid) -syscall sys_getgid nr 47 nbargs 0 types: () args: () -syscall sys_signal nr 48 nbargs 2 types: (int, __sighandler_t) args: (sig, handler) -syscall sys_geteuid nr 49 nbargs 0 types: () args: () -syscall sys_getegid nr 50 nbargs 0 types: () args: () -syscall sys_acct nr 51 nbargs 1 types: (const char *) args: (name) -syscall sys_umount nr 52 nbargs 2 types: (char *, int) args: (name, flags) -syscall sys_ioctl nr 54 nbargs 3 types: (unsigned int, unsigned int, unsigned long) args: (fd, cmd, arg) -syscall sys_fcntl nr 55 nbargs 3 types: (unsigned int, unsigned int, unsigned long) args: (fd, cmd, arg) -syscall sys_setpgid nr 57 nbargs 2 types: (pid_t, pid_t) args: (pid, pgid) -syscall sys_olduname nr 59 nbargs 1 types: (struct oldold_utsname *) args: (name) -syscall sys_umask nr 60 nbargs 1 types: (int) args: (mask) -syscall sys_chroot nr 61 nbargs 1 types: (const char *) args: (filename) -syscall sys_ustat nr 62 nbargs 2 types: (unsigned, struct ustat *) args: (dev, ubuf) -syscall sys_dup2 nr 63 nbargs 2 types: (unsigned int, unsigned int) args: (oldfd, newfd) -syscall sys_getppid nr 64 nbargs 0 types: () args: () -syscall sys_getpgrp nr 65 nbargs 0 types: () args: () -syscall sys_setsid nr 66 nbargs 0 types: () args: () -syscall sys_sgetmask nr 68 nbargs 0 types: () args: () -syscall sys_ssetmask nr 69 nbargs 1 types: (int) args: (newmask) -syscall sys_setreuid nr 70 nbargs 2 types: (uid_t, uid_t) args: (ruid, euid) -syscall sys_setregid nr 71 nbargs 2 types: (gid_t, gid_t) args: (rgid, egid) -syscall sys_sigpending nr 73 nbargs 1 types: (old_sigset_t *) args: (set) -syscall sys_sethostname nr 74 nbargs 2 types: (char *, int) args: (name, len) -syscall sys_setrlimit nr 75 nbargs 2 types: (unsigned int, struct rlimit *) args: (resource, rlim) -syscall sys_old_getrlimit nr 76 nbargs 2 types: (unsigned int, struct rlimit *) args: (resource, rlim) -syscall sys_getrusage nr 77 nbargs 2 types: (int, struct rusage *) args: (who, ru) -syscall sys_gettimeofday nr 78 nbargs 2 types: (struct timeval *, struct timezone *) args: (tv, tz) -syscall sys_settimeofday nr 79 nbargs 2 types: (struct timeval *, struct timezone *) args: (tv, tz) -syscall sys_getgroups nr 80 nbargs 2 types: (int, gid_t *) args: (gidsetsize, grouplist) -syscall sys_setgroups nr 81 nbargs 2 types: (int, gid_t *) args: (gidsetsize, grouplist) -syscall sys_symlink nr 83 nbargs 2 types: (const char *, const char *) args: (oldname, newname) -syscall sys_lstat nr 84 nbargs 2 types: (const char *, struct __old_kernel_stat *) args: (filename, statbuf) -syscall sys_readlink nr 85 nbargs 3 types: (const char *, char *, int) args: (path, buf, bufsiz) -syscall sys_uselib nr 86 nbargs 1 types: (const char *) args: (library) -syscall sys_swapon nr 87 nbargs 2 types: (const char *, int) args: (specialfile, swap_flags) -syscall sys_reboot nr 88 nbargs 4 types: (int, int, unsigned int, void *) args: (magic1, magic2, cmd, arg) -syscall sys_old_readdir nr 89 nbargs 3 types: (unsigned int, struct old_linux_dirent *, unsigned int) args: (fd, dirent, count) -syscall sys_munmap nr 91 nbargs 2 types: (unsigned long, size_t) args: (addr, len) -syscall sys_truncate nr 92 nbargs 2 types: (const char *, long) args: (path, length) -syscall sys_ftruncate nr 93 nbargs 2 types: (unsigned int, unsigned long) args: (fd, length) -syscall sys_fchmod nr 94 nbargs 2 types: (unsigned int, mode_t) args: (fd, mode) -syscall sys_fchown nr 95 nbargs 3 types: (unsigned int, uid_t, gid_t) args: (fd, user, group) -syscall sys_getpriority nr 96 nbargs 2 types: (int, int) args: (which, who) -syscall sys_setpriority nr 97 nbargs 3 types: (int, int, int) args: (which, who, niceval) -syscall sys_statfs nr 99 nbargs 2 types: (const char *, struct statfs *) args: (pathname, buf) -syscall sys_fstatfs nr 100 nbargs 2 types: (unsigned int, struct statfs *) args: (fd, buf) -syscall sys_socketcall nr 102 nbargs 2 types: (int, unsigned long *) args: (call, args) -syscall sys_syslog nr 103 nbargs 3 types: (int, char *, int) args: (type, buf, len) -syscall sys_setitimer nr 104 nbargs 3 types: (int, struct itimerval *, struct itimerval *) args: (which, value, ovalue) -syscall sys_getitimer nr 105 nbargs 2 types: (int, struct itimerval *) args: (which, value) -syscall sys_newstat nr 106 nbargs 2 types: (const char *, struct stat *) args: (filename, statbuf) -syscall sys_newlstat nr 107 nbargs 2 types: (const char *, struct stat *) args: (filename, statbuf) -syscall sys_newfstat nr 108 nbargs 2 types: (unsigned int, struct stat *) args: (fd, statbuf) -syscall sys_uname nr 109 nbargs 1 types: (struct old_utsname *) args: (name) -syscall sys_vhangup nr 111 nbargs 0 types: () args: () -syscall sys_wait4 nr 114 nbargs 4 types: (pid_t, int *, int, struct rusage *) args: (upid, stat_addr, options, ru) -syscall sys_swapoff nr 115 nbargs 1 types: (const char *) args: (specialfile) -syscall sys_sysinfo nr 116 nbargs 1 types: (struct sysinfo *) args: (info) -syscall sys_ipc nr 117 nbargs 6 types: (unsigned int, int, unsigned long, unsigned long, void *, long) args: (call, first, second, third, ptr, fifth) -syscall sys_fsync nr 118 nbargs 1 types: (unsigned int) args: (fd) -syscall sys_setdomainname nr 121 nbargs 2 types: (char *, int) args: (name, len) -syscall sys_newuname nr 122 nbargs 1 types: (struct new_utsname *) args: (name) -syscall sys_adjtimex nr 124 nbargs 1 types: (struct timex *) args: (txc_p) -syscall sys_mprotect nr 125 nbargs 3 types: (unsigned long, size_t, unsigned long) args: (start, len, prot) -syscall sys_sigprocmask nr 126 nbargs 3 types: (int, old_sigset_t *, old_sigset_t *) args: (how, nset, oset) -syscall sys_init_module nr 128 nbargs 3 types: (void *, unsigned long, const char *) args: (umod, len, uargs) -syscall sys_delete_module nr 129 nbargs 2 types: (const char *, unsigned int) args: (name_user, flags) -syscall sys_getpgid nr 132 nbargs 1 types: (pid_t) args: (pid) -syscall sys_fchdir nr 133 nbargs 1 types: (unsigned int) args: (fd) -syscall sys_bdflush nr 134 nbargs 2 types: (int, long) args: (func, data) -syscall sys_sysfs nr 135 nbargs 3 types: (int, unsigned long, unsigned long) args: (option, arg1, arg2) -syscall sys_personality nr 136 nbargs 1 types: (unsigned int) args: (personality) -syscall sys_setfsuid nr 138 nbargs 1 types: (uid_t) args: (uid) -syscall sys_setfsgid nr 139 nbargs 1 types: (gid_t) args: (gid) -syscall sys_llseek nr 140 nbargs 5 types: (unsigned int, unsigned long, unsigned long, loff_t *, unsigned int) args: (fd, offset_high, offset_low, result, origin) -syscall sys_getdents nr 141 nbargs 3 types: (unsigned int, struct linux_dirent *, unsigned int) args: (fd, dirent, count) -syscall sys_select nr 142 nbargs 5 types: (int, fd_set *, fd_set *, fd_set *, struct timeval *) args: (n, inp, outp, exp, tvp) -syscall sys_flock nr 143 nbargs 2 types: (unsigned int, unsigned int) args: (fd, cmd) -syscall sys_msync nr 144 nbargs 3 types: (unsigned long, size_t, int) args: (start, len, flags) -syscall sys_readv nr 145 nbargs 3 types: (unsigned long, const struct iovec *, unsigned long) args: (fd, vec, vlen) -syscall sys_writev nr 146 nbargs 3 types: (unsigned long, const struct iovec *, unsigned long) args: (fd, vec, vlen) -syscall sys_getsid nr 147 nbargs 1 types: (pid_t) args: (pid) -syscall sys_fdatasync nr 148 nbargs 1 types: (unsigned int) args: (fd) -syscall sys_sysctl nr 149 nbargs 1 types: (struct __sysctl_args *) args: (args) -syscall sys_mlock nr 150 nbargs 2 types: (unsigned long, size_t) args: (start, len) -syscall sys_munlock nr 151 nbargs 2 types: (unsigned long, size_t) args: (start, len) -syscall sys_mlockall nr 152 nbargs 1 types: (int) args: (flags) -syscall sys_munlockall nr 153 nbargs 0 types: () args: () -syscall sys_sched_setparam nr 154 nbargs 2 types: (pid_t, struct sched_param *) args: (pid, param) -syscall sys_sched_getparam nr 155 nbargs 2 types: (pid_t, struct sched_param *) args: (pid, param) -syscall sys_sched_setscheduler nr 156 nbargs 3 types: (pid_t, int, struct sched_param *) args: (pid, policy, param) -syscall sys_sched_getscheduler nr 157 nbargs 1 types: (pid_t) args: (pid) -syscall sys_sched_yield nr 158 nbargs 0 types: () args: () -syscall sys_sched_get_priority_max nr 159 nbargs 1 types: (int) args: (policy) -syscall sys_sched_get_priority_min nr 160 nbargs 1 types: (int) args: (policy) -syscall sys_sched_rr_get_interval nr 161 nbargs 2 types: (pid_t, struct timespec *) args: (pid, interval) -syscall sys_nanosleep nr 162 nbargs 2 types: (struct timespec *, struct timespec *) args: (rqtp, rmtp) -syscall sys_mremap nr 163 nbargs 5 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long) args: (addr, old_len, new_len, flags, new_addr) -syscall sys_setresuid nr 164 nbargs 3 types: (uid_t, uid_t, uid_t) args: (ruid, euid, suid) -syscall sys_getresuid nr 165 nbargs 3 types: (uid_t *, uid_t *, uid_t *) args: (ruid, euid, suid) -syscall sys_poll nr 167 nbargs 3 types: (struct pollfd *, unsigned int, long) args: (ufds, nfds, timeout_msecs) -syscall sys_nfsservctl nr 168 nbargs 3 types: (int, struct nfsctl_arg *, void *) args: (cmd, arg, res) -syscall sys_setresgid nr 169 nbargs 3 types: (gid_t, gid_t, gid_t) args: (rgid, egid, sgid) -syscall sys_getresgid nr 170 nbargs 3 types: (gid_t *, gid_t *, gid_t *) args: (rgid, egid, sgid) -syscall sys_prctl nr 171 nbargs 5 types: (int, unsigned long, unsigned long, unsigned long, unsigned long) args: (option, arg2, arg3, arg4, arg5) -syscall sys_rt_sigaction nr 173 nbargs 4 types: (int, const struct sigaction *, struct sigaction *, size_t) args: (sig, act, oact, sigsetsize) -syscall sys_rt_sigprocmask nr 174 nbargs 4 types: (int, sigset_t *, sigset_t *, size_t) args: (how, nset, oset, sigsetsize) -syscall sys_rt_sigpending nr 175 nbargs 2 types: (sigset_t *, size_t) args: (set, sigsetsize) -syscall sys_rt_sigtimedwait nr 176 nbargs 4 types: (const sigset_t *, siginfo_t *, const struct timespec *, size_t) args: (uthese, uinfo, uts, sigsetsize) -syscall sys_rt_sigqueueinfo nr 177 nbargs 3 types: (pid_t, int, siginfo_t *) args: (pid, sig, uinfo) -syscall sys_rt_sigsuspend nr 178 nbargs 2 types: (sigset_t *, size_t) args: (unewset, sigsetsize) -syscall sys_chown nr 181 nbargs 3 types: (const char *, uid_t, gid_t) args: (filename, user, group) -syscall sys_getcwd nr 182 nbargs 2 types: (char *, unsigned long) args: (buf, size) -syscall sys_capget nr 183 nbargs 2 types: (cap_user_header_t, cap_user_data_t) args: (header, dataptr) -syscall sys_capset nr 184 nbargs 2 types: (cap_user_header_t, const cap_user_data_t) args: (header, data) -syscall sys_sendfile nr 186 nbargs 4 types: (int, int, off_t *, size_t) args: (out_fd, in_fd, offset, count) -syscall sys_getrlimit nr 190 nbargs 2 types: (unsigned int, struct rlimit *) args: (resource, rlim) -syscall sys_stat64 nr 195 nbargs 2 types: (const char *, struct stat64 *) args: (filename, statbuf) -syscall sys_lstat64 nr 196 nbargs 2 types: (const char *, struct stat64 *) args: (filename, statbuf) -syscall sys_fstat64 nr 197 nbargs 2 types: (unsigned long, struct stat64 *) args: (fd, statbuf) -syscall sys_pciconfig_read nr 198 nbargs 5 types: (unsigned long, unsigned long, unsigned long, unsigned long, void *) args: (bus, dfn, off, len, buf) -syscall sys_pciconfig_write nr 199 nbargs 5 types: (unsigned long, unsigned long, unsigned long, unsigned long, void *) args: (bus, dfn, off, len, buf) -syscall sys_getdents64 nr 202 nbargs 3 types: (unsigned int, struct linux_dirent64 *, unsigned int) args: (fd, dirent, count) -syscall sys_pivot_root nr 203 nbargs 2 types: (const char *, const char *) args: (new_root, put_old) -syscall sys_fcntl64 nr 204 nbargs 3 types: (unsigned int, unsigned int, unsigned long) args: (fd, cmd, arg) -syscall sys_madvise nr 205 nbargs 3 types: (unsigned long, size_t, int) args: (start, len_in, behavior) -syscall sys_mincore nr 206 nbargs 3 types: (unsigned long, size_t, unsigned char *) args: (start, len, vec) -syscall sys_gettid nr 207 nbargs 0 types: () args: () -syscall sys_tkill nr 208 nbargs 2 types: (pid_t, int) args: (pid, sig) -syscall sys_setxattr nr 209 nbargs 5 types: (const char *, const char *, const void *, size_t, int) args: (pathname, name, value, size, flags) -syscall sys_lsetxattr nr 210 nbargs 5 types: (const char *, const char *, const void *, size_t, int) args: (pathname, name, value, size, flags) -syscall sys_fsetxattr nr 211 nbargs 5 types: (int, const char *, const void *, size_t, int) args: (fd, name, value, size, flags) -syscall sys_getxattr nr 212 nbargs 4 types: (const char *, const char *, void *, size_t) args: (pathname, name, value, size) -syscall sys_lgetxattr nr 213 nbargs 4 types: (const char *, const char *, void *, size_t) args: (pathname, name, value, size) -syscall sys_fgetxattr nr 214 nbargs 4 types: (int, const char *, void *, size_t) args: (fd, name, value, size) -syscall sys_listxattr nr 215 nbargs 3 types: (const char *, char *, size_t) args: (pathname, list, size) -syscall sys_llistxattr nr 216 nbargs 3 types: (const char *, char *, size_t) args: (pathname, list, size) -syscall sys_flistxattr nr 217 nbargs 3 types: (int, char *, size_t) args: (fd, list, size) -syscall sys_removexattr nr 218 nbargs 2 types: (const char *, const char *) args: (pathname, name) -syscall sys_lremovexattr nr 219 nbargs 2 types: (const char *, const char *) args: (pathname, name) -syscall sys_fremovexattr nr 220 nbargs 2 types: (int, const char *) args: (fd, name) -syscall sys_futex nr 221 nbargs 6 types: (u32 *, int, u32, struct timespec *, u32 *, u32) args: (uaddr, op, val, utime, uaddr2, val3) -syscall sys_sched_setaffinity nr 222 nbargs 3 types: (pid_t, unsigned int, unsigned long *) args: (pid, len, user_mask_ptr) -syscall sys_sched_getaffinity nr 223 nbargs 3 types: (pid_t, unsigned int, unsigned long *) args: (pid, len, user_mask_ptr) -syscall sys_sendfile64 nr 226 nbargs 4 types: (int, int, loff_t *, size_t) args: (out_fd, in_fd, offset, count) -syscall sys_io_setup nr 227 nbargs 2 types: (unsigned, aio_context_t *) args: (nr_events, ctxp) -syscall sys_io_destroy nr 228 nbargs 1 types: (aio_context_t) args: (ctx) -syscall sys_io_getevents nr 229 nbargs 5 types: (aio_context_t, long, long, struct io_event *, struct timespec *) args: (ctx_id, min_nr, nr, events, timeout) -syscall sys_io_submit nr 230 nbargs 3 types: (aio_context_t, long, struct iocb * *) args: (ctx_id, nr, iocbpp) -syscall sys_io_cancel nr 231 nbargs 3 types: (aio_context_t, struct iocb *, struct io_event *) args: (ctx_id, iocb, result) -syscall sys_set_tid_address nr 232 nbargs 1 types: (int *) args: (tidptr) -syscall sys_exit_group nr 234 nbargs 1 types: (int) args: (error_code) -syscall sys_epoll_create nr 236 nbargs 1 types: (int) args: (size) -syscall sys_epoll_ctl nr 237 nbargs 4 types: (int, int, int, struct epoll_event *) args: (epfd, op, fd, event) -syscall sys_epoll_wait nr 238 nbargs 4 types: (int, struct epoll_event *, int, int) args: (epfd, events, maxevents, timeout) -syscall sys_remap_file_pages nr 239 nbargs 5 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long) args: (start, size, prot, pgoff, flags) -syscall sys_timer_create nr 240 nbargs 3 types: (const clockid_t, struct sigevent *, timer_t *) args: (which_clock, timer_event_spec, created_timer_id) -syscall sys_timer_settime nr 241 nbargs 4 types: (timer_t, int, const struct itimerspec *, struct itimerspec *) args: (timer_id, flags, new_setting, old_setting) -syscall sys_timer_gettime nr 242 nbargs 2 types: (timer_t, struct itimerspec *) args: (timer_id, setting) -syscall sys_timer_getoverrun nr 243 nbargs 1 types: (timer_t) args: (timer_id) -syscall sys_timer_delete nr 244 nbargs 1 types: (timer_t) args: (timer_id) -syscall sys_clock_settime nr 245 nbargs 2 types: (const clockid_t, const struct timespec *) args: (which_clock, tp) -syscall sys_clock_gettime nr 246 nbargs 2 types: (const clockid_t, struct timespec *) args: (which_clock, tp) -syscall sys_clock_getres nr 247 nbargs 2 types: (const clockid_t, struct timespec *) args: (which_clock, tp) -syscall sys_clock_nanosleep nr 248 nbargs 4 types: (const clockid_t, int, const struct timespec *, struct timespec *) args: (which_clock, flags, rqtp, rmtp) -syscall sys_tgkill nr 250 nbargs 3 types: (pid_t, pid_t, int) args: (tgid, pid, sig) -syscall sys_utimes nr 251 nbargs 2 types: (char *, struct timeval *) args: (filename, utimes) -syscall sys_statfs64 nr 252 nbargs 3 types: (const char *, size_t, struct statfs64 *) args: (pathname, sz, buf) -syscall sys_fstatfs64 nr 253 nbargs 3 types: (unsigned int, size_t, struct statfs64 *) args: (fd, sz, buf) -syscall sys_mq_open nr 262 nbargs 4 types: (const char *, int, mode_t, struct mq_attr *) args: (u_name, oflag, mode, u_attr) -syscall sys_mq_unlink nr 263 nbargs 1 types: (const char *) args: (u_name) -syscall sys_mq_timedsend nr 264 nbargs 5 types: (mqd_t, const char *, size_t, unsigned int, const struct timespec *) args: (mqdes, u_msg_ptr, msg_len, msg_prio, u_abs_timeout) -syscall sys_mq_timedreceive nr 265 nbargs 5 types: (mqd_t, char *, size_t, unsigned int *, const struct timespec *) args: (mqdes, u_msg_ptr, msg_len, u_msg_prio, u_abs_timeout) -syscall sys_mq_notify nr 266 nbargs 2 types: (mqd_t, const struct sigevent *) args: (mqdes, u_notification) -syscall sys_mq_getsetattr nr 267 nbargs 3 types: (mqd_t, const struct mq_attr *, struct mq_attr *) args: (mqdes, u_mqstat, u_omqstat) -syscall sys_add_key nr 269 nbargs 5 types: (const char *, const char *, const void *, size_t, key_serial_t) args: (_type, _description, _payload, plen, ringid) -syscall sys_request_key nr 270 nbargs 4 types: (const char *, const char *, const char *, key_serial_t) args: (_type, _description, _callout_info, destringid) -syscall sys_keyctl nr 271 nbargs 5 types: (int, unsigned long, unsigned long, unsigned long, unsigned long) args: (option, arg2, arg3, arg4, arg5) -syscall sys_waitid nr 272 nbargs 5 types: (int, pid_t, struct siginfo *, int, struct rusage *) args: (which, upid, infop, options, ru) -syscall sys_ioprio_set nr 273 nbargs 3 types: (int, int, int) args: (which, who, ioprio) -syscall sys_ioprio_get nr 274 nbargs 2 types: (int, int) args: (which, who) -syscall sys_inotify_init nr 275 nbargs 0 types: () args: () -syscall sys_inotify_add_watch nr 276 nbargs 3 types: (int, const char *, u32) args: (fd, pathname, mask) -syscall sys_inotify_rm_watch nr 277 nbargs 2 types: (int, __s32) args: (fd, wd) -syscall sys_pselect6 nr 280 nbargs 6 types: (int, fd_set *, fd_set *, fd_set *, struct timespec *, void *) args: (n, inp, outp, exp, tsp, sig) -syscall sys_ppoll nr 281 nbargs 5 types: (struct pollfd *, unsigned int, struct timespec *, const sigset_t *, size_t) args: (ufds, nfds, tsp, sigmask, sigsetsize) -syscall sys_unshare nr 282 nbargs 1 types: (unsigned long) args: (unshare_flags) -syscall sys_splice nr 283 nbargs 6 types: (int, loff_t *, int, loff_t *, size_t, unsigned int) args: (fd_in, off_in, fd_out, off_out, len, flags) -syscall sys_tee nr 284 nbargs 4 types: (int, int, size_t, unsigned int) args: (fdin, fdout, len, flags) -syscall sys_vmsplice nr 285 nbargs 4 types: (int, const struct iovec *, unsigned long, unsigned int) args: (fd, iov, nr_segs, flags) -syscall sys_openat nr 286 nbargs 4 types: (int, const char *, int, int) args: (dfd, filename, flags, mode) -syscall sys_mkdirat nr 287 nbargs 3 types: (int, const char *, int) args: (dfd, pathname, mode) -syscall sys_mknodat nr 288 nbargs 4 types: (int, const char *, int, unsigned) args: (dfd, filename, mode, dev) -syscall sys_fchownat nr 289 nbargs 5 types: (int, const char *, uid_t, gid_t, int) args: (dfd, filename, user, group, flag) -syscall sys_futimesat nr 290 nbargs 3 types: (int, const char *, struct timeval *) args: (dfd, filename, utimes) -syscall sys_fstatat64 nr 291 nbargs 4 types: (int, const char *, struct stat64 *, int) args: (dfd, filename, statbuf, flag) -syscall sys_unlinkat nr 292 nbargs 3 types: (int, const char *, int) args: (dfd, pathname, flag) -syscall sys_renameat nr 293 nbargs 4 types: (int, const char *, int, const char *) args: (olddfd, oldname, newdfd, newname) -syscall sys_linkat nr 294 nbargs 5 types: (int, const char *, int, const char *, int) args: (olddfd, oldname, newdfd, newname, flags) -syscall sys_symlinkat nr 295 nbargs 3 types: (const char *, int, const char *) args: (oldname, newdfd, newname) -syscall sys_readlinkat nr 296 nbargs 4 types: (int, const char *, char *, int) args: (dfd, pathname, buf, bufsiz) -syscall sys_fchmodat nr 297 nbargs 3 types: (int, const char *, mode_t) args: (dfd, filename, mode) -syscall sys_faccessat nr 298 nbargs 3 types: (int, const char *, int) args: (dfd, filename, mode) -syscall sys_get_robust_list nr 299 nbargs 3 types: (int, struct robust_list_head * *, size_t *) args: (pid, head_ptr, len_ptr) -syscall sys_set_robust_list nr 300 nbargs 2 types: (struct robust_list_head *, size_t) args: (head, len) -syscall sys_getcpu nr 302 nbargs 3 types: (unsigned *, unsigned *, struct getcpu_cache *) args: (cpup, nodep, unused) -syscall sys_epoll_pwait nr 303 nbargs 6 types: (int, struct epoll_event *, int, int, const sigset_t *, size_t) args: (epfd, events, maxevents, timeout, sigmask, sigsetsize) -syscall sys_utimensat nr 304 nbargs 4 types: (int, const char *, struct timespec *, int) args: (dfd, filename, utimes, flags) -syscall sys_signalfd nr 305 nbargs 3 types: (int, sigset_t *, size_t) args: (ufd, user_mask, sizemask) -syscall sys_timerfd_create nr 306 nbargs 2 types: (int, int) args: (clockid, flags) -syscall sys_eventfd nr 307 nbargs 1 types: (unsigned int) args: (count) -syscall sys_timerfd_settime nr 311 nbargs 4 types: (int, int, const struct itimerspec *, struct itimerspec *) args: (ufd, flags, utmr, otmr) -syscall sys_timerfd_gettime nr 312 nbargs 2 types: (int, struct itimerspec *) args: (ufd, otmr) -syscall sys_signalfd4 nr 313 nbargs 4 types: (int, sigset_t *, size_t, int) args: (ufd, user_mask, sizemask, flags) -syscall sys_eventfd2 nr 314 nbargs 2 types: (unsigned int, int) args: (count, flags) -syscall sys_epoll_create1 nr 315 nbargs 1 types: (int) args: (flags) -syscall sys_dup3 nr 316 nbargs 3 types: (unsigned int, unsigned int, int) args: (oldfd, newfd, flags) -syscall sys_pipe2 nr 317 nbargs 2 types: (int *, int) args: (fildes, flags) -syscall sys_inotify_init1 nr 318 nbargs 1 types: (int) args: (flags) -syscall sys_perf_event_open nr 319 nbargs 5 types: (struct perf_event_attr *, pid_t, int, int, unsigned long) args: (attr_uptr, pid, cpu, group_fd, flags) -syscall sys_preadv nr 320 nbargs 5 types: (unsigned long, const struct iovec *, unsigned long, unsigned long, unsigned long) args: (fd, vec, vlen, pos_l, pos_h) -syscall sys_pwritev nr 321 nbargs 5 types: (unsigned long, const struct iovec *, unsigned long, unsigned long, unsigned long) args: (fd, vec, vlen, pos_l, pos_h) -syscall sys_rt_tgsigqueueinfo nr 322 nbargs 4 types: (pid_t, pid_t, int, siginfo_t *) args: (tgid, pid, sig, uinfo) -syscall sys_prlimit64 nr 325 nbargs 4 types: (pid_t, unsigned int, const struct rlimit64 *, struct rlimit64 *) args: (pid, resource, new_rlim, old_rlim) -syscall sys_socket nr 326 nbargs 3 types: (int, int, int) args: (family, type, protocol) -syscall sys_bind nr 327 nbargs 3 types: (int, struct sockaddr *, int) args: (fd, umyaddr, addrlen) -syscall sys_connect nr 328 nbargs 3 types: (int, struct sockaddr *, int) args: (fd, uservaddr, addrlen) -syscall sys_listen nr 329 nbargs 2 types: (int, int) args: (fd, backlog) -syscall sys_accept nr 330 nbargs 3 types: (int, struct sockaddr *, int *) args: (fd, upeer_sockaddr, upeer_addrlen) -syscall sys_getsockname nr 331 nbargs 3 types: (int, struct sockaddr *, int *) args: (fd, usockaddr, usockaddr_len) -syscall sys_getpeername nr 332 nbargs 3 types: (int, struct sockaddr *, int *) args: (fd, usockaddr, usockaddr_len) -syscall sys_socketpair nr 333 nbargs 4 types: (int, int, int, int *) args: (family, type, protocol, usockvec) -syscall sys_send nr 334 nbargs 4 types: (int, void *, size_t, unsigned) args: (fd, buff, len, flags) -syscall sys_sendto nr 335 nbargs 6 types: (int, void *, size_t, unsigned, struct sockaddr *, int) args: (fd, buff, len, flags, addr, addr_len) -syscall sys_recvfrom nr 337 nbargs 6 types: (int, void *, size_t, unsigned, struct sockaddr *, int *) args: (fd, ubuf, size, flags, addr, addr_len) -syscall sys_shutdown nr 338 nbargs 2 types: (int, int) args: (fd, how) -syscall sys_setsockopt nr 339 nbargs 5 types: (int, int, int, char *, int) args: (fd, level, optname, optval, optlen) -syscall sys_getsockopt nr 340 nbargs 5 types: (int, int, int, char *, int *) args: (fd, level, optname, optval, optlen) -syscall sys_sendmsg nr 341 nbargs 3 types: (int, struct msghdr *, unsigned) args: (fd, msg, flags) -syscall sys_recvmsg nr 342 nbargs 3 types: (int, struct msghdr *, unsigned int) args: (fd, msg, flags) -syscall sys_recvmmsg nr 343 nbargs 5 types: (int, struct mmsghdr *, unsigned int, unsigned int, struct timespec *) args: (fd, mmsg, vlen, flags, timeout) -syscall sys_accept4 nr 344 nbargs 4 types: (int, struct sockaddr *, int *, int) args: (fd, upeer_sockaddr, upeer_addrlen, flags) -syscall sys_clock_adjtime nr 347 nbargs 2 types: (const clockid_t, struct timex *) args: (which_clock, utx) -syscall sys_syncfs nr 348 nbargs 1 types: (int) args: (fd) -syscall sys_sendmmsg nr 349 nbargs 4 types: (int, struct mmsghdr *, unsigned int, unsigned int) args: (fd, mmsg, vlen, flags) -syscall sys_setns nr 350 nbargs 2 types: (int, int) args: (fd, nstype) diff --git a/instrumentation/syscalls/3.1.0-rc6/x86-32-syscalls b/instrumentation/syscalls/3.1.0-rc6/x86-32-syscalls deleted file mode 100644 index 130c1e3e..00000000 --- a/instrumentation/syscalls/3.1.0-rc6/x86-32-syscalls +++ /dev/null @@ -1,291 +0,0 @@ -syscall sys_restart_syscall nr 0 nbargs 0 types: () args: () -syscall sys_exit nr 1 nbargs 1 types: (int) args: (error_code) -syscall sys_read nr 3 nbargs 3 types: (unsigned int, char *, size_t) args: (fd, buf, count) -syscall sys_write nr 4 nbargs 3 types: (unsigned int, const char *, size_t) args: (fd, buf, count) -syscall sys_open nr 5 nbargs 3 types: (const char *, int, int) args: (filename, flags, mode) -syscall sys_close nr 6 nbargs 1 types: (unsigned int) args: (fd) -syscall sys_waitpid nr 7 nbargs 3 types: (pid_t, int *, int) args: (pid, stat_addr, options) -syscall sys_creat nr 8 nbargs 2 types: (const char *, int) args: (pathname, mode) -syscall sys_link nr 9 nbargs 2 types: (const char *, const char *) args: (oldname, newname) -syscall sys_unlink nr 10 nbargs 1 types: (const char *) args: (pathname) -syscall sys_chdir nr 12 nbargs 1 types: (const char *) args: (filename) -syscall sys_time nr 13 nbargs 1 types: (time_t *) args: (tloc) -syscall sys_mknod nr 14 nbargs 3 types: (const char *, int, unsigned) args: (filename, mode, dev) -syscall sys_chmod nr 15 nbargs 2 types: (const char *, mode_t) args: (filename, mode) -syscall sys_lchown16 nr 16 nbargs 3 types: (const char *, old_uid_t, old_gid_t) args: (filename, user, group) -syscall sys_stat nr 18 nbargs 2 types: (const char *, struct __old_kernel_stat *) args: (filename, statbuf) -syscall sys_lseek nr 19 nbargs 3 types: (unsigned int, off_t, unsigned int) args: (fd, offset, origin) -syscall sys_getpid nr 20 nbargs 0 types: () args: () -syscall sys_mount nr 21 nbargs 5 types: (char *, char *, char *, unsigned long, void *) args: (dev_name, dir_name, type, flags, data) -syscall sys_oldumount nr 22 nbargs 1 types: (char *) args: (name) -syscall sys_setuid16 nr 23 nbargs 1 types: (old_uid_t) args: (uid) -syscall sys_getuid16 nr 24 nbargs 0 types: () args: () -syscall sys_stime nr 25 nbargs 1 types: (time_t *) args: (tptr) -syscall sys_ptrace nr 26 nbargs 4 types: (long, long, unsigned long, unsigned long) args: (request, pid, addr, data) -syscall sys_alarm nr 27 nbargs 1 types: (unsigned int) args: (seconds) -syscall sys_fstat nr 28 nbargs 2 types: (unsigned int, struct __old_kernel_stat *) args: (fd, statbuf) -syscall sys_pause nr 29 nbargs 0 types: () args: () -syscall sys_utime nr 30 nbargs 2 types: (char *, struct utimbuf *) args: (filename, times) -syscall sys_access nr 33 nbargs 2 types: (const char *, int) args: (filename, mode) -syscall sys_nice nr 34 nbargs 1 types: (int) args: (increment) -syscall sys_sync nr 36 nbargs 0 types: () args: () -syscall sys_kill nr 37 nbargs 2 types: (pid_t, int) args: (pid, sig) -syscall sys_rename nr 38 nbargs 2 types: (const char *, const char *) args: (oldname, newname) -syscall sys_mkdir nr 39 nbargs 2 types: (const char *, int) args: (pathname, mode) -syscall sys_rmdir nr 40 nbargs 1 types: (const char *) args: (pathname) -syscall sys_dup nr 41 nbargs 1 types: (unsigned int) args: (fildes) -syscall sys_pipe nr 42 nbargs 1 types: (int *) args: (fildes) -syscall sys_times nr 43 nbargs 1 types: (struct tms *) args: (tbuf) -syscall sys_brk nr 45 nbargs 1 types: (unsigned long) args: (brk) -syscall sys_setgid16 nr 46 nbargs 1 types: (old_gid_t) args: (gid) -syscall sys_getgid16 nr 47 nbargs 0 types: () args: () -syscall sys_signal nr 48 nbargs 2 types: (int, __sighandler_t) args: (sig, handler) -syscall sys_geteuid16 nr 49 nbargs 0 types: () args: () -syscall sys_getegid16 nr 50 nbargs 0 types: () args: () -syscall sys_acct nr 51 nbargs 1 types: (const char *) args: (name) -syscall sys_umount nr 52 nbargs 2 types: (char *, int) args: (name, flags) -syscall sys_ioctl nr 54 nbargs 3 types: (unsigned int, unsigned int, unsigned long) args: (fd, cmd, arg) -syscall sys_fcntl nr 55 nbargs 3 types: (unsigned int, unsigned int, unsigned long) args: (fd, cmd, arg) -syscall sys_setpgid nr 57 nbargs 2 types: (pid_t, pid_t) args: (pid, pgid) -syscall sys_olduname nr 59 nbargs 1 types: (struct oldold_utsname *) args: (name) -syscall sys_umask nr 60 nbargs 1 types: (int) args: (mask) -syscall sys_chroot nr 61 nbargs 1 types: (const char *) args: (filename) -syscall sys_ustat nr 62 nbargs 2 types: (unsigned, struct ustat *) args: (dev, ubuf) -syscall sys_dup2 nr 63 nbargs 2 types: (unsigned int, unsigned int) args: (oldfd, newfd) -syscall sys_getppid nr 64 nbargs 0 types: () args: () -syscall sys_getpgrp nr 65 nbargs 0 types: () args: () -syscall sys_setsid nr 66 nbargs 0 types: () args: () -syscall sys_sgetmask nr 68 nbargs 0 types: () args: () -syscall sys_ssetmask nr 69 nbargs 1 types: (int) args: (newmask) -syscall sys_setreuid16 nr 70 nbargs 2 types: (old_uid_t, old_uid_t) args: (ruid, euid) -syscall sys_setregid16 nr 71 nbargs 2 types: (old_gid_t, old_gid_t) args: (rgid, egid) -syscall sys_sigpending nr 73 nbargs 1 types: (old_sigset_t *) args: (set) -syscall sys_sethostname nr 74 nbargs 2 types: (char *, int) args: (name, len) -syscall sys_setrlimit nr 75 nbargs 2 types: (unsigned int, struct rlimit *) args: (resource, rlim) -syscall sys_old_getrlimit nr 76 nbargs 2 types: (unsigned int, struct rlimit *) args: (resource, rlim) -syscall sys_getrusage nr 77 nbargs 2 types: (int, struct rusage *) args: (who, ru) -syscall sys_gettimeofday nr 78 nbargs 2 types: (struct timeval *, struct timezone *) args: (tv, tz) -syscall sys_settimeofday nr 79 nbargs 2 types: (struct timeval *, struct timezone *) args: (tv, tz) -syscall sys_getgroups16 nr 80 nbargs 2 types: (int, old_gid_t *) args: (gidsetsize, grouplist) -syscall sys_setgroups16 nr 81 nbargs 2 types: (int, old_gid_t *) args: (gidsetsize, grouplist) -syscall sys_old_select nr 82 nbargs 1 types: (struct sel_arg_struct *) args: (arg) -syscall sys_symlink nr 83 nbargs 2 types: (const char *, const char *) args: (oldname, newname) -syscall sys_lstat nr 84 nbargs 2 types: (const char *, struct __old_kernel_stat *) args: (filename, statbuf) -syscall sys_readlink nr 85 nbargs 3 types: (const char *, char *, int) args: (path, buf, bufsiz) -syscall sys_uselib nr 86 nbargs 1 types: (const char *) args: (library) -syscall sys_swapon nr 87 nbargs 2 types: (const char *, int) args: (specialfile, swap_flags) -syscall sys_reboot nr 88 nbargs 4 types: (int, int, unsigned int, void *) args: (magic1, magic2, cmd, arg) -syscall sys_old_readdir nr 89 nbargs 3 types: (unsigned int, struct old_linux_dirent *, unsigned int) args: (fd, dirent, count) -syscall sys_old_mmap nr 90 nbargs 1 types: (struct mmap_arg_struct *) args: (arg) -syscall sys_munmap nr 91 nbargs 2 types: (unsigned long, size_t) args: (addr, len) -syscall sys_truncate nr 92 nbargs 2 types: (const char *, long) args: (path, length) -syscall sys_ftruncate nr 93 nbargs 2 types: (unsigned int, unsigned long) args: (fd, length) -syscall sys_fchmod nr 94 nbargs 2 types: (unsigned int, mode_t) args: (fd, mode) -syscall sys_fchown16 nr 95 nbargs 3 types: (unsigned int, old_uid_t, old_gid_t) args: (fd, user, group) -syscall sys_getpriority nr 96 nbargs 2 types: (int, int) args: (which, who) -syscall sys_setpriority nr 97 nbargs 3 types: (int, int, int) args: (which, who, niceval) -syscall sys_statfs nr 99 nbargs 2 types: (const char *, struct statfs *) args: (pathname, buf) -syscall sys_fstatfs nr 100 nbargs 2 types: (unsigned int, struct statfs *) args: (fd, buf) -syscall sys_socketcall nr 102 nbargs 2 types: (int, unsigned long *) args: (call, args) -syscall sys_syslog nr 103 nbargs 3 types: (int, char *, int) args: (type, buf, len) -syscall sys_setitimer nr 104 nbargs 3 types: (int, struct itimerval *, struct itimerval *) args: (which, value, ovalue) -syscall sys_getitimer nr 105 nbargs 2 types: (int, struct itimerval *) args: (which, value) -syscall sys_newstat nr 106 nbargs 2 types: (const char *, struct stat *) args: (filename, statbuf) -syscall sys_newlstat nr 107 nbargs 2 types: (const char *, struct stat *) args: (filename, statbuf) -syscall sys_newfstat nr 108 nbargs 2 types: (unsigned int, struct stat *) args: (fd, statbuf) -syscall sys_uname nr 109 nbargs 1 types: (struct old_utsname *) args: (name) -syscall sys_vhangup nr 111 nbargs 0 types: () args: () -syscall sys_wait4 nr 114 nbargs 4 types: (pid_t, int *, int, struct rusage *) args: (upid, stat_addr, options, ru) -syscall sys_swapoff nr 115 nbargs 1 types: (const char *) args: (specialfile) -syscall sys_sysinfo nr 116 nbargs 1 types: (struct sysinfo *) args: (info) -syscall sys_ipc nr 117 nbargs 6 types: (unsigned int, int, unsigned long, unsigned long, void *, long) args: (call, first, second, third, ptr, fifth) -syscall sys_fsync nr 118 nbargs 1 types: (unsigned int) args: (fd) -syscall sys_setdomainname nr 121 nbargs 2 types: (char *, int) args: (name, len) -syscall sys_newuname nr 122 nbargs 1 types: (struct new_utsname *) args: (name) -syscall sys_adjtimex nr 124 nbargs 1 types: (struct timex *) args: (txc_p) -syscall sys_mprotect nr 125 nbargs 3 types: (unsigned long, size_t, unsigned long) args: (start, len, prot) -syscall sys_sigprocmask nr 126 nbargs 3 types: (int, old_sigset_t *, old_sigset_t *) args: (how, nset, oset) -syscall sys_init_module nr 128 nbargs 3 types: (void *, unsigned long, const char *) args: (umod, len, uargs) -syscall sys_delete_module nr 129 nbargs 2 types: (const char *, unsigned int) args: (name_user, flags) -syscall sys_quotactl nr 131 nbargs 4 types: (unsigned int, const char *, qid_t, void *) args: (cmd, special, id, addr) -syscall sys_getpgid nr 132 nbargs 1 types: (pid_t) args: (pid) -syscall sys_fchdir nr 133 nbargs 1 types: (unsigned int) args: (fd) -syscall sys_bdflush nr 134 nbargs 2 types: (int, long) args: (func, data) -syscall sys_sysfs nr 135 nbargs 3 types: (int, unsigned long, unsigned long) args: (option, arg1, arg2) -syscall sys_personality nr 136 nbargs 1 types: (unsigned int) args: (personality) -syscall sys_setfsuid16 nr 138 nbargs 1 types: (old_uid_t) args: (uid) -syscall sys_setfsgid16 nr 139 nbargs 1 types: (old_gid_t) args: (gid) -syscall sys_llseek nr 140 nbargs 5 types: (unsigned int, unsigned long, unsigned long, loff_t *, unsigned int) args: (fd, offset_high, offset_low, result, origin) -syscall sys_getdents nr 141 nbargs 3 types: (unsigned int, struct linux_dirent *, unsigned int) args: (fd, dirent, count) -syscall sys_select nr 142 nbargs 5 types: (int, fd_set *, fd_set *, fd_set *, struct timeval *) args: (n, inp, outp, exp, tvp) -syscall sys_flock nr 143 nbargs 2 types: (unsigned int, unsigned int) args: (fd, cmd) -syscall sys_msync nr 144 nbargs 3 types: (unsigned long, size_t, int) args: (start, len, flags) -syscall sys_readv nr 145 nbargs 3 types: (unsigned long, const struct iovec *, unsigned long) args: (fd, vec, vlen) -syscall sys_writev nr 146 nbargs 3 types: (unsigned long, const struct iovec *, unsigned long) args: (fd, vec, vlen) -syscall sys_getsid nr 147 nbargs 1 types: (pid_t) args: (pid) -syscall sys_fdatasync nr 148 nbargs 1 types: (unsigned int) args: (fd) -syscall sys_sysctl nr 149 nbargs 1 types: (struct __sysctl_args *) args: (args) -syscall sys_mlock nr 150 nbargs 2 types: (unsigned long, size_t) args: (start, len) -syscall sys_munlock nr 151 nbargs 2 types: (unsigned long, size_t) args: (start, len) -syscall sys_mlockall nr 152 nbargs 1 types: (int) args: (flags) -syscall sys_munlockall nr 153 nbargs 0 types: () args: () -syscall sys_sched_setparam nr 154 nbargs 2 types: (pid_t, struct sched_param *) args: (pid, param) -syscall sys_sched_getparam nr 155 nbargs 2 types: (pid_t, struct sched_param *) args: (pid, param) -syscall sys_sched_setscheduler nr 156 nbargs 3 types: (pid_t, int, struct sched_param *) args: (pid, policy, param) -syscall sys_sched_getscheduler nr 157 nbargs 1 types: (pid_t) args: (pid) -syscall sys_sched_yield nr 158 nbargs 0 types: () args: () -syscall sys_sched_get_priority_max nr 159 nbargs 1 types: (int) args: (policy) -syscall sys_sched_get_priority_min nr 160 nbargs 1 types: (int) args: (policy) -syscall sys_sched_rr_get_interval nr 161 nbargs 2 types: (pid_t, struct timespec *) args: (pid, interval) -syscall sys_nanosleep nr 162 nbargs 2 types: (struct timespec *, struct timespec *) args: (rqtp, rmtp) -syscall sys_mremap nr 163 nbargs 5 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long) args: (addr, old_len, new_len, flags, new_addr) -syscall sys_setresuid16 nr 164 nbargs 3 types: (old_uid_t, old_uid_t, old_uid_t) args: (ruid, euid, suid) -syscall sys_getresuid16 nr 165 nbargs 3 types: (old_uid_t *, old_uid_t *, old_uid_t *) args: (ruid, euid, suid) -syscall sys_poll nr 168 nbargs 3 types: (struct pollfd *, unsigned int, long) args: (ufds, nfds, timeout_msecs) -syscall sys_setresgid16 nr 170 nbargs 3 types: (old_gid_t, old_gid_t, old_gid_t) args: (rgid, egid, sgid) -syscall sys_getresgid16 nr 171 nbargs 3 types: (old_gid_t *, old_gid_t *, old_gid_t *) args: (rgid, egid, sgid) -syscall sys_prctl nr 172 nbargs 5 types: (int, unsigned long, unsigned long, unsigned long, unsigned long) args: (option, arg2, arg3, arg4, arg5) -syscall sys_rt_sigaction nr 174 nbargs 4 types: (int, const struct sigaction *, struct sigaction *, size_t) args: (sig, act, oact, sigsetsize) -syscall sys_rt_sigprocmask nr 175 nbargs 4 types: (int, sigset_t *, sigset_t *, size_t) args: (how, nset, oset, sigsetsize) -syscall sys_rt_sigpending nr 176 nbargs 2 types: (sigset_t *, size_t) args: (set, sigsetsize) -syscall sys_rt_sigtimedwait nr 177 nbargs 4 types: (const sigset_t *, siginfo_t *, const struct timespec *, size_t) args: (uthese, uinfo, uts, sigsetsize) -syscall sys_rt_sigqueueinfo nr 178 nbargs 3 types: (pid_t, int, siginfo_t *) args: (pid, sig, uinfo) -syscall sys_rt_sigsuspend nr 179 nbargs 2 types: (sigset_t *, size_t) args: (unewset, sigsetsize) -syscall sys_chown16 nr 182 nbargs 3 types: (const char *, old_uid_t, old_gid_t) args: (filename, user, group) -syscall sys_getcwd nr 183 nbargs 2 types: (char *, unsigned long) args: (buf, size) -syscall sys_capget nr 184 nbargs 2 types: (cap_user_header_t, cap_user_data_t) args: (header, dataptr) -syscall sys_capset nr 185 nbargs 2 types: (cap_user_header_t, const cap_user_data_t) args: (header, data) -syscall sys_sendfile nr 187 nbargs 4 types: (int, int, off_t *, size_t) args: (out_fd, in_fd, offset, count) -syscall sys_getrlimit nr 191 nbargs 2 types: (unsigned int, struct rlimit *) args: (resource, rlim) -syscall sys_mmap_pgoff nr 192 nbargs 6 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long, unsigned long) args: (addr, len, prot, flags, fd, pgoff) -syscall sys_stat64 nr 195 nbargs 2 types: (const char *, struct stat64 *) args: (filename, statbuf) -syscall sys_lstat64 nr 196 nbargs 2 types: (const char *, struct stat64 *) args: (filename, statbuf) -syscall sys_fstat64 nr 197 nbargs 2 types: (unsigned long, struct stat64 *) args: (fd, statbuf) -syscall sys_lchown nr 198 nbargs 3 types: (const char *, uid_t, gid_t) args: (filename, user, group) -syscall sys_getuid nr 199 nbargs 0 types: () args: () -syscall sys_getgid nr 200 nbargs 0 types: () args: () -syscall sys_geteuid nr 201 nbargs 0 types: () args: () -syscall sys_getegid nr 202 nbargs 0 types: () args: () -syscall sys_setreuid nr 203 nbargs 2 types: (uid_t, uid_t) args: (ruid, euid) -syscall sys_setregid nr 204 nbargs 2 types: (gid_t, gid_t) args: (rgid, egid) -syscall sys_getgroups nr 205 nbargs 2 types: (int, gid_t *) args: (gidsetsize, grouplist) -syscall sys_setgroups nr 206 nbargs 2 types: (int, gid_t *) args: (gidsetsize, grouplist) -syscall sys_fchown nr 207 nbargs 3 types: (unsigned int, uid_t, gid_t) args: (fd, user, group) -syscall sys_setresuid nr 208 nbargs 3 types: (uid_t, uid_t, uid_t) args: (ruid, euid, suid) -syscall sys_getresuid nr 209 nbargs 3 types: (uid_t *, uid_t *, uid_t *) args: (ruid, euid, suid) -syscall sys_setresgid nr 210 nbargs 3 types: (gid_t, gid_t, gid_t) args: (rgid, egid, sgid) -syscall sys_getresgid nr 211 nbargs 3 types: (gid_t *, gid_t *, gid_t *) args: (rgid, egid, sgid) -syscall sys_chown nr 212 nbargs 3 types: (const char *, uid_t, gid_t) args: (filename, user, group) -syscall sys_setuid nr 213 nbargs 1 types: (uid_t) args: (uid) -syscall sys_setgid nr 214 nbargs 1 types: (gid_t) args: (gid) -syscall sys_setfsuid nr 215 nbargs 1 types: (uid_t) args: (uid) -syscall sys_setfsgid nr 216 nbargs 1 types: (gid_t) args: (gid) -syscall sys_pivot_root nr 217 nbargs 2 types: (const char *, const char *) args: (new_root, put_old) -syscall sys_mincore nr 218 nbargs 3 types: (unsigned long, size_t, unsigned char *) args: (start, len, vec) -syscall sys_madvise nr 219 nbargs 3 types: (unsigned long, size_t, int) args: (start, len_in, behavior) -syscall sys_getdents64 nr 220 nbargs 3 types: (unsigned int, struct linux_dirent64 *, unsigned int) args: (fd, dirent, count) -syscall sys_fcntl64 nr 221 nbargs 3 types: (unsigned int, unsigned int, unsigned long) args: (fd, cmd, arg) -syscall sys_gettid nr 224 nbargs 0 types: () args: () -syscall sys_setxattr nr 226 nbargs 5 types: (const char *, const char *, const void *, size_t, int) args: (pathname, name, value, size, flags) -syscall sys_lsetxattr nr 227 nbargs 5 types: (const char *, const char *, const void *, size_t, int) args: (pathname, name, value, size, flags) -syscall sys_fsetxattr nr 228 nbargs 5 types: (int, const char *, const void *, size_t, int) args: (fd, name, value, size, flags) -syscall sys_getxattr nr 229 nbargs 4 types: (const char *, const char *, void *, size_t) args: (pathname, name, value, size) -syscall sys_lgetxattr nr 230 nbargs 4 types: (const char *, const char *, void *, size_t) args: (pathname, name, value, size) -syscall sys_fgetxattr nr 231 nbargs 4 types: (int, const char *, void *, size_t) args: (fd, name, value, size) -syscall sys_listxattr nr 232 nbargs 3 types: (const char *, char *, size_t) args: (pathname, list, size) -syscall sys_llistxattr nr 233 nbargs 3 types: (const char *, char *, size_t) args: (pathname, list, size) -syscall sys_flistxattr nr 234 nbargs 3 types: (int, char *, size_t) args: (fd, list, size) -syscall sys_removexattr nr 235 nbargs 2 types: (const char *, const char *) args: (pathname, name) -syscall sys_lremovexattr nr 236 nbargs 2 types: (const char *, const char *) args: (pathname, name) -syscall sys_fremovexattr nr 237 nbargs 2 types: (int, const char *) args: (fd, name) -syscall sys_tkill nr 238 nbargs 2 types: (pid_t, int) args: (pid, sig) -syscall sys_sendfile64 nr 239 nbargs 4 types: (int, int, loff_t *, size_t) args: (out_fd, in_fd, offset, count) -syscall sys_futex nr 240 nbargs 6 types: (u32 *, int, u32, struct timespec *, u32 *, u32) args: (uaddr, op, val, utime, uaddr2, val3) -syscall sys_sched_setaffinity nr 241 nbargs 3 types: (pid_t, unsigned int, unsigned long *) args: (pid, len, user_mask_ptr) -syscall sys_sched_getaffinity nr 242 nbargs 3 types: (pid_t, unsigned int, unsigned long *) args: (pid, len, user_mask_ptr) -syscall sys_io_setup nr 245 nbargs 2 types: (unsigned, aio_context_t *) args: (nr_events, ctxp) -syscall sys_io_destroy nr 246 nbargs 1 types: (aio_context_t) args: (ctx) -syscall sys_io_getevents nr 247 nbargs 5 types: (aio_context_t, long, long, struct io_event *, struct timespec *) args: (ctx_id, min_nr, nr, events, timeout) -syscall sys_io_submit nr 248 nbargs 3 types: (aio_context_t, long, struct iocb * *) args: (ctx_id, nr, iocbpp) -syscall sys_io_cancel nr 249 nbargs 3 types: (aio_context_t, struct iocb *, struct io_event *) args: (ctx_id, iocb, result) -syscall sys_exit_group nr 252 nbargs 1 types: (int) args: (error_code) -syscall sys_epoll_create nr 254 nbargs 1 types: (int) args: (size) -syscall sys_epoll_ctl nr 255 nbargs 4 types: (int, int, int, struct epoll_event *) args: (epfd, op, fd, event) -syscall sys_epoll_wait nr 256 nbargs 4 types: (int, struct epoll_event *, int, int) args: (epfd, events, maxevents, timeout) -syscall sys_remap_file_pages nr 257 nbargs 5 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long) args: (start, size, prot, pgoff, flags) -syscall sys_set_tid_address nr 258 nbargs 1 types: (int *) args: (tidptr) -syscall sys_timer_create nr 259 nbargs 3 types: (const clockid_t, struct sigevent *, timer_t *) args: (which_clock, timer_event_spec, created_timer_id) -syscall sys_timer_settime nr 260 nbargs 4 types: (timer_t, int, const struct itimerspec *, struct itimerspec *) args: (timer_id, flags, new_setting, old_setting) -syscall sys_timer_gettime nr 261 nbargs 2 types: (timer_t, struct itimerspec *) args: (timer_id, setting) -syscall sys_timer_getoverrun nr 262 nbargs 1 types: (timer_t) args: (timer_id) -syscall sys_timer_delete nr 263 nbargs 1 types: (timer_t) args: (timer_id) -syscall sys_clock_settime nr 264 nbargs 2 types: (const clockid_t, const struct timespec *) args: (which_clock, tp) -syscall sys_clock_gettime nr 265 nbargs 2 types: (const clockid_t, struct timespec *) args: (which_clock, tp) -syscall sys_clock_getres nr 266 nbargs 2 types: (const clockid_t, struct timespec *) args: (which_clock, tp) -syscall sys_clock_nanosleep nr 267 nbargs 4 types: (const clockid_t, int, const struct timespec *, struct timespec *) args: (which_clock, flags, rqtp, rmtp) -syscall sys_statfs64 nr 268 nbargs 3 types: (const char *, size_t, struct statfs64 *) args: (pathname, sz, buf) -syscall sys_fstatfs64 nr 269 nbargs 3 types: (unsigned int, size_t, struct statfs64 *) args: (fd, sz, buf) -syscall sys_tgkill nr 270 nbargs 3 types: (pid_t, pid_t, int) args: (tgid, pid, sig) -syscall sys_utimes nr 271 nbargs 2 types: (char *, struct timeval *) args: (filename, utimes) -syscall sys_mq_open nr 277 nbargs 4 types: (const char *, int, mode_t, struct mq_attr *) args: (u_name, oflag, mode, u_attr) -syscall sys_mq_unlink nr 278 nbargs 1 types: (const char *) args: (u_name) -syscall sys_mq_timedsend nr 279 nbargs 5 types: (mqd_t, const char *, size_t, unsigned int, const struct timespec *) args: (mqdes, u_msg_ptr, msg_len, msg_prio, u_abs_timeout) -syscall sys_mq_timedreceive nr 280 nbargs 5 types: (mqd_t, char *, size_t, unsigned int *, const struct timespec *) args: (mqdes, u_msg_ptr, msg_len, u_msg_prio, u_abs_timeout) -syscall sys_mq_notify nr 281 nbargs 2 types: (mqd_t, const struct sigevent *) args: (mqdes, u_notification) -syscall sys_mq_getsetattr nr 282 nbargs 3 types: (mqd_t, const struct mq_attr *, struct mq_attr *) args: (mqdes, u_mqstat, u_omqstat) -syscall sys_kexec_load nr 283 nbargs 4 types: (unsigned long, unsigned long, struct kexec_segment *, unsigned long) args: (entry, nr_segments, segments, flags) -syscall sys_waitid nr 284 nbargs 5 types: (int, pid_t, struct siginfo *, int, struct rusage *) args: (which, upid, infop, options, ru) -syscall sys_add_key nr 286 nbargs 5 types: (const char *, const char *, const void *, size_t, key_serial_t) args: (_type, _description, _payload, plen, ringid) -syscall sys_request_key nr 287 nbargs 4 types: (const char *, const char *, const char *, key_serial_t) args: (_type, _description, _callout_info, destringid) -syscall sys_keyctl nr 288 nbargs 5 types: (int, unsigned long, unsigned long, unsigned long, unsigned long) args: (option, arg2, arg3, arg4, arg5) -syscall sys_ioprio_set nr 289 nbargs 3 types: (int, int, int) args: (which, who, ioprio) -syscall sys_ioprio_get nr 290 nbargs 2 types: (int, int) args: (which, who) -syscall sys_inotify_init nr 291 nbargs 0 types: () args: () -syscall sys_inotify_add_watch nr 292 nbargs 3 types: (int, const char *, u32) args: (fd, pathname, mask) -syscall sys_inotify_rm_watch nr 293 nbargs 2 types: (int, __s32) args: (fd, wd) -syscall sys_openat nr 295 nbargs 4 types: (int, const char *, int, int) args: (dfd, filename, flags, mode) -syscall sys_mkdirat nr 296 nbargs 3 types: (int, const char *, int) args: (dfd, pathname, mode) -syscall sys_mknodat nr 297 nbargs 4 types: (int, const char *, int, unsigned) args: (dfd, filename, mode, dev) -syscall sys_fchownat nr 298 nbargs 5 types: (int, const char *, uid_t, gid_t, int) args: (dfd, filename, user, group, flag) -syscall sys_futimesat nr 299 nbargs 3 types: (int, const char *, struct timeval *) args: (dfd, filename, utimes) -syscall sys_fstatat64 nr 300 nbargs 4 types: (int, const char *, struct stat64 *, int) args: (dfd, filename, statbuf, flag) -syscall sys_unlinkat nr 301 nbargs 3 types: (int, const char *, int) args: (dfd, pathname, flag) -syscall sys_renameat nr 302 nbargs 4 types: (int, const char *, int, const char *) args: (olddfd, oldname, newdfd, newname) -syscall sys_linkat nr 303 nbargs 5 types: (int, const char *, int, const char *, int) args: (olddfd, oldname, newdfd, newname, flags) -syscall sys_symlinkat nr 304 nbargs 3 types: (const char *, int, const char *) args: (oldname, newdfd, newname) -syscall sys_readlinkat nr 305 nbargs 4 types: (int, const char *, char *, int) args: (dfd, pathname, buf, bufsiz) -syscall sys_fchmodat nr 306 nbargs 3 types: (int, const char *, mode_t) args: (dfd, filename, mode) -syscall sys_faccessat nr 307 nbargs 3 types: (int, const char *, int) args: (dfd, filename, mode) -syscall sys_pselect6 nr 308 nbargs 6 types: (int, fd_set *, fd_set *, fd_set *, struct timespec *, void *) args: (n, inp, outp, exp, tsp, sig) -syscall sys_ppoll nr 309 nbargs 5 types: (struct pollfd *, unsigned int, struct timespec *, const sigset_t *, size_t) args: (ufds, nfds, tsp, sigmask, sigsetsize) -syscall sys_unshare nr 310 nbargs 1 types: (unsigned long) args: (unshare_flags) -syscall sys_set_robust_list nr 311 nbargs 2 types: (struct robust_list_head *, size_t) args: (head, len) -syscall sys_get_robust_list nr 312 nbargs 3 types: (int, struct robust_list_head * *, size_t *) args: (pid, head_ptr, len_ptr) -syscall sys_splice nr 313 nbargs 6 types: (int, loff_t *, int, loff_t *, size_t, unsigned int) args: (fd_in, off_in, fd_out, off_out, len, flags) -syscall sys_tee nr 315 nbargs 4 types: (int, int, size_t, unsigned int) args: (fdin, fdout, len, flags) -syscall sys_vmsplice nr 316 nbargs 4 types: (int, const struct iovec *, unsigned long, unsigned int) args: (fd, iov, nr_segs, flags) -syscall sys_getcpu nr 318 nbargs 3 types: (unsigned *, unsigned *, struct getcpu_cache *) args: (cpup, nodep, unused) -syscall sys_epoll_pwait nr 319 nbargs 6 types: (int, struct epoll_event *, int, int, const sigset_t *, size_t) args: (epfd, events, maxevents, timeout, sigmask, sigsetsize) -syscall sys_utimensat nr 320 nbargs 4 types: (int, const char *, struct timespec *, int) args: (dfd, filename, utimes, flags) -syscall sys_signalfd nr 321 nbargs 3 types: (int, sigset_t *, size_t) args: (ufd, user_mask, sizemask) -syscall sys_timerfd_create nr 322 nbargs 2 types: (int, int) args: (clockid, flags) -syscall sys_eventfd nr 323 nbargs 1 types: (unsigned int) args: (count) -syscall sys_timerfd_settime nr 325 nbargs 4 types: (int, int, const struct itimerspec *, struct itimerspec *) args: (ufd, flags, utmr, otmr) -syscall sys_timerfd_gettime nr 326 nbargs 2 types: (int, struct itimerspec *) args: (ufd, otmr) -syscall sys_signalfd4 nr 327 nbargs 4 types: (int, sigset_t *, size_t, int) args: (ufd, user_mask, sizemask, flags) -syscall sys_eventfd2 nr 328 nbargs 2 types: (unsigned int, int) args: (count, flags) -syscall sys_epoll_create1 nr 329 nbargs 1 types: (int) args: (flags) -syscall sys_dup3 nr 330 nbargs 3 types: (unsigned int, unsigned int, int) args: (oldfd, newfd, flags) -syscall sys_pipe2 nr 331 nbargs 2 types: (int *, int) args: (fildes, flags) -syscall sys_inotify_init1 nr 332 nbargs 1 types: (int) args: (flags) -syscall sys_preadv nr 333 nbargs 5 types: (unsigned long, const struct iovec *, unsigned long, unsigned long, unsigned long) args: (fd, vec, vlen, pos_l, pos_h) -syscall sys_pwritev nr 334 nbargs 5 types: (unsigned long, const struct iovec *, unsigned long, unsigned long, unsigned long) args: (fd, vec, vlen, pos_l, pos_h) -syscall sys_rt_tgsigqueueinfo nr 335 nbargs 4 types: (pid_t, pid_t, int, siginfo_t *) args: (tgid, pid, sig, uinfo) -syscall sys_perf_event_open nr 336 nbargs 5 types: (struct perf_event_attr *, pid_t, int, int, unsigned long) args: (attr_uptr, pid, cpu, group_fd, flags) -syscall sys_recvmmsg nr 337 nbargs 5 types: (int, struct mmsghdr *, unsigned int, unsigned int, struct timespec *) args: (fd, mmsg, vlen, flags, timeout) -syscall sys_fanotify_init nr 338 nbargs 2 types: (unsigned int, unsigned int) args: (flags, event_f_flags) -syscall sys_prlimit64 nr 340 nbargs 4 types: (pid_t, unsigned int, const struct rlimit64 *, struct rlimit64 *) args: (pid, resource, new_rlim, old_rlim) -syscall sys_clock_adjtime nr 343 nbargs 2 types: (const clockid_t, struct timex *) args: (which_clock, utx) -syscall sys_syncfs nr 344 nbargs 1 types: (int) args: (fd) -syscall sys_sendmmsg nr 345 nbargs 4 types: (int, struct mmsghdr *, unsigned int, unsigned int) args: (fd, mmsg, vlen, flags) -syscall sys_setns nr 346 nbargs 2 types: (int, int) args: (fd, nstype) diff --git a/instrumentation/syscalls/3.10.0-rc7/x86-64-syscalls b/instrumentation/syscalls/3.10.0-rc7/x86-64-syscalls deleted file mode 100644 index 5db1a4f1..00000000 --- a/instrumentation/syscalls/3.10.0-rc7/x86-64-syscalls +++ /dev/null @@ -1,289 +0,0 @@ -syscall sys_read nr 0 nbargs 3 types: (unsigned int, char *, size_t) args: (fd, buf, count) -syscall sys_write nr 1 nbargs 3 types: (unsigned int, const char *, size_t) args: (fd, buf, count) -syscall sys_open nr 2 nbargs 3 types: (const char *, int, umode_t) args: (filename, flags, mode) -syscall sys_close nr 3 nbargs 1 types: (unsigned int) args: (fd) -syscall sys_newstat nr 4 nbargs 2 types: (const char *, struct stat *) args: (filename, statbuf) -syscall sys_newfstat nr 5 nbargs 2 types: (unsigned int, struct stat *) args: (fd, statbuf) -syscall sys_newlstat nr 6 nbargs 2 types: (const char *, struct stat *) args: (filename, statbuf) -syscall sys_poll nr 7 nbargs 3 types: (struct pollfd *, unsigned int, int) args: (ufds, nfds, timeout_msecs) -syscall sys_lseek nr 8 nbargs 3 types: (unsigned int, off_t, unsigned int) args: (fd, offset, whence) -syscall sys_mmap nr 9 nbargs 6 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long, unsigned long) args: (addr, len, prot, flags, fd, off) -syscall sys_mprotect nr 10 nbargs 3 types: (unsigned long, size_t, unsigned long) args: (start, len, prot) -syscall sys_munmap nr 11 nbargs 2 types: (unsigned long, size_t) args: (addr, len) -syscall sys_brk nr 12 nbargs 1 types: (unsigned long) args: (brk) -syscall sys_rt_sigaction nr 13 nbargs 4 types: (int, const struct sigaction *, struct sigaction *, size_t) args: (sig, act, oact, sigsetsize) -syscall sys_rt_sigprocmask nr 14 nbargs 4 types: (int, sigset_t *, sigset_t *, size_t) args: (how, nset, oset, sigsetsize) -syscall sys_ioctl nr 16 nbargs 3 types: (unsigned int, unsigned int, unsigned long) args: (fd, cmd, arg) -syscall sys_pread64 nr 17 nbargs 4 types: (unsigned int, char *, size_t, loff_t) args: (fd, buf, count, pos) -syscall sys_pwrite64 nr 18 nbargs 4 types: (unsigned int, const char *, size_t, loff_t) args: (fd, buf, count, pos) -syscall sys_readv nr 19 nbargs 3 types: (unsigned long, const struct iovec *, unsigned long) args: (fd, vec, vlen) -syscall sys_writev nr 20 nbargs 3 types: (unsigned long, const struct iovec *, unsigned long) args: (fd, vec, vlen) -syscall sys_access nr 21 nbargs 2 types: (const char *, int) args: (filename, mode) -syscall sys_pipe nr 22 nbargs 1 types: (int *) args: (fildes) -syscall sys_select nr 23 nbargs 5 types: (int, fd_set *, fd_set *, fd_set *, struct timeval *) args: (n, inp, outp, exp, tvp) -syscall sys_sched_yield nr 24 nbargs 0 types: () args: () -syscall sys_mremap nr 25 nbargs 5 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long) args: (addr, old_len, new_len, flags, new_addr) -syscall sys_msync nr 26 nbargs 3 types: (unsigned long, size_t, int) args: (start, len, flags) -syscall sys_mincore nr 27 nbargs 3 types: (unsigned long, size_t, unsigned char *) args: (start, len, vec) -syscall sys_madvise nr 28 nbargs 3 types: (unsigned long, size_t, int) args: (start, len_in, behavior) -syscall sys_shmget nr 29 nbargs 3 types: (key_t, size_t, int) args: (key, size, shmflg) -syscall sys_shmat nr 30 nbargs 3 types: (int, char *, int) args: (shmid, shmaddr, shmflg) -syscall sys_shmctl nr 31 nbargs 3 types: (int, int, struct shmid_ds *) args: (shmid, cmd, buf) -syscall sys_dup nr 32 nbargs 1 types: (unsigned int) args: (fildes) -syscall sys_dup2 nr 33 nbargs 2 types: (unsigned int, unsigned int) args: (oldfd, newfd) -syscall sys_pause nr 34 nbargs 0 types: () args: () -syscall sys_nanosleep nr 35 nbargs 2 types: (struct timespec *, struct timespec *) args: (rqtp, rmtp) -syscall sys_getitimer nr 36 nbargs 2 types: (int, struct itimerval *) args: (which, value) -syscall sys_alarm nr 37 nbargs 1 types: (unsigned int) args: (seconds) -syscall sys_setitimer nr 38 nbargs 3 types: (int, struct itimerval *, struct itimerval *) args: (which, value, ovalue) -syscall sys_getpid nr 39 nbargs 0 types: () args: () -syscall sys_sendfile64 nr 40 nbargs 4 types: (int, int, loff_t *, size_t) args: (out_fd, in_fd, offset, count) -syscall sys_socket nr 41 nbargs 3 types: (int, int, int) args: (family, type, protocol) -syscall sys_connect nr 42 nbargs 3 types: (int, struct sockaddr *, int) args: (fd, uservaddr, addrlen) -syscall sys_accept nr 43 nbargs 3 types: (int, struct sockaddr *, int *) args: (fd, upeer_sockaddr, upeer_addrlen) -syscall sys_sendto nr 44 nbargs 6 types: (int, void *, size_t, unsigned int, struct sockaddr *, int) args: (fd, buff, len, flags, addr, addr_len) -syscall sys_recvfrom nr 45 nbargs 6 types: (int, void *, size_t, unsigned int, struct sockaddr *, int *) args: (fd, ubuf, size, flags, addr, addr_len) -syscall sys_sendmsg nr 46 nbargs 3 types: (int, struct msghdr *, unsigned int) args: (fd, msg, flags) -syscall sys_recvmsg nr 47 nbargs 3 types: (int, struct msghdr *, unsigned int) args: (fd, msg, flags) -syscall sys_shutdown nr 48 nbargs 2 types: (int, int) args: (fd, how) -syscall sys_bind nr 49 nbargs 3 types: (int, struct sockaddr *, int) args: (fd, umyaddr, addrlen) -syscall sys_listen nr 50 nbargs 2 types: (int, int) args: (fd, backlog) -syscall sys_getsockname nr 51 nbargs 3 types: (int, struct sockaddr *, int *) args: (fd, usockaddr, usockaddr_len) -syscall sys_getpeername nr 52 nbargs 3 types: (int, struct sockaddr *, int *) args: (fd, usockaddr, usockaddr_len) -syscall sys_socketpair nr 53 nbargs 4 types: (int, int, int, int *) args: (family, type, protocol, usockvec) -syscall sys_setsockopt nr 54 nbargs 5 types: (int, int, int, char *, int) args: (fd, level, optname, optval, optlen) -syscall sys_getsockopt nr 55 nbargs 5 types: (int, int, int, char *, int *) args: (fd, level, optname, optval, optlen) -syscall sys_exit nr 60 nbargs 1 types: (int) args: (error_code) -syscall sys_wait4 nr 61 nbargs 4 types: (pid_t, int *, int, struct rusage *) args: (upid, stat_addr, options, ru) -syscall sys_kill nr 62 nbargs 2 types: (pid_t, int) args: (pid, sig) -syscall sys_newuname nr 63 nbargs 1 types: (struct new_utsname *) args: (name) -syscall sys_semget nr 64 nbargs 3 types: (key_t, int, int) args: (key, nsems, semflg) -syscall sys_semop nr 65 nbargs 3 types: (int, struct sembuf *, unsigned) args: (semid, tsops, nsops) -syscall sys_semctl nr 66 nbargs 4 types: (int, int, int, unsigned long) args: (semid, semnum, cmd, arg) -syscall sys_shmdt nr 67 nbargs 1 types: (char *) args: (shmaddr) -syscall sys_msgget nr 68 nbargs 2 types: (key_t, int) args: (key, msgflg) -syscall sys_msgsnd nr 69 nbargs 4 types: (int, struct msgbuf *, size_t, int) args: (msqid, msgp, msgsz, msgflg) -syscall sys_msgrcv nr 70 nbargs 5 types: (int, struct msgbuf *, size_t, long, int) args: (msqid, msgp, msgsz, msgtyp, msgflg) -syscall sys_msgctl nr 71 nbargs 3 types: (int, int, struct msqid_ds *) args: (msqid, cmd, buf) -syscall sys_fcntl nr 72 nbargs 3 types: (unsigned int, unsigned int, unsigned long) args: (fd, cmd, arg) -syscall sys_flock nr 73 nbargs 2 types: (unsigned int, unsigned int) args: (fd, cmd) -syscall sys_fsync nr 74 nbargs 1 types: (unsigned int) args: (fd) -syscall sys_fdatasync nr 75 nbargs 1 types: (unsigned int) args: (fd) -syscall sys_truncate nr 76 nbargs 2 types: (const char *, long) args: (path, length) -syscall sys_ftruncate nr 77 nbargs 2 types: (unsigned int, unsigned long) args: (fd, length) -syscall sys_getdents nr 78 nbargs 3 types: (unsigned int, struct linux_dirent *, unsigned int) args: (fd, dirent, count) -syscall sys_getcwd nr 79 nbargs 2 types: (char *, unsigned long) args: (buf, size) -syscall sys_chdir nr 80 nbargs 1 types: (const char *) args: (filename) -syscall sys_fchdir nr 81 nbargs 1 types: (unsigned int) args: (fd) -syscall sys_rename nr 82 nbargs 2 types: (const char *, const char *) args: (oldname, newname) -syscall sys_mkdir nr 83 nbargs 2 types: (const char *, umode_t) args: (pathname, mode) -syscall sys_rmdir nr 84 nbargs 1 types: (const char *) args: (pathname) -syscall sys_creat nr 85 nbargs 2 types: (const char *, umode_t) args: (pathname, mode) -syscall sys_link nr 86 nbargs 2 types: (const char *, const char *) args: (oldname, newname) -syscall sys_unlink nr 87 nbargs 1 types: (const char *) args: (pathname) -syscall sys_symlink nr 88 nbargs 2 types: (const char *, const char *) args: (oldname, newname) -syscall sys_readlink nr 89 nbargs 3 types: (const char *, char *, int) args: (path, buf, bufsiz) -syscall sys_chmod nr 90 nbargs 2 types: (const char *, umode_t) args: (filename, mode) -syscall sys_fchmod nr 91 nbargs 2 types: (unsigned int, umode_t) args: (fd, mode) -syscall sys_chown nr 92 nbargs 3 types: (const char *, uid_t, gid_t) args: (filename, user, group) -syscall sys_fchown nr 93 nbargs 3 types: (unsigned int, uid_t, gid_t) args: (fd, user, group) -syscall sys_lchown nr 94 nbargs 3 types: (const char *, uid_t, gid_t) args: (filename, user, group) -syscall sys_umask nr 95 nbargs 1 types: (int) args: (mask) -syscall sys_gettimeofday nr 96 nbargs 2 types: (struct timeval *, struct timezone *) args: (tv, tz) -syscall sys_getrlimit nr 97 nbargs 2 types: (unsigned int, struct rlimit *) args: (resource, rlim) -syscall sys_getrusage nr 98 nbargs 2 types: (int, struct rusage *) args: (who, ru) -syscall sys_sysinfo nr 99 nbargs 1 types: (struct sysinfo *) args: (info) -syscall sys_times nr 100 nbargs 1 types: (struct tms *) args: (tbuf) -syscall sys_ptrace nr 101 nbargs 4 types: (long, long, unsigned long, unsigned long) args: (request, pid, addr, data) -syscall sys_getuid nr 102 nbargs 0 types: () args: () -syscall sys_syslog nr 103 nbargs 3 types: (int, char *, int) args: (type, buf, len) -syscall sys_getgid nr 104 nbargs 0 types: () args: () -syscall sys_setuid nr 105 nbargs 1 types: (uid_t) args: (uid) -syscall sys_setgid nr 106 nbargs 1 types: (gid_t) args: (gid) -syscall sys_geteuid nr 107 nbargs 0 types: () args: () -syscall sys_getegid nr 108 nbargs 0 types: () args: () -syscall sys_setpgid nr 109 nbargs 2 types: (pid_t, pid_t) args: (pid, pgid) -syscall sys_getppid nr 110 nbargs 0 types: () args: () -syscall sys_getpgrp nr 111 nbargs 0 types: () args: () -syscall sys_setsid nr 112 nbargs 0 types: () args: () -syscall sys_setreuid nr 113 nbargs 2 types: (uid_t, uid_t) args: (ruid, euid) -syscall sys_setregid nr 114 nbargs 2 types: (gid_t, gid_t) args: (rgid, egid) -syscall sys_getgroups nr 115 nbargs 2 types: (int, gid_t *) args: (gidsetsize, grouplist) -syscall sys_setgroups nr 116 nbargs 2 types: (int, gid_t *) args: (gidsetsize, grouplist) -syscall sys_setresuid nr 117 nbargs 3 types: (uid_t, uid_t, uid_t) args: (ruid, euid, suid) -syscall sys_getresuid nr 118 nbargs 3 types: (uid_t *, uid_t *, uid_t *) args: (ruidp, euidp, suidp) -syscall sys_setresgid nr 119 nbargs 3 types: (gid_t, gid_t, gid_t) args: (rgid, egid, sgid) -syscall sys_getresgid nr 120 nbargs 3 types: (gid_t *, gid_t *, gid_t *) args: (rgidp, egidp, sgidp) -syscall sys_getpgid nr 121 nbargs 1 types: (pid_t) args: (pid) -syscall sys_setfsuid nr 122 nbargs 1 types: (uid_t) args: (uid) -syscall sys_setfsgid nr 123 nbargs 1 types: (gid_t) args: (gid) -syscall sys_getsid nr 124 nbargs 1 types: (pid_t) args: (pid) -syscall sys_capget nr 125 nbargs 2 types: (cap_user_header_t, cap_user_data_t) args: (header, dataptr) -syscall sys_capset nr 126 nbargs 2 types: (cap_user_header_t, const cap_user_data_t) args: (header, data) -syscall sys_rt_sigpending nr 127 nbargs 2 types: (sigset_t *, size_t) args: (uset, sigsetsize) -syscall sys_rt_sigtimedwait nr 128 nbargs 4 types: (const sigset_t *, siginfo_t *, const struct timespec *, size_t) args: (uthese, uinfo, uts, sigsetsize) -syscall sys_rt_sigqueueinfo nr 129 nbargs 3 types: (pid_t, int, siginfo_t *) args: (pid, sig, uinfo) -syscall sys_rt_sigsuspend nr 130 nbargs 2 types: (sigset_t *, size_t) args: (unewset, sigsetsize) -syscall sys_sigaltstack nr 131 nbargs 2 types: (const stack_t *, stack_t *) args: (uss, uoss) -syscall sys_utime nr 132 nbargs 2 types: (char *, struct utimbuf *) args: (filename, times) -syscall sys_mknod nr 133 nbargs 3 types: (const char *, umode_t, unsigned) args: (filename, mode, dev) -syscall sys_personality nr 135 nbargs 1 types: (unsigned int) args: (personality) -syscall sys_ustat nr 136 nbargs 2 types: (unsigned, struct ustat *) args: (dev, ubuf) -syscall sys_statfs nr 137 nbargs 2 types: (const char *, struct statfs *) args: (pathname, buf) -syscall sys_fstatfs nr 138 nbargs 2 types: (unsigned int, struct statfs *) args: (fd, buf) -syscall sys_sysfs nr 139 nbargs 3 types: (int, unsigned long, unsigned long) args: (option, arg1, arg2) -syscall sys_getpriority nr 140 nbargs 2 types: (int, int) args: (which, who) -syscall sys_setpriority nr 141 nbargs 3 types: (int, int, int) args: (which, who, niceval) -syscall sys_sched_setparam nr 142 nbargs 2 types: (pid_t, struct sched_param *) args: (pid, param) -syscall sys_sched_getparam nr 143 nbargs 2 types: (pid_t, struct sched_param *) args: (pid, param) -syscall sys_sched_setscheduler nr 144 nbargs 3 types: (pid_t, int, struct sched_param *) args: (pid, policy, param) -syscall sys_sched_getscheduler nr 145 nbargs 1 types: (pid_t) args: (pid) -syscall sys_sched_get_priority_max nr 146 nbargs 1 types: (int) args: (policy) -syscall sys_sched_get_priority_min nr 147 nbargs 1 types: (int) args: (policy) -syscall sys_sched_rr_get_interval nr 148 nbargs 2 types: (pid_t, struct timespec *) args: (pid, interval) -syscall sys_mlock nr 149 nbargs 2 types: (unsigned long, size_t) args: (start, len) -syscall sys_munlock nr 150 nbargs 2 types: (unsigned long, size_t) args: (start, len) -syscall sys_mlockall nr 151 nbargs 1 types: (int) args: (flags) -syscall sys_munlockall nr 152 nbargs 0 types: () args: () -syscall sys_vhangup nr 153 nbargs 0 types: () args: () -syscall sys_pivot_root nr 155 nbargs 2 types: (const char *, const char *) args: (new_root, put_old) -syscall sys_sysctl nr 156 nbargs 1 types: (struct __sysctl_args *) args: (args) -syscall sys_prctl nr 157 nbargs 5 types: (int, unsigned long, unsigned long, unsigned long, unsigned long) args: (option, arg2, arg3, arg4, arg5) -syscall sys_adjtimex nr 159 nbargs 1 types: (struct timex *) args: (txc_p) -syscall sys_setrlimit nr 160 nbargs 2 types: (unsigned int, struct rlimit *) args: (resource, rlim) -syscall sys_chroot nr 161 nbargs 1 types: (const char *) args: (filename) -syscall sys_sync nr 162 nbargs 0 types: () args: () -syscall sys_acct nr 163 nbargs 1 types: (const char *) args: (name) -syscall sys_settimeofday nr 164 nbargs 2 types: (struct timeval *, struct timezone *) args: (tv, tz) -syscall sys_mount nr 165 nbargs 5 types: (char *, char *, char *, unsigned long, void *) args: (dev_name, dir_name, type, flags, data) -syscall sys_umount nr 166 nbargs 2 types: (char *, int) args: (name, flags) -syscall sys_swapon nr 167 nbargs 2 types: (const char *, int) args: (specialfile, swap_flags) -syscall sys_swapoff nr 168 nbargs 1 types: (const char *) args: (specialfile) -syscall sys_reboot nr 169 nbargs 4 types: (int, int, unsigned int, void *) args: (magic1, magic2, cmd, arg) -syscall sys_sethostname nr 170 nbargs 2 types: (char *, int) args: (name, len) -syscall sys_setdomainname nr 171 nbargs 2 types: (char *, int) args: (name, len) -syscall sys_init_module nr 175 nbargs 3 types: (void *, unsigned long, const char *) args: (umod, len, uargs) -syscall sys_delete_module nr 176 nbargs 2 types: (const char *, unsigned int) args: (name_user, flags) -syscall sys_quotactl nr 179 nbargs 4 types: (unsigned int, const char *, qid_t, void *) args: (cmd, special, id, addr) -syscall sys_gettid nr 186 nbargs 0 types: () args: () -syscall sys_readahead nr 187 nbargs 3 types: (int, loff_t, size_t) args: (fd, offset, count) -syscall sys_setxattr nr 188 nbargs 5 types: (const char *, const char *, const void *, size_t, int) args: (pathname, name, value, size, flags) -syscall sys_lsetxattr nr 189 nbargs 5 types: (const char *, const char *, const void *, size_t, int) args: (pathname, name, value, size, flags) -syscall sys_fsetxattr nr 190 nbargs 5 types: (int, const char *, const void *, size_t, int) args: (fd, name, value, size, flags) -syscall sys_getxattr nr 191 nbargs 4 types: (const char *, const char *, void *, size_t) args: (pathname, name, value, size) -syscall sys_lgetxattr nr 192 nbargs 4 types: (const char *, const char *, void *, size_t) args: (pathname, name, value, size) -syscall sys_fgetxattr nr 193 nbargs 4 types: (int, const char *, void *, size_t) args: (fd, name, value, size) -syscall sys_listxattr nr 194 nbargs 3 types: (const char *, char *, size_t) args: (pathname, list, size) -syscall sys_llistxattr nr 195 nbargs 3 types: (const char *, char *, size_t) args: (pathname, list, size) -syscall sys_flistxattr nr 196 nbargs 3 types: (int, char *, size_t) args: (fd, list, size) -syscall sys_removexattr nr 197 nbargs 2 types: (const char *, const char *) args: (pathname, name) -syscall sys_lremovexattr nr 198 nbargs 2 types: (const char *, const char *) args: (pathname, name) -syscall sys_fremovexattr nr 199 nbargs 2 types: (int, const char *) args: (fd, name) -syscall sys_tkill nr 200 nbargs 2 types: (pid_t, int) args: (pid, sig) -syscall sys_time nr 201 nbargs 1 types: (time_t *) args: (tloc) -syscall sys_futex nr 202 nbargs 6 types: (u32 *, int, u32, struct timespec *, u32 *, u32) args: (uaddr, op, val, utime, uaddr2, val3) -syscall sys_sched_setaffinity nr 203 nbargs 3 types: (pid_t, unsigned int, unsigned long *) args: (pid, len, user_mask_ptr) -syscall sys_sched_getaffinity nr 204 nbargs 3 types: (pid_t, unsigned int, unsigned long *) args: (pid, len, user_mask_ptr) -syscall sys_io_setup nr 206 nbargs 2 types: (unsigned, aio_context_t *) args: (nr_events, ctxp) -syscall sys_io_destroy nr 207 nbargs 1 types: (aio_context_t) args: (ctx) -syscall sys_io_getevents nr 208 nbargs 5 types: (aio_context_t, long, long, struct io_event *, struct timespec *) args: (ctx_id, min_nr, nr, events, timeout) -syscall sys_io_submit nr 209 nbargs 3 types: (aio_context_t, long, struct iocb * *) args: (ctx_id, nr, iocbpp) -syscall sys_io_cancel nr 210 nbargs 3 types: (aio_context_t, struct iocb *, struct io_event *) args: (ctx_id, iocb, result) -syscall sys_lookup_dcookie nr 212 nbargs 3 types: (u64, char *, size_t) args: (cookie64, buf, len) -syscall sys_epoll_create nr 213 nbargs 1 types: (int) args: (size) -syscall sys_remap_file_pages nr 216 nbargs 5 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long) args: (start, size, prot, pgoff, flags) -syscall sys_getdents64 nr 217 nbargs 3 types: (unsigned int, struct linux_dirent64 *, unsigned int) args: (fd, dirent, count) -syscall sys_set_tid_address nr 218 nbargs 1 types: (int *) args: (tidptr) -syscall sys_restart_syscall nr 219 nbargs 0 types: () args: () -syscall sys_semtimedop nr 220 nbargs 4 types: (int, struct sembuf *, unsigned, const struct timespec *) args: (semid, tsops, nsops, timeout) -syscall sys_fadvise64 nr 221 nbargs 4 types: (int, loff_t, size_t, int) args: (fd, offset, len, advice) -syscall sys_timer_create nr 222 nbargs 3 types: (const clockid_t, struct sigevent *, timer_t *) args: (which_clock, timer_event_spec, created_timer_id) -syscall sys_timer_settime nr 223 nbargs 4 types: (timer_t, int, const struct itimerspec *, struct itimerspec *) args: (timer_id, flags, new_setting, old_setting) -syscall sys_timer_gettime nr 224 nbargs 2 types: (timer_t, struct itimerspec *) args: (timer_id, setting) -syscall sys_timer_getoverrun nr 225 nbargs 1 types: (timer_t) args: (timer_id) -syscall sys_timer_delete nr 226 nbargs 1 types: (timer_t) args: (timer_id) -syscall sys_clock_settime nr 227 nbargs 2 types: (const clockid_t, const struct timespec *) args: (which_clock, tp) -syscall sys_clock_gettime nr 228 nbargs 2 types: (const clockid_t, struct timespec *) args: (which_clock, tp) -syscall sys_clock_getres nr 229 nbargs 2 types: (const clockid_t, struct timespec *) args: (which_clock, tp) -syscall sys_clock_nanosleep nr 230 nbargs 4 types: (const clockid_t, int, const struct timespec *, struct timespec *) args: (which_clock, flags, rqtp, rmtp) -syscall sys_exit_group nr 231 nbargs 1 types: (int) args: (error_code) -syscall sys_epoll_wait nr 232 nbargs 4 types: (int, struct epoll_event *, int, int) args: (epfd, events, maxevents, timeout) -syscall sys_epoll_ctl nr 233 nbargs 4 types: (int, int, int, struct epoll_event *) args: (epfd, op, fd, event) -syscall sys_tgkill nr 234 nbargs 3 types: (pid_t, pid_t, int) args: (tgid, pid, sig) -syscall sys_utimes nr 235 nbargs 2 types: (char *, struct timeval *) args: (filename, utimes) -syscall sys_mbind nr 237 nbargs 6 types: (unsigned long, unsigned long, unsigned long, unsigned long *, unsigned long, unsigned) args: (start, len, mode, nmask, maxnode, flags) -syscall sys_set_mempolicy nr 238 nbargs 3 types: (int, unsigned long *, unsigned long) args: (mode, nmask, maxnode) -syscall sys_get_mempolicy nr 239 nbargs 5 types: (int *, unsigned long *, unsigned long, unsigned long, unsigned long) args: (policy, nmask, maxnode, addr, flags) -syscall sys_mq_open nr 240 nbargs 4 types: (const char *, int, umode_t, struct mq_attr *) args: (u_name, oflag, mode, u_attr) -syscall sys_mq_unlink nr 241 nbargs 1 types: (const char *) args: (u_name) -syscall sys_mq_timedsend nr 242 nbargs 5 types: (mqd_t, const char *, size_t, unsigned int, const struct timespec *) args: (mqdes, u_msg_ptr, msg_len, msg_prio, u_abs_timeout) -syscall sys_mq_timedreceive nr 243 nbargs 5 types: (mqd_t, char *, size_t, unsigned int *, const struct timespec *) args: (mqdes, u_msg_ptr, msg_len, u_msg_prio, u_abs_timeout) -syscall sys_mq_notify nr 244 nbargs 2 types: (mqd_t, const struct sigevent *) args: (mqdes, u_notification) -syscall sys_mq_getsetattr nr 245 nbargs 3 types: (mqd_t, const struct mq_attr *, struct mq_attr *) args: (mqdes, u_mqstat, u_omqstat) -syscall sys_kexec_load nr 246 nbargs 4 types: (unsigned long, unsigned long, struct kexec_segment *, unsigned long) args: (entry, nr_segments, segments, flags) -syscall sys_waitid nr 247 nbargs 5 types: (int, pid_t, struct siginfo *, int, struct rusage *) args: (which, upid, infop, options, ru) -syscall sys_add_key nr 248 nbargs 5 types: (const char *, const char *, const void *, size_t, key_serial_t) args: (_type, _description, _payload, plen, ringid) -syscall sys_request_key nr 249 nbargs 4 types: (const char *, const char *, const char *, key_serial_t) args: (_type, _description, _callout_info, destringid) -syscall sys_keyctl nr 250 nbargs 5 types: (int, unsigned long, unsigned long, unsigned long, unsigned long) args: (option, arg2, arg3, arg4, arg5) -syscall sys_ioprio_set nr 251 nbargs 3 types: (int, int, int) args: (which, who, ioprio) -syscall sys_ioprio_get nr 252 nbargs 2 types: (int, int) args: (which, who) -syscall sys_inotify_init nr 253 nbargs 0 types: () args: () -syscall sys_inotify_add_watch nr 254 nbargs 3 types: (int, const char *, u32) args: (fd, pathname, mask) -syscall sys_inotify_rm_watch nr 255 nbargs 2 types: (int, __s32) args: (fd, wd) -syscall sys_migrate_pages nr 256 nbargs 4 types: (pid_t, unsigned long, const unsigned long *, const unsigned long *) args: (pid, maxnode, old_nodes, new_nodes) -syscall sys_openat nr 257 nbargs 4 types: (int, const char *, int, umode_t) args: (dfd, filename, flags, mode) -syscall sys_mkdirat nr 258 nbargs 3 types: (int, const char *, umode_t) args: (dfd, pathname, mode) -syscall sys_mknodat nr 259 nbargs 4 types: (int, const char *, umode_t, unsigned) args: (dfd, filename, mode, dev) -syscall sys_fchownat nr 260 nbargs 5 types: (int, const char *, uid_t, gid_t, int) args: (dfd, filename, user, group, flag) -syscall sys_futimesat nr 261 nbargs 3 types: (int, const char *, struct timeval *) args: (dfd, filename, utimes) -syscall sys_newfstatat nr 262 nbargs 4 types: (int, const char *, struct stat *, int) args: (dfd, filename, statbuf, flag) -syscall sys_unlinkat nr 263 nbargs 3 types: (int, const char *, int) args: (dfd, pathname, flag) -syscall sys_renameat nr 264 nbargs 4 types: (int, const char *, int, const char *) args: (olddfd, oldname, newdfd, newname) -syscall sys_linkat nr 265 nbargs 5 types: (int, const char *, int, const char *, int) args: (olddfd, oldname, newdfd, newname, flags) -syscall sys_symlinkat nr 266 nbargs 3 types: (const char *, int, const char *) args: (oldname, newdfd, newname) -syscall sys_readlinkat nr 267 nbargs 4 types: (int, const char *, char *, int) args: (dfd, pathname, buf, bufsiz) -syscall sys_fchmodat nr 268 nbargs 3 types: (int, const char *, umode_t) args: (dfd, filename, mode) -syscall sys_faccessat nr 269 nbargs 3 types: (int, const char *, int) args: (dfd, filename, mode) -syscall sys_pselect6 nr 270 nbargs 6 types: (int, fd_set *, fd_set *, fd_set *, struct timespec *, void *) args: (n, inp, outp, exp, tsp, sig) -syscall sys_ppoll nr 271 nbargs 5 types: (struct pollfd *, unsigned int, struct timespec *, const sigset_t *, size_t) args: (ufds, nfds, tsp, sigmask, sigsetsize) -syscall sys_unshare nr 272 nbargs 1 types: (unsigned long) args: (unshare_flags) -syscall sys_set_robust_list nr 273 nbargs 2 types: (struct robust_list_head *, size_t) args: (head, len) -syscall sys_get_robust_list nr 274 nbargs 3 types: (int, struct robust_list_head * *, size_t *) args: (pid, head_ptr, len_ptr) -syscall sys_splice nr 275 nbargs 6 types: (int, loff_t *, int, loff_t *, size_t, unsigned int) args: (fd_in, off_in, fd_out, off_out, len, flags) -syscall sys_tee nr 276 nbargs 4 types: (int, int, size_t, unsigned int) args: (fdin, fdout, len, flags) -syscall sys_sync_file_range nr 277 nbargs 4 types: (int, loff_t, loff_t, unsigned int) args: (fd, offset, nbytes, flags) -syscall sys_vmsplice nr 278 nbargs 4 types: (int, const struct iovec *, unsigned long, unsigned int) args: (fd, iov, nr_segs, flags) -syscall sys_move_pages nr 279 nbargs 6 types: (pid_t, unsigned long, const void * *, const int *, int *, int) args: (pid, nr_pages, pages, nodes, status, flags) -syscall sys_utimensat nr 280 nbargs 4 types: (int, const char *, struct timespec *, int) args: (dfd, filename, utimes, flags) -syscall sys_epoll_pwait nr 281 nbargs 6 types: (int, struct epoll_event *, int, int, const sigset_t *, size_t) args: (epfd, events, maxevents, timeout, sigmask, sigsetsize) -syscall sys_signalfd nr 282 nbargs 3 types: (int, sigset_t *, size_t) args: (ufd, user_mask, sizemask) -syscall sys_timerfd_create nr 283 nbargs 2 types: (int, int) args: (clockid, flags) -syscall sys_eventfd nr 284 nbargs 1 types: (unsigned int) args: (count) -syscall sys_fallocate nr 285 nbargs 4 types: (int, int, loff_t, loff_t) args: (fd, mode, offset, len) -syscall sys_timerfd_settime nr 286 nbargs 4 types: (int, int, const struct itimerspec *, struct itimerspec *) args: (ufd, flags, utmr, otmr) -syscall sys_timerfd_gettime nr 287 nbargs 2 types: (int, struct itimerspec *) args: (ufd, otmr) -syscall sys_accept4 nr 288 nbargs 4 types: (int, struct sockaddr *, int *, int) args: (fd, upeer_sockaddr, upeer_addrlen, flags) -syscall sys_signalfd4 nr 289 nbargs 4 types: (int, sigset_t *, size_t, int) args: (ufd, user_mask, sizemask, flags) -syscall sys_eventfd2 nr 290 nbargs 2 types: (unsigned int, int) args: (count, flags) -syscall sys_epoll_create1 nr 291 nbargs 1 types: (int) args: (flags) -syscall sys_dup3 nr 292 nbargs 3 types: (unsigned int, unsigned int, int) args: (oldfd, newfd, flags) -syscall sys_pipe2 nr 293 nbargs 2 types: (int *, int) args: (fildes, flags) -syscall sys_inotify_init1 nr 294 nbargs 1 types: (int) args: (flags) -syscall sys_preadv nr 295 nbargs 5 types: (unsigned long, const struct iovec *, unsigned long, unsigned long, unsigned long) args: (fd, vec, vlen, pos_l, pos_h) -syscall sys_pwritev nr 296 nbargs 5 types: (unsigned long, const struct iovec *, unsigned long, unsigned long, unsigned long) args: (fd, vec, vlen, pos_l, pos_h) -syscall sys_rt_tgsigqueueinfo nr 297 nbargs 4 types: (pid_t, pid_t, int, siginfo_t *) args: (tgid, pid, sig, uinfo) -syscall sys_perf_event_open nr 298 nbargs 5 types: (struct perf_event_attr *, pid_t, int, int, unsigned long) args: (attr_uptr, pid, cpu, group_fd, flags) -syscall sys_recvmmsg nr 299 nbargs 5 types: (int, struct mmsghdr *, unsigned int, unsigned int, struct timespec *) args: (fd, mmsg, vlen, flags, timeout) -syscall sys_fanotify_init nr 300 nbargs 2 types: (unsigned int, unsigned int) args: (flags, event_f_flags) -syscall sys_fanotify_mark nr 301 nbargs 5 types: (int, unsigned int, __u64, int, const char *) args: (fanotify_fd, flags, mask, dfd, pathname) -syscall sys_prlimit64 nr 302 nbargs 4 types: (pid_t, unsigned int, const struct rlimit64 *, struct rlimit64 *) args: (pid, resource, new_rlim, old_rlim) -syscall sys_name_to_handle_at nr 303 nbargs 5 types: (int, const char *, struct file_handle *, int *, int) args: (dfd, name, handle, mnt_id, flag) -syscall sys_open_by_handle_at nr 304 nbargs 3 types: (int, struct file_handle *, int) args: (mountdirfd, handle, flags) -syscall sys_clock_adjtime nr 305 nbargs 2 types: (const clockid_t, struct timex *) args: (which_clock, utx) -syscall sys_syncfs nr 306 nbargs 1 types: (int) args: (fd) -syscall sys_sendmmsg nr 307 nbargs 4 types: (int, struct mmsghdr *, unsigned int, unsigned int) args: (fd, mmsg, vlen, flags) -syscall sys_setns nr 308 nbargs 2 types: (int, int) args: (fd, nstype) -syscall sys_getcpu nr 309 nbargs 3 types: (unsigned *, unsigned *, struct getcpu_cache *) args: (cpup, nodep, unused) -syscall sys_process_vm_readv nr 310 nbargs 6 types: (pid_t, const struct iovec *, unsigned long, const struct iovec *, unsigned long, unsigned long) args: (pid, lvec, liovcnt, rvec, riovcnt, flags) -syscall sys_process_vm_writev nr 311 nbargs 6 types: (pid_t, const struct iovec *, unsigned long, const struct iovec *, unsigned long, unsigned long) args: (pid, lvec, liovcnt, rvec, riovcnt, flags) -syscall sys_finit_module nr 313 nbargs 3 types: (int, const char *, int) args: (fd, uargs, flags) diff --git a/instrumentation/syscalls/3.13.0/mips-32-syscalls b/instrumentation/syscalls/3.13.0/mips-32-syscalls deleted file mode 100644 index e815a989..00000000 --- a/instrumentation/syscalls/3.13.0/mips-32-syscalls +++ /dev/null @@ -1,283 +0,0 @@ -syscall sys_exit nr 4001 nbargs 1 types: (int) args: (error_code) -syscall sys_read nr 4003 nbargs 3 types: (unsigned int, char *, size_t) args: (fd, buf, count) -syscall sys_write nr 4004 nbargs 3 types: (unsigned int, const char *, size_t) args: (fd, buf, count) -syscall sys_open nr 4005 nbargs 3 types: (const char *, int, umode_t) args: (filename, flags, mode) -syscall sys_close nr 4006 nbargs 1 types: (unsigned int) args: (fd) -syscall sys_waitpid nr 4007 nbargs 3 types: (pid_t, int *, int) args: (pid, stat_addr, options) -syscall sys_creat nr 4008 nbargs 2 types: (const char *, umode_t) args: (pathname, mode) -syscall sys_link nr 4009 nbargs 2 types: (const char *, const char *) args: (oldname, newname) -syscall sys_unlink nr 4010 nbargs 1 types: (const char *) args: (pathname) -syscall sys_execve nr 4011 nbargs 3 types: (const char *, const char *const *, const char *const *) args: (filename, argv, envp) -syscall sys_chdir nr 4012 nbargs 1 types: (const char *) args: (filename) -syscall sys_time nr 4013 nbargs 1 types: (time_t *) args: (tloc) -syscall sys_mknod nr 4014 nbargs 3 types: (const char *, umode_t, unsigned) args: (filename, mode, dev) -syscall sys_chmod nr 4015 nbargs 2 types: (const char *, umode_t) args: (filename, mode) -syscall sys_lchown nr 4016 nbargs 3 types: (const char *, uid_t, gid_t) args: (filename, user, group) -syscall sys_lseek nr 4019 nbargs 3 types: (unsigned int, off_t, unsigned int) args: (fd, offset, whence) -syscall sys_getpid nr 4020 nbargs 0 types: () args: () -syscall sys_mount nr 4021 nbargs 5 types: (char *, char *, char *, unsigned long, void *) args: (dev_name, dir_name, type, flags, data) -syscall sys_oldumount nr 4022 nbargs 1 types: (char *) args: (name) -syscall sys_setuid nr 4023 nbargs 1 types: (uid_t) args: (uid) -syscall sys_getuid nr 4024 nbargs 0 types: () args: () -syscall sys_stime nr 4025 nbargs 1 types: (time_t *) args: (tptr) -syscall sys_ptrace nr 4026 nbargs 4 types: (long, long, unsigned long, unsigned long) args: (request, pid, addr, data) -syscall sys_alarm nr 4027 nbargs 1 types: (unsigned int) args: (seconds) -syscall sys_pause nr 4029 nbargs 0 types: () args: () -syscall sys_utime nr 4030 nbargs 2 types: (char *, struct utimbuf *) args: (filename, times) -syscall sys_access nr 4033 nbargs 2 types: (const char *, int) args: (filename, mode) -syscall sys_nice nr 4034 nbargs 1 types: (int) args: (increment) -syscall sys_sync nr 4036 nbargs 0 types: () args: () -syscall sys_kill nr 4037 nbargs 2 types: (pid_t, int) args: (pid, sig) -syscall sys_rename nr 4038 nbargs 2 types: (const char *, const char *) args: (oldname, newname) -syscall sys_mkdir nr 4039 nbargs 2 types: (const char *, umode_t) args: (pathname, mode) -syscall sys_rmdir nr 4040 nbargs 1 types: (const char *) args: (pathname) -syscall sys_dup nr 4041 nbargs 1 types: (unsigned int) args: (fildes) -syscall sys_times nr 4043 nbargs 1 types: (struct tms *) args: (tbuf) -syscall sys_brk nr 4045 nbargs 1 types: (unsigned long) args: (brk) -syscall sys_setgid nr 4046 nbargs 1 types: (gid_t) args: (gid) -syscall sys_getgid nr 4047 nbargs 0 types: () args: () -syscall sys_geteuid nr 4049 nbargs 0 types: () args: () -syscall sys_getegid nr 4050 nbargs 0 types: () args: () -syscall sys_umount nr 4052 nbargs 2 types: (char *, int) args: (name, flags) -syscall sys_ioctl nr 4054 nbargs 3 types: (unsigned int, unsigned int, unsigned long) args: (fd, cmd, arg) -syscall sys_fcntl nr 4055 nbargs 3 types: (unsigned int, unsigned int, unsigned long) args: (fd, cmd, arg) -syscall sys_setpgid nr 4057 nbargs 2 types: (pid_t, pid_t) args: (pid, pgid) -syscall sys_olduname nr 4059 nbargs 1 types: (struct oldold_utsname *) args: (name) -syscall sys_umask nr 4060 nbargs 1 types: (int) args: (mask) -syscall sys_chroot nr 4061 nbargs 1 types: (const char *) args: (filename) -syscall sys_ustat nr 4062 nbargs 2 types: (unsigned, struct ustat *) args: (dev, ubuf) -syscall sys_dup2 nr 4063 nbargs 2 types: (unsigned int, unsigned int) args: (oldfd, newfd) -syscall sys_getppid nr 4064 nbargs 0 types: () args: () -syscall sys_getpgrp nr 4065 nbargs 0 types: () args: () -syscall sys_setsid nr 4066 nbargs 0 types: () args: () -syscall sys_sigaction nr 4067 nbargs 3 types: (int, const struct sigaction *, struct sigaction *) args: (sig, act, oact) -syscall sys_sgetmask nr 4068 nbargs 0 types: () args: () -syscall sys_ssetmask nr 4069 nbargs 1 types: (int) args: (newmask) -syscall sys_setreuid nr 4070 nbargs 2 types: (uid_t, uid_t) args: (ruid, euid) -syscall sys_setregid nr 4071 nbargs 2 types: (gid_t, gid_t) args: (rgid, egid) -syscall sys_sigsuspend nr 4072 nbargs 1 types: (sigset_t *) args: (uset) -syscall sys_sigpending nr 4073 nbargs 1 types: (old_sigset_t *) args: (set) -syscall sys_sethostname nr 4074 nbargs 2 types: (char *, int) args: (name, len) -syscall sys_setrlimit nr 4075 nbargs 2 types: (unsigned int, struct rlimit *) args: (resource, rlim) -syscall sys_getrlimit nr 4076 nbargs 2 types: (unsigned int, struct rlimit *) args: (resource, rlim) -syscall sys_getrusage nr 4077 nbargs 2 types: (int, struct rusage *) args: (who, ru) -syscall sys_gettimeofday nr 4078 nbargs 2 types: (struct timeval *, struct timezone *) args: (tv, tz) -syscall sys_settimeofday nr 4079 nbargs 2 types: (struct timeval *, struct timezone *) args: (tv, tz) -syscall sys_getgroups nr 4080 nbargs 2 types: (int, gid_t *) args: (gidsetsize, grouplist) -syscall sys_setgroups nr 4081 nbargs 2 types: (int, gid_t *) args: (gidsetsize, grouplist) -syscall sys_symlink nr 4083 nbargs 2 types: (const char *, const char *) args: (oldname, newname) -syscall sys_readlink nr 4085 nbargs 3 types: (const char *, char *, int) args: (path, buf, bufsiz) -syscall sys_uselib nr 4086 nbargs 1 types: (const char *) args: (library) -syscall sys_reboot nr 4088 nbargs 4 types: (int, int, unsigned int, void *) args: (magic1, magic2, cmd, arg) -syscall sys_old_readdir nr 4089 nbargs 3 types: (unsigned int, struct old_linux_dirent *, unsigned int) args: (fd, dirent, count) -syscall sys_mips_mmap nr 4090 nbargs 6 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long, off_t) args: (addr, len, prot, flags, fd, offset) -syscall sys_munmap nr 4091 nbargs 2 types: (unsigned long, size_t) args: (addr, len) -syscall sys_truncate nr 4092 nbargs 2 types: (const char *, long) args: (path, length) -syscall sys_ftruncate nr 4093 nbargs 2 types: (unsigned int, unsigned long) args: (fd, length) -syscall sys_fchmod nr 4094 nbargs 2 types: (unsigned int, umode_t) args: (fd, mode) -syscall sys_fchown nr 4095 nbargs 3 types: (unsigned int, uid_t, gid_t) args: (fd, user, group) -syscall sys_getpriority nr 4096 nbargs 2 types: (int, int) args: (which, who) -syscall sys_setpriority nr 4097 nbargs 3 types: (int, int, int) args: (which, who, niceval) -syscall sys_statfs nr 4099 nbargs 2 types: (const char *, struct statfs *) args: (pathname, buf) -syscall sys_fstatfs nr 4100 nbargs 2 types: (unsigned int, struct statfs *) args: (fd, buf) -syscall sys_socketcall nr 4102 nbargs 2 types: (int, unsigned long *) args: (call, args) -syscall sys_syslog nr 4103 nbargs 3 types: (int, char *, int) args: (type, buf, len) -syscall sys_setitimer nr 4104 nbargs 3 types: (int, struct itimerval *, struct itimerval *) args: (which, value, ovalue) -syscall sys_getitimer nr 4105 nbargs 2 types: (int, struct itimerval *) args: (which, value) -syscall sys_newstat nr 4106 nbargs 2 types: (const char *, struct stat *) args: (filename, statbuf) -syscall sys_newlstat nr 4107 nbargs 2 types: (const char *, struct stat *) args: (filename, statbuf) -syscall sys_newfstat nr 4108 nbargs 2 types: (unsigned int, struct stat *) args: (fd, statbuf) -syscall sys_uname nr 4109 nbargs 1 types: (struct old_utsname *) args: (name) -syscall sys_vhangup nr 4111 nbargs 0 types: () args: () -syscall sys_wait4 nr 4114 nbargs 4 types: (pid_t, int *, int, struct rusage *) args: (upid, stat_addr, options, ru) -syscall sys_sysinfo nr 4116 nbargs 1 types: (struct sysinfo *) args: (info) -syscall sys_ipc nr 4117 nbargs 6 types: (unsigned int, int, unsigned long, unsigned long, void *, long) args: (call, first, second, third, ptr, fifth) -syscall sys_fsync nr 4118 nbargs 1 types: (unsigned int) args: (fd) -syscall sys_setdomainname nr 4121 nbargs 2 types: (char *, int) args: (name, len) -syscall sys_newuname nr 4122 nbargs 1 types: (struct new_utsname *) args: (name) -syscall sys_adjtimex nr 4124 nbargs 1 types: (struct timex *) args: (txc_p) -syscall sys_mprotect nr 4125 nbargs 3 types: (unsigned long, size_t, unsigned long) args: (start, len, prot) -syscall sys_sigprocmask nr 4126 nbargs 3 types: (int, old_sigset_t *, old_sigset_t *) args: (how, nset, oset) -syscall sys_init_module nr 4128 nbargs 3 types: (void *, unsigned long, const char *) args: (umod, len, uargs) -syscall sys_delete_module nr 4129 nbargs 2 types: (const char *, unsigned int) args: (name_user, flags) -syscall sys_getpgid nr 4132 nbargs 1 types: (pid_t) args: (pid) -syscall sys_fchdir nr 4133 nbargs 1 types: (unsigned int) args: (fd) -syscall sys_bdflush nr 4134 nbargs 2 types: (int, long) args: (func, data) -syscall sys_sysfs nr 4135 nbargs 3 types: (int, unsigned long, unsigned long) args: (option, arg1, arg2) -syscall sys_personality nr 4136 nbargs 1 types: (unsigned int) args: (personality) -syscall sys_setfsuid nr 4138 nbargs 1 types: (uid_t) args: (uid) -syscall sys_setfsgid nr 4139 nbargs 1 types: (gid_t) args: (gid) -syscall sys_llseek nr 4140 nbargs 5 types: (unsigned int, unsigned long, unsigned long, loff_t *, unsigned int) args: (fd, offset_high, offset_low, result, whence) -syscall sys_getdents nr 4141 nbargs 3 types: (unsigned int, struct linux_dirent *, unsigned int) args: (fd, dirent, count) -syscall sys_select nr 4142 nbargs 5 types: (int, fd_set *, fd_set *, fd_set *, struct timeval *) args: (n, inp, outp, exp, tvp) -syscall sys_flock nr 4143 nbargs 2 types: (unsigned int, unsigned int) args: (fd, cmd) -syscall sys_msync nr 4144 nbargs 3 types: (unsigned long, size_t, int) args: (start, len, flags) -syscall sys_readv nr 4145 nbargs 3 types: (unsigned long, const struct iovec *, unsigned long) args: (fd, vec, vlen) -syscall sys_writev nr 4146 nbargs 3 types: (unsigned long, const struct iovec *, unsigned long) args: (fd, vec, vlen) -syscall sys_cacheflush nr 4147 nbargs 3 types: (unsigned long, unsigned long, unsigned int) args: (addr, bytes, cache) -syscall sys_cachectl nr 4148 nbargs 3 types: (char *, int, int) args: (addr, nbytes, op) -syscall sys_sysmips nr 4149 nbargs 3 types: (long, long, long) args: (cmd, arg1, arg2) -syscall sys_getsid nr 4151 nbargs 1 types: (pid_t) args: (pid) -syscall sys_fdatasync nr 4152 nbargs 1 types: (unsigned int) args: (fd) -syscall sys_sysctl nr 4153 nbargs 1 types: (struct __sysctl_args *) args: (args) -syscall sys_mlock nr 4154 nbargs 2 types: (unsigned long, size_t) args: (start, len) -syscall sys_munlock nr 4155 nbargs 2 types: (unsigned long, size_t) args: (start, len) -syscall sys_mlockall nr 4156 nbargs 1 types: (int) args: (flags) -syscall sys_munlockall nr 4157 nbargs 0 types: () args: () -syscall sys_sched_setparam nr 4158 nbargs 2 types: (pid_t, struct sched_param *) args: (pid, param) -syscall sys_sched_getparam nr 4159 nbargs 2 types: (pid_t, struct sched_param *) args: (pid, param) -syscall sys_sched_setscheduler nr 4160 nbargs 3 types: (pid_t, int, struct sched_param *) args: (pid, policy, param) -syscall sys_sched_getscheduler nr 4161 nbargs 1 types: (pid_t) args: (pid) -syscall sys_sched_yield nr 4162 nbargs 0 types: () args: () -syscall sys_sched_get_priority_max nr 4163 nbargs 1 types: (int) args: (policy) -syscall sys_sched_get_priority_min nr 4164 nbargs 1 types: (int) args: (policy) -syscall sys_sched_rr_get_interval nr 4165 nbargs 2 types: (pid_t, struct timespec *) args: (pid, interval) -syscall sys_nanosleep nr 4166 nbargs 2 types: (struct timespec *, struct timespec *) args: (rqtp, rmtp) -syscall sys_mremap nr 4167 nbargs 5 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long) args: (addr, old_len, new_len, flags, new_addr) -syscall sys_accept nr 4168 nbargs 3 types: (int, struct sockaddr *, int *) args: (fd, upeer_sockaddr, upeer_addrlen) -syscall sys_bind nr 4169 nbargs 3 types: (int, struct sockaddr *, int) args: (fd, umyaddr, addrlen) -syscall sys_connect nr 4170 nbargs 3 types: (int, struct sockaddr *, int) args: (fd, uservaddr, addrlen) -syscall sys_getpeername nr 4171 nbargs 3 types: (int, struct sockaddr *, int *) args: (fd, usockaddr, usockaddr_len) -syscall sys_getsockname nr 4172 nbargs 3 types: (int, struct sockaddr *, int *) args: (fd, usockaddr, usockaddr_len) -syscall sys_getsockopt nr 4173 nbargs 5 types: (int, int, int, char *, int *) args: (fd, level, optname, optval, optlen) -syscall sys_listen nr 4174 nbargs 2 types: (int, int) args: (fd, backlog) -syscall sys_recvfrom nr 4176 nbargs 6 types: (int, void *, size_t, unsigned int, struct sockaddr *, int *) args: (fd, ubuf, size, flags, addr, addr_len) -syscall sys_recvmsg nr 4177 nbargs 3 types: (int, struct msghdr *, unsigned int) args: (fd, msg, flags) -syscall sys_send nr 4178 nbargs 4 types: (int, void *, size_t, unsigned int) args: (fd, buff, len, flags) -syscall sys_sendmsg nr 4179 nbargs 3 types: (int, struct msghdr *, unsigned int) args: (fd, msg, flags) -syscall sys_sendto nr 4180 nbargs 6 types: (int, void *, size_t, unsigned int, struct sockaddr *, int) args: (fd, buff, len, flags, addr, addr_len) -syscall sys_setsockopt nr 4181 nbargs 5 types: (int, int, int, char *, int) args: (fd, level, optname, optval, optlen) -syscall sys_shutdown nr 4182 nbargs 2 types: (int, int) args: (fd, how) -syscall sys_socket nr 4183 nbargs 3 types: (int, int, int) args: (family, type, protocol) -syscall sys_socketpair nr 4184 nbargs 4 types: (int, int, int, int *) args: (family, type, protocol, usockvec) -syscall sys_setresuid nr 4185 nbargs 3 types: (uid_t, uid_t, uid_t) args: (ruid, euid, suid) -syscall sys_getresuid nr 4186 nbargs 3 types: (uid_t *, uid_t *, uid_t *) args: (ruidp, euidp, suidp) -syscall sys_poll nr 4188 nbargs 3 types: (struct pollfd *, unsigned int, int) args: (ufds, nfds, timeout_msecs) -syscall sys_setresgid nr 4190 nbargs 3 types: (gid_t, gid_t, gid_t) args: (rgid, egid, sgid) -syscall sys_getresgid nr 4191 nbargs 3 types: (gid_t *, gid_t *, gid_t *) args: (rgidp, egidp, sgidp) -syscall sys_prctl nr 4192 nbargs 5 types: (int, unsigned long, unsigned long, unsigned long, unsigned long) args: (option, arg2, arg3, arg4, arg5) -syscall sys_rt_sigaction nr 4194 nbargs 4 types: (int, const struct sigaction *, struct sigaction *, size_t) args: (sig, act, oact, sigsetsize) -syscall sys_rt_sigprocmask nr 4195 nbargs 4 types: (int, sigset_t *, sigset_t *, size_t) args: (how, nset, oset, sigsetsize) -syscall sys_rt_sigpending nr 4196 nbargs 2 types: (sigset_t *, size_t) args: (uset, sigsetsize) -syscall sys_rt_sigtimedwait nr 4197 nbargs 4 types: (const sigset_t *, siginfo_t *, const struct timespec *, size_t) args: (uthese, uinfo, uts, sigsetsize) -syscall sys_rt_sigqueueinfo nr 4198 nbargs 3 types: (pid_t, int, siginfo_t *) args: (pid, sig, uinfo) -syscall sys_rt_sigsuspend nr 4199 nbargs 2 types: (sigset_t *, size_t) args: (unewset, sigsetsize) -syscall sys_pread64 nr 4200 nbargs 4 types: (unsigned int, char *, size_t, loff_t) args: (fd, buf, count, pos) -syscall sys_pwrite64 nr 4201 nbargs 4 types: (unsigned int, const char *, size_t, loff_t) args: (fd, buf, count, pos) -syscall sys_chown nr 4202 nbargs 3 types: (const char *, uid_t, gid_t) args: (filename, user, group) -syscall sys_getcwd nr 4203 nbargs 2 types: (char *, unsigned long) args: (buf, size) -syscall sys_capget nr 4204 nbargs 2 types: (cap_user_header_t, cap_user_data_t) args: (header, dataptr) -syscall sys_capset nr 4205 nbargs 2 types: (cap_user_header_t, const cap_user_data_t) args: (header, data) -syscall sys_sigaltstack nr 4206 nbargs 2 types: (const stack_t *, stack_t *) args: (uss, uoss) -syscall sys_sendfile nr 4207 nbargs 4 types: (int, int, off_t *, size_t) args: (out_fd, in_fd, offset, count) -syscall sys_mips_mmap2 nr 4210 nbargs 6 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long, unsigned long) args: (addr, len, prot, flags, fd, pgoff) -syscall sys_truncate64 nr 4211 nbargs 2 types: (const char *, loff_t) args: (path, length) -syscall sys_ftruncate64 nr 4212 nbargs 2 types: (unsigned int, loff_t) args: (fd, length) -syscall sys_stat64 nr 4213 nbargs 2 types: (const char *, struct stat64 *) args: (filename, statbuf) -syscall sys_lstat64 nr 4214 nbargs 2 types: (const char *, struct stat64 *) args: (filename, statbuf) -syscall sys_fstat64 nr 4215 nbargs 2 types: (unsigned long, struct stat64 *) args: (fd, statbuf) -syscall sys_pivot_root nr 4216 nbargs 2 types: (const char *, const char *) args: (new_root, put_old) -syscall sys_mincore nr 4217 nbargs 3 types: (unsigned long, size_t, unsigned char *) args: (start, len, vec) -syscall sys_madvise nr 4218 nbargs 3 types: (unsigned long, size_t, int) args: (start, len_in, behavior) -syscall sys_getdents64 nr 4219 nbargs 3 types: (unsigned int, struct linux_dirent64 *, unsigned int) args: (fd, dirent, count) -syscall sys_fcntl64 nr 4220 nbargs 3 types: (unsigned int, unsigned int, unsigned long) args: (fd, cmd, arg) -syscall sys_gettid nr 4222 nbargs 0 types: () args: () -syscall sys_readahead nr 4223 nbargs 3 types: (int, loff_t, size_t) args: (fd, offset, count) -syscall sys_setxattr nr 4224 nbargs 5 types: (const char *, const char *, const void *, size_t, int) args: (pathname, name, value, size, flags) -syscall sys_lsetxattr nr 4225 nbargs 5 types: (const char *, const char *, const void *, size_t, int) args: (pathname, name, value, size, flags) -syscall sys_fsetxattr nr 4226 nbargs 5 types: (int, const char *, const void *, size_t, int) args: (fd, name, value, size, flags) -syscall sys_getxattr nr 4227 nbargs 4 types: (const char *, const char *, void *, size_t) args: (pathname, name, value, size) -syscall sys_lgetxattr nr 4228 nbargs 4 types: (const char *, const char *, void *, size_t) args: (pathname, name, value, size) -syscall sys_fgetxattr nr 4229 nbargs 4 types: (int, const char *, void *, size_t) args: (fd, name, value, size) -syscall sys_listxattr nr 4230 nbargs 3 types: (const char *, char *, size_t) args: (pathname, list, size) -syscall sys_llistxattr nr 4231 nbargs 3 types: (const char *, char *, size_t) args: (pathname, list, size) -syscall sys_flistxattr nr 4232 nbargs 3 types: (int, char *, size_t) args: (fd, list, size) -syscall sys_removexattr nr 4233 nbargs 2 types: (const char *, const char *) args: (pathname, name) -syscall sys_lremovexattr nr 4234 nbargs 2 types: (const char *, const char *) args: (pathname, name) -syscall sys_fremovexattr nr 4235 nbargs 2 types: (int, const char *) args: (fd, name) -syscall sys_tkill nr 4236 nbargs 2 types: (pid_t, int) args: (pid, sig) -syscall sys_sendfile64 nr 4237 nbargs 4 types: (int, int, loff_t *, size_t) args: (out_fd, in_fd, offset, count) -syscall sys_futex nr 4238 nbargs 6 types: (u32 *, int, u32, struct timespec *, u32 *, u32) args: (uaddr, op, val, utime, uaddr2, val3) -syscall sys_io_setup nr 4241 nbargs 2 types: (unsigned, aio_context_t *) args: (nr_events, ctxp) -syscall sys_io_destroy nr 4242 nbargs 1 types: (aio_context_t) args: (ctx) -syscall sys_io_getevents nr 4243 nbargs 5 types: (aio_context_t, long, long, struct io_event *, struct timespec *) args: (ctx_id, min_nr, nr, events, timeout) -syscall sys_io_submit nr 4244 nbargs 3 types: (aio_context_t, long, struct iocb * *) args: (ctx_id, nr, iocbpp) -syscall sys_io_cancel nr 4245 nbargs 3 types: (aio_context_t, struct iocb *, struct io_event *) args: (ctx_id, iocb, result) -syscall sys_exit_group nr 4246 nbargs 1 types: (int) args: (error_code) -syscall sys_epoll_create nr 4248 nbargs 1 types: (int) args: (size) -syscall sys_epoll_ctl nr 4249 nbargs 4 types: (int, int, int, struct epoll_event *) args: (epfd, op, fd, event) -syscall sys_epoll_wait nr 4250 nbargs 4 types: (int, struct epoll_event *, int, int) args: (epfd, events, maxevents, timeout) -syscall sys_remap_file_pages nr 4251 nbargs 5 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long) args: (start, size, prot, pgoff, flags) -syscall sys_set_tid_address nr 4252 nbargs 1 types: (int *) args: (tidptr) -syscall sys_restart_syscall nr 4253 nbargs 0 types: () args: () -syscall sys_fadvise64_64 nr 4254 nbargs 4 types: (int, loff_t, loff_t, int) args: (fd, offset, len, advice) -syscall sys_statfs64 nr 4255 nbargs 3 types: (const char *, size_t, struct statfs64 *) args: (pathname, sz, buf) -syscall sys_fstatfs64 nr 4256 nbargs 3 types: (unsigned int, size_t, struct statfs64 *) args: (fd, sz, buf) -syscall sys_timer_create nr 4257 nbargs 3 types: (const clockid_t, struct sigevent *, timer_t *) args: (which_clock, timer_event_spec, created_timer_id) -syscall sys_timer_settime nr 4258 nbargs 4 types: (timer_t, int, const struct itimerspec *, struct itimerspec *) args: (timer_id, flags, new_setting, old_setting) -syscall sys_timer_gettime nr 4259 nbargs 2 types: (timer_t, struct itimerspec *) args: (timer_id, setting) -syscall sys_timer_getoverrun nr 4260 nbargs 1 types: (timer_t) args: (timer_id) -syscall sys_timer_delete nr 4261 nbargs 1 types: (timer_t) args: (timer_id) -syscall sys_clock_settime nr 4262 nbargs 2 types: (const clockid_t, const struct timespec *) args: (which_clock, tp) -syscall sys_clock_gettime nr 4263 nbargs 2 types: (const clockid_t, struct timespec *) args: (which_clock, tp) -syscall sys_clock_getres nr 4264 nbargs 2 types: (const clockid_t, struct timespec *) args: (which_clock, tp) -syscall sys_clock_nanosleep nr 4265 nbargs 4 types: (const clockid_t, int, const struct timespec *, struct timespec *) args: (which_clock, flags, rqtp, rmtp) -syscall sys_tgkill nr 4266 nbargs 3 types: (pid_t, pid_t, int) args: (tgid, pid, sig) -syscall sys_utimes nr 4267 nbargs 2 types: (char *, struct timeval *) args: (filename, utimes) -syscall sys_waitid nr 4278 nbargs 5 types: (int, pid_t, struct siginfo *, int, struct rusage *) args: (which, upid, infop, options, ru) -syscall sys_set_thread_area nr 4283 nbargs 1 types: (unsigned long) args: (addr) -syscall sys_inotify_init nr 4284 nbargs 0 types: () args: () -syscall sys_inotify_add_watch nr 4285 nbargs 3 types: (int, const char *, u32) args: (fd, pathname, mask) -syscall sys_inotify_rm_watch nr 4286 nbargs 2 types: (int, __s32) args: (fd, wd) -syscall sys_openat nr 4288 nbargs 4 types: (int, const char *, int, umode_t) args: (dfd, filename, flags, mode) -syscall sys_mkdirat nr 4289 nbargs 3 types: (int, const char *, umode_t) args: (dfd, pathname, mode) -syscall sys_mknodat nr 4290 nbargs 4 types: (int, const char *, umode_t, unsigned) args: (dfd, filename, mode, dev) -syscall sys_fchownat nr 4291 nbargs 5 types: (int, const char *, uid_t, gid_t, int) args: (dfd, filename, user, group, flag) -syscall sys_futimesat nr 4292 nbargs 3 types: (int, const char *, struct timeval *) args: (dfd, filename, utimes) -syscall sys_fstatat64 nr 4293 nbargs 4 types: (int, const char *, struct stat64 *, int) args: (dfd, filename, statbuf, flag) -syscall sys_unlinkat nr 4294 nbargs 3 types: (int, const char *, int) args: (dfd, pathname, flag) -syscall sys_renameat nr 4295 nbargs 4 types: (int, const char *, int, const char *) args: (olddfd, oldname, newdfd, newname) -syscall sys_linkat nr 4296 nbargs 5 types: (int, const char *, int, const char *, int) args: (olddfd, oldname, newdfd, newname, flags) -syscall sys_symlinkat nr 4297 nbargs 3 types: (const char *, int, const char *) args: (oldname, newdfd, newname) -syscall sys_readlinkat nr 4298 nbargs 4 types: (int, const char *, char *, int) args: (dfd, pathname, buf, bufsiz) -syscall sys_fchmodat nr 4299 nbargs 3 types: (int, const char *, umode_t) args: (dfd, filename, mode) -syscall sys_faccessat nr 4300 nbargs 3 types: (int, const char *, int) args: (dfd, filename, mode) -syscall sys_pselect6 nr 4301 nbargs 6 types: (int, fd_set *, fd_set *, fd_set *, struct timespec *, void *) args: (n, inp, outp, exp, tsp, sig) -syscall sys_ppoll nr 4302 nbargs 5 types: (struct pollfd *, unsigned int, struct timespec *, const sigset_t *, size_t) args: (ufds, nfds, tsp, sigmask, sigsetsize) -syscall sys_unshare nr 4303 nbargs 1 types: (unsigned long) args: (unshare_flags) -syscall sys_splice nr 4304 nbargs 6 types: (int, loff_t *, int, loff_t *, size_t, unsigned int) args: (fd_in, off_in, fd_out, off_out, len, flags) -syscall sys_sync_file_range nr 4305 nbargs 4 types: (int, loff_t, loff_t, unsigned int) args: (fd, offset, nbytes, flags) -syscall sys_tee nr 4306 nbargs 4 types: (int, int, size_t, unsigned int) args: (fdin, fdout, len, flags) -syscall sys_vmsplice nr 4307 nbargs 4 types: (int, const struct iovec *, unsigned long, unsigned int) args: (fd, iov, nr_segs, flags) -syscall sys_set_robust_list nr 4309 nbargs 2 types: (struct robust_list_head *, size_t) args: (head, len) -syscall sys_get_robust_list nr 4310 nbargs 3 types: (int, struct robust_list_head * *, size_t *) args: (pid, head_ptr, len_ptr) -syscall sys_getcpu nr 4312 nbargs 3 types: (unsigned *, unsigned *, struct getcpu_cache *) args: (cpup, nodep, unused) -syscall sys_epoll_pwait nr 4313 nbargs 6 types: (int, struct epoll_event *, int, int, const sigset_t *, size_t) args: (epfd, events, maxevents, timeout, sigmask, sigsetsize) -syscall sys_ioprio_set nr 4314 nbargs 3 types: (int, int, int) args: (which, who, ioprio) -syscall sys_ioprio_get nr 4315 nbargs 2 types: (int, int) args: (which, who) -syscall sys_utimensat nr 4316 nbargs 4 types: (int, const char *, struct timespec *, int) args: (dfd, filename, utimes, flags) -syscall sys_signalfd nr 4317 nbargs 3 types: (int, sigset_t *, size_t) args: (ufd, user_mask, sizemask) -syscall sys_eventfd nr 4319 nbargs 1 types: (unsigned int) args: (count) -syscall sys_fallocate nr 4320 nbargs 4 types: (int, int, loff_t, loff_t) args: (fd, mode, offset, len) -syscall sys_timerfd_create nr 4321 nbargs 2 types: (int, int) args: (clockid, flags) -syscall sys_timerfd_gettime nr 4322 nbargs 2 types: (int, struct itimerspec *) args: (ufd, otmr) -syscall sys_timerfd_settime nr 4323 nbargs 4 types: (int, int, const struct itimerspec *, struct itimerspec *) args: (ufd, flags, utmr, otmr) -syscall sys_signalfd4 nr 4324 nbargs 4 types: (int, sigset_t *, size_t, int) args: (ufd, user_mask, sizemask, flags) -syscall sys_eventfd2 nr 4325 nbargs 2 types: (unsigned int, int) args: (count, flags) -syscall sys_epoll_create1 nr 4326 nbargs 1 types: (int) args: (flags) -syscall sys_dup3 nr 4327 nbargs 3 types: (unsigned int, unsigned int, int) args: (oldfd, newfd, flags) -syscall sys_pipe2 nr 4328 nbargs 2 types: (int *, int) args: (fildes, flags) -syscall sys_inotify_init1 nr 4329 nbargs 1 types: (int) args: (flags) -syscall sys_preadv nr 4330 nbargs 5 types: (unsigned long, const struct iovec *, unsigned long, unsigned long, unsigned long) args: (fd, vec, vlen, pos_l, pos_h) -syscall sys_pwritev nr 4331 nbargs 5 types: (unsigned long, const struct iovec *, unsigned long, unsigned long, unsigned long) args: (fd, vec, vlen, pos_l, pos_h) -syscall sys_rt_tgsigqueueinfo nr 4332 nbargs 4 types: (pid_t, pid_t, int, siginfo_t *) args: (tgid, pid, sig, uinfo) -syscall sys_perf_event_open nr 4333 nbargs 5 types: (struct perf_event_attr *, pid_t, int, int, unsigned long) args: (attr_uptr, pid, cpu, group_fd, flags) -syscall sys_accept4 nr 4334 nbargs 4 types: (int, struct sockaddr *, int *, int) args: (fd, upeer_sockaddr, upeer_addrlen, flags) -syscall sys_recvmmsg nr 4335 nbargs 5 types: (int, struct mmsghdr *, unsigned int, unsigned int, struct timespec *) args: (fd, mmsg, vlen, flags, timeout) -syscall sys_prlimit64 nr 4338 nbargs 4 types: (pid_t, unsigned int, const struct rlimit64 *, struct rlimit64 *) args: (pid, resource, new_rlim, old_rlim) -syscall sys_name_to_handle_at nr 4339 nbargs 5 types: (int, const char *, struct file_handle *, int *, int) args: (dfd, name, handle, mnt_id, flag) -syscall sys_open_by_handle_at nr 4340 nbargs 3 types: (int, struct file_handle *, int) args: (mountdirfd, handle, flags) -syscall sys_clock_adjtime nr 4341 nbargs 2 types: (const clockid_t, struct timex *) args: (which_clock, utx) -syscall sys_syncfs nr 4342 nbargs 1 types: (int) args: (fd) -syscall sys_sendmmsg nr 4343 nbargs 4 types: (int, struct mmsghdr *, unsigned int, unsigned int) args: (fd, mmsg, vlen, flags) -syscall sys_setns nr 4344 nbargs 2 types: (int, int) args: (fd, nstype) diff --git a/instrumentation/syscalls/3.18.0/mips-32-syscalls b/instrumentation/syscalls/3.18.0/mips-32-syscalls deleted file mode 100644 index d0b35a67..00000000 --- a/instrumentation/syscalls/3.18.0/mips-32-syscalls +++ /dev/null @@ -1,287 +0,0 @@ -syscall sys_exit nr 4001 nbargs 1 types: (int) args: (error_code) -syscall sys_read nr 4003 nbargs 3 types: (unsigned int, char *, size_t) args: (fd, buf, count) -syscall sys_write nr 4004 nbargs 3 types: (unsigned int, const char *, size_t) args: (fd, buf, count) -syscall sys_open nr 4005 nbargs 3 types: (const char *, int, umode_t) args: (filename, flags, mode) -syscall sys_close nr 4006 nbargs 1 types: (unsigned int) args: (fd) -syscall sys_waitpid nr 4007 nbargs 3 types: (pid_t, int *, int) args: (pid, stat_addr, options) -syscall sys_creat nr 4008 nbargs 2 types: (const char *, umode_t) args: (pathname, mode) -syscall sys_link nr 4009 nbargs 2 types: (const char *, const char *) args: (oldname, newname) -syscall sys_unlink nr 4010 nbargs 1 types: (const char *) args: (pathname) -syscall sys_execve nr 4011 nbargs 3 types: (const char *, const char *const *, const char *const *) args: (filename, argv, envp) -syscall sys_chdir nr 4012 nbargs 1 types: (const char *) args: (filename) -syscall sys_time nr 4013 nbargs 1 types: (time_t *) args: (tloc) -syscall sys_mknod nr 4014 nbargs 3 types: (const char *, umode_t, unsigned) args: (filename, mode, dev) -syscall sys_chmod nr 4015 nbargs 2 types: (const char *, umode_t) args: (filename, mode) -syscall sys_lchown nr 4016 nbargs 3 types: (const char *, uid_t, gid_t) args: (filename, user, group) -syscall sys_lseek nr 4019 nbargs 3 types: (unsigned int, off_t, unsigned int) args: (fd, offset, whence) -syscall sys_getpid nr 4020 nbargs 0 types: () args: () -syscall sys_mount nr 4021 nbargs 5 types: (char *, char *, char *, unsigned long, void *) args: (dev_name, dir_name, type, flags, data) -syscall sys_oldumount nr 4022 nbargs 1 types: (char *) args: (name) -syscall sys_setuid nr 4023 nbargs 1 types: (uid_t) args: (uid) -syscall sys_getuid nr 4024 nbargs 0 types: () args: () -syscall sys_stime nr 4025 nbargs 1 types: (time_t *) args: (tptr) -syscall sys_ptrace nr 4026 nbargs 4 types: (long, long, unsigned long, unsigned long) args: (request, pid, addr, data) -syscall sys_alarm nr 4027 nbargs 1 types: (unsigned int) args: (seconds) -syscall sys_pause nr 4029 nbargs 0 types: () args: () -syscall sys_utime nr 4030 nbargs 2 types: (char *, struct utimbuf *) args: (filename, times) -syscall sys_access nr 4033 nbargs 2 types: (const char *, int) args: (filename, mode) -syscall sys_nice nr 4034 nbargs 1 types: (int) args: (increment) -syscall sys_sync nr 4036 nbargs 0 types: () args: () -syscall sys_kill nr 4037 nbargs 2 types: (pid_t, int) args: (pid, sig) -syscall sys_rename nr 4038 nbargs 2 types: (const char *, const char *) args: (oldname, newname) -syscall sys_mkdir nr 4039 nbargs 2 types: (const char *, umode_t) args: (pathname, mode) -syscall sys_rmdir nr 4040 nbargs 1 types: (const char *) args: (pathname) -syscall sys_dup nr 4041 nbargs 1 types: (unsigned int) args: (fildes) -syscall sys_times nr 4043 nbargs 1 types: (struct tms *) args: (tbuf) -syscall sys_brk nr 4045 nbargs 1 types: (unsigned long) args: (brk) -syscall sys_setgid nr 4046 nbargs 1 types: (gid_t) args: (gid) -syscall sys_getgid nr 4047 nbargs 0 types: () args: () -syscall sys_geteuid nr 4049 nbargs 0 types: () args: () -syscall sys_getegid nr 4050 nbargs 0 types: () args: () -syscall sys_umount nr 4052 nbargs 2 types: (char *, int) args: (name, flags) -syscall sys_ioctl nr 4054 nbargs 3 types: (unsigned int, unsigned int, unsigned long) args: (fd, cmd, arg) -syscall sys_fcntl nr 4055 nbargs 3 types: (unsigned int, unsigned int, unsigned long) args: (fd, cmd, arg) -syscall sys_setpgid nr 4057 nbargs 2 types: (pid_t, pid_t) args: (pid, pgid) -syscall sys_olduname nr 4059 nbargs 1 types: (struct oldold_utsname *) args: (name) -syscall sys_umask nr 4060 nbargs 1 types: (int) args: (mask) -syscall sys_chroot nr 4061 nbargs 1 types: (const char *) args: (filename) -syscall sys_ustat nr 4062 nbargs 2 types: (unsigned, struct ustat *) args: (dev, ubuf) -syscall sys_dup2 nr 4063 nbargs 2 types: (unsigned int, unsigned int) args: (oldfd, newfd) -syscall sys_getppid nr 4064 nbargs 0 types: () args: () -syscall sys_getpgrp nr 4065 nbargs 0 types: () args: () -syscall sys_setsid nr 4066 nbargs 0 types: () args: () -syscall sys_sigaction nr 4067 nbargs 3 types: (int, const struct sigaction *, struct sigaction *) args: (sig, act, oact) -syscall sys_setreuid nr 4070 nbargs 2 types: (uid_t, uid_t) args: (ruid, euid) -syscall sys_setregid nr 4071 nbargs 2 types: (gid_t, gid_t) args: (rgid, egid) -syscall sys_sigsuspend nr 4072 nbargs 1 types: (sigset_t *) args: (uset) -syscall sys_sigpending nr 4073 nbargs 1 types: (old_sigset_t *) args: (set) -syscall sys_sethostname nr 4074 nbargs 2 types: (char *, int) args: (name, len) -syscall sys_setrlimit nr 4075 nbargs 2 types: (unsigned int, struct rlimit *) args: (resource, rlim) -syscall sys_getrlimit nr 4076 nbargs 2 types: (unsigned int, struct rlimit *) args: (resource, rlim) -syscall sys_getrusage nr 4077 nbargs 2 types: (int, struct rusage *) args: (who, ru) -syscall sys_gettimeofday nr 4078 nbargs 2 types: (struct timeval *, struct timezone *) args: (tv, tz) -syscall sys_settimeofday nr 4079 nbargs 2 types: (struct timeval *, struct timezone *) args: (tv, tz) -syscall sys_getgroups nr 4080 nbargs 2 types: (int, gid_t *) args: (gidsetsize, grouplist) -syscall sys_setgroups nr 4081 nbargs 2 types: (int, gid_t *) args: (gidsetsize, grouplist) -syscall sys_symlink nr 4083 nbargs 2 types: (const char *, const char *) args: (oldname, newname) -syscall sys_readlink nr 4085 nbargs 3 types: (const char *, char *, int) args: (path, buf, bufsiz) -syscall sys_reboot nr 4088 nbargs 4 types: (int, int, unsigned int, void *) args: (magic1, magic2, cmd, arg) -syscall sys_old_readdir nr 4089 nbargs 3 types: (unsigned int, struct old_linux_dirent *, unsigned int) args: (fd, dirent, count) -syscall sys_mmap nr 4090 nbargs 6 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long, off_t) args: (addr, len, prot, flags, fd, offset) -syscall sys_munmap nr 4091 nbargs 2 types: (unsigned long, size_t) args: (addr, len) -syscall sys_truncate nr 4092 nbargs 2 types: (const char *, long) args: (path, length) -syscall sys_ftruncate nr 4093 nbargs 2 types: (unsigned int, unsigned long) args: (fd, length) -syscall sys_fchmod nr 4094 nbargs 2 types: (unsigned int, umode_t) args: (fd, mode) -syscall sys_fchown nr 4095 nbargs 3 types: (unsigned int, uid_t, gid_t) args: (fd, user, group) -syscall sys_getpriority nr 4096 nbargs 2 types: (int, int) args: (which, who) -syscall sys_setpriority nr 4097 nbargs 3 types: (int, int, int) args: (which, who, niceval) -syscall sys_statfs nr 4099 nbargs 2 types: (const char *, struct statfs *) args: (pathname, buf) -syscall sys_fstatfs nr 4100 nbargs 2 types: (unsigned int, struct statfs *) args: (fd, buf) -syscall sys_socketcall nr 4102 nbargs 2 types: (int, unsigned long *) args: (call, args) -syscall sys_syslog nr 4103 nbargs 3 types: (int, char *, int) args: (type, buf, len) -syscall sys_setitimer nr 4104 nbargs 3 types: (int, struct itimerval *, struct itimerval *) args: (which, value, ovalue) -syscall sys_getitimer nr 4105 nbargs 2 types: (int, struct itimerval *) args: (which, value) -syscall sys_newstat nr 4106 nbargs 2 types: (const char *, struct stat *) args: (filename, statbuf) -syscall sys_newlstat nr 4107 nbargs 2 types: (const char *, struct stat *) args: (filename, statbuf) -syscall sys_newfstat nr 4108 nbargs 2 types: (unsigned int, struct stat *) args: (fd, statbuf) -syscall sys_uname nr 4109 nbargs 1 types: (struct old_utsname *) args: (name) -syscall sys_vhangup nr 4111 nbargs 0 types: () args: () -syscall sys_wait4 nr 4114 nbargs 4 types: (pid_t, int *, int, struct rusage *) args: (upid, stat_addr, options, ru) -syscall sys_sysinfo nr 4116 nbargs 1 types: (struct sysinfo *) args: (info) -syscall sys_ipc nr 4117 nbargs 6 types: (unsigned int, int, unsigned long, unsigned long, void *, long) args: (call, first, second, third, ptr, fifth) -syscall sys_fsync nr 4118 nbargs 1 types: (unsigned int) args: (fd) -syscall sys_setdomainname nr 4121 nbargs 2 types: (char *, int) args: (name, len) -syscall sys_newuname nr 4122 nbargs 1 types: (struct new_utsname *) args: (name) -syscall sys_adjtimex nr 4124 nbargs 1 types: (struct timex *) args: (txc_p) -syscall sys_mprotect nr 4125 nbargs 3 types: (unsigned long, size_t, unsigned long) args: (start, len, prot) -syscall sys_sigprocmask nr 4126 nbargs 3 types: (int, old_sigset_t *, old_sigset_t *) args: (how, nset, oset) -syscall sys_init_module nr 4128 nbargs 3 types: (void *, unsigned long, const char *) args: (umod, len, uargs) -syscall sys_delete_module nr 4129 nbargs 2 types: (const char *, unsigned int) args: (name_user, flags) -syscall sys_getpgid nr 4132 nbargs 1 types: (pid_t) args: (pid) -syscall sys_fchdir nr 4133 nbargs 1 types: (unsigned int) args: (fd) -syscall sys_bdflush nr 4134 nbargs 2 types: (int, long) args: (func, data) -syscall sys_personality nr 4136 nbargs 1 types: (unsigned int) args: (personality) -syscall sys_setfsuid nr 4138 nbargs 1 types: (uid_t) args: (uid) -syscall sys_setfsgid nr 4139 nbargs 1 types: (gid_t) args: (gid) -syscall sys_llseek nr 4140 nbargs 5 types: (unsigned int, unsigned long, unsigned long, loff_t *, unsigned int) args: (fd, offset_high, offset_low, result, whence) -syscall sys_getdents nr 4141 nbargs 3 types: (unsigned int, struct linux_dirent *, unsigned int) args: (fd, dirent, count) -syscall sys_select nr 4142 nbargs 5 types: (int, fd_set *, fd_set *, fd_set *, struct timeval *) args: (n, inp, outp, exp, tvp) -syscall sys_flock nr 4143 nbargs 2 types: (unsigned int, unsigned int) args: (fd, cmd) -syscall sys_msync nr 4144 nbargs 3 types: (unsigned long, size_t, int) args: (start, len, flags) -syscall sys_readv nr 4145 nbargs 3 types: (unsigned long, const struct iovec *, unsigned long) args: (fd, vec, vlen) -syscall sys_writev nr 4146 nbargs 3 types: (unsigned long, const struct iovec *, unsigned long) args: (fd, vec, vlen) -syscall sys_cacheflush nr 4147 nbargs 3 types: (unsigned long, unsigned long, unsigned int) args: (addr, bytes, cache) -syscall sys_cachectl nr 4148 nbargs 3 types: (char *, int, int) args: (addr, nbytes, op) -syscall sys_sysmips nr 4149 nbargs 3 types: (long, long, long) args: (cmd, arg1, arg2) -syscall sys_getsid nr 4151 nbargs 1 types: (pid_t) args: (pid) -syscall sys_fdatasync nr 4152 nbargs 1 types: (unsigned int) args: (fd) -syscall sys_sysctl nr 4153 nbargs 1 types: (struct __sysctl_args *) args: (args) -syscall sys_mlock nr 4154 nbargs 2 types: (unsigned long, size_t) args: (start, len) -syscall sys_munlock nr 4155 nbargs 2 types: (unsigned long, size_t) args: (start, len) -syscall sys_mlockall nr 4156 nbargs 1 types: (int) args: (flags) -syscall sys_munlockall nr 4157 nbargs 0 types: () args: () -syscall sys_sched_setparam nr 4158 nbargs 2 types: (pid_t, struct sched_param *) args: (pid, param) -syscall sys_sched_getparam nr 4159 nbargs 2 types: (pid_t, struct sched_param *) args: (pid, param) -syscall sys_sched_setscheduler nr 4160 nbargs 3 types: (pid_t, int, struct sched_param *) args: (pid, policy, param) -syscall sys_sched_getscheduler nr 4161 nbargs 1 types: (pid_t) args: (pid) -syscall sys_sched_yield nr 4162 nbargs 0 types: () args: () -syscall sys_sched_get_priority_max nr 4163 nbargs 1 types: (int) args: (policy) -syscall sys_sched_get_priority_min nr 4164 nbargs 1 types: (int) args: (policy) -syscall sys_sched_rr_get_interval nr 4165 nbargs 2 types: (pid_t, struct timespec *) args: (pid, interval) -syscall sys_nanosleep nr 4166 nbargs 2 types: (struct timespec *, struct timespec *) args: (rqtp, rmtp) -syscall sys_mremap nr 4167 nbargs 5 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long) args: (addr, old_len, new_len, flags, new_addr) -syscall sys_accept nr 4168 nbargs 3 types: (int, struct sockaddr *, int *) args: (fd, upeer_sockaddr, upeer_addrlen) -syscall sys_bind nr 4169 nbargs 3 types: (int, struct sockaddr *, int) args: (fd, umyaddr, addrlen) -syscall sys_connect nr 4170 nbargs 3 types: (int, struct sockaddr *, int) args: (fd, uservaddr, addrlen) -syscall sys_getpeername nr 4171 nbargs 3 types: (int, struct sockaddr *, int *) args: (fd, usockaddr, usockaddr_len) -syscall sys_getsockname nr 4172 nbargs 3 types: (int, struct sockaddr *, int *) args: (fd, usockaddr, usockaddr_len) -syscall sys_getsockopt nr 4173 nbargs 5 types: (int, int, int, char *, int *) args: (fd, level, optname, optval, optlen) -syscall sys_listen nr 4174 nbargs 2 types: (int, int) args: (fd, backlog) -syscall sys_recv nr 4175 nbargs 4 types: (int, void *, size_t, unsigned int) args: (fd, ubuf, size, flags) -syscall sys_recvfrom nr 4176 nbargs 6 types: (int, void *, size_t, unsigned int, struct sockaddr *, int *) args: (fd, ubuf, size, flags, addr, addr_len) -syscall sys_recvmsg nr 4177 nbargs 3 types: (int, struct msghdr *, unsigned int) args: (fd, msg, flags) -syscall sys_send nr 4178 nbargs 4 types: (int, void *, size_t, unsigned int) args: (fd, buff, len, flags) -syscall sys_sendmsg nr 4179 nbargs 3 types: (int, struct msghdr *, unsigned int) args: (fd, msg, flags) -syscall sys_sendto nr 4180 nbargs 6 types: (int, void *, size_t, unsigned int, struct sockaddr *, int) args: (fd, buff, len, flags, addr, addr_len) -syscall sys_setsockopt nr 4181 nbargs 5 types: (int, int, int, char *, int) args: (fd, level, optname, optval, optlen) -syscall sys_shutdown nr 4182 nbargs 2 types: (int, int) args: (fd, how) -syscall sys_socket nr 4183 nbargs 3 types: (int, int, int) args: (family, type, protocol) -syscall sys_socketpair nr 4184 nbargs 4 types: (int, int, int, int *) args: (family, type, protocol, usockvec) -syscall sys_setresuid nr 4185 nbargs 3 types: (uid_t, uid_t, uid_t) args: (ruid, euid, suid) -syscall sys_getresuid nr 4186 nbargs 3 types: (uid_t *, uid_t *, uid_t *) args: (ruidp, euidp, suidp) -syscall sys_poll nr 4188 nbargs 3 types: (struct pollfd *, unsigned int, int) args: (ufds, nfds, timeout_msecs) -syscall sys_setresgid nr 4190 nbargs 3 types: (gid_t, gid_t, gid_t) args: (rgid, egid, sgid) -syscall sys_getresgid nr 4191 nbargs 3 types: (gid_t *, gid_t *, gid_t *) args: (rgidp, egidp, sgidp) -syscall sys_prctl nr 4192 nbargs 5 types: (int, unsigned long, unsigned long, unsigned long, unsigned long) args: (option, arg2, arg3, arg4, arg5) -syscall sys_rt_sigaction nr 4194 nbargs 4 types: (int, const struct sigaction *, struct sigaction *, size_t) args: (sig, act, oact, sigsetsize) -syscall sys_rt_sigprocmask nr 4195 nbargs 4 types: (int, sigset_t *, sigset_t *, size_t) args: (how, nset, oset, sigsetsize) -syscall sys_rt_sigpending nr 4196 nbargs 2 types: (sigset_t *, size_t) args: (uset, sigsetsize) -syscall sys_rt_sigtimedwait nr 4197 nbargs 4 types: (const sigset_t *, siginfo_t *, const struct timespec *, size_t) args: (uthese, uinfo, uts, sigsetsize) -syscall sys_rt_sigqueueinfo nr 4198 nbargs 3 types: (pid_t, int, siginfo_t *) args: (pid, sig, uinfo) -syscall sys_rt_sigsuspend nr 4199 nbargs 2 types: (sigset_t *, size_t) args: (unewset, sigsetsize) -syscall sys_pread64 nr 4200 nbargs 4 types: (unsigned int, char *, size_t, loff_t) args: (fd, buf, count, pos) -syscall sys_pwrite64 nr 4201 nbargs 4 types: (unsigned int, const char *, size_t, loff_t) args: (fd, buf, count, pos) -syscall sys_chown nr 4202 nbargs 3 types: (const char *, uid_t, gid_t) args: (filename, user, group) -syscall sys_getcwd nr 4203 nbargs 2 types: (char *, unsigned long) args: (buf, size) -syscall sys_capget nr 4204 nbargs 2 types: (cap_user_header_t, cap_user_data_t) args: (header, dataptr) -syscall sys_capset nr 4205 nbargs 2 types: (cap_user_header_t, const cap_user_data_t) args: (header, data) -syscall sys_sigaltstack nr 4206 nbargs 2 types: (const stack_t *, stack_t *) args: (uss, uoss) -syscall sys_sendfile nr 4207 nbargs 4 types: (int, int, off_t *, size_t) args: (out_fd, in_fd, offset, count) -syscall sys_mips_mmap2 nr 4210 nbargs 6 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long, unsigned long) args: (addr, len, prot, flags, fd, pgoff) -syscall sys_truncate64 nr 4211 nbargs 2 types: (const char *, loff_t) args: (path, length) -syscall sys_ftruncate64 nr 4212 nbargs 2 types: (unsigned int, loff_t) args: (fd, length) -syscall sys_stat64 nr 4213 nbargs 2 types: (const char *, struct stat64 *) args: (filename, statbuf) -syscall sys_lstat64 nr 4214 nbargs 2 types: (const char *, struct stat64 *) args: (filename, statbuf) -syscall sys_fstat64 nr 4215 nbargs 2 types: (unsigned long, struct stat64 *) args: (fd, statbuf) -syscall sys_pivot_root nr 4216 nbargs 2 types: (const char *, const char *) args: (new_root, put_old) -syscall sys_mincore nr 4217 nbargs 3 types: (unsigned long, size_t, unsigned char *) args: (start, len, vec) -syscall sys_madvise nr 4218 nbargs 3 types: (unsigned long, size_t, int) args: (start, len_in, behavior) -syscall sys_getdents64 nr 4219 nbargs 3 types: (unsigned int, struct linux_dirent64 *, unsigned int) args: (fd, dirent, count) -syscall sys_fcntl64 nr 4220 nbargs 3 types: (unsigned int, unsigned int, unsigned long) args: (fd, cmd, arg) -syscall sys_gettid nr 4222 nbargs 0 types: () args: () -syscall sys_readahead nr 4223 nbargs 3 types: (int, loff_t, size_t) args: (fd, offset, count) -syscall sys_setxattr nr 4224 nbargs 5 types: (const char *, const char *, const void *, size_t, int) args: (pathname, name, value, size, flags) -syscall sys_lsetxattr nr 4225 nbargs 5 types: (const char *, const char *, const void *, size_t, int) args: (pathname, name, value, size, flags) -syscall sys_fsetxattr nr 4226 nbargs 5 types: (int, const char *, const void *, size_t, int) args: (fd, name, value, size, flags) -syscall sys_getxattr nr 4227 nbargs 4 types: (const char *, const char *, void *, size_t) args: (pathname, name, value, size) -syscall sys_lgetxattr nr 4228 nbargs 4 types: (const char *, const char *, void *, size_t) args: (pathname, name, value, size) -syscall sys_fgetxattr nr 4229 nbargs 4 types: (int, const char *, void *, size_t) args: (fd, name, value, size) -syscall sys_listxattr nr 4230 nbargs 3 types: (const char *, char *, size_t) args: (pathname, list, size) -syscall sys_llistxattr nr 4231 nbargs 3 types: (const char *, char *, size_t) args: (pathname, list, size) -syscall sys_flistxattr nr 4232 nbargs 3 types: (int, char *, size_t) args: (fd, list, size) -syscall sys_removexattr nr 4233 nbargs 2 types: (const char *, const char *) args: (pathname, name) -syscall sys_lremovexattr nr 4234 nbargs 2 types: (const char *, const char *) args: (pathname, name) -syscall sys_fremovexattr nr 4235 nbargs 2 types: (int, const char *) args: (fd, name) -syscall sys_tkill nr 4236 nbargs 2 types: (pid_t, int) args: (pid, sig) -syscall sys_sendfile64 nr 4237 nbargs 4 types: (int, int, loff_t *, size_t) args: (out_fd, in_fd, offset, count) -syscall sys_futex nr 4238 nbargs 6 types: (u32 *, int, u32, struct timespec *, u32 *, u32) args: (uaddr, op, val, utime, uaddr2, val3) -syscall sys_io_setup nr 4241 nbargs 2 types: (unsigned, aio_context_t *) args: (nr_events, ctxp) -syscall sys_io_destroy nr 4242 nbargs 1 types: (aio_context_t) args: (ctx) -syscall sys_io_getevents nr 4243 nbargs 5 types: (aio_context_t, long, long, struct io_event *, struct timespec *) args: (ctx_id, min_nr, nr, events, timeout) -syscall sys_io_submit nr 4244 nbargs 3 types: (aio_context_t, long, struct iocb * *) args: (ctx_id, nr, iocbpp) -syscall sys_io_cancel nr 4245 nbargs 3 types: (aio_context_t, struct iocb *, struct io_event *) args: (ctx_id, iocb, result) -syscall sys_exit_group nr 4246 nbargs 1 types: (int) args: (error_code) -syscall sys_epoll_create nr 4248 nbargs 1 types: (int) args: (size) -syscall sys_epoll_ctl nr 4249 nbargs 4 types: (int, int, int, struct epoll_event *) args: (epfd, op, fd, event) -syscall sys_epoll_wait nr 4250 nbargs 4 types: (int, struct epoll_event *, int, int) args: (epfd, events, maxevents, timeout) -syscall sys_remap_file_pages nr 4251 nbargs 5 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long) args: (start, size, prot, pgoff, flags) -syscall sys_set_tid_address nr 4252 nbargs 1 types: (int *) args: (tidptr) -syscall sys_restart_syscall nr 4253 nbargs 0 types: () args: () -syscall sys_fadvise64_64 nr 4254 nbargs 4 types: (int, loff_t, loff_t, int) args: (fd, offset, len, advice) -syscall sys_statfs64 nr 4255 nbargs 3 types: (const char *, size_t, struct statfs64 *) args: (pathname, sz, buf) -syscall sys_fstatfs64 nr 4256 nbargs 3 types: (unsigned int, size_t, struct statfs64 *) args: (fd, sz, buf) -syscall sys_timer_create nr 4257 nbargs 3 types: (const clockid_t, struct sigevent *, timer_t *) args: (which_clock, timer_event_spec, created_timer_id) -syscall sys_timer_settime nr 4258 nbargs 4 types: (timer_t, int, const struct itimerspec *, struct itimerspec *) args: (timer_id, flags, new_setting, old_setting) -syscall sys_timer_gettime nr 4259 nbargs 2 types: (timer_t, struct itimerspec *) args: (timer_id, setting) -syscall sys_timer_getoverrun nr 4260 nbargs 1 types: (timer_t) args: (timer_id) -syscall sys_timer_delete nr 4261 nbargs 1 types: (timer_t) args: (timer_id) -syscall sys_clock_settime nr 4262 nbargs 2 types: (const clockid_t, const struct timespec *) args: (which_clock, tp) -syscall sys_clock_gettime nr 4263 nbargs 2 types: (const clockid_t, struct timespec *) args: (which_clock, tp) -syscall sys_clock_getres nr 4264 nbargs 2 types: (const clockid_t, struct timespec *) args: (which_clock, tp) -syscall sys_clock_nanosleep nr 4265 nbargs 4 types: (const clockid_t, int, const struct timespec *, struct timespec *) args: (which_clock, flags, rqtp, rmtp) -syscall sys_tgkill nr 4266 nbargs 3 types: (pid_t, pid_t, int) args: (tgid, pid, sig) -syscall sys_utimes nr 4267 nbargs 2 types: (char *, struct timeval *) args: (filename, utimes) -syscall sys_waitid nr 4278 nbargs 5 types: (int, pid_t, struct siginfo *, int, struct rusage *) args: (which, upid, infop, options, ru) -syscall sys_set_thread_area nr 4283 nbargs 1 types: (unsigned long) args: (addr) -syscall sys_inotify_init nr 4284 nbargs 0 types: () args: () -syscall sys_inotify_add_watch nr 4285 nbargs 3 types: (int, const char *, u32) args: (fd, pathname, mask) -syscall sys_inotify_rm_watch nr 4286 nbargs 2 types: (int, __s32) args: (fd, wd) -syscall sys_openat nr 4288 nbargs 4 types: (int, const char *, int, umode_t) args: (dfd, filename, flags, mode) -syscall sys_mkdirat nr 4289 nbargs 3 types: (int, const char *, umode_t) args: (dfd, pathname, mode) -syscall sys_mknodat nr 4290 nbargs 4 types: (int, const char *, umode_t, unsigned) args: (dfd, filename, mode, dev) -syscall sys_fchownat nr 4291 nbargs 5 types: (int, const char *, uid_t, gid_t, int) args: (dfd, filename, user, group, flag) -syscall sys_futimesat nr 4292 nbargs 3 types: (int, const char *, struct timeval *) args: (dfd, filename, utimes) -syscall sys_fstatat64 nr 4293 nbargs 4 types: (int, const char *, struct stat64 *, int) args: (dfd, filename, statbuf, flag) -syscall sys_unlinkat nr 4294 nbargs 3 types: (int, const char *, int) args: (dfd, pathname, flag) -syscall sys_renameat nr 4295 nbargs 4 types: (int, const char *, int, const char *) args: (olddfd, oldname, newdfd, newname) -syscall sys_linkat nr 4296 nbargs 5 types: (int, const char *, int, const char *, int) args: (olddfd, oldname, newdfd, newname, flags) -syscall sys_symlinkat nr 4297 nbargs 3 types: (const char *, int, const char *) args: (oldname, newdfd, newname) -syscall sys_readlinkat nr 4298 nbargs 4 types: (int, const char *, char *, int) args: (dfd, pathname, buf, bufsiz) -syscall sys_fchmodat nr 4299 nbargs 3 types: (int, const char *, umode_t) args: (dfd, filename, mode) -syscall sys_faccessat nr 4300 nbargs 3 types: (int, const char *, int) args: (dfd, filename, mode) -syscall sys_pselect6 nr 4301 nbargs 6 types: (int, fd_set *, fd_set *, fd_set *, struct timespec *, void *) args: (n, inp, outp, exp, tsp, sig) -syscall sys_ppoll nr 4302 nbargs 5 types: (struct pollfd *, unsigned int, struct timespec *, const sigset_t *, size_t) args: (ufds, nfds, tsp, sigmask, sigsetsize) -syscall sys_unshare nr 4303 nbargs 1 types: (unsigned long) args: (unshare_flags) -syscall sys_splice nr 4304 nbargs 6 types: (int, loff_t *, int, loff_t *, size_t, unsigned int) args: (fd_in, off_in, fd_out, off_out, len, flags) -syscall sys_sync_file_range nr 4305 nbargs 4 types: (int, loff_t, loff_t, unsigned int) args: (fd, offset, nbytes, flags) -syscall sys_tee nr 4306 nbargs 4 types: (int, int, size_t, unsigned int) args: (fdin, fdout, len, flags) -syscall sys_vmsplice nr 4307 nbargs 4 types: (int, const struct iovec *, unsigned long, unsigned int) args: (fd, iov, nr_segs, flags) -syscall sys_set_robust_list nr 4309 nbargs 2 types: (struct robust_list_head *, size_t) args: (head, len) -syscall sys_get_robust_list nr 4310 nbargs 3 types: (int, struct robust_list_head * *, size_t *) args: (pid, head_ptr, len_ptr) -syscall sys_getcpu nr 4312 nbargs 3 types: (unsigned *, unsigned *, struct getcpu_cache *) args: (cpup, nodep, unused) -syscall sys_epoll_pwait nr 4313 nbargs 6 types: (int, struct epoll_event *, int, int, const sigset_t *, size_t) args: (epfd, events, maxevents, timeout, sigmask, sigsetsize) -syscall sys_ioprio_set nr 4314 nbargs 3 types: (int, int, int) args: (which, who, ioprio) -syscall sys_ioprio_get nr 4315 nbargs 2 types: (int, int) args: (which, who) -syscall sys_utimensat nr 4316 nbargs 4 types: (int, const char *, struct timespec *, int) args: (dfd, filename, utimes, flags) -syscall sys_signalfd nr 4317 nbargs 3 types: (int, sigset_t *, size_t) args: (ufd, user_mask, sizemask) -syscall sys_eventfd nr 4319 nbargs 1 types: (unsigned int) args: (count) -syscall sys_fallocate nr 4320 nbargs 4 types: (int, int, loff_t, loff_t) args: (fd, mode, offset, len) -syscall sys_timerfd_create nr 4321 nbargs 2 types: (int, int) args: (clockid, flags) -syscall sys_timerfd_gettime nr 4322 nbargs 2 types: (int, struct itimerspec *) args: (ufd, otmr) -syscall sys_timerfd_settime nr 4323 nbargs 4 types: (int, int, const struct itimerspec *, struct itimerspec *) args: (ufd, flags, utmr, otmr) -syscall sys_signalfd4 nr 4324 nbargs 4 types: (int, sigset_t *, size_t, int) args: (ufd, user_mask, sizemask, flags) -syscall sys_eventfd2 nr 4325 nbargs 2 types: (unsigned int, int) args: (count, flags) -syscall sys_epoll_create1 nr 4326 nbargs 1 types: (int) args: (flags) -syscall sys_dup3 nr 4327 nbargs 3 types: (unsigned int, unsigned int, int) args: (oldfd, newfd, flags) -syscall sys_pipe2 nr 4328 nbargs 2 types: (int *, int) args: (fildes, flags) -syscall sys_inotify_init1 nr 4329 nbargs 1 types: (int) args: (flags) -syscall sys_preadv nr 4330 nbargs 5 types: (unsigned long, const struct iovec *, unsigned long, unsigned long, unsigned long) args: (fd, vec, vlen, pos_l, pos_h) -syscall sys_pwritev nr 4331 nbargs 5 types: (unsigned long, const struct iovec *, unsigned long, unsigned long, unsigned long) args: (fd, vec, vlen, pos_l, pos_h) -syscall sys_rt_tgsigqueueinfo nr 4332 nbargs 4 types: (pid_t, pid_t, int, siginfo_t *) args: (tgid, pid, sig, uinfo) -syscall sys_perf_event_open nr 4333 nbargs 5 types: (struct perf_event_attr *, pid_t, int, int, unsigned long) args: (attr_uptr, pid, cpu, group_fd, flags) -syscall sys_accept4 nr 4334 nbargs 4 types: (int, struct sockaddr *, int *, int) args: (fd, upeer_sockaddr, upeer_addrlen, flags) -syscall sys_recvmmsg nr 4335 nbargs 5 types: (int, struct mmsghdr *, unsigned int, unsigned int, struct timespec *) args: (fd, mmsg, vlen, flags, timeout) -syscall sys_prlimit64 nr 4338 nbargs 4 types: (pid_t, unsigned int, const struct rlimit64 *, struct rlimit64 *) args: (pid, resource, new_rlim, old_rlim) -syscall sys_name_to_handle_at nr 4339 nbargs 5 types: (int, const char *, struct file_handle *, int *, int) args: (dfd, name, handle, mnt_id, flag) -syscall sys_open_by_handle_at nr 4340 nbargs 3 types: (int, struct file_handle *, int) args: (mountdirfd, handle, flags) -syscall sys_clock_adjtime nr 4341 nbargs 2 types: (const clockid_t, struct timex *) args: (which_clock, utx) -syscall sys_syncfs nr 4342 nbargs 1 types: (int) args: (fd) -syscall sys_sendmmsg nr 4343 nbargs 4 types: (int, struct mmsghdr *, unsigned int, unsigned int) args: (fd, mmsg, vlen, flags) -syscall sys_setns nr 4344 nbargs 2 types: (int, int) args: (fd, nstype) -syscall sys_finit_module nr 4348 nbargs 3 types: (int, const char *, int) args: (fd, uargs, flags) -syscall sys_sched_setattr nr 4349 nbargs 3 types: (pid_t, struct sched_attr *, unsigned int) args: (pid, uattr, flags) -syscall sys_sched_getattr nr 4350 nbargs 4 types: (pid_t, struct sched_attr *, unsigned int, unsigned int) args: (pid, uattr, size, flags) -syscall sys_renameat2 nr 4351 nbargs 5 types: (int, const char *, int, const char *, unsigned int) args: (olddfd, oldname, newdfd, newname, flags) -syscall sys_seccomp nr 4352 nbargs 3 types: (unsigned int, unsigned int, const char *) args: (op, flags, uargs) -syscall sys_getrandom nr 4353 nbargs 3 types: (char *, size_t, unsigned int) args: (buf, count, flags) -syscall sys_memfd_create nr 4354 nbargs 2 types: (const char *, unsigned int) args: (uname, flags) diff --git a/instrumentation/syscalls/3.4.25/arm-32-syscalls b/instrumentation/syscalls/3.4.25/arm-32-syscalls deleted file mode 100644 index 65c3973d..00000000 --- a/instrumentation/syscalls/3.4.25/arm-32-syscalls +++ /dev/null @@ -1,299 +0,0 @@ -syscall sys_restart_syscall nr 0 nbargs 0 types: () args: () -syscall sys_exit nr 1 nbargs 1 types: (int) args: (error_code) -syscall sys_read nr 3 nbargs 3 types: (unsigned int, char *, size_t) args: (fd, buf, count) -syscall sys_write nr 4 nbargs 3 types: (unsigned int, const char *, size_t) args: (fd, buf, count) -syscall sys_open nr 5 nbargs 3 types: (const char *, int, umode_t) args: (filename, flags, mode) -syscall sys_close nr 6 nbargs 1 types: (unsigned int) args: (fd) -syscall sys_creat nr 8 nbargs 2 types: (const char *, umode_t) args: (pathname, mode) -syscall sys_link nr 9 nbargs 2 types: (const char *, const char *) args: (oldname, newname) -syscall sys_unlink nr 10 nbargs 1 types: (const char *) args: (pathname) -syscall sys_chdir nr 12 nbargs 1 types: (const char *) args: (filename) -syscall sys_mknod nr 14 nbargs 3 types: (const char *, umode_t, unsigned) args: (filename, mode, dev) -syscall sys_chmod nr 15 nbargs 2 types: (const char *, umode_t) args: (filename, mode) -syscall sys_lchown16 nr 16 nbargs 3 types: (const char *, old_uid_t, old_gid_t) args: (filename, user, group) -syscall sys_lseek nr 19 nbargs 3 types: (unsigned int, off_t, unsigned int) args: (fd, offset, origin) -syscall sys_getpid nr 20 nbargs 0 types: () args: () -syscall sys_mount nr 21 nbargs 5 types: (char *, char *, char *, unsigned long, void *) args: (dev_name, dir_name, type, flags, data) -syscall sys_setuid16 nr 23 nbargs 1 types: (old_uid_t) args: (uid) -syscall sys_getuid16 nr 24 nbargs 0 types: () args: () -syscall sys_ptrace nr 26 nbargs 4 types: (long, long, unsigned long, unsigned long) args: (request, pid, addr, data) -syscall sys_pause nr 29 nbargs 0 types: () args: () -syscall sys_access nr 33 nbargs 2 types: (const char *, int) args: (filename, mode) -syscall sys_nice nr 34 nbargs 1 types: (int) args: (increment) -syscall sys_sync nr 36 nbargs 0 types: () args: () -syscall sys_kill nr 37 nbargs 2 types: (pid_t, int) args: (pid, sig) -syscall sys_rename nr 38 nbargs 2 types: (const char *, const char *) args: (oldname, newname) -syscall sys_mkdir nr 39 nbargs 2 types: (const char *, umode_t) args: (pathname, mode) -syscall sys_rmdir nr 40 nbargs 1 types: (const char *) args: (pathname) -syscall sys_dup nr 41 nbargs 1 types: (unsigned int) args: (fildes) -syscall sys_pipe nr 42 nbargs 1 types: (int *) args: (fildes) -syscall sys_times nr 43 nbargs 1 types: (struct tms *) args: (tbuf) -syscall sys_brk nr 45 nbargs 1 types: (unsigned long) args: (brk) -syscall sys_setgid16 nr 46 nbargs 1 types: (old_gid_t) args: (gid) -syscall sys_getgid16 nr 47 nbargs 0 types: () args: () -syscall sys_geteuid16 nr 49 nbargs 0 types: () args: () -syscall sys_getegid16 nr 50 nbargs 0 types: () args: () -syscall sys_acct nr 51 nbargs 1 types: (const char *) args: (name) -syscall sys_umount nr 52 nbargs 2 types: (char *, int) args: (name, flags) -syscall sys_ioctl nr 54 nbargs 3 types: (unsigned int, unsigned int, unsigned long) args: (fd, cmd, arg) -syscall sys_fcntl nr 55 nbargs 3 types: (unsigned int, unsigned int, unsigned long) args: (fd, cmd, arg) -syscall sys_setpgid nr 57 nbargs 2 types: (pid_t, pid_t) args: (pid, pgid) -syscall sys_umask nr 60 nbargs 1 types: (int) args: (mask) -syscall sys_chroot nr 61 nbargs 1 types: (const char *) args: (filename) -syscall sys_ustat nr 62 nbargs 2 types: (unsigned, struct ustat *) args: (dev, ubuf) -syscall sys_dup2 nr 63 nbargs 2 types: (unsigned int, unsigned int) args: (oldfd, newfd) -syscall sys_getppid nr 64 nbargs 0 types: () args: () -syscall sys_getpgrp nr 65 nbargs 0 types: () args: () -syscall sys_setsid nr 66 nbargs 0 types: () args: () -syscall sys_setreuid16 nr 70 nbargs 2 types: (old_uid_t, old_uid_t) args: (ruid, euid) -syscall sys_setregid16 nr 71 nbargs 2 types: (old_gid_t, old_gid_t) args: (rgid, egid) -syscall sys_sigpending nr 73 nbargs 1 types: (old_sigset_t *) args: (set) -syscall sys_sethostname nr 74 nbargs 2 types: (char *, int) args: (name, len) -syscall sys_setrlimit nr 75 nbargs 2 types: (unsigned int, struct rlimit *) args: (resource, rlim) -syscall sys_getrusage nr 77 nbargs 2 types: (int, struct rusage *) args: (who, ru) -syscall sys_gettimeofday nr 78 nbargs 2 types: (struct timeval *, struct timezone *) args: (tv, tz) -syscall sys_settimeofday nr 79 nbargs 2 types: (struct timeval *, struct timezone *) args: (tv, tz) -syscall sys_getgroups16 nr 80 nbargs 2 types: (int, old_gid_t *) args: (gidsetsize, grouplist) -syscall sys_setgroups16 nr 81 nbargs 2 types: (int, old_gid_t *) args: (gidsetsize, grouplist) -syscall sys_symlink nr 83 nbargs 2 types: (const char *, const char *) args: (oldname, newname) -syscall sys_readlink nr 85 nbargs 3 types: (const char *, char *, int) args: (path, buf, bufsiz) -syscall sys_uselib nr 86 nbargs 1 types: (const char *) args: (library) -syscall sys_swapon nr 87 nbargs 2 types: (const char *, int) args: (specialfile, swap_flags) -syscall sys_reboot nr 88 nbargs 4 types: (int, int, unsigned int, void *) args: (magic1, magic2, cmd, arg) -syscall sys_munmap nr 91 nbargs 2 types: (unsigned long, size_t) args: (addr, len) -syscall sys_truncate nr 92 nbargs 2 types: (const char *, long) args: (path, length) -syscall sys_ftruncate nr 93 nbargs 2 types: (unsigned int, unsigned long) args: (fd, length) -syscall sys_fchmod nr 94 nbargs 2 types: (unsigned int, umode_t) args: (fd, mode) -syscall sys_fchown16 nr 95 nbargs 3 types: (unsigned int, old_uid_t, old_gid_t) args: (fd, user, group) -syscall sys_getpriority nr 96 nbargs 2 types: (int, int) args: (which, who) -syscall sys_setpriority nr 97 nbargs 3 types: (int, int, int) args: (which, who, niceval) -syscall sys_statfs nr 99 nbargs 2 types: (const char *, struct statfs *) args: (pathname, buf) -syscall sys_fstatfs nr 100 nbargs 2 types: (unsigned int, struct statfs *) args: (fd, buf) -syscall sys_syslog nr 103 nbargs 3 types: (int, char *, int) args: (type, buf, len) -syscall sys_setitimer nr 104 nbargs 3 types: (int, struct itimerval *, struct itimerval *) args: (which, value, ovalue) -syscall sys_getitimer nr 105 nbargs 2 types: (int, struct itimerval *) args: (which, value) -syscall sys_newstat nr 106 nbargs 2 types: (const char *, struct stat *) args: (filename, statbuf) -syscall sys_newlstat nr 107 nbargs 2 types: (const char *, struct stat *) args: (filename, statbuf) -syscall sys_newfstat nr 108 nbargs 2 types: (unsigned int, struct stat *) args: (fd, statbuf) -syscall sys_vhangup nr 111 nbargs 0 types: () args: () -syscall sys_wait4 nr 114 nbargs 4 types: (pid_t, int *, int, struct rusage *) args: (upid, stat_addr, options, ru) -syscall sys_swapoff nr 115 nbargs 1 types: (const char *) args: (specialfile) -syscall sys_sysinfo nr 116 nbargs 1 types: (struct sysinfo *) args: (info) -syscall sys_fsync nr 118 nbargs 1 types: (unsigned int) args: (fd) -syscall sys_setdomainname nr 121 nbargs 2 types: (char *, int) args: (name, len) -syscall sys_newuname nr 122 nbargs 1 types: (struct new_utsname *) args: (name) -syscall sys_adjtimex nr 124 nbargs 1 types: (struct timex *) args: (txc_p) -syscall sys_mprotect nr 125 nbargs 3 types: (unsigned long, size_t, unsigned long) args: (start, len, prot) -syscall sys_sigprocmask nr 126 nbargs 3 types: (int, old_sigset_t *, old_sigset_t *) args: (how, nset, oset) -syscall sys_init_module nr 128 nbargs 3 types: (void *, unsigned long, const char *) args: (umod, len, uargs) -syscall sys_delete_module nr 129 nbargs 2 types: (const char *, unsigned int) args: (name_user, flags) -syscall sys_quotactl nr 131 nbargs 4 types: (unsigned int, const char *, qid_t, void *) args: (cmd, special, id, addr) -syscall sys_getpgid nr 132 nbargs 1 types: (pid_t) args: (pid) -syscall sys_fchdir nr 133 nbargs 1 types: (unsigned int) args: (fd) -syscall sys_bdflush nr 134 nbargs 2 types: (int, long) args: (func, data) -syscall sys_sysfs nr 135 nbargs 3 types: (int, unsigned long, unsigned long) args: (option, arg1, arg2) -syscall sys_personality nr 136 nbargs 1 types: (unsigned int) args: (personality) -syscall sys_setfsuid16 nr 138 nbargs 1 types: (old_uid_t) args: (uid) -syscall sys_setfsgid16 nr 139 nbargs 1 types: (old_gid_t) args: (gid) -syscall sys_llseek nr 140 nbargs 5 types: (unsigned int, unsigned long, unsigned long, loff_t *, unsigned int) args: (fd, offset_high, offset_low, result, origin) -syscall sys_getdents nr 141 nbargs 3 types: (unsigned int, struct linux_dirent *, unsigned int) args: (fd, dirent, count) -syscall sys_select nr 142 nbargs 5 types: (int, fd_set *, fd_set *, fd_set *, struct timeval *) args: (n, inp, outp, exp, tvp) -syscall sys_flock nr 143 nbargs 2 types: (unsigned int, unsigned int) args: (fd, cmd) -syscall sys_msync nr 144 nbargs 3 types: (unsigned long, size_t, int) args: (start, len, flags) -syscall sys_readv nr 145 nbargs 3 types: (unsigned long, const struct iovec *, unsigned long) args: (fd, vec, vlen) -syscall sys_writev nr 146 nbargs 3 types: (unsigned long, const struct iovec *, unsigned long) args: (fd, vec, vlen) -syscall sys_getsid nr 147 nbargs 1 types: (pid_t) args: (pid) -syscall sys_fdatasync nr 148 nbargs 1 types: (unsigned int) args: (fd) -syscall sys_sysctl nr 149 nbargs 1 types: (struct __sysctl_args *) args: (args) -syscall sys_mlock nr 150 nbargs 2 types: (unsigned long, size_t) args: (start, len) -syscall sys_munlock nr 151 nbargs 2 types: (unsigned long, size_t) args: (start, len) -syscall sys_mlockall nr 152 nbargs 1 types: (int) args: (flags) -syscall sys_munlockall nr 153 nbargs 0 types: () args: () -syscall sys_sched_setparam nr 154 nbargs 2 types: (pid_t, struct sched_param *) args: (pid, param) -syscall sys_sched_getparam nr 155 nbargs 2 types: (pid_t, struct sched_param *) args: (pid, param) -syscall sys_sched_setscheduler nr 156 nbargs 3 types: (pid_t, int, struct sched_param *) args: (pid, policy, param) -syscall sys_sched_getscheduler nr 157 nbargs 1 types: (pid_t) args: (pid) -syscall sys_sched_yield nr 158 nbargs 0 types: () args: () -syscall sys_sched_get_priority_max nr 159 nbargs 1 types: (int) args: (policy) -syscall sys_sched_get_priority_min nr 160 nbargs 1 types: (int) args: (policy) -syscall sys_sched_rr_get_interval nr 161 nbargs 2 types: (pid_t, struct timespec *) args: (pid, interval) -syscall sys_nanosleep nr 162 nbargs 2 types: (struct timespec *, struct timespec *) args: (rqtp, rmtp) -syscall sys_mremap nr 163 nbargs 5 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long) args: (addr, old_len, new_len, flags, new_addr) -syscall sys_setresuid16 nr 164 nbargs 3 types: (old_uid_t, old_uid_t, old_uid_t) args: (ruid, euid, suid) -syscall sys_getresuid16 nr 165 nbargs 3 types: (old_uid_t *, old_uid_t *, old_uid_t *) args: (ruid, euid, suid) -syscall sys_poll nr 168 nbargs 3 types: (struct pollfd *, unsigned int, int) args: (ufds, nfds, timeout_msecs) -syscall sys_setresgid16 nr 170 nbargs 3 types: (old_gid_t, old_gid_t, old_gid_t) args: (rgid, egid, sgid) -syscall sys_getresgid16 nr 171 nbargs 3 types: (old_gid_t *, old_gid_t *, old_gid_t *) args: (rgid, egid, sgid) -syscall sys_prctl nr 172 nbargs 5 types: (int, unsigned long, unsigned long, unsigned long, unsigned long) args: (option, arg2, arg3, arg4, arg5) -syscall sys_rt_sigaction nr 174 nbargs 4 types: (int, const struct sigaction *, struct sigaction *, size_t) args: (sig, act, oact, sigsetsize) -syscall sys_rt_sigprocmask nr 175 nbargs 4 types: (int, sigset_t *, sigset_t *, size_t) args: (how, nset, oset, sigsetsize) -syscall sys_rt_sigpending nr 176 nbargs 2 types: (sigset_t *, size_t) args: (set, sigsetsize) -syscall sys_rt_sigtimedwait nr 177 nbargs 4 types: (const sigset_t *, siginfo_t *, const struct timespec *, size_t) args: (uthese, uinfo, uts, sigsetsize) -syscall sys_rt_sigqueueinfo nr 178 nbargs 3 types: (pid_t, int, siginfo_t *) args: (pid, sig, uinfo) -syscall sys_rt_sigsuspend nr 179 nbargs 2 types: (sigset_t *, size_t) args: (unewset, sigsetsize) -syscall sys_chown16 nr 182 nbargs 3 types: (const char *, old_uid_t, old_gid_t) args: (filename, user, group) -syscall sys_getcwd nr 183 nbargs 2 types: (char *, unsigned long) args: (buf, size) -syscall sys_capget nr 184 nbargs 2 types: (cap_user_header_t, cap_user_data_t) args: (header, dataptr) -syscall sys_capset nr 185 nbargs 2 types: (cap_user_header_t, const cap_user_data_t) args: (header, data) -syscall sys_sendfile nr 187 nbargs 4 types: (int, int, off_t *, size_t) args: (out_fd, in_fd, offset, count) -syscall sys_getrlimit nr 191 nbargs 2 types: (unsigned int, struct rlimit *) args: (resource, rlim) -syscall sys_stat64 nr 195 nbargs 2 types: (const char *, struct stat64 *) args: (filename, statbuf) -syscall sys_lstat64 nr 196 nbargs 2 types: (const char *, struct stat64 *) args: (filename, statbuf) -syscall sys_fstat64 nr 197 nbargs 2 types: (unsigned long, struct stat64 *) args: (fd, statbuf) -syscall sys_lchown nr 198 nbargs 3 types: (const char *, uid_t, gid_t) args: (filename, user, group) -syscall sys_getuid nr 199 nbargs 0 types: () args: () -syscall sys_getgid nr 200 nbargs 0 types: () args: () -syscall sys_geteuid nr 201 nbargs 0 types: () args: () -syscall sys_getegid nr 202 nbargs 0 types: () args: () -syscall sys_setreuid nr 203 nbargs 2 types: (uid_t, uid_t) args: (ruid, euid) -syscall sys_setregid nr 204 nbargs 2 types: (gid_t, gid_t) args: (rgid, egid) -syscall sys_getgroups nr 205 nbargs 2 types: (int, gid_t *) args: (gidsetsize, grouplist) -syscall sys_setgroups nr 206 nbargs 2 types: (int, gid_t *) args: (gidsetsize, grouplist) -syscall sys_fchown nr 207 nbargs 3 types: (unsigned int, uid_t, gid_t) args: (fd, user, group) -syscall sys_setresuid nr 208 nbargs 3 types: (uid_t, uid_t, uid_t) args: (ruid, euid, suid) -syscall sys_getresuid nr 209 nbargs 3 types: (uid_t *, uid_t *, uid_t *) args: (ruid, euid, suid) -syscall sys_setresgid nr 210 nbargs 3 types: (gid_t, gid_t, gid_t) args: (rgid, egid, sgid) -syscall sys_getresgid nr 211 nbargs 3 types: (gid_t *, gid_t *, gid_t *) args: (rgid, egid, sgid) -syscall sys_chown nr 212 nbargs 3 types: (const char *, uid_t, gid_t) args: (filename, user, group) -syscall sys_setuid nr 213 nbargs 1 types: (uid_t) args: (uid) -syscall sys_setgid nr 214 nbargs 1 types: (gid_t) args: (gid) -syscall sys_setfsuid nr 215 nbargs 1 types: (uid_t) args: (uid) -syscall sys_setfsgid nr 216 nbargs 1 types: (gid_t) args: (gid) -syscall sys_getdents64 nr 217 nbargs 3 types: (unsigned int, struct linux_dirent64 *, unsigned int) args: (fd, dirent, count) -syscall sys_pivot_root nr 218 nbargs 2 types: (const char *, const char *) args: (new_root, put_old) -syscall sys_mincore nr 219 nbargs 3 types: (unsigned long, size_t, unsigned char *) args: (start, len, vec) -syscall sys_madvise nr 220 nbargs 3 types: (unsigned long, size_t, int) args: (start, len_in, behavior) -syscall sys_fcntl64 nr 221 nbargs 3 types: (unsigned int, unsigned int, unsigned long) args: (fd, cmd, arg) -syscall sys_gettid nr 224 nbargs 0 types: () args: () -syscall sys_setxattr nr 226 nbargs 5 types: (const char *, const char *, const void *, size_t, int) args: (pathname, name, value, size, flags) -syscall sys_lsetxattr nr 227 nbargs 5 types: (const char *, const char *, const void *, size_t, int) args: (pathname, name, value, size, flags) -syscall sys_fsetxattr nr 228 nbargs 5 types: (int, const char *, const void *, size_t, int) args: (fd, name, value, size, flags) -syscall sys_getxattr nr 229 nbargs 4 types: (const char *, const char *, void *, size_t) args: (pathname, name, value, size) -syscall sys_lgetxattr nr 230 nbargs 4 types: (const char *, const char *, void *, size_t) args: (pathname, name, value, size) -syscall sys_fgetxattr nr 231 nbargs 4 types: (int, const char *, void *, size_t) args: (fd, name, value, size) -syscall sys_listxattr nr 232 nbargs 3 types: (const char *, char *, size_t) args: (pathname, list, size) -syscall sys_llistxattr nr 233 nbargs 3 types: (const char *, char *, size_t) args: (pathname, list, size) -syscall sys_flistxattr nr 234 nbargs 3 types: (int, char *, size_t) args: (fd, list, size) -syscall sys_removexattr nr 235 nbargs 2 types: (const char *, const char *) args: (pathname, name) -syscall sys_lremovexattr nr 236 nbargs 2 types: (const char *, const char *) args: (pathname, name) -syscall sys_fremovexattr nr 237 nbargs 2 types: (int, const char *) args: (fd, name) -syscall sys_tkill nr 238 nbargs 2 types: (pid_t, int) args: (pid, sig) -syscall sys_sendfile64 nr 239 nbargs 4 types: (int, int, loff_t *, size_t) args: (out_fd, in_fd, offset, count) -syscall sys_futex nr 240 nbargs 6 types: (u32 *, int, u32, struct timespec *, u32 *, u32) args: (uaddr, op, val, utime, uaddr2, val3) -syscall sys_sched_setaffinity nr 241 nbargs 3 types: (pid_t, unsigned int, unsigned long *) args: (pid, len, user_mask_ptr) -syscall sys_sched_getaffinity nr 242 nbargs 3 types: (pid_t, unsigned int, unsigned long *) args: (pid, len, user_mask_ptr) -syscall sys_io_setup nr 243 nbargs 2 types: (unsigned, aio_context_t *) args: (nr_events, ctxp) -syscall sys_io_destroy nr 244 nbargs 1 types: (aio_context_t) args: (ctx) -syscall sys_io_getevents nr 245 nbargs 5 types: (aio_context_t, long, long, struct io_event *, struct timespec *) args: (ctx_id, min_nr, nr, events, timeout) -syscall sys_io_submit nr 246 nbargs 3 types: (aio_context_t, long, struct iocb * *) args: (ctx_id, nr, iocbpp) -syscall sys_io_cancel nr 247 nbargs 3 types: (aio_context_t, struct iocb *, struct io_event *) args: (ctx_id, iocb, result) -syscall sys_exit_group nr 248 nbargs 1 types: (int) args: (error_code) -syscall sys_epoll_create nr 250 nbargs 1 types: (int) args: (size) -syscall sys_epoll_ctl nr 251 nbargs 4 types: (int, int, int, struct epoll_event *) args: (epfd, op, fd, event) -syscall sys_epoll_wait nr 252 nbargs 4 types: (int, struct epoll_event *, int, int) args: (epfd, events, maxevents, timeout) -syscall sys_remap_file_pages nr 253 nbargs 5 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long) args: (start, size, prot, pgoff, flags) -syscall sys_set_tid_address nr 256 nbargs 1 types: (int *) args: (tidptr) -syscall sys_timer_create nr 257 nbargs 3 types: (const clockid_t, struct sigevent *, timer_t *) args: (which_clock, timer_event_spec, created_timer_id) -syscall sys_timer_settime nr 258 nbargs 4 types: (timer_t, int, const struct itimerspec *, struct itimerspec *) args: (timer_id, flags, new_setting, old_setting) -syscall sys_timer_gettime nr 259 nbargs 2 types: (timer_t, struct itimerspec *) args: (timer_id, setting) -syscall sys_timer_getoverrun nr 260 nbargs 1 types: (timer_t) args: (timer_id) -syscall sys_timer_delete nr 261 nbargs 1 types: (timer_t) args: (timer_id) -syscall sys_clock_settime nr 262 nbargs 2 types: (const clockid_t, const struct timespec *) args: (which_clock, tp) -syscall sys_clock_gettime nr 263 nbargs 2 types: (const clockid_t, struct timespec *) args: (which_clock, tp) -syscall sys_clock_getres nr 264 nbargs 2 types: (const clockid_t, struct timespec *) args: (which_clock, tp) -syscall sys_clock_nanosleep nr 265 nbargs 4 types: (const clockid_t, int, const struct timespec *, struct timespec *) args: (which_clock, flags, rqtp, rmtp) -syscall sys_tgkill nr 268 nbargs 3 types: (pid_t, pid_t, int) args: (tgid, pid, sig) -syscall sys_utimes nr 269 nbargs 2 types: (char *, struct timeval *) args: (filename, utimes) -syscall sys_mq_open nr 274 nbargs 4 types: (const char *, int, umode_t, struct mq_attr *) args: (u_name, oflag, mode, u_attr) -syscall sys_mq_unlink nr 275 nbargs 1 types: (const char *) args: (u_name) -syscall sys_mq_timedsend nr 276 nbargs 5 types: (mqd_t, const char *, size_t, unsigned int, const struct timespec *) args: (mqdes, u_msg_ptr, msg_len, msg_prio, u_abs_timeout) -syscall sys_mq_timedreceive nr 277 nbargs 5 types: (mqd_t, char *, size_t, unsigned int *, const struct timespec *) args: (mqdes, u_msg_ptr, msg_len, u_msg_prio, u_abs_timeout) -syscall sys_mq_notify nr 278 nbargs 2 types: (mqd_t, const struct sigevent *) args: (mqdes, u_notification) -syscall sys_mq_getsetattr nr 279 nbargs 3 types: (mqd_t, const struct mq_attr *, struct mq_attr *) args: (mqdes, u_mqstat, u_omqstat) -syscall sys_waitid nr 280 nbargs 5 types: (int, pid_t, struct siginfo *, int, struct rusage *) args: (which, upid, infop, options, ru) -syscall sys_socket nr 281 nbargs 3 types: (int, int, int) args: (family, type, protocol) -syscall sys_bind nr 282 nbargs 3 types: (int, struct sockaddr *, int) args: (fd, umyaddr, addrlen) -syscall sys_connect nr 283 nbargs 3 types: (int, struct sockaddr *, int) args: (fd, uservaddr, addrlen) -syscall sys_listen nr 284 nbargs 2 types: (int, int) args: (fd, backlog) -syscall sys_accept nr 285 nbargs 3 types: (int, struct sockaddr *, int *) args: (fd, upeer_sockaddr, upeer_addrlen) -syscall sys_getsockname nr 286 nbargs 3 types: (int, struct sockaddr *, int *) args: (fd, usockaddr, usockaddr_len) -syscall sys_getpeername nr 287 nbargs 3 types: (int, struct sockaddr *, int *) args: (fd, usockaddr, usockaddr_len) -syscall sys_socketpair nr 288 nbargs 4 types: (int, int, int, int *) args: (family, type, protocol, usockvec) -syscall sys_send nr 289 nbargs 4 types: (int, void *, size_t, unsigned) args: (fd, buff, len, flags) -syscall sys_sendto nr 290 nbargs 6 types: (int, void *, size_t, unsigned, struct sockaddr *, int) args: (fd, buff, len, flags, addr, addr_len) -syscall sys_recvfrom nr 292 nbargs 6 types: (int, void *, size_t, unsigned, struct sockaddr *, int *) args: (fd, ubuf, size, flags, addr, addr_len) -syscall sys_shutdown nr 293 nbargs 2 types: (int, int) args: (fd, how) -syscall sys_setsockopt nr 294 nbargs 5 types: (int, int, int, char *, int) args: (fd, level, optname, optval, optlen) -syscall sys_getsockopt nr 295 nbargs 5 types: (int, int, int, char *, int *) args: (fd, level, optname, optval, optlen) -syscall sys_sendmsg nr 296 nbargs 3 types: (int, struct msghdr *, unsigned) args: (fd, msg, flags) -syscall sys_recvmsg nr 297 nbargs 3 types: (int, struct msghdr *, unsigned int) args: (fd, msg, flags) -syscall sys_semop nr 298 nbargs 3 types: (int, struct sembuf *, unsigned) args: (semid, tsops, nsops) -syscall sys_semget nr 299 nbargs 3 types: (key_t, int, int) args: (key, nsems, semflg) -syscall sys_msgsnd nr 301 nbargs 4 types: (int, struct msgbuf *, size_t, int) args: (msqid, msgp, msgsz, msgflg) -syscall sys_msgrcv nr 302 nbargs 5 types: (int, struct msgbuf *, size_t, long, int) args: (msqid, msgp, msgsz, msgtyp, msgflg) -syscall sys_msgget nr 303 nbargs 2 types: (key_t, int) args: (key, msgflg) -syscall sys_msgctl nr 304 nbargs 3 types: (int, int, struct msqid_ds *) args: (msqid, cmd, buf) -syscall sys_shmat nr 305 nbargs 3 types: (int, char *, int) args: (shmid, shmaddr, shmflg) -syscall sys_shmdt nr 306 nbargs 1 types: (char *) args: (shmaddr) -syscall sys_shmget nr 307 nbargs 3 types: (key_t, size_t, int) args: (key, size, shmflg) -syscall sys_shmctl nr 308 nbargs 3 types: (int, int, struct shmid_ds *) args: (shmid, cmd, buf) -syscall sys_add_key nr 309 nbargs 5 types: (const char *, const char *, const void *, size_t, key_serial_t) args: (_type, _description, _payload, plen, ringid) -syscall sys_request_key nr 310 nbargs 4 types: (const char *, const char *, const char *, key_serial_t) args: (_type, _description, _callout_info, destringid) -syscall sys_keyctl nr 311 nbargs 5 types: (int, unsigned long, unsigned long, unsigned long, unsigned long) args: (option, arg2, arg3, arg4, arg5) -syscall sys_semtimedop nr 312 nbargs 4 types: (int, struct sembuf *, unsigned, const struct timespec *) args: (semid, tsops, nsops, timeout) -syscall sys_ioprio_set nr 314 nbargs 3 types: (int, int, int) args: (which, who, ioprio) -syscall sys_ioprio_get nr 315 nbargs 2 types: (int, int) args: (which, who) -syscall sys_inotify_init nr 316 nbargs 0 types: () args: () -syscall sys_inotify_add_watch nr 317 nbargs 3 types: (int, const char *, u32) args: (fd, pathname, mask) -syscall sys_inotify_rm_watch nr 318 nbargs 2 types: (int, __s32) args: (fd, wd) -syscall sys_openat nr 322 nbargs 4 types: (int, const char *, int, umode_t) args: (dfd, filename, flags, mode) -syscall sys_mkdirat nr 323 nbargs 3 types: (int, const char *, umode_t) args: (dfd, pathname, mode) -syscall sys_mknodat nr 324 nbargs 4 types: (int, const char *, umode_t, unsigned) args: (dfd, filename, mode, dev) -syscall sys_fchownat nr 325 nbargs 5 types: (int, const char *, uid_t, gid_t, int) args: (dfd, filename, user, group, flag) -syscall sys_futimesat nr 326 nbargs 3 types: (int, const char *, struct timeval *) args: (dfd, filename, utimes) -syscall sys_fstatat64 nr 327 nbargs 4 types: (int, const char *, struct stat64 *, int) args: (dfd, filename, statbuf, flag) -syscall sys_unlinkat nr 328 nbargs 3 types: (int, const char *, int) args: (dfd, pathname, flag) -syscall sys_renameat nr 329 nbargs 4 types: (int, const char *, int, const char *) args: (olddfd, oldname, newdfd, newname) -syscall sys_linkat nr 330 nbargs 5 types: (int, const char *, int, const char *, int) args: (olddfd, oldname, newdfd, newname, flags) -syscall sys_symlinkat nr 331 nbargs 3 types: (const char *, int, const char *) args: (oldname, newdfd, newname) -syscall sys_readlinkat nr 332 nbargs 4 types: (int, const char *, char *, int) args: (dfd, pathname, buf, bufsiz) -syscall sys_fchmodat nr 333 nbargs 3 types: (int, const char *, umode_t) args: (dfd, filename, mode) -syscall sys_faccessat nr 334 nbargs 3 types: (int, const char *, int) args: (dfd, filename, mode) -syscall sys_pselect6 nr 335 nbargs 6 types: (int, fd_set *, fd_set *, fd_set *, struct timespec *, void *) args: (n, inp, outp, exp, tsp, sig) -syscall sys_ppoll nr 336 nbargs 5 types: (struct pollfd *, unsigned int, struct timespec *, const sigset_t *, size_t) args: (ufds, nfds, tsp, sigmask, sigsetsize) -syscall sys_unshare nr 337 nbargs 1 types: (unsigned long) args: (unshare_flags) -syscall sys_set_robust_list nr 338 nbargs 2 types: (struct robust_list_head *, size_t) args: (head, len) -syscall sys_get_robust_list nr 339 nbargs 3 types: (int, struct robust_list_head * *, size_t *) args: (pid, head_ptr, len_ptr) -syscall sys_splice nr 340 nbargs 6 types: (int, loff_t *, int, loff_t *, size_t, unsigned int) args: (fd_in, off_in, fd_out, off_out, len, flags) -syscall sys_tee nr 342 nbargs 4 types: (int, int, size_t, unsigned int) args: (fdin, fdout, len, flags) -syscall sys_vmsplice nr 343 nbargs 4 types: (int, const struct iovec *, unsigned long, unsigned int) args: (fd, iov, nr_segs, flags) -syscall sys_getcpu nr 345 nbargs 3 types: (unsigned *, unsigned *, struct getcpu_cache *) args: (cpup, nodep, unused) -syscall sys_epoll_pwait nr 346 nbargs 6 types: (int, struct epoll_event *, int, int, const sigset_t *, size_t) args: (epfd, events, maxevents, timeout, sigmask, sigsetsize) -syscall sys_utimensat nr 348 nbargs 4 types: (int, const char *, struct timespec *, int) args: (dfd, filename, utimes, flags) -syscall sys_signalfd nr 349 nbargs 3 types: (int, sigset_t *, size_t) args: (ufd, user_mask, sizemask) -syscall sys_timerfd_create nr 350 nbargs 2 types: (int, int) args: (clockid, flags) -syscall sys_eventfd nr 351 nbargs 1 types: (unsigned int) args: (count) -syscall sys_timerfd_settime nr 353 nbargs 4 types: (int, int, const struct itimerspec *, struct itimerspec *) args: (ufd, flags, utmr, otmr) -syscall sys_timerfd_gettime nr 354 nbargs 2 types: (int, struct itimerspec *) args: (ufd, otmr) -syscall sys_signalfd4 nr 355 nbargs 4 types: (int, sigset_t *, size_t, int) args: (ufd, user_mask, sizemask, flags) -syscall sys_eventfd2 nr 356 nbargs 2 types: (unsigned int, int) args: (count, flags) -syscall sys_epoll_create1 nr 357 nbargs 1 types: (int) args: (flags) -syscall sys_dup3 nr 358 nbargs 3 types: (unsigned int, unsigned int, int) args: (oldfd, newfd, flags) -syscall sys_pipe2 nr 359 nbargs 2 types: (int *, int) args: (fildes, flags) -syscall sys_inotify_init1 nr 360 nbargs 1 types: (int) args: (flags) -syscall sys_preadv nr 361 nbargs 5 types: (unsigned long, const struct iovec *, unsigned long, unsigned long, unsigned long) args: (fd, vec, vlen, pos_l, pos_h) -syscall sys_pwritev nr 362 nbargs 5 types: (unsigned long, const struct iovec *, unsigned long, unsigned long, unsigned long) args: (fd, vec, vlen, pos_l, pos_h) -syscall sys_rt_tgsigqueueinfo nr 363 nbargs 4 types: (pid_t, pid_t, int, siginfo_t *) args: (tgid, pid, sig, uinfo) -syscall sys_perf_event_open nr 364 nbargs 5 types: (struct perf_event_attr *, pid_t, int, int, unsigned long) args: (attr_uptr, pid, cpu, group_fd, flags) -syscall sys_recvmmsg nr 365 nbargs 5 types: (int, struct mmsghdr *, unsigned int, unsigned int, struct timespec *) args: (fd, mmsg, vlen, flags, timeout) -syscall sys_accept4 nr 366 nbargs 4 types: (int, struct sockaddr *, int *, int) args: (fd, upeer_sockaddr, upeer_addrlen, flags) -syscall sys_fanotify_init nr 367 nbargs 2 types: (unsigned int, unsigned int) args: (flags, event_f_flags) -syscall sys_prlimit64 nr 369 nbargs 4 types: (pid_t, unsigned int, const struct rlimit64 *, struct rlimit64 *) args: (pid, resource, new_rlim, old_rlim) -syscall sys_name_to_handle_at nr 370 nbargs 5 types: (int, const char *, struct file_handle *, int *, int) args: (dfd, name, handle, mnt_id, flag) -syscall sys_open_by_handle_at nr 371 nbargs 3 types: (int, struct file_handle *, int) args: (mountdirfd, handle, flags) -syscall sys_clock_adjtime nr 372 nbargs 2 types: (const clockid_t, struct timex *) args: (which_clock, utx) -syscall sys_syncfs nr 373 nbargs 1 types: (int) args: (fd) -syscall sys_sendmmsg nr 374 nbargs 4 types: (int, struct mmsghdr *, unsigned int, unsigned int) args: (fd, mmsg, vlen, flags) -syscall sys_setns nr 375 nbargs 2 types: (int, int) args: (fd, nstype) -syscall sys_process_vm_readv nr 376 nbargs 6 types: (pid_t, const struct iovec *, unsigned long, const struct iovec *, unsigned long, unsigned long) args: (pid, lvec, liovcnt, rvec, riovcnt, flags) -syscall sys_process_vm_writev nr 377 nbargs 6 types: (pid_t, const struct iovec *, unsigned long, const struct iovec *, unsigned long, unsigned long) args: (pid, lvec, liovcnt, rvec, riovcnt, flags) diff --git a/instrumentation/syscalls/3.5.0/mips-32-syscalls b/instrumentation/syscalls/3.5.0/mips-32-syscalls deleted file mode 100644 index 5b62cc7b..00000000 --- a/instrumentation/syscalls/3.5.0/mips-32-syscalls +++ /dev/null @@ -1,141 +0,0 @@ -syscall sys_exit nr 4003 nbargs 1 types: (int) args: (error_code) -syscall sys_read nr 4007 nbargs 3 types: (unsigned int, char *, size_t) args: (fd, buf, count) -syscall sys_write nr 4009 nbargs 3 types: (unsigned int, const char *, size_t) args: (fd, buf, count) -syscall sys_open nr 4011 nbargs 3 types: (const char *, int, umode_t) args: (filename, flags, mode) -syscall sys_close nr 4013 nbargs 1 types: (unsigned int) args: (fd) -syscall sys_waitpid nr 4015 nbargs 3 types: (pid_t, int *, int) args: (pid, stat_addr, options) -syscall sys_creat nr 4017 nbargs 2 types: (const char *, umode_t) args: (pathname, mode) -syscall sys_link nr 4019 nbargs 2 types: (const char *, const char *) args: (oldname, newname) -syscall sys_unlink nr 4021 nbargs 1 types: (const char *) args: (pathname) -syscall sys_chdir nr 4025 nbargs 1 types: (const char *) args: (filename) -syscall sys_time nr 4027 nbargs 1 types: (time_t *) args: (tloc) -syscall sys_mknod nr 4029 nbargs 3 types: (const char *, umode_t, unsigned) args: (filename, mode, dev) -syscall sys_chmod nr 4031 nbargs 2 types: (const char *, umode_t) args: (filename, mode) -syscall sys_lchown nr 4033 nbargs 3 types: (const char *, uid_t, gid_t) args: (filename, user, group) -syscall sys_lseek nr 4039 nbargs 3 types: (unsigned int, off_t, unsigned int) args: (fd, offset, origin) -syscall sys_getpid nr 4041 nbargs 0 types: () args: () -syscall sys_mount nr 4043 nbargs 5 types: (char *, char *, char *, unsigned long, void *) args: (dev_name, dir_name, type, flags, data) -syscall sys_oldumount nr 4045 nbargs 1 types: (char *) args: (name) -syscall sys_setuid nr 4047 nbargs 1 types: (uid_t) args: (uid) -syscall sys_getuid nr 4049 nbargs 0 types: () args: () -syscall sys_stime nr 4051 nbargs 1 types: (time_t *) args: (tptr) -syscall sys_ptrace nr 4053 nbargs 4 types: (long, long, unsigned long, unsigned long) args: (request, pid, addr, data) -syscall sys_alarm nr 4055 nbargs 1 types: (unsigned int) args: (seconds) -syscall sys_pause nr 4059 nbargs 0 types: () args: () -syscall sys_utime nr 4061 nbargs 2 types: (char *, struct utimbuf *) args: (filename, times) -syscall sys_access nr 4067 nbargs 2 types: (const char *, int) args: (filename, mode) -syscall sys_nice nr 4069 nbargs 1 types: (int) args: (increment) -syscall sys_sync nr 4073 nbargs 0 types: () args: () -syscall sys_kill nr 4075 nbargs 2 types: (pid_t, int) args: (pid, sig) -syscall sys_rename nr 4077 nbargs 2 types: (const char *, const char *) args: (oldname, newname) -syscall sys_mkdir nr 4079 nbargs 2 types: (const char *, umode_t) args: (pathname, mode) -syscall sys_rmdir nr 4081 nbargs 1 types: (const char *) args: (pathname) -syscall sys_dup nr 4083 nbargs 1 types: (unsigned int) args: (fildes) -syscall sys_times nr 4087 nbargs 1 types: (struct tms *) args: (tbuf) -syscall sys_brk nr 4091 nbargs 1 types: (unsigned long) args: (brk) -syscall sys_setgid nr 4093 nbargs 1 types: (gid_t) args: (gid) -syscall sys_getgid nr 4095 nbargs 0 types: () args: () -syscall sys_geteuid nr 4099 nbargs 0 types: () args: () -syscall sys_getegid nr 4101 nbargs 0 types: () args: () -syscall sys_umount nr 4105 nbargs 2 types: (char *, int) args: (name, flags) -syscall sys_ioctl nr 4109 nbargs 3 types: (unsigned int, unsigned int, unsigned long) args: (fd, cmd, arg) -syscall sys_fcntl nr 4111 nbargs 3 types: (unsigned int, unsigned int, unsigned long) args: (fd, cmd, arg) -syscall sys_setpgid nr 4115 nbargs 2 types: (pid_t, pid_t) args: (pid, pgid) -syscall sys_olduname nr 4119 nbargs 1 types: (struct oldold_utsname *) args: (name) -syscall sys_umask nr 4121 nbargs 1 types: (int) args: (mask) -syscall sys_chroot nr 4123 nbargs 1 types: (const char *) args: (filename) -syscall sys_ustat nr 4125 nbargs 2 types: (unsigned, struct ustat *) args: (dev, ubuf) -syscall sys_dup2 nr 4127 nbargs 2 types: (unsigned int, unsigned int) args: (oldfd, newfd) -syscall sys_getppid nr 4129 nbargs 0 types: () args: () -syscall sys_getpgrp nr 4131 nbargs 0 types: () args: () -syscall sys_setsid nr 4133 nbargs 0 types: () args: () -syscall sys_sigaction nr 4135 nbargs 3 types: (int, const struct sigaction *, struct sigaction *) args: (sig, act, oact) -syscall sys_sgetmask nr 4137 nbargs 0 types: () args: () -syscall sys_ssetmask nr 4139 nbargs 1 types: (int) args: (newmask) -syscall sys_setreuid nr 4141 nbargs 2 types: (uid_t, uid_t) args: (ruid, euid) -syscall sys_setregid nr 4143 nbargs 2 types: (gid_t, gid_t) args: (rgid, egid) -syscall sys_sigpending nr 4147 nbargs 1 types: (old_sigset_t *) args: (set) -syscall sys_sethostname nr 4149 nbargs 2 types: (char *, int) args: (name, len) -syscall sys_setrlimit nr 4151 nbargs 2 types: (unsigned int, struct rlimit *) args: (resource, rlim) -syscall sys_getrlimit nr 4153 nbargs 2 types: (unsigned int, struct rlimit *) args: (resource, rlim) -syscall sys_getrusage nr 4155 nbargs 2 types: (int, struct rusage *) args: (who, ru) -syscall sys_gettimeofday nr 4157 nbargs 2 types: (struct timeval *, struct timezone *) args: (tv, tz) -syscall sys_settimeofday nr 4159 nbargs 2 types: (struct timeval *, struct timezone *) args: (tv, tz) -syscall sys_getgroups nr 4161 nbargs 2 types: (int, gid_t *) args: (gidsetsize, grouplist) -syscall sys_setgroups nr 4163 nbargs 2 types: (int, gid_t *) args: (gidsetsize, grouplist) -syscall sys_symlink nr 4167 nbargs 2 types: (const char *, const char *) args: (oldname, newname) -syscall sys_readlink nr 4171 nbargs 3 types: (const char *, char *, int) args: (path, buf, bufsiz) -syscall sys_uselib nr 4173 nbargs 1 types: (const char *) args: (library) -syscall sys_swapon nr 4175 nbargs 2 types: (const char *, int) args: (specialfile, swap_flags) -syscall sys_reboot nr 4177 nbargs 4 types: (int, int, unsigned int, void *) args: (magic1, magic2, cmd, arg) -syscall sys_old_readdir nr 4179 nbargs 3 types: (unsigned int, struct old_linux_dirent *, unsigned int) args: (fd, dirent, count) -syscall sys_mips_mmap nr 4181 nbargs 6 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long, off_t) args: (addr, len, prot, flags, fd, offset) -syscall sys_munmap nr 4183 nbargs 2 types: (unsigned long, size_t) args: (addr, len) -syscall sys_truncate nr 4185 nbargs 2 types: (const char *, long) args: (path, length) -syscall sys_ftruncate nr 4187 nbargs 2 types: (unsigned int, unsigned long) args: (fd, length) -syscall sys_fchmod nr 4189 nbargs 2 types: (unsigned int, umode_t) args: (fd, mode) -syscall sys_fchown nr 4191 nbargs 3 types: (unsigned int, uid_t, gid_t) args: (fd, user, group) -syscall sys_getpriority nr 4193 nbargs 2 types: (int, int) args: (which, who) -syscall sys_setpriority nr 4195 nbargs 3 types: (int, int, int) args: (which, who, niceval) -syscall sys_statfs nr 4199 nbargs 2 types: (const char *, struct statfs *) args: (pathname, buf) -syscall sys_fstatfs nr 4201 nbargs 2 types: (unsigned int, struct statfs *) args: (fd, buf) -syscall sys_socketcall nr 4205 nbargs 2 types: (int, unsigned long *) args: (call, args) -syscall sys_syslog nr 4207 nbargs 3 types: (int, char *, int) args: (type, buf, len) -syscall sys_setitimer nr 4209 nbargs 3 types: (int, struct itimerval *, struct itimerval *) args: (which, value, ovalue) -syscall sys_getitimer nr 4211 nbargs 2 types: (int, struct itimerval *) args: (which, value) -syscall sys_newstat nr 4213 nbargs 2 types: (const char *, struct stat *) args: (filename, statbuf) -syscall sys_newlstat nr 4215 nbargs 2 types: (const char *, struct stat *) args: (filename, statbuf) -syscall sys_newfstat nr 4217 nbargs 2 types: (unsigned int, struct stat *) args: (fd, statbuf) -syscall sys_uname nr 4219 nbargs 1 types: (struct old_utsname *) args: (name) -syscall sys_vhangup nr 4223 nbargs 0 types: () args: () -syscall sys_wait4 nr 4229 nbargs 4 types: (pid_t, int *, int, struct rusage *) args: (upid, stat_addr, options, ru) -syscall sys_swapoff nr 4231 nbargs 1 types: (const char *) args: (specialfile) -syscall sys_sysinfo nr 4233 nbargs 1 types: (struct sysinfo *) args: (info) -syscall sys_ipc nr 4235 nbargs 6 types: (unsigned int, int, unsigned long, unsigned long, void *, long) args: (call, first, second, third, ptr, fifth) -syscall sys_fsync nr 4237 nbargs 1 types: (unsigned int) args: (fd) -syscall sys_setdomainname nr 4243 nbargs 2 types: (char *, int) args: (name, len) -syscall sys_newuname nr 4245 nbargs 1 types: (struct new_utsname *) args: (name) -syscall sys_adjtimex nr 4249 nbargs 1 types: (struct timex *) args: (txc_p) -syscall sys_mprotect nr 4251 nbargs 3 types: (unsigned long, size_t, unsigned long) args: (start, len, prot) -syscall sys_sigprocmask nr 4253 nbargs 3 types: (int, old_sigset_t *, old_sigset_t *) args: (how, nset, oset) -syscall sys_init_module nr 4257 nbargs 3 types: (void *, unsigned long, const char *) args: (umod, len, uargs) -syscall sys_delete_module nr 4259 nbargs 2 types: (const char *, unsigned int) args: (name_user, flags) -syscall sys_quotactl nr 4263 nbargs 4 types: (unsigned int, const char *, qid_t, void *) args: (cmd, special, id, addr) -syscall sys_getpgid nr 4265 nbargs 1 types: (pid_t) args: (pid) -syscall sys_fchdir nr 4267 nbargs 1 types: (unsigned int) args: (fd) -syscall sys_bdflush nr 4269 nbargs 2 types: (int, long) args: (func, data) -syscall sys_sysfs nr 4271 nbargs 3 types: (int, unsigned long, unsigned long) args: (option, arg1, arg2) -syscall sys_personality nr 4273 nbargs 1 types: (unsigned int) args: (personality) -syscall sys_setfsuid nr 4277 nbargs 1 types: (uid_t) args: (uid) -syscall sys_setfsgid nr 4279 nbargs 1 types: (gid_t) args: (gid) -syscall sys_llseek nr 4281 nbargs 5 types: (unsigned int, unsigned long, unsigned long, loff_t *, unsigned int) args: (fd, offset_high, offset_low, result, origin) -syscall sys_getdents nr 4283 nbargs 3 types: (unsigned int, struct linux_dirent *, unsigned int) args: (fd, dirent, count) -syscall sys_select nr 4285 nbargs 5 types: (int, fd_set *, fd_set *, fd_set *, struct timeval *) args: (n, inp, outp, exp, tvp) -syscall sys_flock nr 4287 nbargs 2 types: (unsigned int, unsigned int) args: (fd, cmd) -syscall sys_msync nr 4289 nbargs 3 types: (unsigned long, size_t, int) args: (start, len, flags) -syscall sys_readv nr 4291 nbargs 3 types: (unsigned long, const struct iovec *, unsigned long) args: (fd, vec, vlen) -syscall sys_writev nr 4293 nbargs 3 types: (unsigned long, const struct iovec *, unsigned long) args: (fd, vec, vlen) -syscall sys_cacheflush nr 4295 nbargs 3 types: (unsigned long, unsigned long, unsigned int) args: (addr, bytes, cache) -syscall sys_cachectl nr 4297 nbargs 3 types: (char *, int, int) args: (addr, nbytes, op) -syscall sys_getsid nr 4303 nbargs 1 types: (pid_t) args: (pid) -syscall sys_fdatasync nr 4305 nbargs 1 types: (unsigned int) args: (fd) -syscall sys_sysctl nr 4307 nbargs 1 types: (struct __sysctl_args *) args: (args) -syscall sys_mlock nr 4309 nbargs 2 types: (unsigned long, size_t) args: (start, len) -syscall sys_munlock nr 4311 nbargs 2 types: (unsigned long, size_t) args: (start, len) -syscall sys_mlockall nr 4313 nbargs 1 types: (int) args: (flags) -syscall sys_munlockall nr 4315 nbargs 0 types: () args: () -syscall sys_sched_setparam nr 4317 nbargs 2 types: (pid_t, struct sched_param *) args: (pid, param) -syscall sys_sched_getparam nr 4319 nbargs 2 types: (pid_t, struct sched_param *) args: (pid, param) -syscall sys_sched_setscheduler nr 4321 nbargs 3 types: (pid_t, int, struct sched_param *) args: (pid, policy, param) -syscall sys_sched_getscheduler nr 4323 nbargs 1 types: (pid_t) args: (pid) -syscall sys_sched_yield nr 4325 nbargs 0 types: () args: () -syscall sys_sched_get_priority_max nr 4327 nbargs 1 types: (int) args: (policy) -syscall sys_sched_get_priority_min nr 4329 nbargs 1 types: (int) args: (policy) -syscall sys_sched_rr_get_interval nr 4331 nbargs 2 types: (pid_t, struct timespec *) args: (pid, interval) -syscall sys_nanosleep nr 4333 nbargs 2 types: (struct timespec *, struct timespec *) args: (rqtp, rmtp) -syscall sys_mremap nr 4335 nbargs 5 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long) args: (addr, old_len, new_len, flags, new_addr) -syscall sys_accept nr 4337 nbargs 3 types: (int, struct sockaddr *, int *) args: (fd, upeer_sockaddr, upeer_addrlen) -syscall sys_bind nr 4339 nbargs 3 types: (int, struct sockaddr *, int) args: (fd, umyaddr, addrlen) -syscall sys_connect nr 4341 nbargs 3 types: (int, struct sockaddr *, int) args: (fd, uservaddr, addrlen) -syscall sys_getpeername nr 4343 nbargs 3 types: (int, struct sockaddr *, int *) args: (fd, usockaddr, usockaddr_len) -syscall sys_getsockname nr 4345 nbargs 3 types: (int, struct sockaddr *, int *) args: (fd, usockaddr, usockaddr_len) diff --git a/instrumentation/syscalls/3.5.0/mips-64-syscalls b/instrumentation/syscalls/3.5.0/mips-64-syscalls deleted file mode 100644 index 7753e06e..00000000 --- a/instrumentation/syscalls/3.5.0/mips-64-syscalls +++ /dev/null @@ -1,289 +0,0 @@ -syscall sys_waitpid nr 4007 nbargs 3 types: (pid_t, int *, int) args: (pid, stat_addr, options) -syscall sys_oldumount nr 4022 nbargs 1 types: (char *) args: (name) -syscall sys_nice nr 4034 nbargs 1 types: (int) args: (increment) -syscall sys_olduname nr 4059 nbargs 1 types: (struct oldold_utsname *) args: (name) -syscall sys_32_sigaction nr 4067 nbargs 3 types: (long, const struct sigaction32 *, struct sigaction32 *) args: (sig, act, oact) -syscall sys_sgetmask nr 4068 nbargs 0 types: () args: () -syscall sys_ssetmask nr 4069 nbargs 1 types: (int) args: (newmask) -syscall sys_uselib nr 4086 nbargs 1 types: (const char *) args: (library) -syscall sys_uname nr 4109 nbargs 1 types: (struct old_utsname *) args: (name) -syscall sys_32_ipc nr 4117 nbargs 6 types: (u32, long, long, long, unsigned long, unsigned long) args: (call, first, second, third, ptr, fifth) -syscall sys_bdflush nr 4134 nbargs 2 types: (int, long) args: (func, data) -syscall sys_32_llseek nr 4140 nbargs 5 types: (unsigned int, unsigned int, unsigned int, loff_t *, unsigned int) args: (fd, offset_high, offset_low, result, origin) -syscall sys_send nr 4178 nbargs 4 types: (int, void *, size_t, unsigned int) args: (fd, buff, len, flags) -syscall sys_32_pread nr 4200 nbargs 6 types: (unsigned long, char *, size_t, unsigned long, unsigned long, unsigned long) args: (fd, buf, count, unused, a4, a5) -syscall sys_32_pwrite nr 4201 nbargs 6 types: (unsigned int, const char *, size_t, u32, u64, u64) args: (fd, buf, count, unused, a4, a5) -syscall sys_mips_mmap2 nr 4210 nbargs 6 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long, unsigned long) args: (addr, len, prot, flags, fd, pgoff) -syscall sys_32_truncate64 nr 4211 nbargs 4 types: (const char *, unsigned long, unsigned long, unsigned long) args: (path, __dummy, a2, a3) -syscall sys_32_ftruncate64 nr 4212 nbargs 4 types: (unsigned long, unsigned long, unsigned long, unsigned long) args: (fd, __dummy, a2, a3) -syscall sys_32_waitid nr 4278 nbargs 5 types: (int, compat_pid_t, compat_siginfo_t *, int, struct compat_rusage *) args: (which, pid, uinfo, options, uru) -syscall sys_32_fanotify_mark nr 4337 nbargs 6 types: (int, unsigned int, u64, u64, int, const char *) args: (fanotify_fd, flags, a3, a4, dfd, pathname) -syscall sys_rt_sigaction nr 5013 nbargs 4 types: (int, const struct sigaction *, struct sigaction *, size_t) args: (sig, act, oact, sigsetsize) -syscall sys_rt_sigprocmask nr 5014 nbargs 4 types: (int, sigset_t *, sigset_t *, size_t) args: (how, nset, oset, sigsetsize) -syscall sys_ioctl nr 5015 nbargs 3 types: (unsigned int, unsigned int, unsigned long) args: (fd, cmd, arg) -syscall sys_readv nr 5018 nbargs 3 types: (unsigned long, const struct iovec *, unsigned long) args: (fd, vec, vlen) -syscall sys_writev nr 5019 nbargs 3 types: (unsigned long, const struct iovec *, unsigned long) args: (fd, vec, vlen) -syscall sys_select nr 5022 nbargs 5 types: (int, fd_set *, fd_set *, fd_set *, struct timeval *) args: (n, inp, outp, exp, tvp) -syscall sys_shmctl nr 5030 nbargs 3 types: (int, int, struct shmid_ds *) args: (shmid, cmd, buf) -syscall sys_nanosleep nr 5034 nbargs 2 types: (struct timespec *, struct timespec *) args: (rqtp, rmtp) -syscall sys_getitimer nr 5035 nbargs 2 types: (int, struct itimerval *) args: (which, value) -syscall sys_setitimer nr 5036 nbargs 3 types: (int, struct itimerval *, struct itimerval *) args: (which, value, ovalue) -syscall sys_recvfrom nr 5044 nbargs 6 types: (int, void *, size_t, unsigned int, struct sockaddr *, int *) args: (fd, ubuf, size, flags, addr, addr_len) -syscall sys_sendmsg nr 5045 nbargs 3 types: (int, struct msghdr *, unsigned int) args: (fd, msg, flags) -syscall sys_recvmsg nr 5046 nbargs 3 types: (int, struct msghdr *, unsigned int) args: (fd, msg, flags) -syscall sys_setsockopt nr 5053 nbargs 5 types: (int, int, int, char *, int) args: (fd, level, optname, optval, optlen) -syscall sys_wait4 nr 5059 nbargs 4 types: (pid_t, int *, int, struct rusage *) args: (upid, stat_addr, options, ru) -syscall sys_msgsnd nr 5067 nbargs 4 types: (int, struct msgbuf *, size_t, int) args: (msqid, msgp, msgsz, msgflg) -syscall sys_msgrcv nr 5068 nbargs 5 types: (int, struct msgbuf *, size_t, long, int) args: (msqid, msgp, msgsz, msgtyp, msgflg) -syscall sys_msgctl nr 5069 nbargs 3 types: (int, int, struct msqid_ds *) args: (msqid, cmd, buf) -syscall sys_fcntl nr 5070 nbargs 3 types: (unsigned int, unsigned int, unsigned long) args: (fd, cmd, arg) -syscall sys_getdents nr 5076 nbargs 3 types: (unsigned int, struct linux_dirent *, unsigned int) args: (fd, dirent, count) -syscall sys_gettimeofday nr 5094 nbargs 2 types: (struct timeval *, struct timezone *) args: (tv, tz) -syscall sys_getrlimit nr 5095 nbargs 2 types: (unsigned int, struct rlimit *) args: (resource, rlim) -syscall sys_getrusage nr 5096 nbargs 2 types: (int, struct rusage *) args: (who, ru) -syscall sys_sysinfo nr 5097 nbargs 1 types: (struct sysinfo *) args: (info) -syscall sys_times nr 5098 nbargs 1 types: (struct tms *) args: (tbuf) -syscall sys_ptrace nr 5099 nbargs 4 types: (long, long, unsigned long, unsigned long) args: (request, pid, addr, data) -syscall sys_rt_sigpending nr 5125 nbargs 2 types: (sigset_t *, size_t) args: (set, sigsetsize) -syscall sys_rt_sigtimedwait nr 5126 nbargs 4 types: (const sigset_t *, siginfo_t *, const struct timespec *, size_t) args: (uthese, uinfo, uts, sigsetsize) -syscall sys_rt_sigqueueinfo nr 5127 nbargs 3 types: (pid_t, int, siginfo_t *) args: (pid, sig, uinfo) -syscall sys_utime nr 5130 nbargs 2 types: (char *, struct utimbuf *) args: (filename, times) -syscall sys_personality nr 5132 nbargs 1 types: (unsigned int) args: (personality) -syscall sys_ustat nr 5133 nbargs 2 types: (unsigned, struct ustat *) args: (dev, ubuf) -syscall sys_statfs nr 5134 nbargs 2 types: (const char *, struct statfs *) args: (pathname, buf) -syscall sys_fstatfs nr 5135 nbargs 2 types: (unsigned int, struct statfs *) args: (fd, buf) -syscall sys_sched_rr_get_interval nr 5145 nbargs 2 types: (pid_t, struct timespec *) args: (pid, interval) -syscall sys_sysctl nr 5152 nbargs 1 types: (struct __sysctl_args *) args: (args) -syscall sys_adjtimex nr 5154 nbargs 1 types: (struct timex *) args: (txc_p) -syscall sys_setrlimit nr 5155 nbargs 2 types: (unsigned int, struct rlimit *) args: (resource, rlim) -syscall sys_settimeofday nr 5159 nbargs 2 types: (struct timeval *, struct timezone *) args: (tv, tz) -syscall sys_mount nr 5160 nbargs 5 types: (char *, char *, char *, unsigned long, void *) args: (dev_name, dir_name, type, flags, data) -syscall sys_futex nr 5194 nbargs 6 types: (u32 *, int, u32, struct timespec *, u32 *, u32) args: (uaddr, op, val, utime, uaddr2, val3) -syscall sys_sched_setaffinity nr 5195 nbargs 3 types: (pid_t, unsigned int, unsigned long *) args: (pid, len, user_mask_ptr) -syscall sys_sched_getaffinity nr 5196 nbargs 3 types: (pid_t, unsigned int, unsigned long *) args: (pid, len, user_mask_ptr) -syscall sys_io_setup nr 5200 nbargs 2 types: (unsigned, aio_context_t *) args: (nr_events, ctxp) -syscall sys_io_getevents nr 5202 nbargs 5 types: (aio_context_t, long, long, struct io_event *, struct timespec *) args: (ctx_id, min_nr, nr, events, timeout) -syscall sys_io_submit nr 5203 nbargs 3 types: (aio_context_t, long, struct iocb * *) args: (ctx_id, nr, iocbpp) -syscall sys_semtimedop nr 5214 nbargs 4 types: (int, struct sembuf *, unsigned, const struct timespec *) args: (semid, tsops, nsops, timeout) -syscall sys_timer_create nr 5216 nbargs 3 types: (const clockid_t, struct sigevent *, timer_t *) args: (which_clock, timer_event_spec, created_timer_id) -syscall sys_timer_settime nr 5217 nbargs 4 types: (timer_t, int, const struct itimerspec *, struct itimerspec *) args: (timer_id, flags, new_setting, old_setting) -syscall sys_timer_gettime nr 5218 nbargs 2 types: (timer_t, struct itimerspec *) args: (timer_id, setting) -syscall sys_clock_settime nr 5221 nbargs 2 types: (const clockid_t, const struct timespec *) args: (which_clock, tp) -syscall sys_clock_gettime nr 5222 nbargs 2 types: (const clockid_t, struct timespec *) args: (which_clock, tp) -syscall sys_clock_getres nr 5223 nbargs 2 types: (const clockid_t, struct timespec *) args: (which_clock, tp) -syscall sys_clock_nanosleep nr 5224 nbargs 4 types: (const clockid_t, int, const struct timespec *, struct timespec *) args: (which_clock, flags, rqtp, rmtp) -syscall sys_utimes nr 5226 nbargs 2 types: (char *, struct timeval *) args: (filename, utimes) -syscall sys_waitid nr 5237 nbargs 5 types: (int, pid_t, struct siginfo *, int, struct rusage *) args: (which, upid, infop, options, ru) -syscall sys_futimesat nr 5251 nbargs 3 types: (int, const char *, struct timeval *) args: (dfd, filename, utimes) -syscall sys_pselect6 nr 5260 nbargs 6 types: (int, fd_set *, fd_set *, fd_set *, struct timespec *, void *) args: (n, inp, outp, exp, tsp, sig) -syscall sys_ppoll nr 5261 nbargs 5 types: (struct pollfd *, unsigned int, struct timespec *, const sigset_t *, size_t) args: (ufds, nfds, tsp, sigmask, sigsetsize) -syscall sys_vmsplice nr 5266 nbargs 4 types: (int, const struct iovec *, unsigned long, unsigned int) args: (fd, iov, nr_segs, flags) -syscall sys_set_robust_list nr 5268 nbargs 2 types: (struct robust_list_head *, size_t) args: (head, len) -syscall sys_get_robust_list nr 5269 nbargs 3 types: (int, struct robust_list_head * *, size_t *) args: (pid, head_ptr, len_ptr) -syscall sys_epoll_pwait nr 5272 nbargs 6 types: (int, struct epoll_event *, int, int, const sigset_t *, size_t) args: (epfd, events, maxevents, timeout, sigmask, sigsetsize) -syscall sys_utimensat nr 5275 nbargs 4 types: (int, const char *, struct timespec *, int) args: (dfd, filename, utimes, flags) -syscall sys_signalfd nr 5276 nbargs 3 types: (int, sigset_t *, size_t) args: (ufd, user_mask, sizemask) -syscall sys_timerfd_gettime nr 5281 nbargs 2 types: (int, struct itimerspec *) args: (ufd, otmr) -syscall sys_timerfd_settime nr 5282 nbargs 4 types: (int, int, const struct itimerspec *, struct itimerspec *) args: (ufd, flags, utmr, otmr) -syscall sys_rt_tgsigqueueinfo nr 5291 nbargs 4 types: (pid_t, pid_t, int, siginfo_t *) args: (tgid, pid, sig, uinfo) -syscall sys_recvmmsg nr 5294 nbargs 5 types: (int, struct mmsghdr *, unsigned int, unsigned int, struct timespec *) args: (fd, mmsg, vlen, flags, timeout) -syscall sys_clock_adjtime nr 5300 nbargs 2 types: (const clockid_t, struct timex *) args: (which_clock, utx) -syscall sys_sendmmsg nr 5302 nbargs 4 types: (int, struct mmsghdr *, unsigned int, unsigned int) args: (fd, mmsg, vlen, flags) -syscall sys_process_vm_readv nr 5304 nbargs 6 types: (pid_t, const struct iovec *, unsigned long, const struct iovec *, unsigned long, unsigned long) args: (pid, lvec, liovcnt, rvec, riovcnt, flags) -syscall sys_process_vm_writev nr 5305 nbargs 6 types: (pid_t, const struct iovec *, unsigned long, const struct iovec *, unsigned long, unsigned long) args: (pid, lvec, liovcnt, rvec, riovcnt, flags) -syscall sys_read nr 6000 nbargs 3 types: (unsigned int, char *, size_t) args: (fd, buf, count) -syscall sys_write nr 6001 nbargs 3 types: (unsigned int, const char *, size_t) args: (fd, buf, count) -syscall sys_open nr 6002 nbargs 3 types: (const char *, int, umode_t) args: (filename, flags, mode) -syscall sys_close nr 6003 nbargs 1 types: (unsigned int) args: (fd) -syscall sys_newstat nr 6004 nbargs 2 types: (const char *, struct stat *) args: (filename, statbuf) -syscall sys_newfstat nr 6005 nbargs 2 types: (unsigned int, struct stat *) args: (fd, statbuf) -syscall sys_newlstat nr 6006 nbargs 2 types: (const char *, struct stat *) args: (filename, statbuf) -syscall sys_poll nr 6007 nbargs 3 types: (struct pollfd *, unsigned int, int) args: (ufds, nfds, timeout_msecs) -syscall sys_lseek nr 6008 nbargs 3 types: (unsigned int, off_t, unsigned int) args: (fd, offset, origin) -syscall sys_mips_mmap nr 6009 nbargs 6 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long, off_t) args: (addr, len, prot, flags, fd, offset) -syscall sys_mprotect nr 6010 nbargs 3 types: (unsigned long, size_t, unsigned long) args: (start, len, prot) -syscall sys_munmap nr 6011 nbargs 2 types: (unsigned long, size_t) args: (addr, len) -syscall sys_brk nr 6012 nbargs 1 types: (unsigned long) args: (brk) -syscall sys_32_rt_sigaction nr 6013 nbargs 4 types: (int, const struct sigaction32 *, struct sigaction32 *, unsigned int) args: (sig, act, oact, sigsetsize) -syscall sys_32_rt_sigprocmask nr 6014 nbargs 4 types: (int, compat_sigset_t *, compat_sigset_t *, unsigned int) args: (how, set, oset, sigsetsize) -syscall sys_access nr 6020 nbargs 2 types: (const char *, int) args: (filename, mode) -syscall sys_sched_yield nr 6023 nbargs 0 types: () args: () -syscall sys_mremap nr 6024 nbargs 5 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long) args: (addr, old_len, new_len, flags, new_addr) -syscall sys_msync nr 6025 nbargs 3 types: (unsigned long, size_t, int) args: (start, len, flags) -syscall sys_mincore nr 6026 nbargs 3 types: (unsigned long, size_t, unsigned char *) args: (start, len, vec) -syscall sys_madvise nr 6027 nbargs 3 types: (unsigned long, size_t, int) args: (start, len_in, behavior) -syscall sys_shmget nr 6028 nbargs 3 types: (key_t, size_t, int) args: (key, size, shmflg) -syscall sys_shmat nr 6029 nbargs 3 types: (int, char *, int) args: (shmid, shmaddr, shmflg) -syscall sys_dup nr 6031 nbargs 1 types: (unsigned int) args: (fildes) -syscall sys_dup2 nr 6032 nbargs 2 types: (unsigned int, unsigned int) args: (oldfd, newfd) -syscall sys_pause nr 6033 nbargs 0 types: () args: () -syscall sys_alarm nr 6037 nbargs 1 types: (unsigned int) args: (seconds) -syscall sys_getpid nr 6038 nbargs 0 types: () args: () -syscall sys_32_sendfile nr 6039 nbargs 4 types: (long, long, compat_off_t *, s32) args: (out_fd, in_fd, offset, count) -syscall sys_socket nr 6040 nbargs 3 types: (int, int, int) args: (family, type, protocol) -syscall sys_connect nr 6041 nbargs 3 types: (int, struct sockaddr *, int) args: (fd, uservaddr, addrlen) -syscall sys_accept nr 6042 nbargs 3 types: (int, struct sockaddr *, int *) args: (fd, upeer_sockaddr, upeer_addrlen) -syscall sys_sendto nr 6043 nbargs 6 types: (int, void *, size_t, unsigned int, struct sockaddr *, int) args: (fd, buff, len, flags, addr, addr_len) -syscall sys_shutdown nr 6047 nbargs 2 types: (int, int) args: (fd, how) -syscall sys_bind nr 6048 nbargs 3 types: (int, struct sockaddr *, int) args: (fd, umyaddr, addrlen) -syscall sys_listen nr 6049 nbargs 2 types: (int, int) args: (fd, backlog) -syscall sys_getsockname nr 6050 nbargs 3 types: (int, struct sockaddr *, int *) args: (fd, usockaddr, usockaddr_len) -syscall sys_getpeername nr 6051 nbargs 3 types: (int, struct sockaddr *, int *) args: (fd, usockaddr, usockaddr_len) -syscall sys_socketpair nr 6052 nbargs 4 types: (int, int, int, int *) args: (family, type, protocol, usockvec) -syscall sys_getsockopt nr 6054 nbargs 5 types: (int, int, int, char *, int *) args: (fd, level, optname, optval, optlen) -syscall sys_exit nr 6058 nbargs 1 types: (int) args: (error_code) -syscall sys_kill nr 6060 nbargs 2 types: (pid_t, int) args: (pid, sig) -syscall sys_newuname nr 6061 nbargs 1 types: (struct new_utsname *) args: (name) -syscall sys_semget nr 6062 nbargs 3 types: (key_t, int, int) args: (key, nsems, semflg) -syscall sys_semop nr 6063 nbargs 3 types: (int, struct sembuf *, unsigned) args: (semid, tsops, nsops) -syscall sys_n32_semctl nr 6064 nbargs 4 types: (int, int, int, u32) args: (semid, semnum, cmd, arg) -syscall sys_shmdt nr 6065 nbargs 1 types: (char *) args: (shmaddr) -syscall sys_msgget nr 6066 nbargs 2 types: (key_t, int) args: (key, msgflg) -syscall sys_n32_msgsnd nr 6067 nbargs 4 types: (int, u32, unsigned int, int) args: (msqid, msgp, msgsz, msgflg) -syscall sys_n32_msgrcv nr 6068 nbargs 5 types: (int, u32, size_t, int, int) args: (msqid, msgp, msgsz, msgtyp, msgflg) -syscall sys_flock nr 6071 nbargs 2 types: (unsigned int, unsigned int) args: (fd, cmd) -syscall sys_fsync nr 6072 nbargs 1 types: (unsigned int) args: (fd) -syscall sys_fdatasync nr 6073 nbargs 1 types: (unsigned int) args: (fd) -syscall sys_truncate nr 6074 nbargs 2 types: (const char *, long) args: (path, length) -syscall sys_ftruncate nr 6075 nbargs 2 types: (unsigned int, unsigned long) args: (fd, length) -syscall sys_getcwd nr 6077 nbargs 2 types: (char *, unsigned long) args: (buf, size) -syscall sys_chdir nr 6078 nbargs 1 types: (const char *) args: (filename) -syscall sys_fchdir nr 6079 nbargs 1 types: (unsigned int) args: (fd) -syscall sys_rename nr 6080 nbargs 2 types: (const char *, const char *) args: (oldname, newname) -syscall sys_mkdir nr 6081 nbargs 2 types: (const char *, umode_t) args: (pathname, mode) -syscall sys_rmdir nr 6082 nbargs 1 types: (const char *) args: (pathname) -syscall sys_creat nr 6083 nbargs 2 types: (const char *, umode_t) args: (pathname, mode) -syscall sys_link nr 6084 nbargs 2 types: (const char *, const char *) args: (oldname, newname) -syscall sys_unlink nr 6085 nbargs 1 types: (const char *) args: (pathname) -syscall sys_symlink nr 6086 nbargs 2 types: (const char *, const char *) args: (oldname, newname) -syscall sys_readlink nr 6087 nbargs 3 types: (const char *, char *, int) args: (path, buf, bufsiz) -syscall sys_chmod nr 6088 nbargs 2 types: (const char *, umode_t) args: (filename, mode) -syscall sys_fchmod nr 6089 nbargs 2 types: (unsigned int, umode_t) args: (fd, mode) -syscall sys_chown nr 6090 nbargs 3 types: (const char *, uid_t, gid_t) args: (filename, user, group) -syscall sys_fchown nr 6091 nbargs 3 types: (unsigned int, uid_t, gid_t) args: (fd, user, group) -syscall sys_lchown nr 6092 nbargs 3 types: (const char *, uid_t, gid_t) args: (filename, user, group) -syscall sys_umask nr 6093 nbargs 1 types: (int) args: (mask) -syscall sys_getuid nr 6100 nbargs 0 types: () args: () -syscall sys_syslog nr 6101 nbargs 3 types: (int, char *, int) args: (type, buf, len) -syscall sys_getgid nr 6102 nbargs 0 types: () args: () -syscall sys_setuid nr 6103 nbargs 1 types: (uid_t) args: (uid) -syscall sys_setgid nr 6104 nbargs 1 types: (gid_t) args: (gid) -syscall sys_geteuid nr 6105 nbargs 0 types: () args: () -syscall sys_getegid nr 6106 nbargs 0 types: () args: () -syscall sys_setpgid nr 6107 nbargs 2 types: (pid_t, pid_t) args: (pid, pgid) -syscall sys_getppid nr 6108 nbargs 0 types: () args: () -syscall sys_getpgrp nr 6109 nbargs 0 types: () args: () -syscall sys_setsid nr 6110 nbargs 0 types: () args: () -syscall sys_setreuid nr 6111 nbargs 2 types: (uid_t, uid_t) args: (ruid, euid) -syscall sys_setregid nr 6112 nbargs 2 types: (gid_t, gid_t) args: (rgid, egid) -syscall sys_getgroups nr 6113 nbargs 2 types: (int, gid_t *) args: (gidsetsize, grouplist) -syscall sys_setgroups nr 6114 nbargs 2 types: (int, gid_t *) args: (gidsetsize, grouplist) -syscall sys_setresuid nr 6115 nbargs 3 types: (uid_t, uid_t, uid_t) args: (ruid, euid, suid) -syscall sys_getresuid nr 6116 nbargs 3 types: (uid_t *, uid_t *, uid_t *) args: (ruidp, euidp, suidp) -syscall sys_setresgid nr 6117 nbargs 3 types: (gid_t, gid_t, gid_t) args: (rgid, egid, sgid) -syscall sys_getresgid nr 6118 nbargs 3 types: (gid_t *, gid_t *, gid_t *) args: (rgidp, egidp, sgidp) -syscall sys_getpgid nr 6119 nbargs 1 types: (pid_t) args: (pid) -syscall sys_setfsuid nr 6120 nbargs 1 types: (uid_t) args: (uid) -syscall sys_setfsgid nr 6121 nbargs 1 types: (gid_t) args: (gid) -syscall sys_getsid nr 6122 nbargs 1 types: (pid_t) args: (pid) -syscall sys_capget nr 6123 nbargs 2 types: (cap_user_header_t, cap_user_data_t) args: (header, dataptr) -syscall sys_capset nr 6124 nbargs 2 types: (cap_user_header_t, const cap_user_data_t) args: (header, data) -syscall sys_32_rt_sigpending nr 6125 nbargs 2 types: (compat_sigset_t *, unsigned int) args: (uset, sigsetsize) -syscall sys_32_rt_sigqueueinfo nr 6127 nbargs 3 types: (int, int, compat_siginfo_t *) args: (pid, sig, uinfo) -syscall sys_mknod nr 6131 nbargs 3 types: (const char *, umode_t, unsigned) args: (filename, mode, dev) -syscall sys_32_personality nr 6132 nbargs 1 types: (unsigned long) args: (personality) -syscall sys_sysfs nr 6136 nbargs 3 types: (int, unsigned long, unsigned long) args: (option, arg1, arg2) -syscall sys_getpriority nr 6137 nbargs 2 types: (int, int) args: (which, who) -syscall sys_setpriority nr 6138 nbargs 3 types: (int, int, int) args: (which, who, niceval) -syscall sys_sched_setparam nr 6139 nbargs 2 types: (pid_t, struct sched_param *) args: (pid, param) -syscall sys_sched_getparam nr 6140 nbargs 2 types: (pid_t, struct sched_param *) args: (pid, param) -syscall sys_sched_setscheduler nr 6141 nbargs 3 types: (pid_t, int, struct sched_param *) args: (pid, policy, param) -syscall sys_sched_getscheduler nr 6142 nbargs 1 types: (pid_t) args: (pid) -syscall sys_sched_get_priority_max nr 6143 nbargs 1 types: (int) args: (policy) -syscall sys_sched_get_priority_min nr 6144 nbargs 1 types: (int) args: (policy) -syscall sys_32_sched_rr_get_interval nr 6145 nbargs 2 types: (compat_pid_t, struct compat_timespec *) args: (pid, interval) -syscall sys_mlock nr 6146 nbargs 2 types: (unsigned long, size_t) args: (start, len) -syscall sys_munlock nr 6147 nbargs 2 types: (unsigned long, size_t) args: (start, len) -syscall sys_mlockall nr 6148 nbargs 1 types: (int) args: (flags) -syscall sys_munlockall nr 6149 nbargs 0 types: () args: () -syscall sys_vhangup nr 6150 nbargs 0 types: () args: () -syscall sys_pivot_root nr 6151 nbargs 2 types: (const char *, const char *) args: (new_root, put_old) -syscall sys_prctl nr 6153 nbargs 5 types: (int, unsigned long, unsigned long, unsigned long, unsigned long) args: (option, arg2, arg3, arg4, arg5) -syscall sys_chroot nr 6156 nbargs 1 types: (const char *) args: (filename) -syscall sys_sync nr 6157 nbargs 0 types: () args: () -syscall sys_umount nr 6161 nbargs 2 types: (char *, int) args: (name, flags) -syscall sys_swapon nr 6162 nbargs 2 types: (const char *, int) args: (specialfile, swap_flags) -syscall sys_swapoff nr 6163 nbargs 1 types: (const char *) args: (specialfile) -syscall sys_reboot nr 6164 nbargs 4 types: (int, int, unsigned int, void *) args: (magic1, magic2, cmd, arg) -syscall sys_sethostname nr 6165 nbargs 2 types: (char *, int) args: (name, len) -syscall sys_setdomainname nr 6166 nbargs 2 types: (char *, int) args: (name, len) -syscall sys_init_module nr 6168 nbargs 3 types: (void *, unsigned long, const char *) args: (umod, len, uargs) -syscall sys_delete_module nr 6169 nbargs 2 types: (const char *, unsigned int) args: (name_user, flags) -syscall sys_quotactl nr 6172 nbargs 4 types: (unsigned int, const char *, qid_t, void *) args: (cmd, special, id, addr) -syscall sys_gettid nr 6178 nbargs 0 types: () args: () -syscall sys_setxattr nr 6180 nbargs 5 types: (const char *, const char *, const void *, size_t, int) args: (pathname, name, value, size, flags) -syscall sys_lsetxattr nr 6181 nbargs 5 types: (const char *, const char *, const void *, size_t, int) args: (pathname, name, value, size, flags) -syscall sys_fsetxattr nr 6182 nbargs 5 types: (int, const char *, const void *, size_t, int) args: (fd, name, value, size, flags) -syscall sys_getxattr nr 6183 nbargs 4 types: (const char *, const char *, void *, size_t) args: (pathname, name, value, size) -syscall sys_lgetxattr nr 6184 nbargs 4 types: (const char *, const char *, void *, size_t) args: (pathname, name, value, size) -syscall sys_fgetxattr nr 6185 nbargs 4 types: (int, const char *, void *, size_t) args: (fd, name, value, size) -syscall sys_listxattr nr 6186 nbargs 3 types: (const char *, char *, size_t) args: (pathname, list, size) -syscall sys_llistxattr nr 6187 nbargs 3 types: (const char *, char *, size_t) args: (pathname, list, size) -syscall sys_flistxattr nr 6188 nbargs 3 types: (int, char *, size_t) args: (fd, list, size) -syscall sys_removexattr nr 6189 nbargs 2 types: (const char *, const char *) args: (pathname, name) -syscall sys_lremovexattr nr 6190 nbargs 2 types: (const char *, const char *) args: (pathname, name) -syscall sys_fremovexattr nr 6191 nbargs 2 types: (int, const char *) args: (fd, name) -syscall sys_tkill nr 6192 nbargs 2 types: (pid_t, int) args: (pid, sig) -syscall sys_32_futex nr 6194 nbargs 6 types: (u32 *, int, u32, struct compat_timespec *, u32 *, u32) args: (uaddr, op, val, utime, uaddr2, val3) -syscall sys_cacheflush nr 6197 nbargs 3 types: (unsigned long, unsigned long, unsigned int) args: (addr, bytes, cache) -syscall sys_cachectl nr 6198 nbargs 3 types: (char *, int, int) args: (addr, nbytes, op) -syscall sys_io_destroy nr 6201 nbargs 1 types: (aio_context_t) args: (ctx) -syscall sys_io_cancel nr 6204 nbargs 3 types: (aio_context_t, struct iocb *, struct io_event *) args: (ctx_id, iocb, result) -syscall sys_exit_group nr 6205 nbargs 1 types: (int) args: (error_code) -syscall sys_epoll_create nr 6207 nbargs 1 types: (int) args: (size) -syscall sys_epoll_ctl nr 6208 nbargs 4 types: (int, int, int, struct epoll_event *) args: (epfd, op, fd, event) -syscall sys_epoll_wait nr 6209 nbargs 4 types: (int, struct epoll_event *, int, int) args: (epfd, events, maxevents, timeout) -syscall sys_remap_file_pages nr 6210 nbargs 5 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long) args: (start, size, prot, pgoff, flags) -syscall sys_set_tid_address nr 6213 nbargs 1 types: (int *) args: (tidptr) -syscall sys_restart_syscall nr 6214 nbargs 0 types: () args: () -syscall sys_sendfile64 nr 6219 nbargs 4 types: (int, int, loff_t *, size_t) args: (out_fd, in_fd, offset, count) -syscall sys_timer_getoverrun nr 6223 nbargs 1 types: (timer_t) args: (timer_id) -syscall sys_timer_delete nr 6224 nbargs 1 types: (timer_t) args: (timer_id) -syscall sys_tgkill nr 6229 nbargs 3 types: (pid_t, pid_t, int) args: (tgid, pid, sig) -syscall sys_set_thread_area nr 6246 nbargs 1 types: (unsigned long) args: (addr) -syscall sys_inotify_init nr 6247 nbargs 0 types: () args: () -syscall sys_inotify_add_watch nr 6248 nbargs 3 types: (int, const char *, u32) args: (fd, pathname, mask) -syscall sys_inotify_rm_watch nr 6249 nbargs 2 types: (int, __s32) args: (fd, wd) -syscall sys_openat nr 6251 nbargs 4 types: (int, const char *, int, umode_t) args: (dfd, filename, flags, mode) -syscall sys_mkdirat nr 6252 nbargs 3 types: (int, const char *, umode_t) args: (dfd, pathname, mode) -syscall sys_mknodat nr 6253 nbargs 4 types: (int, const char *, umode_t, unsigned) args: (dfd, filename, mode, dev) -syscall sys_fchownat nr 6254 nbargs 5 types: (int, const char *, uid_t, gid_t, int) args: (dfd, filename, user, group, flag) -syscall sys_newfstatat nr 6256 nbargs 4 types: (int, const char *, struct stat *, int) args: (dfd, filename, statbuf, flag) -syscall sys_unlinkat nr 6257 nbargs 3 types: (int, const char *, int) args: (dfd, pathname, flag) -syscall sys_renameat nr 6258 nbargs 4 types: (int, const char *, int, const char *) args: (olddfd, oldname, newdfd, newname) -syscall sys_linkat nr 6259 nbargs 5 types: (int, const char *, int, const char *, int) args: (olddfd, oldname, newdfd, newname, flags) -syscall sys_symlinkat nr 6260 nbargs 3 types: (const char *, int, const char *) args: (oldname, newdfd, newname) -syscall sys_readlinkat nr 6261 nbargs 4 types: (int, const char *, char *, int) args: (dfd, pathname, buf, bufsiz) -syscall sys_fchmodat nr 6262 nbargs 3 types: (int, const char *, umode_t) args: (dfd, filename, mode) -syscall sys_faccessat nr 6263 nbargs 3 types: (int, const char *, int) args: (dfd, filename, mode) -syscall sys_unshare nr 6266 nbargs 1 types: (unsigned long) args: (unshare_flags) -syscall sys_splice nr 6267 nbargs 6 types: (int, loff_t *, int, loff_t *, size_t, unsigned int) args: (fd_in, off_in, fd_out, off_out, len, flags) -syscall sys_tee nr 6269 nbargs 4 types: (int, int, size_t, unsigned int) args: (fdin, fdout, len, flags) -syscall sys_getcpu nr 6275 nbargs 3 types: (unsigned *, unsigned *, struct getcpu_cache *) args: (cpup, nodep, unused) -syscall sys_ioprio_set nr 6277 nbargs 3 types: (int, int, int) args: (which, who, ioprio) -syscall sys_ioprio_get nr 6278 nbargs 2 types: (int, int) args: (which, who) -syscall sys_eventfd nr 6282 nbargs 1 types: (unsigned int) args: (count) -syscall sys_timerfd_create nr 6284 nbargs 2 types: (int, int) args: (clockid, flags) -syscall sys_signalfd4 nr 6287 nbargs 4 types: (int, sigset_t *, size_t, int) args: (ufd, user_mask, sizemask, flags) -syscall sys_eventfd2 nr 6288 nbargs 2 types: (unsigned int, int) args: (count, flags) -syscall sys_epoll_create1 nr 6289 nbargs 1 types: (int) args: (flags) -syscall sys_dup3 nr 6290 nbargs 3 types: (unsigned int, unsigned int, int) args: (oldfd, newfd, flags) -syscall sys_pipe2 nr 6291 nbargs 2 types: (int *, int) args: (fildes, flags) -syscall sys_inotify_init1 nr 6292 nbargs 1 types: (int) args: (flags) -syscall sys_preadv nr 6293 nbargs 5 types: (unsigned long, const struct iovec *, unsigned long, unsigned long, unsigned long) args: (fd, vec, vlen, pos_l, pos_h) -syscall sys_pwritev nr 6294 nbargs 5 types: (unsigned long, const struct iovec *, unsigned long, unsigned long, unsigned long) args: (fd, vec, vlen, pos_l, pos_h) -syscall sys_accept4 nr 6297 nbargs 4 types: (int, struct sockaddr *, int *, int) args: (fd, upeer_sockaddr, upeer_addrlen, flags) -syscall sys_getdents64 nr 6299 nbargs 3 types: (unsigned int, struct linux_dirent64 *, unsigned int) args: (fd, dirent, count) -syscall sys_prlimit64 nr 6302 nbargs 4 types: (pid_t, unsigned int, const struct rlimit64 *, struct rlimit64 *) args: (pid, resource, new_rlim, old_rlim) -syscall sys_syncfs nr 6306 nbargs 1 types: (int) args: (fd) -syscall sys_setns nr 6308 nbargs 2 types: (int, int) args: (fd, nstype) diff --git a/instrumentation/syscalls/4.4.0/arm-64-syscalls b/instrumentation/syscalls/4.4.0/arm-64-syscalls deleted file mode 100644 index 99360cee..00000000 --- a/instrumentation/syscalls/4.4.0/arm-64-syscalls +++ /dev/null @@ -1,256 +0,0 @@ -syscall sys_io_setup nr 0 nbargs 2 types: (unsigned, aio_context_t *) args: (nr_events, ctxp) -syscall sys_io_destroy nr 1 nbargs 1 types: (aio_context_t) args: (ctx) -syscall sys_io_submit nr 2 nbargs 3 types: (aio_context_t, long, struct iocb * *) args: (ctx_id, nr, iocbpp) -syscall sys_io_cancel nr 3 nbargs 3 types: (aio_context_t, struct iocb *, struct io_event *) args: (ctx_id, iocb, result) -syscall sys_io_getevents nr 4 nbargs 5 types: (aio_context_t, long, long, struct io_event *, struct timespec *) args: (ctx_id, min_nr, nr, events, timeout) -syscall sys_setxattr nr 5 nbargs 5 types: (const char *, const char *, const void *, size_t, int) args: (pathname, name, value, size, flags) -syscall sys_lsetxattr nr 6 nbargs 5 types: (const char *, const char *, const void *, size_t, int) args: (pathname, name, value, size, flags) -syscall sys_fsetxattr nr 7 nbargs 5 types: (int, const char *, const void *, size_t, int) args: (fd, name, value, size, flags) -syscall sys_getxattr nr 8 nbargs 4 types: (const char *, const char *, void *, size_t) args: (pathname, name, value, size) -syscall sys_lgetxattr nr 9 nbargs 4 types: (const char *, const char *, void *, size_t) args: (pathname, name, value, size) -syscall sys_fgetxattr nr 10 nbargs 4 types: (int, const char *, void *, size_t) args: (fd, name, value, size) -syscall sys_listxattr nr 11 nbargs 3 types: (const char *, char *, size_t) args: (pathname, list, size) -syscall sys_llistxattr nr 12 nbargs 3 types: (const char *, char *, size_t) args: (pathname, list, size) -syscall sys_flistxattr nr 13 nbargs 3 types: (int, char *, size_t) args: (fd, list, size) -syscall sys_removexattr nr 14 nbargs 2 types: (const char *, const char *) args: (pathname, name) -syscall sys_lremovexattr nr 15 nbargs 2 types: (const char *, const char *) args: (pathname, name) -syscall sys_fremovexattr nr 16 nbargs 2 types: (int, const char *) args: (fd, name) -syscall sys_getcwd nr 17 nbargs 2 types: (char *, unsigned long) args: (buf, size) -syscall sys_lookup_dcookie nr 18 nbargs 3 types: (u64, char *, size_t) args: (cookie64, buf, len) -syscall sys_eventfd2 nr 19 nbargs 2 types: (unsigned int, int) args: (count, flags) -syscall sys_epoll_create1 nr 20 nbargs 1 types: (int) args: (flags) -syscall sys_epoll_ctl nr 21 nbargs 4 types: (int, int, int, struct epoll_event *) args: (epfd, op, fd, event) -syscall sys_epoll_pwait nr 22 nbargs 6 types: (int, struct epoll_event *, int, int, const sigset_t *, size_t) args: (epfd, events, maxevents, timeout, sigmask, sigsetsize) -syscall sys_dup nr 23 nbargs 1 types: (unsigned int) args: (fildes) -syscall sys_dup3 nr 24 nbargs 3 types: (unsigned int, unsigned int, int) args: (oldfd, newfd, flags) -syscall sys_fcntl nr 25 nbargs 3 types: (unsigned int, unsigned int, unsigned long) args: (fd, cmd, arg) -syscall sys_inotify_init1 nr 26 nbargs 1 types: (int) args: (flags) -syscall sys_inotify_add_watch nr 27 nbargs 3 types: (int, const char *, u32) args: (fd, pathname, mask) -syscall sys_inotify_rm_watch nr 28 nbargs 2 types: (int, __s32) args: (fd, wd) -syscall sys_ioctl nr 29 nbargs 3 types: (unsigned int, unsigned int, unsigned long) args: (fd, cmd, arg) -syscall sys_ioprio_set nr 30 nbargs 3 types: (int, int, int) args: (which, who, ioprio) -syscall sys_ioprio_get nr 31 nbargs 2 types: (int, int) args: (which, who) -syscall sys_flock nr 32 nbargs 2 types: (unsigned int, unsigned int) args: (fd, cmd) -syscall sys_mknodat nr 33 nbargs 4 types: (int, const char *, umode_t, unsigned) args: (dfd, filename, mode, dev) -syscall sys_mkdirat nr 34 nbargs 3 types: (int, const char *, umode_t) args: (dfd, pathname, mode) -syscall sys_unlinkat nr 35 nbargs 3 types: (int, const char *, int) args: (dfd, pathname, flag) -syscall sys_symlinkat nr 36 nbargs 3 types: (const char *, int, const char *) args: (oldname, newdfd, newname) -syscall sys_linkat nr 37 nbargs 5 types: (int, const char *, int, const char *, int) args: (olddfd, oldname, newdfd, newname, flags) -syscall sys_renameat nr 38 nbargs 4 types: (int, const char *, int, const char *) args: (olddfd, oldname, newdfd, newname) -syscall sys_umount nr 39 nbargs 2 types: (char *, int) args: (name, flags) -syscall sys_mount nr 40 nbargs 5 types: (char *, char *, char *, unsigned long, void *) args: (dev_name, dir_name, type, flags, data) -syscall sys_pivot_root nr 41 nbargs 2 types: (const char *, const char *) args: (new_root, put_old) -syscall sys_statfs nr 43 nbargs 2 types: (const char *, struct statfs *) args: (pathname, buf) -syscall sys_fstatfs nr 44 nbargs 2 types: (unsigned int, struct statfs *) args: (fd, buf) -syscall sys_truncate nr 45 nbargs 2 types: (const char *, long) args: (path, length) -syscall sys_ftruncate nr 46 nbargs 2 types: (unsigned int, unsigned long) args: (fd, length) -syscall sys_fallocate nr 47 nbargs 4 types: (int, int, loff_t, loff_t) args: (fd, mode, offset, len) -syscall sys_faccessat nr 48 nbargs 3 types: (int, const char *, int) args: (dfd, filename, mode) -syscall sys_chdir nr 49 nbargs 1 types: (const char *) args: (filename) -syscall sys_fchdir nr 50 nbargs 1 types: (unsigned int) args: (fd) -syscall sys_chroot nr 51 nbargs 1 types: (const char *) args: (filename) -syscall sys_fchmod nr 52 nbargs 2 types: (unsigned int, umode_t) args: (fd, mode) -syscall sys_fchmodat nr 53 nbargs 3 types: (int, const char *, umode_t) args: (dfd, filename, mode) -syscall sys_fchownat nr 54 nbargs 5 types: (int, const char *, uid_t, gid_t, int) args: (dfd, filename, user, group, flag) -syscall sys_fchown nr 55 nbargs 3 types: (unsigned int, uid_t, gid_t) args: (fd, user, group) -syscall sys_openat nr 56 nbargs 4 types: (int, const char *, int, umode_t) args: (dfd, filename, flags, mode) -syscall sys_close nr 57 nbargs 1 types: (unsigned int) args: (fd) -syscall sys_vhangup nr 58 nbargs 0 types: () args: () -syscall sys_pipe2 nr 59 nbargs 2 types: (int *, int) args: (fildes, flags) -syscall sys_quotactl nr 60 nbargs 4 types: (unsigned int, const char *, qid_t, void *) args: (cmd, special, id, addr) -syscall sys_getdents64 nr 61 nbargs 3 types: (unsigned int, struct linux_dirent64 *, unsigned int) args: (fd, dirent, count) -syscall sys_lseek nr 62 nbargs 3 types: (unsigned int, off_t, unsigned int) args: (fd, offset, whence) -syscall sys_read nr 63 nbargs 3 types: (unsigned int, char *, size_t) args: (fd, buf, count) -syscall sys_write nr 64 nbargs 3 types: (unsigned int, const char *, size_t) args: (fd, buf, count) -syscall sys_readv nr 65 nbargs 3 types: (unsigned long, const struct iovec *, unsigned long) args: (fd, vec, vlen) -syscall sys_writev nr 66 nbargs 3 types: (unsigned long, const struct iovec *, unsigned long) args: (fd, vec, vlen) -syscall sys_pread64 nr 67 nbargs 4 types: (unsigned int, char *, size_t, loff_t) args: (fd, buf, count, pos) -syscall sys_pwrite64 nr 68 nbargs 4 types: (unsigned int, const char *, size_t, loff_t) args: (fd, buf, count, pos) -syscall sys_preadv nr 69 nbargs 5 types: (unsigned long, const struct iovec *, unsigned long, unsigned long, unsigned long) args: (fd, vec, vlen, pos_l, pos_h) -syscall sys_pwritev nr 70 nbargs 5 types: (unsigned long, const struct iovec *, unsigned long, unsigned long, unsigned long) args: (fd, vec, vlen, pos_l, pos_h) -syscall sys_sendfile64 nr 71 nbargs 4 types: (int, int, loff_t *, size_t) args: (out_fd, in_fd, offset, count) -syscall sys_pselect6 nr 72 nbargs 6 types: (int, fd_set *, fd_set *, fd_set *, struct timespec *, void *) args: (n, inp, outp, exp, tsp, sig) -syscall sys_ppoll nr 73 nbargs 5 types: (struct pollfd *, unsigned int, struct timespec *, const sigset_t *, size_t) args: (ufds, nfds, tsp, sigmask, sigsetsize) -syscall sys_signalfd4 nr 74 nbargs 4 types: (int, sigset_t *, size_t, int) args: (ufd, user_mask, sizemask, flags) -syscall sys_vmsplice nr 75 nbargs 4 types: (int, const struct iovec *, unsigned long, unsigned int) args: (fd, iov, nr_segs, flags) -syscall sys_splice nr 76 nbargs 6 types: (int, loff_t *, int, loff_t *, size_t, unsigned int) args: (fd_in, off_in, fd_out, off_out, len, flags) -syscall sys_tee nr 77 nbargs 4 types: (int, int, size_t, unsigned int) args: (fdin, fdout, len, flags) -syscall sys_readlinkat nr 78 nbargs 4 types: (int, const char *, char *, int) args: (dfd, pathname, buf, bufsiz) -syscall sys_newfstatat nr 79 nbargs 4 types: (int, const char *, struct stat *, int) args: (dfd, filename, statbuf, flag) -syscall sys_newfstat nr 80 nbargs 2 types: (unsigned int, struct stat *) args: (fd, statbuf) -syscall sys_sync nr 81 nbargs 0 types: () args: () -syscall sys_fsync nr 82 nbargs 1 types: (unsigned int) args: (fd) -syscall sys_fdatasync nr 83 nbargs 1 types: (unsigned int) args: (fd) -syscall sys_sync_file_range nr 84 nbargs 4 types: (int, loff_t, loff_t, unsigned int) args: (fd, offset, nbytes, flags) -syscall sys_timerfd_create nr 85 nbargs 2 types: (int, int) args: (clockid, flags) -syscall sys_timerfd_settime nr 86 nbargs 4 types: (int, int, const struct itimerspec *, struct itimerspec *) args: (ufd, flags, utmr, otmr) -syscall sys_timerfd_gettime nr 87 nbargs 2 types: (int, struct itimerspec *) args: (ufd, otmr) -syscall sys_utimensat nr 88 nbargs 4 types: (int, const char *, struct timespec *, int) args: (dfd, filename, utimes, flags) -syscall sys_acct nr 89 nbargs 1 types: (const char *) args: (name) -syscall sys_capget nr 90 nbargs 2 types: (cap_user_header_t, cap_user_data_t) args: (header, dataptr) -syscall sys_capset nr 91 nbargs 2 types: (cap_user_header_t, const cap_user_data_t) args: (header, data) -syscall sys_personality nr 92 nbargs 1 types: (unsigned int) args: (personality) -syscall sys_exit nr 93 nbargs 1 types: (int) args: (error_code) -syscall sys_exit_group nr 94 nbargs 1 types: (int) args: (error_code) -syscall sys_waitid nr 95 nbargs 5 types: (int, pid_t, struct siginfo *, int, struct rusage *) args: (which, upid, infop, options, ru) -syscall sys_set_tid_address nr 96 nbargs 1 types: (int *) args: (tidptr) -syscall sys_unshare nr 97 nbargs 1 types: (unsigned long) args: (unshare_flags) -syscall sys_futex nr 98 nbargs 6 types: (u32 *, int, u32, struct timespec *, u32 *, u32) args: (uaddr, op, val, utime, uaddr2, val3) -syscall sys_set_robust_list nr 99 nbargs 2 types: (struct robust_list_head *, size_t) args: (head, len) -syscall sys_get_robust_list nr 100 nbargs 3 types: (int, struct robust_list_head * *, size_t *) args: (pid, head_ptr, len_ptr) -syscall sys_nanosleep nr 101 nbargs 2 types: (struct timespec *, struct timespec *) args: (rqtp, rmtp) -syscall sys_getitimer nr 102 nbargs 2 types: (int, struct itimerval *) args: (which, value) -syscall sys_setitimer nr 103 nbargs 3 types: (int, struct itimerval *, struct itimerval *) args: (which, value, ovalue) -syscall sys_init_module nr 105 nbargs 3 types: (void *, unsigned long, const char *) args: (umod, len, uargs) -syscall sys_delete_module nr 106 nbargs 2 types: (const char *, unsigned int) args: (name_user, flags) -syscall sys_timer_create nr 107 nbargs 3 types: (const clockid_t, struct sigevent *, timer_t *) args: (which_clock, timer_event_spec, created_timer_id) -syscall sys_timer_gettime nr 108 nbargs 2 types: (timer_t, struct itimerspec *) args: (timer_id, setting) -syscall sys_timer_getoverrun nr 109 nbargs 1 types: (timer_t) args: (timer_id) -syscall sys_timer_settime nr 110 nbargs 4 types: (timer_t, int, const struct itimerspec *, struct itimerspec *) args: (timer_id, flags, new_setting, old_setting) -syscall sys_timer_delete nr 111 nbargs 1 types: (timer_t) args: (timer_id) -syscall sys_clock_settime nr 112 nbargs 2 types: (const clockid_t, const struct timespec *) args: (which_clock, tp) -syscall sys_clock_gettime nr 113 nbargs 2 types: (const clockid_t, struct timespec *) args: (which_clock, tp) -syscall sys_clock_getres nr 114 nbargs 2 types: (const clockid_t, struct timespec *) args: (which_clock, tp) -syscall sys_clock_nanosleep nr 115 nbargs 4 types: (const clockid_t, int, const struct timespec *, struct timespec *) args: (which_clock, flags, rqtp, rmtp) -syscall sys_syslog nr 116 nbargs 3 types: (int, char *, int) args: (type, buf, len) -syscall sys_ptrace nr 117 nbargs 4 types: (long, long, unsigned long, unsigned long) args: (request, pid, addr, data) -syscall sys_sched_setparam nr 118 nbargs 2 types: (pid_t, struct sched_param *) args: (pid, param) -syscall sys_sched_setscheduler nr 119 nbargs 3 types: (pid_t, int, struct sched_param *) args: (pid, policy, param) -syscall sys_sched_getscheduler nr 120 nbargs 1 types: (pid_t) args: (pid) -syscall sys_sched_getparam nr 121 nbargs 2 types: (pid_t, struct sched_param *) args: (pid, param) -syscall sys_sched_setaffinity nr 122 nbargs 3 types: (pid_t, unsigned int, unsigned long *) args: (pid, len, user_mask_ptr) -syscall sys_sched_getaffinity nr 123 nbargs 3 types: (pid_t, unsigned int, unsigned long *) args: (pid, len, user_mask_ptr) -syscall sys_sched_yield nr 124 nbargs 0 types: () args: () -syscall sys_sched_get_priority_max nr 125 nbargs 1 types: (int) args: (policy) -syscall sys_sched_get_priority_min nr 126 nbargs 1 types: (int) args: (policy) -syscall sys_sched_rr_get_interval nr 127 nbargs 2 types: (pid_t, struct timespec *) args: (pid, interval) -syscall sys_restart_syscall nr 128 nbargs 0 types: () args: () -syscall sys_kill nr 129 nbargs 2 types: (pid_t, int) args: (pid, sig) -syscall sys_tkill nr 130 nbargs 2 types: (pid_t, int) args: (pid, sig) -syscall sys_tgkill nr 131 nbargs 3 types: (pid_t, pid_t, int) args: (tgid, pid, sig) -syscall sys_sigaltstack nr 132 nbargs 2 types: (const stack_t *, stack_t *) args: (uss, uoss) -syscall sys_rt_sigsuspend nr 133 nbargs 2 types: (sigset_t *, size_t) args: (unewset, sigsetsize) -syscall sys_rt_sigaction nr 134 nbargs 4 types: (int, const struct sigaction *, struct sigaction *, size_t) args: (sig, act, oact, sigsetsize) -syscall sys_rt_sigprocmask nr 135 nbargs 4 types: (int, sigset_t *, sigset_t *, size_t) args: (how, nset, oset, sigsetsize) -syscall sys_rt_sigpending nr 136 nbargs 2 types: (sigset_t *, size_t) args: (uset, sigsetsize) -syscall sys_rt_sigtimedwait nr 137 nbargs 4 types: (const sigset_t *, siginfo_t *, const struct timespec *, size_t) args: (uthese, uinfo, uts, sigsetsize) -syscall sys_rt_sigqueueinfo nr 138 nbargs 3 types: (pid_t, int, siginfo_t *) args: (pid, sig, uinfo) -syscall sys_setpriority nr 140 nbargs 3 types: (int, int, int) args: (which, who, niceval) -syscall sys_getpriority nr 141 nbargs 2 types: (int, int) args: (which, who) -syscall sys_reboot nr 142 nbargs 4 types: (int, int, unsigned int, void *) args: (magic1, magic2, cmd, arg) -syscall sys_setregid nr 143 nbargs 2 types: (gid_t, gid_t) args: (rgid, egid) -syscall sys_setgid nr 144 nbargs 1 types: (gid_t) args: (gid) -syscall sys_setreuid nr 145 nbargs 2 types: (uid_t, uid_t) args: (ruid, euid) -syscall sys_setuid nr 146 nbargs 1 types: (uid_t) args: (uid) -syscall sys_setresuid nr 147 nbargs 3 types: (uid_t, uid_t, uid_t) args: (ruid, euid, suid) -syscall sys_getresuid nr 148 nbargs 3 types: (uid_t *, uid_t *, uid_t *) args: (ruidp, euidp, suidp) -syscall sys_setresgid nr 149 nbargs 3 types: (gid_t, gid_t, gid_t) args: (rgid, egid, sgid) -syscall sys_getresgid nr 150 nbargs 3 types: (gid_t *, gid_t *, gid_t *) args: (rgidp, egidp, sgidp) -syscall sys_setfsuid nr 151 nbargs 1 types: (uid_t) args: (uid) -syscall sys_setfsgid nr 152 nbargs 1 types: (gid_t) args: (gid) -syscall sys_times nr 153 nbargs 1 types: (struct tms *) args: (tbuf) -syscall sys_setpgid nr 154 nbargs 2 types: (pid_t, pid_t) args: (pid, pgid) -syscall sys_getpgid nr 155 nbargs 1 types: (pid_t) args: (pid) -syscall sys_getsid nr 156 nbargs 1 types: (pid_t) args: (pid) -syscall sys_setsid nr 157 nbargs 0 types: () args: () -syscall sys_getgroups nr 158 nbargs 2 types: (int, gid_t *) args: (gidsetsize, grouplist) -syscall sys_setgroups nr 159 nbargs 2 types: (int, gid_t *) args: (gidsetsize, grouplist) -syscall sys_newuname nr 160 nbargs 1 types: (struct new_utsname *) args: (name) -syscall sys_sethostname nr 161 nbargs 2 types: (char *, int) args: (name, len) -syscall sys_setdomainname nr 162 nbargs 2 types: (char *, int) args: (name, len) -syscall sys_getrlimit nr 163 nbargs 2 types: (unsigned int, struct rlimit *) args: (resource, rlim) -syscall sys_setrlimit nr 164 nbargs 2 types: (unsigned int, struct rlimit *) args: (resource, rlim) -syscall sys_getrusage nr 165 nbargs 2 types: (int, struct rusage *) args: (who, ru) -syscall sys_umask nr 166 nbargs 1 types: (int) args: (mask) -syscall sys_prctl nr 167 nbargs 5 types: (int, unsigned long, unsigned long, unsigned long, unsigned long) args: (option, arg2, arg3, arg4, arg5) -syscall sys_getcpu nr 168 nbargs 3 types: (unsigned *, unsigned *, struct getcpu_cache *) args: (cpup, nodep, unused) -syscall sys_gettimeofday nr 169 nbargs 2 types: (struct timeval *, struct timezone *) args: (tv, tz) -syscall sys_settimeofday nr 170 nbargs 2 types: (struct timeval *, struct timezone *) args: (tv, tz) -syscall sys_adjtimex nr 171 nbargs 1 types: (struct timex *) args: (txc_p) -syscall sys_getpid nr 172 nbargs 0 types: () args: () -syscall sys_getppid nr 173 nbargs 0 types: () args: () -syscall sys_getuid nr 174 nbargs 0 types: () args: () -syscall sys_geteuid nr 175 nbargs 0 types: () args: () -syscall sys_getgid nr 176 nbargs 0 types: () args: () -syscall sys_getegid nr 177 nbargs 0 types: () args: () -syscall sys_gettid nr 178 nbargs 0 types: () args: () -syscall sys_sysinfo nr 179 nbargs 1 types: (struct sysinfo *) args: (info) -syscall sys_mq_open nr 180 nbargs 4 types: (const char *, int, umode_t, struct mq_attr *) args: (u_name, oflag, mode, u_attr) -syscall sys_mq_unlink nr 181 nbargs 1 types: (const char *) args: (u_name) -syscall sys_mq_timedsend nr 182 nbargs 5 types: (mqd_t, const char *, size_t, unsigned int, const struct timespec *) args: (mqdes, u_msg_ptr, msg_len, msg_prio, u_abs_timeout) -syscall sys_mq_timedreceive nr 183 nbargs 5 types: (mqd_t, char *, size_t, unsigned int *, const struct timespec *) args: (mqdes, u_msg_ptr, msg_len, u_msg_prio, u_abs_timeout) -syscall sys_mq_notify nr 184 nbargs 2 types: (mqd_t, const struct sigevent *) args: (mqdes, u_notification) -syscall sys_mq_getsetattr nr 185 nbargs 3 types: (mqd_t, const struct mq_attr *, struct mq_attr *) args: (mqdes, u_mqstat, u_omqstat) -syscall sys_msgget nr 186 nbargs 2 types: (key_t, int) args: (key, msgflg) -syscall sys_msgctl nr 187 nbargs 3 types: (int, int, struct msqid_ds *) args: (msqid, cmd, buf) -syscall sys_msgrcv nr 188 nbargs 5 types: (int, struct msgbuf *, size_t, long, int) args: (msqid, msgp, msgsz, msgtyp, msgflg) -syscall sys_msgsnd nr 189 nbargs 4 types: (int, struct msgbuf *, size_t, int) args: (msqid, msgp, msgsz, msgflg) -syscall sys_semget nr 190 nbargs 3 types: (key_t, int, int) args: (key, nsems, semflg) -syscall sys_semctl nr 191 nbargs 4 types: (int, int, int, unsigned long) args: (semid, semnum, cmd, arg) -syscall sys_semtimedop nr 192 nbargs 4 types: (int, struct sembuf *, unsigned, const struct timespec *) args: (semid, tsops, nsops, timeout) -syscall sys_semop nr 193 nbargs 3 types: (int, struct sembuf *, unsigned) args: (semid, tsops, nsops) -syscall sys_shmget nr 194 nbargs 3 types: (key_t, size_t, int) args: (key, size, shmflg) -syscall sys_shmctl nr 195 nbargs 3 types: (int, int, struct shmid_ds *) args: (shmid, cmd, buf) -syscall sys_shmat nr 196 nbargs 3 types: (int, char *, int) args: (shmid, shmaddr, shmflg) -syscall sys_shmdt nr 197 nbargs 1 types: (char *) args: (shmaddr) -syscall sys_socket nr 198 nbargs 3 types: (int, int, int) args: (family, type, protocol) -syscall sys_socketpair nr 199 nbargs 4 types: (int, int, int, int *) args: (family, type, protocol, usockvec) -syscall sys_bind nr 200 nbargs 3 types: (int, struct sockaddr *, int) args: (fd, umyaddr, addrlen) -syscall sys_listen nr 201 nbargs 2 types: (int, int) args: (fd, backlog) -syscall sys_accept nr 202 nbargs 3 types: (int, struct sockaddr *, int *) args: (fd, upeer_sockaddr, upeer_addrlen) -syscall sys_connect nr 203 nbargs 3 types: (int, struct sockaddr *, int) args: (fd, uservaddr, addrlen) -syscall sys_getsockname nr 204 nbargs 3 types: (int, struct sockaddr *, int *) args: (fd, usockaddr, usockaddr_len) -syscall sys_getpeername nr 205 nbargs 3 types: (int, struct sockaddr *, int *) args: (fd, usockaddr, usockaddr_len) -syscall sys_sendto nr 206 nbargs 6 types: (int, void *, size_t, unsigned int, struct sockaddr *, int) args: (fd, buff, len, flags, addr, addr_len) -syscall sys_recvfrom nr 207 nbargs 6 types: (int, void *, size_t, unsigned int, struct sockaddr *, int *) args: (fd, ubuf, size, flags, addr, addr_len) -syscall sys_setsockopt nr 208 nbargs 5 types: (int, int, int, char *, int) args: (fd, level, optname, optval, optlen) -syscall sys_getsockopt nr 209 nbargs 5 types: (int, int, int, char *, int *) args: (fd, level, optname, optval, optlen) -syscall sys_shutdown nr 210 nbargs 2 types: (int, int) args: (fd, how) -syscall sys_sendmsg nr 211 nbargs 3 types: (int, struct user_msghdr *, unsigned int) args: (fd, msg, flags) -syscall sys_recvmsg nr 212 nbargs 3 types: (int, struct user_msghdr *, unsigned int) args: (fd, msg, flags) -syscall sys_readahead nr 213 nbargs 3 types: (int, loff_t, size_t) args: (fd, offset, count) -syscall sys_brk nr 214 nbargs 1 types: (unsigned long) args: (brk) -syscall sys_munmap nr 215 nbargs 2 types: (unsigned long, size_t) args: (addr, len) -syscall sys_mremap nr 216 nbargs 5 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long) args: (addr, old_len, new_len, flags, new_addr) -syscall sys_add_key nr 217 nbargs 5 types: (const char *, const char *, const void *, size_t, key_serial_t) args: (_type, _description, _payload, plen, ringid) -syscall sys_request_key nr 218 nbargs 4 types: (const char *, const char *, const char *, key_serial_t) args: (_type, _description, _callout_info, destringid) -syscall sys_keyctl nr 219 nbargs 5 types: (int, unsigned long, unsigned long, unsigned long, unsigned long) args: (option, arg2, arg3, arg4, arg5) -syscall sys_execve nr 221 nbargs 3 types: (const char *, const char *const *, const char *const *) args: (filename, argv, envp) -syscall sys_fadvise64_64 nr 223 nbargs 4 types: (int, loff_t, loff_t, int) args: (fd, offset, len, advice) -syscall sys_swapon nr 224 nbargs 2 types: (const char *, int) args: (specialfile, swap_flags) -syscall sys_swapoff nr 225 nbargs 1 types: (const char *) args: (specialfile) -syscall sys_mprotect nr 226 nbargs 3 types: (unsigned long, size_t, unsigned long) args: (start, len, prot) -syscall sys_msync nr 227 nbargs 3 types: (unsigned long, size_t, int) args: (start, len, flags) -syscall sys_mlock nr 228 nbargs 2 types: (unsigned long, size_t) args: (start, len) -syscall sys_munlock nr 229 nbargs 2 types: (unsigned long, size_t) args: (start, len) -syscall sys_mlockall nr 230 nbargs 1 types: (int) args: (flags) -syscall sys_munlockall nr 231 nbargs 0 types: () args: () -syscall sys_mincore nr 232 nbargs 3 types: (unsigned long, size_t, unsigned char *) args: (start, len, vec) -syscall sys_madvise nr 233 nbargs 3 types: (unsigned long, size_t, int) args: (start, len_in, behavior) -syscall sys_remap_file_pages nr 234 nbargs 5 types: (unsigned long, unsigned long, unsigned long, unsigned long, unsigned long) args: (start, size, prot, pgoff, flags) -syscall sys_rt_tgsigqueueinfo nr 240 nbargs 4 types: (pid_t, pid_t, int, siginfo_t *) args: (tgid, pid, sig, uinfo) -syscall sys_perf_event_open nr 241 nbargs 5 types: (struct perf_event_attr *, pid_t, int, int, unsigned long) args: (attr_uptr, pid, cpu, group_fd, flags) -syscall sys_accept4 nr 242 nbargs 4 types: (int, struct sockaddr *, int *, int) args: (fd, upeer_sockaddr, upeer_addrlen, flags) -syscall sys_recvmmsg nr 243 nbargs 5 types: (int, struct mmsghdr *, unsigned int, unsigned int, struct timespec *) args: (fd, mmsg, vlen, flags, timeout) -syscall sys_wait4 nr 260 nbargs 4 types: (pid_t, int *, int, struct rusage *) args: (upid, stat_addr, options, ru) -syscall sys_prlimit64 nr 261 nbargs 4 types: (pid_t, unsigned int, const struct rlimit64 *, struct rlimit64 *) args: (pid, resource, new_rlim, old_rlim) -syscall sys_fanotify_init nr 262 nbargs 2 types: (unsigned int, unsigned int) args: (flags, event_f_flags) -syscall sys_fanotify_mark nr 263 nbargs 5 types: (int, unsigned int, __u64, int, const char *) args: (fanotify_fd, flags, mask, dfd, pathname) -syscall sys_name_to_handle_at nr 264 nbargs 5 types: (int, const char *, struct file_handle *, int *, int) args: (dfd, name, handle, mnt_id, flag) -syscall sys_open_by_handle_at nr 265 nbargs 3 types: (int, struct file_handle *, int) args: (mountdirfd, handle, flags) -syscall sys_clock_adjtime nr 266 nbargs 2 types: (const clockid_t, struct timex *) args: (which_clock, utx) -syscall sys_syncfs nr 267 nbargs 1 types: (int) args: (fd) -syscall sys_setns nr 268 nbargs 2 types: (int, int) args: (fd, nstype) -syscall sys_sendmmsg nr 269 nbargs 4 types: (int, struct mmsghdr *, unsigned int, unsigned int) args: (fd, mmsg, vlen, flags) -syscall sys_process_vm_readv nr 270 nbargs 6 types: (pid_t, const struct iovec *, unsigned long, const struct iovec *, unsigned long, unsigned long) args: (pid, lvec, liovcnt, rvec, riovcnt, flags) -syscall sys_process_vm_writev nr 271 nbargs 6 types: (pid_t, const struct iovec *, unsigned long, const struct iovec *, unsigned long, unsigned long) args: (pid, lvec, liovcnt, rvec, riovcnt, flags) -syscall sys_finit_module nr 273 nbargs 3 types: (int, const char *, int) args: (fd, uargs, flags) -syscall sys_sched_setattr nr 274 nbargs 3 types: (pid_t, struct sched_attr *, unsigned int) args: (pid, uattr, flags) -syscall sys_sched_getattr nr 275 nbargs 4 types: (pid_t, struct sched_attr *, unsigned int, unsigned int) args: (pid, uattr, size, flags) -syscall sys_renameat2 nr 276 nbargs 5 types: (int, const char *, int, const char *, unsigned int) args: (olddfd, oldname, newdfd, newname, flags) -syscall sys_seccomp nr 277 nbargs 3 types: (unsigned int, unsigned int, const char *) args: (op, flags, uargs) -syscall sys_getrandom nr 278 nbargs 3 types: (char *, size_t, unsigned int) args: (buf, count, flags) -syscall sys_memfd_create nr 279 nbargs 2 types: (const char *, unsigned int) args: (uname, flags) -syscall sys_execveat nr 281 nbargs 5 types: (int, const char *, const char *const *, const char *const *, int) args: (fd, filename, argv, envp, flags) -syscall sys_membarrier nr 283 nbargs 2 types: (int, int) args: (cmd, flags) -syscall sys_mlock2 nr 284 nbargs 3 types: (unsigned long, size_t, int) args: (start, len, flags) \ No newline at end of file diff --git a/instrumentation/syscalls/README b/instrumentation/syscalls/README deleted file mode 100644 index 6dbc640e..00000000 --- a/instrumentation/syscalls/README +++ /dev/null @@ -1,33 +0,0 @@ -LTTng system call tracing - -1) lttng-syscall-extractor - -You need to build a kernel with CONFIG_FTRACE_SYSCALLS=y and -CONFIG_KALLSYMS_ALL=y for extraction. Apply the linker patch to get your -kernel to keep the system call metadata after boot. Then build and load -the LTTng syscall extractor module. The module will fail to load (this -is expected). See the dmesg output for system call metadata. - -2) Generate system call TRACE_EVENT(). - -Take the dmesg data and feed it to lttng-syscalls-generate-headers.sh from -the instrumentation/syscalls directory. See the script header for usage -example. It should be run for both the integers and pointers types. - -After these are created, you just need to follow the new system call additions, -no need to regenerate the whole thing, since system calls are only appended to. - -3) Override headers - -You need to provide override headers (even if they don't contain -overrides) for each architecture. Those are meant to contain manual -overrides for specific system calls for cases where the script do not -generate the correct typing for specific system calls. - -4) Integrating the new architecture, updating architecture header - -Edit instrumentation/syscalls/headers/syscalls_integers.h and -syscalls_pointers.h. Add the new architecture -(e.g. CONFIG_X86_64) to the newly-generated headers -(e.g. changing the current x86-64-syscalls-3.10.0-rc7_.h into -x86-64-syscalls-3.13.7_.h), then rebuild lttng-modules. diff --git a/instrumentation/syscalls/headers/arm-32-syscalls_integers.h b/instrumentation/syscalls/headers/arm-32-syscalls_integers.h deleted file mode 100644 index 5d0e8709..00000000 --- a/instrumentation/syscalls/headers/arm-32-syscalls_integers.h +++ /dev/null @@ -1,1218 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ - -/* THIS FILE IS AUTO-GENERATED. DO NOT EDIT */ - -/* Generated from arm-32-syscalls 3.4.25 */ - -#ifndef CREATE_SYSCALL_TABLE - -#if !defined(_TRACE_SYSCALLS_INTEGERS_H) || defined(TRACE_HEADER_MULTI_READ) -#define _TRACE_SYSCALLS_INTEGERS_H - -#include -#include -#include "arm-32-syscalls_integers_override.h" -#include "syscalls_integers_override.h" - -#ifdef SC_ENTER -SC_LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(syscalls_noargs, - TP_FIELDS() -) -#ifndef OVERRIDE_32_restart_syscall -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, restart_syscall) -#endif -#ifndef OVERRIDE_32_getpid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getpid) -#endif -#ifndef OVERRIDE_32_getuid16 -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getuid16) -#endif -#ifndef OVERRIDE_32_pause -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, pause) -#endif -#ifndef OVERRIDE_32_sync -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, sync) -#endif -#ifndef OVERRIDE_32_getgid16 -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getgid16) -#endif -#ifndef OVERRIDE_32_geteuid16 -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, geteuid16) -#endif -#ifndef OVERRIDE_32_getegid16 -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getegid16) -#endif -#ifndef OVERRIDE_32_getppid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getppid) -#endif -#ifndef OVERRIDE_32_getpgrp -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getpgrp) -#endif -#ifndef OVERRIDE_32_setsid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, setsid) -#endif -#ifndef OVERRIDE_32_vhangup -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, vhangup) -#endif -#ifndef OVERRIDE_32_munlockall -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, munlockall) -#endif -#ifndef OVERRIDE_32_sched_yield -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, sched_yield) -#endif -#ifndef OVERRIDE_32_getuid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getuid) -#endif -#ifndef OVERRIDE_32_getgid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getgid) -#endif -#ifndef OVERRIDE_32_geteuid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, geteuid) -#endif -#ifndef OVERRIDE_32_getegid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getegid) -#endif -#ifndef OVERRIDE_32_gettid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, gettid) -#endif -#ifndef OVERRIDE_32_inotify_init -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, inotify_init) -#endif -#else /* #ifdef SC_ENTER */ -#ifndef OVERRIDE_32_restart_syscall -SC_LTTNG_TRACEPOINT_EVENT(restart_syscall, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_getpid -SC_LTTNG_TRACEPOINT_EVENT(getpid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_getuid16 -SC_LTTNG_TRACEPOINT_EVENT(getuid16, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_pause -SC_LTTNG_TRACEPOINT_EVENT(pause, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_sync -SC_LTTNG_TRACEPOINT_EVENT(sync, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_getgid16 -SC_LTTNG_TRACEPOINT_EVENT(getgid16, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_geteuid16 -SC_LTTNG_TRACEPOINT_EVENT(geteuid16, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_getegid16 -SC_LTTNG_TRACEPOINT_EVENT(getegid16, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_getppid -SC_LTTNG_TRACEPOINT_EVENT(getppid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_getpgrp -SC_LTTNG_TRACEPOINT_EVENT(getpgrp, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_setsid -SC_LTTNG_TRACEPOINT_EVENT(setsid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_vhangup -SC_LTTNG_TRACEPOINT_EVENT(vhangup, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_munlockall -SC_LTTNG_TRACEPOINT_EVENT(munlockall, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_sched_yield -SC_LTTNG_TRACEPOINT_EVENT(sched_yield, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_getuid -SC_LTTNG_TRACEPOINT_EVENT(getuid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_getgid -SC_LTTNG_TRACEPOINT_EVENT(getgid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_geteuid -SC_LTTNG_TRACEPOINT_EVENT(geteuid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_getegid -SC_LTTNG_TRACEPOINT_EVENT(getegid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_gettid -SC_LTTNG_TRACEPOINT_EVENT(gettid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_inotify_init -SC_LTTNG_TRACEPOINT_EVENT(inotify_init, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#endif /* else #ifdef SC_ENTER */ -#ifndef OVERRIDE_32_exit -SC_LTTNG_TRACEPOINT_EVENT(exit, - TP_PROTO(sc_exit(long ret,) int error_code), - TP_ARGS(sc_exit(ret,) error_code), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, error_code, error_code))) -) -#endif -#ifndef OVERRIDE_32_close -SC_LTTNG_TRACEPOINT_EVENT(close, - TP_PROTO(sc_exit(long ret,) unsigned int fd), - TP_ARGS(sc_exit(ret,) fd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) -) -#endif -#ifndef OVERRIDE_32_setuid16 -SC_LTTNG_TRACEPOINT_EVENT(setuid16, - TP_PROTO(sc_exit(long ret,) old_uid_t uid), - TP_ARGS(sc_exit(ret,) uid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(old_uid_t, uid, uid))) -) -#endif -#ifndef OVERRIDE_32_nice -SC_LTTNG_TRACEPOINT_EVENT(nice, - TP_PROTO(sc_exit(long ret,) int increment), - TP_ARGS(sc_exit(ret,) increment), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, increment, increment))) -) -#endif -#ifndef OVERRIDE_32_dup -SC_LTTNG_TRACEPOINT_EVENT(dup, - TP_PROTO(sc_exit(long ret,) unsigned int fildes), - TP_ARGS(sc_exit(ret,) fildes), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fildes, fildes))) -) -#endif -#ifndef OVERRIDE_32_brk -SC_LTTNG_TRACEPOINT_EVENT(brk, - TP_PROTO(sc_exit(long ret,) unsigned long brk), - TP_ARGS(sc_exit(ret,) brk), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, brk, brk))) -) -#endif -#ifndef OVERRIDE_32_setgid16 -SC_LTTNG_TRACEPOINT_EVENT(setgid16, - TP_PROTO(sc_exit(long ret,) old_gid_t gid), - TP_ARGS(sc_exit(ret,) gid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(old_gid_t, gid, gid))) -) -#endif -#ifndef OVERRIDE_32_umask -SC_LTTNG_TRACEPOINT_EVENT(umask, - TP_PROTO(sc_exit(long ret,) int mask), - TP_ARGS(sc_exit(ret,) mask), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, mask, mask))) -) -#endif -#ifndef OVERRIDE_32_fsync -SC_LTTNG_TRACEPOINT_EVENT(fsync, - TP_PROTO(sc_exit(long ret,) unsigned int fd), - TP_ARGS(sc_exit(ret,) fd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) -) -#endif -#ifndef OVERRIDE_32_getpgid -SC_LTTNG_TRACEPOINT_EVENT(getpgid, - TP_PROTO(sc_exit(long ret,) pid_t pid), - TP_ARGS(sc_exit(ret,) pid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid))) -) -#endif -#ifndef OVERRIDE_32_fchdir -SC_LTTNG_TRACEPOINT_EVENT(fchdir, - TP_PROTO(sc_exit(long ret,) unsigned int fd), - TP_ARGS(sc_exit(ret,) fd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) -) -#endif -#ifndef OVERRIDE_32_personality -SC_LTTNG_TRACEPOINT_EVENT(personality, - TP_PROTO(sc_exit(long ret,) unsigned int personality), - TP_ARGS(sc_exit(ret,) personality), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, personality, personality))) -) -#endif -#ifndef OVERRIDE_32_setfsuid16 -SC_LTTNG_TRACEPOINT_EVENT(setfsuid16, - TP_PROTO(sc_exit(long ret,) old_uid_t uid), - TP_ARGS(sc_exit(ret,) uid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(old_uid_t, uid, uid))) -) -#endif -#ifndef OVERRIDE_32_setfsgid16 -SC_LTTNG_TRACEPOINT_EVENT(setfsgid16, - TP_PROTO(sc_exit(long ret,) old_gid_t gid), - TP_ARGS(sc_exit(ret,) gid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(old_gid_t, gid, gid))) -) -#endif -#ifndef OVERRIDE_32_getsid -SC_LTTNG_TRACEPOINT_EVENT(getsid, - TP_PROTO(sc_exit(long ret,) pid_t pid), - TP_ARGS(sc_exit(ret,) pid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid))) -) -#endif -#ifndef OVERRIDE_32_fdatasync -SC_LTTNG_TRACEPOINT_EVENT(fdatasync, - TP_PROTO(sc_exit(long ret,) unsigned int fd), - TP_ARGS(sc_exit(ret,) fd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) -) -#endif -#ifndef OVERRIDE_32_mlockall -SC_LTTNG_TRACEPOINT_EVENT(mlockall, - TP_PROTO(sc_exit(long ret,) int flags), - TP_ARGS(sc_exit(ret,) flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_sched_getscheduler -SC_LTTNG_TRACEPOINT_EVENT(sched_getscheduler, - TP_PROTO(sc_exit(long ret,) pid_t pid), - TP_ARGS(sc_exit(ret,) pid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid))) -) -#endif -#ifndef OVERRIDE_32_sched_get_priority_max -SC_LTTNG_TRACEPOINT_EVENT(sched_get_priority_max, - TP_PROTO(sc_exit(long ret,) int policy), - TP_ARGS(sc_exit(ret,) policy), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, policy, policy))) -) -#endif -#ifndef OVERRIDE_32_sched_get_priority_min -SC_LTTNG_TRACEPOINT_EVENT(sched_get_priority_min, - TP_PROTO(sc_exit(long ret,) int policy), - TP_ARGS(sc_exit(ret,) policy), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, policy, policy))) -) -#endif -#ifndef OVERRIDE_32_setuid -SC_LTTNG_TRACEPOINT_EVENT(setuid, - TP_PROTO(sc_exit(long ret,) uid_t uid), - TP_ARGS(sc_exit(ret,) uid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, uid, uid))) -) -#endif -#ifndef OVERRIDE_32_setgid -SC_LTTNG_TRACEPOINT_EVENT(setgid, - TP_PROTO(sc_exit(long ret,) gid_t gid), - TP_ARGS(sc_exit(ret,) gid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, gid, gid))) -) -#endif -#ifndef OVERRIDE_32_setfsuid -SC_LTTNG_TRACEPOINT_EVENT(setfsuid, - TP_PROTO(sc_exit(long ret,) uid_t uid), - TP_ARGS(sc_exit(ret,) uid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, uid, uid))) -) -#endif -#ifndef OVERRIDE_32_setfsgid -SC_LTTNG_TRACEPOINT_EVENT(setfsgid, - TP_PROTO(sc_exit(long ret,) gid_t gid), - TP_ARGS(sc_exit(ret,) gid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, gid, gid))) -) -#endif -#ifndef OVERRIDE_32_io_destroy -SC_LTTNG_TRACEPOINT_EVENT(io_destroy, - TP_PROTO(sc_exit(long ret,) aio_context_t ctx), - TP_ARGS(sc_exit(ret,) ctx), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx, ctx))) -) -#endif -#ifndef OVERRIDE_32_exit_group -SC_LTTNG_TRACEPOINT_EVENT(exit_group, - TP_PROTO(sc_exit(long ret,) int error_code), - TP_ARGS(sc_exit(ret,) error_code), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, error_code, error_code))) -) -#endif -#ifndef OVERRIDE_32_epoll_create -SC_LTTNG_TRACEPOINT_EVENT(epoll_create, - TP_PROTO(sc_exit(long ret,) int size), - TP_ARGS(sc_exit(ret,) size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, size, size))) -) -#endif -#ifndef OVERRIDE_32_timer_getoverrun -SC_LTTNG_TRACEPOINT_EVENT(timer_getoverrun, - TP_PROTO(sc_exit(long ret,) timer_t timer_id), - TP_ARGS(sc_exit(ret,) timer_id), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id))) -) -#endif -#ifndef OVERRIDE_32_timer_delete -SC_LTTNG_TRACEPOINT_EVENT(timer_delete, - TP_PROTO(sc_exit(long ret,) timer_t timer_id), - TP_ARGS(sc_exit(ret,) timer_id), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id))) -) -#endif -#ifndef OVERRIDE_32_unshare -SC_LTTNG_TRACEPOINT_EVENT(unshare, - TP_PROTO(sc_exit(long ret,) unsigned long unshare_flags), - TP_ARGS(sc_exit(ret,) unshare_flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, unshare_flags, unshare_flags))) -) -#endif -#ifndef OVERRIDE_32_eventfd -SC_LTTNG_TRACEPOINT_EVENT(eventfd, - TP_PROTO(sc_exit(long ret,) unsigned int count), - TP_ARGS(sc_exit(ret,) count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, count, count))) -) -#endif -#ifndef OVERRIDE_32_epoll_create1 -SC_LTTNG_TRACEPOINT_EVENT(epoll_create1, - TP_PROTO(sc_exit(long ret,) int flags), - TP_ARGS(sc_exit(ret,) flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_inotify_init1 -SC_LTTNG_TRACEPOINT_EVENT(inotify_init1, - TP_PROTO(sc_exit(long ret,) int flags), - TP_ARGS(sc_exit(ret,) flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_syncfs -SC_LTTNG_TRACEPOINT_EVENT(syncfs, - TP_PROTO(sc_exit(long ret,) int fd), - TP_ARGS(sc_exit(ret,) fd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd))) -) -#endif -#ifndef OVERRIDE_32_kill -SC_LTTNG_TRACEPOINT_EVENT(kill, - TP_PROTO(sc_exit(long ret,) pid_t pid, int sig), - TP_ARGS(sc_exit(ret,) pid, sig), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig))) -) -#endif -#ifndef OVERRIDE_32_setpgid -SC_LTTNG_TRACEPOINT_EVENT(setpgid, - TP_PROTO(sc_exit(long ret,) pid_t pid, pid_t pgid), - TP_ARGS(sc_exit(ret,) pid, pgid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(pid_t, pgid, pgid))) -) -#endif -#ifndef OVERRIDE_32_dup2 -SC_LTTNG_TRACEPOINT_EVENT(dup2, - TP_PROTO(sc_exit(long ret,) unsigned int oldfd, unsigned int newfd), - TP_ARGS(sc_exit(ret,) oldfd, newfd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, oldfd, oldfd)) sc_in(ctf_integer(unsigned int, newfd, newfd))) -) -#endif -#ifndef OVERRIDE_32_setreuid16 -SC_LTTNG_TRACEPOINT_EVENT(setreuid16, - TP_PROTO(sc_exit(long ret,) old_uid_t ruid, old_uid_t euid), - TP_ARGS(sc_exit(ret,) ruid, euid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(old_uid_t, ruid, ruid)) sc_inout(ctf_integer(old_uid_t, euid, euid))) -) -#endif -#ifndef OVERRIDE_32_setregid16 -SC_LTTNG_TRACEPOINT_EVENT(setregid16, - TP_PROTO(sc_exit(long ret,) old_gid_t rgid, old_gid_t egid), - TP_ARGS(sc_exit(ret,) rgid, egid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(old_gid_t, rgid, rgid)) sc_inout(ctf_integer(old_gid_t, egid, egid))) -) -#endif -#ifndef OVERRIDE_32_munmap -SC_LTTNG_TRACEPOINT_EVENT(munmap, - TP_PROTO(sc_exit(long ret,) unsigned long addr, size_t len), - TP_ARGS(sc_exit(ret,) addr, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, addr, addr)) sc_in(ctf_integer(size_t, len, len))) -) -#endif -#ifndef OVERRIDE_32_ftruncate -SC_LTTNG_TRACEPOINT_EVENT(ftruncate, - TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned long length), - TP_ARGS(sc_exit(ret,) fd, length), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned long, length, length))) -) -#endif -#ifndef OVERRIDE_32_fchmod -SC_LTTNG_TRACEPOINT_EVENT(fchmod, - TP_PROTO(sc_exit(long ret,) unsigned int fd, umode_t mode), - TP_ARGS(sc_exit(ret,) fd, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(umode_t, mode, mode))) -) -#endif -#ifndef OVERRIDE_32_getpriority -SC_LTTNG_TRACEPOINT_EVENT(getpriority, - TP_PROTO(sc_exit(long ret,) int which, int who), - TP_ARGS(sc_exit(ret,) which, who), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who))) -) -#endif -#ifndef OVERRIDE_32_bdflush -SC_LTTNG_TRACEPOINT_EVENT(bdflush, - TP_PROTO(sc_exit(long ret,) int func, long data), - TP_ARGS(sc_exit(ret,) func, data), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, func, func)) sc_inout(ctf_integer(long, data, data))) -) -#endif -#ifndef OVERRIDE_32_flock -SC_LTTNG_TRACEPOINT_EVENT(flock, - TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd), - TP_ARGS(sc_exit(ret,) fd, cmd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned int, cmd, cmd))) -) -#endif -#ifndef OVERRIDE_32_mlock -SC_LTTNG_TRACEPOINT_EVENT(mlock, - TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len), - TP_ARGS(sc_exit(ret,) start, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len))) -) -#endif -#ifndef OVERRIDE_32_munlock -SC_LTTNG_TRACEPOINT_EVENT(munlock, - TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len), - TP_ARGS(sc_exit(ret,) start, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len))) -) -#endif -#ifndef OVERRIDE_32_setreuid -SC_LTTNG_TRACEPOINT_EVENT(setreuid, - TP_PROTO(sc_exit(long ret,) uid_t ruid, uid_t euid), - TP_ARGS(sc_exit(ret,) ruid, euid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, ruid, ruid)) sc_in(ctf_integer(uid_t, euid, euid))) -) -#endif -#ifndef OVERRIDE_32_setregid -SC_LTTNG_TRACEPOINT_EVENT(setregid, - TP_PROTO(sc_exit(long ret,) gid_t rgid, gid_t egid), - TP_ARGS(sc_exit(ret,) rgid, egid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, rgid, rgid)) sc_in(ctf_integer(gid_t, egid, egid))) -) -#endif -#ifndef OVERRIDE_32_tkill -SC_LTTNG_TRACEPOINT_EVENT(tkill, - TP_PROTO(sc_exit(long ret,) pid_t pid, int sig), - TP_ARGS(sc_exit(ret,) pid, sig), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig))) -) -#endif -#ifndef OVERRIDE_32_listen -SC_LTTNG_TRACEPOINT_EVENT(listen, - TP_PROTO(sc_exit(long ret,) int fd, int backlog), - TP_ARGS(sc_exit(ret,) fd, backlog), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, backlog, backlog))) -) -#endif -#ifndef OVERRIDE_32_shutdown -SC_LTTNG_TRACEPOINT_EVENT(shutdown, - TP_PROTO(sc_exit(long ret,) int fd, int how), - TP_ARGS(sc_exit(ret,) fd, how), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, how, how))) -) -#endif -#ifndef OVERRIDE_32_msgget -SC_LTTNG_TRACEPOINT_EVENT(msgget, - TP_PROTO(sc_exit(long ret,) key_t key, int msgflg), - TP_ARGS(sc_exit(ret,) key, msgflg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(key_t, key, key)) sc_in(ctf_integer(int, msgflg, msgflg))) -) -#endif -#ifndef OVERRIDE_32_ioprio_get -SC_LTTNG_TRACEPOINT_EVENT(ioprio_get, - TP_PROTO(sc_exit(long ret,) int which, int who), - TP_ARGS(sc_exit(ret,) which, who), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who))) -) -#endif -#ifndef OVERRIDE_32_inotify_rm_watch -SC_LTTNG_TRACEPOINT_EVENT(inotify_rm_watch, - TP_PROTO(sc_exit(long ret,) int fd, __s32 wd), - TP_ARGS(sc_exit(ret,) fd, wd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(__s32, wd, wd))) -) -#endif -#ifndef OVERRIDE_32_timerfd_create -SC_LTTNG_TRACEPOINT_EVENT(timerfd_create, - TP_PROTO(sc_exit(long ret,) int clockid, int flags), - TP_ARGS(sc_exit(ret,) clockid, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, clockid, clockid)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_eventfd2 -SC_LTTNG_TRACEPOINT_EVENT(eventfd2, - TP_PROTO(sc_exit(long ret,) unsigned int count, int flags), - TP_ARGS(sc_exit(ret,) count, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, count, count)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_fanotify_init -SC_LTTNG_TRACEPOINT_EVENT(fanotify_init, - TP_PROTO(sc_exit(long ret,) unsigned int flags, unsigned int event_f_flags), - TP_ARGS(sc_exit(ret,) flags, event_f_flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, flags, flags)) sc_in(ctf_integer(unsigned int, event_f_flags, event_f_flags))) -) -#endif -#ifndef OVERRIDE_32_setns -SC_LTTNG_TRACEPOINT_EVENT(setns, - TP_PROTO(sc_exit(long ret,) int fd, int nstype), - TP_ARGS(sc_exit(ret,) fd, nstype), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, nstype, nstype))) -) -#endif -#ifndef OVERRIDE_32_lseek -SC_LTTNG_TRACEPOINT_EVENT(lseek, - TP_PROTO(sc_exit(long ret,) unsigned int fd, off_t offset, unsigned int origin), - TP_ARGS(sc_exit(ret,) fd, offset, origin), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(off_t, offset, offset)) sc_in(ctf_integer(unsigned int, origin, origin))) -) -#endif -#ifndef OVERRIDE_32_ioctl -SC_LTTNG_TRACEPOINT_EVENT(ioctl, - TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd, unsigned long arg), - TP_ARGS(sc_exit(ret,) fd, cmd, arg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_inout(ctf_integer(unsigned long, arg, arg))) -) -#endif -#ifndef OVERRIDE_32_fcntl -SC_LTTNG_TRACEPOINT_EVENT(fcntl, - TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd, unsigned long arg), - TP_ARGS(sc_exit(ret,) fd, cmd, arg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_inout(ctf_integer(unsigned long, arg, arg))) -) -#endif -#ifndef OVERRIDE_32_fchown16 -SC_LTTNG_TRACEPOINT_EVENT(fchown16, - TP_PROTO(sc_exit(long ret,) unsigned int fd, old_uid_t user, old_gid_t group), - TP_ARGS(sc_exit(ret,) fd, user, group), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, fd, fd)) sc_inout(ctf_integer(old_uid_t, user, user)) sc_inout(ctf_integer(old_gid_t, group, group))) -) -#endif -#ifndef OVERRIDE_32_setpriority -SC_LTTNG_TRACEPOINT_EVENT(setpriority, - TP_PROTO(sc_exit(long ret,) int which, int who, int niceval), - TP_ARGS(sc_exit(ret,) which, who, niceval), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who)) sc_in(ctf_integer(int, niceval, niceval))) -) -#endif -#ifndef OVERRIDE_32_mprotect -SC_LTTNG_TRACEPOINT_EVENT(mprotect, - TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len, unsigned long prot), - TP_ARGS(sc_exit(ret,) start, len, prot), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned long, prot, prot))) -) -#endif -#ifndef OVERRIDE_32_sysfs -SC_LTTNG_TRACEPOINT_EVENT(sysfs, - TP_PROTO(sc_exit(long ret,) int option, unsigned long arg1, unsigned long arg2), - TP_ARGS(sc_exit(ret,) option, arg1, arg2), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, option, option)) sc_in(ctf_integer(unsigned long, arg1, arg1)) sc_in(ctf_integer(unsigned long, arg2, arg2))) -) -#endif -#ifndef OVERRIDE_32_msync -SC_LTTNG_TRACEPOINT_EVENT(msync, - TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len, int flags), - TP_ARGS(sc_exit(ret,) start, len, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_setresuid16 -SC_LTTNG_TRACEPOINT_EVENT(setresuid16, - TP_PROTO(sc_exit(long ret,) old_uid_t ruid, old_uid_t euid, old_uid_t suid), - TP_ARGS(sc_exit(ret,) ruid, euid, suid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(old_uid_t, ruid, ruid)) sc_inout(ctf_integer(old_uid_t, euid, euid)) sc_inout(ctf_integer(old_uid_t, suid, suid))) -) -#endif -#ifndef OVERRIDE_32_setresgid16 -SC_LTTNG_TRACEPOINT_EVENT(setresgid16, - TP_PROTO(sc_exit(long ret,) old_gid_t rgid, old_gid_t egid, old_gid_t sgid), - TP_ARGS(sc_exit(ret,) rgid, egid, sgid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(old_gid_t, rgid, rgid)) sc_inout(ctf_integer(old_gid_t, egid, egid)) sc_inout(ctf_integer(old_gid_t, sgid, sgid))) -) -#endif -#ifndef OVERRIDE_32_fchown -SC_LTTNG_TRACEPOINT_EVENT(fchown, - TP_PROTO(sc_exit(long ret,) unsigned int fd, uid_t user, gid_t group), - TP_ARGS(sc_exit(ret,) fd, user, group), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group))) -) -#endif -#ifndef OVERRIDE_32_setresuid -SC_LTTNG_TRACEPOINT_EVENT(setresuid, - TP_PROTO(sc_exit(long ret,) uid_t ruid, uid_t euid, uid_t suid), - TP_ARGS(sc_exit(ret,) ruid, euid, suid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, ruid, ruid)) sc_in(ctf_integer(uid_t, euid, euid)) sc_in(ctf_integer(uid_t, suid, suid))) -) -#endif -#ifndef OVERRIDE_32_setresgid -SC_LTTNG_TRACEPOINT_EVENT(setresgid, - TP_PROTO(sc_exit(long ret,) gid_t rgid, gid_t egid, gid_t sgid), - TP_ARGS(sc_exit(ret,) rgid, egid, sgid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, rgid, rgid)) sc_in(ctf_integer(gid_t, egid, egid)) sc_in(ctf_integer(gid_t, sgid, sgid))) -) -#endif -#ifndef OVERRIDE_32_madvise -SC_LTTNG_TRACEPOINT_EVENT(madvise, - TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len_in, int behavior), - TP_ARGS(sc_exit(ret,) start, len_in, behavior), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len_in, len_in)) sc_in(ctf_integer(int, behavior, behavior))) -) -#endif -#ifndef OVERRIDE_32_fcntl64 -SC_LTTNG_TRACEPOINT_EVENT(fcntl64, - TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd, unsigned long arg), - TP_ARGS(sc_exit(ret,) fd, cmd, arg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, fd, fd)) sc_inout(ctf_integer(unsigned int, cmd, cmd)) sc_inout(ctf_integer(unsigned long, arg, arg))) -) -#endif -#ifndef OVERRIDE_32_tgkill -SC_LTTNG_TRACEPOINT_EVENT(tgkill, - TP_PROTO(sc_exit(long ret,) pid_t tgid, pid_t pid, int sig), - TP_ARGS(sc_exit(ret,) tgid, pid, sig), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, tgid, tgid)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig))) -) -#endif -#ifndef OVERRIDE_32_socket -SC_LTTNG_TRACEPOINT_EVENT(socket, - TP_PROTO(sc_exit(long ret,) int family, int type, int protocol), - TP_ARGS(sc_exit(ret,) family, type, protocol), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, family, family)) sc_in(ctf_integer(int, type, type)) sc_in(ctf_integer(int, protocol, protocol))) -) -#endif -#ifndef OVERRIDE_32_semget -SC_LTTNG_TRACEPOINT_EVENT(semget, - TP_PROTO(sc_exit(long ret,) key_t key, int nsems, int semflg), - TP_ARGS(sc_exit(ret,) key, nsems, semflg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(key_t, key, key)) sc_in(ctf_integer(int, nsems, nsems)) sc_in(ctf_integer(int, semflg, semflg))) -) -#endif -#ifndef OVERRIDE_32_shmget -SC_LTTNG_TRACEPOINT_EVENT(shmget, - TP_PROTO(sc_exit(long ret,) key_t key, size_t size, int shmflg), - TP_ARGS(sc_exit(ret,) key, size, shmflg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(key_t, key, key)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(int, shmflg, shmflg))) -) -#endif -#ifndef OVERRIDE_32_ioprio_set -SC_LTTNG_TRACEPOINT_EVENT(ioprio_set, - TP_PROTO(sc_exit(long ret,) int which, int who, int ioprio), - TP_ARGS(sc_exit(ret,) which, who, ioprio), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who)) sc_in(ctf_integer(int, ioprio, ioprio))) -) -#endif -#ifndef OVERRIDE_32_dup3 -SC_LTTNG_TRACEPOINT_EVENT(dup3, - TP_PROTO(sc_exit(long ret,) unsigned int oldfd, unsigned int newfd, int flags), - TP_ARGS(sc_exit(ret,) oldfd, newfd, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, oldfd, oldfd)) sc_in(ctf_integer(unsigned int, newfd, newfd)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_ptrace -SC_LTTNG_TRACEPOINT_EVENT(ptrace, - TP_PROTO(sc_exit(long ret,) long request, long pid, unsigned long addr, unsigned long data), - TP_ARGS(sc_exit(ret,) request, pid, addr, data), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(long, request, request)) sc_in(ctf_integer(long, pid, pid)) sc_inout(ctf_integer(unsigned long, addr, addr)) sc_inout(ctf_integer(unsigned long, data, data))) -) -#endif -#ifndef OVERRIDE_32_tee -SC_LTTNG_TRACEPOINT_EVENT(tee, - TP_PROTO(sc_exit(long ret,) int fdin, int fdout, size_t len, unsigned int flags), - TP_ARGS(sc_exit(ret,) fdin, fdout, len, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fdin, fdin)) sc_in(ctf_integer(int, fdout, fdout)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_mremap -SC_LTTNG_TRACEPOINT_EVENT(mremap, - TP_PROTO(sc_exit(long ret,) unsigned long addr, unsigned long old_len, unsigned long new_len, unsigned long flags, unsigned long new_addr), - TP_ARGS(sc_exit(ret,) addr, old_len, new_len, flags, new_addr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, addr, addr)) sc_in(ctf_integer(unsigned long, old_len, old_len)) sc_in(ctf_integer(unsigned long, new_len, new_len)) sc_in(ctf_integer(unsigned long, flags, flags)) sc_in(ctf_integer(unsigned long, new_addr, new_addr))) -) -#endif -#ifndef OVERRIDE_32_prctl -SC_LTTNG_TRACEPOINT_EVENT(prctl, - TP_PROTO(sc_exit(long ret,) int option, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5), - TP_ARGS(sc_exit(ret,) option, arg2, arg3, arg4, arg5), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, option, option)) sc_inout(ctf_integer(unsigned long, arg2, arg2)) sc_in(ctf_integer(unsigned long, arg3, arg3)) sc_in(ctf_integer(unsigned long, arg4, arg4)) sc_in(ctf_integer(unsigned long, arg5, arg5))) -) -#endif -#ifndef OVERRIDE_32_remap_file_pages -SC_LTTNG_TRACEPOINT_EVENT(remap_file_pages, - TP_PROTO(sc_exit(long ret,) unsigned long start, unsigned long size, unsigned long prot, unsigned long pgoff, unsigned long flags), - TP_ARGS(sc_exit(ret,) start, size, prot, pgoff, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(unsigned long, size, size)) sc_in(ctf_integer(unsigned long, prot, prot)) sc_in(ctf_integer(unsigned long, pgoff, pgoff)) sc_in(ctf_integer(unsigned long, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_keyctl -SC_LTTNG_TRACEPOINT_EVENT(keyctl, - TP_PROTO(sc_exit(long ret,) int option, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5), - TP_ARGS(sc_exit(ret,) option, arg2, arg3, arg4, arg5), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, option, option)) sc_inout(ctf_integer(unsigned long, arg2, arg2)) sc_inout(ctf_integer(unsigned long, arg3, arg3)) sc_inout(ctf_integer(unsigned long, arg4, arg4)) sc_inout(ctf_integer(unsigned long, arg5, arg5))) -) -#endif - -#endif /* _TRACE_SYSCALLS_INTEGERS_H */ - -/* This part must be outside protection */ -#include - -#else /* CREATE_SYSCALL_TABLE */ - -#include "arm-32-syscalls_integers_override.h" -#include "syscalls_integers_override.h" - -#ifdef SC_ENTER -#ifndef OVERRIDE_TABLE_32_restart_syscall -TRACE_SYSCALL_TABLE(syscalls_noargs, restart_syscall, 0, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getpid -TRACE_SYSCALL_TABLE(syscalls_noargs, getpid, 20, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getuid16 -TRACE_SYSCALL_TABLE(syscalls_noargs, getuid16, 24, 0) -#endif -#ifndef OVERRIDE_TABLE_32_pause -TRACE_SYSCALL_TABLE(syscalls_noargs, pause, 29, 0) -#endif -#ifndef OVERRIDE_TABLE_32_sync -TRACE_SYSCALL_TABLE(syscalls_noargs, sync, 36, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getgid16 -TRACE_SYSCALL_TABLE(syscalls_noargs, getgid16, 47, 0) -#endif -#ifndef OVERRIDE_TABLE_32_geteuid16 -TRACE_SYSCALL_TABLE(syscalls_noargs, geteuid16, 49, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getegid16 -TRACE_SYSCALL_TABLE(syscalls_noargs, getegid16, 50, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getppid -TRACE_SYSCALL_TABLE(syscalls_noargs, getppid, 64, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getpgrp -TRACE_SYSCALL_TABLE(syscalls_noargs, getpgrp, 65, 0) -#endif -#ifndef OVERRIDE_TABLE_32_setsid -TRACE_SYSCALL_TABLE(syscalls_noargs, setsid, 66, 0) -#endif -#ifndef OVERRIDE_TABLE_32_vhangup -TRACE_SYSCALL_TABLE(syscalls_noargs, vhangup, 111, 0) -#endif -#ifndef OVERRIDE_TABLE_32_munlockall -TRACE_SYSCALL_TABLE(syscalls_noargs, munlockall, 153, 0) -#endif -#ifndef OVERRIDE_TABLE_32_sched_yield -TRACE_SYSCALL_TABLE(syscalls_noargs, sched_yield, 158, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getuid -TRACE_SYSCALL_TABLE(syscalls_noargs, getuid, 199, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getgid -TRACE_SYSCALL_TABLE(syscalls_noargs, getgid, 200, 0) -#endif -#ifndef OVERRIDE_TABLE_32_geteuid -TRACE_SYSCALL_TABLE(syscalls_noargs, geteuid, 201, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getegid -TRACE_SYSCALL_TABLE(syscalls_noargs, getegid, 202, 0) -#endif -#ifndef OVERRIDE_TABLE_32_gettid -TRACE_SYSCALL_TABLE(syscalls_noargs, gettid, 224, 0) -#endif -#ifndef OVERRIDE_TABLE_32_inotify_init -TRACE_SYSCALL_TABLE(syscalls_noargs, inotify_init, 316, 0) -#endif -#else /* #ifdef SC_ENTER */ -#ifndef OVERRIDE_TABLE_32_restart_syscall -TRACE_SYSCALL_TABLE(restart_syscall, restart_syscall, 0, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getpid -TRACE_SYSCALL_TABLE(getpid, getpid, 20, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getuid16 -TRACE_SYSCALL_TABLE(getuid16, getuid16, 24, 0) -#endif -#ifndef OVERRIDE_TABLE_32_pause -TRACE_SYSCALL_TABLE(pause, pause, 29, 0) -#endif -#ifndef OVERRIDE_TABLE_32_sync -TRACE_SYSCALL_TABLE(sync, sync, 36, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getgid16 -TRACE_SYSCALL_TABLE(getgid16, getgid16, 47, 0) -#endif -#ifndef OVERRIDE_TABLE_32_geteuid16 -TRACE_SYSCALL_TABLE(geteuid16, geteuid16, 49, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getegid16 -TRACE_SYSCALL_TABLE(getegid16, getegid16, 50, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getppid -TRACE_SYSCALL_TABLE(getppid, getppid, 64, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getpgrp -TRACE_SYSCALL_TABLE(getpgrp, getpgrp, 65, 0) -#endif -#ifndef OVERRIDE_TABLE_32_setsid -TRACE_SYSCALL_TABLE(setsid, setsid, 66, 0) -#endif -#ifndef OVERRIDE_TABLE_32_vhangup -TRACE_SYSCALL_TABLE(vhangup, vhangup, 111, 0) -#endif -#ifndef OVERRIDE_TABLE_32_munlockall -TRACE_SYSCALL_TABLE(munlockall, munlockall, 153, 0) -#endif -#ifndef OVERRIDE_TABLE_32_sched_yield -TRACE_SYSCALL_TABLE(sched_yield, sched_yield, 158, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getuid -TRACE_SYSCALL_TABLE(getuid, getuid, 199, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getgid -TRACE_SYSCALL_TABLE(getgid, getgid, 200, 0) -#endif -#ifndef OVERRIDE_TABLE_32_geteuid -TRACE_SYSCALL_TABLE(geteuid, geteuid, 201, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getegid -TRACE_SYSCALL_TABLE(getegid, getegid, 202, 0) -#endif -#ifndef OVERRIDE_TABLE_32_gettid -TRACE_SYSCALL_TABLE(gettid, gettid, 224, 0) -#endif -#ifndef OVERRIDE_TABLE_32_inotify_init -TRACE_SYSCALL_TABLE(inotify_init, inotify_init, 316, 0) -#endif -#endif /* else #ifdef SC_ENTER */ -#ifndef OVERRIDE_TABLE_32_exit -TRACE_SYSCALL_TABLE(exit, exit, 1, 1) -#endif -#ifndef OVERRIDE_TABLE_32_close -TRACE_SYSCALL_TABLE(close, close, 6, 1) -#endif -#ifndef OVERRIDE_TABLE_32_lseek -TRACE_SYSCALL_TABLE(lseek, lseek, 19, 3) -#endif -#ifndef OVERRIDE_TABLE_32_setuid16 -TRACE_SYSCALL_TABLE(setuid16, setuid16, 23, 1) -#endif -#ifndef OVERRIDE_TABLE_32_ptrace -TRACE_SYSCALL_TABLE(ptrace, ptrace, 26, 4) -#endif -#ifndef OVERRIDE_TABLE_32_nice -TRACE_SYSCALL_TABLE(nice, nice, 34, 1) -#endif -#ifndef OVERRIDE_TABLE_32_kill -TRACE_SYSCALL_TABLE(kill, kill, 37, 2) -#endif -#ifndef OVERRIDE_TABLE_32_dup -TRACE_SYSCALL_TABLE(dup, dup, 41, 1) -#endif -#ifndef OVERRIDE_TABLE_32_brk -TRACE_SYSCALL_TABLE(brk, brk, 45, 1) -#endif -#ifndef OVERRIDE_TABLE_32_setgid16 -TRACE_SYSCALL_TABLE(setgid16, setgid16, 46, 1) -#endif -#ifndef OVERRIDE_TABLE_32_ioctl -TRACE_SYSCALL_TABLE(ioctl, ioctl, 54, 3) -#endif -#ifndef OVERRIDE_TABLE_32_fcntl -TRACE_SYSCALL_TABLE(fcntl, fcntl, 55, 3) -#endif -#ifndef OVERRIDE_TABLE_32_setpgid -TRACE_SYSCALL_TABLE(setpgid, setpgid, 57, 2) -#endif -#ifndef OVERRIDE_TABLE_32_umask -TRACE_SYSCALL_TABLE(umask, umask, 60, 1) -#endif -#ifndef OVERRIDE_TABLE_32_dup2 -TRACE_SYSCALL_TABLE(dup2, dup2, 63, 2) -#endif -#ifndef OVERRIDE_TABLE_32_setreuid16 -TRACE_SYSCALL_TABLE(setreuid16, setreuid16, 70, 2) -#endif -#ifndef OVERRIDE_TABLE_32_setregid16 -TRACE_SYSCALL_TABLE(setregid16, setregid16, 71, 2) -#endif -#ifndef OVERRIDE_TABLE_32_munmap -TRACE_SYSCALL_TABLE(munmap, munmap, 91, 2) -#endif -#ifndef OVERRIDE_TABLE_32_ftruncate -TRACE_SYSCALL_TABLE(ftruncate, ftruncate, 93, 2) -#endif -#ifndef OVERRIDE_TABLE_32_fchmod -TRACE_SYSCALL_TABLE(fchmod, fchmod, 94, 2) -#endif -#ifndef OVERRIDE_TABLE_32_fchown16 -TRACE_SYSCALL_TABLE(fchown16, fchown16, 95, 3) -#endif -#ifndef OVERRIDE_TABLE_32_getpriority -TRACE_SYSCALL_TABLE(getpriority, getpriority, 96, 2) -#endif -#ifndef OVERRIDE_TABLE_32_setpriority -TRACE_SYSCALL_TABLE(setpriority, setpriority, 97, 3) -#endif -#ifndef OVERRIDE_TABLE_32_fsync -TRACE_SYSCALL_TABLE(fsync, fsync, 118, 1) -#endif -#ifndef OVERRIDE_TABLE_32_mprotect -TRACE_SYSCALL_TABLE(mprotect, mprotect, 125, 3) -#endif -#ifndef OVERRIDE_TABLE_32_getpgid -TRACE_SYSCALL_TABLE(getpgid, getpgid, 132, 1) -#endif -#ifndef OVERRIDE_TABLE_32_fchdir -TRACE_SYSCALL_TABLE(fchdir, fchdir, 133, 1) -#endif -#ifndef OVERRIDE_TABLE_32_bdflush -TRACE_SYSCALL_TABLE(bdflush, bdflush, 134, 2) -#endif -#ifndef OVERRIDE_TABLE_32_sysfs -TRACE_SYSCALL_TABLE(sysfs, sysfs, 135, 3) -#endif -#ifndef OVERRIDE_TABLE_32_personality -TRACE_SYSCALL_TABLE(personality, personality, 136, 1) -#endif -#ifndef OVERRIDE_TABLE_32_setfsuid16 -TRACE_SYSCALL_TABLE(setfsuid16, setfsuid16, 138, 1) -#endif -#ifndef OVERRIDE_TABLE_32_setfsgid16 -TRACE_SYSCALL_TABLE(setfsgid16, setfsgid16, 139, 1) -#endif -#ifndef OVERRIDE_TABLE_32_flock -TRACE_SYSCALL_TABLE(flock, flock, 143, 2) -#endif -#ifndef OVERRIDE_TABLE_32_msync -TRACE_SYSCALL_TABLE(msync, msync, 144, 3) -#endif -#ifndef OVERRIDE_TABLE_32_getsid -TRACE_SYSCALL_TABLE(getsid, getsid, 147, 1) -#endif -#ifndef OVERRIDE_TABLE_32_fdatasync -TRACE_SYSCALL_TABLE(fdatasync, fdatasync, 148, 1) -#endif -#ifndef OVERRIDE_TABLE_32_mlock -TRACE_SYSCALL_TABLE(mlock, mlock, 150, 2) -#endif -#ifndef OVERRIDE_TABLE_32_munlock -TRACE_SYSCALL_TABLE(munlock, munlock, 151, 2) -#endif -#ifndef OVERRIDE_TABLE_32_mlockall -TRACE_SYSCALL_TABLE(mlockall, mlockall, 152, 1) -#endif -#ifndef OVERRIDE_TABLE_32_sched_getscheduler -TRACE_SYSCALL_TABLE(sched_getscheduler, sched_getscheduler, 157, 1) -#endif -#ifndef OVERRIDE_TABLE_32_sched_get_priority_max -TRACE_SYSCALL_TABLE(sched_get_priority_max, sched_get_priority_max, 159, 1) -#endif -#ifndef OVERRIDE_TABLE_32_sched_get_priority_min -TRACE_SYSCALL_TABLE(sched_get_priority_min, sched_get_priority_min, 160, 1) -#endif -#ifndef OVERRIDE_TABLE_32_mremap -TRACE_SYSCALL_TABLE(mremap, mremap, 163, 5) -#endif -#ifndef OVERRIDE_TABLE_32_setresuid16 -TRACE_SYSCALL_TABLE(setresuid16, setresuid16, 164, 3) -#endif -#ifndef OVERRIDE_TABLE_32_setresgid16 -TRACE_SYSCALL_TABLE(setresgid16, setresgid16, 170, 3) -#endif -#ifndef OVERRIDE_TABLE_32_prctl -TRACE_SYSCALL_TABLE(prctl, prctl, 172, 5) -#endif -#ifndef OVERRIDE_TABLE_32_setreuid -TRACE_SYSCALL_TABLE(setreuid, setreuid, 203, 2) -#endif -#ifndef OVERRIDE_TABLE_32_setregid -TRACE_SYSCALL_TABLE(setregid, setregid, 204, 2) -#endif -#ifndef OVERRIDE_TABLE_32_fchown -TRACE_SYSCALL_TABLE(fchown, fchown, 207, 3) -#endif -#ifndef OVERRIDE_TABLE_32_setresuid -TRACE_SYSCALL_TABLE(setresuid, setresuid, 208, 3) -#endif -#ifndef OVERRIDE_TABLE_32_setresgid -TRACE_SYSCALL_TABLE(setresgid, setresgid, 210, 3) -#endif -#ifndef OVERRIDE_TABLE_32_setuid -TRACE_SYSCALL_TABLE(setuid, setuid, 213, 1) -#endif -#ifndef OVERRIDE_TABLE_32_setgid -TRACE_SYSCALL_TABLE(setgid, setgid, 214, 1) -#endif -#ifndef OVERRIDE_TABLE_32_setfsuid -TRACE_SYSCALL_TABLE(setfsuid, setfsuid, 215, 1) -#endif -#ifndef OVERRIDE_TABLE_32_setfsgid -TRACE_SYSCALL_TABLE(setfsgid, setfsgid, 216, 1) -#endif -#ifndef OVERRIDE_TABLE_32_madvise -TRACE_SYSCALL_TABLE(madvise, madvise, 220, 3) -#endif -#ifndef OVERRIDE_TABLE_32_fcntl64 -TRACE_SYSCALL_TABLE(fcntl64, fcntl64, 221, 3) -#endif -#ifndef OVERRIDE_TABLE_32_tkill -TRACE_SYSCALL_TABLE(tkill, tkill, 238, 2) -#endif -#ifndef OVERRIDE_TABLE_32_io_destroy -TRACE_SYSCALL_TABLE(io_destroy, io_destroy, 244, 1) -#endif -#ifndef OVERRIDE_TABLE_32_exit_group -TRACE_SYSCALL_TABLE(exit_group, exit_group, 248, 1) -#endif -#ifndef OVERRIDE_TABLE_32_epoll_create -TRACE_SYSCALL_TABLE(epoll_create, epoll_create, 250, 1) -#endif -#ifndef OVERRIDE_TABLE_32_remap_file_pages -TRACE_SYSCALL_TABLE(remap_file_pages, remap_file_pages, 253, 5) -#endif -#ifndef OVERRIDE_TABLE_32_timer_getoverrun -TRACE_SYSCALL_TABLE(timer_getoverrun, timer_getoverrun, 260, 1) -#endif -#ifndef OVERRIDE_TABLE_32_timer_delete -TRACE_SYSCALL_TABLE(timer_delete, timer_delete, 261, 1) -#endif -#ifndef OVERRIDE_TABLE_32_tgkill -TRACE_SYSCALL_TABLE(tgkill, tgkill, 268, 3) -#endif -#ifndef OVERRIDE_TABLE_32_socket -TRACE_SYSCALL_TABLE(socket, socket, 281, 3) -#endif -#ifndef OVERRIDE_TABLE_32_listen -TRACE_SYSCALL_TABLE(listen, listen, 284, 2) -#endif -#ifndef OVERRIDE_TABLE_32_shutdown -TRACE_SYSCALL_TABLE(shutdown, shutdown, 293, 2) -#endif -#ifndef OVERRIDE_TABLE_32_semget -TRACE_SYSCALL_TABLE(semget, semget, 299, 3) -#endif -#ifndef OVERRIDE_TABLE_32_msgget -TRACE_SYSCALL_TABLE(msgget, msgget, 303, 2) -#endif -#ifndef OVERRIDE_TABLE_32_shmget -TRACE_SYSCALL_TABLE(shmget, shmget, 307, 3) -#endif -#ifndef OVERRIDE_TABLE_32_keyctl -TRACE_SYSCALL_TABLE(keyctl, keyctl, 311, 5) -#endif -#ifndef OVERRIDE_TABLE_32_ioprio_set -TRACE_SYSCALL_TABLE(ioprio_set, ioprio_set, 314, 3) -#endif -#ifndef OVERRIDE_TABLE_32_ioprio_get -TRACE_SYSCALL_TABLE(ioprio_get, ioprio_get, 315, 2) -#endif -#ifndef OVERRIDE_TABLE_32_inotify_rm_watch -TRACE_SYSCALL_TABLE(inotify_rm_watch, inotify_rm_watch, 318, 2) -#endif -#ifndef OVERRIDE_TABLE_32_unshare -TRACE_SYSCALL_TABLE(unshare, unshare, 337, 1) -#endif -#ifndef OVERRIDE_TABLE_32_tee -TRACE_SYSCALL_TABLE(tee, tee, 342, 4) -#endif -#ifndef OVERRIDE_TABLE_32_timerfd_create -TRACE_SYSCALL_TABLE(timerfd_create, timerfd_create, 350, 2) -#endif -#ifndef OVERRIDE_TABLE_32_eventfd -TRACE_SYSCALL_TABLE(eventfd, eventfd, 351, 1) -#endif -#ifndef OVERRIDE_TABLE_32_eventfd2 -TRACE_SYSCALL_TABLE(eventfd2, eventfd2, 356, 2) -#endif -#ifndef OVERRIDE_TABLE_32_epoll_create1 -TRACE_SYSCALL_TABLE(epoll_create1, epoll_create1, 357, 1) -#endif -#ifndef OVERRIDE_TABLE_32_dup3 -TRACE_SYSCALL_TABLE(dup3, dup3, 358, 3) -#endif -#ifndef OVERRIDE_TABLE_32_inotify_init1 -TRACE_SYSCALL_TABLE(inotify_init1, inotify_init1, 360, 1) -#endif -#ifndef OVERRIDE_TABLE_32_fanotify_init -TRACE_SYSCALL_TABLE(fanotify_init, fanotify_init, 367, 2) -#endif -#ifndef OVERRIDE_TABLE_32_syncfs -TRACE_SYSCALL_TABLE(syncfs, syncfs, 373, 1) -#endif -#ifndef OVERRIDE_TABLE_32_setns -TRACE_SYSCALL_TABLE(setns, setns, 375, 2) -#endif - -#endif /* CREATE_SYSCALL_TABLE */ diff --git a/instrumentation/syscalls/headers/arm-32-syscalls_integers_override.h b/instrumentation/syscalls/headers/arm-32-syscalls_integers_override.h deleted file mode 100644 index 4dfbdebf..00000000 --- a/instrumentation/syscalls/headers/arm-32-syscalls_integers_override.h +++ /dev/null @@ -1,143 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ - -#ifndef CONFIG_UID16 - -#define OVERRIDE_32_getuid16 -#define OVERRIDE_32_getgid16 -#define OVERRIDE_32_geteuid16 -#define OVERRIDE_32_getegid16 -#define OVERRIDE_32_setuid16 -#define OVERRIDE_32_setgid16 -#define OVERRIDE_32_setfsuid16 -#define OVERRIDE_32_setfsgid16 -#define OVERRIDE_32_setreuid16 -#define OVERRIDE_32_setregid16 -#define OVERRIDE_32_fchown16 -#define OVERRIDE_32_setresuid16 -#define OVERRIDE_32_setresgid16 - -#define OVERRIDE_TABLE_32_getuid16 -#define OVERRIDE_TABLE_32_getgid16 -#define OVERRIDE_TABLE_32_geteuid16 -#define OVERRIDE_TABLE_32_getegid16 -#define OVERRIDE_TABLE_32_setuid16 -#define OVERRIDE_TABLE_32_setgid16 -#define OVERRIDE_TABLE_32_setreuid16 -#define OVERRIDE_TABLE_32_setregid16 -#define OVERRIDE_TABLE_32_fchown16 -#define OVERRIDE_TABLE_32_setfsuid16 -#define OVERRIDE_TABLE_32_setfsgid16 -#define OVERRIDE_TABLE_32_setresuid16 -#define OVERRIDE_TABLE_32_setresgid16 - -#endif - -#ifndef CREATE_SYSCALL_TABLE - -#if (__BYTE_ORDER == __LITTLE_ENDIAN) - -#define OVERRIDE_32_arm_fadvise64_64 -SC_LTTNG_TRACEPOINT_EVENT(arm_fadvise64_64, - TP_PROTO(sc_exit(long ret,) int fd, int advice, - int32_t offset_low, int32_t offset_high, - int32_t len_low, int32_t len_high), - TP_ARGS(sc_exit(ret,) fd, advice, offset_low, offset_high, - len_low, len_high), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) - sc_in(ctf_integer(int, fd, fd)) - sc_in(ctf_integer(int, advice, advice)) - sc_in(ctf_integer(loff_t, offset, - ((loff_t) offset_high << 32) | offset_low)) - sc_in(ctf_integer(loff_t, len, - ((loff_t) len_high << 32) | len_low)) - ) -) - -#define OVERRIDE_32_sync_file_range2 -SC_LTTNG_TRACEPOINT_EVENT(sync_file_range2, - TP_PROTO(sc_exit(long ret,) int fd, - unsigned int flags, - int32_t offset_low, int32_t offset_high, - int32_t nbytes_low, int32_t nbytes_high), - TP_ARGS(sc_exit(ret,) fd, flags, offset_low, offset_high, - nbytes_low, nbytes_high), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) - sc_in(ctf_integer(int, fd, fd)) - sc_in(ctf_integer(unsigned int, flags, flags)) - sc_in(ctf_integer(loff_t, offset, - ((loff_t) offset_high << 32) | offset_low)) - sc_in(ctf_integer(loff_t, nbytes, - ((loff_t) nbytes_high << 32) | nbytes_low)) - ) -) - -#else /* __BIG_ENDIAN */ - -#define OVERRIDE_32_arm_fadvise64_64 -SC_LTTNG_TRACEPOINT_EVENT(arm_fadvise64_64, - TP_PROTO(sc_exit(long ret,) int fd, int advice, - int32_t offset_high, int32_t offset_low, - int32_t len_high, int32_t len_low), - TP_ARGS(sc_exit(ret,) fd, advice, offset_high, offset_low, - len_high, len_low), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) - sc_in(ctf_integer(int, fd, fd)) - sc_in(ctf_integer(int, advice, advice)) - sc_in(ctf_integer(loff_t, offset, - ((loff_t) offset_high << 32) | offset_low)) - sc_in(ctf_integer(loff_t, len, - ((loff_t) len_high << 32) | len_low)) - ) -) - -#define OVERRIDE_32_sync_file_range2 -SC_LTTNG_TRACEPOINT_EVENT(sync_file_range2, - TP_PROTO(sc_exit(long ret,) int fd, - unsigned int flags, - int32_t offset_high, int32_t offset_low, - int32_t nbytes_high, int32_t nbytes_low), - TP_ARGS(sc_exit(ret,) fd, flags, offset_high, offset_low, - nbytes_high, nbytes_low), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) - sc_in(ctf_integer(int, fd, fd)) - sc_in(ctf_integer(unsigned int, flags, flags)) - sc_in(ctf_integer(loff_t, offset, - ((loff_t) offset_high << 32) | offset_low)) - sc_in(ctf_integer(loff_t, nbytes, - ((loff_t) nbytes_high << 32) | nbytes_low)) - ) -) - -#endif - -#define OVERRIDE_32_mmap2 -SC_LTTNG_TRACEPOINT_EVENT(mmap2, - TP_PROTO(sc_exit(unsigned long ret,) - unsigned long addr, unsigned long len, - unsigned long prot, unsigned long flags, - unsigned long fd, unsigned long pgoff), - TP_ARGS(sc_exit(ret,) addr, len, prot, flags, fd, pgoff), - TP_FIELDS(sc_exit(ctf_integer_hex(unsigned long, ret, ret)) - sc_in(ctf_integer_hex(unsigned long, addr, addr)) - sc_in(ctf_integer(size_t, len, len)) - sc_in(ctf_integer(int, prot, prot)) - sc_in(ctf_integer(int, flags, flags)) - sc_in(ctf_integer(int, fd, fd)) - sc_in(ctf_integer(off_t, pgoff, pgoff)) - ) -) - -#else /* CREATE_SYSCALL_TABLE */ - -#define OVERRIDE_TABLE_32_mmap -TRACE_SYSCALL_TABLE(mmap, mmap, 90, 6) -#define OVERRIDE_TABLE_32_mmap2 -TRACE_SYSCALL_TABLE(mmap2, mmap2, 192, 6) -#define OVERRIDE_TABLE_32_arm_fadvise64_64 -TRACE_SYSCALL_TABLE(arm_fadvise64_64, arm_fadvise64_64, 270, 6) -#define OVERRIDE_TABLE_32_sync_file_range2 -TRACE_SYSCALL_TABLE(sync_file_range2, sync_file_range2, 341, 6) - -#endif /* CREATE_SYSCALL_TABLE */ - - diff --git a/instrumentation/syscalls/headers/arm-32-syscalls_pointers.h b/instrumentation/syscalls/headers/arm-32-syscalls_pointers.h deleted file mode 100644 index 094fa2ec..00000000 --- a/instrumentation/syscalls/headers/arm-32-syscalls_pointers.h +++ /dev/null @@ -1,1939 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ - -/* THIS FILE IS AUTO-GENERATED. DO NOT EDIT */ - -/* Generated from arm-32-syscalls 3.4.25 */ - -#ifndef CREATE_SYSCALL_TABLE - -#if !defined(_TRACE_SYSCALLS_POINTERS_H) || defined(TRACE_HEADER_MULTI_READ) -#define _TRACE_SYSCALLS_POINTERS_H - -#include -#include -#include "arm-32-syscalls_pointers_override.h" -#include "syscalls_pointers_override.h" - -#ifndef OVERRIDE_32_unlink -SC_LTTNG_TRACEPOINT_EVENT(unlink, - TP_PROTO(sc_exit(long ret,) const char * pathname), - TP_ARGS(sc_exit(ret,) pathname), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname))) -) -#endif -#ifndef OVERRIDE_32_chdir -SC_LTTNG_TRACEPOINT_EVENT(chdir, - TP_PROTO(sc_exit(long ret,) const char * filename), - TP_ARGS(sc_exit(ret,) filename), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename))) -) -#endif -#ifndef OVERRIDE_32_rmdir -SC_LTTNG_TRACEPOINT_EVENT(rmdir, - TP_PROTO(sc_exit(long ret,) const char * pathname), - TP_ARGS(sc_exit(ret,) pathname), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname))) -) -#endif -#ifndef OVERRIDE_32_pipe -SC_LTTNG_TRACEPOINT_EVENT(pipe, - TP_PROTO(sc_exit(long ret,) int * fildes), - TP_ARGS(sc_exit(ret,) fildes), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(int *, fildes, fildes))) -) -#endif -#ifndef OVERRIDE_32_times -SC_LTTNG_TRACEPOINT_EVENT(times, - TP_PROTO(sc_exit(long ret,) struct tms * tbuf), - TP_ARGS(sc_exit(ret,) tbuf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct tms *, tbuf, tbuf))) -) -#endif -#ifndef OVERRIDE_32_acct -SC_LTTNG_TRACEPOINT_EVENT(acct, - TP_PROTO(sc_exit(long ret,) const char * name), - TP_ARGS(sc_exit(ret,) name), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name))) -) -#endif -#ifndef OVERRIDE_32_chroot -SC_LTTNG_TRACEPOINT_EVENT(chroot, - TP_PROTO(sc_exit(long ret,) const char * filename), - TP_ARGS(sc_exit(ret,) filename), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename))) -) -#endif -#ifndef OVERRIDE_32_sigpending -SC_LTTNG_TRACEPOINT_EVENT(sigpending, - TP_PROTO(sc_exit(long ret,) old_sigset_t * set), - TP_ARGS(sc_exit(ret,) set), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(old_sigset_t *, set, set))) -) -#endif -#ifndef OVERRIDE_32_uselib -SC_LTTNG_TRACEPOINT_EVENT(uselib, - TP_PROTO(sc_exit(long ret,) const char * library), - TP_ARGS(sc_exit(ret,) library), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(const char *, library, library))) -) -#endif -#ifndef OVERRIDE_32_swapoff -SC_LTTNG_TRACEPOINT_EVENT(swapoff, - TP_PROTO(sc_exit(long ret,) const char * specialfile), - TP_ARGS(sc_exit(ret,) specialfile), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(specialfile, specialfile))) -) -#endif -#ifndef OVERRIDE_32_sysinfo -SC_LTTNG_TRACEPOINT_EVENT(sysinfo, - TP_PROTO(sc_exit(long ret,) struct sysinfo * info), - TP_ARGS(sc_exit(ret,) info), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct sysinfo *, info, info))) -) -#endif -#ifndef OVERRIDE_32_newuname -SC_LTTNG_TRACEPOINT_EVENT(newuname, - TP_PROTO(sc_exit(long ret,) struct new_utsname * name), - TP_ARGS(sc_exit(ret,) name), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct new_utsname *, name, name))) -) -#endif -#ifndef OVERRIDE_32_adjtimex -SC_LTTNG_TRACEPOINT_EVENT(adjtimex, - TP_PROTO(sc_exit(long ret,) struct timex * txc_p), - TP_ARGS(sc_exit(ret,) txc_p), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct timex *, txc_p, txc_p))) -) -#endif -#ifndef OVERRIDE_32_sysctl -SC_LTTNG_TRACEPOINT_EVENT(sysctl, - TP_PROTO(sc_exit(long ret,) struct __sysctl_args * args), - TP_ARGS(sc_exit(ret,) args), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct __sysctl_args *, args, args))) -) -#endif -#ifndef OVERRIDE_32_set_tid_address -SC_LTTNG_TRACEPOINT_EVENT(set_tid_address, - TP_PROTO(sc_exit(long ret,) int * tidptr), - TP_ARGS(sc_exit(ret,) tidptr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int *, tidptr, tidptr))) -) -#endif -#ifndef OVERRIDE_32_mq_unlink -SC_LTTNG_TRACEPOINT_EVENT(mq_unlink, - TP_PROTO(sc_exit(long ret,) const char * u_name), - TP_ARGS(sc_exit(ret,) u_name), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(u_name, u_name))) -) -#endif -#ifndef OVERRIDE_32_shmdt -SC_LTTNG_TRACEPOINT_EVENT(shmdt, - TP_PROTO(sc_exit(long ret,) char * shmaddr), - TP_ARGS(sc_exit(ret,) shmaddr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(char *, shmaddr, shmaddr))) -) -#endif -#ifndef OVERRIDE_32_creat -SC_LTTNG_TRACEPOINT_EVENT(creat, - TP_PROTO(sc_exit(long ret,) const char * pathname, umode_t mode), - TP_ARGS(sc_exit(ret,) pathname, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(umode_t, mode, mode))) -) -#endif -#ifndef OVERRIDE_32_link -SC_LTTNG_TRACEPOINT_EVENT(link, - TP_PROTO(sc_exit(long ret,) const char * oldname, const char * newname), - TP_ARGS(sc_exit(ret,) oldname, newname), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_user_string(newname, newname))) -) -#endif -#ifndef OVERRIDE_32_chmod -SC_LTTNG_TRACEPOINT_EVENT(chmod, - TP_PROTO(sc_exit(long ret,) const char * filename, umode_t mode), - TP_ARGS(sc_exit(ret,) filename, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(umode_t, mode, mode))) -) -#endif -#ifndef OVERRIDE_32_access -SC_LTTNG_TRACEPOINT_EVENT(access, - TP_PROTO(sc_exit(long ret,) const char * filename, int mode), - TP_ARGS(sc_exit(ret,) filename, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, mode, mode))) -) -#endif -#ifndef OVERRIDE_32_rename -SC_LTTNG_TRACEPOINT_EVENT(rename, - TP_PROTO(sc_exit(long ret,) const char * oldname, const char * newname), - TP_ARGS(sc_exit(ret,) oldname, newname), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_user_string(newname, newname))) -) -#endif -#ifndef OVERRIDE_32_mkdir -SC_LTTNG_TRACEPOINT_EVENT(mkdir, - TP_PROTO(sc_exit(long ret,) const char * pathname, umode_t mode), - TP_ARGS(sc_exit(ret,) pathname, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(umode_t, mode, mode))) -) -#endif -#ifndef OVERRIDE_32_umount -SC_LTTNG_TRACEPOINT_EVENT(umount, - TP_PROTO(sc_exit(long ret,) char * name, int flags), - TP_ARGS(sc_exit(ret,) name, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_ustat -SC_LTTNG_TRACEPOINT_EVENT(ustat, - TP_PROTO(sc_exit(long ret,) unsigned dev, struct ustat * ubuf), - TP_ARGS(sc_exit(ret,) dev, ubuf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned, dev, dev)) sc_out(ctf_integer(struct ustat *, ubuf, ubuf))) -) -#endif -#ifndef OVERRIDE_32_sethostname -SC_LTTNG_TRACEPOINT_EVENT(sethostname, - TP_PROTO(sc_exit(long ret,) char * name, int len), - TP_ARGS(sc_exit(ret,) name, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(int, len, len))) -) -#endif -#ifndef OVERRIDE_32_setrlimit -SC_LTTNG_TRACEPOINT_EVENT(setrlimit, - TP_PROTO(sc_exit(long ret,) unsigned int resource, struct rlimit * rlim), - TP_ARGS(sc_exit(ret,) resource, rlim), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, resource, resource)) sc_in(ctf_integer(struct rlimit *, rlim, rlim))) -) -#endif -#ifndef OVERRIDE_32_getrusage -SC_LTTNG_TRACEPOINT_EVENT(getrusage, - TP_PROTO(sc_exit(long ret,) int who, struct rusage * ru), - TP_ARGS(sc_exit(ret,) who, ru), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, who, who)) sc_out(ctf_integer(struct rusage *, ru, ru))) -) -#endif -#ifndef OVERRIDE_32_gettimeofday -SC_LTTNG_TRACEPOINT_EVENT(gettimeofday, - TP_PROTO(sc_exit(long ret,) struct timeval * tv, struct timezone * tz), - TP_ARGS(sc_exit(ret,) tv, tz), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct timeval *, tv, tv)) sc_out(ctf_integer(struct timezone *, tz, tz))) -) -#endif -#ifndef OVERRIDE_32_settimeofday -SC_LTTNG_TRACEPOINT_EVENT(settimeofday, - TP_PROTO(sc_exit(long ret,) struct timeval * tv, struct timezone * tz), - TP_ARGS(sc_exit(ret,) tv, tz), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct timeval *, tv, tv)) sc_in(ctf_integer(struct timezone *, tz, tz))) -) -#endif -#ifndef OVERRIDE_32_getgroups16 -SC_LTTNG_TRACEPOINT_EVENT(getgroups16, - TP_PROTO(sc_exit(long ret,) int gidsetsize, old_gid_t * grouplist), - TP_ARGS(sc_exit(ret,) gidsetsize, grouplist), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, gidsetsize, gidsetsize)) sc_inout(ctf_integer(old_gid_t *, grouplist, grouplist))) -) -#endif -#ifndef OVERRIDE_32_setgroups16 -SC_LTTNG_TRACEPOINT_EVENT(setgroups16, - TP_PROTO(sc_exit(long ret,) int gidsetsize, old_gid_t * grouplist), - TP_ARGS(sc_exit(ret,) gidsetsize, grouplist), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, gidsetsize, gidsetsize)) sc_inout(ctf_integer(old_gid_t *, grouplist, grouplist))) -) -#endif -#ifndef OVERRIDE_32_symlink -SC_LTTNG_TRACEPOINT_EVENT(symlink, - TP_PROTO(sc_exit(long ret,) const char * oldname, const char * newname), - TP_ARGS(sc_exit(ret,) oldname, newname), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_user_string(newname, newname))) -) -#endif -#ifndef OVERRIDE_32_swapon -SC_LTTNG_TRACEPOINT_EVENT(swapon, - TP_PROTO(sc_exit(long ret,) const char * specialfile, int swap_flags), - TP_ARGS(sc_exit(ret,) specialfile, swap_flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(specialfile, specialfile)) sc_in(ctf_integer(int, swap_flags, swap_flags))) -) -#endif -#ifndef OVERRIDE_32_truncate -SC_LTTNG_TRACEPOINT_EVENT(truncate, - TP_PROTO(sc_exit(long ret,) const char * path, long length), - TP_ARGS(sc_exit(ret,) path, length), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(path, path)) sc_in(ctf_integer(long, length, length))) -) -#endif -#ifndef OVERRIDE_32_statfs -SC_LTTNG_TRACEPOINT_EVENT(statfs, - TP_PROTO(sc_exit(long ret,) const char * pathname, struct statfs * buf), - TP_ARGS(sc_exit(ret,) pathname, buf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(struct statfs *, buf, buf))) -) -#endif -#ifndef OVERRIDE_32_fstatfs -SC_LTTNG_TRACEPOINT_EVENT(fstatfs, - TP_PROTO(sc_exit(long ret,) unsigned int fd, struct statfs * buf), - TP_ARGS(sc_exit(ret,) fd, buf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct statfs *, buf, buf))) -) -#endif -#ifndef OVERRIDE_32_getitimer -SC_LTTNG_TRACEPOINT_EVENT(getitimer, - TP_PROTO(sc_exit(long ret,) int which, struct itimerval * value), - TP_ARGS(sc_exit(ret,) which, value), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_out(ctf_integer(struct itimerval *, value, value))) -) -#endif -#ifndef OVERRIDE_32_newstat -SC_LTTNG_TRACEPOINT_EVENT(newstat, - TP_PROTO(sc_exit(long ret,) const char * filename, struct stat * statbuf), - TP_ARGS(sc_exit(ret,) filename, statbuf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_out(ctf_integer(struct stat *, statbuf, statbuf))) -) -#endif -#ifndef OVERRIDE_32_newlstat -SC_LTTNG_TRACEPOINT_EVENT(newlstat, - TP_PROTO(sc_exit(long ret,) const char * filename, struct stat * statbuf), - TP_ARGS(sc_exit(ret,) filename, statbuf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_out(ctf_integer(struct stat *, statbuf, statbuf))) -) -#endif -#ifndef OVERRIDE_32_newfstat -SC_LTTNG_TRACEPOINT_EVENT(newfstat, - TP_PROTO(sc_exit(long ret,) unsigned int fd, struct stat * statbuf), - TP_ARGS(sc_exit(ret,) fd, statbuf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct stat *, statbuf, statbuf))) -) -#endif -#ifndef OVERRIDE_32_setdomainname -SC_LTTNG_TRACEPOINT_EVENT(setdomainname, - TP_PROTO(sc_exit(long ret,) char * name, int len), - TP_ARGS(sc_exit(ret,) name, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(int, len, len))) -) -#endif -#ifndef OVERRIDE_32_delete_module -SC_LTTNG_TRACEPOINT_EVENT(delete_module, - TP_PROTO(sc_exit(long ret,) const char * name_user, unsigned int flags), - TP_ARGS(sc_exit(ret,) name_user, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name_user, name_user)) sc_in(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_sched_setparam -SC_LTTNG_TRACEPOINT_EVENT(sched_setparam, - TP_PROTO(sc_exit(long ret,) pid_t pid, struct sched_param * param), - TP_ARGS(sc_exit(ret,) pid, param), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(struct sched_param *, param, param))) -) -#endif -#ifndef OVERRIDE_32_sched_getparam -SC_LTTNG_TRACEPOINT_EVENT(sched_getparam, - TP_PROTO(sc_exit(long ret,) pid_t pid, struct sched_param * param), - TP_ARGS(sc_exit(ret,) pid, param), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_out(ctf_integer(struct sched_param *, param, param))) -) -#endif -#ifndef OVERRIDE_32_sched_rr_get_interval -SC_LTTNG_TRACEPOINT_EVENT(sched_rr_get_interval, - TP_PROTO(sc_exit(long ret,) pid_t pid, struct timespec * interval), - TP_ARGS(sc_exit(ret,) pid, interval), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_out(ctf_integer(struct timespec *, interval, interval))) -) -#endif -#ifndef OVERRIDE_32_nanosleep -SC_LTTNG_TRACEPOINT_EVENT(nanosleep, - TP_PROTO(sc_exit(long ret,) struct timespec * rqtp, struct timespec * rmtp), - TP_ARGS(sc_exit(ret,) rqtp, rmtp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct timespec *, rqtp, rqtp)) sc_out(ctf_integer(struct timespec *, rmtp, rmtp))) -) -#endif -#ifndef OVERRIDE_32_rt_sigpending -SC_LTTNG_TRACEPOINT_EVENT(rt_sigpending, - TP_PROTO(sc_exit(long ret,) sigset_t * set, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) set, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(sigset_t *, set, set)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) -) -#endif -#ifndef OVERRIDE_32_rt_sigsuspend -SC_LTTNG_TRACEPOINT_EVENT(rt_sigsuspend, - TP_PROTO(sc_exit(long ret,) sigset_t * unewset, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) unewset, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(sigset_t *, unewset, unewset)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) -) -#endif -#ifndef OVERRIDE_32_getcwd -SC_LTTNG_TRACEPOINT_EVENT(getcwd, - TP_PROTO(sc_exit(long ret,) char * buf, unsigned long size), - TP_ARGS(sc_exit(ret,) buf, size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(unsigned long, size, size))) -) -#endif -#ifndef OVERRIDE_32_getrlimit -SC_LTTNG_TRACEPOINT_EVENT(getrlimit, - TP_PROTO(sc_exit(long ret,) unsigned int resource, struct rlimit * rlim), - TP_ARGS(sc_exit(ret,) resource, rlim), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, resource, resource)) sc_out(ctf_integer(struct rlimit *, rlim, rlim))) -) -#endif -#ifndef OVERRIDE_32_stat64 -SC_LTTNG_TRACEPOINT_EVENT(stat64, - TP_PROTO(sc_exit(long ret,) const char * filename, struct stat64 * statbuf), - TP_ARGS(sc_exit(ret,) filename, statbuf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(filename, filename)) sc_inout(ctf_integer(struct stat64 *, statbuf, statbuf))) -) -#endif -#ifndef OVERRIDE_32_lstat64 -SC_LTTNG_TRACEPOINT_EVENT(lstat64, - TP_PROTO(sc_exit(long ret,) const char * filename, struct stat64 * statbuf), - TP_ARGS(sc_exit(ret,) filename, statbuf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(filename, filename)) sc_inout(ctf_integer(struct stat64 *, statbuf, statbuf))) -) -#endif -#ifndef OVERRIDE_32_fstat64 -SC_LTTNG_TRACEPOINT_EVENT(fstat64, - TP_PROTO(sc_exit(long ret,) unsigned long fd, struct stat64 * statbuf), - TP_ARGS(sc_exit(ret,) fd, statbuf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned long, fd, fd)) sc_inout(ctf_integer(struct stat64 *, statbuf, statbuf))) -) -#endif -#ifndef OVERRIDE_32_getgroups -SC_LTTNG_TRACEPOINT_EVENT(getgroups, - TP_PROTO(sc_exit(long ret,) int gidsetsize, gid_t * grouplist), - TP_ARGS(sc_exit(ret,) gidsetsize, grouplist), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, gidsetsize, gidsetsize)) sc_out(ctf_integer(gid_t *, grouplist, grouplist))) -) -#endif -#ifndef OVERRIDE_32_setgroups -SC_LTTNG_TRACEPOINT_EVENT(setgroups, - TP_PROTO(sc_exit(long ret,) int gidsetsize, gid_t * grouplist), - TP_ARGS(sc_exit(ret,) gidsetsize, grouplist), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, gidsetsize, gidsetsize)) sc_in(ctf_integer(gid_t *, grouplist, grouplist))) -) -#endif -#ifndef OVERRIDE_32_pivot_root -SC_LTTNG_TRACEPOINT_EVENT(pivot_root, - TP_PROTO(sc_exit(long ret,) const char * new_root, const char * put_old), - TP_ARGS(sc_exit(ret,) new_root, put_old), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(new_root, new_root)) sc_in(ctf_user_string(put_old, put_old))) -) -#endif -#ifndef OVERRIDE_32_removexattr -SC_LTTNG_TRACEPOINT_EVENT(removexattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name), - TP_ARGS(sc_exit(ret,) pathname, name), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name))) -) -#endif -#ifndef OVERRIDE_32_lremovexattr -SC_LTTNG_TRACEPOINT_EVENT(lremovexattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name), - TP_ARGS(sc_exit(ret,) pathname, name), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name))) -) -#endif -#ifndef OVERRIDE_32_fremovexattr -SC_LTTNG_TRACEPOINT_EVENT(fremovexattr, - TP_PROTO(sc_exit(long ret,) int fd, const char * name), - TP_ARGS(sc_exit(ret,) fd, name), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(name, name))) -) -#endif -#ifndef OVERRIDE_32_io_setup -SC_LTTNG_TRACEPOINT_EVENT(io_setup, - TP_PROTO(sc_exit(long ret,) unsigned nr_events, aio_context_t * ctxp), - TP_ARGS(sc_exit(ret,) nr_events, ctxp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned, nr_events, nr_events)) sc_in(ctf_integer(aio_context_t *, ctxp, ctxp))) -) -#endif -#ifndef OVERRIDE_32_timer_gettime -SC_LTTNG_TRACEPOINT_EVENT(timer_gettime, - TP_PROTO(sc_exit(long ret,) timer_t timer_id, struct itimerspec * setting), - TP_ARGS(sc_exit(ret,) timer_id, setting), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id)) sc_out(ctf_integer(struct itimerspec *, setting, setting))) -) -#endif -#ifndef OVERRIDE_32_clock_settime -SC_LTTNG_TRACEPOINT_EVENT(clock_settime, - TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, const struct timespec * tp), - TP_ARGS(sc_exit(ret,) which_clock, tp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_in(ctf_integer(const struct timespec *, tp, tp))) -) -#endif -#ifndef OVERRIDE_32_clock_gettime -SC_LTTNG_TRACEPOINT_EVENT(clock_gettime, - TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct timespec * tp), - TP_ARGS(sc_exit(ret,) which_clock, tp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_out(ctf_integer(struct timespec *, tp, tp))) -) -#endif -#ifndef OVERRIDE_32_clock_getres -SC_LTTNG_TRACEPOINT_EVENT(clock_getres, - TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct timespec * tp), - TP_ARGS(sc_exit(ret,) which_clock, tp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_out(ctf_integer(struct timespec *, tp, tp))) -) -#endif -#ifndef OVERRIDE_32_utimes -SC_LTTNG_TRACEPOINT_EVENT(utimes, - TP_PROTO(sc_exit(long ret,) char * filename, struct timeval * utimes), - TP_ARGS(sc_exit(ret,) filename, utimes), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(struct timeval *, utimes, utimes))) -) -#endif -#ifndef OVERRIDE_32_mq_notify -SC_LTTNG_TRACEPOINT_EVENT(mq_notify, - TP_PROTO(sc_exit(long ret,) mqd_t mqdes, const struct sigevent * u_notification), - TP_ARGS(sc_exit(ret,) mqdes, u_notification), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(mqd_t, mqdes, mqdes)) sc_in(ctf_integer(const struct sigevent *, u_notification, u_notification))) -) -#endif -#ifndef OVERRIDE_32_set_robust_list -SC_LTTNG_TRACEPOINT_EVENT(set_robust_list, - TP_PROTO(sc_exit(long ret,) struct robust_list_head * head, size_t len), - TP_ARGS(sc_exit(ret,) head, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct robust_list_head *, head, head)) sc_in(ctf_integer(size_t, len, len))) -) -#endif -#ifndef OVERRIDE_32_timerfd_gettime -SC_LTTNG_TRACEPOINT_EVENT(timerfd_gettime, - TP_PROTO(sc_exit(long ret,) int ufd, struct itimerspec * otmr), - TP_ARGS(sc_exit(ret,) ufd, otmr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_out(ctf_integer(struct itimerspec *, otmr, otmr))) -) -#endif -#ifndef OVERRIDE_32_pipe2 -SC_LTTNG_TRACEPOINT_EVENT(pipe2, - TP_PROTO(sc_exit(long ret,) int * fildes, int flags), - TP_ARGS(sc_exit(ret,) fildes, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(int *, fildes, fildes)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_clock_adjtime -SC_LTTNG_TRACEPOINT_EVENT(clock_adjtime, - TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct timex * utx), - TP_ARGS(sc_exit(ret,) which_clock, utx), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_inout(ctf_integer(struct timex *, utx, utx))) -) -#endif -#ifndef OVERRIDE_32_read -SC_LTTNG_TRACEPOINT_EVENT(read, - TP_PROTO(sc_exit(long ret,) unsigned int fd, char * buf, size_t count), - TP_ARGS(sc_exit(ret,) fd, buf, count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(size_t, count, count))) -) -#endif -#ifndef OVERRIDE_32_write -SC_LTTNG_TRACEPOINT_EVENT(write, - TP_PROTO(sc_exit(long ret,) unsigned int fd, const char * buf, size_t count), - TP_ARGS(sc_exit(ret,) fd, buf, count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(const char *, buf, buf)) sc_in(ctf_integer(size_t, count, count))) -) -#endif -#ifndef OVERRIDE_32_open -SC_LTTNG_TRACEPOINT_EVENT(open, - TP_PROTO(sc_exit(long ret,) const char * filename, int flags, umode_t mode), - TP_ARGS(sc_exit(ret,) filename, flags, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(umode_t, mode, mode))) -) -#endif -#ifndef OVERRIDE_32_mknod -SC_LTTNG_TRACEPOINT_EVENT(mknod, - TP_PROTO(sc_exit(long ret,) const char * filename, umode_t mode, unsigned dev), - TP_ARGS(sc_exit(ret,) filename, mode, dev), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(umode_t, mode, mode)) sc_in(ctf_integer(unsigned, dev, dev))) -) -#endif -#ifndef OVERRIDE_32_lchown16 -SC_LTTNG_TRACEPOINT_EVENT(lchown16, - TP_PROTO(sc_exit(long ret,) const char * filename, old_uid_t user, old_gid_t group), - TP_ARGS(sc_exit(ret,) filename, user, group), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(filename, filename)) sc_inout(ctf_integer(old_uid_t, user, user)) sc_inout(ctf_integer(old_gid_t, group, group))) -) -#endif -#ifndef OVERRIDE_32_readlink -SC_LTTNG_TRACEPOINT_EVENT(readlink, - TP_PROTO(sc_exit(long ret,) const char * path, char * buf, int bufsiz), - TP_ARGS(sc_exit(ret,) path, buf, bufsiz), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(path, path)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(int, bufsiz, bufsiz))) -) -#endif -#ifndef OVERRIDE_32_syslog -SC_LTTNG_TRACEPOINT_EVENT(syslog, - TP_PROTO(sc_exit(long ret,) int type, char * buf, int len), - TP_ARGS(sc_exit(ret,) type, buf, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, type, type)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(int, len, len))) -) -#endif -#ifndef OVERRIDE_32_setitimer -SC_LTTNG_TRACEPOINT_EVENT(setitimer, - TP_PROTO(sc_exit(long ret,) int which, struct itimerval * value, struct itimerval * ovalue), - TP_ARGS(sc_exit(ret,) which, value, ovalue), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(struct itimerval *, value, value)) sc_out(ctf_integer(struct itimerval *, ovalue, ovalue))) -) -#endif -#ifndef OVERRIDE_32_sigprocmask -SC_LTTNG_TRACEPOINT_EVENT(sigprocmask, - TP_PROTO(sc_exit(long ret,) int how, old_sigset_t * nset, old_sigset_t * oset), - TP_ARGS(sc_exit(ret,) how, nset, oset), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, how, how)) sc_inout(ctf_integer(old_sigset_t *, nset, nset)) sc_inout(ctf_integer(old_sigset_t *, oset, oset))) -) -#endif -#ifndef OVERRIDE_32_init_module -SC_LTTNG_TRACEPOINT_EVENT(init_module, - TP_PROTO(sc_exit(long ret,) void * umod, unsigned long len, const char * uargs), - TP_ARGS(sc_exit(ret,) umod, len, uargs), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(void *, umod, umod)) sc_in(ctf_integer(unsigned long, len, len)) sc_in(ctf_integer(const char *, uargs, uargs))) -) -#endif -#ifndef OVERRIDE_32_getdents -SC_LTTNG_TRACEPOINT_EVENT(getdents, - TP_PROTO(sc_exit(long ret,) unsigned int fd, struct linux_dirent * dirent, unsigned int count), - TP_ARGS(sc_exit(ret,) fd, dirent, count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct linux_dirent *, dirent, dirent)) sc_in(ctf_integer(unsigned int, count, count))) -) -#endif -#ifndef OVERRIDE_32_readv -SC_LTTNG_TRACEPOINT_EVENT(readv, - TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen), - TP_ARGS(sc_exit(ret,) fd, vec, vlen), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_inout(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen))) -) -#endif -#ifndef OVERRIDE_32_writev -SC_LTTNG_TRACEPOINT_EVENT(writev, - TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen), - TP_ARGS(sc_exit(ret,) fd, vec, vlen), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_inout(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen))) -) -#endif -#ifndef OVERRIDE_32_sched_setscheduler -SC_LTTNG_TRACEPOINT_EVENT(sched_setscheduler, - TP_PROTO(sc_exit(long ret,) pid_t pid, int policy, struct sched_param * param), - TP_ARGS(sc_exit(ret,) pid, policy, param), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, policy, policy)) sc_in(ctf_integer(struct sched_param *, param, param))) -) -#endif -#ifndef OVERRIDE_32_getresuid16 -SC_LTTNG_TRACEPOINT_EVENT(getresuid16, - TP_PROTO(sc_exit(long ret,) old_uid_t * ruid, old_uid_t * euid, old_uid_t * suid), - TP_ARGS(sc_exit(ret,) ruid, euid, suid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(old_uid_t *, ruid, ruid)) sc_inout(ctf_integer(old_uid_t *, euid, euid)) sc_inout(ctf_integer(old_uid_t *, suid, suid))) -) -#endif -#ifndef OVERRIDE_32_poll -SC_LTTNG_TRACEPOINT_EVENT(poll, - TP_PROTO(sc_exit(long ret,) struct pollfd * ufds, unsigned int nfds, int timeout_msecs), - TP_ARGS(sc_exit(ret,) ufds, nfds, timeout_msecs), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct pollfd *, ufds, ufds)) sc_in(ctf_integer(unsigned int, nfds, nfds)) sc_in(ctf_integer(int, timeout_msecs, timeout_msecs))) -) -#endif -#ifndef OVERRIDE_32_getresgid16 -SC_LTTNG_TRACEPOINT_EVENT(getresgid16, - TP_PROTO(sc_exit(long ret,) old_gid_t * rgid, old_gid_t * egid, old_gid_t * sgid), - TP_ARGS(sc_exit(ret,) rgid, egid, sgid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(old_gid_t *, rgid, rgid)) sc_inout(ctf_integer(old_gid_t *, egid, egid)) sc_inout(ctf_integer(old_gid_t *, sgid, sgid))) -) -#endif -#ifndef OVERRIDE_32_rt_sigqueueinfo -SC_LTTNG_TRACEPOINT_EVENT(rt_sigqueueinfo, - TP_PROTO(sc_exit(long ret,) pid_t pid, int sig, siginfo_t * uinfo), - TP_ARGS(sc_exit(ret,) pid, sig, uinfo), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig)) sc_in(ctf_integer(siginfo_t *, uinfo, uinfo))) -) -#endif -#ifndef OVERRIDE_32_chown16 -SC_LTTNG_TRACEPOINT_EVENT(chown16, - TP_PROTO(sc_exit(long ret,) const char * filename, old_uid_t user, old_gid_t group), - TP_ARGS(sc_exit(ret,) filename, user, group), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(filename, filename)) sc_inout(ctf_integer(old_uid_t, user, user)) sc_inout(ctf_integer(old_gid_t, group, group))) -) -#endif -#ifndef OVERRIDE_32_lchown -SC_LTTNG_TRACEPOINT_EVENT(lchown, - TP_PROTO(sc_exit(long ret,) const char * filename, uid_t user, gid_t group), - TP_ARGS(sc_exit(ret,) filename, user, group), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group))) -) -#endif -#ifndef OVERRIDE_32_getresuid -SC_LTTNG_TRACEPOINT_EVENT(getresuid, - TP_PROTO(sc_exit(long ret,) uid_t * ruid, uid_t * euid, uid_t * suid), - TP_ARGS(sc_exit(ret,) ruid, euid, suid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(uid_t *, ruid, ruid)) sc_out(ctf_integer(uid_t *, euid, euid)) sc_out(ctf_integer(uid_t *, suid, suid))) -) -#endif -#ifndef OVERRIDE_32_getresgid -SC_LTTNG_TRACEPOINT_EVENT(getresgid, - TP_PROTO(sc_exit(long ret,) gid_t * rgid, gid_t * egid, gid_t * sgid), - TP_ARGS(sc_exit(ret,) rgid, egid, sgid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(gid_t *, rgid, rgid)) sc_out(ctf_integer(gid_t *, egid, egid)) sc_out(ctf_integer(gid_t *, sgid, sgid))) -) -#endif -#ifndef OVERRIDE_32_chown -SC_LTTNG_TRACEPOINT_EVENT(chown, - TP_PROTO(sc_exit(long ret,) const char * filename, uid_t user, gid_t group), - TP_ARGS(sc_exit(ret,) filename, user, group), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group))) -) -#endif -#ifndef OVERRIDE_32_getdents64 -SC_LTTNG_TRACEPOINT_EVENT(getdents64, - TP_PROTO(sc_exit(long ret,) unsigned int fd, struct linux_dirent64 * dirent, unsigned int count), - TP_ARGS(sc_exit(ret,) fd, dirent, count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct linux_dirent64 *, dirent, dirent)) sc_in(ctf_integer(unsigned int, count, count))) -) -#endif -#ifndef OVERRIDE_32_mincore -SC_LTTNG_TRACEPOINT_EVENT(mincore, - TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len, unsigned char * vec), - TP_ARGS(sc_exit(ret,) start, len, vec), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len)) sc_out(ctf_integer(unsigned char *, vec, vec))) -) -#endif -#ifndef OVERRIDE_32_listxattr -SC_LTTNG_TRACEPOINT_EVENT(listxattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, char * list, size_t size), - TP_ARGS(sc_exit(ret,) pathname, list, size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(char *, list, list)) sc_in(ctf_integer(size_t, size, size))) -) -#endif -#ifndef OVERRIDE_32_llistxattr -SC_LTTNG_TRACEPOINT_EVENT(llistxattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, char * list, size_t size), - TP_ARGS(sc_exit(ret,) pathname, list, size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(char *, list, list)) sc_in(ctf_integer(size_t, size, size))) -) -#endif -#ifndef OVERRIDE_32_flistxattr -SC_LTTNG_TRACEPOINT_EVENT(flistxattr, - TP_PROTO(sc_exit(long ret,) int fd, char * list, size_t size), - TP_ARGS(sc_exit(ret,) fd, list, size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(char *, list, list)) sc_in(ctf_integer(size_t, size, size))) -) -#endif -#ifndef OVERRIDE_32_sched_setaffinity -SC_LTTNG_TRACEPOINT_EVENT(sched_setaffinity, - TP_PROTO(sc_exit(long ret,) pid_t pid, unsigned int len, unsigned long * user_mask_ptr), - TP_ARGS(sc_exit(ret,) pid, len, user_mask_ptr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(unsigned int, len, len)) sc_in(ctf_integer(unsigned long *, user_mask_ptr, user_mask_ptr))) -) -#endif -#ifndef OVERRIDE_32_sched_getaffinity -SC_LTTNG_TRACEPOINT_EVENT(sched_getaffinity, - TP_PROTO(sc_exit(long ret,) pid_t pid, unsigned int len, unsigned long * user_mask_ptr), - TP_ARGS(sc_exit(ret,) pid, len, user_mask_ptr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(unsigned int, len, len)) sc_out(ctf_integer(unsigned long *, user_mask_ptr, user_mask_ptr))) -) -#endif -#ifndef OVERRIDE_32_io_submit -SC_LTTNG_TRACEPOINT_EVENT(io_submit, - TP_PROTO(sc_exit(long ret,) aio_context_t ctx_id, long nr, struct iocb * * iocbpp), - TP_ARGS(sc_exit(ret,) ctx_id, nr, iocbpp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx_id, ctx_id)) sc_in(ctf_integer(long, nr, nr)) sc_in(ctf_integer(struct iocb * *, iocbpp, iocbpp))) -) -#endif -#ifndef OVERRIDE_32_io_cancel -SC_LTTNG_TRACEPOINT_EVENT(io_cancel, - TP_PROTO(sc_exit(long ret,) aio_context_t ctx_id, struct iocb * iocb, struct io_event * result), - TP_ARGS(sc_exit(ret,) ctx_id, iocb, result), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx_id, ctx_id)) sc_in(ctf_integer(struct iocb *, iocb, iocb)) sc_out(ctf_integer(struct io_event *, result, result))) -) -#endif -#ifndef OVERRIDE_32_timer_create -SC_LTTNG_TRACEPOINT_EVENT(timer_create, - TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct sigevent * timer_event_spec, timer_t * created_timer_id), - TP_ARGS(sc_exit(ret,) which_clock, timer_event_spec, created_timer_id), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_in(ctf_integer(struct sigevent *, timer_event_spec, timer_event_spec)) sc_out(ctf_integer(timer_t *, created_timer_id, created_timer_id))) -) -#endif -#ifndef OVERRIDE_32_mq_getsetattr -SC_LTTNG_TRACEPOINT_EVENT(mq_getsetattr, - TP_PROTO(sc_exit(long ret,) mqd_t mqdes, const struct mq_attr * u_mqstat, struct mq_attr * u_omqstat), - TP_ARGS(sc_exit(ret,) mqdes, u_mqstat, u_omqstat), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(mqd_t, mqdes, mqdes)) sc_in(ctf_integer(const struct mq_attr *, u_mqstat, u_mqstat)) sc_out(ctf_integer(struct mq_attr *, u_omqstat, u_omqstat))) -) -#endif -#ifndef OVERRIDE_32_bind -SC_LTTNG_TRACEPOINT_EVENT(bind, - TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * umyaddr, int addrlen), - TP_ARGS(sc_exit(ret,) fd, umyaddr, addrlen), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct sockaddr *, umyaddr, umyaddr)) sc_in(ctf_integer(int, addrlen, addrlen))) -) -#endif -#ifndef OVERRIDE_32_connect -SC_LTTNG_TRACEPOINT_EVENT(connect, - TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * uservaddr, int addrlen), - TP_ARGS(sc_exit(ret,) fd, uservaddr, addrlen), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct sockaddr *, uservaddr, uservaddr)) sc_in(ctf_integer(int, addrlen, addrlen))) -) -#endif -#ifndef OVERRIDE_32_accept -SC_LTTNG_TRACEPOINT_EVENT(accept, - TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * upeer_sockaddr, int * upeer_addrlen), - TP_ARGS(sc_exit(ret,) fd, upeer_sockaddr, upeer_addrlen), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct sockaddr *, upeer_sockaddr, upeer_sockaddr)) sc_inout(ctf_integer(int *, upeer_addrlen, upeer_addrlen))) -) -#endif -#ifndef OVERRIDE_32_getsockname -SC_LTTNG_TRACEPOINT_EVENT(getsockname, - TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * usockaddr, int * usockaddr_len), - TP_ARGS(sc_exit(ret,) fd, usockaddr, usockaddr_len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct sockaddr *, usockaddr, usockaddr)) sc_inout(ctf_integer(int *, usockaddr_len, usockaddr_len))) -) -#endif -#ifndef OVERRIDE_32_getpeername -SC_LTTNG_TRACEPOINT_EVENT(getpeername, - TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * usockaddr, int * usockaddr_len), - TP_ARGS(sc_exit(ret,) fd, usockaddr, usockaddr_len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct sockaddr *, usockaddr, usockaddr)) sc_inout(ctf_integer(int *, usockaddr_len, usockaddr_len))) -) -#endif -#ifndef OVERRIDE_32_sendmsg -SC_LTTNG_TRACEPOINT_EVENT(sendmsg, - TP_PROTO(sc_exit(long ret,) int fd, struct msghdr * msg, unsigned flags), - TP_ARGS(sc_exit(ret,) fd, msg, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct msghdr *, msg, msg)) sc_in(ctf_integer(unsigned, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_recvmsg -SC_LTTNG_TRACEPOINT_EVENT(recvmsg, - TP_PROTO(sc_exit(long ret,) int fd, struct msghdr * msg, unsigned int flags), - TP_ARGS(sc_exit(ret,) fd, msg, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_inout(ctf_integer(struct msghdr *, msg, msg)) sc_in(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_semop -SC_LTTNG_TRACEPOINT_EVENT(semop, - TP_PROTO(sc_exit(long ret,) int semid, struct sembuf * tsops, unsigned nsops), - TP_ARGS(sc_exit(ret,) semid, tsops, nsops), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, semid, semid)) sc_in(ctf_integer(struct sembuf *, tsops, tsops)) sc_in(ctf_integer(unsigned, nsops, nsops))) -) -#endif -#ifndef OVERRIDE_32_msgctl -SC_LTTNG_TRACEPOINT_EVENT(msgctl, - TP_PROTO(sc_exit(long ret,) int msqid, int cmd, struct msqid_ds * buf), - TP_ARGS(sc_exit(ret,) msqid, cmd, buf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, msqid, msqid)) sc_in(ctf_integer(int, cmd, cmd)) sc_inout(ctf_integer(struct msqid_ds *, buf, buf))) -) -#endif -#ifndef OVERRIDE_32_shmat -SC_LTTNG_TRACEPOINT_EVENT(shmat, - TP_PROTO(sc_exit(long ret,) int shmid, char * shmaddr, int shmflg), - TP_ARGS(sc_exit(ret,) shmid, shmaddr, shmflg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, shmid, shmid)) sc_in(ctf_integer(char *, shmaddr, shmaddr)) sc_in(ctf_integer(int, shmflg, shmflg))) -) -#endif -#ifndef OVERRIDE_32_shmctl -SC_LTTNG_TRACEPOINT_EVENT(shmctl, - TP_PROTO(sc_exit(long ret,) int shmid, int cmd, struct shmid_ds * buf), - TP_ARGS(sc_exit(ret,) shmid, cmd, buf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, shmid, shmid)) sc_in(ctf_integer(int, cmd, cmd)) sc_inout(ctf_integer(struct shmid_ds *, buf, buf))) -) -#endif -#ifndef OVERRIDE_32_inotify_add_watch -SC_LTTNG_TRACEPOINT_EVENT(inotify_add_watch, - TP_PROTO(sc_exit(long ret,) int fd, const char * pathname, u32 mask), - TP_ARGS(sc_exit(ret,) fd, pathname, mask), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(u32, mask, mask))) -) -#endif -#ifndef OVERRIDE_32_mkdirat -SC_LTTNG_TRACEPOINT_EVENT(mkdirat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * pathname, umode_t mode), - TP_ARGS(sc_exit(ret,) dfd, pathname, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(umode_t, mode, mode))) -) -#endif -#ifndef OVERRIDE_32_futimesat -SC_LTTNG_TRACEPOINT_EVENT(futimesat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, struct timeval * utimes), - TP_ARGS(sc_exit(ret,) dfd, filename, utimes), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(struct timeval *, utimes, utimes))) -) -#endif -#ifndef OVERRIDE_32_unlinkat -SC_LTTNG_TRACEPOINT_EVENT(unlinkat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * pathname, int flag), - TP_ARGS(sc_exit(ret,) dfd, pathname, flag), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(int, flag, flag))) -) -#endif -#ifndef OVERRIDE_32_symlinkat -SC_LTTNG_TRACEPOINT_EVENT(symlinkat, - TP_PROTO(sc_exit(long ret,) const char * oldname, int newdfd, const char * newname), - TP_ARGS(sc_exit(ret,) oldname, newdfd, newname), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_integer(int, newdfd, newdfd)) sc_in(ctf_user_string(newname, newname))) -) -#endif -#ifndef OVERRIDE_32_fchmodat -SC_LTTNG_TRACEPOINT_EVENT(fchmodat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, umode_t mode), - TP_ARGS(sc_exit(ret,) dfd, filename, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(umode_t, mode, mode))) -) -#endif -#ifndef OVERRIDE_32_faccessat -SC_LTTNG_TRACEPOINT_EVENT(faccessat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, int mode), - TP_ARGS(sc_exit(ret,) dfd, filename, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, mode, mode))) -) -#endif -#ifndef OVERRIDE_32_get_robust_list -SC_LTTNG_TRACEPOINT_EVENT(get_robust_list, - TP_PROTO(sc_exit(long ret,) int pid, struct robust_list_head * * head_ptr, size_t * len_ptr), - TP_ARGS(sc_exit(ret,) pid, head_ptr, len_ptr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, pid, pid)) sc_out(ctf_integer(struct robust_list_head * *, head_ptr, head_ptr)) sc_out(ctf_integer(size_t *, len_ptr, len_ptr))) -) -#endif -#ifndef OVERRIDE_32_getcpu -SC_LTTNG_TRACEPOINT_EVENT(getcpu, - TP_PROTO(sc_exit(long ret,) unsigned * cpup, unsigned * nodep, struct getcpu_cache * unused), - TP_ARGS(sc_exit(ret,) cpup, nodep, unused), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(unsigned *, cpup, cpup)) sc_out(ctf_integer(unsigned *, nodep, nodep)) sc_inout(ctf_integer(struct getcpu_cache *, unused, unused))) -) -#endif -#ifndef OVERRIDE_32_signalfd -SC_LTTNG_TRACEPOINT_EVENT(signalfd, - TP_PROTO(sc_exit(long ret,) int ufd, sigset_t * user_mask, size_t sizemask), - TP_ARGS(sc_exit(ret,) ufd, user_mask, sizemask), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_in(ctf_integer(sigset_t *, user_mask, user_mask)) sc_in(ctf_integer(size_t, sizemask, sizemask))) -) -#endif -#ifndef OVERRIDE_32_open_by_handle_at -SC_LTTNG_TRACEPOINT_EVENT(open_by_handle_at, - TP_PROTO(sc_exit(long ret,) int mountdirfd, struct file_handle * handle, int flags), - TP_ARGS(sc_exit(ret,) mountdirfd, handle, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, mountdirfd, mountdirfd)) sc_in(ctf_integer(struct file_handle *, handle, handle)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_reboot -SC_LTTNG_TRACEPOINT_EVENT(reboot, - TP_PROTO(sc_exit(long ret,) int magic1, int magic2, unsigned int cmd, void * arg), - TP_ARGS(sc_exit(ret,) magic1, magic2, cmd, arg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, magic1, magic1)) sc_in(ctf_integer(int, magic2, magic2)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_in(ctf_integer(void *, arg, arg))) -) -#endif -#ifndef OVERRIDE_32_wait4 -SC_LTTNG_TRACEPOINT_EVENT(wait4, - TP_PROTO(sc_exit(long ret,) pid_t upid, int * stat_addr, int options, struct rusage * ru), - TP_ARGS(sc_exit(ret,) upid, stat_addr, options, ru), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, upid, upid)) sc_out(ctf_integer(int *, stat_addr, stat_addr)) sc_in(ctf_integer(int, options, options)) sc_out(ctf_integer(struct rusage *, ru, ru))) -) -#endif -#ifndef OVERRIDE_32_quotactl -SC_LTTNG_TRACEPOINT_EVENT(quotactl, - TP_PROTO(sc_exit(long ret,) unsigned int cmd, const char * special, qid_t id, void * addr), - TP_ARGS(sc_exit(ret,) cmd, special, id, addr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_in(ctf_integer(const char *, special, special)) sc_in(ctf_integer(qid_t, id, id)) sc_inout(ctf_integer(void *, addr, addr))) -) -#endif -#ifndef OVERRIDE_32_rt_sigaction -SC_LTTNG_TRACEPOINT_EVENT(rt_sigaction, - TP_PROTO(sc_exit(long ret,) int sig, const struct sigaction * act, struct sigaction * oact, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) sig, act, oact, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, sig, sig)) sc_in(ctf_integer(const struct sigaction *, act, act)) sc_out(ctf_integer(struct sigaction *, oact, oact)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) -) -#endif -#ifndef OVERRIDE_32_rt_sigprocmask -SC_LTTNG_TRACEPOINT_EVENT(rt_sigprocmask, - TP_PROTO(sc_exit(long ret,) int how, sigset_t * nset, sigset_t * oset, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) how, nset, oset, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, how, how)) sc_in(ctf_integer(sigset_t *, nset, nset)) sc_out(ctf_integer(sigset_t *, oset, oset)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) -) -#endif -#ifndef OVERRIDE_32_rt_sigtimedwait -SC_LTTNG_TRACEPOINT_EVENT(rt_sigtimedwait, - TP_PROTO(sc_exit(long ret,) const sigset_t * uthese, siginfo_t * uinfo, const struct timespec * uts, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) uthese, uinfo, uts, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(const sigset_t *, uthese, uthese)) sc_out(ctf_integer(siginfo_t *, uinfo, uinfo)) sc_in(ctf_integer(const struct timespec *, uts, uts)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) -) -#endif -#ifndef OVERRIDE_32_sendfile -SC_LTTNG_TRACEPOINT_EVENT(sendfile, - TP_PROTO(sc_exit(long ret,) int out_fd, int in_fd, off_t * offset, size_t count), - TP_ARGS(sc_exit(ret,) out_fd, in_fd, offset, count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, out_fd, out_fd)) sc_inout(ctf_integer(int, in_fd, in_fd)) sc_inout(ctf_integer(off_t *, offset, offset)) sc_inout(ctf_integer(size_t, count, count))) -) -#endif -#ifndef OVERRIDE_32_getxattr -SC_LTTNG_TRACEPOINT_EVENT(getxattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, void * value, size_t size), - TP_ARGS(sc_exit(ret,) pathname, name, value, size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_out(ctf_integer(void *, value, value)) sc_in(ctf_integer(size_t, size, size))) -) -#endif -#ifndef OVERRIDE_32_lgetxattr -SC_LTTNG_TRACEPOINT_EVENT(lgetxattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, void * value, size_t size), - TP_ARGS(sc_exit(ret,) pathname, name, value, size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_out(ctf_integer(void *, value, value)) sc_in(ctf_integer(size_t, size, size))) -) -#endif -#ifndef OVERRIDE_32_fgetxattr -SC_LTTNG_TRACEPOINT_EVENT(fgetxattr, - TP_PROTO(sc_exit(long ret,) int fd, const char * name, void * value, size_t size), - TP_ARGS(sc_exit(ret,) fd, name, value, size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(name, name)) sc_out(ctf_integer(void *, value, value)) sc_in(ctf_integer(size_t, size, size))) -) -#endif -#ifndef OVERRIDE_32_sendfile64 -SC_LTTNG_TRACEPOINT_EVENT(sendfile64, - TP_PROTO(sc_exit(long ret,) int out_fd, int in_fd, loff_t * offset, size_t count), - TP_ARGS(sc_exit(ret,) out_fd, in_fd, offset, count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, out_fd, out_fd)) sc_in(ctf_integer(int, in_fd, in_fd)) sc_inout(ctf_integer(loff_t *, offset, offset)) sc_in(ctf_integer(size_t, count, count))) -) -#endif -#ifndef OVERRIDE_32_epoll_ctl -SC_LTTNG_TRACEPOINT_EVENT(epoll_ctl, - TP_PROTO(sc_exit(long ret,) int epfd, int op, int fd, struct epoll_event * event), - TP_ARGS(sc_exit(ret,) epfd, op, fd, event), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, epfd, epfd)) sc_in(ctf_integer(int, op, op)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct epoll_event *, event, event))) -) -#endif -#ifndef OVERRIDE_32_epoll_wait -SC_LTTNG_TRACEPOINT_EVENT(epoll_wait, - TP_PROTO(sc_exit(long ret,) int epfd, struct epoll_event * events, int maxevents, int timeout), - TP_ARGS(sc_exit(ret,) epfd, events, maxevents, timeout), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, epfd, epfd)) sc_out(ctf_integer(struct epoll_event *, events, events)) sc_in(ctf_integer(int, maxevents, maxevents)) sc_in(ctf_integer(int, timeout, timeout))) -) -#endif -#ifndef OVERRIDE_32_timer_settime -SC_LTTNG_TRACEPOINT_EVENT(timer_settime, - TP_PROTO(sc_exit(long ret,) timer_t timer_id, int flags, const struct itimerspec * new_setting, struct itimerspec * old_setting), - TP_ARGS(sc_exit(ret,) timer_id, flags, new_setting, old_setting), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(const struct itimerspec *, new_setting, new_setting)) sc_out(ctf_integer(struct itimerspec *, old_setting, old_setting))) -) -#endif -#ifndef OVERRIDE_32_clock_nanosleep -SC_LTTNG_TRACEPOINT_EVENT(clock_nanosleep, - TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, int flags, const struct timespec * rqtp, struct timespec * rmtp), - TP_ARGS(sc_exit(ret,) which_clock, flags, rqtp, rmtp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(const struct timespec *, rqtp, rqtp)) sc_out(ctf_integer(struct timespec *, rmtp, rmtp))) -) -#endif -#ifndef OVERRIDE_32_mq_open -SC_LTTNG_TRACEPOINT_EVENT(mq_open, - TP_PROTO(sc_exit(long ret,) const char * u_name, int oflag, umode_t mode, struct mq_attr * u_attr), - TP_ARGS(sc_exit(ret,) u_name, oflag, mode, u_attr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(u_name, u_name)) sc_in(ctf_integer(int, oflag, oflag)) sc_in(ctf_integer(umode_t, mode, mode)) sc_in(ctf_integer(struct mq_attr *, u_attr, u_attr))) -) -#endif -#ifndef OVERRIDE_32_socketpair -SC_LTTNG_TRACEPOINT_EVENT(socketpair, - TP_PROTO(sc_exit(long ret,) int family, int type, int protocol, int * usockvec), - TP_ARGS(sc_exit(ret,) family, type, protocol, usockvec), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, family, family)) sc_in(ctf_integer(int, type, type)) sc_in(ctf_integer(int, protocol, protocol)) sc_out(ctf_integer(int *, usockvec, usockvec))) -) -#endif -#ifndef OVERRIDE_32_send -SC_LTTNG_TRACEPOINT_EVENT(send, - TP_PROTO(sc_exit(long ret,) int fd, void * buff, size_t len, unsigned flags), - TP_ARGS(sc_exit(ret,) fd, buff, len, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, fd, fd)) sc_inout(ctf_integer(void *, buff, buff)) sc_inout(ctf_integer(size_t, len, len)) sc_inout(ctf_integer(unsigned, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_msgsnd -SC_LTTNG_TRACEPOINT_EVENT(msgsnd, - TP_PROTO(sc_exit(long ret,) int msqid, struct msgbuf * msgp, size_t msgsz, int msgflg), - TP_ARGS(sc_exit(ret,) msqid, msgp, msgsz, msgflg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, msqid, msqid)) sc_in(ctf_integer(struct msgbuf *, msgp, msgp)) sc_in(ctf_integer(size_t, msgsz, msgsz)) sc_in(ctf_integer(int, msgflg, msgflg))) -) -#endif -#ifndef OVERRIDE_32_request_key -SC_LTTNG_TRACEPOINT_EVENT(request_key, - TP_PROTO(sc_exit(long ret,) const char * _type, const char * _description, const char * _callout_info, key_serial_t destringid), - TP_ARGS(sc_exit(ret,) _type, _description, _callout_info, destringid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(_type, _type)) sc_in(ctf_integer(const char *, _description, _description)) sc_in(ctf_integer(const char *, _callout_info, _callout_info)) sc_in(ctf_integer(key_serial_t, destringid, destringid))) -) -#endif -#ifndef OVERRIDE_32_semtimedop -SC_LTTNG_TRACEPOINT_EVENT(semtimedop, - TP_PROTO(sc_exit(long ret,) int semid, struct sembuf * tsops, unsigned nsops, const struct timespec * timeout), - TP_ARGS(sc_exit(ret,) semid, tsops, nsops, timeout), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, semid, semid)) sc_in(ctf_integer(struct sembuf *, tsops, tsops)) sc_in(ctf_integer(unsigned, nsops, nsops)) sc_inout(ctf_integer(const struct timespec *, timeout, timeout))) -) -#endif -#ifndef OVERRIDE_32_openat -SC_LTTNG_TRACEPOINT_EVENT(openat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, int flags, umode_t mode), - TP_ARGS(sc_exit(ret,) dfd, filename, flags, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(umode_t, mode, mode))) -) -#endif -#ifndef OVERRIDE_32_mknodat -SC_LTTNG_TRACEPOINT_EVENT(mknodat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, umode_t mode, unsigned dev), - TP_ARGS(sc_exit(ret,) dfd, filename, mode, dev), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(umode_t, mode, mode)) sc_in(ctf_integer(unsigned, dev, dev))) -) -#endif -#ifndef OVERRIDE_32_fstatat64 -SC_LTTNG_TRACEPOINT_EVENT(fstatat64, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, struct stat64 * statbuf, int flag), - TP_ARGS(sc_exit(ret,) dfd, filename, statbuf, flag), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, dfd, dfd)) sc_inout(ctf_user_string(filename, filename)) sc_inout(ctf_integer(struct stat64 *, statbuf, statbuf)) sc_inout(ctf_integer(int, flag, flag))) -) -#endif -#ifndef OVERRIDE_32_renameat -SC_LTTNG_TRACEPOINT_EVENT(renameat, - TP_PROTO(sc_exit(long ret,) int olddfd, const char * oldname, int newdfd, const char * newname), - TP_ARGS(sc_exit(ret,) olddfd, oldname, newdfd, newname), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, olddfd, olddfd)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_integer(int, newdfd, newdfd)) sc_in(ctf_user_string(newname, newname))) -) -#endif -#ifndef OVERRIDE_32_readlinkat -SC_LTTNG_TRACEPOINT_EVENT(readlinkat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * pathname, char * buf, int bufsiz), - TP_ARGS(sc_exit(ret,) dfd, pathname, buf, bufsiz), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(int, bufsiz, bufsiz))) -) -#endif -#ifndef OVERRIDE_32_vmsplice -SC_LTTNG_TRACEPOINT_EVENT(vmsplice, - TP_PROTO(sc_exit(long ret,) int fd, const struct iovec * iov, unsigned long nr_segs, unsigned int flags), - TP_ARGS(sc_exit(ret,) fd, iov, nr_segs, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(const struct iovec *, iov, iov)) sc_in(ctf_integer(unsigned long, nr_segs, nr_segs)) sc_in(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_utimensat -SC_LTTNG_TRACEPOINT_EVENT(utimensat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, struct timespec * utimes, int flags), - TP_ARGS(sc_exit(ret,) dfd, filename, utimes, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(struct timespec *, utimes, utimes)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_timerfd_settime -SC_LTTNG_TRACEPOINT_EVENT(timerfd_settime, - TP_PROTO(sc_exit(long ret,) int ufd, int flags, const struct itimerspec * utmr, struct itimerspec * otmr), - TP_ARGS(sc_exit(ret,) ufd, flags, utmr, otmr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(const struct itimerspec *, utmr, utmr)) sc_out(ctf_integer(struct itimerspec *, otmr, otmr))) -) -#endif -#ifndef OVERRIDE_32_signalfd4 -SC_LTTNG_TRACEPOINT_EVENT(signalfd4, - TP_PROTO(sc_exit(long ret,) int ufd, sigset_t * user_mask, size_t sizemask, int flags), - TP_ARGS(sc_exit(ret,) ufd, user_mask, sizemask, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_in(ctf_integer(sigset_t *, user_mask, user_mask)) sc_in(ctf_integer(size_t, sizemask, sizemask)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_rt_tgsigqueueinfo -SC_LTTNG_TRACEPOINT_EVENT(rt_tgsigqueueinfo, - TP_PROTO(sc_exit(long ret,) pid_t tgid, pid_t pid, int sig, siginfo_t * uinfo), - TP_ARGS(sc_exit(ret,) tgid, pid, sig, uinfo), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, tgid, tgid)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig)) sc_in(ctf_integer(siginfo_t *, uinfo, uinfo))) -) -#endif -#ifndef OVERRIDE_32_accept4 -SC_LTTNG_TRACEPOINT_EVENT(accept4, - TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * upeer_sockaddr, int * upeer_addrlen, int flags), - TP_ARGS(sc_exit(ret,) fd, upeer_sockaddr, upeer_addrlen, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct sockaddr *, upeer_sockaddr, upeer_sockaddr)) sc_inout(ctf_integer(int *, upeer_addrlen, upeer_addrlen)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_prlimit64 -SC_LTTNG_TRACEPOINT_EVENT(prlimit64, - TP_PROTO(sc_exit(long ret,) pid_t pid, unsigned int resource, const struct rlimit64 * new_rlim, struct rlimit64 * old_rlim), - TP_ARGS(sc_exit(ret,) pid, resource, new_rlim, old_rlim), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(unsigned int, resource, resource)) sc_in(ctf_integer(const struct rlimit64 *, new_rlim, new_rlim)) sc_out(ctf_integer(struct rlimit64 *, old_rlim, old_rlim))) -) -#endif -#ifndef OVERRIDE_32_sendmmsg -SC_LTTNG_TRACEPOINT_EVENT(sendmmsg, - TP_PROTO(sc_exit(long ret,) int fd, struct mmsghdr * mmsg, unsigned int vlen, unsigned int flags), - TP_ARGS(sc_exit(ret,) fd, mmsg, vlen, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct mmsghdr *, mmsg, mmsg)) sc_in(ctf_integer(unsigned int, vlen, vlen)) sc_in(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_mount -SC_LTTNG_TRACEPOINT_EVENT(mount, - TP_PROTO(sc_exit(long ret,) char * dev_name, char * dir_name, char * type, unsigned long flags, void * data), - TP_ARGS(sc_exit(ret,) dev_name, dir_name, type, flags, data), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(dev_name, dev_name)) sc_in(ctf_user_string(dir_name, dir_name)) sc_in(ctf_user_string(type, type)) sc_in(ctf_integer(unsigned long, flags, flags)) sc_in(ctf_integer(void *, data, data))) -) -#endif -#ifndef OVERRIDE_32_llseek -SC_LTTNG_TRACEPOINT_EVENT(llseek, - TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned long offset_high, unsigned long offset_low, loff_t * result, unsigned int origin), - TP_ARGS(sc_exit(ret,) fd, offset_high, offset_low, result, origin), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, fd, fd)) sc_inout(ctf_integer(unsigned long, offset_high, offset_high)) sc_inout(ctf_integer(unsigned long, offset_low, offset_low)) sc_inout(ctf_integer(loff_t *, result, result)) sc_inout(ctf_integer(unsigned int, origin, origin))) -) -#endif -#ifndef OVERRIDE_32_select -SC_LTTNG_TRACEPOINT_EVENT(select, - TP_PROTO(sc_exit(long ret,) int n, fd_set * inp, fd_set * outp, fd_set * exp, struct timeval * tvp), - TP_ARGS(sc_exit(ret,) n, inp, outp, exp, tvp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, n, n)) sc_inout(ctf_integer(fd_set *, inp, inp)) sc_inout(ctf_integer(fd_set *, outp, outp)) sc_inout(ctf_integer(fd_set *, exp, exp)) sc_inout(ctf_integer(struct timeval *, tvp, tvp))) -) -#endif -#ifndef OVERRIDE_32_setxattr -SC_LTTNG_TRACEPOINT_EVENT(setxattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, const void * value, size_t size, int flags), - TP_ARGS(sc_exit(ret,) pathname, name, value, size, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(const void *, value, value)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_lsetxattr -SC_LTTNG_TRACEPOINT_EVENT(lsetxattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, const void * value, size_t size, int flags), - TP_ARGS(sc_exit(ret,) pathname, name, value, size, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(const void *, value, value)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_fsetxattr -SC_LTTNG_TRACEPOINT_EVENT(fsetxattr, - TP_PROTO(sc_exit(long ret,) int fd, const char * name, const void * value, size_t size, int flags), - TP_ARGS(sc_exit(ret,) fd, name, value, size, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(const void *, value, value)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_io_getevents -SC_LTTNG_TRACEPOINT_EVENT(io_getevents, - TP_PROTO(sc_exit(long ret,) aio_context_t ctx_id, long min_nr, long nr, struct io_event * events, struct timespec * timeout), - TP_ARGS(sc_exit(ret,) ctx_id, min_nr, nr, events, timeout), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx_id, ctx_id)) sc_in(ctf_integer(long, min_nr, min_nr)) sc_in(ctf_integer(long, nr, nr)) sc_out(ctf_integer(struct io_event *, events, events)) sc_inout(ctf_integer(struct timespec *, timeout, timeout))) -) -#endif -#ifndef OVERRIDE_32_mq_timedsend -SC_LTTNG_TRACEPOINT_EVENT(mq_timedsend, - TP_PROTO(sc_exit(long ret,) mqd_t mqdes, const char * u_msg_ptr, size_t msg_len, unsigned int msg_prio, const struct timespec * u_abs_timeout), - TP_ARGS(sc_exit(ret,) mqdes, u_msg_ptr, msg_len, msg_prio, u_abs_timeout), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(mqd_t, mqdes, mqdes)) sc_in(ctf_integer(const char *, u_msg_ptr, u_msg_ptr)) sc_in(ctf_integer(size_t, msg_len, msg_len)) sc_in(ctf_integer(unsigned int, msg_prio, msg_prio)) sc_in(ctf_integer(const struct timespec *, u_abs_timeout, u_abs_timeout))) -) -#endif -#ifndef OVERRIDE_32_mq_timedreceive -SC_LTTNG_TRACEPOINT_EVENT(mq_timedreceive, - TP_PROTO(sc_exit(long ret,) mqd_t mqdes, char * u_msg_ptr, size_t msg_len, unsigned int * u_msg_prio, const struct timespec * u_abs_timeout), - TP_ARGS(sc_exit(ret,) mqdes, u_msg_ptr, msg_len, u_msg_prio, u_abs_timeout), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(mqd_t, mqdes, mqdes)) sc_out(ctf_integer(char *, u_msg_ptr, u_msg_ptr)) sc_in(ctf_integer(size_t, msg_len, msg_len)) sc_out(ctf_integer(unsigned int *, u_msg_prio, u_msg_prio)) sc_in(ctf_integer(const struct timespec *, u_abs_timeout, u_abs_timeout))) -) -#endif -#ifndef OVERRIDE_32_waitid -SC_LTTNG_TRACEPOINT_EVENT(waitid, - TP_PROTO(sc_exit(long ret,) int which, pid_t upid, struct siginfo * infop, int options, struct rusage * ru), - TP_ARGS(sc_exit(ret,) which, upid, infop, options, ru), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(pid_t, upid, upid)) sc_out(ctf_integer(struct siginfo *, infop, infop)) sc_in(ctf_integer(int, options, options)) sc_out(ctf_integer(struct rusage *, ru, ru))) -) -#endif -#ifndef OVERRIDE_32_setsockopt -SC_LTTNG_TRACEPOINT_EVENT(setsockopt, - TP_PROTO(sc_exit(long ret,) int fd, int level, int optname, char * optval, int optlen), - TP_ARGS(sc_exit(ret,) fd, level, optname, optval, optlen), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, level, level)) sc_in(ctf_integer(int, optname, optname)) sc_in(ctf_integer(char *, optval, optval)) sc_in(ctf_integer(int, optlen, optlen))) -) -#endif -#ifndef OVERRIDE_32_getsockopt -SC_LTTNG_TRACEPOINT_EVENT(getsockopt, - TP_PROTO(sc_exit(long ret,) int fd, int level, int optname, char * optval, int * optlen), - TP_ARGS(sc_exit(ret,) fd, level, optname, optval, optlen), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, level, level)) sc_in(ctf_integer(int, optname, optname)) sc_out(ctf_integer(char *, optval, optval)) sc_inout(ctf_integer(int *, optlen, optlen))) -) -#endif -#ifndef OVERRIDE_32_msgrcv -SC_LTTNG_TRACEPOINT_EVENT(msgrcv, - TP_PROTO(sc_exit(long ret,) int msqid, struct msgbuf * msgp, size_t msgsz, long msgtyp, int msgflg), - TP_ARGS(sc_exit(ret,) msqid, msgp, msgsz, msgtyp, msgflg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, msqid, msqid)) sc_out(ctf_integer(struct msgbuf *, msgp, msgp)) sc_in(ctf_integer(size_t, msgsz, msgsz)) sc_in(ctf_integer(long, msgtyp, msgtyp)) sc_in(ctf_integer(int, msgflg, msgflg))) -) -#endif -#ifndef OVERRIDE_32_add_key -SC_LTTNG_TRACEPOINT_EVENT(add_key, - TP_PROTO(sc_exit(long ret,) const char * _type, const char * _description, const void * _payload, size_t plen, key_serial_t ringid), - TP_ARGS(sc_exit(ret,) _type, _description, _payload, plen, ringid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(_type, _type)) sc_in(ctf_integer(const char *, _description, _description)) sc_in(ctf_integer(const void *, _payload, _payload)) sc_in(ctf_integer(size_t, plen, plen)) sc_in(ctf_integer(key_serial_t, ringid, ringid))) -) -#endif -#ifndef OVERRIDE_32_fchownat -SC_LTTNG_TRACEPOINT_EVENT(fchownat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, uid_t user, gid_t group, int flag), - TP_ARGS(sc_exit(ret,) dfd, filename, user, group, flag), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group)) sc_in(ctf_integer(int, flag, flag))) -) -#endif -#ifndef OVERRIDE_32_linkat -SC_LTTNG_TRACEPOINT_EVENT(linkat, - TP_PROTO(sc_exit(long ret,) int olddfd, const char * oldname, int newdfd, const char * newname, int flags), - TP_ARGS(sc_exit(ret,) olddfd, oldname, newdfd, newname, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, olddfd, olddfd)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_integer(int, newdfd, newdfd)) sc_in(ctf_user_string(newname, newname)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_ppoll -SC_LTTNG_TRACEPOINT_EVENT(ppoll, - TP_PROTO(sc_exit(long ret,) struct pollfd * ufds, unsigned int nfds, struct timespec * tsp, const sigset_t * sigmask, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) ufds, nfds, tsp, sigmask, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct pollfd *, ufds, ufds)) sc_in(ctf_integer(unsigned int, nfds, nfds)) sc_in(ctf_integer(struct timespec *, tsp, tsp)) sc_in(ctf_integer(const sigset_t *, sigmask, sigmask)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) -) -#endif -#ifndef OVERRIDE_32_preadv -SC_LTTNG_TRACEPOINT_EVENT(preadv, - TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen, unsigned long pos_l, unsigned long pos_h), - TP_ARGS(sc_exit(ret,) fd, vec, vlen, pos_l, pos_h), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_out(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen)) sc_in(ctf_integer(unsigned long, pos_l, pos_l)) sc_in(ctf_integer(unsigned long, pos_h, pos_h))) -) -#endif -#ifndef OVERRIDE_32_pwritev -SC_LTTNG_TRACEPOINT_EVENT(pwritev, - TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen, unsigned long pos_l, unsigned long pos_h), - TP_ARGS(sc_exit(ret,) fd, vec, vlen, pos_l, pos_h), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_in(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen)) sc_in(ctf_integer(unsigned long, pos_l, pos_l)) sc_in(ctf_integer(unsigned long, pos_h, pos_h))) -) -#endif -#ifndef OVERRIDE_32_perf_event_open -SC_LTTNG_TRACEPOINT_EVENT(perf_event_open, - TP_PROTO(sc_exit(long ret,) struct perf_event_attr * attr_uptr, pid_t pid, int cpu, int group_fd, unsigned long flags), - TP_ARGS(sc_exit(ret,) attr_uptr, pid, cpu, group_fd, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct perf_event_attr *, attr_uptr, attr_uptr)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, cpu, cpu)) sc_in(ctf_integer(int, group_fd, group_fd)) sc_in(ctf_integer(unsigned long, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_recvmmsg -SC_LTTNG_TRACEPOINT_EVENT(recvmmsg, - TP_PROTO(sc_exit(long ret,) int fd, struct mmsghdr * mmsg, unsigned int vlen, unsigned int flags, struct timespec * timeout), - TP_ARGS(sc_exit(ret,) fd, mmsg, vlen, flags, timeout), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct mmsghdr *, mmsg, mmsg)) sc_in(ctf_integer(unsigned int, vlen, vlen)) sc_in(ctf_integer(unsigned int, flags, flags)) sc_inout(ctf_integer(struct timespec *, timeout, timeout))) -) -#endif -#ifndef OVERRIDE_32_name_to_handle_at -SC_LTTNG_TRACEPOINT_EVENT(name_to_handle_at, - TP_PROTO(sc_exit(long ret,) int dfd, const char * name, struct file_handle * handle, int * mnt_id, int flag), - TP_ARGS(sc_exit(ret,) dfd, name, handle, mnt_id, flag), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(name, name)) sc_inout(ctf_integer(struct file_handle *, handle, handle)) sc_out(ctf_integer(int *, mnt_id, mnt_id)) sc_in(ctf_integer(int, flag, flag))) -) -#endif -#ifndef OVERRIDE_32_futex -SC_LTTNG_TRACEPOINT_EVENT(futex, - TP_PROTO(sc_exit(long ret,) u32 * uaddr, int op, u32 val, struct timespec * utime, u32 * uaddr2, u32 val3), - TP_ARGS(sc_exit(ret,) uaddr, op, val, utime, uaddr2, val3), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(u32 *, uaddr, uaddr)) sc_in(ctf_integer(int, op, op)) sc_in(ctf_integer(u32, val, val)) sc_in(ctf_integer(struct timespec *, utime, utime)) sc_inout(ctf_integer(u32 *, uaddr2, uaddr2)) sc_in(ctf_integer(u32, val3, val3))) -) -#endif -#ifndef OVERRIDE_32_sendto -SC_LTTNG_TRACEPOINT_EVENT(sendto, - TP_PROTO(sc_exit(long ret,) int fd, void * buff, size_t len, unsigned flags, struct sockaddr * addr, int addr_len), - TP_ARGS(sc_exit(ret,) fd, buff, len, flags, addr, addr_len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(void *, buff, buff)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned, flags, flags)) sc_in(ctf_integer(struct sockaddr *, addr, addr)) sc_in(ctf_integer(int, addr_len, addr_len))) -) -#endif -#ifndef OVERRIDE_32_recvfrom -SC_LTTNG_TRACEPOINT_EVENT(recvfrom, - TP_PROTO(sc_exit(long ret,) int fd, void * ubuf, size_t size, unsigned flags, struct sockaddr * addr, int * addr_len), - TP_ARGS(sc_exit(ret,) fd, ubuf, size, flags, addr, addr_len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(void *, ubuf, ubuf)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(unsigned, flags, flags)) sc_out(ctf_integer(struct sockaddr *, addr, addr)) sc_inout(ctf_integer(int *, addr_len, addr_len))) -) -#endif -#ifndef OVERRIDE_32_pselect6 -SC_LTTNG_TRACEPOINT_EVENT(pselect6, - TP_PROTO(sc_exit(long ret,) int n, fd_set * inp, fd_set * outp, fd_set * exp, struct timespec * tsp, void * sig), - TP_ARGS(sc_exit(ret,) n, inp, outp, exp, tsp, sig), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, n, n)) sc_inout(ctf_integer(fd_set *, inp, inp)) sc_inout(ctf_integer(fd_set *, outp, outp)) sc_inout(ctf_integer(fd_set *, exp, exp)) sc_inout(ctf_integer(struct timespec *, tsp, tsp)) sc_in(ctf_integer(void *, sig, sig))) -) -#endif -#ifndef OVERRIDE_32_splice -SC_LTTNG_TRACEPOINT_EVENT(splice, - TP_PROTO(sc_exit(long ret,) int fd_in, loff_t * off_in, int fd_out, loff_t * off_out, size_t len, unsigned int flags), - TP_ARGS(sc_exit(ret,) fd_in, off_in, fd_out, off_out, len, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd_in, fd_in)) sc_in(ctf_integer(loff_t *, off_in, off_in)) sc_in(ctf_integer(int, fd_out, fd_out)) sc_in(ctf_integer(loff_t *, off_out, off_out)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_epoll_pwait -SC_LTTNG_TRACEPOINT_EVENT(epoll_pwait, - TP_PROTO(sc_exit(long ret,) int epfd, struct epoll_event * events, int maxevents, int timeout, const sigset_t * sigmask, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) epfd, events, maxevents, timeout, sigmask, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, epfd, epfd)) sc_out(ctf_integer(struct epoll_event *, events, events)) sc_in(ctf_integer(int, maxevents, maxevents)) sc_in(ctf_integer(int, timeout, timeout)) sc_in(ctf_integer(const sigset_t *, sigmask, sigmask)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) -) -#endif -#ifndef OVERRIDE_32_process_vm_readv -SC_LTTNG_TRACEPOINT_EVENT(process_vm_readv, - TP_PROTO(sc_exit(long ret,) pid_t pid, const struct iovec * lvec, unsigned long liovcnt, const struct iovec * rvec, unsigned long riovcnt, unsigned long flags), - TP_ARGS(sc_exit(ret,) pid, lvec, liovcnt, rvec, riovcnt, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_out(ctf_integer(const struct iovec *, lvec, lvec)) sc_in(ctf_integer(unsigned long, liovcnt, liovcnt)) sc_in(ctf_integer(const struct iovec *, rvec, rvec)) sc_in(ctf_integer(unsigned long, riovcnt, riovcnt)) sc_in(ctf_integer(unsigned long, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_process_vm_writev -SC_LTTNG_TRACEPOINT_EVENT(process_vm_writev, - TP_PROTO(sc_exit(long ret,) pid_t pid, const struct iovec * lvec, unsigned long liovcnt, const struct iovec * rvec, unsigned long riovcnt, unsigned long flags), - TP_ARGS(sc_exit(ret,) pid, lvec, liovcnt, rvec, riovcnt, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(const struct iovec *, lvec, lvec)) sc_in(ctf_integer(unsigned long, liovcnt, liovcnt)) sc_in(ctf_integer(const struct iovec *, rvec, rvec)) sc_in(ctf_integer(unsigned long, riovcnt, riovcnt)) sc_in(ctf_integer(unsigned long, flags, flags))) -) -#endif - -#endif /* _TRACE_SYSCALLS_POINTERS_H */ - -/* This part must be outside protection */ -#include - -#else /* CREATE_SYSCALL_TABLE */ - -#include "arm-32-syscalls_pointers_override.h" -#include "syscalls_pointers_override.h" - -#ifndef OVERRIDE_TABLE_32_read -TRACE_SYSCALL_TABLE(read, read, 3, 3) -#endif -#ifndef OVERRIDE_TABLE_32_write -TRACE_SYSCALL_TABLE(write, write, 4, 3) -#endif -#ifndef OVERRIDE_TABLE_32_open -TRACE_SYSCALL_TABLE(open, open, 5, 3) -#endif -#ifndef OVERRIDE_TABLE_32_creat -TRACE_SYSCALL_TABLE(creat, creat, 8, 2) -#endif -#ifndef OVERRIDE_TABLE_32_link -TRACE_SYSCALL_TABLE(link, link, 9, 2) -#endif -#ifndef OVERRIDE_TABLE_32_unlink -TRACE_SYSCALL_TABLE(unlink, unlink, 10, 1) -#endif -#ifndef OVERRIDE_TABLE_32_chdir -TRACE_SYSCALL_TABLE(chdir, chdir, 12, 1) -#endif -#ifndef OVERRIDE_TABLE_32_mknod -TRACE_SYSCALL_TABLE(mknod, mknod, 14, 3) -#endif -#ifndef OVERRIDE_TABLE_32_chmod -TRACE_SYSCALL_TABLE(chmod, chmod, 15, 2) -#endif -#ifndef OVERRIDE_TABLE_32_lchown16 -TRACE_SYSCALL_TABLE(lchown16, lchown16, 16, 3) -#endif -#ifndef OVERRIDE_TABLE_32_mount -TRACE_SYSCALL_TABLE(mount, mount, 21, 5) -#endif -#ifndef OVERRIDE_TABLE_32_access -TRACE_SYSCALL_TABLE(access, access, 33, 2) -#endif -#ifndef OVERRIDE_TABLE_32_rename -TRACE_SYSCALL_TABLE(rename, rename, 38, 2) -#endif -#ifndef OVERRIDE_TABLE_32_mkdir -TRACE_SYSCALL_TABLE(mkdir, mkdir, 39, 2) -#endif -#ifndef OVERRIDE_TABLE_32_rmdir -TRACE_SYSCALL_TABLE(rmdir, rmdir, 40, 1) -#endif -#ifndef OVERRIDE_TABLE_32_pipe -TRACE_SYSCALL_TABLE(pipe, pipe, 42, 1) -#endif -#ifndef OVERRIDE_TABLE_32_times -TRACE_SYSCALL_TABLE(times, times, 43, 1) -#endif -#ifndef OVERRIDE_TABLE_32_acct -TRACE_SYSCALL_TABLE(acct, acct, 51, 1) -#endif -#ifndef OVERRIDE_TABLE_32_umount -TRACE_SYSCALL_TABLE(umount, umount, 52, 2) -#endif -#ifndef OVERRIDE_TABLE_32_chroot -TRACE_SYSCALL_TABLE(chroot, chroot, 61, 1) -#endif -#ifndef OVERRIDE_TABLE_32_ustat -TRACE_SYSCALL_TABLE(ustat, ustat, 62, 2) -#endif -#ifndef OVERRIDE_TABLE_32_sigpending -TRACE_SYSCALL_TABLE(sigpending, sigpending, 73, 1) -#endif -#ifndef OVERRIDE_TABLE_32_sethostname -TRACE_SYSCALL_TABLE(sethostname, sethostname, 74, 2) -#endif -#ifndef OVERRIDE_TABLE_32_setrlimit -TRACE_SYSCALL_TABLE(setrlimit, setrlimit, 75, 2) -#endif -#ifndef OVERRIDE_TABLE_32_getrusage -TRACE_SYSCALL_TABLE(getrusage, getrusage, 77, 2) -#endif -#ifndef OVERRIDE_TABLE_32_gettimeofday -TRACE_SYSCALL_TABLE(gettimeofday, gettimeofday, 78, 2) -#endif -#ifndef OVERRIDE_TABLE_32_settimeofday -TRACE_SYSCALL_TABLE(settimeofday, settimeofday, 79, 2) -#endif -#ifndef OVERRIDE_TABLE_32_getgroups16 -TRACE_SYSCALL_TABLE(getgroups16, getgroups16, 80, 2) -#endif -#ifndef OVERRIDE_TABLE_32_setgroups16 -TRACE_SYSCALL_TABLE(setgroups16, setgroups16, 81, 2) -#endif -#ifndef OVERRIDE_TABLE_32_symlink -TRACE_SYSCALL_TABLE(symlink, symlink, 83, 2) -#endif -#ifndef OVERRIDE_TABLE_32_readlink -TRACE_SYSCALL_TABLE(readlink, readlink, 85, 3) -#endif -#ifndef OVERRIDE_TABLE_32_uselib -TRACE_SYSCALL_TABLE(uselib, uselib, 86, 1) -#endif -#ifndef OVERRIDE_TABLE_32_swapon -TRACE_SYSCALL_TABLE(swapon, swapon, 87, 2) -#endif -#ifndef OVERRIDE_TABLE_32_reboot -TRACE_SYSCALL_TABLE(reboot, reboot, 88, 4) -#endif -#ifndef OVERRIDE_TABLE_32_truncate -TRACE_SYSCALL_TABLE(truncate, truncate, 92, 2) -#endif -#ifndef OVERRIDE_TABLE_32_statfs -TRACE_SYSCALL_TABLE(statfs, statfs, 99, 2) -#endif -#ifndef OVERRIDE_TABLE_32_fstatfs -TRACE_SYSCALL_TABLE(fstatfs, fstatfs, 100, 2) -#endif -#ifndef OVERRIDE_TABLE_32_syslog -TRACE_SYSCALL_TABLE(syslog, syslog, 103, 3) -#endif -#ifndef OVERRIDE_TABLE_32_setitimer -TRACE_SYSCALL_TABLE(setitimer, setitimer, 104, 3) -#endif -#ifndef OVERRIDE_TABLE_32_getitimer -TRACE_SYSCALL_TABLE(getitimer, getitimer, 105, 2) -#endif -#ifndef OVERRIDE_TABLE_32_newstat -TRACE_SYSCALL_TABLE(newstat, newstat, 106, 2) -#endif -#ifndef OVERRIDE_TABLE_32_newlstat -TRACE_SYSCALL_TABLE(newlstat, newlstat, 107, 2) -#endif -#ifndef OVERRIDE_TABLE_32_newfstat -TRACE_SYSCALL_TABLE(newfstat, newfstat, 108, 2) -#endif -#ifndef OVERRIDE_TABLE_32_wait4 -TRACE_SYSCALL_TABLE(wait4, wait4, 114, 4) -#endif -#ifndef OVERRIDE_TABLE_32_swapoff -TRACE_SYSCALL_TABLE(swapoff, swapoff, 115, 1) -#endif -#ifndef OVERRIDE_TABLE_32_sysinfo -TRACE_SYSCALL_TABLE(sysinfo, sysinfo, 116, 1) -#endif -#ifndef OVERRIDE_TABLE_32_setdomainname -TRACE_SYSCALL_TABLE(setdomainname, setdomainname, 121, 2) -#endif -#ifndef OVERRIDE_TABLE_32_newuname -TRACE_SYSCALL_TABLE(newuname, newuname, 122, 1) -#endif -#ifndef OVERRIDE_TABLE_32_adjtimex -TRACE_SYSCALL_TABLE(adjtimex, adjtimex, 124, 1) -#endif -#ifndef OVERRIDE_TABLE_32_sigprocmask -TRACE_SYSCALL_TABLE(sigprocmask, sigprocmask, 126, 3) -#endif -#ifndef OVERRIDE_TABLE_32_init_module -TRACE_SYSCALL_TABLE(init_module, init_module, 128, 3) -#endif -#ifndef OVERRIDE_TABLE_32_delete_module -TRACE_SYSCALL_TABLE(delete_module, delete_module, 129, 2) -#endif -#ifndef OVERRIDE_TABLE_32_quotactl -TRACE_SYSCALL_TABLE(quotactl, quotactl, 131, 4) -#endif -#ifndef OVERRIDE_TABLE_32_llseek -TRACE_SYSCALL_TABLE(llseek, llseek, 140, 5) -#endif -#ifndef OVERRIDE_TABLE_32_getdents -TRACE_SYSCALL_TABLE(getdents, getdents, 141, 3) -#endif -#ifndef OVERRIDE_TABLE_32_select -TRACE_SYSCALL_TABLE(select, select, 142, 5) -#endif -#ifndef OVERRIDE_TABLE_32_readv -TRACE_SYSCALL_TABLE(readv, readv, 145, 3) -#endif -#ifndef OVERRIDE_TABLE_32_writev -TRACE_SYSCALL_TABLE(writev, writev, 146, 3) -#endif -#ifndef OVERRIDE_TABLE_32_sysctl -TRACE_SYSCALL_TABLE(sysctl, sysctl, 149, 1) -#endif -#ifndef OVERRIDE_TABLE_32_sched_setparam -TRACE_SYSCALL_TABLE(sched_setparam, sched_setparam, 154, 2) -#endif -#ifndef OVERRIDE_TABLE_32_sched_getparam -TRACE_SYSCALL_TABLE(sched_getparam, sched_getparam, 155, 2) -#endif -#ifndef OVERRIDE_TABLE_32_sched_setscheduler -TRACE_SYSCALL_TABLE(sched_setscheduler, sched_setscheduler, 156, 3) -#endif -#ifndef OVERRIDE_TABLE_32_sched_rr_get_interval -TRACE_SYSCALL_TABLE(sched_rr_get_interval, sched_rr_get_interval, 161, 2) -#endif -#ifndef OVERRIDE_TABLE_32_nanosleep -TRACE_SYSCALL_TABLE(nanosleep, nanosleep, 162, 2) -#endif -#ifndef OVERRIDE_TABLE_32_getresuid16 -TRACE_SYSCALL_TABLE(getresuid16, getresuid16, 165, 3) -#endif -#ifndef OVERRIDE_TABLE_32_poll -TRACE_SYSCALL_TABLE(poll, poll, 168, 3) -#endif -#ifndef OVERRIDE_TABLE_32_getresgid16 -TRACE_SYSCALL_TABLE(getresgid16, getresgid16, 171, 3) -#endif -#ifndef OVERRIDE_TABLE_32_rt_sigaction -TRACE_SYSCALL_TABLE(rt_sigaction, rt_sigaction, 174, 4) -#endif -#ifndef OVERRIDE_TABLE_32_rt_sigprocmask -TRACE_SYSCALL_TABLE(rt_sigprocmask, rt_sigprocmask, 175, 4) -#endif -#ifndef OVERRIDE_TABLE_32_rt_sigpending -TRACE_SYSCALL_TABLE(rt_sigpending, rt_sigpending, 176, 2) -#endif -#ifndef OVERRIDE_TABLE_32_rt_sigtimedwait -TRACE_SYSCALL_TABLE(rt_sigtimedwait, rt_sigtimedwait, 177, 4) -#endif -#ifndef OVERRIDE_TABLE_32_rt_sigqueueinfo -TRACE_SYSCALL_TABLE(rt_sigqueueinfo, rt_sigqueueinfo, 178, 3) -#endif -#ifndef OVERRIDE_TABLE_32_rt_sigsuspend -TRACE_SYSCALL_TABLE(rt_sigsuspend, rt_sigsuspend, 179, 2) -#endif -#ifndef OVERRIDE_TABLE_32_chown16 -TRACE_SYSCALL_TABLE(chown16, chown16, 182, 3) -#endif -#ifndef OVERRIDE_TABLE_32_getcwd -TRACE_SYSCALL_TABLE(getcwd, getcwd, 183, 2) -#endif -#ifndef OVERRIDE_TABLE_32_sendfile -TRACE_SYSCALL_TABLE(sendfile, sendfile, 187, 4) -#endif -#ifndef OVERRIDE_TABLE_32_getrlimit -TRACE_SYSCALL_TABLE(getrlimit, getrlimit, 191, 2) -#endif -#ifndef OVERRIDE_TABLE_32_stat64 -TRACE_SYSCALL_TABLE(stat64, stat64, 195, 2) -#endif -#ifndef OVERRIDE_TABLE_32_lstat64 -TRACE_SYSCALL_TABLE(lstat64, lstat64, 196, 2) -#endif -#ifndef OVERRIDE_TABLE_32_fstat64 -TRACE_SYSCALL_TABLE(fstat64, fstat64, 197, 2) -#endif -#ifndef OVERRIDE_TABLE_32_lchown -TRACE_SYSCALL_TABLE(lchown, lchown, 198, 3) -#endif -#ifndef OVERRIDE_TABLE_32_getgroups -TRACE_SYSCALL_TABLE(getgroups, getgroups, 205, 2) -#endif -#ifndef OVERRIDE_TABLE_32_setgroups -TRACE_SYSCALL_TABLE(setgroups, setgroups, 206, 2) -#endif -#ifndef OVERRIDE_TABLE_32_getresuid -TRACE_SYSCALL_TABLE(getresuid, getresuid, 209, 3) -#endif -#ifndef OVERRIDE_TABLE_32_getresgid -TRACE_SYSCALL_TABLE(getresgid, getresgid, 211, 3) -#endif -#ifndef OVERRIDE_TABLE_32_chown -TRACE_SYSCALL_TABLE(chown, chown, 212, 3) -#endif -#ifndef OVERRIDE_TABLE_32_getdents64 -TRACE_SYSCALL_TABLE(getdents64, getdents64, 217, 3) -#endif -#ifndef OVERRIDE_TABLE_32_pivot_root -TRACE_SYSCALL_TABLE(pivot_root, pivot_root, 218, 2) -#endif -#ifndef OVERRIDE_TABLE_32_mincore -TRACE_SYSCALL_TABLE(mincore, mincore, 219, 3) -#endif -#ifndef OVERRIDE_TABLE_32_setxattr -TRACE_SYSCALL_TABLE(setxattr, setxattr, 226, 5) -#endif -#ifndef OVERRIDE_TABLE_32_lsetxattr -TRACE_SYSCALL_TABLE(lsetxattr, lsetxattr, 227, 5) -#endif -#ifndef OVERRIDE_TABLE_32_fsetxattr -TRACE_SYSCALL_TABLE(fsetxattr, fsetxattr, 228, 5) -#endif -#ifndef OVERRIDE_TABLE_32_getxattr -TRACE_SYSCALL_TABLE(getxattr, getxattr, 229, 4) -#endif -#ifndef OVERRIDE_TABLE_32_lgetxattr -TRACE_SYSCALL_TABLE(lgetxattr, lgetxattr, 230, 4) -#endif -#ifndef OVERRIDE_TABLE_32_fgetxattr -TRACE_SYSCALL_TABLE(fgetxattr, fgetxattr, 231, 4) -#endif -#ifndef OVERRIDE_TABLE_32_listxattr -TRACE_SYSCALL_TABLE(listxattr, listxattr, 232, 3) -#endif -#ifndef OVERRIDE_TABLE_32_llistxattr -TRACE_SYSCALL_TABLE(llistxattr, llistxattr, 233, 3) -#endif -#ifndef OVERRIDE_TABLE_32_flistxattr -TRACE_SYSCALL_TABLE(flistxattr, flistxattr, 234, 3) -#endif -#ifndef OVERRIDE_TABLE_32_removexattr -TRACE_SYSCALL_TABLE(removexattr, removexattr, 235, 2) -#endif -#ifndef OVERRIDE_TABLE_32_lremovexattr -TRACE_SYSCALL_TABLE(lremovexattr, lremovexattr, 236, 2) -#endif -#ifndef OVERRIDE_TABLE_32_fremovexattr -TRACE_SYSCALL_TABLE(fremovexattr, fremovexattr, 237, 2) -#endif -#ifndef OVERRIDE_TABLE_32_sendfile64 -TRACE_SYSCALL_TABLE(sendfile64, sendfile64, 239, 4) -#endif -#ifndef OVERRIDE_TABLE_32_futex -TRACE_SYSCALL_TABLE(futex, futex, 240, 6) -#endif -#ifndef OVERRIDE_TABLE_32_sched_setaffinity -TRACE_SYSCALL_TABLE(sched_setaffinity, sched_setaffinity, 241, 3) -#endif -#ifndef OVERRIDE_TABLE_32_sched_getaffinity -TRACE_SYSCALL_TABLE(sched_getaffinity, sched_getaffinity, 242, 3) -#endif -#ifndef OVERRIDE_TABLE_32_io_setup -TRACE_SYSCALL_TABLE(io_setup, io_setup, 243, 2) -#endif -#ifndef OVERRIDE_TABLE_32_io_getevents -TRACE_SYSCALL_TABLE(io_getevents, io_getevents, 245, 5) -#endif -#ifndef OVERRIDE_TABLE_32_io_submit -TRACE_SYSCALL_TABLE(io_submit, io_submit, 246, 3) -#endif -#ifndef OVERRIDE_TABLE_32_io_cancel -TRACE_SYSCALL_TABLE(io_cancel, io_cancel, 247, 3) -#endif -#ifndef OVERRIDE_TABLE_32_epoll_ctl -TRACE_SYSCALL_TABLE(epoll_ctl, epoll_ctl, 251, 4) -#endif -#ifndef OVERRIDE_TABLE_32_epoll_wait -TRACE_SYSCALL_TABLE(epoll_wait, epoll_wait, 252, 4) -#endif -#ifndef OVERRIDE_TABLE_32_set_tid_address -TRACE_SYSCALL_TABLE(set_tid_address, set_tid_address, 256, 1) -#endif -#ifndef OVERRIDE_TABLE_32_timer_create -TRACE_SYSCALL_TABLE(timer_create, timer_create, 257, 3) -#endif -#ifndef OVERRIDE_TABLE_32_timer_settime -TRACE_SYSCALL_TABLE(timer_settime, timer_settime, 258, 4) -#endif -#ifndef OVERRIDE_TABLE_32_timer_gettime -TRACE_SYSCALL_TABLE(timer_gettime, timer_gettime, 259, 2) -#endif -#ifndef OVERRIDE_TABLE_32_clock_settime -TRACE_SYSCALL_TABLE(clock_settime, clock_settime, 262, 2) -#endif -#ifndef OVERRIDE_TABLE_32_clock_gettime -TRACE_SYSCALL_TABLE(clock_gettime, clock_gettime, 263, 2) -#endif -#ifndef OVERRIDE_TABLE_32_clock_getres -TRACE_SYSCALL_TABLE(clock_getres, clock_getres, 264, 2) -#endif -#ifndef OVERRIDE_TABLE_32_clock_nanosleep -TRACE_SYSCALL_TABLE(clock_nanosleep, clock_nanosleep, 265, 4) -#endif -#ifndef OVERRIDE_TABLE_32_utimes -TRACE_SYSCALL_TABLE(utimes, utimes, 269, 2) -#endif -#ifndef OVERRIDE_TABLE_32_mq_open -TRACE_SYSCALL_TABLE(mq_open, mq_open, 274, 4) -#endif -#ifndef OVERRIDE_TABLE_32_mq_unlink -TRACE_SYSCALL_TABLE(mq_unlink, mq_unlink, 275, 1) -#endif -#ifndef OVERRIDE_TABLE_32_mq_timedsend -TRACE_SYSCALL_TABLE(mq_timedsend, mq_timedsend, 276, 5) -#endif -#ifndef OVERRIDE_TABLE_32_mq_timedreceive -TRACE_SYSCALL_TABLE(mq_timedreceive, mq_timedreceive, 277, 5) -#endif -#ifndef OVERRIDE_TABLE_32_mq_notify -TRACE_SYSCALL_TABLE(mq_notify, mq_notify, 278, 2) -#endif -#ifndef OVERRIDE_TABLE_32_mq_getsetattr -TRACE_SYSCALL_TABLE(mq_getsetattr, mq_getsetattr, 279, 3) -#endif -#ifndef OVERRIDE_TABLE_32_waitid -TRACE_SYSCALL_TABLE(waitid, waitid, 280, 5) -#endif -#ifndef OVERRIDE_TABLE_32_bind -TRACE_SYSCALL_TABLE(bind, bind, 282, 3) -#endif -#ifndef OVERRIDE_TABLE_32_connect -TRACE_SYSCALL_TABLE(connect, connect, 283, 3) -#endif -#ifndef OVERRIDE_TABLE_32_accept -TRACE_SYSCALL_TABLE(accept, accept, 285, 3) -#endif -#ifndef OVERRIDE_TABLE_32_getsockname -TRACE_SYSCALL_TABLE(getsockname, getsockname, 286, 3) -#endif -#ifndef OVERRIDE_TABLE_32_getpeername -TRACE_SYSCALL_TABLE(getpeername, getpeername, 287, 3) -#endif -#ifndef OVERRIDE_TABLE_32_socketpair -TRACE_SYSCALL_TABLE(socketpair, socketpair, 288, 4) -#endif -#ifndef OVERRIDE_TABLE_32_send -TRACE_SYSCALL_TABLE(send, send, 289, 4) -#endif -#ifndef OVERRIDE_TABLE_32_sendto -TRACE_SYSCALL_TABLE(sendto, sendto, 290, 6) -#endif -#ifndef OVERRIDE_TABLE_32_recvfrom -TRACE_SYSCALL_TABLE(recvfrom, recvfrom, 292, 6) -#endif -#ifndef OVERRIDE_TABLE_32_setsockopt -TRACE_SYSCALL_TABLE(setsockopt, setsockopt, 294, 5) -#endif -#ifndef OVERRIDE_TABLE_32_getsockopt -TRACE_SYSCALL_TABLE(getsockopt, getsockopt, 295, 5) -#endif -#ifndef OVERRIDE_TABLE_32_sendmsg -TRACE_SYSCALL_TABLE(sendmsg, sendmsg, 296, 3) -#endif -#ifndef OVERRIDE_TABLE_32_recvmsg -TRACE_SYSCALL_TABLE(recvmsg, recvmsg, 297, 3) -#endif -#ifndef OVERRIDE_TABLE_32_semop -TRACE_SYSCALL_TABLE(semop, semop, 298, 3) -#endif -#ifndef OVERRIDE_TABLE_32_msgsnd -TRACE_SYSCALL_TABLE(msgsnd, msgsnd, 301, 4) -#endif -#ifndef OVERRIDE_TABLE_32_msgrcv -TRACE_SYSCALL_TABLE(msgrcv, msgrcv, 302, 5) -#endif -#ifndef OVERRIDE_TABLE_32_msgctl -TRACE_SYSCALL_TABLE(msgctl, msgctl, 304, 3) -#endif -#ifndef OVERRIDE_TABLE_32_shmat -TRACE_SYSCALL_TABLE(shmat, shmat, 305, 3) -#endif -#ifndef OVERRIDE_TABLE_32_shmdt -TRACE_SYSCALL_TABLE(shmdt, shmdt, 306, 1) -#endif -#ifndef OVERRIDE_TABLE_32_shmctl -TRACE_SYSCALL_TABLE(shmctl, shmctl, 308, 3) -#endif -#ifndef OVERRIDE_TABLE_32_add_key -TRACE_SYSCALL_TABLE(add_key, add_key, 309, 5) -#endif -#ifndef OVERRIDE_TABLE_32_request_key -TRACE_SYSCALL_TABLE(request_key, request_key, 310, 4) -#endif -#ifndef OVERRIDE_TABLE_32_semtimedop -TRACE_SYSCALL_TABLE(semtimedop, semtimedop, 312, 4) -#endif -#ifndef OVERRIDE_TABLE_32_inotify_add_watch -TRACE_SYSCALL_TABLE(inotify_add_watch, inotify_add_watch, 317, 3) -#endif -#ifndef OVERRIDE_TABLE_32_openat -TRACE_SYSCALL_TABLE(openat, openat, 322, 4) -#endif -#ifndef OVERRIDE_TABLE_32_mkdirat -TRACE_SYSCALL_TABLE(mkdirat, mkdirat, 323, 3) -#endif -#ifndef OVERRIDE_TABLE_32_mknodat -TRACE_SYSCALL_TABLE(mknodat, mknodat, 324, 4) -#endif -#ifndef OVERRIDE_TABLE_32_fchownat -TRACE_SYSCALL_TABLE(fchownat, fchownat, 325, 5) -#endif -#ifndef OVERRIDE_TABLE_32_futimesat -TRACE_SYSCALL_TABLE(futimesat, futimesat, 326, 3) -#endif -#ifndef OVERRIDE_TABLE_32_fstatat64 -TRACE_SYSCALL_TABLE(fstatat64, fstatat64, 327, 4) -#endif -#ifndef OVERRIDE_TABLE_32_unlinkat -TRACE_SYSCALL_TABLE(unlinkat, unlinkat, 328, 3) -#endif -#ifndef OVERRIDE_TABLE_32_renameat -TRACE_SYSCALL_TABLE(renameat, renameat, 329, 4) -#endif -#ifndef OVERRIDE_TABLE_32_linkat -TRACE_SYSCALL_TABLE(linkat, linkat, 330, 5) -#endif -#ifndef OVERRIDE_TABLE_32_symlinkat -TRACE_SYSCALL_TABLE(symlinkat, symlinkat, 331, 3) -#endif -#ifndef OVERRIDE_TABLE_32_readlinkat -TRACE_SYSCALL_TABLE(readlinkat, readlinkat, 332, 4) -#endif -#ifndef OVERRIDE_TABLE_32_fchmodat -TRACE_SYSCALL_TABLE(fchmodat, fchmodat, 333, 3) -#endif -#ifndef OVERRIDE_TABLE_32_faccessat -TRACE_SYSCALL_TABLE(faccessat, faccessat, 334, 3) -#endif -#ifndef OVERRIDE_TABLE_32_pselect6 -TRACE_SYSCALL_TABLE(pselect6, pselect6, 335, 6) -#endif -#ifndef OVERRIDE_TABLE_32_ppoll -TRACE_SYSCALL_TABLE(ppoll, ppoll, 336, 5) -#endif -#ifndef OVERRIDE_TABLE_32_set_robust_list -TRACE_SYSCALL_TABLE(set_robust_list, set_robust_list, 338, 2) -#endif -#ifndef OVERRIDE_TABLE_32_get_robust_list -TRACE_SYSCALL_TABLE(get_robust_list, get_robust_list, 339, 3) -#endif -#ifndef OVERRIDE_TABLE_32_splice -TRACE_SYSCALL_TABLE(splice, splice, 340, 6) -#endif -#ifndef OVERRIDE_TABLE_32_vmsplice -TRACE_SYSCALL_TABLE(vmsplice, vmsplice, 343, 4) -#endif -#ifndef OVERRIDE_TABLE_32_getcpu -TRACE_SYSCALL_TABLE(getcpu, getcpu, 345, 3) -#endif -#ifndef OVERRIDE_TABLE_32_epoll_pwait -TRACE_SYSCALL_TABLE(epoll_pwait, epoll_pwait, 346, 6) -#endif -#ifndef OVERRIDE_TABLE_32_utimensat -TRACE_SYSCALL_TABLE(utimensat, utimensat, 348, 4) -#endif -#ifndef OVERRIDE_TABLE_32_signalfd -TRACE_SYSCALL_TABLE(signalfd, signalfd, 349, 3) -#endif -#ifndef OVERRIDE_TABLE_32_timerfd_settime -TRACE_SYSCALL_TABLE(timerfd_settime, timerfd_settime, 353, 4) -#endif -#ifndef OVERRIDE_TABLE_32_timerfd_gettime -TRACE_SYSCALL_TABLE(timerfd_gettime, timerfd_gettime, 354, 2) -#endif -#ifndef OVERRIDE_TABLE_32_signalfd4 -TRACE_SYSCALL_TABLE(signalfd4, signalfd4, 355, 4) -#endif -#ifndef OVERRIDE_TABLE_32_pipe2 -TRACE_SYSCALL_TABLE(pipe2, pipe2, 359, 2) -#endif -#ifndef OVERRIDE_TABLE_32_preadv -TRACE_SYSCALL_TABLE(preadv, preadv, 361, 5) -#endif -#ifndef OVERRIDE_TABLE_32_pwritev -TRACE_SYSCALL_TABLE(pwritev, pwritev, 362, 5) -#endif -#ifndef OVERRIDE_TABLE_32_rt_tgsigqueueinfo -TRACE_SYSCALL_TABLE(rt_tgsigqueueinfo, rt_tgsigqueueinfo, 363, 4) -#endif -#ifndef OVERRIDE_TABLE_32_perf_event_open -TRACE_SYSCALL_TABLE(perf_event_open, perf_event_open, 364, 5) -#endif -#ifndef OVERRIDE_TABLE_32_recvmmsg -TRACE_SYSCALL_TABLE(recvmmsg, recvmmsg, 365, 5) -#endif -#ifndef OVERRIDE_TABLE_32_accept4 -TRACE_SYSCALL_TABLE(accept4, accept4, 366, 4) -#endif -#ifndef OVERRIDE_TABLE_32_prlimit64 -TRACE_SYSCALL_TABLE(prlimit64, prlimit64, 369, 4) -#endif -#ifndef OVERRIDE_TABLE_32_name_to_handle_at -TRACE_SYSCALL_TABLE(name_to_handle_at, name_to_handle_at, 370, 5) -#endif -#ifndef OVERRIDE_TABLE_32_open_by_handle_at -TRACE_SYSCALL_TABLE(open_by_handle_at, open_by_handle_at, 371, 3) -#endif -#ifndef OVERRIDE_TABLE_32_clock_adjtime -TRACE_SYSCALL_TABLE(clock_adjtime, clock_adjtime, 372, 2) -#endif -#ifndef OVERRIDE_TABLE_32_sendmmsg -TRACE_SYSCALL_TABLE(sendmmsg, sendmmsg, 374, 4) -#endif -#ifndef OVERRIDE_TABLE_32_process_vm_readv -TRACE_SYSCALL_TABLE(process_vm_readv, process_vm_readv, 376, 6) -#endif -#ifndef OVERRIDE_TABLE_32_process_vm_writev -TRACE_SYSCALL_TABLE(process_vm_writev, process_vm_writev, 377, 6) -#endif - -#endif /* CREATE_SYSCALL_TABLE */ diff --git a/instrumentation/syscalls/headers/arm-32-syscalls_pointers_override.h b/instrumentation/syscalls/headers/arm-32-syscalls_pointers_override.h deleted file mode 100644 index 68ba1c4e..00000000 --- a/instrumentation/syscalls/headers/arm-32-syscalls_pointers_override.h +++ /dev/null @@ -1,43 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ - -#define OVERRIDE_TABLE_32_mmap2 - -# ifndef CONFIG_UID16 -# define OVERRIDE_32_getgroups16 -# define OVERRIDE_32_setgroups16 -# define OVERRIDE_32_lchown16 -# define OVERRIDE_32_getresuid16 -# define OVERRIDE_32_getresgid16 -# define OVERRIDE_32_chown16 -# endif - -#ifndef CREATE_SYSCALL_TABLE - -#define OVERRIDE_32_pipe -SC_LTTNG_TRACEPOINT_EVENT(pipe, - TP_PROTO(sc_exit(long ret,) int * fildes), - TP_ARGS(sc_exit(ret,) fildes), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) - sc_out(ctf_user_array(int, fildes, fildes, 2)) - ) -) - -#else /* CREATE_SYSCALL_TABLE */ - -# ifndef CONFIG_UID16 -# define OVERRIDE_TABLE_32_getgroups16 -# define OVERRIDE_TABLE_32_setgroups16 -# define OVERRIDE_TABLE_32_lchown16 -# define OVERRIDE_TABLE_32_getresuid16 -# define OVERRIDE_TABLE_32_getresgid16 -# define OVERRIDE_TABLE_32_chown16 -# endif - -#define OVERRIDE_TABLE_32_execve -TRACE_SYSCALL_TABLE(execve, execve, 11, 3) -#define OVERRIDE_TABLE_32_clone -TRACE_SYSCALL_TABLE(clone, clone, 120, 5) - -#endif /* CREATE_SYSCALL_TABLE */ - - diff --git a/instrumentation/syscalls/headers/arm-64-syscalls_integers.h b/instrumentation/syscalls/headers/arm-64-syscalls_integers.h deleted file mode 100644 index 57d2c66b..00000000 --- a/instrumentation/syscalls/headers/arm-64-syscalls_integers.h +++ /dev/null @@ -1,1016 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ - -/* THIS FILE IS AUTO-GENERATED. DO NOT EDIT */ - -/* Generated from arm-64-syscalls 4.4.0 */ - -#ifndef CREATE_SYSCALL_TABLE - -#if !defined(_TRACE_SYSCALLS_INTEGERS_H) || defined(TRACE_HEADER_MULTI_READ) -#define _TRACE_SYSCALLS_INTEGERS_H - -#include -#include -#include "arm-64-syscalls_integers_override.h" -#include "syscalls_integers_override.h" - -#ifdef SC_ENTER -SC_LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(syscalls_noargs, - TP_FIELDS() -) -#ifndef OVERRIDE_64_vhangup -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, vhangup) -#endif -#ifndef OVERRIDE_64_sync -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, sync) -#endif -#ifndef OVERRIDE_64_sched_yield -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, sched_yield) -#endif -#ifndef OVERRIDE_64_restart_syscall -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, restart_syscall) -#endif -#ifndef OVERRIDE_64_setsid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, setsid) -#endif -#ifndef OVERRIDE_64_getpid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getpid) -#endif -#ifndef OVERRIDE_64_getppid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getppid) -#endif -#ifndef OVERRIDE_64_getuid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getuid) -#endif -#ifndef OVERRIDE_64_geteuid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, geteuid) -#endif -#ifndef OVERRIDE_64_getgid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getgid) -#endif -#ifndef OVERRIDE_64_getegid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getegid) -#endif -#ifndef OVERRIDE_64_gettid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, gettid) -#endif -#ifndef OVERRIDE_64_munlockall -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, munlockall) -#endif -#else /* #ifdef SC_ENTER */ -#ifndef OVERRIDE_64_vhangup -SC_LTTNG_TRACEPOINT_EVENT(vhangup, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_64_sync -SC_LTTNG_TRACEPOINT_EVENT(sync, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_64_sched_yield -SC_LTTNG_TRACEPOINT_EVENT(sched_yield, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_64_restart_syscall -SC_LTTNG_TRACEPOINT_EVENT(restart_syscall, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_64_setsid -SC_LTTNG_TRACEPOINT_EVENT(setsid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_64_getpid -SC_LTTNG_TRACEPOINT_EVENT(getpid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_64_getppid -SC_LTTNG_TRACEPOINT_EVENT(getppid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_64_getuid -SC_LTTNG_TRACEPOINT_EVENT(getuid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_64_geteuid -SC_LTTNG_TRACEPOINT_EVENT(geteuid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_64_getgid -SC_LTTNG_TRACEPOINT_EVENT(getgid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_64_getegid -SC_LTTNG_TRACEPOINT_EVENT(getegid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_64_gettid -SC_LTTNG_TRACEPOINT_EVENT(gettid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_64_munlockall -SC_LTTNG_TRACEPOINT_EVENT(munlockall, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#endif /* else #ifdef SC_ENTER */ -#ifndef OVERRIDE_64_io_destroy -SC_LTTNG_TRACEPOINT_EVENT(io_destroy, - TP_PROTO(sc_exit(long ret,) aio_context_t ctx), - TP_ARGS(sc_exit(ret,) ctx), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx, ctx))) -) -#endif -#ifndef OVERRIDE_64_epoll_create1 -SC_LTTNG_TRACEPOINT_EVENT(epoll_create1, - TP_PROTO(sc_exit(long ret,) int flags), - TP_ARGS(sc_exit(ret,) flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_dup -SC_LTTNG_TRACEPOINT_EVENT(dup, - TP_PROTO(sc_exit(long ret,) unsigned int fildes), - TP_ARGS(sc_exit(ret,) fildes), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fildes, fildes))) -) -#endif -#ifndef OVERRIDE_64_inotify_init1 -SC_LTTNG_TRACEPOINT_EVENT(inotify_init1, - TP_PROTO(sc_exit(long ret,) int flags), - TP_ARGS(sc_exit(ret,) flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_fchdir -SC_LTTNG_TRACEPOINT_EVENT(fchdir, - TP_PROTO(sc_exit(long ret,) unsigned int fd), - TP_ARGS(sc_exit(ret,) fd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) -) -#endif -#ifndef OVERRIDE_64_close -SC_LTTNG_TRACEPOINT_EVENT(close, - TP_PROTO(sc_exit(long ret,) unsigned int fd), - TP_ARGS(sc_exit(ret,) fd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) -) -#endif -#ifndef OVERRIDE_64_fsync -SC_LTTNG_TRACEPOINT_EVENT(fsync, - TP_PROTO(sc_exit(long ret,) unsigned int fd), - TP_ARGS(sc_exit(ret,) fd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) -) -#endif -#ifndef OVERRIDE_64_fdatasync -SC_LTTNG_TRACEPOINT_EVENT(fdatasync, - TP_PROTO(sc_exit(long ret,) unsigned int fd), - TP_ARGS(sc_exit(ret,) fd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) -) -#endif -#ifndef OVERRIDE_64_personality -SC_LTTNG_TRACEPOINT_EVENT(personality, - TP_PROTO(sc_exit(long ret,) unsigned int personality), - TP_ARGS(sc_exit(ret,) personality), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, personality, personality))) -) -#endif -#ifndef OVERRIDE_64_exit -SC_LTTNG_TRACEPOINT_EVENT(exit, - TP_PROTO(sc_exit(long ret,) int error_code), - TP_ARGS(sc_exit(ret,) error_code), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, error_code, error_code))) -) -#endif -#ifndef OVERRIDE_64_exit_group -SC_LTTNG_TRACEPOINT_EVENT(exit_group, - TP_PROTO(sc_exit(long ret,) int error_code), - TP_ARGS(sc_exit(ret,) error_code), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, error_code, error_code))) -) -#endif -#ifndef OVERRIDE_64_unshare -SC_LTTNG_TRACEPOINT_EVENT(unshare, - TP_PROTO(sc_exit(long ret,) unsigned long unshare_flags), - TP_ARGS(sc_exit(ret,) unshare_flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, unshare_flags, unshare_flags))) -) -#endif -#ifndef OVERRIDE_64_timer_getoverrun -SC_LTTNG_TRACEPOINT_EVENT(timer_getoverrun, - TP_PROTO(sc_exit(long ret,) timer_t timer_id), - TP_ARGS(sc_exit(ret,) timer_id), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id))) -) -#endif -#ifndef OVERRIDE_64_timer_delete -SC_LTTNG_TRACEPOINT_EVENT(timer_delete, - TP_PROTO(sc_exit(long ret,) timer_t timer_id), - TP_ARGS(sc_exit(ret,) timer_id), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id))) -) -#endif -#ifndef OVERRIDE_64_sched_getscheduler -SC_LTTNG_TRACEPOINT_EVENT(sched_getscheduler, - TP_PROTO(sc_exit(long ret,) pid_t pid), - TP_ARGS(sc_exit(ret,) pid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid))) -) -#endif -#ifndef OVERRIDE_64_sched_get_priority_max -SC_LTTNG_TRACEPOINT_EVENT(sched_get_priority_max, - TP_PROTO(sc_exit(long ret,) int policy), - TP_ARGS(sc_exit(ret,) policy), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, policy, policy))) -) -#endif -#ifndef OVERRIDE_64_sched_get_priority_min -SC_LTTNG_TRACEPOINT_EVENT(sched_get_priority_min, - TP_PROTO(sc_exit(long ret,) int policy), - TP_ARGS(sc_exit(ret,) policy), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, policy, policy))) -) -#endif -#ifndef OVERRIDE_64_setgid -SC_LTTNG_TRACEPOINT_EVENT(setgid, - TP_PROTO(sc_exit(long ret,) gid_t gid), - TP_ARGS(sc_exit(ret,) gid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, gid, gid))) -) -#endif -#ifndef OVERRIDE_64_setuid -SC_LTTNG_TRACEPOINT_EVENT(setuid, - TP_PROTO(sc_exit(long ret,) uid_t uid), - TP_ARGS(sc_exit(ret,) uid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, uid, uid))) -) -#endif -#ifndef OVERRIDE_64_setfsuid -SC_LTTNG_TRACEPOINT_EVENT(setfsuid, - TP_PROTO(sc_exit(long ret,) uid_t uid), - TP_ARGS(sc_exit(ret,) uid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, uid, uid))) -) -#endif -#ifndef OVERRIDE_64_setfsgid -SC_LTTNG_TRACEPOINT_EVENT(setfsgid, - TP_PROTO(sc_exit(long ret,) gid_t gid), - TP_ARGS(sc_exit(ret,) gid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, gid, gid))) -) -#endif -#ifndef OVERRIDE_64_getpgid -SC_LTTNG_TRACEPOINT_EVENT(getpgid, - TP_PROTO(sc_exit(long ret,) pid_t pid), - TP_ARGS(sc_exit(ret,) pid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid))) -) -#endif -#ifndef OVERRIDE_64_getsid -SC_LTTNG_TRACEPOINT_EVENT(getsid, - TP_PROTO(sc_exit(long ret,) pid_t pid), - TP_ARGS(sc_exit(ret,) pid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid))) -) -#endif -#ifndef OVERRIDE_64_umask -SC_LTTNG_TRACEPOINT_EVENT(umask, - TP_PROTO(sc_exit(long ret,) int mask), - TP_ARGS(sc_exit(ret,) mask), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, mask, mask))) -) -#endif -#ifndef OVERRIDE_64_brk -SC_LTTNG_TRACEPOINT_EVENT(brk, - TP_PROTO(sc_exit(long ret,) unsigned long brk), - TP_ARGS(sc_exit(ret,) brk), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, brk, brk))) -) -#endif -#ifndef OVERRIDE_64_mlockall -SC_LTTNG_TRACEPOINT_EVENT(mlockall, - TP_PROTO(sc_exit(long ret,) int flags), - TP_ARGS(sc_exit(ret,) flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_syncfs -SC_LTTNG_TRACEPOINT_EVENT(syncfs, - TP_PROTO(sc_exit(long ret,) int fd), - TP_ARGS(sc_exit(ret,) fd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd))) -) -#endif -#ifndef OVERRIDE_64_eventfd2 -SC_LTTNG_TRACEPOINT_EVENT(eventfd2, - TP_PROTO(sc_exit(long ret,) unsigned int count, int flags), - TP_ARGS(sc_exit(ret,) count, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, count, count)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_inotify_rm_watch -SC_LTTNG_TRACEPOINT_EVENT(inotify_rm_watch, - TP_PROTO(sc_exit(long ret,) int fd, __s32 wd), - TP_ARGS(sc_exit(ret,) fd, wd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(__s32, wd, wd))) -) -#endif -#ifndef OVERRIDE_64_ioprio_get -SC_LTTNG_TRACEPOINT_EVENT(ioprio_get, - TP_PROTO(sc_exit(long ret,) int which, int who), - TP_ARGS(sc_exit(ret,) which, who), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who))) -) -#endif -#ifndef OVERRIDE_64_flock -SC_LTTNG_TRACEPOINT_EVENT(flock, - TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd), - TP_ARGS(sc_exit(ret,) fd, cmd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned int, cmd, cmd))) -) -#endif -#ifndef OVERRIDE_64_ftruncate -SC_LTTNG_TRACEPOINT_EVENT(ftruncate, - TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned long length), - TP_ARGS(sc_exit(ret,) fd, length), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned long, length, length))) -) -#endif -#ifndef OVERRIDE_64_fchmod -SC_LTTNG_TRACEPOINT_EVENT(fchmod, - TP_PROTO(sc_exit(long ret,) unsigned int fd, umode_t mode), - TP_ARGS(sc_exit(ret,) fd, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(umode_t, mode, mode))) -) -#endif -#ifndef OVERRIDE_64_timerfd_create -SC_LTTNG_TRACEPOINT_EVENT(timerfd_create, - TP_PROTO(sc_exit(long ret,) int clockid, int flags), - TP_ARGS(sc_exit(ret,) clockid, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, clockid, clockid)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_kill -SC_LTTNG_TRACEPOINT_EVENT(kill, - TP_PROTO(sc_exit(long ret,) pid_t pid, int sig), - TP_ARGS(sc_exit(ret,) pid, sig), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig))) -) -#endif -#ifndef OVERRIDE_64_tkill -SC_LTTNG_TRACEPOINT_EVENT(tkill, - TP_PROTO(sc_exit(long ret,) pid_t pid, int sig), - TP_ARGS(sc_exit(ret,) pid, sig), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig))) -) -#endif -#ifndef OVERRIDE_64_getpriority -SC_LTTNG_TRACEPOINT_EVENT(getpriority, - TP_PROTO(sc_exit(long ret,) int which, int who), - TP_ARGS(sc_exit(ret,) which, who), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who))) -) -#endif -#ifndef OVERRIDE_64_setregid -SC_LTTNG_TRACEPOINT_EVENT(setregid, - TP_PROTO(sc_exit(long ret,) gid_t rgid, gid_t egid), - TP_ARGS(sc_exit(ret,) rgid, egid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, rgid, rgid)) sc_in(ctf_integer(gid_t, egid, egid))) -) -#endif -#ifndef OVERRIDE_64_setreuid -SC_LTTNG_TRACEPOINT_EVENT(setreuid, - TP_PROTO(sc_exit(long ret,) uid_t ruid, uid_t euid), - TP_ARGS(sc_exit(ret,) ruid, euid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, ruid, ruid)) sc_in(ctf_integer(uid_t, euid, euid))) -) -#endif -#ifndef OVERRIDE_64_setpgid -SC_LTTNG_TRACEPOINT_EVENT(setpgid, - TP_PROTO(sc_exit(long ret,) pid_t pid, pid_t pgid), - TP_ARGS(sc_exit(ret,) pid, pgid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(pid_t, pgid, pgid))) -) -#endif -#ifndef OVERRIDE_64_msgget -SC_LTTNG_TRACEPOINT_EVENT(msgget, - TP_PROTO(sc_exit(long ret,) key_t key, int msgflg), - TP_ARGS(sc_exit(ret,) key, msgflg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(key_t, key, key)) sc_in(ctf_integer(int, msgflg, msgflg))) -) -#endif -#ifndef OVERRIDE_64_listen -SC_LTTNG_TRACEPOINT_EVENT(listen, - TP_PROTO(sc_exit(long ret,) int fd, int backlog), - TP_ARGS(sc_exit(ret,) fd, backlog), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, backlog, backlog))) -) -#endif -#ifndef OVERRIDE_64_shutdown -SC_LTTNG_TRACEPOINT_EVENT(shutdown, - TP_PROTO(sc_exit(long ret,) int fd, int how), - TP_ARGS(sc_exit(ret,) fd, how), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, how, how))) -) -#endif -#ifndef OVERRIDE_64_munmap -SC_LTTNG_TRACEPOINT_EVENT(munmap, - TP_PROTO(sc_exit(long ret,) unsigned long addr, size_t len), - TP_ARGS(sc_exit(ret,) addr, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, addr, addr)) sc_in(ctf_integer(size_t, len, len))) -) -#endif -#ifndef OVERRIDE_64_mlock -SC_LTTNG_TRACEPOINT_EVENT(mlock, - TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len), - TP_ARGS(sc_exit(ret,) start, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len))) -) -#endif -#ifndef OVERRIDE_64_munlock -SC_LTTNG_TRACEPOINT_EVENT(munlock, - TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len), - TP_ARGS(sc_exit(ret,) start, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len))) -) -#endif -#ifndef OVERRIDE_64_fanotify_init -SC_LTTNG_TRACEPOINT_EVENT(fanotify_init, - TP_PROTO(sc_exit(long ret,) unsigned int flags, unsigned int event_f_flags), - TP_ARGS(sc_exit(ret,) flags, event_f_flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, flags, flags)) sc_in(ctf_integer(unsigned int, event_f_flags, event_f_flags))) -) -#endif -#ifndef OVERRIDE_64_setns -SC_LTTNG_TRACEPOINT_EVENT(setns, - TP_PROTO(sc_exit(long ret,) int fd, int nstype), - TP_ARGS(sc_exit(ret,) fd, nstype), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, nstype, nstype))) -) -#endif -#ifndef OVERRIDE_64_membarrier -SC_LTTNG_TRACEPOINT_EVENT(membarrier, - TP_PROTO(sc_exit(long ret,) int cmd, int flags), - TP_ARGS(sc_exit(ret,) cmd, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, cmd, cmd)) sc_inout(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_dup3 -SC_LTTNG_TRACEPOINT_EVENT(dup3, - TP_PROTO(sc_exit(long ret,) unsigned int oldfd, unsigned int newfd, int flags), - TP_ARGS(sc_exit(ret,) oldfd, newfd, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, oldfd, oldfd)) sc_in(ctf_integer(unsigned int, newfd, newfd)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_fcntl -SC_LTTNG_TRACEPOINT_EVENT(fcntl, - TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd, unsigned long arg), - TP_ARGS(sc_exit(ret,) fd, cmd, arg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_inout(ctf_integer(unsigned long, arg, arg))) -) -#endif -#ifndef OVERRIDE_64_ioctl -SC_LTTNG_TRACEPOINT_EVENT(ioctl, - TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd, unsigned long arg), - TP_ARGS(sc_exit(ret,) fd, cmd, arg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_inout(ctf_integer(unsigned long, arg, arg))) -) -#endif -#ifndef OVERRIDE_64_ioprio_set -SC_LTTNG_TRACEPOINT_EVENT(ioprio_set, - TP_PROTO(sc_exit(long ret,) int which, int who, int ioprio), - TP_ARGS(sc_exit(ret,) which, who, ioprio), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who)) sc_in(ctf_integer(int, ioprio, ioprio))) -) -#endif -#ifndef OVERRIDE_64_fchown -SC_LTTNG_TRACEPOINT_EVENT(fchown, - TP_PROTO(sc_exit(long ret,) unsigned int fd, uid_t user, gid_t group), - TP_ARGS(sc_exit(ret,) fd, user, group), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group))) -) -#endif -#ifndef OVERRIDE_64_lseek -SC_LTTNG_TRACEPOINT_EVENT(lseek, - TP_PROTO(sc_exit(long ret,) unsigned int fd, off_t offset, unsigned int whence), - TP_ARGS(sc_exit(ret,) fd, offset, whence), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(off_t, offset, offset)) sc_in(ctf_integer(unsigned int, whence, whence))) -) -#endif -#ifndef OVERRIDE_64_tgkill -SC_LTTNG_TRACEPOINT_EVENT(tgkill, - TP_PROTO(sc_exit(long ret,) pid_t tgid, pid_t pid, int sig), - TP_ARGS(sc_exit(ret,) tgid, pid, sig), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, tgid, tgid)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig))) -) -#endif -#ifndef OVERRIDE_64_setpriority -SC_LTTNG_TRACEPOINT_EVENT(setpriority, - TP_PROTO(sc_exit(long ret,) int which, int who, int niceval), - TP_ARGS(sc_exit(ret,) which, who, niceval), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who)) sc_in(ctf_integer(int, niceval, niceval))) -) -#endif -#ifndef OVERRIDE_64_setresuid -SC_LTTNG_TRACEPOINT_EVENT(setresuid, - TP_PROTO(sc_exit(long ret,) uid_t ruid, uid_t euid, uid_t suid), - TP_ARGS(sc_exit(ret,) ruid, euid, suid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, ruid, ruid)) sc_in(ctf_integer(uid_t, euid, euid)) sc_in(ctf_integer(uid_t, suid, suid))) -) -#endif -#ifndef OVERRIDE_64_setresgid -SC_LTTNG_TRACEPOINT_EVENT(setresgid, - TP_PROTO(sc_exit(long ret,) gid_t rgid, gid_t egid, gid_t sgid), - TP_ARGS(sc_exit(ret,) rgid, egid, sgid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, rgid, rgid)) sc_in(ctf_integer(gid_t, egid, egid)) sc_in(ctf_integer(gid_t, sgid, sgid))) -) -#endif -#ifndef OVERRIDE_64_semget -SC_LTTNG_TRACEPOINT_EVENT(semget, - TP_PROTO(sc_exit(long ret,) key_t key, int nsems, int semflg), - TP_ARGS(sc_exit(ret,) key, nsems, semflg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(key_t, key, key)) sc_in(ctf_integer(int, nsems, nsems)) sc_in(ctf_integer(int, semflg, semflg))) -) -#endif -#ifndef OVERRIDE_64_shmget -SC_LTTNG_TRACEPOINT_EVENT(shmget, - TP_PROTO(sc_exit(long ret,) key_t key, size_t size, int shmflg), - TP_ARGS(sc_exit(ret,) key, size, shmflg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(key_t, key, key)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(int, shmflg, shmflg))) -) -#endif -#ifndef OVERRIDE_64_socket -SC_LTTNG_TRACEPOINT_EVENT(socket, - TP_PROTO(sc_exit(long ret,) int family, int type, int protocol), - TP_ARGS(sc_exit(ret,) family, type, protocol), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, family, family)) sc_in(ctf_integer(int, type, type)) sc_in(ctf_integer(int, protocol, protocol))) -) -#endif -#ifndef OVERRIDE_64_readahead -SC_LTTNG_TRACEPOINT_EVENT(readahead, - TP_PROTO(sc_exit(long ret,) int fd, loff_t offset, size_t count), - TP_ARGS(sc_exit(ret,) fd, offset, count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(loff_t, offset, offset)) sc_in(ctf_integer(size_t, count, count))) -) -#endif -#ifndef OVERRIDE_64_mprotect -SC_LTTNG_TRACEPOINT_EVENT(mprotect, - TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len, unsigned long prot), - TP_ARGS(sc_exit(ret,) start, len, prot), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned long, prot, prot))) -) -#endif -#ifndef OVERRIDE_64_msync -SC_LTTNG_TRACEPOINT_EVENT(msync, - TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len, int flags), - TP_ARGS(sc_exit(ret,) start, len, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_madvise -SC_LTTNG_TRACEPOINT_EVENT(madvise, - TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len_in, int behavior), - TP_ARGS(sc_exit(ret,) start, len_in, behavior), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len_in, len_in)) sc_in(ctf_integer(int, behavior, behavior))) -) -#endif -#ifndef OVERRIDE_64_mlock2 -SC_LTTNG_TRACEPOINT_EVENT(mlock2, - TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len, int flags), - TP_ARGS(sc_exit(ret,) start, len, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned long, start, start)) sc_inout(ctf_integer(size_t, len, len)) sc_inout(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_fallocate -SC_LTTNG_TRACEPOINT_EVENT(fallocate, - TP_PROTO(sc_exit(long ret,) int fd, int mode, loff_t offset, loff_t len), - TP_ARGS(sc_exit(ret,) fd, mode, offset, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, mode, mode)) sc_in(ctf_integer(loff_t, offset, offset)) sc_in(ctf_integer(loff_t, len, len))) -) -#endif -#ifndef OVERRIDE_64_tee -SC_LTTNG_TRACEPOINT_EVENT(tee, - TP_PROTO(sc_exit(long ret,) int fdin, int fdout, size_t len, unsigned int flags), - TP_ARGS(sc_exit(ret,) fdin, fdout, len, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fdin, fdin)) sc_in(ctf_integer(int, fdout, fdout)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_sync_file_range -SC_LTTNG_TRACEPOINT_EVENT(sync_file_range, - TP_PROTO(sc_exit(long ret,) int fd, loff_t offset, loff_t nbytes, unsigned int flags), - TP_ARGS(sc_exit(ret,) fd, offset, nbytes, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(loff_t, offset, offset)) sc_in(ctf_integer(loff_t, nbytes, nbytes)) sc_in(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_ptrace -SC_LTTNG_TRACEPOINT_EVENT(ptrace, - TP_PROTO(sc_exit(long ret,) long request, long pid, unsigned long addr, unsigned long data), - TP_ARGS(sc_exit(ret,) request, pid, addr, data), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(long, request, request)) sc_in(ctf_integer(long, pid, pid)) sc_inout(ctf_integer(unsigned long, addr, addr)) sc_inout(ctf_integer(unsigned long, data, data))) -) -#endif -#ifndef OVERRIDE_64_semctl -SC_LTTNG_TRACEPOINT_EVENT(semctl, - TP_PROTO(sc_exit(long ret,) int semid, int semnum, int cmd, unsigned long arg), - TP_ARGS(sc_exit(ret,) semid, semnum, cmd, arg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, semid, semid)) sc_in(ctf_integer(int, semnum, semnum)) sc_in(ctf_integer(int, cmd, cmd)) sc_inout(ctf_integer(unsigned long, arg, arg))) -) -#endif -#ifndef OVERRIDE_64_fadvise64_64 -SC_LTTNG_TRACEPOINT_EVENT(fadvise64_64, - TP_PROTO(sc_exit(long ret,) int fd, loff_t offset, loff_t len, int advice), - TP_ARGS(sc_exit(ret,) fd, offset, len, advice), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, fd, fd)) sc_inout(ctf_integer(loff_t, offset, offset)) sc_inout(ctf_integer(loff_t, len, len)) sc_inout(ctf_integer(int, advice, advice))) -) -#endif -#ifndef OVERRIDE_64_prctl -SC_LTTNG_TRACEPOINT_EVENT(prctl, - TP_PROTO(sc_exit(long ret,) int option, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5), - TP_ARGS(sc_exit(ret,) option, arg2, arg3, arg4, arg5), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, option, option)) sc_inout(ctf_integer(unsigned long, arg2, arg2)) sc_in(ctf_integer(unsigned long, arg3, arg3)) sc_in(ctf_integer(unsigned long, arg4, arg4)) sc_in(ctf_integer(unsigned long, arg5, arg5))) -) -#endif -#ifndef OVERRIDE_64_mremap -SC_LTTNG_TRACEPOINT_EVENT(mremap, - TP_PROTO(sc_exit(long ret,) unsigned long addr, unsigned long old_len, unsigned long new_len, unsigned long flags, unsigned long new_addr), - TP_ARGS(sc_exit(ret,) addr, old_len, new_len, flags, new_addr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, addr, addr)) sc_in(ctf_integer(unsigned long, old_len, old_len)) sc_in(ctf_integer(unsigned long, new_len, new_len)) sc_in(ctf_integer(unsigned long, flags, flags)) sc_in(ctf_integer(unsigned long, new_addr, new_addr))) -) -#endif -#ifndef OVERRIDE_64_keyctl -SC_LTTNG_TRACEPOINT_EVENT(keyctl, - TP_PROTO(sc_exit(long ret,) int option, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5), - TP_ARGS(sc_exit(ret,) option, arg2, arg3, arg4, arg5), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, option, option)) sc_inout(ctf_integer(unsigned long, arg2, arg2)) sc_inout(ctf_integer(unsigned long, arg3, arg3)) sc_inout(ctf_integer(unsigned long, arg4, arg4)) sc_inout(ctf_integer(unsigned long, arg5, arg5))) -) -#endif -#ifndef OVERRIDE_64_remap_file_pages -SC_LTTNG_TRACEPOINT_EVENT(remap_file_pages, - TP_PROTO(sc_exit(long ret,) unsigned long start, unsigned long size, unsigned long prot, unsigned long pgoff, unsigned long flags), - TP_ARGS(sc_exit(ret,) start, size, prot, pgoff, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(unsigned long, size, size)) sc_in(ctf_integer(unsigned long, prot, prot)) sc_in(ctf_integer(unsigned long, pgoff, pgoff)) sc_in(ctf_integer(unsigned long, flags, flags))) -) -#endif - -#endif /* _TRACE_SYSCALLS_INTEGERS_H */ - -/* This part must be outside protection */ -#include - -#else /* CREATE_SYSCALL_TABLE */ - -#include "arm-64-syscalls_integers_override.h" -#include "syscalls_integers_override.h" - -#ifdef SC_ENTER -#ifndef OVERRIDE_TABLE_64_vhangup -TRACE_SYSCALL_TABLE(syscalls_noargs, vhangup, 58, 0) -#endif -#ifndef OVERRIDE_TABLE_64_sync -TRACE_SYSCALL_TABLE(syscalls_noargs, sync, 81, 0) -#endif -#ifndef OVERRIDE_TABLE_64_sched_yield -TRACE_SYSCALL_TABLE(syscalls_noargs, sched_yield, 124, 0) -#endif -#ifndef OVERRIDE_TABLE_64_restart_syscall -TRACE_SYSCALL_TABLE(syscalls_noargs, restart_syscall, 128, 0) -#endif -#ifndef OVERRIDE_TABLE_64_setsid -TRACE_SYSCALL_TABLE(syscalls_noargs, setsid, 157, 0) -#endif -#ifndef OVERRIDE_TABLE_64_getpid -TRACE_SYSCALL_TABLE(syscalls_noargs, getpid, 172, 0) -#endif -#ifndef OVERRIDE_TABLE_64_getppid -TRACE_SYSCALL_TABLE(syscalls_noargs, getppid, 173, 0) -#endif -#ifndef OVERRIDE_TABLE_64_getuid -TRACE_SYSCALL_TABLE(syscalls_noargs, getuid, 174, 0) -#endif -#ifndef OVERRIDE_TABLE_64_geteuid -TRACE_SYSCALL_TABLE(syscalls_noargs, geteuid, 175, 0) -#endif -#ifndef OVERRIDE_TABLE_64_getgid -TRACE_SYSCALL_TABLE(syscalls_noargs, getgid, 176, 0) -#endif -#ifndef OVERRIDE_TABLE_64_getegid -TRACE_SYSCALL_TABLE(syscalls_noargs, getegid, 177, 0) -#endif -#ifndef OVERRIDE_TABLE_64_gettid -TRACE_SYSCALL_TABLE(syscalls_noargs, gettid, 178, 0) -#endif -#ifndef OVERRIDE_TABLE_64_munlockall -TRACE_SYSCALL_TABLE(syscalls_noargs, munlockall, 231, 0) -#endif -#else /* #ifdef SC_ENTER */ -#ifndef OVERRIDE_TABLE_64_vhangup -TRACE_SYSCALL_TABLE(vhangup, vhangup, 58, 0) -#endif -#ifndef OVERRIDE_TABLE_64_sync -TRACE_SYSCALL_TABLE(sync, sync, 81, 0) -#endif -#ifndef OVERRIDE_TABLE_64_sched_yield -TRACE_SYSCALL_TABLE(sched_yield, sched_yield, 124, 0) -#endif -#ifndef OVERRIDE_TABLE_64_restart_syscall -TRACE_SYSCALL_TABLE(restart_syscall, restart_syscall, 128, 0) -#endif -#ifndef OVERRIDE_TABLE_64_setsid -TRACE_SYSCALL_TABLE(setsid, setsid, 157, 0) -#endif -#ifndef OVERRIDE_TABLE_64_getpid -TRACE_SYSCALL_TABLE(getpid, getpid, 172, 0) -#endif -#ifndef OVERRIDE_TABLE_64_getppid -TRACE_SYSCALL_TABLE(getppid, getppid, 173, 0) -#endif -#ifndef OVERRIDE_TABLE_64_getuid -TRACE_SYSCALL_TABLE(getuid, getuid, 174, 0) -#endif -#ifndef OVERRIDE_TABLE_64_geteuid -TRACE_SYSCALL_TABLE(geteuid, geteuid, 175, 0) -#endif -#ifndef OVERRIDE_TABLE_64_getgid -TRACE_SYSCALL_TABLE(getgid, getgid, 176, 0) -#endif -#ifndef OVERRIDE_TABLE_64_getegid -TRACE_SYSCALL_TABLE(getegid, getegid, 177, 0) -#endif -#ifndef OVERRIDE_TABLE_64_gettid -TRACE_SYSCALL_TABLE(gettid, gettid, 178, 0) -#endif -#ifndef OVERRIDE_TABLE_64_munlockall -TRACE_SYSCALL_TABLE(munlockall, munlockall, 231, 0) -#endif -#endif /* else #ifdef SC_ENTER */ -#ifndef OVERRIDE_TABLE_64_io_destroy -TRACE_SYSCALL_TABLE(io_destroy, io_destroy, 1, 1) -#endif -#ifndef OVERRIDE_TABLE_64_eventfd2 -TRACE_SYSCALL_TABLE(eventfd2, eventfd2, 19, 2) -#endif -#ifndef OVERRIDE_TABLE_64_epoll_create1 -TRACE_SYSCALL_TABLE(epoll_create1, epoll_create1, 20, 1) -#endif -#ifndef OVERRIDE_TABLE_64_dup -TRACE_SYSCALL_TABLE(dup, dup, 23, 1) -#endif -#ifndef OVERRIDE_TABLE_64_dup3 -TRACE_SYSCALL_TABLE(dup3, dup3, 24, 3) -#endif -#ifndef OVERRIDE_TABLE_64_fcntl -TRACE_SYSCALL_TABLE(fcntl, fcntl, 25, 3) -#endif -#ifndef OVERRIDE_TABLE_64_inotify_init1 -TRACE_SYSCALL_TABLE(inotify_init1, inotify_init1, 26, 1) -#endif -#ifndef OVERRIDE_TABLE_64_inotify_rm_watch -TRACE_SYSCALL_TABLE(inotify_rm_watch, inotify_rm_watch, 28, 2) -#endif -#ifndef OVERRIDE_TABLE_64_ioctl -TRACE_SYSCALL_TABLE(ioctl, ioctl, 29, 3) -#endif -#ifndef OVERRIDE_TABLE_64_ioprio_set -TRACE_SYSCALL_TABLE(ioprio_set, ioprio_set, 30, 3) -#endif -#ifndef OVERRIDE_TABLE_64_ioprio_get -TRACE_SYSCALL_TABLE(ioprio_get, ioprio_get, 31, 2) -#endif -#ifndef OVERRIDE_TABLE_64_flock -TRACE_SYSCALL_TABLE(flock, flock, 32, 2) -#endif -#ifndef OVERRIDE_TABLE_64_ftruncate -TRACE_SYSCALL_TABLE(ftruncate, ftruncate, 46, 2) -#endif -#ifndef OVERRIDE_TABLE_64_fallocate -TRACE_SYSCALL_TABLE(fallocate, fallocate, 47, 4) -#endif -#ifndef OVERRIDE_TABLE_64_fchdir -TRACE_SYSCALL_TABLE(fchdir, fchdir, 50, 1) -#endif -#ifndef OVERRIDE_TABLE_64_fchmod -TRACE_SYSCALL_TABLE(fchmod, fchmod, 52, 2) -#endif -#ifndef OVERRIDE_TABLE_64_fchown -TRACE_SYSCALL_TABLE(fchown, fchown, 55, 3) -#endif -#ifndef OVERRIDE_TABLE_64_close -TRACE_SYSCALL_TABLE(close, close, 57, 1) -#endif -#ifndef OVERRIDE_TABLE_64_lseek -TRACE_SYSCALL_TABLE(lseek, lseek, 62, 3) -#endif -#ifndef OVERRIDE_TABLE_64_tee -TRACE_SYSCALL_TABLE(tee, tee, 77, 4) -#endif -#ifndef OVERRIDE_TABLE_64_fsync -TRACE_SYSCALL_TABLE(fsync, fsync, 82, 1) -#endif -#ifndef OVERRIDE_TABLE_64_fdatasync -TRACE_SYSCALL_TABLE(fdatasync, fdatasync, 83, 1) -#endif -#ifndef OVERRIDE_TABLE_64_sync_file_range -TRACE_SYSCALL_TABLE(sync_file_range, sync_file_range, 84, 4) -#endif -#ifndef OVERRIDE_TABLE_64_timerfd_create -TRACE_SYSCALL_TABLE(timerfd_create, timerfd_create, 85, 2) -#endif -#ifndef OVERRIDE_TABLE_64_personality -TRACE_SYSCALL_TABLE(personality, personality, 92, 1) -#endif -#ifndef OVERRIDE_TABLE_64_exit -TRACE_SYSCALL_TABLE(exit, exit, 93, 1) -#endif -#ifndef OVERRIDE_TABLE_64_exit_group -TRACE_SYSCALL_TABLE(exit_group, exit_group, 94, 1) -#endif -#ifndef OVERRIDE_TABLE_64_unshare -TRACE_SYSCALL_TABLE(unshare, unshare, 97, 1) -#endif -#ifndef OVERRIDE_TABLE_64_timer_getoverrun -TRACE_SYSCALL_TABLE(timer_getoverrun, timer_getoverrun, 109, 1) -#endif -#ifndef OVERRIDE_TABLE_64_timer_delete -TRACE_SYSCALL_TABLE(timer_delete, timer_delete, 111, 1) -#endif -#ifndef OVERRIDE_TABLE_64_ptrace -TRACE_SYSCALL_TABLE(ptrace, ptrace, 117, 4) -#endif -#ifndef OVERRIDE_TABLE_64_sched_getscheduler -TRACE_SYSCALL_TABLE(sched_getscheduler, sched_getscheduler, 120, 1) -#endif -#ifndef OVERRIDE_TABLE_64_sched_get_priority_max -TRACE_SYSCALL_TABLE(sched_get_priority_max, sched_get_priority_max, 125, 1) -#endif -#ifndef OVERRIDE_TABLE_64_sched_get_priority_min -TRACE_SYSCALL_TABLE(sched_get_priority_min, sched_get_priority_min, 126, 1) -#endif -#ifndef OVERRIDE_TABLE_64_kill -TRACE_SYSCALL_TABLE(kill, kill, 129, 2) -#endif -#ifndef OVERRIDE_TABLE_64_tkill -TRACE_SYSCALL_TABLE(tkill, tkill, 130, 2) -#endif -#ifndef OVERRIDE_TABLE_64_tgkill -TRACE_SYSCALL_TABLE(tgkill, tgkill, 131, 3) -#endif -#ifndef OVERRIDE_TABLE_64_setpriority -TRACE_SYSCALL_TABLE(setpriority, setpriority, 140, 3) -#endif -#ifndef OVERRIDE_TABLE_64_getpriority -TRACE_SYSCALL_TABLE(getpriority, getpriority, 141, 2) -#endif -#ifndef OVERRIDE_TABLE_64_setregid -TRACE_SYSCALL_TABLE(setregid, setregid, 143, 2) -#endif -#ifndef OVERRIDE_TABLE_64_setgid -TRACE_SYSCALL_TABLE(setgid, setgid, 144, 1) -#endif -#ifndef OVERRIDE_TABLE_64_setreuid -TRACE_SYSCALL_TABLE(setreuid, setreuid, 145, 2) -#endif -#ifndef OVERRIDE_TABLE_64_setuid -TRACE_SYSCALL_TABLE(setuid, setuid, 146, 1) -#endif -#ifndef OVERRIDE_TABLE_64_setresuid -TRACE_SYSCALL_TABLE(setresuid, setresuid, 147, 3) -#endif -#ifndef OVERRIDE_TABLE_64_setresgid -TRACE_SYSCALL_TABLE(setresgid, setresgid, 149, 3) -#endif -#ifndef OVERRIDE_TABLE_64_setfsuid -TRACE_SYSCALL_TABLE(setfsuid, setfsuid, 151, 1) -#endif -#ifndef OVERRIDE_TABLE_64_setfsgid -TRACE_SYSCALL_TABLE(setfsgid, setfsgid, 152, 1) -#endif -#ifndef OVERRIDE_TABLE_64_setpgid -TRACE_SYSCALL_TABLE(setpgid, setpgid, 154, 2) -#endif -#ifndef OVERRIDE_TABLE_64_getpgid -TRACE_SYSCALL_TABLE(getpgid, getpgid, 155, 1) -#endif -#ifndef OVERRIDE_TABLE_64_getsid -TRACE_SYSCALL_TABLE(getsid, getsid, 156, 1) -#endif -#ifndef OVERRIDE_TABLE_64_umask -TRACE_SYSCALL_TABLE(umask, umask, 166, 1) -#endif -#ifndef OVERRIDE_TABLE_64_prctl -TRACE_SYSCALL_TABLE(prctl, prctl, 167, 5) -#endif -#ifndef OVERRIDE_TABLE_64_msgget -TRACE_SYSCALL_TABLE(msgget, msgget, 186, 2) -#endif -#ifndef OVERRIDE_TABLE_64_semget -TRACE_SYSCALL_TABLE(semget, semget, 190, 3) -#endif -#ifndef OVERRIDE_TABLE_64_semctl -TRACE_SYSCALL_TABLE(semctl, semctl, 191, 4) -#endif -#ifndef OVERRIDE_TABLE_64_shmget -TRACE_SYSCALL_TABLE(shmget, shmget, 194, 3) -#endif -#ifndef OVERRIDE_TABLE_64_socket -TRACE_SYSCALL_TABLE(socket, socket, 198, 3) -#endif -#ifndef OVERRIDE_TABLE_64_listen -TRACE_SYSCALL_TABLE(listen, listen, 201, 2) -#endif -#ifndef OVERRIDE_TABLE_64_shutdown -TRACE_SYSCALL_TABLE(shutdown, shutdown, 210, 2) -#endif -#ifndef OVERRIDE_TABLE_64_readahead -TRACE_SYSCALL_TABLE(readahead, readahead, 213, 3) -#endif -#ifndef OVERRIDE_TABLE_64_brk -TRACE_SYSCALL_TABLE(brk, brk, 214, 1) -#endif -#ifndef OVERRIDE_TABLE_64_munmap -TRACE_SYSCALL_TABLE(munmap, munmap, 215, 2) -#endif -#ifndef OVERRIDE_TABLE_64_mremap -TRACE_SYSCALL_TABLE(mremap, mremap, 216, 5) -#endif -#ifndef OVERRIDE_TABLE_64_keyctl -TRACE_SYSCALL_TABLE(keyctl, keyctl, 219, 5) -#endif -#ifndef OVERRIDE_TABLE_64_fadvise64_64 -TRACE_SYSCALL_TABLE(fadvise64_64, fadvise64_64, 223, 4) -#endif -#ifndef OVERRIDE_TABLE_64_mprotect -TRACE_SYSCALL_TABLE(mprotect, mprotect, 226, 3) -#endif -#ifndef OVERRIDE_TABLE_64_msync -TRACE_SYSCALL_TABLE(msync, msync, 227, 3) -#endif -#ifndef OVERRIDE_TABLE_64_mlock -TRACE_SYSCALL_TABLE(mlock, mlock, 228, 2) -#endif -#ifndef OVERRIDE_TABLE_64_munlock -TRACE_SYSCALL_TABLE(munlock, munlock, 229, 2) -#endif -#ifndef OVERRIDE_TABLE_64_mlockall -TRACE_SYSCALL_TABLE(mlockall, mlockall, 230, 1) -#endif -#ifndef OVERRIDE_TABLE_64_madvise -TRACE_SYSCALL_TABLE(madvise, madvise, 233, 3) -#endif -#ifndef OVERRIDE_TABLE_64_remap_file_pages -TRACE_SYSCALL_TABLE(remap_file_pages, remap_file_pages, 234, 5) -#endif -#ifndef OVERRIDE_TABLE_64_fanotify_init -TRACE_SYSCALL_TABLE(fanotify_init, fanotify_init, 262, 2) -#endif -#ifndef OVERRIDE_TABLE_64_syncfs -TRACE_SYSCALL_TABLE(syncfs, syncfs, 267, 1) -#endif -#ifndef OVERRIDE_TABLE_64_setns -TRACE_SYSCALL_TABLE(setns, setns, 268, 2) -#endif -#ifndef OVERRIDE_TABLE_64_membarrier -TRACE_SYSCALL_TABLE(membarrier, membarrier, 283, 2) -#endif -#ifndef OVERRIDE_TABLE_64_mlock2 -TRACE_SYSCALL_TABLE(mlock2, mlock2, 284, 3) -#endif - -#endif /* CREATE_SYSCALL_TABLE */ diff --git a/instrumentation/syscalls/headers/arm-64-syscalls_integers_override.h b/instrumentation/syscalls/headers/arm-64-syscalls_integers_override.h deleted file mode 100644 index ac0d5443..00000000 --- a/instrumentation/syscalls/headers/arm-64-syscalls_integers_override.h +++ /dev/null @@ -1,10 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ - -/* - * this is a place-holder for arm64 integer syscall definition override. - */ -#ifndef CREATE_SYSCALL_TABLE -#else /* CREATE_SYSCALL_TABLE */ -#define OVERRIDE_TABLE_64_mmap -TRACE_SYSCALL_TABLE(mmap, mmap, 222, 6) -#endif /* CREATE_SYSCALL_TABLE */ diff --git a/instrumentation/syscalls/headers/arm-64-syscalls_pointers.h b/instrumentation/syscalls/headers/arm-64-syscalls_pointers.h deleted file mode 100644 index f7ae855f..00000000 --- a/instrumentation/syscalls/headers/arm-64-syscalls_pointers.h +++ /dev/null @@ -1,1669 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ - -/* THIS FILE IS AUTO-GENERATED. DO NOT EDIT */ - -/* Generated from arm-64-syscalls 4.4.0 */ - -#ifndef CREATE_SYSCALL_TABLE - -#if !defined(_TRACE_SYSCALLS_POINTERS_H) || defined(TRACE_HEADER_MULTI_READ) -#define _TRACE_SYSCALLS_POINTERS_H - -#include -#include -#include "arm-64-syscalls_pointers_override.h" -#include "syscalls_pointers_override.h" - -#ifndef OVERRIDE_64_chdir -SC_LTTNG_TRACEPOINT_EVENT(chdir, - TP_PROTO(sc_exit(long ret,) const char * filename), - TP_ARGS(sc_exit(ret,) filename), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename))) -) -#endif -#ifndef OVERRIDE_64_chroot -SC_LTTNG_TRACEPOINT_EVENT(chroot, - TP_PROTO(sc_exit(long ret,) const char * filename), - TP_ARGS(sc_exit(ret,) filename), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename))) -) -#endif -#ifndef OVERRIDE_64_acct -SC_LTTNG_TRACEPOINT_EVENT(acct, - TP_PROTO(sc_exit(long ret,) const char * name), - TP_ARGS(sc_exit(ret,) name), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name))) -) -#endif -#ifndef OVERRIDE_64_set_tid_address -SC_LTTNG_TRACEPOINT_EVENT(set_tid_address, - TP_PROTO(sc_exit(long ret,) int * tidptr), - TP_ARGS(sc_exit(ret,) tidptr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int *, tidptr, tidptr))) -) -#endif -#ifndef OVERRIDE_64_times -SC_LTTNG_TRACEPOINT_EVENT(times, - TP_PROTO(sc_exit(long ret,) struct tms * tbuf), - TP_ARGS(sc_exit(ret,) tbuf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct tms *, tbuf, tbuf))) -) -#endif -#ifndef OVERRIDE_64_newuname -SC_LTTNG_TRACEPOINT_EVENT(newuname, - TP_PROTO(sc_exit(long ret,) struct new_utsname * name), - TP_ARGS(sc_exit(ret,) name), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct new_utsname *, name, name))) -) -#endif -#ifndef OVERRIDE_64_adjtimex -SC_LTTNG_TRACEPOINT_EVENT(adjtimex, - TP_PROTO(sc_exit(long ret,) struct timex * txc_p), - TP_ARGS(sc_exit(ret,) txc_p), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct timex *, txc_p, txc_p))) -) -#endif -#ifndef OVERRIDE_64_sysinfo -SC_LTTNG_TRACEPOINT_EVENT(sysinfo, - TP_PROTO(sc_exit(long ret,) struct sysinfo * info), - TP_ARGS(sc_exit(ret,) info), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct sysinfo *, info, info))) -) -#endif -#ifndef OVERRIDE_64_mq_unlink -SC_LTTNG_TRACEPOINT_EVENT(mq_unlink, - TP_PROTO(sc_exit(long ret,) const char * u_name), - TP_ARGS(sc_exit(ret,) u_name), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(u_name, u_name))) -) -#endif -#ifndef OVERRIDE_64_shmdt -SC_LTTNG_TRACEPOINT_EVENT(shmdt, - TP_PROTO(sc_exit(long ret,) char * shmaddr), - TP_ARGS(sc_exit(ret,) shmaddr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(char *, shmaddr, shmaddr))) -) -#endif -#ifndef OVERRIDE_64_swapoff -SC_LTTNG_TRACEPOINT_EVENT(swapoff, - TP_PROTO(sc_exit(long ret,) const char * specialfile), - TP_ARGS(sc_exit(ret,) specialfile), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(specialfile, specialfile))) -) -#endif -#ifndef OVERRIDE_64_io_setup -SC_LTTNG_TRACEPOINT_EVENT(io_setup, - TP_PROTO(sc_exit(long ret,) unsigned nr_events, aio_context_t * ctxp), - TP_ARGS(sc_exit(ret,) nr_events, ctxp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned, nr_events, nr_events)) sc_in(ctf_integer(aio_context_t *, ctxp, ctxp))) -) -#endif -#ifndef OVERRIDE_64_removexattr -SC_LTTNG_TRACEPOINT_EVENT(removexattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name), - TP_ARGS(sc_exit(ret,) pathname, name), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name))) -) -#endif -#ifndef OVERRIDE_64_lremovexattr -SC_LTTNG_TRACEPOINT_EVENT(lremovexattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name), - TP_ARGS(sc_exit(ret,) pathname, name), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name))) -) -#endif -#ifndef OVERRIDE_64_fremovexattr -SC_LTTNG_TRACEPOINT_EVENT(fremovexattr, - TP_PROTO(sc_exit(long ret,) int fd, const char * name), - TP_ARGS(sc_exit(ret,) fd, name), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(name, name))) -) -#endif -#ifndef OVERRIDE_64_getcwd -SC_LTTNG_TRACEPOINT_EVENT(getcwd, - TP_PROTO(sc_exit(long ret,) char * buf, unsigned long size), - TP_ARGS(sc_exit(ret,) buf, size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(unsigned long, size, size))) -) -#endif -#ifndef OVERRIDE_64_umount -SC_LTTNG_TRACEPOINT_EVENT(umount, - TP_PROTO(sc_exit(long ret,) char * name, int flags), - TP_ARGS(sc_exit(ret,) name, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_pivot_root -SC_LTTNG_TRACEPOINT_EVENT(pivot_root, - TP_PROTO(sc_exit(long ret,) const char * new_root, const char * put_old), - TP_ARGS(sc_exit(ret,) new_root, put_old), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(new_root, new_root)) sc_in(ctf_user_string(put_old, put_old))) -) -#endif -#ifndef OVERRIDE_64_statfs -SC_LTTNG_TRACEPOINT_EVENT(statfs, - TP_PROTO(sc_exit(long ret,) const char * pathname, struct statfs * buf), - TP_ARGS(sc_exit(ret,) pathname, buf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(struct statfs *, buf, buf))) -) -#endif -#ifndef OVERRIDE_64_fstatfs -SC_LTTNG_TRACEPOINT_EVENT(fstatfs, - TP_PROTO(sc_exit(long ret,) unsigned int fd, struct statfs * buf), - TP_ARGS(sc_exit(ret,) fd, buf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct statfs *, buf, buf))) -) -#endif -#ifndef OVERRIDE_64_truncate -SC_LTTNG_TRACEPOINT_EVENT(truncate, - TP_PROTO(sc_exit(long ret,) const char * path, long length), - TP_ARGS(sc_exit(ret,) path, length), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(path, path)) sc_in(ctf_integer(long, length, length))) -) -#endif -#ifndef OVERRIDE_64_pipe2 -SC_LTTNG_TRACEPOINT_EVENT(pipe2, - TP_PROTO(sc_exit(long ret,) int * fildes, int flags), - TP_ARGS(sc_exit(ret,) fildes, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(int *, fildes, fildes)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_newfstat -SC_LTTNG_TRACEPOINT_EVENT(newfstat, - TP_PROTO(sc_exit(long ret,) unsigned int fd, struct stat * statbuf), - TP_ARGS(sc_exit(ret,) fd, statbuf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct stat *, statbuf, statbuf))) -) -#endif -#ifndef OVERRIDE_64_timerfd_gettime -SC_LTTNG_TRACEPOINT_EVENT(timerfd_gettime, - TP_PROTO(sc_exit(long ret,) int ufd, struct itimerspec * otmr), - TP_ARGS(sc_exit(ret,) ufd, otmr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_out(ctf_integer(struct itimerspec *, otmr, otmr))) -) -#endif -#ifndef OVERRIDE_64_set_robust_list -SC_LTTNG_TRACEPOINT_EVENT(set_robust_list, - TP_PROTO(sc_exit(long ret,) struct robust_list_head * head, size_t len), - TP_ARGS(sc_exit(ret,) head, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct robust_list_head *, head, head)) sc_in(ctf_integer(size_t, len, len))) -) -#endif -#ifndef OVERRIDE_64_nanosleep -SC_LTTNG_TRACEPOINT_EVENT(nanosleep, - TP_PROTO(sc_exit(long ret,) struct timespec * rqtp, struct timespec * rmtp), - TP_ARGS(sc_exit(ret,) rqtp, rmtp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct timespec *, rqtp, rqtp)) sc_out(ctf_integer(struct timespec *, rmtp, rmtp))) -) -#endif -#ifndef OVERRIDE_64_getitimer -SC_LTTNG_TRACEPOINT_EVENT(getitimer, - TP_PROTO(sc_exit(long ret,) int which, struct itimerval * value), - TP_ARGS(sc_exit(ret,) which, value), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_out(ctf_integer(struct itimerval *, value, value))) -) -#endif -#ifndef OVERRIDE_64_delete_module -SC_LTTNG_TRACEPOINT_EVENT(delete_module, - TP_PROTO(sc_exit(long ret,) const char * name_user, unsigned int flags), - TP_ARGS(sc_exit(ret,) name_user, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name_user, name_user)) sc_in(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_timer_gettime -SC_LTTNG_TRACEPOINT_EVENT(timer_gettime, - TP_PROTO(sc_exit(long ret,) timer_t timer_id, struct itimerspec * setting), - TP_ARGS(sc_exit(ret,) timer_id, setting), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id)) sc_out(ctf_integer(struct itimerspec *, setting, setting))) -) -#endif -#ifndef OVERRIDE_64_clock_settime -SC_LTTNG_TRACEPOINT_EVENT(clock_settime, - TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, const struct timespec * tp), - TP_ARGS(sc_exit(ret,) which_clock, tp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_in(ctf_integer(const struct timespec *, tp, tp))) -) -#endif -#ifndef OVERRIDE_64_clock_gettime -SC_LTTNG_TRACEPOINT_EVENT(clock_gettime, - TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct timespec * tp), - TP_ARGS(sc_exit(ret,) which_clock, tp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_out(ctf_integer(struct timespec *, tp, tp))) -) -#endif -#ifndef OVERRIDE_64_clock_getres -SC_LTTNG_TRACEPOINT_EVENT(clock_getres, - TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct timespec * tp), - TP_ARGS(sc_exit(ret,) which_clock, tp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_out(ctf_integer(struct timespec *, tp, tp))) -) -#endif -#ifndef OVERRIDE_64_sched_setparam -SC_LTTNG_TRACEPOINT_EVENT(sched_setparam, - TP_PROTO(sc_exit(long ret,) pid_t pid, struct sched_param * param), - TP_ARGS(sc_exit(ret,) pid, param), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(struct sched_param *, param, param))) -) -#endif -#ifndef OVERRIDE_64_sched_getparam -SC_LTTNG_TRACEPOINT_EVENT(sched_getparam, - TP_PROTO(sc_exit(long ret,) pid_t pid, struct sched_param * param), - TP_ARGS(sc_exit(ret,) pid, param), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_out(ctf_integer(struct sched_param *, param, param))) -) -#endif -#ifndef OVERRIDE_64_sched_rr_get_interval -SC_LTTNG_TRACEPOINT_EVENT(sched_rr_get_interval, - TP_PROTO(sc_exit(long ret,) pid_t pid, struct timespec * interval), - TP_ARGS(sc_exit(ret,) pid, interval), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_out(ctf_integer(struct timespec *, interval, interval))) -) -#endif -#ifndef OVERRIDE_64_sigaltstack -SC_LTTNG_TRACEPOINT_EVENT(sigaltstack, - TP_PROTO(sc_exit(long ret,) const stack_t * uss, stack_t * uoss), - TP_ARGS(sc_exit(ret,) uss, uoss), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const stack_t *, uss, uss)) sc_inout(ctf_integer(stack_t *, uoss, uoss))) -) -#endif -#ifndef OVERRIDE_64_rt_sigsuspend -SC_LTTNG_TRACEPOINT_EVENT(rt_sigsuspend, - TP_PROTO(sc_exit(long ret,) sigset_t * unewset, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) unewset, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(sigset_t *, unewset, unewset)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) -) -#endif -#ifndef OVERRIDE_64_rt_sigpending -SC_LTTNG_TRACEPOINT_EVENT(rt_sigpending, - TP_PROTO(sc_exit(long ret,) sigset_t * uset, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) uset, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(sigset_t *, uset, uset)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) -) -#endif -#ifndef OVERRIDE_64_getgroups -SC_LTTNG_TRACEPOINT_EVENT(getgroups, - TP_PROTO(sc_exit(long ret,) int gidsetsize, gid_t * grouplist), - TP_ARGS(sc_exit(ret,) gidsetsize, grouplist), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, gidsetsize, gidsetsize)) sc_out(ctf_integer(gid_t *, grouplist, grouplist))) -) -#endif -#ifndef OVERRIDE_64_setgroups -SC_LTTNG_TRACEPOINT_EVENT(setgroups, - TP_PROTO(sc_exit(long ret,) int gidsetsize, gid_t * grouplist), - TP_ARGS(sc_exit(ret,) gidsetsize, grouplist), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, gidsetsize, gidsetsize)) sc_in(ctf_integer(gid_t *, grouplist, grouplist))) -) -#endif -#ifndef OVERRIDE_64_sethostname -SC_LTTNG_TRACEPOINT_EVENT(sethostname, - TP_PROTO(sc_exit(long ret,) char * name, int len), - TP_ARGS(sc_exit(ret,) name, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(int, len, len))) -) -#endif -#ifndef OVERRIDE_64_setdomainname -SC_LTTNG_TRACEPOINT_EVENT(setdomainname, - TP_PROTO(sc_exit(long ret,) char * name, int len), - TP_ARGS(sc_exit(ret,) name, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(int, len, len))) -) -#endif -#ifndef OVERRIDE_64_getrlimit -SC_LTTNG_TRACEPOINT_EVENT(getrlimit, - TP_PROTO(sc_exit(long ret,) unsigned int resource, struct rlimit * rlim), - TP_ARGS(sc_exit(ret,) resource, rlim), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, resource, resource)) sc_out(ctf_integer(struct rlimit *, rlim, rlim))) -) -#endif -#ifndef OVERRIDE_64_setrlimit -SC_LTTNG_TRACEPOINT_EVENT(setrlimit, - TP_PROTO(sc_exit(long ret,) unsigned int resource, struct rlimit * rlim), - TP_ARGS(sc_exit(ret,) resource, rlim), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, resource, resource)) sc_in(ctf_integer(struct rlimit *, rlim, rlim))) -) -#endif -#ifndef OVERRIDE_64_getrusage -SC_LTTNG_TRACEPOINT_EVENT(getrusage, - TP_PROTO(sc_exit(long ret,) int who, struct rusage * ru), - TP_ARGS(sc_exit(ret,) who, ru), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, who, who)) sc_out(ctf_integer(struct rusage *, ru, ru))) -) -#endif -#ifndef OVERRIDE_64_gettimeofday -SC_LTTNG_TRACEPOINT_EVENT(gettimeofday, - TP_PROTO(sc_exit(long ret,) struct timeval * tv, struct timezone * tz), - TP_ARGS(sc_exit(ret,) tv, tz), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct timeval *, tv, tv)) sc_out(ctf_integer(struct timezone *, tz, tz))) -) -#endif -#ifndef OVERRIDE_64_settimeofday -SC_LTTNG_TRACEPOINT_EVENT(settimeofday, - TP_PROTO(sc_exit(long ret,) struct timeval * tv, struct timezone * tz), - TP_ARGS(sc_exit(ret,) tv, tz), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct timeval *, tv, tv)) sc_in(ctf_integer(struct timezone *, tz, tz))) -) -#endif -#ifndef OVERRIDE_64_mq_notify -SC_LTTNG_TRACEPOINT_EVENT(mq_notify, - TP_PROTO(sc_exit(long ret,) mqd_t mqdes, const struct sigevent * u_notification), - TP_ARGS(sc_exit(ret,) mqdes, u_notification), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(mqd_t, mqdes, mqdes)) sc_in(ctf_integer(const struct sigevent *, u_notification, u_notification))) -) -#endif -#ifndef OVERRIDE_64_swapon -SC_LTTNG_TRACEPOINT_EVENT(swapon, - TP_PROTO(sc_exit(long ret,) const char * specialfile, int swap_flags), - TP_ARGS(sc_exit(ret,) specialfile, swap_flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(specialfile, specialfile)) sc_in(ctf_integer(int, swap_flags, swap_flags))) -) -#endif -#ifndef OVERRIDE_64_clock_adjtime -SC_LTTNG_TRACEPOINT_EVENT(clock_adjtime, - TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct timex * utx), - TP_ARGS(sc_exit(ret,) which_clock, utx), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_inout(ctf_integer(struct timex *, utx, utx))) -) -#endif -#ifndef OVERRIDE_64_memfd_create -SC_LTTNG_TRACEPOINT_EVENT(memfd_create, - TP_PROTO(sc_exit(long ret,) const char * uname, unsigned int flags), - TP_ARGS(sc_exit(ret,) uname, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(uname, uname)) sc_inout(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_io_submit -SC_LTTNG_TRACEPOINT_EVENT(io_submit, - TP_PROTO(sc_exit(long ret,) aio_context_t ctx_id, long nr, struct iocb * * iocbpp), - TP_ARGS(sc_exit(ret,) ctx_id, nr, iocbpp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx_id, ctx_id)) sc_in(ctf_integer(long, nr, nr)) sc_in(ctf_integer(struct iocb * *, iocbpp, iocbpp))) -) -#endif -#ifndef OVERRIDE_64_io_cancel -SC_LTTNG_TRACEPOINT_EVENT(io_cancel, - TP_PROTO(sc_exit(long ret,) aio_context_t ctx_id, struct iocb * iocb, struct io_event * result), - TP_ARGS(sc_exit(ret,) ctx_id, iocb, result), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx_id, ctx_id)) sc_in(ctf_integer(struct iocb *, iocb, iocb)) sc_out(ctf_integer(struct io_event *, result, result))) -) -#endif -#ifndef OVERRIDE_64_listxattr -SC_LTTNG_TRACEPOINT_EVENT(listxattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, char * list, size_t size), - TP_ARGS(sc_exit(ret,) pathname, list, size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(char *, list, list)) sc_in(ctf_integer(size_t, size, size))) -) -#endif -#ifndef OVERRIDE_64_llistxattr -SC_LTTNG_TRACEPOINT_EVENT(llistxattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, char * list, size_t size), - TP_ARGS(sc_exit(ret,) pathname, list, size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(char *, list, list)) sc_in(ctf_integer(size_t, size, size))) -) -#endif -#ifndef OVERRIDE_64_flistxattr -SC_LTTNG_TRACEPOINT_EVENT(flistxattr, - TP_PROTO(sc_exit(long ret,) int fd, char * list, size_t size), - TP_ARGS(sc_exit(ret,) fd, list, size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(char *, list, list)) sc_in(ctf_integer(size_t, size, size))) -) -#endif -#ifndef OVERRIDE_64_lookup_dcookie -SC_LTTNG_TRACEPOINT_EVENT(lookup_dcookie, - TP_PROTO(sc_exit(long ret,) u64 cookie64, char * buf, size_t len), - TP_ARGS(sc_exit(ret,) cookie64, buf, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(u64, cookie64, cookie64)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(size_t, len, len))) -) -#endif -#ifndef OVERRIDE_64_inotify_add_watch -SC_LTTNG_TRACEPOINT_EVENT(inotify_add_watch, - TP_PROTO(sc_exit(long ret,) int fd, const char * pathname, u32 mask), - TP_ARGS(sc_exit(ret,) fd, pathname, mask), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(u32, mask, mask))) -) -#endif -#ifndef OVERRIDE_64_mkdirat -SC_LTTNG_TRACEPOINT_EVENT(mkdirat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * pathname, umode_t mode), - TP_ARGS(sc_exit(ret,) dfd, pathname, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(umode_t, mode, mode))) -) -#endif -#ifndef OVERRIDE_64_unlinkat -SC_LTTNG_TRACEPOINT_EVENT(unlinkat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * pathname, int flag), - TP_ARGS(sc_exit(ret,) dfd, pathname, flag), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(int, flag, flag))) -) -#endif -#ifndef OVERRIDE_64_symlinkat -SC_LTTNG_TRACEPOINT_EVENT(symlinkat, - TP_PROTO(sc_exit(long ret,) const char * oldname, int newdfd, const char * newname), - TP_ARGS(sc_exit(ret,) oldname, newdfd, newname), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_integer(int, newdfd, newdfd)) sc_in(ctf_user_string(newname, newname))) -) -#endif -#ifndef OVERRIDE_64_faccessat -SC_LTTNG_TRACEPOINT_EVENT(faccessat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, int mode), - TP_ARGS(sc_exit(ret,) dfd, filename, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, mode, mode))) -) -#endif -#ifndef OVERRIDE_64_fchmodat -SC_LTTNG_TRACEPOINT_EVENT(fchmodat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, umode_t mode), - TP_ARGS(sc_exit(ret,) dfd, filename, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(umode_t, mode, mode))) -) -#endif -#ifndef OVERRIDE_64_getdents64 -SC_LTTNG_TRACEPOINT_EVENT(getdents64, - TP_PROTO(sc_exit(long ret,) unsigned int fd, struct linux_dirent64 * dirent, unsigned int count), - TP_ARGS(sc_exit(ret,) fd, dirent, count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct linux_dirent64 *, dirent, dirent)) sc_in(ctf_integer(unsigned int, count, count))) -) -#endif -#ifndef OVERRIDE_64_read -SC_LTTNG_TRACEPOINT_EVENT(read, - TP_PROTO(sc_exit(long ret,) unsigned int fd, char * buf, size_t count), - TP_ARGS(sc_exit(ret,) fd, buf, count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(size_t, count, count))) -) -#endif -#ifndef OVERRIDE_64_write -SC_LTTNG_TRACEPOINT_EVENT(write, - TP_PROTO(sc_exit(long ret,) unsigned int fd, const char * buf, size_t count), - TP_ARGS(sc_exit(ret,) fd, buf, count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(const char *, buf, buf)) sc_in(ctf_integer(size_t, count, count))) -) -#endif -#ifndef OVERRIDE_64_readv -SC_LTTNG_TRACEPOINT_EVENT(readv, - TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen), - TP_ARGS(sc_exit(ret,) fd, vec, vlen), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_inout(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen))) -) -#endif -#ifndef OVERRIDE_64_writev -SC_LTTNG_TRACEPOINT_EVENT(writev, - TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen), - TP_ARGS(sc_exit(ret,) fd, vec, vlen), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_inout(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen))) -) -#endif -#ifndef OVERRIDE_64_get_robust_list -SC_LTTNG_TRACEPOINT_EVENT(get_robust_list, - TP_PROTO(sc_exit(long ret,) int pid, struct robust_list_head * * head_ptr, size_t * len_ptr), - TP_ARGS(sc_exit(ret,) pid, head_ptr, len_ptr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, pid, pid)) sc_out(ctf_integer(struct robust_list_head * *, head_ptr, head_ptr)) sc_out(ctf_integer(size_t *, len_ptr, len_ptr))) -) -#endif -#ifndef OVERRIDE_64_setitimer -SC_LTTNG_TRACEPOINT_EVENT(setitimer, - TP_PROTO(sc_exit(long ret,) int which, struct itimerval * value, struct itimerval * ovalue), - TP_ARGS(sc_exit(ret,) which, value, ovalue), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(struct itimerval *, value, value)) sc_out(ctf_integer(struct itimerval *, ovalue, ovalue))) -) -#endif -#ifndef OVERRIDE_64_init_module -SC_LTTNG_TRACEPOINT_EVENT(init_module, - TP_PROTO(sc_exit(long ret,) void * umod, unsigned long len, const char * uargs), - TP_ARGS(sc_exit(ret,) umod, len, uargs), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(void *, umod, umod)) sc_in(ctf_integer(unsigned long, len, len)) sc_in(ctf_integer(const char *, uargs, uargs))) -) -#endif -#ifndef OVERRIDE_64_timer_create -SC_LTTNG_TRACEPOINT_EVENT(timer_create, - TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct sigevent * timer_event_spec, timer_t * created_timer_id), - TP_ARGS(sc_exit(ret,) which_clock, timer_event_spec, created_timer_id), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_in(ctf_integer(struct sigevent *, timer_event_spec, timer_event_spec)) sc_out(ctf_integer(timer_t *, created_timer_id, created_timer_id))) -) -#endif -#ifndef OVERRIDE_64_syslog -SC_LTTNG_TRACEPOINT_EVENT(syslog, - TP_PROTO(sc_exit(long ret,) int type, char * buf, int len), - TP_ARGS(sc_exit(ret,) type, buf, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, type, type)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(int, len, len))) -) -#endif -#ifndef OVERRIDE_64_sched_setscheduler -SC_LTTNG_TRACEPOINT_EVENT(sched_setscheduler, - TP_PROTO(sc_exit(long ret,) pid_t pid, int policy, struct sched_param * param), - TP_ARGS(sc_exit(ret,) pid, policy, param), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, policy, policy)) sc_in(ctf_integer(struct sched_param *, param, param))) -) -#endif -#ifndef OVERRIDE_64_sched_setaffinity -SC_LTTNG_TRACEPOINT_EVENT(sched_setaffinity, - TP_PROTO(sc_exit(long ret,) pid_t pid, unsigned int len, unsigned long * user_mask_ptr), - TP_ARGS(sc_exit(ret,) pid, len, user_mask_ptr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(unsigned int, len, len)) sc_in(ctf_integer(unsigned long *, user_mask_ptr, user_mask_ptr))) -) -#endif -#ifndef OVERRIDE_64_sched_getaffinity -SC_LTTNG_TRACEPOINT_EVENT(sched_getaffinity, - TP_PROTO(sc_exit(long ret,) pid_t pid, unsigned int len, unsigned long * user_mask_ptr), - TP_ARGS(sc_exit(ret,) pid, len, user_mask_ptr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(unsigned int, len, len)) sc_out(ctf_integer(unsigned long *, user_mask_ptr, user_mask_ptr))) -) -#endif -#ifndef OVERRIDE_64_rt_sigqueueinfo -SC_LTTNG_TRACEPOINT_EVENT(rt_sigqueueinfo, - TP_PROTO(sc_exit(long ret,) pid_t pid, int sig, siginfo_t * uinfo), - TP_ARGS(sc_exit(ret,) pid, sig, uinfo), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig)) sc_in(ctf_integer(siginfo_t *, uinfo, uinfo))) -) -#endif -#ifndef OVERRIDE_64_getresuid -SC_LTTNG_TRACEPOINT_EVENT(getresuid, - TP_PROTO(sc_exit(long ret,) uid_t * ruidp, uid_t * euidp, uid_t * suidp), - TP_ARGS(sc_exit(ret,) ruidp, euidp, suidp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(uid_t *, ruidp, ruidp)) sc_out(ctf_integer(uid_t *, euidp, euidp)) sc_out(ctf_integer(uid_t *, suidp, suidp))) -) -#endif -#ifndef OVERRIDE_64_getresgid -SC_LTTNG_TRACEPOINT_EVENT(getresgid, - TP_PROTO(sc_exit(long ret,) gid_t * rgidp, gid_t * egidp, gid_t * sgidp), - TP_ARGS(sc_exit(ret,) rgidp, egidp, sgidp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(gid_t *, rgidp, rgidp)) sc_out(ctf_integer(gid_t *, egidp, egidp)) sc_out(ctf_integer(gid_t *, sgidp, sgidp))) -) -#endif -#ifndef OVERRIDE_64_getcpu -SC_LTTNG_TRACEPOINT_EVENT(getcpu, - TP_PROTO(sc_exit(long ret,) unsigned * cpup, unsigned * nodep, struct getcpu_cache * unused), - TP_ARGS(sc_exit(ret,) cpup, nodep, unused), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(unsigned *, cpup, cpup)) sc_out(ctf_integer(unsigned *, nodep, nodep)) sc_inout(ctf_integer(struct getcpu_cache *, unused, unused))) -) -#endif -#ifndef OVERRIDE_64_mq_getsetattr -SC_LTTNG_TRACEPOINT_EVENT(mq_getsetattr, - TP_PROTO(sc_exit(long ret,) mqd_t mqdes, const struct mq_attr * u_mqstat, struct mq_attr * u_omqstat), - TP_ARGS(sc_exit(ret,) mqdes, u_mqstat, u_omqstat), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(mqd_t, mqdes, mqdes)) sc_in(ctf_integer(const struct mq_attr *, u_mqstat, u_mqstat)) sc_out(ctf_integer(struct mq_attr *, u_omqstat, u_omqstat))) -) -#endif -#ifndef OVERRIDE_64_msgctl -SC_LTTNG_TRACEPOINT_EVENT(msgctl, - TP_PROTO(sc_exit(long ret,) int msqid, int cmd, struct msqid_ds * buf), - TP_ARGS(sc_exit(ret,) msqid, cmd, buf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, msqid, msqid)) sc_in(ctf_integer(int, cmd, cmd)) sc_inout(ctf_integer(struct msqid_ds *, buf, buf))) -) -#endif -#ifndef OVERRIDE_64_semop -SC_LTTNG_TRACEPOINT_EVENT(semop, - TP_PROTO(sc_exit(long ret,) int semid, struct sembuf * tsops, unsigned nsops), - TP_ARGS(sc_exit(ret,) semid, tsops, nsops), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, semid, semid)) sc_in(ctf_integer(struct sembuf *, tsops, tsops)) sc_in(ctf_integer(unsigned, nsops, nsops))) -) -#endif -#ifndef OVERRIDE_64_shmctl -SC_LTTNG_TRACEPOINT_EVENT(shmctl, - TP_PROTO(sc_exit(long ret,) int shmid, int cmd, struct shmid_ds * buf), - TP_ARGS(sc_exit(ret,) shmid, cmd, buf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, shmid, shmid)) sc_in(ctf_integer(int, cmd, cmd)) sc_inout(ctf_integer(struct shmid_ds *, buf, buf))) -) -#endif -#ifndef OVERRIDE_64_shmat -SC_LTTNG_TRACEPOINT_EVENT(shmat, - TP_PROTO(sc_exit(long ret,) int shmid, char * shmaddr, int shmflg), - TP_ARGS(sc_exit(ret,) shmid, shmaddr, shmflg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, shmid, shmid)) sc_in(ctf_integer(char *, shmaddr, shmaddr)) sc_in(ctf_integer(int, shmflg, shmflg))) -) -#endif -#ifndef OVERRIDE_64_bind -SC_LTTNG_TRACEPOINT_EVENT(bind, - TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * umyaddr, int addrlen), - TP_ARGS(sc_exit(ret,) fd, umyaddr, addrlen), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct sockaddr *, umyaddr, umyaddr)) sc_in(ctf_integer(int, addrlen, addrlen))) -) -#endif -#ifndef OVERRIDE_64_accept -SC_LTTNG_TRACEPOINT_EVENT(accept, - TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * upeer_sockaddr, int * upeer_addrlen), - TP_ARGS(sc_exit(ret,) fd, upeer_sockaddr, upeer_addrlen), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct sockaddr *, upeer_sockaddr, upeer_sockaddr)) sc_inout(ctf_integer(int *, upeer_addrlen, upeer_addrlen))) -) -#endif -#ifndef OVERRIDE_64_connect -SC_LTTNG_TRACEPOINT_EVENT(connect, - TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * uservaddr, int addrlen), - TP_ARGS(sc_exit(ret,) fd, uservaddr, addrlen), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct sockaddr *, uservaddr, uservaddr)) sc_in(ctf_integer(int, addrlen, addrlen))) -) -#endif -#ifndef OVERRIDE_64_getsockname -SC_LTTNG_TRACEPOINT_EVENT(getsockname, - TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * usockaddr, int * usockaddr_len), - TP_ARGS(sc_exit(ret,) fd, usockaddr, usockaddr_len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct sockaddr *, usockaddr, usockaddr)) sc_inout(ctf_integer(int *, usockaddr_len, usockaddr_len))) -) -#endif -#ifndef OVERRIDE_64_getpeername -SC_LTTNG_TRACEPOINT_EVENT(getpeername, - TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * usockaddr, int * usockaddr_len), - TP_ARGS(sc_exit(ret,) fd, usockaddr, usockaddr_len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct sockaddr *, usockaddr, usockaddr)) sc_inout(ctf_integer(int *, usockaddr_len, usockaddr_len))) -) -#endif -#ifndef OVERRIDE_64_sendmsg -SC_LTTNG_TRACEPOINT_EVENT(sendmsg, - TP_PROTO(sc_exit(long ret,) int fd, struct user_msghdr * msg, unsigned int flags), - TP_ARGS(sc_exit(ret,) fd, msg, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct user_msghdr *, msg, msg)) sc_in(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_recvmsg -SC_LTTNG_TRACEPOINT_EVENT(recvmsg, - TP_PROTO(sc_exit(long ret,) int fd, struct user_msghdr * msg, unsigned int flags), - TP_ARGS(sc_exit(ret,) fd, msg, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_inout(ctf_integer(struct user_msghdr *, msg, msg)) sc_in(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_execve -SC_LTTNG_TRACEPOINT_EVENT(execve, - TP_PROTO(sc_exit(long ret,) const char * filename, const char *const * argv, const char *const * envp), - TP_ARGS(sc_exit(ret,) filename, argv, envp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(filename, filename)) sc_inout(ctf_integer(const char *const *, argv, argv)) sc_inout(ctf_integer(const char *const *, envp, envp))) -) -#endif -#ifndef OVERRIDE_64_mincore -SC_LTTNG_TRACEPOINT_EVENT(mincore, - TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len, unsigned char * vec), - TP_ARGS(sc_exit(ret,) start, len, vec), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len)) sc_out(ctf_integer(unsigned char *, vec, vec))) -) -#endif -#ifndef OVERRIDE_64_open_by_handle_at -SC_LTTNG_TRACEPOINT_EVENT(open_by_handle_at, - TP_PROTO(sc_exit(long ret,) int mountdirfd, struct file_handle * handle, int flags), - TP_ARGS(sc_exit(ret,) mountdirfd, handle, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, mountdirfd, mountdirfd)) sc_in(ctf_integer(struct file_handle *, handle, handle)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_finit_module -SC_LTTNG_TRACEPOINT_EVENT(finit_module, - TP_PROTO(sc_exit(long ret,) int fd, const char * uargs, int flags), - TP_ARGS(sc_exit(ret,) fd, uargs, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(const char *, uargs, uargs)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_sched_setattr -SC_LTTNG_TRACEPOINT_EVENT(sched_setattr, - TP_PROTO(sc_exit(long ret,) pid_t pid, struct sched_attr * uattr, unsigned int flags), - TP_ARGS(sc_exit(ret,) pid, uattr, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(pid_t, pid, pid)) sc_inout(ctf_integer(struct sched_attr *, uattr, uattr)) sc_inout(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_seccomp -SC_LTTNG_TRACEPOINT_EVENT(seccomp, - TP_PROTO(sc_exit(long ret,) unsigned int op, unsigned int flags, const char * uargs), - TP_ARGS(sc_exit(ret,) op, flags, uargs), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, op, op)) sc_inout(ctf_integer(unsigned int, flags, flags)) sc_inout(ctf_integer(const char *, uargs, uargs))) -) -#endif -#ifndef OVERRIDE_64_getrandom -SC_LTTNG_TRACEPOINT_EVENT(getrandom, - TP_PROTO(sc_exit(long ret,) char * buf, size_t count, unsigned int flags), - TP_ARGS(sc_exit(ret,) buf, count, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(char *, buf, buf)) sc_inout(ctf_integer(size_t, count, count)) sc_inout(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_getxattr -SC_LTTNG_TRACEPOINT_EVENT(getxattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, void * value, size_t size), - TP_ARGS(sc_exit(ret,) pathname, name, value, size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_out(ctf_integer(void *, value, value)) sc_in(ctf_integer(size_t, size, size))) -) -#endif -#ifndef OVERRIDE_64_lgetxattr -SC_LTTNG_TRACEPOINT_EVENT(lgetxattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, void * value, size_t size), - TP_ARGS(sc_exit(ret,) pathname, name, value, size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_out(ctf_integer(void *, value, value)) sc_in(ctf_integer(size_t, size, size))) -) -#endif -#ifndef OVERRIDE_64_fgetxattr -SC_LTTNG_TRACEPOINT_EVENT(fgetxattr, - TP_PROTO(sc_exit(long ret,) int fd, const char * name, void * value, size_t size), - TP_ARGS(sc_exit(ret,) fd, name, value, size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(name, name)) sc_out(ctf_integer(void *, value, value)) sc_in(ctf_integer(size_t, size, size))) -) -#endif -#ifndef OVERRIDE_64_epoll_ctl -SC_LTTNG_TRACEPOINT_EVENT(epoll_ctl, - TP_PROTO(sc_exit(long ret,) int epfd, int op, int fd, struct epoll_event * event), - TP_ARGS(sc_exit(ret,) epfd, op, fd, event), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, epfd, epfd)) sc_in(ctf_integer(int, op, op)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct epoll_event *, event, event))) -) -#endif -#ifndef OVERRIDE_64_mknodat -SC_LTTNG_TRACEPOINT_EVENT(mknodat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, umode_t mode, unsigned dev), - TP_ARGS(sc_exit(ret,) dfd, filename, mode, dev), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(umode_t, mode, mode)) sc_in(ctf_integer(unsigned, dev, dev))) -) -#endif -#ifndef OVERRIDE_64_renameat -SC_LTTNG_TRACEPOINT_EVENT(renameat, - TP_PROTO(sc_exit(long ret,) int olddfd, const char * oldname, int newdfd, const char * newname), - TP_ARGS(sc_exit(ret,) olddfd, oldname, newdfd, newname), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, olddfd, olddfd)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_integer(int, newdfd, newdfd)) sc_in(ctf_user_string(newname, newname))) -) -#endif -#ifndef OVERRIDE_64_openat -SC_LTTNG_TRACEPOINT_EVENT(openat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, int flags, umode_t mode), - TP_ARGS(sc_exit(ret,) dfd, filename, flags, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(umode_t, mode, mode))) -) -#endif -#ifndef OVERRIDE_64_quotactl -SC_LTTNG_TRACEPOINT_EVENT(quotactl, - TP_PROTO(sc_exit(long ret,) unsigned int cmd, const char * special, qid_t id, void * addr), - TP_ARGS(sc_exit(ret,) cmd, special, id, addr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_in(ctf_integer(const char *, special, special)) sc_in(ctf_integer(qid_t, id, id)) sc_inout(ctf_integer(void *, addr, addr))) -) -#endif -#ifndef OVERRIDE_64_pread64 -SC_LTTNG_TRACEPOINT_EVENT(pread64, - TP_PROTO(sc_exit(long ret,) unsigned int fd, char * buf, size_t count, loff_t pos), - TP_ARGS(sc_exit(ret,) fd, buf, count, pos), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(size_t, count, count)) sc_in(ctf_integer(loff_t, pos, pos))) -) -#endif -#ifndef OVERRIDE_64_pwrite64 -SC_LTTNG_TRACEPOINT_EVENT(pwrite64, - TP_PROTO(sc_exit(long ret,) unsigned int fd, const char * buf, size_t count, loff_t pos), - TP_ARGS(sc_exit(ret,) fd, buf, count, pos), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(const char *, buf, buf)) sc_in(ctf_integer(size_t, count, count)) sc_in(ctf_integer(loff_t, pos, pos))) -) -#endif -#ifndef OVERRIDE_64_sendfile64 -SC_LTTNG_TRACEPOINT_EVENT(sendfile64, - TP_PROTO(sc_exit(long ret,) int out_fd, int in_fd, loff_t * offset, size_t count), - TP_ARGS(sc_exit(ret,) out_fd, in_fd, offset, count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, out_fd, out_fd)) sc_in(ctf_integer(int, in_fd, in_fd)) sc_inout(ctf_integer(loff_t *, offset, offset)) sc_in(ctf_integer(size_t, count, count))) -) -#endif -#ifndef OVERRIDE_64_signalfd4 -SC_LTTNG_TRACEPOINT_EVENT(signalfd4, - TP_PROTO(sc_exit(long ret,) int ufd, sigset_t * user_mask, size_t sizemask, int flags), - TP_ARGS(sc_exit(ret,) ufd, user_mask, sizemask, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_in(ctf_integer(sigset_t *, user_mask, user_mask)) sc_in(ctf_integer(size_t, sizemask, sizemask)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_vmsplice -SC_LTTNG_TRACEPOINT_EVENT(vmsplice, - TP_PROTO(sc_exit(long ret,) int fd, const struct iovec * iov, unsigned long nr_segs, unsigned int flags), - TP_ARGS(sc_exit(ret,) fd, iov, nr_segs, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(const struct iovec *, iov, iov)) sc_in(ctf_integer(unsigned long, nr_segs, nr_segs)) sc_in(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_readlinkat -SC_LTTNG_TRACEPOINT_EVENT(readlinkat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * pathname, char * buf, int bufsiz), - TP_ARGS(sc_exit(ret,) dfd, pathname, buf, bufsiz), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(int, bufsiz, bufsiz))) -) -#endif -#ifndef OVERRIDE_64_newfstatat -SC_LTTNG_TRACEPOINT_EVENT(newfstatat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, struct stat * statbuf, int flag), - TP_ARGS(sc_exit(ret,) dfd, filename, statbuf, flag), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_out(ctf_integer(struct stat *, statbuf, statbuf)) sc_in(ctf_integer(int, flag, flag))) -) -#endif -#ifndef OVERRIDE_64_timerfd_settime -SC_LTTNG_TRACEPOINT_EVENT(timerfd_settime, - TP_PROTO(sc_exit(long ret,) int ufd, int flags, const struct itimerspec * utmr, struct itimerspec * otmr), - TP_ARGS(sc_exit(ret,) ufd, flags, utmr, otmr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(const struct itimerspec *, utmr, utmr)) sc_out(ctf_integer(struct itimerspec *, otmr, otmr))) -) -#endif -#ifndef OVERRIDE_64_utimensat -SC_LTTNG_TRACEPOINT_EVENT(utimensat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, struct timespec * utimes, int flags), - TP_ARGS(sc_exit(ret,) dfd, filename, utimes, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(struct timespec *, utimes, utimes)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_timer_settime -SC_LTTNG_TRACEPOINT_EVENT(timer_settime, - TP_PROTO(sc_exit(long ret,) timer_t timer_id, int flags, const struct itimerspec * new_setting, struct itimerspec * old_setting), - TP_ARGS(sc_exit(ret,) timer_id, flags, new_setting, old_setting), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(const struct itimerspec *, new_setting, new_setting)) sc_out(ctf_integer(struct itimerspec *, old_setting, old_setting))) -) -#endif -#ifndef OVERRIDE_64_clock_nanosleep -SC_LTTNG_TRACEPOINT_EVENT(clock_nanosleep, - TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, int flags, const struct timespec * rqtp, struct timespec * rmtp), - TP_ARGS(sc_exit(ret,) which_clock, flags, rqtp, rmtp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(const struct timespec *, rqtp, rqtp)) sc_out(ctf_integer(struct timespec *, rmtp, rmtp))) -) -#endif -#ifndef OVERRIDE_64_rt_sigaction -SC_LTTNG_TRACEPOINT_EVENT(rt_sigaction, - TP_PROTO(sc_exit(long ret,) int sig, const struct sigaction * act, struct sigaction * oact, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) sig, act, oact, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, sig, sig)) sc_in(ctf_integer(const struct sigaction *, act, act)) sc_out(ctf_integer(struct sigaction *, oact, oact)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) -) -#endif -#ifndef OVERRIDE_64_rt_sigprocmask -SC_LTTNG_TRACEPOINT_EVENT(rt_sigprocmask, - TP_PROTO(sc_exit(long ret,) int how, sigset_t * nset, sigset_t * oset, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) how, nset, oset, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, how, how)) sc_in(ctf_integer(sigset_t *, nset, nset)) sc_out(ctf_integer(sigset_t *, oset, oset)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) -) -#endif -#ifndef OVERRIDE_64_rt_sigtimedwait -SC_LTTNG_TRACEPOINT_EVENT(rt_sigtimedwait, - TP_PROTO(sc_exit(long ret,) const sigset_t * uthese, siginfo_t * uinfo, const struct timespec * uts, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) uthese, uinfo, uts, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(const sigset_t *, uthese, uthese)) sc_out(ctf_integer(siginfo_t *, uinfo, uinfo)) sc_in(ctf_integer(const struct timespec *, uts, uts)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) -) -#endif -#ifndef OVERRIDE_64_reboot -SC_LTTNG_TRACEPOINT_EVENT(reboot, - TP_PROTO(sc_exit(long ret,) int magic1, int magic2, unsigned int cmd, void * arg), - TP_ARGS(sc_exit(ret,) magic1, magic2, cmd, arg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, magic1, magic1)) sc_in(ctf_integer(int, magic2, magic2)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_in(ctf_integer(void *, arg, arg))) -) -#endif -#ifndef OVERRIDE_64_mq_open -SC_LTTNG_TRACEPOINT_EVENT(mq_open, - TP_PROTO(sc_exit(long ret,) const char * u_name, int oflag, umode_t mode, struct mq_attr * u_attr), - TP_ARGS(sc_exit(ret,) u_name, oflag, mode, u_attr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(u_name, u_name)) sc_in(ctf_integer(int, oflag, oflag)) sc_in(ctf_integer(umode_t, mode, mode)) sc_in(ctf_integer(struct mq_attr *, u_attr, u_attr))) -) -#endif -#ifndef OVERRIDE_64_msgsnd -SC_LTTNG_TRACEPOINT_EVENT(msgsnd, - TP_PROTO(sc_exit(long ret,) int msqid, struct msgbuf * msgp, size_t msgsz, int msgflg), - TP_ARGS(sc_exit(ret,) msqid, msgp, msgsz, msgflg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, msqid, msqid)) sc_in(ctf_integer(struct msgbuf *, msgp, msgp)) sc_in(ctf_integer(size_t, msgsz, msgsz)) sc_in(ctf_integer(int, msgflg, msgflg))) -) -#endif -#ifndef OVERRIDE_64_semtimedop -SC_LTTNG_TRACEPOINT_EVENT(semtimedop, - TP_PROTO(sc_exit(long ret,) int semid, struct sembuf * tsops, unsigned nsops, const struct timespec * timeout), - TP_ARGS(sc_exit(ret,) semid, tsops, nsops, timeout), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, semid, semid)) sc_in(ctf_integer(struct sembuf *, tsops, tsops)) sc_in(ctf_integer(unsigned, nsops, nsops)) sc_inout(ctf_integer(const struct timespec *, timeout, timeout))) -) -#endif -#ifndef OVERRIDE_64_socketpair -SC_LTTNG_TRACEPOINT_EVENT(socketpair, - TP_PROTO(sc_exit(long ret,) int family, int type, int protocol, int * usockvec), - TP_ARGS(sc_exit(ret,) family, type, protocol, usockvec), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, family, family)) sc_in(ctf_integer(int, type, type)) sc_in(ctf_integer(int, protocol, protocol)) sc_out(ctf_integer(int *, usockvec, usockvec))) -) -#endif -#ifndef OVERRIDE_64_request_key -SC_LTTNG_TRACEPOINT_EVENT(request_key, - TP_PROTO(sc_exit(long ret,) const char * _type, const char * _description, const char * _callout_info, key_serial_t destringid), - TP_ARGS(sc_exit(ret,) _type, _description, _callout_info, destringid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(_type, _type)) sc_in(ctf_integer(const char *, _description, _description)) sc_in(ctf_integer(const char *, _callout_info, _callout_info)) sc_in(ctf_integer(key_serial_t, destringid, destringid))) -) -#endif -#ifndef OVERRIDE_64_rt_tgsigqueueinfo -SC_LTTNG_TRACEPOINT_EVENT(rt_tgsigqueueinfo, - TP_PROTO(sc_exit(long ret,) pid_t tgid, pid_t pid, int sig, siginfo_t * uinfo), - TP_ARGS(sc_exit(ret,) tgid, pid, sig, uinfo), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, tgid, tgid)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig)) sc_in(ctf_integer(siginfo_t *, uinfo, uinfo))) -) -#endif -#ifndef OVERRIDE_64_accept4 -SC_LTTNG_TRACEPOINT_EVENT(accept4, - TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * upeer_sockaddr, int * upeer_addrlen, int flags), - TP_ARGS(sc_exit(ret,) fd, upeer_sockaddr, upeer_addrlen, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct sockaddr *, upeer_sockaddr, upeer_sockaddr)) sc_inout(ctf_integer(int *, upeer_addrlen, upeer_addrlen)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_wait4 -SC_LTTNG_TRACEPOINT_EVENT(wait4, - TP_PROTO(sc_exit(long ret,) pid_t upid, int * stat_addr, int options, struct rusage * ru), - TP_ARGS(sc_exit(ret,) upid, stat_addr, options, ru), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, upid, upid)) sc_out(ctf_integer(int *, stat_addr, stat_addr)) sc_in(ctf_integer(int, options, options)) sc_out(ctf_integer(struct rusage *, ru, ru))) -) -#endif -#ifndef OVERRIDE_64_prlimit64 -SC_LTTNG_TRACEPOINT_EVENT(prlimit64, - TP_PROTO(sc_exit(long ret,) pid_t pid, unsigned int resource, const struct rlimit64 * new_rlim, struct rlimit64 * old_rlim), - TP_ARGS(sc_exit(ret,) pid, resource, new_rlim, old_rlim), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(unsigned int, resource, resource)) sc_in(ctf_integer(const struct rlimit64 *, new_rlim, new_rlim)) sc_out(ctf_integer(struct rlimit64 *, old_rlim, old_rlim))) -) -#endif -#ifndef OVERRIDE_64_sendmmsg -SC_LTTNG_TRACEPOINT_EVENT(sendmmsg, - TP_PROTO(sc_exit(long ret,) int fd, struct mmsghdr * mmsg, unsigned int vlen, unsigned int flags), - TP_ARGS(sc_exit(ret,) fd, mmsg, vlen, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct mmsghdr *, mmsg, mmsg)) sc_in(ctf_integer(unsigned int, vlen, vlen)) sc_in(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_sched_getattr -SC_LTTNG_TRACEPOINT_EVENT(sched_getattr, - TP_PROTO(sc_exit(long ret,) pid_t pid, struct sched_attr * uattr, unsigned int size, unsigned int flags), - TP_ARGS(sc_exit(ret,) pid, uattr, size, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(pid_t, pid, pid)) sc_inout(ctf_integer(struct sched_attr *, uattr, uattr)) sc_inout(ctf_integer(unsigned int, size, size)) sc_inout(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_io_getevents -SC_LTTNG_TRACEPOINT_EVENT(io_getevents, - TP_PROTO(sc_exit(long ret,) aio_context_t ctx_id, long min_nr, long nr, struct io_event * events, struct timespec * timeout), - TP_ARGS(sc_exit(ret,) ctx_id, min_nr, nr, events, timeout), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx_id, ctx_id)) sc_in(ctf_integer(long, min_nr, min_nr)) sc_in(ctf_integer(long, nr, nr)) sc_out(ctf_integer(struct io_event *, events, events)) sc_inout(ctf_integer(struct timespec *, timeout, timeout))) -) -#endif -#ifndef OVERRIDE_64_setxattr -SC_LTTNG_TRACEPOINT_EVENT(setxattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, const void * value, size_t size, int flags), - TP_ARGS(sc_exit(ret,) pathname, name, value, size, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(const void *, value, value)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_lsetxattr -SC_LTTNG_TRACEPOINT_EVENT(lsetxattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, const void * value, size_t size, int flags), - TP_ARGS(sc_exit(ret,) pathname, name, value, size, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(const void *, value, value)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_fsetxattr -SC_LTTNG_TRACEPOINT_EVENT(fsetxattr, - TP_PROTO(sc_exit(long ret,) int fd, const char * name, const void * value, size_t size, int flags), - TP_ARGS(sc_exit(ret,) fd, name, value, size, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(const void *, value, value)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_linkat -SC_LTTNG_TRACEPOINT_EVENT(linkat, - TP_PROTO(sc_exit(long ret,) int olddfd, const char * oldname, int newdfd, const char * newname, int flags), - TP_ARGS(sc_exit(ret,) olddfd, oldname, newdfd, newname, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, olddfd, olddfd)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_integer(int, newdfd, newdfd)) sc_in(ctf_user_string(newname, newname)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_mount -SC_LTTNG_TRACEPOINT_EVENT(mount, - TP_PROTO(sc_exit(long ret,) char * dev_name, char * dir_name, char * type, unsigned long flags, void * data), - TP_ARGS(sc_exit(ret,) dev_name, dir_name, type, flags, data), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(dev_name, dev_name)) sc_in(ctf_user_string(dir_name, dir_name)) sc_in(ctf_user_string(type, type)) sc_in(ctf_integer(unsigned long, flags, flags)) sc_in(ctf_integer(void *, data, data))) -) -#endif -#ifndef OVERRIDE_64_fchownat -SC_LTTNG_TRACEPOINT_EVENT(fchownat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, uid_t user, gid_t group, int flag), - TP_ARGS(sc_exit(ret,) dfd, filename, user, group, flag), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group)) sc_in(ctf_integer(int, flag, flag))) -) -#endif -#ifndef OVERRIDE_64_preadv -SC_LTTNG_TRACEPOINT_EVENT(preadv, - TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen, unsigned long pos_l, unsigned long pos_h), - TP_ARGS(sc_exit(ret,) fd, vec, vlen, pos_l, pos_h), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_out(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen)) sc_in(ctf_integer(unsigned long, pos_l, pos_l)) sc_in(ctf_integer(unsigned long, pos_h, pos_h))) -) -#endif -#ifndef OVERRIDE_64_pwritev -SC_LTTNG_TRACEPOINT_EVENT(pwritev, - TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen, unsigned long pos_l, unsigned long pos_h), - TP_ARGS(sc_exit(ret,) fd, vec, vlen, pos_l, pos_h), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_in(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen)) sc_in(ctf_integer(unsigned long, pos_l, pos_l)) sc_in(ctf_integer(unsigned long, pos_h, pos_h))) -) -#endif -#ifndef OVERRIDE_64_ppoll -SC_LTTNG_TRACEPOINT_EVENT(ppoll, - TP_PROTO(sc_exit(long ret,) struct pollfd * ufds, unsigned int nfds, struct timespec * tsp, const sigset_t * sigmask, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) ufds, nfds, tsp, sigmask, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct pollfd *, ufds, ufds)) sc_in(ctf_integer(unsigned int, nfds, nfds)) sc_in(ctf_integer(struct timespec *, tsp, tsp)) sc_in(ctf_integer(const sigset_t *, sigmask, sigmask)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) -) -#endif -#ifndef OVERRIDE_64_waitid -SC_LTTNG_TRACEPOINT_EVENT(waitid, - TP_PROTO(sc_exit(long ret,) int which, pid_t upid, struct siginfo * infop, int options, struct rusage * ru), - TP_ARGS(sc_exit(ret,) which, upid, infop, options, ru), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(pid_t, upid, upid)) sc_out(ctf_integer(struct siginfo *, infop, infop)) sc_in(ctf_integer(int, options, options)) sc_out(ctf_integer(struct rusage *, ru, ru))) -) -#endif -#ifndef OVERRIDE_64_mq_timedsend -SC_LTTNG_TRACEPOINT_EVENT(mq_timedsend, - TP_PROTO(sc_exit(long ret,) mqd_t mqdes, const char * u_msg_ptr, size_t msg_len, unsigned int msg_prio, const struct timespec * u_abs_timeout), - TP_ARGS(sc_exit(ret,) mqdes, u_msg_ptr, msg_len, msg_prio, u_abs_timeout), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(mqd_t, mqdes, mqdes)) sc_in(ctf_integer(const char *, u_msg_ptr, u_msg_ptr)) sc_in(ctf_integer(size_t, msg_len, msg_len)) sc_in(ctf_integer(unsigned int, msg_prio, msg_prio)) sc_in(ctf_integer(const struct timespec *, u_abs_timeout, u_abs_timeout))) -) -#endif -#ifndef OVERRIDE_64_mq_timedreceive -SC_LTTNG_TRACEPOINT_EVENT(mq_timedreceive, - TP_PROTO(sc_exit(long ret,) mqd_t mqdes, char * u_msg_ptr, size_t msg_len, unsigned int * u_msg_prio, const struct timespec * u_abs_timeout), - TP_ARGS(sc_exit(ret,) mqdes, u_msg_ptr, msg_len, u_msg_prio, u_abs_timeout), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(mqd_t, mqdes, mqdes)) sc_out(ctf_integer(char *, u_msg_ptr, u_msg_ptr)) sc_in(ctf_integer(size_t, msg_len, msg_len)) sc_out(ctf_integer(unsigned int *, u_msg_prio, u_msg_prio)) sc_in(ctf_integer(const struct timespec *, u_abs_timeout, u_abs_timeout))) -) -#endif -#ifndef OVERRIDE_64_msgrcv -SC_LTTNG_TRACEPOINT_EVENT(msgrcv, - TP_PROTO(sc_exit(long ret,) int msqid, struct msgbuf * msgp, size_t msgsz, long msgtyp, int msgflg), - TP_ARGS(sc_exit(ret,) msqid, msgp, msgsz, msgtyp, msgflg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, msqid, msqid)) sc_out(ctf_integer(struct msgbuf *, msgp, msgp)) sc_in(ctf_integer(size_t, msgsz, msgsz)) sc_in(ctf_integer(long, msgtyp, msgtyp)) sc_in(ctf_integer(int, msgflg, msgflg))) -) -#endif -#ifndef OVERRIDE_64_setsockopt -SC_LTTNG_TRACEPOINT_EVENT(setsockopt, - TP_PROTO(sc_exit(long ret,) int fd, int level, int optname, char * optval, int optlen), - TP_ARGS(sc_exit(ret,) fd, level, optname, optval, optlen), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, level, level)) sc_in(ctf_integer(int, optname, optname)) sc_in(ctf_integer(char *, optval, optval)) sc_in(ctf_integer(int, optlen, optlen))) -) -#endif -#ifndef OVERRIDE_64_getsockopt -SC_LTTNG_TRACEPOINT_EVENT(getsockopt, - TP_PROTO(sc_exit(long ret,) int fd, int level, int optname, char * optval, int * optlen), - TP_ARGS(sc_exit(ret,) fd, level, optname, optval, optlen), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, level, level)) sc_in(ctf_integer(int, optname, optname)) sc_out(ctf_integer(char *, optval, optval)) sc_inout(ctf_integer(int *, optlen, optlen))) -) -#endif -#ifndef OVERRIDE_64_add_key -SC_LTTNG_TRACEPOINT_EVENT(add_key, - TP_PROTO(sc_exit(long ret,) const char * _type, const char * _description, const void * _payload, size_t plen, key_serial_t ringid), - TP_ARGS(sc_exit(ret,) _type, _description, _payload, plen, ringid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(_type, _type)) sc_in(ctf_integer(const char *, _description, _description)) sc_in(ctf_integer(const void *, _payload, _payload)) sc_in(ctf_integer(size_t, plen, plen)) sc_in(ctf_integer(key_serial_t, ringid, ringid))) -) -#endif -#ifndef OVERRIDE_64_perf_event_open -SC_LTTNG_TRACEPOINT_EVENT(perf_event_open, - TP_PROTO(sc_exit(long ret,) struct perf_event_attr * attr_uptr, pid_t pid, int cpu, int group_fd, unsigned long flags), - TP_ARGS(sc_exit(ret,) attr_uptr, pid, cpu, group_fd, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct perf_event_attr *, attr_uptr, attr_uptr)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, cpu, cpu)) sc_in(ctf_integer(int, group_fd, group_fd)) sc_in(ctf_integer(unsigned long, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_recvmmsg -SC_LTTNG_TRACEPOINT_EVENT(recvmmsg, - TP_PROTO(sc_exit(long ret,) int fd, struct mmsghdr * mmsg, unsigned int vlen, unsigned int flags, struct timespec * timeout), - TP_ARGS(sc_exit(ret,) fd, mmsg, vlen, flags, timeout), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct mmsghdr *, mmsg, mmsg)) sc_in(ctf_integer(unsigned int, vlen, vlen)) sc_in(ctf_integer(unsigned int, flags, flags)) sc_inout(ctf_integer(struct timespec *, timeout, timeout))) -) -#endif -#ifndef OVERRIDE_64_fanotify_mark -SC_LTTNG_TRACEPOINT_EVENT(fanotify_mark, - TP_PROTO(sc_exit(long ret,) int fanotify_fd, unsigned int flags, __u64 mask, int dfd, const char * pathname), - TP_ARGS(sc_exit(ret,) fanotify_fd, flags, mask, dfd, pathname), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fanotify_fd, fanotify_fd)) sc_in(ctf_integer(unsigned int, flags, flags)) sc_in(ctf_integer(__u64, mask, mask)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(pathname, pathname))) -) -#endif -#ifndef OVERRIDE_64_name_to_handle_at -SC_LTTNG_TRACEPOINT_EVENT(name_to_handle_at, - TP_PROTO(sc_exit(long ret,) int dfd, const char * name, struct file_handle * handle, int * mnt_id, int flag), - TP_ARGS(sc_exit(ret,) dfd, name, handle, mnt_id, flag), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(name, name)) sc_inout(ctf_integer(struct file_handle *, handle, handle)) sc_out(ctf_integer(int *, mnt_id, mnt_id)) sc_in(ctf_integer(int, flag, flag))) -) -#endif -#ifndef OVERRIDE_64_renameat2 -SC_LTTNG_TRACEPOINT_EVENT(renameat2, - TP_PROTO(sc_exit(long ret,) int olddfd, const char * oldname, int newdfd, const char * newname, unsigned int flags), - TP_ARGS(sc_exit(ret,) olddfd, oldname, newdfd, newname, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, olddfd, olddfd)) sc_inout(ctf_user_string(oldname, oldname)) sc_inout(ctf_integer(int, newdfd, newdfd)) sc_inout(ctf_user_string(newname, newname)) sc_inout(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_execveat -SC_LTTNG_TRACEPOINT_EVENT(execveat, - TP_PROTO(sc_exit(long ret,) int fd, const char * filename, const char *const * argv, const char *const * envp, int flags), - TP_ARGS(sc_exit(ret,) fd, filename, argv, envp, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, fd, fd)) sc_inout(ctf_user_string(filename, filename)) sc_inout(ctf_integer(const char *const *, argv, argv)) sc_inout(ctf_integer(const char *const *, envp, envp)) sc_inout(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_epoll_pwait -SC_LTTNG_TRACEPOINT_EVENT(epoll_pwait, - TP_PROTO(sc_exit(long ret,) int epfd, struct epoll_event * events, int maxevents, int timeout, const sigset_t * sigmask, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) epfd, events, maxevents, timeout, sigmask, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, epfd, epfd)) sc_out(ctf_integer(struct epoll_event *, events, events)) sc_in(ctf_integer(int, maxevents, maxevents)) sc_in(ctf_integer(int, timeout, timeout)) sc_in(ctf_integer(const sigset_t *, sigmask, sigmask)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) -) -#endif -#ifndef OVERRIDE_64_pselect6 -SC_LTTNG_TRACEPOINT_EVENT(pselect6, - TP_PROTO(sc_exit(long ret,) int n, fd_set * inp, fd_set * outp, fd_set * exp, struct timespec * tsp, void * sig), - TP_ARGS(sc_exit(ret,) n, inp, outp, exp, tsp, sig), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, n, n)) sc_inout(ctf_integer(fd_set *, inp, inp)) sc_inout(ctf_integer(fd_set *, outp, outp)) sc_inout(ctf_integer(fd_set *, exp, exp)) sc_inout(ctf_integer(struct timespec *, tsp, tsp)) sc_in(ctf_integer(void *, sig, sig))) -) -#endif -#ifndef OVERRIDE_64_splice -SC_LTTNG_TRACEPOINT_EVENT(splice, - TP_PROTO(sc_exit(long ret,) int fd_in, loff_t * off_in, int fd_out, loff_t * off_out, size_t len, unsigned int flags), - TP_ARGS(sc_exit(ret,) fd_in, off_in, fd_out, off_out, len, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd_in, fd_in)) sc_in(ctf_integer(loff_t *, off_in, off_in)) sc_in(ctf_integer(int, fd_out, fd_out)) sc_in(ctf_integer(loff_t *, off_out, off_out)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_futex -SC_LTTNG_TRACEPOINT_EVENT(futex, - TP_PROTO(sc_exit(long ret,) u32 * uaddr, int op, u32 val, struct timespec * utime, u32 * uaddr2, u32 val3), - TP_ARGS(sc_exit(ret,) uaddr, op, val, utime, uaddr2, val3), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(u32 *, uaddr, uaddr)) sc_in(ctf_integer(int, op, op)) sc_in(ctf_integer(u32, val, val)) sc_in(ctf_integer(struct timespec *, utime, utime)) sc_inout(ctf_integer(u32 *, uaddr2, uaddr2)) sc_in(ctf_integer(u32, val3, val3))) -) -#endif -#ifndef OVERRIDE_64_sendto -SC_LTTNG_TRACEPOINT_EVENT(sendto, - TP_PROTO(sc_exit(long ret,) int fd, void * buff, size_t len, unsigned int flags, struct sockaddr * addr, int addr_len), - TP_ARGS(sc_exit(ret,) fd, buff, len, flags, addr, addr_len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(void *, buff, buff)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned int, flags, flags)) sc_in(ctf_integer(struct sockaddr *, addr, addr)) sc_in(ctf_integer(int, addr_len, addr_len))) -) -#endif -#ifndef OVERRIDE_64_recvfrom -SC_LTTNG_TRACEPOINT_EVENT(recvfrom, - TP_PROTO(sc_exit(long ret,) int fd, void * ubuf, size_t size, unsigned int flags, struct sockaddr * addr, int * addr_len), - TP_ARGS(sc_exit(ret,) fd, ubuf, size, flags, addr, addr_len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(void *, ubuf, ubuf)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(unsigned int, flags, flags)) sc_out(ctf_integer(struct sockaddr *, addr, addr)) sc_inout(ctf_integer(int *, addr_len, addr_len))) -) -#endif -#ifndef OVERRIDE_64_process_vm_readv -SC_LTTNG_TRACEPOINT_EVENT(process_vm_readv, - TP_PROTO(sc_exit(long ret,) pid_t pid, const struct iovec * lvec, unsigned long liovcnt, const struct iovec * rvec, unsigned long riovcnt, unsigned long flags), - TP_ARGS(sc_exit(ret,) pid, lvec, liovcnt, rvec, riovcnt, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_out(ctf_integer(const struct iovec *, lvec, lvec)) sc_in(ctf_integer(unsigned long, liovcnt, liovcnt)) sc_in(ctf_integer(const struct iovec *, rvec, rvec)) sc_in(ctf_integer(unsigned long, riovcnt, riovcnt)) sc_in(ctf_integer(unsigned long, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_process_vm_writev -SC_LTTNG_TRACEPOINT_EVENT(process_vm_writev, - TP_PROTO(sc_exit(long ret,) pid_t pid, const struct iovec * lvec, unsigned long liovcnt, const struct iovec * rvec, unsigned long riovcnt, unsigned long flags), - TP_ARGS(sc_exit(ret,) pid, lvec, liovcnt, rvec, riovcnt, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(const struct iovec *, lvec, lvec)) sc_in(ctf_integer(unsigned long, liovcnt, liovcnt)) sc_in(ctf_integer(const struct iovec *, rvec, rvec)) sc_in(ctf_integer(unsigned long, riovcnt, riovcnt)) sc_in(ctf_integer(unsigned long, flags, flags))) -) -#endif - -#endif /* _TRACE_SYSCALLS_POINTERS_H */ - -/* This part must be outside protection */ -#include - -#else /* CREATE_SYSCALL_TABLE */ - -#include "arm-64-syscalls_pointers_override.h" -#include "syscalls_pointers_override.h" - -#ifndef OVERRIDE_TABLE_64_io_setup -TRACE_SYSCALL_TABLE(io_setup, io_setup, 0, 2) -#endif -#ifndef OVERRIDE_TABLE_64_io_submit -TRACE_SYSCALL_TABLE(io_submit, io_submit, 2, 3) -#endif -#ifndef OVERRIDE_TABLE_64_io_cancel -TRACE_SYSCALL_TABLE(io_cancel, io_cancel, 3, 3) -#endif -#ifndef OVERRIDE_TABLE_64_io_getevents -TRACE_SYSCALL_TABLE(io_getevents, io_getevents, 4, 5) -#endif -#ifndef OVERRIDE_TABLE_64_setxattr -TRACE_SYSCALL_TABLE(setxattr, setxattr, 5, 5) -#endif -#ifndef OVERRIDE_TABLE_64_lsetxattr -TRACE_SYSCALL_TABLE(lsetxattr, lsetxattr, 6, 5) -#endif -#ifndef OVERRIDE_TABLE_64_fsetxattr -TRACE_SYSCALL_TABLE(fsetxattr, fsetxattr, 7, 5) -#endif -#ifndef OVERRIDE_TABLE_64_getxattr -TRACE_SYSCALL_TABLE(getxattr, getxattr, 8, 4) -#endif -#ifndef OVERRIDE_TABLE_64_lgetxattr -TRACE_SYSCALL_TABLE(lgetxattr, lgetxattr, 9, 4) -#endif -#ifndef OVERRIDE_TABLE_64_fgetxattr -TRACE_SYSCALL_TABLE(fgetxattr, fgetxattr, 10, 4) -#endif -#ifndef OVERRIDE_TABLE_64_listxattr -TRACE_SYSCALL_TABLE(listxattr, listxattr, 11, 3) -#endif -#ifndef OVERRIDE_TABLE_64_llistxattr -TRACE_SYSCALL_TABLE(llistxattr, llistxattr, 12, 3) -#endif -#ifndef OVERRIDE_TABLE_64_flistxattr -TRACE_SYSCALL_TABLE(flistxattr, flistxattr, 13, 3) -#endif -#ifndef OVERRIDE_TABLE_64_removexattr -TRACE_SYSCALL_TABLE(removexattr, removexattr, 14, 2) -#endif -#ifndef OVERRIDE_TABLE_64_lremovexattr -TRACE_SYSCALL_TABLE(lremovexattr, lremovexattr, 15, 2) -#endif -#ifndef OVERRIDE_TABLE_64_fremovexattr -TRACE_SYSCALL_TABLE(fremovexattr, fremovexattr, 16, 2) -#endif -#ifndef OVERRIDE_TABLE_64_getcwd -TRACE_SYSCALL_TABLE(getcwd, getcwd, 17, 2) -#endif -#ifndef OVERRIDE_TABLE_64_lookup_dcookie -TRACE_SYSCALL_TABLE(lookup_dcookie, lookup_dcookie, 18, 3) -#endif -#ifndef OVERRIDE_TABLE_64_epoll_ctl -TRACE_SYSCALL_TABLE(epoll_ctl, epoll_ctl, 21, 4) -#endif -#ifndef OVERRIDE_TABLE_64_epoll_pwait -TRACE_SYSCALL_TABLE(epoll_pwait, epoll_pwait, 22, 6) -#endif -#ifndef OVERRIDE_TABLE_64_inotify_add_watch -TRACE_SYSCALL_TABLE(inotify_add_watch, inotify_add_watch, 27, 3) -#endif -#ifndef OVERRIDE_TABLE_64_mknodat -TRACE_SYSCALL_TABLE(mknodat, mknodat, 33, 4) -#endif -#ifndef OVERRIDE_TABLE_64_mkdirat -TRACE_SYSCALL_TABLE(mkdirat, mkdirat, 34, 3) -#endif -#ifndef OVERRIDE_TABLE_64_unlinkat -TRACE_SYSCALL_TABLE(unlinkat, unlinkat, 35, 3) -#endif -#ifndef OVERRIDE_TABLE_64_symlinkat -TRACE_SYSCALL_TABLE(symlinkat, symlinkat, 36, 3) -#endif -#ifndef OVERRIDE_TABLE_64_linkat -TRACE_SYSCALL_TABLE(linkat, linkat, 37, 5) -#endif -#ifndef OVERRIDE_TABLE_64_renameat -TRACE_SYSCALL_TABLE(renameat, renameat, 38, 4) -#endif -#ifndef OVERRIDE_TABLE_64_umount -TRACE_SYSCALL_TABLE(umount, umount, 39, 2) -#endif -#ifndef OVERRIDE_TABLE_64_mount -TRACE_SYSCALL_TABLE(mount, mount, 40, 5) -#endif -#ifndef OVERRIDE_TABLE_64_pivot_root -TRACE_SYSCALL_TABLE(pivot_root, pivot_root, 41, 2) -#endif -#ifndef OVERRIDE_TABLE_64_statfs -TRACE_SYSCALL_TABLE(statfs, statfs, 43, 2) -#endif -#ifndef OVERRIDE_TABLE_64_fstatfs -TRACE_SYSCALL_TABLE(fstatfs, fstatfs, 44, 2) -#endif -#ifndef OVERRIDE_TABLE_64_truncate -TRACE_SYSCALL_TABLE(truncate, truncate, 45, 2) -#endif -#ifndef OVERRIDE_TABLE_64_faccessat -TRACE_SYSCALL_TABLE(faccessat, faccessat, 48, 3) -#endif -#ifndef OVERRIDE_TABLE_64_chdir -TRACE_SYSCALL_TABLE(chdir, chdir, 49, 1) -#endif -#ifndef OVERRIDE_TABLE_64_chroot -TRACE_SYSCALL_TABLE(chroot, chroot, 51, 1) -#endif -#ifndef OVERRIDE_TABLE_64_fchmodat -TRACE_SYSCALL_TABLE(fchmodat, fchmodat, 53, 3) -#endif -#ifndef OVERRIDE_TABLE_64_fchownat -TRACE_SYSCALL_TABLE(fchownat, fchownat, 54, 5) -#endif -#ifndef OVERRIDE_TABLE_64_openat -TRACE_SYSCALL_TABLE(openat, openat, 56, 4) -#endif -#ifndef OVERRIDE_TABLE_64_pipe2 -TRACE_SYSCALL_TABLE(pipe2, pipe2, 59, 2) -#endif -#ifndef OVERRIDE_TABLE_64_quotactl -TRACE_SYSCALL_TABLE(quotactl, quotactl, 60, 4) -#endif -#ifndef OVERRIDE_TABLE_64_getdents64 -TRACE_SYSCALL_TABLE(getdents64, getdents64, 61, 3) -#endif -#ifndef OVERRIDE_TABLE_64_read -TRACE_SYSCALL_TABLE(read, read, 63, 3) -#endif -#ifndef OVERRIDE_TABLE_64_write -TRACE_SYSCALL_TABLE(write, write, 64, 3) -#endif -#ifndef OVERRIDE_TABLE_64_readv -TRACE_SYSCALL_TABLE(readv, readv, 65, 3) -#endif -#ifndef OVERRIDE_TABLE_64_writev -TRACE_SYSCALL_TABLE(writev, writev, 66, 3) -#endif -#ifndef OVERRIDE_TABLE_64_pread64 -TRACE_SYSCALL_TABLE(pread64, pread64, 67, 4) -#endif -#ifndef OVERRIDE_TABLE_64_pwrite64 -TRACE_SYSCALL_TABLE(pwrite64, pwrite64, 68, 4) -#endif -#ifndef OVERRIDE_TABLE_64_preadv -TRACE_SYSCALL_TABLE(preadv, preadv, 69, 5) -#endif -#ifndef OVERRIDE_TABLE_64_pwritev -TRACE_SYSCALL_TABLE(pwritev, pwritev, 70, 5) -#endif -#ifndef OVERRIDE_TABLE_64_sendfile64 -TRACE_SYSCALL_TABLE(sendfile64, sendfile64, 71, 4) -#endif -#ifndef OVERRIDE_TABLE_64_pselect6 -TRACE_SYSCALL_TABLE(pselect6, pselect6, 72, 6) -#endif -#ifndef OVERRIDE_TABLE_64_ppoll -TRACE_SYSCALL_TABLE(ppoll, ppoll, 73, 5) -#endif -#ifndef OVERRIDE_TABLE_64_signalfd4 -TRACE_SYSCALL_TABLE(signalfd4, signalfd4, 74, 4) -#endif -#ifndef OVERRIDE_TABLE_64_vmsplice -TRACE_SYSCALL_TABLE(vmsplice, vmsplice, 75, 4) -#endif -#ifndef OVERRIDE_TABLE_64_splice -TRACE_SYSCALL_TABLE(splice, splice, 76, 6) -#endif -#ifndef OVERRIDE_TABLE_64_readlinkat -TRACE_SYSCALL_TABLE(readlinkat, readlinkat, 78, 4) -#endif -#ifndef OVERRIDE_TABLE_64_newfstatat -TRACE_SYSCALL_TABLE(newfstatat, newfstatat, 79, 4) -#endif -#ifndef OVERRIDE_TABLE_64_newfstat -TRACE_SYSCALL_TABLE(newfstat, newfstat, 80, 2) -#endif -#ifndef OVERRIDE_TABLE_64_timerfd_settime -TRACE_SYSCALL_TABLE(timerfd_settime, timerfd_settime, 86, 4) -#endif -#ifndef OVERRIDE_TABLE_64_timerfd_gettime -TRACE_SYSCALL_TABLE(timerfd_gettime, timerfd_gettime, 87, 2) -#endif -#ifndef OVERRIDE_TABLE_64_utimensat -TRACE_SYSCALL_TABLE(utimensat, utimensat, 88, 4) -#endif -#ifndef OVERRIDE_TABLE_64_acct -TRACE_SYSCALL_TABLE(acct, acct, 89, 1) -#endif -#ifndef OVERRIDE_TABLE_64_waitid -TRACE_SYSCALL_TABLE(waitid, waitid, 95, 5) -#endif -#ifndef OVERRIDE_TABLE_64_set_tid_address -TRACE_SYSCALL_TABLE(set_tid_address, set_tid_address, 96, 1) -#endif -#ifndef OVERRIDE_TABLE_64_futex -TRACE_SYSCALL_TABLE(futex, futex, 98, 6) -#endif -#ifndef OVERRIDE_TABLE_64_set_robust_list -TRACE_SYSCALL_TABLE(set_robust_list, set_robust_list, 99, 2) -#endif -#ifndef OVERRIDE_TABLE_64_get_robust_list -TRACE_SYSCALL_TABLE(get_robust_list, get_robust_list, 100, 3) -#endif -#ifndef OVERRIDE_TABLE_64_nanosleep -TRACE_SYSCALL_TABLE(nanosleep, nanosleep, 101, 2) -#endif -#ifndef OVERRIDE_TABLE_64_getitimer -TRACE_SYSCALL_TABLE(getitimer, getitimer, 102, 2) -#endif -#ifndef OVERRIDE_TABLE_64_setitimer -TRACE_SYSCALL_TABLE(setitimer, setitimer, 103, 3) -#endif -#ifndef OVERRIDE_TABLE_64_init_module -TRACE_SYSCALL_TABLE(init_module, init_module, 105, 3) -#endif -#ifndef OVERRIDE_TABLE_64_delete_module -TRACE_SYSCALL_TABLE(delete_module, delete_module, 106, 2) -#endif -#ifndef OVERRIDE_TABLE_64_timer_create -TRACE_SYSCALL_TABLE(timer_create, timer_create, 107, 3) -#endif -#ifndef OVERRIDE_TABLE_64_timer_gettime -TRACE_SYSCALL_TABLE(timer_gettime, timer_gettime, 108, 2) -#endif -#ifndef OVERRIDE_TABLE_64_timer_settime -TRACE_SYSCALL_TABLE(timer_settime, timer_settime, 110, 4) -#endif -#ifndef OVERRIDE_TABLE_64_clock_settime -TRACE_SYSCALL_TABLE(clock_settime, clock_settime, 112, 2) -#endif -#ifndef OVERRIDE_TABLE_64_clock_gettime -TRACE_SYSCALL_TABLE(clock_gettime, clock_gettime, 113, 2) -#endif -#ifndef OVERRIDE_TABLE_64_clock_getres -TRACE_SYSCALL_TABLE(clock_getres, clock_getres, 114, 2) -#endif -#ifndef OVERRIDE_TABLE_64_clock_nanosleep -TRACE_SYSCALL_TABLE(clock_nanosleep, clock_nanosleep, 115, 4) -#endif -#ifndef OVERRIDE_TABLE_64_syslog -TRACE_SYSCALL_TABLE(syslog, syslog, 116, 3) -#endif -#ifndef OVERRIDE_TABLE_64_sched_setparam -TRACE_SYSCALL_TABLE(sched_setparam, sched_setparam, 118, 2) -#endif -#ifndef OVERRIDE_TABLE_64_sched_setscheduler -TRACE_SYSCALL_TABLE(sched_setscheduler, sched_setscheduler, 119, 3) -#endif -#ifndef OVERRIDE_TABLE_64_sched_getparam -TRACE_SYSCALL_TABLE(sched_getparam, sched_getparam, 121, 2) -#endif -#ifndef OVERRIDE_TABLE_64_sched_setaffinity -TRACE_SYSCALL_TABLE(sched_setaffinity, sched_setaffinity, 122, 3) -#endif -#ifndef OVERRIDE_TABLE_64_sched_getaffinity -TRACE_SYSCALL_TABLE(sched_getaffinity, sched_getaffinity, 123, 3) -#endif -#ifndef OVERRIDE_TABLE_64_sched_rr_get_interval -TRACE_SYSCALL_TABLE(sched_rr_get_interval, sched_rr_get_interval, 127, 2) -#endif -#ifndef OVERRIDE_TABLE_64_sigaltstack -TRACE_SYSCALL_TABLE(sigaltstack, sigaltstack, 132, 2) -#endif -#ifndef OVERRIDE_TABLE_64_rt_sigsuspend -TRACE_SYSCALL_TABLE(rt_sigsuspend, rt_sigsuspend, 133, 2) -#endif -#ifndef OVERRIDE_TABLE_64_rt_sigaction -TRACE_SYSCALL_TABLE(rt_sigaction, rt_sigaction, 134, 4) -#endif -#ifndef OVERRIDE_TABLE_64_rt_sigprocmask -TRACE_SYSCALL_TABLE(rt_sigprocmask, rt_sigprocmask, 135, 4) -#endif -#ifndef OVERRIDE_TABLE_64_rt_sigpending -TRACE_SYSCALL_TABLE(rt_sigpending, rt_sigpending, 136, 2) -#endif -#ifndef OVERRIDE_TABLE_64_rt_sigtimedwait -TRACE_SYSCALL_TABLE(rt_sigtimedwait, rt_sigtimedwait, 137, 4) -#endif -#ifndef OVERRIDE_TABLE_64_rt_sigqueueinfo -TRACE_SYSCALL_TABLE(rt_sigqueueinfo, rt_sigqueueinfo, 138, 3) -#endif -#ifndef OVERRIDE_TABLE_64_reboot -TRACE_SYSCALL_TABLE(reboot, reboot, 142, 4) -#endif -#ifndef OVERRIDE_TABLE_64_getresuid -TRACE_SYSCALL_TABLE(getresuid, getresuid, 148, 3) -#endif -#ifndef OVERRIDE_TABLE_64_getresgid -TRACE_SYSCALL_TABLE(getresgid, getresgid, 150, 3) -#endif -#ifndef OVERRIDE_TABLE_64_times -TRACE_SYSCALL_TABLE(times, times, 153, 1) -#endif -#ifndef OVERRIDE_TABLE_64_getgroups -TRACE_SYSCALL_TABLE(getgroups, getgroups, 158, 2) -#endif -#ifndef OVERRIDE_TABLE_64_setgroups -TRACE_SYSCALL_TABLE(setgroups, setgroups, 159, 2) -#endif -#ifndef OVERRIDE_TABLE_64_newuname -TRACE_SYSCALL_TABLE(newuname, newuname, 160, 1) -#endif -#ifndef OVERRIDE_TABLE_64_sethostname -TRACE_SYSCALL_TABLE(sethostname, sethostname, 161, 2) -#endif -#ifndef OVERRIDE_TABLE_64_setdomainname -TRACE_SYSCALL_TABLE(setdomainname, setdomainname, 162, 2) -#endif -#ifndef OVERRIDE_TABLE_64_getrlimit -TRACE_SYSCALL_TABLE(getrlimit, getrlimit, 163, 2) -#endif -#ifndef OVERRIDE_TABLE_64_setrlimit -TRACE_SYSCALL_TABLE(setrlimit, setrlimit, 164, 2) -#endif -#ifndef OVERRIDE_TABLE_64_getrusage -TRACE_SYSCALL_TABLE(getrusage, getrusage, 165, 2) -#endif -#ifndef OVERRIDE_TABLE_64_getcpu -TRACE_SYSCALL_TABLE(getcpu, getcpu, 168, 3) -#endif -#ifndef OVERRIDE_TABLE_64_gettimeofday -TRACE_SYSCALL_TABLE(gettimeofday, gettimeofday, 169, 2) -#endif -#ifndef OVERRIDE_TABLE_64_settimeofday -TRACE_SYSCALL_TABLE(settimeofday, settimeofday, 170, 2) -#endif -#ifndef OVERRIDE_TABLE_64_adjtimex -TRACE_SYSCALL_TABLE(adjtimex, adjtimex, 171, 1) -#endif -#ifndef OVERRIDE_TABLE_64_sysinfo -TRACE_SYSCALL_TABLE(sysinfo, sysinfo, 179, 1) -#endif -#ifndef OVERRIDE_TABLE_64_mq_open -TRACE_SYSCALL_TABLE(mq_open, mq_open, 180, 4) -#endif -#ifndef OVERRIDE_TABLE_64_mq_unlink -TRACE_SYSCALL_TABLE(mq_unlink, mq_unlink, 181, 1) -#endif -#ifndef OVERRIDE_TABLE_64_mq_timedsend -TRACE_SYSCALL_TABLE(mq_timedsend, mq_timedsend, 182, 5) -#endif -#ifndef OVERRIDE_TABLE_64_mq_timedreceive -TRACE_SYSCALL_TABLE(mq_timedreceive, mq_timedreceive, 183, 5) -#endif -#ifndef OVERRIDE_TABLE_64_mq_notify -TRACE_SYSCALL_TABLE(mq_notify, mq_notify, 184, 2) -#endif -#ifndef OVERRIDE_TABLE_64_mq_getsetattr -TRACE_SYSCALL_TABLE(mq_getsetattr, mq_getsetattr, 185, 3) -#endif -#ifndef OVERRIDE_TABLE_64_msgctl -TRACE_SYSCALL_TABLE(msgctl, msgctl, 187, 3) -#endif -#ifndef OVERRIDE_TABLE_64_msgrcv -TRACE_SYSCALL_TABLE(msgrcv, msgrcv, 188, 5) -#endif -#ifndef OVERRIDE_TABLE_64_msgsnd -TRACE_SYSCALL_TABLE(msgsnd, msgsnd, 189, 4) -#endif -#ifndef OVERRIDE_TABLE_64_semtimedop -TRACE_SYSCALL_TABLE(semtimedop, semtimedop, 192, 4) -#endif -#ifndef OVERRIDE_TABLE_64_semop -TRACE_SYSCALL_TABLE(semop, semop, 193, 3) -#endif -#ifndef OVERRIDE_TABLE_64_shmctl -TRACE_SYSCALL_TABLE(shmctl, shmctl, 195, 3) -#endif -#ifndef OVERRIDE_TABLE_64_shmat -TRACE_SYSCALL_TABLE(shmat, shmat, 196, 3) -#endif -#ifndef OVERRIDE_TABLE_64_shmdt -TRACE_SYSCALL_TABLE(shmdt, shmdt, 197, 1) -#endif -#ifndef OVERRIDE_TABLE_64_socketpair -TRACE_SYSCALL_TABLE(socketpair, socketpair, 199, 4) -#endif -#ifndef OVERRIDE_TABLE_64_bind -TRACE_SYSCALL_TABLE(bind, bind, 200, 3) -#endif -#ifndef OVERRIDE_TABLE_64_accept -TRACE_SYSCALL_TABLE(accept, accept, 202, 3) -#endif -#ifndef OVERRIDE_TABLE_64_connect -TRACE_SYSCALL_TABLE(connect, connect, 203, 3) -#endif -#ifndef OVERRIDE_TABLE_64_getsockname -TRACE_SYSCALL_TABLE(getsockname, getsockname, 204, 3) -#endif -#ifndef OVERRIDE_TABLE_64_getpeername -TRACE_SYSCALL_TABLE(getpeername, getpeername, 205, 3) -#endif -#ifndef OVERRIDE_TABLE_64_sendto -TRACE_SYSCALL_TABLE(sendto, sendto, 206, 6) -#endif -#ifndef OVERRIDE_TABLE_64_recvfrom -TRACE_SYSCALL_TABLE(recvfrom, recvfrom, 207, 6) -#endif -#ifndef OVERRIDE_TABLE_64_setsockopt -TRACE_SYSCALL_TABLE(setsockopt, setsockopt, 208, 5) -#endif -#ifndef OVERRIDE_TABLE_64_getsockopt -TRACE_SYSCALL_TABLE(getsockopt, getsockopt, 209, 5) -#endif -#ifndef OVERRIDE_TABLE_64_sendmsg -TRACE_SYSCALL_TABLE(sendmsg, sendmsg, 211, 3) -#endif -#ifndef OVERRIDE_TABLE_64_recvmsg -TRACE_SYSCALL_TABLE(recvmsg, recvmsg, 212, 3) -#endif -#ifndef OVERRIDE_TABLE_64_add_key -TRACE_SYSCALL_TABLE(add_key, add_key, 217, 5) -#endif -#ifndef OVERRIDE_TABLE_64_request_key -TRACE_SYSCALL_TABLE(request_key, request_key, 218, 4) -#endif -#ifndef OVERRIDE_TABLE_64_execve -TRACE_SYSCALL_TABLE(execve, execve, 221, 3) -#endif -#ifndef OVERRIDE_TABLE_64_swapon -TRACE_SYSCALL_TABLE(swapon, swapon, 224, 2) -#endif -#ifndef OVERRIDE_TABLE_64_swapoff -TRACE_SYSCALL_TABLE(swapoff, swapoff, 225, 1) -#endif -#ifndef OVERRIDE_TABLE_64_mincore -TRACE_SYSCALL_TABLE(mincore, mincore, 232, 3) -#endif -#ifndef OVERRIDE_TABLE_64_rt_tgsigqueueinfo -TRACE_SYSCALL_TABLE(rt_tgsigqueueinfo, rt_tgsigqueueinfo, 240, 4) -#endif -#ifndef OVERRIDE_TABLE_64_perf_event_open -TRACE_SYSCALL_TABLE(perf_event_open, perf_event_open, 241, 5) -#endif -#ifndef OVERRIDE_TABLE_64_accept4 -TRACE_SYSCALL_TABLE(accept4, accept4, 242, 4) -#endif -#ifndef OVERRIDE_TABLE_64_recvmmsg -TRACE_SYSCALL_TABLE(recvmmsg, recvmmsg, 243, 5) -#endif -#ifndef OVERRIDE_TABLE_64_wait4 -TRACE_SYSCALL_TABLE(wait4, wait4, 260, 4) -#endif -#ifndef OVERRIDE_TABLE_64_prlimit64 -TRACE_SYSCALL_TABLE(prlimit64, prlimit64, 261, 4) -#endif -#ifndef OVERRIDE_TABLE_64_fanotify_mark -TRACE_SYSCALL_TABLE(fanotify_mark, fanotify_mark, 263, 5) -#endif -#ifndef OVERRIDE_TABLE_64_name_to_handle_at -TRACE_SYSCALL_TABLE(name_to_handle_at, name_to_handle_at, 264, 5) -#endif -#ifndef OVERRIDE_TABLE_64_open_by_handle_at -TRACE_SYSCALL_TABLE(open_by_handle_at, open_by_handle_at, 265, 3) -#endif -#ifndef OVERRIDE_TABLE_64_clock_adjtime -TRACE_SYSCALL_TABLE(clock_adjtime, clock_adjtime, 266, 2) -#endif -#ifndef OVERRIDE_TABLE_64_sendmmsg -TRACE_SYSCALL_TABLE(sendmmsg, sendmmsg, 269, 4) -#endif -#ifndef OVERRIDE_TABLE_64_process_vm_readv -TRACE_SYSCALL_TABLE(process_vm_readv, process_vm_readv, 270, 6) -#endif -#ifndef OVERRIDE_TABLE_64_process_vm_writev -TRACE_SYSCALL_TABLE(process_vm_writev, process_vm_writev, 271, 6) -#endif -#ifndef OVERRIDE_TABLE_64_finit_module -TRACE_SYSCALL_TABLE(finit_module, finit_module, 273, 3) -#endif -#ifndef OVERRIDE_TABLE_64_sched_setattr -TRACE_SYSCALL_TABLE(sched_setattr, sched_setattr, 274, 3) -#endif -#ifndef OVERRIDE_TABLE_64_sched_getattr -TRACE_SYSCALL_TABLE(sched_getattr, sched_getattr, 275, 4) -#endif -#ifndef OVERRIDE_TABLE_64_renameat2 -TRACE_SYSCALL_TABLE(renameat2, renameat2, 276, 5) -#endif -#ifndef OVERRIDE_TABLE_64_seccomp -TRACE_SYSCALL_TABLE(seccomp, seccomp, 277, 3) -#endif -#ifndef OVERRIDE_TABLE_64_getrandom -TRACE_SYSCALL_TABLE(getrandom, getrandom, 278, 3) -#endif -#ifndef OVERRIDE_TABLE_64_memfd_create -TRACE_SYSCALL_TABLE(memfd_create, memfd_create, 279, 2) -#endif -#ifndef OVERRIDE_TABLE_64_execveat -TRACE_SYSCALL_TABLE(execveat, execveat, 281, 5) -#endif - -#endif /* CREATE_SYSCALL_TABLE */ diff --git a/instrumentation/syscalls/headers/arm-64-syscalls_pointers_override.h b/instrumentation/syscalls/headers/arm-64-syscalls_pointers_override.h deleted file mode 100644 index f35ce2f8..00000000 --- a/instrumentation/syscalls/headers/arm-64-syscalls_pointers_override.h +++ /dev/null @@ -1,11 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ - -/* - * this is a place-holder for arm64 integer syscall definition override. - */ -#ifndef CREATE_SYSCALL_TABLE - -#else -#define OVERRIDE_TABLE_64_clone -TRACE_SYSCALL_TABLE(clone, clone, 220, 5) -#endif diff --git a/instrumentation/syscalls/headers/compat_syscalls_integers.h b/instrumentation/syscalls/headers/compat_syscalls_integers.h deleted file mode 100644 index 080a36a8..00000000 --- a/instrumentation/syscalls/headers/compat_syscalls_integers.h +++ /dev/null @@ -1,13 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ - -#ifdef CONFIG_X86_64 -#include "x86-32-syscalls_integers.h" -#endif - -#ifdef CONFIG_ARM64 -#include "arm-32-syscalls_integers.h" -#endif - -#ifdef CONFIG_PPC64 -#include "powerpc-32-syscalls_integers.h" -#endif diff --git a/instrumentation/syscalls/headers/compat_syscalls_pointers.h b/instrumentation/syscalls/headers/compat_syscalls_pointers.h deleted file mode 100644 index 4d893862..00000000 --- a/instrumentation/syscalls/headers/compat_syscalls_pointers.h +++ /dev/null @@ -1,13 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ - -#ifdef CONFIG_X86_64 -#include "x86-32-syscalls_pointers.h" -#endif - -#ifdef CONFIG_ARM64 -#include "arm-32-syscalls_pointers.h" -#endif - -#ifdef CONFIG_PPC64 -#include "powerpc-32-syscalls_pointers.h" -#endif diff --git a/instrumentation/syscalls/headers/mips-32-syscalls_integers.h b/instrumentation/syscalls/headers/mips-32-syscalls_integers.h deleted file mode 100644 index 69338a12..00000000 --- a/instrumentation/syscalls/headers/mips-32-syscalls_integers.h +++ /dev/null @@ -1,1114 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ - -/* THIS FILE IS AUTO-GENERATED. DO NOT EDIT */ - -/* Generated from mips-32-syscalls 3.18.0 */ - -#ifndef CREATE_SYSCALL_TABLE - -#if !defined(_TRACE_SYSCALLS_INTEGERS_H) || defined(TRACE_HEADER_MULTI_READ) -#define _TRACE_SYSCALLS_INTEGERS_H - -#include -#include -#include "mips-32-syscalls_integers_override.h" -#include "syscalls_integers_override.h" - -#ifdef SC_ENTER -SC_LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(syscalls_noargs, - TP_FIELDS() -) -#ifndef OVERRIDE_32_getpid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getpid) -#endif -#ifndef OVERRIDE_32_getuid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getuid) -#endif -#ifndef OVERRIDE_32_pause -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, pause) -#endif -#ifndef OVERRIDE_32_sync -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, sync) -#endif -#ifndef OVERRIDE_32_getgid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getgid) -#endif -#ifndef OVERRIDE_32_geteuid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, geteuid) -#endif -#ifndef OVERRIDE_32_getegid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getegid) -#endif -#ifndef OVERRIDE_32_getppid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getppid) -#endif -#ifndef OVERRIDE_32_getpgrp -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getpgrp) -#endif -#ifndef OVERRIDE_32_setsid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, setsid) -#endif -#ifndef OVERRIDE_32_vhangup -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, vhangup) -#endif -#ifndef OVERRIDE_32_munlockall -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, munlockall) -#endif -#ifndef OVERRIDE_32_sched_yield -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, sched_yield) -#endif -#ifndef OVERRIDE_32_gettid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, gettid) -#endif -#ifndef OVERRIDE_32_restart_syscall -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, restart_syscall) -#endif -#ifndef OVERRIDE_32_inotify_init -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, inotify_init) -#endif -#else /* #ifdef SC_ENTER */ -#ifndef OVERRIDE_32_getpid -SC_LTTNG_TRACEPOINT_EVENT(getpid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_getuid -SC_LTTNG_TRACEPOINT_EVENT(getuid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_pause -SC_LTTNG_TRACEPOINT_EVENT(pause, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_sync -SC_LTTNG_TRACEPOINT_EVENT(sync, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_getgid -SC_LTTNG_TRACEPOINT_EVENT(getgid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_geteuid -SC_LTTNG_TRACEPOINT_EVENT(geteuid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_getegid -SC_LTTNG_TRACEPOINT_EVENT(getegid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_getppid -SC_LTTNG_TRACEPOINT_EVENT(getppid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_getpgrp -SC_LTTNG_TRACEPOINT_EVENT(getpgrp, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_setsid -SC_LTTNG_TRACEPOINT_EVENT(setsid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_vhangup -SC_LTTNG_TRACEPOINT_EVENT(vhangup, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_munlockall -SC_LTTNG_TRACEPOINT_EVENT(munlockall, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_sched_yield -SC_LTTNG_TRACEPOINT_EVENT(sched_yield, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_gettid -SC_LTTNG_TRACEPOINT_EVENT(gettid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_restart_syscall -SC_LTTNG_TRACEPOINT_EVENT(restart_syscall, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_inotify_init -SC_LTTNG_TRACEPOINT_EVENT(inotify_init, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#endif /* else #ifdef SC_ENTER */ -#ifndef OVERRIDE_32_exit -SC_LTTNG_TRACEPOINT_EVENT(exit, - TP_PROTO(sc_exit(long ret,) int error_code), - TP_ARGS(sc_exit(ret,) error_code), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, error_code, error_code))) -) -#endif -#ifndef OVERRIDE_32_close -SC_LTTNG_TRACEPOINT_EVENT(close, - TP_PROTO(sc_exit(long ret,) unsigned int fd), - TP_ARGS(sc_exit(ret,) fd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) -) -#endif -#ifndef OVERRIDE_32_setuid -SC_LTTNG_TRACEPOINT_EVENT(setuid, - TP_PROTO(sc_exit(long ret,) uid_t uid), - TP_ARGS(sc_exit(ret,) uid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, uid, uid))) -) -#endif -#ifndef OVERRIDE_32_alarm -SC_LTTNG_TRACEPOINT_EVENT(alarm, - TP_PROTO(sc_exit(long ret,) unsigned int seconds), - TP_ARGS(sc_exit(ret,) seconds), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, seconds, seconds))) -) -#endif -#ifndef OVERRIDE_32_nice -SC_LTTNG_TRACEPOINT_EVENT(nice, - TP_PROTO(sc_exit(long ret,) int increment), - TP_ARGS(sc_exit(ret,) increment), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, increment, increment))) -) -#endif -#ifndef OVERRIDE_32_dup -SC_LTTNG_TRACEPOINT_EVENT(dup, - TP_PROTO(sc_exit(long ret,) unsigned int fildes), - TP_ARGS(sc_exit(ret,) fildes), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fildes, fildes))) -) -#endif -#ifndef OVERRIDE_32_brk -SC_LTTNG_TRACEPOINT_EVENT(brk, - TP_PROTO(sc_exit(long ret,) unsigned long brk), - TP_ARGS(sc_exit(ret,) brk), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, brk, brk))) -) -#endif -#ifndef OVERRIDE_32_setgid -SC_LTTNG_TRACEPOINT_EVENT(setgid, - TP_PROTO(sc_exit(long ret,) gid_t gid), - TP_ARGS(sc_exit(ret,) gid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, gid, gid))) -) -#endif -#ifndef OVERRIDE_32_umask -SC_LTTNG_TRACEPOINT_EVENT(umask, - TP_PROTO(sc_exit(long ret,) int mask), - TP_ARGS(sc_exit(ret,) mask), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, mask, mask))) -) -#endif -#ifndef OVERRIDE_32_fsync -SC_LTTNG_TRACEPOINT_EVENT(fsync, - TP_PROTO(sc_exit(long ret,) unsigned int fd), - TP_ARGS(sc_exit(ret,) fd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) -) -#endif -#ifndef OVERRIDE_32_getpgid -SC_LTTNG_TRACEPOINT_EVENT(getpgid, - TP_PROTO(sc_exit(long ret,) pid_t pid), - TP_ARGS(sc_exit(ret,) pid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid))) -) -#endif -#ifndef OVERRIDE_32_fchdir -SC_LTTNG_TRACEPOINT_EVENT(fchdir, - TP_PROTO(sc_exit(long ret,) unsigned int fd), - TP_ARGS(sc_exit(ret,) fd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) -) -#endif -#ifndef OVERRIDE_32_personality -SC_LTTNG_TRACEPOINT_EVENT(personality, - TP_PROTO(sc_exit(long ret,) unsigned int personality), - TP_ARGS(sc_exit(ret,) personality), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, personality, personality))) -) -#endif -#ifndef OVERRIDE_32_setfsuid -SC_LTTNG_TRACEPOINT_EVENT(setfsuid, - TP_PROTO(sc_exit(long ret,) uid_t uid), - TP_ARGS(sc_exit(ret,) uid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, uid, uid))) -) -#endif -#ifndef OVERRIDE_32_setfsgid -SC_LTTNG_TRACEPOINT_EVENT(setfsgid, - TP_PROTO(sc_exit(long ret,) gid_t gid), - TP_ARGS(sc_exit(ret,) gid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, gid, gid))) -) -#endif -#ifndef OVERRIDE_32_getsid -SC_LTTNG_TRACEPOINT_EVENT(getsid, - TP_PROTO(sc_exit(long ret,) pid_t pid), - TP_ARGS(sc_exit(ret,) pid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid))) -) -#endif -#ifndef OVERRIDE_32_fdatasync -SC_LTTNG_TRACEPOINT_EVENT(fdatasync, - TP_PROTO(sc_exit(long ret,) unsigned int fd), - TP_ARGS(sc_exit(ret,) fd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) -) -#endif -#ifndef OVERRIDE_32_mlockall -SC_LTTNG_TRACEPOINT_EVENT(mlockall, - TP_PROTO(sc_exit(long ret,) int flags), - TP_ARGS(sc_exit(ret,) flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_sched_getscheduler -SC_LTTNG_TRACEPOINT_EVENT(sched_getscheduler, - TP_PROTO(sc_exit(long ret,) pid_t pid), - TP_ARGS(sc_exit(ret,) pid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid))) -) -#endif -#ifndef OVERRIDE_32_sched_get_priority_max -SC_LTTNG_TRACEPOINT_EVENT(sched_get_priority_max, - TP_PROTO(sc_exit(long ret,) int policy), - TP_ARGS(sc_exit(ret,) policy), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, policy, policy))) -) -#endif -#ifndef OVERRIDE_32_sched_get_priority_min -SC_LTTNG_TRACEPOINT_EVENT(sched_get_priority_min, - TP_PROTO(sc_exit(long ret,) int policy), - TP_ARGS(sc_exit(ret,) policy), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, policy, policy))) -) -#endif -#ifndef OVERRIDE_32_io_destroy -SC_LTTNG_TRACEPOINT_EVENT(io_destroy, - TP_PROTO(sc_exit(long ret,) aio_context_t ctx), - TP_ARGS(sc_exit(ret,) ctx), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx, ctx))) -) -#endif -#ifndef OVERRIDE_32_exit_group -SC_LTTNG_TRACEPOINT_EVENT(exit_group, - TP_PROTO(sc_exit(long ret,) int error_code), - TP_ARGS(sc_exit(ret,) error_code), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, error_code, error_code))) -) -#endif -#ifndef OVERRIDE_32_epoll_create -SC_LTTNG_TRACEPOINT_EVENT(epoll_create, - TP_PROTO(sc_exit(long ret,) int size), - TP_ARGS(sc_exit(ret,) size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, size, size))) -) -#endif -#ifndef OVERRIDE_32_timer_getoverrun -SC_LTTNG_TRACEPOINT_EVENT(timer_getoverrun, - TP_PROTO(sc_exit(long ret,) timer_t timer_id), - TP_ARGS(sc_exit(ret,) timer_id), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id))) -) -#endif -#ifndef OVERRIDE_32_timer_delete -SC_LTTNG_TRACEPOINT_EVENT(timer_delete, - TP_PROTO(sc_exit(long ret,) timer_t timer_id), - TP_ARGS(sc_exit(ret,) timer_id), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id))) -) -#endif -#ifndef OVERRIDE_32_set_thread_area -SC_LTTNG_TRACEPOINT_EVENT(set_thread_area, - TP_PROTO(sc_exit(long ret,) unsigned long addr), - TP_ARGS(sc_exit(ret,) addr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned long, addr, addr))) -) -#endif -#ifndef OVERRIDE_32_unshare -SC_LTTNG_TRACEPOINT_EVENT(unshare, - TP_PROTO(sc_exit(long ret,) unsigned long unshare_flags), - TP_ARGS(sc_exit(ret,) unshare_flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, unshare_flags, unshare_flags))) -) -#endif -#ifndef OVERRIDE_32_eventfd -SC_LTTNG_TRACEPOINT_EVENT(eventfd, - TP_PROTO(sc_exit(long ret,) unsigned int count), - TP_ARGS(sc_exit(ret,) count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, count, count))) -) -#endif -#ifndef OVERRIDE_32_epoll_create1 -SC_LTTNG_TRACEPOINT_EVENT(epoll_create1, - TP_PROTO(sc_exit(long ret,) int flags), - TP_ARGS(sc_exit(ret,) flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_inotify_init1 -SC_LTTNG_TRACEPOINT_EVENT(inotify_init1, - TP_PROTO(sc_exit(long ret,) int flags), - TP_ARGS(sc_exit(ret,) flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_syncfs -SC_LTTNG_TRACEPOINT_EVENT(syncfs, - TP_PROTO(sc_exit(long ret,) int fd), - TP_ARGS(sc_exit(ret,) fd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd))) -) -#endif -#ifndef OVERRIDE_32_kill -SC_LTTNG_TRACEPOINT_EVENT(kill, - TP_PROTO(sc_exit(long ret,) pid_t pid, int sig), - TP_ARGS(sc_exit(ret,) pid, sig), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig))) -) -#endif -#ifndef OVERRIDE_32_setpgid -SC_LTTNG_TRACEPOINT_EVENT(setpgid, - TP_PROTO(sc_exit(long ret,) pid_t pid, pid_t pgid), - TP_ARGS(sc_exit(ret,) pid, pgid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(pid_t, pgid, pgid))) -) -#endif -#ifndef OVERRIDE_32_dup2 -SC_LTTNG_TRACEPOINT_EVENT(dup2, - TP_PROTO(sc_exit(long ret,) unsigned int oldfd, unsigned int newfd), - TP_ARGS(sc_exit(ret,) oldfd, newfd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, oldfd, oldfd)) sc_in(ctf_integer(unsigned int, newfd, newfd))) -) -#endif -#ifndef OVERRIDE_32_setreuid -SC_LTTNG_TRACEPOINT_EVENT(setreuid, - TP_PROTO(sc_exit(long ret,) uid_t ruid, uid_t euid), - TP_ARGS(sc_exit(ret,) ruid, euid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, ruid, ruid)) sc_in(ctf_integer(uid_t, euid, euid))) -) -#endif -#ifndef OVERRIDE_32_setregid -SC_LTTNG_TRACEPOINT_EVENT(setregid, - TP_PROTO(sc_exit(long ret,) gid_t rgid, gid_t egid), - TP_ARGS(sc_exit(ret,) rgid, egid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, rgid, rgid)) sc_in(ctf_integer(gid_t, egid, egid))) -) -#endif -#ifndef OVERRIDE_32_munmap -SC_LTTNG_TRACEPOINT_EVENT(munmap, - TP_PROTO(sc_exit(long ret,) unsigned long addr, size_t len), - TP_ARGS(sc_exit(ret,) addr, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, addr, addr)) sc_in(ctf_integer(size_t, len, len))) -) -#endif -#ifndef OVERRIDE_32_ftruncate -SC_LTTNG_TRACEPOINT_EVENT(ftruncate, - TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned long length), - TP_ARGS(sc_exit(ret,) fd, length), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned long, length, length))) -) -#endif -#ifndef OVERRIDE_32_fchmod -SC_LTTNG_TRACEPOINT_EVENT(fchmod, - TP_PROTO(sc_exit(long ret,) unsigned int fd, umode_t mode), - TP_ARGS(sc_exit(ret,) fd, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(umode_t, mode, mode))) -) -#endif -#ifndef OVERRIDE_32_getpriority -SC_LTTNG_TRACEPOINT_EVENT(getpriority, - TP_PROTO(sc_exit(long ret,) int which, int who), - TP_ARGS(sc_exit(ret,) which, who), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who))) -) -#endif -#ifndef OVERRIDE_32_bdflush -SC_LTTNG_TRACEPOINT_EVENT(bdflush, - TP_PROTO(sc_exit(long ret,) int func, long data), - TP_ARGS(sc_exit(ret,) func, data), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, func, func)) sc_inout(ctf_integer(long, data, data))) -) -#endif -#ifndef OVERRIDE_32_flock -SC_LTTNG_TRACEPOINT_EVENT(flock, - TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd), - TP_ARGS(sc_exit(ret,) fd, cmd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned int, cmd, cmd))) -) -#endif -#ifndef OVERRIDE_32_mlock -SC_LTTNG_TRACEPOINT_EVENT(mlock, - TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len), - TP_ARGS(sc_exit(ret,) start, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len))) -) -#endif -#ifndef OVERRIDE_32_munlock -SC_LTTNG_TRACEPOINT_EVENT(munlock, - TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len), - TP_ARGS(sc_exit(ret,) start, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len))) -) -#endif -#ifndef OVERRIDE_32_listen -SC_LTTNG_TRACEPOINT_EVENT(listen, - TP_PROTO(sc_exit(long ret,) int fd, int backlog), - TP_ARGS(sc_exit(ret,) fd, backlog), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, backlog, backlog))) -) -#endif -#ifndef OVERRIDE_32_shutdown -SC_LTTNG_TRACEPOINT_EVENT(shutdown, - TP_PROTO(sc_exit(long ret,) int fd, int how), - TP_ARGS(sc_exit(ret,) fd, how), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, how, how))) -) -#endif -#ifndef OVERRIDE_32_ftruncate64 -SC_LTTNG_TRACEPOINT_EVENT(ftruncate64, - TP_PROTO(sc_exit(long ret,) unsigned int fd, loff_t length), - TP_ARGS(sc_exit(ret,) fd, length), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, fd, fd)) sc_inout(ctf_integer(loff_t, length, length))) -) -#endif -#ifndef OVERRIDE_32_tkill -SC_LTTNG_TRACEPOINT_EVENT(tkill, - TP_PROTO(sc_exit(long ret,) pid_t pid, int sig), - TP_ARGS(sc_exit(ret,) pid, sig), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig))) -) -#endif -#ifndef OVERRIDE_32_inotify_rm_watch -SC_LTTNG_TRACEPOINT_EVENT(inotify_rm_watch, - TP_PROTO(sc_exit(long ret,) int fd, __s32 wd), - TP_ARGS(sc_exit(ret,) fd, wd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(__s32, wd, wd))) -) -#endif -#ifndef OVERRIDE_32_ioprio_get -SC_LTTNG_TRACEPOINT_EVENT(ioprio_get, - TP_PROTO(sc_exit(long ret,) int which, int who), - TP_ARGS(sc_exit(ret,) which, who), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who))) -) -#endif -#ifndef OVERRIDE_32_timerfd_create -SC_LTTNG_TRACEPOINT_EVENT(timerfd_create, - TP_PROTO(sc_exit(long ret,) int clockid, int flags), - TP_ARGS(sc_exit(ret,) clockid, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, clockid, clockid)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_eventfd2 -SC_LTTNG_TRACEPOINT_EVENT(eventfd2, - TP_PROTO(sc_exit(long ret,) unsigned int count, int flags), - TP_ARGS(sc_exit(ret,) count, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, count, count)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_setns -SC_LTTNG_TRACEPOINT_EVENT(setns, - TP_PROTO(sc_exit(long ret,) int fd, int nstype), - TP_ARGS(sc_exit(ret,) fd, nstype), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, nstype, nstype))) -) -#endif -#ifndef OVERRIDE_32_lseek -SC_LTTNG_TRACEPOINT_EVENT(lseek, - TP_PROTO(sc_exit(long ret,) unsigned int fd, off_t offset, unsigned int whence), - TP_ARGS(sc_exit(ret,) fd, offset, whence), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(off_t, offset, offset)) sc_in(ctf_integer(unsigned int, whence, whence))) -) -#endif -#ifndef OVERRIDE_32_ioctl -SC_LTTNG_TRACEPOINT_EVENT(ioctl, - TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd, unsigned long arg), - TP_ARGS(sc_exit(ret,) fd, cmd, arg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_inout(ctf_integer(unsigned long, arg, arg))) -) -#endif -#ifndef OVERRIDE_32_fcntl -SC_LTTNG_TRACEPOINT_EVENT(fcntl, - TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd, unsigned long arg), - TP_ARGS(sc_exit(ret,) fd, cmd, arg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_inout(ctf_integer(unsigned long, arg, arg))) -) -#endif -#ifndef OVERRIDE_32_fchown -SC_LTTNG_TRACEPOINT_EVENT(fchown, - TP_PROTO(sc_exit(long ret,) unsigned int fd, uid_t user, gid_t group), - TP_ARGS(sc_exit(ret,) fd, user, group), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group))) -) -#endif -#ifndef OVERRIDE_32_setpriority -SC_LTTNG_TRACEPOINT_EVENT(setpriority, - TP_PROTO(sc_exit(long ret,) int which, int who, int niceval), - TP_ARGS(sc_exit(ret,) which, who, niceval), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who)) sc_in(ctf_integer(int, niceval, niceval))) -) -#endif -#ifndef OVERRIDE_32_mprotect -SC_LTTNG_TRACEPOINT_EVENT(mprotect, - TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len, unsigned long prot), - TP_ARGS(sc_exit(ret,) start, len, prot), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned long, prot, prot))) -) -#endif -#ifndef OVERRIDE_32_msync -SC_LTTNG_TRACEPOINT_EVENT(msync, - TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len, int flags), - TP_ARGS(sc_exit(ret,) start, len, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_cacheflush -SC_LTTNG_TRACEPOINT_EVENT(cacheflush, - TP_PROTO(sc_exit(long ret,) unsigned long addr, unsigned long bytes, unsigned int cache), - TP_ARGS(sc_exit(ret,) addr, bytes, cache), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned long, addr, addr)) sc_inout(ctf_integer(unsigned long, bytes, bytes)) sc_inout(ctf_integer(unsigned int, cache, cache))) -) -#endif -#ifndef OVERRIDE_32_sysmips -SC_LTTNG_TRACEPOINT_EVENT(sysmips, - TP_PROTO(sc_exit(long ret,) long cmd, long arg1, long arg2), - TP_ARGS(sc_exit(ret,) cmd, arg1, arg2), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(long, cmd, cmd)) sc_inout(ctf_integer(long, arg1, arg1)) sc_inout(ctf_integer(long, arg2, arg2))) -) -#endif -#ifndef OVERRIDE_32_socket -SC_LTTNG_TRACEPOINT_EVENT(socket, - TP_PROTO(sc_exit(long ret,) int family, int type, int protocol), - TP_ARGS(sc_exit(ret,) family, type, protocol), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, family, family)) sc_in(ctf_integer(int, type, type)) sc_in(ctf_integer(int, protocol, protocol))) -) -#endif -#ifndef OVERRIDE_32_setresuid -SC_LTTNG_TRACEPOINT_EVENT(setresuid, - TP_PROTO(sc_exit(long ret,) uid_t ruid, uid_t euid, uid_t suid), - TP_ARGS(sc_exit(ret,) ruid, euid, suid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, ruid, ruid)) sc_in(ctf_integer(uid_t, euid, euid)) sc_in(ctf_integer(uid_t, suid, suid))) -) -#endif -#ifndef OVERRIDE_32_setresgid -SC_LTTNG_TRACEPOINT_EVENT(setresgid, - TP_PROTO(sc_exit(long ret,) gid_t rgid, gid_t egid, gid_t sgid), - TP_ARGS(sc_exit(ret,) rgid, egid, sgid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, rgid, rgid)) sc_in(ctf_integer(gid_t, egid, egid)) sc_in(ctf_integer(gid_t, sgid, sgid))) -) -#endif -#ifndef OVERRIDE_32_madvise -SC_LTTNG_TRACEPOINT_EVENT(madvise, - TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len_in, int behavior), - TP_ARGS(sc_exit(ret,) start, len_in, behavior), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len_in, len_in)) sc_in(ctf_integer(int, behavior, behavior))) -) -#endif -#ifndef OVERRIDE_32_fcntl64 -SC_LTTNG_TRACEPOINT_EVENT(fcntl64, - TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd, unsigned long arg), - TP_ARGS(sc_exit(ret,) fd, cmd, arg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, fd, fd)) sc_inout(ctf_integer(unsigned int, cmd, cmd)) sc_inout(ctf_integer(unsigned long, arg, arg))) -) -#endif -#ifndef OVERRIDE_32_readahead -SC_LTTNG_TRACEPOINT_EVENT(readahead, - TP_PROTO(sc_exit(long ret,) int fd, loff_t offset, size_t count), - TP_ARGS(sc_exit(ret,) fd, offset, count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(loff_t, offset, offset)) sc_in(ctf_integer(size_t, count, count))) -) -#endif -#ifndef OVERRIDE_32_tgkill -SC_LTTNG_TRACEPOINT_EVENT(tgkill, - TP_PROTO(sc_exit(long ret,) pid_t tgid, pid_t pid, int sig), - TP_ARGS(sc_exit(ret,) tgid, pid, sig), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, tgid, tgid)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig))) -) -#endif -#ifndef OVERRIDE_32_ioprio_set -SC_LTTNG_TRACEPOINT_EVENT(ioprio_set, - TP_PROTO(sc_exit(long ret,) int which, int who, int ioprio), - TP_ARGS(sc_exit(ret,) which, who, ioprio), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who)) sc_in(ctf_integer(int, ioprio, ioprio))) -) -#endif -#ifndef OVERRIDE_32_dup3 -SC_LTTNG_TRACEPOINT_EVENT(dup3, - TP_PROTO(sc_exit(long ret,) unsigned int oldfd, unsigned int newfd, int flags), - TP_ARGS(sc_exit(ret,) oldfd, newfd, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, oldfd, oldfd)) sc_in(ctf_integer(unsigned int, newfd, newfd)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_ptrace -SC_LTTNG_TRACEPOINT_EVENT(ptrace, - TP_PROTO(sc_exit(long ret,) long request, long pid, unsigned long addr, unsigned long data), - TP_ARGS(sc_exit(ret,) request, pid, addr, data), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(long, request, request)) sc_in(ctf_integer(long, pid, pid)) sc_inout(ctf_integer(unsigned long, addr, addr)) sc_inout(ctf_integer(unsigned long, data, data))) -) -#endif -#ifndef OVERRIDE_32_fadvise64_64 -SC_LTTNG_TRACEPOINT_EVENT(fadvise64_64, - TP_PROTO(sc_exit(long ret,) int fd, loff_t offset, loff_t len, int advice), - TP_ARGS(sc_exit(ret,) fd, offset, len, advice), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, fd, fd)) sc_inout(ctf_integer(loff_t, offset, offset)) sc_inout(ctf_integer(loff_t, len, len)) sc_inout(ctf_integer(int, advice, advice))) -) -#endif -#ifndef OVERRIDE_32_sync_file_range -SC_LTTNG_TRACEPOINT_EVENT(sync_file_range, - TP_PROTO(sc_exit(long ret,) int fd, loff_t offset, loff_t nbytes, unsigned int flags), - TP_ARGS(sc_exit(ret,) fd, offset, nbytes, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(loff_t, offset, offset)) sc_in(ctf_integer(loff_t, nbytes, nbytes)) sc_in(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_tee -SC_LTTNG_TRACEPOINT_EVENT(tee, - TP_PROTO(sc_exit(long ret,) int fdin, int fdout, size_t len, unsigned int flags), - TP_ARGS(sc_exit(ret,) fdin, fdout, len, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fdin, fdin)) sc_in(ctf_integer(int, fdout, fdout)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_fallocate -SC_LTTNG_TRACEPOINT_EVENT(fallocate, - TP_PROTO(sc_exit(long ret,) int fd, int mode, loff_t offset, loff_t len), - TP_ARGS(sc_exit(ret,) fd, mode, offset, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, mode, mode)) sc_in(ctf_integer(loff_t, offset, offset)) sc_in(ctf_integer(loff_t, len, len))) -) -#endif -#ifndef OVERRIDE_32_mremap -SC_LTTNG_TRACEPOINT_EVENT(mremap, - TP_PROTO(sc_exit(long ret,) unsigned long addr, unsigned long old_len, unsigned long new_len, unsigned long flags, unsigned long new_addr), - TP_ARGS(sc_exit(ret,) addr, old_len, new_len, flags, new_addr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, addr, addr)) sc_in(ctf_integer(unsigned long, old_len, old_len)) sc_in(ctf_integer(unsigned long, new_len, new_len)) sc_in(ctf_integer(unsigned long, flags, flags)) sc_in(ctf_integer(unsigned long, new_addr, new_addr))) -) -#endif -#ifndef OVERRIDE_32_prctl -SC_LTTNG_TRACEPOINT_EVENT(prctl, - TP_PROTO(sc_exit(long ret,) int option, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5), - TP_ARGS(sc_exit(ret,) option, arg2, arg3, arg4, arg5), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, option, option)) sc_inout(ctf_integer(unsigned long, arg2, arg2)) sc_in(ctf_integer(unsigned long, arg3, arg3)) sc_in(ctf_integer(unsigned long, arg4, arg4)) sc_in(ctf_integer(unsigned long, arg5, arg5))) -) -#endif -#ifndef OVERRIDE_32_remap_file_pages -SC_LTTNG_TRACEPOINT_EVENT(remap_file_pages, - TP_PROTO(sc_exit(long ret,) unsigned long start, unsigned long size, unsigned long prot, unsigned long pgoff, unsigned long flags), - TP_ARGS(sc_exit(ret,) start, size, prot, pgoff, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(unsigned long, size, size)) sc_in(ctf_integer(unsigned long, prot, prot)) sc_in(ctf_integer(unsigned long, pgoff, pgoff)) sc_in(ctf_integer(unsigned long, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_mmap -SC_LTTNG_TRACEPOINT_EVENT(mmap, - TP_PROTO(sc_exit(long ret,) unsigned long addr, unsigned long len, unsigned long prot, unsigned long flags, unsigned long fd, off_t offset), - TP_ARGS(sc_exit(ret,) addr, len, prot, flags, fd, offset), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, addr, addr)) sc_in(ctf_integer(unsigned long, len, len)) sc_in(ctf_integer(unsigned long, prot, prot)) sc_in(ctf_integer(unsigned long, flags, flags)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_in(ctf_integer(off_t, offset, offset))) -) -#endif -#ifndef OVERRIDE_32_mips_mmap2 -SC_LTTNG_TRACEPOINT_EVENT(mips_mmap2, - TP_PROTO(sc_exit(long ret,) unsigned long addr, unsigned long len, unsigned long prot, unsigned long flags, unsigned long fd, unsigned long pgoff), - TP_ARGS(sc_exit(ret,) addr, len, prot, flags, fd, pgoff), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned long, addr, addr)) sc_inout(ctf_integer(unsigned long, len, len)) sc_inout(ctf_integer(unsigned long, prot, prot)) sc_inout(ctf_integer(unsigned long, flags, flags)) sc_inout(ctf_integer(unsigned long, fd, fd)) sc_inout(ctf_integer(unsigned long, pgoff, pgoff))) -) -#endif - -#endif /* _TRACE_SYSCALLS_INTEGERS_H */ - -/* This part must be outside protection */ -#include - -#else /* CREATE_SYSCALL_TABLE */ - -#include "mips-32-syscalls_integers_override.h" -#include "syscalls_integers_override.h" - -#ifdef SC_ENTER -#ifndef OVERRIDE_TABLE_32_getpid -TRACE_SYSCALL_TABLE(syscalls_noargs, getpid, 4020, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getuid -TRACE_SYSCALL_TABLE(syscalls_noargs, getuid, 4024, 0) -#endif -#ifndef OVERRIDE_TABLE_32_pause -TRACE_SYSCALL_TABLE(syscalls_noargs, pause, 4029, 0) -#endif -#ifndef OVERRIDE_TABLE_32_sync -TRACE_SYSCALL_TABLE(syscalls_noargs, sync, 4036, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getgid -TRACE_SYSCALL_TABLE(syscalls_noargs, getgid, 4047, 0) -#endif -#ifndef OVERRIDE_TABLE_32_geteuid -TRACE_SYSCALL_TABLE(syscalls_noargs, geteuid, 4049, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getegid -TRACE_SYSCALL_TABLE(syscalls_noargs, getegid, 4050, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getppid -TRACE_SYSCALL_TABLE(syscalls_noargs, getppid, 4064, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getpgrp -TRACE_SYSCALL_TABLE(syscalls_noargs, getpgrp, 4065, 0) -#endif -#ifndef OVERRIDE_TABLE_32_setsid -TRACE_SYSCALL_TABLE(syscalls_noargs, setsid, 4066, 0) -#endif -#ifndef OVERRIDE_TABLE_32_vhangup -TRACE_SYSCALL_TABLE(syscalls_noargs, vhangup, 4111, 0) -#endif -#ifndef OVERRIDE_TABLE_32_munlockall -TRACE_SYSCALL_TABLE(syscalls_noargs, munlockall, 4157, 0) -#endif -#ifndef OVERRIDE_TABLE_32_sched_yield -TRACE_SYSCALL_TABLE(syscalls_noargs, sched_yield, 4162, 0) -#endif -#ifndef OVERRIDE_TABLE_32_gettid -TRACE_SYSCALL_TABLE(syscalls_noargs, gettid, 4222, 0) -#endif -#ifndef OVERRIDE_TABLE_32_restart_syscall -TRACE_SYSCALL_TABLE(syscalls_noargs, restart_syscall, 4253, 0) -#endif -#ifndef OVERRIDE_TABLE_32_inotify_init -TRACE_SYSCALL_TABLE(syscalls_noargs, inotify_init, 4284, 0) -#endif -#else /* #ifdef SC_ENTER */ -#ifndef OVERRIDE_TABLE_32_getpid -TRACE_SYSCALL_TABLE(getpid, getpid, 4020, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getuid -TRACE_SYSCALL_TABLE(getuid, getuid, 4024, 0) -#endif -#ifndef OVERRIDE_TABLE_32_pause -TRACE_SYSCALL_TABLE(pause, pause, 4029, 0) -#endif -#ifndef OVERRIDE_TABLE_32_sync -TRACE_SYSCALL_TABLE(sync, sync, 4036, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getgid -TRACE_SYSCALL_TABLE(getgid, getgid, 4047, 0) -#endif -#ifndef OVERRIDE_TABLE_32_geteuid -TRACE_SYSCALL_TABLE(geteuid, geteuid, 4049, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getegid -TRACE_SYSCALL_TABLE(getegid, getegid, 4050, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getppid -TRACE_SYSCALL_TABLE(getppid, getppid, 4064, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getpgrp -TRACE_SYSCALL_TABLE(getpgrp, getpgrp, 4065, 0) -#endif -#ifndef OVERRIDE_TABLE_32_setsid -TRACE_SYSCALL_TABLE(setsid, setsid, 4066, 0) -#endif -#ifndef OVERRIDE_TABLE_32_vhangup -TRACE_SYSCALL_TABLE(vhangup, vhangup, 4111, 0) -#endif -#ifndef OVERRIDE_TABLE_32_munlockall -TRACE_SYSCALL_TABLE(munlockall, munlockall, 4157, 0) -#endif -#ifndef OVERRIDE_TABLE_32_sched_yield -TRACE_SYSCALL_TABLE(sched_yield, sched_yield, 4162, 0) -#endif -#ifndef OVERRIDE_TABLE_32_gettid -TRACE_SYSCALL_TABLE(gettid, gettid, 4222, 0) -#endif -#ifndef OVERRIDE_TABLE_32_restart_syscall -TRACE_SYSCALL_TABLE(restart_syscall, restart_syscall, 4253, 0) -#endif -#ifndef OVERRIDE_TABLE_32_inotify_init -TRACE_SYSCALL_TABLE(inotify_init, inotify_init, 4284, 0) -#endif -#endif /* else #ifdef SC_ENTER */ -#ifndef OVERRIDE_TABLE_32_exit -TRACE_SYSCALL_TABLE(exit, exit, 4001, 1) -#endif -#ifndef OVERRIDE_TABLE_32_close -TRACE_SYSCALL_TABLE(close, close, 4006, 1) -#endif -#ifndef OVERRIDE_TABLE_32_lseek -TRACE_SYSCALL_TABLE(lseek, lseek, 4019, 3) -#endif -#ifndef OVERRIDE_TABLE_32_setuid -TRACE_SYSCALL_TABLE(setuid, setuid, 4023, 1) -#endif -#ifndef OVERRIDE_TABLE_32_ptrace -TRACE_SYSCALL_TABLE(ptrace, ptrace, 4026, 4) -#endif -#ifndef OVERRIDE_TABLE_32_alarm -TRACE_SYSCALL_TABLE(alarm, alarm, 4027, 1) -#endif -#ifndef OVERRIDE_TABLE_32_nice -TRACE_SYSCALL_TABLE(nice, nice, 4034, 1) -#endif -#ifndef OVERRIDE_TABLE_32_kill -TRACE_SYSCALL_TABLE(kill, kill, 4037, 2) -#endif -#ifndef OVERRIDE_TABLE_32_dup -TRACE_SYSCALL_TABLE(dup, dup, 4041, 1) -#endif -#ifndef OVERRIDE_TABLE_32_brk -TRACE_SYSCALL_TABLE(brk, brk, 4045, 1) -#endif -#ifndef OVERRIDE_TABLE_32_setgid -TRACE_SYSCALL_TABLE(setgid, setgid, 4046, 1) -#endif -#ifndef OVERRIDE_TABLE_32_ioctl -TRACE_SYSCALL_TABLE(ioctl, ioctl, 4054, 3) -#endif -#ifndef OVERRIDE_TABLE_32_fcntl -TRACE_SYSCALL_TABLE(fcntl, fcntl, 4055, 3) -#endif -#ifndef OVERRIDE_TABLE_32_setpgid -TRACE_SYSCALL_TABLE(setpgid, setpgid, 4057, 2) -#endif -#ifndef OVERRIDE_TABLE_32_umask -TRACE_SYSCALL_TABLE(umask, umask, 4060, 1) -#endif -#ifndef OVERRIDE_TABLE_32_dup2 -TRACE_SYSCALL_TABLE(dup2, dup2, 4063, 2) -#endif -#ifndef OVERRIDE_TABLE_32_setreuid -TRACE_SYSCALL_TABLE(setreuid, setreuid, 4070, 2) -#endif -#ifndef OVERRIDE_TABLE_32_setregid -TRACE_SYSCALL_TABLE(setregid, setregid, 4071, 2) -#endif -#ifndef OVERRIDE_TABLE_32_mmap -TRACE_SYSCALL_TABLE(mmap, mmap, 4090, 6) -#endif -#ifndef OVERRIDE_TABLE_32_munmap -TRACE_SYSCALL_TABLE(munmap, munmap, 4091, 2) -#endif -#ifndef OVERRIDE_TABLE_32_ftruncate -TRACE_SYSCALL_TABLE(ftruncate, ftruncate, 4093, 2) -#endif -#ifndef OVERRIDE_TABLE_32_fchmod -TRACE_SYSCALL_TABLE(fchmod, fchmod, 4094, 2) -#endif -#ifndef OVERRIDE_TABLE_32_fchown -TRACE_SYSCALL_TABLE(fchown, fchown, 4095, 3) -#endif -#ifndef OVERRIDE_TABLE_32_getpriority -TRACE_SYSCALL_TABLE(getpriority, getpriority, 4096, 2) -#endif -#ifndef OVERRIDE_TABLE_32_setpriority -TRACE_SYSCALL_TABLE(setpriority, setpriority, 4097, 3) -#endif -#ifndef OVERRIDE_TABLE_32_fsync -TRACE_SYSCALL_TABLE(fsync, fsync, 4118, 1) -#endif -#ifndef OVERRIDE_TABLE_32_mprotect -TRACE_SYSCALL_TABLE(mprotect, mprotect, 4125, 3) -#endif -#ifndef OVERRIDE_TABLE_32_getpgid -TRACE_SYSCALL_TABLE(getpgid, getpgid, 4132, 1) -#endif -#ifndef OVERRIDE_TABLE_32_fchdir -TRACE_SYSCALL_TABLE(fchdir, fchdir, 4133, 1) -#endif -#ifndef OVERRIDE_TABLE_32_bdflush -TRACE_SYSCALL_TABLE(bdflush, bdflush, 4134, 2) -#endif -#ifndef OVERRIDE_TABLE_32_personality -TRACE_SYSCALL_TABLE(personality, personality, 4136, 1) -#endif -#ifndef OVERRIDE_TABLE_32_setfsuid -TRACE_SYSCALL_TABLE(setfsuid, setfsuid, 4138, 1) -#endif -#ifndef OVERRIDE_TABLE_32_setfsgid -TRACE_SYSCALL_TABLE(setfsgid, setfsgid, 4139, 1) -#endif -#ifndef OVERRIDE_TABLE_32_flock -TRACE_SYSCALL_TABLE(flock, flock, 4143, 2) -#endif -#ifndef OVERRIDE_TABLE_32_msync -TRACE_SYSCALL_TABLE(msync, msync, 4144, 3) -#endif -#ifndef OVERRIDE_TABLE_32_cacheflush -TRACE_SYSCALL_TABLE(cacheflush, cacheflush, 4147, 3) -#endif -#ifndef OVERRIDE_TABLE_32_sysmips -TRACE_SYSCALL_TABLE(sysmips, sysmips, 4149, 3) -#endif -#ifndef OVERRIDE_TABLE_32_getsid -TRACE_SYSCALL_TABLE(getsid, getsid, 4151, 1) -#endif -#ifndef OVERRIDE_TABLE_32_fdatasync -TRACE_SYSCALL_TABLE(fdatasync, fdatasync, 4152, 1) -#endif -#ifndef OVERRIDE_TABLE_32_mlock -TRACE_SYSCALL_TABLE(mlock, mlock, 4154, 2) -#endif -#ifndef OVERRIDE_TABLE_32_munlock -TRACE_SYSCALL_TABLE(munlock, munlock, 4155, 2) -#endif -#ifndef OVERRIDE_TABLE_32_mlockall -TRACE_SYSCALL_TABLE(mlockall, mlockall, 4156, 1) -#endif -#ifndef OVERRIDE_TABLE_32_sched_getscheduler -TRACE_SYSCALL_TABLE(sched_getscheduler, sched_getscheduler, 4161, 1) -#endif -#ifndef OVERRIDE_TABLE_32_sched_get_priority_max -TRACE_SYSCALL_TABLE(sched_get_priority_max, sched_get_priority_max, 4163, 1) -#endif -#ifndef OVERRIDE_TABLE_32_sched_get_priority_min -TRACE_SYSCALL_TABLE(sched_get_priority_min, sched_get_priority_min, 4164, 1) -#endif -#ifndef OVERRIDE_TABLE_32_mremap -TRACE_SYSCALL_TABLE(mremap, mremap, 4167, 5) -#endif -#ifndef OVERRIDE_TABLE_32_listen -TRACE_SYSCALL_TABLE(listen, listen, 4174, 2) -#endif -#ifndef OVERRIDE_TABLE_32_shutdown -TRACE_SYSCALL_TABLE(shutdown, shutdown, 4182, 2) -#endif -#ifndef OVERRIDE_TABLE_32_socket -TRACE_SYSCALL_TABLE(socket, socket, 4183, 3) -#endif -#ifndef OVERRIDE_TABLE_32_setresuid -TRACE_SYSCALL_TABLE(setresuid, setresuid, 4185, 3) -#endif -#ifndef OVERRIDE_TABLE_32_setresgid -TRACE_SYSCALL_TABLE(setresgid, setresgid, 4190, 3) -#endif -#ifndef OVERRIDE_TABLE_32_prctl -TRACE_SYSCALL_TABLE(prctl, prctl, 4192, 5) -#endif -#ifndef OVERRIDE_TABLE_32_mips_mmap2 -TRACE_SYSCALL_TABLE(mips_mmap2, mips_mmap2, 4210, 6) -#endif -#ifndef OVERRIDE_TABLE_32_ftruncate64 -TRACE_SYSCALL_TABLE(ftruncate64, ftruncate64, 4212, 2) -#endif -#ifndef OVERRIDE_TABLE_32_madvise -TRACE_SYSCALL_TABLE(madvise, madvise, 4218, 3) -#endif -#ifndef OVERRIDE_TABLE_32_fcntl64 -TRACE_SYSCALL_TABLE(fcntl64, fcntl64, 4220, 3) -#endif -#ifndef OVERRIDE_TABLE_32_readahead -TRACE_SYSCALL_TABLE(readahead, readahead, 4223, 3) -#endif -#ifndef OVERRIDE_TABLE_32_tkill -TRACE_SYSCALL_TABLE(tkill, tkill, 4236, 2) -#endif -#ifndef OVERRIDE_TABLE_32_io_destroy -TRACE_SYSCALL_TABLE(io_destroy, io_destroy, 4242, 1) -#endif -#ifndef OVERRIDE_TABLE_32_exit_group -TRACE_SYSCALL_TABLE(exit_group, exit_group, 4246, 1) -#endif -#ifndef OVERRIDE_TABLE_32_epoll_create -TRACE_SYSCALL_TABLE(epoll_create, epoll_create, 4248, 1) -#endif -#ifndef OVERRIDE_TABLE_32_remap_file_pages -TRACE_SYSCALL_TABLE(remap_file_pages, remap_file_pages, 4251, 5) -#endif -#ifndef OVERRIDE_TABLE_32_fadvise64_64 -TRACE_SYSCALL_TABLE(fadvise64_64, fadvise64_64, 4254, 4) -#endif -#ifndef OVERRIDE_TABLE_32_timer_getoverrun -TRACE_SYSCALL_TABLE(timer_getoverrun, timer_getoverrun, 4260, 1) -#endif -#ifndef OVERRIDE_TABLE_32_timer_delete -TRACE_SYSCALL_TABLE(timer_delete, timer_delete, 4261, 1) -#endif -#ifndef OVERRIDE_TABLE_32_tgkill -TRACE_SYSCALL_TABLE(tgkill, tgkill, 4266, 3) -#endif -#ifndef OVERRIDE_TABLE_32_set_thread_area -TRACE_SYSCALL_TABLE(set_thread_area, set_thread_area, 4283, 1) -#endif -#ifndef OVERRIDE_TABLE_32_inotify_rm_watch -TRACE_SYSCALL_TABLE(inotify_rm_watch, inotify_rm_watch, 4286, 2) -#endif -#ifndef OVERRIDE_TABLE_32_unshare -TRACE_SYSCALL_TABLE(unshare, unshare, 4303, 1) -#endif -#ifndef OVERRIDE_TABLE_32_sync_file_range -TRACE_SYSCALL_TABLE(sync_file_range, sync_file_range, 4305, 4) -#endif -#ifndef OVERRIDE_TABLE_32_tee -TRACE_SYSCALL_TABLE(tee, tee, 4306, 4) -#endif -#ifndef OVERRIDE_TABLE_32_ioprio_set -TRACE_SYSCALL_TABLE(ioprio_set, ioprio_set, 4314, 3) -#endif -#ifndef OVERRIDE_TABLE_32_ioprio_get -TRACE_SYSCALL_TABLE(ioprio_get, ioprio_get, 4315, 2) -#endif -#ifndef OVERRIDE_TABLE_32_eventfd -TRACE_SYSCALL_TABLE(eventfd, eventfd, 4319, 1) -#endif -#ifndef OVERRIDE_TABLE_32_fallocate -TRACE_SYSCALL_TABLE(fallocate, fallocate, 4320, 4) -#endif -#ifndef OVERRIDE_TABLE_32_timerfd_create -TRACE_SYSCALL_TABLE(timerfd_create, timerfd_create, 4321, 2) -#endif -#ifndef OVERRIDE_TABLE_32_eventfd2 -TRACE_SYSCALL_TABLE(eventfd2, eventfd2, 4325, 2) -#endif -#ifndef OVERRIDE_TABLE_32_epoll_create1 -TRACE_SYSCALL_TABLE(epoll_create1, epoll_create1, 4326, 1) -#endif -#ifndef OVERRIDE_TABLE_32_dup3 -TRACE_SYSCALL_TABLE(dup3, dup3, 4327, 3) -#endif -#ifndef OVERRIDE_TABLE_32_inotify_init1 -TRACE_SYSCALL_TABLE(inotify_init1, inotify_init1, 4329, 1) -#endif -#ifndef OVERRIDE_TABLE_32_syncfs -TRACE_SYSCALL_TABLE(syncfs, syncfs, 4342, 1) -#endif -#ifndef OVERRIDE_TABLE_32_setns -TRACE_SYSCALL_TABLE(setns, setns, 4344, 2) -#endif - -#endif /* CREATE_SYSCALL_TABLE */ diff --git a/instrumentation/syscalls/headers/mips-32-syscalls_integers_override.h b/instrumentation/syscalls/headers/mips-32-syscalls_integers_override.h deleted file mode 100644 index 64021873..00000000 --- a/instrumentation/syscalls/headers/mips-32-syscalls_integers_override.h +++ /dev/null @@ -1,5 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ - -/* - * this is a place-holder for MIPS integer syscall definition override. - */ diff --git a/instrumentation/syscalls/headers/mips-32-syscalls_pointers.h b/instrumentation/syscalls/headers/mips-32-syscalls_pointers.h deleted file mode 100644 index d638087b..00000000 --- a/instrumentation/syscalls/headers/mips-32-syscalls_pointers.h +++ /dev/null @@ -1,1899 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ - -/* THIS FILE IS AUTO-GENERATED. DO NOT EDIT */ - -/* Generated from mips-32-syscalls 3.18.0 */ - -#ifndef CREATE_SYSCALL_TABLE - -#if !defined(_TRACE_SYSCALLS_POINTERS_H) || defined(TRACE_HEADER_MULTI_READ) -#define _TRACE_SYSCALLS_POINTERS_H - -#include -#include -#include "mips-32-syscalls_pointers_override.h" -#include "syscalls_pointers_override.h" - -#ifndef OVERRIDE_32_unlink -SC_LTTNG_TRACEPOINT_EVENT(unlink, - TP_PROTO(sc_exit(long ret,) const char * pathname), - TP_ARGS(sc_exit(ret,) pathname), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname))) -) -#endif -#ifndef OVERRIDE_32_chdir -SC_LTTNG_TRACEPOINT_EVENT(chdir, - TP_PROTO(sc_exit(long ret,) const char * filename), - TP_ARGS(sc_exit(ret,) filename), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename))) -) -#endif -#ifndef OVERRIDE_32_time -SC_LTTNG_TRACEPOINT_EVENT(time, - TP_PROTO(sc_exit(long ret,) time_t * tloc), - TP_ARGS(sc_exit(ret,) tloc), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(time_t *, tloc, tloc))) -) -#endif -#ifndef OVERRIDE_32_oldumount -SC_LTTNG_TRACEPOINT_EVENT(oldumount, - TP_PROTO(sc_exit(long ret,) char * name), - TP_ARGS(sc_exit(ret,) name), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(name, name))) -) -#endif -#ifndef OVERRIDE_32_stime -SC_LTTNG_TRACEPOINT_EVENT(stime, - TP_PROTO(sc_exit(long ret,) time_t * tptr), - TP_ARGS(sc_exit(ret,) tptr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(time_t *, tptr, tptr))) -) -#endif -#ifndef OVERRIDE_32_rmdir -SC_LTTNG_TRACEPOINT_EVENT(rmdir, - TP_PROTO(sc_exit(long ret,) const char * pathname), - TP_ARGS(sc_exit(ret,) pathname), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname))) -) -#endif -#ifndef OVERRIDE_32_times -SC_LTTNG_TRACEPOINT_EVENT(times, - TP_PROTO(sc_exit(long ret,) struct tms * tbuf), - TP_ARGS(sc_exit(ret,) tbuf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct tms *, tbuf, tbuf))) -) -#endif -#ifndef OVERRIDE_32_olduname -SC_LTTNG_TRACEPOINT_EVENT(olduname, - TP_PROTO(sc_exit(long ret,) struct oldold_utsname * name), - TP_ARGS(sc_exit(ret,) name), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct oldold_utsname *, name, name))) -) -#endif -#ifndef OVERRIDE_32_chroot -SC_LTTNG_TRACEPOINT_EVENT(chroot, - TP_PROTO(sc_exit(long ret,) const char * filename), - TP_ARGS(sc_exit(ret,) filename), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename))) -) -#endif -#ifndef OVERRIDE_32_sigsuspend -SC_LTTNG_TRACEPOINT_EVENT(sigsuspend, - TP_PROTO(sc_exit(long ret,) sigset_t * uset), - TP_ARGS(sc_exit(ret,) uset), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(sigset_t *, uset, uset))) -) -#endif -#ifndef OVERRIDE_32_sigpending -SC_LTTNG_TRACEPOINT_EVENT(sigpending, - TP_PROTO(sc_exit(long ret,) old_sigset_t * set), - TP_ARGS(sc_exit(ret,) set), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(old_sigset_t *, set, set))) -) -#endif -#ifndef OVERRIDE_32_uname -SC_LTTNG_TRACEPOINT_EVENT(uname, - TP_PROTO(sc_exit(long ret,) struct old_utsname * name), - TP_ARGS(sc_exit(ret,) name), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct old_utsname *, name, name))) -) -#endif -#ifndef OVERRIDE_32_sysinfo -SC_LTTNG_TRACEPOINT_EVENT(sysinfo, - TP_PROTO(sc_exit(long ret,) struct sysinfo * info), - TP_ARGS(sc_exit(ret,) info), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct sysinfo *, info, info))) -) -#endif -#ifndef OVERRIDE_32_newuname -SC_LTTNG_TRACEPOINT_EVENT(newuname, - TP_PROTO(sc_exit(long ret,) struct new_utsname * name), - TP_ARGS(sc_exit(ret,) name), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct new_utsname *, name, name))) -) -#endif -#ifndef OVERRIDE_32_adjtimex -SC_LTTNG_TRACEPOINT_EVENT(adjtimex, - TP_PROTO(sc_exit(long ret,) struct timex * txc_p), - TP_ARGS(sc_exit(ret,) txc_p), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct timex *, txc_p, txc_p))) -) -#endif -#ifndef OVERRIDE_32_sysctl -SC_LTTNG_TRACEPOINT_EVENT(sysctl, - TP_PROTO(sc_exit(long ret,) struct __sysctl_args * args), - TP_ARGS(sc_exit(ret,) args), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct __sysctl_args *, args, args))) -) -#endif -#ifndef OVERRIDE_32_set_tid_address -SC_LTTNG_TRACEPOINT_EVENT(set_tid_address, - TP_PROTO(sc_exit(long ret,) int * tidptr), - TP_ARGS(sc_exit(ret,) tidptr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int *, tidptr, tidptr))) -) -#endif -#ifndef OVERRIDE_32_creat -SC_LTTNG_TRACEPOINT_EVENT(creat, - TP_PROTO(sc_exit(long ret,) const char * pathname, umode_t mode), - TP_ARGS(sc_exit(ret,) pathname, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(umode_t, mode, mode))) -) -#endif -#ifndef OVERRIDE_32_link -SC_LTTNG_TRACEPOINT_EVENT(link, - TP_PROTO(sc_exit(long ret,) const char * oldname, const char * newname), - TP_ARGS(sc_exit(ret,) oldname, newname), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_user_string(newname, newname))) -) -#endif -#ifndef OVERRIDE_32_chmod -SC_LTTNG_TRACEPOINT_EVENT(chmod, - TP_PROTO(sc_exit(long ret,) const char * filename, umode_t mode), - TP_ARGS(sc_exit(ret,) filename, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(umode_t, mode, mode))) -) -#endif -#ifndef OVERRIDE_32_utime -SC_LTTNG_TRACEPOINT_EVENT(utime, - TP_PROTO(sc_exit(long ret,) char * filename, struct utimbuf * times), - TP_ARGS(sc_exit(ret,) filename, times), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(struct utimbuf *, times, times))) -) -#endif -#ifndef OVERRIDE_32_access -SC_LTTNG_TRACEPOINT_EVENT(access, - TP_PROTO(sc_exit(long ret,) const char * filename, int mode), - TP_ARGS(sc_exit(ret,) filename, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, mode, mode))) -) -#endif -#ifndef OVERRIDE_32_rename -SC_LTTNG_TRACEPOINT_EVENT(rename, - TP_PROTO(sc_exit(long ret,) const char * oldname, const char * newname), - TP_ARGS(sc_exit(ret,) oldname, newname), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_user_string(newname, newname))) -) -#endif -#ifndef OVERRIDE_32_mkdir -SC_LTTNG_TRACEPOINT_EVENT(mkdir, - TP_PROTO(sc_exit(long ret,) const char * pathname, umode_t mode), - TP_ARGS(sc_exit(ret,) pathname, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(umode_t, mode, mode))) -) -#endif -#ifndef OVERRIDE_32_umount -SC_LTTNG_TRACEPOINT_EVENT(umount, - TP_PROTO(sc_exit(long ret,) char * name, int flags), - TP_ARGS(sc_exit(ret,) name, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_ustat -SC_LTTNG_TRACEPOINT_EVENT(ustat, - TP_PROTO(sc_exit(long ret,) unsigned dev, struct ustat * ubuf), - TP_ARGS(sc_exit(ret,) dev, ubuf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned, dev, dev)) sc_out(ctf_integer(struct ustat *, ubuf, ubuf))) -) -#endif -#ifndef OVERRIDE_32_sethostname -SC_LTTNG_TRACEPOINT_EVENT(sethostname, - TP_PROTO(sc_exit(long ret,) char * name, int len), - TP_ARGS(sc_exit(ret,) name, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(int, len, len))) -) -#endif -#ifndef OVERRIDE_32_setrlimit -SC_LTTNG_TRACEPOINT_EVENT(setrlimit, - TP_PROTO(sc_exit(long ret,) unsigned int resource, struct rlimit * rlim), - TP_ARGS(sc_exit(ret,) resource, rlim), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, resource, resource)) sc_in(ctf_integer(struct rlimit *, rlim, rlim))) -) -#endif -#ifndef OVERRIDE_32_getrlimit -SC_LTTNG_TRACEPOINT_EVENT(getrlimit, - TP_PROTO(sc_exit(long ret,) unsigned int resource, struct rlimit * rlim), - TP_ARGS(sc_exit(ret,) resource, rlim), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, resource, resource)) sc_out(ctf_integer(struct rlimit *, rlim, rlim))) -) -#endif -#ifndef OVERRIDE_32_getrusage -SC_LTTNG_TRACEPOINT_EVENT(getrusage, - TP_PROTO(sc_exit(long ret,) int who, struct rusage * ru), - TP_ARGS(sc_exit(ret,) who, ru), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, who, who)) sc_out(ctf_integer(struct rusage *, ru, ru))) -) -#endif -#ifndef OVERRIDE_32_gettimeofday -SC_LTTNG_TRACEPOINT_EVENT(gettimeofday, - TP_PROTO(sc_exit(long ret,) struct timeval * tv, struct timezone * tz), - TP_ARGS(sc_exit(ret,) tv, tz), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct timeval *, tv, tv)) sc_out(ctf_integer(struct timezone *, tz, tz))) -) -#endif -#ifndef OVERRIDE_32_settimeofday -SC_LTTNG_TRACEPOINT_EVENT(settimeofday, - TP_PROTO(sc_exit(long ret,) struct timeval * tv, struct timezone * tz), - TP_ARGS(sc_exit(ret,) tv, tz), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct timeval *, tv, tv)) sc_in(ctf_integer(struct timezone *, tz, tz))) -) -#endif -#ifndef OVERRIDE_32_getgroups -SC_LTTNG_TRACEPOINT_EVENT(getgroups, - TP_PROTO(sc_exit(long ret,) int gidsetsize, gid_t * grouplist), - TP_ARGS(sc_exit(ret,) gidsetsize, grouplist), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, gidsetsize, gidsetsize)) sc_out(ctf_integer(gid_t *, grouplist, grouplist))) -) -#endif -#ifndef OVERRIDE_32_setgroups -SC_LTTNG_TRACEPOINT_EVENT(setgroups, - TP_PROTO(sc_exit(long ret,) int gidsetsize, gid_t * grouplist), - TP_ARGS(sc_exit(ret,) gidsetsize, grouplist), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, gidsetsize, gidsetsize)) sc_in(ctf_integer(gid_t *, grouplist, grouplist))) -) -#endif -#ifndef OVERRIDE_32_symlink -SC_LTTNG_TRACEPOINT_EVENT(symlink, - TP_PROTO(sc_exit(long ret,) const char * oldname, const char * newname), - TP_ARGS(sc_exit(ret,) oldname, newname), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_user_string(newname, newname))) -) -#endif -#ifndef OVERRIDE_32_truncate -SC_LTTNG_TRACEPOINT_EVENT(truncate, - TP_PROTO(sc_exit(long ret,) const char * path, long length), - TP_ARGS(sc_exit(ret,) path, length), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(path, path)) sc_in(ctf_integer(long, length, length))) -) -#endif -#ifndef OVERRIDE_32_statfs -SC_LTTNG_TRACEPOINT_EVENT(statfs, - TP_PROTO(sc_exit(long ret,) const char * pathname, struct statfs * buf), - TP_ARGS(sc_exit(ret,) pathname, buf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(struct statfs *, buf, buf))) -) -#endif -#ifndef OVERRIDE_32_fstatfs -SC_LTTNG_TRACEPOINT_EVENT(fstatfs, - TP_PROTO(sc_exit(long ret,) unsigned int fd, struct statfs * buf), - TP_ARGS(sc_exit(ret,) fd, buf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct statfs *, buf, buf))) -) -#endif -#ifndef OVERRIDE_32_socketcall -SC_LTTNG_TRACEPOINT_EVENT(socketcall, - TP_PROTO(sc_exit(long ret,) int call, unsigned long * args), - TP_ARGS(sc_exit(ret,) call, args), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, call, call)) sc_inout(ctf_integer(unsigned long *, args, args))) -) -#endif -#ifndef OVERRIDE_32_getitimer -SC_LTTNG_TRACEPOINT_EVENT(getitimer, - TP_PROTO(sc_exit(long ret,) int which, struct itimerval * value), - TP_ARGS(sc_exit(ret,) which, value), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_out(ctf_integer(struct itimerval *, value, value))) -) -#endif -#ifndef OVERRIDE_32_newstat -SC_LTTNG_TRACEPOINT_EVENT(newstat, - TP_PROTO(sc_exit(long ret,) const char * filename, struct stat * statbuf), - TP_ARGS(sc_exit(ret,) filename, statbuf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_out(ctf_integer(struct stat *, statbuf, statbuf))) -) -#endif -#ifndef OVERRIDE_32_newlstat -SC_LTTNG_TRACEPOINT_EVENT(newlstat, - TP_PROTO(sc_exit(long ret,) const char * filename, struct stat * statbuf), - TP_ARGS(sc_exit(ret,) filename, statbuf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_out(ctf_integer(struct stat *, statbuf, statbuf))) -) -#endif -#ifndef OVERRIDE_32_newfstat -SC_LTTNG_TRACEPOINT_EVENT(newfstat, - TP_PROTO(sc_exit(long ret,) unsigned int fd, struct stat * statbuf), - TP_ARGS(sc_exit(ret,) fd, statbuf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct stat *, statbuf, statbuf))) -) -#endif -#ifndef OVERRIDE_32_setdomainname -SC_LTTNG_TRACEPOINT_EVENT(setdomainname, - TP_PROTO(sc_exit(long ret,) char * name, int len), - TP_ARGS(sc_exit(ret,) name, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(int, len, len))) -) -#endif -#ifndef OVERRIDE_32_delete_module -SC_LTTNG_TRACEPOINT_EVENT(delete_module, - TP_PROTO(sc_exit(long ret,) const char * name_user, unsigned int flags), - TP_ARGS(sc_exit(ret,) name_user, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name_user, name_user)) sc_in(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_sched_setparam -SC_LTTNG_TRACEPOINT_EVENT(sched_setparam, - TP_PROTO(sc_exit(long ret,) pid_t pid, struct sched_param * param), - TP_ARGS(sc_exit(ret,) pid, param), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(struct sched_param *, param, param))) -) -#endif -#ifndef OVERRIDE_32_sched_getparam -SC_LTTNG_TRACEPOINT_EVENT(sched_getparam, - TP_PROTO(sc_exit(long ret,) pid_t pid, struct sched_param * param), - TP_ARGS(sc_exit(ret,) pid, param), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_out(ctf_integer(struct sched_param *, param, param))) -) -#endif -#ifndef OVERRIDE_32_sched_rr_get_interval -SC_LTTNG_TRACEPOINT_EVENT(sched_rr_get_interval, - TP_PROTO(sc_exit(long ret,) pid_t pid, struct timespec * interval), - TP_ARGS(sc_exit(ret,) pid, interval), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_out(ctf_integer(struct timespec *, interval, interval))) -) -#endif -#ifndef OVERRIDE_32_nanosleep -SC_LTTNG_TRACEPOINT_EVENT(nanosleep, - TP_PROTO(sc_exit(long ret,) struct timespec * rqtp, struct timespec * rmtp), - TP_ARGS(sc_exit(ret,) rqtp, rmtp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct timespec *, rqtp, rqtp)) sc_out(ctf_integer(struct timespec *, rmtp, rmtp))) -) -#endif -#ifndef OVERRIDE_32_rt_sigpending -SC_LTTNG_TRACEPOINT_EVENT(rt_sigpending, - TP_PROTO(sc_exit(long ret,) sigset_t * uset, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) uset, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(sigset_t *, uset, uset)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) -) -#endif -#ifndef OVERRIDE_32_rt_sigsuspend -SC_LTTNG_TRACEPOINT_EVENT(rt_sigsuspend, - TP_PROTO(sc_exit(long ret,) sigset_t * unewset, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) unewset, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(sigset_t *, unewset, unewset)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) -) -#endif -#ifndef OVERRIDE_32_getcwd -SC_LTTNG_TRACEPOINT_EVENT(getcwd, - TP_PROTO(sc_exit(long ret,) char * buf, unsigned long size), - TP_ARGS(sc_exit(ret,) buf, size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(unsigned long, size, size))) -) -#endif -#ifndef OVERRIDE_32_sigaltstack -SC_LTTNG_TRACEPOINT_EVENT(sigaltstack, - TP_PROTO(sc_exit(long ret,) const stack_t * uss, stack_t * uoss), - TP_ARGS(sc_exit(ret,) uss, uoss), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const stack_t *, uss, uss)) sc_inout(ctf_integer(stack_t *, uoss, uoss))) -) -#endif -#ifndef OVERRIDE_32_truncate64 -SC_LTTNG_TRACEPOINT_EVENT(truncate64, - TP_PROTO(sc_exit(long ret,) const char * path, loff_t length), - TP_ARGS(sc_exit(ret,) path, length), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(path, path)) sc_inout(ctf_integer(loff_t, length, length))) -) -#endif -#ifndef OVERRIDE_32_stat64 -SC_LTTNG_TRACEPOINT_EVENT(stat64, - TP_PROTO(sc_exit(long ret,) const char * filename, struct stat64 * statbuf), - TP_ARGS(sc_exit(ret,) filename, statbuf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(filename, filename)) sc_inout(ctf_integer(struct stat64 *, statbuf, statbuf))) -) -#endif -#ifndef OVERRIDE_32_lstat64 -SC_LTTNG_TRACEPOINT_EVENT(lstat64, - TP_PROTO(sc_exit(long ret,) const char * filename, struct stat64 * statbuf), - TP_ARGS(sc_exit(ret,) filename, statbuf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(filename, filename)) sc_inout(ctf_integer(struct stat64 *, statbuf, statbuf))) -) -#endif -#ifndef OVERRIDE_32_fstat64 -SC_LTTNG_TRACEPOINT_EVENT(fstat64, - TP_PROTO(sc_exit(long ret,) unsigned long fd, struct stat64 * statbuf), - TP_ARGS(sc_exit(ret,) fd, statbuf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned long, fd, fd)) sc_inout(ctf_integer(struct stat64 *, statbuf, statbuf))) -) -#endif -#ifndef OVERRIDE_32_pivot_root -SC_LTTNG_TRACEPOINT_EVENT(pivot_root, - TP_PROTO(sc_exit(long ret,) const char * new_root, const char * put_old), - TP_ARGS(sc_exit(ret,) new_root, put_old), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(new_root, new_root)) sc_in(ctf_user_string(put_old, put_old))) -) -#endif -#ifndef OVERRIDE_32_removexattr -SC_LTTNG_TRACEPOINT_EVENT(removexattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name), - TP_ARGS(sc_exit(ret,) pathname, name), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name))) -) -#endif -#ifndef OVERRIDE_32_lremovexattr -SC_LTTNG_TRACEPOINT_EVENT(lremovexattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name), - TP_ARGS(sc_exit(ret,) pathname, name), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name))) -) -#endif -#ifndef OVERRIDE_32_fremovexattr -SC_LTTNG_TRACEPOINT_EVENT(fremovexattr, - TP_PROTO(sc_exit(long ret,) int fd, const char * name), - TP_ARGS(sc_exit(ret,) fd, name), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(name, name))) -) -#endif -#ifndef OVERRIDE_32_io_setup -SC_LTTNG_TRACEPOINT_EVENT(io_setup, - TP_PROTO(sc_exit(long ret,) unsigned nr_events, aio_context_t * ctxp), - TP_ARGS(sc_exit(ret,) nr_events, ctxp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned, nr_events, nr_events)) sc_in(ctf_integer(aio_context_t *, ctxp, ctxp))) -) -#endif -#ifndef OVERRIDE_32_timer_gettime -SC_LTTNG_TRACEPOINT_EVENT(timer_gettime, - TP_PROTO(sc_exit(long ret,) timer_t timer_id, struct itimerspec * setting), - TP_ARGS(sc_exit(ret,) timer_id, setting), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id)) sc_out(ctf_integer(struct itimerspec *, setting, setting))) -) -#endif -#ifndef OVERRIDE_32_clock_settime -SC_LTTNG_TRACEPOINT_EVENT(clock_settime, - TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, const struct timespec * tp), - TP_ARGS(sc_exit(ret,) which_clock, tp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_in(ctf_integer(const struct timespec *, tp, tp))) -) -#endif -#ifndef OVERRIDE_32_clock_gettime -SC_LTTNG_TRACEPOINT_EVENT(clock_gettime, - TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct timespec * tp), - TP_ARGS(sc_exit(ret,) which_clock, tp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_out(ctf_integer(struct timespec *, tp, tp))) -) -#endif -#ifndef OVERRIDE_32_clock_getres -SC_LTTNG_TRACEPOINT_EVENT(clock_getres, - TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct timespec * tp), - TP_ARGS(sc_exit(ret,) which_clock, tp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_out(ctf_integer(struct timespec *, tp, tp))) -) -#endif -#ifndef OVERRIDE_32_utimes -SC_LTTNG_TRACEPOINT_EVENT(utimes, - TP_PROTO(sc_exit(long ret,) char * filename, struct timeval * utimes), - TP_ARGS(sc_exit(ret,) filename, utimes), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(struct timeval *, utimes, utimes))) -) -#endif -#ifndef OVERRIDE_32_set_robust_list -SC_LTTNG_TRACEPOINT_EVENT(set_robust_list, - TP_PROTO(sc_exit(long ret,) struct robust_list_head * head, size_t len), - TP_ARGS(sc_exit(ret,) head, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct robust_list_head *, head, head)) sc_in(ctf_integer(size_t, len, len))) -) -#endif -#ifndef OVERRIDE_32_timerfd_gettime -SC_LTTNG_TRACEPOINT_EVENT(timerfd_gettime, - TP_PROTO(sc_exit(long ret,) int ufd, struct itimerspec * otmr), - TP_ARGS(sc_exit(ret,) ufd, otmr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_out(ctf_integer(struct itimerspec *, otmr, otmr))) -) -#endif -#ifndef OVERRIDE_32_pipe2 -SC_LTTNG_TRACEPOINT_EVENT(pipe2, - TP_PROTO(sc_exit(long ret,) int * fildes, int flags), - TP_ARGS(sc_exit(ret,) fildes, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(int *, fildes, fildes)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_clock_adjtime -SC_LTTNG_TRACEPOINT_EVENT(clock_adjtime, - TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct timex * utx), - TP_ARGS(sc_exit(ret,) which_clock, utx), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_inout(ctf_integer(struct timex *, utx, utx))) -) -#endif -#ifndef OVERRIDE_32_memfd_create -SC_LTTNG_TRACEPOINT_EVENT(memfd_create, - TP_PROTO(sc_exit(long ret,) const char * uname, unsigned int flags), - TP_ARGS(sc_exit(ret,) uname, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(uname, uname)) sc_inout(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_read -SC_LTTNG_TRACEPOINT_EVENT(read, - TP_PROTO(sc_exit(long ret,) unsigned int fd, char * buf, size_t count), - TP_ARGS(sc_exit(ret,) fd, buf, count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(size_t, count, count))) -) -#endif -#ifndef OVERRIDE_32_write -SC_LTTNG_TRACEPOINT_EVENT(write, - TP_PROTO(sc_exit(long ret,) unsigned int fd, const char * buf, size_t count), - TP_ARGS(sc_exit(ret,) fd, buf, count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(const char *, buf, buf)) sc_in(ctf_integer(size_t, count, count))) -) -#endif -#ifndef OVERRIDE_32_open -SC_LTTNG_TRACEPOINT_EVENT(open, - TP_PROTO(sc_exit(long ret,) const char * filename, int flags, umode_t mode), - TP_ARGS(sc_exit(ret,) filename, flags, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(umode_t, mode, mode))) -) -#endif -#ifndef OVERRIDE_32_waitpid -SC_LTTNG_TRACEPOINT_EVENT(waitpid, - TP_PROTO(sc_exit(long ret,) pid_t pid, int * stat_addr, int options), - TP_ARGS(sc_exit(ret,) pid, stat_addr, options), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(pid_t, pid, pid)) sc_inout(ctf_integer(int *, stat_addr, stat_addr)) sc_inout(ctf_integer(int, options, options))) -) -#endif -#ifndef OVERRIDE_32_execve -SC_LTTNG_TRACEPOINT_EVENT(execve, - TP_PROTO(sc_exit(long ret,) const char * filename, const char *const * argv, const char *const * envp), - TP_ARGS(sc_exit(ret,) filename, argv, envp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(filename, filename)) sc_inout(ctf_integer(const char *const *, argv, argv)) sc_inout(ctf_integer(const char *const *, envp, envp))) -) -#endif -#ifndef OVERRIDE_32_mknod -SC_LTTNG_TRACEPOINT_EVENT(mknod, - TP_PROTO(sc_exit(long ret,) const char * filename, umode_t mode, unsigned dev), - TP_ARGS(sc_exit(ret,) filename, mode, dev), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(umode_t, mode, mode)) sc_in(ctf_integer(unsigned, dev, dev))) -) -#endif -#ifndef OVERRIDE_32_lchown -SC_LTTNG_TRACEPOINT_EVENT(lchown, - TP_PROTO(sc_exit(long ret,) const char * filename, uid_t user, gid_t group), - TP_ARGS(sc_exit(ret,) filename, user, group), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group))) -) -#endif -#ifndef OVERRIDE_32_sigaction -SC_LTTNG_TRACEPOINT_EVENT(sigaction, - TP_PROTO(sc_exit(long ret,) int sig, const struct sigaction * act, struct sigaction * oact), - TP_ARGS(sc_exit(ret,) sig, act, oact), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, sig, sig)) sc_inout(ctf_integer(const struct sigaction *, act, act)) sc_inout(ctf_integer(struct sigaction *, oact, oact))) -) -#endif -#ifndef OVERRIDE_32_readlink -SC_LTTNG_TRACEPOINT_EVENT(readlink, - TP_PROTO(sc_exit(long ret,) const char * path, char * buf, int bufsiz), - TP_ARGS(sc_exit(ret,) path, buf, bufsiz), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(path, path)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(int, bufsiz, bufsiz))) -) -#endif -#ifndef OVERRIDE_32_old_readdir -SC_LTTNG_TRACEPOINT_EVENT(old_readdir, - TP_PROTO(sc_exit(long ret,) unsigned int fd, struct old_linux_dirent * dirent, unsigned int count), - TP_ARGS(sc_exit(ret,) fd, dirent, count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, fd, fd)) sc_inout(ctf_integer(struct old_linux_dirent *, dirent, dirent)) sc_inout(ctf_integer(unsigned int, count, count))) -) -#endif -#ifndef OVERRIDE_32_syslog -SC_LTTNG_TRACEPOINT_EVENT(syslog, - TP_PROTO(sc_exit(long ret,) int type, char * buf, int len), - TP_ARGS(sc_exit(ret,) type, buf, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, type, type)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(int, len, len))) -) -#endif -#ifndef OVERRIDE_32_setitimer -SC_LTTNG_TRACEPOINT_EVENT(setitimer, - TP_PROTO(sc_exit(long ret,) int which, struct itimerval * value, struct itimerval * ovalue), - TP_ARGS(sc_exit(ret,) which, value, ovalue), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(struct itimerval *, value, value)) sc_out(ctf_integer(struct itimerval *, ovalue, ovalue))) -) -#endif -#ifndef OVERRIDE_32_sigprocmask -SC_LTTNG_TRACEPOINT_EVENT(sigprocmask, - TP_PROTO(sc_exit(long ret,) int how, old_sigset_t * nset, old_sigset_t * oset), - TP_ARGS(sc_exit(ret,) how, nset, oset), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, how, how)) sc_inout(ctf_integer(old_sigset_t *, nset, nset)) sc_inout(ctf_integer(old_sigset_t *, oset, oset))) -) -#endif -#ifndef OVERRIDE_32_init_module -SC_LTTNG_TRACEPOINT_EVENT(init_module, - TP_PROTO(sc_exit(long ret,) void * umod, unsigned long len, const char * uargs), - TP_ARGS(sc_exit(ret,) umod, len, uargs), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(void *, umod, umod)) sc_in(ctf_integer(unsigned long, len, len)) sc_in(ctf_integer(const char *, uargs, uargs))) -) -#endif -#ifndef OVERRIDE_32_getdents -SC_LTTNG_TRACEPOINT_EVENT(getdents, - TP_PROTO(sc_exit(long ret,) unsigned int fd, struct linux_dirent * dirent, unsigned int count), - TP_ARGS(sc_exit(ret,) fd, dirent, count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct linux_dirent *, dirent, dirent)) sc_in(ctf_integer(unsigned int, count, count))) -) -#endif -#ifndef OVERRIDE_32_readv -SC_LTTNG_TRACEPOINT_EVENT(readv, - TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen), - TP_ARGS(sc_exit(ret,) fd, vec, vlen), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_inout(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen))) -) -#endif -#ifndef OVERRIDE_32_writev -SC_LTTNG_TRACEPOINT_EVENT(writev, - TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen), - TP_ARGS(sc_exit(ret,) fd, vec, vlen), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_inout(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen))) -) -#endif -#ifndef OVERRIDE_32_cachectl -SC_LTTNG_TRACEPOINT_EVENT(cachectl, - TP_PROTO(sc_exit(long ret,) char * addr, int nbytes, int op), - TP_ARGS(sc_exit(ret,) addr, nbytes, op), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(char *, addr, addr)) sc_inout(ctf_integer(int, nbytes, nbytes)) sc_inout(ctf_integer(int, op, op))) -) -#endif -#ifndef OVERRIDE_32_sched_setscheduler -SC_LTTNG_TRACEPOINT_EVENT(sched_setscheduler, - TP_PROTO(sc_exit(long ret,) pid_t pid, int policy, struct sched_param * param), - TP_ARGS(sc_exit(ret,) pid, policy, param), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, policy, policy)) sc_in(ctf_integer(struct sched_param *, param, param))) -) -#endif -#ifndef OVERRIDE_32_accept -SC_LTTNG_TRACEPOINT_EVENT(accept, - TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * upeer_sockaddr, int * upeer_addrlen), - TP_ARGS(sc_exit(ret,) fd, upeer_sockaddr, upeer_addrlen), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct sockaddr *, upeer_sockaddr, upeer_sockaddr)) sc_inout(ctf_integer(int *, upeer_addrlen, upeer_addrlen))) -) -#endif -#ifndef OVERRIDE_32_bind -SC_LTTNG_TRACEPOINT_EVENT(bind, - TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * umyaddr, int addrlen), - TP_ARGS(sc_exit(ret,) fd, umyaddr, addrlen), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct sockaddr *, umyaddr, umyaddr)) sc_in(ctf_integer(int, addrlen, addrlen))) -) -#endif -#ifndef OVERRIDE_32_connect -SC_LTTNG_TRACEPOINT_EVENT(connect, - TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * uservaddr, int addrlen), - TP_ARGS(sc_exit(ret,) fd, uservaddr, addrlen), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct sockaddr *, uservaddr, uservaddr)) sc_in(ctf_integer(int, addrlen, addrlen))) -) -#endif -#ifndef OVERRIDE_32_getpeername -SC_LTTNG_TRACEPOINT_EVENT(getpeername, - TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * usockaddr, int * usockaddr_len), - TP_ARGS(sc_exit(ret,) fd, usockaddr, usockaddr_len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct sockaddr *, usockaddr, usockaddr)) sc_inout(ctf_integer(int *, usockaddr_len, usockaddr_len))) -) -#endif -#ifndef OVERRIDE_32_getsockname -SC_LTTNG_TRACEPOINT_EVENT(getsockname, - TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * usockaddr, int * usockaddr_len), - TP_ARGS(sc_exit(ret,) fd, usockaddr, usockaddr_len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct sockaddr *, usockaddr, usockaddr)) sc_inout(ctf_integer(int *, usockaddr_len, usockaddr_len))) -) -#endif -#ifndef OVERRIDE_32_recvmsg -SC_LTTNG_TRACEPOINT_EVENT(recvmsg, - TP_PROTO(sc_exit(long ret,) int fd, struct msghdr * msg, unsigned int flags), - TP_ARGS(sc_exit(ret,) fd, msg, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_inout(ctf_integer(struct msghdr *, msg, msg)) sc_in(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_sendmsg -SC_LTTNG_TRACEPOINT_EVENT(sendmsg, - TP_PROTO(sc_exit(long ret,) int fd, struct msghdr * msg, unsigned int flags), - TP_ARGS(sc_exit(ret,) fd, msg, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct msghdr *, msg, msg)) sc_in(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_getresuid -SC_LTTNG_TRACEPOINT_EVENT(getresuid, - TP_PROTO(sc_exit(long ret,) uid_t * ruidp, uid_t * euidp, uid_t * suidp), - TP_ARGS(sc_exit(ret,) ruidp, euidp, suidp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(uid_t *, ruidp, ruidp)) sc_out(ctf_integer(uid_t *, euidp, euidp)) sc_out(ctf_integer(uid_t *, suidp, suidp))) -) -#endif -#ifndef OVERRIDE_32_poll -SC_LTTNG_TRACEPOINT_EVENT(poll, - TP_PROTO(sc_exit(long ret,) struct pollfd * ufds, unsigned int nfds, int timeout_msecs), - TP_ARGS(sc_exit(ret,) ufds, nfds, timeout_msecs), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct pollfd *, ufds, ufds)) sc_in(ctf_integer(unsigned int, nfds, nfds)) sc_in(ctf_integer(int, timeout_msecs, timeout_msecs))) -) -#endif -#ifndef OVERRIDE_32_getresgid -SC_LTTNG_TRACEPOINT_EVENT(getresgid, - TP_PROTO(sc_exit(long ret,) gid_t * rgidp, gid_t * egidp, gid_t * sgidp), - TP_ARGS(sc_exit(ret,) rgidp, egidp, sgidp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(gid_t *, rgidp, rgidp)) sc_out(ctf_integer(gid_t *, egidp, egidp)) sc_out(ctf_integer(gid_t *, sgidp, sgidp))) -) -#endif -#ifndef OVERRIDE_32_rt_sigqueueinfo -SC_LTTNG_TRACEPOINT_EVENT(rt_sigqueueinfo, - TP_PROTO(sc_exit(long ret,) pid_t pid, int sig, siginfo_t * uinfo), - TP_ARGS(sc_exit(ret,) pid, sig, uinfo), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig)) sc_in(ctf_integer(siginfo_t *, uinfo, uinfo))) -) -#endif -#ifndef OVERRIDE_32_chown -SC_LTTNG_TRACEPOINT_EVENT(chown, - TP_PROTO(sc_exit(long ret,) const char * filename, uid_t user, gid_t group), - TP_ARGS(sc_exit(ret,) filename, user, group), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group))) -) -#endif -#ifndef OVERRIDE_32_mincore -SC_LTTNG_TRACEPOINT_EVENT(mincore, - TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len, unsigned char * vec), - TP_ARGS(sc_exit(ret,) start, len, vec), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len)) sc_out(ctf_integer(unsigned char *, vec, vec))) -) -#endif -#ifndef OVERRIDE_32_getdents64 -SC_LTTNG_TRACEPOINT_EVENT(getdents64, - TP_PROTO(sc_exit(long ret,) unsigned int fd, struct linux_dirent64 * dirent, unsigned int count), - TP_ARGS(sc_exit(ret,) fd, dirent, count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct linux_dirent64 *, dirent, dirent)) sc_in(ctf_integer(unsigned int, count, count))) -) -#endif -#ifndef OVERRIDE_32_listxattr -SC_LTTNG_TRACEPOINT_EVENT(listxattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, char * list, size_t size), - TP_ARGS(sc_exit(ret,) pathname, list, size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(char *, list, list)) sc_in(ctf_integer(size_t, size, size))) -) -#endif -#ifndef OVERRIDE_32_llistxattr -SC_LTTNG_TRACEPOINT_EVENT(llistxattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, char * list, size_t size), - TP_ARGS(sc_exit(ret,) pathname, list, size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(char *, list, list)) sc_in(ctf_integer(size_t, size, size))) -) -#endif -#ifndef OVERRIDE_32_flistxattr -SC_LTTNG_TRACEPOINT_EVENT(flistxattr, - TP_PROTO(sc_exit(long ret,) int fd, char * list, size_t size), - TP_ARGS(sc_exit(ret,) fd, list, size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(char *, list, list)) sc_in(ctf_integer(size_t, size, size))) -) -#endif -#ifndef OVERRIDE_32_io_submit -SC_LTTNG_TRACEPOINT_EVENT(io_submit, - TP_PROTO(sc_exit(long ret,) aio_context_t ctx_id, long nr, struct iocb * * iocbpp), - TP_ARGS(sc_exit(ret,) ctx_id, nr, iocbpp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx_id, ctx_id)) sc_in(ctf_integer(long, nr, nr)) sc_in(ctf_integer(struct iocb * *, iocbpp, iocbpp))) -) -#endif -#ifndef OVERRIDE_32_io_cancel -SC_LTTNG_TRACEPOINT_EVENT(io_cancel, - TP_PROTO(sc_exit(long ret,) aio_context_t ctx_id, struct iocb * iocb, struct io_event * result), - TP_ARGS(sc_exit(ret,) ctx_id, iocb, result), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx_id, ctx_id)) sc_in(ctf_integer(struct iocb *, iocb, iocb)) sc_out(ctf_integer(struct io_event *, result, result))) -) -#endif -#ifndef OVERRIDE_32_statfs64 -SC_LTTNG_TRACEPOINT_EVENT(statfs64, - TP_PROTO(sc_exit(long ret,) const char * pathname, size_t sz, struct statfs64 * buf), - TP_ARGS(sc_exit(ret,) pathname, sz, buf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(pathname, pathname)) sc_inout(ctf_integer(size_t, sz, sz)) sc_inout(ctf_integer(struct statfs64 *, buf, buf))) -) -#endif -#ifndef OVERRIDE_32_fstatfs64 -SC_LTTNG_TRACEPOINT_EVENT(fstatfs64, - TP_PROTO(sc_exit(long ret,) unsigned int fd, size_t sz, struct statfs64 * buf), - TP_ARGS(sc_exit(ret,) fd, sz, buf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, fd, fd)) sc_inout(ctf_integer(size_t, sz, sz)) sc_inout(ctf_integer(struct statfs64 *, buf, buf))) -) -#endif -#ifndef OVERRIDE_32_timer_create -SC_LTTNG_TRACEPOINT_EVENT(timer_create, - TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct sigevent * timer_event_spec, timer_t * created_timer_id), - TP_ARGS(sc_exit(ret,) which_clock, timer_event_spec, created_timer_id), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_in(ctf_integer(struct sigevent *, timer_event_spec, timer_event_spec)) sc_out(ctf_integer(timer_t *, created_timer_id, created_timer_id))) -) -#endif -#ifndef OVERRIDE_32_inotify_add_watch -SC_LTTNG_TRACEPOINT_EVENT(inotify_add_watch, - TP_PROTO(sc_exit(long ret,) int fd, const char * pathname, u32 mask), - TP_ARGS(sc_exit(ret,) fd, pathname, mask), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(u32, mask, mask))) -) -#endif -#ifndef OVERRIDE_32_mkdirat -SC_LTTNG_TRACEPOINT_EVENT(mkdirat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * pathname, umode_t mode), - TP_ARGS(sc_exit(ret,) dfd, pathname, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(umode_t, mode, mode))) -) -#endif -#ifndef OVERRIDE_32_futimesat -SC_LTTNG_TRACEPOINT_EVENT(futimesat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, struct timeval * utimes), - TP_ARGS(sc_exit(ret,) dfd, filename, utimes), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(struct timeval *, utimes, utimes))) -) -#endif -#ifndef OVERRIDE_32_unlinkat -SC_LTTNG_TRACEPOINT_EVENT(unlinkat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * pathname, int flag), - TP_ARGS(sc_exit(ret,) dfd, pathname, flag), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(int, flag, flag))) -) -#endif -#ifndef OVERRIDE_32_symlinkat -SC_LTTNG_TRACEPOINT_EVENT(symlinkat, - TP_PROTO(sc_exit(long ret,) const char * oldname, int newdfd, const char * newname), - TP_ARGS(sc_exit(ret,) oldname, newdfd, newname), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_integer(int, newdfd, newdfd)) sc_in(ctf_user_string(newname, newname))) -) -#endif -#ifndef OVERRIDE_32_fchmodat -SC_LTTNG_TRACEPOINT_EVENT(fchmodat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, umode_t mode), - TP_ARGS(sc_exit(ret,) dfd, filename, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(umode_t, mode, mode))) -) -#endif -#ifndef OVERRIDE_32_faccessat -SC_LTTNG_TRACEPOINT_EVENT(faccessat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, int mode), - TP_ARGS(sc_exit(ret,) dfd, filename, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, mode, mode))) -) -#endif -#ifndef OVERRIDE_32_get_robust_list -SC_LTTNG_TRACEPOINT_EVENT(get_robust_list, - TP_PROTO(sc_exit(long ret,) int pid, struct robust_list_head * * head_ptr, size_t * len_ptr), - TP_ARGS(sc_exit(ret,) pid, head_ptr, len_ptr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, pid, pid)) sc_out(ctf_integer(struct robust_list_head * *, head_ptr, head_ptr)) sc_out(ctf_integer(size_t *, len_ptr, len_ptr))) -) -#endif -#ifndef OVERRIDE_32_getcpu -SC_LTTNG_TRACEPOINT_EVENT(getcpu, - TP_PROTO(sc_exit(long ret,) unsigned * cpup, unsigned * nodep, struct getcpu_cache * unused), - TP_ARGS(sc_exit(ret,) cpup, nodep, unused), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(unsigned *, cpup, cpup)) sc_out(ctf_integer(unsigned *, nodep, nodep)) sc_inout(ctf_integer(struct getcpu_cache *, unused, unused))) -) -#endif -#ifndef OVERRIDE_32_signalfd -SC_LTTNG_TRACEPOINT_EVENT(signalfd, - TP_PROTO(sc_exit(long ret,) int ufd, sigset_t * user_mask, size_t sizemask), - TP_ARGS(sc_exit(ret,) ufd, user_mask, sizemask), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_in(ctf_integer(sigset_t *, user_mask, user_mask)) sc_in(ctf_integer(size_t, sizemask, sizemask))) -) -#endif -#ifndef OVERRIDE_32_open_by_handle_at -SC_LTTNG_TRACEPOINT_EVENT(open_by_handle_at, - TP_PROTO(sc_exit(long ret,) int mountdirfd, struct file_handle * handle, int flags), - TP_ARGS(sc_exit(ret,) mountdirfd, handle, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, mountdirfd, mountdirfd)) sc_in(ctf_integer(struct file_handle *, handle, handle)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_finit_module -SC_LTTNG_TRACEPOINT_EVENT(finit_module, - TP_PROTO(sc_exit(long ret,) int fd, const char * uargs, int flags), - TP_ARGS(sc_exit(ret,) fd, uargs, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(const char *, uargs, uargs)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_sched_setattr -SC_LTTNG_TRACEPOINT_EVENT(sched_setattr, - TP_PROTO(sc_exit(long ret,) pid_t pid, struct sched_attr * uattr, unsigned int flags), - TP_ARGS(sc_exit(ret,) pid, uattr, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(pid_t, pid, pid)) sc_inout(ctf_integer(struct sched_attr *, uattr, uattr)) sc_inout(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_seccomp -SC_LTTNG_TRACEPOINT_EVENT(seccomp, - TP_PROTO(sc_exit(long ret,) unsigned int op, unsigned int flags, const char * uargs), - TP_ARGS(sc_exit(ret,) op, flags, uargs), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, op, op)) sc_inout(ctf_integer(unsigned int, flags, flags)) sc_inout(ctf_integer(const char *, uargs, uargs))) -) -#endif -#ifndef OVERRIDE_32_getrandom -SC_LTTNG_TRACEPOINT_EVENT(getrandom, - TP_PROTO(sc_exit(long ret,) char * buf, size_t count, unsigned int flags), - TP_ARGS(sc_exit(ret,) buf, count, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(char *, buf, buf)) sc_inout(ctf_integer(size_t, count, count)) sc_inout(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_reboot -SC_LTTNG_TRACEPOINT_EVENT(reboot, - TP_PROTO(sc_exit(long ret,) int magic1, int magic2, unsigned int cmd, void * arg), - TP_ARGS(sc_exit(ret,) magic1, magic2, cmd, arg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, magic1, magic1)) sc_in(ctf_integer(int, magic2, magic2)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_in(ctf_integer(void *, arg, arg))) -) -#endif -#ifndef OVERRIDE_32_wait4 -SC_LTTNG_TRACEPOINT_EVENT(wait4, - TP_PROTO(sc_exit(long ret,) pid_t upid, int * stat_addr, int options, struct rusage * ru), - TP_ARGS(sc_exit(ret,) upid, stat_addr, options, ru), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, upid, upid)) sc_out(ctf_integer(int *, stat_addr, stat_addr)) sc_in(ctf_integer(int, options, options)) sc_out(ctf_integer(struct rusage *, ru, ru))) -) -#endif -#ifndef OVERRIDE_32_recv -SC_LTTNG_TRACEPOINT_EVENT(recv, - TP_PROTO(sc_exit(long ret,) int fd, void * ubuf, size_t size, unsigned int flags), - TP_ARGS(sc_exit(ret,) fd, ubuf, size, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, fd, fd)) sc_inout(ctf_integer(void *, ubuf, ubuf)) sc_inout(ctf_integer(size_t, size, size)) sc_inout(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_send -SC_LTTNG_TRACEPOINT_EVENT(send, - TP_PROTO(sc_exit(long ret,) int fd, void * buff, size_t len, unsigned int flags), - TP_ARGS(sc_exit(ret,) fd, buff, len, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, fd, fd)) sc_inout(ctf_integer(void *, buff, buff)) sc_inout(ctf_integer(size_t, len, len)) sc_inout(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_socketpair -SC_LTTNG_TRACEPOINT_EVENT(socketpair, - TP_PROTO(sc_exit(long ret,) int family, int type, int protocol, int * usockvec), - TP_ARGS(sc_exit(ret,) family, type, protocol, usockvec), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, family, family)) sc_in(ctf_integer(int, type, type)) sc_in(ctf_integer(int, protocol, protocol)) sc_out(ctf_integer(int *, usockvec, usockvec))) -) -#endif -#ifndef OVERRIDE_32_rt_sigaction -SC_LTTNG_TRACEPOINT_EVENT(rt_sigaction, - TP_PROTO(sc_exit(long ret,) int sig, const struct sigaction * act, struct sigaction * oact, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) sig, act, oact, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, sig, sig)) sc_in(ctf_integer(const struct sigaction *, act, act)) sc_out(ctf_integer(struct sigaction *, oact, oact)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) -) -#endif -#ifndef OVERRIDE_32_rt_sigprocmask -SC_LTTNG_TRACEPOINT_EVENT(rt_sigprocmask, - TP_PROTO(sc_exit(long ret,) int how, sigset_t * nset, sigset_t * oset, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) how, nset, oset, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, how, how)) sc_in(ctf_integer(sigset_t *, nset, nset)) sc_out(ctf_integer(sigset_t *, oset, oset)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) -) -#endif -#ifndef OVERRIDE_32_rt_sigtimedwait -SC_LTTNG_TRACEPOINT_EVENT(rt_sigtimedwait, - TP_PROTO(sc_exit(long ret,) const sigset_t * uthese, siginfo_t * uinfo, const struct timespec * uts, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) uthese, uinfo, uts, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(const sigset_t *, uthese, uthese)) sc_out(ctf_integer(siginfo_t *, uinfo, uinfo)) sc_in(ctf_integer(const struct timespec *, uts, uts)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) -) -#endif -#ifndef OVERRIDE_32_pread64 -SC_LTTNG_TRACEPOINT_EVENT(pread64, - TP_PROTO(sc_exit(long ret,) unsigned int fd, char * buf, size_t count, loff_t pos), - TP_ARGS(sc_exit(ret,) fd, buf, count, pos), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(size_t, count, count)) sc_in(ctf_integer(loff_t, pos, pos))) -) -#endif -#ifndef OVERRIDE_32_pwrite64 -SC_LTTNG_TRACEPOINT_EVENT(pwrite64, - TP_PROTO(sc_exit(long ret,) unsigned int fd, const char * buf, size_t count, loff_t pos), - TP_ARGS(sc_exit(ret,) fd, buf, count, pos), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(const char *, buf, buf)) sc_in(ctf_integer(size_t, count, count)) sc_in(ctf_integer(loff_t, pos, pos))) -) -#endif -#ifndef OVERRIDE_32_sendfile -SC_LTTNG_TRACEPOINT_EVENT(sendfile, - TP_PROTO(sc_exit(long ret,) int out_fd, int in_fd, off_t * offset, size_t count), - TP_ARGS(sc_exit(ret,) out_fd, in_fd, offset, count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, out_fd, out_fd)) sc_inout(ctf_integer(int, in_fd, in_fd)) sc_inout(ctf_integer(off_t *, offset, offset)) sc_inout(ctf_integer(size_t, count, count))) -) -#endif -#ifndef OVERRIDE_32_getxattr -SC_LTTNG_TRACEPOINT_EVENT(getxattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, void * value, size_t size), - TP_ARGS(sc_exit(ret,) pathname, name, value, size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_out(ctf_integer(void *, value, value)) sc_in(ctf_integer(size_t, size, size))) -) -#endif -#ifndef OVERRIDE_32_lgetxattr -SC_LTTNG_TRACEPOINT_EVENT(lgetxattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, void * value, size_t size), - TP_ARGS(sc_exit(ret,) pathname, name, value, size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_out(ctf_integer(void *, value, value)) sc_in(ctf_integer(size_t, size, size))) -) -#endif -#ifndef OVERRIDE_32_fgetxattr -SC_LTTNG_TRACEPOINT_EVENT(fgetxattr, - TP_PROTO(sc_exit(long ret,) int fd, const char * name, void * value, size_t size), - TP_ARGS(sc_exit(ret,) fd, name, value, size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(name, name)) sc_out(ctf_integer(void *, value, value)) sc_in(ctf_integer(size_t, size, size))) -) -#endif -#ifndef OVERRIDE_32_sendfile64 -SC_LTTNG_TRACEPOINT_EVENT(sendfile64, - TP_PROTO(sc_exit(long ret,) int out_fd, int in_fd, loff_t * offset, size_t count), - TP_ARGS(sc_exit(ret,) out_fd, in_fd, offset, count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, out_fd, out_fd)) sc_in(ctf_integer(int, in_fd, in_fd)) sc_inout(ctf_integer(loff_t *, offset, offset)) sc_in(ctf_integer(size_t, count, count))) -) -#endif -#ifndef OVERRIDE_32_epoll_ctl -SC_LTTNG_TRACEPOINT_EVENT(epoll_ctl, - TP_PROTO(sc_exit(long ret,) int epfd, int op, int fd, struct epoll_event * event), - TP_ARGS(sc_exit(ret,) epfd, op, fd, event), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, epfd, epfd)) sc_in(ctf_integer(int, op, op)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct epoll_event *, event, event))) -) -#endif -#ifndef OVERRIDE_32_epoll_wait -SC_LTTNG_TRACEPOINT_EVENT(epoll_wait, - TP_PROTO(sc_exit(long ret,) int epfd, struct epoll_event * events, int maxevents, int timeout), - TP_ARGS(sc_exit(ret,) epfd, events, maxevents, timeout), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, epfd, epfd)) sc_out(ctf_integer(struct epoll_event *, events, events)) sc_in(ctf_integer(int, maxevents, maxevents)) sc_in(ctf_integer(int, timeout, timeout))) -) -#endif -#ifndef OVERRIDE_32_timer_settime -SC_LTTNG_TRACEPOINT_EVENT(timer_settime, - TP_PROTO(sc_exit(long ret,) timer_t timer_id, int flags, const struct itimerspec * new_setting, struct itimerspec * old_setting), - TP_ARGS(sc_exit(ret,) timer_id, flags, new_setting, old_setting), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(const struct itimerspec *, new_setting, new_setting)) sc_out(ctf_integer(struct itimerspec *, old_setting, old_setting))) -) -#endif -#ifndef OVERRIDE_32_clock_nanosleep -SC_LTTNG_TRACEPOINT_EVENT(clock_nanosleep, - TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, int flags, const struct timespec * rqtp, struct timespec * rmtp), - TP_ARGS(sc_exit(ret,) which_clock, flags, rqtp, rmtp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(const struct timespec *, rqtp, rqtp)) sc_out(ctf_integer(struct timespec *, rmtp, rmtp))) -) -#endif -#ifndef OVERRIDE_32_openat -SC_LTTNG_TRACEPOINT_EVENT(openat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, int flags, umode_t mode), - TP_ARGS(sc_exit(ret,) dfd, filename, flags, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(umode_t, mode, mode))) -) -#endif -#ifndef OVERRIDE_32_mknodat -SC_LTTNG_TRACEPOINT_EVENT(mknodat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, umode_t mode, unsigned dev), - TP_ARGS(sc_exit(ret,) dfd, filename, mode, dev), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(umode_t, mode, mode)) sc_in(ctf_integer(unsigned, dev, dev))) -) -#endif -#ifndef OVERRIDE_32_fstatat64 -SC_LTTNG_TRACEPOINT_EVENT(fstatat64, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, struct stat64 * statbuf, int flag), - TP_ARGS(sc_exit(ret,) dfd, filename, statbuf, flag), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, dfd, dfd)) sc_inout(ctf_user_string(filename, filename)) sc_inout(ctf_integer(struct stat64 *, statbuf, statbuf)) sc_inout(ctf_integer(int, flag, flag))) -) -#endif -#ifndef OVERRIDE_32_renameat -SC_LTTNG_TRACEPOINT_EVENT(renameat, - TP_PROTO(sc_exit(long ret,) int olddfd, const char * oldname, int newdfd, const char * newname), - TP_ARGS(sc_exit(ret,) olddfd, oldname, newdfd, newname), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, olddfd, olddfd)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_integer(int, newdfd, newdfd)) sc_in(ctf_user_string(newname, newname))) -) -#endif -#ifndef OVERRIDE_32_readlinkat -SC_LTTNG_TRACEPOINT_EVENT(readlinkat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * pathname, char * buf, int bufsiz), - TP_ARGS(sc_exit(ret,) dfd, pathname, buf, bufsiz), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(int, bufsiz, bufsiz))) -) -#endif -#ifndef OVERRIDE_32_vmsplice -SC_LTTNG_TRACEPOINT_EVENT(vmsplice, - TP_PROTO(sc_exit(long ret,) int fd, const struct iovec * iov, unsigned long nr_segs, unsigned int flags), - TP_ARGS(sc_exit(ret,) fd, iov, nr_segs, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(const struct iovec *, iov, iov)) sc_in(ctf_integer(unsigned long, nr_segs, nr_segs)) sc_in(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_utimensat -SC_LTTNG_TRACEPOINT_EVENT(utimensat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, struct timespec * utimes, int flags), - TP_ARGS(sc_exit(ret,) dfd, filename, utimes, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(struct timespec *, utimes, utimes)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_timerfd_settime -SC_LTTNG_TRACEPOINT_EVENT(timerfd_settime, - TP_PROTO(sc_exit(long ret,) int ufd, int flags, const struct itimerspec * utmr, struct itimerspec * otmr), - TP_ARGS(sc_exit(ret,) ufd, flags, utmr, otmr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(const struct itimerspec *, utmr, utmr)) sc_out(ctf_integer(struct itimerspec *, otmr, otmr))) -) -#endif -#ifndef OVERRIDE_32_signalfd4 -SC_LTTNG_TRACEPOINT_EVENT(signalfd4, - TP_PROTO(sc_exit(long ret,) int ufd, sigset_t * user_mask, size_t sizemask, int flags), - TP_ARGS(sc_exit(ret,) ufd, user_mask, sizemask, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_in(ctf_integer(sigset_t *, user_mask, user_mask)) sc_in(ctf_integer(size_t, sizemask, sizemask)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_rt_tgsigqueueinfo -SC_LTTNG_TRACEPOINT_EVENT(rt_tgsigqueueinfo, - TP_PROTO(sc_exit(long ret,) pid_t tgid, pid_t pid, int sig, siginfo_t * uinfo), - TP_ARGS(sc_exit(ret,) tgid, pid, sig, uinfo), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, tgid, tgid)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig)) sc_in(ctf_integer(siginfo_t *, uinfo, uinfo))) -) -#endif -#ifndef OVERRIDE_32_accept4 -SC_LTTNG_TRACEPOINT_EVENT(accept4, - TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * upeer_sockaddr, int * upeer_addrlen, int flags), - TP_ARGS(sc_exit(ret,) fd, upeer_sockaddr, upeer_addrlen, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct sockaddr *, upeer_sockaddr, upeer_sockaddr)) sc_inout(ctf_integer(int *, upeer_addrlen, upeer_addrlen)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_prlimit64 -SC_LTTNG_TRACEPOINT_EVENT(prlimit64, - TP_PROTO(sc_exit(long ret,) pid_t pid, unsigned int resource, const struct rlimit64 * new_rlim, struct rlimit64 * old_rlim), - TP_ARGS(sc_exit(ret,) pid, resource, new_rlim, old_rlim), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(unsigned int, resource, resource)) sc_in(ctf_integer(const struct rlimit64 *, new_rlim, new_rlim)) sc_out(ctf_integer(struct rlimit64 *, old_rlim, old_rlim))) -) -#endif -#ifndef OVERRIDE_32_sendmmsg -SC_LTTNG_TRACEPOINT_EVENT(sendmmsg, - TP_PROTO(sc_exit(long ret,) int fd, struct mmsghdr * mmsg, unsigned int vlen, unsigned int flags), - TP_ARGS(sc_exit(ret,) fd, mmsg, vlen, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct mmsghdr *, mmsg, mmsg)) sc_in(ctf_integer(unsigned int, vlen, vlen)) sc_in(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_sched_getattr -SC_LTTNG_TRACEPOINT_EVENT(sched_getattr, - TP_PROTO(sc_exit(long ret,) pid_t pid, struct sched_attr * uattr, unsigned int size, unsigned int flags), - TP_ARGS(sc_exit(ret,) pid, uattr, size, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(pid_t, pid, pid)) sc_inout(ctf_integer(struct sched_attr *, uattr, uattr)) sc_inout(ctf_integer(unsigned int, size, size)) sc_inout(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_mount -SC_LTTNG_TRACEPOINT_EVENT(mount, - TP_PROTO(sc_exit(long ret,) char * dev_name, char * dir_name, char * type, unsigned long flags, void * data), - TP_ARGS(sc_exit(ret,) dev_name, dir_name, type, flags, data), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(dev_name, dev_name)) sc_in(ctf_user_string(dir_name, dir_name)) sc_in(ctf_user_string(type, type)) sc_in(ctf_integer(unsigned long, flags, flags)) sc_in(ctf_integer(void *, data, data))) -) -#endif -#ifndef OVERRIDE_32_llseek -SC_LTTNG_TRACEPOINT_EVENT(llseek, - TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned long offset_high, unsigned long offset_low, loff_t * result, unsigned int whence), - TP_ARGS(sc_exit(ret,) fd, offset_high, offset_low, result, whence), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, fd, fd)) sc_inout(ctf_integer(unsigned long, offset_high, offset_high)) sc_inout(ctf_integer(unsigned long, offset_low, offset_low)) sc_inout(ctf_integer(loff_t *, result, result)) sc_inout(ctf_integer(unsigned int, whence, whence))) -) -#endif -#ifndef OVERRIDE_32_select -SC_LTTNG_TRACEPOINT_EVENT(select, - TP_PROTO(sc_exit(long ret,) int n, fd_set * inp, fd_set * outp, fd_set * exp, struct timeval * tvp), - TP_ARGS(sc_exit(ret,) n, inp, outp, exp, tvp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, n, n)) sc_inout(ctf_integer(fd_set *, inp, inp)) sc_inout(ctf_integer(fd_set *, outp, outp)) sc_inout(ctf_integer(fd_set *, exp, exp)) sc_inout(ctf_integer(struct timeval *, tvp, tvp))) -) -#endif -#ifndef OVERRIDE_32_getsockopt -SC_LTTNG_TRACEPOINT_EVENT(getsockopt, - TP_PROTO(sc_exit(long ret,) int fd, int level, int optname, char * optval, int * optlen), - TP_ARGS(sc_exit(ret,) fd, level, optname, optval, optlen), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, level, level)) sc_in(ctf_integer(int, optname, optname)) sc_out(ctf_integer(char *, optval, optval)) sc_inout(ctf_integer(int *, optlen, optlen))) -) -#endif -#ifndef OVERRIDE_32_setsockopt -SC_LTTNG_TRACEPOINT_EVENT(setsockopt, - TP_PROTO(sc_exit(long ret,) int fd, int level, int optname, char * optval, int optlen), - TP_ARGS(sc_exit(ret,) fd, level, optname, optval, optlen), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, level, level)) sc_in(ctf_integer(int, optname, optname)) sc_in(ctf_integer(char *, optval, optval)) sc_in(ctf_integer(int, optlen, optlen))) -) -#endif -#ifndef OVERRIDE_32_setxattr -SC_LTTNG_TRACEPOINT_EVENT(setxattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, const void * value, size_t size, int flags), - TP_ARGS(sc_exit(ret,) pathname, name, value, size, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(const void *, value, value)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_lsetxattr -SC_LTTNG_TRACEPOINT_EVENT(lsetxattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, const void * value, size_t size, int flags), - TP_ARGS(sc_exit(ret,) pathname, name, value, size, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(const void *, value, value)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_fsetxattr -SC_LTTNG_TRACEPOINT_EVENT(fsetxattr, - TP_PROTO(sc_exit(long ret,) int fd, const char * name, const void * value, size_t size, int flags), - TP_ARGS(sc_exit(ret,) fd, name, value, size, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(const void *, value, value)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_io_getevents -SC_LTTNG_TRACEPOINT_EVENT(io_getevents, - TP_PROTO(sc_exit(long ret,) aio_context_t ctx_id, long min_nr, long nr, struct io_event * events, struct timespec * timeout), - TP_ARGS(sc_exit(ret,) ctx_id, min_nr, nr, events, timeout), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx_id, ctx_id)) sc_in(ctf_integer(long, min_nr, min_nr)) sc_in(ctf_integer(long, nr, nr)) sc_out(ctf_integer(struct io_event *, events, events)) sc_inout(ctf_integer(struct timespec *, timeout, timeout))) -) -#endif -#ifndef OVERRIDE_32_waitid -SC_LTTNG_TRACEPOINT_EVENT(waitid, - TP_PROTO(sc_exit(long ret,) int which, pid_t upid, struct siginfo * infop, int options, struct rusage * ru), - TP_ARGS(sc_exit(ret,) which, upid, infop, options, ru), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(pid_t, upid, upid)) sc_out(ctf_integer(struct siginfo *, infop, infop)) sc_in(ctf_integer(int, options, options)) sc_out(ctf_integer(struct rusage *, ru, ru))) -) -#endif -#ifndef OVERRIDE_32_fchownat -SC_LTTNG_TRACEPOINT_EVENT(fchownat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, uid_t user, gid_t group, int flag), - TP_ARGS(sc_exit(ret,) dfd, filename, user, group, flag), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group)) sc_in(ctf_integer(int, flag, flag))) -) -#endif -#ifndef OVERRIDE_32_linkat -SC_LTTNG_TRACEPOINT_EVENT(linkat, - TP_PROTO(sc_exit(long ret,) int olddfd, const char * oldname, int newdfd, const char * newname, int flags), - TP_ARGS(sc_exit(ret,) olddfd, oldname, newdfd, newname, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, olddfd, olddfd)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_integer(int, newdfd, newdfd)) sc_in(ctf_user_string(newname, newname)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_ppoll -SC_LTTNG_TRACEPOINT_EVENT(ppoll, - TP_PROTO(sc_exit(long ret,) struct pollfd * ufds, unsigned int nfds, struct timespec * tsp, const sigset_t * sigmask, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) ufds, nfds, tsp, sigmask, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct pollfd *, ufds, ufds)) sc_in(ctf_integer(unsigned int, nfds, nfds)) sc_in(ctf_integer(struct timespec *, tsp, tsp)) sc_in(ctf_integer(const sigset_t *, sigmask, sigmask)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) -) -#endif -#ifndef OVERRIDE_32_preadv -SC_LTTNG_TRACEPOINT_EVENT(preadv, - TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen, unsigned long pos_l, unsigned long pos_h), - TP_ARGS(sc_exit(ret,) fd, vec, vlen, pos_l, pos_h), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_out(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen)) sc_in(ctf_integer(unsigned long, pos_l, pos_l)) sc_in(ctf_integer(unsigned long, pos_h, pos_h))) -) -#endif -#ifndef OVERRIDE_32_pwritev -SC_LTTNG_TRACEPOINT_EVENT(pwritev, - TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen, unsigned long pos_l, unsigned long pos_h), - TP_ARGS(sc_exit(ret,) fd, vec, vlen, pos_l, pos_h), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_in(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen)) sc_in(ctf_integer(unsigned long, pos_l, pos_l)) sc_in(ctf_integer(unsigned long, pos_h, pos_h))) -) -#endif -#ifndef OVERRIDE_32_perf_event_open -SC_LTTNG_TRACEPOINT_EVENT(perf_event_open, - TP_PROTO(sc_exit(long ret,) struct perf_event_attr * attr_uptr, pid_t pid, int cpu, int group_fd, unsigned long flags), - TP_ARGS(sc_exit(ret,) attr_uptr, pid, cpu, group_fd, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct perf_event_attr *, attr_uptr, attr_uptr)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, cpu, cpu)) sc_in(ctf_integer(int, group_fd, group_fd)) sc_in(ctf_integer(unsigned long, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_recvmmsg -SC_LTTNG_TRACEPOINT_EVENT(recvmmsg, - TP_PROTO(sc_exit(long ret,) int fd, struct mmsghdr * mmsg, unsigned int vlen, unsigned int flags, struct timespec * timeout), - TP_ARGS(sc_exit(ret,) fd, mmsg, vlen, flags, timeout), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct mmsghdr *, mmsg, mmsg)) sc_in(ctf_integer(unsigned int, vlen, vlen)) sc_in(ctf_integer(unsigned int, flags, flags)) sc_inout(ctf_integer(struct timespec *, timeout, timeout))) -) -#endif -#ifndef OVERRIDE_32_name_to_handle_at -SC_LTTNG_TRACEPOINT_EVENT(name_to_handle_at, - TP_PROTO(sc_exit(long ret,) int dfd, const char * name, struct file_handle * handle, int * mnt_id, int flag), - TP_ARGS(sc_exit(ret,) dfd, name, handle, mnt_id, flag), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(name, name)) sc_inout(ctf_integer(struct file_handle *, handle, handle)) sc_out(ctf_integer(int *, mnt_id, mnt_id)) sc_in(ctf_integer(int, flag, flag))) -) -#endif -#ifndef OVERRIDE_32_renameat2 -SC_LTTNG_TRACEPOINT_EVENT(renameat2, - TP_PROTO(sc_exit(long ret,) int olddfd, const char * oldname, int newdfd, const char * newname, unsigned int flags), - TP_ARGS(sc_exit(ret,) olddfd, oldname, newdfd, newname, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, olddfd, olddfd)) sc_inout(ctf_user_string(oldname, oldname)) sc_inout(ctf_integer(int, newdfd, newdfd)) sc_inout(ctf_user_string(newname, newname)) sc_inout(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_ipc -SC_LTTNG_TRACEPOINT_EVENT(ipc, - TP_PROTO(sc_exit(long ret,) unsigned int call, int first, unsigned long second, unsigned long third, void * ptr, long fifth), - TP_ARGS(sc_exit(ret,) call, first, second, third, ptr, fifth), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, call, call)) sc_inout(ctf_integer(int, first, first)) sc_inout(ctf_integer(unsigned long, second, second)) sc_inout(ctf_integer(unsigned long, third, third)) sc_inout(ctf_integer(void *, ptr, ptr)) sc_inout(ctf_integer(long, fifth, fifth))) -) -#endif -#ifndef OVERRIDE_32_recvfrom -SC_LTTNG_TRACEPOINT_EVENT(recvfrom, - TP_PROTO(sc_exit(long ret,) int fd, void * ubuf, size_t size, unsigned int flags, struct sockaddr * addr, int * addr_len), - TP_ARGS(sc_exit(ret,) fd, ubuf, size, flags, addr, addr_len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(void *, ubuf, ubuf)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(unsigned int, flags, flags)) sc_out(ctf_integer(struct sockaddr *, addr, addr)) sc_inout(ctf_integer(int *, addr_len, addr_len))) -) -#endif -#ifndef OVERRIDE_32_sendto -SC_LTTNG_TRACEPOINT_EVENT(sendto, - TP_PROTO(sc_exit(long ret,) int fd, void * buff, size_t len, unsigned int flags, struct sockaddr * addr, int addr_len), - TP_ARGS(sc_exit(ret,) fd, buff, len, flags, addr, addr_len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(void *, buff, buff)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned int, flags, flags)) sc_in(ctf_integer(struct sockaddr *, addr, addr)) sc_in(ctf_integer(int, addr_len, addr_len))) -) -#endif -#ifndef OVERRIDE_32_futex -SC_LTTNG_TRACEPOINT_EVENT(futex, - TP_PROTO(sc_exit(long ret,) u32 * uaddr, int op, u32 val, struct timespec * utime, u32 * uaddr2, u32 val3), - TP_ARGS(sc_exit(ret,) uaddr, op, val, utime, uaddr2, val3), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(u32 *, uaddr, uaddr)) sc_in(ctf_integer(int, op, op)) sc_in(ctf_integer(u32, val, val)) sc_in(ctf_integer(struct timespec *, utime, utime)) sc_inout(ctf_integer(u32 *, uaddr2, uaddr2)) sc_in(ctf_integer(u32, val3, val3))) -) -#endif -#ifndef OVERRIDE_32_pselect6 -SC_LTTNG_TRACEPOINT_EVENT(pselect6, - TP_PROTO(sc_exit(long ret,) int n, fd_set * inp, fd_set * outp, fd_set * exp, struct timespec * tsp, void * sig), - TP_ARGS(sc_exit(ret,) n, inp, outp, exp, tsp, sig), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, n, n)) sc_inout(ctf_integer(fd_set *, inp, inp)) sc_inout(ctf_integer(fd_set *, outp, outp)) sc_inout(ctf_integer(fd_set *, exp, exp)) sc_inout(ctf_integer(struct timespec *, tsp, tsp)) sc_in(ctf_integer(void *, sig, sig))) -) -#endif -#ifndef OVERRIDE_32_splice -SC_LTTNG_TRACEPOINT_EVENT(splice, - TP_PROTO(sc_exit(long ret,) int fd_in, loff_t * off_in, int fd_out, loff_t * off_out, size_t len, unsigned int flags), - TP_ARGS(sc_exit(ret,) fd_in, off_in, fd_out, off_out, len, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd_in, fd_in)) sc_in(ctf_integer(loff_t *, off_in, off_in)) sc_in(ctf_integer(int, fd_out, fd_out)) sc_in(ctf_integer(loff_t *, off_out, off_out)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_epoll_pwait -SC_LTTNG_TRACEPOINT_EVENT(epoll_pwait, - TP_PROTO(sc_exit(long ret,) int epfd, struct epoll_event * events, int maxevents, int timeout, const sigset_t * sigmask, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) epfd, events, maxevents, timeout, sigmask, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, epfd, epfd)) sc_out(ctf_integer(struct epoll_event *, events, events)) sc_in(ctf_integer(int, maxevents, maxevents)) sc_in(ctf_integer(int, timeout, timeout)) sc_in(ctf_integer(const sigset_t *, sigmask, sigmask)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) -) -#endif - -#endif /* _TRACE_SYSCALLS_POINTERS_H */ - -/* This part must be outside protection */ -#include - -#else /* CREATE_SYSCALL_TABLE */ - -#include "mips-32-syscalls_pointers_override.h" -#include "syscalls_pointers_override.h" - -#ifndef OVERRIDE_TABLE_32_read -TRACE_SYSCALL_TABLE(read, read, 4003, 3) -#endif -#ifndef OVERRIDE_TABLE_32_write -TRACE_SYSCALL_TABLE(write, write, 4004, 3) -#endif -#ifndef OVERRIDE_TABLE_32_open -TRACE_SYSCALL_TABLE(open, open, 4005, 3) -#endif -#ifndef OVERRIDE_TABLE_32_waitpid -TRACE_SYSCALL_TABLE(waitpid, waitpid, 4007, 3) -#endif -#ifndef OVERRIDE_TABLE_32_creat -TRACE_SYSCALL_TABLE(creat, creat, 4008, 2) -#endif -#ifndef OVERRIDE_TABLE_32_link -TRACE_SYSCALL_TABLE(link, link, 4009, 2) -#endif -#ifndef OVERRIDE_TABLE_32_unlink -TRACE_SYSCALL_TABLE(unlink, unlink, 4010, 1) -#endif -#ifndef OVERRIDE_TABLE_32_execve -TRACE_SYSCALL_TABLE(execve, execve, 4011, 3) -#endif -#ifndef OVERRIDE_TABLE_32_chdir -TRACE_SYSCALL_TABLE(chdir, chdir, 4012, 1) -#endif -#ifndef OVERRIDE_TABLE_32_time -TRACE_SYSCALL_TABLE(time, time, 4013, 1) -#endif -#ifndef OVERRIDE_TABLE_32_mknod -TRACE_SYSCALL_TABLE(mknod, mknod, 4014, 3) -#endif -#ifndef OVERRIDE_TABLE_32_chmod -TRACE_SYSCALL_TABLE(chmod, chmod, 4015, 2) -#endif -#ifndef OVERRIDE_TABLE_32_lchown -TRACE_SYSCALL_TABLE(lchown, lchown, 4016, 3) -#endif -#ifndef OVERRIDE_TABLE_32_mount -TRACE_SYSCALL_TABLE(mount, mount, 4021, 5) -#endif -#ifndef OVERRIDE_TABLE_32_oldumount -TRACE_SYSCALL_TABLE(oldumount, oldumount, 4022, 1) -#endif -#ifndef OVERRIDE_TABLE_32_stime -TRACE_SYSCALL_TABLE(stime, stime, 4025, 1) -#endif -#ifndef OVERRIDE_TABLE_32_utime -TRACE_SYSCALL_TABLE(utime, utime, 4030, 2) -#endif -#ifndef OVERRIDE_TABLE_32_access -TRACE_SYSCALL_TABLE(access, access, 4033, 2) -#endif -#ifndef OVERRIDE_TABLE_32_rename -TRACE_SYSCALL_TABLE(rename, rename, 4038, 2) -#endif -#ifndef OVERRIDE_TABLE_32_mkdir -TRACE_SYSCALL_TABLE(mkdir, mkdir, 4039, 2) -#endif -#ifndef OVERRIDE_TABLE_32_rmdir -TRACE_SYSCALL_TABLE(rmdir, rmdir, 4040, 1) -#endif -#ifndef OVERRIDE_TABLE_32_times -TRACE_SYSCALL_TABLE(times, times, 4043, 1) -#endif -#ifndef OVERRIDE_TABLE_32_umount -TRACE_SYSCALL_TABLE(umount, umount, 4052, 2) -#endif -#ifndef OVERRIDE_TABLE_32_olduname -TRACE_SYSCALL_TABLE(olduname, olduname, 4059, 1) -#endif -#ifndef OVERRIDE_TABLE_32_chroot -TRACE_SYSCALL_TABLE(chroot, chroot, 4061, 1) -#endif -#ifndef OVERRIDE_TABLE_32_ustat -TRACE_SYSCALL_TABLE(ustat, ustat, 4062, 2) -#endif -#ifndef OVERRIDE_TABLE_32_sigaction -TRACE_SYSCALL_TABLE(sigaction, sigaction, 4067, 3) -#endif -#ifndef OVERRIDE_TABLE_32_sigsuspend -TRACE_SYSCALL_TABLE(sigsuspend, sigsuspend, 4072, 1) -#endif -#ifndef OVERRIDE_TABLE_32_sigpending -TRACE_SYSCALL_TABLE(sigpending, sigpending, 4073, 1) -#endif -#ifndef OVERRIDE_TABLE_32_sethostname -TRACE_SYSCALL_TABLE(sethostname, sethostname, 4074, 2) -#endif -#ifndef OVERRIDE_TABLE_32_setrlimit -TRACE_SYSCALL_TABLE(setrlimit, setrlimit, 4075, 2) -#endif -#ifndef OVERRIDE_TABLE_32_getrlimit -TRACE_SYSCALL_TABLE(getrlimit, getrlimit, 4076, 2) -#endif -#ifndef OVERRIDE_TABLE_32_getrusage -TRACE_SYSCALL_TABLE(getrusage, getrusage, 4077, 2) -#endif -#ifndef OVERRIDE_TABLE_32_gettimeofday -TRACE_SYSCALL_TABLE(gettimeofday, gettimeofday, 4078, 2) -#endif -#ifndef OVERRIDE_TABLE_32_settimeofday -TRACE_SYSCALL_TABLE(settimeofday, settimeofday, 4079, 2) -#endif -#ifndef OVERRIDE_TABLE_32_getgroups -TRACE_SYSCALL_TABLE(getgroups, getgroups, 4080, 2) -#endif -#ifndef OVERRIDE_TABLE_32_setgroups -TRACE_SYSCALL_TABLE(setgroups, setgroups, 4081, 2) -#endif -#ifndef OVERRIDE_TABLE_32_symlink -TRACE_SYSCALL_TABLE(symlink, symlink, 4083, 2) -#endif -#ifndef OVERRIDE_TABLE_32_readlink -TRACE_SYSCALL_TABLE(readlink, readlink, 4085, 3) -#endif -#ifndef OVERRIDE_TABLE_32_reboot -TRACE_SYSCALL_TABLE(reboot, reboot, 4088, 4) -#endif -#ifndef OVERRIDE_TABLE_32_old_readdir -TRACE_SYSCALL_TABLE(old_readdir, old_readdir, 4089, 3) -#endif -#ifndef OVERRIDE_TABLE_32_truncate -TRACE_SYSCALL_TABLE(truncate, truncate, 4092, 2) -#endif -#ifndef OVERRIDE_TABLE_32_statfs -TRACE_SYSCALL_TABLE(statfs, statfs, 4099, 2) -#endif -#ifndef OVERRIDE_TABLE_32_fstatfs -TRACE_SYSCALL_TABLE(fstatfs, fstatfs, 4100, 2) -#endif -#ifndef OVERRIDE_TABLE_32_socketcall -TRACE_SYSCALL_TABLE(socketcall, socketcall, 4102, 2) -#endif -#ifndef OVERRIDE_TABLE_32_syslog -TRACE_SYSCALL_TABLE(syslog, syslog, 4103, 3) -#endif -#ifndef OVERRIDE_TABLE_32_setitimer -TRACE_SYSCALL_TABLE(setitimer, setitimer, 4104, 3) -#endif -#ifndef OVERRIDE_TABLE_32_getitimer -TRACE_SYSCALL_TABLE(getitimer, getitimer, 4105, 2) -#endif -#ifndef OVERRIDE_TABLE_32_newstat -TRACE_SYSCALL_TABLE(newstat, newstat, 4106, 2) -#endif -#ifndef OVERRIDE_TABLE_32_newlstat -TRACE_SYSCALL_TABLE(newlstat, newlstat, 4107, 2) -#endif -#ifndef OVERRIDE_TABLE_32_newfstat -TRACE_SYSCALL_TABLE(newfstat, newfstat, 4108, 2) -#endif -#ifndef OVERRIDE_TABLE_32_uname -TRACE_SYSCALL_TABLE(uname, uname, 4109, 1) -#endif -#ifndef OVERRIDE_TABLE_32_wait4 -TRACE_SYSCALL_TABLE(wait4, wait4, 4114, 4) -#endif -#ifndef OVERRIDE_TABLE_32_sysinfo -TRACE_SYSCALL_TABLE(sysinfo, sysinfo, 4116, 1) -#endif -#ifndef OVERRIDE_TABLE_32_ipc -TRACE_SYSCALL_TABLE(ipc, ipc, 4117, 6) -#endif -#ifndef OVERRIDE_TABLE_32_setdomainname -TRACE_SYSCALL_TABLE(setdomainname, setdomainname, 4121, 2) -#endif -#ifndef OVERRIDE_TABLE_32_newuname -TRACE_SYSCALL_TABLE(newuname, newuname, 4122, 1) -#endif -#ifndef OVERRIDE_TABLE_32_adjtimex -TRACE_SYSCALL_TABLE(adjtimex, adjtimex, 4124, 1) -#endif -#ifndef OVERRIDE_TABLE_32_sigprocmask -TRACE_SYSCALL_TABLE(sigprocmask, sigprocmask, 4126, 3) -#endif -#ifndef OVERRIDE_TABLE_32_init_module -TRACE_SYSCALL_TABLE(init_module, init_module, 4128, 3) -#endif -#ifndef OVERRIDE_TABLE_32_delete_module -TRACE_SYSCALL_TABLE(delete_module, delete_module, 4129, 2) -#endif -#ifndef OVERRIDE_TABLE_32_llseek -TRACE_SYSCALL_TABLE(llseek, llseek, 4140, 5) -#endif -#ifndef OVERRIDE_TABLE_32_getdents -TRACE_SYSCALL_TABLE(getdents, getdents, 4141, 3) -#endif -#ifndef OVERRIDE_TABLE_32_select -TRACE_SYSCALL_TABLE(select, select, 4142, 5) -#endif -#ifndef OVERRIDE_TABLE_32_readv -TRACE_SYSCALL_TABLE(readv, readv, 4145, 3) -#endif -#ifndef OVERRIDE_TABLE_32_writev -TRACE_SYSCALL_TABLE(writev, writev, 4146, 3) -#endif -#ifndef OVERRIDE_TABLE_32_cachectl -TRACE_SYSCALL_TABLE(cachectl, cachectl, 4148, 3) -#endif -#ifndef OVERRIDE_TABLE_32_sysctl -TRACE_SYSCALL_TABLE(sysctl, sysctl, 4153, 1) -#endif -#ifndef OVERRIDE_TABLE_32_sched_setparam -TRACE_SYSCALL_TABLE(sched_setparam, sched_setparam, 4158, 2) -#endif -#ifndef OVERRIDE_TABLE_32_sched_getparam -TRACE_SYSCALL_TABLE(sched_getparam, sched_getparam, 4159, 2) -#endif -#ifndef OVERRIDE_TABLE_32_sched_setscheduler -TRACE_SYSCALL_TABLE(sched_setscheduler, sched_setscheduler, 4160, 3) -#endif -#ifndef OVERRIDE_TABLE_32_sched_rr_get_interval -TRACE_SYSCALL_TABLE(sched_rr_get_interval, sched_rr_get_interval, 4165, 2) -#endif -#ifndef OVERRIDE_TABLE_32_nanosleep -TRACE_SYSCALL_TABLE(nanosleep, nanosleep, 4166, 2) -#endif -#ifndef OVERRIDE_TABLE_32_accept -TRACE_SYSCALL_TABLE(accept, accept, 4168, 3) -#endif -#ifndef OVERRIDE_TABLE_32_bind -TRACE_SYSCALL_TABLE(bind, bind, 4169, 3) -#endif -#ifndef OVERRIDE_TABLE_32_connect -TRACE_SYSCALL_TABLE(connect, connect, 4170, 3) -#endif -#ifndef OVERRIDE_TABLE_32_getpeername -TRACE_SYSCALL_TABLE(getpeername, getpeername, 4171, 3) -#endif -#ifndef OVERRIDE_TABLE_32_getsockname -TRACE_SYSCALL_TABLE(getsockname, getsockname, 4172, 3) -#endif -#ifndef OVERRIDE_TABLE_32_getsockopt -TRACE_SYSCALL_TABLE(getsockopt, getsockopt, 4173, 5) -#endif -#ifndef OVERRIDE_TABLE_32_recv -TRACE_SYSCALL_TABLE(recv, recv, 4175, 4) -#endif -#ifndef OVERRIDE_TABLE_32_recvfrom -TRACE_SYSCALL_TABLE(recvfrom, recvfrom, 4176, 6) -#endif -#ifndef OVERRIDE_TABLE_32_recvmsg -TRACE_SYSCALL_TABLE(recvmsg, recvmsg, 4177, 3) -#endif -#ifndef OVERRIDE_TABLE_32_send -TRACE_SYSCALL_TABLE(send, send, 4178, 4) -#endif -#ifndef OVERRIDE_TABLE_32_sendmsg -TRACE_SYSCALL_TABLE(sendmsg, sendmsg, 4179, 3) -#endif -#ifndef OVERRIDE_TABLE_32_sendto -TRACE_SYSCALL_TABLE(sendto, sendto, 4180, 6) -#endif -#ifndef OVERRIDE_TABLE_32_setsockopt -TRACE_SYSCALL_TABLE(setsockopt, setsockopt, 4181, 5) -#endif -#ifndef OVERRIDE_TABLE_32_socketpair -TRACE_SYSCALL_TABLE(socketpair, socketpair, 4184, 4) -#endif -#ifndef OVERRIDE_TABLE_32_getresuid -TRACE_SYSCALL_TABLE(getresuid, getresuid, 4186, 3) -#endif -#ifndef OVERRIDE_TABLE_32_poll -TRACE_SYSCALL_TABLE(poll, poll, 4188, 3) -#endif -#ifndef OVERRIDE_TABLE_32_getresgid -TRACE_SYSCALL_TABLE(getresgid, getresgid, 4191, 3) -#endif -#ifndef OVERRIDE_TABLE_32_rt_sigaction -TRACE_SYSCALL_TABLE(rt_sigaction, rt_sigaction, 4194, 4) -#endif -#ifndef OVERRIDE_TABLE_32_rt_sigprocmask -TRACE_SYSCALL_TABLE(rt_sigprocmask, rt_sigprocmask, 4195, 4) -#endif -#ifndef OVERRIDE_TABLE_32_rt_sigpending -TRACE_SYSCALL_TABLE(rt_sigpending, rt_sigpending, 4196, 2) -#endif -#ifndef OVERRIDE_TABLE_32_rt_sigtimedwait -TRACE_SYSCALL_TABLE(rt_sigtimedwait, rt_sigtimedwait, 4197, 4) -#endif -#ifndef OVERRIDE_TABLE_32_rt_sigqueueinfo -TRACE_SYSCALL_TABLE(rt_sigqueueinfo, rt_sigqueueinfo, 4198, 3) -#endif -#ifndef OVERRIDE_TABLE_32_rt_sigsuspend -TRACE_SYSCALL_TABLE(rt_sigsuspend, rt_sigsuspend, 4199, 2) -#endif -#ifndef OVERRIDE_TABLE_32_pread64 -TRACE_SYSCALL_TABLE(pread64, pread64, 4200, 4) -#endif -#ifndef OVERRIDE_TABLE_32_pwrite64 -TRACE_SYSCALL_TABLE(pwrite64, pwrite64, 4201, 4) -#endif -#ifndef OVERRIDE_TABLE_32_chown -TRACE_SYSCALL_TABLE(chown, chown, 4202, 3) -#endif -#ifndef OVERRIDE_TABLE_32_getcwd -TRACE_SYSCALL_TABLE(getcwd, getcwd, 4203, 2) -#endif -#ifndef OVERRIDE_TABLE_32_sigaltstack -TRACE_SYSCALL_TABLE(sigaltstack, sigaltstack, 4206, 2) -#endif -#ifndef OVERRIDE_TABLE_32_sendfile -TRACE_SYSCALL_TABLE(sendfile, sendfile, 4207, 4) -#endif -#ifndef OVERRIDE_TABLE_32_truncate64 -TRACE_SYSCALL_TABLE(truncate64, truncate64, 4211, 2) -#endif -#ifndef OVERRIDE_TABLE_32_stat64 -TRACE_SYSCALL_TABLE(stat64, stat64, 4213, 2) -#endif -#ifndef OVERRIDE_TABLE_32_lstat64 -TRACE_SYSCALL_TABLE(lstat64, lstat64, 4214, 2) -#endif -#ifndef OVERRIDE_TABLE_32_fstat64 -TRACE_SYSCALL_TABLE(fstat64, fstat64, 4215, 2) -#endif -#ifndef OVERRIDE_TABLE_32_pivot_root -TRACE_SYSCALL_TABLE(pivot_root, pivot_root, 4216, 2) -#endif -#ifndef OVERRIDE_TABLE_32_mincore -TRACE_SYSCALL_TABLE(mincore, mincore, 4217, 3) -#endif -#ifndef OVERRIDE_TABLE_32_getdents64 -TRACE_SYSCALL_TABLE(getdents64, getdents64, 4219, 3) -#endif -#ifndef OVERRIDE_TABLE_32_setxattr -TRACE_SYSCALL_TABLE(setxattr, setxattr, 4224, 5) -#endif -#ifndef OVERRIDE_TABLE_32_lsetxattr -TRACE_SYSCALL_TABLE(lsetxattr, lsetxattr, 4225, 5) -#endif -#ifndef OVERRIDE_TABLE_32_fsetxattr -TRACE_SYSCALL_TABLE(fsetxattr, fsetxattr, 4226, 5) -#endif -#ifndef OVERRIDE_TABLE_32_getxattr -TRACE_SYSCALL_TABLE(getxattr, getxattr, 4227, 4) -#endif -#ifndef OVERRIDE_TABLE_32_lgetxattr -TRACE_SYSCALL_TABLE(lgetxattr, lgetxattr, 4228, 4) -#endif -#ifndef OVERRIDE_TABLE_32_fgetxattr -TRACE_SYSCALL_TABLE(fgetxattr, fgetxattr, 4229, 4) -#endif -#ifndef OVERRIDE_TABLE_32_listxattr -TRACE_SYSCALL_TABLE(listxattr, listxattr, 4230, 3) -#endif -#ifndef OVERRIDE_TABLE_32_llistxattr -TRACE_SYSCALL_TABLE(llistxattr, llistxattr, 4231, 3) -#endif -#ifndef OVERRIDE_TABLE_32_flistxattr -TRACE_SYSCALL_TABLE(flistxattr, flistxattr, 4232, 3) -#endif -#ifndef OVERRIDE_TABLE_32_removexattr -TRACE_SYSCALL_TABLE(removexattr, removexattr, 4233, 2) -#endif -#ifndef OVERRIDE_TABLE_32_lremovexattr -TRACE_SYSCALL_TABLE(lremovexattr, lremovexattr, 4234, 2) -#endif -#ifndef OVERRIDE_TABLE_32_fremovexattr -TRACE_SYSCALL_TABLE(fremovexattr, fremovexattr, 4235, 2) -#endif -#ifndef OVERRIDE_TABLE_32_sendfile64 -TRACE_SYSCALL_TABLE(sendfile64, sendfile64, 4237, 4) -#endif -#ifndef OVERRIDE_TABLE_32_futex -TRACE_SYSCALL_TABLE(futex, futex, 4238, 6) -#endif -#ifndef OVERRIDE_TABLE_32_io_setup -TRACE_SYSCALL_TABLE(io_setup, io_setup, 4241, 2) -#endif -#ifndef OVERRIDE_TABLE_32_io_getevents -TRACE_SYSCALL_TABLE(io_getevents, io_getevents, 4243, 5) -#endif -#ifndef OVERRIDE_TABLE_32_io_submit -TRACE_SYSCALL_TABLE(io_submit, io_submit, 4244, 3) -#endif -#ifndef OVERRIDE_TABLE_32_io_cancel -TRACE_SYSCALL_TABLE(io_cancel, io_cancel, 4245, 3) -#endif -#ifndef OVERRIDE_TABLE_32_epoll_ctl -TRACE_SYSCALL_TABLE(epoll_ctl, epoll_ctl, 4249, 4) -#endif -#ifndef OVERRIDE_TABLE_32_epoll_wait -TRACE_SYSCALL_TABLE(epoll_wait, epoll_wait, 4250, 4) -#endif -#ifndef OVERRIDE_TABLE_32_set_tid_address -TRACE_SYSCALL_TABLE(set_tid_address, set_tid_address, 4252, 1) -#endif -#ifndef OVERRIDE_TABLE_32_statfs64 -TRACE_SYSCALL_TABLE(statfs64, statfs64, 4255, 3) -#endif -#ifndef OVERRIDE_TABLE_32_fstatfs64 -TRACE_SYSCALL_TABLE(fstatfs64, fstatfs64, 4256, 3) -#endif -#ifndef OVERRIDE_TABLE_32_timer_create -TRACE_SYSCALL_TABLE(timer_create, timer_create, 4257, 3) -#endif -#ifndef OVERRIDE_TABLE_32_timer_settime -TRACE_SYSCALL_TABLE(timer_settime, timer_settime, 4258, 4) -#endif -#ifndef OVERRIDE_TABLE_32_timer_gettime -TRACE_SYSCALL_TABLE(timer_gettime, timer_gettime, 4259, 2) -#endif -#ifndef OVERRIDE_TABLE_32_clock_settime -TRACE_SYSCALL_TABLE(clock_settime, clock_settime, 4262, 2) -#endif -#ifndef OVERRIDE_TABLE_32_clock_gettime -TRACE_SYSCALL_TABLE(clock_gettime, clock_gettime, 4263, 2) -#endif -#ifndef OVERRIDE_TABLE_32_clock_getres -TRACE_SYSCALL_TABLE(clock_getres, clock_getres, 4264, 2) -#endif -#ifndef OVERRIDE_TABLE_32_clock_nanosleep -TRACE_SYSCALL_TABLE(clock_nanosleep, clock_nanosleep, 4265, 4) -#endif -#ifndef OVERRIDE_TABLE_32_utimes -TRACE_SYSCALL_TABLE(utimes, utimes, 4267, 2) -#endif -#ifndef OVERRIDE_TABLE_32_waitid -TRACE_SYSCALL_TABLE(waitid, waitid, 4278, 5) -#endif -#ifndef OVERRIDE_TABLE_32_inotify_add_watch -TRACE_SYSCALL_TABLE(inotify_add_watch, inotify_add_watch, 4285, 3) -#endif -#ifndef OVERRIDE_TABLE_32_openat -TRACE_SYSCALL_TABLE(openat, openat, 4288, 4) -#endif -#ifndef OVERRIDE_TABLE_32_mkdirat -TRACE_SYSCALL_TABLE(mkdirat, mkdirat, 4289, 3) -#endif -#ifndef OVERRIDE_TABLE_32_mknodat -TRACE_SYSCALL_TABLE(mknodat, mknodat, 4290, 4) -#endif -#ifndef OVERRIDE_TABLE_32_fchownat -TRACE_SYSCALL_TABLE(fchownat, fchownat, 4291, 5) -#endif -#ifndef OVERRIDE_TABLE_32_futimesat -TRACE_SYSCALL_TABLE(futimesat, futimesat, 4292, 3) -#endif -#ifndef OVERRIDE_TABLE_32_fstatat64 -TRACE_SYSCALL_TABLE(fstatat64, fstatat64, 4293, 4) -#endif -#ifndef OVERRIDE_TABLE_32_unlinkat -TRACE_SYSCALL_TABLE(unlinkat, unlinkat, 4294, 3) -#endif -#ifndef OVERRIDE_TABLE_32_renameat -TRACE_SYSCALL_TABLE(renameat, renameat, 4295, 4) -#endif -#ifndef OVERRIDE_TABLE_32_linkat -TRACE_SYSCALL_TABLE(linkat, linkat, 4296, 5) -#endif -#ifndef OVERRIDE_TABLE_32_symlinkat -TRACE_SYSCALL_TABLE(symlinkat, symlinkat, 4297, 3) -#endif -#ifndef OVERRIDE_TABLE_32_readlinkat -TRACE_SYSCALL_TABLE(readlinkat, readlinkat, 4298, 4) -#endif -#ifndef OVERRIDE_TABLE_32_fchmodat -TRACE_SYSCALL_TABLE(fchmodat, fchmodat, 4299, 3) -#endif -#ifndef OVERRIDE_TABLE_32_faccessat -TRACE_SYSCALL_TABLE(faccessat, faccessat, 4300, 3) -#endif -#ifndef OVERRIDE_TABLE_32_pselect6 -TRACE_SYSCALL_TABLE(pselect6, pselect6, 4301, 6) -#endif -#ifndef OVERRIDE_TABLE_32_ppoll -TRACE_SYSCALL_TABLE(ppoll, ppoll, 4302, 5) -#endif -#ifndef OVERRIDE_TABLE_32_splice -TRACE_SYSCALL_TABLE(splice, splice, 4304, 6) -#endif -#ifndef OVERRIDE_TABLE_32_vmsplice -TRACE_SYSCALL_TABLE(vmsplice, vmsplice, 4307, 4) -#endif -#ifndef OVERRIDE_TABLE_32_set_robust_list -TRACE_SYSCALL_TABLE(set_robust_list, set_robust_list, 4309, 2) -#endif -#ifndef OVERRIDE_TABLE_32_get_robust_list -TRACE_SYSCALL_TABLE(get_robust_list, get_robust_list, 4310, 3) -#endif -#ifndef OVERRIDE_TABLE_32_getcpu -TRACE_SYSCALL_TABLE(getcpu, getcpu, 4312, 3) -#endif -#ifndef OVERRIDE_TABLE_32_epoll_pwait -TRACE_SYSCALL_TABLE(epoll_pwait, epoll_pwait, 4313, 6) -#endif -#ifndef OVERRIDE_TABLE_32_utimensat -TRACE_SYSCALL_TABLE(utimensat, utimensat, 4316, 4) -#endif -#ifndef OVERRIDE_TABLE_32_signalfd -TRACE_SYSCALL_TABLE(signalfd, signalfd, 4317, 3) -#endif -#ifndef OVERRIDE_TABLE_32_timerfd_gettime -TRACE_SYSCALL_TABLE(timerfd_gettime, timerfd_gettime, 4322, 2) -#endif -#ifndef OVERRIDE_TABLE_32_timerfd_settime -TRACE_SYSCALL_TABLE(timerfd_settime, timerfd_settime, 4323, 4) -#endif -#ifndef OVERRIDE_TABLE_32_signalfd4 -TRACE_SYSCALL_TABLE(signalfd4, signalfd4, 4324, 4) -#endif -#ifndef OVERRIDE_TABLE_32_pipe2 -TRACE_SYSCALL_TABLE(pipe2, pipe2, 4328, 2) -#endif -#ifndef OVERRIDE_TABLE_32_preadv -TRACE_SYSCALL_TABLE(preadv, preadv, 4330, 5) -#endif -#ifndef OVERRIDE_TABLE_32_pwritev -TRACE_SYSCALL_TABLE(pwritev, pwritev, 4331, 5) -#endif -#ifndef OVERRIDE_TABLE_32_rt_tgsigqueueinfo -TRACE_SYSCALL_TABLE(rt_tgsigqueueinfo, rt_tgsigqueueinfo, 4332, 4) -#endif -#ifndef OVERRIDE_TABLE_32_perf_event_open -TRACE_SYSCALL_TABLE(perf_event_open, perf_event_open, 4333, 5) -#endif -#ifndef OVERRIDE_TABLE_32_accept4 -TRACE_SYSCALL_TABLE(accept4, accept4, 4334, 4) -#endif -#ifndef OVERRIDE_TABLE_32_recvmmsg -TRACE_SYSCALL_TABLE(recvmmsg, recvmmsg, 4335, 5) -#endif -#ifndef OVERRIDE_TABLE_32_prlimit64 -TRACE_SYSCALL_TABLE(prlimit64, prlimit64, 4338, 4) -#endif -#ifndef OVERRIDE_TABLE_32_name_to_handle_at -TRACE_SYSCALL_TABLE(name_to_handle_at, name_to_handle_at, 4339, 5) -#endif -#ifndef OVERRIDE_TABLE_32_open_by_handle_at -TRACE_SYSCALL_TABLE(open_by_handle_at, open_by_handle_at, 4340, 3) -#endif -#ifndef OVERRIDE_TABLE_32_clock_adjtime -TRACE_SYSCALL_TABLE(clock_adjtime, clock_adjtime, 4341, 2) -#endif -#ifndef OVERRIDE_TABLE_32_sendmmsg -TRACE_SYSCALL_TABLE(sendmmsg, sendmmsg, 4343, 4) -#endif -#ifndef OVERRIDE_TABLE_32_finit_module -TRACE_SYSCALL_TABLE(finit_module, finit_module, 4348, 3) -#endif -#ifndef OVERRIDE_TABLE_32_sched_setattr -TRACE_SYSCALL_TABLE(sched_setattr, sched_setattr, 4349, 3) -#endif -#ifndef OVERRIDE_TABLE_32_sched_getattr -TRACE_SYSCALL_TABLE(sched_getattr, sched_getattr, 4350, 4) -#endif -#ifndef OVERRIDE_TABLE_32_renameat2 -TRACE_SYSCALL_TABLE(renameat2, renameat2, 4351, 5) -#endif -#ifndef OVERRIDE_TABLE_32_seccomp -TRACE_SYSCALL_TABLE(seccomp, seccomp, 4352, 3) -#endif -#ifndef OVERRIDE_TABLE_32_getrandom -TRACE_SYSCALL_TABLE(getrandom, getrandom, 4353, 3) -#endif -#ifndef OVERRIDE_TABLE_32_memfd_create -TRACE_SYSCALL_TABLE(memfd_create, memfd_create, 4354, 2) -#endif - -#endif /* CREATE_SYSCALL_TABLE */ diff --git a/instrumentation/syscalls/headers/mips-32-syscalls_pointers_override.h b/instrumentation/syscalls/headers/mips-32-syscalls_pointers_override.h deleted file mode 100644 index 9a38fb5a..00000000 --- a/instrumentation/syscalls/headers/mips-32-syscalls_pointers_override.h +++ /dev/null @@ -1,30 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ - -#ifndef CREATE_SYSCALL_TABLE - -#define OVERRIDE_32_sched_setaffinity -SC_LTTNG_TRACEPOINT_EVENT(sched_setaffinity, - TP_PROTO(sc_exit(long ret,) pid_t pid, unsigned int len, unsigned long * user_mask_ptr), - TP_ARGS(sc_exit(ret,) pid, len, user_mask_ptr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(unsigned int, len, len)) sc_in(ctf_integer(unsigned long *, user_mask_ptr, user_mask_ptr))) -) - -#define OVERRIDE_32_sched_getaffinity -SC_LTTNG_TRACEPOINT_EVENT(sched_getaffinity, - TP_PROTO(sc_exit(long ret,) pid_t pid, unsigned int len, unsigned long * user_mask_ptr), - TP_ARGS(sc_exit(ret,) pid, len, user_mask_ptr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(unsigned int, len, len)) sc_out(ctf_integer(unsigned long *, user_mask_ptr, user_mask_ptr))) -) - -#else /* CREATE_SYSCALL_TABLE */ - -#define OVERRIDE_TABLE_32_clone -TRACE_SYSCALL_TABLE(clone, clone, 4120, 0) - -#define OVERRIDE_TABLE_32_sys_sched_setaffinity -TRACE_SYSCALL_TABLE(sched_setaffinity, sched_setaffinity, 4239, 3) - -#define OVERRIDE_TABLE_32_sys_sched_getaffinity -TRACE_SYSCALL_TABLE(sched_getaffinity, sched_getaffinity, 4240, 3) - -#endif /* CREATE_SYSCALL_TABLE */ diff --git a/instrumentation/syscalls/headers/mips-64-syscalls_integers.h b/instrumentation/syscalls/headers/mips-64-syscalls_integers.h deleted file mode 100644 index 302a788d..00000000 --- a/instrumentation/syscalls/headers/mips-64-syscalls_integers.h +++ /dev/null @@ -1,1170 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ - -/* THIS FILE IS AUTO-GENERATED. DO NOT EDIT */ - -/* Generated from mips-64-syscalls 3.5.0 */ - -#ifndef CREATE_SYSCALL_TABLE - -#if !defined(_TRACE_SYSCALLS_INTEGERS_H) || defined(TRACE_HEADER_MULTI_READ) -#define _TRACE_SYSCALLS_INTEGERS_H - -#include -#include -#include "mips-64-syscalls_integers_override.h" -#include "syscalls_integers_override.h" - -#ifdef SC_ENTER -SC_LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(syscalls_noargs, - TP_FIELDS() -) -#ifndef OVERRIDE_64_sgetmask -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, sgetmask) -#endif -#ifndef OVERRIDE_64_sched_yield -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, sched_yield) -#endif -#ifndef OVERRIDE_64_pause -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, pause) -#endif -#ifndef OVERRIDE_64_getpid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getpid) -#endif -#ifndef OVERRIDE_64_getuid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getuid) -#endif -#ifndef OVERRIDE_64_getgid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getgid) -#endif -#ifndef OVERRIDE_64_geteuid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, geteuid) -#endif -#ifndef OVERRIDE_64_getegid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getegid) -#endif -#ifndef OVERRIDE_64_getppid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getppid) -#endif -#ifndef OVERRIDE_64_getpgrp -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getpgrp) -#endif -#ifndef OVERRIDE_64_setsid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, setsid) -#endif -#ifndef OVERRIDE_64_munlockall -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, munlockall) -#endif -#ifndef OVERRIDE_64_vhangup -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, vhangup) -#endif -#ifndef OVERRIDE_64_sync -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, sync) -#endif -#ifndef OVERRIDE_64_gettid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, gettid) -#endif -#ifndef OVERRIDE_64_restart_syscall -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, restart_syscall) -#endif -#ifndef OVERRIDE_64_inotify_init -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, inotify_init) -#endif -#else /* #ifdef SC_ENTER */ -#ifndef OVERRIDE_64_sgetmask -SC_LTTNG_TRACEPOINT_EVENT(sgetmask, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_64_sched_yield -SC_LTTNG_TRACEPOINT_EVENT(sched_yield, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_64_pause -SC_LTTNG_TRACEPOINT_EVENT(pause, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_64_getpid -SC_LTTNG_TRACEPOINT_EVENT(getpid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_64_getuid -SC_LTTNG_TRACEPOINT_EVENT(getuid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_64_getgid -SC_LTTNG_TRACEPOINT_EVENT(getgid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_64_geteuid -SC_LTTNG_TRACEPOINT_EVENT(geteuid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_64_getegid -SC_LTTNG_TRACEPOINT_EVENT(getegid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_64_getppid -SC_LTTNG_TRACEPOINT_EVENT(getppid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_64_getpgrp -SC_LTTNG_TRACEPOINT_EVENT(getpgrp, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_64_setsid -SC_LTTNG_TRACEPOINT_EVENT(setsid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_64_munlockall -SC_LTTNG_TRACEPOINT_EVENT(munlockall, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_64_vhangup -SC_LTTNG_TRACEPOINT_EVENT(vhangup, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_64_sync -SC_LTTNG_TRACEPOINT_EVENT(sync, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_64_gettid -SC_LTTNG_TRACEPOINT_EVENT(gettid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_64_restart_syscall -SC_LTTNG_TRACEPOINT_EVENT(restart_syscall, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_64_inotify_init -SC_LTTNG_TRACEPOINT_EVENT(inotify_init, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#endif /* else #ifdef SC_ENTER */ -#ifndef OVERRIDE_64_nice -SC_LTTNG_TRACEPOINT_EVENT(nice, - TP_PROTO(sc_exit(long ret,) int increment), - TP_ARGS(sc_exit(ret,) increment), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, increment, increment))) -) -#endif -#ifndef OVERRIDE_64_ssetmask -SC_LTTNG_TRACEPOINT_EVENT(ssetmask, - TP_PROTO(sc_exit(long ret,) int newmask), - TP_ARGS(sc_exit(ret,) newmask), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, newmask, newmask))) -) -#endif -#ifndef OVERRIDE_64_personality -SC_LTTNG_TRACEPOINT_EVENT(personality, - TP_PROTO(sc_exit(long ret,) unsigned int personality), - TP_ARGS(sc_exit(ret,) personality), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, personality, personality))) -) -#endif -#ifndef OVERRIDE_64_close -SC_LTTNG_TRACEPOINT_EVENT(close, - TP_PROTO(sc_exit(long ret,) unsigned int fd), - TP_ARGS(sc_exit(ret,) fd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) -) -#endif -#ifndef OVERRIDE_64_brk -SC_LTTNG_TRACEPOINT_EVENT(brk, - TP_PROTO(sc_exit(long ret,) unsigned long brk), - TP_ARGS(sc_exit(ret,) brk), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, brk, brk))) -) -#endif -#ifndef OVERRIDE_64_dup -SC_LTTNG_TRACEPOINT_EVENT(dup, - TP_PROTO(sc_exit(long ret,) unsigned int fildes), - TP_ARGS(sc_exit(ret,) fildes), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fildes, fildes))) -) -#endif -#ifndef OVERRIDE_64_alarm -SC_LTTNG_TRACEPOINT_EVENT(alarm, - TP_PROTO(sc_exit(long ret,) unsigned int seconds), - TP_ARGS(sc_exit(ret,) seconds), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, seconds, seconds))) -) -#endif -#ifndef OVERRIDE_64_exit -SC_LTTNG_TRACEPOINT_EVENT(exit, - TP_PROTO(sc_exit(long ret,) int error_code), - TP_ARGS(sc_exit(ret,) error_code), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, error_code, error_code))) -) -#endif -#ifndef OVERRIDE_64_fsync -SC_LTTNG_TRACEPOINT_EVENT(fsync, - TP_PROTO(sc_exit(long ret,) unsigned int fd), - TP_ARGS(sc_exit(ret,) fd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) -) -#endif -#ifndef OVERRIDE_64_fdatasync -SC_LTTNG_TRACEPOINT_EVENT(fdatasync, - TP_PROTO(sc_exit(long ret,) unsigned int fd), - TP_ARGS(sc_exit(ret,) fd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) -) -#endif -#ifndef OVERRIDE_64_fchdir -SC_LTTNG_TRACEPOINT_EVENT(fchdir, - TP_PROTO(sc_exit(long ret,) unsigned int fd), - TP_ARGS(sc_exit(ret,) fd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) -) -#endif -#ifndef OVERRIDE_64_umask -SC_LTTNG_TRACEPOINT_EVENT(umask, - TP_PROTO(sc_exit(long ret,) int mask), - TP_ARGS(sc_exit(ret,) mask), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, mask, mask))) -) -#endif -#ifndef OVERRIDE_64_setuid -SC_LTTNG_TRACEPOINT_EVENT(setuid, - TP_PROTO(sc_exit(long ret,) uid_t uid), - TP_ARGS(sc_exit(ret,) uid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, uid, uid))) -) -#endif -#ifndef OVERRIDE_64_setgid -SC_LTTNG_TRACEPOINT_EVENT(setgid, - TP_PROTO(sc_exit(long ret,) gid_t gid), - TP_ARGS(sc_exit(ret,) gid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, gid, gid))) -) -#endif -#ifndef OVERRIDE_64_getpgid -SC_LTTNG_TRACEPOINT_EVENT(getpgid, - TP_PROTO(sc_exit(long ret,) pid_t pid), - TP_ARGS(sc_exit(ret,) pid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid))) -) -#endif -#ifndef OVERRIDE_64_setfsuid -SC_LTTNG_TRACEPOINT_EVENT(setfsuid, - TP_PROTO(sc_exit(long ret,) uid_t uid), - TP_ARGS(sc_exit(ret,) uid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, uid, uid))) -) -#endif -#ifndef OVERRIDE_64_setfsgid -SC_LTTNG_TRACEPOINT_EVENT(setfsgid, - TP_PROTO(sc_exit(long ret,) gid_t gid), - TP_ARGS(sc_exit(ret,) gid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, gid, gid))) -) -#endif -#ifndef OVERRIDE_64_getsid -SC_LTTNG_TRACEPOINT_EVENT(getsid, - TP_PROTO(sc_exit(long ret,) pid_t pid), - TP_ARGS(sc_exit(ret,) pid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid))) -) -#endif -#ifndef OVERRIDE_64_32_personality -SC_LTTNG_TRACEPOINT_EVENT(32_personality, - TP_PROTO(sc_exit(long ret,) unsigned long personality), - TP_ARGS(sc_exit(ret,) personality), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned long, personality, personality))) -) -#endif -#ifndef OVERRIDE_64_sched_getscheduler -SC_LTTNG_TRACEPOINT_EVENT(sched_getscheduler, - TP_PROTO(sc_exit(long ret,) pid_t pid), - TP_ARGS(sc_exit(ret,) pid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid))) -) -#endif -#ifndef OVERRIDE_64_sched_get_priority_max -SC_LTTNG_TRACEPOINT_EVENT(sched_get_priority_max, - TP_PROTO(sc_exit(long ret,) int policy), - TP_ARGS(sc_exit(ret,) policy), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, policy, policy))) -) -#endif -#ifndef OVERRIDE_64_sched_get_priority_min -SC_LTTNG_TRACEPOINT_EVENT(sched_get_priority_min, - TP_PROTO(sc_exit(long ret,) int policy), - TP_ARGS(sc_exit(ret,) policy), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, policy, policy))) -) -#endif -#ifndef OVERRIDE_64_mlockall -SC_LTTNG_TRACEPOINT_EVENT(mlockall, - TP_PROTO(sc_exit(long ret,) int flags), - TP_ARGS(sc_exit(ret,) flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_io_destroy -SC_LTTNG_TRACEPOINT_EVENT(io_destroy, - TP_PROTO(sc_exit(long ret,) aio_context_t ctx), - TP_ARGS(sc_exit(ret,) ctx), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx, ctx))) -) -#endif -#ifndef OVERRIDE_64_exit_group -SC_LTTNG_TRACEPOINT_EVENT(exit_group, - TP_PROTO(sc_exit(long ret,) int error_code), - TP_ARGS(sc_exit(ret,) error_code), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, error_code, error_code))) -) -#endif -#ifndef OVERRIDE_64_epoll_create -SC_LTTNG_TRACEPOINT_EVENT(epoll_create, - TP_PROTO(sc_exit(long ret,) int size), - TP_ARGS(sc_exit(ret,) size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, size, size))) -) -#endif -#ifndef OVERRIDE_64_timer_getoverrun -SC_LTTNG_TRACEPOINT_EVENT(timer_getoverrun, - TP_PROTO(sc_exit(long ret,) timer_t timer_id), - TP_ARGS(sc_exit(ret,) timer_id), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id))) -) -#endif -#ifndef OVERRIDE_64_timer_delete -SC_LTTNG_TRACEPOINT_EVENT(timer_delete, - TP_PROTO(sc_exit(long ret,) timer_t timer_id), - TP_ARGS(sc_exit(ret,) timer_id), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id))) -) -#endif -#ifndef OVERRIDE_64_set_thread_area -SC_LTTNG_TRACEPOINT_EVENT(set_thread_area, - TP_PROTO(sc_exit(long ret,) unsigned long addr), - TP_ARGS(sc_exit(ret,) addr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned long, addr, addr))) -) -#endif -#ifndef OVERRIDE_64_unshare -SC_LTTNG_TRACEPOINT_EVENT(unshare, - TP_PROTO(sc_exit(long ret,) unsigned long unshare_flags), - TP_ARGS(sc_exit(ret,) unshare_flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, unshare_flags, unshare_flags))) -) -#endif -#ifndef OVERRIDE_64_eventfd -SC_LTTNG_TRACEPOINT_EVENT(eventfd, - TP_PROTO(sc_exit(long ret,) unsigned int count), - TP_ARGS(sc_exit(ret,) count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, count, count))) -) -#endif -#ifndef OVERRIDE_64_epoll_create1 -SC_LTTNG_TRACEPOINT_EVENT(epoll_create1, - TP_PROTO(sc_exit(long ret,) int flags), - TP_ARGS(sc_exit(ret,) flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_inotify_init1 -SC_LTTNG_TRACEPOINT_EVENT(inotify_init1, - TP_PROTO(sc_exit(long ret,) int flags), - TP_ARGS(sc_exit(ret,) flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_syncfs -SC_LTTNG_TRACEPOINT_EVENT(syncfs, - TP_PROTO(sc_exit(long ret,) int fd), - TP_ARGS(sc_exit(ret,) fd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd))) -) -#endif -#ifndef OVERRIDE_64_bdflush -SC_LTTNG_TRACEPOINT_EVENT(bdflush, - TP_PROTO(sc_exit(long ret,) int func, long data), - TP_ARGS(sc_exit(ret,) func, data), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, func, func)) sc_inout(ctf_integer(long, data, data))) -) -#endif -#ifndef OVERRIDE_64_munmap -SC_LTTNG_TRACEPOINT_EVENT(munmap, - TP_PROTO(sc_exit(long ret,) unsigned long addr, size_t len), - TP_ARGS(sc_exit(ret,) addr, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, addr, addr)) sc_in(ctf_integer(size_t, len, len))) -) -#endif -#ifndef OVERRIDE_64_dup2 -SC_LTTNG_TRACEPOINT_EVENT(dup2, - TP_PROTO(sc_exit(long ret,) unsigned int oldfd, unsigned int newfd), - TP_ARGS(sc_exit(ret,) oldfd, newfd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, oldfd, oldfd)) sc_in(ctf_integer(unsigned int, newfd, newfd))) -) -#endif -#ifndef OVERRIDE_64_shutdown -SC_LTTNG_TRACEPOINT_EVENT(shutdown, - TP_PROTO(sc_exit(long ret,) int fd, int how), - TP_ARGS(sc_exit(ret,) fd, how), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, how, how))) -) -#endif -#ifndef OVERRIDE_64_listen -SC_LTTNG_TRACEPOINT_EVENT(listen, - TP_PROTO(sc_exit(long ret,) int fd, int backlog), - TP_ARGS(sc_exit(ret,) fd, backlog), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, backlog, backlog))) -) -#endif -#ifndef OVERRIDE_64_kill -SC_LTTNG_TRACEPOINT_EVENT(kill, - TP_PROTO(sc_exit(long ret,) pid_t pid, int sig), - TP_ARGS(sc_exit(ret,) pid, sig), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig))) -) -#endif -#ifndef OVERRIDE_64_msgget -SC_LTTNG_TRACEPOINT_EVENT(msgget, - TP_PROTO(sc_exit(long ret,) key_t key, int msgflg), - TP_ARGS(sc_exit(ret,) key, msgflg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(key_t, key, key)) sc_in(ctf_integer(int, msgflg, msgflg))) -) -#endif -#ifndef OVERRIDE_64_flock -SC_LTTNG_TRACEPOINT_EVENT(flock, - TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd), - TP_ARGS(sc_exit(ret,) fd, cmd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned int, cmd, cmd))) -) -#endif -#ifndef OVERRIDE_64_ftruncate -SC_LTTNG_TRACEPOINT_EVENT(ftruncate, - TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned long length), - TP_ARGS(sc_exit(ret,) fd, length), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned long, length, length))) -) -#endif -#ifndef OVERRIDE_64_fchmod -SC_LTTNG_TRACEPOINT_EVENT(fchmod, - TP_PROTO(sc_exit(long ret,) unsigned int fd, umode_t mode), - TP_ARGS(sc_exit(ret,) fd, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(umode_t, mode, mode))) -) -#endif -#ifndef OVERRIDE_64_setpgid -SC_LTTNG_TRACEPOINT_EVENT(setpgid, - TP_PROTO(sc_exit(long ret,) pid_t pid, pid_t pgid), - TP_ARGS(sc_exit(ret,) pid, pgid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(pid_t, pgid, pgid))) -) -#endif -#ifndef OVERRIDE_64_setreuid -SC_LTTNG_TRACEPOINT_EVENT(setreuid, - TP_PROTO(sc_exit(long ret,) uid_t ruid, uid_t euid), - TP_ARGS(sc_exit(ret,) ruid, euid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, ruid, ruid)) sc_in(ctf_integer(uid_t, euid, euid))) -) -#endif -#ifndef OVERRIDE_64_setregid -SC_LTTNG_TRACEPOINT_EVENT(setregid, - TP_PROTO(sc_exit(long ret,) gid_t rgid, gid_t egid), - TP_ARGS(sc_exit(ret,) rgid, egid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, rgid, rgid)) sc_in(ctf_integer(gid_t, egid, egid))) -) -#endif -#ifndef OVERRIDE_64_getpriority -SC_LTTNG_TRACEPOINT_EVENT(getpriority, - TP_PROTO(sc_exit(long ret,) int which, int who), - TP_ARGS(sc_exit(ret,) which, who), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who))) -) -#endif -#ifndef OVERRIDE_64_mlock -SC_LTTNG_TRACEPOINT_EVENT(mlock, - TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len), - TP_ARGS(sc_exit(ret,) start, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len))) -) -#endif -#ifndef OVERRIDE_64_munlock -SC_LTTNG_TRACEPOINT_EVENT(munlock, - TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len), - TP_ARGS(sc_exit(ret,) start, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len))) -) -#endif -#ifndef OVERRIDE_64_tkill -SC_LTTNG_TRACEPOINT_EVENT(tkill, - TP_PROTO(sc_exit(long ret,) pid_t pid, int sig), - TP_ARGS(sc_exit(ret,) pid, sig), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig))) -) -#endif -#ifndef OVERRIDE_64_inotify_rm_watch -SC_LTTNG_TRACEPOINT_EVENT(inotify_rm_watch, - TP_PROTO(sc_exit(long ret,) int fd, __s32 wd), - TP_ARGS(sc_exit(ret,) fd, wd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(__s32, wd, wd))) -) -#endif -#ifndef OVERRIDE_64_ioprio_get -SC_LTTNG_TRACEPOINT_EVENT(ioprio_get, - TP_PROTO(sc_exit(long ret,) int which, int who), - TP_ARGS(sc_exit(ret,) which, who), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who))) -) -#endif -#ifndef OVERRIDE_64_timerfd_create -SC_LTTNG_TRACEPOINT_EVENT(timerfd_create, - TP_PROTO(sc_exit(long ret,) int clockid, int flags), - TP_ARGS(sc_exit(ret,) clockid, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, clockid, clockid)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_eventfd2 -SC_LTTNG_TRACEPOINT_EVENT(eventfd2, - TP_PROTO(sc_exit(long ret,) unsigned int count, int flags), - TP_ARGS(sc_exit(ret,) count, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, count, count)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_setns -SC_LTTNG_TRACEPOINT_EVENT(setns, - TP_PROTO(sc_exit(long ret,) int fd, int nstype), - TP_ARGS(sc_exit(ret,) fd, nstype), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, nstype, nstype))) -) -#endif -#ifndef OVERRIDE_64_ioctl -SC_LTTNG_TRACEPOINT_EVENT(ioctl, - TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd, unsigned long arg), - TP_ARGS(sc_exit(ret,) fd, cmd, arg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_inout(ctf_integer(unsigned long, arg, arg))) -) -#endif -#ifndef OVERRIDE_64_fcntl -SC_LTTNG_TRACEPOINT_EVENT(fcntl, - TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd, unsigned long arg), - TP_ARGS(sc_exit(ret,) fd, cmd, arg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_inout(ctf_integer(unsigned long, arg, arg))) -) -#endif -#ifndef OVERRIDE_64_lseek -SC_LTTNG_TRACEPOINT_EVENT(lseek, - TP_PROTO(sc_exit(long ret,) unsigned int fd, off_t offset, unsigned int origin), - TP_ARGS(sc_exit(ret,) fd, offset, origin), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(off_t, offset, offset)) sc_in(ctf_integer(unsigned int, origin, origin))) -) -#endif -#ifndef OVERRIDE_64_mprotect -SC_LTTNG_TRACEPOINT_EVENT(mprotect, - TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len, unsigned long prot), - TP_ARGS(sc_exit(ret,) start, len, prot), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned long, prot, prot))) -) -#endif -#ifndef OVERRIDE_64_msync -SC_LTTNG_TRACEPOINT_EVENT(msync, - TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len, int flags), - TP_ARGS(sc_exit(ret,) start, len, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_madvise -SC_LTTNG_TRACEPOINT_EVENT(madvise, - TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len_in, int behavior), - TP_ARGS(sc_exit(ret,) start, len_in, behavior), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len_in, len_in)) sc_in(ctf_integer(int, behavior, behavior))) -) -#endif -#ifndef OVERRIDE_64_shmget -SC_LTTNG_TRACEPOINT_EVENT(shmget, - TP_PROTO(sc_exit(long ret,) key_t key, size_t size, int shmflg), - TP_ARGS(sc_exit(ret,) key, size, shmflg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(key_t, key, key)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(int, shmflg, shmflg))) -) -#endif -#ifndef OVERRIDE_64_socket -SC_LTTNG_TRACEPOINT_EVENT(socket, - TP_PROTO(sc_exit(long ret,) int family, int type, int protocol), - TP_ARGS(sc_exit(ret,) family, type, protocol), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, family, family)) sc_in(ctf_integer(int, type, type)) sc_in(ctf_integer(int, protocol, protocol))) -) -#endif -#ifndef OVERRIDE_64_semget -SC_LTTNG_TRACEPOINT_EVENT(semget, - TP_PROTO(sc_exit(long ret,) key_t key, int nsems, int semflg), - TP_ARGS(sc_exit(ret,) key, nsems, semflg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(key_t, key, key)) sc_in(ctf_integer(int, nsems, nsems)) sc_in(ctf_integer(int, semflg, semflg))) -) -#endif -#ifndef OVERRIDE_64_fchown -SC_LTTNG_TRACEPOINT_EVENT(fchown, - TP_PROTO(sc_exit(long ret,) unsigned int fd, uid_t user, gid_t group), - TP_ARGS(sc_exit(ret,) fd, user, group), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group))) -) -#endif -#ifndef OVERRIDE_64_setresuid -SC_LTTNG_TRACEPOINT_EVENT(setresuid, - TP_PROTO(sc_exit(long ret,) uid_t ruid, uid_t euid, uid_t suid), - TP_ARGS(sc_exit(ret,) ruid, euid, suid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, ruid, ruid)) sc_in(ctf_integer(uid_t, euid, euid)) sc_in(ctf_integer(uid_t, suid, suid))) -) -#endif -#ifndef OVERRIDE_64_setresgid -SC_LTTNG_TRACEPOINT_EVENT(setresgid, - TP_PROTO(sc_exit(long ret,) gid_t rgid, gid_t egid, gid_t sgid), - TP_ARGS(sc_exit(ret,) rgid, egid, sgid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, rgid, rgid)) sc_in(ctf_integer(gid_t, egid, egid)) sc_in(ctf_integer(gid_t, sgid, sgid))) -) -#endif -#ifndef OVERRIDE_64_sysfs -SC_LTTNG_TRACEPOINT_EVENT(sysfs, - TP_PROTO(sc_exit(long ret,) int option, unsigned long arg1, unsigned long arg2), - TP_ARGS(sc_exit(ret,) option, arg1, arg2), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, option, option)) sc_in(ctf_integer(unsigned long, arg1, arg1)) sc_in(ctf_integer(unsigned long, arg2, arg2))) -) -#endif -#ifndef OVERRIDE_64_setpriority -SC_LTTNG_TRACEPOINT_EVENT(setpriority, - TP_PROTO(sc_exit(long ret,) int which, int who, int niceval), - TP_ARGS(sc_exit(ret,) which, who, niceval), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who)) sc_in(ctf_integer(int, niceval, niceval))) -) -#endif -#ifndef OVERRIDE_64_cacheflush -SC_LTTNG_TRACEPOINT_EVENT(cacheflush, - TP_PROTO(sc_exit(long ret,) unsigned long addr, unsigned long bytes, unsigned int cache), - TP_ARGS(sc_exit(ret,) addr, bytes, cache), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned long, addr, addr)) sc_inout(ctf_integer(unsigned long, bytes, bytes)) sc_inout(ctf_integer(unsigned int, cache, cache))) -) -#endif -#ifndef OVERRIDE_64_tgkill -SC_LTTNG_TRACEPOINT_EVENT(tgkill, - TP_PROTO(sc_exit(long ret,) pid_t tgid, pid_t pid, int sig), - TP_ARGS(sc_exit(ret,) tgid, pid, sig), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, tgid, tgid)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig))) -) -#endif -#ifndef OVERRIDE_64_ioprio_set -SC_LTTNG_TRACEPOINT_EVENT(ioprio_set, - TP_PROTO(sc_exit(long ret,) int which, int who, int ioprio), - TP_ARGS(sc_exit(ret,) which, who, ioprio), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who)) sc_in(ctf_integer(int, ioprio, ioprio))) -) -#endif -#ifndef OVERRIDE_64_dup3 -SC_LTTNG_TRACEPOINT_EVENT(dup3, - TP_PROTO(sc_exit(long ret,) unsigned int oldfd, unsigned int newfd, int flags), - TP_ARGS(sc_exit(ret,) oldfd, newfd, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, oldfd, oldfd)) sc_in(ctf_integer(unsigned int, newfd, newfd)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_32_ftruncate64 -SC_LTTNG_TRACEPOINT_EVENT(32_ftruncate64, - TP_PROTO(sc_exit(long ret,) unsigned long fd, unsigned long __dummy, unsigned long a2, unsigned long a3), - TP_ARGS(sc_exit(ret,) fd, __dummy, a2, a3), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned long, fd, fd)) sc_inout(ctf_integer(unsigned long, __dummy, __dummy)) sc_inout(ctf_integer(unsigned long, a2, a2)) sc_inout(ctf_integer(unsigned long, a3, a3))) -) -#endif -#ifndef OVERRIDE_64_ptrace -SC_LTTNG_TRACEPOINT_EVENT(ptrace, - TP_PROTO(sc_exit(long ret,) long request, long pid, unsigned long addr, unsigned long data), - TP_ARGS(sc_exit(ret,) request, pid, addr, data), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(long, request, request)) sc_in(ctf_integer(long, pid, pid)) sc_inout(ctf_integer(unsigned long, addr, addr)) sc_inout(ctf_integer(unsigned long, data, data))) -) -#endif -#ifndef OVERRIDE_64_n32_semctl -SC_LTTNG_TRACEPOINT_EVENT(n32_semctl, - TP_PROTO(sc_exit(long ret,) int semid, int semnum, int cmd, u32 arg), - TP_ARGS(sc_exit(ret,) semid, semnum, cmd, arg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, semid, semid)) sc_inout(ctf_integer(int, semnum, semnum)) sc_inout(ctf_integer(int, cmd, cmd)) sc_inout(ctf_integer(u32, arg, arg))) -) -#endif -#ifndef OVERRIDE_64_n32_msgsnd -SC_LTTNG_TRACEPOINT_EVENT(n32_msgsnd, - TP_PROTO(sc_exit(long ret,) int msqid, u32 msgp, unsigned int msgsz, int msgflg), - TP_ARGS(sc_exit(ret,) msqid, msgp, msgsz, msgflg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, msqid, msqid)) sc_inout(ctf_integer(u32, msgp, msgp)) sc_inout(ctf_integer(unsigned int, msgsz, msgsz)) sc_inout(ctf_integer(int, msgflg, msgflg))) -) -#endif -#ifndef OVERRIDE_64_tee -SC_LTTNG_TRACEPOINT_EVENT(tee, - TP_PROTO(sc_exit(long ret,) int fdin, int fdout, size_t len, unsigned int flags), - TP_ARGS(sc_exit(ret,) fdin, fdout, len, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fdin, fdin)) sc_in(ctf_integer(int, fdout, fdout)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_mremap -SC_LTTNG_TRACEPOINT_EVENT(mremap, - TP_PROTO(sc_exit(long ret,) unsigned long addr, unsigned long old_len, unsigned long new_len, unsigned long flags, unsigned long new_addr), - TP_ARGS(sc_exit(ret,) addr, old_len, new_len, flags, new_addr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, addr, addr)) sc_in(ctf_integer(unsigned long, old_len, old_len)) sc_in(ctf_integer(unsigned long, new_len, new_len)) sc_in(ctf_integer(unsigned long, flags, flags)) sc_in(ctf_integer(unsigned long, new_addr, new_addr))) -) -#endif -#ifndef OVERRIDE_64_n32_msgrcv -SC_LTTNG_TRACEPOINT_EVENT(n32_msgrcv, - TP_PROTO(sc_exit(long ret,) int msqid, u32 msgp, size_t msgsz, int msgtyp, int msgflg), - TP_ARGS(sc_exit(ret,) msqid, msgp, msgsz, msgtyp, msgflg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, msqid, msqid)) sc_inout(ctf_integer(u32, msgp, msgp)) sc_inout(ctf_integer(size_t, msgsz, msgsz)) sc_inout(ctf_integer(int, msgtyp, msgtyp)) sc_inout(ctf_integer(int, msgflg, msgflg))) -) -#endif -#ifndef OVERRIDE_64_prctl -SC_LTTNG_TRACEPOINT_EVENT(prctl, - TP_PROTO(sc_exit(long ret,) int option, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5), - TP_ARGS(sc_exit(ret,) option, arg2, arg3, arg4, arg5), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, option, option)) sc_inout(ctf_integer(unsigned long, arg2, arg2)) sc_in(ctf_integer(unsigned long, arg3, arg3)) sc_in(ctf_integer(unsigned long, arg4, arg4)) sc_in(ctf_integer(unsigned long, arg5, arg5))) -) -#endif -#ifndef OVERRIDE_64_remap_file_pages -SC_LTTNG_TRACEPOINT_EVENT(remap_file_pages, - TP_PROTO(sc_exit(long ret,) unsigned long start, unsigned long size, unsigned long prot, unsigned long pgoff, unsigned long flags), - TP_ARGS(sc_exit(ret,) start, size, prot, pgoff, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(unsigned long, size, size)) sc_in(ctf_integer(unsigned long, prot, prot)) sc_in(ctf_integer(unsigned long, pgoff, pgoff)) sc_in(ctf_integer(unsigned long, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_32_ipc -SC_LTTNG_TRACEPOINT_EVENT(32_ipc, - TP_PROTO(sc_exit(long ret,) u32 call, long first, long second, long third, unsigned long ptr, unsigned long fifth), - TP_ARGS(sc_exit(ret,) call, first, second, third, ptr, fifth), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(u32, call, call)) sc_inout(ctf_integer(long, first, first)) sc_inout(ctf_integer(long, second, second)) sc_inout(ctf_integer(long, third, third)) sc_inout(ctf_integer(unsigned long, ptr, ptr)) sc_inout(ctf_integer(unsigned long, fifth, fifth))) -) -#endif -#ifndef OVERRIDE_64_mips_mmap2 -SC_LTTNG_TRACEPOINT_EVENT(mips_mmap2, - TP_PROTO(sc_exit(long ret,) unsigned long addr, unsigned long len, unsigned long prot, unsigned long flags, unsigned long fd, unsigned long pgoff), - TP_ARGS(sc_exit(ret,) addr, len, prot, flags, fd, pgoff), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned long, addr, addr)) sc_inout(ctf_integer(unsigned long, len, len)) sc_inout(ctf_integer(unsigned long, prot, prot)) sc_inout(ctf_integer(unsigned long, flags, flags)) sc_inout(ctf_integer(unsigned long, fd, fd)) sc_inout(ctf_integer(unsigned long, pgoff, pgoff))) -) -#endif -#ifndef OVERRIDE_64_mips_mmap -SC_LTTNG_TRACEPOINT_EVENT(mips_mmap, - TP_PROTO(sc_exit(long ret,) unsigned long addr, unsigned long len, unsigned long prot, unsigned long flags, unsigned long fd, off_t offset), - TP_ARGS(sc_exit(ret,) addr, len, prot, flags, fd, offset), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned long, addr, addr)) sc_inout(ctf_integer(unsigned long, len, len)) sc_inout(ctf_integer(unsigned long, prot, prot)) sc_inout(ctf_integer(unsigned long, flags, flags)) sc_inout(ctf_integer(unsigned long, fd, fd)) sc_inout(ctf_integer(off_t, offset, offset))) -) -#endif - -#endif /* _TRACE_SYSCALLS_INTEGERS_H */ - -/* This part must be outside protection */ -#include - -#else /* CREATE_SYSCALL_TABLE */ - -#include "mips-64-syscalls_integers_override.h" -#include "syscalls_integers_override.h" - -#ifdef SC_ENTER -#ifndef OVERRIDE_TABLE_64_sgetmask -TRACE_SYSCALL_TABLE(syscalls_noargs, sgetmask, 4068, 0) -#endif -#ifndef OVERRIDE_TABLE_64_sched_yield -TRACE_SYSCALL_TABLE(syscalls_noargs, sched_yield, 6023, 0) -#endif -#ifndef OVERRIDE_TABLE_64_pause -TRACE_SYSCALL_TABLE(syscalls_noargs, pause, 6033, 0) -#endif -#ifndef OVERRIDE_TABLE_64_getpid -TRACE_SYSCALL_TABLE(syscalls_noargs, getpid, 6038, 0) -#endif -#ifndef OVERRIDE_TABLE_64_getuid -TRACE_SYSCALL_TABLE(syscalls_noargs, getuid, 6100, 0) -#endif -#ifndef OVERRIDE_TABLE_64_getgid -TRACE_SYSCALL_TABLE(syscalls_noargs, getgid, 6102, 0) -#endif -#ifndef OVERRIDE_TABLE_64_geteuid -TRACE_SYSCALL_TABLE(syscalls_noargs, geteuid, 6105, 0) -#endif -#ifndef OVERRIDE_TABLE_64_getegid -TRACE_SYSCALL_TABLE(syscalls_noargs, getegid, 6106, 0) -#endif -#ifndef OVERRIDE_TABLE_64_getppid -TRACE_SYSCALL_TABLE(syscalls_noargs, getppid, 6108, 0) -#endif -#ifndef OVERRIDE_TABLE_64_getpgrp -TRACE_SYSCALL_TABLE(syscalls_noargs, getpgrp, 6109, 0) -#endif -#ifndef OVERRIDE_TABLE_64_setsid -TRACE_SYSCALL_TABLE(syscalls_noargs, setsid, 6110, 0) -#endif -#ifndef OVERRIDE_TABLE_64_munlockall -TRACE_SYSCALL_TABLE(syscalls_noargs, munlockall, 6149, 0) -#endif -#ifndef OVERRIDE_TABLE_64_vhangup -TRACE_SYSCALL_TABLE(syscalls_noargs, vhangup, 6150, 0) -#endif -#ifndef OVERRIDE_TABLE_64_sync -TRACE_SYSCALL_TABLE(syscalls_noargs, sync, 6157, 0) -#endif -#ifndef OVERRIDE_TABLE_64_gettid -TRACE_SYSCALL_TABLE(syscalls_noargs, gettid, 6178, 0) -#endif -#ifndef OVERRIDE_TABLE_64_restart_syscall -TRACE_SYSCALL_TABLE(syscalls_noargs, restart_syscall, 6214, 0) -#endif -#ifndef OVERRIDE_TABLE_64_inotify_init -TRACE_SYSCALL_TABLE(syscalls_noargs, inotify_init, 6247, 0) -#endif -#else /* #ifdef SC_ENTER */ -#ifndef OVERRIDE_TABLE_64_sgetmask -TRACE_SYSCALL_TABLE(sgetmask, sgetmask, 4068, 0) -#endif -#ifndef OVERRIDE_TABLE_64_sched_yield -TRACE_SYSCALL_TABLE(sched_yield, sched_yield, 6023, 0) -#endif -#ifndef OVERRIDE_TABLE_64_pause -TRACE_SYSCALL_TABLE(pause, pause, 6033, 0) -#endif -#ifndef OVERRIDE_TABLE_64_getpid -TRACE_SYSCALL_TABLE(getpid, getpid, 6038, 0) -#endif -#ifndef OVERRIDE_TABLE_64_getuid -TRACE_SYSCALL_TABLE(getuid, getuid, 6100, 0) -#endif -#ifndef OVERRIDE_TABLE_64_getgid -TRACE_SYSCALL_TABLE(getgid, getgid, 6102, 0) -#endif -#ifndef OVERRIDE_TABLE_64_geteuid -TRACE_SYSCALL_TABLE(geteuid, geteuid, 6105, 0) -#endif -#ifndef OVERRIDE_TABLE_64_getegid -TRACE_SYSCALL_TABLE(getegid, getegid, 6106, 0) -#endif -#ifndef OVERRIDE_TABLE_64_getppid -TRACE_SYSCALL_TABLE(getppid, getppid, 6108, 0) -#endif -#ifndef OVERRIDE_TABLE_64_getpgrp -TRACE_SYSCALL_TABLE(getpgrp, getpgrp, 6109, 0) -#endif -#ifndef OVERRIDE_TABLE_64_setsid -TRACE_SYSCALL_TABLE(setsid, setsid, 6110, 0) -#endif -#ifndef OVERRIDE_TABLE_64_munlockall -TRACE_SYSCALL_TABLE(munlockall, munlockall, 6149, 0) -#endif -#ifndef OVERRIDE_TABLE_64_vhangup -TRACE_SYSCALL_TABLE(vhangup, vhangup, 6150, 0) -#endif -#ifndef OVERRIDE_TABLE_64_sync -TRACE_SYSCALL_TABLE(sync, sync, 6157, 0) -#endif -#ifndef OVERRIDE_TABLE_64_gettid -TRACE_SYSCALL_TABLE(gettid, gettid, 6178, 0) -#endif -#ifndef OVERRIDE_TABLE_64_restart_syscall -TRACE_SYSCALL_TABLE(restart_syscall, restart_syscall, 6214, 0) -#endif -#ifndef OVERRIDE_TABLE_64_inotify_init -TRACE_SYSCALL_TABLE(inotify_init, inotify_init, 6247, 0) -#endif -#endif /* else #ifdef SC_ENTER */ -#ifndef OVERRIDE_TABLE_64_nice -TRACE_SYSCALL_TABLE(nice, nice, 4034, 1) -#endif -#ifndef OVERRIDE_TABLE_64_ssetmask -TRACE_SYSCALL_TABLE(ssetmask, ssetmask, 4069, 1) -#endif -#ifndef OVERRIDE_TABLE_64_32_ipc -TRACE_SYSCALL_TABLE(32_ipc, 32_ipc, 4117, 6) -#endif -#ifndef OVERRIDE_TABLE_64_bdflush -TRACE_SYSCALL_TABLE(bdflush, bdflush, 4134, 2) -#endif -#ifndef OVERRIDE_TABLE_64_mips_mmap2 -TRACE_SYSCALL_TABLE(mips_mmap2, mips_mmap2, 4210, 6) -#endif -#ifndef OVERRIDE_TABLE_64_32_ftruncate64 -TRACE_SYSCALL_TABLE(32_ftruncate64, 32_ftruncate64, 4212, 4) -#endif -#ifndef OVERRIDE_TABLE_64_ioctl -TRACE_SYSCALL_TABLE(ioctl, ioctl, 5015, 3) -#endif -#ifndef OVERRIDE_TABLE_64_fcntl -TRACE_SYSCALL_TABLE(fcntl, fcntl, 5070, 3) -#endif -#ifndef OVERRIDE_TABLE_64_ptrace -TRACE_SYSCALL_TABLE(ptrace, ptrace, 5099, 4) -#endif -#ifndef OVERRIDE_TABLE_64_personality -TRACE_SYSCALL_TABLE(personality, personality, 5132, 1) -#endif -#ifndef OVERRIDE_TABLE_64_close -TRACE_SYSCALL_TABLE(close, close, 6003, 1) -#endif -#ifndef OVERRIDE_TABLE_64_lseek -TRACE_SYSCALL_TABLE(lseek, lseek, 6008, 3) -#endif -#ifndef OVERRIDE_TABLE_64_mips_mmap -TRACE_SYSCALL_TABLE(mips_mmap, mips_mmap, 6009, 6) -#endif -#ifndef OVERRIDE_TABLE_64_mprotect -TRACE_SYSCALL_TABLE(mprotect, mprotect, 6010, 3) -#endif -#ifndef OVERRIDE_TABLE_64_munmap -TRACE_SYSCALL_TABLE(munmap, munmap, 6011, 2) -#endif -#ifndef OVERRIDE_TABLE_64_brk -TRACE_SYSCALL_TABLE(brk, brk, 6012, 1) -#endif -#ifndef OVERRIDE_TABLE_64_mremap -TRACE_SYSCALL_TABLE(mremap, mremap, 6024, 5) -#endif -#ifndef OVERRIDE_TABLE_64_msync -TRACE_SYSCALL_TABLE(msync, msync, 6025, 3) -#endif -#ifndef OVERRIDE_TABLE_64_madvise -TRACE_SYSCALL_TABLE(madvise, madvise, 6027, 3) -#endif -#ifndef OVERRIDE_TABLE_64_shmget -TRACE_SYSCALL_TABLE(shmget, shmget, 6028, 3) -#endif -#ifndef OVERRIDE_TABLE_64_dup -TRACE_SYSCALL_TABLE(dup, dup, 6031, 1) -#endif -#ifndef OVERRIDE_TABLE_64_dup2 -TRACE_SYSCALL_TABLE(dup2, dup2, 6032, 2) -#endif -#ifndef OVERRIDE_TABLE_64_alarm -TRACE_SYSCALL_TABLE(alarm, alarm, 6037, 1) -#endif -#ifndef OVERRIDE_TABLE_64_socket -TRACE_SYSCALL_TABLE(socket, socket, 6040, 3) -#endif -#ifndef OVERRIDE_TABLE_64_shutdown -TRACE_SYSCALL_TABLE(shutdown, shutdown, 6047, 2) -#endif -#ifndef OVERRIDE_TABLE_64_listen -TRACE_SYSCALL_TABLE(listen, listen, 6049, 2) -#endif -#ifndef OVERRIDE_TABLE_64_exit -TRACE_SYSCALL_TABLE(exit, exit, 6058, 1) -#endif -#ifndef OVERRIDE_TABLE_64_kill -TRACE_SYSCALL_TABLE(kill, kill, 6060, 2) -#endif -#ifndef OVERRIDE_TABLE_64_semget -TRACE_SYSCALL_TABLE(semget, semget, 6062, 3) -#endif -#ifndef OVERRIDE_TABLE_64_n32_semctl -TRACE_SYSCALL_TABLE(n32_semctl, n32_semctl, 6064, 4) -#endif -#ifndef OVERRIDE_TABLE_64_msgget -TRACE_SYSCALL_TABLE(msgget, msgget, 6066, 2) -#endif -#ifndef OVERRIDE_TABLE_64_n32_msgsnd -TRACE_SYSCALL_TABLE(n32_msgsnd, n32_msgsnd, 6067, 4) -#endif -#ifndef OVERRIDE_TABLE_64_n32_msgrcv -TRACE_SYSCALL_TABLE(n32_msgrcv, n32_msgrcv, 6068, 5) -#endif -#ifndef OVERRIDE_TABLE_64_flock -TRACE_SYSCALL_TABLE(flock, flock, 6071, 2) -#endif -#ifndef OVERRIDE_TABLE_64_fsync -TRACE_SYSCALL_TABLE(fsync, fsync, 6072, 1) -#endif -#ifndef OVERRIDE_TABLE_64_fdatasync -TRACE_SYSCALL_TABLE(fdatasync, fdatasync, 6073, 1) -#endif -#ifndef OVERRIDE_TABLE_64_ftruncate -TRACE_SYSCALL_TABLE(ftruncate, ftruncate, 6075, 2) -#endif -#ifndef OVERRIDE_TABLE_64_fchdir -TRACE_SYSCALL_TABLE(fchdir, fchdir, 6079, 1) -#endif -#ifndef OVERRIDE_TABLE_64_fchmod -TRACE_SYSCALL_TABLE(fchmod, fchmod, 6089, 2) -#endif -#ifndef OVERRIDE_TABLE_64_fchown -TRACE_SYSCALL_TABLE(fchown, fchown, 6091, 3) -#endif -#ifndef OVERRIDE_TABLE_64_umask -TRACE_SYSCALL_TABLE(umask, umask, 6093, 1) -#endif -#ifndef OVERRIDE_TABLE_64_setuid -TRACE_SYSCALL_TABLE(setuid, setuid, 6103, 1) -#endif -#ifndef OVERRIDE_TABLE_64_setgid -TRACE_SYSCALL_TABLE(setgid, setgid, 6104, 1) -#endif -#ifndef OVERRIDE_TABLE_64_setpgid -TRACE_SYSCALL_TABLE(setpgid, setpgid, 6107, 2) -#endif -#ifndef OVERRIDE_TABLE_64_setreuid -TRACE_SYSCALL_TABLE(setreuid, setreuid, 6111, 2) -#endif -#ifndef OVERRIDE_TABLE_64_setregid -TRACE_SYSCALL_TABLE(setregid, setregid, 6112, 2) -#endif -#ifndef OVERRIDE_TABLE_64_setresuid -TRACE_SYSCALL_TABLE(setresuid, setresuid, 6115, 3) -#endif -#ifndef OVERRIDE_TABLE_64_setresgid -TRACE_SYSCALL_TABLE(setresgid, setresgid, 6117, 3) -#endif -#ifndef OVERRIDE_TABLE_64_getpgid -TRACE_SYSCALL_TABLE(getpgid, getpgid, 6119, 1) -#endif -#ifndef OVERRIDE_TABLE_64_setfsuid -TRACE_SYSCALL_TABLE(setfsuid, setfsuid, 6120, 1) -#endif -#ifndef OVERRIDE_TABLE_64_setfsgid -TRACE_SYSCALL_TABLE(setfsgid, setfsgid, 6121, 1) -#endif -#ifndef OVERRIDE_TABLE_64_getsid -TRACE_SYSCALL_TABLE(getsid, getsid, 6122, 1) -#endif -#ifndef OVERRIDE_TABLE_64_32_personality -TRACE_SYSCALL_TABLE(32_personality, 32_personality, 6132, 1) -#endif -#ifndef OVERRIDE_TABLE_64_sysfs -TRACE_SYSCALL_TABLE(sysfs, sysfs, 6136, 3) -#endif -#ifndef OVERRIDE_TABLE_64_getpriority -TRACE_SYSCALL_TABLE(getpriority, getpriority, 6137, 2) -#endif -#ifndef OVERRIDE_TABLE_64_setpriority -TRACE_SYSCALL_TABLE(setpriority, setpriority, 6138, 3) -#endif -#ifndef OVERRIDE_TABLE_64_sched_getscheduler -TRACE_SYSCALL_TABLE(sched_getscheduler, sched_getscheduler, 6142, 1) -#endif -#ifndef OVERRIDE_TABLE_64_sched_get_priority_max -TRACE_SYSCALL_TABLE(sched_get_priority_max, sched_get_priority_max, 6143, 1) -#endif -#ifndef OVERRIDE_TABLE_64_sched_get_priority_min -TRACE_SYSCALL_TABLE(sched_get_priority_min, sched_get_priority_min, 6144, 1) -#endif -#ifndef OVERRIDE_TABLE_64_mlock -TRACE_SYSCALL_TABLE(mlock, mlock, 6146, 2) -#endif -#ifndef OVERRIDE_TABLE_64_munlock -TRACE_SYSCALL_TABLE(munlock, munlock, 6147, 2) -#endif -#ifndef OVERRIDE_TABLE_64_mlockall -TRACE_SYSCALL_TABLE(mlockall, mlockall, 6148, 1) -#endif -#ifndef OVERRIDE_TABLE_64_prctl -TRACE_SYSCALL_TABLE(prctl, prctl, 6153, 5) -#endif -#ifndef OVERRIDE_TABLE_64_tkill -TRACE_SYSCALL_TABLE(tkill, tkill, 6192, 2) -#endif -#ifndef OVERRIDE_TABLE_64_cacheflush -TRACE_SYSCALL_TABLE(cacheflush, cacheflush, 6197, 3) -#endif -#ifndef OVERRIDE_TABLE_64_io_destroy -TRACE_SYSCALL_TABLE(io_destroy, io_destroy, 6201, 1) -#endif -#ifndef OVERRIDE_TABLE_64_exit_group -TRACE_SYSCALL_TABLE(exit_group, exit_group, 6205, 1) -#endif -#ifndef OVERRIDE_TABLE_64_epoll_create -TRACE_SYSCALL_TABLE(epoll_create, epoll_create, 6207, 1) -#endif -#ifndef OVERRIDE_TABLE_64_remap_file_pages -TRACE_SYSCALL_TABLE(remap_file_pages, remap_file_pages, 6210, 5) -#endif -#ifndef OVERRIDE_TABLE_64_timer_getoverrun -TRACE_SYSCALL_TABLE(timer_getoverrun, timer_getoverrun, 6223, 1) -#endif -#ifndef OVERRIDE_TABLE_64_timer_delete -TRACE_SYSCALL_TABLE(timer_delete, timer_delete, 6224, 1) -#endif -#ifndef OVERRIDE_TABLE_64_tgkill -TRACE_SYSCALL_TABLE(tgkill, tgkill, 6229, 3) -#endif -#ifndef OVERRIDE_TABLE_64_set_thread_area -TRACE_SYSCALL_TABLE(set_thread_area, set_thread_area, 6246, 1) -#endif -#ifndef OVERRIDE_TABLE_64_inotify_rm_watch -TRACE_SYSCALL_TABLE(inotify_rm_watch, inotify_rm_watch, 6249, 2) -#endif -#ifndef OVERRIDE_TABLE_64_unshare -TRACE_SYSCALL_TABLE(unshare, unshare, 6266, 1) -#endif -#ifndef OVERRIDE_TABLE_64_tee -TRACE_SYSCALL_TABLE(tee, tee, 6269, 4) -#endif -#ifndef OVERRIDE_TABLE_64_ioprio_set -TRACE_SYSCALL_TABLE(ioprio_set, ioprio_set, 6277, 3) -#endif -#ifndef OVERRIDE_TABLE_64_ioprio_get -TRACE_SYSCALL_TABLE(ioprio_get, ioprio_get, 6278, 2) -#endif -#ifndef OVERRIDE_TABLE_64_eventfd -TRACE_SYSCALL_TABLE(eventfd, eventfd, 6282, 1) -#endif -#ifndef OVERRIDE_TABLE_64_timerfd_create -TRACE_SYSCALL_TABLE(timerfd_create, timerfd_create, 6284, 2) -#endif -#ifndef OVERRIDE_TABLE_64_eventfd2 -TRACE_SYSCALL_TABLE(eventfd2, eventfd2, 6288, 2) -#endif -#ifndef OVERRIDE_TABLE_64_epoll_create1 -TRACE_SYSCALL_TABLE(epoll_create1, epoll_create1, 6289, 1) -#endif -#ifndef OVERRIDE_TABLE_64_dup3 -TRACE_SYSCALL_TABLE(dup3, dup3, 6290, 3) -#endif -#ifndef OVERRIDE_TABLE_64_inotify_init1 -TRACE_SYSCALL_TABLE(inotify_init1, inotify_init1, 6292, 1) -#endif -#ifndef OVERRIDE_TABLE_64_syncfs -TRACE_SYSCALL_TABLE(syncfs, syncfs, 6306, 1) -#endif -#ifndef OVERRIDE_TABLE_64_setns -TRACE_SYSCALL_TABLE(setns, setns, 6308, 2) -#endif - -#endif /* CREATE_SYSCALL_TABLE */ diff --git a/instrumentation/syscalls/headers/mips-64-syscalls_integers_override.h b/instrumentation/syscalls/headers/mips-64-syscalls_integers_override.h deleted file mode 100644 index 64021873..00000000 --- a/instrumentation/syscalls/headers/mips-64-syscalls_integers_override.h +++ /dev/null @@ -1,5 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ - -/* - * this is a place-holder for MIPS integer syscall definition override. - */ diff --git a/instrumentation/syscalls/headers/mips-64-syscalls_pointers.h b/instrumentation/syscalls/headers/mips-64-syscalls_pointers.h deleted file mode 100644 index 8bcf9b00..00000000 --- a/instrumentation/syscalls/headers/mips-64-syscalls_pointers.h +++ /dev/null @@ -1,1869 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ - -/* THIS FILE IS AUTO-GENERATED. DO NOT EDIT */ - -/* Generated from mips-64-syscalls 3.5.0 */ - -#ifndef CREATE_SYSCALL_TABLE - -#if !defined(_TRACE_SYSCALLS_POINTERS_H) || defined(TRACE_HEADER_MULTI_READ) -#define _TRACE_SYSCALLS_POINTERS_H - -#include -#include -#include "mips-64-syscalls_pointers_override.h" -#include "syscalls_pointers_override.h" - -#ifndef OVERRIDE_64_oldumount -SC_LTTNG_TRACEPOINT_EVENT(oldumount, - TP_PROTO(sc_exit(long ret,) char * name), - TP_ARGS(sc_exit(ret,) name), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(name, name))) -) -#endif -#ifndef OVERRIDE_64_olduname -SC_LTTNG_TRACEPOINT_EVENT(olduname, - TP_PROTO(sc_exit(long ret,) struct oldold_utsname * name), - TP_ARGS(sc_exit(ret,) name), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct oldold_utsname *, name, name))) -) -#endif -#ifndef OVERRIDE_64_uselib -SC_LTTNG_TRACEPOINT_EVENT(uselib, - TP_PROTO(sc_exit(long ret,) const char * library), - TP_ARGS(sc_exit(ret,) library), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(const char *, library, library))) -) -#endif -#ifndef OVERRIDE_64_uname -SC_LTTNG_TRACEPOINT_EVENT(uname, - TP_PROTO(sc_exit(long ret,) struct old_utsname * name), - TP_ARGS(sc_exit(ret,) name), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct old_utsname *, name, name))) -) -#endif -#ifndef OVERRIDE_64_sysinfo -SC_LTTNG_TRACEPOINT_EVENT(sysinfo, - TP_PROTO(sc_exit(long ret,) struct sysinfo * info), - TP_ARGS(sc_exit(ret,) info), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct sysinfo *, info, info))) -) -#endif -#ifndef OVERRIDE_64_times -SC_LTTNG_TRACEPOINT_EVENT(times, - TP_PROTO(sc_exit(long ret,) struct tms * tbuf), - TP_ARGS(sc_exit(ret,) tbuf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct tms *, tbuf, tbuf))) -) -#endif -#ifndef OVERRIDE_64_sysctl -SC_LTTNG_TRACEPOINT_EVENT(sysctl, - TP_PROTO(sc_exit(long ret,) struct __sysctl_args * args), - TP_ARGS(sc_exit(ret,) args), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct __sysctl_args *, args, args))) -) -#endif -#ifndef OVERRIDE_64_adjtimex -SC_LTTNG_TRACEPOINT_EVENT(adjtimex, - TP_PROTO(sc_exit(long ret,) struct timex * txc_p), - TP_ARGS(sc_exit(ret,) txc_p), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct timex *, txc_p, txc_p))) -) -#endif -#ifndef OVERRIDE_64_newuname -SC_LTTNG_TRACEPOINT_EVENT(newuname, - TP_PROTO(sc_exit(long ret,) struct new_utsname * name), - TP_ARGS(sc_exit(ret,) name), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct new_utsname *, name, name))) -) -#endif -#ifndef OVERRIDE_64_shmdt -SC_LTTNG_TRACEPOINT_EVENT(shmdt, - TP_PROTO(sc_exit(long ret,) char * shmaddr), - TP_ARGS(sc_exit(ret,) shmaddr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(char *, shmaddr, shmaddr))) -) -#endif -#ifndef OVERRIDE_64_chdir -SC_LTTNG_TRACEPOINT_EVENT(chdir, - TP_PROTO(sc_exit(long ret,) const char * filename), - TP_ARGS(sc_exit(ret,) filename), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename))) -) -#endif -#ifndef OVERRIDE_64_rmdir -SC_LTTNG_TRACEPOINT_EVENT(rmdir, - TP_PROTO(sc_exit(long ret,) const char * pathname), - TP_ARGS(sc_exit(ret,) pathname), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname))) -) -#endif -#ifndef OVERRIDE_64_unlink -SC_LTTNG_TRACEPOINT_EVENT(unlink, - TP_PROTO(sc_exit(long ret,) const char * pathname), - TP_ARGS(sc_exit(ret,) pathname), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname))) -) -#endif -#ifndef OVERRIDE_64_chroot -SC_LTTNG_TRACEPOINT_EVENT(chroot, - TP_PROTO(sc_exit(long ret,) const char * filename), - TP_ARGS(sc_exit(ret,) filename), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename))) -) -#endif -#ifndef OVERRIDE_64_swapoff -SC_LTTNG_TRACEPOINT_EVENT(swapoff, - TP_PROTO(sc_exit(long ret,) const char * specialfile), - TP_ARGS(sc_exit(ret,) specialfile), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(specialfile, specialfile))) -) -#endif -#ifndef OVERRIDE_64_set_tid_address -SC_LTTNG_TRACEPOINT_EVENT(set_tid_address, - TP_PROTO(sc_exit(long ret,) int * tidptr), - TP_ARGS(sc_exit(ret,) tidptr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int *, tidptr, tidptr))) -) -#endif -#ifndef OVERRIDE_64_nanosleep -SC_LTTNG_TRACEPOINT_EVENT(nanosleep, - TP_PROTO(sc_exit(long ret,) struct timespec * rqtp, struct timespec * rmtp), - TP_ARGS(sc_exit(ret,) rqtp, rmtp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct timespec *, rqtp, rqtp)) sc_out(ctf_integer(struct timespec *, rmtp, rmtp))) -) -#endif -#ifndef OVERRIDE_64_getitimer -SC_LTTNG_TRACEPOINT_EVENT(getitimer, - TP_PROTO(sc_exit(long ret,) int which, struct itimerval * value), - TP_ARGS(sc_exit(ret,) which, value), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_out(ctf_integer(struct itimerval *, value, value))) -) -#endif -#ifndef OVERRIDE_64_gettimeofday -SC_LTTNG_TRACEPOINT_EVENT(gettimeofday, - TP_PROTO(sc_exit(long ret,) struct timeval * tv, struct timezone * tz), - TP_ARGS(sc_exit(ret,) tv, tz), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct timeval *, tv, tv)) sc_out(ctf_integer(struct timezone *, tz, tz))) -) -#endif -#ifndef OVERRIDE_64_getrlimit -SC_LTTNG_TRACEPOINT_EVENT(getrlimit, - TP_PROTO(sc_exit(long ret,) unsigned int resource, struct rlimit * rlim), - TP_ARGS(sc_exit(ret,) resource, rlim), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, resource, resource)) sc_out(ctf_integer(struct rlimit *, rlim, rlim))) -) -#endif -#ifndef OVERRIDE_64_getrusage -SC_LTTNG_TRACEPOINT_EVENT(getrusage, - TP_PROTO(sc_exit(long ret,) int who, struct rusage * ru), - TP_ARGS(sc_exit(ret,) who, ru), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, who, who)) sc_out(ctf_integer(struct rusage *, ru, ru))) -) -#endif -#ifndef OVERRIDE_64_rt_sigpending -SC_LTTNG_TRACEPOINT_EVENT(rt_sigpending, - TP_PROTO(sc_exit(long ret,) sigset_t * set, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) set, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(sigset_t *, set, set)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) -) -#endif -#ifndef OVERRIDE_64_utime -SC_LTTNG_TRACEPOINT_EVENT(utime, - TP_PROTO(sc_exit(long ret,) char * filename, struct utimbuf * times), - TP_ARGS(sc_exit(ret,) filename, times), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(struct utimbuf *, times, times))) -) -#endif -#ifndef OVERRIDE_64_ustat -SC_LTTNG_TRACEPOINT_EVENT(ustat, - TP_PROTO(sc_exit(long ret,) unsigned dev, struct ustat * ubuf), - TP_ARGS(sc_exit(ret,) dev, ubuf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned, dev, dev)) sc_out(ctf_integer(struct ustat *, ubuf, ubuf))) -) -#endif -#ifndef OVERRIDE_64_statfs -SC_LTTNG_TRACEPOINT_EVENT(statfs, - TP_PROTO(sc_exit(long ret,) const char * pathname, struct statfs * buf), - TP_ARGS(sc_exit(ret,) pathname, buf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(struct statfs *, buf, buf))) -) -#endif -#ifndef OVERRIDE_64_fstatfs -SC_LTTNG_TRACEPOINT_EVENT(fstatfs, - TP_PROTO(sc_exit(long ret,) unsigned int fd, struct statfs * buf), - TP_ARGS(sc_exit(ret,) fd, buf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct statfs *, buf, buf))) -) -#endif -#ifndef OVERRIDE_64_sched_rr_get_interval -SC_LTTNG_TRACEPOINT_EVENT(sched_rr_get_interval, - TP_PROTO(sc_exit(long ret,) pid_t pid, struct timespec * interval), - TP_ARGS(sc_exit(ret,) pid, interval), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_out(ctf_integer(struct timespec *, interval, interval))) -) -#endif -#ifndef OVERRIDE_64_setrlimit -SC_LTTNG_TRACEPOINT_EVENT(setrlimit, - TP_PROTO(sc_exit(long ret,) unsigned int resource, struct rlimit * rlim), - TP_ARGS(sc_exit(ret,) resource, rlim), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, resource, resource)) sc_in(ctf_integer(struct rlimit *, rlim, rlim))) -) -#endif -#ifndef OVERRIDE_64_settimeofday -SC_LTTNG_TRACEPOINT_EVENT(settimeofday, - TP_PROTO(sc_exit(long ret,) struct timeval * tv, struct timezone * tz), - TP_ARGS(sc_exit(ret,) tv, tz), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct timeval *, tv, tv)) sc_in(ctf_integer(struct timezone *, tz, tz))) -) -#endif -#ifndef OVERRIDE_64_io_setup -SC_LTTNG_TRACEPOINT_EVENT(io_setup, - TP_PROTO(sc_exit(long ret,) unsigned nr_events, aio_context_t * ctxp), - TP_ARGS(sc_exit(ret,) nr_events, ctxp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned, nr_events, nr_events)) sc_in(ctf_integer(aio_context_t *, ctxp, ctxp))) -) -#endif -#ifndef OVERRIDE_64_timer_gettime -SC_LTTNG_TRACEPOINT_EVENT(timer_gettime, - TP_PROTO(sc_exit(long ret,) timer_t timer_id, struct itimerspec * setting), - TP_ARGS(sc_exit(ret,) timer_id, setting), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id)) sc_out(ctf_integer(struct itimerspec *, setting, setting))) -) -#endif -#ifndef OVERRIDE_64_clock_settime -SC_LTTNG_TRACEPOINT_EVENT(clock_settime, - TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, const struct timespec * tp), - TP_ARGS(sc_exit(ret,) which_clock, tp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_in(ctf_integer(const struct timespec *, tp, tp))) -) -#endif -#ifndef OVERRIDE_64_clock_gettime -SC_LTTNG_TRACEPOINT_EVENT(clock_gettime, - TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct timespec * tp), - TP_ARGS(sc_exit(ret,) which_clock, tp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_out(ctf_integer(struct timespec *, tp, tp))) -) -#endif -#ifndef OVERRIDE_64_clock_getres -SC_LTTNG_TRACEPOINT_EVENT(clock_getres, - TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct timespec * tp), - TP_ARGS(sc_exit(ret,) which_clock, tp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_out(ctf_integer(struct timespec *, tp, tp))) -) -#endif -#ifndef OVERRIDE_64_utimes -SC_LTTNG_TRACEPOINT_EVENT(utimes, - TP_PROTO(sc_exit(long ret,) char * filename, struct timeval * utimes), - TP_ARGS(sc_exit(ret,) filename, utimes), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(struct timeval *, utimes, utimes))) -) -#endif -#ifndef OVERRIDE_64_set_robust_list -SC_LTTNG_TRACEPOINT_EVENT(set_robust_list, - TP_PROTO(sc_exit(long ret,) struct robust_list_head * head, size_t len), - TP_ARGS(sc_exit(ret,) head, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct robust_list_head *, head, head)) sc_in(ctf_integer(size_t, len, len))) -) -#endif -#ifndef OVERRIDE_64_timerfd_gettime -SC_LTTNG_TRACEPOINT_EVENT(timerfd_gettime, - TP_PROTO(sc_exit(long ret,) int ufd, struct itimerspec * otmr), - TP_ARGS(sc_exit(ret,) ufd, otmr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_out(ctf_integer(struct itimerspec *, otmr, otmr))) -) -#endif -#ifndef OVERRIDE_64_clock_adjtime -SC_LTTNG_TRACEPOINT_EVENT(clock_adjtime, - TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct timex * utx), - TP_ARGS(sc_exit(ret,) which_clock, utx), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_inout(ctf_integer(struct timex *, utx, utx))) -) -#endif -#ifndef OVERRIDE_64_newstat -SC_LTTNG_TRACEPOINT_EVENT(newstat, - TP_PROTO(sc_exit(long ret,) const char * filename, struct stat * statbuf), - TP_ARGS(sc_exit(ret,) filename, statbuf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_out(ctf_integer(struct stat *, statbuf, statbuf))) -) -#endif -#ifndef OVERRIDE_64_newfstat -SC_LTTNG_TRACEPOINT_EVENT(newfstat, - TP_PROTO(sc_exit(long ret,) unsigned int fd, struct stat * statbuf), - TP_ARGS(sc_exit(ret,) fd, statbuf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct stat *, statbuf, statbuf))) -) -#endif -#ifndef OVERRIDE_64_newlstat -SC_LTTNG_TRACEPOINT_EVENT(newlstat, - TP_PROTO(sc_exit(long ret,) const char * filename, struct stat * statbuf), - TP_ARGS(sc_exit(ret,) filename, statbuf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_out(ctf_integer(struct stat *, statbuf, statbuf))) -) -#endif -#ifndef OVERRIDE_64_access -SC_LTTNG_TRACEPOINT_EVENT(access, - TP_PROTO(sc_exit(long ret,) const char * filename, int mode), - TP_ARGS(sc_exit(ret,) filename, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, mode, mode))) -) -#endif -#ifndef OVERRIDE_64_truncate -SC_LTTNG_TRACEPOINT_EVENT(truncate, - TP_PROTO(sc_exit(long ret,) const char * path, long length), - TP_ARGS(sc_exit(ret,) path, length), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(path, path)) sc_in(ctf_integer(long, length, length))) -) -#endif -#ifndef OVERRIDE_64_getcwd -SC_LTTNG_TRACEPOINT_EVENT(getcwd, - TP_PROTO(sc_exit(long ret,) char * buf, unsigned long size), - TP_ARGS(sc_exit(ret,) buf, size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(unsigned long, size, size))) -) -#endif -#ifndef OVERRIDE_64_rename -SC_LTTNG_TRACEPOINT_EVENT(rename, - TP_PROTO(sc_exit(long ret,) const char * oldname, const char * newname), - TP_ARGS(sc_exit(ret,) oldname, newname), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_user_string(newname, newname))) -) -#endif -#ifndef OVERRIDE_64_mkdir -SC_LTTNG_TRACEPOINT_EVENT(mkdir, - TP_PROTO(sc_exit(long ret,) const char * pathname, umode_t mode), - TP_ARGS(sc_exit(ret,) pathname, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(umode_t, mode, mode))) -) -#endif -#ifndef OVERRIDE_64_creat -SC_LTTNG_TRACEPOINT_EVENT(creat, - TP_PROTO(sc_exit(long ret,) const char * pathname, umode_t mode), - TP_ARGS(sc_exit(ret,) pathname, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(umode_t, mode, mode))) -) -#endif -#ifndef OVERRIDE_64_link -SC_LTTNG_TRACEPOINT_EVENT(link, - TP_PROTO(sc_exit(long ret,) const char * oldname, const char * newname), - TP_ARGS(sc_exit(ret,) oldname, newname), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_user_string(newname, newname))) -) -#endif -#ifndef OVERRIDE_64_symlink -SC_LTTNG_TRACEPOINT_EVENT(symlink, - TP_PROTO(sc_exit(long ret,) const char * oldname, const char * newname), - TP_ARGS(sc_exit(ret,) oldname, newname), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_user_string(newname, newname))) -) -#endif -#ifndef OVERRIDE_64_chmod -SC_LTTNG_TRACEPOINT_EVENT(chmod, - TP_PROTO(sc_exit(long ret,) const char * filename, umode_t mode), - TP_ARGS(sc_exit(ret,) filename, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(umode_t, mode, mode))) -) -#endif -#ifndef OVERRIDE_64_getgroups -SC_LTTNG_TRACEPOINT_EVENT(getgroups, - TP_PROTO(sc_exit(long ret,) int gidsetsize, gid_t * grouplist), - TP_ARGS(sc_exit(ret,) gidsetsize, grouplist), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, gidsetsize, gidsetsize)) sc_out(ctf_integer(gid_t *, grouplist, grouplist))) -) -#endif -#ifndef OVERRIDE_64_setgroups -SC_LTTNG_TRACEPOINT_EVENT(setgroups, - TP_PROTO(sc_exit(long ret,) int gidsetsize, gid_t * grouplist), - TP_ARGS(sc_exit(ret,) gidsetsize, grouplist), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, gidsetsize, gidsetsize)) sc_in(ctf_integer(gid_t *, grouplist, grouplist))) -) -#endif -#ifndef OVERRIDE_64_32_rt_sigpending -SC_LTTNG_TRACEPOINT_EVENT(32_rt_sigpending, - TP_PROTO(sc_exit(long ret,) compat_sigset_t * uset, unsigned int sigsetsize), - TP_ARGS(sc_exit(ret,) uset, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(compat_sigset_t *, uset, uset)) sc_inout(ctf_integer(unsigned int, sigsetsize, sigsetsize))) -) -#endif -#ifndef OVERRIDE_64_sched_setparam -SC_LTTNG_TRACEPOINT_EVENT(sched_setparam, - TP_PROTO(sc_exit(long ret,) pid_t pid, struct sched_param * param), - TP_ARGS(sc_exit(ret,) pid, param), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(struct sched_param *, param, param))) -) -#endif -#ifndef OVERRIDE_64_sched_getparam -SC_LTTNG_TRACEPOINT_EVENT(sched_getparam, - TP_PROTO(sc_exit(long ret,) pid_t pid, struct sched_param * param), - TP_ARGS(sc_exit(ret,) pid, param), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_out(ctf_integer(struct sched_param *, param, param))) -) -#endif -#ifndef OVERRIDE_64_32_sched_rr_get_interval -SC_LTTNG_TRACEPOINT_EVENT(32_sched_rr_get_interval, - TP_PROTO(sc_exit(long ret,) compat_pid_t pid, struct compat_timespec * interval), - TP_ARGS(sc_exit(ret,) pid, interval), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(compat_pid_t, pid, pid)) sc_inout(ctf_integer(struct compat_timespec *, interval, interval))) -) -#endif -#ifndef OVERRIDE_64_pivot_root -SC_LTTNG_TRACEPOINT_EVENT(pivot_root, - TP_PROTO(sc_exit(long ret,) const char * new_root, const char * put_old), - TP_ARGS(sc_exit(ret,) new_root, put_old), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(new_root, new_root)) sc_in(ctf_user_string(put_old, put_old))) -) -#endif -#ifndef OVERRIDE_64_umount -SC_LTTNG_TRACEPOINT_EVENT(umount, - TP_PROTO(sc_exit(long ret,) char * name, int flags), - TP_ARGS(sc_exit(ret,) name, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_swapon -SC_LTTNG_TRACEPOINT_EVENT(swapon, - TP_PROTO(sc_exit(long ret,) const char * specialfile, int swap_flags), - TP_ARGS(sc_exit(ret,) specialfile, swap_flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(specialfile, specialfile)) sc_in(ctf_integer(int, swap_flags, swap_flags))) -) -#endif -#ifndef OVERRIDE_64_sethostname -SC_LTTNG_TRACEPOINT_EVENT(sethostname, - TP_PROTO(sc_exit(long ret,) char * name, int len), - TP_ARGS(sc_exit(ret,) name, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(int, len, len))) -) -#endif -#ifndef OVERRIDE_64_setdomainname -SC_LTTNG_TRACEPOINT_EVENT(setdomainname, - TP_PROTO(sc_exit(long ret,) char * name, int len), - TP_ARGS(sc_exit(ret,) name, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(int, len, len))) -) -#endif -#ifndef OVERRIDE_64_delete_module -SC_LTTNG_TRACEPOINT_EVENT(delete_module, - TP_PROTO(sc_exit(long ret,) const char * name_user, unsigned int flags), - TP_ARGS(sc_exit(ret,) name_user, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name_user, name_user)) sc_in(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_removexattr -SC_LTTNG_TRACEPOINT_EVENT(removexattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name), - TP_ARGS(sc_exit(ret,) pathname, name), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name))) -) -#endif -#ifndef OVERRIDE_64_lremovexattr -SC_LTTNG_TRACEPOINT_EVENT(lremovexattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name), - TP_ARGS(sc_exit(ret,) pathname, name), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name))) -) -#endif -#ifndef OVERRIDE_64_fremovexattr -SC_LTTNG_TRACEPOINT_EVENT(fremovexattr, - TP_PROTO(sc_exit(long ret,) int fd, const char * name), - TP_ARGS(sc_exit(ret,) fd, name), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(name, name))) -) -#endif -#ifndef OVERRIDE_64_pipe2 -SC_LTTNG_TRACEPOINT_EVENT(pipe2, - TP_PROTO(sc_exit(long ret,) int * fildes, int flags), - TP_ARGS(sc_exit(ret,) fildes, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(int *, fildes, fildes)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_waitpid -SC_LTTNG_TRACEPOINT_EVENT(waitpid, - TP_PROTO(sc_exit(long ret,) pid_t pid, int * stat_addr, int options), - TP_ARGS(sc_exit(ret,) pid, stat_addr, options), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(pid_t, pid, pid)) sc_inout(ctf_integer(int *, stat_addr, stat_addr)) sc_inout(ctf_integer(int, options, options))) -) -#endif -#ifndef OVERRIDE_64_32_sigaction -SC_LTTNG_TRACEPOINT_EVENT(32_sigaction, - TP_PROTO(sc_exit(long ret,) long sig, const struct sigaction32 * act, struct sigaction32 * oact), - TP_ARGS(sc_exit(ret,) sig, act, oact), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(long, sig, sig)) sc_inout(ctf_integer(const struct sigaction32 *, act, act)) sc_inout(ctf_integer(struct sigaction32 *, oact, oact))) -) -#endif -#ifndef OVERRIDE_64_readv -SC_LTTNG_TRACEPOINT_EVENT(readv, - TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen), - TP_ARGS(sc_exit(ret,) fd, vec, vlen), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_inout(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen))) -) -#endif -#ifndef OVERRIDE_64_writev -SC_LTTNG_TRACEPOINT_EVENT(writev, - TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen), - TP_ARGS(sc_exit(ret,) fd, vec, vlen), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_inout(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen))) -) -#endif -#ifndef OVERRIDE_64_shmctl -SC_LTTNG_TRACEPOINT_EVENT(shmctl, - TP_PROTO(sc_exit(long ret,) int shmid, int cmd, struct shmid_ds * buf), - TP_ARGS(sc_exit(ret,) shmid, cmd, buf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, shmid, shmid)) sc_in(ctf_integer(int, cmd, cmd)) sc_inout(ctf_integer(struct shmid_ds *, buf, buf))) -) -#endif -#ifndef OVERRIDE_64_setitimer -SC_LTTNG_TRACEPOINT_EVENT(setitimer, - TP_PROTO(sc_exit(long ret,) int which, struct itimerval * value, struct itimerval * ovalue), - TP_ARGS(sc_exit(ret,) which, value, ovalue), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(struct itimerval *, value, value)) sc_out(ctf_integer(struct itimerval *, ovalue, ovalue))) -) -#endif -#ifndef OVERRIDE_64_sendmsg -SC_LTTNG_TRACEPOINT_EVENT(sendmsg, - TP_PROTO(sc_exit(long ret,) int fd, struct msghdr * msg, unsigned int flags), - TP_ARGS(sc_exit(ret,) fd, msg, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct msghdr *, msg, msg)) sc_in(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_recvmsg -SC_LTTNG_TRACEPOINT_EVENT(recvmsg, - TP_PROTO(sc_exit(long ret,) int fd, struct msghdr * msg, unsigned int flags), - TP_ARGS(sc_exit(ret,) fd, msg, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_inout(ctf_integer(struct msghdr *, msg, msg)) sc_in(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_msgctl -SC_LTTNG_TRACEPOINT_EVENT(msgctl, - TP_PROTO(sc_exit(long ret,) int msqid, int cmd, struct msqid_ds * buf), - TP_ARGS(sc_exit(ret,) msqid, cmd, buf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, msqid, msqid)) sc_in(ctf_integer(int, cmd, cmd)) sc_inout(ctf_integer(struct msqid_ds *, buf, buf))) -) -#endif -#ifndef OVERRIDE_64_getdents -SC_LTTNG_TRACEPOINT_EVENT(getdents, - TP_PROTO(sc_exit(long ret,) unsigned int fd, struct linux_dirent * dirent, unsigned int count), - TP_ARGS(sc_exit(ret,) fd, dirent, count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct linux_dirent *, dirent, dirent)) sc_in(ctf_integer(unsigned int, count, count))) -) -#endif -#ifndef OVERRIDE_64_rt_sigqueueinfo -SC_LTTNG_TRACEPOINT_EVENT(rt_sigqueueinfo, - TP_PROTO(sc_exit(long ret,) pid_t pid, int sig, siginfo_t * uinfo), - TP_ARGS(sc_exit(ret,) pid, sig, uinfo), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig)) sc_in(ctf_integer(siginfo_t *, uinfo, uinfo))) -) -#endif -#ifndef OVERRIDE_64_sched_setaffinity -SC_LTTNG_TRACEPOINT_EVENT(sched_setaffinity, - TP_PROTO(sc_exit(long ret,) pid_t pid, unsigned int len, unsigned long * user_mask_ptr), - TP_ARGS(sc_exit(ret,) pid, len, user_mask_ptr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(unsigned int, len, len)) sc_in(ctf_integer(unsigned long *, user_mask_ptr, user_mask_ptr))) -) -#endif -#ifndef OVERRIDE_64_sched_getaffinity -SC_LTTNG_TRACEPOINT_EVENT(sched_getaffinity, - TP_PROTO(sc_exit(long ret,) pid_t pid, unsigned int len, unsigned long * user_mask_ptr), - TP_ARGS(sc_exit(ret,) pid, len, user_mask_ptr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(unsigned int, len, len)) sc_out(ctf_integer(unsigned long *, user_mask_ptr, user_mask_ptr))) -) -#endif -#ifndef OVERRIDE_64_io_submit -SC_LTTNG_TRACEPOINT_EVENT(io_submit, - TP_PROTO(sc_exit(long ret,) aio_context_t ctx_id, long nr, struct iocb * * iocbpp), - TP_ARGS(sc_exit(ret,) ctx_id, nr, iocbpp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx_id, ctx_id)) sc_in(ctf_integer(long, nr, nr)) sc_in(ctf_integer(struct iocb * *, iocbpp, iocbpp))) -) -#endif -#ifndef OVERRIDE_64_timer_create -SC_LTTNG_TRACEPOINT_EVENT(timer_create, - TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct sigevent * timer_event_spec, timer_t * created_timer_id), - TP_ARGS(sc_exit(ret,) which_clock, timer_event_spec, created_timer_id), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_in(ctf_integer(struct sigevent *, timer_event_spec, timer_event_spec)) sc_out(ctf_integer(timer_t *, created_timer_id, created_timer_id))) -) -#endif -#ifndef OVERRIDE_64_futimesat -SC_LTTNG_TRACEPOINT_EVENT(futimesat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, struct timeval * utimes), - TP_ARGS(sc_exit(ret,) dfd, filename, utimes), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(struct timeval *, utimes, utimes))) -) -#endif -#ifndef OVERRIDE_64_get_robust_list -SC_LTTNG_TRACEPOINT_EVENT(get_robust_list, - TP_PROTO(sc_exit(long ret,) int pid, struct robust_list_head * * head_ptr, size_t * len_ptr), - TP_ARGS(sc_exit(ret,) pid, head_ptr, len_ptr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, pid, pid)) sc_out(ctf_integer(struct robust_list_head * *, head_ptr, head_ptr)) sc_out(ctf_integer(size_t *, len_ptr, len_ptr))) -) -#endif -#ifndef OVERRIDE_64_signalfd -SC_LTTNG_TRACEPOINT_EVENT(signalfd, - TP_PROTO(sc_exit(long ret,) int ufd, sigset_t * user_mask, size_t sizemask), - TP_ARGS(sc_exit(ret,) ufd, user_mask, sizemask), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_in(ctf_integer(sigset_t *, user_mask, user_mask)) sc_in(ctf_integer(size_t, sizemask, sizemask))) -) -#endif -#ifndef OVERRIDE_64_read -SC_LTTNG_TRACEPOINT_EVENT(read, - TP_PROTO(sc_exit(long ret,) unsigned int fd, char * buf, size_t count), - TP_ARGS(sc_exit(ret,) fd, buf, count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(size_t, count, count))) -) -#endif -#ifndef OVERRIDE_64_write -SC_LTTNG_TRACEPOINT_EVENT(write, - TP_PROTO(sc_exit(long ret,) unsigned int fd, const char * buf, size_t count), - TP_ARGS(sc_exit(ret,) fd, buf, count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(const char *, buf, buf)) sc_in(ctf_integer(size_t, count, count))) -) -#endif -#ifndef OVERRIDE_64_open -SC_LTTNG_TRACEPOINT_EVENT(open, - TP_PROTO(sc_exit(long ret,) const char * filename, int flags, umode_t mode), - TP_ARGS(sc_exit(ret,) filename, flags, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(umode_t, mode, mode))) -) -#endif -#ifndef OVERRIDE_64_poll -SC_LTTNG_TRACEPOINT_EVENT(poll, - TP_PROTO(sc_exit(long ret,) struct pollfd * ufds, unsigned int nfds, int timeout_msecs), - TP_ARGS(sc_exit(ret,) ufds, nfds, timeout_msecs), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct pollfd *, ufds, ufds)) sc_in(ctf_integer(unsigned int, nfds, nfds)) sc_in(ctf_integer(int, timeout_msecs, timeout_msecs))) -) -#endif -#ifndef OVERRIDE_64_mincore -SC_LTTNG_TRACEPOINT_EVENT(mincore, - TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len, unsigned char * vec), - TP_ARGS(sc_exit(ret,) start, len, vec), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len)) sc_out(ctf_integer(unsigned char *, vec, vec))) -) -#endif -#ifndef OVERRIDE_64_shmat -SC_LTTNG_TRACEPOINT_EVENT(shmat, - TP_PROTO(sc_exit(long ret,) int shmid, char * shmaddr, int shmflg), - TP_ARGS(sc_exit(ret,) shmid, shmaddr, shmflg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, shmid, shmid)) sc_in(ctf_integer(char *, shmaddr, shmaddr)) sc_in(ctf_integer(int, shmflg, shmflg))) -) -#endif -#ifndef OVERRIDE_64_connect -SC_LTTNG_TRACEPOINT_EVENT(connect, - TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * uservaddr, int addrlen), - TP_ARGS(sc_exit(ret,) fd, uservaddr, addrlen), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct sockaddr *, uservaddr, uservaddr)) sc_in(ctf_integer(int, addrlen, addrlen))) -) -#endif -#ifndef OVERRIDE_64_accept -SC_LTTNG_TRACEPOINT_EVENT(accept, - TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * upeer_sockaddr, int * upeer_addrlen), - TP_ARGS(sc_exit(ret,) fd, upeer_sockaddr, upeer_addrlen), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct sockaddr *, upeer_sockaddr, upeer_sockaddr)) sc_inout(ctf_integer(int *, upeer_addrlen, upeer_addrlen))) -) -#endif -#ifndef OVERRIDE_64_bind -SC_LTTNG_TRACEPOINT_EVENT(bind, - TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * umyaddr, int addrlen), - TP_ARGS(sc_exit(ret,) fd, umyaddr, addrlen), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct sockaddr *, umyaddr, umyaddr)) sc_in(ctf_integer(int, addrlen, addrlen))) -) -#endif -#ifndef OVERRIDE_64_getsockname -SC_LTTNG_TRACEPOINT_EVENT(getsockname, - TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * usockaddr, int * usockaddr_len), - TP_ARGS(sc_exit(ret,) fd, usockaddr, usockaddr_len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct sockaddr *, usockaddr, usockaddr)) sc_inout(ctf_integer(int *, usockaddr_len, usockaddr_len))) -) -#endif -#ifndef OVERRIDE_64_getpeername -SC_LTTNG_TRACEPOINT_EVENT(getpeername, - TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * usockaddr, int * usockaddr_len), - TP_ARGS(sc_exit(ret,) fd, usockaddr, usockaddr_len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct sockaddr *, usockaddr, usockaddr)) sc_inout(ctf_integer(int *, usockaddr_len, usockaddr_len))) -) -#endif -#ifndef OVERRIDE_64_semop -SC_LTTNG_TRACEPOINT_EVENT(semop, - TP_PROTO(sc_exit(long ret,) int semid, struct sembuf * tsops, unsigned nsops), - TP_ARGS(sc_exit(ret,) semid, tsops, nsops), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, semid, semid)) sc_in(ctf_integer(struct sembuf *, tsops, tsops)) sc_in(ctf_integer(unsigned, nsops, nsops))) -) -#endif -#ifndef OVERRIDE_64_readlink -SC_LTTNG_TRACEPOINT_EVENT(readlink, - TP_PROTO(sc_exit(long ret,) const char * path, char * buf, int bufsiz), - TP_ARGS(sc_exit(ret,) path, buf, bufsiz), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(path, path)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(int, bufsiz, bufsiz))) -) -#endif -#ifndef OVERRIDE_64_chown -SC_LTTNG_TRACEPOINT_EVENT(chown, - TP_PROTO(sc_exit(long ret,) const char * filename, uid_t user, gid_t group), - TP_ARGS(sc_exit(ret,) filename, user, group), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group))) -) -#endif -#ifndef OVERRIDE_64_lchown -SC_LTTNG_TRACEPOINT_EVENT(lchown, - TP_PROTO(sc_exit(long ret,) const char * filename, uid_t user, gid_t group), - TP_ARGS(sc_exit(ret,) filename, user, group), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group))) -) -#endif -#ifndef OVERRIDE_64_syslog -SC_LTTNG_TRACEPOINT_EVENT(syslog, - TP_PROTO(sc_exit(long ret,) int type, char * buf, int len), - TP_ARGS(sc_exit(ret,) type, buf, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, type, type)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(int, len, len))) -) -#endif -#ifndef OVERRIDE_64_getresuid -SC_LTTNG_TRACEPOINT_EVENT(getresuid, - TP_PROTO(sc_exit(long ret,) uid_t * ruidp, uid_t * euidp, uid_t * suidp), - TP_ARGS(sc_exit(ret,) ruidp, euidp, suidp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(uid_t *, ruidp, ruidp)) sc_out(ctf_integer(uid_t *, euidp, euidp)) sc_out(ctf_integer(uid_t *, suidp, suidp))) -) -#endif -#ifndef OVERRIDE_64_getresgid -SC_LTTNG_TRACEPOINT_EVENT(getresgid, - TP_PROTO(sc_exit(long ret,) gid_t * rgidp, gid_t * egidp, gid_t * sgidp), - TP_ARGS(sc_exit(ret,) rgidp, egidp, sgidp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(gid_t *, rgidp, rgidp)) sc_out(ctf_integer(gid_t *, egidp, egidp)) sc_out(ctf_integer(gid_t *, sgidp, sgidp))) -) -#endif -#ifndef OVERRIDE_64_32_rt_sigqueueinfo -SC_LTTNG_TRACEPOINT_EVENT(32_rt_sigqueueinfo, - TP_PROTO(sc_exit(long ret,) int pid, int sig, compat_siginfo_t * uinfo), - TP_ARGS(sc_exit(ret,) pid, sig, uinfo), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, pid, pid)) sc_inout(ctf_integer(int, sig, sig)) sc_inout(ctf_integer(compat_siginfo_t *, uinfo, uinfo))) -) -#endif -#ifndef OVERRIDE_64_mknod -SC_LTTNG_TRACEPOINT_EVENT(mknod, - TP_PROTO(sc_exit(long ret,) const char * filename, umode_t mode, unsigned dev), - TP_ARGS(sc_exit(ret,) filename, mode, dev), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(umode_t, mode, mode)) sc_in(ctf_integer(unsigned, dev, dev))) -) -#endif -#ifndef OVERRIDE_64_sched_setscheduler -SC_LTTNG_TRACEPOINT_EVENT(sched_setscheduler, - TP_PROTO(sc_exit(long ret,) pid_t pid, int policy, struct sched_param * param), - TP_ARGS(sc_exit(ret,) pid, policy, param), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, policy, policy)) sc_in(ctf_integer(struct sched_param *, param, param))) -) -#endif -#ifndef OVERRIDE_64_init_module -SC_LTTNG_TRACEPOINT_EVENT(init_module, - TP_PROTO(sc_exit(long ret,) void * umod, unsigned long len, const char * uargs), - TP_ARGS(sc_exit(ret,) umod, len, uargs), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(void *, umod, umod)) sc_in(ctf_integer(unsigned long, len, len)) sc_in(ctf_integer(const char *, uargs, uargs))) -) -#endif -#ifndef OVERRIDE_64_listxattr -SC_LTTNG_TRACEPOINT_EVENT(listxattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, char * list, size_t size), - TP_ARGS(sc_exit(ret,) pathname, list, size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(char *, list, list)) sc_in(ctf_integer(size_t, size, size))) -) -#endif -#ifndef OVERRIDE_64_llistxattr -SC_LTTNG_TRACEPOINT_EVENT(llistxattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, char * list, size_t size), - TP_ARGS(sc_exit(ret,) pathname, list, size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(char *, list, list)) sc_in(ctf_integer(size_t, size, size))) -) -#endif -#ifndef OVERRIDE_64_flistxattr -SC_LTTNG_TRACEPOINT_EVENT(flistxattr, - TP_PROTO(sc_exit(long ret,) int fd, char * list, size_t size), - TP_ARGS(sc_exit(ret,) fd, list, size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(char *, list, list)) sc_in(ctf_integer(size_t, size, size))) -) -#endif -#ifndef OVERRIDE_64_cachectl -SC_LTTNG_TRACEPOINT_EVENT(cachectl, - TP_PROTO(sc_exit(long ret,) char * addr, int nbytes, int op), - TP_ARGS(sc_exit(ret,) addr, nbytes, op), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(char *, addr, addr)) sc_inout(ctf_integer(int, nbytes, nbytes)) sc_inout(ctf_integer(int, op, op))) -) -#endif -#ifndef OVERRIDE_64_io_cancel -SC_LTTNG_TRACEPOINT_EVENT(io_cancel, - TP_PROTO(sc_exit(long ret,) aio_context_t ctx_id, struct iocb * iocb, struct io_event * result), - TP_ARGS(sc_exit(ret,) ctx_id, iocb, result), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx_id, ctx_id)) sc_in(ctf_integer(struct iocb *, iocb, iocb)) sc_out(ctf_integer(struct io_event *, result, result))) -) -#endif -#ifndef OVERRIDE_64_inotify_add_watch -SC_LTTNG_TRACEPOINT_EVENT(inotify_add_watch, - TP_PROTO(sc_exit(long ret,) int fd, const char * pathname, u32 mask), - TP_ARGS(sc_exit(ret,) fd, pathname, mask), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(u32, mask, mask))) -) -#endif -#ifndef OVERRIDE_64_mkdirat -SC_LTTNG_TRACEPOINT_EVENT(mkdirat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * pathname, umode_t mode), - TP_ARGS(sc_exit(ret,) dfd, pathname, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(umode_t, mode, mode))) -) -#endif -#ifndef OVERRIDE_64_unlinkat -SC_LTTNG_TRACEPOINT_EVENT(unlinkat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * pathname, int flag), - TP_ARGS(sc_exit(ret,) dfd, pathname, flag), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(int, flag, flag))) -) -#endif -#ifndef OVERRIDE_64_symlinkat -SC_LTTNG_TRACEPOINT_EVENT(symlinkat, - TP_PROTO(sc_exit(long ret,) const char * oldname, int newdfd, const char * newname), - TP_ARGS(sc_exit(ret,) oldname, newdfd, newname), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_integer(int, newdfd, newdfd)) sc_in(ctf_user_string(newname, newname))) -) -#endif -#ifndef OVERRIDE_64_fchmodat -SC_LTTNG_TRACEPOINT_EVENT(fchmodat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, umode_t mode), - TP_ARGS(sc_exit(ret,) dfd, filename, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(umode_t, mode, mode))) -) -#endif -#ifndef OVERRIDE_64_faccessat -SC_LTTNG_TRACEPOINT_EVENT(faccessat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, int mode), - TP_ARGS(sc_exit(ret,) dfd, filename, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, mode, mode))) -) -#endif -#ifndef OVERRIDE_64_getcpu -SC_LTTNG_TRACEPOINT_EVENT(getcpu, - TP_PROTO(sc_exit(long ret,) unsigned * cpup, unsigned * nodep, struct getcpu_cache * unused), - TP_ARGS(sc_exit(ret,) cpup, nodep, unused), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(unsigned *, cpup, cpup)) sc_out(ctf_integer(unsigned *, nodep, nodep)) sc_inout(ctf_integer(struct getcpu_cache *, unused, unused))) -) -#endif -#ifndef OVERRIDE_64_getdents64 -SC_LTTNG_TRACEPOINT_EVENT(getdents64, - TP_PROTO(sc_exit(long ret,) unsigned int fd, struct linux_dirent64 * dirent, unsigned int count), - TP_ARGS(sc_exit(ret,) fd, dirent, count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct linux_dirent64 *, dirent, dirent)) sc_in(ctf_integer(unsigned int, count, count))) -) -#endif -#ifndef OVERRIDE_64_send -SC_LTTNG_TRACEPOINT_EVENT(send, - TP_PROTO(sc_exit(long ret,) int fd, void * buff, size_t len, unsigned int flags), - TP_ARGS(sc_exit(ret,) fd, buff, len, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, fd, fd)) sc_inout(ctf_integer(void *, buff, buff)) sc_inout(ctf_integer(size_t, len, len)) sc_inout(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_32_truncate64 -SC_LTTNG_TRACEPOINT_EVENT(32_truncate64, - TP_PROTO(sc_exit(long ret,) const char * path, unsigned long __dummy, unsigned long a2, unsigned long a3), - TP_ARGS(sc_exit(ret,) path, __dummy, a2, a3), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(path, path)) sc_inout(ctf_integer(unsigned long, __dummy, __dummy)) sc_inout(ctf_integer(unsigned long, a2, a2)) sc_inout(ctf_integer(unsigned long, a3, a3))) -) -#endif -#ifndef OVERRIDE_64_rt_sigaction -SC_LTTNG_TRACEPOINT_EVENT(rt_sigaction, - TP_PROTO(sc_exit(long ret,) int sig, const struct sigaction * act, struct sigaction * oact, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) sig, act, oact, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, sig, sig)) sc_in(ctf_integer(const struct sigaction *, act, act)) sc_out(ctf_integer(struct sigaction *, oact, oact)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) -) -#endif -#ifndef OVERRIDE_64_rt_sigprocmask -SC_LTTNG_TRACEPOINT_EVENT(rt_sigprocmask, - TP_PROTO(sc_exit(long ret,) int how, sigset_t * nset, sigset_t * oset, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) how, nset, oset, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, how, how)) sc_in(ctf_integer(sigset_t *, nset, nset)) sc_out(ctf_integer(sigset_t *, oset, oset)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) -) -#endif -#ifndef OVERRIDE_64_wait4 -SC_LTTNG_TRACEPOINT_EVENT(wait4, - TP_PROTO(sc_exit(long ret,) pid_t upid, int * stat_addr, int options, struct rusage * ru), - TP_ARGS(sc_exit(ret,) upid, stat_addr, options, ru), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, upid, upid)) sc_out(ctf_integer(int *, stat_addr, stat_addr)) sc_in(ctf_integer(int, options, options)) sc_out(ctf_integer(struct rusage *, ru, ru))) -) -#endif -#ifndef OVERRIDE_64_msgsnd -SC_LTTNG_TRACEPOINT_EVENT(msgsnd, - TP_PROTO(sc_exit(long ret,) int msqid, struct msgbuf * msgp, size_t msgsz, int msgflg), - TP_ARGS(sc_exit(ret,) msqid, msgp, msgsz, msgflg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, msqid, msqid)) sc_in(ctf_integer(struct msgbuf *, msgp, msgp)) sc_in(ctf_integer(size_t, msgsz, msgsz)) sc_in(ctf_integer(int, msgflg, msgflg))) -) -#endif -#ifndef OVERRIDE_64_rt_sigtimedwait -SC_LTTNG_TRACEPOINT_EVENT(rt_sigtimedwait, - TP_PROTO(sc_exit(long ret,) const sigset_t * uthese, siginfo_t * uinfo, const struct timespec * uts, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) uthese, uinfo, uts, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(const sigset_t *, uthese, uthese)) sc_out(ctf_integer(siginfo_t *, uinfo, uinfo)) sc_in(ctf_integer(const struct timespec *, uts, uts)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) -) -#endif -#ifndef OVERRIDE_64_semtimedop -SC_LTTNG_TRACEPOINT_EVENT(semtimedop, - TP_PROTO(sc_exit(long ret,) int semid, struct sembuf * tsops, unsigned nsops, const struct timespec * timeout), - TP_ARGS(sc_exit(ret,) semid, tsops, nsops, timeout), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, semid, semid)) sc_in(ctf_integer(struct sembuf *, tsops, tsops)) sc_in(ctf_integer(unsigned, nsops, nsops)) sc_inout(ctf_integer(const struct timespec *, timeout, timeout))) -) -#endif -#ifndef OVERRIDE_64_timer_settime -SC_LTTNG_TRACEPOINT_EVENT(timer_settime, - TP_PROTO(sc_exit(long ret,) timer_t timer_id, int flags, const struct itimerspec * new_setting, struct itimerspec * old_setting), - TP_ARGS(sc_exit(ret,) timer_id, flags, new_setting, old_setting), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(const struct itimerspec *, new_setting, new_setting)) sc_out(ctf_integer(struct itimerspec *, old_setting, old_setting))) -) -#endif -#ifndef OVERRIDE_64_clock_nanosleep -SC_LTTNG_TRACEPOINT_EVENT(clock_nanosleep, - TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, int flags, const struct timespec * rqtp, struct timespec * rmtp), - TP_ARGS(sc_exit(ret,) which_clock, flags, rqtp, rmtp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(const struct timespec *, rqtp, rqtp)) sc_out(ctf_integer(struct timespec *, rmtp, rmtp))) -) -#endif -#ifndef OVERRIDE_64_vmsplice -SC_LTTNG_TRACEPOINT_EVENT(vmsplice, - TP_PROTO(sc_exit(long ret,) int fd, const struct iovec * iov, unsigned long nr_segs, unsigned int flags), - TP_ARGS(sc_exit(ret,) fd, iov, nr_segs, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(const struct iovec *, iov, iov)) sc_in(ctf_integer(unsigned long, nr_segs, nr_segs)) sc_in(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_utimensat -SC_LTTNG_TRACEPOINT_EVENT(utimensat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, struct timespec * utimes, int flags), - TP_ARGS(sc_exit(ret,) dfd, filename, utimes, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(struct timespec *, utimes, utimes)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_timerfd_settime -SC_LTTNG_TRACEPOINT_EVENT(timerfd_settime, - TP_PROTO(sc_exit(long ret,) int ufd, int flags, const struct itimerspec * utmr, struct itimerspec * otmr), - TP_ARGS(sc_exit(ret,) ufd, flags, utmr, otmr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(const struct itimerspec *, utmr, utmr)) sc_out(ctf_integer(struct itimerspec *, otmr, otmr))) -) -#endif -#ifndef OVERRIDE_64_rt_tgsigqueueinfo -SC_LTTNG_TRACEPOINT_EVENT(rt_tgsigqueueinfo, - TP_PROTO(sc_exit(long ret,) pid_t tgid, pid_t pid, int sig, siginfo_t * uinfo), - TP_ARGS(sc_exit(ret,) tgid, pid, sig, uinfo), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, tgid, tgid)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig)) sc_in(ctf_integer(siginfo_t *, uinfo, uinfo))) -) -#endif -#ifndef OVERRIDE_64_sendmmsg -SC_LTTNG_TRACEPOINT_EVENT(sendmmsg, - TP_PROTO(sc_exit(long ret,) int fd, struct mmsghdr * mmsg, unsigned int vlen, unsigned int flags), - TP_ARGS(sc_exit(ret,) fd, mmsg, vlen, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct mmsghdr *, mmsg, mmsg)) sc_in(ctf_integer(unsigned int, vlen, vlen)) sc_in(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_32_rt_sigaction -SC_LTTNG_TRACEPOINT_EVENT(32_rt_sigaction, - TP_PROTO(sc_exit(long ret,) int sig, const struct sigaction32 * act, struct sigaction32 * oact, unsigned int sigsetsize), - TP_ARGS(sc_exit(ret,) sig, act, oact, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, sig, sig)) sc_inout(ctf_integer(const struct sigaction32 *, act, act)) sc_inout(ctf_integer(struct sigaction32 *, oact, oact)) sc_inout(ctf_integer(unsigned int, sigsetsize, sigsetsize))) -) -#endif -#ifndef OVERRIDE_64_32_rt_sigprocmask -SC_LTTNG_TRACEPOINT_EVENT(32_rt_sigprocmask, - TP_PROTO(sc_exit(long ret,) int how, compat_sigset_t * set, compat_sigset_t * oset, unsigned int sigsetsize), - TP_ARGS(sc_exit(ret,) how, set, oset, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, how, how)) sc_inout(ctf_integer(compat_sigset_t *, set, set)) sc_inout(ctf_integer(compat_sigset_t *, oset, oset)) sc_inout(ctf_integer(unsigned int, sigsetsize, sigsetsize))) -) -#endif -#ifndef OVERRIDE_64_32_sendfile -SC_LTTNG_TRACEPOINT_EVENT(32_sendfile, - TP_PROTO(sc_exit(long ret,) long out_fd, long in_fd, compat_off_t * offset, s32 count), - TP_ARGS(sc_exit(ret,) out_fd, in_fd, offset, count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(long, out_fd, out_fd)) sc_inout(ctf_integer(long, in_fd, in_fd)) sc_inout(ctf_integer(compat_off_t *, offset, offset)) sc_inout(ctf_integer(s32, count, count))) -) -#endif -#ifndef OVERRIDE_64_socketpair -SC_LTTNG_TRACEPOINT_EVENT(socketpair, - TP_PROTO(sc_exit(long ret,) int family, int type, int protocol, int * usockvec), - TP_ARGS(sc_exit(ret,) family, type, protocol, usockvec), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, family, family)) sc_in(ctf_integer(int, type, type)) sc_in(ctf_integer(int, protocol, protocol)) sc_out(ctf_integer(int *, usockvec, usockvec))) -) -#endif -#ifndef OVERRIDE_64_reboot -SC_LTTNG_TRACEPOINT_EVENT(reboot, - TP_PROTO(sc_exit(long ret,) int magic1, int magic2, unsigned int cmd, void * arg), - TP_ARGS(sc_exit(ret,) magic1, magic2, cmd, arg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, magic1, magic1)) sc_in(ctf_integer(int, magic2, magic2)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_in(ctf_integer(void *, arg, arg))) -) -#endif -#ifndef OVERRIDE_64_quotactl -SC_LTTNG_TRACEPOINT_EVENT(quotactl, - TP_PROTO(sc_exit(long ret,) unsigned int cmd, const char * special, qid_t id, void * addr), - TP_ARGS(sc_exit(ret,) cmd, special, id, addr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_in(ctf_integer(const char *, special, special)) sc_in(ctf_integer(qid_t, id, id)) sc_inout(ctf_integer(void *, addr, addr))) -) -#endif -#ifndef OVERRIDE_64_getxattr -SC_LTTNG_TRACEPOINT_EVENT(getxattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, void * value, size_t size), - TP_ARGS(sc_exit(ret,) pathname, name, value, size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_out(ctf_integer(void *, value, value)) sc_in(ctf_integer(size_t, size, size))) -) -#endif -#ifndef OVERRIDE_64_lgetxattr -SC_LTTNG_TRACEPOINT_EVENT(lgetxattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, void * value, size_t size), - TP_ARGS(sc_exit(ret,) pathname, name, value, size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_out(ctf_integer(void *, value, value)) sc_in(ctf_integer(size_t, size, size))) -) -#endif -#ifndef OVERRIDE_64_fgetxattr -SC_LTTNG_TRACEPOINT_EVENT(fgetxattr, - TP_PROTO(sc_exit(long ret,) int fd, const char * name, void * value, size_t size), - TP_ARGS(sc_exit(ret,) fd, name, value, size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(name, name)) sc_out(ctf_integer(void *, value, value)) sc_in(ctf_integer(size_t, size, size))) -) -#endif -#ifndef OVERRIDE_64_epoll_ctl -SC_LTTNG_TRACEPOINT_EVENT(epoll_ctl, - TP_PROTO(sc_exit(long ret,) int epfd, int op, int fd, struct epoll_event * event), - TP_ARGS(sc_exit(ret,) epfd, op, fd, event), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, epfd, epfd)) sc_in(ctf_integer(int, op, op)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct epoll_event *, event, event))) -) -#endif -#ifndef OVERRIDE_64_epoll_wait -SC_LTTNG_TRACEPOINT_EVENT(epoll_wait, - TP_PROTO(sc_exit(long ret,) int epfd, struct epoll_event * events, int maxevents, int timeout), - TP_ARGS(sc_exit(ret,) epfd, events, maxevents, timeout), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, epfd, epfd)) sc_out(ctf_integer(struct epoll_event *, events, events)) sc_in(ctf_integer(int, maxevents, maxevents)) sc_in(ctf_integer(int, timeout, timeout))) -) -#endif -#ifndef OVERRIDE_64_sendfile64 -SC_LTTNG_TRACEPOINT_EVENT(sendfile64, - TP_PROTO(sc_exit(long ret,) int out_fd, int in_fd, loff_t * offset, size_t count), - TP_ARGS(sc_exit(ret,) out_fd, in_fd, offset, count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, out_fd, out_fd)) sc_in(ctf_integer(int, in_fd, in_fd)) sc_inout(ctf_integer(loff_t *, offset, offset)) sc_in(ctf_integer(size_t, count, count))) -) -#endif -#ifndef OVERRIDE_64_openat -SC_LTTNG_TRACEPOINT_EVENT(openat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, int flags, umode_t mode), - TP_ARGS(sc_exit(ret,) dfd, filename, flags, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(umode_t, mode, mode))) -) -#endif -#ifndef OVERRIDE_64_mknodat -SC_LTTNG_TRACEPOINT_EVENT(mknodat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, umode_t mode, unsigned dev), - TP_ARGS(sc_exit(ret,) dfd, filename, mode, dev), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(umode_t, mode, mode)) sc_in(ctf_integer(unsigned, dev, dev))) -) -#endif -#ifndef OVERRIDE_64_newfstatat -SC_LTTNG_TRACEPOINT_EVENT(newfstatat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, struct stat * statbuf, int flag), - TP_ARGS(sc_exit(ret,) dfd, filename, statbuf, flag), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_out(ctf_integer(struct stat *, statbuf, statbuf)) sc_in(ctf_integer(int, flag, flag))) -) -#endif -#ifndef OVERRIDE_64_renameat -SC_LTTNG_TRACEPOINT_EVENT(renameat, - TP_PROTO(sc_exit(long ret,) int olddfd, const char * oldname, int newdfd, const char * newname), - TP_ARGS(sc_exit(ret,) olddfd, oldname, newdfd, newname), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, olddfd, olddfd)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_integer(int, newdfd, newdfd)) sc_in(ctf_user_string(newname, newname))) -) -#endif -#ifndef OVERRIDE_64_readlinkat -SC_LTTNG_TRACEPOINT_EVENT(readlinkat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * pathname, char * buf, int bufsiz), - TP_ARGS(sc_exit(ret,) dfd, pathname, buf, bufsiz), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(int, bufsiz, bufsiz))) -) -#endif -#ifndef OVERRIDE_64_signalfd4 -SC_LTTNG_TRACEPOINT_EVENT(signalfd4, - TP_PROTO(sc_exit(long ret,) int ufd, sigset_t * user_mask, size_t sizemask, int flags), - TP_ARGS(sc_exit(ret,) ufd, user_mask, sizemask, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_in(ctf_integer(sigset_t *, user_mask, user_mask)) sc_in(ctf_integer(size_t, sizemask, sizemask)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_accept4 -SC_LTTNG_TRACEPOINT_EVENT(accept4, - TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * upeer_sockaddr, int * upeer_addrlen, int flags), - TP_ARGS(sc_exit(ret,) fd, upeer_sockaddr, upeer_addrlen, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct sockaddr *, upeer_sockaddr, upeer_sockaddr)) sc_inout(ctf_integer(int *, upeer_addrlen, upeer_addrlen)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_prlimit64 -SC_LTTNG_TRACEPOINT_EVENT(prlimit64, - TP_PROTO(sc_exit(long ret,) pid_t pid, unsigned int resource, const struct rlimit64 * new_rlim, struct rlimit64 * old_rlim), - TP_ARGS(sc_exit(ret,) pid, resource, new_rlim, old_rlim), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(unsigned int, resource, resource)) sc_in(ctf_integer(const struct rlimit64 *, new_rlim, new_rlim)) sc_out(ctf_integer(struct rlimit64 *, old_rlim, old_rlim))) -) -#endif -#ifndef OVERRIDE_64_32_llseek -SC_LTTNG_TRACEPOINT_EVENT(32_llseek, - TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int offset_high, unsigned int offset_low, loff_t * result, unsigned int origin), - TP_ARGS(sc_exit(ret,) fd, offset_high, offset_low, result, origin), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, fd, fd)) sc_inout(ctf_integer(unsigned int, offset_high, offset_high)) sc_inout(ctf_integer(unsigned int, offset_low, offset_low)) sc_inout(ctf_integer(loff_t *, result, result)) sc_inout(ctf_integer(unsigned int, origin, origin))) -) -#endif -#ifndef OVERRIDE_64_32_waitid -SC_LTTNG_TRACEPOINT_EVENT(32_waitid, - TP_PROTO(sc_exit(long ret,) int which, compat_pid_t pid, compat_siginfo_t * uinfo, int options, struct compat_rusage * uru), - TP_ARGS(sc_exit(ret,) which, pid, uinfo, options, uru), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, which, which)) sc_inout(ctf_integer(compat_pid_t, pid, pid)) sc_inout(ctf_integer(compat_siginfo_t *, uinfo, uinfo)) sc_inout(ctf_integer(int, options, options)) sc_inout(ctf_integer(struct compat_rusage *, uru, uru))) -) -#endif -#ifndef OVERRIDE_64_select -SC_LTTNG_TRACEPOINT_EVENT(select, - TP_PROTO(sc_exit(long ret,) int n, fd_set * inp, fd_set * outp, fd_set * exp, struct timeval * tvp), - TP_ARGS(sc_exit(ret,) n, inp, outp, exp, tvp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, n, n)) sc_inout(ctf_integer(fd_set *, inp, inp)) sc_inout(ctf_integer(fd_set *, outp, outp)) sc_inout(ctf_integer(fd_set *, exp, exp)) sc_inout(ctf_integer(struct timeval *, tvp, tvp))) -) -#endif -#ifndef OVERRIDE_64_setsockopt -SC_LTTNG_TRACEPOINT_EVENT(setsockopt, - TP_PROTO(sc_exit(long ret,) int fd, int level, int optname, char * optval, int optlen), - TP_ARGS(sc_exit(ret,) fd, level, optname, optval, optlen), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, level, level)) sc_in(ctf_integer(int, optname, optname)) sc_in(ctf_integer(char *, optval, optval)) sc_in(ctf_integer(int, optlen, optlen))) -) -#endif -#ifndef OVERRIDE_64_msgrcv -SC_LTTNG_TRACEPOINT_EVENT(msgrcv, - TP_PROTO(sc_exit(long ret,) int msqid, struct msgbuf * msgp, size_t msgsz, long msgtyp, int msgflg), - TP_ARGS(sc_exit(ret,) msqid, msgp, msgsz, msgtyp, msgflg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, msqid, msqid)) sc_out(ctf_integer(struct msgbuf *, msgp, msgp)) sc_in(ctf_integer(size_t, msgsz, msgsz)) sc_in(ctf_integer(long, msgtyp, msgtyp)) sc_in(ctf_integer(int, msgflg, msgflg))) -) -#endif -#ifndef OVERRIDE_64_mount -SC_LTTNG_TRACEPOINT_EVENT(mount, - TP_PROTO(sc_exit(long ret,) char * dev_name, char * dir_name, char * type, unsigned long flags, void * data), - TP_ARGS(sc_exit(ret,) dev_name, dir_name, type, flags, data), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(dev_name, dev_name)) sc_in(ctf_user_string(dir_name, dir_name)) sc_in(ctf_user_string(type, type)) sc_in(ctf_integer(unsigned long, flags, flags)) sc_in(ctf_integer(void *, data, data))) -) -#endif -#ifndef OVERRIDE_64_io_getevents -SC_LTTNG_TRACEPOINT_EVENT(io_getevents, - TP_PROTO(sc_exit(long ret,) aio_context_t ctx_id, long min_nr, long nr, struct io_event * events, struct timespec * timeout), - TP_ARGS(sc_exit(ret,) ctx_id, min_nr, nr, events, timeout), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx_id, ctx_id)) sc_in(ctf_integer(long, min_nr, min_nr)) sc_in(ctf_integer(long, nr, nr)) sc_out(ctf_integer(struct io_event *, events, events)) sc_inout(ctf_integer(struct timespec *, timeout, timeout))) -) -#endif -#ifndef OVERRIDE_64_waitid -SC_LTTNG_TRACEPOINT_EVENT(waitid, - TP_PROTO(sc_exit(long ret,) int which, pid_t upid, struct siginfo * infop, int options, struct rusage * ru), - TP_ARGS(sc_exit(ret,) which, upid, infop, options, ru), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(pid_t, upid, upid)) sc_out(ctf_integer(struct siginfo *, infop, infop)) sc_in(ctf_integer(int, options, options)) sc_out(ctf_integer(struct rusage *, ru, ru))) -) -#endif -#ifndef OVERRIDE_64_ppoll -SC_LTTNG_TRACEPOINT_EVENT(ppoll, - TP_PROTO(sc_exit(long ret,) struct pollfd * ufds, unsigned int nfds, struct timespec * tsp, const sigset_t * sigmask, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) ufds, nfds, tsp, sigmask, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct pollfd *, ufds, ufds)) sc_in(ctf_integer(unsigned int, nfds, nfds)) sc_in(ctf_integer(struct timespec *, tsp, tsp)) sc_in(ctf_integer(const sigset_t *, sigmask, sigmask)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) -) -#endif -#ifndef OVERRIDE_64_recvmmsg -SC_LTTNG_TRACEPOINT_EVENT(recvmmsg, - TP_PROTO(sc_exit(long ret,) int fd, struct mmsghdr * mmsg, unsigned int vlen, unsigned int flags, struct timespec * timeout), - TP_ARGS(sc_exit(ret,) fd, mmsg, vlen, flags, timeout), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct mmsghdr *, mmsg, mmsg)) sc_in(ctf_integer(unsigned int, vlen, vlen)) sc_in(ctf_integer(unsigned int, flags, flags)) sc_inout(ctf_integer(struct timespec *, timeout, timeout))) -) -#endif -#ifndef OVERRIDE_64_getsockopt -SC_LTTNG_TRACEPOINT_EVENT(getsockopt, - TP_PROTO(sc_exit(long ret,) int fd, int level, int optname, char * optval, int * optlen), - TP_ARGS(sc_exit(ret,) fd, level, optname, optval, optlen), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, level, level)) sc_in(ctf_integer(int, optname, optname)) sc_out(ctf_integer(char *, optval, optval)) sc_inout(ctf_integer(int *, optlen, optlen))) -) -#endif -#ifndef OVERRIDE_64_setxattr -SC_LTTNG_TRACEPOINT_EVENT(setxattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, const void * value, size_t size, int flags), - TP_ARGS(sc_exit(ret,) pathname, name, value, size, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(const void *, value, value)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_lsetxattr -SC_LTTNG_TRACEPOINT_EVENT(lsetxattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, const void * value, size_t size, int flags), - TP_ARGS(sc_exit(ret,) pathname, name, value, size, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(const void *, value, value)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_fsetxattr -SC_LTTNG_TRACEPOINT_EVENT(fsetxattr, - TP_PROTO(sc_exit(long ret,) int fd, const char * name, const void * value, size_t size, int flags), - TP_ARGS(sc_exit(ret,) fd, name, value, size, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(const void *, value, value)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_fchownat -SC_LTTNG_TRACEPOINT_EVENT(fchownat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, uid_t user, gid_t group, int flag), - TP_ARGS(sc_exit(ret,) dfd, filename, user, group, flag), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group)) sc_in(ctf_integer(int, flag, flag))) -) -#endif -#ifndef OVERRIDE_64_linkat -SC_LTTNG_TRACEPOINT_EVENT(linkat, - TP_PROTO(sc_exit(long ret,) int olddfd, const char * oldname, int newdfd, const char * newname, int flags), - TP_ARGS(sc_exit(ret,) olddfd, oldname, newdfd, newname, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, olddfd, olddfd)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_integer(int, newdfd, newdfd)) sc_in(ctf_user_string(newname, newname)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_preadv -SC_LTTNG_TRACEPOINT_EVENT(preadv, - TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen, unsigned long pos_l, unsigned long pos_h), - TP_ARGS(sc_exit(ret,) fd, vec, vlen, pos_l, pos_h), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_out(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen)) sc_in(ctf_integer(unsigned long, pos_l, pos_l)) sc_in(ctf_integer(unsigned long, pos_h, pos_h))) -) -#endif -#ifndef OVERRIDE_64_pwritev -SC_LTTNG_TRACEPOINT_EVENT(pwritev, - TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen, unsigned long pos_l, unsigned long pos_h), - TP_ARGS(sc_exit(ret,) fd, vec, vlen, pos_l, pos_h), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_in(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen)) sc_in(ctf_integer(unsigned long, pos_l, pos_l)) sc_in(ctf_integer(unsigned long, pos_h, pos_h))) -) -#endif -#ifndef OVERRIDE_64_32_pread -SC_LTTNG_TRACEPOINT_EVENT(32_pread, - TP_PROTO(sc_exit(long ret,) unsigned long fd, char * buf, size_t count, unsigned long unused, unsigned long a4, unsigned long a5), - TP_ARGS(sc_exit(ret,) fd, buf, count, unused, a4, a5), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned long, fd, fd)) sc_inout(ctf_integer(char *, buf, buf)) sc_inout(ctf_integer(size_t, count, count)) sc_inout(ctf_integer(unsigned long, unused, unused)) sc_inout(ctf_integer(unsigned long, a4, a4)) sc_inout(ctf_integer(unsigned long, a5, a5))) -) -#endif -#ifndef OVERRIDE_64_32_pwrite -SC_LTTNG_TRACEPOINT_EVENT(32_pwrite, - TP_PROTO(sc_exit(long ret,) unsigned int fd, const char * buf, size_t count, u32 unused, u64 a4, u64 a5), - TP_ARGS(sc_exit(ret,) fd, buf, count, unused, a4, a5), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, fd, fd)) sc_inout(ctf_integer(const char *, buf, buf)) sc_inout(ctf_integer(size_t, count, count)) sc_inout(ctf_integer(u32, unused, unused)) sc_inout(ctf_integer(u64, a4, a4)) sc_inout(ctf_integer(u64, a5, a5))) -) -#endif -#ifndef OVERRIDE_64_32_fanotify_mark -SC_LTTNG_TRACEPOINT_EVENT(32_fanotify_mark, - TP_PROTO(sc_exit(long ret,) int fanotify_fd, unsigned int flags, u64 a3, u64 a4, int dfd, const char * pathname), - TP_ARGS(sc_exit(ret,) fanotify_fd, flags, a3, a4, dfd, pathname), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, fanotify_fd, fanotify_fd)) sc_inout(ctf_integer(unsigned int, flags, flags)) sc_inout(ctf_integer(u64, a3, a3)) sc_inout(ctf_integer(u64, a4, a4)) sc_inout(ctf_integer(int, dfd, dfd)) sc_inout(ctf_user_string(pathname, pathname))) -) -#endif -#ifndef OVERRIDE_64_recvfrom -SC_LTTNG_TRACEPOINT_EVENT(recvfrom, - TP_PROTO(sc_exit(long ret,) int fd, void * ubuf, size_t size, unsigned int flags, struct sockaddr * addr, int * addr_len), - TP_ARGS(sc_exit(ret,) fd, ubuf, size, flags, addr, addr_len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(void *, ubuf, ubuf)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(unsigned int, flags, flags)) sc_out(ctf_integer(struct sockaddr *, addr, addr)) sc_inout(ctf_integer(int *, addr_len, addr_len))) -) -#endif -#ifndef OVERRIDE_64_futex -SC_LTTNG_TRACEPOINT_EVENT(futex, - TP_PROTO(sc_exit(long ret,) u32 * uaddr, int op, u32 val, struct timespec * utime, u32 * uaddr2, u32 val3), - TP_ARGS(sc_exit(ret,) uaddr, op, val, utime, uaddr2, val3), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(u32 *, uaddr, uaddr)) sc_in(ctf_integer(int, op, op)) sc_in(ctf_integer(u32, val, val)) sc_in(ctf_integer(struct timespec *, utime, utime)) sc_inout(ctf_integer(u32 *, uaddr2, uaddr2)) sc_in(ctf_integer(u32, val3, val3))) -) -#endif -#ifndef OVERRIDE_64_pselect6 -SC_LTTNG_TRACEPOINT_EVENT(pselect6, - TP_PROTO(sc_exit(long ret,) int n, fd_set * inp, fd_set * outp, fd_set * exp, struct timespec * tsp, void * sig), - TP_ARGS(sc_exit(ret,) n, inp, outp, exp, tsp, sig), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, n, n)) sc_inout(ctf_integer(fd_set *, inp, inp)) sc_inout(ctf_integer(fd_set *, outp, outp)) sc_inout(ctf_integer(fd_set *, exp, exp)) sc_inout(ctf_integer(struct timespec *, tsp, tsp)) sc_in(ctf_integer(void *, sig, sig))) -) -#endif -#ifndef OVERRIDE_64_epoll_pwait -SC_LTTNG_TRACEPOINT_EVENT(epoll_pwait, - TP_PROTO(sc_exit(long ret,) int epfd, struct epoll_event * events, int maxevents, int timeout, const sigset_t * sigmask, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) epfd, events, maxevents, timeout, sigmask, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, epfd, epfd)) sc_out(ctf_integer(struct epoll_event *, events, events)) sc_in(ctf_integer(int, maxevents, maxevents)) sc_in(ctf_integer(int, timeout, timeout)) sc_in(ctf_integer(const sigset_t *, sigmask, sigmask)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) -) -#endif -#ifndef OVERRIDE_64_process_vm_readv -SC_LTTNG_TRACEPOINT_EVENT(process_vm_readv, - TP_PROTO(sc_exit(long ret,) pid_t pid, const struct iovec * lvec, unsigned long liovcnt, const struct iovec * rvec, unsigned long riovcnt, unsigned long flags), - TP_ARGS(sc_exit(ret,) pid, lvec, liovcnt, rvec, riovcnt, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_out(ctf_integer(const struct iovec *, lvec, lvec)) sc_in(ctf_integer(unsigned long, liovcnt, liovcnt)) sc_in(ctf_integer(const struct iovec *, rvec, rvec)) sc_in(ctf_integer(unsigned long, riovcnt, riovcnt)) sc_in(ctf_integer(unsigned long, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_process_vm_writev -SC_LTTNG_TRACEPOINT_EVENT(process_vm_writev, - TP_PROTO(sc_exit(long ret,) pid_t pid, const struct iovec * lvec, unsigned long liovcnt, const struct iovec * rvec, unsigned long riovcnt, unsigned long flags), - TP_ARGS(sc_exit(ret,) pid, lvec, liovcnt, rvec, riovcnt, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(const struct iovec *, lvec, lvec)) sc_in(ctf_integer(unsigned long, liovcnt, liovcnt)) sc_in(ctf_integer(const struct iovec *, rvec, rvec)) sc_in(ctf_integer(unsigned long, riovcnt, riovcnt)) sc_in(ctf_integer(unsigned long, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_sendto -SC_LTTNG_TRACEPOINT_EVENT(sendto, - TP_PROTO(sc_exit(long ret,) int fd, void * buff, size_t len, unsigned int flags, struct sockaddr * addr, int addr_len), - TP_ARGS(sc_exit(ret,) fd, buff, len, flags, addr, addr_len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(void *, buff, buff)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned int, flags, flags)) sc_in(ctf_integer(struct sockaddr *, addr, addr)) sc_in(ctf_integer(int, addr_len, addr_len))) -) -#endif -#ifndef OVERRIDE_64_32_futex -SC_LTTNG_TRACEPOINT_EVENT(32_futex, - TP_PROTO(sc_exit(long ret,) u32 * uaddr, int op, u32 val, struct compat_timespec * utime, u32 * uaddr2, u32 val3), - TP_ARGS(sc_exit(ret,) uaddr, op, val, utime, uaddr2, val3), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(u32 *, uaddr, uaddr)) sc_inout(ctf_integer(int, op, op)) sc_inout(ctf_integer(u32, val, val)) sc_inout(ctf_integer(struct compat_timespec *, utime, utime)) sc_inout(ctf_integer(u32 *, uaddr2, uaddr2)) sc_inout(ctf_integer(u32, val3, val3))) -) -#endif -#ifndef OVERRIDE_64_splice -SC_LTTNG_TRACEPOINT_EVENT(splice, - TP_PROTO(sc_exit(long ret,) int fd_in, loff_t * off_in, int fd_out, loff_t * off_out, size_t len, unsigned int flags), - TP_ARGS(sc_exit(ret,) fd_in, off_in, fd_out, off_out, len, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd_in, fd_in)) sc_in(ctf_integer(loff_t *, off_in, off_in)) sc_in(ctf_integer(int, fd_out, fd_out)) sc_in(ctf_integer(loff_t *, off_out, off_out)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned int, flags, flags))) -) -#endif - -#endif /* _TRACE_SYSCALLS_POINTERS_H */ - -/* This part must be outside protection */ -#include - -#else /* CREATE_SYSCALL_TABLE */ - -#include "mips-64-syscalls_pointers_override.h" -#include "syscalls_pointers_override.h" - -#ifndef OVERRIDE_TABLE_64_waitpid -TRACE_SYSCALL_TABLE(waitpid, waitpid, 4007, 3) -#endif -#ifndef OVERRIDE_TABLE_64_oldumount -TRACE_SYSCALL_TABLE(oldumount, oldumount, 4022, 1) -#endif -#ifndef OVERRIDE_TABLE_64_olduname -TRACE_SYSCALL_TABLE(olduname, olduname, 4059, 1) -#endif -#ifndef OVERRIDE_TABLE_64_32_sigaction -TRACE_SYSCALL_TABLE(32_sigaction, 32_sigaction, 4067, 3) -#endif -#ifndef OVERRIDE_TABLE_64_uselib -TRACE_SYSCALL_TABLE(uselib, uselib, 4086, 1) -#endif -#ifndef OVERRIDE_TABLE_64_uname -TRACE_SYSCALL_TABLE(uname, uname, 4109, 1) -#endif -#ifndef OVERRIDE_TABLE_64_32_llseek -TRACE_SYSCALL_TABLE(32_llseek, 32_llseek, 4140, 5) -#endif -#ifndef OVERRIDE_TABLE_64_send -TRACE_SYSCALL_TABLE(send, send, 4178, 4) -#endif -#ifndef OVERRIDE_TABLE_64_32_pread -TRACE_SYSCALL_TABLE(32_pread, 32_pread, 4200, 6) -#endif -#ifndef OVERRIDE_TABLE_64_32_pwrite -TRACE_SYSCALL_TABLE(32_pwrite, 32_pwrite, 4201, 6) -#endif -#ifndef OVERRIDE_TABLE_64_32_truncate64 -TRACE_SYSCALL_TABLE(32_truncate64, 32_truncate64, 4211, 4) -#endif -#ifndef OVERRIDE_TABLE_64_32_waitid -TRACE_SYSCALL_TABLE(32_waitid, 32_waitid, 4278, 5) -#endif -#ifndef OVERRIDE_TABLE_64_32_fanotify_mark -TRACE_SYSCALL_TABLE(32_fanotify_mark, 32_fanotify_mark, 4337, 6) -#endif -#ifndef OVERRIDE_TABLE_64_rt_sigaction -TRACE_SYSCALL_TABLE(rt_sigaction, rt_sigaction, 5013, 4) -#endif -#ifndef OVERRIDE_TABLE_64_rt_sigprocmask -TRACE_SYSCALL_TABLE(rt_sigprocmask, rt_sigprocmask, 5014, 4) -#endif -#ifndef OVERRIDE_TABLE_64_readv -TRACE_SYSCALL_TABLE(readv, readv, 5018, 3) -#endif -#ifndef OVERRIDE_TABLE_64_writev -TRACE_SYSCALL_TABLE(writev, writev, 5019, 3) -#endif -#ifndef OVERRIDE_TABLE_64_select -TRACE_SYSCALL_TABLE(select, select, 5022, 5) -#endif -#ifndef OVERRIDE_TABLE_64_shmctl -TRACE_SYSCALL_TABLE(shmctl, shmctl, 5030, 3) -#endif -#ifndef OVERRIDE_TABLE_64_nanosleep -TRACE_SYSCALL_TABLE(nanosleep, nanosleep, 5034, 2) -#endif -#ifndef OVERRIDE_TABLE_64_getitimer -TRACE_SYSCALL_TABLE(getitimer, getitimer, 5035, 2) -#endif -#ifndef OVERRIDE_TABLE_64_setitimer -TRACE_SYSCALL_TABLE(setitimer, setitimer, 5036, 3) -#endif -#ifndef OVERRIDE_TABLE_64_recvfrom -TRACE_SYSCALL_TABLE(recvfrom, recvfrom, 5044, 6) -#endif -#ifndef OVERRIDE_TABLE_64_sendmsg -TRACE_SYSCALL_TABLE(sendmsg, sendmsg, 5045, 3) -#endif -#ifndef OVERRIDE_TABLE_64_recvmsg -TRACE_SYSCALL_TABLE(recvmsg, recvmsg, 5046, 3) -#endif -#ifndef OVERRIDE_TABLE_64_setsockopt -TRACE_SYSCALL_TABLE(setsockopt, setsockopt, 5053, 5) -#endif -#ifndef OVERRIDE_TABLE_64_wait4 -TRACE_SYSCALL_TABLE(wait4, wait4, 5059, 4) -#endif -#ifndef OVERRIDE_TABLE_64_msgsnd -TRACE_SYSCALL_TABLE(msgsnd, msgsnd, 5067, 4) -#endif -#ifndef OVERRIDE_TABLE_64_msgrcv -TRACE_SYSCALL_TABLE(msgrcv, msgrcv, 5068, 5) -#endif -#ifndef OVERRIDE_TABLE_64_msgctl -TRACE_SYSCALL_TABLE(msgctl, msgctl, 5069, 3) -#endif -#ifndef OVERRIDE_TABLE_64_getdents -TRACE_SYSCALL_TABLE(getdents, getdents, 5076, 3) -#endif -#ifndef OVERRIDE_TABLE_64_gettimeofday -TRACE_SYSCALL_TABLE(gettimeofday, gettimeofday, 5094, 2) -#endif -#ifndef OVERRIDE_TABLE_64_getrlimit -TRACE_SYSCALL_TABLE(getrlimit, getrlimit, 5095, 2) -#endif -#ifndef OVERRIDE_TABLE_64_getrusage -TRACE_SYSCALL_TABLE(getrusage, getrusage, 5096, 2) -#endif -#ifndef OVERRIDE_TABLE_64_sysinfo -TRACE_SYSCALL_TABLE(sysinfo, sysinfo, 5097, 1) -#endif -#ifndef OVERRIDE_TABLE_64_times -TRACE_SYSCALL_TABLE(times, times, 5098, 1) -#endif -#ifndef OVERRIDE_TABLE_64_rt_sigpending -TRACE_SYSCALL_TABLE(rt_sigpending, rt_sigpending, 5125, 2) -#endif -#ifndef OVERRIDE_TABLE_64_rt_sigtimedwait -TRACE_SYSCALL_TABLE(rt_sigtimedwait, rt_sigtimedwait, 5126, 4) -#endif -#ifndef OVERRIDE_TABLE_64_rt_sigqueueinfo -TRACE_SYSCALL_TABLE(rt_sigqueueinfo, rt_sigqueueinfo, 5127, 3) -#endif -#ifndef OVERRIDE_TABLE_64_utime -TRACE_SYSCALL_TABLE(utime, utime, 5130, 2) -#endif -#ifndef OVERRIDE_TABLE_64_ustat -TRACE_SYSCALL_TABLE(ustat, ustat, 5133, 2) -#endif -#ifndef OVERRIDE_TABLE_64_statfs -TRACE_SYSCALL_TABLE(statfs, statfs, 5134, 2) -#endif -#ifndef OVERRIDE_TABLE_64_fstatfs -TRACE_SYSCALL_TABLE(fstatfs, fstatfs, 5135, 2) -#endif -#ifndef OVERRIDE_TABLE_64_sched_rr_get_interval -TRACE_SYSCALL_TABLE(sched_rr_get_interval, sched_rr_get_interval, 5145, 2) -#endif -#ifndef OVERRIDE_TABLE_64_sysctl -TRACE_SYSCALL_TABLE(sysctl, sysctl, 5152, 1) -#endif -#ifndef OVERRIDE_TABLE_64_adjtimex -TRACE_SYSCALL_TABLE(adjtimex, adjtimex, 5154, 1) -#endif -#ifndef OVERRIDE_TABLE_64_setrlimit -TRACE_SYSCALL_TABLE(setrlimit, setrlimit, 5155, 2) -#endif -#ifndef OVERRIDE_TABLE_64_settimeofday -TRACE_SYSCALL_TABLE(settimeofday, settimeofday, 5159, 2) -#endif -#ifndef OVERRIDE_TABLE_64_mount -TRACE_SYSCALL_TABLE(mount, mount, 5160, 5) -#endif -#ifndef OVERRIDE_TABLE_64_futex -TRACE_SYSCALL_TABLE(futex, futex, 5194, 6) -#endif -#ifndef OVERRIDE_TABLE_64_sched_setaffinity -TRACE_SYSCALL_TABLE(sched_setaffinity, sched_setaffinity, 5195, 3) -#endif -#ifndef OVERRIDE_TABLE_64_sched_getaffinity -TRACE_SYSCALL_TABLE(sched_getaffinity, sched_getaffinity, 5196, 3) -#endif -#ifndef OVERRIDE_TABLE_64_io_setup -TRACE_SYSCALL_TABLE(io_setup, io_setup, 5200, 2) -#endif -#ifndef OVERRIDE_TABLE_64_io_getevents -TRACE_SYSCALL_TABLE(io_getevents, io_getevents, 5202, 5) -#endif -#ifndef OVERRIDE_TABLE_64_io_submit -TRACE_SYSCALL_TABLE(io_submit, io_submit, 5203, 3) -#endif -#ifndef OVERRIDE_TABLE_64_semtimedop -TRACE_SYSCALL_TABLE(semtimedop, semtimedop, 5214, 4) -#endif -#ifndef OVERRIDE_TABLE_64_timer_create -TRACE_SYSCALL_TABLE(timer_create, timer_create, 5216, 3) -#endif -#ifndef OVERRIDE_TABLE_64_timer_settime -TRACE_SYSCALL_TABLE(timer_settime, timer_settime, 5217, 4) -#endif -#ifndef OVERRIDE_TABLE_64_timer_gettime -TRACE_SYSCALL_TABLE(timer_gettime, timer_gettime, 5218, 2) -#endif -#ifndef OVERRIDE_TABLE_64_clock_settime -TRACE_SYSCALL_TABLE(clock_settime, clock_settime, 5221, 2) -#endif -#ifndef OVERRIDE_TABLE_64_clock_gettime -TRACE_SYSCALL_TABLE(clock_gettime, clock_gettime, 5222, 2) -#endif -#ifndef OVERRIDE_TABLE_64_clock_getres -TRACE_SYSCALL_TABLE(clock_getres, clock_getres, 5223, 2) -#endif -#ifndef OVERRIDE_TABLE_64_clock_nanosleep -TRACE_SYSCALL_TABLE(clock_nanosleep, clock_nanosleep, 5224, 4) -#endif -#ifndef OVERRIDE_TABLE_64_utimes -TRACE_SYSCALL_TABLE(utimes, utimes, 5226, 2) -#endif -#ifndef OVERRIDE_TABLE_64_waitid -TRACE_SYSCALL_TABLE(waitid, waitid, 5237, 5) -#endif -#ifndef OVERRIDE_TABLE_64_futimesat -TRACE_SYSCALL_TABLE(futimesat, futimesat, 5251, 3) -#endif -#ifndef OVERRIDE_TABLE_64_pselect6 -TRACE_SYSCALL_TABLE(pselect6, pselect6, 5260, 6) -#endif -#ifndef OVERRIDE_TABLE_64_ppoll -TRACE_SYSCALL_TABLE(ppoll, ppoll, 5261, 5) -#endif -#ifndef OVERRIDE_TABLE_64_vmsplice -TRACE_SYSCALL_TABLE(vmsplice, vmsplice, 5266, 4) -#endif -#ifndef OVERRIDE_TABLE_64_set_robust_list -TRACE_SYSCALL_TABLE(set_robust_list, set_robust_list, 5268, 2) -#endif -#ifndef OVERRIDE_TABLE_64_get_robust_list -TRACE_SYSCALL_TABLE(get_robust_list, get_robust_list, 5269, 3) -#endif -#ifndef OVERRIDE_TABLE_64_epoll_pwait -TRACE_SYSCALL_TABLE(epoll_pwait, epoll_pwait, 5272, 6) -#endif -#ifndef OVERRIDE_TABLE_64_utimensat -TRACE_SYSCALL_TABLE(utimensat, utimensat, 5275, 4) -#endif -#ifndef OVERRIDE_TABLE_64_signalfd -TRACE_SYSCALL_TABLE(signalfd, signalfd, 5276, 3) -#endif -#ifndef OVERRIDE_TABLE_64_timerfd_gettime -TRACE_SYSCALL_TABLE(timerfd_gettime, timerfd_gettime, 5281, 2) -#endif -#ifndef OVERRIDE_TABLE_64_timerfd_settime -TRACE_SYSCALL_TABLE(timerfd_settime, timerfd_settime, 5282, 4) -#endif -#ifndef OVERRIDE_TABLE_64_rt_tgsigqueueinfo -TRACE_SYSCALL_TABLE(rt_tgsigqueueinfo, rt_tgsigqueueinfo, 5291, 4) -#endif -#ifndef OVERRIDE_TABLE_64_recvmmsg -TRACE_SYSCALL_TABLE(recvmmsg, recvmmsg, 5294, 5) -#endif -#ifndef OVERRIDE_TABLE_64_clock_adjtime -TRACE_SYSCALL_TABLE(clock_adjtime, clock_adjtime, 5300, 2) -#endif -#ifndef OVERRIDE_TABLE_64_sendmmsg -TRACE_SYSCALL_TABLE(sendmmsg, sendmmsg, 5302, 4) -#endif -#ifndef OVERRIDE_TABLE_64_process_vm_readv -TRACE_SYSCALL_TABLE(process_vm_readv, process_vm_readv, 5304, 6) -#endif -#ifndef OVERRIDE_TABLE_64_process_vm_writev -TRACE_SYSCALL_TABLE(process_vm_writev, process_vm_writev, 5305, 6) -#endif -#ifndef OVERRIDE_TABLE_64_read -TRACE_SYSCALL_TABLE(read, read, 6000, 3) -#endif -#ifndef OVERRIDE_TABLE_64_write -TRACE_SYSCALL_TABLE(write, write, 6001, 3) -#endif -#ifndef OVERRIDE_TABLE_64_open -TRACE_SYSCALL_TABLE(open, open, 6002, 3) -#endif -#ifndef OVERRIDE_TABLE_64_newstat -TRACE_SYSCALL_TABLE(newstat, newstat, 6004, 2) -#endif -#ifndef OVERRIDE_TABLE_64_newfstat -TRACE_SYSCALL_TABLE(newfstat, newfstat, 6005, 2) -#endif -#ifndef OVERRIDE_TABLE_64_newlstat -TRACE_SYSCALL_TABLE(newlstat, newlstat, 6006, 2) -#endif -#ifndef OVERRIDE_TABLE_64_poll -TRACE_SYSCALL_TABLE(poll, poll, 6007, 3) -#endif -#ifndef OVERRIDE_TABLE_64_32_rt_sigaction -TRACE_SYSCALL_TABLE(32_rt_sigaction, 32_rt_sigaction, 6013, 4) -#endif -#ifndef OVERRIDE_TABLE_64_32_rt_sigprocmask -TRACE_SYSCALL_TABLE(32_rt_sigprocmask, 32_rt_sigprocmask, 6014, 4) -#endif -#ifndef OVERRIDE_TABLE_64_access -TRACE_SYSCALL_TABLE(access, access, 6020, 2) -#endif -#ifndef OVERRIDE_TABLE_64_mincore -TRACE_SYSCALL_TABLE(mincore, mincore, 6026, 3) -#endif -#ifndef OVERRIDE_TABLE_64_shmat -TRACE_SYSCALL_TABLE(shmat, shmat, 6029, 3) -#endif -#ifndef OVERRIDE_TABLE_64_32_sendfile -TRACE_SYSCALL_TABLE(32_sendfile, 32_sendfile, 6039, 4) -#endif -#ifndef OVERRIDE_TABLE_64_connect -TRACE_SYSCALL_TABLE(connect, connect, 6041, 3) -#endif -#ifndef OVERRIDE_TABLE_64_accept -TRACE_SYSCALL_TABLE(accept, accept, 6042, 3) -#endif -#ifndef OVERRIDE_TABLE_64_sendto -TRACE_SYSCALL_TABLE(sendto, sendto, 6043, 6) -#endif -#ifndef OVERRIDE_TABLE_64_bind -TRACE_SYSCALL_TABLE(bind, bind, 6048, 3) -#endif -#ifndef OVERRIDE_TABLE_64_getsockname -TRACE_SYSCALL_TABLE(getsockname, getsockname, 6050, 3) -#endif -#ifndef OVERRIDE_TABLE_64_getpeername -TRACE_SYSCALL_TABLE(getpeername, getpeername, 6051, 3) -#endif -#ifndef OVERRIDE_TABLE_64_socketpair -TRACE_SYSCALL_TABLE(socketpair, socketpair, 6052, 4) -#endif -#ifndef OVERRIDE_TABLE_64_getsockopt -TRACE_SYSCALL_TABLE(getsockopt, getsockopt, 6054, 5) -#endif -#ifndef OVERRIDE_TABLE_64_newuname -TRACE_SYSCALL_TABLE(newuname, newuname, 6061, 1) -#endif -#ifndef OVERRIDE_TABLE_64_semop -TRACE_SYSCALL_TABLE(semop, semop, 6063, 3) -#endif -#ifndef OVERRIDE_TABLE_64_shmdt -TRACE_SYSCALL_TABLE(shmdt, shmdt, 6065, 1) -#endif -#ifndef OVERRIDE_TABLE_64_truncate -TRACE_SYSCALL_TABLE(truncate, truncate, 6074, 2) -#endif -#ifndef OVERRIDE_TABLE_64_getcwd -TRACE_SYSCALL_TABLE(getcwd, getcwd, 6077, 2) -#endif -#ifndef OVERRIDE_TABLE_64_chdir -TRACE_SYSCALL_TABLE(chdir, chdir, 6078, 1) -#endif -#ifndef OVERRIDE_TABLE_64_rename -TRACE_SYSCALL_TABLE(rename, rename, 6080, 2) -#endif -#ifndef OVERRIDE_TABLE_64_mkdir -TRACE_SYSCALL_TABLE(mkdir, mkdir, 6081, 2) -#endif -#ifndef OVERRIDE_TABLE_64_rmdir -TRACE_SYSCALL_TABLE(rmdir, rmdir, 6082, 1) -#endif -#ifndef OVERRIDE_TABLE_64_creat -TRACE_SYSCALL_TABLE(creat, creat, 6083, 2) -#endif -#ifndef OVERRIDE_TABLE_64_link -TRACE_SYSCALL_TABLE(link, link, 6084, 2) -#endif -#ifndef OVERRIDE_TABLE_64_unlink -TRACE_SYSCALL_TABLE(unlink, unlink, 6085, 1) -#endif -#ifndef OVERRIDE_TABLE_64_symlink -TRACE_SYSCALL_TABLE(symlink, symlink, 6086, 2) -#endif -#ifndef OVERRIDE_TABLE_64_readlink -TRACE_SYSCALL_TABLE(readlink, readlink, 6087, 3) -#endif -#ifndef OVERRIDE_TABLE_64_chmod -TRACE_SYSCALL_TABLE(chmod, chmod, 6088, 2) -#endif -#ifndef OVERRIDE_TABLE_64_chown -TRACE_SYSCALL_TABLE(chown, chown, 6090, 3) -#endif -#ifndef OVERRIDE_TABLE_64_lchown -TRACE_SYSCALL_TABLE(lchown, lchown, 6092, 3) -#endif -#ifndef OVERRIDE_TABLE_64_syslog -TRACE_SYSCALL_TABLE(syslog, syslog, 6101, 3) -#endif -#ifndef OVERRIDE_TABLE_64_getgroups -TRACE_SYSCALL_TABLE(getgroups, getgroups, 6113, 2) -#endif -#ifndef OVERRIDE_TABLE_64_setgroups -TRACE_SYSCALL_TABLE(setgroups, setgroups, 6114, 2) -#endif -#ifndef OVERRIDE_TABLE_64_getresuid -TRACE_SYSCALL_TABLE(getresuid, getresuid, 6116, 3) -#endif -#ifndef OVERRIDE_TABLE_64_getresgid -TRACE_SYSCALL_TABLE(getresgid, getresgid, 6118, 3) -#endif -#ifndef OVERRIDE_TABLE_64_32_rt_sigpending -TRACE_SYSCALL_TABLE(32_rt_sigpending, 32_rt_sigpending, 6125, 2) -#endif -#ifndef OVERRIDE_TABLE_64_32_rt_sigqueueinfo -TRACE_SYSCALL_TABLE(32_rt_sigqueueinfo, 32_rt_sigqueueinfo, 6127, 3) -#endif -#ifndef OVERRIDE_TABLE_64_mknod -TRACE_SYSCALL_TABLE(mknod, mknod, 6131, 3) -#endif -#ifndef OVERRIDE_TABLE_64_sched_setparam -TRACE_SYSCALL_TABLE(sched_setparam, sched_setparam, 6139, 2) -#endif -#ifndef OVERRIDE_TABLE_64_sched_getparam -TRACE_SYSCALL_TABLE(sched_getparam, sched_getparam, 6140, 2) -#endif -#ifndef OVERRIDE_TABLE_64_sched_setscheduler -TRACE_SYSCALL_TABLE(sched_setscheduler, sched_setscheduler, 6141, 3) -#endif -#ifndef OVERRIDE_TABLE_64_32_sched_rr_get_interval -TRACE_SYSCALL_TABLE(32_sched_rr_get_interval, 32_sched_rr_get_interval, 6145, 2) -#endif -#ifndef OVERRIDE_TABLE_64_pivot_root -TRACE_SYSCALL_TABLE(pivot_root, pivot_root, 6151, 2) -#endif -#ifndef OVERRIDE_TABLE_64_chroot -TRACE_SYSCALL_TABLE(chroot, chroot, 6156, 1) -#endif -#ifndef OVERRIDE_TABLE_64_umount -TRACE_SYSCALL_TABLE(umount, umount, 6161, 2) -#endif -#ifndef OVERRIDE_TABLE_64_swapon -TRACE_SYSCALL_TABLE(swapon, swapon, 6162, 2) -#endif -#ifndef OVERRIDE_TABLE_64_swapoff -TRACE_SYSCALL_TABLE(swapoff, swapoff, 6163, 1) -#endif -#ifndef OVERRIDE_TABLE_64_reboot -TRACE_SYSCALL_TABLE(reboot, reboot, 6164, 4) -#endif -#ifndef OVERRIDE_TABLE_64_sethostname -TRACE_SYSCALL_TABLE(sethostname, sethostname, 6165, 2) -#endif -#ifndef OVERRIDE_TABLE_64_setdomainname -TRACE_SYSCALL_TABLE(setdomainname, setdomainname, 6166, 2) -#endif -#ifndef OVERRIDE_TABLE_64_init_module -TRACE_SYSCALL_TABLE(init_module, init_module, 6168, 3) -#endif -#ifndef OVERRIDE_TABLE_64_delete_module -TRACE_SYSCALL_TABLE(delete_module, delete_module, 6169, 2) -#endif -#ifndef OVERRIDE_TABLE_64_quotactl -TRACE_SYSCALL_TABLE(quotactl, quotactl, 6172, 4) -#endif -#ifndef OVERRIDE_TABLE_64_setxattr -TRACE_SYSCALL_TABLE(setxattr, setxattr, 6180, 5) -#endif -#ifndef OVERRIDE_TABLE_64_lsetxattr -TRACE_SYSCALL_TABLE(lsetxattr, lsetxattr, 6181, 5) -#endif -#ifndef OVERRIDE_TABLE_64_fsetxattr -TRACE_SYSCALL_TABLE(fsetxattr, fsetxattr, 6182, 5) -#endif -#ifndef OVERRIDE_TABLE_64_getxattr -TRACE_SYSCALL_TABLE(getxattr, getxattr, 6183, 4) -#endif -#ifndef OVERRIDE_TABLE_64_lgetxattr -TRACE_SYSCALL_TABLE(lgetxattr, lgetxattr, 6184, 4) -#endif -#ifndef OVERRIDE_TABLE_64_fgetxattr -TRACE_SYSCALL_TABLE(fgetxattr, fgetxattr, 6185, 4) -#endif -#ifndef OVERRIDE_TABLE_64_listxattr -TRACE_SYSCALL_TABLE(listxattr, listxattr, 6186, 3) -#endif -#ifndef OVERRIDE_TABLE_64_llistxattr -TRACE_SYSCALL_TABLE(llistxattr, llistxattr, 6187, 3) -#endif -#ifndef OVERRIDE_TABLE_64_flistxattr -TRACE_SYSCALL_TABLE(flistxattr, flistxattr, 6188, 3) -#endif -#ifndef OVERRIDE_TABLE_64_removexattr -TRACE_SYSCALL_TABLE(removexattr, removexattr, 6189, 2) -#endif -#ifndef OVERRIDE_TABLE_64_lremovexattr -TRACE_SYSCALL_TABLE(lremovexattr, lremovexattr, 6190, 2) -#endif -#ifndef OVERRIDE_TABLE_64_fremovexattr -TRACE_SYSCALL_TABLE(fremovexattr, fremovexattr, 6191, 2) -#endif -#ifndef OVERRIDE_TABLE_64_32_futex -TRACE_SYSCALL_TABLE(32_futex, 32_futex, 6194, 6) -#endif -#ifndef OVERRIDE_TABLE_64_cachectl -TRACE_SYSCALL_TABLE(cachectl, cachectl, 6198, 3) -#endif -#ifndef OVERRIDE_TABLE_64_io_cancel -TRACE_SYSCALL_TABLE(io_cancel, io_cancel, 6204, 3) -#endif -#ifndef OVERRIDE_TABLE_64_epoll_ctl -TRACE_SYSCALL_TABLE(epoll_ctl, epoll_ctl, 6208, 4) -#endif -#ifndef OVERRIDE_TABLE_64_epoll_wait -TRACE_SYSCALL_TABLE(epoll_wait, epoll_wait, 6209, 4) -#endif -#ifndef OVERRIDE_TABLE_64_set_tid_address -TRACE_SYSCALL_TABLE(set_tid_address, set_tid_address, 6213, 1) -#endif -#ifndef OVERRIDE_TABLE_64_sendfile64 -TRACE_SYSCALL_TABLE(sendfile64, sendfile64, 6219, 4) -#endif -#ifndef OVERRIDE_TABLE_64_inotify_add_watch -TRACE_SYSCALL_TABLE(inotify_add_watch, inotify_add_watch, 6248, 3) -#endif -#ifndef OVERRIDE_TABLE_64_openat -TRACE_SYSCALL_TABLE(openat, openat, 6251, 4) -#endif -#ifndef OVERRIDE_TABLE_64_mkdirat -TRACE_SYSCALL_TABLE(mkdirat, mkdirat, 6252, 3) -#endif -#ifndef OVERRIDE_TABLE_64_mknodat -TRACE_SYSCALL_TABLE(mknodat, mknodat, 6253, 4) -#endif -#ifndef OVERRIDE_TABLE_64_fchownat -TRACE_SYSCALL_TABLE(fchownat, fchownat, 6254, 5) -#endif -#ifndef OVERRIDE_TABLE_64_newfstatat -TRACE_SYSCALL_TABLE(newfstatat, newfstatat, 6256, 4) -#endif -#ifndef OVERRIDE_TABLE_64_unlinkat -TRACE_SYSCALL_TABLE(unlinkat, unlinkat, 6257, 3) -#endif -#ifndef OVERRIDE_TABLE_64_renameat -TRACE_SYSCALL_TABLE(renameat, renameat, 6258, 4) -#endif -#ifndef OVERRIDE_TABLE_64_linkat -TRACE_SYSCALL_TABLE(linkat, linkat, 6259, 5) -#endif -#ifndef OVERRIDE_TABLE_64_symlinkat -TRACE_SYSCALL_TABLE(symlinkat, symlinkat, 6260, 3) -#endif -#ifndef OVERRIDE_TABLE_64_readlinkat -TRACE_SYSCALL_TABLE(readlinkat, readlinkat, 6261, 4) -#endif -#ifndef OVERRIDE_TABLE_64_fchmodat -TRACE_SYSCALL_TABLE(fchmodat, fchmodat, 6262, 3) -#endif -#ifndef OVERRIDE_TABLE_64_faccessat -TRACE_SYSCALL_TABLE(faccessat, faccessat, 6263, 3) -#endif -#ifndef OVERRIDE_TABLE_64_splice -TRACE_SYSCALL_TABLE(splice, splice, 6267, 6) -#endif -#ifndef OVERRIDE_TABLE_64_getcpu -TRACE_SYSCALL_TABLE(getcpu, getcpu, 6275, 3) -#endif -#ifndef OVERRIDE_TABLE_64_signalfd4 -TRACE_SYSCALL_TABLE(signalfd4, signalfd4, 6287, 4) -#endif -#ifndef OVERRIDE_TABLE_64_pipe2 -TRACE_SYSCALL_TABLE(pipe2, pipe2, 6291, 2) -#endif -#ifndef OVERRIDE_TABLE_64_preadv -TRACE_SYSCALL_TABLE(preadv, preadv, 6293, 5) -#endif -#ifndef OVERRIDE_TABLE_64_pwritev -TRACE_SYSCALL_TABLE(pwritev, pwritev, 6294, 5) -#endif -#ifndef OVERRIDE_TABLE_64_accept4 -TRACE_SYSCALL_TABLE(accept4, accept4, 6297, 4) -#endif -#ifndef OVERRIDE_TABLE_64_getdents64 -TRACE_SYSCALL_TABLE(getdents64, getdents64, 6299, 3) -#endif -#ifndef OVERRIDE_TABLE_64_prlimit64 -TRACE_SYSCALL_TABLE(prlimit64, prlimit64, 6302, 4) -#endif - -#endif /* CREATE_SYSCALL_TABLE */ diff --git a/instrumentation/syscalls/headers/mips-64-syscalls_pointers_override.h b/instrumentation/syscalls/headers/mips-64-syscalls_pointers_override.h deleted file mode 100644 index eb2b48cf..00000000 --- a/instrumentation/syscalls/headers/mips-64-syscalls_pointers_override.h +++ /dev/null @@ -1,10 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ - -#ifndef CREATE_SYSCALL_TABLE - -#else /* CREATE_SYSCALL_TABLE */ - -#define OVERRIDE_TABLE_64_sys_clone -TRACE_SYSCALL_TABLE(clone, clone, 5055, 0) - -#endif /* CREATE_SYSCALL_TABLE */ diff --git a/instrumentation/syscalls/headers/powerpc-32-syscalls_integers.h b/instrumentation/syscalls/headers/powerpc-32-syscalls_integers.h deleted file mode 100644 index a4ee13e9..00000000 --- a/instrumentation/syscalls/headers/powerpc-32-syscalls_integers.h +++ /dev/null @@ -1,1070 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ - -/* THIS FILE IS AUTO-GENERATED. DO NOT EDIT */ - -/* Generated from powerpc-32-syscalls 3.0.34 */ - -#ifndef CREATE_SYSCALL_TABLE - -#if !defined(_TRACE_SYSCALLS_INTEGERS_H) || defined(TRACE_HEADER_MULTI_READ) -#define _TRACE_SYSCALLS_INTEGERS_H - -#include -#include -#include "powerpc-32-syscalls_integers_override.h" -#include "syscalls_integers_override.h" - -#ifdef SC_ENTER -SC_LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(syscalls_noargs, - TP_FIELDS() -) -#ifndef OVERRIDE_32_restart_syscall -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, restart_syscall) -#endif -#ifndef OVERRIDE_32_getpid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getpid) -#endif -#ifndef OVERRIDE_32_getuid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getuid) -#endif -#ifndef OVERRIDE_32_pause -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, pause) -#endif -#ifndef OVERRIDE_32_sync -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, sync) -#endif -#ifndef OVERRIDE_32_getgid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getgid) -#endif -#ifndef OVERRIDE_32_geteuid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, geteuid) -#endif -#ifndef OVERRIDE_32_getegid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getegid) -#endif -#ifndef OVERRIDE_32_getppid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getppid) -#endif -#ifndef OVERRIDE_32_getpgrp -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getpgrp) -#endif -#ifndef OVERRIDE_32_setsid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, setsid) -#endif -#ifndef OVERRIDE_32_sgetmask -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, sgetmask) -#endif -#ifndef OVERRIDE_32_vhangup -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, vhangup) -#endif -#ifndef OVERRIDE_32_munlockall -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, munlockall) -#endif -#ifndef OVERRIDE_32_sched_yield -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, sched_yield) -#endif -#ifndef OVERRIDE_32_gettid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, gettid) -#endif -#ifndef OVERRIDE_32_inotify_init -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, inotify_init) -#endif -#else /* #ifdef SC_ENTER */ -#ifndef OVERRIDE_32_restart_syscall -SC_LTTNG_TRACEPOINT_EVENT(restart_syscall, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_getpid -SC_LTTNG_TRACEPOINT_EVENT(getpid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_getuid -SC_LTTNG_TRACEPOINT_EVENT(getuid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_pause -SC_LTTNG_TRACEPOINT_EVENT(pause, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_sync -SC_LTTNG_TRACEPOINT_EVENT(sync, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_getgid -SC_LTTNG_TRACEPOINT_EVENT(getgid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_geteuid -SC_LTTNG_TRACEPOINT_EVENT(geteuid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_getegid -SC_LTTNG_TRACEPOINT_EVENT(getegid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_getppid -SC_LTTNG_TRACEPOINT_EVENT(getppid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_getpgrp -SC_LTTNG_TRACEPOINT_EVENT(getpgrp, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_setsid -SC_LTTNG_TRACEPOINT_EVENT(setsid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_sgetmask -SC_LTTNG_TRACEPOINT_EVENT(sgetmask, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_vhangup -SC_LTTNG_TRACEPOINT_EVENT(vhangup, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_munlockall -SC_LTTNG_TRACEPOINT_EVENT(munlockall, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_sched_yield -SC_LTTNG_TRACEPOINT_EVENT(sched_yield, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_gettid -SC_LTTNG_TRACEPOINT_EVENT(gettid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_inotify_init -SC_LTTNG_TRACEPOINT_EVENT(inotify_init, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#endif /* else #ifdef SC_ENTER */ -#ifndef OVERRIDE_32_exit -SC_LTTNG_TRACEPOINT_EVENT(exit, - TP_PROTO(sc_exit(long ret,) int error_code), - TP_ARGS(sc_exit(ret,) error_code), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, error_code, error_code))) -) -#endif -#ifndef OVERRIDE_32_close -SC_LTTNG_TRACEPOINT_EVENT(close, - TP_PROTO(sc_exit(long ret,) unsigned int fd), - TP_ARGS(sc_exit(ret,) fd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) -) -#endif -#ifndef OVERRIDE_32_setuid -SC_LTTNG_TRACEPOINT_EVENT(setuid, - TP_PROTO(sc_exit(long ret,) uid_t uid), - TP_ARGS(sc_exit(ret,) uid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, uid, uid))) -) -#endif -#ifndef OVERRIDE_32_alarm -SC_LTTNG_TRACEPOINT_EVENT(alarm, - TP_PROTO(sc_exit(long ret,) unsigned int seconds), - TP_ARGS(sc_exit(ret,) seconds), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, seconds, seconds))) -) -#endif -#ifndef OVERRIDE_32_nice -SC_LTTNG_TRACEPOINT_EVENT(nice, - TP_PROTO(sc_exit(long ret,) int increment), - TP_ARGS(sc_exit(ret,) increment), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, increment, increment))) -) -#endif -#ifndef OVERRIDE_32_dup -SC_LTTNG_TRACEPOINT_EVENT(dup, - TP_PROTO(sc_exit(long ret,) unsigned int fildes), - TP_ARGS(sc_exit(ret,) fildes), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fildes, fildes))) -) -#endif -#ifndef OVERRIDE_32_brk -SC_LTTNG_TRACEPOINT_EVENT(brk, - TP_PROTO(sc_exit(long ret,) unsigned long brk), - TP_ARGS(sc_exit(ret,) brk), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, brk, brk))) -) -#endif -#ifndef OVERRIDE_32_setgid -SC_LTTNG_TRACEPOINT_EVENT(setgid, - TP_PROTO(sc_exit(long ret,) gid_t gid), - TP_ARGS(sc_exit(ret,) gid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, gid, gid))) -) -#endif -#ifndef OVERRIDE_32_umask -SC_LTTNG_TRACEPOINT_EVENT(umask, - TP_PROTO(sc_exit(long ret,) int mask), - TP_ARGS(sc_exit(ret,) mask), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, mask, mask))) -) -#endif -#ifndef OVERRIDE_32_ssetmask -SC_LTTNG_TRACEPOINT_EVENT(ssetmask, - TP_PROTO(sc_exit(long ret,) int newmask), - TP_ARGS(sc_exit(ret,) newmask), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, newmask, newmask))) -) -#endif -#ifndef OVERRIDE_32_fsync -SC_LTTNG_TRACEPOINT_EVENT(fsync, - TP_PROTO(sc_exit(long ret,) unsigned int fd), - TP_ARGS(sc_exit(ret,) fd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) -) -#endif -#ifndef OVERRIDE_32_getpgid -SC_LTTNG_TRACEPOINT_EVENT(getpgid, - TP_PROTO(sc_exit(long ret,) pid_t pid), - TP_ARGS(sc_exit(ret,) pid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid))) -) -#endif -#ifndef OVERRIDE_32_fchdir -SC_LTTNG_TRACEPOINT_EVENT(fchdir, - TP_PROTO(sc_exit(long ret,) unsigned int fd), - TP_ARGS(sc_exit(ret,) fd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) -) -#endif -#ifndef OVERRIDE_32_personality -SC_LTTNG_TRACEPOINT_EVENT(personality, - TP_PROTO(sc_exit(long ret,) unsigned int personality), - TP_ARGS(sc_exit(ret,) personality), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, personality, personality))) -) -#endif -#ifndef OVERRIDE_32_setfsuid -SC_LTTNG_TRACEPOINT_EVENT(setfsuid, - TP_PROTO(sc_exit(long ret,) uid_t uid), - TP_ARGS(sc_exit(ret,) uid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, uid, uid))) -) -#endif -#ifndef OVERRIDE_32_setfsgid -SC_LTTNG_TRACEPOINT_EVENT(setfsgid, - TP_PROTO(sc_exit(long ret,) gid_t gid), - TP_ARGS(sc_exit(ret,) gid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, gid, gid))) -) -#endif -#ifndef OVERRIDE_32_getsid -SC_LTTNG_TRACEPOINT_EVENT(getsid, - TP_PROTO(sc_exit(long ret,) pid_t pid), - TP_ARGS(sc_exit(ret,) pid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid))) -) -#endif -#ifndef OVERRIDE_32_fdatasync -SC_LTTNG_TRACEPOINT_EVENT(fdatasync, - TP_PROTO(sc_exit(long ret,) unsigned int fd), - TP_ARGS(sc_exit(ret,) fd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) -) -#endif -#ifndef OVERRIDE_32_mlockall -SC_LTTNG_TRACEPOINT_EVENT(mlockall, - TP_PROTO(sc_exit(long ret,) int flags), - TP_ARGS(sc_exit(ret,) flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_sched_getscheduler -SC_LTTNG_TRACEPOINT_EVENT(sched_getscheduler, - TP_PROTO(sc_exit(long ret,) pid_t pid), - TP_ARGS(sc_exit(ret,) pid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid))) -) -#endif -#ifndef OVERRIDE_32_sched_get_priority_max -SC_LTTNG_TRACEPOINT_EVENT(sched_get_priority_max, - TP_PROTO(sc_exit(long ret,) int policy), - TP_ARGS(sc_exit(ret,) policy), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, policy, policy))) -) -#endif -#ifndef OVERRIDE_32_sched_get_priority_min -SC_LTTNG_TRACEPOINT_EVENT(sched_get_priority_min, - TP_PROTO(sc_exit(long ret,) int policy), - TP_ARGS(sc_exit(ret,) policy), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, policy, policy))) -) -#endif -#ifndef OVERRIDE_32_io_destroy -SC_LTTNG_TRACEPOINT_EVENT(io_destroy, - TP_PROTO(sc_exit(long ret,) aio_context_t ctx), - TP_ARGS(sc_exit(ret,) ctx), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx, ctx))) -) -#endif -#ifndef OVERRIDE_32_exit_group -SC_LTTNG_TRACEPOINT_EVENT(exit_group, - TP_PROTO(sc_exit(long ret,) int error_code), - TP_ARGS(sc_exit(ret,) error_code), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, error_code, error_code))) -) -#endif -#ifndef OVERRIDE_32_epoll_create -SC_LTTNG_TRACEPOINT_EVENT(epoll_create, - TP_PROTO(sc_exit(long ret,) int size), - TP_ARGS(sc_exit(ret,) size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, size, size))) -) -#endif -#ifndef OVERRIDE_32_timer_getoverrun -SC_LTTNG_TRACEPOINT_EVENT(timer_getoverrun, - TP_PROTO(sc_exit(long ret,) timer_t timer_id), - TP_ARGS(sc_exit(ret,) timer_id), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id))) -) -#endif -#ifndef OVERRIDE_32_timer_delete -SC_LTTNG_TRACEPOINT_EVENT(timer_delete, - TP_PROTO(sc_exit(long ret,) timer_t timer_id), - TP_ARGS(sc_exit(ret,) timer_id), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id))) -) -#endif -#ifndef OVERRIDE_32_unshare -SC_LTTNG_TRACEPOINT_EVENT(unshare, - TP_PROTO(sc_exit(long ret,) unsigned long unshare_flags), - TP_ARGS(sc_exit(ret,) unshare_flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, unshare_flags, unshare_flags))) -) -#endif -#ifndef OVERRIDE_32_eventfd -SC_LTTNG_TRACEPOINT_EVENT(eventfd, - TP_PROTO(sc_exit(long ret,) unsigned int count), - TP_ARGS(sc_exit(ret,) count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, count, count))) -) -#endif -#ifndef OVERRIDE_32_epoll_create1 -SC_LTTNG_TRACEPOINT_EVENT(epoll_create1, - TP_PROTO(sc_exit(long ret,) int flags), - TP_ARGS(sc_exit(ret,) flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_inotify_init1 -SC_LTTNG_TRACEPOINT_EVENT(inotify_init1, - TP_PROTO(sc_exit(long ret,) int flags), - TP_ARGS(sc_exit(ret,) flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_syncfs -SC_LTTNG_TRACEPOINT_EVENT(syncfs, - TP_PROTO(sc_exit(long ret,) int fd), - TP_ARGS(sc_exit(ret,) fd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd))) -) -#endif -#ifndef OVERRIDE_32_kill -SC_LTTNG_TRACEPOINT_EVENT(kill, - TP_PROTO(sc_exit(long ret,) pid_t pid, int sig), - TP_ARGS(sc_exit(ret,) pid, sig), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig))) -) -#endif -#ifndef OVERRIDE_32_signal -SC_LTTNG_TRACEPOINT_EVENT(signal, - TP_PROTO(sc_exit(long ret,) int sig, __sighandler_t handler), - TP_ARGS(sc_exit(ret,) sig, handler), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, sig, sig)) sc_inout(ctf_integer(__sighandler_t, handler, handler))) -) -#endif -#ifndef OVERRIDE_32_setpgid -SC_LTTNG_TRACEPOINT_EVENT(setpgid, - TP_PROTO(sc_exit(long ret,) pid_t pid, pid_t pgid), - TP_ARGS(sc_exit(ret,) pid, pgid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(pid_t, pgid, pgid))) -) -#endif -#ifndef OVERRIDE_32_dup2 -SC_LTTNG_TRACEPOINT_EVENT(dup2, - TP_PROTO(sc_exit(long ret,) unsigned int oldfd, unsigned int newfd), - TP_ARGS(sc_exit(ret,) oldfd, newfd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, oldfd, oldfd)) sc_in(ctf_integer(unsigned int, newfd, newfd))) -) -#endif -#ifndef OVERRIDE_32_setreuid -SC_LTTNG_TRACEPOINT_EVENT(setreuid, - TP_PROTO(sc_exit(long ret,) uid_t ruid, uid_t euid), - TP_ARGS(sc_exit(ret,) ruid, euid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, ruid, ruid)) sc_in(ctf_integer(uid_t, euid, euid))) -) -#endif -#ifndef OVERRIDE_32_setregid -SC_LTTNG_TRACEPOINT_EVENT(setregid, - TP_PROTO(sc_exit(long ret,) gid_t rgid, gid_t egid), - TP_ARGS(sc_exit(ret,) rgid, egid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, rgid, rgid)) sc_in(ctf_integer(gid_t, egid, egid))) -) -#endif -#ifndef OVERRIDE_32_munmap -SC_LTTNG_TRACEPOINT_EVENT(munmap, - TP_PROTO(sc_exit(long ret,) unsigned long addr, size_t len), - TP_ARGS(sc_exit(ret,) addr, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, addr, addr)) sc_in(ctf_integer(size_t, len, len))) -) -#endif -#ifndef OVERRIDE_32_ftruncate -SC_LTTNG_TRACEPOINT_EVENT(ftruncate, - TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned long length), - TP_ARGS(sc_exit(ret,) fd, length), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned long, length, length))) -) -#endif -#ifndef OVERRIDE_32_fchmod -SC_LTTNG_TRACEPOINT_EVENT(fchmod, - TP_PROTO(sc_exit(long ret,) unsigned int fd, mode_t mode), - TP_ARGS(sc_exit(ret,) fd, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(mode_t, mode, mode))) -) -#endif -#ifndef OVERRIDE_32_getpriority -SC_LTTNG_TRACEPOINT_EVENT(getpriority, - TP_PROTO(sc_exit(long ret,) int which, int who), - TP_ARGS(sc_exit(ret,) which, who), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who))) -) -#endif -#ifndef OVERRIDE_32_bdflush -SC_LTTNG_TRACEPOINT_EVENT(bdflush, - TP_PROTO(sc_exit(long ret,) int func, long data), - TP_ARGS(sc_exit(ret,) func, data), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, func, func)) sc_inout(ctf_integer(long, data, data))) -) -#endif -#ifndef OVERRIDE_32_flock -SC_LTTNG_TRACEPOINT_EVENT(flock, - TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd), - TP_ARGS(sc_exit(ret,) fd, cmd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned int, cmd, cmd))) -) -#endif -#ifndef OVERRIDE_32_mlock -SC_LTTNG_TRACEPOINT_EVENT(mlock, - TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len), - TP_ARGS(sc_exit(ret,) start, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len))) -) -#endif -#ifndef OVERRIDE_32_munlock -SC_LTTNG_TRACEPOINT_EVENT(munlock, - TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len), - TP_ARGS(sc_exit(ret,) start, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len))) -) -#endif -#ifndef OVERRIDE_32_tkill -SC_LTTNG_TRACEPOINT_EVENT(tkill, - TP_PROTO(sc_exit(long ret,) pid_t pid, int sig), - TP_ARGS(sc_exit(ret,) pid, sig), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig))) -) -#endif -#ifndef OVERRIDE_32_ioprio_get -SC_LTTNG_TRACEPOINT_EVENT(ioprio_get, - TP_PROTO(sc_exit(long ret,) int which, int who), - TP_ARGS(sc_exit(ret,) which, who), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who))) -) -#endif -#ifndef OVERRIDE_32_inotify_rm_watch -SC_LTTNG_TRACEPOINT_EVENT(inotify_rm_watch, - TP_PROTO(sc_exit(long ret,) int fd, __s32 wd), - TP_ARGS(sc_exit(ret,) fd, wd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(__s32, wd, wd))) -) -#endif -#ifndef OVERRIDE_32_timerfd_create -SC_LTTNG_TRACEPOINT_EVENT(timerfd_create, - TP_PROTO(sc_exit(long ret,) int clockid, int flags), - TP_ARGS(sc_exit(ret,) clockid, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, clockid, clockid)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_eventfd2 -SC_LTTNG_TRACEPOINT_EVENT(eventfd2, - TP_PROTO(sc_exit(long ret,) unsigned int count, int flags), - TP_ARGS(sc_exit(ret,) count, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, count, count)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_listen -SC_LTTNG_TRACEPOINT_EVENT(listen, - TP_PROTO(sc_exit(long ret,) int fd, int backlog), - TP_ARGS(sc_exit(ret,) fd, backlog), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, backlog, backlog))) -) -#endif -#ifndef OVERRIDE_32_shutdown -SC_LTTNG_TRACEPOINT_EVENT(shutdown, - TP_PROTO(sc_exit(long ret,) int fd, int how), - TP_ARGS(sc_exit(ret,) fd, how), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, how, how))) -) -#endif -#ifndef OVERRIDE_32_setns -SC_LTTNG_TRACEPOINT_EVENT(setns, - TP_PROTO(sc_exit(long ret,) int fd, int nstype), - TP_ARGS(sc_exit(ret,) fd, nstype), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, nstype, nstype))) -) -#endif -#ifndef OVERRIDE_32_lseek -SC_LTTNG_TRACEPOINT_EVENT(lseek, - TP_PROTO(sc_exit(long ret,) unsigned int fd, off_t offset, unsigned int origin), - TP_ARGS(sc_exit(ret,) fd, offset, origin), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(off_t, offset, offset)) sc_in(ctf_integer(unsigned int, origin, origin))) -) -#endif -#ifndef OVERRIDE_32_ioctl -SC_LTTNG_TRACEPOINT_EVENT(ioctl, - TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd, unsigned long arg), - TP_ARGS(sc_exit(ret,) fd, cmd, arg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_inout(ctf_integer(unsigned long, arg, arg))) -) -#endif -#ifndef OVERRIDE_32_fcntl -SC_LTTNG_TRACEPOINT_EVENT(fcntl, - TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd, unsigned long arg), - TP_ARGS(sc_exit(ret,) fd, cmd, arg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_inout(ctf_integer(unsigned long, arg, arg))) -) -#endif -#ifndef OVERRIDE_32_fchown -SC_LTTNG_TRACEPOINT_EVENT(fchown, - TP_PROTO(sc_exit(long ret,) unsigned int fd, uid_t user, gid_t group), - TP_ARGS(sc_exit(ret,) fd, user, group), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group))) -) -#endif -#ifndef OVERRIDE_32_setpriority -SC_LTTNG_TRACEPOINT_EVENT(setpriority, - TP_PROTO(sc_exit(long ret,) int which, int who, int niceval), - TP_ARGS(sc_exit(ret,) which, who, niceval), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who)) sc_in(ctf_integer(int, niceval, niceval))) -) -#endif -#ifndef OVERRIDE_32_mprotect -SC_LTTNG_TRACEPOINT_EVENT(mprotect, - TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len, unsigned long prot), - TP_ARGS(sc_exit(ret,) start, len, prot), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned long, prot, prot))) -) -#endif -#ifndef OVERRIDE_32_sysfs -SC_LTTNG_TRACEPOINT_EVENT(sysfs, - TP_PROTO(sc_exit(long ret,) int option, unsigned long arg1, unsigned long arg2), - TP_ARGS(sc_exit(ret,) option, arg1, arg2), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, option, option)) sc_in(ctf_integer(unsigned long, arg1, arg1)) sc_in(ctf_integer(unsigned long, arg2, arg2))) -) -#endif -#ifndef OVERRIDE_32_msync -SC_LTTNG_TRACEPOINT_EVENT(msync, - TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len, int flags), - TP_ARGS(sc_exit(ret,) start, len, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_setresuid -SC_LTTNG_TRACEPOINT_EVENT(setresuid, - TP_PROTO(sc_exit(long ret,) uid_t ruid, uid_t euid, uid_t suid), - TP_ARGS(sc_exit(ret,) ruid, euid, suid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, ruid, ruid)) sc_in(ctf_integer(uid_t, euid, euid)) sc_in(ctf_integer(uid_t, suid, suid))) -) -#endif -#ifndef OVERRIDE_32_setresgid -SC_LTTNG_TRACEPOINT_EVENT(setresgid, - TP_PROTO(sc_exit(long ret,) gid_t rgid, gid_t egid, gid_t sgid), - TP_ARGS(sc_exit(ret,) rgid, egid, sgid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, rgid, rgid)) sc_in(ctf_integer(gid_t, egid, egid)) sc_in(ctf_integer(gid_t, sgid, sgid))) -) -#endif -#ifndef OVERRIDE_32_fcntl64 -SC_LTTNG_TRACEPOINT_EVENT(fcntl64, - TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd, unsigned long arg), - TP_ARGS(sc_exit(ret,) fd, cmd, arg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, fd, fd)) sc_inout(ctf_integer(unsigned int, cmd, cmd)) sc_inout(ctf_integer(unsigned long, arg, arg))) -) -#endif -#ifndef OVERRIDE_32_madvise -SC_LTTNG_TRACEPOINT_EVENT(madvise, - TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len_in, int behavior), - TP_ARGS(sc_exit(ret,) start, len_in, behavior), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len_in, len_in)) sc_in(ctf_integer(int, behavior, behavior))) -) -#endif -#ifndef OVERRIDE_32_tgkill -SC_LTTNG_TRACEPOINT_EVENT(tgkill, - TP_PROTO(sc_exit(long ret,) pid_t tgid, pid_t pid, int sig), - TP_ARGS(sc_exit(ret,) tgid, pid, sig), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, tgid, tgid)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig))) -) -#endif -#ifndef OVERRIDE_32_ioprio_set -SC_LTTNG_TRACEPOINT_EVENT(ioprio_set, - TP_PROTO(sc_exit(long ret,) int which, int who, int ioprio), - TP_ARGS(sc_exit(ret,) which, who, ioprio), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who)) sc_in(ctf_integer(int, ioprio, ioprio))) -) -#endif -#ifndef OVERRIDE_32_dup3 -SC_LTTNG_TRACEPOINT_EVENT(dup3, - TP_PROTO(sc_exit(long ret,) unsigned int oldfd, unsigned int newfd, int flags), - TP_ARGS(sc_exit(ret,) oldfd, newfd, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, oldfd, oldfd)) sc_in(ctf_integer(unsigned int, newfd, newfd)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_socket -SC_LTTNG_TRACEPOINT_EVENT(socket, - TP_PROTO(sc_exit(long ret,) int family, int type, int protocol), - TP_ARGS(sc_exit(ret,) family, type, protocol), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, family, family)) sc_in(ctf_integer(int, type, type)) sc_in(ctf_integer(int, protocol, protocol))) -) -#endif -#ifndef OVERRIDE_32_ptrace -SC_LTTNG_TRACEPOINT_EVENT(ptrace, - TP_PROTO(sc_exit(long ret,) long request, long pid, unsigned long addr, unsigned long data), - TP_ARGS(sc_exit(ret,) request, pid, addr, data), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(long, request, request)) sc_in(ctf_integer(long, pid, pid)) sc_inout(ctf_integer(unsigned long, addr, addr)) sc_inout(ctf_integer(unsigned long, data, data))) -) -#endif -#ifndef OVERRIDE_32_tee -SC_LTTNG_TRACEPOINT_EVENT(tee, - TP_PROTO(sc_exit(long ret,) int fdin, int fdout, size_t len, unsigned int flags), - TP_ARGS(sc_exit(ret,) fdin, fdout, len, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fdin, fdin)) sc_in(ctf_integer(int, fdout, fdout)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_mremap -SC_LTTNG_TRACEPOINT_EVENT(mremap, - TP_PROTO(sc_exit(long ret,) unsigned long addr, unsigned long old_len, unsigned long new_len, unsigned long flags, unsigned long new_addr), - TP_ARGS(sc_exit(ret,) addr, old_len, new_len, flags, new_addr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, addr, addr)) sc_in(ctf_integer(unsigned long, old_len, old_len)) sc_in(ctf_integer(unsigned long, new_len, new_len)) sc_in(ctf_integer(unsigned long, flags, flags)) sc_in(ctf_integer(unsigned long, new_addr, new_addr))) -) -#endif -#ifndef OVERRIDE_32_prctl -SC_LTTNG_TRACEPOINT_EVENT(prctl, - TP_PROTO(sc_exit(long ret,) int option, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5), - TP_ARGS(sc_exit(ret,) option, arg2, arg3, arg4, arg5), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, option, option)) sc_inout(ctf_integer(unsigned long, arg2, arg2)) sc_in(ctf_integer(unsigned long, arg3, arg3)) sc_in(ctf_integer(unsigned long, arg4, arg4)) sc_in(ctf_integer(unsigned long, arg5, arg5))) -) -#endif -#ifndef OVERRIDE_32_remap_file_pages -SC_LTTNG_TRACEPOINT_EVENT(remap_file_pages, - TP_PROTO(sc_exit(long ret,) unsigned long start, unsigned long size, unsigned long prot, unsigned long pgoff, unsigned long flags), - TP_ARGS(sc_exit(ret,) start, size, prot, pgoff, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(unsigned long, size, size)) sc_in(ctf_integer(unsigned long, prot, prot)) sc_in(ctf_integer(unsigned long, pgoff, pgoff)) sc_in(ctf_integer(unsigned long, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_keyctl -SC_LTTNG_TRACEPOINT_EVENT(keyctl, - TP_PROTO(sc_exit(long ret,) int option, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5), - TP_ARGS(sc_exit(ret,) option, arg2, arg3, arg4, arg5), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, option, option)) sc_inout(ctf_integer(unsigned long, arg2, arg2)) sc_inout(ctf_integer(unsigned long, arg3, arg3)) sc_inout(ctf_integer(unsigned long, arg4, arg4)) sc_inout(ctf_integer(unsigned long, arg5, arg5))) -) -#endif - -#endif /* _TRACE_SYSCALLS_INTEGERS_H */ - -/* This part must be outside protection */ -#include - -#else /* CREATE_SYSCALL_TABLE */ - -#include "powerpc-32-syscalls_integers_override.h" -#include "syscalls_integers_override.h" - -#ifdef SC_ENTER -#ifndef OVERRIDE_TABLE_32_restart_syscall -TRACE_SYSCALL_TABLE(syscalls_noargs, restart_syscall, 0, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getpid -TRACE_SYSCALL_TABLE(syscalls_noargs, getpid, 20, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getuid -TRACE_SYSCALL_TABLE(syscalls_noargs, getuid, 24, 0) -#endif -#ifndef OVERRIDE_TABLE_32_pause -TRACE_SYSCALL_TABLE(syscalls_noargs, pause, 29, 0) -#endif -#ifndef OVERRIDE_TABLE_32_sync -TRACE_SYSCALL_TABLE(syscalls_noargs, sync, 36, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getgid -TRACE_SYSCALL_TABLE(syscalls_noargs, getgid, 47, 0) -#endif -#ifndef OVERRIDE_TABLE_32_geteuid -TRACE_SYSCALL_TABLE(syscalls_noargs, geteuid, 49, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getegid -TRACE_SYSCALL_TABLE(syscalls_noargs, getegid, 50, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getppid -TRACE_SYSCALL_TABLE(syscalls_noargs, getppid, 64, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getpgrp -TRACE_SYSCALL_TABLE(syscalls_noargs, getpgrp, 65, 0) -#endif -#ifndef OVERRIDE_TABLE_32_setsid -TRACE_SYSCALL_TABLE(syscalls_noargs, setsid, 66, 0) -#endif -#ifndef OVERRIDE_TABLE_32_sgetmask -TRACE_SYSCALL_TABLE(syscalls_noargs, sgetmask, 68, 0) -#endif -#ifndef OVERRIDE_TABLE_32_vhangup -TRACE_SYSCALL_TABLE(syscalls_noargs, vhangup, 111, 0) -#endif -#ifndef OVERRIDE_TABLE_32_munlockall -TRACE_SYSCALL_TABLE(syscalls_noargs, munlockall, 153, 0) -#endif -#ifndef OVERRIDE_TABLE_32_sched_yield -TRACE_SYSCALL_TABLE(syscalls_noargs, sched_yield, 158, 0) -#endif -#ifndef OVERRIDE_TABLE_32_gettid -TRACE_SYSCALL_TABLE(syscalls_noargs, gettid, 207, 0) -#endif -#ifndef OVERRIDE_TABLE_32_inotify_init -TRACE_SYSCALL_TABLE(syscalls_noargs, inotify_init, 275, 0) -#endif -#else /* #ifdef SC_ENTER */ -#ifndef OVERRIDE_TABLE_32_restart_syscall -TRACE_SYSCALL_TABLE(restart_syscall, restart_syscall, 0, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getpid -TRACE_SYSCALL_TABLE(getpid, getpid, 20, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getuid -TRACE_SYSCALL_TABLE(getuid, getuid, 24, 0) -#endif -#ifndef OVERRIDE_TABLE_32_pause -TRACE_SYSCALL_TABLE(pause, pause, 29, 0) -#endif -#ifndef OVERRIDE_TABLE_32_sync -TRACE_SYSCALL_TABLE(sync, sync, 36, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getgid -TRACE_SYSCALL_TABLE(getgid, getgid, 47, 0) -#endif -#ifndef OVERRIDE_TABLE_32_geteuid -TRACE_SYSCALL_TABLE(geteuid, geteuid, 49, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getegid -TRACE_SYSCALL_TABLE(getegid, getegid, 50, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getppid -TRACE_SYSCALL_TABLE(getppid, getppid, 64, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getpgrp -TRACE_SYSCALL_TABLE(getpgrp, getpgrp, 65, 0) -#endif -#ifndef OVERRIDE_TABLE_32_setsid -TRACE_SYSCALL_TABLE(setsid, setsid, 66, 0) -#endif -#ifndef OVERRIDE_TABLE_32_sgetmask -TRACE_SYSCALL_TABLE(sgetmask, sgetmask, 68, 0) -#endif -#ifndef OVERRIDE_TABLE_32_vhangup -TRACE_SYSCALL_TABLE(vhangup, vhangup, 111, 0) -#endif -#ifndef OVERRIDE_TABLE_32_munlockall -TRACE_SYSCALL_TABLE(munlockall, munlockall, 153, 0) -#endif -#ifndef OVERRIDE_TABLE_32_sched_yield -TRACE_SYSCALL_TABLE(sched_yield, sched_yield, 158, 0) -#endif -#ifndef OVERRIDE_TABLE_32_gettid -TRACE_SYSCALL_TABLE(gettid, gettid, 207, 0) -#endif -#ifndef OVERRIDE_TABLE_32_inotify_init -TRACE_SYSCALL_TABLE(inotify_init, inotify_init, 275, 0) -#endif -#endif /* else #ifdef SC_ENTER */ -#ifndef OVERRIDE_TABLE_32_exit -TRACE_SYSCALL_TABLE(exit, exit, 1, 1) -#endif -#ifndef OVERRIDE_TABLE_32_close -TRACE_SYSCALL_TABLE(close, close, 6, 1) -#endif -#ifndef OVERRIDE_TABLE_32_lseek -TRACE_SYSCALL_TABLE(lseek, lseek, 19, 3) -#endif -#ifndef OVERRIDE_TABLE_32_setuid -TRACE_SYSCALL_TABLE(setuid, setuid, 23, 1) -#endif -#ifndef OVERRIDE_TABLE_32_ptrace -TRACE_SYSCALL_TABLE(ptrace, ptrace, 26, 4) -#endif -#ifndef OVERRIDE_TABLE_32_alarm -TRACE_SYSCALL_TABLE(alarm, alarm, 27, 1) -#endif -#ifndef OVERRIDE_TABLE_32_nice -TRACE_SYSCALL_TABLE(nice, nice, 34, 1) -#endif -#ifndef OVERRIDE_TABLE_32_kill -TRACE_SYSCALL_TABLE(kill, kill, 37, 2) -#endif -#ifndef OVERRIDE_TABLE_32_dup -TRACE_SYSCALL_TABLE(dup, dup, 41, 1) -#endif -#ifndef OVERRIDE_TABLE_32_brk -TRACE_SYSCALL_TABLE(brk, brk, 45, 1) -#endif -#ifndef OVERRIDE_TABLE_32_setgid -TRACE_SYSCALL_TABLE(setgid, setgid, 46, 1) -#endif -#ifndef OVERRIDE_TABLE_32_signal -TRACE_SYSCALL_TABLE(signal, signal, 48, 2) -#endif -#ifndef OVERRIDE_TABLE_32_ioctl -TRACE_SYSCALL_TABLE(ioctl, ioctl, 54, 3) -#endif -#ifndef OVERRIDE_TABLE_32_fcntl -TRACE_SYSCALL_TABLE(fcntl, fcntl, 55, 3) -#endif -#ifndef OVERRIDE_TABLE_32_setpgid -TRACE_SYSCALL_TABLE(setpgid, setpgid, 57, 2) -#endif -#ifndef OVERRIDE_TABLE_32_umask -TRACE_SYSCALL_TABLE(umask, umask, 60, 1) -#endif -#ifndef OVERRIDE_TABLE_32_dup2 -TRACE_SYSCALL_TABLE(dup2, dup2, 63, 2) -#endif -#ifndef OVERRIDE_TABLE_32_ssetmask -TRACE_SYSCALL_TABLE(ssetmask, ssetmask, 69, 1) -#endif -#ifndef OVERRIDE_TABLE_32_setreuid -TRACE_SYSCALL_TABLE(setreuid, setreuid, 70, 2) -#endif -#ifndef OVERRIDE_TABLE_32_setregid -TRACE_SYSCALL_TABLE(setregid, setregid, 71, 2) -#endif -#ifndef OVERRIDE_TABLE_32_munmap -TRACE_SYSCALL_TABLE(munmap, munmap, 91, 2) -#endif -#ifndef OVERRIDE_TABLE_32_ftruncate -TRACE_SYSCALL_TABLE(ftruncate, ftruncate, 93, 2) -#endif -#ifndef OVERRIDE_TABLE_32_fchmod -TRACE_SYSCALL_TABLE(fchmod, fchmod, 94, 2) -#endif -#ifndef OVERRIDE_TABLE_32_fchown -TRACE_SYSCALL_TABLE(fchown, fchown, 95, 3) -#endif -#ifndef OVERRIDE_TABLE_32_getpriority -TRACE_SYSCALL_TABLE(getpriority, getpriority, 96, 2) -#endif -#ifndef OVERRIDE_TABLE_32_setpriority -TRACE_SYSCALL_TABLE(setpriority, setpriority, 97, 3) -#endif -#ifndef OVERRIDE_TABLE_32_fsync -TRACE_SYSCALL_TABLE(fsync, fsync, 118, 1) -#endif -#ifndef OVERRIDE_TABLE_32_mprotect -TRACE_SYSCALL_TABLE(mprotect, mprotect, 125, 3) -#endif -#ifndef OVERRIDE_TABLE_32_getpgid -TRACE_SYSCALL_TABLE(getpgid, getpgid, 132, 1) -#endif -#ifndef OVERRIDE_TABLE_32_fchdir -TRACE_SYSCALL_TABLE(fchdir, fchdir, 133, 1) -#endif -#ifndef OVERRIDE_TABLE_32_bdflush -TRACE_SYSCALL_TABLE(bdflush, bdflush, 134, 2) -#endif -#ifndef OVERRIDE_TABLE_32_sysfs -TRACE_SYSCALL_TABLE(sysfs, sysfs, 135, 3) -#endif -#ifndef OVERRIDE_TABLE_32_personality -TRACE_SYSCALL_TABLE(personality, personality, 136, 1) -#endif -#ifndef OVERRIDE_TABLE_32_setfsuid -TRACE_SYSCALL_TABLE(setfsuid, setfsuid, 138, 1) -#endif -#ifndef OVERRIDE_TABLE_32_setfsgid -TRACE_SYSCALL_TABLE(setfsgid, setfsgid, 139, 1) -#endif -#ifndef OVERRIDE_TABLE_32_flock -TRACE_SYSCALL_TABLE(flock, flock, 143, 2) -#endif -#ifndef OVERRIDE_TABLE_32_msync -TRACE_SYSCALL_TABLE(msync, msync, 144, 3) -#endif -#ifndef OVERRIDE_TABLE_32_getsid -TRACE_SYSCALL_TABLE(getsid, getsid, 147, 1) -#endif -#ifndef OVERRIDE_TABLE_32_fdatasync -TRACE_SYSCALL_TABLE(fdatasync, fdatasync, 148, 1) -#endif -#ifndef OVERRIDE_TABLE_32_mlock -TRACE_SYSCALL_TABLE(mlock, mlock, 150, 2) -#endif -#ifndef OVERRIDE_TABLE_32_munlock -TRACE_SYSCALL_TABLE(munlock, munlock, 151, 2) -#endif -#ifndef OVERRIDE_TABLE_32_mlockall -TRACE_SYSCALL_TABLE(mlockall, mlockall, 152, 1) -#endif -#ifndef OVERRIDE_TABLE_32_sched_getscheduler -TRACE_SYSCALL_TABLE(sched_getscheduler, sched_getscheduler, 157, 1) -#endif -#ifndef OVERRIDE_TABLE_32_sched_get_priority_max -TRACE_SYSCALL_TABLE(sched_get_priority_max, sched_get_priority_max, 159, 1) -#endif -#ifndef OVERRIDE_TABLE_32_sched_get_priority_min -TRACE_SYSCALL_TABLE(sched_get_priority_min, sched_get_priority_min, 160, 1) -#endif -#ifndef OVERRIDE_TABLE_32_mremap -TRACE_SYSCALL_TABLE(mremap, mremap, 163, 5) -#endif -#ifndef OVERRIDE_TABLE_32_setresuid -TRACE_SYSCALL_TABLE(setresuid, setresuid, 164, 3) -#endif -#ifndef OVERRIDE_TABLE_32_setresgid -TRACE_SYSCALL_TABLE(setresgid, setresgid, 169, 3) -#endif -#ifndef OVERRIDE_TABLE_32_prctl -TRACE_SYSCALL_TABLE(prctl, prctl, 171, 5) -#endif -#ifndef OVERRIDE_TABLE_32_fcntl64 -TRACE_SYSCALL_TABLE(fcntl64, fcntl64, 204, 3) -#endif -#ifndef OVERRIDE_TABLE_32_madvise -TRACE_SYSCALL_TABLE(madvise, madvise, 205, 3) -#endif -#ifndef OVERRIDE_TABLE_32_tkill -TRACE_SYSCALL_TABLE(tkill, tkill, 208, 2) -#endif -#ifndef OVERRIDE_TABLE_32_io_destroy -TRACE_SYSCALL_TABLE(io_destroy, io_destroy, 228, 1) -#endif -#ifndef OVERRIDE_TABLE_32_exit_group -TRACE_SYSCALL_TABLE(exit_group, exit_group, 234, 1) -#endif -#ifndef OVERRIDE_TABLE_32_epoll_create -TRACE_SYSCALL_TABLE(epoll_create, epoll_create, 236, 1) -#endif -#ifndef OVERRIDE_TABLE_32_remap_file_pages -TRACE_SYSCALL_TABLE(remap_file_pages, remap_file_pages, 239, 5) -#endif -#ifndef OVERRIDE_TABLE_32_timer_getoverrun -TRACE_SYSCALL_TABLE(timer_getoverrun, timer_getoverrun, 243, 1) -#endif -#ifndef OVERRIDE_TABLE_32_timer_delete -TRACE_SYSCALL_TABLE(timer_delete, timer_delete, 244, 1) -#endif -#ifndef OVERRIDE_TABLE_32_tgkill -TRACE_SYSCALL_TABLE(tgkill, tgkill, 250, 3) -#endif -#ifndef OVERRIDE_TABLE_32_keyctl -TRACE_SYSCALL_TABLE(keyctl, keyctl, 271, 5) -#endif -#ifndef OVERRIDE_TABLE_32_ioprio_set -TRACE_SYSCALL_TABLE(ioprio_set, ioprio_set, 273, 3) -#endif -#ifndef OVERRIDE_TABLE_32_ioprio_get -TRACE_SYSCALL_TABLE(ioprio_get, ioprio_get, 274, 2) -#endif -#ifndef OVERRIDE_TABLE_32_inotify_rm_watch -TRACE_SYSCALL_TABLE(inotify_rm_watch, inotify_rm_watch, 277, 2) -#endif -#ifndef OVERRIDE_TABLE_32_unshare -TRACE_SYSCALL_TABLE(unshare, unshare, 282, 1) -#endif -#ifndef OVERRIDE_TABLE_32_tee -TRACE_SYSCALL_TABLE(tee, tee, 284, 4) -#endif -#ifndef OVERRIDE_TABLE_32_timerfd_create -TRACE_SYSCALL_TABLE(timerfd_create, timerfd_create, 306, 2) -#endif -#ifndef OVERRIDE_TABLE_32_eventfd -TRACE_SYSCALL_TABLE(eventfd, eventfd, 307, 1) -#endif -#ifndef OVERRIDE_TABLE_32_eventfd2 -TRACE_SYSCALL_TABLE(eventfd2, eventfd2, 314, 2) -#endif -#ifndef OVERRIDE_TABLE_32_epoll_create1 -TRACE_SYSCALL_TABLE(epoll_create1, epoll_create1, 315, 1) -#endif -#ifndef OVERRIDE_TABLE_32_dup3 -TRACE_SYSCALL_TABLE(dup3, dup3, 316, 3) -#endif -#ifndef OVERRIDE_TABLE_32_inotify_init1 -TRACE_SYSCALL_TABLE(inotify_init1, inotify_init1, 318, 1) -#endif -#ifndef OVERRIDE_TABLE_32_socket -TRACE_SYSCALL_TABLE(socket, socket, 326, 3) -#endif -#ifndef OVERRIDE_TABLE_32_listen -TRACE_SYSCALL_TABLE(listen, listen, 329, 2) -#endif -#ifndef OVERRIDE_TABLE_32_shutdown -TRACE_SYSCALL_TABLE(shutdown, shutdown, 338, 2) -#endif -#ifndef OVERRIDE_TABLE_32_syncfs -TRACE_SYSCALL_TABLE(syncfs, syncfs, 348, 1) -#endif -#ifndef OVERRIDE_TABLE_32_setns -TRACE_SYSCALL_TABLE(setns, setns, 350, 2) -#endif - -#endif /* CREATE_SYSCALL_TABLE */ diff --git a/instrumentation/syscalls/headers/powerpc-32-syscalls_integers_override.h b/instrumentation/syscalls/headers/powerpc-32-syscalls_integers_override.h deleted file mode 100644 index 529a4927..00000000 --- a/instrumentation/syscalls/headers/powerpc-32-syscalls_integers_override.h +++ /dev/null @@ -1,74 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ - -#ifndef CREATE_SYSCALL_TABLE - -#define OVERRIDE_32_mmap2 -SC_LTTNG_TRACEPOINT_EVENT(mmap2, - TP_PROTO(sc_exit(unsigned long ret,) - unsigned long addr, unsigned long len, - unsigned long prot, unsigned long flags, - unsigned long fd, unsigned long pgoff), - TP_ARGS(sc_exit(ret,) addr, len, prot, flags, fd, pgoff), - TP_FIELDS(sc_exit(ctf_integer_hex(unsigned long, ret, ret)) - sc_in(ctf_integer_hex(unsigned long, addr, addr)) - sc_in(ctf_integer(size_t, len, len)) - sc_in(ctf_integer(int, prot, prot)) - sc_in(ctf_integer(int, flags, flags)) - sc_in(ctf_integer(int, fd, fd)) - sc_in(ctf_integer(off_t, pgoff, pgoff)) - ) -) - -#if (__BYTE_ORDER == __LITTLE_ENDIAN) - -#define OVERRIDE_32_sync_file_range2 -SC_LTTNG_TRACEPOINT_EVENT(sync_file_range2, - TP_PROTO(sc_exit(long ret,) int fd, - unsigned int flags, - int32_t offset_low, int32_t offset_high, - int32_t nbytes_low, int32_t nbytes_high), - TP_ARGS(sc_exit(ret,) fd, flags, offset_low, offset_high, - nbytes_low, nbytes_high), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) - sc_in(ctf_integer(int, fd, fd)) - sc_in(ctf_integer(unsigned int, flags, flags)) - sc_in(ctf_integer(loff_t, offset, - ((loff_t) offset_high << 32) | offset_low)) - sc_in(ctf_integer(loff_t, nbytes, - ((loff_t) nbytes_high << 32) | nbytes_low)) - ) -) - -#else /* __BIG_ENDIAN */ - -#define OVERRIDE_32_sync_file_range2 -SC_LTTNG_TRACEPOINT_EVENT(sync_file_range2, - TP_PROTO(sc_exit(long ret,) int fd, - unsigned int flags, - int32_t offset_high, int32_t offset_low, - int32_t nbytes_high, int32_t nbytes_low), - TP_ARGS(sc_exit(ret,) fd, flags, offset_high, offset_low, - nbytes_high, nbytes_low), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) - sc_in(ctf_integer(int, fd, fd)) - sc_in(ctf_integer(unsigned int, flags, flags)) - sc_in(ctf_integer(loff_t, offset, - ((loff_t) offset_high << 32) | offset_low)) - sc_in(ctf_integer(loff_t, nbytes, - ((loff_t) nbytes_high << 32) | nbytes_low)) - ) -) - -#endif - -#else /* CREATE_SYSCALL_TABLE */ - -#define OVERRIDE_TABLE_32_mmap -TRACE_SYSCALL_TABLE(mmap, mmap, 90, 6) -#define OVERRIDE_TABLE_32_mmap2 -TRACE_SYSCALL_TABLE(mmap2, mmap2, 192, 6) -#define OVERRIDE_TABLE_32_sync_file_range2 -TRACE_SYSCALL_TABLE(sync_file_range2, sync_file_range2, 308, 6) - -#endif /* CREATE_SYSCALL_TABLE */ - diff --git a/instrumentation/syscalls/headers/powerpc-32-syscalls_pointers.h b/instrumentation/syscalls/headers/powerpc-32-syscalls_pointers.h deleted file mode 100644 index 73a28a79..00000000 --- a/instrumentation/syscalls/headers/powerpc-32-syscalls_pointers.h +++ /dev/null @@ -1,1939 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ - -/* THIS FILE IS AUTO-GENERATED. DO NOT EDIT */ - -/* Generated from powerpc-32-syscalls 3.0.34 */ - -#ifndef CREATE_SYSCALL_TABLE - -#if !defined(_TRACE_SYSCALLS_POINTERS_H) || defined(TRACE_HEADER_MULTI_READ) -#define _TRACE_SYSCALLS_POINTERS_H - -#include -#include -#include "powerpc-32-syscalls_pointers_override.h" -#include "syscalls_pointers_override.h" - -#ifndef OVERRIDE_32_unlink -SC_LTTNG_TRACEPOINT_EVENT(unlink, - TP_PROTO(sc_exit(long ret,) const char * pathname), - TP_ARGS(sc_exit(ret,) pathname), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname))) -) -#endif -#ifndef OVERRIDE_32_chdir -SC_LTTNG_TRACEPOINT_EVENT(chdir, - TP_PROTO(sc_exit(long ret,) const char * filename), - TP_ARGS(sc_exit(ret,) filename), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename))) -) -#endif -#ifndef OVERRIDE_32_time -SC_LTTNG_TRACEPOINT_EVENT(time, - TP_PROTO(sc_exit(long ret,) time_t * tloc), - TP_ARGS(sc_exit(ret,) tloc), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(time_t *, tloc, tloc))) -) -#endif -#ifndef OVERRIDE_32_oldumount -SC_LTTNG_TRACEPOINT_EVENT(oldumount, - TP_PROTO(sc_exit(long ret,) char * name), - TP_ARGS(sc_exit(ret,) name), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(name, name))) -) -#endif -#ifndef OVERRIDE_32_stime -SC_LTTNG_TRACEPOINT_EVENT(stime, - TP_PROTO(sc_exit(long ret,) time_t * tptr), - TP_ARGS(sc_exit(ret,) tptr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(time_t *, tptr, tptr))) -) -#endif -#ifndef OVERRIDE_32_rmdir -SC_LTTNG_TRACEPOINT_EVENT(rmdir, - TP_PROTO(sc_exit(long ret,) const char * pathname), - TP_ARGS(sc_exit(ret,) pathname), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname))) -) -#endif -#ifndef OVERRIDE_32_pipe -SC_LTTNG_TRACEPOINT_EVENT(pipe, - TP_PROTO(sc_exit(long ret,) int * fildes), - TP_ARGS(sc_exit(ret,) fildes), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(int *, fildes, fildes))) -) -#endif -#ifndef OVERRIDE_32_times -SC_LTTNG_TRACEPOINT_EVENT(times, - TP_PROTO(sc_exit(long ret,) struct tms * tbuf), - TP_ARGS(sc_exit(ret,) tbuf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct tms *, tbuf, tbuf))) -) -#endif -#ifndef OVERRIDE_32_acct -SC_LTTNG_TRACEPOINT_EVENT(acct, - TP_PROTO(sc_exit(long ret,) const char * name), - TP_ARGS(sc_exit(ret,) name), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name))) -) -#endif -#ifndef OVERRIDE_32_olduname -SC_LTTNG_TRACEPOINT_EVENT(olduname, - TP_PROTO(sc_exit(long ret,) struct oldold_utsname * name), - TP_ARGS(sc_exit(ret,) name), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct oldold_utsname *, name, name))) -) -#endif -#ifndef OVERRIDE_32_chroot -SC_LTTNG_TRACEPOINT_EVENT(chroot, - TP_PROTO(sc_exit(long ret,) const char * filename), - TP_ARGS(sc_exit(ret,) filename), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename))) -) -#endif -#ifndef OVERRIDE_32_sigpending -SC_LTTNG_TRACEPOINT_EVENT(sigpending, - TP_PROTO(sc_exit(long ret,) old_sigset_t * set), - TP_ARGS(sc_exit(ret,) set), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(old_sigset_t *, set, set))) -) -#endif -#ifndef OVERRIDE_32_uselib -SC_LTTNG_TRACEPOINT_EVENT(uselib, - TP_PROTO(sc_exit(long ret,) const char * library), - TP_ARGS(sc_exit(ret,) library), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(const char *, library, library))) -) -#endif -#ifndef OVERRIDE_32_uname -SC_LTTNG_TRACEPOINT_EVENT(uname, - TP_PROTO(sc_exit(long ret,) struct old_utsname * name), - TP_ARGS(sc_exit(ret,) name), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct old_utsname *, name, name))) -) -#endif -#ifndef OVERRIDE_32_swapoff -SC_LTTNG_TRACEPOINT_EVENT(swapoff, - TP_PROTO(sc_exit(long ret,) const char * specialfile), - TP_ARGS(sc_exit(ret,) specialfile), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(specialfile, specialfile))) -) -#endif -#ifndef OVERRIDE_32_sysinfo -SC_LTTNG_TRACEPOINT_EVENT(sysinfo, - TP_PROTO(sc_exit(long ret,) struct sysinfo * info), - TP_ARGS(sc_exit(ret,) info), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct sysinfo *, info, info))) -) -#endif -#ifndef OVERRIDE_32_newuname -SC_LTTNG_TRACEPOINT_EVENT(newuname, - TP_PROTO(sc_exit(long ret,) struct new_utsname * name), - TP_ARGS(sc_exit(ret,) name), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct new_utsname *, name, name))) -) -#endif -#ifndef OVERRIDE_32_adjtimex -SC_LTTNG_TRACEPOINT_EVENT(adjtimex, - TP_PROTO(sc_exit(long ret,) struct timex * txc_p), - TP_ARGS(sc_exit(ret,) txc_p), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct timex *, txc_p, txc_p))) -) -#endif -#ifndef OVERRIDE_32_sysctl -SC_LTTNG_TRACEPOINT_EVENT(sysctl, - TP_PROTO(sc_exit(long ret,) struct __sysctl_args * args), - TP_ARGS(sc_exit(ret,) args), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct __sysctl_args *, args, args))) -) -#endif -#ifndef OVERRIDE_32_set_tid_address -SC_LTTNG_TRACEPOINT_EVENT(set_tid_address, - TP_PROTO(sc_exit(long ret,) int * tidptr), - TP_ARGS(sc_exit(ret,) tidptr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int *, tidptr, tidptr))) -) -#endif -#ifndef OVERRIDE_32_mq_unlink -SC_LTTNG_TRACEPOINT_EVENT(mq_unlink, - TP_PROTO(sc_exit(long ret,) const char * u_name), - TP_ARGS(sc_exit(ret,) u_name), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(u_name, u_name))) -) -#endif -#ifndef OVERRIDE_32_creat -SC_LTTNG_TRACEPOINT_EVENT(creat, - TP_PROTO(sc_exit(long ret,) const char * pathname, int mode), - TP_ARGS(sc_exit(ret,) pathname, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(int, mode, mode))) -) -#endif -#ifndef OVERRIDE_32_link -SC_LTTNG_TRACEPOINT_EVENT(link, - TP_PROTO(sc_exit(long ret,) const char * oldname, const char * newname), - TP_ARGS(sc_exit(ret,) oldname, newname), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_user_string(newname, newname))) -) -#endif -#ifndef OVERRIDE_32_chmod -SC_LTTNG_TRACEPOINT_EVENT(chmod, - TP_PROTO(sc_exit(long ret,) const char * filename, mode_t mode), - TP_ARGS(sc_exit(ret,) filename, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(mode_t, mode, mode))) -) -#endif -#ifndef OVERRIDE_32_stat -SC_LTTNG_TRACEPOINT_EVENT(stat, - TP_PROTO(sc_exit(long ret,) const char * filename, struct __old_kernel_stat * statbuf), - TP_ARGS(sc_exit(ret,) filename, statbuf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(filename, filename)) sc_inout(ctf_integer(struct __old_kernel_stat *, statbuf, statbuf))) -) -#endif -#ifndef OVERRIDE_32_fstat -SC_LTTNG_TRACEPOINT_EVENT(fstat, - TP_PROTO(sc_exit(long ret,) unsigned int fd, struct __old_kernel_stat * statbuf), - TP_ARGS(sc_exit(ret,) fd, statbuf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, fd, fd)) sc_inout(ctf_integer(struct __old_kernel_stat *, statbuf, statbuf))) -) -#endif -#ifndef OVERRIDE_32_utime -SC_LTTNG_TRACEPOINT_EVENT(utime, - TP_PROTO(sc_exit(long ret,) char * filename, struct utimbuf * times), - TP_ARGS(sc_exit(ret,) filename, times), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(struct utimbuf *, times, times))) -) -#endif -#ifndef OVERRIDE_32_access -SC_LTTNG_TRACEPOINT_EVENT(access, - TP_PROTO(sc_exit(long ret,) const char * filename, int mode), - TP_ARGS(sc_exit(ret,) filename, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, mode, mode))) -) -#endif -#ifndef OVERRIDE_32_rename -SC_LTTNG_TRACEPOINT_EVENT(rename, - TP_PROTO(sc_exit(long ret,) const char * oldname, const char * newname), - TP_ARGS(sc_exit(ret,) oldname, newname), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_user_string(newname, newname))) -) -#endif -#ifndef OVERRIDE_32_mkdir -SC_LTTNG_TRACEPOINT_EVENT(mkdir, - TP_PROTO(sc_exit(long ret,) const char * pathname, int mode), - TP_ARGS(sc_exit(ret,) pathname, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(int, mode, mode))) -) -#endif -#ifndef OVERRIDE_32_umount -SC_LTTNG_TRACEPOINT_EVENT(umount, - TP_PROTO(sc_exit(long ret,) char * name, int flags), - TP_ARGS(sc_exit(ret,) name, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_ustat -SC_LTTNG_TRACEPOINT_EVENT(ustat, - TP_PROTO(sc_exit(long ret,) unsigned dev, struct ustat * ubuf), - TP_ARGS(sc_exit(ret,) dev, ubuf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned, dev, dev)) sc_out(ctf_integer(struct ustat *, ubuf, ubuf))) -) -#endif -#ifndef OVERRIDE_32_sethostname -SC_LTTNG_TRACEPOINT_EVENT(sethostname, - TP_PROTO(sc_exit(long ret,) char * name, int len), - TP_ARGS(sc_exit(ret,) name, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(int, len, len))) -) -#endif -#ifndef OVERRIDE_32_setrlimit -SC_LTTNG_TRACEPOINT_EVENT(setrlimit, - TP_PROTO(sc_exit(long ret,) unsigned int resource, struct rlimit * rlim), - TP_ARGS(sc_exit(ret,) resource, rlim), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, resource, resource)) sc_in(ctf_integer(struct rlimit *, rlim, rlim))) -) -#endif -#ifndef OVERRIDE_32_old_getrlimit -SC_LTTNG_TRACEPOINT_EVENT(old_getrlimit, - TP_PROTO(sc_exit(long ret,) unsigned int resource, struct rlimit * rlim), - TP_ARGS(sc_exit(ret,) resource, rlim), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, resource, resource)) sc_inout(ctf_integer(struct rlimit *, rlim, rlim))) -) -#endif -#ifndef OVERRIDE_32_getrusage -SC_LTTNG_TRACEPOINT_EVENT(getrusage, - TP_PROTO(sc_exit(long ret,) int who, struct rusage * ru), - TP_ARGS(sc_exit(ret,) who, ru), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, who, who)) sc_out(ctf_integer(struct rusage *, ru, ru))) -) -#endif -#ifndef OVERRIDE_32_gettimeofday -SC_LTTNG_TRACEPOINT_EVENT(gettimeofday, - TP_PROTO(sc_exit(long ret,) struct timeval * tv, struct timezone * tz), - TP_ARGS(sc_exit(ret,) tv, tz), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct timeval *, tv, tv)) sc_out(ctf_integer(struct timezone *, tz, tz))) -) -#endif -#ifndef OVERRIDE_32_settimeofday -SC_LTTNG_TRACEPOINT_EVENT(settimeofday, - TP_PROTO(sc_exit(long ret,) struct timeval * tv, struct timezone * tz), - TP_ARGS(sc_exit(ret,) tv, tz), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct timeval *, tv, tv)) sc_in(ctf_integer(struct timezone *, tz, tz))) -) -#endif -#ifndef OVERRIDE_32_getgroups -SC_LTTNG_TRACEPOINT_EVENT(getgroups, - TP_PROTO(sc_exit(long ret,) int gidsetsize, gid_t * grouplist), - TP_ARGS(sc_exit(ret,) gidsetsize, grouplist), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, gidsetsize, gidsetsize)) sc_out(ctf_integer(gid_t *, grouplist, grouplist))) -) -#endif -#ifndef OVERRIDE_32_setgroups -SC_LTTNG_TRACEPOINT_EVENT(setgroups, - TP_PROTO(sc_exit(long ret,) int gidsetsize, gid_t * grouplist), - TP_ARGS(sc_exit(ret,) gidsetsize, grouplist), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, gidsetsize, gidsetsize)) sc_in(ctf_integer(gid_t *, grouplist, grouplist))) -) -#endif -#ifndef OVERRIDE_32_symlink -SC_LTTNG_TRACEPOINT_EVENT(symlink, - TP_PROTO(sc_exit(long ret,) const char * oldname, const char * newname), - TP_ARGS(sc_exit(ret,) oldname, newname), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_user_string(newname, newname))) -) -#endif -#ifndef OVERRIDE_32_lstat -SC_LTTNG_TRACEPOINT_EVENT(lstat, - TP_PROTO(sc_exit(long ret,) const char * filename, struct __old_kernel_stat * statbuf), - TP_ARGS(sc_exit(ret,) filename, statbuf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(filename, filename)) sc_inout(ctf_integer(struct __old_kernel_stat *, statbuf, statbuf))) -) -#endif -#ifndef OVERRIDE_32_swapon -SC_LTTNG_TRACEPOINT_EVENT(swapon, - TP_PROTO(sc_exit(long ret,) const char * specialfile, int swap_flags), - TP_ARGS(sc_exit(ret,) specialfile, swap_flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(specialfile, specialfile)) sc_in(ctf_integer(int, swap_flags, swap_flags))) -) -#endif -#ifndef OVERRIDE_32_truncate -SC_LTTNG_TRACEPOINT_EVENT(truncate, - TP_PROTO(sc_exit(long ret,) const char * path, long length), - TP_ARGS(sc_exit(ret,) path, length), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(path, path)) sc_in(ctf_integer(long, length, length))) -) -#endif -#ifndef OVERRIDE_32_statfs -SC_LTTNG_TRACEPOINT_EVENT(statfs, - TP_PROTO(sc_exit(long ret,) const char * pathname, struct statfs * buf), - TP_ARGS(sc_exit(ret,) pathname, buf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(struct statfs *, buf, buf))) -) -#endif -#ifndef OVERRIDE_32_fstatfs -SC_LTTNG_TRACEPOINT_EVENT(fstatfs, - TP_PROTO(sc_exit(long ret,) unsigned int fd, struct statfs * buf), - TP_ARGS(sc_exit(ret,) fd, buf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct statfs *, buf, buf))) -) -#endif -#ifndef OVERRIDE_32_socketcall -SC_LTTNG_TRACEPOINT_EVENT(socketcall, - TP_PROTO(sc_exit(long ret,) int call, unsigned long * args), - TP_ARGS(sc_exit(ret,) call, args), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, call, call)) sc_inout(ctf_integer(unsigned long *, args, args))) -) -#endif -#ifndef OVERRIDE_32_getitimer -SC_LTTNG_TRACEPOINT_EVENT(getitimer, - TP_PROTO(sc_exit(long ret,) int which, struct itimerval * value), - TP_ARGS(sc_exit(ret,) which, value), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_out(ctf_integer(struct itimerval *, value, value))) -) -#endif -#ifndef OVERRIDE_32_newstat -SC_LTTNG_TRACEPOINT_EVENT(newstat, - TP_PROTO(sc_exit(long ret,) const char * filename, struct stat * statbuf), - TP_ARGS(sc_exit(ret,) filename, statbuf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_out(ctf_integer(struct stat *, statbuf, statbuf))) -) -#endif -#ifndef OVERRIDE_32_newlstat -SC_LTTNG_TRACEPOINT_EVENT(newlstat, - TP_PROTO(sc_exit(long ret,) const char * filename, struct stat * statbuf), - TP_ARGS(sc_exit(ret,) filename, statbuf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_out(ctf_integer(struct stat *, statbuf, statbuf))) -) -#endif -#ifndef OVERRIDE_32_newfstat -SC_LTTNG_TRACEPOINT_EVENT(newfstat, - TP_PROTO(sc_exit(long ret,) unsigned int fd, struct stat * statbuf), - TP_ARGS(sc_exit(ret,) fd, statbuf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct stat *, statbuf, statbuf))) -) -#endif -#ifndef OVERRIDE_32_setdomainname -SC_LTTNG_TRACEPOINT_EVENT(setdomainname, - TP_PROTO(sc_exit(long ret,) char * name, int len), - TP_ARGS(sc_exit(ret,) name, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(int, len, len))) -) -#endif -#ifndef OVERRIDE_32_delete_module -SC_LTTNG_TRACEPOINT_EVENT(delete_module, - TP_PROTO(sc_exit(long ret,) const char * name_user, unsigned int flags), - TP_ARGS(sc_exit(ret,) name_user, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name_user, name_user)) sc_in(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_sched_setparam -SC_LTTNG_TRACEPOINT_EVENT(sched_setparam, - TP_PROTO(sc_exit(long ret,) pid_t pid, struct sched_param * param), - TP_ARGS(sc_exit(ret,) pid, param), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(struct sched_param *, param, param))) -) -#endif -#ifndef OVERRIDE_32_sched_getparam -SC_LTTNG_TRACEPOINT_EVENT(sched_getparam, - TP_PROTO(sc_exit(long ret,) pid_t pid, struct sched_param * param), - TP_ARGS(sc_exit(ret,) pid, param), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_out(ctf_integer(struct sched_param *, param, param))) -) -#endif -#ifndef OVERRIDE_32_sched_rr_get_interval -SC_LTTNG_TRACEPOINT_EVENT(sched_rr_get_interval, - TP_PROTO(sc_exit(long ret,) pid_t pid, struct timespec * interval), - TP_ARGS(sc_exit(ret,) pid, interval), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_out(ctf_integer(struct timespec *, interval, interval))) -) -#endif -#ifndef OVERRIDE_32_nanosleep -SC_LTTNG_TRACEPOINT_EVENT(nanosleep, - TP_PROTO(sc_exit(long ret,) struct timespec * rqtp, struct timespec * rmtp), - TP_ARGS(sc_exit(ret,) rqtp, rmtp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct timespec *, rqtp, rqtp)) sc_out(ctf_integer(struct timespec *, rmtp, rmtp))) -) -#endif -#ifndef OVERRIDE_32_rt_sigpending -SC_LTTNG_TRACEPOINT_EVENT(rt_sigpending, - TP_PROTO(sc_exit(long ret,) sigset_t * set, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) set, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(sigset_t *, set, set)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) -) -#endif -#ifndef OVERRIDE_32_rt_sigsuspend -SC_LTTNG_TRACEPOINT_EVENT(rt_sigsuspend, - TP_PROTO(sc_exit(long ret,) sigset_t * unewset, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) unewset, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(sigset_t *, unewset, unewset)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) -) -#endif -#ifndef OVERRIDE_32_getcwd -SC_LTTNG_TRACEPOINT_EVENT(getcwd, - TP_PROTO(sc_exit(long ret,) char * buf, unsigned long size), - TP_ARGS(sc_exit(ret,) buf, size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(unsigned long, size, size))) -) -#endif -#ifndef OVERRIDE_32_getrlimit -SC_LTTNG_TRACEPOINT_EVENT(getrlimit, - TP_PROTO(sc_exit(long ret,) unsigned int resource, struct rlimit * rlim), - TP_ARGS(sc_exit(ret,) resource, rlim), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, resource, resource)) sc_out(ctf_integer(struct rlimit *, rlim, rlim))) -) -#endif -#ifndef OVERRIDE_32_stat64 -SC_LTTNG_TRACEPOINT_EVENT(stat64, - TP_PROTO(sc_exit(long ret,) const char * filename, struct stat64 * statbuf), - TP_ARGS(sc_exit(ret,) filename, statbuf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(filename, filename)) sc_inout(ctf_integer(struct stat64 *, statbuf, statbuf))) -) -#endif -#ifndef OVERRIDE_32_lstat64 -SC_LTTNG_TRACEPOINT_EVENT(lstat64, - TP_PROTO(sc_exit(long ret,) const char * filename, struct stat64 * statbuf), - TP_ARGS(sc_exit(ret,) filename, statbuf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(filename, filename)) sc_inout(ctf_integer(struct stat64 *, statbuf, statbuf))) -) -#endif -#ifndef OVERRIDE_32_fstat64 -SC_LTTNG_TRACEPOINT_EVENT(fstat64, - TP_PROTO(sc_exit(long ret,) unsigned long fd, struct stat64 * statbuf), - TP_ARGS(sc_exit(ret,) fd, statbuf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned long, fd, fd)) sc_inout(ctf_integer(struct stat64 *, statbuf, statbuf))) -) -#endif -#ifndef OVERRIDE_32_pivot_root -SC_LTTNG_TRACEPOINT_EVENT(pivot_root, - TP_PROTO(sc_exit(long ret,) const char * new_root, const char * put_old), - TP_ARGS(sc_exit(ret,) new_root, put_old), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(new_root, new_root)) sc_in(ctf_user_string(put_old, put_old))) -) -#endif -#ifndef OVERRIDE_32_removexattr -SC_LTTNG_TRACEPOINT_EVENT(removexattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name), - TP_ARGS(sc_exit(ret,) pathname, name), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name))) -) -#endif -#ifndef OVERRIDE_32_lremovexattr -SC_LTTNG_TRACEPOINT_EVENT(lremovexattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name), - TP_ARGS(sc_exit(ret,) pathname, name), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name))) -) -#endif -#ifndef OVERRIDE_32_fremovexattr -SC_LTTNG_TRACEPOINT_EVENT(fremovexattr, - TP_PROTO(sc_exit(long ret,) int fd, const char * name), - TP_ARGS(sc_exit(ret,) fd, name), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(name, name))) -) -#endif -#ifndef OVERRIDE_32_io_setup -SC_LTTNG_TRACEPOINT_EVENT(io_setup, - TP_PROTO(sc_exit(long ret,) unsigned nr_events, aio_context_t * ctxp), - TP_ARGS(sc_exit(ret,) nr_events, ctxp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned, nr_events, nr_events)) sc_in(ctf_integer(aio_context_t *, ctxp, ctxp))) -) -#endif -#ifndef OVERRIDE_32_timer_gettime -SC_LTTNG_TRACEPOINT_EVENT(timer_gettime, - TP_PROTO(sc_exit(long ret,) timer_t timer_id, struct itimerspec * setting), - TP_ARGS(sc_exit(ret,) timer_id, setting), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id)) sc_out(ctf_integer(struct itimerspec *, setting, setting))) -) -#endif -#ifndef OVERRIDE_32_clock_settime -SC_LTTNG_TRACEPOINT_EVENT(clock_settime, - TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, const struct timespec * tp), - TP_ARGS(sc_exit(ret,) which_clock, tp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_in(ctf_integer(const struct timespec *, tp, tp))) -) -#endif -#ifndef OVERRIDE_32_clock_gettime -SC_LTTNG_TRACEPOINT_EVENT(clock_gettime, - TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct timespec * tp), - TP_ARGS(sc_exit(ret,) which_clock, tp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_out(ctf_integer(struct timespec *, tp, tp))) -) -#endif -#ifndef OVERRIDE_32_clock_getres -SC_LTTNG_TRACEPOINT_EVENT(clock_getres, - TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct timespec * tp), - TP_ARGS(sc_exit(ret,) which_clock, tp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_out(ctf_integer(struct timespec *, tp, tp))) -) -#endif -#ifndef OVERRIDE_32_utimes -SC_LTTNG_TRACEPOINT_EVENT(utimes, - TP_PROTO(sc_exit(long ret,) char * filename, struct timeval * utimes), - TP_ARGS(sc_exit(ret,) filename, utimes), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(struct timeval *, utimes, utimes))) -) -#endif -#ifndef OVERRIDE_32_mq_notify -SC_LTTNG_TRACEPOINT_EVENT(mq_notify, - TP_PROTO(sc_exit(long ret,) mqd_t mqdes, const struct sigevent * u_notification), - TP_ARGS(sc_exit(ret,) mqdes, u_notification), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(mqd_t, mqdes, mqdes)) sc_in(ctf_integer(const struct sigevent *, u_notification, u_notification))) -) -#endif -#ifndef OVERRIDE_32_set_robust_list -SC_LTTNG_TRACEPOINT_EVENT(set_robust_list, - TP_PROTO(sc_exit(long ret,) struct robust_list_head * head, size_t len), - TP_ARGS(sc_exit(ret,) head, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct robust_list_head *, head, head)) sc_in(ctf_integer(size_t, len, len))) -) -#endif -#ifndef OVERRIDE_32_timerfd_gettime -SC_LTTNG_TRACEPOINT_EVENT(timerfd_gettime, - TP_PROTO(sc_exit(long ret,) int ufd, struct itimerspec * otmr), - TP_ARGS(sc_exit(ret,) ufd, otmr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_out(ctf_integer(struct itimerspec *, otmr, otmr))) -) -#endif -#ifndef OVERRIDE_32_pipe2 -SC_LTTNG_TRACEPOINT_EVENT(pipe2, - TP_PROTO(sc_exit(long ret,) int * fildes, int flags), - TP_ARGS(sc_exit(ret,) fildes, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(int *, fildes, fildes)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_clock_adjtime -SC_LTTNG_TRACEPOINT_EVENT(clock_adjtime, - TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct timex * utx), - TP_ARGS(sc_exit(ret,) which_clock, utx), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_inout(ctf_integer(struct timex *, utx, utx))) -) -#endif -#ifndef OVERRIDE_32_read -SC_LTTNG_TRACEPOINT_EVENT(read, - TP_PROTO(sc_exit(long ret,) unsigned int fd, char * buf, size_t count), - TP_ARGS(sc_exit(ret,) fd, buf, count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(size_t, count, count))) -) -#endif -#ifndef OVERRIDE_32_write -SC_LTTNG_TRACEPOINT_EVENT(write, - TP_PROTO(sc_exit(long ret,) unsigned int fd, const char * buf, size_t count), - TP_ARGS(sc_exit(ret,) fd, buf, count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(const char *, buf, buf)) sc_in(ctf_integer(size_t, count, count))) -) -#endif -#ifndef OVERRIDE_32_open -SC_LTTNG_TRACEPOINT_EVENT(open, - TP_PROTO(sc_exit(long ret,) const char * filename, int flags, int mode), - TP_ARGS(sc_exit(ret,) filename, flags, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(int, mode, mode))) -) -#endif -#ifndef OVERRIDE_32_waitpid -SC_LTTNG_TRACEPOINT_EVENT(waitpid, - TP_PROTO(sc_exit(long ret,) pid_t pid, int * stat_addr, int options), - TP_ARGS(sc_exit(ret,) pid, stat_addr, options), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(pid_t, pid, pid)) sc_inout(ctf_integer(int *, stat_addr, stat_addr)) sc_inout(ctf_integer(int, options, options))) -) -#endif -#ifndef OVERRIDE_32_mknod -SC_LTTNG_TRACEPOINT_EVENT(mknod, - TP_PROTO(sc_exit(long ret,) const char * filename, int mode, unsigned dev), - TP_ARGS(sc_exit(ret,) filename, mode, dev), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, mode, mode)) sc_in(ctf_integer(unsigned, dev, dev))) -) -#endif -#ifndef OVERRIDE_32_lchown -SC_LTTNG_TRACEPOINT_EVENT(lchown, - TP_PROTO(sc_exit(long ret,) const char * filename, uid_t user, gid_t group), - TP_ARGS(sc_exit(ret,) filename, user, group), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group))) -) -#endif -#ifndef OVERRIDE_32_readlink -SC_LTTNG_TRACEPOINT_EVENT(readlink, - TP_PROTO(sc_exit(long ret,) const char * path, char * buf, int bufsiz), - TP_ARGS(sc_exit(ret,) path, buf, bufsiz), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(path, path)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(int, bufsiz, bufsiz))) -) -#endif -#ifndef OVERRIDE_32_old_readdir -SC_LTTNG_TRACEPOINT_EVENT(old_readdir, - TP_PROTO(sc_exit(long ret,) unsigned int fd, struct old_linux_dirent * dirent, unsigned int count), - TP_ARGS(sc_exit(ret,) fd, dirent, count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, fd, fd)) sc_inout(ctf_integer(struct old_linux_dirent *, dirent, dirent)) sc_inout(ctf_integer(unsigned int, count, count))) -) -#endif -#ifndef OVERRIDE_32_syslog -SC_LTTNG_TRACEPOINT_EVENT(syslog, - TP_PROTO(sc_exit(long ret,) int type, char * buf, int len), - TP_ARGS(sc_exit(ret,) type, buf, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, type, type)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(int, len, len))) -) -#endif -#ifndef OVERRIDE_32_setitimer -SC_LTTNG_TRACEPOINT_EVENT(setitimer, - TP_PROTO(sc_exit(long ret,) int which, struct itimerval * value, struct itimerval * ovalue), - TP_ARGS(sc_exit(ret,) which, value, ovalue), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(struct itimerval *, value, value)) sc_out(ctf_integer(struct itimerval *, ovalue, ovalue))) -) -#endif -#ifndef OVERRIDE_32_sigprocmask -SC_LTTNG_TRACEPOINT_EVENT(sigprocmask, - TP_PROTO(sc_exit(long ret,) int how, old_sigset_t * nset, old_sigset_t * oset), - TP_ARGS(sc_exit(ret,) how, nset, oset), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, how, how)) sc_inout(ctf_integer(old_sigset_t *, nset, nset)) sc_inout(ctf_integer(old_sigset_t *, oset, oset))) -) -#endif -#ifndef OVERRIDE_32_init_module -SC_LTTNG_TRACEPOINT_EVENT(init_module, - TP_PROTO(sc_exit(long ret,) void * umod, unsigned long len, const char * uargs), - TP_ARGS(sc_exit(ret,) umod, len, uargs), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(void *, umod, umod)) sc_in(ctf_integer(unsigned long, len, len)) sc_in(ctf_integer(const char *, uargs, uargs))) -) -#endif -#ifndef OVERRIDE_32_getdents -SC_LTTNG_TRACEPOINT_EVENT(getdents, - TP_PROTO(sc_exit(long ret,) unsigned int fd, struct linux_dirent * dirent, unsigned int count), - TP_ARGS(sc_exit(ret,) fd, dirent, count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct linux_dirent *, dirent, dirent)) sc_in(ctf_integer(unsigned int, count, count))) -) -#endif -#ifndef OVERRIDE_32_readv -SC_LTTNG_TRACEPOINT_EVENT(readv, - TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen), - TP_ARGS(sc_exit(ret,) fd, vec, vlen), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_inout(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen))) -) -#endif -#ifndef OVERRIDE_32_writev -SC_LTTNG_TRACEPOINT_EVENT(writev, - TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen), - TP_ARGS(sc_exit(ret,) fd, vec, vlen), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_inout(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen))) -) -#endif -#ifndef OVERRIDE_32_sched_setscheduler -SC_LTTNG_TRACEPOINT_EVENT(sched_setscheduler, - TP_PROTO(sc_exit(long ret,) pid_t pid, int policy, struct sched_param * param), - TP_ARGS(sc_exit(ret,) pid, policy, param), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, policy, policy)) sc_in(ctf_integer(struct sched_param *, param, param))) -) -#endif -#ifndef OVERRIDE_32_getresuid -SC_LTTNG_TRACEPOINT_EVENT(getresuid, - TP_PROTO(sc_exit(long ret,) uid_t * ruid, uid_t * euid, uid_t * suid), - TP_ARGS(sc_exit(ret,) ruid, euid, suid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(uid_t *, ruid, ruid)) sc_out(ctf_integer(uid_t *, euid, euid)) sc_out(ctf_integer(uid_t *, suid, suid))) -) -#endif -#ifndef OVERRIDE_32_poll -SC_LTTNG_TRACEPOINT_EVENT(poll, - TP_PROTO(sc_exit(long ret,) struct pollfd * ufds, unsigned int nfds, long timeout_msecs), - TP_ARGS(sc_exit(ret,) ufds, nfds, timeout_msecs), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct pollfd *, ufds, ufds)) sc_in(ctf_integer(unsigned int, nfds, nfds)) sc_in(ctf_integer(long, timeout_msecs, timeout_msecs))) -) -#endif -#ifndef OVERRIDE_32_nfsservctl -SC_LTTNG_TRACEPOINT_EVENT(nfsservctl, - TP_PROTO(sc_exit(long ret,) int cmd, struct nfsctl_arg * arg, void * res), - TP_ARGS(sc_exit(ret,) cmd, arg, res), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, cmd, cmd)) sc_inout(ctf_integer(struct nfsctl_arg *, arg, arg)) sc_inout(ctf_integer(void *, res, res))) -) -#endif -#ifndef OVERRIDE_32_getresgid -SC_LTTNG_TRACEPOINT_EVENT(getresgid, - TP_PROTO(sc_exit(long ret,) gid_t * rgid, gid_t * egid, gid_t * sgid), - TP_ARGS(sc_exit(ret,) rgid, egid, sgid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(gid_t *, rgid, rgid)) sc_out(ctf_integer(gid_t *, egid, egid)) sc_out(ctf_integer(gid_t *, sgid, sgid))) -) -#endif -#ifndef OVERRIDE_32_rt_sigqueueinfo -SC_LTTNG_TRACEPOINT_EVENT(rt_sigqueueinfo, - TP_PROTO(sc_exit(long ret,) pid_t pid, int sig, siginfo_t * uinfo), - TP_ARGS(sc_exit(ret,) pid, sig, uinfo), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig)) sc_in(ctf_integer(siginfo_t *, uinfo, uinfo))) -) -#endif -#ifndef OVERRIDE_32_chown -SC_LTTNG_TRACEPOINT_EVENT(chown, - TP_PROTO(sc_exit(long ret,) const char * filename, uid_t user, gid_t group), - TP_ARGS(sc_exit(ret,) filename, user, group), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group))) -) -#endif -#ifndef OVERRIDE_32_getdents64 -SC_LTTNG_TRACEPOINT_EVENT(getdents64, - TP_PROTO(sc_exit(long ret,) unsigned int fd, struct linux_dirent64 * dirent, unsigned int count), - TP_ARGS(sc_exit(ret,) fd, dirent, count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct linux_dirent64 *, dirent, dirent)) sc_in(ctf_integer(unsigned int, count, count))) -) -#endif -#ifndef OVERRIDE_32_mincore -SC_LTTNG_TRACEPOINT_EVENT(mincore, - TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len, unsigned char * vec), - TP_ARGS(sc_exit(ret,) start, len, vec), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len)) sc_out(ctf_integer(unsigned char *, vec, vec))) -) -#endif -#ifndef OVERRIDE_32_listxattr -SC_LTTNG_TRACEPOINT_EVENT(listxattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, char * list, size_t size), - TP_ARGS(sc_exit(ret,) pathname, list, size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(char *, list, list)) sc_in(ctf_integer(size_t, size, size))) -) -#endif -#ifndef OVERRIDE_32_llistxattr -SC_LTTNG_TRACEPOINT_EVENT(llistxattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, char * list, size_t size), - TP_ARGS(sc_exit(ret,) pathname, list, size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(char *, list, list)) sc_in(ctf_integer(size_t, size, size))) -) -#endif -#ifndef OVERRIDE_32_flistxattr -SC_LTTNG_TRACEPOINT_EVENT(flistxattr, - TP_PROTO(sc_exit(long ret,) int fd, char * list, size_t size), - TP_ARGS(sc_exit(ret,) fd, list, size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(char *, list, list)) sc_in(ctf_integer(size_t, size, size))) -) -#endif -#ifndef OVERRIDE_32_sched_setaffinity -SC_LTTNG_TRACEPOINT_EVENT(sched_setaffinity, - TP_PROTO(sc_exit(long ret,) pid_t pid, unsigned int len, unsigned long * user_mask_ptr), - TP_ARGS(sc_exit(ret,) pid, len, user_mask_ptr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(unsigned int, len, len)) sc_in(ctf_integer(unsigned long *, user_mask_ptr, user_mask_ptr))) -) -#endif -#ifndef OVERRIDE_32_sched_getaffinity -SC_LTTNG_TRACEPOINT_EVENT(sched_getaffinity, - TP_PROTO(sc_exit(long ret,) pid_t pid, unsigned int len, unsigned long * user_mask_ptr), - TP_ARGS(sc_exit(ret,) pid, len, user_mask_ptr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(unsigned int, len, len)) sc_out(ctf_integer(unsigned long *, user_mask_ptr, user_mask_ptr))) -) -#endif -#ifndef OVERRIDE_32_io_submit -SC_LTTNG_TRACEPOINT_EVENT(io_submit, - TP_PROTO(sc_exit(long ret,) aio_context_t ctx_id, long nr, struct iocb * * iocbpp), - TP_ARGS(sc_exit(ret,) ctx_id, nr, iocbpp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx_id, ctx_id)) sc_in(ctf_integer(long, nr, nr)) sc_in(ctf_integer(struct iocb * *, iocbpp, iocbpp))) -) -#endif -#ifndef OVERRIDE_32_io_cancel -SC_LTTNG_TRACEPOINT_EVENT(io_cancel, - TP_PROTO(sc_exit(long ret,) aio_context_t ctx_id, struct iocb * iocb, struct io_event * result), - TP_ARGS(sc_exit(ret,) ctx_id, iocb, result), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx_id, ctx_id)) sc_in(ctf_integer(struct iocb *, iocb, iocb)) sc_out(ctf_integer(struct io_event *, result, result))) -) -#endif -#ifndef OVERRIDE_32_timer_create -SC_LTTNG_TRACEPOINT_EVENT(timer_create, - TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct sigevent * timer_event_spec, timer_t * created_timer_id), - TP_ARGS(sc_exit(ret,) which_clock, timer_event_spec, created_timer_id), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_in(ctf_integer(struct sigevent *, timer_event_spec, timer_event_spec)) sc_out(ctf_integer(timer_t *, created_timer_id, created_timer_id))) -) -#endif -#ifndef OVERRIDE_32_statfs64 -SC_LTTNG_TRACEPOINT_EVENT(statfs64, - TP_PROTO(sc_exit(long ret,) const char * pathname, size_t sz, struct statfs64 * buf), - TP_ARGS(sc_exit(ret,) pathname, sz, buf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(pathname, pathname)) sc_inout(ctf_integer(size_t, sz, sz)) sc_inout(ctf_integer(struct statfs64 *, buf, buf))) -) -#endif -#ifndef OVERRIDE_32_fstatfs64 -SC_LTTNG_TRACEPOINT_EVENT(fstatfs64, - TP_PROTO(sc_exit(long ret,) unsigned int fd, size_t sz, struct statfs64 * buf), - TP_ARGS(sc_exit(ret,) fd, sz, buf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, fd, fd)) sc_inout(ctf_integer(size_t, sz, sz)) sc_inout(ctf_integer(struct statfs64 *, buf, buf))) -) -#endif -#ifndef OVERRIDE_32_mq_getsetattr -SC_LTTNG_TRACEPOINT_EVENT(mq_getsetattr, - TP_PROTO(sc_exit(long ret,) mqd_t mqdes, const struct mq_attr * u_mqstat, struct mq_attr * u_omqstat), - TP_ARGS(sc_exit(ret,) mqdes, u_mqstat, u_omqstat), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(mqd_t, mqdes, mqdes)) sc_in(ctf_integer(const struct mq_attr *, u_mqstat, u_mqstat)) sc_out(ctf_integer(struct mq_attr *, u_omqstat, u_omqstat))) -) -#endif -#ifndef OVERRIDE_32_inotify_add_watch -SC_LTTNG_TRACEPOINT_EVENT(inotify_add_watch, - TP_PROTO(sc_exit(long ret,) int fd, const char * pathname, u32 mask), - TP_ARGS(sc_exit(ret,) fd, pathname, mask), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(u32, mask, mask))) -) -#endif -#ifndef OVERRIDE_32_mkdirat -SC_LTTNG_TRACEPOINT_EVENT(mkdirat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * pathname, int mode), - TP_ARGS(sc_exit(ret,) dfd, pathname, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(int, mode, mode))) -) -#endif -#ifndef OVERRIDE_32_futimesat -SC_LTTNG_TRACEPOINT_EVENT(futimesat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, struct timeval * utimes), - TP_ARGS(sc_exit(ret,) dfd, filename, utimes), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(struct timeval *, utimes, utimes))) -) -#endif -#ifndef OVERRIDE_32_unlinkat -SC_LTTNG_TRACEPOINT_EVENT(unlinkat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * pathname, int flag), - TP_ARGS(sc_exit(ret,) dfd, pathname, flag), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(int, flag, flag))) -) -#endif -#ifndef OVERRIDE_32_symlinkat -SC_LTTNG_TRACEPOINT_EVENT(symlinkat, - TP_PROTO(sc_exit(long ret,) const char * oldname, int newdfd, const char * newname), - TP_ARGS(sc_exit(ret,) oldname, newdfd, newname), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_integer(int, newdfd, newdfd)) sc_in(ctf_user_string(newname, newname))) -) -#endif -#ifndef OVERRIDE_32_fchmodat -SC_LTTNG_TRACEPOINT_EVENT(fchmodat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, mode_t mode), - TP_ARGS(sc_exit(ret,) dfd, filename, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(mode_t, mode, mode))) -) -#endif -#ifndef OVERRIDE_32_faccessat -SC_LTTNG_TRACEPOINT_EVENT(faccessat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, int mode), - TP_ARGS(sc_exit(ret,) dfd, filename, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, mode, mode))) -) -#endif -#ifndef OVERRIDE_32_get_robust_list -SC_LTTNG_TRACEPOINT_EVENT(get_robust_list, - TP_PROTO(sc_exit(long ret,) int pid, struct robust_list_head * * head_ptr, size_t * len_ptr), - TP_ARGS(sc_exit(ret,) pid, head_ptr, len_ptr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, pid, pid)) sc_out(ctf_integer(struct robust_list_head * *, head_ptr, head_ptr)) sc_out(ctf_integer(size_t *, len_ptr, len_ptr))) -) -#endif -#ifndef OVERRIDE_32_getcpu -SC_LTTNG_TRACEPOINT_EVENT(getcpu, - TP_PROTO(sc_exit(long ret,) unsigned * cpup, unsigned * nodep, struct getcpu_cache * unused), - TP_ARGS(sc_exit(ret,) cpup, nodep, unused), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(unsigned *, cpup, cpup)) sc_out(ctf_integer(unsigned *, nodep, nodep)) sc_inout(ctf_integer(struct getcpu_cache *, unused, unused))) -) -#endif -#ifndef OVERRIDE_32_signalfd -SC_LTTNG_TRACEPOINT_EVENT(signalfd, - TP_PROTO(sc_exit(long ret,) int ufd, sigset_t * user_mask, size_t sizemask), - TP_ARGS(sc_exit(ret,) ufd, user_mask, sizemask), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_in(ctf_integer(sigset_t *, user_mask, user_mask)) sc_in(ctf_integer(size_t, sizemask, sizemask))) -) -#endif -#ifndef OVERRIDE_32_bind -SC_LTTNG_TRACEPOINT_EVENT(bind, - TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * umyaddr, int addrlen), - TP_ARGS(sc_exit(ret,) fd, umyaddr, addrlen), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct sockaddr *, umyaddr, umyaddr)) sc_in(ctf_integer(int, addrlen, addrlen))) -) -#endif -#ifndef OVERRIDE_32_connect -SC_LTTNG_TRACEPOINT_EVENT(connect, - TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * uservaddr, int addrlen), - TP_ARGS(sc_exit(ret,) fd, uservaddr, addrlen), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct sockaddr *, uservaddr, uservaddr)) sc_in(ctf_integer(int, addrlen, addrlen))) -) -#endif -#ifndef OVERRIDE_32_accept -SC_LTTNG_TRACEPOINT_EVENT(accept, - TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * upeer_sockaddr, int * upeer_addrlen), - TP_ARGS(sc_exit(ret,) fd, upeer_sockaddr, upeer_addrlen), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct sockaddr *, upeer_sockaddr, upeer_sockaddr)) sc_inout(ctf_integer(int *, upeer_addrlen, upeer_addrlen))) -) -#endif -#ifndef OVERRIDE_32_getsockname -SC_LTTNG_TRACEPOINT_EVENT(getsockname, - TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * usockaddr, int * usockaddr_len), - TP_ARGS(sc_exit(ret,) fd, usockaddr, usockaddr_len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct sockaddr *, usockaddr, usockaddr)) sc_inout(ctf_integer(int *, usockaddr_len, usockaddr_len))) -) -#endif -#ifndef OVERRIDE_32_getpeername -SC_LTTNG_TRACEPOINT_EVENT(getpeername, - TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * usockaddr, int * usockaddr_len), - TP_ARGS(sc_exit(ret,) fd, usockaddr, usockaddr_len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct sockaddr *, usockaddr, usockaddr)) sc_inout(ctf_integer(int *, usockaddr_len, usockaddr_len))) -) -#endif -#ifndef OVERRIDE_32_sendmsg -SC_LTTNG_TRACEPOINT_EVENT(sendmsg, - TP_PROTO(sc_exit(long ret,) int fd, struct msghdr * msg, unsigned flags), - TP_ARGS(sc_exit(ret,) fd, msg, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct msghdr *, msg, msg)) sc_in(ctf_integer(unsigned, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_recvmsg -SC_LTTNG_TRACEPOINT_EVENT(recvmsg, - TP_PROTO(sc_exit(long ret,) int fd, struct msghdr * msg, unsigned int flags), - TP_ARGS(sc_exit(ret,) fd, msg, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_inout(ctf_integer(struct msghdr *, msg, msg)) sc_in(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_reboot -SC_LTTNG_TRACEPOINT_EVENT(reboot, - TP_PROTO(sc_exit(long ret,) int magic1, int magic2, unsigned int cmd, void * arg), - TP_ARGS(sc_exit(ret,) magic1, magic2, cmd, arg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, magic1, magic1)) sc_in(ctf_integer(int, magic2, magic2)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_in(ctf_integer(void *, arg, arg))) -) -#endif -#ifndef OVERRIDE_32_wait4 -SC_LTTNG_TRACEPOINT_EVENT(wait4, - TP_PROTO(sc_exit(long ret,) pid_t upid, int * stat_addr, int options, struct rusage * ru), - TP_ARGS(sc_exit(ret,) upid, stat_addr, options, ru), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, upid, upid)) sc_out(ctf_integer(int *, stat_addr, stat_addr)) sc_in(ctf_integer(int, options, options)) sc_out(ctf_integer(struct rusage *, ru, ru))) -) -#endif -#ifndef OVERRIDE_32_rt_sigaction -SC_LTTNG_TRACEPOINT_EVENT(rt_sigaction, - TP_PROTO(sc_exit(long ret,) int sig, const struct sigaction * act, struct sigaction * oact, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) sig, act, oact, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, sig, sig)) sc_in(ctf_integer(const struct sigaction *, act, act)) sc_out(ctf_integer(struct sigaction *, oact, oact)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) -) -#endif -#ifndef OVERRIDE_32_rt_sigprocmask -SC_LTTNG_TRACEPOINT_EVENT(rt_sigprocmask, - TP_PROTO(sc_exit(long ret,) int how, sigset_t * nset, sigset_t * oset, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) how, nset, oset, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, how, how)) sc_in(ctf_integer(sigset_t *, nset, nset)) sc_out(ctf_integer(sigset_t *, oset, oset)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) -) -#endif -#ifndef OVERRIDE_32_rt_sigtimedwait -SC_LTTNG_TRACEPOINT_EVENT(rt_sigtimedwait, - TP_PROTO(sc_exit(long ret,) const sigset_t * uthese, siginfo_t * uinfo, const struct timespec * uts, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) uthese, uinfo, uts, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(const sigset_t *, uthese, uthese)) sc_out(ctf_integer(siginfo_t *, uinfo, uinfo)) sc_in(ctf_integer(const struct timespec *, uts, uts)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) -) -#endif -#ifndef OVERRIDE_32_sendfile -SC_LTTNG_TRACEPOINT_EVENT(sendfile, - TP_PROTO(sc_exit(long ret,) int out_fd, int in_fd, off_t * offset, size_t count), - TP_ARGS(sc_exit(ret,) out_fd, in_fd, offset, count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, out_fd, out_fd)) sc_inout(ctf_integer(int, in_fd, in_fd)) sc_inout(ctf_integer(off_t *, offset, offset)) sc_inout(ctf_integer(size_t, count, count))) -) -#endif -#ifndef OVERRIDE_32_getxattr -SC_LTTNG_TRACEPOINT_EVENT(getxattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, void * value, size_t size), - TP_ARGS(sc_exit(ret,) pathname, name, value, size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_out(ctf_integer(void *, value, value)) sc_in(ctf_integer(size_t, size, size))) -) -#endif -#ifndef OVERRIDE_32_lgetxattr -SC_LTTNG_TRACEPOINT_EVENT(lgetxattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, void * value, size_t size), - TP_ARGS(sc_exit(ret,) pathname, name, value, size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_out(ctf_integer(void *, value, value)) sc_in(ctf_integer(size_t, size, size))) -) -#endif -#ifndef OVERRIDE_32_fgetxattr -SC_LTTNG_TRACEPOINT_EVENT(fgetxattr, - TP_PROTO(sc_exit(long ret,) int fd, const char * name, void * value, size_t size), - TP_ARGS(sc_exit(ret,) fd, name, value, size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(name, name)) sc_out(ctf_integer(void *, value, value)) sc_in(ctf_integer(size_t, size, size))) -) -#endif -#ifndef OVERRIDE_32_sendfile64 -SC_LTTNG_TRACEPOINT_EVENT(sendfile64, - TP_PROTO(sc_exit(long ret,) int out_fd, int in_fd, loff_t * offset, size_t count), - TP_ARGS(sc_exit(ret,) out_fd, in_fd, offset, count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, out_fd, out_fd)) sc_in(ctf_integer(int, in_fd, in_fd)) sc_inout(ctf_integer(loff_t *, offset, offset)) sc_in(ctf_integer(size_t, count, count))) -) -#endif -#ifndef OVERRIDE_32_epoll_ctl -SC_LTTNG_TRACEPOINT_EVENT(epoll_ctl, - TP_PROTO(sc_exit(long ret,) int epfd, int op, int fd, struct epoll_event * event), - TP_ARGS(sc_exit(ret,) epfd, op, fd, event), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, epfd, epfd)) sc_in(ctf_integer(int, op, op)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct epoll_event *, event, event))) -) -#endif -#ifndef OVERRIDE_32_epoll_wait -SC_LTTNG_TRACEPOINT_EVENT(epoll_wait, - TP_PROTO(sc_exit(long ret,) int epfd, struct epoll_event * events, int maxevents, int timeout), - TP_ARGS(sc_exit(ret,) epfd, events, maxevents, timeout), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, epfd, epfd)) sc_out(ctf_integer(struct epoll_event *, events, events)) sc_in(ctf_integer(int, maxevents, maxevents)) sc_in(ctf_integer(int, timeout, timeout))) -) -#endif -#ifndef OVERRIDE_32_timer_settime -SC_LTTNG_TRACEPOINT_EVENT(timer_settime, - TP_PROTO(sc_exit(long ret,) timer_t timer_id, int flags, const struct itimerspec * new_setting, struct itimerspec * old_setting), - TP_ARGS(sc_exit(ret,) timer_id, flags, new_setting, old_setting), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(const struct itimerspec *, new_setting, new_setting)) sc_out(ctf_integer(struct itimerspec *, old_setting, old_setting))) -) -#endif -#ifndef OVERRIDE_32_clock_nanosleep -SC_LTTNG_TRACEPOINT_EVENT(clock_nanosleep, - TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, int flags, const struct timespec * rqtp, struct timespec * rmtp), - TP_ARGS(sc_exit(ret,) which_clock, flags, rqtp, rmtp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(const struct timespec *, rqtp, rqtp)) sc_out(ctf_integer(struct timespec *, rmtp, rmtp))) -) -#endif -#ifndef OVERRIDE_32_mq_open -SC_LTTNG_TRACEPOINT_EVENT(mq_open, - TP_PROTO(sc_exit(long ret,) const char * u_name, int oflag, mode_t mode, struct mq_attr * u_attr), - TP_ARGS(sc_exit(ret,) u_name, oflag, mode, u_attr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(u_name, u_name)) sc_in(ctf_integer(int, oflag, oflag)) sc_in(ctf_integer(mode_t, mode, mode)) sc_in(ctf_integer(struct mq_attr *, u_attr, u_attr))) -) -#endif -#ifndef OVERRIDE_32_request_key -SC_LTTNG_TRACEPOINT_EVENT(request_key, - TP_PROTO(sc_exit(long ret,) const char * _type, const char * _description, const char * _callout_info, key_serial_t destringid), - TP_ARGS(sc_exit(ret,) _type, _description, _callout_info, destringid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(_type, _type)) sc_in(ctf_integer(const char *, _description, _description)) sc_in(ctf_integer(const char *, _callout_info, _callout_info)) sc_in(ctf_integer(key_serial_t, destringid, destringid))) -) -#endif -#ifndef OVERRIDE_32_vmsplice -SC_LTTNG_TRACEPOINT_EVENT(vmsplice, - TP_PROTO(sc_exit(long ret,) int fd, const struct iovec * iov, unsigned long nr_segs, unsigned int flags), - TP_ARGS(sc_exit(ret,) fd, iov, nr_segs, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(const struct iovec *, iov, iov)) sc_in(ctf_integer(unsigned long, nr_segs, nr_segs)) sc_in(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_openat -SC_LTTNG_TRACEPOINT_EVENT(openat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, int flags, int mode), - TP_ARGS(sc_exit(ret,) dfd, filename, flags, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(int, mode, mode))) -) -#endif -#ifndef OVERRIDE_32_mknodat -SC_LTTNG_TRACEPOINT_EVENT(mknodat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, int mode, unsigned dev), - TP_ARGS(sc_exit(ret,) dfd, filename, mode, dev), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, mode, mode)) sc_in(ctf_integer(unsigned, dev, dev))) -) -#endif -#ifndef OVERRIDE_32_fstatat64 -SC_LTTNG_TRACEPOINT_EVENT(fstatat64, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, struct stat64 * statbuf, int flag), - TP_ARGS(sc_exit(ret,) dfd, filename, statbuf, flag), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, dfd, dfd)) sc_inout(ctf_user_string(filename, filename)) sc_inout(ctf_integer(struct stat64 *, statbuf, statbuf)) sc_inout(ctf_integer(int, flag, flag))) -) -#endif -#ifndef OVERRIDE_32_renameat -SC_LTTNG_TRACEPOINT_EVENT(renameat, - TP_PROTO(sc_exit(long ret,) int olddfd, const char * oldname, int newdfd, const char * newname), - TP_ARGS(sc_exit(ret,) olddfd, oldname, newdfd, newname), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, olddfd, olddfd)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_integer(int, newdfd, newdfd)) sc_in(ctf_user_string(newname, newname))) -) -#endif -#ifndef OVERRIDE_32_readlinkat -SC_LTTNG_TRACEPOINT_EVENT(readlinkat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * pathname, char * buf, int bufsiz), - TP_ARGS(sc_exit(ret,) dfd, pathname, buf, bufsiz), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(int, bufsiz, bufsiz))) -) -#endif -#ifndef OVERRIDE_32_utimensat -SC_LTTNG_TRACEPOINT_EVENT(utimensat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, struct timespec * utimes, int flags), - TP_ARGS(sc_exit(ret,) dfd, filename, utimes, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(struct timespec *, utimes, utimes)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_timerfd_settime -SC_LTTNG_TRACEPOINT_EVENT(timerfd_settime, - TP_PROTO(sc_exit(long ret,) int ufd, int flags, const struct itimerspec * utmr, struct itimerspec * otmr), - TP_ARGS(sc_exit(ret,) ufd, flags, utmr, otmr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(const struct itimerspec *, utmr, utmr)) sc_out(ctf_integer(struct itimerspec *, otmr, otmr))) -) -#endif -#ifndef OVERRIDE_32_signalfd4 -SC_LTTNG_TRACEPOINT_EVENT(signalfd4, - TP_PROTO(sc_exit(long ret,) int ufd, sigset_t * user_mask, size_t sizemask, int flags), - TP_ARGS(sc_exit(ret,) ufd, user_mask, sizemask, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_in(ctf_integer(sigset_t *, user_mask, user_mask)) sc_in(ctf_integer(size_t, sizemask, sizemask)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_rt_tgsigqueueinfo -SC_LTTNG_TRACEPOINT_EVENT(rt_tgsigqueueinfo, - TP_PROTO(sc_exit(long ret,) pid_t tgid, pid_t pid, int sig, siginfo_t * uinfo), - TP_ARGS(sc_exit(ret,) tgid, pid, sig, uinfo), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, tgid, tgid)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig)) sc_in(ctf_integer(siginfo_t *, uinfo, uinfo))) -) -#endif -#ifndef OVERRIDE_32_prlimit64 -SC_LTTNG_TRACEPOINT_EVENT(prlimit64, - TP_PROTO(sc_exit(long ret,) pid_t pid, unsigned int resource, const struct rlimit64 * new_rlim, struct rlimit64 * old_rlim), - TP_ARGS(sc_exit(ret,) pid, resource, new_rlim, old_rlim), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(unsigned int, resource, resource)) sc_in(ctf_integer(const struct rlimit64 *, new_rlim, new_rlim)) sc_out(ctf_integer(struct rlimit64 *, old_rlim, old_rlim))) -) -#endif -#ifndef OVERRIDE_32_socketpair -SC_LTTNG_TRACEPOINT_EVENT(socketpair, - TP_PROTO(sc_exit(long ret,) int family, int type, int protocol, int * usockvec), - TP_ARGS(sc_exit(ret,) family, type, protocol, usockvec), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, family, family)) sc_in(ctf_integer(int, type, type)) sc_in(ctf_integer(int, protocol, protocol)) sc_out(ctf_integer(int *, usockvec, usockvec))) -) -#endif -#ifndef OVERRIDE_32_send -SC_LTTNG_TRACEPOINT_EVENT(send, - TP_PROTO(sc_exit(long ret,) int fd, void * buff, size_t len, unsigned flags), - TP_ARGS(sc_exit(ret,) fd, buff, len, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, fd, fd)) sc_inout(ctf_integer(void *, buff, buff)) sc_inout(ctf_integer(size_t, len, len)) sc_inout(ctf_integer(unsigned, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_accept4 -SC_LTTNG_TRACEPOINT_EVENT(accept4, - TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * upeer_sockaddr, int * upeer_addrlen, int flags), - TP_ARGS(sc_exit(ret,) fd, upeer_sockaddr, upeer_addrlen, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct sockaddr *, upeer_sockaddr, upeer_sockaddr)) sc_inout(ctf_integer(int *, upeer_addrlen, upeer_addrlen)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_sendmmsg -SC_LTTNG_TRACEPOINT_EVENT(sendmmsg, - TP_PROTO(sc_exit(long ret,) int fd, struct mmsghdr * mmsg, unsigned int vlen, unsigned int flags), - TP_ARGS(sc_exit(ret,) fd, mmsg, vlen, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct mmsghdr *, mmsg, mmsg)) sc_in(ctf_integer(unsigned int, vlen, vlen)) sc_in(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_mount -SC_LTTNG_TRACEPOINT_EVENT(mount, - TP_PROTO(sc_exit(long ret,) char * dev_name, char * dir_name, char * type, unsigned long flags, void * data), - TP_ARGS(sc_exit(ret,) dev_name, dir_name, type, flags, data), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(dev_name, dev_name)) sc_in(ctf_user_string(dir_name, dir_name)) sc_in(ctf_user_string(type, type)) sc_in(ctf_integer(unsigned long, flags, flags)) sc_in(ctf_integer(void *, data, data))) -) -#endif -#ifndef OVERRIDE_32_llseek -SC_LTTNG_TRACEPOINT_EVENT(llseek, - TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned long offset_high, unsigned long offset_low, loff_t * result, unsigned int origin), - TP_ARGS(sc_exit(ret,) fd, offset_high, offset_low, result, origin), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, fd, fd)) sc_inout(ctf_integer(unsigned long, offset_high, offset_high)) sc_inout(ctf_integer(unsigned long, offset_low, offset_low)) sc_inout(ctf_integer(loff_t *, result, result)) sc_inout(ctf_integer(unsigned int, origin, origin))) -) -#endif -#ifndef OVERRIDE_32_select -SC_LTTNG_TRACEPOINT_EVENT(select, - TP_PROTO(sc_exit(long ret,) int n, fd_set * inp, fd_set * outp, fd_set * exp, struct timeval * tvp), - TP_ARGS(sc_exit(ret,) n, inp, outp, exp, tvp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, n, n)) sc_inout(ctf_integer(fd_set *, inp, inp)) sc_inout(ctf_integer(fd_set *, outp, outp)) sc_inout(ctf_integer(fd_set *, exp, exp)) sc_inout(ctf_integer(struct timeval *, tvp, tvp))) -) -#endif -#ifndef OVERRIDE_32_pciconfig_read -SC_LTTNG_TRACEPOINT_EVENT(pciconfig_read, - TP_PROTO(sc_exit(long ret,) unsigned long bus, unsigned long dfn, unsigned long off, unsigned long len, void * buf), - TP_ARGS(sc_exit(ret,) bus, dfn, off, len, buf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned long, bus, bus)) sc_inout(ctf_integer(unsigned long, dfn, dfn)) sc_inout(ctf_integer(unsigned long, off, off)) sc_inout(ctf_integer(unsigned long, len, len)) sc_inout(ctf_integer(void *, buf, buf))) -) -#endif -#ifndef OVERRIDE_32_pciconfig_write -SC_LTTNG_TRACEPOINT_EVENT(pciconfig_write, - TP_PROTO(sc_exit(long ret,) unsigned long bus, unsigned long dfn, unsigned long off, unsigned long len, void * buf), - TP_ARGS(sc_exit(ret,) bus, dfn, off, len, buf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned long, bus, bus)) sc_inout(ctf_integer(unsigned long, dfn, dfn)) sc_inout(ctf_integer(unsigned long, off, off)) sc_inout(ctf_integer(unsigned long, len, len)) sc_inout(ctf_integer(void *, buf, buf))) -) -#endif -#ifndef OVERRIDE_32_setxattr -SC_LTTNG_TRACEPOINT_EVENT(setxattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, const void * value, size_t size, int flags), - TP_ARGS(sc_exit(ret,) pathname, name, value, size, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(const void *, value, value)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_lsetxattr -SC_LTTNG_TRACEPOINT_EVENT(lsetxattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, const void * value, size_t size, int flags), - TP_ARGS(sc_exit(ret,) pathname, name, value, size, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(const void *, value, value)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_fsetxattr -SC_LTTNG_TRACEPOINT_EVENT(fsetxattr, - TP_PROTO(sc_exit(long ret,) int fd, const char * name, const void * value, size_t size, int flags), - TP_ARGS(sc_exit(ret,) fd, name, value, size, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(const void *, value, value)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_io_getevents -SC_LTTNG_TRACEPOINT_EVENT(io_getevents, - TP_PROTO(sc_exit(long ret,) aio_context_t ctx_id, long min_nr, long nr, struct io_event * events, struct timespec * timeout), - TP_ARGS(sc_exit(ret,) ctx_id, min_nr, nr, events, timeout), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx_id, ctx_id)) sc_in(ctf_integer(long, min_nr, min_nr)) sc_in(ctf_integer(long, nr, nr)) sc_out(ctf_integer(struct io_event *, events, events)) sc_inout(ctf_integer(struct timespec *, timeout, timeout))) -) -#endif -#ifndef OVERRIDE_32_mq_timedsend -SC_LTTNG_TRACEPOINT_EVENT(mq_timedsend, - TP_PROTO(sc_exit(long ret,) mqd_t mqdes, const char * u_msg_ptr, size_t msg_len, unsigned int msg_prio, const struct timespec * u_abs_timeout), - TP_ARGS(sc_exit(ret,) mqdes, u_msg_ptr, msg_len, msg_prio, u_abs_timeout), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(mqd_t, mqdes, mqdes)) sc_in(ctf_integer(const char *, u_msg_ptr, u_msg_ptr)) sc_in(ctf_integer(size_t, msg_len, msg_len)) sc_in(ctf_integer(unsigned int, msg_prio, msg_prio)) sc_in(ctf_integer(const struct timespec *, u_abs_timeout, u_abs_timeout))) -) -#endif -#ifndef OVERRIDE_32_mq_timedreceive -SC_LTTNG_TRACEPOINT_EVENT(mq_timedreceive, - TP_PROTO(sc_exit(long ret,) mqd_t mqdes, char * u_msg_ptr, size_t msg_len, unsigned int * u_msg_prio, const struct timespec * u_abs_timeout), - TP_ARGS(sc_exit(ret,) mqdes, u_msg_ptr, msg_len, u_msg_prio, u_abs_timeout), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(mqd_t, mqdes, mqdes)) sc_out(ctf_integer(char *, u_msg_ptr, u_msg_ptr)) sc_in(ctf_integer(size_t, msg_len, msg_len)) sc_out(ctf_integer(unsigned int *, u_msg_prio, u_msg_prio)) sc_in(ctf_integer(const struct timespec *, u_abs_timeout, u_abs_timeout))) -) -#endif -#ifndef OVERRIDE_32_add_key -SC_LTTNG_TRACEPOINT_EVENT(add_key, - TP_PROTO(sc_exit(long ret,) const char * _type, const char * _description, const void * _payload, size_t plen, key_serial_t ringid), - TP_ARGS(sc_exit(ret,) _type, _description, _payload, plen, ringid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(_type, _type)) sc_in(ctf_integer(const char *, _description, _description)) sc_in(ctf_integer(const void *, _payload, _payload)) sc_in(ctf_integer(size_t, plen, plen)) sc_in(ctf_integer(key_serial_t, ringid, ringid))) -) -#endif -#ifndef OVERRIDE_32_waitid -SC_LTTNG_TRACEPOINT_EVENT(waitid, - TP_PROTO(sc_exit(long ret,) int which, pid_t upid, struct siginfo * infop, int options, struct rusage * ru), - TP_ARGS(sc_exit(ret,) which, upid, infop, options, ru), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(pid_t, upid, upid)) sc_out(ctf_integer(struct siginfo *, infop, infop)) sc_in(ctf_integer(int, options, options)) sc_out(ctf_integer(struct rusage *, ru, ru))) -) -#endif -#ifndef OVERRIDE_32_ppoll -SC_LTTNG_TRACEPOINT_EVENT(ppoll, - TP_PROTO(sc_exit(long ret,) struct pollfd * ufds, unsigned int nfds, struct timespec * tsp, const sigset_t * sigmask, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) ufds, nfds, tsp, sigmask, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct pollfd *, ufds, ufds)) sc_in(ctf_integer(unsigned int, nfds, nfds)) sc_in(ctf_integer(struct timespec *, tsp, tsp)) sc_in(ctf_integer(const sigset_t *, sigmask, sigmask)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) -) -#endif -#ifndef OVERRIDE_32_fchownat -SC_LTTNG_TRACEPOINT_EVENT(fchownat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, uid_t user, gid_t group, int flag), - TP_ARGS(sc_exit(ret,) dfd, filename, user, group, flag), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group)) sc_in(ctf_integer(int, flag, flag))) -) -#endif -#ifndef OVERRIDE_32_linkat -SC_LTTNG_TRACEPOINT_EVENT(linkat, - TP_PROTO(sc_exit(long ret,) int olddfd, const char * oldname, int newdfd, const char * newname, int flags), - TP_ARGS(sc_exit(ret,) olddfd, oldname, newdfd, newname, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, olddfd, olddfd)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_integer(int, newdfd, newdfd)) sc_in(ctf_user_string(newname, newname)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_perf_event_open -SC_LTTNG_TRACEPOINT_EVENT(perf_event_open, - TP_PROTO(sc_exit(long ret,) struct perf_event_attr * attr_uptr, pid_t pid, int cpu, int group_fd, unsigned long flags), - TP_ARGS(sc_exit(ret,) attr_uptr, pid, cpu, group_fd, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct perf_event_attr *, attr_uptr, attr_uptr)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, cpu, cpu)) sc_in(ctf_integer(int, group_fd, group_fd)) sc_in(ctf_integer(unsigned long, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_preadv -SC_LTTNG_TRACEPOINT_EVENT(preadv, - TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen, unsigned long pos_l, unsigned long pos_h), - TP_ARGS(sc_exit(ret,) fd, vec, vlen, pos_l, pos_h), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_out(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen)) sc_in(ctf_integer(unsigned long, pos_l, pos_l)) sc_in(ctf_integer(unsigned long, pos_h, pos_h))) -) -#endif -#ifndef OVERRIDE_32_pwritev -SC_LTTNG_TRACEPOINT_EVENT(pwritev, - TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen, unsigned long pos_l, unsigned long pos_h), - TP_ARGS(sc_exit(ret,) fd, vec, vlen, pos_l, pos_h), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_in(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen)) sc_in(ctf_integer(unsigned long, pos_l, pos_l)) sc_in(ctf_integer(unsigned long, pos_h, pos_h))) -) -#endif -#ifndef OVERRIDE_32_setsockopt -SC_LTTNG_TRACEPOINT_EVENT(setsockopt, - TP_PROTO(sc_exit(long ret,) int fd, int level, int optname, char * optval, int optlen), - TP_ARGS(sc_exit(ret,) fd, level, optname, optval, optlen), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, level, level)) sc_in(ctf_integer(int, optname, optname)) sc_in(ctf_integer(char *, optval, optval)) sc_in(ctf_integer(int, optlen, optlen))) -) -#endif -#ifndef OVERRIDE_32_getsockopt -SC_LTTNG_TRACEPOINT_EVENT(getsockopt, - TP_PROTO(sc_exit(long ret,) int fd, int level, int optname, char * optval, int * optlen), - TP_ARGS(sc_exit(ret,) fd, level, optname, optval, optlen), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, level, level)) sc_in(ctf_integer(int, optname, optname)) sc_out(ctf_integer(char *, optval, optval)) sc_inout(ctf_integer(int *, optlen, optlen))) -) -#endif -#ifndef OVERRIDE_32_recvmmsg -SC_LTTNG_TRACEPOINT_EVENT(recvmmsg, - TP_PROTO(sc_exit(long ret,) int fd, struct mmsghdr * mmsg, unsigned int vlen, unsigned int flags, struct timespec * timeout), - TP_ARGS(sc_exit(ret,) fd, mmsg, vlen, flags, timeout), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct mmsghdr *, mmsg, mmsg)) sc_in(ctf_integer(unsigned int, vlen, vlen)) sc_in(ctf_integer(unsigned int, flags, flags)) sc_inout(ctf_integer(struct timespec *, timeout, timeout))) -) -#endif -#ifndef OVERRIDE_32_ipc -SC_LTTNG_TRACEPOINT_EVENT(ipc, - TP_PROTO(sc_exit(long ret,) unsigned int call, int first, unsigned long second, unsigned long third, void * ptr, long fifth), - TP_ARGS(sc_exit(ret,) call, first, second, third, ptr, fifth), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, call, call)) sc_inout(ctf_integer(int, first, first)) sc_inout(ctf_integer(unsigned long, second, second)) sc_inout(ctf_integer(unsigned long, third, third)) sc_inout(ctf_integer(void *, ptr, ptr)) sc_inout(ctf_integer(long, fifth, fifth))) -) -#endif -#ifndef OVERRIDE_32_futex -SC_LTTNG_TRACEPOINT_EVENT(futex, - TP_PROTO(sc_exit(long ret,) u32 * uaddr, int op, u32 val, struct timespec * utime, u32 * uaddr2, u32 val3), - TP_ARGS(sc_exit(ret,) uaddr, op, val, utime, uaddr2, val3), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(u32 *, uaddr, uaddr)) sc_in(ctf_integer(int, op, op)) sc_in(ctf_integer(u32, val, val)) sc_in(ctf_integer(struct timespec *, utime, utime)) sc_inout(ctf_integer(u32 *, uaddr2, uaddr2)) sc_in(ctf_integer(u32, val3, val3))) -) -#endif -#ifndef OVERRIDE_32_pselect6 -SC_LTTNG_TRACEPOINT_EVENT(pselect6, - TP_PROTO(sc_exit(long ret,) int n, fd_set * inp, fd_set * outp, fd_set * exp, struct timespec * tsp, void * sig), - TP_ARGS(sc_exit(ret,) n, inp, outp, exp, tsp, sig), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, n, n)) sc_inout(ctf_integer(fd_set *, inp, inp)) sc_inout(ctf_integer(fd_set *, outp, outp)) sc_inout(ctf_integer(fd_set *, exp, exp)) sc_inout(ctf_integer(struct timespec *, tsp, tsp)) sc_in(ctf_integer(void *, sig, sig))) -) -#endif -#ifndef OVERRIDE_32_splice -SC_LTTNG_TRACEPOINT_EVENT(splice, - TP_PROTO(sc_exit(long ret,) int fd_in, loff_t * off_in, int fd_out, loff_t * off_out, size_t len, unsigned int flags), - TP_ARGS(sc_exit(ret,) fd_in, off_in, fd_out, off_out, len, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd_in, fd_in)) sc_in(ctf_integer(loff_t *, off_in, off_in)) sc_in(ctf_integer(int, fd_out, fd_out)) sc_in(ctf_integer(loff_t *, off_out, off_out)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_epoll_pwait -SC_LTTNG_TRACEPOINT_EVENT(epoll_pwait, - TP_PROTO(sc_exit(long ret,) int epfd, struct epoll_event * events, int maxevents, int timeout, const sigset_t * sigmask, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) epfd, events, maxevents, timeout, sigmask, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, epfd, epfd)) sc_out(ctf_integer(struct epoll_event *, events, events)) sc_in(ctf_integer(int, maxevents, maxevents)) sc_in(ctf_integer(int, timeout, timeout)) sc_in(ctf_integer(const sigset_t *, sigmask, sigmask)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) -) -#endif -#ifndef OVERRIDE_32_sendto -SC_LTTNG_TRACEPOINT_EVENT(sendto, - TP_PROTO(sc_exit(long ret,) int fd, void * buff, size_t len, unsigned flags, struct sockaddr * addr, int addr_len), - TP_ARGS(sc_exit(ret,) fd, buff, len, flags, addr, addr_len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(void *, buff, buff)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned, flags, flags)) sc_in(ctf_integer(struct sockaddr *, addr, addr)) sc_in(ctf_integer(int, addr_len, addr_len))) -) -#endif -#ifndef OVERRIDE_32_recvfrom -SC_LTTNG_TRACEPOINT_EVENT(recvfrom, - TP_PROTO(sc_exit(long ret,) int fd, void * ubuf, size_t size, unsigned flags, struct sockaddr * addr, int * addr_len), - TP_ARGS(sc_exit(ret,) fd, ubuf, size, flags, addr, addr_len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(void *, ubuf, ubuf)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(unsigned, flags, flags)) sc_out(ctf_integer(struct sockaddr *, addr, addr)) sc_inout(ctf_integer(int *, addr_len, addr_len))) -) -#endif - -#endif /* _TRACE_SYSCALLS_POINTERS_H */ - -/* This part must be outside protection */ -#include - -#else /* CREATE_SYSCALL_TABLE */ - -#include "powerpc-32-syscalls_pointers_override.h" -#include "syscalls_pointers_override.h" - -#ifndef OVERRIDE_TABLE_32_read -TRACE_SYSCALL_TABLE(read, read, 3, 3) -#endif -#ifndef OVERRIDE_TABLE_32_write -TRACE_SYSCALL_TABLE(write, write, 4, 3) -#endif -#ifndef OVERRIDE_TABLE_32_open -TRACE_SYSCALL_TABLE(open, open, 5, 3) -#endif -#ifndef OVERRIDE_TABLE_32_waitpid -TRACE_SYSCALL_TABLE(waitpid, waitpid, 7, 3) -#endif -#ifndef OVERRIDE_TABLE_32_creat -TRACE_SYSCALL_TABLE(creat, creat, 8, 2) -#endif -#ifndef OVERRIDE_TABLE_32_link -TRACE_SYSCALL_TABLE(link, link, 9, 2) -#endif -#ifndef OVERRIDE_TABLE_32_unlink -TRACE_SYSCALL_TABLE(unlink, unlink, 10, 1) -#endif -#ifndef OVERRIDE_TABLE_32_chdir -TRACE_SYSCALL_TABLE(chdir, chdir, 12, 1) -#endif -#ifndef OVERRIDE_TABLE_32_time -TRACE_SYSCALL_TABLE(time, time, 13, 1) -#endif -#ifndef OVERRIDE_TABLE_32_mknod -TRACE_SYSCALL_TABLE(mknod, mknod, 14, 3) -#endif -#ifndef OVERRIDE_TABLE_32_chmod -TRACE_SYSCALL_TABLE(chmod, chmod, 15, 2) -#endif -#ifndef OVERRIDE_TABLE_32_lchown -TRACE_SYSCALL_TABLE(lchown, lchown, 16, 3) -#endif -#ifndef OVERRIDE_TABLE_32_stat -TRACE_SYSCALL_TABLE(stat, stat, 18, 2) -#endif -#ifndef OVERRIDE_TABLE_32_mount -TRACE_SYSCALL_TABLE(mount, mount, 21, 5) -#endif -#ifndef OVERRIDE_TABLE_32_oldumount -TRACE_SYSCALL_TABLE(oldumount, oldumount, 22, 1) -#endif -#ifndef OVERRIDE_TABLE_32_stime -TRACE_SYSCALL_TABLE(stime, stime, 25, 1) -#endif -#ifndef OVERRIDE_TABLE_32_fstat -TRACE_SYSCALL_TABLE(fstat, fstat, 28, 2) -#endif -#ifndef OVERRIDE_TABLE_32_utime -TRACE_SYSCALL_TABLE(utime, utime, 30, 2) -#endif -#ifndef OVERRIDE_TABLE_32_access -TRACE_SYSCALL_TABLE(access, access, 33, 2) -#endif -#ifndef OVERRIDE_TABLE_32_rename -TRACE_SYSCALL_TABLE(rename, rename, 38, 2) -#endif -#ifndef OVERRIDE_TABLE_32_mkdir -TRACE_SYSCALL_TABLE(mkdir, mkdir, 39, 2) -#endif -#ifndef OVERRIDE_TABLE_32_rmdir -TRACE_SYSCALL_TABLE(rmdir, rmdir, 40, 1) -#endif -#ifndef OVERRIDE_TABLE_32_pipe -TRACE_SYSCALL_TABLE(pipe, pipe, 42, 1) -#endif -#ifndef OVERRIDE_TABLE_32_times -TRACE_SYSCALL_TABLE(times, times, 43, 1) -#endif -#ifndef OVERRIDE_TABLE_32_acct -TRACE_SYSCALL_TABLE(acct, acct, 51, 1) -#endif -#ifndef OVERRIDE_TABLE_32_umount -TRACE_SYSCALL_TABLE(umount, umount, 52, 2) -#endif -#ifndef OVERRIDE_TABLE_32_olduname -TRACE_SYSCALL_TABLE(olduname, olduname, 59, 1) -#endif -#ifndef OVERRIDE_TABLE_32_chroot -TRACE_SYSCALL_TABLE(chroot, chroot, 61, 1) -#endif -#ifndef OVERRIDE_TABLE_32_ustat -TRACE_SYSCALL_TABLE(ustat, ustat, 62, 2) -#endif -#ifndef OVERRIDE_TABLE_32_sigpending -TRACE_SYSCALL_TABLE(sigpending, sigpending, 73, 1) -#endif -#ifndef OVERRIDE_TABLE_32_sethostname -TRACE_SYSCALL_TABLE(sethostname, sethostname, 74, 2) -#endif -#ifndef OVERRIDE_TABLE_32_setrlimit -TRACE_SYSCALL_TABLE(setrlimit, setrlimit, 75, 2) -#endif -#ifndef OVERRIDE_TABLE_32_old_getrlimit -TRACE_SYSCALL_TABLE(old_getrlimit, old_getrlimit, 76, 2) -#endif -#ifndef OVERRIDE_TABLE_32_getrusage -TRACE_SYSCALL_TABLE(getrusage, getrusage, 77, 2) -#endif -#ifndef OVERRIDE_TABLE_32_gettimeofday -TRACE_SYSCALL_TABLE(gettimeofday, gettimeofday, 78, 2) -#endif -#ifndef OVERRIDE_TABLE_32_settimeofday -TRACE_SYSCALL_TABLE(settimeofday, settimeofday, 79, 2) -#endif -#ifndef OVERRIDE_TABLE_32_getgroups -TRACE_SYSCALL_TABLE(getgroups, getgroups, 80, 2) -#endif -#ifndef OVERRIDE_TABLE_32_setgroups -TRACE_SYSCALL_TABLE(setgroups, setgroups, 81, 2) -#endif -#ifndef OVERRIDE_TABLE_32_symlink -TRACE_SYSCALL_TABLE(symlink, symlink, 83, 2) -#endif -#ifndef OVERRIDE_TABLE_32_lstat -TRACE_SYSCALL_TABLE(lstat, lstat, 84, 2) -#endif -#ifndef OVERRIDE_TABLE_32_readlink -TRACE_SYSCALL_TABLE(readlink, readlink, 85, 3) -#endif -#ifndef OVERRIDE_TABLE_32_uselib -TRACE_SYSCALL_TABLE(uselib, uselib, 86, 1) -#endif -#ifndef OVERRIDE_TABLE_32_swapon -TRACE_SYSCALL_TABLE(swapon, swapon, 87, 2) -#endif -#ifndef OVERRIDE_TABLE_32_reboot -TRACE_SYSCALL_TABLE(reboot, reboot, 88, 4) -#endif -#ifndef OVERRIDE_TABLE_32_old_readdir -TRACE_SYSCALL_TABLE(old_readdir, old_readdir, 89, 3) -#endif -#ifndef OVERRIDE_TABLE_32_truncate -TRACE_SYSCALL_TABLE(truncate, truncate, 92, 2) -#endif -#ifndef OVERRIDE_TABLE_32_statfs -TRACE_SYSCALL_TABLE(statfs, statfs, 99, 2) -#endif -#ifndef OVERRIDE_TABLE_32_fstatfs -TRACE_SYSCALL_TABLE(fstatfs, fstatfs, 100, 2) -#endif -#ifndef OVERRIDE_TABLE_32_socketcall -TRACE_SYSCALL_TABLE(socketcall, socketcall, 102, 2) -#endif -#ifndef OVERRIDE_TABLE_32_syslog -TRACE_SYSCALL_TABLE(syslog, syslog, 103, 3) -#endif -#ifndef OVERRIDE_TABLE_32_setitimer -TRACE_SYSCALL_TABLE(setitimer, setitimer, 104, 3) -#endif -#ifndef OVERRIDE_TABLE_32_getitimer -TRACE_SYSCALL_TABLE(getitimer, getitimer, 105, 2) -#endif -#ifndef OVERRIDE_TABLE_32_newstat -TRACE_SYSCALL_TABLE(newstat, newstat, 106, 2) -#endif -#ifndef OVERRIDE_TABLE_32_newlstat -TRACE_SYSCALL_TABLE(newlstat, newlstat, 107, 2) -#endif -#ifndef OVERRIDE_TABLE_32_newfstat -TRACE_SYSCALL_TABLE(newfstat, newfstat, 108, 2) -#endif -#ifndef OVERRIDE_TABLE_32_uname -TRACE_SYSCALL_TABLE(uname, uname, 109, 1) -#endif -#ifndef OVERRIDE_TABLE_32_wait4 -TRACE_SYSCALL_TABLE(wait4, wait4, 114, 4) -#endif -#ifndef OVERRIDE_TABLE_32_swapoff -TRACE_SYSCALL_TABLE(swapoff, swapoff, 115, 1) -#endif -#ifndef OVERRIDE_TABLE_32_sysinfo -TRACE_SYSCALL_TABLE(sysinfo, sysinfo, 116, 1) -#endif -#ifndef OVERRIDE_TABLE_32_ipc -TRACE_SYSCALL_TABLE(ipc, ipc, 117, 6) -#endif -#ifndef OVERRIDE_TABLE_32_setdomainname -TRACE_SYSCALL_TABLE(setdomainname, setdomainname, 121, 2) -#endif -#ifndef OVERRIDE_TABLE_32_newuname -TRACE_SYSCALL_TABLE(newuname, newuname, 122, 1) -#endif -#ifndef OVERRIDE_TABLE_32_adjtimex -TRACE_SYSCALL_TABLE(adjtimex, adjtimex, 124, 1) -#endif -#ifndef OVERRIDE_TABLE_32_sigprocmask -TRACE_SYSCALL_TABLE(sigprocmask, sigprocmask, 126, 3) -#endif -#ifndef OVERRIDE_TABLE_32_init_module -TRACE_SYSCALL_TABLE(init_module, init_module, 128, 3) -#endif -#ifndef OVERRIDE_TABLE_32_delete_module -TRACE_SYSCALL_TABLE(delete_module, delete_module, 129, 2) -#endif -#ifndef OVERRIDE_TABLE_32_llseek -TRACE_SYSCALL_TABLE(llseek, llseek, 140, 5) -#endif -#ifndef OVERRIDE_TABLE_32_getdents -TRACE_SYSCALL_TABLE(getdents, getdents, 141, 3) -#endif -#ifndef OVERRIDE_TABLE_32_select -TRACE_SYSCALL_TABLE(select, select, 142, 5) -#endif -#ifndef OVERRIDE_TABLE_32_readv -TRACE_SYSCALL_TABLE(readv, readv, 145, 3) -#endif -#ifndef OVERRIDE_TABLE_32_writev -TRACE_SYSCALL_TABLE(writev, writev, 146, 3) -#endif -#ifndef OVERRIDE_TABLE_32_sysctl -TRACE_SYSCALL_TABLE(sysctl, sysctl, 149, 1) -#endif -#ifndef OVERRIDE_TABLE_32_sched_setparam -TRACE_SYSCALL_TABLE(sched_setparam, sched_setparam, 154, 2) -#endif -#ifndef OVERRIDE_TABLE_32_sched_getparam -TRACE_SYSCALL_TABLE(sched_getparam, sched_getparam, 155, 2) -#endif -#ifndef OVERRIDE_TABLE_32_sched_setscheduler -TRACE_SYSCALL_TABLE(sched_setscheduler, sched_setscheduler, 156, 3) -#endif -#ifndef OVERRIDE_TABLE_32_sched_rr_get_interval -TRACE_SYSCALL_TABLE(sched_rr_get_interval, sched_rr_get_interval, 161, 2) -#endif -#ifndef OVERRIDE_TABLE_32_nanosleep -TRACE_SYSCALL_TABLE(nanosleep, nanosleep, 162, 2) -#endif -#ifndef OVERRIDE_TABLE_32_getresuid -TRACE_SYSCALL_TABLE(getresuid, getresuid, 165, 3) -#endif -#ifndef OVERRIDE_TABLE_32_poll -TRACE_SYSCALL_TABLE(poll, poll, 167, 3) -#endif -#ifndef OVERRIDE_TABLE_32_nfsservctl -TRACE_SYSCALL_TABLE(nfsservctl, nfsservctl, 168, 3) -#endif -#ifndef OVERRIDE_TABLE_32_getresgid -TRACE_SYSCALL_TABLE(getresgid, getresgid, 170, 3) -#endif -#ifndef OVERRIDE_TABLE_32_rt_sigaction -TRACE_SYSCALL_TABLE(rt_sigaction, rt_sigaction, 173, 4) -#endif -#ifndef OVERRIDE_TABLE_32_rt_sigprocmask -TRACE_SYSCALL_TABLE(rt_sigprocmask, rt_sigprocmask, 174, 4) -#endif -#ifndef OVERRIDE_TABLE_32_rt_sigpending -TRACE_SYSCALL_TABLE(rt_sigpending, rt_sigpending, 175, 2) -#endif -#ifndef OVERRIDE_TABLE_32_rt_sigtimedwait -TRACE_SYSCALL_TABLE(rt_sigtimedwait, rt_sigtimedwait, 176, 4) -#endif -#ifndef OVERRIDE_TABLE_32_rt_sigqueueinfo -TRACE_SYSCALL_TABLE(rt_sigqueueinfo, rt_sigqueueinfo, 177, 3) -#endif -#ifndef OVERRIDE_TABLE_32_rt_sigsuspend -TRACE_SYSCALL_TABLE(rt_sigsuspend, rt_sigsuspend, 178, 2) -#endif -#ifndef OVERRIDE_TABLE_32_chown -TRACE_SYSCALL_TABLE(chown, chown, 181, 3) -#endif -#ifndef OVERRIDE_TABLE_32_getcwd -TRACE_SYSCALL_TABLE(getcwd, getcwd, 182, 2) -#endif -#ifndef OVERRIDE_TABLE_32_sendfile -TRACE_SYSCALL_TABLE(sendfile, sendfile, 186, 4) -#endif -#ifndef OVERRIDE_TABLE_32_getrlimit -TRACE_SYSCALL_TABLE(getrlimit, getrlimit, 190, 2) -#endif -#ifndef OVERRIDE_TABLE_32_stat64 -TRACE_SYSCALL_TABLE(stat64, stat64, 195, 2) -#endif -#ifndef OVERRIDE_TABLE_32_lstat64 -TRACE_SYSCALL_TABLE(lstat64, lstat64, 196, 2) -#endif -#ifndef OVERRIDE_TABLE_32_fstat64 -TRACE_SYSCALL_TABLE(fstat64, fstat64, 197, 2) -#endif -#ifndef OVERRIDE_TABLE_32_pciconfig_read -TRACE_SYSCALL_TABLE(pciconfig_read, pciconfig_read, 198, 5) -#endif -#ifndef OVERRIDE_TABLE_32_pciconfig_write -TRACE_SYSCALL_TABLE(pciconfig_write, pciconfig_write, 199, 5) -#endif -#ifndef OVERRIDE_TABLE_32_getdents64 -TRACE_SYSCALL_TABLE(getdents64, getdents64, 202, 3) -#endif -#ifndef OVERRIDE_TABLE_32_pivot_root -TRACE_SYSCALL_TABLE(pivot_root, pivot_root, 203, 2) -#endif -#ifndef OVERRIDE_TABLE_32_mincore -TRACE_SYSCALL_TABLE(mincore, mincore, 206, 3) -#endif -#ifndef OVERRIDE_TABLE_32_setxattr -TRACE_SYSCALL_TABLE(setxattr, setxattr, 209, 5) -#endif -#ifndef OVERRIDE_TABLE_32_lsetxattr -TRACE_SYSCALL_TABLE(lsetxattr, lsetxattr, 210, 5) -#endif -#ifndef OVERRIDE_TABLE_32_fsetxattr -TRACE_SYSCALL_TABLE(fsetxattr, fsetxattr, 211, 5) -#endif -#ifndef OVERRIDE_TABLE_32_getxattr -TRACE_SYSCALL_TABLE(getxattr, getxattr, 212, 4) -#endif -#ifndef OVERRIDE_TABLE_32_lgetxattr -TRACE_SYSCALL_TABLE(lgetxattr, lgetxattr, 213, 4) -#endif -#ifndef OVERRIDE_TABLE_32_fgetxattr -TRACE_SYSCALL_TABLE(fgetxattr, fgetxattr, 214, 4) -#endif -#ifndef OVERRIDE_TABLE_32_listxattr -TRACE_SYSCALL_TABLE(listxattr, listxattr, 215, 3) -#endif -#ifndef OVERRIDE_TABLE_32_llistxattr -TRACE_SYSCALL_TABLE(llistxattr, llistxattr, 216, 3) -#endif -#ifndef OVERRIDE_TABLE_32_flistxattr -TRACE_SYSCALL_TABLE(flistxattr, flistxattr, 217, 3) -#endif -#ifndef OVERRIDE_TABLE_32_removexattr -TRACE_SYSCALL_TABLE(removexattr, removexattr, 218, 2) -#endif -#ifndef OVERRIDE_TABLE_32_lremovexattr -TRACE_SYSCALL_TABLE(lremovexattr, lremovexattr, 219, 2) -#endif -#ifndef OVERRIDE_TABLE_32_fremovexattr -TRACE_SYSCALL_TABLE(fremovexattr, fremovexattr, 220, 2) -#endif -#ifndef OVERRIDE_TABLE_32_futex -TRACE_SYSCALL_TABLE(futex, futex, 221, 6) -#endif -#ifndef OVERRIDE_TABLE_32_sched_setaffinity -TRACE_SYSCALL_TABLE(sched_setaffinity, sched_setaffinity, 222, 3) -#endif -#ifndef OVERRIDE_TABLE_32_sched_getaffinity -TRACE_SYSCALL_TABLE(sched_getaffinity, sched_getaffinity, 223, 3) -#endif -#ifndef OVERRIDE_TABLE_32_sendfile64 -TRACE_SYSCALL_TABLE(sendfile64, sendfile64, 226, 4) -#endif -#ifndef OVERRIDE_TABLE_32_io_setup -TRACE_SYSCALL_TABLE(io_setup, io_setup, 227, 2) -#endif -#ifndef OVERRIDE_TABLE_32_io_getevents -TRACE_SYSCALL_TABLE(io_getevents, io_getevents, 229, 5) -#endif -#ifndef OVERRIDE_TABLE_32_io_submit -TRACE_SYSCALL_TABLE(io_submit, io_submit, 230, 3) -#endif -#ifndef OVERRIDE_TABLE_32_io_cancel -TRACE_SYSCALL_TABLE(io_cancel, io_cancel, 231, 3) -#endif -#ifndef OVERRIDE_TABLE_32_set_tid_address -TRACE_SYSCALL_TABLE(set_tid_address, set_tid_address, 232, 1) -#endif -#ifndef OVERRIDE_TABLE_32_epoll_ctl -TRACE_SYSCALL_TABLE(epoll_ctl, epoll_ctl, 237, 4) -#endif -#ifndef OVERRIDE_TABLE_32_epoll_wait -TRACE_SYSCALL_TABLE(epoll_wait, epoll_wait, 238, 4) -#endif -#ifndef OVERRIDE_TABLE_32_timer_create -TRACE_SYSCALL_TABLE(timer_create, timer_create, 240, 3) -#endif -#ifndef OVERRIDE_TABLE_32_timer_settime -TRACE_SYSCALL_TABLE(timer_settime, timer_settime, 241, 4) -#endif -#ifndef OVERRIDE_TABLE_32_timer_gettime -TRACE_SYSCALL_TABLE(timer_gettime, timer_gettime, 242, 2) -#endif -#ifndef OVERRIDE_TABLE_32_clock_settime -TRACE_SYSCALL_TABLE(clock_settime, clock_settime, 245, 2) -#endif -#ifndef OVERRIDE_TABLE_32_clock_gettime -TRACE_SYSCALL_TABLE(clock_gettime, clock_gettime, 246, 2) -#endif -#ifndef OVERRIDE_TABLE_32_clock_getres -TRACE_SYSCALL_TABLE(clock_getres, clock_getres, 247, 2) -#endif -#ifndef OVERRIDE_TABLE_32_clock_nanosleep -TRACE_SYSCALL_TABLE(clock_nanosleep, clock_nanosleep, 248, 4) -#endif -#ifndef OVERRIDE_TABLE_32_utimes -TRACE_SYSCALL_TABLE(utimes, utimes, 251, 2) -#endif -#ifndef OVERRIDE_TABLE_32_statfs64 -TRACE_SYSCALL_TABLE(statfs64, statfs64, 252, 3) -#endif -#ifndef OVERRIDE_TABLE_32_fstatfs64 -TRACE_SYSCALL_TABLE(fstatfs64, fstatfs64, 253, 3) -#endif -#ifndef OVERRIDE_TABLE_32_mq_open -TRACE_SYSCALL_TABLE(mq_open, mq_open, 262, 4) -#endif -#ifndef OVERRIDE_TABLE_32_mq_unlink -TRACE_SYSCALL_TABLE(mq_unlink, mq_unlink, 263, 1) -#endif -#ifndef OVERRIDE_TABLE_32_mq_timedsend -TRACE_SYSCALL_TABLE(mq_timedsend, mq_timedsend, 264, 5) -#endif -#ifndef OVERRIDE_TABLE_32_mq_timedreceive -TRACE_SYSCALL_TABLE(mq_timedreceive, mq_timedreceive, 265, 5) -#endif -#ifndef OVERRIDE_TABLE_32_mq_notify -TRACE_SYSCALL_TABLE(mq_notify, mq_notify, 266, 2) -#endif -#ifndef OVERRIDE_TABLE_32_mq_getsetattr -TRACE_SYSCALL_TABLE(mq_getsetattr, mq_getsetattr, 267, 3) -#endif -#ifndef OVERRIDE_TABLE_32_add_key -TRACE_SYSCALL_TABLE(add_key, add_key, 269, 5) -#endif -#ifndef OVERRIDE_TABLE_32_request_key -TRACE_SYSCALL_TABLE(request_key, request_key, 270, 4) -#endif -#ifndef OVERRIDE_TABLE_32_waitid -TRACE_SYSCALL_TABLE(waitid, waitid, 272, 5) -#endif -#ifndef OVERRIDE_TABLE_32_inotify_add_watch -TRACE_SYSCALL_TABLE(inotify_add_watch, inotify_add_watch, 276, 3) -#endif -#ifndef OVERRIDE_TABLE_32_pselect6 -TRACE_SYSCALL_TABLE(pselect6, pselect6, 280, 6) -#endif -#ifndef OVERRIDE_TABLE_32_ppoll -TRACE_SYSCALL_TABLE(ppoll, ppoll, 281, 5) -#endif -#ifndef OVERRIDE_TABLE_32_splice -TRACE_SYSCALL_TABLE(splice, splice, 283, 6) -#endif -#ifndef OVERRIDE_TABLE_32_vmsplice -TRACE_SYSCALL_TABLE(vmsplice, vmsplice, 285, 4) -#endif -#ifndef OVERRIDE_TABLE_32_openat -TRACE_SYSCALL_TABLE(openat, openat, 286, 4) -#endif -#ifndef OVERRIDE_TABLE_32_mkdirat -TRACE_SYSCALL_TABLE(mkdirat, mkdirat, 287, 3) -#endif -#ifndef OVERRIDE_TABLE_32_mknodat -TRACE_SYSCALL_TABLE(mknodat, mknodat, 288, 4) -#endif -#ifndef OVERRIDE_TABLE_32_fchownat -TRACE_SYSCALL_TABLE(fchownat, fchownat, 289, 5) -#endif -#ifndef OVERRIDE_TABLE_32_futimesat -TRACE_SYSCALL_TABLE(futimesat, futimesat, 290, 3) -#endif -#ifndef OVERRIDE_TABLE_32_fstatat64 -TRACE_SYSCALL_TABLE(fstatat64, fstatat64, 291, 4) -#endif -#ifndef OVERRIDE_TABLE_32_unlinkat -TRACE_SYSCALL_TABLE(unlinkat, unlinkat, 292, 3) -#endif -#ifndef OVERRIDE_TABLE_32_renameat -TRACE_SYSCALL_TABLE(renameat, renameat, 293, 4) -#endif -#ifndef OVERRIDE_TABLE_32_linkat -TRACE_SYSCALL_TABLE(linkat, linkat, 294, 5) -#endif -#ifndef OVERRIDE_TABLE_32_symlinkat -TRACE_SYSCALL_TABLE(symlinkat, symlinkat, 295, 3) -#endif -#ifndef OVERRIDE_TABLE_32_readlinkat -TRACE_SYSCALL_TABLE(readlinkat, readlinkat, 296, 4) -#endif -#ifndef OVERRIDE_TABLE_32_fchmodat -TRACE_SYSCALL_TABLE(fchmodat, fchmodat, 297, 3) -#endif -#ifndef OVERRIDE_TABLE_32_faccessat -TRACE_SYSCALL_TABLE(faccessat, faccessat, 298, 3) -#endif -#ifndef OVERRIDE_TABLE_32_get_robust_list -TRACE_SYSCALL_TABLE(get_robust_list, get_robust_list, 299, 3) -#endif -#ifndef OVERRIDE_TABLE_32_set_robust_list -TRACE_SYSCALL_TABLE(set_robust_list, set_robust_list, 300, 2) -#endif -#ifndef OVERRIDE_TABLE_32_getcpu -TRACE_SYSCALL_TABLE(getcpu, getcpu, 302, 3) -#endif -#ifndef OVERRIDE_TABLE_32_epoll_pwait -TRACE_SYSCALL_TABLE(epoll_pwait, epoll_pwait, 303, 6) -#endif -#ifndef OVERRIDE_TABLE_32_utimensat -TRACE_SYSCALL_TABLE(utimensat, utimensat, 304, 4) -#endif -#ifndef OVERRIDE_TABLE_32_signalfd -TRACE_SYSCALL_TABLE(signalfd, signalfd, 305, 3) -#endif -#ifndef OVERRIDE_TABLE_32_timerfd_settime -TRACE_SYSCALL_TABLE(timerfd_settime, timerfd_settime, 311, 4) -#endif -#ifndef OVERRIDE_TABLE_32_timerfd_gettime -TRACE_SYSCALL_TABLE(timerfd_gettime, timerfd_gettime, 312, 2) -#endif -#ifndef OVERRIDE_TABLE_32_signalfd4 -TRACE_SYSCALL_TABLE(signalfd4, signalfd4, 313, 4) -#endif -#ifndef OVERRIDE_TABLE_32_pipe2 -TRACE_SYSCALL_TABLE(pipe2, pipe2, 317, 2) -#endif -#ifndef OVERRIDE_TABLE_32_perf_event_open -TRACE_SYSCALL_TABLE(perf_event_open, perf_event_open, 319, 5) -#endif -#ifndef OVERRIDE_TABLE_32_preadv -TRACE_SYSCALL_TABLE(preadv, preadv, 320, 5) -#endif -#ifndef OVERRIDE_TABLE_32_pwritev -TRACE_SYSCALL_TABLE(pwritev, pwritev, 321, 5) -#endif -#ifndef OVERRIDE_TABLE_32_rt_tgsigqueueinfo -TRACE_SYSCALL_TABLE(rt_tgsigqueueinfo, rt_tgsigqueueinfo, 322, 4) -#endif -#ifndef OVERRIDE_TABLE_32_prlimit64 -TRACE_SYSCALL_TABLE(prlimit64, prlimit64, 325, 4) -#endif -#ifndef OVERRIDE_TABLE_32_bind -TRACE_SYSCALL_TABLE(bind, bind, 327, 3) -#endif -#ifndef OVERRIDE_TABLE_32_connect -TRACE_SYSCALL_TABLE(connect, connect, 328, 3) -#endif -#ifndef OVERRIDE_TABLE_32_accept -TRACE_SYSCALL_TABLE(accept, accept, 330, 3) -#endif -#ifndef OVERRIDE_TABLE_32_getsockname -TRACE_SYSCALL_TABLE(getsockname, getsockname, 331, 3) -#endif -#ifndef OVERRIDE_TABLE_32_getpeername -TRACE_SYSCALL_TABLE(getpeername, getpeername, 332, 3) -#endif -#ifndef OVERRIDE_TABLE_32_socketpair -TRACE_SYSCALL_TABLE(socketpair, socketpair, 333, 4) -#endif -#ifndef OVERRIDE_TABLE_32_send -TRACE_SYSCALL_TABLE(send, send, 334, 4) -#endif -#ifndef OVERRIDE_TABLE_32_sendto -TRACE_SYSCALL_TABLE(sendto, sendto, 335, 6) -#endif -#ifndef OVERRIDE_TABLE_32_recvfrom -TRACE_SYSCALL_TABLE(recvfrom, recvfrom, 337, 6) -#endif -#ifndef OVERRIDE_TABLE_32_setsockopt -TRACE_SYSCALL_TABLE(setsockopt, setsockopt, 339, 5) -#endif -#ifndef OVERRIDE_TABLE_32_getsockopt -TRACE_SYSCALL_TABLE(getsockopt, getsockopt, 340, 5) -#endif -#ifndef OVERRIDE_TABLE_32_sendmsg -TRACE_SYSCALL_TABLE(sendmsg, sendmsg, 341, 3) -#endif -#ifndef OVERRIDE_TABLE_32_recvmsg -TRACE_SYSCALL_TABLE(recvmsg, recvmsg, 342, 3) -#endif -#ifndef OVERRIDE_TABLE_32_recvmmsg -TRACE_SYSCALL_TABLE(recvmmsg, recvmmsg, 343, 5) -#endif -#ifndef OVERRIDE_TABLE_32_accept4 -TRACE_SYSCALL_TABLE(accept4, accept4, 344, 4) -#endif -#ifndef OVERRIDE_TABLE_32_clock_adjtime -TRACE_SYSCALL_TABLE(clock_adjtime, clock_adjtime, 347, 2) -#endif -#ifndef OVERRIDE_TABLE_32_sendmmsg -TRACE_SYSCALL_TABLE(sendmmsg, sendmmsg, 349, 4) -#endif - -#endif /* CREATE_SYSCALL_TABLE */ diff --git a/instrumentation/syscalls/headers/powerpc-32-syscalls_pointers_override.h b/instrumentation/syscalls/headers/powerpc-32-syscalls_pointers_override.h deleted file mode 100644 index fde30d27..00000000 --- a/instrumentation/syscalls/headers/powerpc-32-syscalls_pointers_override.h +++ /dev/null @@ -1,24 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ - -#define OVERRIDE_TABLE_32_mmap2 - -#ifndef CREATE_SYSCALL_TABLE - -#define OVERRIDE_32_pipe -SC_LTTNG_TRACEPOINT_EVENT(pipe, - TP_PROTO(sc_exit(long ret,) int * fildes), - TP_ARGS(sc_exit(ret,) fildes), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) - sc_out(ctf_user_array(int, fildes, fildes, 2)) - ) -) - -#else /* CREATE_SYSCALL_TABLE */ - -#define OVERRIDE_TABLE_32_execve -TRACE_SYSCALL_TABLE(execve, execve, 11, 3) -#define OVERRIDE_TABLE_32_clone -TRACE_SYSCALL_TABLE(clone, clone, 120, 5) - -#endif /* CREATE_SYSCALL_TABLE */ - diff --git a/instrumentation/syscalls/headers/syscalls_integers.h b/instrumentation/syscalls/headers/syscalls_integers.h deleted file mode 100644 index ea8e29bc..00000000 --- a/instrumentation/syscalls/headers/syscalls_integers.h +++ /dev/null @@ -1,25 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ - -#ifdef CONFIG_X86_64 -#include "x86-64-syscalls_integers.h" -#endif - -#ifdef CONFIG_X86_32 -#include "x86-32-syscalls_integers.h" -#endif - -#ifdef CONFIG_ARM -#include "arm-32-syscalls_integers.h" -#endif - -#ifdef CONFIG_PPC -#include "powerpc-32-syscalls_integers.h" -#endif - -#ifdef CONFIG_CPU_MIPS32 -#include "mips-32-syscalls_integers.h" -#endif - -#ifdef CONFIG_ARM64 -#include "arm-64-syscalls_integers.h" -#endif diff --git a/instrumentation/syscalls/headers/syscalls_integers_override.h b/instrumentation/syscalls/headers/syscalls_integers_override.h deleted file mode 100644 index 2866fdce..00000000 --- a/instrumentation/syscalls/headers/syscalls_integers_override.h +++ /dev/null @@ -1,78 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ - -#ifndef CREATE_SYSCALL_TABLE - -#define OVERRIDE_32_mmap -#define OVERRIDE_64_mmap -SC_LTTNG_TRACEPOINT_EVENT(mmap, - TP_PROTO(sc_exit(unsigned long ret,) - unsigned long addr, unsigned long len, - unsigned long prot, unsigned long flags, - unsigned long fd, unsigned long off), - TP_ARGS(sc_exit(ret,) addr, len, prot, flags, fd, off), - TP_FIELDS(sc_exit(ctf_integer_hex(unsigned long, ret, ret)) - sc_in(ctf_integer_hex(unsigned long, addr, addr)) - sc_in(ctf_integer(size_t, len, len)) - sc_in(ctf_integer(int, prot, prot)) - sc_in(ctf_integer(int, flags, flags)) - sc_in(ctf_integer(int, fd, fd)) - sc_in(ctf_integer(off_t, offset, off)) - ) -) - -/* - * Enumeration of the open flags, as described in the 'open' - * system call man page. - */ -SC_LTTNG_TRACEPOINT_ENUM(lttng_fcntl_cmd_flags, - TP_ENUM_VALUES( - ctf_enum_value("F_DUPFD", F_DUPFD) - ctf_enum_value("F_GETFD", F_GETFD) - ctf_enum_value("F_SETFD", F_SETFD) - ctf_enum_value("F_GETFL", F_GETFL) - ctf_enum_value("F_SETFL", F_SETFL) - ctf_enum_value("F_GETLK", F_GETLK) - ctf_enum_value("F_SETLK", F_SETLK) - ctf_enum_value("F_SETLKW", F_SETLKW) - ctf_enum_value("F_SETOWN", F_SETOWN) - ctf_enum_value("F_GETOWN", F_GETOWN) - ctf_enum_value("F_SETSIG", F_SETSIG) - ctf_enum_value("F_GETSIG", F_GETSIG) - ctf_enum_value("F_GETLK64", F_GETLK64) - ctf_enum_value("F_SETLK64", F_SETLK64) - ctf_enum_value("F_SETLKW64", F_SETLKW64) - ctf_enum_value("F_SETOWN_EX", F_SETOWN_EX) - ctf_enum_value("F_GETOWN_EX", F_GETOWN_EX) - ctf_enum_value("F_GETOWNER_UIDS", F_GETOWNER_UIDS) - ctf_enum_value("F_OFD_GETLK", F_OFD_GETLK) - ctf_enum_value("F_OFD_SETLK", F_OFD_SETLK) - ctf_enum_value("F_OFD_SETLKW", F_OFD_SETLKW) - ctf_enum_value("F_SETLEASE", F_SETLEASE) - ctf_enum_value("F_GETLEASE", F_GETLEASE) - ctf_enum_value("F_NOTIFY", F_NOTIFY) - ctf_enum_value("F_CANCELLK", F_CANCELLK) - ctf_enum_value("F_DUPFD_CLOEXEC", F_DUPFD_CLOEXEC) - ctf_enum_value("F_SETPIPE_SZ", F_SETPIPE_SZ) - ctf_enum_value("F_GETPIPE_SZ", F_GETPIPE_SZ) - ctf_enum_value("F_ADD_SEALS", F_ADD_SEALS) - ctf_enum_value("F_GET_SEALS", F_GET_SEALS) - ctf_enum_value("F_GET_RW_HINT", F_GET_RW_HINT) - ctf_enum_value("F_SET_RW_HINT", F_SET_RW_HINT) - ctf_enum_value("F_GET_FILE_RW_HINT", F_GET_FILE_RW_HINT) - ctf_enum_value("F_SET_FILE_RW_HINT", F_SET_FILE_RW_HINT) - ) -) - -#define OVERRIDE_32_fcntl -#define OVERRIDE_64_fcntl -SC_LTTNG_TRACEPOINT_EVENT(fcntl, - TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd, unsigned long arg), - TP_ARGS(sc_exit(ret,) fd, cmd, arg), - TP_FIELDS( - sc_exit(ctf_integer(long, ret, ret)) - sc_in(ctf_integer(unsigned int, fd, fd)) - sc_in(ctf_enum(lttng_fcntl_cmd_flags, unsigned int, cmd, cmd)) - sc_inout(ctf_integer(unsigned long, arg, arg))) -) - -#endif /* CREATE_SYSCALL_TABLE */ diff --git a/instrumentation/syscalls/headers/syscalls_pointers.h b/instrumentation/syscalls/headers/syscalls_pointers.h deleted file mode 100644 index a2ee3127..00000000 --- a/instrumentation/syscalls/headers/syscalls_pointers.h +++ /dev/null @@ -1,25 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ - -#ifdef CONFIG_X86_64 -#include "x86-64-syscalls_pointers.h" -#endif - -#ifdef CONFIG_X86_32 -#include "x86-32-syscalls_pointers.h" -#endif - -#ifdef CONFIG_ARM -#include "arm-32-syscalls_pointers.h" -#endif - -#ifdef CONFIG_PPC -#include "powerpc-32-syscalls_pointers.h" -#endif - -#ifdef CONFIG_CPU_MIPS32 -#include "mips-32-syscalls_pointers.h" -#endif - -#ifdef CONFIG_ARM64 -#include "arm-64-syscalls_pointers.h" -#endif diff --git a/instrumentation/syscalls/headers/syscalls_pointers_override.h b/instrumentation/syscalls/headers/syscalls_pointers_override.h deleted file mode 100644 index 341e93b6..00000000 --- a/instrumentation/syscalls/headers/syscalls_pointers_override.h +++ /dev/null @@ -1,1004 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ - -#ifndef CREATE_SYSCALL_TABLE - -#define OVERRIDE_32_execve -#define OVERRIDE_64_execve -SC_LTTNG_TRACEPOINT_EVENT(execve, - TP_PROTO(sc_exit(long ret,) const char *filename, char *const *argv, char *const *envp), - TP_ARGS(sc_exit(ret,) filename, argv, envp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) - sc_in(ctf_user_string(filename, filename)) - sc_in(ctf_integer_hex(char *const *, argv, argv)) - sc_in(ctf_integer_hex(char *const *, envp, envp)) - ) -) - -#define OVERRIDE_32_clone -#define OVERRIDE_64_clone -SC_LTTNG_TRACEPOINT_EVENT(clone, - TP_PROTO(sc_exit(long ret,) unsigned long clone_flags, unsigned long newsp, - void __user *parent_tid, - void __user *child_tid), - TP_ARGS(sc_exit(ret,) clone_flags, newsp, parent_tid, child_tid), - TP_FIELDS( - sc_exit(ctf_integer(long, ret, ret)) - sc_in(ctf_integer_hex(unsigned long, clone_flags, clone_flags)) - sc_in(ctf_integer_hex(unsigned long, newsp, newsp)) - sc_in(ctf_integer_hex(void *, parent_tid, parent_tid)) - sc_in(ctf_integer_hex(void *, child_tid, child_tid)) - ) -) - -/* present in 32, missing in 64 due to old kernel headers */ -#define OVERRIDE_32_getcpu -#define OVERRIDE_64_getcpu -SC_LTTNG_TRACEPOINT_EVENT(getcpu, - TP_PROTO(sc_exit(long ret,) unsigned __user *cpup, unsigned __user *nodep, void *tcache), - TP_ARGS(sc_exit(ret,) cpup, nodep, tcache), - TP_FIELDS( - sc_exit(ctf_integer(long, ret, ret)) - sc_out(ctf_integer_hex(unsigned *, cpup, cpup)) - sc_out(ctf_integer_hex(unsigned *, nodep, nodep)) - sc_inout(ctf_integer_hex(void *, tcache, tcache)) - ) -) - -#define OVERRIDE_32_pipe2 -#define OVERRIDE_64_pipe2 -SC_LTTNG_TRACEPOINT_EVENT(pipe2, - TP_PROTO(sc_exit(long ret,) int * fildes, int flags), - TP_ARGS(sc_exit(ret,) fildes, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) - sc_out(ctf_user_array(int, fildes, fildes, 2)) - sc_in(ctf_integer(int, flags, flags)) - ) -) - -#define LTTNG_SYSCALL_SELECT_locvar \ - unsigned long *fds_in, *fds_out, *fds_ex; \ - unsigned long nr_bytes, nr_ulong; \ - uint8_t overflow; - -#define LTTNG_SYSCALL_SELECT_code_pre \ - sc_inout( \ - { \ - int err; \ - unsigned int n_in_bytes; \ - \ - tp_locvar->fds_in = NULL; \ - tp_locvar->fds_out = NULL; \ - tp_locvar->fds_ex = NULL; \ - tp_locvar->overflow = 0; \ - \ - sc_out( \ - if (ret <= 0) \ - goto error; \ - ) \ - \ - if (n <= 0) \ - goto error; \ - \ - /* On error or bogus input, don't copy anything. */ \ - if (n >__FD_SETSIZE) \ - goto error; \ - \ - n_in_bytes = DIV_ROUND_UP((unsigned int) n, BITS_PER_BYTE); \ - \ - /* \ - * Limit atomic memory allocation to one page, since n \ - * is limited to 1024 and the smallest page size on Linux \ - * is 4k, this should not happen, don't try to make it work. \ - */ \ - if (n_in_bytes > PAGE_SIZE) { \ - WARN_ON_ONCE(1); \ - /* Inform the user that we did not output everything. */ \ - tp_locvar->overflow = 1; \ - goto error; \ - } else { \ - tp_locvar->nr_bytes = n_in_bytes; \ - tp_locvar->nr_ulong = DIV_ROUND_UP(n_in_bytes, \ - sizeof(unsigned long)); \ - } \ - \ - if (inp) { \ - tp_locvar->fds_in = lttng_tp_mempool_alloc( \ - tp_locvar->nr_ulong * sizeof(unsigned long)); \ - if (!tp_locvar->fds_in) \ - goto error; \ - \ - err = lib_ring_buffer_copy_from_user_check_nofault( \ - tp_locvar->fds_in, inp, \ - tp_locvar->nr_ulong * sizeof(unsigned long)); \ - if (err != 0) \ - goto error; \ - } \ - if (outp) { \ - tp_locvar->fds_out = lttng_tp_mempool_alloc( \ - tp_locvar->nr_ulong * sizeof(unsigned long)); \ - if (!tp_locvar->fds_out) \ - goto error; \ - \ - err = lib_ring_buffer_copy_from_user_check_nofault( \ - tp_locvar->fds_out, outp, \ - tp_locvar->nr_ulong * sizeof(unsigned long)); \ - if (err != 0) \ - goto error; \ - } \ - if (exp) { \ - tp_locvar->fds_ex = lttng_tp_mempool_alloc( \ - tp_locvar->nr_ulong * sizeof(unsigned long)); \ - if (!tp_locvar->fds_ex) \ - goto error; \ - \ - err = lib_ring_buffer_copy_from_user_check_nofault( \ - tp_locvar->fds_ex, exp, \ - tp_locvar->nr_ulong * sizeof(unsigned long)); \ - if (err != 0) \ - goto error; \ - } \ - goto end; \ - \ -error: \ - tp_locvar->nr_bytes = 0; \ - tp_locvar->nr_ulong = 0; \ -end: ; /* Label at end of compound statement. */ \ - } \ - ) - -#define LTTNG_SYSCALL_SELECT_fds_field_LE(name, input) \ - ctf_custom_field( \ - ctf_custom_type( \ - __type_integer(uint8_t, 0, 0, 0, __BYTE_ORDER, 10, none) \ - ), \ - _ ## name ## _length, \ - ctf_custom_code( \ - if (input) { \ - ctf_integer_type(uint8_t, tp_locvar->nr_bytes) \ - ctf_align(uint8_t) \ - } else { \ - ctf_integer_type(uint8_t, 0) \ - ctf_align(uint8_t) \ - } \ - ) \ - ) \ - ctf_custom_field( \ - ctf_custom_type( \ - { \ - .atype = atype_sequence_nestable, \ - .u.sequence_nestable.length_name = "_" #name "_length", \ - .u.sequence_nestable.elem_type = __LTTNG_COMPOUND_LITERAL(struct lttng_type, \ - __type_integer(uint8_t, 0, 0, 0, __BYTE_ORDER, 16, none)), \ - .u.sequence_nestable.alignment = 0, \ - } \ - ), \ - name, \ - ctf_custom_code( \ - unsigned int src; \ - unsigned int nr_bytes_out = 0; \ - \ - if (!input) \ - goto skip_##name; \ - \ - for (src = 0; src < tp_locvar->nr_ulong; src++) { \ - int dst; \ - for (dst = 0; dst < sizeof(long); dst++) { \ - if (nr_bytes_out++ >= tp_locvar->nr_bytes) { \ - goto skip_##name; \ - } \ - ctf_user_integer_type(uint8_t, \ - ((uint8_t __user *) (input->fds_bits + src))[dst]); \ - } \ - } \ - skip_##name: ; \ - ) \ - ) - -#define LTTNG_SYSCALL_SELECT_fds_field_BE(name, input) \ - ctf_custom_field( \ - ctf_custom_type( \ - __type_integer(uint8_t, 0, 0, 0, __BYTE_ORDER, 10, none) \ - ), \ - _ ## name ## _length, \ - ctf_custom_code( \ - if (input) { \ - ctf_integer_type(uint8_t, tp_locvar->nr_bytes) \ - ctf_align(uint8_t) \ - } else { \ - ctf_integer_type(uint8_t, 0) \ - ctf_align(uint8_t) \ - } \ - ) \ - ) \ - ctf_custom_field( \ - ctf_custom_type( \ - { \ - .atype = atype_sequence_nestable, \ - .u.sequence_nestable.elem_type = __LTTNG_COMPOUND_LITERAL(struct lttng_type, \ - __type_integer(uint8_t, 0, 0, 0, __BYTE_ORDER, 16, none)), \ - .u.sequence_nestable.alignment = 0, \ - } \ - ), \ - name, \ - ctf_custom_code( \ - unsigned int src, nr_bytes_out = 0; \ - \ - if (!input) \ - goto skip_##name; \ - \ - for (src = 0; src < tp_locvar->nr_ulong; src++) { \ - int dst; \ - for (dst = sizeof(long); dst >= 0; dst--) { \ - if (nr_bytes_out++ >= tp_locvar->nr_bytes) { \ - goto skip_##name; \ - } \ - ctf_user_integer_type(uint8_t, \ - ((uint8_t __user *) (input->fds_bits + src))[dst]); \ - } \ - } \ - skip_##name: ; \ - ) \ - ) - -#define LTTNG_SYSCALL_SELECT_code_post \ - lttng_tp_mempool_free(tp_locvar->fds_in); \ - lttng_tp_mempool_free(tp_locvar->fds_out); \ - lttng_tp_mempool_free(tp_locvar->fds_ex); - -#if defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM) -#define OVERRIDE_32_select -#define OVERRIDE_64_select -SC_LTTNG_TRACEPOINT_EVENT_CODE(select, - TP_PROTO(sc_exit(long ret,) int n, fd_set __user *inp, fd_set __user *outp, - fd_set __user *exp, struct timeval *tvp), - TP_ARGS(sc_exit(ret,) n, inp, outp, exp, tvp), - TP_locvar( - LTTNG_SYSCALL_SELECT_locvar - ), - TP_code_pre( - LTTNG_SYSCALL_SELECT_code_pre - ), - TP_FIELDS( - sc_exit(ctf_integer(long, ret, ret)) - sc_in(ctf_integer(int, n, n)) - sc_inout(ctf_integer(uint8_t, overflow, tp_locvar->overflow)) - sc_inout(ctf_integer(struct timeval *, tvp, tvp)) - - sc_inout( -#if (__BYTE_ORDER == __LITTLE_ENDIAN) - LTTNG_SYSCALL_SELECT_fds_field_LE(readfds, inp) - LTTNG_SYSCALL_SELECT_fds_field_LE(writefds, outp) - LTTNG_SYSCALL_SELECT_fds_field_LE(exceptfds, exp) -#else - LTTNG_SYSCALL_SELECT_fds_field_BE(readfds, inp) - LTTNG_SYSCALL_SELECT_fds_field_BE(writefds, outp) - LTTNG_SYSCALL_SELECT_fds_field_BE(exceptfds, exp) -#endif - ) - ), - TP_code_post( - LTTNG_SYSCALL_SELECT_code_post - ) -) -#endif /* defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM) */ - -#if defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM) -#define OVERRIDE_32_pselect6 -#define OVERRIDE_64_pselect6 -SC_LTTNG_TRACEPOINT_EVENT_CODE(pselect6, - TP_PROTO(sc_exit(long ret,) int n, fd_set __user * inp, fd_set __user * outp, - fd_set __user * exp, struct timeval __user * tvp, void __user * sig), - TP_ARGS(sc_exit(ret,) n, inp, outp, exp, tvp, sig), - TP_locvar( - LTTNG_SYSCALL_SELECT_locvar - ), - TP_code_pre( - LTTNG_SYSCALL_SELECT_code_pre - ), - TP_FIELDS( - sc_exit(ctf_integer(long, ret, ret)) - sc_in(ctf_integer(int, n, n)) - sc_inout(ctf_integer(uint8_t, overflow, tp_locvar->overflow)) - sc_inout(ctf_integer(struct timeval *, tvp, tvp)) - sc_in(ctf_integer_hex(void *, sig, sig)) - - sc_inout( -#if (__BYTE_ORDER == __LITTLE_ENDIAN) - LTTNG_SYSCALL_SELECT_fds_field_LE(readfds, inp) - LTTNG_SYSCALL_SELECT_fds_field_LE(writefds, outp) - LTTNG_SYSCALL_SELECT_fds_field_LE(exceptfds, exp) -#else - LTTNG_SYSCALL_SELECT_fds_field_BE(readfds, inp) - LTTNG_SYSCALL_SELECT_fds_field_BE(writefds, outp) - LTTNG_SYSCALL_SELECT_fds_field_BE(exceptfds, exp) -#endif - ) - ), - TP_code_post( - LTTNG_SYSCALL_SELECT_code_post - ) -) -#endif /* defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM) */ - -#ifndef ONCE_LTTNG_TRACE_POLL_H -#define ONCE_LTTNG_TRACE_POLL_H - -#define LTTNG_POLL_NRFLAGS (POLLNVAL + 1) -#define POLL_FLAGS_PADDING_SIZE (sizeof(uint8_t) * BITS_PER_BYTE) - \ - ilog2(LTTNG_POLL_NRFLAGS - 1) - -/* - * Only extract the values specified by iBCS2 for now. - */ -static struct lttng_event_field lttng_pollfd_flag_fields[] = { - [ilog2(POLLIN)] = { - .name = "POLLIN", - .type = __type_integer(int, 1, 1, 0, __LITTLE_ENDIAN, 10, none), - }, - [ilog2(POLLPRI)] = { - .name = "POLLPRI", - .type = __type_integer(int, 1, 1, 0, __LITTLE_ENDIAN, 10, none), - }, - [ilog2(POLLOUT)] = { - .name = "POLLOUT", - .type = __type_integer(int, 1, 1, 0, __LITTLE_ENDIAN, 10, none), - }, - [ilog2(POLLERR)] = { - .name = "POLLERR", - .type = __type_integer(int, 1, 1, 0, __LITTLE_ENDIAN, 10, none), - }, - [ilog2(POLLHUP)] = { - .name = "POLLHUP", - .type = __type_integer(int, 1, 1, 0, __LITTLE_ENDIAN, 10, none), - }, - [ilog2(POLLNVAL)] = { - .name = "POLLNVAL", - .type = __type_integer(int, 1, 1, 0, __LITTLE_ENDIAN, 10, none), - }, - [ilog2(LTTNG_POLL_NRFLAGS)] = { - .name = "padding", - .type = __type_integer(int, POLL_FLAGS_PADDING_SIZE, 1, 0, - __LITTLE_ENDIAN, 10, none), - }, -}; - -static struct lttng_event_field lttng_pollfd_fields[] = { - [0] = { - .name = "fd", - .type = __type_integer(int, 0, 0, 0, __BYTE_ORDER, 10, none), - }, - [1] = { - .name = "raw_events", - .type = __type_integer(short, 0, 0, 0, __BYTE_ORDER, 16, none), - }, - [2] = { - .name = "events", - .type = { - .atype = atype_struct_nestable, - .u.struct_nestable.nr_fields = ARRAY_SIZE(lttng_pollfd_flag_fields), - .u.struct_nestable.fields = lttng_pollfd_flag_fields, - .u.struct_nestable.alignment = 0, - } - }, -}; - -static struct lttng_type lttng_pollfd_elem = { - .atype = atype_struct_nestable, - .u.struct_nestable.nr_fields = ARRAY_SIZE(lttng_pollfd_fields), - .u.struct_nestable.fields = lttng_pollfd_fields, - .u.struct_nestable.alignment = 0, -}; -#endif /* ONCE_LTTNG_TRACE_POLL_H */ - -#define LTTNG_SYSCALL_POLL_locvar \ - unsigned int fds_length, fds_max_len, alloc_fds; \ - struct pollfd *fds; \ - uint8_t overflow; - -#define LTTNG_SYSCALL_POLL_code_pre \ - BUILD_BUG_ON(((ARRAY_SIZE(lttng_pollfd_flag_fields) - 1) + \ - POLL_FLAGS_PADDING_SIZE) != \ - sizeof(uint8_t) * BITS_PER_BYTE); \ - tp_locvar->fds = NULL; \ - tp_locvar->overflow = 0; \ - \ - sc_in( \ - if (nfds > PAGE_SIZE / sizeof(struct pollfd)) { \ - tp_locvar->fds_length = PAGE_SIZE / sizeof(struct pollfd); \ - tp_locvar->fds_max_len = PAGE_SIZE / sizeof(struct pollfd); \ - tp_locvar->overflow = 1; \ - } else { \ - tp_locvar->fds_length = nfds; \ - tp_locvar->fds_max_len = nfds; \ - } \ - tp_locvar->alloc_fds = tp_locvar->fds_length * sizeof(struct pollfd); \ - ) \ - /* \ - * On exit, the number of active FDs is determined by ret, \ - * nfds stays the same as the entry, but we only want to \ - * output the FDs that are relevant. \ - */ \ - sc_out( \ - if (ret <= 0 || ret > nfds) \ - goto error; \ - \ - if (nfds > PAGE_SIZE / sizeof(struct pollfd)) { \ - tp_locvar->fds_length = PAGE_SIZE / sizeof(struct pollfd); \ - tp_locvar->fds_max_len = PAGE_SIZE / sizeof(struct pollfd); \ - tp_locvar->overflow = 1; \ - } else { \ - tp_locvar->fds_length = ret; \ - tp_locvar->fds_max_len = nfds; \ - } \ - tp_locvar->alloc_fds = tp_locvar->fds_max_len * sizeof(struct pollfd); \ - ) \ - { \ - int err; \ - \ - tp_locvar->fds = lttng_tp_mempool_alloc(tp_locvar->alloc_fds); \ - if (!tp_locvar->fds) \ - goto error; \ - err = lib_ring_buffer_copy_from_user_check_nofault( \ - tp_locvar->fds, ufds, tp_locvar->alloc_fds); \ - if (err != 0) \ - goto error; \ - } \ - goto end; \ - \ -error: \ - tp_locvar->fds_length = 0; \ - tp_locvar->fds_max_len = 0; \ -end: \ - ; - -#define LTTNG_SYSCALL_POLL_fds_field \ - sc_in( \ - ctf_custom_field( \ - ctf_custom_type( \ - { \ - .atype = atype_sequence_nestable, \ - .u.sequence_nestable.length_name = "fds_length", \ - .u.sequence_nestable.elem_type = <tng_pollfd_elem, \ - } \ - ), \ - fds, \ - ctf_custom_code( \ - uint32_t i; \ - \ - ctf_align(int) /* Align on largest field in struct. */ \ - for (i = 0; i < tp_locvar->fds_length; i++) { \ - ctf_integer_type(int, tp_locvar->fds[i].fd) \ - ctf_integer_type(short, tp_locvar->fds[i].events) \ - ctf_integer_bitfield_type(uint8_t, \ - (uint8_t) tp_locvar->fds[i].events) \ - } \ - ) \ - ) \ - ) \ - sc_out( \ - ctf_custom_field( \ - ctf_custom_type( \ - { \ - .atype = atype_sequence_nestable, \ - .u.sequence_nestable.length_name = "fds_length", \ - .u.sequence_nestable.elem_type = <tng_pollfd_elem, \ - } \ - ), \ - fds, \ - ctf_custom_code( \ - unsigned int i, nr = 0; \ - \ - ctf_align(int) /* Align on largest field in struct. */ \ - /* \ - * Iterate over the complete array, but only output \ - * "ret" active FDs. \ - */ \ - for (i = 0; i < tp_locvar->fds_max_len; i++) { \ - if (!tp_locvar->fds[i].revents) \ - continue; \ - if (nr++ >= tp_locvar->fds_length) \ - break; \ - ctf_integer_type(int, tp_locvar->fds[i].fd) \ - ctf_integer_type(short, tp_locvar->fds[i].revents) \ - ctf_integer_bitfield_type(uint8_t, \ - (uint8_t) tp_locvar->fds[i].revents) \ - } \ - /* \ - * If there is a discrepancy between ret and the \ - * content of revents (e.g. caused by userspace corrupting \ - * the array from a concurrent thread), we have to output \ - * zeros to keep the trace readable. \ - */ \ - for (i = nr; i < tp_locvar->fds_length; i++) { \ - ctf_integer_type(int, 0) \ - ctf_integer_type(short, 0) \ - ctf_integer_bitfield_type(uint8_t, 0) \ - } \ - ) \ - ) \ - ) - -#define LTTNG_SYSCALL_POLL_code_post \ - lttng_tp_mempool_free(tp_locvar->fds); - -#if defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM) -#define OVERRIDE_32_poll -#define OVERRIDE_64_poll -SC_LTTNG_TRACEPOINT_EVENT_CODE(poll, - TP_PROTO(sc_exit(long ret,) struct pollfd __user * ufds, - unsigned int nfds, int timeout_msecs), - TP_ARGS(sc_exit(ret,) ufds, nfds, timeout_msecs), - TP_locvar( - LTTNG_SYSCALL_POLL_locvar - ), - TP_code_pre( - LTTNG_SYSCALL_POLL_code_pre - ), - TP_FIELDS( - sc_exit(ctf_integer(long, ret, ret)) - sc_in(ctf_integer(int, timeout_msecs, timeout_msecs)) - sc_inout(ctf_integer(unsigned int, nfds, nfds)) - sc_inout(ctf_integer(unsigned int, fds_length, tp_locvar->fds_length)) - sc_in(ctf_integer(uint8_t, overflow, tp_locvar->overflow)) - LTTNG_SYSCALL_POLL_fds_field - ), - TP_code_post( - LTTNG_SYSCALL_POLL_code_post - ) -) -#endif /* defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM) */ - -#if defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM) -#define OVERRIDE_32_ppoll -#define OVERRIDE_64_ppoll -SC_LTTNG_TRACEPOINT_EVENT_CODE(ppoll, - TP_PROTO(sc_exit(long ret,) struct pollfd __user * ufds, - unsigned int nfds, struct timespec * tsp, const sigset_t * sigmask, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) ufds, nfds, tsp, sigmask, sigsetsize), - TP_locvar( - LTTNG_SYSCALL_POLL_locvar - ), - TP_code_pre( - LTTNG_SYSCALL_POLL_code_pre - ), - TP_FIELDS( - sc_exit(ctf_integer(long, ret, ret)) - sc_in(ctf_integer(struct timespec *, tsp, tsp)) - sc_in(ctf_integer(const sigset_t *, sigmask, sigmask)) - sc_in(ctf_integer(size_t, sigsetsize, sigsetsize)) - sc_inout(ctf_integer(unsigned int, nfds, nfds)) - sc_inout(ctf_integer(unsigned int, fds_length, tp_locvar->fds_length)) - sc_inout(ctf_integer(uint8_t, overflow, tp_locvar->overflow)) - LTTNG_SYSCALL_POLL_fds_field - ), - TP_code_post( - LTTNG_SYSCALL_POLL_code_post - ) -) -#endif /* defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM) */ - -#include - -SC_LTTNG_TRACEPOINT_ENUM(lttng_epoll_op, - TP_ENUM_VALUES( - ctf_enum_value("EPOLL_CTL_ADD", EPOLL_CTL_ADD) - ctf_enum_value("EPOLL_CTL_DEL", EPOLL_CTL_DEL) - ctf_enum_value("EPOLL_CTL_MOD", EPOLL_CTL_MOD) - ) -) - -#ifndef ONCE_LTTNG_TRACE_EPOLL_CTL_H -#define ONCE_LTTNG_TRACE_EPOLL_CTL_H - -#define LTTNG_EPOLL_NRFLAGS (POLLHUP + 1) -#define EPOLL_FLAGS_PADDING_SIZE (sizeof(uint8_t) * BITS_PER_BYTE) - \ - ilog2(LTTNG_EPOLL_NRFLAGS - 1) - -/* - * Only extract the values specified by iBCS2 for now. - */ -static struct lttng_event_field lttng_epoll_ctl_events_fields[] = { - /* 0x0001 */ - [ilog2(POLLIN)] = { - .name = "EPOLLIN", - .type = __type_integer(int, 1, 1, 0, __LITTLE_ENDIAN, 10, none), - }, - /* 0x0002 */ - [ilog2(POLLPRI)] = { - .name = "EPOLLPRI", - .type = __type_integer(int, 1, 1, 0, __LITTLE_ENDIAN, 10, none), - }, - /* 0x0004 */ - [ilog2(POLLOUT)] = { - .name = "EPOLLOUT", - .type = __type_integer(int, 1, 1, 0, __LITTLE_ENDIAN, 10, none), - }, - /* 0x0008 */ - [ilog2(POLLERR)] = { - .name = "EPOLLERR", - .type = __type_integer(int, 1, 1, 0, __LITTLE_ENDIAN, 10, none), - }, - /* 0x0010 */ - [ilog2(POLLHUP)] = { - .name = "EPOLLHUP", - .type = __type_integer(int, 1, 1, 0, __LITTLE_ENDIAN, 10, none), - }, - [ilog2(LTTNG_EPOLL_NRFLAGS)] = { - .name = "padding", - .type = __type_integer(int, EPOLL_FLAGS_PADDING_SIZE, 1, 0, - __LITTLE_ENDIAN, 10, none), - }, - -}; - -static struct lttng_event_field lttng_epoll_data_fields[] = { - [0] = { - .name = "u64", - .type = __type_integer(uint64_t, 0, 0, 0, __BYTE_ORDER, 16, none), - }, - [1] = { - .name = "fd", - .type = __type_integer(int, 0, 0, 0, __BYTE_ORDER, 10, none), - }, -}; - -static struct lttng_event_field epoll_ctl_fields[] = { - [0] = { - .name = "data_union", - .type = { - .atype = atype_struct_nestable, - .u.struct_nestable.nr_fields = ARRAY_SIZE(lttng_epoll_data_fields), - .u.struct_nestable.fields = lttng_epoll_data_fields, - .u.struct_nestable.alignment = 0, - } - }, - [1] = { - .name = "raw_events", - .type = __type_integer(uint32_t, 0, 0, 0, __BYTE_ORDER, 16, none), - }, - [2] = { - .name = "events", - .type = { - .atype = atype_struct_nestable, - .u.struct_nestable.nr_fields = ARRAY_SIZE(lttng_epoll_ctl_events_fields), - .u.struct_nestable.fields = lttng_epoll_ctl_events_fields, - .u.struct_nestable.alignment = 0, - } - }, -}; -#endif /* ONCE_LTTNG_TRACE_EPOLL_CTL_H */ - -#if defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM) -#define OVERRIDE_32_epoll_ctl -#define OVERRIDE_64_epoll_ctl -SC_LTTNG_TRACEPOINT_EVENT_CODE(epoll_ctl, - TP_PROTO(sc_exit(long ret,) int epfd, int op, int fd, - struct epoll_event __user * uevent), - TP_ARGS(sc_exit(ret,) epfd, op, fd, uevent), - TP_locvar( - struct epoll_event event; - int err; - ), - TP_code_pre( - tp_locvar->err = lib_ring_buffer_copy_from_user_check_nofault( - &tp_locvar->event, uevent, sizeof(struct epoll_event)); - ), - TP_FIELDS( - sc_exit(ctf_integer(long, ret, ret)) - sc_in(ctf_integer(int, epfd, epfd)) - sc_in(ctf_enum(lttng_epoll_op, int, op_enum, op)) - sc_in(ctf_integer(int, fd, fd)) - sc_in( - ctf_custom_field( - ctf_custom_type( - { - .atype = atype_struct_nestable, - .u.struct_nestable.nr_fields = ARRAY_SIZE(epoll_ctl_fields), - .u.struct_nestable.fields = epoll_ctl_fields, - .u.struct_nestable.alignment = 0, - } - ), - event, - ctf_custom_code( - ctf_align(uint64_t) - if (!tp_locvar->err) { - ctf_integer_type(uint64_t, tp_locvar->event.data) - ctf_integer_type(int, tp_locvar->event.data) - ctf_integer_bitfield_type(uint32_t, - tp_locvar->event.events) - ctf_integer_bitfield_type(uint8_t, - (uint8_t) tp_locvar->event.events) - } else { - ctf_integer_type(uint64_t, 0) - ctf_integer_type(int, 0) - ctf_integer_bitfield_type(uint32_t, 0) - ctf_integer_bitfield_type(uint8_t, 0) - } - ) - ) - ) - ), - TP_code_post() -) -#endif /* defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM) */ - -#ifndef ONCE_LTTNG_TRACE_EPOLL_H -#define ONCE_LTTNG_TRACE_EPOLL_H - -static struct lttng_event_field lttng_epoll_wait_fields[] = { - [0] = { - .name = "data_union", - .type = { - .atype = atype_struct_nestable, - .u.struct_nestable.nr_fields = ARRAY_SIZE(lttng_epoll_data_fields), - .u.struct_nestable.fields = lttng_epoll_data_fields, - .u.struct_nestable.alignment = 0, - } - }, - [1] = { - .name = "raw_events", - .type = __type_integer(uint32_t, 0, 0, 0, __BYTE_ORDER, 16, none), - }, - [2] = { - .name = "events", - .type = { - .atype = atype_struct_nestable, - .u.struct_nestable.nr_fields = ARRAY_SIZE(lttng_epoll_ctl_events_fields), - .u.struct_nestable.fields = lttng_epoll_ctl_events_fields, - .u.struct_nestable.alignment = 0, - } - }, -}; - -static struct lttng_type lttng_epoll_wait_elem = { - .atype = atype_struct_nestable, - .u.struct_nestable.nr_fields = ARRAY_SIZE(lttng_epoll_wait_fields), - .u.struct_nestable.fields = lttng_epoll_wait_fields, - .u.struct_nestable.alignment = 0, -}; - -#endif /* ONCE_LTTNG_TRACE_EPOLL_H */ - -#define LTTNG_SYSCALL_EPOLL_WAIT_locvar \ - sc_out( \ - unsigned int fds_length; \ - uint8_t overflow; \ - struct epoll_event *events; \ - ) - -#define LTTNG_SYSCALL_EPOLL_WAIT_code_pre \ - BUILD_BUG_ON(((ARRAY_SIZE(lttng_epoll_ctl_events_fields) - 1) + \ - EPOLL_FLAGS_PADDING_SIZE) != \ - sizeof(uint8_t) * BITS_PER_BYTE); \ - sc_out({ \ - int err; \ - unsigned long maxalloc; \ - \ - tp_locvar->fds_length = 0; \ - tp_locvar->events = NULL; \ - tp_locvar->overflow = 0; \ - \ - if (maxevents <= 0 || ret <= 0 || ret > maxevents) \ - goto skip_code; \ - \ - if (maxevents > PAGE_SIZE / sizeof(struct epoll_event)) { \ - maxalloc = PAGE_SIZE / sizeof(struct epoll_event); \ - } else { \ - maxalloc = maxevents; \ - } \ - \ - if (ret > maxalloc) { \ - tp_locvar->fds_length = maxalloc; \ - tp_locvar->overflow = 1; \ - } else { \ - tp_locvar->fds_length = ret; \ - } \ - \ - tp_locvar->events = lttng_tp_mempool_alloc( \ - maxalloc * sizeof(struct epoll_event)); \ - if (!tp_locvar->events) { \ - tp_locvar->fds_length = 0; \ - goto skip_code; \ - } \ - \ - err = lib_ring_buffer_copy_from_user_check_nofault( \ - tp_locvar->events, uevents, \ - maxalloc * sizeof(struct epoll_event)); \ - if (err != 0) \ - tp_locvar->fds_length = 0; \ - } \ - skip_code: \ - ) - -#define LTTNG_SYSCALL_EPOLL_WAIT_fds_field \ - ctf_custom_field( \ - ctf_custom_type( \ - { \ - .atype = atype_sequence_nestable, \ - .u.sequence_nestable.length_name = \ - "fds_length", \ - .u.sequence_nestable.elem_type = \ - <tng_epoll_wait_elem, \ - } \ - ), \ - fds, \ - ctf_custom_code( \ - uint32_t i; \ - \ - ctf_align(uint64_t) \ - for (i = 0; i < tp_locvar->fds_length; i++) { \ - ctf_integer_type(uint64_t, tp_locvar->events[i].data) \ - ctf_integer_type(int, tp_locvar->events[i].data) \ - ctf_integer_bitfield_type(uint32_t, \ - tp_locvar->events[i].events) \ - ctf_integer_bitfield_type(uint8_t, \ - (uint8_t) tp_locvar->events[i].events) \ - } \ - ) \ - ) - -#define LTTNG_SYSCALL_EPOLL_WAIT_code_post \ - sc_out( \ - lttng_tp_mempool_free(tp_locvar->events); \ - ) - - -#if defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM) -#define OVERRIDE_32_epoll_wait -#define OVERRIDE_64_epoll_wait -SC_LTTNG_TRACEPOINT_EVENT_CODE(epoll_wait, - TP_PROTO(sc_exit(long ret,) int epfd, struct epoll_event __user * uevents, - int maxevents, int timeout), - TP_ARGS(sc_exit(ret,) epfd, uevents, maxevents, timeout), - TP_locvar( - LTTNG_SYSCALL_EPOLL_WAIT_locvar - ), - TP_code_pre( - LTTNG_SYSCALL_EPOLL_WAIT_code_pre - ), - TP_FIELDS( - sc_exit(ctf_integer(long, ret, ret)) - sc_in(ctf_integer(int, epfd, epfd)) - sc_in(ctf_integer(int, maxevents, maxevents)) - sc_in(ctf_integer(int, timeout, timeout)) - sc_out(ctf_integer(unsigned int, fds_length, tp_locvar->fds_length)) - sc_out(ctf_integer(uint8_t, overflow, tp_locvar->overflow)) - sc_out( - LTTNG_SYSCALL_EPOLL_WAIT_fds_field - ) - ), - TP_code_post( - LTTNG_SYSCALL_EPOLL_WAIT_code_post - ) -) -#endif /* defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM) */ - -#if defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM) -#define OVERRIDE_32_epoll_pwait -#define OVERRIDE_64_epoll_pwait -SC_LTTNG_TRACEPOINT_EVENT_CODE(epoll_pwait, - TP_PROTO(sc_exit(long ret,) int epfd, struct epoll_event __user * uevents, - int maxevents, int timeout, const sigset_t __user * sigmask, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) epfd, uevents, maxevents, timeout, sigmask, sigsetsize), - TP_locvar( - LTTNG_SYSCALL_EPOLL_WAIT_locvar - ), - TP_code_pre( - LTTNG_SYSCALL_EPOLL_WAIT_code_pre - ), - TP_FIELDS( - sc_exit(ctf_integer(long, ret, ret)) - sc_in(ctf_integer(int, epfd, epfd)) - sc_in(ctf_integer(int, maxevents, maxevents)) - sc_in(ctf_integer(int, timeout, timeout)) - sc_in(ctf_integer_hex(const sigset_t *, sigmask, sigmask)) - sc_in(ctf_integer(size_t, sigsetsize, sigsetsize)) - sc_out(ctf_integer(unsigned int, fds_length, tp_locvar->fds_length)) - sc_out(ctf_integer(uint8_t, overflow, tp_locvar->overflow)) - sc_out( - LTTNG_SYSCALL_EPOLL_WAIT_fds_field - ) - ), - TP_code_post( - LTTNG_SYSCALL_EPOLL_WAIT_code_post - ) -) -#endif /* defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM) */ - -#if (defined(CONFIG_X86_64) && !defined(LTTNG_SC_COMPAT)) || defined(CONFIG_ARM64) || defined(CONFIG_ARM) -#define OVERRIDE_32_socketpair -#define OVERRIDE_64_socketpair -SC_LTTNG_TRACEPOINT_EVENT(socketpair, - TP_PROTO(sc_exit(long ret,) int family, int type, int protocol, int *usockvec), - TP_ARGS(sc_exit(ret,) family, type, protocol, usockvec), - TP_FIELDS( - sc_exit(ctf_integer(long, ret, ret)) - sc_in(ctf_integer(int, family, family)) - sc_in(ctf_integer(int, type, type)) - sc_in(ctf_integer(int, protocol, protocol)) - sc_out(ctf_user_array(int, socket, usockvec, 2)) - ) -) -#endif /* (defined(CONFIG_X86_64) && !defined(LTTNG_SC_COMPAT)) || defined(CONFIG_ARM64) || defined(CONFIG_ARM) */ - -/* - * Enumeration of the open flags, as described in the 'open' - * system call man page. - */ -SC_LTTNG_TRACEPOINT_ENUM(lttng_file_status_flags, - TP_ENUM_VALUES( - ctf_enum_value("O_RDONLY", O_RDONLY) - ctf_enum_value("O_WRONLY", O_WRONLY) - ctf_enum_value("O_RDWR", O_RDWR) - ctf_enum_value("O_CREAT", O_CREAT) - ctf_enum_value("O_EXCL", O_EXCL) - ctf_enum_value("O_NOCTTY", O_NOCTTY) - ctf_enum_value("O_TRUNC", O_TRUNC) - ctf_enum_value("O_APPEND", O_APPEND) - ctf_enum_value("O_NONBLOCK", O_NONBLOCK) - ctf_enum_value("O_DSYNC", O_DSYNC) - ctf_enum_value("FASYNC", FASYNC) - ctf_enum_value("O_DIRECT", O_DIRECT) - ctf_enum_value("O_LARGEFILE", O_LARGEFILE) - ctf_enum_value("O_DIRECTORY", O_DIRECTORY) - ctf_enum_value("O_NOFOLLOW", O_NOFOLLOW) - ctf_enum_value("O_NOATIME", O_NOATIME) - ctf_enum_value("O_CLOEXEC", O_CLOEXEC) - ctf_enum_value("O_SYNC", __O_SYNC) - ctf_enum_value("O_PATH", O_PATH) - ctf_enum_value("O_TMPFILE", __O_TMPFILE) - ) -) - -/* - * Enumeration of the open flags, as described in the 'open' - * system call man page. - */ -SC_LTTNG_TRACEPOINT_ENUM(lttng_file_mode, - TP_ENUM_VALUES( - ctf_enum_value("S_IRWXU", S_IRWXU) - ctf_enum_value("S_IRUSR", S_IRUSR) - ctf_enum_value("S_IWUSR", S_IWUSR) - ctf_enum_value("S_IXUSR", S_IXUSR) - ctf_enum_value("S_IRWXG", S_IRWXG) - ctf_enum_value("S_IRGRP", S_IRGRP) - ctf_enum_value("S_IWGRP", S_IWGRP) - ctf_enum_value("S_IXGRP", S_IXGRP) - ctf_enum_value("S_IRWXO", S_IRWXO) - ctf_enum_value("S_IROTH", S_IROTH) - ctf_enum_value("S_IWOTH", S_IWOTH) - ctf_enum_value("S_IXOTH", S_IXOTH) - ctf_enum_value("S_ISUID", S_ISUID) - ctf_enum_value("S_ISGID", S_ISGID) - ctf_enum_value("S_ISVTX", S_ISVTX) - ) -) - -#define OVERRIDE_32_openat -#define OVERRIDE_64_openat -SC_LTTNG_TRACEPOINT_EVENT(openat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, int flags, umode_t mode), - TP_ARGS(sc_exit(ret,) dfd, filename, flags, mode), - TP_FIELDS( - sc_exit(ctf_integer(long, ret, ret)) - sc_in(ctf_integer(int, dfd, dfd)) - sc_in(ctf_user_string(filename, filename)) - sc_in(ctf_enum(lttng_file_status_flags, int, flags, flags)) - sc_in(ctf_enum(lttng_file_mode, umode_t, mode, mode)) - ) -) - -#define OVERRIDE_32_open -#define OVERRIDE_64_open -SC_LTTNG_TRACEPOINT_EVENT(open, - TP_PROTO(sc_exit(long ret,) const char * filename, int flags, umode_t mode), - TP_ARGS(sc_exit(ret,) filename, flags, mode), - TP_FIELDS( - sc_exit(ctf_integer(long, ret, ret)) - sc_in(ctf_user_string(filename, filename)) - sc_in(ctf_enum(lttng_file_status_flags, int, flags, flags)) - sc_in(ctf_enum(lttng_file_mode, umode_t, mode, mode)) - ) -) - -#endif /* CREATE_SYSCALL_TABLE */ diff --git a/instrumentation/syscalls/headers/syscalls_unknown.h b/instrumentation/syscalls/headers/syscalls_unknown.h deleted file mode 100644 index 1718f5c0..00000000 --- a/instrumentation/syscalls/headers/syscalls_unknown.h +++ /dev/null @@ -1,55 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ - -#if !defined(_TRACE_SYSCALLS_UNKNOWN_H) || defined(TRACE_HEADER_MULTI_READ) -#define _TRACE_SYSCALLS_UNKNOWN_H - -#include -#include - -#define UNKNOWN_SYSCALL_NRARGS 6 - -#undef TP_PROBE_CB -#define TP_PROBE_CB(_template) &syscall_entry_probe - -LTTNG_TRACEPOINT_EVENT(syscall_entry_unknown, - TP_PROTO(int id, unsigned long *args), - TP_ARGS(id, args), - TP_FIELDS( - ctf_integer(int, id, id) - ctf_array(unsigned long, args, args, UNKNOWN_SYSCALL_NRARGS) - ) -) -LTTNG_TRACEPOINT_EVENT(compat_syscall_entry_unknown, - TP_PROTO(int id, unsigned long *args), - TP_ARGS(id, args), - TP_FIELDS( - ctf_integer(int, id, id) - ctf_array(unsigned long, args, args, UNKNOWN_SYSCALL_NRARGS) - ) -) - -#undef TP_PROBE_CB -#define TP_PROBE_CB(_template) &syscall_exit_probe - -LTTNG_TRACEPOINT_EVENT(syscall_exit_unknown, - TP_PROTO(int id, long ret, unsigned long *args), - TP_ARGS(id, ret, args), - TP_FIELDS( - ctf_integer(int, id, id) - ctf_integer(long, ret, ret) - ctf_array(unsigned long, args, args, UNKNOWN_SYSCALL_NRARGS) - ) -) -LTTNG_TRACEPOINT_EVENT(compat_syscall_exit_unknown, - TP_PROTO(int id, long ret, unsigned long *args), - TP_ARGS(id, ret, args), - TP_FIELDS( - ctf_integer(int, id, id) - ctf_integer(long, ret, ret) - ctf_array(unsigned long, args, args, UNKNOWN_SYSCALL_NRARGS) - ) -) -#endif /* _TRACE_SYSCALLS_UNKNOWN_H */ - -/* This part must be outside protection */ -#include diff --git a/instrumentation/syscalls/headers/x86-32-syscalls_integers.h b/instrumentation/syscalls/headers/x86-32-syscalls_integers.h deleted file mode 100644 index 6e1fc8ec..00000000 --- a/instrumentation/syscalls/headers/x86-32-syscalls_integers.h +++ /dev/null @@ -1,1214 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ - -/* THIS FILE IS AUTO-GENERATED. DO NOT EDIT */ - -/* Generated from x86-32-syscalls 3.1.0-rc6 */ - -#ifndef CREATE_SYSCALL_TABLE - -#if !defined(_TRACE_SYSCALLS_INTEGERS_H) || defined(TRACE_HEADER_MULTI_READ) -#define _TRACE_SYSCALLS_INTEGERS_H - -#include -#include -#include "x86-32-syscalls_integers_override.h" -#include "syscalls_integers_override.h" - -#ifdef SC_ENTER -SC_LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(syscalls_noargs, - TP_FIELDS() -) -#ifndef OVERRIDE_32_restart_syscall -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, restart_syscall) -#endif -#ifndef OVERRIDE_32_getpid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getpid) -#endif -#ifndef OVERRIDE_32_getuid16 -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getuid16) -#endif -#ifndef OVERRIDE_32_pause -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, pause) -#endif -#ifndef OVERRIDE_32_sync -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, sync) -#endif -#ifndef OVERRIDE_32_getgid16 -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getgid16) -#endif -#ifndef OVERRIDE_32_geteuid16 -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, geteuid16) -#endif -#ifndef OVERRIDE_32_getegid16 -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getegid16) -#endif -#ifndef OVERRIDE_32_getppid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getppid) -#endif -#ifndef OVERRIDE_32_getpgrp -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getpgrp) -#endif -#ifndef OVERRIDE_32_setsid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, setsid) -#endif -#ifndef OVERRIDE_32_sgetmask -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, sgetmask) -#endif -#ifndef OVERRIDE_32_vhangup -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, vhangup) -#endif -#ifndef OVERRIDE_32_munlockall -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, munlockall) -#endif -#ifndef OVERRIDE_32_sched_yield -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, sched_yield) -#endif -#ifndef OVERRIDE_32_getuid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getuid) -#endif -#ifndef OVERRIDE_32_getgid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getgid) -#endif -#ifndef OVERRIDE_32_geteuid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, geteuid) -#endif -#ifndef OVERRIDE_32_getegid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getegid) -#endif -#ifndef OVERRIDE_32_gettid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, gettid) -#endif -#ifndef OVERRIDE_32_inotify_init -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, inotify_init) -#endif -#else /* #ifdef SC_ENTER */ -#ifndef OVERRIDE_32_restart_syscall -SC_LTTNG_TRACEPOINT_EVENT(restart_syscall, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_getpid -SC_LTTNG_TRACEPOINT_EVENT(getpid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_getuid16 -SC_LTTNG_TRACEPOINT_EVENT(getuid16, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_pause -SC_LTTNG_TRACEPOINT_EVENT(pause, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_sync -SC_LTTNG_TRACEPOINT_EVENT(sync, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_getgid16 -SC_LTTNG_TRACEPOINT_EVENT(getgid16, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_geteuid16 -SC_LTTNG_TRACEPOINT_EVENT(geteuid16, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_getegid16 -SC_LTTNG_TRACEPOINT_EVENT(getegid16, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_getppid -SC_LTTNG_TRACEPOINT_EVENT(getppid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_getpgrp -SC_LTTNG_TRACEPOINT_EVENT(getpgrp, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_setsid -SC_LTTNG_TRACEPOINT_EVENT(setsid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_sgetmask -SC_LTTNG_TRACEPOINT_EVENT(sgetmask, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_vhangup -SC_LTTNG_TRACEPOINT_EVENT(vhangup, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_munlockall -SC_LTTNG_TRACEPOINT_EVENT(munlockall, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_sched_yield -SC_LTTNG_TRACEPOINT_EVENT(sched_yield, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_getuid -SC_LTTNG_TRACEPOINT_EVENT(getuid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_getgid -SC_LTTNG_TRACEPOINT_EVENT(getgid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_geteuid -SC_LTTNG_TRACEPOINT_EVENT(geteuid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_getegid -SC_LTTNG_TRACEPOINT_EVENT(getegid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_gettid -SC_LTTNG_TRACEPOINT_EVENT(gettid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_32_inotify_init -SC_LTTNG_TRACEPOINT_EVENT(inotify_init, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#endif /* else #ifdef SC_ENTER */ -#ifndef OVERRIDE_32_exit -SC_LTTNG_TRACEPOINT_EVENT(exit, - TP_PROTO(sc_exit(long ret,) int error_code), - TP_ARGS(sc_exit(ret,) error_code), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, error_code, error_code))) -) -#endif -#ifndef OVERRIDE_32_close -SC_LTTNG_TRACEPOINT_EVENT(close, - TP_PROTO(sc_exit(long ret,) unsigned int fd), - TP_ARGS(sc_exit(ret,) fd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) -) -#endif -#ifndef OVERRIDE_32_setuid16 -SC_LTTNG_TRACEPOINT_EVENT(setuid16, - TP_PROTO(sc_exit(long ret,) old_uid_t uid), - TP_ARGS(sc_exit(ret,) uid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(old_uid_t, uid, uid))) -) -#endif -#ifndef OVERRIDE_32_alarm -SC_LTTNG_TRACEPOINT_EVENT(alarm, - TP_PROTO(sc_exit(long ret,) unsigned int seconds), - TP_ARGS(sc_exit(ret,) seconds), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, seconds, seconds))) -) -#endif -#ifndef OVERRIDE_32_nice -SC_LTTNG_TRACEPOINT_EVENT(nice, - TP_PROTO(sc_exit(long ret,) int increment), - TP_ARGS(sc_exit(ret,) increment), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, increment, increment))) -) -#endif -#ifndef OVERRIDE_32_dup -SC_LTTNG_TRACEPOINT_EVENT(dup, - TP_PROTO(sc_exit(long ret,) unsigned int fildes), - TP_ARGS(sc_exit(ret,) fildes), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fildes, fildes))) -) -#endif -#ifndef OVERRIDE_32_brk -SC_LTTNG_TRACEPOINT_EVENT(brk, - TP_PROTO(sc_exit(long ret,) unsigned long brk), - TP_ARGS(sc_exit(ret,) brk), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, brk, brk))) -) -#endif -#ifndef OVERRIDE_32_setgid16 -SC_LTTNG_TRACEPOINT_EVENT(setgid16, - TP_PROTO(sc_exit(long ret,) old_gid_t gid), - TP_ARGS(sc_exit(ret,) gid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(old_gid_t, gid, gid))) -) -#endif -#ifndef OVERRIDE_32_umask -SC_LTTNG_TRACEPOINT_EVENT(umask, - TP_PROTO(sc_exit(long ret,) int mask), - TP_ARGS(sc_exit(ret,) mask), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, mask, mask))) -) -#endif -#ifndef OVERRIDE_32_ssetmask -SC_LTTNG_TRACEPOINT_EVENT(ssetmask, - TP_PROTO(sc_exit(long ret,) int newmask), - TP_ARGS(sc_exit(ret,) newmask), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, newmask, newmask))) -) -#endif -#ifndef OVERRIDE_32_fsync -SC_LTTNG_TRACEPOINT_EVENT(fsync, - TP_PROTO(sc_exit(long ret,) unsigned int fd), - TP_ARGS(sc_exit(ret,) fd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) -) -#endif -#ifndef OVERRIDE_32_getpgid -SC_LTTNG_TRACEPOINT_EVENT(getpgid, - TP_PROTO(sc_exit(long ret,) pid_t pid), - TP_ARGS(sc_exit(ret,) pid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid))) -) -#endif -#ifndef OVERRIDE_32_fchdir -SC_LTTNG_TRACEPOINT_EVENT(fchdir, - TP_PROTO(sc_exit(long ret,) unsigned int fd), - TP_ARGS(sc_exit(ret,) fd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) -) -#endif -#ifndef OVERRIDE_32_personality -SC_LTTNG_TRACEPOINT_EVENT(personality, - TP_PROTO(sc_exit(long ret,) unsigned int personality), - TP_ARGS(sc_exit(ret,) personality), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, personality, personality))) -) -#endif -#ifndef OVERRIDE_32_setfsuid16 -SC_LTTNG_TRACEPOINT_EVENT(setfsuid16, - TP_PROTO(sc_exit(long ret,) old_uid_t uid), - TP_ARGS(sc_exit(ret,) uid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(old_uid_t, uid, uid))) -) -#endif -#ifndef OVERRIDE_32_setfsgid16 -SC_LTTNG_TRACEPOINT_EVENT(setfsgid16, - TP_PROTO(sc_exit(long ret,) old_gid_t gid), - TP_ARGS(sc_exit(ret,) gid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(old_gid_t, gid, gid))) -) -#endif -#ifndef OVERRIDE_32_getsid -SC_LTTNG_TRACEPOINT_EVENT(getsid, - TP_PROTO(sc_exit(long ret,) pid_t pid), - TP_ARGS(sc_exit(ret,) pid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid))) -) -#endif -#ifndef OVERRIDE_32_fdatasync -SC_LTTNG_TRACEPOINT_EVENT(fdatasync, - TP_PROTO(sc_exit(long ret,) unsigned int fd), - TP_ARGS(sc_exit(ret,) fd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) -) -#endif -#ifndef OVERRIDE_32_mlockall -SC_LTTNG_TRACEPOINT_EVENT(mlockall, - TP_PROTO(sc_exit(long ret,) int flags), - TP_ARGS(sc_exit(ret,) flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_sched_getscheduler -SC_LTTNG_TRACEPOINT_EVENT(sched_getscheduler, - TP_PROTO(sc_exit(long ret,) pid_t pid), - TP_ARGS(sc_exit(ret,) pid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid))) -) -#endif -#ifndef OVERRIDE_32_sched_get_priority_max -SC_LTTNG_TRACEPOINT_EVENT(sched_get_priority_max, - TP_PROTO(sc_exit(long ret,) int policy), - TP_ARGS(sc_exit(ret,) policy), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, policy, policy))) -) -#endif -#ifndef OVERRIDE_32_sched_get_priority_min -SC_LTTNG_TRACEPOINT_EVENT(sched_get_priority_min, - TP_PROTO(sc_exit(long ret,) int policy), - TP_ARGS(sc_exit(ret,) policy), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, policy, policy))) -) -#endif -#ifndef OVERRIDE_32_setuid -SC_LTTNG_TRACEPOINT_EVENT(setuid, - TP_PROTO(sc_exit(long ret,) uid_t uid), - TP_ARGS(sc_exit(ret,) uid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, uid, uid))) -) -#endif -#ifndef OVERRIDE_32_setgid -SC_LTTNG_TRACEPOINT_EVENT(setgid, - TP_PROTO(sc_exit(long ret,) gid_t gid), - TP_ARGS(sc_exit(ret,) gid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, gid, gid))) -) -#endif -#ifndef OVERRIDE_32_setfsuid -SC_LTTNG_TRACEPOINT_EVENT(setfsuid, - TP_PROTO(sc_exit(long ret,) uid_t uid), - TP_ARGS(sc_exit(ret,) uid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, uid, uid))) -) -#endif -#ifndef OVERRIDE_32_setfsgid -SC_LTTNG_TRACEPOINT_EVENT(setfsgid, - TP_PROTO(sc_exit(long ret,) gid_t gid), - TP_ARGS(sc_exit(ret,) gid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, gid, gid))) -) -#endif -#ifndef OVERRIDE_32_io_destroy -SC_LTTNG_TRACEPOINT_EVENT(io_destroy, - TP_PROTO(sc_exit(long ret,) aio_context_t ctx), - TP_ARGS(sc_exit(ret,) ctx), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx, ctx))) -) -#endif -#ifndef OVERRIDE_32_exit_group -SC_LTTNG_TRACEPOINT_EVENT(exit_group, - TP_PROTO(sc_exit(long ret,) int error_code), - TP_ARGS(sc_exit(ret,) error_code), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, error_code, error_code))) -) -#endif -#ifndef OVERRIDE_32_epoll_create -SC_LTTNG_TRACEPOINT_EVENT(epoll_create, - TP_PROTO(sc_exit(long ret,) int size), - TP_ARGS(sc_exit(ret,) size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, size, size))) -) -#endif -#ifndef OVERRIDE_32_timer_getoverrun -SC_LTTNG_TRACEPOINT_EVENT(timer_getoverrun, - TP_PROTO(sc_exit(long ret,) timer_t timer_id), - TP_ARGS(sc_exit(ret,) timer_id), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id))) -) -#endif -#ifndef OVERRIDE_32_timer_delete -SC_LTTNG_TRACEPOINT_EVENT(timer_delete, - TP_PROTO(sc_exit(long ret,) timer_t timer_id), - TP_ARGS(sc_exit(ret,) timer_id), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id))) -) -#endif -#ifndef OVERRIDE_32_unshare -SC_LTTNG_TRACEPOINT_EVENT(unshare, - TP_PROTO(sc_exit(long ret,) unsigned long unshare_flags), - TP_ARGS(sc_exit(ret,) unshare_flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, unshare_flags, unshare_flags))) -) -#endif -#ifndef OVERRIDE_32_eventfd -SC_LTTNG_TRACEPOINT_EVENT(eventfd, - TP_PROTO(sc_exit(long ret,) unsigned int count), - TP_ARGS(sc_exit(ret,) count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, count, count))) -) -#endif -#ifndef OVERRIDE_32_epoll_create1 -SC_LTTNG_TRACEPOINT_EVENT(epoll_create1, - TP_PROTO(sc_exit(long ret,) int flags), - TP_ARGS(sc_exit(ret,) flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_inotify_init1 -SC_LTTNG_TRACEPOINT_EVENT(inotify_init1, - TP_PROTO(sc_exit(long ret,) int flags), - TP_ARGS(sc_exit(ret,) flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_syncfs -SC_LTTNG_TRACEPOINT_EVENT(syncfs, - TP_PROTO(sc_exit(long ret,) int fd), - TP_ARGS(sc_exit(ret,) fd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd))) -) -#endif -#ifndef OVERRIDE_32_kill -SC_LTTNG_TRACEPOINT_EVENT(kill, - TP_PROTO(sc_exit(long ret,) pid_t pid, int sig), - TP_ARGS(sc_exit(ret,) pid, sig), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig))) -) -#endif -#ifndef OVERRIDE_32_signal -SC_LTTNG_TRACEPOINT_EVENT(signal, - TP_PROTO(sc_exit(long ret,) int sig, __sighandler_t handler), - TP_ARGS(sc_exit(ret,) sig, handler), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, sig, sig)) sc_inout(ctf_integer(__sighandler_t, handler, handler))) -) -#endif -#ifndef OVERRIDE_32_setpgid -SC_LTTNG_TRACEPOINT_EVENT(setpgid, - TP_PROTO(sc_exit(long ret,) pid_t pid, pid_t pgid), - TP_ARGS(sc_exit(ret,) pid, pgid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(pid_t, pgid, pgid))) -) -#endif -#ifndef OVERRIDE_32_dup2 -SC_LTTNG_TRACEPOINT_EVENT(dup2, - TP_PROTO(sc_exit(long ret,) unsigned int oldfd, unsigned int newfd), - TP_ARGS(sc_exit(ret,) oldfd, newfd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, oldfd, oldfd)) sc_in(ctf_integer(unsigned int, newfd, newfd))) -) -#endif -#ifndef OVERRIDE_32_setreuid16 -SC_LTTNG_TRACEPOINT_EVENT(setreuid16, - TP_PROTO(sc_exit(long ret,) old_uid_t ruid, old_uid_t euid), - TP_ARGS(sc_exit(ret,) ruid, euid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(old_uid_t, ruid, ruid)) sc_inout(ctf_integer(old_uid_t, euid, euid))) -) -#endif -#ifndef OVERRIDE_32_setregid16 -SC_LTTNG_TRACEPOINT_EVENT(setregid16, - TP_PROTO(sc_exit(long ret,) old_gid_t rgid, old_gid_t egid), - TP_ARGS(sc_exit(ret,) rgid, egid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(old_gid_t, rgid, rgid)) sc_inout(ctf_integer(old_gid_t, egid, egid))) -) -#endif -#ifndef OVERRIDE_32_munmap -SC_LTTNG_TRACEPOINT_EVENT(munmap, - TP_PROTO(sc_exit(long ret,) unsigned long addr, size_t len), - TP_ARGS(sc_exit(ret,) addr, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, addr, addr)) sc_in(ctf_integer(size_t, len, len))) -) -#endif -#ifndef OVERRIDE_32_ftruncate -SC_LTTNG_TRACEPOINT_EVENT(ftruncate, - TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned long length), - TP_ARGS(sc_exit(ret,) fd, length), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned long, length, length))) -) -#endif -#ifndef OVERRIDE_32_fchmod -SC_LTTNG_TRACEPOINT_EVENT(fchmod, - TP_PROTO(sc_exit(long ret,) unsigned int fd, mode_t mode), - TP_ARGS(sc_exit(ret,) fd, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(mode_t, mode, mode))) -) -#endif -#ifndef OVERRIDE_32_getpriority -SC_LTTNG_TRACEPOINT_EVENT(getpriority, - TP_PROTO(sc_exit(long ret,) int which, int who), - TP_ARGS(sc_exit(ret,) which, who), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who))) -) -#endif -#ifndef OVERRIDE_32_bdflush -SC_LTTNG_TRACEPOINT_EVENT(bdflush, - TP_PROTO(sc_exit(long ret,) int func, long data), - TP_ARGS(sc_exit(ret,) func, data), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, func, func)) sc_inout(ctf_integer(long, data, data))) -) -#endif -#ifndef OVERRIDE_32_flock -SC_LTTNG_TRACEPOINT_EVENT(flock, - TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd), - TP_ARGS(sc_exit(ret,) fd, cmd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned int, cmd, cmd))) -) -#endif -#ifndef OVERRIDE_32_mlock -SC_LTTNG_TRACEPOINT_EVENT(mlock, - TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len), - TP_ARGS(sc_exit(ret,) start, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len))) -) -#endif -#ifndef OVERRIDE_32_munlock -SC_LTTNG_TRACEPOINT_EVENT(munlock, - TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len), - TP_ARGS(sc_exit(ret,) start, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len))) -) -#endif -#ifndef OVERRIDE_32_setreuid -SC_LTTNG_TRACEPOINT_EVENT(setreuid, - TP_PROTO(sc_exit(long ret,) uid_t ruid, uid_t euid), - TP_ARGS(sc_exit(ret,) ruid, euid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, ruid, ruid)) sc_in(ctf_integer(uid_t, euid, euid))) -) -#endif -#ifndef OVERRIDE_32_setregid -SC_LTTNG_TRACEPOINT_EVENT(setregid, - TP_PROTO(sc_exit(long ret,) gid_t rgid, gid_t egid), - TP_ARGS(sc_exit(ret,) rgid, egid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, rgid, rgid)) sc_in(ctf_integer(gid_t, egid, egid))) -) -#endif -#ifndef OVERRIDE_32_tkill -SC_LTTNG_TRACEPOINT_EVENT(tkill, - TP_PROTO(sc_exit(long ret,) pid_t pid, int sig), - TP_ARGS(sc_exit(ret,) pid, sig), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig))) -) -#endif -#ifndef OVERRIDE_32_ioprio_get -SC_LTTNG_TRACEPOINT_EVENT(ioprio_get, - TP_PROTO(sc_exit(long ret,) int which, int who), - TP_ARGS(sc_exit(ret,) which, who), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who))) -) -#endif -#ifndef OVERRIDE_32_inotify_rm_watch -SC_LTTNG_TRACEPOINT_EVENT(inotify_rm_watch, - TP_PROTO(sc_exit(long ret,) int fd, __s32 wd), - TP_ARGS(sc_exit(ret,) fd, wd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(__s32, wd, wd))) -) -#endif -#ifndef OVERRIDE_32_timerfd_create -SC_LTTNG_TRACEPOINT_EVENT(timerfd_create, - TP_PROTO(sc_exit(long ret,) int clockid, int flags), - TP_ARGS(sc_exit(ret,) clockid, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, clockid, clockid)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_eventfd2 -SC_LTTNG_TRACEPOINT_EVENT(eventfd2, - TP_PROTO(sc_exit(long ret,) unsigned int count, int flags), - TP_ARGS(sc_exit(ret,) count, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, count, count)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_fanotify_init -SC_LTTNG_TRACEPOINT_EVENT(fanotify_init, - TP_PROTO(sc_exit(long ret,) unsigned int flags, unsigned int event_f_flags), - TP_ARGS(sc_exit(ret,) flags, event_f_flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, flags, flags)) sc_in(ctf_integer(unsigned int, event_f_flags, event_f_flags))) -) -#endif -#ifndef OVERRIDE_32_setns -SC_LTTNG_TRACEPOINT_EVENT(setns, - TP_PROTO(sc_exit(long ret,) int fd, int nstype), - TP_ARGS(sc_exit(ret,) fd, nstype), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, nstype, nstype))) -) -#endif -#ifndef OVERRIDE_32_lseek -SC_LTTNG_TRACEPOINT_EVENT(lseek, - TP_PROTO(sc_exit(long ret,) unsigned int fd, off_t offset, unsigned int origin), - TP_ARGS(sc_exit(ret,) fd, offset, origin), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(off_t, offset, offset)) sc_in(ctf_integer(unsigned int, origin, origin))) -) -#endif -#ifndef OVERRIDE_32_ioctl -SC_LTTNG_TRACEPOINT_EVENT(ioctl, - TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd, unsigned long arg), - TP_ARGS(sc_exit(ret,) fd, cmd, arg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_inout(ctf_integer(unsigned long, arg, arg))) -) -#endif -#ifndef OVERRIDE_32_fcntl -SC_LTTNG_TRACEPOINT_EVENT(fcntl, - TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd, unsigned long arg), - TP_ARGS(sc_exit(ret,) fd, cmd, arg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_inout(ctf_integer(unsigned long, arg, arg))) -) -#endif -#ifndef OVERRIDE_32_fchown16 -SC_LTTNG_TRACEPOINT_EVENT(fchown16, - TP_PROTO(sc_exit(long ret,) unsigned int fd, old_uid_t user, old_gid_t group), - TP_ARGS(sc_exit(ret,) fd, user, group), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, fd, fd)) sc_inout(ctf_integer(old_uid_t, user, user)) sc_inout(ctf_integer(old_gid_t, group, group))) -) -#endif -#ifndef OVERRIDE_32_setpriority -SC_LTTNG_TRACEPOINT_EVENT(setpriority, - TP_PROTO(sc_exit(long ret,) int which, int who, int niceval), - TP_ARGS(sc_exit(ret,) which, who, niceval), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who)) sc_in(ctf_integer(int, niceval, niceval))) -) -#endif -#ifndef OVERRIDE_32_mprotect -SC_LTTNG_TRACEPOINT_EVENT(mprotect, - TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len, unsigned long prot), - TP_ARGS(sc_exit(ret,) start, len, prot), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned long, prot, prot))) -) -#endif -#ifndef OVERRIDE_32_sysfs -SC_LTTNG_TRACEPOINT_EVENT(sysfs, - TP_PROTO(sc_exit(long ret,) int option, unsigned long arg1, unsigned long arg2), - TP_ARGS(sc_exit(ret,) option, arg1, arg2), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, option, option)) sc_in(ctf_integer(unsigned long, arg1, arg1)) sc_in(ctf_integer(unsigned long, arg2, arg2))) -) -#endif -#ifndef OVERRIDE_32_msync -SC_LTTNG_TRACEPOINT_EVENT(msync, - TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len, int flags), - TP_ARGS(sc_exit(ret,) start, len, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_setresuid16 -SC_LTTNG_TRACEPOINT_EVENT(setresuid16, - TP_PROTO(sc_exit(long ret,) old_uid_t ruid, old_uid_t euid, old_uid_t suid), - TP_ARGS(sc_exit(ret,) ruid, euid, suid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(old_uid_t, ruid, ruid)) sc_inout(ctf_integer(old_uid_t, euid, euid)) sc_inout(ctf_integer(old_uid_t, suid, suid))) -) -#endif -#ifndef OVERRIDE_32_setresgid16 -SC_LTTNG_TRACEPOINT_EVENT(setresgid16, - TP_PROTO(sc_exit(long ret,) old_gid_t rgid, old_gid_t egid, old_gid_t sgid), - TP_ARGS(sc_exit(ret,) rgid, egid, sgid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(old_gid_t, rgid, rgid)) sc_inout(ctf_integer(old_gid_t, egid, egid)) sc_inout(ctf_integer(old_gid_t, sgid, sgid))) -) -#endif -#ifndef OVERRIDE_32_fchown -SC_LTTNG_TRACEPOINT_EVENT(fchown, - TP_PROTO(sc_exit(long ret,) unsigned int fd, uid_t user, gid_t group), - TP_ARGS(sc_exit(ret,) fd, user, group), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group))) -) -#endif -#ifndef OVERRIDE_32_setresuid -SC_LTTNG_TRACEPOINT_EVENT(setresuid, - TP_PROTO(sc_exit(long ret,) uid_t ruid, uid_t euid, uid_t suid), - TP_ARGS(sc_exit(ret,) ruid, euid, suid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, ruid, ruid)) sc_in(ctf_integer(uid_t, euid, euid)) sc_in(ctf_integer(uid_t, suid, suid))) -) -#endif -#ifndef OVERRIDE_32_setresgid -SC_LTTNG_TRACEPOINT_EVENT(setresgid, - TP_PROTO(sc_exit(long ret,) gid_t rgid, gid_t egid, gid_t sgid), - TP_ARGS(sc_exit(ret,) rgid, egid, sgid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, rgid, rgid)) sc_in(ctf_integer(gid_t, egid, egid)) sc_in(ctf_integer(gid_t, sgid, sgid))) -) -#endif -#ifndef OVERRIDE_32_madvise -SC_LTTNG_TRACEPOINT_EVENT(madvise, - TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len_in, int behavior), - TP_ARGS(sc_exit(ret,) start, len_in, behavior), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len_in, len_in)) sc_in(ctf_integer(int, behavior, behavior))) -) -#endif -#ifndef OVERRIDE_32_fcntl64 -SC_LTTNG_TRACEPOINT_EVENT(fcntl64, - TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd, unsigned long arg), - TP_ARGS(sc_exit(ret,) fd, cmd, arg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, fd, fd)) sc_inout(ctf_integer(unsigned int, cmd, cmd)) sc_inout(ctf_integer(unsigned long, arg, arg))) -) -#endif -#ifndef OVERRIDE_32_tgkill -SC_LTTNG_TRACEPOINT_EVENT(tgkill, - TP_PROTO(sc_exit(long ret,) pid_t tgid, pid_t pid, int sig), - TP_ARGS(sc_exit(ret,) tgid, pid, sig), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, tgid, tgid)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig))) -) -#endif -#ifndef OVERRIDE_32_ioprio_set -SC_LTTNG_TRACEPOINT_EVENT(ioprio_set, - TP_PROTO(sc_exit(long ret,) int which, int who, int ioprio), - TP_ARGS(sc_exit(ret,) which, who, ioprio), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who)) sc_in(ctf_integer(int, ioprio, ioprio))) -) -#endif -#ifndef OVERRIDE_32_dup3 -SC_LTTNG_TRACEPOINT_EVENT(dup3, - TP_PROTO(sc_exit(long ret,) unsigned int oldfd, unsigned int newfd, int flags), - TP_ARGS(sc_exit(ret,) oldfd, newfd, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, oldfd, oldfd)) sc_in(ctf_integer(unsigned int, newfd, newfd)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_ptrace -SC_LTTNG_TRACEPOINT_EVENT(ptrace, - TP_PROTO(sc_exit(long ret,) long request, long pid, unsigned long addr, unsigned long data), - TP_ARGS(sc_exit(ret,) request, pid, addr, data), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(long, request, request)) sc_in(ctf_integer(long, pid, pid)) sc_inout(ctf_integer(unsigned long, addr, addr)) sc_inout(ctf_integer(unsigned long, data, data))) -) -#endif -#ifndef OVERRIDE_32_tee -SC_LTTNG_TRACEPOINT_EVENT(tee, - TP_PROTO(sc_exit(long ret,) int fdin, int fdout, size_t len, unsigned int flags), - TP_ARGS(sc_exit(ret,) fdin, fdout, len, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fdin, fdin)) sc_in(ctf_integer(int, fdout, fdout)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_mremap -SC_LTTNG_TRACEPOINT_EVENT(mremap, - TP_PROTO(sc_exit(long ret,) unsigned long addr, unsigned long old_len, unsigned long new_len, unsigned long flags, unsigned long new_addr), - TP_ARGS(sc_exit(ret,) addr, old_len, new_len, flags, new_addr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, addr, addr)) sc_in(ctf_integer(unsigned long, old_len, old_len)) sc_in(ctf_integer(unsigned long, new_len, new_len)) sc_in(ctf_integer(unsigned long, flags, flags)) sc_in(ctf_integer(unsigned long, new_addr, new_addr))) -) -#endif -#ifndef OVERRIDE_32_prctl -SC_LTTNG_TRACEPOINT_EVENT(prctl, - TP_PROTO(sc_exit(long ret,) int option, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5), - TP_ARGS(sc_exit(ret,) option, arg2, arg3, arg4, arg5), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, option, option)) sc_inout(ctf_integer(unsigned long, arg2, arg2)) sc_in(ctf_integer(unsigned long, arg3, arg3)) sc_in(ctf_integer(unsigned long, arg4, arg4)) sc_in(ctf_integer(unsigned long, arg5, arg5))) -) -#endif -#ifndef OVERRIDE_32_remap_file_pages -SC_LTTNG_TRACEPOINT_EVENT(remap_file_pages, - TP_PROTO(sc_exit(long ret,) unsigned long start, unsigned long size, unsigned long prot, unsigned long pgoff, unsigned long flags), - TP_ARGS(sc_exit(ret,) start, size, prot, pgoff, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(unsigned long, size, size)) sc_in(ctf_integer(unsigned long, prot, prot)) sc_in(ctf_integer(unsigned long, pgoff, pgoff)) sc_in(ctf_integer(unsigned long, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_keyctl -SC_LTTNG_TRACEPOINT_EVENT(keyctl, - TP_PROTO(sc_exit(long ret,) int option, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5), - TP_ARGS(sc_exit(ret,) option, arg2, arg3, arg4, arg5), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, option, option)) sc_inout(ctf_integer(unsigned long, arg2, arg2)) sc_inout(ctf_integer(unsigned long, arg3, arg3)) sc_inout(ctf_integer(unsigned long, arg4, arg4)) sc_inout(ctf_integer(unsigned long, arg5, arg5))) -) -#endif -#ifndef OVERRIDE_32_mmap_pgoff -SC_LTTNG_TRACEPOINT_EVENT(mmap_pgoff, - TP_PROTO(sc_exit(long ret,) unsigned long addr, unsigned long len, unsigned long prot, unsigned long flags, unsigned long fd, unsigned long pgoff), - TP_ARGS(sc_exit(ret,) addr, len, prot, flags, fd, pgoff), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned long, addr, addr)) sc_inout(ctf_integer(unsigned long, len, len)) sc_inout(ctf_integer(unsigned long, prot, prot)) sc_inout(ctf_integer(unsigned long, flags, flags)) sc_inout(ctf_integer(unsigned long, fd, fd)) sc_inout(ctf_integer(unsigned long, pgoff, pgoff))) -) -#endif - -#endif /* _TRACE_SYSCALLS_INTEGERS_H */ - -/* This part must be outside protection */ -#include - -#else /* CREATE_SYSCALL_TABLE */ - -#include "x86-32-syscalls_integers_override.h" -#include "syscalls_integers_override.h" - -#ifdef SC_ENTER -#ifndef OVERRIDE_TABLE_32_restart_syscall -TRACE_SYSCALL_TABLE(syscalls_noargs, restart_syscall, 0, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getpid -TRACE_SYSCALL_TABLE(syscalls_noargs, getpid, 20, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getuid16 -TRACE_SYSCALL_TABLE(syscalls_noargs, getuid16, 24, 0) -#endif -#ifndef OVERRIDE_TABLE_32_pause -TRACE_SYSCALL_TABLE(syscalls_noargs, pause, 29, 0) -#endif -#ifndef OVERRIDE_TABLE_32_sync -TRACE_SYSCALL_TABLE(syscalls_noargs, sync, 36, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getgid16 -TRACE_SYSCALL_TABLE(syscalls_noargs, getgid16, 47, 0) -#endif -#ifndef OVERRIDE_TABLE_32_geteuid16 -TRACE_SYSCALL_TABLE(syscalls_noargs, geteuid16, 49, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getegid16 -TRACE_SYSCALL_TABLE(syscalls_noargs, getegid16, 50, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getppid -TRACE_SYSCALL_TABLE(syscalls_noargs, getppid, 64, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getpgrp -TRACE_SYSCALL_TABLE(syscalls_noargs, getpgrp, 65, 0) -#endif -#ifndef OVERRIDE_TABLE_32_setsid -TRACE_SYSCALL_TABLE(syscalls_noargs, setsid, 66, 0) -#endif -#ifndef OVERRIDE_TABLE_32_sgetmask -TRACE_SYSCALL_TABLE(syscalls_noargs, sgetmask, 68, 0) -#endif -#ifndef OVERRIDE_TABLE_32_vhangup -TRACE_SYSCALL_TABLE(syscalls_noargs, vhangup, 111, 0) -#endif -#ifndef OVERRIDE_TABLE_32_munlockall -TRACE_SYSCALL_TABLE(syscalls_noargs, munlockall, 153, 0) -#endif -#ifndef OVERRIDE_TABLE_32_sched_yield -TRACE_SYSCALL_TABLE(syscalls_noargs, sched_yield, 158, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getuid -TRACE_SYSCALL_TABLE(syscalls_noargs, getuid, 199, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getgid -TRACE_SYSCALL_TABLE(syscalls_noargs, getgid, 200, 0) -#endif -#ifndef OVERRIDE_TABLE_32_geteuid -TRACE_SYSCALL_TABLE(syscalls_noargs, geteuid, 201, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getegid -TRACE_SYSCALL_TABLE(syscalls_noargs, getegid, 202, 0) -#endif -#ifndef OVERRIDE_TABLE_32_gettid -TRACE_SYSCALL_TABLE(syscalls_noargs, gettid, 224, 0) -#endif -#ifndef OVERRIDE_TABLE_32_inotify_init -TRACE_SYSCALL_TABLE(syscalls_noargs, inotify_init, 291, 0) -#endif -#else /* #ifdef SC_ENTER */ -#ifndef OVERRIDE_TABLE_32_restart_syscall -TRACE_SYSCALL_TABLE(restart_syscall, restart_syscall, 0, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getpid -TRACE_SYSCALL_TABLE(getpid, getpid, 20, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getuid16 -TRACE_SYSCALL_TABLE(getuid16, getuid16, 24, 0) -#endif -#ifndef OVERRIDE_TABLE_32_pause -TRACE_SYSCALL_TABLE(pause, pause, 29, 0) -#endif -#ifndef OVERRIDE_TABLE_32_sync -TRACE_SYSCALL_TABLE(sync, sync, 36, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getgid16 -TRACE_SYSCALL_TABLE(getgid16, getgid16, 47, 0) -#endif -#ifndef OVERRIDE_TABLE_32_geteuid16 -TRACE_SYSCALL_TABLE(geteuid16, geteuid16, 49, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getegid16 -TRACE_SYSCALL_TABLE(getegid16, getegid16, 50, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getppid -TRACE_SYSCALL_TABLE(getppid, getppid, 64, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getpgrp -TRACE_SYSCALL_TABLE(getpgrp, getpgrp, 65, 0) -#endif -#ifndef OVERRIDE_TABLE_32_setsid -TRACE_SYSCALL_TABLE(setsid, setsid, 66, 0) -#endif -#ifndef OVERRIDE_TABLE_32_sgetmask -TRACE_SYSCALL_TABLE(sgetmask, sgetmask, 68, 0) -#endif -#ifndef OVERRIDE_TABLE_32_vhangup -TRACE_SYSCALL_TABLE(vhangup, vhangup, 111, 0) -#endif -#ifndef OVERRIDE_TABLE_32_munlockall -TRACE_SYSCALL_TABLE(munlockall, munlockall, 153, 0) -#endif -#ifndef OVERRIDE_TABLE_32_sched_yield -TRACE_SYSCALL_TABLE(sched_yield, sched_yield, 158, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getuid -TRACE_SYSCALL_TABLE(getuid, getuid, 199, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getgid -TRACE_SYSCALL_TABLE(getgid, getgid, 200, 0) -#endif -#ifndef OVERRIDE_TABLE_32_geteuid -TRACE_SYSCALL_TABLE(geteuid, geteuid, 201, 0) -#endif -#ifndef OVERRIDE_TABLE_32_getegid -TRACE_SYSCALL_TABLE(getegid, getegid, 202, 0) -#endif -#ifndef OVERRIDE_TABLE_32_gettid -TRACE_SYSCALL_TABLE(gettid, gettid, 224, 0) -#endif -#ifndef OVERRIDE_TABLE_32_inotify_init -TRACE_SYSCALL_TABLE(inotify_init, inotify_init, 291, 0) -#endif -#endif /* else #ifdef SC_ENTER */ -#ifndef OVERRIDE_TABLE_32_exit -TRACE_SYSCALL_TABLE(exit, exit, 1, 1) -#endif -#ifndef OVERRIDE_TABLE_32_close -TRACE_SYSCALL_TABLE(close, close, 6, 1) -#endif -#ifndef OVERRIDE_TABLE_32_lseek -TRACE_SYSCALL_TABLE(lseek, lseek, 19, 3) -#endif -#ifndef OVERRIDE_TABLE_32_setuid16 -TRACE_SYSCALL_TABLE(setuid16, setuid16, 23, 1) -#endif -#ifndef OVERRIDE_TABLE_32_ptrace -TRACE_SYSCALL_TABLE(ptrace, ptrace, 26, 4) -#endif -#ifndef OVERRIDE_TABLE_32_alarm -TRACE_SYSCALL_TABLE(alarm, alarm, 27, 1) -#endif -#ifndef OVERRIDE_TABLE_32_nice -TRACE_SYSCALL_TABLE(nice, nice, 34, 1) -#endif -#ifndef OVERRIDE_TABLE_32_kill -TRACE_SYSCALL_TABLE(kill, kill, 37, 2) -#endif -#ifndef OVERRIDE_TABLE_32_dup -TRACE_SYSCALL_TABLE(dup, dup, 41, 1) -#endif -#ifndef OVERRIDE_TABLE_32_brk -TRACE_SYSCALL_TABLE(brk, brk, 45, 1) -#endif -#ifndef OVERRIDE_TABLE_32_setgid16 -TRACE_SYSCALL_TABLE(setgid16, setgid16, 46, 1) -#endif -#ifndef OVERRIDE_TABLE_32_signal -TRACE_SYSCALL_TABLE(signal, signal, 48, 2) -#endif -#ifndef OVERRIDE_TABLE_32_ioctl -TRACE_SYSCALL_TABLE(ioctl, ioctl, 54, 3) -#endif -#ifndef OVERRIDE_TABLE_32_fcntl -TRACE_SYSCALL_TABLE(fcntl, fcntl, 55, 3) -#endif -#ifndef OVERRIDE_TABLE_32_setpgid -TRACE_SYSCALL_TABLE(setpgid, setpgid, 57, 2) -#endif -#ifndef OVERRIDE_TABLE_32_umask -TRACE_SYSCALL_TABLE(umask, umask, 60, 1) -#endif -#ifndef OVERRIDE_TABLE_32_dup2 -TRACE_SYSCALL_TABLE(dup2, dup2, 63, 2) -#endif -#ifndef OVERRIDE_TABLE_32_ssetmask -TRACE_SYSCALL_TABLE(ssetmask, ssetmask, 69, 1) -#endif -#ifndef OVERRIDE_TABLE_32_setreuid16 -TRACE_SYSCALL_TABLE(setreuid16, setreuid16, 70, 2) -#endif -#ifndef OVERRIDE_TABLE_32_setregid16 -TRACE_SYSCALL_TABLE(setregid16, setregid16, 71, 2) -#endif -#ifndef OVERRIDE_TABLE_32_munmap -TRACE_SYSCALL_TABLE(munmap, munmap, 91, 2) -#endif -#ifndef OVERRIDE_TABLE_32_ftruncate -TRACE_SYSCALL_TABLE(ftruncate, ftruncate, 93, 2) -#endif -#ifndef OVERRIDE_TABLE_32_fchmod -TRACE_SYSCALL_TABLE(fchmod, fchmod, 94, 2) -#endif -#ifndef OVERRIDE_TABLE_32_fchown16 -TRACE_SYSCALL_TABLE(fchown16, fchown16, 95, 3) -#endif -#ifndef OVERRIDE_TABLE_32_getpriority -TRACE_SYSCALL_TABLE(getpriority, getpriority, 96, 2) -#endif -#ifndef OVERRIDE_TABLE_32_setpriority -TRACE_SYSCALL_TABLE(setpriority, setpriority, 97, 3) -#endif -#ifndef OVERRIDE_TABLE_32_fsync -TRACE_SYSCALL_TABLE(fsync, fsync, 118, 1) -#endif -#ifndef OVERRIDE_TABLE_32_mprotect -TRACE_SYSCALL_TABLE(mprotect, mprotect, 125, 3) -#endif -#ifndef OVERRIDE_TABLE_32_getpgid -TRACE_SYSCALL_TABLE(getpgid, getpgid, 132, 1) -#endif -#ifndef OVERRIDE_TABLE_32_fchdir -TRACE_SYSCALL_TABLE(fchdir, fchdir, 133, 1) -#endif -#ifndef OVERRIDE_TABLE_32_bdflush -TRACE_SYSCALL_TABLE(bdflush, bdflush, 134, 2) -#endif -#ifndef OVERRIDE_TABLE_32_sysfs -TRACE_SYSCALL_TABLE(sysfs, sysfs, 135, 3) -#endif -#ifndef OVERRIDE_TABLE_32_personality -TRACE_SYSCALL_TABLE(personality, personality, 136, 1) -#endif -#ifndef OVERRIDE_TABLE_32_setfsuid16 -TRACE_SYSCALL_TABLE(setfsuid16, setfsuid16, 138, 1) -#endif -#ifndef OVERRIDE_TABLE_32_setfsgid16 -TRACE_SYSCALL_TABLE(setfsgid16, setfsgid16, 139, 1) -#endif -#ifndef OVERRIDE_TABLE_32_flock -TRACE_SYSCALL_TABLE(flock, flock, 143, 2) -#endif -#ifndef OVERRIDE_TABLE_32_msync -TRACE_SYSCALL_TABLE(msync, msync, 144, 3) -#endif -#ifndef OVERRIDE_TABLE_32_getsid -TRACE_SYSCALL_TABLE(getsid, getsid, 147, 1) -#endif -#ifndef OVERRIDE_TABLE_32_fdatasync -TRACE_SYSCALL_TABLE(fdatasync, fdatasync, 148, 1) -#endif -#ifndef OVERRIDE_TABLE_32_mlock -TRACE_SYSCALL_TABLE(mlock, mlock, 150, 2) -#endif -#ifndef OVERRIDE_TABLE_32_munlock -TRACE_SYSCALL_TABLE(munlock, munlock, 151, 2) -#endif -#ifndef OVERRIDE_TABLE_32_mlockall -TRACE_SYSCALL_TABLE(mlockall, mlockall, 152, 1) -#endif -#ifndef OVERRIDE_TABLE_32_sched_getscheduler -TRACE_SYSCALL_TABLE(sched_getscheduler, sched_getscheduler, 157, 1) -#endif -#ifndef OVERRIDE_TABLE_32_sched_get_priority_max -TRACE_SYSCALL_TABLE(sched_get_priority_max, sched_get_priority_max, 159, 1) -#endif -#ifndef OVERRIDE_TABLE_32_sched_get_priority_min -TRACE_SYSCALL_TABLE(sched_get_priority_min, sched_get_priority_min, 160, 1) -#endif -#ifndef OVERRIDE_TABLE_32_mremap -TRACE_SYSCALL_TABLE(mremap, mremap, 163, 5) -#endif -#ifndef OVERRIDE_TABLE_32_setresuid16 -TRACE_SYSCALL_TABLE(setresuid16, setresuid16, 164, 3) -#endif -#ifndef OVERRIDE_TABLE_32_setresgid16 -TRACE_SYSCALL_TABLE(setresgid16, setresgid16, 170, 3) -#endif -#ifndef OVERRIDE_TABLE_32_prctl -TRACE_SYSCALL_TABLE(prctl, prctl, 172, 5) -#endif -#ifndef OVERRIDE_TABLE_32_mmap_pgoff -TRACE_SYSCALL_TABLE(mmap_pgoff, mmap_pgoff, 192, 6) -#endif -#ifndef OVERRIDE_TABLE_32_setreuid -TRACE_SYSCALL_TABLE(setreuid, setreuid, 203, 2) -#endif -#ifndef OVERRIDE_TABLE_32_setregid -TRACE_SYSCALL_TABLE(setregid, setregid, 204, 2) -#endif -#ifndef OVERRIDE_TABLE_32_fchown -TRACE_SYSCALL_TABLE(fchown, fchown, 207, 3) -#endif -#ifndef OVERRIDE_TABLE_32_setresuid -TRACE_SYSCALL_TABLE(setresuid, setresuid, 208, 3) -#endif -#ifndef OVERRIDE_TABLE_32_setresgid -TRACE_SYSCALL_TABLE(setresgid, setresgid, 210, 3) -#endif -#ifndef OVERRIDE_TABLE_32_setuid -TRACE_SYSCALL_TABLE(setuid, setuid, 213, 1) -#endif -#ifndef OVERRIDE_TABLE_32_setgid -TRACE_SYSCALL_TABLE(setgid, setgid, 214, 1) -#endif -#ifndef OVERRIDE_TABLE_32_setfsuid -TRACE_SYSCALL_TABLE(setfsuid, setfsuid, 215, 1) -#endif -#ifndef OVERRIDE_TABLE_32_setfsgid -TRACE_SYSCALL_TABLE(setfsgid, setfsgid, 216, 1) -#endif -#ifndef OVERRIDE_TABLE_32_madvise -TRACE_SYSCALL_TABLE(madvise, madvise, 219, 3) -#endif -#ifndef OVERRIDE_TABLE_32_fcntl64 -TRACE_SYSCALL_TABLE(fcntl64, fcntl64, 221, 3) -#endif -#ifndef OVERRIDE_TABLE_32_tkill -TRACE_SYSCALL_TABLE(tkill, tkill, 238, 2) -#endif -#ifndef OVERRIDE_TABLE_32_io_destroy -TRACE_SYSCALL_TABLE(io_destroy, io_destroy, 246, 1) -#endif -#ifndef OVERRIDE_TABLE_32_exit_group -TRACE_SYSCALL_TABLE(exit_group, exit_group, 252, 1) -#endif -#ifndef OVERRIDE_TABLE_32_epoll_create -TRACE_SYSCALL_TABLE(epoll_create, epoll_create, 254, 1) -#endif -#ifndef OVERRIDE_TABLE_32_remap_file_pages -TRACE_SYSCALL_TABLE(remap_file_pages, remap_file_pages, 257, 5) -#endif -#ifndef OVERRIDE_TABLE_32_timer_getoverrun -TRACE_SYSCALL_TABLE(timer_getoverrun, timer_getoverrun, 262, 1) -#endif -#ifndef OVERRIDE_TABLE_32_timer_delete -TRACE_SYSCALL_TABLE(timer_delete, timer_delete, 263, 1) -#endif -#ifndef OVERRIDE_TABLE_32_tgkill -TRACE_SYSCALL_TABLE(tgkill, tgkill, 270, 3) -#endif -#ifndef OVERRIDE_TABLE_32_keyctl -TRACE_SYSCALL_TABLE(keyctl, keyctl, 288, 5) -#endif -#ifndef OVERRIDE_TABLE_32_ioprio_set -TRACE_SYSCALL_TABLE(ioprio_set, ioprio_set, 289, 3) -#endif -#ifndef OVERRIDE_TABLE_32_ioprio_get -TRACE_SYSCALL_TABLE(ioprio_get, ioprio_get, 290, 2) -#endif -#ifndef OVERRIDE_TABLE_32_inotify_rm_watch -TRACE_SYSCALL_TABLE(inotify_rm_watch, inotify_rm_watch, 293, 2) -#endif -#ifndef OVERRIDE_TABLE_32_unshare -TRACE_SYSCALL_TABLE(unshare, unshare, 310, 1) -#endif -#ifndef OVERRIDE_TABLE_32_tee -TRACE_SYSCALL_TABLE(tee, tee, 315, 4) -#endif -#ifndef OVERRIDE_TABLE_32_timerfd_create -TRACE_SYSCALL_TABLE(timerfd_create, timerfd_create, 322, 2) -#endif -#ifndef OVERRIDE_TABLE_32_eventfd -TRACE_SYSCALL_TABLE(eventfd, eventfd, 323, 1) -#endif -#ifndef OVERRIDE_TABLE_32_eventfd2 -TRACE_SYSCALL_TABLE(eventfd2, eventfd2, 328, 2) -#endif -#ifndef OVERRIDE_TABLE_32_epoll_create1 -TRACE_SYSCALL_TABLE(epoll_create1, epoll_create1, 329, 1) -#endif -#ifndef OVERRIDE_TABLE_32_dup3 -TRACE_SYSCALL_TABLE(dup3, dup3, 330, 3) -#endif -#ifndef OVERRIDE_TABLE_32_inotify_init1 -TRACE_SYSCALL_TABLE(inotify_init1, inotify_init1, 332, 1) -#endif -#ifndef OVERRIDE_TABLE_32_fanotify_init -TRACE_SYSCALL_TABLE(fanotify_init, fanotify_init, 338, 2) -#endif -#ifndef OVERRIDE_TABLE_32_syncfs -TRACE_SYSCALL_TABLE(syncfs, syncfs, 344, 1) -#endif -#ifndef OVERRIDE_TABLE_32_setns -TRACE_SYSCALL_TABLE(setns, setns, 346, 2) -#endif - -#endif /* CREATE_SYSCALL_TABLE */ diff --git a/instrumentation/syscalls/headers/x86-32-syscalls_integers_override.h b/instrumentation/syscalls/headers/x86-32-syscalls_integers_override.h deleted file mode 100644 index 3d933ad3..00000000 --- a/instrumentation/syscalls/headers/x86-32-syscalls_integers_override.h +++ /dev/null @@ -1,87 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ - -#ifndef CONFIG_UID16 - -#define OVERRIDE_32_getuid16 -#define OVERRIDE_32_getgid16 -#define OVERRIDE_32_geteuid16 -#define OVERRIDE_32_getegid16 -#define OVERRIDE_32_setuid16 -#define OVERRIDE_32_setgid16 -#define OVERRIDE_32_setfsuid16 -#define OVERRIDE_32_setfsgid16 -#define OVERRIDE_32_setreuid16 -#define OVERRIDE_32_setregid16 -#define OVERRIDE_32_fchown16 -#define OVERRIDE_32_setresuid16 -#define OVERRIDE_32_setresgid16 - -#define OVERRIDE_TABLE_32_getuid16 -#define OVERRIDE_TABLE_32_getgid16 -#define OVERRIDE_TABLE_32_geteuid16 -#define OVERRIDE_TABLE_32_getegid16 -#define OVERRIDE_TABLE_32_setuid16 -#define OVERRIDE_TABLE_32_setgid16 -#define OVERRIDE_TABLE_32_setreuid16 -#define OVERRIDE_TABLE_32_setregid16 -#define OVERRIDE_TABLE_32_fchown16 -#define OVERRIDE_TABLE_32_setfsuid16 -#define OVERRIDE_TABLE_32_setfsgid16 -#define OVERRIDE_TABLE_32_setresuid16 -#define OVERRIDE_TABLE_32_setresgid16 - -#endif - -#ifndef CREATE_SYSCALL_TABLE - -/* mmap_pgoff is kernel internal. mmap2 is exposed in unistd.h. */ -#define OVERRIDE_32_mmap_pgoff -#define OVERRIDE_32_mmap2 -SC_LTTNG_TRACEPOINT_EVENT(mmap2, - TP_PROTO(sc_exit(unsigned long ret,) - unsigned long addr, unsigned long len, - unsigned long prot, unsigned long flags, - unsigned long fd, unsigned long pgoff), - TP_ARGS(sc_exit(ret,) addr, len, prot, flags, fd, pgoff), - TP_FIELDS(sc_exit(ctf_integer_hex(unsigned long, ret, ret)) - sc_in(ctf_integer_hex(unsigned long, addr, addr)) - sc_in(ctf_integer(size_t, len, len)) - sc_in(ctf_integer(int, prot, prot)) - sc_in(ctf_integer(int, flags, flags)) - sc_in(ctf_integer(int, fd, fd)) - sc_in(ctf_integer(off_t, pgoff, pgoff)) - ) -) - -#define OVERRIDE_32_sync_file_range -SC_LTTNG_TRACEPOINT_EVENT(sync_file_range, - TP_PROTO(sc_exit(long ret,) int fd, - int32_t offset_low, int32_t offset_high, - int32_t nbytes_low, int32_t nbytes_high, - unsigned int flags), - TP_ARGS(sc_exit(ret,) fd, offset_low, offset_high, - nbytes_low, nbytes_high, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) - sc_in(ctf_integer(int, fd, fd)) - sc_in(ctf_integer(loff_t, offset, - ((loff_t) offset_high << 32) | offset_low)) - sc_in(ctf_integer(loff_t, nbytes, - ((loff_t) nbytes_high << 32) | nbytes_low)) - sc_in(ctf_integer(unsigned int, flags, flags)) - ) -) - -#else /* #ifndef CREATE_SYSCALL_TABLE */ - -#define OVERRIDE_TABLE_32_mmap -TRACE_SYSCALL_TABLE(mmap, mmap, 90, 6) - -/* mmap_pgoff is kernel internal. mmap2 is exposed in unistd.h. */ -#define OVERRIDE_TABLE_32_mmap_pgoff -#define OVERRIDE_TABLE_32_mmap2 -TRACE_SYSCALL_TABLE(mmap2, mmap2, 192, 6) - -#define OVERRIDE_TABLE_32_sync_file_range -TRACE_SYSCALL_TABLE(sync_file_range, sync_file_range, 314, 6) - -#endif /* #else #ifndef CREATE_SYSCALL_TABLE */ diff --git a/instrumentation/syscalls/headers/x86-32-syscalls_pointers.h b/instrumentation/syscalls/headers/x86-32-syscalls_pointers.h deleted file mode 100644 index da15bfd1..00000000 --- a/instrumentation/syscalls/headers/x86-32-syscalls_pointers.h +++ /dev/null @@ -1,1869 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ - -/* THIS FILE IS AUTO-GENERATED. DO NOT EDIT */ - -/* Generated from x86-32-syscalls 3.1.0-rc6 */ - -#ifndef CREATE_SYSCALL_TABLE - -#if !defined(_TRACE_SYSCALLS_POINTERS_H) || defined(TRACE_HEADER_MULTI_READ) -#define _TRACE_SYSCALLS_POINTERS_H - -#include -#include -#include "x86-32-syscalls_pointers_override.h" -#include "syscalls_pointers_override.h" - -#ifndef OVERRIDE_32_unlink -SC_LTTNG_TRACEPOINT_EVENT(unlink, - TP_PROTO(sc_exit(long ret,) const char * pathname), - TP_ARGS(sc_exit(ret,) pathname), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname))) -) -#endif -#ifndef OVERRIDE_32_chdir -SC_LTTNG_TRACEPOINT_EVENT(chdir, - TP_PROTO(sc_exit(long ret,) const char * filename), - TP_ARGS(sc_exit(ret,) filename), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename))) -) -#endif -#ifndef OVERRIDE_32_time -SC_LTTNG_TRACEPOINT_EVENT(time, - TP_PROTO(sc_exit(long ret,) time_t * tloc), - TP_ARGS(sc_exit(ret,) tloc), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(time_t *, tloc, tloc))) -) -#endif -#ifndef OVERRIDE_32_oldumount -SC_LTTNG_TRACEPOINT_EVENT(oldumount, - TP_PROTO(sc_exit(long ret,) char * name), - TP_ARGS(sc_exit(ret,) name), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(name, name))) -) -#endif -#ifndef OVERRIDE_32_stime -SC_LTTNG_TRACEPOINT_EVENT(stime, - TP_PROTO(sc_exit(long ret,) time_t * tptr), - TP_ARGS(sc_exit(ret,) tptr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(time_t *, tptr, tptr))) -) -#endif -#ifndef OVERRIDE_32_rmdir -SC_LTTNG_TRACEPOINT_EVENT(rmdir, - TP_PROTO(sc_exit(long ret,) const char * pathname), - TP_ARGS(sc_exit(ret,) pathname), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname))) -) -#endif -#ifndef OVERRIDE_32_pipe -SC_LTTNG_TRACEPOINT_EVENT(pipe, - TP_PROTO(sc_exit(long ret,) int * fildes), - TP_ARGS(sc_exit(ret,) fildes), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(int *, fildes, fildes))) -) -#endif -#ifndef OVERRIDE_32_times -SC_LTTNG_TRACEPOINT_EVENT(times, - TP_PROTO(sc_exit(long ret,) struct tms * tbuf), - TP_ARGS(sc_exit(ret,) tbuf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct tms *, tbuf, tbuf))) -) -#endif -#ifndef OVERRIDE_32_acct -SC_LTTNG_TRACEPOINT_EVENT(acct, - TP_PROTO(sc_exit(long ret,) const char * name), - TP_ARGS(sc_exit(ret,) name), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name))) -) -#endif -#ifndef OVERRIDE_32_olduname -SC_LTTNG_TRACEPOINT_EVENT(olduname, - TP_PROTO(sc_exit(long ret,) struct oldold_utsname * name), - TP_ARGS(sc_exit(ret,) name), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct oldold_utsname *, name, name))) -) -#endif -#ifndef OVERRIDE_32_chroot -SC_LTTNG_TRACEPOINT_EVENT(chroot, - TP_PROTO(sc_exit(long ret,) const char * filename), - TP_ARGS(sc_exit(ret,) filename), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename))) -) -#endif -#ifndef OVERRIDE_32_sigpending -SC_LTTNG_TRACEPOINT_EVENT(sigpending, - TP_PROTO(sc_exit(long ret,) old_sigset_t * set), - TP_ARGS(sc_exit(ret,) set), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(old_sigset_t *, set, set))) -) -#endif -#ifndef OVERRIDE_32_old_select -SC_LTTNG_TRACEPOINT_EVENT(old_select, - TP_PROTO(sc_exit(long ret,) struct sel_arg_struct * arg), - TP_ARGS(sc_exit(ret,) arg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct sel_arg_struct *, arg, arg))) -) -#endif -#ifndef OVERRIDE_32_uselib -SC_LTTNG_TRACEPOINT_EVENT(uselib, - TP_PROTO(sc_exit(long ret,) const char * library), - TP_ARGS(sc_exit(ret,) library), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(const char *, library, library))) -) -#endif -#ifndef OVERRIDE_32_old_mmap -SC_LTTNG_TRACEPOINT_EVENT(old_mmap, - TP_PROTO(sc_exit(long ret,) struct mmap_arg_struct * arg), - TP_ARGS(sc_exit(ret,) arg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct mmap_arg_struct *, arg, arg))) -) -#endif -#ifndef OVERRIDE_32_uname -SC_LTTNG_TRACEPOINT_EVENT(uname, - TP_PROTO(sc_exit(long ret,) struct old_utsname * name), - TP_ARGS(sc_exit(ret,) name), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct old_utsname *, name, name))) -) -#endif -#ifndef OVERRIDE_32_swapoff -SC_LTTNG_TRACEPOINT_EVENT(swapoff, - TP_PROTO(sc_exit(long ret,) const char * specialfile), - TP_ARGS(sc_exit(ret,) specialfile), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(specialfile, specialfile))) -) -#endif -#ifndef OVERRIDE_32_sysinfo -SC_LTTNG_TRACEPOINT_EVENT(sysinfo, - TP_PROTO(sc_exit(long ret,) struct sysinfo * info), - TP_ARGS(sc_exit(ret,) info), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct sysinfo *, info, info))) -) -#endif -#ifndef OVERRIDE_32_newuname -SC_LTTNG_TRACEPOINT_EVENT(newuname, - TP_PROTO(sc_exit(long ret,) struct new_utsname * name), - TP_ARGS(sc_exit(ret,) name), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct new_utsname *, name, name))) -) -#endif -#ifndef OVERRIDE_32_adjtimex -SC_LTTNG_TRACEPOINT_EVENT(adjtimex, - TP_PROTO(sc_exit(long ret,) struct timex * txc_p), - TP_ARGS(sc_exit(ret,) txc_p), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct timex *, txc_p, txc_p))) -) -#endif -#ifndef OVERRIDE_32_sysctl -SC_LTTNG_TRACEPOINT_EVENT(sysctl, - TP_PROTO(sc_exit(long ret,) struct __sysctl_args * args), - TP_ARGS(sc_exit(ret,) args), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct __sysctl_args *, args, args))) -) -#endif -#ifndef OVERRIDE_32_set_tid_address -SC_LTTNG_TRACEPOINT_EVENT(set_tid_address, - TP_PROTO(sc_exit(long ret,) int * tidptr), - TP_ARGS(sc_exit(ret,) tidptr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int *, tidptr, tidptr))) -) -#endif -#ifndef OVERRIDE_32_mq_unlink -SC_LTTNG_TRACEPOINT_EVENT(mq_unlink, - TP_PROTO(sc_exit(long ret,) const char * u_name), - TP_ARGS(sc_exit(ret,) u_name), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(u_name, u_name))) -) -#endif -#ifndef OVERRIDE_32_creat -SC_LTTNG_TRACEPOINT_EVENT(creat, - TP_PROTO(sc_exit(long ret,) const char * pathname, int mode), - TP_ARGS(sc_exit(ret,) pathname, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(int, mode, mode))) -) -#endif -#ifndef OVERRIDE_32_link -SC_LTTNG_TRACEPOINT_EVENT(link, - TP_PROTO(sc_exit(long ret,) const char * oldname, const char * newname), - TP_ARGS(sc_exit(ret,) oldname, newname), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_user_string(newname, newname))) -) -#endif -#ifndef OVERRIDE_32_chmod -SC_LTTNG_TRACEPOINT_EVENT(chmod, - TP_PROTO(sc_exit(long ret,) const char * filename, mode_t mode), - TP_ARGS(sc_exit(ret,) filename, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(mode_t, mode, mode))) -) -#endif -#ifndef OVERRIDE_32_stat -SC_LTTNG_TRACEPOINT_EVENT(stat, - TP_PROTO(sc_exit(long ret,) const char * filename, struct __old_kernel_stat * statbuf), - TP_ARGS(sc_exit(ret,) filename, statbuf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(filename, filename)) sc_inout(ctf_integer(struct __old_kernel_stat *, statbuf, statbuf))) -) -#endif -#ifndef OVERRIDE_32_fstat -SC_LTTNG_TRACEPOINT_EVENT(fstat, - TP_PROTO(sc_exit(long ret,) unsigned int fd, struct __old_kernel_stat * statbuf), - TP_ARGS(sc_exit(ret,) fd, statbuf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, fd, fd)) sc_inout(ctf_integer(struct __old_kernel_stat *, statbuf, statbuf))) -) -#endif -#ifndef OVERRIDE_32_utime -SC_LTTNG_TRACEPOINT_EVENT(utime, - TP_PROTO(sc_exit(long ret,) char * filename, struct utimbuf * times), - TP_ARGS(sc_exit(ret,) filename, times), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(struct utimbuf *, times, times))) -) -#endif -#ifndef OVERRIDE_32_access -SC_LTTNG_TRACEPOINT_EVENT(access, - TP_PROTO(sc_exit(long ret,) const char * filename, int mode), - TP_ARGS(sc_exit(ret,) filename, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, mode, mode))) -) -#endif -#ifndef OVERRIDE_32_rename -SC_LTTNG_TRACEPOINT_EVENT(rename, - TP_PROTO(sc_exit(long ret,) const char * oldname, const char * newname), - TP_ARGS(sc_exit(ret,) oldname, newname), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_user_string(newname, newname))) -) -#endif -#ifndef OVERRIDE_32_mkdir -SC_LTTNG_TRACEPOINT_EVENT(mkdir, - TP_PROTO(sc_exit(long ret,) const char * pathname, int mode), - TP_ARGS(sc_exit(ret,) pathname, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(int, mode, mode))) -) -#endif -#ifndef OVERRIDE_32_umount -SC_LTTNG_TRACEPOINT_EVENT(umount, - TP_PROTO(sc_exit(long ret,) char * name, int flags), - TP_ARGS(sc_exit(ret,) name, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_ustat -SC_LTTNG_TRACEPOINT_EVENT(ustat, - TP_PROTO(sc_exit(long ret,) unsigned dev, struct ustat * ubuf), - TP_ARGS(sc_exit(ret,) dev, ubuf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned, dev, dev)) sc_out(ctf_integer(struct ustat *, ubuf, ubuf))) -) -#endif -#ifndef OVERRIDE_32_sethostname -SC_LTTNG_TRACEPOINT_EVENT(sethostname, - TP_PROTO(sc_exit(long ret,) char * name, int len), - TP_ARGS(sc_exit(ret,) name, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(int, len, len))) -) -#endif -#ifndef OVERRIDE_32_setrlimit -SC_LTTNG_TRACEPOINT_EVENT(setrlimit, - TP_PROTO(sc_exit(long ret,) unsigned int resource, struct rlimit * rlim), - TP_ARGS(sc_exit(ret,) resource, rlim), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, resource, resource)) sc_in(ctf_integer(struct rlimit *, rlim, rlim))) -) -#endif -#ifndef OVERRIDE_32_old_getrlimit -SC_LTTNG_TRACEPOINT_EVENT(old_getrlimit, - TP_PROTO(sc_exit(long ret,) unsigned int resource, struct rlimit * rlim), - TP_ARGS(sc_exit(ret,) resource, rlim), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, resource, resource)) sc_inout(ctf_integer(struct rlimit *, rlim, rlim))) -) -#endif -#ifndef OVERRIDE_32_getrusage -SC_LTTNG_TRACEPOINT_EVENT(getrusage, - TP_PROTO(sc_exit(long ret,) int who, struct rusage * ru), - TP_ARGS(sc_exit(ret,) who, ru), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, who, who)) sc_out(ctf_integer(struct rusage *, ru, ru))) -) -#endif -#ifndef OVERRIDE_32_gettimeofday -SC_LTTNG_TRACEPOINT_EVENT(gettimeofday, - TP_PROTO(sc_exit(long ret,) struct timeval * tv, struct timezone * tz), - TP_ARGS(sc_exit(ret,) tv, tz), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct timeval *, tv, tv)) sc_out(ctf_integer(struct timezone *, tz, tz))) -) -#endif -#ifndef OVERRIDE_32_settimeofday -SC_LTTNG_TRACEPOINT_EVENT(settimeofday, - TP_PROTO(sc_exit(long ret,) struct timeval * tv, struct timezone * tz), - TP_ARGS(sc_exit(ret,) tv, tz), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct timeval *, tv, tv)) sc_in(ctf_integer(struct timezone *, tz, tz))) -) -#endif -#ifndef OVERRIDE_32_getgroups16 -SC_LTTNG_TRACEPOINT_EVENT(getgroups16, - TP_PROTO(sc_exit(long ret,) int gidsetsize, old_gid_t * grouplist), - TP_ARGS(sc_exit(ret,) gidsetsize, grouplist), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, gidsetsize, gidsetsize)) sc_inout(ctf_integer(old_gid_t *, grouplist, grouplist))) -) -#endif -#ifndef OVERRIDE_32_setgroups16 -SC_LTTNG_TRACEPOINT_EVENT(setgroups16, - TP_PROTO(sc_exit(long ret,) int gidsetsize, old_gid_t * grouplist), - TP_ARGS(sc_exit(ret,) gidsetsize, grouplist), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, gidsetsize, gidsetsize)) sc_inout(ctf_integer(old_gid_t *, grouplist, grouplist))) -) -#endif -#ifndef OVERRIDE_32_symlink -SC_LTTNG_TRACEPOINT_EVENT(symlink, - TP_PROTO(sc_exit(long ret,) const char * oldname, const char * newname), - TP_ARGS(sc_exit(ret,) oldname, newname), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_user_string(newname, newname))) -) -#endif -#ifndef OVERRIDE_32_lstat -SC_LTTNG_TRACEPOINT_EVENT(lstat, - TP_PROTO(sc_exit(long ret,) const char * filename, struct __old_kernel_stat * statbuf), - TP_ARGS(sc_exit(ret,) filename, statbuf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(filename, filename)) sc_inout(ctf_integer(struct __old_kernel_stat *, statbuf, statbuf))) -) -#endif -#ifndef OVERRIDE_32_swapon -SC_LTTNG_TRACEPOINT_EVENT(swapon, - TP_PROTO(sc_exit(long ret,) const char * specialfile, int swap_flags), - TP_ARGS(sc_exit(ret,) specialfile, swap_flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(specialfile, specialfile)) sc_in(ctf_integer(int, swap_flags, swap_flags))) -) -#endif -#ifndef OVERRIDE_32_truncate -SC_LTTNG_TRACEPOINT_EVENT(truncate, - TP_PROTO(sc_exit(long ret,) const char * path, long length), - TP_ARGS(sc_exit(ret,) path, length), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(path, path)) sc_in(ctf_integer(long, length, length))) -) -#endif -#ifndef OVERRIDE_32_statfs -SC_LTTNG_TRACEPOINT_EVENT(statfs, - TP_PROTO(sc_exit(long ret,) const char * pathname, struct statfs * buf), - TP_ARGS(sc_exit(ret,) pathname, buf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(struct statfs *, buf, buf))) -) -#endif -#ifndef OVERRIDE_32_fstatfs -SC_LTTNG_TRACEPOINT_EVENT(fstatfs, - TP_PROTO(sc_exit(long ret,) unsigned int fd, struct statfs * buf), - TP_ARGS(sc_exit(ret,) fd, buf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct statfs *, buf, buf))) -) -#endif -#ifndef OVERRIDE_32_socketcall -SC_LTTNG_TRACEPOINT_EVENT(socketcall, - TP_PROTO(sc_exit(long ret,) int call, unsigned long * args), - TP_ARGS(sc_exit(ret,) call, args), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, call, call)) sc_inout(ctf_integer(unsigned long *, args, args))) -) -#endif -#ifndef OVERRIDE_32_getitimer -SC_LTTNG_TRACEPOINT_EVENT(getitimer, - TP_PROTO(sc_exit(long ret,) int which, struct itimerval * value), - TP_ARGS(sc_exit(ret,) which, value), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_out(ctf_integer(struct itimerval *, value, value))) -) -#endif -#ifndef OVERRIDE_32_newstat -SC_LTTNG_TRACEPOINT_EVENT(newstat, - TP_PROTO(sc_exit(long ret,) const char * filename, struct stat * statbuf), - TP_ARGS(sc_exit(ret,) filename, statbuf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_out(ctf_integer(struct stat *, statbuf, statbuf))) -) -#endif -#ifndef OVERRIDE_32_newlstat -SC_LTTNG_TRACEPOINT_EVENT(newlstat, - TP_PROTO(sc_exit(long ret,) const char * filename, struct stat * statbuf), - TP_ARGS(sc_exit(ret,) filename, statbuf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_out(ctf_integer(struct stat *, statbuf, statbuf))) -) -#endif -#ifndef OVERRIDE_32_newfstat -SC_LTTNG_TRACEPOINT_EVENT(newfstat, - TP_PROTO(sc_exit(long ret,) unsigned int fd, struct stat * statbuf), - TP_ARGS(sc_exit(ret,) fd, statbuf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct stat *, statbuf, statbuf))) -) -#endif -#ifndef OVERRIDE_32_setdomainname -SC_LTTNG_TRACEPOINT_EVENT(setdomainname, - TP_PROTO(sc_exit(long ret,) char * name, int len), - TP_ARGS(sc_exit(ret,) name, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(int, len, len))) -) -#endif -#ifndef OVERRIDE_32_delete_module -SC_LTTNG_TRACEPOINT_EVENT(delete_module, - TP_PROTO(sc_exit(long ret,) const char * name_user, unsigned int flags), - TP_ARGS(sc_exit(ret,) name_user, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name_user, name_user)) sc_in(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_sched_setparam -SC_LTTNG_TRACEPOINT_EVENT(sched_setparam, - TP_PROTO(sc_exit(long ret,) pid_t pid, struct sched_param * param), - TP_ARGS(sc_exit(ret,) pid, param), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(struct sched_param *, param, param))) -) -#endif -#ifndef OVERRIDE_32_sched_getparam -SC_LTTNG_TRACEPOINT_EVENT(sched_getparam, - TP_PROTO(sc_exit(long ret,) pid_t pid, struct sched_param * param), - TP_ARGS(sc_exit(ret,) pid, param), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_out(ctf_integer(struct sched_param *, param, param))) -) -#endif -#ifndef OVERRIDE_32_sched_rr_get_interval -SC_LTTNG_TRACEPOINT_EVENT(sched_rr_get_interval, - TP_PROTO(sc_exit(long ret,) pid_t pid, struct timespec * interval), - TP_ARGS(sc_exit(ret,) pid, interval), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_out(ctf_integer(struct timespec *, interval, interval))) -) -#endif -#ifndef OVERRIDE_32_nanosleep -SC_LTTNG_TRACEPOINT_EVENT(nanosleep, - TP_PROTO(sc_exit(long ret,) struct timespec * rqtp, struct timespec * rmtp), - TP_ARGS(sc_exit(ret,) rqtp, rmtp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct timespec *, rqtp, rqtp)) sc_out(ctf_integer(struct timespec *, rmtp, rmtp))) -) -#endif -#ifndef OVERRIDE_32_rt_sigpending -SC_LTTNG_TRACEPOINT_EVENT(rt_sigpending, - TP_PROTO(sc_exit(long ret,) sigset_t * set, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) set, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(sigset_t *, set, set)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) -) -#endif -#ifndef OVERRIDE_32_rt_sigsuspend -SC_LTTNG_TRACEPOINT_EVENT(rt_sigsuspend, - TP_PROTO(sc_exit(long ret,) sigset_t * unewset, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) unewset, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(sigset_t *, unewset, unewset)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) -) -#endif -#ifndef OVERRIDE_32_getcwd -SC_LTTNG_TRACEPOINT_EVENT(getcwd, - TP_PROTO(sc_exit(long ret,) char * buf, unsigned long size), - TP_ARGS(sc_exit(ret,) buf, size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(unsigned long, size, size))) -) -#endif -#ifndef OVERRIDE_32_getrlimit -SC_LTTNG_TRACEPOINT_EVENT(getrlimit, - TP_PROTO(sc_exit(long ret,) unsigned int resource, struct rlimit * rlim), - TP_ARGS(sc_exit(ret,) resource, rlim), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, resource, resource)) sc_out(ctf_integer(struct rlimit *, rlim, rlim))) -) -#endif -#ifndef OVERRIDE_32_stat64 -SC_LTTNG_TRACEPOINT_EVENT(stat64, - TP_PROTO(sc_exit(long ret,) const char * filename, struct stat64 * statbuf), - TP_ARGS(sc_exit(ret,) filename, statbuf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(filename, filename)) sc_inout(ctf_integer(struct stat64 *, statbuf, statbuf))) -) -#endif -#ifndef OVERRIDE_32_lstat64 -SC_LTTNG_TRACEPOINT_EVENT(lstat64, - TP_PROTO(sc_exit(long ret,) const char * filename, struct stat64 * statbuf), - TP_ARGS(sc_exit(ret,) filename, statbuf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(filename, filename)) sc_inout(ctf_integer(struct stat64 *, statbuf, statbuf))) -) -#endif -#ifndef OVERRIDE_32_fstat64 -SC_LTTNG_TRACEPOINT_EVENT(fstat64, - TP_PROTO(sc_exit(long ret,) unsigned long fd, struct stat64 * statbuf), - TP_ARGS(sc_exit(ret,) fd, statbuf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned long, fd, fd)) sc_inout(ctf_integer(struct stat64 *, statbuf, statbuf))) -) -#endif -#ifndef OVERRIDE_32_getgroups -SC_LTTNG_TRACEPOINT_EVENT(getgroups, - TP_PROTO(sc_exit(long ret,) int gidsetsize, gid_t * grouplist), - TP_ARGS(sc_exit(ret,) gidsetsize, grouplist), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, gidsetsize, gidsetsize)) sc_out(ctf_integer(gid_t *, grouplist, grouplist))) -) -#endif -#ifndef OVERRIDE_32_setgroups -SC_LTTNG_TRACEPOINT_EVENT(setgroups, - TP_PROTO(sc_exit(long ret,) int gidsetsize, gid_t * grouplist), - TP_ARGS(sc_exit(ret,) gidsetsize, grouplist), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, gidsetsize, gidsetsize)) sc_in(ctf_integer(gid_t *, grouplist, grouplist))) -) -#endif -#ifndef OVERRIDE_32_pivot_root -SC_LTTNG_TRACEPOINT_EVENT(pivot_root, - TP_PROTO(sc_exit(long ret,) const char * new_root, const char * put_old), - TP_ARGS(sc_exit(ret,) new_root, put_old), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(new_root, new_root)) sc_in(ctf_user_string(put_old, put_old))) -) -#endif -#ifndef OVERRIDE_32_removexattr -SC_LTTNG_TRACEPOINT_EVENT(removexattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name), - TP_ARGS(sc_exit(ret,) pathname, name), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name))) -) -#endif -#ifndef OVERRIDE_32_lremovexattr -SC_LTTNG_TRACEPOINT_EVENT(lremovexattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name), - TP_ARGS(sc_exit(ret,) pathname, name), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name))) -) -#endif -#ifndef OVERRIDE_32_fremovexattr -SC_LTTNG_TRACEPOINT_EVENT(fremovexattr, - TP_PROTO(sc_exit(long ret,) int fd, const char * name), - TP_ARGS(sc_exit(ret,) fd, name), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(name, name))) -) -#endif -#ifndef OVERRIDE_32_io_setup -SC_LTTNG_TRACEPOINT_EVENT(io_setup, - TP_PROTO(sc_exit(long ret,) unsigned nr_events, aio_context_t * ctxp), - TP_ARGS(sc_exit(ret,) nr_events, ctxp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned, nr_events, nr_events)) sc_in(ctf_integer(aio_context_t *, ctxp, ctxp))) -) -#endif -#ifndef OVERRIDE_32_timer_gettime -SC_LTTNG_TRACEPOINT_EVENT(timer_gettime, - TP_PROTO(sc_exit(long ret,) timer_t timer_id, struct itimerspec * setting), - TP_ARGS(sc_exit(ret,) timer_id, setting), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id)) sc_out(ctf_integer(struct itimerspec *, setting, setting))) -) -#endif -#ifndef OVERRIDE_32_clock_settime -SC_LTTNG_TRACEPOINT_EVENT(clock_settime, - TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, const struct timespec * tp), - TP_ARGS(sc_exit(ret,) which_clock, tp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_in(ctf_integer(const struct timespec *, tp, tp))) -) -#endif -#ifndef OVERRIDE_32_clock_gettime -SC_LTTNG_TRACEPOINT_EVENT(clock_gettime, - TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct timespec * tp), - TP_ARGS(sc_exit(ret,) which_clock, tp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_out(ctf_integer(struct timespec *, tp, tp))) -) -#endif -#ifndef OVERRIDE_32_clock_getres -SC_LTTNG_TRACEPOINT_EVENT(clock_getres, - TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct timespec * tp), - TP_ARGS(sc_exit(ret,) which_clock, tp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_out(ctf_integer(struct timespec *, tp, tp))) -) -#endif -#ifndef OVERRIDE_32_utimes -SC_LTTNG_TRACEPOINT_EVENT(utimes, - TP_PROTO(sc_exit(long ret,) char * filename, struct timeval * utimes), - TP_ARGS(sc_exit(ret,) filename, utimes), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(struct timeval *, utimes, utimes))) -) -#endif -#ifndef OVERRIDE_32_mq_notify -SC_LTTNG_TRACEPOINT_EVENT(mq_notify, - TP_PROTO(sc_exit(long ret,) mqd_t mqdes, const struct sigevent * u_notification), - TP_ARGS(sc_exit(ret,) mqdes, u_notification), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(mqd_t, mqdes, mqdes)) sc_in(ctf_integer(const struct sigevent *, u_notification, u_notification))) -) -#endif -#ifndef OVERRIDE_32_set_robust_list -SC_LTTNG_TRACEPOINT_EVENT(set_robust_list, - TP_PROTO(sc_exit(long ret,) struct robust_list_head * head, size_t len), - TP_ARGS(sc_exit(ret,) head, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct robust_list_head *, head, head)) sc_in(ctf_integer(size_t, len, len))) -) -#endif -#ifndef OVERRIDE_32_timerfd_gettime -SC_LTTNG_TRACEPOINT_EVENT(timerfd_gettime, - TP_PROTO(sc_exit(long ret,) int ufd, struct itimerspec * otmr), - TP_ARGS(sc_exit(ret,) ufd, otmr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_out(ctf_integer(struct itimerspec *, otmr, otmr))) -) -#endif -#ifndef OVERRIDE_32_pipe2 -SC_LTTNG_TRACEPOINT_EVENT(pipe2, - TP_PROTO(sc_exit(long ret,) int * fildes, int flags), - TP_ARGS(sc_exit(ret,) fildes, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(int *, fildes, fildes)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_clock_adjtime -SC_LTTNG_TRACEPOINT_EVENT(clock_adjtime, - TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct timex * utx), - TP_ARGS(sc_exit(ret,) which_clock, utx), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_inout(ctf_integer(struct timex *, utx, utx))) -) -#endif -#ifndef OVERRIDE_32_read -SC_LTTNG_TRACEPOINT_EVENT(read, - TP_PROTO(sc_exit(long ret,) unsigned int fd, char * buf, size_t count), - TP_ARGS(sc_exit(ret,) fd, buf, count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(size_t, count, count))) -) -#endif -#ifndef OVERRIDE_32_write -SC_LTTNG_TRACEPOINT_EVENT(write, - TP_PROTO(sc_exit(long ret,) unsigned int fd, const char * buf, size_t count), - TP_ARGS(sc_exit(ret,) fd, buf, count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(const char *, buf, buf)) sc_in(ctf_integer(size_t, count, count))) -) -#endif -#ifndef OVERRIDE_32_open -SC_LTTNG_TRACEPOINT_EVENT(open, - TP_PROTO(sc_exit(long ret,) const char * filename, int flags, int mode), - TP_ARGS(sc_exit(ret,) filename, flags, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(int, mode, mode))) -) -#endif -#ifndef OVERRIDE_32_waitpid -SC_LTTNG_TRACEPOINT_EVENT(waitpid, - TP_PROTO(sc_exit(long ret,) pid_t pid, int * stat_addr, int options), - TP_ARGS(sc_exit(ret,) pid, stat_addr, options), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(pid_t, pid, pid)) sc_inout(ctf_integer(int *, stat_addr, stat_addr)) sc_inout(ctf_integer(int, options, options))) -) -#endif -#ifndef OVERRIDE_32_mknod -SC_LTTNG_TRACEPOINT_EVENT(mknod, - TP_PROTO(sc_exit(long ret,) const char * filename, int mode, unsigned dev), - TP_ARGS(sc_exit(ret,) filename, mode, dev), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, mode, mode)) sc_in(ctf_integer(unsigned, dev, dev))) -) -#endif -#ifndef OVERRIDE_32_lchown16 -SC_LTTNG_TRACEPOINT_EVENT(lchown16, - TP_PROTO(sc_exit(long ret,) const char * filename, old_uid_t user, old_gid_t group), - TP_ARGS(sc_exit(ret,) filename, user, group), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(filename, filename)) sc_inout(ctf_integer(old_uid_t, user, user)) sc_inout(ctf_integer(old_gid_t, group, group))) -) -#endif -#ifndef OVERRIDE_32_readlink -SC_LTTNG_TRACEPOINT_EVENT(readlink, - TP_PROTO(sc_exit(long ret,) const char * path, char * buf, int bufsiz), - TP_ARGS(sc_exit(ret,) path, buf, bufsiz), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(path, path)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(int, bufsiz, bufsiz))) -) -#endif -#ifndef OVERRIDE_32_old_readdir -SC_LTTNG_TRACEPOINT_EVENT(old_readdir, - TP_PROTO(sc_exit(long ret,) unsigned int fd, struct old_linux_dirent * dirent, unsigned int count), - TP_ARGS(sc_exit(ret,) fd, dirent, count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, fd, fd)) sc_inout(ctf_integer(struct old_linux_dirent *, dirent, dirent)) sc_inout(ctf_integer(unsigned int, count, count))) -) -#endif -#ifndef OVERRIDE_32_syslog -SC_LTTNG_TRACEPOINT_EVENT(syslog, - TP_PROTO(sc_exit(long ret,) int type, char * buf, int len), - TP_ARGS(sc_exit(ret,) type, buf, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, type, type)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(int, len, len))) -) -#endif -#ifndef OVERRIDE_32_setitimer -SC_LTTNG_TRACEPOINT_EVENT(setitimer, - TP_PROTO(sc_exit(long ret,) int which, struct itimerval * value, struct itimerval * ovalue), - TP_ARGS(sc_exit(ret,) which, value, ovalue), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(struct itimerval *, value, value)) sc_out(ctf_integer(struct itimerval *, ovalue, ovalue))) -) -#endif -#ifndef OVERRIDE_32_sigprocmask -SC_LTTNG_TRACEPOINT_EVENT(sigprocmask, - TP_PROTO(sc_exit(long ret,) int how, old_sigset_t * nset, old_sigset_t * oset), - TP_ARGS(sc_exit(ret,) how, nset, oset), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, how, how)) sc_inout(ctf_integer(old_sigset_t *, nset, nset)) sc_inout(ctf_integer(old_sigset_t *, oset, oset))) -) -#endif -#ifndef OVERRIDE_32_init_module -SC_LTTNG_TRACEPOINT_EVENT(init_module, - TP_PROTO(sc_exit(long ret,) void * umod, unsigned long len, const char * uargs), - TP_ARGS(sc_exit(ret,) umod, len, uargs), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(void *, umod, umod)) sc_in(ctf_integer(unsigned long, len, len)) sc_in(ctf_integer(const char *, uargs, uargs))) -) -#endif -#ifndef OVERRIDE_32_getdents -SC_LTTNG_TRACEPOINT_EVENT(getdents, - TP_PROTO(sc_exit(long ret,) unsigned int fd, struct linux_dirent * dirent, unsigned int count), - TP_ARGS(sc_exit(ret,) fd, dirent, count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct linux_dirent *, dirent, dirent)) sc_in(ctf_integer(unsigned int, count, count))) -) -#endif -#ifndef OVERRIDE_32_readv -SC_LTTNG_TRACEPOINT_EVENT(readv, - TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen), - TP_ARGS(sc_exit(ret,) fd, vec, vlen), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_inout(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen))) -) -#endif -#ifndef OVERRIDE_32_writev -SC_LTTNG_TRACEPOINT_EVENT(writev, - TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen), - TP_ARGS(sc_exit(ret,) fd, vec, vlen), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_inout(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen))) -) -#endif -#ifndef OVERRIDE_32_sched_setscheduler -SC_LTTNG_TRACEPOINT_EVENT(sched_setscheduler, - TP_PROTO(sc_exit(long ret,) pid_t pid, int policy, struct sched_param * param), - TP_ARGS(sc_exit(ret,) pid, policy, param), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, policy, policy)) sc_in(ctf_integer(struct sched_param *, param, param))) -) -#endif -#ifndef OVERRIDE_32_getresuid16 -SC_LTTNG_TRACEPOINT_EVENT(getresuid16, - TP_PROTO(sc_exit(long ret,) old_uid_t * ruid, old_uid_t * euid, old_uid_t * suid), - TP_ARGS(sc_exit(ret,) ruid, euid, suid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(old_uid_t *, ruid, ruid)) sc_inout(ctf_integer(old_uid_t *, euid, euid)) sc_inout(ctf_integer(old_uid_t *, suid, suid))) -) -#endif -#ifndef OVERRIDE_32_poll -SC_LTTNG_TRACEPOINT_EVENT(poll, - TP_PROTO(sc_exit(long ret,) struct pollfd * ufds, unsigned int nfds, long timeout_msecs), - TP_ARGS(sc_exit(ret,) ufds, nfds, timeout_msecs), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct pollfd *, ufds, ufds)) sc_in(ctf_integer(unsigned int, nfds, nfds)) sc_in(ctf_integer(long, timeout_msecs, timeout_msecs))) -) -#endif -#ifndef OVERRIDE_32_getresgid16 -SC_LTTNG_TRACEPOINT_EVENT(getresgid16, - TP_PROTO(sc_exit(long ret,) old_gid_t * rgid, old_gid_t * egid, old_gid_t * sgid), - TP_ARGS(sc_exit(ret,) rgid, egid, sgid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(old_gid_t *, rgid, rgid)) sc_inout(ctf_integer(old_gid_t *, egid, egid)) sc_inout(ctf_integer(old_gid_t *, sgid, sgid))) -) -#endif -#ifndef OVERRIDE_32_rt_sigqueueinfo -SC_LTTNG_TRACEPOINT_EVENT(rt_sigqueueinfo, - TP_PROTO(sc_exit(long ret,) pid_t pid, int sig, siginfo_t * uinfo), - TP_ARGS(sc_exit(ret,) pid, sig, uinfo), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig)) sc_in(ctf_integer(siginfo_t *, uinfo, uinfo))) -) -#endif -#ifndef OVERRIDE_32_chown16 -SC_LTTNG_TRACEPOINT_EVENT(chown16, - TP_PROTO(sc_exit(long ret,) const char * filename, old_uid_t user, old_gid_t group), - TP_ARGS(sc_exit(ret,) filename, user, group), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(filename, filename)) sc_inout(ctf_integer(old_uid_t, user, user)) sc_inout(ctf_integer(old_gid_t, group, group))) -) -#endif -#ifndef OVERRIDE_32_lchown -SC_LTTNG_TRACEPOINT_EVENT(lchown, - TP_PROTO(sc_exit(long ret,) const char * filename, uid_t user, gid_t group), - TP_ARGS(sc_exit(ret,) filename, user, group), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group))) -) -#endif -#ifndef OVERRIDE_32_getresuid -SC_LTTNG_TRACEPOINT_EVENT(getresuid, - TP_PROTO(sc_exit(long ret,) uid_t * ruid, uid_t * euid, uid_t * suid), - TP_ARGS(sc_exit(ret,) ruid, euid, suid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(uid_t *, ruid, ruid)) sc_out(ctf_integer(uid_t *, euid, euid)) sc_out(ctf_integer(uid_t *, suid, suid))) -) -#endif -#ifndef OVERRIDE_32_getresgid -SC_LTTNG_TRACEPOINT_EVENT(getresgid, - TP_PROTO(sc_exit(long ret,) gid_t * rgid, gid_t * egid, gid_t * sgid), - TP_ARGS(sc_exit(ret,) rgid, egid, sgid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(gid_t *, rgid, rgid)) sc_out(ctf_integer(gid_t *, egid, egid)) sc_out(ctf_integer(gid_t *, sgid, sgid))) -) -#endif -#ifndef OVERRIDE_32_chown -SC_LTTNG_TRACEPOINT_EVENT(chown, - TP_PROTO(sc_exit(long ret,) const char * filename, uid_t user, gid_t group), - TP_ARGS(sc_exit(ret,) filename, user, group), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group))) -) -#endif -#ifndef OVERRIDE_32_mincore -SC_LTTNG_TRACEPOINT_EVENT(mincore, - TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len, unsigned char * vec), - TP_ARGS(sc_exit(ret,) start, len, vec), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len)) sc_out(ctf_integer(unsigned char *, vec, vec))) -) -#endif -#ifndef OVERRIDE_32_getdents64 -SC_LTTNG_TRACEPOINT_EVENT(getdents64, - TP_PROTO(sc_exit(long ret,) unsigned int fd, struct linux_dirent64 * dirent, unsigned int count), - TP_ARGS(sc_exit(ret,) fd, dirent, count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct linux_dirent64 *, dirent, dirent)) sc_in(ctf_integer(unsigned int, count, count))) -) -#endif -#ifndef OVERRIDE_32_listxattr -SC_LTTNG_TRACEPOINT_EVENT(listxattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, char * list, size_t size), - TP_ARGS(sc_exit(ret,) pathname, list, size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(char *, list, list)) sc_in(ctf_integer(size_t, size, size))) -) -#endif -#ifndef OVERRIDE_32_llistxattr -SC_LTTNG_TRACEPOINT_EVENT(llistxattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, char * list, size_t size), - TP_ARGS(sc_exit(ret,) pathname, list, size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(char *, list, list)) sc_in(ctf_integer(size_t, size, size))) -) -#endif -#ifndef OVERRIDE_32_flistxattr -SC_LTTNG_TRACEPOINT_EVENT(flistxattr, - TP_PROTO(sc_exit(long ret,) int fd, char * list, size_t size), - TP_ARGS(sc_exit(ret,) fd, list, size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(char *, list, list)) sc_in(ctf_integer(size_t, size, size))) -) -#endif -#ifndef OVERRIDE_32_sched_setaffinity -SC_LTTNG_TRACEPOINT_EVENT(sched_setaffinity, - TP_PROTO(sc_exit(long ret,) pid_t pid, unsigned int len, unsigned long * user_mask_ptr), - TP_ARGS(sc_exit(ret,) pid, len, user_mask_ptr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(unsigned int, len, len)) sc_in(ctf_integer(unsigned long *, user_mask_ptr, user_mask_ptr))) -) -#endif -#ifndef OVERRIDE_32_sched_getaffinity -SC_LTTNG_TRACEPOINT_EVENT(sched_getaffinity, - TP_PROTO(sc_exit(long ret,) pid_t pid, unsigned int len, unsigned long * user_mask_ptr), - TP_ARGS(sc_exit(ret,) pid, len, user_mask_ptr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(unsigned int, len, len)) sc_out(ctf_integer(unsigned long *, user_mask_ptr, user_mask_ptr))) -) -#endif -#ifndef OVERRIDE_32_io_submit -SC_LTTNG_TRACEPOINT_EVENT(io_submit, - TP_PROTO(sc_exit(long ret,) aio_context_t ctx_id, long nr, struct iocb * * iocbpp), - TP_ARGS(sc_exit(ret,) ctx_id, nr, iocbpp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx_id, ctx_id)) sc_in(ctf_integer(long, nr, nr)) sc_in(ctf_integer(struct iocb * *, iocbpp, iocbpp))) -) -#endif -#ifndef OVERRIDE_32_io_cancel -SC_LTTNG_TRACEPOINT_EVENT(io_cancel, - TP_PROTO(sc_exit(long ret,) aio_context_t ctx_id, struct iocb * iocb, struct io_event * result), - TP_ARGS(sc_exit(ret,) ctx_id, iocb, result), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx_id, ctx_id)) sc_in(ctf_integer(struct iocb *, iocb, iocb)) sc_out(ctf_integer(struct io_event *, result, result))) -) -#endif -#ifndef OVERRIDE_32_timer_create -SC_LTTNG_TRACEPOINT_EVENT(timer_create, - TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct sigevent * timer_event_spec, timer_t * created_timer_id), - TP_ARGS(sc_exit(ret,) which_clock, timer_event_spec, created_timer_id), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_in(ctf_integer(struct sigevent *, timer_event_spec, timer_event_spec)) sc_out(ctf_integer(timer_t *, created_timer_id, created_timer_id))) -) -#endif -#ifndef OVERRIDE_32_statfs64 -SC_LTTNG_TRACEPOINT_EVENT(statfs64, - TP_PROTO(sc_exit(long ret,) const char * pathname, size_t sz, struct statfs64 * buf), - TP_ARGS(sc_exit(ret,) pathname, sz, buf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_user_string(pathname, pathname)) sc_inout(ctf_integer(size_t, sz, sz)) sc_inout(ctf_integer(struct statfs64 *, buf, buf))) -) -#endif -#ifndef OVERRIDE_32_fstatfs64 -SC_LTTNG_TRACEPOINT_EVENT(fstatfs64, - TP_PROTO(sc_exit(long ret,) unsigned int fd, size_t sz, struct statfs64 * buf), - TP_ARGS(sc_exit(ret,) fd, sz, buf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, fd, fd)) sc_inout(ctf_integer(size_t, sz, sz)) sc_inout(ctf_integer(struct statfs64 *, buf, buf))) -) -#endif -#ifndef OVERRIDE_32_mq_getsetattr -SC_LTTNG_TRACEPOINT_EVENT(mq_getsetattr, - TP_PROTO(sc_exit(long ret,) mqd_t mqdes, const struct mq_attr * u_mqstat, struct mq_attr * u_omqstat), - TP_ARGS(sc_exit(ret,) mqdes, u_mqstat, u_omqstat), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(mqd_t, mqdes, mqdes)) sc_in(ctf_integer(const struct mq_attr *, u_mqstat, u_mqstat)) sc_out(ctf_integer(struct mq_attr *, u_omqstat, u_omqstat))) -) -#endif -#ifndef OVERRIDE_32_inotify_add_watch -SC_LTTNG_TRACEPOINT_EVENT(inotify_add_watch, - TP_PROTO(sc_exit(long ret,) int fd, const char * pathname, u32 mask), - TP_ARGS(sc_exit(ret,) fd, pathname, mask), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(u32, mask, mask))) -) -#endif -#ifndef OVERRIDE_32_mkdirat -SC_LTTNG_TRACEPOINT_EVENT(mkdirat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * pathname, int mode), - TP_ARGS(sc_exit(ret,) dfd, pathname, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(int, mode, mode))) -) -#endif -#ifndef OVERRIDE_32_futimesat -SC_LTTNG_TRACEPOINT_EVENT(futimesat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, struct timeval * utimes), - TP_ARGS(sc_exit(ret,) dfd, filename, utimes), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(struct timeval *, utimes, utimes))) -) -#endif -#ifndef OVERRIDE_32_unlinkat -SC_LTTNG_TRACEPOINT_EVENT(unlinkat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * pathname, int flag), - TP_ARGS(sc_exit(ret,) dfd, pathname, flag), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(int, flag, flag))) -) -#endif -#ifndef OVERRIDE_32_symlinkat -SC_LTTNG_TRACEPOINT_EVENT(symlinkat, - TP_PROTO(sc_exit(long ret,) const char * oldname, int newdfd, const char * newname), - TP_ARGS(sc_exit(ret,) oldname, newdfd, newname), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_integer(int, newdfd, newdfd)) sc_in(ctf_user_string(newname, newname))) -) -#endif -#ifndef OVERRIDE_32_fchmodat -SC_LTTNG_TRACEPOINT_EVENT(fchmodat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, mode_t mode), - TP_ARGS(sc_exit(ret,) dfd, filename, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(mode_t, mode, mode))) -) -#endif -#ifndef OVERRIDE_32_faccessat -SC_LTTNG_TRACEPOINT_EVENT(faccessat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, int mode), - TP_ARGS(sc_exit(ret,) dfd, filename, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, mode, mode))) -) -#endif -#ifndef OVERRIDE_32_get_robust_list -SC_LTTNG_TRACEPOINT_EVENT(get_robust_list, - TP_PROTO(sc_exit(long ret,) int pid, struct robust_list_head * * head_ptr, size_t * len_ptr), - TP_ARGS(sc_exit(ret,) pid, head_ptr, len_ptr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, pid, pid)) sc_out(ctf_integer(struct robust_list_head * *, head_ptr, head_ptr)) sc_out(ctf_integer(size_t *, len_ptr, len_ptr))) -) -#endif -#ifndef OVERRIDE_32_getcpu -SC_LTTNG_TRACEPOINT_EVENT(getcpu, - TP_PROTO(sc_exit(long ret,) unsigned * cpup, unsigned * nodep, struct getcpu_cache * unused), - TP_ARGS(sc_exit(ret,) cpup, nodep, unused), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(unsigned *, cpup, cpup)) sc_out(ctf_integer(unsigned *, nodep, nodep)) sc_inout(ctf_integer(struct getcpu_cache *, unused, unused))) -) -#endif -#ifndef OVERRIDE_32_signalfd -SC_LTTNG_TRACEPOINT_EVENT(signalfd, - TP_PROTO(sc_exit(long ret,) int ufd, sigset_t * user_mask, size_t sizemask), - TP_ARGS(sc_exit(ret,) ufd, user_mask, sizemask), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_in(ctf_integer(sigset_t *, user_mask, user_mask)) sc_in(ctf_integer(size_t, sizemask, sizemask))) -) -#endif -#ifndef OVERRIDE_32_reboot -SC_LTTNG_TRACEPOINT_EVENT(reboot, - TP_PROTO(sc_exit(long ret,) int magic1, int magic2, unsigned int cmd, void * arg), - TP_ARGS(sc_exit(ret,) magic1, magic2, cmd, arg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, magic1, magic1)) sc_in(ctf_integer(int, magic2, magic2)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_in(ctf_integer(void *, arg, arg))) -) -#endif -#ifndef OVERRIDE_32_wait4 -SC_LTTNG_TRACEPOINT_EVENT(wait4, - TP_PROTO(sc_exit(long ret,) pid_t upid, int * stat_addr, int options, struct rusage * ru), - TP_ARGS(sc_exit(ret,) upid, stat_addr, options, ru), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, upid, upid)) sc_out(ctf_integer(int *, stat_addr, stat_addr)) sc_in(ctf_integer(int, options, options)) sc_out(ctf_integer(struct rusage *, ru, ru))) -) -#endif -#ifndef OVERRIDE_32_quotactl -SC_LTTNG_TRACEPOINT_EVENT(quotactl, - TP_PROTO(sc_exit(long ret,) unsigned int cmd, const char * special, qid_t id, void * addr), - TP_ARGS(sc_exit(ret,) cmd, special, id, addr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_in(ctf_integer(const char *, special, special)) sc_in(ctf_integer(qid_t, id, id)) sc_inout(ctf_integer(void *, addr, addr))) -) -#endif -#ifndef OVERRIDE_32_rt_sigaction -SC_LTTNG_TRACEPOINT_EVENT(rt_sigaction, - TP_PROTO(sc_exit(long ret,) int sig, const struct sigaction * act, struct sigaction * oact, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) sig, act, oact, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, sig, sig)) sc_in(ctf_integer(const struct sigaction *, act, act)) sc_out(ctf_integer(struct sigaction *, oact, oact)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) -) -#endif -#ifndef OVERRIDE_32_rt_sigprocmask -SC_LTTNG_TRACEPOINT_EVENT(rt_sigprocmask, - TP_PROTO(sc_exit(long ret,) int how, sigset_t * nset, sigset_t * oset, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) how, nset, oset, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, how, how)) sc_in(ctf_integer(sigset_t *, nset, nset)) sc_out(ctf_integer(sigset_t *, oset, oset)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) -) -#endif -#ifndef OVERRIDE_32_rt_sigtimedwait -SC_LTTNG_TRACEPOINT_EVENT(rt_sigtimedwait, - TP_PROTO(sc_exit(long ret,) const sigset_t * uthese, siginfo_t * uinfo, const struct timespec * uts, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) uthese, uinfo, uts, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(const sigset_t *, uthese, uthese)) sc_out(ctf_integer(siginfo_t *, uinfo, uinfo)) sc_in(ctf_integer(const struct timespec *, uts, uts)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) -) -#endif -#ifndef OVERRIDE_32_sendfile -SC_LTTNG_TRACEPOINT_EVENT(sendfile, - TP_PROTO(sc_exit(long ret,) int out_fd, int in_fd, off_t * offset, size_t count), - TP_ARGS(sc_exit(ret,) out_fd, in_fd, offset, count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, out_fd, out_fd)) sc_inout(ctf_integer(int, in_fd, in_fd)) sc_inout(ctf_integer(off_t *, offset, offset)) sc_inout(ctf_integer(size_t, count, count))) -) -#endif -#ifndef OVERRIDE_32_getxattr -SC_LTTNG_TRACEPOINT_EVENT(getxattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, void * value, size_t size), - TP_ARGS(sc_exit(ret,) pathname, name, value, size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_out(ctf_integer(void *, value, value)) sc_in(ctf_integer(size_t, size, size))) -) -#endif -#ifndef OVERRIDE_32_lgetxattr -SC_LTTNG_TRACEPOINT_EVENT(lgetxattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, void * value, size_t size), - TP_ARGS(sc_exit(ret,) pathname, name, value, size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_out(ctf_integer(void *, value, value)) sc_in(ctf_integer(size_t, size, size))) -) -#endif -#ifndef OVERRIDE_32_fgetxattr -SC_LTTNG_TRACEPOINT_EVENT(fgetxattr, - TP_PROTO(sc_exit(long ret,) int fd, const char * name, void * value, size_t size), - TP_ARGS(sc_exit(ret,) fd, name, value, size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(name, name)) sc_out(ctf_integer(void *, value, value)) sc_in(ctf_integer(size_t, size, size))) -) -#endif -#ifndef OVERRIDE_32_sendfile64 -SC_LTTNG_TRACEPOINT_EVENT(sendfile64, - TP_PROTO(sc_exit(long ret,) int out_fd, int in_fd, loff_t * offset, size_t count), - TP_ARGS(sc_exit(ret,) out_fd, in_fd, offset, count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, out_fd, out_fd)) sc_in(ctf_integer(int, in_fd, in_fd)) sc_inout(ctf_integer(loff_t *, offset, offset)) sc_in(ctf_integer(size_t, count, count))) -) -#endif -#ifndef OVERRIDE_32_epoll_ctl -SC_LTTNG_TRACEPOINT_EVENT(epoll_ctl, - TP_PROTO(sc_exit(long ret,) int epfd, int op, int fd, struct epoll_event * event), - TP_ARGS(sc_exit(ret,) epfd, op, fd, event), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, epfd, epfd)) sc_in(ctf_integer(int, op, op)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct epoll_event *, event, event))) -) -#endif -#ifndef OVERRIDE_32_epoll_wait -SC_LTTNG_TRACEPOINT_EVENT(epoll_wait, - TP_PROTO(sc_exit(long ret,) int epfd, struct epoll_event * events, int maxevents, int timeout), - TP_ARGS(sc_exit(ret,) epfd, events, maxevents, timeout), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, epfd, epfd)) sc_out(ctf_integer(struct epoll_event *, events, events)) sc_in(ctf_integer(int, maxevents, maxevents)) sc_in(ctf_integer(int, timeout, timeout))) -) -#endif -#ifndef OVERRIDE_32_timer_settime -SC_LTTNG_TRACEPOINT_EVENT(timer_settime, - TP_PROTO(sc_exit(long ret,) timer_t timer_id, int flags, const struct itimerspec * new_setting, struct itimerspec * old_setting), - TP_ARGS(sc_exit(ret,) timer_id, flags, new_setting, old_setting), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(const struct itimerspec *, new_setting, new_setting)) sc_out(ctf_integer(struct itimerspec *, old_setting, old_setting))) -) -#endif -#ifndef OVERRIDE_32_clock_nanosleep -SC_LTTNG_TRACEPOINT_EVENT(clock_nanosleep, - TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, int flags, const struct timespec * rqtp, struct timespec * rmtp), - TP_ARGS(sc_exit(ret,) which_clock, flags, rqtp, rmtp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(const struct timespec *, rqtp, rqtp)) sc_out(ctf_integer(struct timespec *, rmtp, rmtp))) -) -#endif -#ifndef OVERRIDE_32_mq_open -SC_LTTNG_TRACEPOINT_EVENT(mq_open, - TP_PROTO(sc_exit(long ret,) const char * u_name, int oflag, mode_t mode, struct mq_attr * u_attr), - TP_ARGS(sc_exit(ret,) u_name, oflag, mode, u_attr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(u_name, u_name)) sc_in(ctf_integer(int, oflag, oflag)) sc_in(ctf_integer(mode_t, mode, mode)) sc_in(ctf_integer(struct mq_attr *, u_attr, u_attr))) -) -#endif -#ifndef OVERRIDE_32_kexec_load -SC_LTTNG_TRACEPOINT_EVENT(kexec_load, - TP_PROTO(sc_exit(long ret,) unsigned long entry, unsigned long nr_segments, struct kexec_segment * segments, unsigned long flags), - TP_ARGS(sc_exit(ret,) entry, nr_segments, segments, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, entry, entry)) sc_in(ctf_integer(unsigned long, nr_segments, nr_segments)) sc_in(ctf_integer(struct kexec_segment *, segments, segments)) sc_in(ctf_integer(unsigned long, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_request_key -SC_LTTNG_TRACEPOINT_EVENT(request_key, - TP_PROTO(sc_exit(long ret,) const char * _type, const char * _description, const char * _callout_info, key_serial_t destringid), - TP_ARGS(sc_exit(ret,) _type, _description, _callout_info, destringid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(_type, _type)) sc_in(ctf_integer(const char *, _description, _description)) sc_in(ctf_integer(const char *, _callout_info, _callout_info)) sc_in(ctf_integer(key_serial_t, destringid, destringid))) -) -#endif -#ifndef OVERRIDE_32_openat -SC_LTTNG_TRACEPOINT_EVENT(openat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, int flags, int mode), - TP_ARGS(sc_exit(ret,) dfd, filename, flags, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(int, mode, mode))) -) -#endif -#ifndef OVERRIDE_32_mknodat -SC_LTTNG_TRACEPOINT_EVENT(mknodat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, int mode, unsigned dev), - TP_ARGS(sc_exit(ret,) dfd, filename, mode, dev), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, mode, mode)) sc_in(ctf_integer(unsigned, dev, dev))) -) -#endif -#ifndef OVERRIDE_32_fstatat64 -SC_LTTNG_TRACEPOINT_EVENT(fstatat64, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, struct stat64 * statbuf, int flag), - TP_ARGS(sc_exit(ret,) dfd, filename, statbuf, flag), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(int, dfd, dfd)) sc_inout(ctf_user_string(filename, filename)) sc_inout(ctf_integer(struct stat64 *, statbuf, statbuf)) sc_inout(ctf_integer(int, flag, flag))) -) -#endif -#ifndef OVERRIDE_32_renameat -SC_LTTNG_TRACEPOINT_EVENT(renameat, - TP_PROTO(sc_exit(long ret,) int olddfd, const char * oldname, int newdfd, const char * newname), - TP_ARGS(sc_exit(ret,) olddfd, oldname, newdfd, newname), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, olddfd, olddfd)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_integer(int, newdfd, newdfd)) sc_in(ctf_user_string(newname, newname))) -) -#endif -#ifndef OVERRIDE_32_readlinkat -SC_LTTNG_TRACEPOINT_EVENT(readlinkat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * pathname, char * buf, int bufsiz), - TP_ARGS(sc_exit(ret,) dfd, pathname, buf, bufsiz), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(int, bufsiz, bufsiz))) -) -#endif -#ifndef OVERRIDE_32_vmsplice -SC_LTTNG_TRACEPOINT_EVENT(vmsplice, - TP_PROTO(sc_exit(long ret,) int fd, const struct iovec * iov, unsigned long nr_segs, unsigned int flags), - TP_ARGS(sc_exit(ret,) fd, iov, nr_segs, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(const struct iovec *, iov, iov)) sc_in(ctf_integer(unsigned long, nr_segs, nr_segs)) sc_in(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_utimensat -SC_LTTNG_TRACEPOINT_EVENT(utimensat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, struct timespec * utimes, int flags), - TP_ARGS(sc_exit(ret,) dfd, filename, utimes, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(struct timespec *, utimes, utimes)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_timerfd_settime -SC_LTTNG_TRACEPOINT_EVENT(timerfd_settime, - TP_PROTO(sc_exit(long ret,) int ufd, int flags, const struct itimerspec * utmr, struct itimerspec * otmr), - TP_ARGS(sc_exit(ret,) ufd, flags, utmr, otmr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(const struct itimerspec *, utmr, utmr)) sc_out(ctf_integer(struct itimerspec *, otmr, otmr))) -) -#endif -#ifndef OVERRIDE_32_signalfd4 -SC_LTTNG_TRACEPOINT_EVENT(signalfd4, - TP_PROTO(sc_exit(long ret,) int ufd, sigset_t * user_mask, size_t sizemask, int flags), - TP_ARGS(sc_exit(ret,) ufd, user_mask, sizemask, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_in(ctf_integer(sigset_t *, user_mask, user_mask)) sc_in(ctf_integer(size_t, sizemask, sizemask)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_rt_tgsigqueueinfo -SC_LTTNG_TRACEPOINT_EVENT(rt_tgsigqueueinfo, - TP_PROTO(sc_exit(long ret,) pid_t tgid, pid_t pid, int sig, siginfo_t * uinfo), - TP_ARGS(sc_exit(ret,) tgid, pid, sig, uinfo), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, tgid, tgid)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig)) sc_in(ctf_integer(siginfo_t *, uinfo, uinfo))) -) -#endif -#ifndef OVERRIDE_32_prlimit64 -SC_LTTNG_TRACEPOINT_EVENT(prlimit64, - TP_PROTO(sc_exit(long ret,) pid_t pid, unsigned int resource, const struct rlimit64 * new_rlim, struct rlimit64 * old_rlim), - TP_ARGS(sc_exit(ret,) pid, resource, new_rlim, old_rlim), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(unsigned int, resource, resource)) sc_in(ctf_integer(const struct rlimit64 *, new_rlim, new_rlim)) sc_out(ctf_integer(struct rlimit64 *, old_rlim, old_rlim))) -) -#endif -#ifndef OVERRIDE_32_sendmmsg -SC_LTTNG_TRACEPOINT_EVENT(sendmmsg, - TP_PROTO(sc_exit(long ret,) int fd, struct mmsghdr * mmsg, unsigned int vlen, unsigned int flags), - TP_ARGS(sc_exit(ret,) fd, mmsg, vlen, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct mmsghdr *, mmsg, mmsg)) sc_in(ctf_integer(unsigned int, vlen, vlen)) sc_in(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_mount -SC_LTTNG_TRACEPOINT_EVENT(mount, - TP_PROTO(sc_exit(long ret,) char * dev_name, char * dir_name, char * type, unsigned long flags, void * data), - TP_ARGS(sc_exit(ret,) dev_name, dir_name, type, flags, data), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(dev_name, dev_name)) sc_in(ctf_user_string(dir_name, dir_name)) sc_in(ctf_user_string(type, type)) sc_in(ctf_integer(unsigned long, flags, flags)) sc_in(ctf_integer(void *, data, data))) -) -#endif -#ifndef OVERRIDE_32_llseek -SC_LTTNG_TRACEPOINT_EVENT(llseek, - TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned long offset_high, unsigned long offset_low, loff_t * result, unsigned int origin), - TP_ARGS(sc_exit(ret,) fd, offset_high, offset_low, result, origin), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, fd, fd)) sc_inout(ctf_integer(unsigned long, offset_high, offset_high)) sc_inout(ctf_integer(unsigned long, offset_low, offset_low)) sc_inout(ctf_integer(loff_t *, result, result)) sc_inout(ctf_integer(unsigned int, origin, origin))) -) -#endif -#ifndef OVERRIDE_32_select -SC_LTTNG_TRACEPOINT_EVENT(select, - TP_PROTO(sc_exit(long ret,) int n, fd_set * inp, fd_set * outp, fd_set * exp, struct timeval * tvp), - TP_ARGS(sc_exit(ret,) n, inp, outp, exp, tvp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, n, n)) sc_inout(ctf_integer(fd_set *, inp, inp)) sc_inout(ctf_integer(fd_set *, outp, outp)) sc_inout(ctf_integer(fd_set *, exp, exp)) sc_inout(ctf_integer(struct timeval *, tvp, tvp))) -) -#endif -#ifndef OVERRIDE_32_setxattr -SC_LTTNG_TRACEPOINT_EVENT(setxattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, const void * value, size_t size, int flags), - TP_ARGS(sc_exit(ret,) pathname, name, value, size, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(const void *, value, value)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_lsetxattr -SC_LTTNG_TRACEPOINT_EVENT(lsetxattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, const void * value, size_t size, int flags), - TP_ARGS(sc_exit(ret,) pathname, name, value, size, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(const void *, value, value)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_fsetxattr -SC_LTTNG_TRACEPOINT_EVENT(fsetxattr, - TP_PROTO(sc_exit(long ret,) int fd, const char * name, const void * value, size_t size, int flags), - TP_ARGS(sc_exit(ret,) fd, name, value, size, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(const void *, value, value)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_io_getevents -SC_LTTNG_TRACEPOINT_EVENT(io_getevents, - TP_PROTO(sc_exit(long ret,) aio_context_t ctx_id, long min_nr, long nr, struct io_event * events, struct timespec * timeout), - TP_ARGS(sc_exit(ret,) ctx_id, min_nr, nr, events, timeout), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx_id, ctx_id)) sc_in(ctf_integer(long, min_nr, min_nr)) sc_in(ctf_integer(long, nr, nr)) sc_out(ctf_integer(struct io_event *, events, events)) sc_inout(ctf_integer(struct timespec *, timeout, timeout))) -) -#endif -#ifndef OVERRIDE_32_mq_timedsend -SC_LTTNG_TRACEPOINT_EVENT(mq_timedsend, - TP_PROTO(sc_exit(long ret,) mqd_t mqdes, const char * u_msg_ptr, size_t msg_len, unsigned int msg_prio, const struct timespec * u_abs_timeout), - TP_ARGS(sc_exit(ret,) mqdes, u_msg_ptr, msg_len, msg_prio, u_abs_timeout), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(mqd_t, mqdes, mqdes)) sc_in(ctf_integer(const char *, u_msg_ptr, u_msg_ptr)) sc_in(ctf_integer(size_t, msg_len, msg_len)) sc_in(ctf_integer(unsigned int, msg_prio, msg_prio)) sc_in(ctf_integer(const struct timespec *, u_abs_timeout, u_abs_timeout))) -) -#endif -#ifndef OVERRIDE_32_mq_timedreceive -SC_LTTNG_TRACEPOINT_EVENT(mq_timedreceive, - TP_PROTO(sc_exit(long ret,) mqd_t mqdes, char * u_msg_ptr, size_t msg_len, unsigned int * u_msg_prio, const struct timespec * u_abs_timeout), - TP_ARGS(sc_exit(ret,) mqdes, u_msg_ptr, msg_len, u_msg_prio, u_abs_timeout), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(mqd_t, mqdes, mqdes)) sc_out(ctf_integer(char *, u_msg_ptr, u_msg_ptr)) sc_in(ctf_integer(size_t, msg_len, msg_len)) sc_out(ctf_integer(unsigned int *, u_msg_prio, u_msg_prio)) sc_in(ctf_integer(const struct timespec *, u_abs_timeout, u_abs_timeout))) -) -#endif -#ifndef OVERRIDE_32_waitid -SC_LTTNG_TRACEPOINT_EVENT(waitid, - TP_PROTO(sc_exit(long ret,) int which, pid_t upid, struct siginfo * infop, int options, struct rusage * ru), - TP_ARGS(sc_exit(ret,) which, upid, infop, options, ru), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(pid_t, upid, upid)) sc_out(ctf_integer(struct siginfo *, infop, infop)) sc_in(ctf_integer(int, options, options)) sc_out(ctf_integer(struct rusage *, ru, ru))) -) -#endif -#ifndef OVERRIDE_32_add_key -SC_LTTNG_TRACEPOINT_EVENT(add_key, - TP_PROTO(sc_exit(long ret,) const char * _type, const char * _description, const void * _payload, size_t plen, key_serial_t ringid), - TP_ARGS(sc_exit(ret,) _type, _description, _payload, plen, ringid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(_type, _type)) sc_in(ctf_integer(const char *, _description, _description)) sc_in(ctf_integer(const void *, _payload, _payload)) sc_in(ctf_integer(size_t, plen, plen)) sc_in(ctf_integer(key_serial_t, ringid, ringid))) -) -#endif -#ifndef OVERRIDE_32_fchownat -SC_LTTNG_TRACEPOINT_EVENT(fchownat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, uid_t user, gid_t group, int flag), - TP_ARGS(sc_exit(ret,) dfd, filename, user, group, flag), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group)) sc_in(ctf_integer(int, flag, flag))) -) -#endif -#ifndef OVERRIDE_32_linkat -SC_LTTNG_TRACEPOINT_EVENT(linkat, - TP_PROTO(sc_exit(long ret,) int olddfd, const char * oldname, int newdfd, const char * newname, int flags), - TP_ARGS(sc_exit(ret,) olddfd, oldname, newdfd, newname, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, olddfd, olddfd)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_integer(int, newdfd, newdfd)) sc_in(ctf_user_string(newname, newname)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_ppoll -SC_LTTNG_TRACEPOINT_EVENT(ppoll, - TP_PROTO(sc_exit(long ret,) struct pollfd * ufds, unsigned int nfds, struct timespec * tsp, const sigset_t * sigmask, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) ufds, nfds, tsp, sigmask, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct pollfd *, ufds, ufds)) sc_in(ctf_integer(unsigned int, nfds, nfds)) sc_in(ctf_integer(struct timespec *, tsp, tsp)) sc_in(ctf_integer(const sigset_t *, sigmask, sigmask)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) -) -#endif -#ifndef OVERRIDE_32_preadv -SC_LTTNG_TRACEPOINT_EVENT(preadv, - TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen, unsigned long pos_l, unsigned long pos_h), - TP_ARGS(sc_exit(ret,) fd, vec, vlen, pos_l, pos_h), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_out(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen)) sc_in(ctf_integer(unsigned long, pos_l, pos_l)) sc_in(ctf_integer(unsigned long, pos_h, pos_h))) -) -#endif -#ifndef OVERRIDE_32_pwritev -SC_LTTNG_TRACEPOINT_EVENT(pwritev, - TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen, unsigned long pos_l, unsigned long pos_h), - TP_ARGS(sc_exit(ret,) fd, vec, vlen, pos_l, pos_h), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_in(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen)) sc_in(ctf_integer(unsigned long, pos_l, pos_l)) sc_in(ctf_integer(unsigned long, pos_h, pos_h))) -) -#endif -#ifndef OVERRIDE_32_perf_event_open -SC_LTTNG_TRACEPOINT_EVENT(perf_event_open, - TP_PROTO(sc_exit(long ret,) struct perf_event_attr * attr_uptr, pid_t pid, int cpu, int group_fd, unsigned long flags), - TP_ARGS(sc_exit(ret,) attr_uptr, pid, cpu, group_fd, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct perf_event_attr *, attr_uptr, attr_uptr)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, cpu, cpu)) sc_in(ctf_integer(int, group_fd, group_fd)) sc_in(ctf_integer(unsigned long, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_recvmmsg -SC_LTTNG_TRACEPOINT_EVENT(recvmmsg, - TP_PROTO(sc_exit(long ret,) int fd, struct mmsghdr * mmsg, unsigned int vlen, unsigned int flags, struct timespec * timeout), - TP_ARGS(sc_exit(ret,) fd, mmsg, vlen, flags, timeout), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct mmsghdr *, mmsg, mmsg)) sc_in(ctf_integer(unsigned int, vlen, vlen)) sc_in(ctf_integer(unsigned int, flags, flags)) sc_inout(ctf_integer(struct timespec *, timeout, timeout))) -) -#endif -#ifndef OVERRIDE_32_ipc -SC_LTTNG_TRACEPOINT_EVENT(ipc, - TP_PROTO(sc_exit(long ret,) unsigned int call, int first, unsigned long second, unsigned long third, void * ptr, long fifth), - TP_ARGS(sc_exit(ret,) call, first, second, third, ptr, fifth), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(unsigned int, call, call)) sc_inout(ctf_integer(int, first, first)) sc_inout(ctf_integer(unsigned long, second, second)) sc_inout(ctf_integer(unsigned long, third, third)) sc_inout(ctf_integer(void *, ptr, ptr)) sc_inout(ctf_integer(long, fifth, fifth))) -) -#endif -#ifndef OVERRIDE_32_futex -SC_LTTNG_TRACEPOINT_EVENT(futex, - TP_PROTO(sc_exit(long ret,) u32 * uaddr, int op, u32 val, struct timespec * utime, u32 * uaddr2, u32 val3), - TP_ARGS(sc_exit(ret,) uaddr, op, val, utime, uaddr2, val3), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(u32 *, uaddr, uaddr)) sc_in(ctf_integer(int, op, op)) sc_in(ctf_integer(u32, val, val)) sc_in(ctf_integer(struct timespec *, utime, utime)) sc_inout(ctf_integer(u32 *, uaddr2, uaddr2)) sc_in(ctf_integer(u32, val3, val3))) -) -#endif -#ifndef OVERRIDE_32_pselect6 -SC_LTTNG_TRACEPOINT_EVENT(pselect6, - TP_PROTO(sc_exit(long ret,) int n, fd_set * inp, fd_set * outp, fd_set * exp, struct timespec * tsp, void * sig), - TP_ARGS(sc_exit(ret,) n, inp, outp, exp, tsp, sig), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, n, n)) sc_inout(ctf_integer(fd_set *, inp, inp)) sc_inout(ctf_integer(fd_set *, outp, outp)) sc_inout(ctf_integer(fd_set *, exp, exp)) sc_inout(ctf_integer(struct timespec *, tsp, tsp)) sc_in(ctf_integer(void *, sig, sig))) -) -#endif -#ifndef OVERRIDE_32_splice -SC_LTTNG_TRACEPOINT_EVENT(splice, - TP_PROTO(sc_exit(long ret,) int fd_in, loff_t * off_in, int fd_out, loff_t * off_out, size_t len, unsigned int flags), - TP_ARGS(sc_exit(ret,) fd_in, off_in, fd_out, off_out, len, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd_in, fd_in)) sc_in(ctf_integer(loff_t *, off_in, off_in)) sc_in(ctf_integer(int, fd_out, fd_out)) sc_in(ctf_integer(loff_t *, off_out, off_out)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_32_epoll_pwait -SC_LTTNG_TRACEPOINT_EVENT(epoll_pwait, - TP_PROTO(sc_exit(long ret,) int epfd, struct epoll_event * events, int maxevents, int timeout, const sigset_t * sigmask, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) epfd, events, maxevents, timeout, sigmask, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, epfd, epfd)) sc_out(ctf_integer(struct epoll_event *, events, events)) sc_in(ctf_integer(int, maxevents, maxevents)) sc_in(ctf_integer(int, timeout, timeout)) sc_in(ctf_integer(const sigset_t *, sigmask, sigmask)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) -) -#endif - -#endif /* _TRACE_SYSCALLS_POINTERS_H */ - -/* This part must be outside protection */ -#include - -#else /* CREATE_SYSCALL_TABLE */ - -#include "x86-32-syscalls_pointers_override.h" -#include "syscalls_pointers_override.h" - -#ifndef OVERRIDE_TABLE_32_read -TRACE_SYSCALL_TABLE(read, read, 3, 3) -#endif -#ifndef OVERRIDE_TABLE_32_write -TRACE_SYSCALL_TABLE(write, write, 4, 3) -#endif -#ifndef OVERRIDE_TABLE_32_open -TRACE_SYSCALL_TABLE(open, open, 5, 3) -#endif -#ifndef OVERRIDE_TABLE_32_waitpid -TRACE_SYSCALL_TABLE(waitpid, waitpid, 7, 3) -#endif -#ifndef OVERRIDE_TABLE_32_creat -TRACE_SYSCALL_TABLE(creat, creat, 8, 2) -#endif -#ifndef OVERRIDE_TABLE_32_link -TRACE_SYSCALL_TABLE(link, link, 9, 2) -#endif -#ifndef OVERRIDE_TABLE_32_unlink -TRACE_SYSCALL_TABLE(unlink, unlink, 10, 1) -#endif -#ifndef OVERRIDE_TABLE_32_chdir -TRACE_SYSCALL_TABLE(chdir, chdir, 12, 1) -#endif -#ifndef OVERRIDE_TABLE_32_time -TRACE_SYSCALL_TABLE(time, time, 13, 1) -#endif -#ifndef OVERRIDE_TABLE_32_mknod -TRACE_SYSCALL_TABLE(mknod, mknod, 14, 3) -#endif -#ifndef OVERRIDE_TABLE_32_chmod -TRACE_SYSCALL_TABLE(chmod, chmod, 15, 2) -#endif -#ifndef OVERRIDE_TABLE_32_lchown16 -TRACE_SYSCALL_TABLE(lchown16, lchown16, 16, 3) -#endif -#ifndef OVERRIDE_TABLE_32_stat -TRACE_SYSCALL_TABLE(stat, stat, 18, 2) -#endif -#ifndef OVERRIDE_TABLE_32_mount -TRACE_SYSCALL_TABLE(mount, mount, 21, 5) -#endif -#ifndef OVERRIDE_TABLE_32_oldumount -TRACE_SYSCALL_TABLE(oldumount, oldumount, 22, 1) -#endif -#ifndef OVERRIDE_TABLE_32_stime -TRACE_SYSCALL_TABLE(stime, stime, 25, 1) -#endif -#ifndef OVERRIDE_TABLE_32_fstat -TRACE_SYSCALL_TABLE(fstat, fstat, 28, 2) -#endif -#ifndef OVERRIDE_TABLE_32_utime -TRACE_SYSCALL_TABLE(utime, utime, 30, 2) -#endif -#ifndef OVERRIDE_TABLE_32_access -TRACE_SYSCALL_TABLE(access, access, 33, 2) -#endif -#ifndef OVERRIDE_TABLE_32_rename -TRACE_SYSCALL_TABLE(rename, rename, 38, 2) -#endif -#ifndef OVERRIDE_TABLE_32_mkdir -TRACE_SYSCALL_TABLE(mkdir, mkdir, 39, 2) -#endif -#ifndef OVERRIDE_TABLE_32_rmdir -TRACE_SYSCALL_TABLE(rmdir, rmdir, 40, 1) -#endif -#ifndef OVERRIDE_TABLE_32_pipe -TRACE_SYSCALL_TABLE(pipe, pipe, 42, 1) -#endif -#ifndef OVERRIDE_TABLE_32_times -TRACE_SYSCALL_TABLE(times, times, 43, 1) -#endif -#ifndef OVERRIDE_TABLE_32_acct -TRACE_SYSCALL_TABLE(acct, acct, 51, 1) -#endif -#ifndef OVERRIDE_TABLE_32_umount -TRACE_SYSCALL_TABLE(umount, umount, 52, 2) -#endif -#ifndef OVERRIDE_TABLE_32_olduname -TRACE_SYSCALL_TABLE(olduname, olduname, 59, 1) -#endif -#ifndef OVERRIDE_TABLE_32_chroot -TRACE_SYSCALL_TABLE(chroot, chroot, 61, 1) -#endif -#ifndef OVERRIDE_TABLE_32_ustat -TRACE_SYSCALL_TABLE(ustat, ustat, 62, 2) -#endif -#ifndef OVERRIDE_TABLE_32_sigpending -TRACE_SYSCALL_TABLE(sigpending, sigpending, 73, 1) -#endif -#ifndef OVERRIDE_TABLE_32_sethostname -TRACE_SYSCALL_TABLE(sethostname, sethostname, 74, 2) -#endif -#ifndef OVERRIDE_TABLE_32_setrlimit -TRACE_SYSCALL_TABLE(setrlimit, setrlimit, 75, 2) -#endif -#ifndef OVERRIDE_TABLE_32_old_getrlimit -TRACE_SYSCALL_TABLE(old_getrlimit, old_getrlimit, 76, 2) -#endif -#ifndef OVERRIDE_TABLE_32_getrusage -TRACE_SYSCALL_TABLE(getrusage, getrusage, 77, 2) -#endif -#ifndef OVERRIDE_TABLE_32_gettimeofday -TRACE_SYSCALL_TABLE(gettimeofday, gettimeofday, 78, 2) -#endif -#ifndef OVERRIDE_TABLE_32_settimeofday -TRACE_SYSCALL_TABLE(settimeofday, settimeofday, 79, 2) -#endif -#ifndef OVERRIDE_TABLE_32_getgroups16 -TRACE_SYSCALL_TABLE(getgroups16, getgroups16, 80, 2) -#endif -#ifndef OVERRIDE_TABLE_32_setgroups16 -TRACE_SYSCALL_TABLE(setgroups16, setgroups16, 81, 2) -#endif -#ifndef OVERRIDE_TABLE_32_old_select -TRACE_SYSCALL_TABLE(old_select, old_select, 82, 1) -#endif -#ifndef OVERRIDE_TABLE_32_symlink -TRACE_SYSCALL_TABLE(symlink, symlink, 83, 2) -#endif -#ifndef OVERRIDE_TABLE_32_lstat -TRACE_SYSCALL_TABLE(lstat, lstat, 84, 2) -#endif -#ifndef OVERRIDE_TABLE_32_readlink -TRACE_SYSCALL_TABLE(readlink, readlink, 85, 3) -#endif -#ifndef OVERRIDE_TABLE_32_uselib -TRACE_SYSCALL_TABLE(uselib, uselib, 86, 1) -#endif -#ifndef OVERRIDE_TABLE_32_swapon -TRACE_SYSCALL_TABLE(swapon, swapon, 87, 2) -#endif -#ifndef OVERRIDE_TABLE_32_reboot -TRACE_SYSCALL_TABLE(reboot, reboot, 88, 4) -#endif -#ifndef OVERRIDE_TABLE_32_old_readdir -TRACE_SYSCALL_TABLE(old_readdir, old_readdir, 89, 3) -#endif -#ifndef OVERRIDE_TABLE_32_old_mmap -TRACE_SYSCALL_TABLE(old_mmap, old_mmap, 90, 1) -#endif -#ifndef OVERRIDE_TABLE_32_truncate -TRACE_SYSCALL_TABLE(truncate, truncate, 92, 2) -#endif -#ifndef OVERRIDE_TABLE_32_statfs -TRACE_SYSCALL_TABLE(statfs, statfs, 99, 2) -#endif -#ifndef OVERRIDE_TABLE_32_fstatfs -TRACE_SYSCALL_TABLE(fstatfs, fstatfs, 100, 2) -#endif -#ifndef OVERRIDE_TABLE_32_socketcall -TRACE_SYSCALL_TABLE(socketcall, socketcall, 102, 2) -#endif -#ifndef OVERRIDE_TABLE_32_syslog -TRACE_SYSCALL_TABLE(syslog, syslog, 103, 3) -#endif -#ifndef OVERRIDE_TABLE_32_setitimer -TRACE_SYSCALL_TABLE(setitimer, setitimer, 104, 3) -#endif -#ifndef OVERRIDE_TABLE_32_getitimer -TRACE_SYSCALL_TABLE(getitimer, getitimer, 105, 2) -#endif -#ifndef OVERRIDE_TABLE_32_newstat -TRACE_SYSCALL_TABLE(newstat, newstat, 106, 2) -#endif -#ifndef OVERRIDE_TABLE_32_newlstat -TRACE_SYSCALL_TABLE(newlstat, newlstat, 107, 2) -#endif -#ifndef OVERRIDE_TABLE_32_newfstat -TRACE_SYSCALL_TABLE(newfstat, newfstat, 108, 2) -#endif -#ifndef OVERRIDE_TABLE_32_uname -TRACE_SYSCALL_TABLE(uname, uname, 109, 1) -#endif -#ifndef OVERRIDE_TABLE_32_wait4 -TRACE_SYSCALL_TABLE(wait4, wait4, 114, 4) -#endif -#ifndef OVERRIDE_TABLE_32_swapoff -TRACE_SYSCALL_TABLE(swapoff, swapoff, 115, 1) -#endif -#ifndef OVERRIDE_TABLE_32_sysinfo -TRACE_SYSCALL_TABLE(sysinfo, sysinfo, 116, 1) -#endif -#ifndef OVERRIDE_TABLE_32_ipc -TRACE_SYSCALL_TABLE(ipc, ipc, 117, 6) -#endif -#ifndef OVERRIDE_TABLE_32_setdomainname -TRACE_SYSCALL_TABLE(setdomainname, setdomainname, 121, 2) -#endif -#ifndef OVERRIDE_TABLE_32_newuname -TRACE_SYSCALL_TABLE(newuname, newuname, 122, 1) -#endif -#ifndef OVERRIDE_TABLE_32_adjtimex -TRACE_SYSCALL_TABLE(adjtimex, adjtimex, 124, 1) -#endif -#ifndef OVERRIDE_TABLE_32_sigprocmask -TRACE_SYSCALL_TABLE(sigprocmask, sigprocmask, 126, 3) -#endif -#ifndef OVERRIDE_TABLE_32_init_module -TRACE_SYSCALL_TABLE(init_module, init_module, 128, 3) -#endif -#ifndef OVERRIDE_TABLE_32_delete_module -TRACE_SYSCALL_TABLE(delete_module, delete_module, 129, 2) -#endif -#ifndef OVERRIDE_TABLE_32_quotactl -TRACE_SYSCALL_TABLE(quotactl, quotactl, 131, 4) -#endif -#ifndef OVERRIDE_TABLE_32_llseek -TRACE_SYSCALL_TABLE(llseek, llseek, 140, 5) -#endif -#ifndef OVERRIDE_TABLE_32_getdents -TRACE_SYSCALL_TABLE(getdents, getdents, 141, 3) -#endif -#ifndef OVERRIDE_TABLE_32_select -TRACE_SYSCALL_TABLE(select, select, 142, 5) -#endif -#ifndef OVERRIDE_TABLE_32_readv -TRACE_SYSCALL_TABLE(readv, readv, 145, 3) -#endif -#ifndef OVERRIDE_TABLE_32_writev -TRACE_SYSCALL_TABLE(writev, writev, 146, 3) -#endif -#ifndef OVERRIDE_TABLE_32_sysctl -TRACE_SYSCALL_TABLE(sysctl, sysctl, 149, 1) -#endif -#ifndef OVERRIDE_TABLE_32_sched_setparam -TRACE_SYSCALL_TABLE(sched_setparam, sched_setparam, 154, 2) -#endif -#ifndef OVERRIDE_TABLE_32_sched_getparam -TRACE_SYSCALL_TABLE(sched_getparam, sched_getparam, 155, 2) -#endif -#ifndef OVERRIDE_TABLE_32_sched_setscheduler -TRACE_SYSCALL_TABLE(sched_setscheduler, sched_setscheduler, 156, 3) -#endif -#ifndef OVERRIDE_TABLE_32_sched_rr_get_interval -TRACE_SYSCALL_TABLE(sched_rr_get_interval, sched_rr_get_interval, 161, 2) -#endif -#ifndef OVERRIDE_TABLE_32_nanosleep -TRACE_SYSCALL_TABLE(nanosleep, nanosleep, 162, 2) -#endif -#ifndef OVERRIDE_TABLE_32_getresuid16 -TRACE_SYSCALL_TABLE(getresuid16, getresuid16, 165, 3) -#endif -#ifndef OVERRIDE_TABLE_32_poll -TRACE_SYSCALL_TABLE(poll, poll, 168, 3) -#endif -#ifndef OVERRIDE_TABLE_32_getresgid16 -TRACE_SYSCALL_TABLE(getresgid16, getresgid16, 171, 3) -#endif -#ifndef OVERRIDE_TABLE_32_rt_sigaction -TRACE_SYSCALL_TABLE(rt_sigaction, rt_sigaction, 174, 4) -#endif -#ifndef OVERRIDE_TABLE_32_rt_sigprocmask -TRACE_SYSCALL_TABLE(rt_sigprocmask, rt_sigprocmask, 175, 4) -#endif -#ifndef OVERRIDE_TABLE_32_rt_sigpending -TRACE_SYSCALL_TABLE(rt_sigpending, rt_sigpending, 176, 2) -#endif -#ifndef OVERRIDE_TABLE_32_rt_sigtimedwait -TRACE_SYSCALL_TABLE(rt_sigtimedwait, rt_sigtimedwait, 177, 4) -#endif -#ifndef OVERRIDE_TABLE_32_rt_sigqueueinfo -TRACE_SYSCALL_TABLE(rt_sigqueueinfo, rt_sigqueueinfo, 178, 3) -#endif -#ifndef OVERRIDE_TABLE_32_rt_sigsuspend -TRACE_SYSCALL_TABLE(rt_sigsuspend, rt_sigsuspend, 179, 2) -#endif -#ifndef OVERRIDE_TABLE_32_chown16 -TRACE_SYSCALL_TABLE(chown16, chown16, 182, 3) -#endif -#ifndef OVERRIDE_TABLE_32_getcwd -TRACE_SYSCALL_TABLE(getcwd, getcwd, 183, 2) -#endif -#ifndef OVERRIDE_TABLE_32_sendfile -TRACE_SYSCALL_TABLE(sendfile, sendfile, 187, 4) -#endif -#ifndef OVERRIDE_TABLE_32_getrlimit -TRACE_SYSCALL_TABLE(getrlimit, getrlimit, 191, 2) -#endif -#ifndef OVERRIDE_TABLE_32_stat64 -TRACE_SYSCALL_TABLE(stat64, stat64, 195, 2) -#endif -#ifndef OVERRIDE_TABLE_32_lstat64 -TRACE_SYSCALL_TABLE(lstat64, lstat64, 196, 2) -#endif -#ifndef OVERRIDE_TABLE_32_fstat64 -TRACE_SYSCALL_TABLE(fstat64, fstat64, 197, 2) -#endif -#ifndef OVERRIDE_TABLE_32_lchown -TRACE_SYSCALL_TABLE(lchown, lchown, 198, 3) -#endif -#ifndef OVERRIDE_TABLE_32_getgroups -TRACE_SYSCALL_TABLE(getgroups, getgroups, 205, 2) -#endif -#ifndef OVERRIDE_TABLE_32_setgroups -TRACE_SYSCALL_TABLE(setgroups, setgroups, 206, 2) -#endif -#ifndef OVERRIDE_TABLE_32_getresuid -TRACE_SYSCALL_TABLE(getresuid, getresuid, 209, 3) -#endif -#ifndef OVERRIDE_TABLE_32_getresgid -TRACE_SYSCALL_TABLE(getresgid, getresgid, 211, 3) -#endif -#ifndef OVERRIDE_TABLE_32_chown -TRACE_SYSCALL_TABLE(chown, chown, 212, 3) -#endif -#ifndef OVERRIDE_TABLE_32_pivot_root -TRACE_SYSCALL_TABLE(pivot_root, pivot_root, 217, 2) -#endif -#ifndef OVERRIDE_TABLE_32_mincore -TRACE_SYSCALL_TABLE(mincore, mincore, 218, 3) -#endif -#ifndef OVERRIDE_TABLE_32_getdents64 -TRACE_SYSCALL_TABLE(getdents64, getdents64, 220, 3) -#endif -#ifndef OVERRIDE_TABLE_32_setxattr -TRACE_SYSCALL_TABLE(setxattr, setxattr, 226, 5) -#endif -#ifndef OVERRIDE_TABLE_32_lsetxattr -TRACE_SYSCALL_TABLE(lsetxattr, lsetxattr, 227, 5) -#endif -#ifndef OVERRIDE_TABLE_32_fsetxattr -TRACE_SYSCALL_TABLE(fsetxattr, fsetxattr, 228, 5) -#endif -#ifndef OVERRIDE_TABLE_32_getxattr -TRACE_SYSCALL_TABLE(getxattr, getxattr, 229, 4) -#endif -#ifndef OVERRIDE_TABLE_32_lgetxattr -TRACE_SYSCALL_TABLE(lgetxattr, lgetxattr, 230, 4) -#endif -#ifndef OVERRIDE_TABLE_32_fgetxattr -TRACE_SYSCALL_TABLE(fgetxattr, fgetxattr, 231, 4) -#endif -#ifndef OVERRIDE_TABLE_32_listxattr -TRACE_SYSCALL_TABLE(listxattr, listxattr, 232, 3) -#endif -#ifndef OVERRIDE_TABLE_32_llistxattr -TRACE_SYSCALL_TABLE(llistxattr, llistxattr, 233, 3) -#endif -#ifndef OVERRIDE_TABLE_32_flistxattr -TRACE_SYSCALL_TABLE(flistxattr, flistxattr, 234, 3) -#endif -#ifndef OVERRIDE_TABLE_32_removexattr -TRACE_SYSCALL_TABLE(removexattr, removexattr, 235, 2) -#endif -#ifndef OVERRIDE_TABLE_32_lremovexattr -TRACE_SYSCALL_TABLE(lremovexattr, lremovexattr, 236, 2) -#endif -#ifndef OVERRIDE_TABLE_32_fremovexattr -TRACE_SYSCALL_TABLE(fremovexattr, fremovexattr, 237, 2) -#endif -#ifndef OVERRIDE_TABLE_32_sendfile64 -TRACE_SYSCALL_TABLE(sendfile64, sendfile64, 239, 4) -#endif -#ifndef OVERRIDE_TABLE_32_futex -TRACE_SYSCALL_TABLE(futex, futex, 240, 6) -#endif -#ifndef OVERRIDE_TABLE_32_sched_setaffinity -TRACE_SYSCALL_TABLE(sched_setaffinity, sched_setaffinity, 241, 3) -#endif -#ifndef OVERRIDE_TABLE_32_sched_getaffinity -TRACE_SYSCALL_TABLE(sched_getaffinity, sched_getaffinity, 242, 3) -#endif -#ifndef OVERRIDE_TABLE_32_io_setup -TRACE_SYSCALL_TABLE(io_setup, io_setup, 245, 2) -#endif -#ifndef OVERRIDE_TABLE_32_io_getevents -TRACE_SYSCALL_TABLE(io_getevents, io_getevents, 247, 5) -#endif -#ifndef OVERRIDE_TABLE_32_io_submit -TRACE_SYSCALL_TABLE(io_submit, io_submit, 248, 3) -#endif -#ifndef OVERRIDE_TABLE_32_io_cancel -TRACE_SYSCALL_TABLE(io_cancel, io_cancel, 249, 3) -#endif -#ifndef OVERRIDE_TABLE_32_epoll_ctl -TRACE_SYSCALL_TABLE(epoll_ctl, epoll_ctl, 255, 4) -#endif -#ifndef OVERRIDE_TABLE_32_epoll_wait -TRACE_SYSCALL_TABLE(epoll_wait, epoll_wait, 256, 4) -#endif -#ifndef OVERRIDE_TABLE_32_set_tid_address -TRACE_SYSCALL_TABLE(set_tid_address, set_tid_address, 258, 1) -#endif -#ifndef OVERRIDE_TABLE_32_timer_create -TRACE_SYSCALL_TABLE(timer_create, timer_create, 259, 3) -#endif -#ifndef OVERRIDE_TABLE_32_timer_settime -TRACE_SYSCALL_TABLE(timer_settime, timer_settime, 260, 4) -#endif -#ifndef OVERRIDE_TABLE_32_timer_gettime -TRACE_SYSCALL_TABLE(timer_gettime, timer_gettime, 261, 2) -#endif -#ifndef OVERRIDE_TABLE_32_clock_settime -TRACE_SYSCALL_TABLE(clock_settime, clock_settime, 264, 2) -#endif -#ifndef OVERRIDE_TABLE_32_clock_gettime -TRACE_SYSCALL_TABLE(clock_gettime, clock_gettime, 265, 2) -#endif -#ifndef OVERRIDE_TABLE_32_clock_getres -TRACE_SYSCALL_TABLE(clock_getres, clock_getres, 266, 2) -#endif -#ifndef OVERRIDE_TABLE_32_clock_nanosleep -TRACE_SYSCALL_TABLE(clock_nanosleep, clock_nanosleep, 267, 4) -#endif -#ifndef OVERRIDE_TABLE_32_statfs64 -TRACE_SYSCALL_TABLE(statfs64, statfs64, 268, 3) -#endif -#ifndef OVERRIDE_TABLE_32_fstatfs64 -TRACE_SYSCALL_TABLE(fstatfs64, fstatfs64, 269, 3) -#endif -#ifndef OVERRIDE_TABLE_32_utimes -TRACE_SYSCALL_TABLE(utimes, utimes, 271, 2) -#endif -#ifndef OVERRIDE_TABLE_32_mq_open -TRACE_SYSCALL_TABLE(mq_open, mq_open, 277, 4) -#endif -#ifndef OVERRIDE_TABLE_32_mq_unlink -TRACE_SYSCALL_TABLE(mq_unlink, mq_unlink, 278, 1) -#endif -#ifndef OVERRIDE_TABLE_32_mq_timedsend -TRACE_SYSCALL_TABLE(mq_timedsend, mq_timedsend, 279, 5) -#endif -#ifndef OVERRIDE_TABLE_32_mq_timedreceive -TRACE_SYSCALL_TABLE(mq_timedreceive, mq_timedreceive, 280, 5) -#endif -#ifndef OVERRIDE_TABLE_32_mq_notify -TRACE_SYSCALL_TABLE(mq_notify, mq_notify, 281, 2) -#endif -#ifndef OVERRIDE_TABLE_32_mq_getsetattr -TRACE_SYSCALL_TABLE(mq_getsetattr, mq_getsetattr, 282, 3) -#endif -#ifndef OVERRIDE_TABLE_32_kexec_load -TRACE_SYSCALL_TABLE(kexec_load, kexec_load, 283, 4) -#endif -#ifndef OVERRIDE_TABLE_32_waitid -TRACE_SYSCALL_TABLE(waitid, waitid, 284, 5) -#endif -#ifndef OVERRIDE_TABLE_32_add_key -TRACE_SYSCALL_TABLE(add_key, add_key, 286, 5) -#endif -#ifndef OVERRIDE_TABLE_32_request_key -TRACE_SYSCALL_TABLE(request_key, request_key, 287, 4) -#endif -#ifndef OVERRIDE_TABLE_32_inotify_add_watch -TRACE_SYSCALL_TABLE(inotify_add_watch, inotify_add_watch, 292, 3) -#endif -#ifndef OVERRIDE_TABLE_32_openat -TRACE_SYSCALL_TABLE(openat, openat, 295, 4) -#endif -#ifndef OVERRIDE_TABLE_32_mkdirat -TRACE_SYSCALL_TABLE(mkdirat, mkdirat, 296, 3) -#endif -#ifndef OVERRIDE_TABLE_32_mknodat -TRACE_SYSCALL_TABLE(mknodat, mknodat, 297, 4) -#endif -#ifndef OVERRIDE_TABLE_32_fchownat -TRACE_SYSCALL_TABLE(fchownat, fchownat, 298, 5) -#endif -#ifndef OVERRIDE_TABLE_32_futimesat -TRACE_SYSCALL_TABLE(futimesat, futimesat, 299, 3) -#endif -#ifndef OVERRIDE_TABLE_32_fstatat64 -TRACE_SYSCALL_TABLE(fstatat64, fstatat64, 300, 4) -#endif -#ifndef OVERRIDE_TABLE_32_unlinkat -TRACE_SYSCALL_TABLE(unlinkat, unlinkat, 301, 3) -#endif -#ifndef OVERRIDE_TABLE_32_renameat -TRACE_SYSCALL_TABLE(renameat, renameat, 302, 4) -#endif -#ifndef OVERRIDE_TABLE_32_linkat -TRACE_SYSCALL_TABLE(linkat, linkat, 303, 5) -#endif -#ifndef OVERRIDE_TABLE_32_symlinkat -TRACE_SYSCALL_TABLE(symlinkat, symlinkat, 304, 3) -#endif -#ifndef OVERRIDE_TABLE_32_readlinkat -TRACE_SYSCALL_TABLE(readlinkat, readlinkat, 305, 4) -#endif -#ifndef OVERRIDE_TABLE_32_fchmodat -TRACE_SYSCALL_TABLE(fchmodat, fchmodat, 306, 3) -#endif -#ifndef OVERRIDE_TABLE_32_faccessat -TRACE_SYSCALL_TABLE(faccessat, faccessat, 307, 3) -#endif -#ifndef OVERRIDE_TABLE_32_pselect6 -TRACE_SYSCALL_TABLE(pselect6, pselect6, 308, 6) -#endif -#ifndef OVERRIDE_TABLE_32_ppoll -TRACE_SYSCALL_TABLE(ppoll, ppoll, 309, 5) -#endif -#ifndef OVERRIDE_TABLE_32_set_robust_list -TRACE_SYSCALL_TABLE(set_robust_list, set_robust_list, 311, 2) -#endif -#ifndef OVERRIDE_TABLE_32_get_robust_list -TRACE_SYSCALL_TABLE(get_robust_list, get_robust_list, 312, 3) -#endif -#ifndef OVERRIDE_TABLE_32_splice -TRACE_SYSCALL_TABLE(splice, splice, 313, 6) -#endif -#ifndef OVERRIDE_TABLE_32_vmsplice -TRACE_SYSCALL_TABLE(vmsplice, vmsplice, 316, 4) -#endif -#ifndef OVERRIDE_TABLE_32_getcpu -TRACE_SYSCALL_TABLE(getcpu, getcpu, 318, 3) -#endif -#ifndef OVERRIDE_TABLE_32_epoll_pwait -TRACE_SYSCALL_TABLE(epoll_pwait, epoll_pwait, 319, 6) -#endif -#ifndef OVERRIDE_TABLE_32_utimensat -TRACE_SYSCALL_TABLE(utimensat, utimensat, 320, 4) -#endif -#ifndef OVERRIDE_TABLE_32_signalfd -TRACE_SYSCALL_TABLE(signalfd, signalfd, 321, 3) -#endif -#ifndef OVERRIDE_TABLE_32_timerfd_settime -TRACE_SYSCALL_TABLE(timerfd_settime, timerfd_settime, 325, 4) -#endif -#ifndef OVERRIDE_TABLE_32_timerfd_gettime -TRACE_SYSCALL_TABLE(timerfd_gettime, timerfd_gettime, 326, 2) -#endif -#ifndef OVERRIDE_TABLE_32_signalfd4 -TRACE_SYSCALL_TABLE(signalfd4, signalfd4, 327, 4) -#endif -#ifndef OVERRIDE_TABLE_32_pipe2 -TRACE_SYSCALL_TABLE(pipe2, pipe2, 331, 2) -#endif -#ifndef OVERRIDE_TABLE_32_preadv -TRACE_SYSCALL_TABLE(preadv, preadv, 333, 5) -#endif -#ifndef OVERRIDE_TABLE_32_pwritev -TRACE_SYSCALL_TABLE(pwritev, pwritev, 334, 5) -#endif -#ifndef OVERRIDE_TABLE_32_rt_tgsigqueueinfo -TRACE_SYSCALL_TABLE(rt_tgsigqueueinfo, rt_tgsigqueueinfo, 335, 4) -#endif -#ifndef OVERRIDE_TABLE_32_perf_event_open -TRACE_SYSCALL_TABLE(perf_event_open, perf_event_open, 336, 5) -#endif -#ifndef OVERRIDE_TABLE_32_recvmmsg -TRACE_SYSCALL_TABLE(recvmmsg, recvmmsg, 337, 5) -#endif -#ifndef OVERRIDE_TABLE_32_prlimit64 -TRACE_SYSCALL_TABLE(prlimit64, prlimit64, 340, 4) -#endif -#ifndef OVERRIDE_TABLE_32_clock_adjtime -TRACE_SYSCALL_TABLE(clock_adjtime, clock_adjtime, 343, 2) -#endif -#ifndef OVERRIDE_TABLE_32_sendmmsg -TRACE_SYSCALL_TABLE(sendmmsg, sendmmsg, 345, 4) -#endif - -#endif /* CREATE_SYSCALL_TABLE */ diff --git a/instrumentation/syscalls/headers/x86-32-syscalls_pointers_override.h b/instrumentation/syscalls/headers/x86-32-syscalls_pointers_override.h deleted file mode 100644 index e93213f6..00000000 --- a/instrumentation/syscalls/headers/x86-32-syscalls_pointers_override.h +++ /dev/null @@ -1,44 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ - -#ifndef CREATE_SYSCALL_TABLE - -# ifndef CONFIG_UID16 -# define OVERRIDE_32_getgroups16 -# define OVERRIDE_32_setgroups16 -# define OVERRIDE_32_lchown16 -# define OVERRIDE_32_getresuid16 -# define OVERRIDE_32_getresgid16 -# define OVERRIDE_32_chown16 -# endif - -#define OVERRIDE_32_pipe -#define OVERRIDE_64_pipe -SC_LTTNG_TRACEPOINT_EVENT(pipe, - TP_PROTO(sc_exit(long ret,) int * fildes), - TP_ARGS(sc_exit(ret,) fildes), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) - sc_out(ctf_user_array(int, fildes, fildes, 2)) - ) -) - -#else /* CREATE_SYSCALL_TABLE */ - -# ifndef CONFIG_UID16 -# define OVERRIDE_TABLE_32_getgroups16 -# define OVERRIDE_TABLE_32_setgroups16 -# define OVERRIDE_TABLE_32_lchown16 -# define OVERRIDE_TABLE_32_getresuid16 -# define OVERRIDE_TABLE_32_getresgid16 -# define OVERRIDE_TABLE_32_chown16 -# endif - -#define OVERRIDE_TABLE_32_execve -TRACE_SYSCALL_TABLE(execve, execve, 11, 3) -#define OVERRIDE_TABLE_32_clone -TRACE_SYSCALL_TABLE(clone, clone, 120, 5) -#define OVERRIDE_TABLE_32_getcpu -TRACE_SYSCALL_TABLE(getcpu, getcpu, 318, 3) - -#endif /* CREATE_SYSCALL_TABLE */ - - diff --git a/instrumentation/syscalls/headers/x86-64-syscalls_integers.h b/instrumentation/syscalls/headers/x86-64-syscalls_integers.h deleted file mode 100644 index c2963921..00000000 --- a/instrumentation/syscalls/headers/x86-64-syscalls_integers.h +++ /dev/null @@ -1,1104 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ - -/* THIS FILE IS AUTO-GENERATED. DO NOT EDIT */ - -/* Generated from x86-64-syscalls 3.10.0-rc7 */ - -#ifndef CREATE_SYSCALL_TABLE - -#if !defined(_TRACE_SYSCALLS_INTEGERS_H) || defined(TRACE_HEADER_MULTI_READ) -#define _TRACE_SYSCALLS_INTEGERS_H - -#include -#include -#include "x86-64-syscalls_integers_override.h" -#include "syscalls_integers_override.h" - -#ifdef SC_ENTER -SC_LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(syscalls_noargs, - TP_FIELDS() -) -#ifndef OVERRIDE_64_sched_yield -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, sched_yield) -#endif -#ifndef OVERRIDE_64_pause -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, pause) -#endif -#ifndef OVERRIDE_64_getpid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getpid) -#endif -#ifndef OVERRIDE_64_getuid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getuid) -#endif -#ifndef OVERRIDE_64_getgid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getgid) -#endif -#ifndef OVERRIDE_64_geteuid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, geteuid) -#endif -#ifndef OVERRIDE_64_getegid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getegid) -#endif -#ifndef OVERRIDE_64_getppid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getppid) -#endif -#ifndef OVERRIDE_64_getpgrp -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, getpgrp) -#endif -#ifndef OVERRIDE_64_setsid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, setsid) -#endif -#ifndef OVERRIDE_64_munlockall -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, munlockall) -#endif -#ifndef OVERRIDE_64_vhangup -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, vhangup) -#endif -#ifndef OVERRIDE_64_sync -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, sync) -#endif -#ifndef OVERRIDE_64_gettid -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, gettid) -#endif -#ifndef OVERRIDE_64_restart_syscall -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, restart_syscall) -#endif -#ifndef OVERRIDE_64_inotify_init -SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, inotify_init) -#endif -#else /* #ifdef SC_ENTER */ -#ifndef OVERRIDE_64_sched_yield -SC_LTTNG_TRACEPOINT_EVENT(sched_yield, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_64_pause -SC_LTTNG_TRACEPOINT_EVENT(pause, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_64_getpid -SC_LTTNG_TRACEPOINT_EVENT(getpid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_64_getuid -SC_LTTNG_TRACEPOINT_EVENT(getuid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_64_getgid -SC_LTTNG_TRACEPOINT_EVENT(getgid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_64_geteuid -SC_LTTNG_TRACEPOINT_EVENT(geteuid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_64_getegid -SC_LTTNG_TRACEPOINT_EVENT(getegid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_64_getppid -SC_LTTNG_TRACEPOINT_EVENT(getppid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_64_getpgrp -SC_LTTNG_TRACEPOINT_EVENT(getpgrp, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_64_setsid -SC_LTTNG_TRACEPOINT_EVENT(setsid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_64_munlockall -SC_LTTNG_TRACEPOINT_EVENT(munlockall, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_64_vhangup -SC_LTTNG_TRACEPOINT_EVENT(vhangup, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_64_sync -SC_LTTNG_TRACEPOINT_EVENT(sync, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_64_gettid -SC_LTTNG_TRACEPOINT_EVENT(gettid, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_64_restart_syscall -SC_LTTNG_TRACEPOINT_EVENT(restart_syscall, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#ifndef OVERRIDE_64_inotify_init -SC_LTTNG_TRACEPOINT_EVENT(inotify_init, - TP_PROTO(sc_exit(long ret)), - TP_ARGS(sc_exit(ret)), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))) -) -#endif -#endif /* else #ifdef SC_ENTER */ -#ifndef OVERRIDE_64_close -SC_LTTNG_TRACEPOINT_EVENT(close, - TP_PROTO(sc_exit(long ret,) unsigned int fd), - TP_ARGS(sc_exit(ret,) fd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) -) -#endif -#ifndef OVERRIDE_64_brk -SC_LTTNG_TRACEPOINT_EVENT(brk, - TP_PROTO(sc_exit(long ret,) unsigned long brk), - TP_ARGS(sc_exit(ret,) brk), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, brk, brk))) -) -#endif -#ifndef OVERRIDE_64_dup -SC_LTTNG_TRACEPOINT_EVENT(dup, - TP_PROTO(sc_exit(long ret,) unsigned int fildes), - TP_ARGS(sc_exit(ret,) fildes), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fildes, fildes))) -) -#endif -#ifndef OVERRIDE_64_alarm -SC_LTTNG_TRACEPOINT_EVENT(alarm, - TP_PROTO(sc_exit(long ret,) unsigned int seconds), - TP_ARGS(sc_exit(ret,) seconds), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, seconds, seconds))) -) -#endif -#ifndef OVERRIDE_64_exit -SC_LTTNG_TRACEPOINT_EVENT(exit, - TP_PROTO(sc_exit(long ret,) int error_code), - TP_ARGS(sc_exit(ret,) error_code), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, error_code, error_code))) -) -#endif -#ifndef OVERRIDE_64_fsync -SC_LTTNG_TRACEPOINT_EVENT(fsync, - TP_PROTO(sc_exit(long ret,) unsigned int fd), - TP_ARGS(sc_exit(ret,) fd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) -) -#endif -#ifndef OVERRIDE_64_fdatasync -SC_LTTNG_TRACEPOINT_EVENT(fdatasync, - TP_PROTO(sc_exit(long ret,) unsigned int fd), - TP_ARGS(sc_exit(ret,) fd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) -) -#endif -#ifndef OVERRIDE_64_fchdir -SC_LTTNG_TRACEPOINT_EVENT(fchdir, - TP_PROTO(sc_exit(long ret,) unsigned int fd), - TP_ARGS(sc_exit(ret,) fd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd))) -) -#endif -#ifndef OVERRIDE_64_umask -SC_LTTNG_TRACEPOINT_EVENT(umask, - TP_PROTO(sc_exit(long ret,) int mask), - TP_ARGS(sc_exit(ret,) mask), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, mask, mask))) -) -#endif -#ifndef OVERRIDE_64_setuid -SC_LTTNG_TRACEPOINT_EVENT(setuid, - TP_PROTO(sc_exit(long ret,) uid_t uid), - TP_ARGS(sc_exit(ret,) uid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, uid, uid))) -) -#endif -#ifndef OVERRIDE_64_setgid -SC_LTTNG_TRACEPOINT_EVENT(setgid, - TP_PROTO(sc_exit(long ret,) gid_t gid), - TP_ARGS(sc_exit(ret,) gid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, gid, gid))) -) -#endif -#ifndef OVERRIDE_64_getpgid -SC_LTTNG_TRACEPOINT_EVENT(getpgid, - TP_PROTO(sc_exit(long ret,) pid_t pid), - TP_ARGS(sc_exit(ret,) pid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid))) -) -#endif -#ifndef OVERRIDE_64_setfsuid -SC_LTTNG_TRACEPOINT_EVENT(setfsuid, - TP_PROTO(sc_exit(long ret,) uid_t uid), - TP_ARGS(sc_exit(ret,) uid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, uid, uid))) -) -#endif -#ifndef OVERRIDE_64_setfsgid -SC_LTTNG_TRACEPOINT_EVENT(setfsgid, - TP_PROTO(sc_exit(long ret,) gid_t gid), - TP_ARGS(sc_exit(ret,) gid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, gid, gid))) -) -#endif -#ifndef OVERRIDE_64_getsid -SC_LTTNG_TRACEPOINT_EVENT(getsid, - TP_PROTO(sc_exit(long ret,) pid_t pid), - TP_ARGS(sc_exit(ret,) pid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid))) -) -#endif -#ifndef OVERRIDE_64_personality -SC_LTTNG_TRACEPOINT_EVENT(personality, - TP_PROTO(sc_exit(long ret,) unsigned int personality), - TP_ARGS(sc_exit(ret,) personality), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, personality, personality))) -) -#endif -#ifndef OVERRIDE_64_sched_getscheduler -SC_LTTNG_TRACEPOINT_EVENT(sched_getscheduler, - TP_PROTO(sc_exit(long ret,) pid_t pid), - TP_ARGS(sc_exit(ret,) pid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid))) -) -#endif -#ifndef OVERRIDE_64_sched_get_priority_max -SC_LTTNG_TRACEPOINT_EVENT(sched_get_priority_max, - TP_PROTO(sc_exit(long ret,) int policy), - TP_ARGS(sc_exit(ret,) policy), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, policy, policy))) -) -#endif -#ifndef OVERRIDE_64_sched_get_priority_min -SC_LTTNG_TRACEPOINT_EVENT(sched_get_priority_min, - TP_PROTO(sc_exit(long ret,) int policy), - TP_ARGS(sc_exit(ret,) policy), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, policy, policy))) -) -#endif -#ifndef OVERRIDE_64_mlockall -SC_LTTNG_TRACEPOINT_EVENT(mlockall, - TP_PROTO(sc_exit(long ret,) int flags), - TP_ARGS(sc_exit(ret,) flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_io_destroy -SC_LTTNG_TRACEPOINT_EVENT(io_destroy, - TP_PROTO(sc_exit(long ret,) aio_context_t ctx), - TP_ARGS(sc_exit(ret,) ctx), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx, ctx))) -) -#endif -#ifndef OVERRIDE_64_epoll_create -SC_LTTNG_TRACEPOINT_EVENT(epoll_create, - TP_PROTO(sc_exit(long ret,) int size), - TP_ARGS(sc_exit(ret,) size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, size, size))) -) -#endif -#ifndef OVERRIDE_64_timer_getoverrun -SC_LTTNG_TRACEPOINT_EVENT(timer_getoverrun, - TP_PROTO(sc_exit(long ret,) timer_t timer_id), - TP_ARGS(sc_exit(ret,) timer_id), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id))) -) -#endif -#ifndef OVERRIDE_64_timer_delete -SC_LTTNG_TRACEPOINT_EVENT(timer_delete, - TP_PROTO(sc_exit(long ret,) timer_t timer_id), - TP_ARGS(sc_exit(ret,) timer_id), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id))) -) -#endif -#ifndef OVERRIDE_64_exit_group -SC_LTTNG_TRACEPOINT_EVENT(exit_group, - TP_PROTO(sc_exit(long ret,) int error_code), - TP_ARGS(sc_exit(ret,) error_code), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, error_code, error_code))) -) -#endif -#ifndef OVERRIDE_64_unshare -SC_LTTNG_TRACEPOINT_EVENT(unshare, - TP_PROTO(sc_exit(long ret,) unsigned long unshare_flags), - TP_ARGS(sc_exit(ret,) unshare_flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, unshare_flags, unshare_flags))) -) -#endif -#ifndef OVERRIDE_64_eventfd -SC_LTTNG_TRACEPOINT_EVENT(eventfd, - TP_PROTO(sc_exit(long ret,) unsigned int count), - TP_ARGS(sc_exit(ret,) count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, count, count))) -) -#endif -#ifndef OVERRIDE_64_epoll_create1 -SC_LTTNG_TRACEPOINT_EVENT(epoll_create1, - TP_PROTO(sc_exit(long ret,) int flags), - TP_ARGS(sc_exit(ret,) flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_inotify_init1 -SC_LTTNG_TRACEPOINT_EVENT(inotify_init1, - TP_PROTO(sc_exit(long ret,) int flags), - TP_ARGS(sc_exit(ret,) flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_syncfs -SC_LTTNG_TRACEPOINT_EVENT(syncfs, - TP_PROTO(sc_exit(long ret,) int fd), - TP_ARGS(sc_exit(ret,) fd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd))) -) -#endif -#ifndef OVERRIDE_64_munmap -SC_LTTNG_TRACEPOINT_EVENT(munmap, - TP_PROTO(sc_exit(long ret,) unsigned long addr, size_t len), - TP_ARGS(sc_exit(ret,) addr, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, addr, addr)) sc_in(ctf_integer(size_t, len, len))) -) -#endif -#ifndef OVERRIDE_64_dup2 -SC_LTTNG_TRACEPOINT_EVENT(dup2, - TP_PROTO(sc_exit(long ret,) unsigned int oldfd, unsigned int newfd), - TP_ARGS(sc_exit(ret,) oldfd, newfd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, oldfd, oldfd)) sc_in(ctf_integer(unsigned int, newfd, newfd))) -) -#endif -#ifndef OVERRIDE_64_shutdown -SC_LTTNG_TRACEPOINT_EVENT(shutdown, - TP_PROTO(sc_exit(long ret,) int fd, int how), - TP_ARGS(sc_exit(ret,) fd, how), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, how, how))) -) -#endif -#ifndef OVERRIDE_64_listen -SC_LTTNG_TRACEPOINT_EVENT(listen, - TP_PROTO(sc_exit(long ret,) int fd, int backlog), - TP_ARGS(sc_exit(ret,) fd, backlog), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, backlog, backlog))) -) -#endif -#ifndef OVERRIDE_64_kill -SC_LTTNG_TRACEPOINT_EVENT(kill, - TP_PROTO(sc_exit(long ret,) pid_t pid, int sig), - TP_ARGS(sc_exit(ret,) pid, sig), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig))) -) -#endif -#ifndef OVERRIDE_64_msgget -SC_LTTNG_TRACEPOINT_EVENT(msgget, - TP_PROTO(sc_exit(long ret,) key_t key, int msgflg), - TP_ARGS(sc_exit(ret,) key, msgflg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(key_t, key, key)) sc_in(ctf_integer(int, msgflg, msgflg))) -) -#endif -#ifndef OVERRIDE_64_flock -SC_LTTNG_TRACEPOINT_EVENT(flock, - TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd), - TP_ARGS(sc_exit(ret,) fd, cmd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned int, cmd, cmd))) -) -#endif -#ifndef OVERRIDE_64_ftruncate -SC_LTTNG_TRACEPOINT_EVENT(ftruncate, - TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned long length), - TP_ARGS(sc_exit(ret,) fd, length), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned long, length, length))) -) -#endif -#ifndef OVERRIDE_64_fchmod -SC_LTTNG_TRACEPOINT_EVENT(fchmod, - TP_PROTO(sc_exit(long ret,) unsigned int fd, umode_t mode), - TP_ARGS(sc_exit(ret,) fd, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(umode_t, mode, mode))) -) -#endif -#ifndef OVERRIDE_64_setpgid -SC_LTTNG_TRACEPOINT_EVENT(setpgid, - TP_PROTO(sc_exit(long ret,) pid_t pid, pid_t pgid), - TP_ARGS(sc_exit(ret,) pid, pgid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(pid_t, pgid, pgid))) -) -#endif -#ifndef OVERRIDE_64_setreuid -SC_LTTNG_TRACEPOINT_EVENT(setreuid, - TP_PROTO(sc_exit(long ret,) uid_t ruid, uid_t euid), - TP_ARGS(sc_exit(ret,) ruid, euid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, ruid, ruid)) sc_in(ctf_integer(uid_t, euid, euid))) -) -#endif -#ifndef OVERRIDE_64_setregid -SC_LTTNG_TRACEPOINT_EVENT(setregid, - TP_PROTO(sc_exit(long ret,) gid_t rgid, gid_t egid), - TP_ARGS(sc_exit(ret,) rgid, egid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, rgid, rgid)) sc_in(ctf_integer(gid_t, egid, egid))) -) -#endif -#ifndef OVERRIDE_64_getpriority -SC_LTTNG_TRACEPOINT_EVENT(getpriority, - TP_PROTO(sc_exit(long ret,) int which, int who), - TP_ARGS(sc_exit(ret,) which, who), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who))) -) -#endif -#ifndef OVERRIDE_64_mlock -SC_LTTNG_TRACEPOINT_EVENT(mlock, - TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len), - TP_ARGS(sc_exit(ret,) start, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len))) -) -#endif -#ifndef OVERRIDE_64_munlock -SC_LTTNG_TRACEPOINT_EVENT(munlock, - TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len), - TP_ARGS(sc_exit(ret,) start, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len))) -) -#endif -#ifndef OVERRIDE_64_tkill -SC_LTTNG_TRACEPOINT_EVENT(tkill, - TP_PROTO(sc_exit(long ret,) pid_t pid, int sig), - TP_ARGS(sc_exit(ret,) pid, sig), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig))) -) -#endif -#ifndef OVERRIDE_64_ioprio_get -SC_LTTNG_TRACEPOINT_EVENT(ioprio_get, - TP_PROTO(sc_exit(long ret,) int which, int who), - TP_ARGS(sc_exit(ret,) which, who), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who))) -) -#endif -#ifndef OVERRIDE_64_inotify_rm_watch -SC_LTTNG_TRACEPOINT_EVENT(inotify_rm_watch, - TP_PROTO(sc_exit(long ret,) int fd, __s32 wd), - TP_ARGS(sc_exit(ret,) fd, wd), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(__s32, wd, wd))) -) -#endif -#ifndef OVERRIDE_64_timerfd_create -SC_LTTNG_TRACEPOINT_EVENT(timerfd_create, - TP_PROTO(sc_exit(long ret,) int clockid, int flags), - TP_ARGS(sc_exit(ret,) clockid, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, clockid, clockid)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_eventfd2 -SC_LTTNG_TRACEPOINT_EVENT(eventfd2, - TP_PROTO(sc_exit(long ret,) unsigned int count, int flags), - TP_ARGS(sc_exit(ret,) count, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, count, count)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_fanotify_init -SC_LTTNG_TRACEPOINT_EVENT(fanotify_init, - TP_PROTO(sc_exit(long ret,) unsigned int flags, unsigned int event_f_flags), - TP_ARGS(sc_exit(ret,) flags, event_f_flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, flags, flags)) sc_in(ctf_integer(unsigned int, event_f_flags, event_f_flags))) -) -#endif -#ifndef OVERRIDE_64_setns -SC_LTTNG_TRACEPOINT_EVENT(setns, - TP_PROTO(sc_exit(long ret,) int fd, int nstype), - TP_ARGS(sc_exit(ret,) fd, nstype), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, nstype, nstype))) -) -#endif -#ifndef OVERRIDE_64_lseek -SC_LTTNG_TRACEPOINT_EVENT(lseek, - TP_PROTO(sc_exit(long ret,) unsigned int fd, off_t offset, unsigned int whence), - TP_ARGS(sc_exit(ret,) fd, offset, whence), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(off_t, offset, offset)) sc_in(ctf_integer(unsigned int, whence, whence))) -) -#endif -#ifndef OVERRIDE_64_mprotect -SC_LTTNG_TRACEPOINT_EVENT(mprotect, - TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len, unsigned long prot), - TP_ARGS(sc_exit(ret,) start, len, prot), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned long, prot, prot))) -) -#endif -#ifndef OVERRIDE_64_ioctl -SC_LTTNG_TRACEPOINT_EVENT(ioctl, - TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd, unsigned long arg), - TP_ARGS(sc_exit(ret,) fd, cmd, arg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_inout(ctf_integer(unsigned long, arg, arg))) -) -#endif -#ifndef OVERRIDE_64_msync -SC_LTTNG_TRACEPOINT_EVENT(msync, - TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len, int flags), - TP_ARGS(sc_exit(ret,) start, len, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_madvise -SC_LTTNG_TRACEPOINT_EVENT(madvise, - TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len_in, int behavior), - TP_ARGS(sc_exit(ret,) start, len_in, behavior), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len_in, len_in)) sc_in(ctf_integer(int, behavior, behavior))) -) -#endif -#ifndef OVERRIDE_64_shmget -SC_LTTNG_TRACEPOINT_EVENT(shmget, - TP_PROTO(sc_exit(long ret,) key_t key, size_t size, int shmflg), - TP_ARGS(sc_exit(ret,) key, size, shmflg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(key_t, key, key)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(int, shmflg, shmflg))) -) -#endif -#ifndef OVERRIDE_64_socket -SC_LTTNG_TRACEPOINT_EVENT(socket, - TP_PROTO(sc_exit(long ret,) int family, int type, int protocol), - TP_ARGS(sc_exit(ret,) family, type, protocol), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, family, family)) sc_in(ctf_integer(int, type, type)) sc_in(ctf_integer(int, protocol, protocol))) -) -#endif -#ifndef OVERRIDE_64_semget -SC_LTTNG_TRACEPOINT_EVENT(semget, - TP_PROTO(sc_exit(long ret,) key_t key, int nsems, int semflg), - TP_ARGS(sc_exit(ret,) key, nsems, semflg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(key_t, key, key)) sc_in(ctf_integer(int, nsems, nsems)) sc_in(ctf_integer(int, semflg, semflg))) -) -#endif -#ifndef OVERRIDE_64_fcntl -SC_LTTNG_TRACEPOINT_EVENT(fcntl, - TP_PROTO(sc_exit(long ret,) unsigned int fd, unsigned int cmd, unsigned long arg), - TP_ARGS(sc_exit(ret,) fd, cmd, arg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_inout(ctf_integer(unsigned long, arg, arg))) -) -#endif -#ifndef OVERRIDE_64_fchown -SC_LTTNG_TRACEPOINT_EVENT(fchown, - TP_PROTO(sc_exit(long ret,) unsigned int fd, uid_t user, gid_t group), - TP_ARGS(sc_exit(ret,) fd, user, group), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group))) -) -#endif -#ifndef OVERRIDE_64_setresuid -SC_LTTNG_TRACEPOINT_EVENT(setresuid, - TP_PROTO(sc_exit(long ret,) uid_t ruid, uid_t euid, uid_t suid), - TP_ARGS(sc_exit(ret,) ruid, euid, suid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(uid_t, ruid, ruid)) sc_in(ctf_integer(uid_t, euid, euid)) sc_in(ctf_integer(uid_t, suid, suid))) -) -#endif -#ifndef OVERRIDE_64_setresgid -SC_LTTNG_TRACEPOINT_EVENT(setresgid, - TP_PROTO(sc_exit(long ret,) gid_t rgid, gid_t egid, gid_t sgid), - TP_ARGS(sc_exit(ret,) rgid, egid, sgid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(gid_t, rgid, rgid)) sc_in(ctf_integer(gid_t, egid, egid)) sc_in(ctf_integer(gid_t, sgid, sgid))) -) -#endif -#ifndef OVERRIDE_64_sysfs -SC_LTTNG_TRACEPOINT_EVENT(sysfs, - TP_PROTO(sc_exit(long ret,) int option, unsigned long arg1, unsigned long arg2), - TP_ARGS(sc_exit(ret,) option, arg1, arg2), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, option, option)) sc_in(ctf_integer(unsigned long, arg1, arg1)) sc_in(ctf_integer(unsigned long, arg2, arg2))) -) -#endif -#ifndef OVERRIDE_64_setpriority -SC_LTTNG_TRACEPOINT_EVENT(setpriority, - TP_PROTO(sc_exit(long ret,) int which, int who, int niceval), - TP_ARGS(sc_exit(ret,) which, who, niceval), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who)) sc_in(ctf_integer(int, niceval, niceval))) -) -#endif -#ifndef OVERRIDE_64_readahead -SC_LTTNG_TRACEPOINT_EVENT(readahead, - TP_PROTO(sc_exit(long ret,) int fd, loff_t offset, size_t count), - TP_ARGS(sc_exit(ret,) fd, offset, count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(loff_t, offset, offset)) sc_in(ctf_integer(size_t, count, count))) -) -#endif -#ifndef OVERRIDE_64_tgkill -SC_LTTNG_TRACEPOINT_EVENT(tgkill, - TP_PROTO(sc_exit(long ret,) pid_t tgid, pid_t pid, int sig), - TP_ARGS(sc_exit(ret,) tgid, pid, sig), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, tgid, tgid)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig))) -) -#endif -#ifndef OVERRIDE_64_ioprio_set -SC_LTTNG_TRACEPOINT_EVENT(ioprio_set, - TP_PROTO(sc_exit(long ret,) int which, int who, int ioprio), - TP_ARGS(sc_exit(ret,) which, who, ioprio), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(int, who, who)) sc_in(ctf_integer(int, ioprio, ioprio))) -) -#endif -#ifndef OVERRIDE_64_dup3 -SC_LTTNG_TRACEPOINT_EVENT(dup3, - TP_PROTO(sc_exit(long ret,) unsigned int oldfd, unsigned int newfd, int flags), - TP_ARGS(sc_exit(ret,) oldfd, newfd, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, oldfd, oldfd)) sc_in(ctf_integer(unsigned int, newfd, newfd)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_semctl -SC_LTTNG_TRACEPOINT_EVENT(semctl, - TP_PROTO(sc_exit(long ret,) int semid, int semnum, int cmd, unsigned long arg), - TP_ARGS(sc_exit(ret,) semid, semnum, cmd, arg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, semid, semid)) sc_in(ctf_integer(int, semnum, semnum)) sc_in(ctf_integer(int, cmd, cmd)) sc_inout(ctf_integer(unsigned long, arg, arg))) -) -#endif -#ifndef OVERRIDE_64_ptrace -SC_LTTNG_TRACEPOINT_EVENT(ptrace, - TP_PROTO(sc_exit(long ret,) long request, long pid, unsigned long addr, unsigned long data), - TP_ARGS(sc_exit(ret,) request, pid, addr, data), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(long, request, request)) sc_in(ctf_integer(long, pid, pid)) sc_inout(ctf_integer(unsigned long, addr, addr)) sc_inout(ctf_integer(unsigned long, data, data))) -) -#endif -#ifndef OVERRIDE_64_fadvise64 -SC_LTTNG_TRACEPOINT_EVENT(fadvise64, - TP_PROTO(sc_exit(long ret,) int fd, loff_t offset, size_t len, int advice), - TP_ARGS(sc_exit(ret,) fd, offset, len, advice), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(loff_t, offset, offset)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(int, advice, advice))) -) -#endif -#ifndef OVERRIDE_64_tee -SC_LTTNG_TRACEPOINT_EVENT(tee, - TP_PROTO(sc_exit(long ret,) int fdin, int fdout, size_t len, unsigned int flags), - TP_ARGS(sc_exit(ret,) fdin, fdout, len, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fdin, fdin)) sc_in(ctf_integer(int, fdout, fdout)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_sync_file_range -SC_LTTNG_TRACEPOINT_EVENT(sync_file_range, - TP_PROTO(sc_exit(long ret,) int fd, loff_t offset, loff_t nbytes, unsigned int flags), - TP_ARGS(sc_exit(ret,) fd, offset, nbytes, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(loff_t, offset, offset)) sc_in(ctf_integer(loff_t, nbytes, nbytes)) sc_in(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_fallocate -SC_LTTNG_TRACEPOINT_EVENT(fallocate, - TP_PROTO(sc_exit(long ret,) int fd, int mode, loff_t offset, loff_t len), - TP_ARGS(sc_exit(ret,) fd, mode, offset, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, mode, mode)) sc_in(ctf_integer(loff_t, offset, offset)) sc_in(ctf_integer(loff_t, len, len))) -) -#endif -#ifndef OVERRIDE_64_mremap -SC_LTTNG_TRACEPOINT_EVENT(mremap, - TP_PROTO(sc_exit(long ret,) unsigned long addr, unsigned long old_len, unsigned long new_len, unsigned long flags, unsigned long new_addr), - TP_ARGS(sc_exit(ret,) addr, old_len, new_len, flags, new_addr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, addr, addr)) sc_in(ctf_integer(unsigned long, old_len, old_len)) sc_in(ctf_integer(unsigned long, new_len, new_len)) sc_in(ctf_integer(unsigned long, flags, flags)) sc_in(ctf_integer(unsigned long, new_addr, new_addr))) -) -#endif -#ifndef OVERRIDE_64_prctl -SC_LTTNG_TRACEPOINT_EVENT(prctl, - TP_PROTO(sc_exit(long ret,) int option, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5), - TP_ARGS(sc_exit(ret,) option, arg2, arg3, arg4, arg5), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, option, option)) sc_inout(ctf_integer(unsigned long, arg2, arg2)) sc_in(ctf_integer(unsigned long, arg3, arg3)) sc_in(ctf_integer(unsigned long, arg4, arg4)) sc_in(ctf_integer(unsigned long, arg5, arg5))) -) -#endif -#ifndef OVERRIDE_64_remap_file_pages -SC_LTTNG_TRACEPOINT_EVENT(remap_file_pages, - TP_PROTO(sc_exit(long ret,) unsigned long start, unsigned long size, unsigned long prot, unsigned long pgoff, unsigned long flags), - TP_ARGS(sc_exit(ret,) start, size, prot, pgoff, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(unsigned long, size, size)) sc_in(ctf_integer(unsigned long, prot, prot)) sc_in(ctf_integer(unsigned long, pgoff, pgoff)) sc_in(ctf_integer(unsigned long, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_keyctl -SC_LTTNG_TRACEPOINT_EVENT(keyctl, - TP_PROTO(sc_exit(long ret,) int option, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5), - TP_ARGS(sc_exit(ret,) option, arg2, arg3, arg4, arg5), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, option, option)) sc_inout(ctf_integer(unsigned long, arg2, arg2)) sc_inout(ctf_integer(unsigned long, arg3, arg3)) sc_inout(ctf_integer(unsigned long, arg4, arg4)) sc_inout(ctf_integer(unsigned long, arg5, arg5))) -) -#endif -#ifndef OVERRIDE_64_mmap -SC_LTTNG_TRACEPOINT_EVENT(mmap, - TP_PROTO(sc_exit(long ret,) unsigned long addr, unsigned long len, unsigned long prot, unsigned long flags, unsigned long fd, unsigned long off), - TP_ARGS(sc_exit(ret,) addr, len, prot, flags, fd, off), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, addr, addr)) sc_in(ctf_integer(unsigned long, len, len)) sc_in(ctf_integer(unsigned long, prot, prot)) sc_in(ctf_integer(unsigned long, flags, flags)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_in(ctf_integer(unsigned long, off, off))) -) -#endif - -#endif /* _TRACE_SYSCALLS_INTEGERS_H */ - -/* This part must be outside protection */ -#include - -#else /* CREATE_SYSCALL_TABLE */ - -#include "x86-64-syscalls_integers_override.h" -#include "syscalls_integers_override.h" - -#ifdef SC_ENTER -#ifndef OVERRIDE_TABLE_64_sched_yield -TRACE_SYSCALL_TABLE(syscalls_noargs, sched_yield, 24, 0) -#endif -#ifndef OVERRIDE_TABLE_64_pause -TRACE_SYSCALL_TABLE(syscalls_noargs, pause, 34, 0) -#endif -#ifndef OVERRIDE_TABLE_64_getpid -TRACE_SYSCALL_TABLE(syscalls_noargs, getpid, 39, 0) -#endif -#ifndef OVERRIDE_TABLE_64_getuid -TRACE_SYSCALL_TABLE(syscalls_noargs, getuid, 102, 0) -#endif -#ifndef OVERRIDE_TABLE_64_getgid -TRACE_SYSCALL_TABLE(syscalls_noargs, getgid, 104, 0) -#endif -#ifndef OVERRIDE_TABLE_64_geteuid -TRACE_SYSCALL_TABLE(syscalls_noargs, geteuid, 107, 0) -#endif -#ifndef OVERRIDE_TABLE_64_getegid -TRACE_SYSCALL_TABLE(syscalls_noargs, getegid, 108, 0) -#endif -#ifndef OVERRIDE_TABLE_64_getppid -TRACE_SYSCALL_TABLE(syscalls_noargs, getppid, 110, 0) -#endif -#ifndef OVERRIDE_TABLE_64_getpgrp -TRACE_SYSCALL_TABLE(syscalls_noargs, getpgrp, 111, 0) -#endif -#ifndef OVERRIDE_TABLE_64_setsid -TRACE_SYSCALL_TABLE(syscalls_noargs, setsid, 112, 0) -#endif -#ifndef OVERRIDE_TABLE_64_munlockall -TRACE_SYSCALL_TABLE(syscalls_noargs, munlockall, 152, 0) -#endif -#ifndef OVERRIDE_TABLE_64_vhangup -TRACE_SYSCALL_TABLE(syscalls_noargs, vhangup, 153, 0) -#endif -#ifndef OVERRIDE_TABLE_64_sync -TRACE_SYSCALL_TABLE(syscalls_noargs, sync, 162, 0) -#endif -#ifndef OVERRIDE_TABLE_64_gettid -TRACE_SYSCALL_TABLE(syscalls_noargs, gettid, 186, 0) -#endif -#ifndef OVERRIDE_TABLE_64_restart_syscall -TRACE_SYSCALL_TABLE(syscalls_noargs, restart_syscall, 219, 0) -#endif -#ifndef OVERRIDE_TABLE_64_inotify_init -TRACE_SYSCALL_TABLE(syscalls_noargs, inotify_init, 253, 0) -#endif -#else /* #ifdef SC_ENTER */ -#ifndef OVERRIDE_TABLE_64_sched_yield -TRACE_SYSCALL_TABLE(sched_yield, sched_yield, 24, 0) -#endif -#ifndef OVERRIDE_TABLE_64_pause -TRACE_SYSCALL_TABLE(pause, pause, 34, 0) -#endif -#ifndef OVERRIDE_TABLE_64_getpid -TRACE_SYSCALL_TABLE(getpid, getpid, 39, 0) -#endif -#ifndef OVERRIDE_TABLE_64_getuid -TRACE_SYSCALL_TABLE(getuid, getuid, 102, 0) -#endif -#ifndef OVERRIDE_TABLE_64_getgid -TRACE_SYSCALL_TABLE(getgid, getgid, 104, 0) -#endif -#ifndef OVERRIDE_TABLE_64_geteuid -TRACE_SYSCALL_TABLE(geteuid, geteuid, 107, 0) -#endif -#ifndef OVERRIDE_TABLE_64_getegid -TRACE_SYSCALL_TABLE(getegid, getegid, 108, 0) -#endif -#ifndef OVERRIDE_TABLE_64_getppid -TRACE_SYSCALL_TABLE(getppid, getppid, 110, 0) -#endif -#ifndef OVERRIDE_TABLE_64_getpgrp -TRACE_SYSCALL_TABLE(getpgrp, getpgrp, 111, 0) -#endif -#ifndef OVERRIDE_TABLE_64_setsid -TRACE_SYSCALL_TABLE(setsid, setsid, 112, 0) -#endif -#ifndef OVERRIDE_TABLE_64_munlockall -TRACE_SYSCALL_TABLE(munlockall, munlockall, 152, 0) -#endif -#ifndef OVERRIDE_TABLE_64_vhangup -TRACE_SYSCALL_TABLE(vhangup, vhangup, 153, 0) -#endif -#ifndef OVERRIDE_TABLE_64_sync -TRACE_SYSCALL_TABLE(sync, sync, 162, 0) -#endif -#ifndef OVERRIDE_TABLE_64_gettid -TRACE_SYSCALL_TABLE(gettid, gettid, 186, 0) -#endif -#ifndef OVERRIDE_TABLE_64_restart_syscall -TRACE_SYSCALL_TABLE(restart_syscall, restart_syscall, 219, 0) -#endif -#ifndef OVERRIDE_TABLE_64_inotify_init -TRACE_SYSCALL_TABLE(inotify_init, inotify_init, 253, 0) -#endif -#endif /* else #ifdef SC_ENTER */ -#ifndef OVERRIDE_TABLE_64_close -TRACE_SYSCALL_TABLE(close, close, 3, 1) -#endif -#ifndef OVERRIDE_TABLE_64_lseek -TRACE_SYSCALL_TABLE(lseek, lseek, 8, 3) -#endif -#ifndef OVERRIDE_TABLE_64_mmap -TRACE_SYSCALL_TABLE(mmap, mmap, 9, 6) -#endif -#ifndef OVERRIDE_TABLE_64_mprotect -TRACE_SYSCALL_TABLE(mprotect, mprotect, 10, 3) -#endif -#ifndef OVERRIDE_TABLE_64_munmap -TRACE_SYSCALL_TABLE(munmap, munmap, 11, 2) -#endif -#ifndef OVERRIDE_TABLE_64_brk -TRACE_SYSCALL_TABLE(brk, brk, 12, 1) -#endif -#ifndef OVERRIDE_TABLE_64_ioctl -TRACE_SYSCALL_TABLE(ioctl, ioctl, 16, 3) -#endif -#ifndef OVERRIDE_TABLE_64_mremap -TRACE_SYSCALL_TABLE(mremap, mremap, 25, 5) -#endif -#ifndef OVERRIDE_TABLE_64_msync -TRACE_SYSCALL_TABLE(msync, msync, 26, 3) -#endif -#ifndef OVERRIDE_TABLE_64_madvise -TRACE_SYSCALL_TABLE(madvise, madvise, 28, 3) -#endif -#ifndef OVERRIDE_TABLE_64_shmget -TRACE_SYSCALL_TABLE(shmget, shmget, 29, 3) -#endif -#ifndef OVERRIDE_TABLE_64_dup -TRACE_SYSCALL_TABLE(dup, dup, 32, 1) -#endif -#ifndef OVERRIDE_TABLE_64_dup2 -TRACE_SYSCALL_TABLE(dup2, dup2, 33, 2) -#endif -#ifndef OVERRIDE_TABLE_64_alarm -TRACE_SYSCALL_TABLE(alarm, alarm, 37, 1) -#endif -#ifndef OVERRIDE_TABLE_64_socket -TRACE_SYSCALL_TABLE(socket, socket, 41, 3) -#endif -#ifndef OVERRIDE_TABLE_64_shutdown -TRACE_SYSCALL_TABLE(shutdown, shutdown, 48, 2) -#endif -#ifndef OVERRIDE_TABLE_64_listen -TRACE_SYSCALL_TABLE(listen, listen, 50, 2) -#endif -#ifndef OVERRIDE_TABLE_64_exit -TRACE_SYSCALL_TABLE(exit, exit, 60, 1) -#endif -#ifndef OVERRIDE_TABLE_64_kill -TRACE_SYSCALL_TABLE(kill, kill, 62, 2) -#endif -#ifndef OVERRIDE_TABLE_64_semget -TRACE_SYSCALL_TABLE(semget, semget, 64, 3) -#endif -#ifndef OVERRIDE_TABLE_64_semctl -TRACE_SYSCALL_TABLE(semctl, semctl, 66, 4) -#endif -#ifndef OVERRIDE_TABLE_64_msgget -TRACE_SYSCALL_TABLE(msgget, msgget, 68, 2) -#endif -#ifndef OVERRIDE_TABLE_64_fcntl -TRACE_SYSCALL_TABLE(fcntl, fcntl, 72, 3) -#endif -#ifndef OVERRIDE_TABLE_64_flock -TRACE_SYSCALL_TABLE(flock, flock, 73, 2) -#endif -#ifndef OVERRIDE_TABLE_64_fsync -TRACE_SYSCALL_TABLE(fsync, fsync, 74, 1) -#endif -#ifndef OVERRIDE_TABLE_64_fdatasync -TRACE_SYSCALL_TABLE(fdatasync, fdatasync, 75, 1) -#endif -#ifndef OVERRIDE_TABLE_64_ftruncate -TRACE_SYSCALL_TABLE(ftruncate, ftruncate, 77, 2) -#endif -#ifndef OVERRIDE_TABLE_64_fchdir -TRACE_SYSCALL_TABLE(fchdir, fchdir, 81, 1) -#endif -#ifndef OVERRIDE_TABLE_64_fchmod -TRACE_SYSCALL_TABLE(fchmod, fchmod, 91, 2) -#endif -#ifndef OVERRIDE_TABLE_64_fchown -TRACE_SYSCALL_TABLE(fchown, fchown, 93, 3) -#endif -#ifndef OVERRIDE_TABLE_64_umask -TRACE_SYSCALL_TABLE(umask, umask, 95, 1) -#endif -#ifndef OVERRIDE_TABLE_64_ptrace -TRACE_SYSCALL_TABLE(ptrace, ptrace, 101, 4) -#endif -#ifndef OVERRIDE_TABLE_64_setuid -TRACE_SYSCALL_TABLE(setuid, setuid, 105, 1) -#endif -#ifndef OVERRIDE_TABLE_64_setgid -TRACE_SYSCALL_TABLE(setgid, setgid, 106, 1) -#endif -#ifndef OVERRIDE_TABLE_64_setpgid -TRACE_SYSCALL_TABLE(setpgid, setpgid, 109, 2) -#endif -#ifndef OVERRIDE_TABLE_64_setreuid -TRACE_SYSCALL_TABLE(setreuid, setreuid, 113, 2) -#endif -#ifndef OVERRIDE_TABLE_64_setregid -TRACE_SYSCALL_TABLE(setregid, setregid, 114, 2) -#endif -#ifndef OVERRIDE_TABLE_64_setresuid -TRACE_SYSCALL_TABLE(setresuid, setresuid, 117, 3) -#endif -#ifndef OVERRIDE_TABLE_64_setresgid -TRACE_SYSCALL_TABLE(setresgid, setresgid, 119, 3) -#endif -#ifndef OVERRIDE_TABLE_64_getpgid -TRACE_SYSCALL_TABLE(getpgid, getpgid, 121, 1) -#endif -#ifndef OVERRIDE_TABLE_64_setfsuid -TRACE_SYSCALL_TABLE(setfsuid, setfsuid, 122, 1) -#endif -#ifndef OVERRIDE_TABLE_64_setfsgid -TRACE_SYSCALL_TABLE(setfsgid, setfsgid, 123, 1) -#endif -#ifndef OVERRIDE_TABLE_64_getsid -TRACE_SYSCALL_TABLE(getsid, getsid, 124, 1) -#endif -#ifndef OVERRIDE_TABLE_64_personality -TRACE_SYSCALL_TABLE(personality, personality, 135, 1) -#endif -#ifndef OVERRIDE_TABLE_64_sysfs -TRACE_SYSCALL_TABLE(sysfs, sysfs, 139, 3) -#endif -#ifndef OVERRIDE_TABLE_64_getpriority -TRACE_SYSCALL_TABLE(getpriority, getpriority, 140, 2) -#endif -#ifndef OVERRIDE_TABLE_64_setpriority -TRACE_SYSCALL_TABLE(setpriority, setpriority, 141, 3) -#endif -#ifndef OVERRIDE_TABLE_64_sched_getscheduler -TRACE_SYSCALL_TABLE(sched_getscheduler, sched_getscheduler, 145, 1) -#endif -#ifndef OVERRIDE_TABLE_64_sched_get_priority_max -TRACE_SYSCALL_TABLE(sched_get_priority_max, sched_get_priority_max, 146, 1) -#endif -#ifndef OVERRIDE_TABLE_64_sched_get_priority_min -TRACE_SYSCALL_TABLE(sched_get_priority_min, sched_get_priority_min, 147, 1) -#endif -#ifndef OVERRIDE_TABLE_64_mlock -TRACE_SYSCALL_TABLE(mlock, mlock, 149, 2) -#endif -#ifndef OVERRIDE_TABLE_64_munlock -TRACE_SYSCALL_TABLE(munlock, munlock, 150, 2) -#endif -#ifndef OVERRIDE_TABLE_64_mlockall -TRACE_SYSCALL_TABLE(mlockall, mlockall, 151, 1) -#endif -#ifndef OVERRIDE_TABLE_64_prctl -TRACE_SYSCALL_TABLE(prctl, prctl, 157, 5) -#endif -#ifndef OVERRIDE_TABLE_64_readahead -TRACE_SYSCALL_TABLE(readahead, readahead, 187, 3) -#endif -#ifndef OVERRIDE_TABLE_64_tkill -TRACE_SYSCALL_TABLE(tkill, tkill, 200, 2) -#endif -#ifndef OVERRIDE_TABLE_64_io_destroy -TRACE_SYSCALL_TABLE(io_destroy, io_destroy, 207, 1) -#endif -#ifndef OVERRIDE_TABLE_64_epoll_create -TRACE_SYSCALL_TABLE(epoll_create, epoll_create, 213, 1) -#endif -#ifndef OVERRIDE_TABLE_64_remap_file_pages -TRACE_SYSCALL_TABLE(remap_file_pages, remap_file_pages, 216, 5) -#endif -#ifndef OVERRIDE_TABLE_64_fadvise64 -TRACE_SYSCALL_TABLE(fadvise64, fadvise64, 221, 4) -#endif -#ifndef OVERRIDE_TABLE_64_timer_getoverrun -TRACE_SYSCALL_TABLE(timer_getoverrun, timer_getoverrun, 225, 1) -#endif -#ifndef OVERRIDE_TABLE_64_timer_delete -TRACE_SYSCALL_TABLE(timer_delete, timer_delete, 226, 1) -#endif -#ifndef OVERRIDE_TABLE_64_exit_group -TRACE_SYSCALL_TABLE(exit_group, exit_group, 231, 1) -#endif -#ifndef OVERRIDE_TABLE_64_tgkill -TRACE_SYSCALL_TABLE(tgkill, tgkill, 234, 3) -#endif -#ifndef OVERRIDE_TABLE_64_keyctl -TRACE_SYSCALL_TABLE(keyctl, keyctl, 250, 5) -#endif -#ifndef OVERRIDE_TABLE_64_ioprio_set -TRACE_SYSCALL_TABLE(ioprio_set, ioprio_set, 251, 3) -#endif -#ifndef OVERRIDE_TABLE_64_ioprio_get -TRACE_SYSCALL_TABLE(ioprio_get, ioprio_get, 252, 2) -#endif -#ifndef OVERRIDE_TABLE_64_inotify_rm_watch -TRACE_SYSCALL_TABLE(inotify_rm_watch, inotify_rm_watch, 255, 2) -#endif -#ifndef OVERRIDE_TABLE_64_unshare -TRACE_SYSCALL_TABLE(unshare, unshare, 272, 1) -#endif -#ifndef OVERRIDE_TABLE_64_tee -TRACE_SYSCALL_TABLE(tee, tee, 276, 4) -#endif -#ifndef OVERRIDE_TABLE_64_sync_file_range -TRACE_SYSCALL_TABLE(sync_file_range, sync_file_range, 277, 4) -#endif -#ifndef OVERRIDE_TABLE_64_timerfd_create -TRACE_SYSCALL_TABLE(timerfd_create, timerfd_create, 283, 2) -#endif -#ifndef OVERRIDE_TABLE_64_eventfd -TRACE_SYSCALL_TABLE(eventfd, eventfd, 284, 1) -#endif -#ifndef OVERRIDE_TABLE_64_fallocate -TRACE_SYSCALL_TABLE(fallocate, fallocate, 285, 4) -#endif -#ifndef OVERRIDE_TABLE_64_eventfd2 -TRACE_SYSCALL_TABLE(eventfd2, eventfd2, 290, 2) -#endif -#ifndef OVERRIDE_TABLE_64_epoll_create1 -TRACE_SYSCALL_TABLE(epoll_create1, epoll_create1, 291, 1) -#endif -#ifndef OVERRIDE_TABLE_64_dup3 -TRACE_SYSCALL_TABLE(dup3, dup3, 292, 3) -#endif -#ifndef OVERRIDE_TABLE_64_inotify_init1 -TRACE_SYSCALL_TABLE(inotify_init1, inotify_init1, 294, 1) -#endif -#ifndef OVERRIDE_TABLE_64_fanotify_init -TRACE_SYSCALL_TABLE(fanotify_init, fanotify_init, 300, 2) -#endif -#ifndef OVERRIDE_TABLE_64_syncfs -TRACE_SYSCALL_TABLE(syncfs, syncfs, 306, 1) -#endif -#ifndef OVERRIDE_TABLE_64_setns -TRACE_SYSCALL_TABLE(setns, setns, 308, 2) -#endif - -#endif /* CREATE_SYSCALL_TABLE */ diff --git a/instrumentation/syscalls/headers/x86-64-syscalls_integers_override.h b/instrumentation/syscalls/headers/x86-64-syscalls_integers_override.h deleted file mode 100644 index a241399b..00000000 --- a/instrumentation/syscalls/headers/x86-64-syscalls_integers_override.h +++ /dev/null @@ -1,5 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ - -/* - * this is a place-holder for x86_64 integer syscall definition override. - */ diff --git a/instrumentation/syscalls/headers/x86-64-syscalls_pointers.h b/instrumentation/syscalls/headers/x86-64-syscalls_pointers.h deleted file mode 100644 index 0d084882..00000000 --- a/instrumentation/syscalls/headers/x86-64-syscalls_pointers.h +++ /dev/null @@ -1,1929 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ - -/* THIS FILE IS AUTO-GENERATED. DO NOT EDIT */ - -/* Generated from x86-64-syscalls 3.10.0-rc7 */ - -#ifndef CREATE_SYSCALL_TABLE - -#if !defined(_TRACE_SYSCALLS_POINTERS_H) || defined(TRACE_HEADER_MULTI_READ) -#define _TRACE_SYSCALLS_POINTERS_H - -#include -#include -#include "x86-64-syscalls_pointers_override.h" -#include "syscalls_pointers_override.h" - -#ifndef OVERRIDE_64_pipe -SC_LTTNG_TRACEPOINT_EVENT(pipe, - TP_PROTO(sc_exit(long ret,) int * fildes), - TP_ARGS(sc_exit(ret,) fildes), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(int *, fildes, fildes))) -) -#endif -#ifndef OVERRIDE_64_newuname -SC_LTTNG_TRACEPOINT_EVENT(newuname, - TP_PROTO(sc_exit(long ret,) struct new_utsname * name), - TP_ARGS(sc_exit(ret,) name), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct new_utsname *, name, name))) -) -#endif -#ifndef OVERRIDE_64_shmdt -SC_LTTNG_TRACEPOINT_EVENT(shmdt, - TP_PROTO(sc_exit(long ret,) char * shmaddr), - TP_ARGS(sc_exit(ret,) shmaddr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(char *, shmaddr, shmaddr))) -) -#endif -#ifndef OVERRIDE_64_chdir -SC_LTTNG_TRACEPOINT_EVENT(chdir, - TP_PROTO(sc_exit(long ret,) const char * filename), - TP_ARGS(sc_exit(ret,) filename), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename))) -) -#endif -#ifndef OVERRIDE_64_rmdir -SC_LTTNG_TRACEPOINT_EVENT(rmdir, - TP_PROTO(sc_exit(long ret,) const char * pathname), - TP_ARGS(sc_exit(ret,) pathname), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname))) -) -#endif -#ifndef OVERRIDE_64_unlink -SC_LTTNG_TRACEPOINT_EVENT(unlink, - TP_PROTO(sc_exit(long ret,) const char * pathname), - TP_ARGS(sc_exit(ret,) pathname), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname))) -) -#endif -#ifndef OVERRIDE_64_sysinfo -SC_LTTNG_TRACEPOINT_EVENT(sysinfo, - TP_PROTO(sc_exit(long ret,) struct sysinfo * info), - TP_ARGS(sc_exit(ret,) info), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct sysinfo *, info, info))) -) -#endif -#ifndef OVERRIDE_64_times -SC_LTTNG_TRACEPOINT_EVENT(times, - TP_PROTO(sc_exit(long ret,) struct tms * tbuf), - TP_ARGS(sc_exit(ret,) tbuf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct tms *, tbuf, tbuf))) -) -#endif -#ifndef OVERRIDE_64_sysctl -SC_LTTNG_TRACEPOINT_EVENT(sysctl, - TP_PROTO(sc_exit(long ret,) struct __sysctl_args * args), - TP_ARGS(sc_exit(ret,) args), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct __sysctl_args *, args, args))) -) -#endif -#ifndef OVERRIDE_64_adjtimex -SC_LTTNG_TRACEPOINT_EVENT(adjtimex, - TP_PROTO(sc_exit(long ret,) struct timex * txc_p), - TP_ARGS(sc_exit(ret,) txc_p), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct timex *, txc_p, txc_p))) -) -#endif -#ifndef OVERRIDE_64_chroot -SC_LTTNG_TRACEPOINT_EVENT(chroot, - TP_PROTO(sc_exit(long ret,) const char * filename), - TP_ARGS(sc_exit(ret,) filename), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename))) -) -#endif -#ifndef OVERRIDE_64_acct -SC_LTTNG_TRACEPOINT_EVENT(acct, - TP_PROTO(sc_exit(long ret,) const char * name), - TP_ARGS(sc_exit(ret,) name), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name))) -) -#endif -#ifndef OVERRIDE_64_swapoff -SC_LTTNG_TRACEPOINT_EVENT(swapoff, - TP_PROTO(sc_exit(long ret,) const char * specialfile), - TP_ARGS(sc_exit(ret,) specialfile), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(specialfile, specialfile))) -) -#endif -#ifndef OVERRIDE_64_time -SC_LTTNG_TRACEPOINT_EVENT(time, - TP_PROTO(sc_exit(long ret,) time_t * tloc), - TP_ARGS(sc_exit(ret,) tloc), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(time_t *, tloc, tloc))) -) -#endif -#ifndef OVERRIDE_64_set_tid_address -SC_LTTNG_TRACEPOINT_EVENT(set_tid_address, - TP_PROTO(sc_exit(long ret,) int * tidptr), - TP_ARGS(sc_exit(ret,) tidptr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int *, tidptr, tidptr))) -) -#endif -#ifndef OVERRIDE_64_mq_unlink -SC_LTTNG_TRACEPOINT_EVENT(mq_unlink, - TP_PROTO(sc_exit(long ret,) const char * u_name), - TP_ARGS(sc_exit(ret,) u_name), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(u_name, u_name))) -) -#endif -#ifndef OVERRIDE_64_newstat -SC_LTTNG_TRACEPOINT_EVENT(newstat, - TP_PROTO(sc_exit(long ret,) const char * filename, struct stat * statbuf), - TP_ARGS(sc_exit(ret,) filename, statbuf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_out(ctf_integer(struct stat *, statbuf, statbuf))) -) -#endif -#ifndef OVERRIDE_64_newfstat -SC_LTTNG_TRACEPOINT_EVENT(newfstat, - TP_PROTO(sc_exit(long ret,) unsigned int fd, struct stat * statbuf), - TP_ARGS(sc_exit(ret,) fd, statbuf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct stat *, statbuf, statbuf))) -) -#endif -#ifndef OVERRIDE_64_newlstat -SC_LTTNG_TRACEPOINT_EVENT(newlstat, - TP_PROTO(sc_exit(long ret,) const char * filename, struct stat * statbuf), - TP_ARGS(sc_exit(ret,) filename, statbuf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_out(ctf_integer(struct stat *, statbuf, statbuf))) -) -#endif -#ifndef OVERRIDE_64_access -SC_LTTNG_TRACEPOINT_EVENT(access, - TP_PROTO(sc_exit(long ret,) const char * filename, int mode), - TP_ARGS(sc_exit(ret,) filename, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, mode, mode))) -) -#endif -#ifndef OVERRIDE_64_nanosleep -SC_LTTNG_TRACEPOINT_EVENT(nanosleep, - TP_PROTO(sc_exit(long ret,) struct timespec * rqtp, struct timespec * rmtp), - TP_ARGS(sc_exit(ret,) rqtp, rmtp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct timespec *, rqtp, rqtp)) sc_out(ctf_integer(struct timespec *, rmtp, rmtp))) -) -#endif -#ifndef OVERRIDE_64_getitimer -SC_LTTNG_TRACEPOINT_EVENT(getitimer, - TP_PROTO(sc_exit(long ret,) int which, struct itimerval * value), - TP_ARGS(sc_exit(ret,) which, value), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_out(ctf_integer(struct itimerval *, value, value))) -) -#endif -#ifndef OVERRIDE_64_truncate -SC_LTTNG_TRACEPOINT_EVENT(truncate, - TP_PROTO(sc_exit(long ret,) const char * path, long length), - TP_ARGS(sc_exit(ret,) path, length), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(path, path)) sc_in(ctf_integer(long, length, length))) -) -#endif -#ifndef OVERRIDE_64_getcwd -SC_LTTNG_TRACEPOINT_EVENT(getcwd, - TP_PROTO(sc_exit(long ret,) char * buf, unsigned long size), - TP_ARGS(sc_exit(ret,) buf, size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(unsigned long, size, size))) -) -#endif -#ifndef OVERRIDE_64_rename -SC_LTTNG_TRACEPOINT_EVENT(rename, - TP_PROTO(sc_exit(long ret,) const char * oldname, const char * newname), - TP_ARGS(sc_exit(ret,) oldname, newname), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_user_string(newname, newname))) -) -#endif -#ifndef OVERRIDE_64_mkdir -SC_LTTNG_TRACEPOINT_EVENT(mkdir, - TP_PROTO(sc_exit(long ret,) const char * pathname, umode_t mode), - TP_ARGS(sc_exit(ret,) pathname, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(umode_t, mode, mode))) -) -#endif -#ifndef OVERRIDE_64_creat -SC_LTTNG_TRACEPOINT_EVENT(creat, - TP_PROTO(sc_exit(long ret,) const char * pathname, umode_t mode), - TP_ARGS(sc_exit(ret,) pathname, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(umode_t, mode, mode))) -) -#endif -#ifndef OVERRIDE_64_link -SC_LTTNG_TRACEPOINT_EVENT(link, - TP_PROTO(sc_exit(long ret,) const char * oldname, const char * newname), - TP_ARGS(sc_exit(ret,) oldname, newname), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_user_string(newname, newname))) -) -#endif -#ifndef OVERRIDE_64_symlink -SC_LTTNG_TRACEPOINT_EVENT(symlink, - TP_PROTO(sc_exit(long ret,) const char * oldname, const char * newname), - TP_ARGS(sc_exit(ret,) oldname, newname), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_user_string(newname, newname))) -) -#endif -#ifndef OVERRIDE_64_chmod -SC_LTTNG_TRACEPOINT_EVENT(chmod, - TP_PROTO(sc_exit(long ret,) const char * filename, umode_t mode), - TP_ARGS(sc_exit(ret,) filename, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(umode_t, mode, mode))) -) -#endif -#ifndef OVERRIDE_64_gettimeofday -SC_LTTNG_TRACEPOINT_EVENT(gettimeofday, - TP_PROTO(sc_exit(long ret,) struct timeval * tv, struct timezone * tz), - TP_ARGS(sc_exit(ret,) tv, tz), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(struct timeval *, tv, tv)) sc_out(ctf_integer(struct timezone *, tz, tz))) -) -#endif -#ifndef OVERRIDE_64_getrlimit -SC_LTTNG_TRACEPOINT_EVENT(getrlimit, - TP_PROTO(sc_exit(long ret,) unsigned int resource, struct rlimit * rlim), - TP_ARGS(sc_exit(ret,) resource, rlim), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, resource, resource)) sc_out(ctf_integer(struct rlimit *, rlim, rlim))) -) -#endif -#ifndef OVERRIDE_64_getrusage -SC_LTTNG_TRACEPOINT_EVENT(getrusage, - TP_PROTO(sc_exit(long ret,) int who, struct rusage * ru), - TP_ARGS(sc_exit(ret,) who, ru), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, who, who)) sc_out(ctf_integer(struct rusage *, ru, ru))) -) -#endif -#ifndef OVERRIDE_64_getgroups -SC_LTTNG_TRACEPOINT_EVENT(getgroups, - TP_PROTO(sc_exit(long ret,) int gidsetsize, gid_t * grouplist), - TP_ARGS(sc_exit(ret,) gidsetsize, grouplist), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, gidsetsize, gidsetsize)) sc_out(ctf_integer(gid_t *, grouplist, grouplist))) -) -#endif -#ifndef OVERRIDE_64_setgroups -SC_LTTNG_TRACEPOINT_EVENT(setgroups, - TP_PROTO(sc_exit(long ret,) int gidsetsize, gid_t * grouplist), - TP_ARGS(sc_exit(ret,) gidsetsize, grouplist), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, gidsetsize, gidsetsize)) sc_in(ctf_integer(gid_t *, grouplist, grouplist))) -) -#endif -#ifndef OVERRIDE_64_rt_sigpending -SC_LTTNG_TRACEPOINT_EVENT(rt_sigpending, - TP_PROTO(sc_exit(long ret,) sigset_t * uset, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) uset, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(sigset_t *, uset, uset)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) -) -#endif -#ifndef OVERRIDE_64_rt_sigsuspend -SC_LTTNG_TRACEPOINT_EVENT(rt_sigsuspend, - TP_PROTO(sc_exit(long ret,) sigset_t * unewset, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) unewset, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(sigset_t *, unewset, unewset)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) -) -#endif -#ifndef OVERRIDE_64_sigaltstack -SC_LTTNG_TRACEPOINT_EVENT(sigaltstack, - TP_PROTO(sc_exit(long ret,) const stack_t * uss, stack_t * uoss), - TP_ARGS(sc_exit(ret,) uss, uoss), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const stack_t *, uss, uss)) sc_inout(ctf_integer(stack_t *, uoss, uoss))) -) -#endif -#ifndef OVERRIDE_64_utime -SC_LTTNG_TRACEPOINT_EVENT(utime, - TP_PROTO(sc_exit(long ret,) char * filename, struct utimbuf * times), - TP_ARGS(sc_exit(ret,) filename, times), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(struct utimbuf *, times, times))) -) -#endif -#ifndef OVERRIDE_64_ustat -SC_LTTNG_TRACEPOINT_EVENT(ustat, - TP_PROTO(sc_exit(long ret,) unsigned dev, struct ustat * ubuf), - TP_ARGS(sc_exit(ret,) dev, ubuf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned, dev, dev)) sc_out(ctf_integer(struct ustat *, ubuf, ubuf))) -) -#endif -#ifndef OVERRIDE_64_statfs -SC_LTTNG_TRACEPOINT_EVENT(statfs, - TP_PROTO(sc_exit(long ret,) const char * pathname, struct statfs * buf), - TP_ARGS(sc_exit(ret,) pathname, buf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(struct statfs *, buf, buf))) -) -#endif -#ifndef OVERRIDE_64_fstatfs -SC_LTTNG_TRACEPOINT_EVENT(fstatfs, - TP_PROTO(sc_exit(long ret,) unsigned int fd, struct statfs * buf), - TP_ARGS(sc_exit(ret,) fd, buf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct statfs *, buf, buf))) -) -#endif -#ifndef OVERRIDE_64_sched_setparam -SC_LTTNG_TRACEPOINT_EVENT(sched_setparam, - TP_PROTO(sc_exit(long ret,) pid_t pid, struct sched_param * param), - TP_ARGS(sc_exit(ret,) pid, param), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(struct sched_param *, param, param))) -) -#endif -#ifndef OVERRIDE_64_sched_getparam -SC_LTTNG_TRACEPOINT_EVENT(sched_getparam, - TP_PROTO(sc_exit(long ret,) pid_t pid, struct sched_param * param), - TP_ARGS(sc_exit(ret,) pid, param), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_out(ctf_integer(struct sched_param *, param, param))) -) -#endif -#ifndef OVERRIDE_64_sched_rr_get_interval -SC_LTTNG_TRACEPOINT_EVENT(sched_rr_get_interval, - TP_PROTO(sc_exit(long ret,) pid_t pid, struct timespec * interval), - TP_ARGS(sc_exit(ret,) pid, interval), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_out(ctf_integer(struct timespec *, interval, interval))) -) -#endif -#ifndef OVERRIDE_64_pivot_root -SC_LTTNG_TRACEPOINT_EVENT(pivot_root, - TP_PROTO(sc_exit(long ret,) const char * new_root, const char * put_old), - TP_ARGS(sc_exit(ret,) new_root, put_old), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(new_root, new_root)) sc_in(ctf_user_string(put_old, put_old))) -) -#endif -#ifndef OVERRIDE_64_setrlimit -SC_LTTNG_TRACEPOINT_EVENT(setrlimit, - TP_PROTO(sc_exit(long ret,) unsigned int resource, struct rlimit * rlim), - TP_ARGS(sc_exit(ret,) resource, rlim), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, resource, resource)) sc_in(ctf_integer(struct rlimit *, rlim, rlim))) -) -#endif -#ifndef OVERRIDE_64_settimeofday -SC_LTTNG_TRACEPOINT_EVENT(settimeofday, - TP_PROTO(sc_exit(long ret,) struct timeval * tv, struct timezone * tz), - TP_ARGS(sc_exit(ret,) tv, tz), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct timeval *, tv, tv)) sc_in(ctf_integer(struct timezone *, tz, tz))) -) -#endif -#ifndef OVERRIDE_64_umount -SC_LTTNG_TRACEPOINT_EVENT(umount, - TP_PROTO(sc_exit(long ret,) char * name, int flags), - TP_ARGS(sc_exit(ret,) name, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_swapon -SC_LTTNG_TRACEPOINT_EVENT(swapon, - TP_PROTO(sc_exit(long ret,) const char * specialfile, int swap_flags), - TP_ARGS(sc_exit(ret,) specialfile, swap_flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(specialfile, specialfile)) sc_in(ctf_integer(int, swap_flags, swap_flags))) -) -#endif -#ifndef OVERRIDE_64_sethostname -SC_LTTNG_TRACEPOINT_EVENT(sethostname, - TP_PROTO(sc_exit(long ret,) char * name, int len), - TP_ARGS(sc_exit(ret,) name, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(int, len, len))) -) -#endif -#ifndef OVERRIDE_64_setdomainname -SC_LTTNG_TRACEPOINT_EVENT(setdomainname, - TP_PROTO(sc_exit(long ret,) char * name, int len), - TP_ARGS(sc_exit(ret,) name, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(int, len, len))) -) -#endif -#ifndef OVERRIDE_64_delete_module -SC_LTTNG_TRACEPOINT_EVENT(delete_module, - TP_PROTO(sc_exit(long ret,) const char * name_user, unsigned int flags), - TP_ARGS(sc_exit(ret,) name_user, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(name_user, name_user)) sc_in(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_removexattr -SC_LTTNG_TRACEPOINT_EVENT(removexattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name), - TP_ARGS(sc_exit(ret,) pathname, name), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name))) -) -#endif -#ifndef OVERRIDE_64_lremovexattr -SC_LTTNG_TRACEPOINT_EVENT(lremovexattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name), - TP_ARGS(sc_exit(ret,) pathname, name), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name))) -) -#endif -#ifndef OVERRIDE_64_fremovexattr -SC_LTTNG_TRACEPOINT_EVENT(fremovexattr, - TP_PROTO(sc_exit(long ret,) int fd, const char * name), - TP_ARGS(sc_exit(ret,) fd, name), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(name, name))) -) -#endif -#ifndef OVERRIDE_64_io_setup -SC_LTTNG_TRACEPOINT_EVENT(io_setup, - TP_PROTO(sc_exit(long ret,) unsigned nr_events, aio_context_t * ctxp), - TP_ARGS(sc_exit(ret,) nr_events, ctxp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned, nr_events, nr_events)) sc_in(ctf_integer(aio_context_t *, ctxp, ctxp))) -) -#endif -#ifndef OVERRIDE_64_timer_gettime -SC_LTTNG_TRACEPOINT_EVENT(timer_gettime, - TP_PROTO(sc_exit(long ret,) timer_t timer_id, struct itimerspec * setting), - TP_ARGS(sc_exit(ret,) timer_id, setting), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id)) sc_out(ctf_integer(struct itimerspec *, setting, setting))) -) -#endif -#ifndef OVERRIDE_64_clock_settime -SC_LTTNG_TRACEPOINT_EVENT(clock_settime, - TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, const struct timespec * tp), - TP_ARGS(sc_exit(ret,) which_clock, tp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_in(ctf_integer(const struct timespec *, tp, tp))) -) -#endif -#ifndef OVERRIDE_64_clock_gettime -SC_LTTNG_TRACEPOINT_EVENT(clock_gettime, - TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct timespec * tp), - TP_ARGS(sc_exit(ret,) which_clock, tp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_out(ctf_integer(struct timespec *, tp, tp))) -) -#endif -#ifndef OVERRIDE_64_clock_getres -SC_LTTNG_TRACEPOINT_EVENT(clock_getres, - TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct timespec * tp), - TP_ARGS(sc_exit(ret,) which_clock, tp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_out(ctf_integer(struct timespec *, tp, tp))) -) -#endif -#ifndef OVERRIDE_64_utimes -SC_LTTNG_TRACEPOINT_EVENT(utimes, - TP_PROTO(sc_exit(long ret,) char * filename, struct timeval * utimes), - TP_ARGS(sc_exit(ret,) filename, utimes), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(struct timeval *, utimes, utimes))) -) -#endif -#ifndef OVERRIDE_64_mq_notify -SC_LTTNG_TRACEPOINT_EVENT(mq_notify, - TP_PROTO(sc_exit(long ret,) mqd_t mqdes, const struct sigevent * u_notification), - TP_ARGS(sc_exit(ret,) mqdes, u_notification), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(mqd_t, mqdes, mqdes)) sc_in(ctf_integer(const struct sigevent *, u_notification, u_notification))) -) -#endif -#ifndef OVERRIDE_64_set_robust_list -SC_LTTNG_TRACEPOINT_EVENT(set_robust_list, - TP_PROTO(sc_exit(long ret,) struct robust_list_head * head, size_t len), - TP_ARGS(sc_exit(ret,) head, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct robust_list_head *, head, head)) sc_in(ctf_integer(size_t, len, len))) -) -#endif -#ifndef OVERRIDE_64_timerfd_gettime -SC_LTTNG_TRACEPOINT_EVENT(timerfd_gettime, - TP_PROTO(sc_exit(long ret,) int ufd, struct itimerspec * otmr), - TP_ARGS(sc_exit(ret,) ufd, otmr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_out(ctf_integer(struct itimerspec *, otmr, otmr))) -) -#endif -#ifndef OVERRIDE_64_pipe2 -SC_LTTNG_TRACEPOINT_EVENT(pipe2, - TP_PROTO(sc_exit(long ret,) int * fildes, int flags), - TP_ARGS(sc_exit(ret,) fildes, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(int *, fildes, fildes)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_clock_adjtime -SC_LTTNG_TRACEPOINT_EVENT(clock_adjtime, - TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct timex * utx), - TP_ARGS(sc_exit(ret,) which_clock, utx), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_inout(ctf_integer(struct timex *, utx, utx))) -) -#endif -#ifndef OVERRIDE_64_read -SC_LTTNG_TRACEPOINT_EVENT(read, - TP_PROTO(sc_exit(long ret,) unsigned int fd, char * buf, size_t count), - TP_ARGS(sc_exit(ret,) fd, buf, count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(size_t, count, count))) -) -#endif -#ifndef OVERRIDE_64_write -SC_LTTNG_TRACEPOINT_EVENT(write, - TP_PROTO(sc_exit(long ret,) unsigned int fd, const char * buf, size_t count), - TP_ARGS(sc_exit(ret,) fd, buf, count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(const char *, buf, buf)) sc_in(ctf_integer(size_t, count, count))) -) -#endif -#ifndef OVERRIDE_64_open -SC_LTTNG_TRACEPOINT_EVENT(open, - TP_PROTO(sc_exit(long ret,) const char * filename, int flags, umode_t mode), - TP_ARGS(sc_exit(ret,) filename, flags, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(umode_t, mode, mode))) -) -#endif -#ifndef OVERRIDE_64_poll -SC_LTTNG_TRACEPOINT_EVENT(poll, - TP_PROTO(sc_exit(long ret,) struct pollfd * ufds, unsigned int nfds, int timeout_msecs), - TP_ARGS(sc_exit(ret,) ufds, nfds, timeout_msecs), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct pollfd *, ufds, ufds)) sc_in(ctf_integer(unsigned int, nfds, nfds)) sc_in(ctf_integer(int, timeout_msecs, timeout_msecs))) -) -#endif -#ifndef OVERRIDE_64_readv -SC_LTTNG_TRACEPOINT_EVENT(readv, - TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen), - TP_ARGS(sc_exit(ret,) fd, vec, vlen), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_inout(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen))) -) -#endif -#ifndef OVERRIDE_64_writev -SC_LTTNG_TRACEPOINT_EVENT(writev, - TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen), - TP_ARGS(sc_exit(ret,) fd, vec, vlen), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_inout(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen))) -) -#endif -#ifndef OVERRIDE_64_mincore -SC_LTTNG_TRACEPOINT_EVENT(mincore, - TP_PROTO(sc_exit(long ret,) unsigned long start, size_t len, unsigned char * vec), - TP_ARGS(sc_exit(ret,) start, len, vec), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(size_t, len, len)) sc_out(ctf_integer(unsigned char *, vec, vec))) -) -#endif -#ifndef OVERRIDE_64_shmat -SC_LTTNG_TRACEPOINT_EVENT(shmat, - TP_PROTO(sc_exit(long ret,) int shmid, char * shmaddr, int shmflg), - TP_ARGS(sc_exit(ret,) shmid, shmaddr, shmflg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, shmid, shmid)) sc_in(ctf_integer(char *, shmaddr, shmaddr)) sc_in(ctf_integer(int, shmflg, shmflg))) -) -#endif -#ifndef OVERRIDE_64_shmctl -SC_LTTNG_TRACEPOINT_EVENT(shmctl, - TP_PROTO(sc_exit(long ret,) int shmid, int cmd, struct shmid_ds * buf), - TP_ARGS(sc_exit(ret,) shmid, cmd, buf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, shmid, shmid)) sc_in(ctf_integer(int, cmd, cmd)) sc_inout(ctf_integer(struct shmid_ds *, buf, buf))) -) -#endif -#ifndef OVERRIDE_64_setitimer -SC_LTTNG_TRACEPOINT_EVENT(setitimer, - TP_PROTO(sc_exit(long ret,) int which, struct itimerval * value, struct itimerval * ovalue), - TP_ARGS(sc_exit(ret,) which, value, ovalue), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(struct itimerval *, value, value)) sc_out(ctf_integer(struct itimerval *, ovalue, ovalue))) -) -#endif -#ifndef OVERRIDE_64_connect -SC_LTTNG_TRACEPOINT_EVENT(connect, - TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * uservaddr, int addrlen), - TP_ARGS(sc_exit(ret,) fd, uservaddr, addrlen), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct sockaddr *, uservaddr, uservaddr)) sc_in(ctf_integer(int, addrlen, addrlen))) -) -#endif -#ifndef OVERRIDE_64_accept -SC_LTTNG_TRACEPOINT_EVENT(accept, - TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * upeer_sockaddr, int * upeer_addrlen), - TP_ARGS(sc_exit(ret,) fd, upeer_sockaddr, upeer_addrlen), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct sockaddr *, upeer_sockaddr, upeer_sockaddr)) sc_inout(ctf_integer(int *, upeer_addrlen, upeer_addrlen))) -) -#endif -#ifndef OVERRIDE_64_sendmsg -SC_LTTNG_TRACEPOINT_EVENT(sendmsg, - TP_PROTO(sc_exit(long ret,) int fd, struct msghdr * msg, unsigned int flags), - TP_ARGS(sc_exit(ret,) fd, msg, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct msghdr *, msg, msg)) sc_in(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_recvmsg -SC_LTTNG_TRACEPOINT_EVENT(recvmsg, - TP_PROTO(sc_exit(long ret,) int fd, struct msghdr * msg, unsigned int flags), - TP_ARGS(sc_exit(ret,) fd, msg, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_inout(ctf_integer(struct msghdr *, msg, msg)) sc_in(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_bind -SC_LTTNG_TRACEPOINT_EVENT(bind, - TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * umyaddr, int addrlen), - TP_ARGS(sc_exit(ret,) fd, umyaddr, addrlen), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct sockaddr *, umyaddr, umyaddr)) sc_in(ctf_integer(int, addrlen, addrlen))) -) -#endif -#ifndef OVERRIDE_64_getsockname -SC_LTTNG_TRACEPOINT_EVENT(getsockname, - TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * usockaddr, int * usockaddr_len), - TP_ARGS(sc_exit(ret,) fd, usockaddr, usockaddr_len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct sockaddr *, usockaddr, usockaddr)) sc_inout(ctf_integer(int *, usockaddr_len, usockaddr_len))) -) -#endif -#ifndef OVERRIDE_64_getpeername -SC_LTTNG_TRACEPOINT_EVENT(getpeername, - TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * usockaddr, int * usockaddr_len), - TP_ARGS(sc_exit(ret,) fd, usockaddr, usockaddr_len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct sockaddr *, usockaddr, usockaddr)) sc_inout(ctf_integer(int *, usockaddr_len, usockaddr_len))) -) -#endif -#ifndef OVERRIDE_64_semop -SC_LTTNG_TRACEPOINT_EVENT(semop, - TP_PROTO(sc_exit(long ret,) int semid, struct sembuf * tsops, unsigned nsops), - TP_ARGS(sc_exit(ret,) semid, tsops, nsops), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, semid, semid)) sc_in(ctf_integer(struct sembuf *, tsops, tsops)) sc_in(ctf_integer(unsigned, nsops, nsops))) -) -#endif -#ifndef OVERRIDE_64_msgctl -SC_LTTNG_TRACEPOINT_EVENT(msgctl, - TP_PROTO(sc_exit(long ret,) int msqid, int cmd, struct msqid_ds * buf), - TP_ARGS(sc_exit(ret,) msqid, cmd, buf), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, msqid, msqid)) sc_in(ctf_integer(int, cmd, cmd)) sc_inout(ctf_integer(struct msqid_ds *, buf, buf))) -) -#endif -#ifndef OVERRIDE_64_getdents -SC_LTTNG_TRACEPOINT_EVENT(getdents, - TP_PROTO(sc_exit(long ret,) unsigned int fd, struct linux_dirent * dirent, unsigned int count), - TP_ARGS(sc_exit(ret,) fd, dirent, count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct linux_dirent *, dirent, dirent)) sc_in(ctf_integer(unsigned int, count, count))) -) -#endif -#ifndef OVERRIDE_64_readlink -SC_LTTNG_TRACEPOINT_EVENT(readlink, - TP_PROTO(sc_exit(long ret,) const char * path, char * buf, int bufsiz), - TP_ARGS(sc_exit(ret,) path, buf, bufsiz), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(path, path)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(int, bufsiz, bufsiz))) -) -#endif -#ifndef OVERRIDE_64_chown -SC_LTTNG_TRACEPOINT_EVENT(chown, - TP_PROTO(sc_exit(long ret,) const char * filename, uid_t user, gid_t group), - TP_ARGS(sc_exit(ret,) filename, user, group), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group))) -) -#endif -#ifndef OVERRIDE_64_lchown -SC_LTTNG_TRACEPOINT_EVENT(lchown, - TP_PROTO(sc_exit(long ret,) const char * filename, uid_t user, gid_t group), - TP_ARGS(sc_exit(ret,) filename, user, group), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group))) -) -#endif -#ifndef OVERRIDE_64_syslog -SC_LTTNG_TRACEPOINT_EVENT(syslog, - TP_PROTO(sc_exit(long ret,) int type, char * buf, int len), - TP_ARGS(sc_exit(ret,) type, buf, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, type, type)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(int, len, len))) -) -#endif -#ifndef OVERRIDE_64_getresuid -SC_LTTNG_TRACEPOINT_EVENT(getresuid, - TP_PROTO(sc_exit(long ret,) uid_t * ruidp, uid_t * euidp, uid_t * suidp), - TP_ARGS(sc_exit(ret,) ruidp, euidp, suidp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(uid_t *, ruidp, ruidp)) sc_out(ctf_integer(uid_t *, euidp, euidp)) sc_out(ctf_integer(uid_t *, suidp, suidp))) -) -#endif -#ifndef OVERRIDE_64_getresgid -SC_LTTNG_TRACEPOINT_EVENT(getresgid, - TP_PROTO(sc_exit(long ret,) gid_t * rgidp, gid_t * egidp, gid_t * sgidp), - TP_ARGS(sc_exit(ret,) rgidp, egidp, sgidp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(gid_t *, rgidp, rgidp)) sc_out(ctf_integer(gid_t *, egidp, egidp)) sc_out(ctf_integer(gid_t *, sgidp, sgidp))) -) -#endif -#ifndef OVERRIDE_64_rt_sigqueueinfo -SC_LTTNG_TRACEPOINT_EVENT(rt_sigqueueinfo, - TP_PROTO(sc_exit(long ret,) pid_t pid, int sig, siginfo_t * uinfo), - TP_ARGS(sc_exit(ret,) pid, sig, uinfo), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig)) sc_in(ctf_integer(siginfo_t *, uinfo, uinfo))) -) -#endif -#ifndef OVERRIDE_64_mknod -SC_LTTNG_TRACEPOINT_EVENT(mknod, - TP_PROTO(sc_exit(long ret,) const char * filename, umode_t mode, unsigned dev), - TP_ARGS(sc_exit(ret,) filename, mode, dev), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(umode_t, mode, mode)) sc_in(ctf_integer(unsigned, dev, dev))) -) -#endif -#ifndef OVERRIDE_64_sched_setscheduler -SC_LTTNG_TRACEPOINT_EVENT(sched_setscheduler, - TP_PROTO(sc_exit(long ret,) pid_t pid, int policy, struct sched_param * param), - TP_ARGS(sc_exit(ret,) pid, policy, param), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, policy, policy)) sc_in(ctf_integer(struct sched_param *, param, param))) -) -#endif -#ifndef OVERRIDE_64_init_module -SC_LTTNG_TRACEPOINT_EVENT(init_module, - TP_PROTO(sc_exit(long ret,) void * umod, unsigned long len, const char * uargs), - TP_ARGS(sc_exit(ret,) umod, len, uargs), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(void *, umod, umod)) sc_in(ctf_integer(unsigned long, len, len)) sc_in(ctf_integer(const char *, uargs, uargs))) -) -#endif -#ifndef OVERRIDE_64_listxattr -SC_LTTNG_TRACEPOINT_EVENT(listxattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, char * list, size_t size), - TP_ARGS(sc_exit(ret,) pathname, list, size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(char *, list, list)) sc_in(ctf_integer(size_t, size, size))) -) -#endif -#ifndef OVERRIDE_64_llistxattr -SC_LTTNG_TRACEPOINT_EVENT(llistxattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, char * list, size_t size), - TP_ARGS(sc_exit(ret,) pathname, list, size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(char *, list, list)) sc_in(ctf_integer(size_t, size, size))) -) -#endif -#ifndef OVERRIDE_64_flistxattr -SC_LTTNG_TRACEPOINT_EVENT(flistxattr, - TP_PROTO(sc_exit(long ret,) int fd, char * list, size_t size), - TP_ARGS(sc_exit(ret,) fd, list, size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(char *, list, list)) sc_in(ctf_integer(size_t, size, size))) -) -#endif -#ifndef OVERRIDE_64_sched_setaffinity -SC_LTTNG_TRACEPOINT_EVENT(sched_setaffinity, - TP_PROTO(sc_exit(long ret,) pid_t pid, unsigned int len, unsigned long * user_mask_ptr), - TP_ARGS(sc_exit(ret,) pid, len, user_mask_ptr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(unsigned int, len, len)) sc_in(ctf_integer(unsigned long *, user_mask_ptr, user_mask_ptr))) -) -#endif -#ifndef OVERRIDE_64_sched_getaffinity -SC_LTTNG_TRACEPOINT_EVENT(sched_getaffinity, - TP_PROTO(sc_exit(long ret,) pid_t pid, unsigned int len, unsigned long * user_mask_ptr), - TP_ARGS(sc_exit(ret,) pid, len, user_mask_ptr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(unsigned int, len, len)) sc_out(ctf_integer(unsigned long *, user_mask_ptr, user_mask_ptr))) -) -#endif -#ifndef OVERRIDE_64_io_submit -SC_LTTNG_TRACEPOINT_EVENT(io_submit, - TP_PROTO(sc_exit(long ret,) aio_context_t ctx_id, long nr, struct iocb * * iocbpp), - TP_ARGS(sc_exit(ret,) ctx_id, nr, iocbpp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx_id, ctx_id)) sc_in(ctf_integer(long, nr, nr)) sc_in(ctf_integer(struct iocb * *, iocbpp, iocbpp))) -) -#endif -#ifndef OVERRIDE_64_io_cancel -SC_LTTNG_TRACEPOINT_EVENT(io_cancel, - TP_PROTO(sc_exit(long ret,) aio_context_t ctx_id, struct iocb * iocb, struct io_event * result), - TP_ARGS(sc_exit(ret,) ctx_id, iocb, result), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx_id, ctx_id)) sc_in(ctf_integer(struct iocb *, iocb, iocb)) sc_out(ctf_integer(struct io_event *, result, result))) -) -#endif -#ifndef OVERRIDE_64_lookup_dcookie -SC_LTTNG_TRACEPOINT_EVENT(lookup_dcookie, - TP_PROTO(sc_exit(long ret,) u64 cookie64, char * buf, size_t len), - TP_ARGS(sc_exit(ret,) cookie64, buf, len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(u64, cookie64, cookie64)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(size_t, len, len))) -) -#endif -#ifndef OVERRIDE_64_getdents64 -SC_LTTNG_TRACEPOINT_EVENT(getdents64, - TP_PROTO(sc_exit(long ret,) unsigned int fd, struct linux_dirent64 * dirent, unsigned int count), - TP_ARGS(sc_exit(ret,) fd, dirent, count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(struct linux_dirent64 *, dirent, dirent)) sc_in(ctf_integer(unsigned int, count, count))) -) -#endif -#ifndef OVERRIDE_64_timer_create -SC_LTTNG_TRACEPOINT_EVENT(timer_create, - TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, struct sigevent * timer_event_spec, timer_t * created_timer_id), - TP_ARGS(sc_exit(ret,) which_clock, timer_event_spec, created_timer_id), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_in(ctf_integer(struct sigevent *, timer_event_spec, timer_event_spec)) sc_out(ctf_integer(timer_t *, created_timer_id, created_timer_id))) -) -#endif -#ifndef OVERRIDE_64_set_mempolicy -SC_LTTNG_TRACEPOINT_EVENT(set_mempolicy, - TP_PROTO(sc_exit(long ret,) int mode, unsigned long * nmask, unsigned long maxnode), - TP_ARGS(sc_exit(ret,) mode, nmask, maxnode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, mode, mode)) sc_in(ctf_integer(unsigned long *, nmask, nmask)) sc_in(ctf_integer(unsigned long, maxnode, maxnode))) -) -#endif -#ifndef OVERRIDE_64_mq_getsetattr -SC_LTTNG_TRACEPOINT_EVENT(mq_getsetattr, - TP_PROTO(sc_exit(long ret,) mqd_t mqdes, const struct mq_attr * u_mqstat, struct mq_attr * u_omqstat), - TP_ARGS(sc_exit(ret,) mqdes, u_mqstat, u_omqstat), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(mqd_t, mqdes, mqdes)) sc_in(ctf_integer(const struct mq_attr *, u_mqstat, u_mqstat)) sc_out(ctf_integer(struct mq_attr *, u_omqstat, u_omqstat))) -) -#endif -#ifndef OVERRIDE_64_inotify_add_watch -SC_LTTNG_TRACEPOINT_EVENT(inotify_add_watch, - TP_PROTO(sc_exit(long ret,) int fd, const char * pathname, u32 mask), - TP_ARGS(sc_exit(ret,) fd, pathname, mask), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(u32, mask, mask))) -) -#endif -#ifndef OVERRIDE_64_mkdirat -SC_LTTNG_TRACEPOINT_EVENT(mkdirat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * pathname, umode_t mode), - TP_ARGS(sc_exit(ret,) dfd, pathname, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(umode_t, mode, mode))) -) -#endif -#ifndef OVERRIDE_64_futimesat -SC_LTTNG_TRACEPOINT_EVENT(futimesat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, struct timeval * utimes), - TP_ARGS(sc_exit(ret,) dfd, filename, utimes), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(struct timeval *, utimes, utimes))) -) -#endif -#ifndef OVERRIDE_64_unlinkat -SC_LTTNG_TRACEPOINT_EVENT(unlinkat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * pathname, int flag), - TP_ARGS(sc_exit(ret,) dfd, pathname, flag), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_integer(int, flag, flag))) -) -#endif -#ifndef OVERRIDE_64_symlinkat -SC_LTTNG_TRACEPOINT_EVENT(symlinkat, - TP_PROTO(sc_exit(long ret,) const char * oldname, int newdfd, const char * newname), - TP_ARGS(sc_exit(ret,) oldname, newdfd, newname), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_integer(int, newdfd, newdfd)) sc_in(ctf_user_string(newname, newname))) -) -#endif -#ifndef OVERRIDE_64_fchmodat -SC_LTTNG_TRACEPOINT_EVENT(fchmodat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, umode_t mode), - TP_ARGS(sc_exit(ret,) dfd, filename, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(umode_t, mode, mode))) -) -#endif -#ifndef OVERRIDE_64_faccessat -SC_LTTNG_TRACEPOINT_EVENT(faccessat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, int mode), - TP_ARGS(sc_exit(ret,) dfd, filename, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, mode, mode))) -) -#endif -#ifndef OVERRIDE_64_get_robust_list -SC_LTTNG_TRACEPOINT_EVENT(get_robust_list, - TP_PROTO(sc_exit(long ret,) int pid, struct robust_list_head * * head_ptr, size_t * len_ptr), - TP_ARGS(sc_exit(ret,) pid, head_ptr, len_ptr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, pid, pid)) sc_out(ctf_integer(struct robust_list_head * *, head_ptr, head_ptr)) sc_out(ctf_integer(size_t *, len_ptr, len_ptr))) -) -#endif -#ifndef OVERRIDE_64_signalfd -SC_LTTNG_TRACEPOINT_EVENT(signalfd, - TP_PROTO(sc_exit(long ret,) int ufd, sigset_t * user_mask, size_t sizemask), - TP_ARGS(sc_exit(ret,) ufd, user_mask, sizemask), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_in(ctf_integer(sigset_t *, user_mask, user_mask)) sc_in(ctf_integer(size_t, sizemask, sizemask))) -) -#endif -#ifndef OVERRIDE_64_open_by_handle_at -SC_LTTNG_TRACEPOINT_EVENT(open_by_handle_at, - TP_PROTO(sc_exit(long ret,) int mountdirfd, struct file_handle * handle, int flags), - TP_ARGS(sc_exit(ret,) mountdirfd, handle, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, mountdirfd, mountdirfd)) sc_in(ctf_integer(struct file_handle *, handle, handle)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_getcpu -SC_LTTNG_TRACEPOINT_EVENT(getcpu, - TP_PROTO(sc_exit(long ret,) unsigned * cpup, unsigned * nodep, struct getcpu_cache * unused), - TP_ARGS(sc_exit(ret,) cpup, nodep, unused), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(unsigned *, cpup, cpup)) sc_out(ctf_integer(unsigned *, nodep, nodep)) sc_inout(ctf_integer(struct getcpu_cache *, unused, unused))) -) -#endif -#ifndef OVERRIDE_64_finit_module -SC_LTTNG_TRACEPOINT_EVENT(finit_module, - TP_PROTO(sc_exit(long ret,) int fd, const char * uargs, int flags), - TP_ARGS(sc_exit(ret,) fd, uargs, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(const char *, uargs, uargs)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_rt_sigaction -SC_LTTNG_TRACEPOINT_EVENT(rt_sigaction, - TP_PROTO(sc_exit(long ret,) int sig, const struct sigaction * act, struct sigaction * oact, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) sig, act, oact, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, sig, sig)) sc_in(ctf_integer(const struct sigaction *, act, act)) sc_out(ctf_integer(struct sigaction *, oact, oact)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) -) -#endif -#ifndef OVERRIDE_64_rt_sigprocmask -SC_LTTNG_TRACEPOINT_EVENT(rt_sigprocmask, - TP_PROTO(sc_exit(long ret,) int how, sigset_t * nset, sigset_t * oset, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) how, nset, oset, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, how, how)) sc_in(ctf_integer(sigset_t *, nset, nset)) sc_out(ctf_integer(sigset_t *, oset, oset)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) -) -#endif -#ifndef OVERRIDE_64_pread64 -SC_LTTNG_TRACEPOINT_EVENT(pread64, - TP_PROTO(sc_exit(long ret,) unsigned int fd, char * buf, size_t count, loff_t pos), - TP_ARGS(sc_exit(ret,) fd, buf, count, pos), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(size_t, count, count)) sc_in(ctf_integer(loff_t, pos, pos))) -) -#endif -#ifndef OVERRIDE_64_pwrite64 -SC_LTTNG_TRACEPOINT_EVENT(pwrite64, - TP_PROTO(sc_exit(long ret,) unsigned int fd, const char * buf, size_t count, loff_t pos), - TP_ARGS(sc_exit(ret,) fd, buf, count, pos), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, fd, fd)) sc_in(ctf_integer(const char *, buf, buf)) sc_in(ctf_integer(size_t, count, count)) sc_in(ctf_integer(loff_t, pos, pos))) -) -#endif -#ifndef OVERRIDE_64_sendfile64 -SC_LTTNG_TRACEPOINT_EVENT(sendfile64, - TP_PROTO(sc_exit(long ret,) int out_fd, int in_fd, loff_t * offset, size_t count), - TP_ARGS(sc_exit(ret,) out_fd, in_fd, offset, count), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, out_fd, out_fd)) sc_in(ctf_integer(int, in_fd, in_fd)) sc_inout(ctf_integer(loff_t *, offset, offset)) sc_in(ctf_integer(size_t, count, count))) -) -#endif -#ifndef OVERRIDE_64_socketpair -SC_LTTNG_TRACEPOINT_EVENT(socketpair, - TP_PROTO(sc_exit(long ret,) int family, int type, int protocol, int * usockvec), - TP_ARGS(sc_exit(ret,) family, type, protocol, usockvec), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, family, family)) sc_in(ctf_integer(int, type, type)) sc_in(ctf_integer(int, protocol, protocol)) sc_out(ctf_integer(int *, usockvec, usockvec))) -) -#endif -#ifndef OVERRIDE_64_wait4 -SC_LTTNG_TRACEPOINT_EVENT(wait4, - TP_PROTO(sc_exit(long ret,) pid_t upid, int * stat_addr, int options, struct rusage * ru), - TP_ARGS(sc_exit(ret,) upid, stat_addr, options, ru), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, upid, upid)) sc_out(ctf_integer(int *, stat_addr, stat_addr)) sc_in(ctf_integer(int, options, options)) sc_out(ctf_integer(struct rusage *, ru, ru))) -) -#endif -#ifndef OVERRIDE_64_msgsnd -SC_LTTNG_TRACEPOINT_EVENT(msgsnd, - TP_PROTO(sc_exit(long ret,) int msqid, struct msgbuf * msgp, size_t msgsz, int msgflg), - TP_ARGS(sc_exit(ret,) msqid, msgp, msgsz, msgflg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, msqid, msqid)) sc_in(ctf_integer(struct msgbuf *, msgp, msgp)) sc_in(ctf_integer(size_t, msgsz, msgsz)) sc_in(ctf_integer(int, msgflg, msgflg))) -) -#endif -#ifndef OVERRIDE_64_rt_sigtimedwait -SC_LTTNG_TRACEPOINT_EVENT(rt_sigtimedwait, - TP_PROTO(sc_exit(long ret,) const sigset_t * uthese, siginfo_t * uinfo, const struct timespec * uts, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) uthese, uinfo, uts, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(const sigset_t *, uthese, uthese)) sc_out(ctf_integer(siginfo_t *, uinfo, uinfo)) sc_in(ctf_integer(const struct timespec *, uts, uts)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) -) -#endif -#ifndef OVERRIDE_64_reboot -SC_LTTNG_TRACEPOINT_EVENT(reboot, - TP_PROTO(sc_exit(long ret,) int magic1, int magic2, unsigned int cmd, void * arg), - TP_ARGS(sc_exit(ret,) magic1, magic2, cmd, arg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, magic1, magic1)) sc_in(ctf_integer(int, magic2, magic2)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_in(ctf_integer(void *, arg, arg))) -) -#endif -#ifndef OVERRIDE_64_quotactl -SC_LTTNG_TRACEPOINT_EVENT(quotactl, - TP_PROTO(sc_exit(long ret,) unsigned int cmd, const char * special, qid_t id, void * addr), - TP_ARGS(sc_exit(ret,) cmd, special, id, addr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned int, cmd, cmd)) sc_in(ctf_integer(const char *, special, special)) sc_in(ctf_integer(qid_t, id, id)) sc_inout(ctf_integer(void *, addr, addr))) -) -#endif -#ifndef OVERRIDE_64_getxattr -SC_LTTNG_TRACEPOINT_EVENT(getxattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, void * value, size_t size), - TP_ARGS(sc_exit(ret,) pathname, name, value, size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_out(ctf_integer(void *, value, value)) sc_in(ctf_integer(size_t, size, size))) -) -#endif -#ifndef OVERRIDE_64_lgetxattr -SC_LTTNG_TRACEPOINT_EVENT(lgetxattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, void * value, size_t size), - TP_ARGS(sc_exit(ret,) pathname, name, value, size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_out(ctf_integer(void *, value, value)) sc_in(ctf_integer(size_t, size, size))) -) -#endif -#ifndef OVERRIDE_64_fgetxattr -SC_LTTNG_TRACEPOINT_EVENT(fgetxattr, - TP_PROTO(sc_exit(long ret,) int fd, const char * name, void * value, size_t size), - TP_ARGS(sc_exit(ret,) fd, name, value, size), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(name, name)) sc_out(ctf_integer(void *, value, value)) sc_in(ctf_integer(size_t, size, size))) -) -#endif -#ifndef OVERRIDE_64_semtimedop -SC_LTTNG_TRACEPOINT_EVENT(semtimedop, - TP_PROTO(sc_exit(long ret,) int semid, struct sembuf * tsops, unsigned nsops, const struct timespec * timeout), - TP_ARGS(sc_exit(ret,) semid, tsops, nsops, timeout), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, semid, semid)) sc_in(ctf_integer(struct sembuf *, tsops, tsops)) sc_in(ctf_integer(unsigned, nsops, nsops)) sc_inout(ctf_integer(const struct timespec *, timeout, timeout))) -) -#endif -#ifndef OVERRIDE_64_timer_settime -SC_LTTNG_TRACEPOINT_EVENT(timer_settime, - TP_PROTO(sc_exit(long ret,) timer_t timer_id, int flags, const struct itimerspec * new_setting, struct itimerspec * old_setting), - TP_ARGS(sc_exit(ret,) timer_id, flags, new_setting, old_setting), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(timer_t, timer_id, timer_id)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(const struct itimerspec *, new_setting, new_setting)) sc_out(ctf_integer(struct itimerspec *, old_setting, old_setting))) -) -#endif -#ifndef OVERRIDE_64_clock_nanosleep -SC_LTTNG_TRACEPOINT_EVENT(clock_nanosleep, - TP_PROTO(sc_exit(long ret,) const clockid_t which_clock, int flags, const struct timespec * rqtp, struct timespec * rmtp), - TP_ARGS(sc_exit(ret,) which_clock, flags, rqtp, rmtp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(const clockid_t, which_clock, which_clock)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(const struct timespec *, rqtp, rqtp)) sc_out(ctf_integer(struct timespec *, rmtp, rmtp))) -) -#endif -#ifndef OVERRIDE_64_epoll_wait -SC_LTTNG_TRACEPOINT_EVENT(epoll_wait, - TP_PROTO(sc_exit(long ret,) int epfd, struct epoll_event * events, int maxevents, int timeout), - TP_ARGS(sc_exit(ret,) epfd, events, maxevents, timeout), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, epfd, epfd)) sc_out(ctf_integer(struct epoll_event *, events, events)) sc_in(ctf_integer(int, maxevents, maxevents)) sc_in(ctf_integer(int, timeout, timeout))) -) -#endif -#ifndef OVERRIDE_64_epoll_ctl -SC_LTTNG_TRACEPOINT_EVENT(epoll_ctl, - TP_PROTO(sc_exit(long ret,) int epfd, int op, int fd, struct epoll_event * event), - TP_ARGS(sc_exit(ret,) epfd, op, fd, event), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, epfd, epfd)) sc_in(ctf_integer(int, op, op)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct epoll_event *, event, event))) -) -#endif -#ifndef OVERRIDE_64_mq_open -SC_LTTNG_TRACEPOINT_EVENT(mq_open, - TP_PROTO(sc_exit(long ret,) const char * u_name, int oflag, umode_t mode, struct mq_attr * u_attr), - TP_ARGS(sc_exit(ret,) u_name, oflag, mode, u_attr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(u_name, u_name)) sc_in(ctf_integer(int, oflag, oflag)) sc_in(ctf_integer(umode_t, mode, mode)) sc_in(ctf_integer(struct mq_attr *, u_attr, u_attr))) -) -#endif -#ifndef OVERRIDE_64_kexec_load -SC_LTTNG_TRACEPOINT_EVENT(kexec_load, - TP_PROTO(sc_exit(long ret,) unsigned long entry, unsigned long nr_segments, struct kexec_segment * segments, unsigned long flags), - TP_ARGS(sc_exit(ret,) entry, nr_segments, segments, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, entry, entry)) sc_in(ctf_integer(unsigned long, nr_segments, nr_segments)) sc_in(ctf_integer(struct kexec_segment *, segments, segments)) sc_in(ctf_integer(unsigned long, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_request_key -SC_LTTNG_TRACEPOINT_EVENT(request_key, - TP_PROTO(sc_exit(long ret,) const char * _type, const char * _description, const char * _callout_info, key_serial_t destringid), - TP_ARGS(sc_exit(ret,) _type, _description, _callout_info, destringid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(_type, _type)) sc_in(ctf_integer(const char *, _description, _description)) sc_in(ctf_integer(const char *, _callout_info, _callout_info)) sc_in(ctf_integer(key_serial_t, destringid, destringid))) -) -#endif -#ifndef OVERRIDE_64_migrate_pages -SC_LTTNG_TRACEPOINT_EVENT(migrate_pages, - TP_PROTO(sc_exit(long ret,) pid_t pid, unsigned long maxnode, const unsigned long * old_nodes, const unsigned long * new_nodes), - TP_ARGS(sc_exit(ret,) pid, maxnode, old_nodes, new_nodes), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(unsigned long, maxnode, maxnode)) sc_in(ctf_integer(const unsigned long *, old_nodes, old_nodes)) sc_in(ctf_integer(const unsigned long *, new_nodes, new_nodes))) -) -#endif -#ifndef OVERRIDE_64_openat -SC_LTTNG_TRACEPOINT_EVENT(openat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, int flags, umode_t mode), - TP_ARGS(sc_exit(ret,) dfd, filename, flags, mode), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(umode_t, mode, mode))) -) -#endif -#ifndef OVERRIDE_64_mknodat -SC_LTTNG_TRACEPOINT_EVENT(mknodat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, umode_t mode, unsigned dev), - TP_ARGS(sc_exit(ret,) dfd, filename, mode, dev), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(umode_t, mode, mode)) sc_in(ctf_integer(unsigned, dev, dev))) -) -#endif -#ifndef OVERRIDE_64_newfstatat -SC_LTTNG_TRACEPOINT_EVENT(newfstatat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, struct stat * statbuf, int flag), - TP_ARGS(sc_exit(ret,) dfd, filename, statbuf, flag), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_out(ctf_integer(struct stat *, statbuf, statbuf)) sc_in(ctf_integer(int, flag, flag))) -) -#endif -#ifndef OVERRIDE_64_renameat -SC_LTTNG_TRACEPOINT_EVENT(renameat, - TP_PROTO(sc_exit(long ret,) int olddfd, const char * oldname, int newdfd, const char * newname), - TP_ARGS(sc_exit(ret,) olddfd, oldname, newdfd, newname), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, olddfd, olddfd)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_integer(int, newdfd, newdfd)) sc_in(ctf_user_string(newname, newname))) -) -#endif -#ifndef OVERRIDE_64_readlinkat -SC_LTTNG_TRACEPOINT_EVENT(readlinkat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * pathname, char * buf, int bufsiz), - TP_ARGS(sc_exit(ret,) dfd, pathname, buf, bufsiz), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(pathname, pathname)) sc_out(ctf_integer(char *, buf, buf)) sc_in(ctf_integer(int, bufsiz, bufsiz))) -) -#endif -#ifndef OVERRIDE_64_vmsplice -SC_LTTNG_TRACEPOINT_EVENT(vmsplice, - TP_PROTO(sc_exit(long ret,) int fd, const struct iovec * iov, unsigned long nr_segs, unsigned int flags), - TP_ARGS(sc_exit(ret,) fd, iov, nr_segs, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(const struct iovec *, iov, iov)) sc_in(ctf_integer(unsigned long, nr_segs, nr_segs)) sc_in(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_utimensat -SC_LTTNG_TRACEPOINT_EVENT(utimensat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, struct timespec * utimes, int flags), - TP_ARGS(sc_exit(ret,) dfd, filename, utimes, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(struct timespec *, utimes, utimes)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_timerfd_settime -SC_LTTNG_TRACEPOINT_EVENT(timerfd_settime, - TP_PROTO(sc_exit(long ret,) int ufd, int flags, const struct itimerspec * utmr, struct itimerspec * otmr), - TP_ARGS(sc_exit(ret,) ufd, flags, utmr, otmr), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_in(ctf_integer(int, flags, flags)) sc_in(ctf_integer(const struct itimerspec *, utmr, utmr)) sc_out(ctf_integer(struct itimerspec *, otmr, otmr))) -) -#endif -#ifndef OVERRIDE_64_accept4 -SC_LTTNG_TRACEPOINT_EVENT(accept4, - TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr * upeer_sockaddr, int * upeer_addrlen, int flags), - TP_ARGS(sc_exit(ret,) fd, upeer_sockaddr, upeer_addrlen, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct sockaddr *, upeer_sockaddr, upeer_sockaddr)) sc_inout(ctf_integer(int *, upeer_addrlen, upeer_addrlen)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_signalfd4 -SC_LTTNG_TRACEPOINT_EVENT(signalfd4, - TP_PROTO(sc_exit(long ret,) int ufd, sigset_t * user_mask, size_t sizemask, int flags), - TP_ARGS(sc_exit(ret,) ufd, user_mask, sizemask, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, ufd, ufd)) sc_in(ctf_integer(sigset_t *, user_mask, user_mask)) sc_in(ctf_integer(size_t, sizemask, sizemask)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_rt_tgsigqueueinfo -SC_LTTNG_TRACEPOINT_EVENT(rt_tgsigqueueinfo, - TP_PROTO(sc_exit(long ret,) pid_t tgid, pid_t pid, int sig, siginfo_t * uinfo), - TP_ARGS(sc_exit(ret,) tgid, pid, sig, uinfo), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, tgid, tgid)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, sig, sig)) sc_in(ctf_integer(siginfo_t *, uinfo, uinfo))) -) -#endif -#ifndef OVERRIDE_64_prlimit64 -SC_LTTNG_TRACEPOINT_EVENT(prlimit64, - TP_PROTO(sc_exit(long ret,) pid_t pid, unsigned int resource, const struct rlimit64 * new_rlim, struct rlimit64 * old_rlim), - TP_ARGS(sc_exit(ret,) pid, resource, new_rlim, old_rlim), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(unsigned int, resource, resource)) sc_in(ctf_integer(const struct rlimit64 *, new_rlim, new_rlim)) sc_out(ctf_integer(struct rlimit64 *, old_rlim, old_rlim))) -) -#endif -#ifndef OVERRIDE_64_sendmmsg -SC_LTTNG_TRACEPOINT_EVENT(sendmmsg, - TP_PROTO(sc_exit(long ret,) int fd, struct mmsghdr * mmsg, unsigned int vlen, unsigned int flags), - TP_ARGS(sc_exit(ret,) fd, mmsg, vlen, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(struct mmsghdr *, mmsg, mmsg)) sc_in(ctf_integer(unsigned int, vlen, vlen)) sc_in(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_select -SC_LTTNG_TRACEPOINT_EVENT(select, - TP_PROTO(sc_exit(long ret,) int n, fd_set * inp, fd_set * outp, fd_set * exp, struct timeval * tvp), - TP_ARGS(sc_exit(ret,) n, inp, outp, exp, tvp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, n, n)) sc_inout(ctf_integer(fd_set *, inp, inp)) sc_inout(ctf_integer(fd_set *, outp, outp)) sc_inout(ctf_integer(fd_set *, exp, exp)) sc_inout(ctf_integer(struct timeval *, tvp, tvp))) -) -#endif -#ifndef OVERRIDE_64_setsockopt -SC_LTTNG_TRACEPOINT_EVENT(setsockopt, - TP_PROTO(sc_exit(long ret,) int fd, int level, int optname, char * optval, int optlen), - TP_ARGS(sc_exit(ret,) fd, level, optname, optval, optlen), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, level, level)) sc_in(ctf_integer(int, optname, optname)) sc_in(ctf_integer(char *, optval, optval)) sc_in(ctf_integer(int, optlen, optlen))) -) -#endif -#ifndef OVERRIDE_64_getsockopt -SC_LTTNG_TRACEPOINT_EVENT(getsockopt, - TP_PROTO(sc_exit(long ret,) int fd, int level, int optname, char * optval, int * optlen), - TP_ARGS(sc_exit(ret,) fd, level, optname, optval, optlen), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(int, level, level)) sc_in(ctf_integer(int, optname, optname)) sc_out(ctf_integer(char *, optval, optval)) sc_inout(ctf_integer(int *, optlen, optlen))) -) -#endif -#ifndef OVERRIDE_64_msgrcv -SC_LTTNG_TRACEPOINT_EVENT(msgrcv, - TP_PROTO(sc_exit(long ret,) int msqid, struct msgbuf * msgp, size_t msgsz, long msgtyp, int msgflg), - TP_ARGS(sc_exit(ret,) msqid, msgp, msgsz, msgtyp, msgflg), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, msqid, msqid)) sc_out(ctf_integer(struct msgbuf *, msgp, msgp)) sc_in(ctf_integer(size_t, msgsz, msgsz)) sc_in(ctf_integer(long, msgtyp, msgtyp)) sc_in(ctf_integer(int, msgflg, msgflg))) -) -#endif -#ifndef OVERRIDE_64_mount -SC_LTTNG_TRACEPOINT_EVENT(mount, - TP_PROTO(sc_exit(long ret,) char * dev_name, char * dir_name, char * type, unsigned long flags, void * data), - TP_ARGS(sc_exit(ret,) dev_name, dir_name, type, flags, data), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(dev_name, dev_name)) sc_in(ctf_user_string(dir_name, dir_name)) sc_in(ctf_user_string(type, type)) sc_in(ctf_integer(unsigned long, flags, flags)) sc_in(ctf_integer(void *, data, data))) -) -#endif -#ifndef OVERRIDE_64_setxattr -SC_LTTNG_TRACEPOINT_EVENT(setxattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, const void * value, size_t size, int flags), - TP_ARGS(sc_exit(ret,) pathname, name, value, size, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(const void *, value, value)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_lsetxattr -SC_LTTNG_TRACEPOINT_EVENT(lsetxattr, - TP_PROTO(sc_exit(long ret,) const char * pathname, const char * name, const void * value, size_t size, int flags), - TP_ARGS(sc_exit(ret,) pathname, name, value, size, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(pathname, pathname)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(const void *, value, value)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_fsetxattr -SC_LTTNG_TRACEPOINT_EVENT(fsetxattr, - TP_PROTO(sc_exit(long ret,) int fd, const char * name, const void * value, size_t size, int flags), - TP_ARGS(sc_exit(ret,) fd, name, value, size, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_user_string(name, name)) sc_in(ctf_integer(const void *, value, value)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_io_getevents -SC_LTTNG_TRACEPOINT_EVENT(io_getevents, - TP_PROTO(sc_exit(long ret,) aio_context_t ctx_id, long min_nr, long nr, struct io_event * events, struct timespec * timeout), - TP_ARGS(sc_exit(ret,) ctx_id, min_nr, nr, events, timeout), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(aio_context_t, ctx_id, ctx_id)) sc_in(ctf_integer(long, min_nr, min_nr)) sc_in(ctf_integer(long, nr, nr)) sc_out(ctf_integer(struct io_event *, events, events)) sc_inout(ctf_integer(struct timespec *, timeout, timeout))) -) -#endif -#ifndef OVERRIDE_64_get_mempolicy -SC_LTTNG_TRACEPOINT_EVENT(get_mempolicy, - TP_PROTO(sc_exit(long ret,) int * policy, unsigned long * nmask, unsigned long maxnode, unsigned long addr, unsigned long flags), - TP_ARGS(sc_exit(ret,) policy, nmask, maxnode, addr, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_out(ctf_integer(int *, policy, policy)) sc_out(ctf_integer(unsigned long *, nmask, nmask)) sc_in(ctf_integer(unsigned long, maxnode, maxnode)) sc_in(ctf_integer(unsigned long, addr, addr)) sc_in(ctf_integer(unsigned long, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_mq_timedsend -SC_LTTNG_TRACEPOINT_EVENT(mq_timedsend, - TP_PROTO(sc_exit(long ret,) mqd_t mqdes, const char * u_msg_ptr, size_t msg_len, unsigned int msg_prio, const struct timespec * u_abs_timeout), - TP_ARGS(sc_exit(ret,) mqdes, u_msg_ptr, msg_len, msg_prio, u_abs_timeout), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(mqd_t, mqdes, mqdes)) sc_in(ctf_integer(const char *, u_msg_ptr, u_msg_ptr)) sc_in(ctf_integer(size_t, msg_len, msg_len)) sc_in(ctf_integer(unsigned int, msg_prio, msg_prio)) sc_in(ctf_integer(const struct timespec *, u_abs_timeout, u_abs_timeout))) -) -#endif -#ifndef OVERRIDE_64_mq_timedreceive -SC_LTTNG_TRACEPOINT_EVENT(mq_timedreceive, - TP_PROTO(sc_exit(long ret,) mqd_t mqdes, char * u_msg_ptr, size_t msg_len, unsigned int * u_msg_prio, const struct timespec * u_abs_timeout), - TP_ARGS(sc_exit(ret,) mqdes, u_msg_ptr, msg_len, u_msg_prio, u_abs_timeout), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(mqd_t, mqdes, mqdes)) sc_out(ctf_integer(char *, u_msg_ptr, u_msg_ptr)) sc_in(ctf_integer(size_t, msg_len, msg_len)) sc_out(ctf_integer(unsigned int *, u_msg_prio, u_msg_prio)) sc_in(ctf_integer(const struct timespec *, u_abs_timeout, u_abs_timeout))) -) -#endif -#ifndef OVERRIDE_64_waitid -SC_LTTNG_TRACEPOINT_EVENT(waitid, - TP_PROTO(sc_exit(long ret,) int which, pid_t upid, struct siginfo * infop, int options, struct rusage * ru), - TP_ARGS(sc_exit(ret,) which, upid, infop, options, ru), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, which, which)) sc_in(ctf_integer(pid_t, upid, upid)) sc_out(ctf_integer(struct siginfo *, infop, infop)) sc_in(ctf_integer(int, options, options)) sc_out(ctf_integer(struct rusage *, ru, ru))) -) -#endif -#ifndef OVERRIDE_64_add_key -SC_LTTNG_TRACEPOINT_EVENT(add_key, - TP_PROTO(sc_exit(long ret,) const char * _type, const char * _description, const void * _payload, size_t plen, key_serial_t ringid), - TP_ARGS(sc_exit(ret,) _type, _description, _payload, plen, ringid), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_user_string(_type, _type)) sc_in(ctf_integer(const char *, _description, _description)) sc_in(ctf_integer(const void *, _payload, _payload)) sc_in(ctf_integer(size_t, plen, plen)) sc_in(ctf_integer(key_serial_t, ringid, ringid))) -) -#endif -#ifndef OVERRIDE_64_fchownat -SC_LTTNG_TRACEPOINT_EVENT(fchownat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, uid_t user, gid_t group, int flag), - TP_ARGS(sc_exit(ret,) dfd, filename, user, group, flag), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(filename, filename)) sc_in(ctf_integer(uid_t, user, user)) sc_in(ctf_integer(gid_t, group, group)) sc_in(ctf_integer(int, flag, flag))) -) -#endif -#ifndef OVERRIDE_64_linkat -SC_LTTNG_TRACEPOINT_EVENT(linkat, - TP_PROTO(sc_exit(long ret,) int olddfd, const char * oldname, int newdfd, const char * newname, int flags), - TP_ARGS(sc_exit(ret,) olddfd, oldname, newdfd, newname, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, olddfd, olddfd)) sc_in(ctf_user_string(oldname, oldname)) sc_in(ctf_integer(int, newdfd, newdfd)) sc_in(ctf_user_string(newname, newname)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_ppoll -SC_LTTNG_TRACEPOINT_EVENT(ppoll, - TP_PROTO(sc_exit(long ret,) struct pollfd * ufds, unsigned int nfds, struct timespec * tsp, const sigset_t * sigmask, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) ufds, nfds, tsp, sigmask, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(struct pollfd *, ufds, ufds)) sc_in(ctf_integer(unsigned int, nfds, nfds)) sc_in(ctf_integer(struct timespec *, tsp, tsp)) sc_in(ctf_integer(const sigset_t *, sigmask, sigmask)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) -) -#endif -#ifndef OVERRIDE_64_preadv -SC_LTTNG_TRACEPOINT_EVENT(preadv, - TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen, unsigned long pos_l, unsigned long pos_h), - TP_ARGS(sc_exit(ret,) fd, vec, vlen, pos_l, pos_h), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_out(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen)) sc_in(ctf_integer(unsigned long, pos_l, pos_l)) sc_in(ctf_integer(unsigned long, pos_h, pos_h))) -) -#endif -#ifndef OVERRIDE_64_pwritev -SC_LTTNG_TRACEPOINT_EVENT(pwritev, - TP_PROTO(sc_exit(long ret,) unsigned long fd, const struct iovec * vec, unsigned long vlen, unsigned long pos_l, unsigned long pos_h), - TP_ARGS(sc_exit(ret,) fd, vec, vlen, pos_l, pos_h), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, fd, fd)) sc_in(ctf_integer(const struct iovec *, vec, vec)) sc_in(ctf_integer(unsigned long, vlen, vlen)) sc_in(ctf_integer(unsigned long, pos_l, pos_l)) sc_in(ctf_integer(unsigned long, pos_h, pos_h))) -) -#endif -#ifndef OVERRIDE_64_perf_event_open -SC_LTTNG_TRACEPOINT_EVENT(perf_event_open, - TP_PROTO(sc_exit(long ret,) struct perf_event_attr * attr_uptr, pid_t pid, int cpu, int group_fd, unsigned long flags), - TP_ARGS(sc_exit(ret,) attr_uptr, pid, cpu, group_fd, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(struct perf_event_attr *, attr_uptr, attr_uptr)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(int, cpu, cpu)) sc_in(ctf_integer(int, group_fd, group_fd)) sc_in(ctf_integer(unsigned long, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_recvmmsg -SC_LTTNG_TRACEPOINT_EVENT(recvmmsg, - TP_PROTO(sc_exit(long ret,) int fd, struct mmsghdr * mmsg, unsigned int vlen, unsigned int flags, struct timespec * timeout), - TP_ARGS(sc_exit(ret,) fd, mmsg, vlen, flags, timeout), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(struct mmsghdr *, mmsg, mmsg)) sc_in(ctf_integer(unsigned int, vlen, vlen)) sc_in(ctf_integer(unsigned int, flags, flags)) sc_inout(ctf_integer(struct timespec *, timeout, timeout))) -) -#endif -#ifndef OVERRIDE_64_fanotify_mark -SC_LTTNG_TRACEPOINT_EVENT(fanotify_mark, - TP_PROTO(sc_exit(long ret,) int fanotify_fd, unsigned int flags, __u64 mask, int dfd, const char * pathname), - TP_ARGS(sc_exit(ret,) fanotify_fd, flags, mask, dfd, pathname), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fanotify_fd, fanotify_fd)) sc_in(ctf_integer(unsigned int, flags, flags)) sc_in(ctf_integer(__u64, mask, mask)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(pathname, pathname))) -) -#endif -#ifndef OVERRIDE_64_name_to_handle_at -SC_LTTNG_TRACEPOINT_EVENT(name_to_handle_at, - TP_PROTO(sc_exit(long ret,) int dfd, const char * name, struct file_handle * handle, int * mnt_id, int flag), - TP_ARGS(sc_exit(ret,) dfd, name, handle, mnt_id, flag), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, dfd, dfd)) sc_in(ctf_user_string(name, name)) sc_inout(ctf_integer(struct file_handle *, handle, handle)) sc_out(ctf_integer(int *, mnt_id, mnt_id)) sc_in(ctf_integer(int, flag, flag))) -) -#endif -#ifndef OVERRIDE_64_sendto -SC_LTTNG_TRACEPOINT_EVENT(sendto, - TP_PROTO(sc_exit(long ret,) int fd, void * buff, size_t len, unsigned int flags, struct sockaddr * addr, int addr_len), - TP_ARGS(sc_exit(ret,) fd, buff, len, flags, addr, addr_len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_in(ctf_integer(void *, buff, buff)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned int, flags, flags)) sc_in(ctf_integer(struct sockaddr *, addr, addr)) sc_in(ctf_integer(int, addr_len, addr_len))) -) -#endif -#ifndef OVERRIDE_64_recvfrom -SC_LTTNG_TRACEPOINT_EVENT(recvfrom, - TP_PROTO(sc_exit(long ret,) int fd, void * ubuf, size_t size, unsigned int flags, struct sockaddr * addr, int * addr_len), - TP_ARGS(sc_exit(ret,) fd, ubuf, size, flags, addr, addr_len), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd, fd)) sc_out(ctf_integer(void *, ubuf, ubuf)) sc_in(ctf_integer(size_t, size, size)) sc_in(ctf_integer(unsigned int, flags, flags)) sc_out(ctf_integer(struct sockaddr *, addr, addr)) sc_inout(ctf_integer(int *, addr_len, addr_len))) -) -#endif -#ifndef OVERRIDE_64_futex -SC_LTTNG_TRACEPOINT_EVENT(futex, - TP_PROTO(sc_exit(long ret,) u32 * uaddr, int op, u32 val, struct timespec * utime, u32 * uaddr2, u32 val3), - TP_ARGS(sc_exit(ret,) uaddr, op, val, utime, uaddr2, val3), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_inout(ctf_integer(u32 *, uaddr, uaddr)) sc_in(ctf_integer(int, op, op)) sc_in(ctf_integer(u32, val, val)) sc_in(ctf_integer(struct timespec *, utime, utime)) sc_inout(ctf_integer(u32 *, uaddr2, uaddr2)) sc_in(ctf_integer(u32, val3, val3))) -) -#endif -#ifndef OVERRIDE_64_mbind -SC_LTTNG_TRACEPOINT_EVENT(mbind, - TP_PROTO(sc_exit(long ret,) unsigned long start, unsigned long len, unsigned long mode, unsigned long * nmask, unsigned long maxnode, unsigned flags), - TP_ARGS(sc_exit(ret,) start, len, mode, nmask, maxnode, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(unsigned long, start, start)) sc_in(ctf_integer(unsigned long, len, len)) sc_in(ctf_integer(unsigned long, mode, mode)) sc_in(ctf_integer(unsigned long *, nmask, nmask)) sc_in(ctf_integer(unsigned long, maxnode, maxnode)) sc_in(ctf_integer(unsigned, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_pselect6 -SC_LTTNG_TRACEPOINT_EVENT(pselect6, - TP_PROTO(sc_exit(long ret,) int n, fd_set * inp, fd_set * outp, fd_set * exp, struct timespec * tsp, void * sig), - TP_ARGS(sc_exit(ret,) n, inp, outp, exp, tsp, sig), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, n, n)) sc_inout(ctf_integer(fd_set *, inp, inp)) sc_inout(ctf_integer(fd_set *, outp, outp)) sc_inout(ctf_integer(fd_set *, exp, exp)) sc_inout(ctf_integer(struct timespec *, tsp, tsp)) sc_in(ctf_integer(void *, sig, sig))) -) -#endif -#ifndef OVERRIDE_64_splice -SC_LTTNG_TRACEPOINT_EVENT(splice, - TP_PROTO(sc_exit(long ret,) int fd_in, loff_t * off_in, int fd_out, loff_t * off_out, size_t len, unsigned int flags), - TP_ARGS(sc_exit(ret,) fd_in, off_in, fd_out, off_out, len, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, fd_in, fd_in)) sc_in(ctf_integer(loff_t *, off_in, off_in)) sc_in(ctf_integer(int, fd_out, fd_out)) sc_in(ctf_integer(loff_t *, off_out, off_out)) sc_in(ctf_integer(size_t, len, len)) sc_in(ctf_integer(unsigned int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_move_pages -SC_LTTNG_TRACEPOINT_EVENT(move_pages, - TP_PROTO(sc_exit(long ret,) pid_t pid, unsigned long nr_pages, const void * * pages, const int * nodes, int * status, int flags), - TP_ARGS(sc_exit(ret,) pid, nr_pages, pages, nodes, status, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(unsigned long, nr_pages, nr_pages)) sc_in(ctf_integer(const void * *, pages, pages)) sc_in(ctf_integer(const int *, nodes, nodes)) sc_out(ctf_integer(int *, status, status)) sc_in(ctf_integer(int, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_epoll_pwait -SC_LTTNG_TRACEPOINT_EVENT(epoll_pwait, - TP_PROTO(sc_exit(long ret,) int epfd, struct epoll_event * events, int maxevents, int timeout, const sigset_t * sigmask, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) epfd, events, maxevents, timeout, sigmask, sigsetsize), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(int, epfd, epfd)) sc_out(ctf_integer(struct epoll_event *, events, events)) sc_in(ctf_integer(int, maxevents, maxevents)) sc_in(ctf_integer(int, timeout, timeout)) sc_in(ctf_integer(const sigset_t *, sigmask, sigmask)) sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))) -) -#endif -#ifndef OVERRIDE_64_process_vm_readv -SC_LTTNG_TRACEPOINT_EVENT(process_vm_readv, - TP_PROTO(sc_exit(long ret,) pid_t pid, const struct iovec * lvec, unsigned long liovcnt, const struct iovec * rvec, unsigned long riovcnt, unsigned long flags), - TP_ARGS(sc_exit(ret,) pid, lvec, liovcnt, rvec, riovcnt, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_out(ctf_integer(const struct iovec *, lvec, lvec)) sc_in(ctf_integer(unsigned long, liovcnt, liovcnt)) sc_in(ctf_integer(const struct iovec *, rvec, rvec)) sc_in(ctf_integer(unsigned long, riovcnt, riovcnt)) sc_in(ctf_integer(unsigned long, flags, flags))) -) -#endif -#ifndef OVERRIDE_64_process_vm_writev -SC_LTTNG_TRACEPOINT_EVENT(process_vm_writev, - TP_PROTO(sc_exit(long ret,) pid_t pid, const struct iovec * lvec, unsigned long liovcnt, const struct iovec * rvec, unsigned long riovcnt, unsigned long flags), - TP_ARGS(sc_exit(ret,) pid, lvec, liovcnt, rvec, riovcnt, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) sc_in(ctf_integer(pid_t, pid, pid)) sc_in(ctf_integer(const struct iovec *, lvec, lvec)) sc_in(ctf_integer(unsigned long, liovcnt, liovcnt)) sc_in(ctf_integer(const struct iovec *, rvec, rvec)) sc_in(ctf_integer(unsigned long, riovcnt, riovcnt)) sc_in(ctf_integer(unsigned long, flags, flags))) -) -#endif - -#endif /* _TRACE_SYSCALLS_POINTERS_H */ - -/* This part must be outside protection */ -#include - -#else /* CREATE_SYSCALL_TABLE */ - -#include "x86-64-syscalls_pointers_override.h" -#include "syscalls_pointers_override.h" - -#ifndef OVERRIDE_TABLE_64_read -TRACE_SYSCALL_TABLE(read, read, 0, 3) -#endif -#ifndef OVERRIDE_TABLE_64_write -TRACE_SYSCALL_TABLE(write, write, 1, 3) -#endif -#ifndef OVERRIDE_TABLE_64_open -TRACE_SYSCALL_TABLE(open, open, 2, 3) -#endif -#ifndef OVERRIDE_TABLE_64_newstat -TRACE_SYSCALL_TABLE(newstat, newstat, 4, 2) -#endif -#ifndef OVERRIDE_TABLE_64_newfstat -TRACE_SYSCALL_TABLE(newfstat, newfstat, 5, 2) -#endif -#ifndef OVERRIDE_TABLE_64_newlstat -TRACE_SYSCALL_TABLE(newlstat, newlstat, 6, 2) -#endif -#ifndef OVERRIDE_TABLE_64_poll -TRACE_SYSCALL_TABLE(poll, poll, 7, 3) -#endif -#ifndef OVERRIDE_TABLE_64_rt_sigaction -TRACE_SYSCALL_TABLE(rt_sigaction, rt_sigaction, 13, 4) -#endif -#ifndef OVERRIDE_TABLE_64_rt_sigprocmask -TRACE_SYSCALL_TABLE(rt_sigprocmask, rt_sigprocmask, 14, 4) -#endif -#ifndef OVERRIDE_TABLE_64_pread64 -TRACE_SYSCALL_TABLE(pread64, pread64, 17, 4) -#endif -#ifndef OVERRIDE_TABLE_64_pwrite64 -TRACE_SYSCALL_TABLE(pwrite64, pwrite64, 18, 4) -#endif -#ifndef OVERRIDE_TABLE_64_readv -TRACE_SYSCALL_TABLE(readv, readv, 19, 3) -#endif -#ifndef OVERRIDE_TABLE_64_writev -TRACE_SYSCALL_TABLE(writev, writev, 20, 3) -#endif -#ifndef OVERRIDE_TABLE_64_access -TRACE_SYSCALL_TABLE(access, access, 21, 2) -#endif -#ifndef OVERRIDE_TABLE_64_pipe -TRACE_SYSCALL_TABLE(pipe, pipe, 22, 1) -#endif -#ifndef OVERRIDE_TABLE_64_select -TRACE_SYSCALL_TABLE(select, select, 23, 5) -#endif -#ifndef OVERRIDE_TABLE_64_mincore -TRACE_SYSCALL_TABLE(mincore, mincore, 27, 3) -#endif -#ifndef OVERRIDE_TABLE_64_shmat -TRACE_SYSCALL_TABLE(shmat, shmat, 30, 3) -#endif -#ifndef OVERRIDE_TABLE_64_shmctl -TRACE_SYSCALL_TABLE(shmctl, shmctl, 31, 3) -#endif -#ifndef OVERRIDE_TABLE_64_nanosleep -TRACE_SYSCALL_TABLE(nanosleep, nanosleep, 35, 2) -#endif -#ifndef OVERRIDE_TABLE_64_getitimer -TRACE_SYSCALL_TABLE(getitimer, getitimer, 36, 2) -#endif -#ifndef OVERRIDE_TABLE_64_setitimer -TRACE_SYSCALL_TABLE(setitimer, setitimer, 38, 3) -#endif -#ifndef OVERRIDE_TABLE_64_sendfile64 -TRACE_SYSCALL_TABLE(sendfile64, sendfile64, 40, 4) -#endif -#ifndef OVERRIDE_TABLE_64_connect -TRACE_SYSCALL_TABLE(connect, connect, 42, 3) -#endif -#ifndef OVERRIDE_TABLE_64_accept -TRACE_SYSCALL_TABLE(accept, accept, 43, 3) -#endif -#ifndef OVERRIDE_TABLE_64_sendto -TRACE_SYSCALL_TABLE(sendto, sendto, 44, 6) -#endif -#ifndef OVERRIDE_TABLE_64_recvfrom -TRACE_SYSCALL_TABLE(recvfrom, recvfrom, 45, 6) -#endif -#ifndef OVERRIDE_TABLE_64_sendmsg -TRACE_SYSCALL_TABLE(sendmsg, sendmsg, 46, 3) -#endif -#ifndef OVERRIDE_TABLE_64_recvmsg -TRACE_SYSCALL_TABLE(recvmsg, recvmsg, 47, 3) -#endif -#ifndef OVERRIDE_TABLE_64_bind -TRACE_SYSCALL_TABLE(bind, bind, 49, 3) -#endif -#ifndef OVERRIDE_TABLE_64_getsockname -TRACE_SYSCALL_TABLE(getsockname, getsockname, 51, 3) -#endif -#ifndef OVERRIDE_TABLE_64_getpeername -TRACE_SYSCALL_TABLE(getpeername, getpeername, 52, 3) -#endif -#ifndef OVERRIDE_TABLE_64_socketpair -TRACE_SYSCALL_TABLE(socketpair, socketpair, 53, 4) -#endif -#ifndef OVERRIDE_TABLE_64_setsockopt -TRACE_SYSCALL_TABLE(setsockopt, setsockopt, 54, 5) -#endif -#ifndef OVERRIDE_TABLE_64_getsockopt -TRACE_SYSCALL_TABLE(getsockopt, getsockopt, 55, 5) -#endif -#ifndef OVERRIDE_TABLE_64_wait4 -TRACE_SYSCALL_TABLE(wait4, wait4, 61, 4) -#endif -#ifndef OVERRIDE_TABLE_64_newuname -TRACE_SYSCALL_TABLE(newuname, newuname, 63, 1) -#endif -#ifndef OVERRIDE_TABLE_64_semop -TRACE_SYSCALL_TABLE(semop, semop, 65, 3) -#endif -#ifndef OVERRIDE_TABLE_64_shmdt -TRACE_SYSCALL_TABLE(shmdt, shmdt, 67, 1) -#endif -#ifndef OVERRIDE_TABLE_64_msgsnd -TRACE_SYSCALL_TABLE(msgsnd, msgsnd, 69, 4) -#endif -#ifndef OVERRIDE_TABLE_64_msgrcv -TRACE_SYSCALL_TABLE(msgrcv, msgrcv, 70, 5) -#endif -#ifndef OVERRIDE_TABLE_64_msgctl -TRACE_SYSCALL_TABLE(msgctl, msgctl, 71, 3) -#endif -#ifndef OVERRIDE_TABLE_64_truncate -TRACE_SYSCALL_TABLE(truncate, truncate, 76, 2) -#endif -#ifndef OVERRIDE_TABLE_64_getdents -TRACE_SYSCALL_TABLE(getdents, getdents, 78, 3) -#endif -#ifndef OVERRIDE_TABLE_64_getcwd -TRACE_SYSCALL_TABLE(getcwd, getcwd, 79, 2) -#endif -#ifndef OVERRIDE_TABLE_64_chdir -TRACE_SYSCALL_TABLE(chdir, chdir, 80, 1) -#endif -#ifndef OVERRIDE_TABLE_64_rename -TRACE_SYSCALL_TABLE(rename, rename, 82, 2) -#endif -#ifndef OVERRIDE_TABLE_64_mkdir -TRACE_SYSCALL_TABLE(mkdir, mkdir, 83, 2) -#endif -#ifndef OVERRIDE_TABLE_64_rmdir -TRACE_SYSCALL_TABLE(rmdir, rmdir, 84, 1) -#endif -#ifndef OVERRIDE_TABLE_64_creat -TRACE_SYSCALL_TABLE(creat, creat, 85, 2) -#endif -#ifndef OVERRIDE_TABLE_64_link -TRACE_SYSCALL_TABLE(link, link, 86, 2) -#endif -#ifndef OVERRIDE_TABLE_64_unlink -TRACE_SYSCALL_TABLE(unlink, unlink, 87, 1) -#endif -#ifndef OVERRIDE_TABLE_64_symlink -TRACE_SYSCALL_TABLE(symlink, symlink, 88, 2) -#endif -#ifndef OVERRIDE_TABLE_64_readlink -TRACE_SYSCALL_TABLE(readlink, readlink, 89, 3) -#endif -#ifndef OVERRIDE_TABLE_64_chmod -TRACE_SYSCALL_TABLE(chmod, chmod, 90, 2) -#endif -#ifndef OVERRIDE_TABLE_64_chown -TRACE_SYSCALL_TABLE(chown, chown, 92, 3) -#endif -#ifndef OVERRIDE_TABLE_64_lchown -TRACE_SYSCALL_TABLE(lchown, lchown, 94, 3) -#endif -#ifndef OVERRIDE_TABLE_64_gettimeofday -TRACE_SYSCALL_TABLE(gettimeofday, gettimeofday, 96, 2) -#endif -#ifndef OVERRIDE_TABLE_64_getrlimit -TRACE_SYSCALL_TABLE(getrlimit, getrlimit, 97, 2) -#endif -#ifndef OVERRIDE_TABLE_64_getrusage -TRACE_SYSCALL_TABLE(getrusage, getrusage, 98, 2) -#endif -#ifndef OVERRIDE_TABLE_64_sysinfo -TRACE_SYSCALL_TABLE(sysinfo, sysinfo, 99, 1) -#endif -#ifndef OVERRIDE_TABLE_64_times -TRACE_SYSCALL_TABLE(times, times, 100, 1) -#endif -#ifndef OVERRIDE_TABLE_64_syslog -TRACE_SYSCALL_TABLE(syslog, syslog, 103, 3) -#endif -#ifndef OVERRIDE_TABLE_64_getgroups -TRACE_SYSCALL_TABLE(getgroups, getgroups, 115, 2) -#endif -#ifndef OVERRIDE_TABLE_64_setgroups -TRACE_SYSCALL_TABLE(setgroups, setgroups, 116, 2) -#endif -#ifndef OVERRIDE_TABLE_64_getresuid -TRACE_SYSCALL_TABLE(getresuid, getresuid, 118, 3) -#endif -#ifndef OVERRIDE_TABLE_64_getresgid -TRACE_SYSCALL_TABLE(getresgid, getresgid, 120, 3) -#endif -#ifndef OVERRIDE_TABLE_64_rt_sigpending -TRACE_SYSCALL_TABLE(rt_sigpending, rt_sigpending, 127, 2) -#endif -#ifndef OVERRIDE_TABLE_64_rt_sigtimedwait -TRACE_SYSCALL_TABLE(rt_sigtimedwait, rt_sigtimedwait, 128, 4) -#endif -#ifndef OVERRIDE_TABLE_64_rt_sigqueueinfo -TRACE_SYSCALL_TABLE(rt_sigqueueinfo, rt_sigqueueinfo, 129, 3) -#endif -#ifndef OVERRIDE_TABLE_64_rt_sigsuspend -TRACE_SYSCALL_TABLE(rt_sigsuspend, rt_sigsuspend, 130, 2) -#endif -#ifndef OVERRIDE_TABLE_64_sigaltstack -TRACE_SYSCALL_TABLE(sigaltstack, sigaltstack, 131, 2) -#endif -#ifndef OVERRIDE_TABLE_64_utime -TRACE_SYSCALL_TABLE(utime, utime, 132, 2) -#endif -#ifndef OVERRIDE_TABLE_64_mknod -TRACE_SYSCALL_TABLE(mknod, mknod, 133, 3) -#endif -#ifndef OVERRIDE_TABLE_64_ustat -TRACE_SYSCALL_TABLE(ustat, ustat, 136, 2) -#endif -#ifndef OVERRIDE_TABLE_64_statfs -TRACE_SYSCALL_TABLE(statfs, statfs, 137, 2) -#endif -#ifndef OVERRIDE_TABLE_64_fstatfs -TRACE_SYSCALL_TABLE(fstatfs, fstatfs, 138, 2) -#endif -#ifndef OVERRIDE_TABLE_64_sched_setparam -TRACE_SYSCALL_TABLE(sched_setparam, sched_setparam, 142, 2) -#endif -#ifndef OVERRIDE_TABLE_64_sched_getparam -TRACE_SYSCALL_TABLE(sched_getparam, sched_getparam, 143, 2) -#endif -#ifndef OVERRIDE_TABLE_64_sched_setscheduler -TRACE_SYSCALL_TABLE(sched_setscheduler, sched_setscheduler, 144, 3) -#endif -#ifndef OVERRIDE_TABLE_64_sched_rr_get_interval -TRACE_SYSCALL_TABLE(sched_rr_get_interval, sched_rr_get_interval, 148, 2) -#endif -#ifndef OVERRIDE_TABLE_64_pivot_root -TRACE_SYSCALL_TABLE(pivot_root, pivot_root, 155, 2) -#endif -#ifndef OVERRIDE_TABLE_64_sysctl -TRACE_SYSCALL_TABLE(sysctl, sysctl, 156, 1) -#endif -#ifndef OVERRIDE_TABLE_64_adjtimex -TRACE_SYSCALL_TABLE(adjtimex, adjtimex, 159, 1) -#endif -#ifndef OVERRIDE_TABLE_64_setrlimit -TRACE_SYSCALL_TABLE(setrlimit, setrlimit, 160, 2) -#endif -#ifndef OVERRIDE_TABLE_64_chroot -TRACE_SYSCALL_TABLE(chroot, chroot, 161, 1) -#endif -#ifndef OVERRIDE_TABLE_64_acct -TRACE_SYSCALL_TABLE(acct, acct, 163, 1) -#endif -#ifndef OVERRIDE_TABLE_64_settimeofday -TRACE_SYSCALL_TABLE(settimeofday, settimeofday, 164, 2) -#endif -#ifndef OVERRIDE_TABLE_64_mount -TRACE_SYSCALL_TABLE(mount, mount, 165, 5) -#endif -#ifndef OVERRIDE_TABLE_64_umount -TRACE_SYSCALL_TABLE(umount, umount, 166, 2) -#endif -#ifndef OVERRIDE_TABLE_64_swapon -TRACE_SYSCALL_TABLE(swapon, swapon, 167, 2) -#endif -#ifndef OVERRIDE_TABLE_64_swapoff -TRACE_SYSCALL_TABLE(swapoff, swapoff, 168, 1) -#endif -#ifndef OVERRIDE_TABLE_64_reboot -TRACE_SYSCALL_TABLE(reboot, reboot, 169, 4) -#endif -#ifndef OVERRIDE_TABLE_64_sethostname -TRACE_SYSCALL_TABLE(sethostname, sethostname, 170, 2) -#endif -#ifndef OVERRIDE_TABLE_64_setdomainname -TRACE_SYSCALL_TABLE(setdomainname, setdomainname, 171, 2) -#endif -#ifndef OVERRIDE_TABLE_64_init_module -TRACE_SYSCALL_TABLE(init_module, init_module, 175, 3) -#endif -#ifndef OVERRIDE_TABLE_64_delete_module -TRACE_SYSCALL_TABLE(delete_module, delete_module, 176, 2) -#endif -#ifndef OVERRIDE_TABLE_64_quotactl -TRACE_SYSCALL_TABLE(quotactl, quotactl, 179, 4) -#endif -#ifndef OVERRIDE_TABLE_64_setxattr -TRACE_SYSCALL_TABLE(setxattr, setxattr, 188, 5) -#endif -#ifndef OVERRIDE_TABLE_64_lsetxattr -TRACE_SYSCALL_TABLE(lsetxattr, lsetxattr, 189, 5) -#endif -#ifndef OVERRIDE_TABLE_64_fsetxattr -TRACE_SYSCALL_TABLE(fsetxattr, fsetxattr, 190, 5) -#endif -#ifndef OVERRIDE_TABLE_64_getxattr -TRACE_SYSCALL_TABLE(getxattr, getxattr, 191, 4) -#endif -#ifndef OVERRIDE_TABLE_64_lgetxattr -TRACE_SYSCALL_TABLE(lgetxattr, lgetxattr, 192, 4) -#endif -#ifndef OVERRIDE_TABLE_64_fgetxattr -TRACE_SYSCALL_TABLE(fgetxattr, fgetxattr, 193, 4) -#endif -#ifndef OVERRIDE_TABLE_64_listxattr -TRACE_SYSCALL_TABLE(listxattr, listxattr, 194, 3) -#endif -#ifndef OVERRIDE_TABLE_64_llistxattr -TRACE_SYSCALL_TABLE(llistxattr, llistxattr, 195, 3) -#endif -#ifndef OVERRIDE_TABLE_64_flistxattr -TRACE_SYSCALL_TABLE(flistxattr, flistxattr, 196, 3) -#endif -#ifndef OVERRIDE_TABLE_64_removexattr -TRACE_SYSCALL_TABLE(removexattr, removexattr, 197, 2) -#endif -#ifndef OVERRIDE_TABLE_64_lremovexattr -TRACE_SYSCALL_TABLE(lremovexattr, lremovexattr, 198, 2) -#endif -#ifndef OVERRIDE_TABLE_64_fremovexattr -TRACE_SYSCALL_TABLE(fremovexattr, fremovexattr, 199, 2) -#endif -#ifndef OVERRIDE_TABLE_64_time -TRACE_SYSCALL_TABLE(time, time, 201, 1) -#endif -#ifndef OVERRIDE_TABLE_64_futex -TRACE_SYSCALL_TABLE(futex, futex, 202, 6) -#endif -#ifndef OVERRIDE_TABLE_64_sched_setaffinity -TRACE_SYSCALL_TABLE(sched_setaffinity, sched_setaffinity, 203, 3) -#endif -#ifndef OVERRIDE_TABLE_64_sched_getaffinity -TRACE_SYSCALL_TABLE(sched_getaffinity, sched_getaffinity, 204, 3) -#endif -#ifndef OVERRIDE_TABLE_64_io_setup -TRACE_SYSCALL_TABLE(io_setup, io_setup, 206, 2) -#endif -#ifndef OVERRIDE_TABLE_64_io_getevents -TRACE_SYSCALL_TABLE(io_getevents, io_getevents, 208, 5) -#endif -#ifndef OVERRIDE_TABLE_64_io_submit -TRACE_SYSCALL_TABLE(io_submit, io_submit, 209, 3) -#endif -#ifndef OVERRIDE_TABLE_64_io_cancel -TRACE_SYSCALL_TABLE(io_cancel, io_cancel, 210, 3) -#endif -#ifndef OVERRIDE_TABLE_64_lookup_dcookie -TRACE_SYSCALL_TABLE(lookup_dcookie, lookup_dcookie, 212, 3) -#endif -#ifndef OVERRIDE_TABLE_64_getdents64 -TRACE_SYSCALL_TABLE(getdents64, getdents64, 217, 3) -#endif -#ifndef OVERRIDE_TABLE_64_set_tid_address -TRACE_SYSCALL_TABLE(set_tid_address, set_tid_address, 218, 1) -#endif -#ifndef OVERRIDE_TABLE_64_semtimedop -TRACE_SYSCALL_TABLE(semtimedop, semtimedop, 220, 4) -#endif -#ifndef OVERRIDE_TABLE_64_timer_create -TRACE_SYSCALL_TABLE(timer_create, timer_create, 222, 3) -#endif -#ifndef OVERRIDE_TABLE_64_timer_settime -TRACE_SYSCALL_TABLE(timer_settime, timer_settime, 223, 4) -#endif -#ifndef OVERRIDE_TABLE_64_timer_gettime -TRACE_SYSCALL_TABLE(timer_gettime, timer_gettime, 224, 2) -#endif -#ifndef OVERRIDE_TABLE_64_clock_settime -TRACE_SYSCALL_TABLE(clock_settime, clock_settime, 227, 2) -#endif -#ifndef OVERRIDE_TABLE_64_clock_gettime -TRACE_SYSCALL_TABLE(clock_gettime, clock_gettime, 228, 2) -#endif -#ifndef OVERRIDE_TABLE_64_clock_getres -TRACE_SYSCALL_TABLE(clock_getres, clock_getres, 229, 2) -#endif -#ifndef OVERRIDE_TABLE_64_clock_nanosleep -TRACE_SYSCALL_TABLE(clock_nanosleep, clock_nanosleep, 230, 4) -#endif -#ifndef OVERRIDE_TABLE_64_epoll_wait -TRACE_SYSCALL_TABLE(epoll_wait, epoll_wait, 232, 4) -#endif -#ifndef OVERRIDE_TABLE_64_epoll_ctl -TRACE_SYSCALL_TABLE(epoll_ctl, epoll_ctl, 233, 4) -#endif -#ifndef OVERRIDE_TABLE_64_utimes -TRACE_SYSCALL_TABLE(utimes, utimes, 235, 2) -#endif -#ifndef OVERRIDE_TABLE_64_mbind -TRACE_SYSCALL_TABLE(mbind, mbind, 237, 6) -#endif -#ifndef OVERRIDE_TABLE_64_set_mempolicy -TRACE_SYSCALL_TABLE(set_mempolicy, set_mempolicy, 238, 3) -#endif -#ifndef OVERRIDE_TABLE_64_get_mempolicy -TRACE_SYSCALL_TABLE(get_mempolicy, get_mempolicy, 239, 5) -#endif -#ifndef OVERRIDE_TABLE_64_mq_open -TRACE_SYSCALL_TABLE(mq_open, mq_open, 240, 4) -#endif -#ifndef OVERRIDE_TABLE_64_mq_unlink -TRACE_SYSCALL_TABLE(mq_unlink, mq_unlink, 241, 1) -#endif -#ifndef OVERRIDE_TABLE_64_mq_timedsend -TRACE_SYSCALL_TABLE(mq_timedsend, mq_timedsend, 242, 5) -#endif -#ifndef OVERRIDE_TABLE_64_mq_timedreceive -TRACE_SYSCALL_TABLE(mq_timedreceive, mq_timedreceive, 243, 5) -#endif -#ifndef OVERRIDE_TABLE_64_mq_notify -TRACE_SYSCALL_TABLE(mq_notify, mq_notify, 244, 2) -#endif -#ifndef OVERRIDE_TABLE_64_mq_getsetattr -TRACE_SYSCALL_TABLE(mq_getsetattr, mq_getsetattr, 245, 3) -#endif -#ifndef OVERRIDE_TABLE_64_kexec_load -TRACE_SYSCALL_TABLE(kexec_load, kexec_load, 246, 4) -#endif -#ifndef OVERRIDE_TABLE_64_waitid -TRACE_SYSCALL_TABLE(waitid, waitid, 247, 5) -#endif -#ifndef OVERRIDE_TABLE_64_add_key -TRACE_SYSCALL_TABLE(add_key, add_key, 248, 5) -#endif -#ifndef OVERRIDE_TABLE_64_request_key -TRACE_SYSCALL_TABLE(request_key, request_key, 249, 4) -#endif -#ifndef OVERRIDE_TABLE_64_inotify_add_watch -TRACE_SYSCALL_TABLE(inotify_add_watch, inotify_add_watch, 254, 3) -#endif -#ifndef OVERRIDE_TABLE_64_migrate_pages -TRACE_SYSCALL_TABLE(migrate_pages, migrate_pages, 256, 4) -#endif -#ifndef OVERRIDE_TABLE_64_openat -TRACE_SYSCALL_TABLE(openat, openat, 257, 4) -#endif -#ifndef OVERRIDE_TABLE_64_mkdirat -TRACE_SYSCALL_TABLE(mkdirat, mkdirat, 258, 3) -#endif -#ifndef OVERRIDE_TABLE_64_mknodat -TRACE_SYSCALL_TABLE(mknodat, mknodat, 259, 4) -#endif -#ifndef OVERRIDE_TABLE_64_fchownat -TRACE_SYSCALL_TABLE(fchownat, fchownat, 260, 5) -#endif -#ifndef OVERRIDE_TABLE_64_futimesat -TRACE_SYSCALL_TABLE(futimesat, futimesat, 261, 3) -#endif -#ifndef OVERRIDE_TABLE_64_newfstatat -TRACE_SYSCALL_TABLE(newfstatat, newfstatat, 262, 4) -#endif -#ifndef OVERRIDE_TABLE_64_unlinkat -TRACE_SYSCALL_TABLE(unlinkat, unlinkat, 263, 3) -#endif -#ifndef OVERRIDE_TABLE_64_renameat -TRACE_SYSCALL_TABLE(renameat, renameat, 264, 4) -#endif -#ifndef OVERRIDE_TABLE_64_linkat -TRACE_SYSCALL_TABLE(linkat, linkat, 265, 5) -#endif -#ifndef OVERRIDE_TABLE_64_symlinkat -TRACE_SYSCALL_TABLE(symlinkat, symlinkat, 266, 3) -#endif -#ifndef OVERRIDE_TABLE_64_readlinkat -TRACE_SYSCALL_TABLE(readlinkat, readlinkat, 267, 4) -#endif -#ifndef OVERRIDE_TABLE_64_fchmodat -TRACE_SYSCALL_TABLE(fchmodat, fchmodat, 268, 3) -#endif -#ifndef OVERRIDE_TABLE_64_faccessat -TRACE_SYSCALL_TABLE(faccessat, faccessat, 269, 3) -#endif -#ifndef OVERRIDE_TABLE_64_pselect6 -TRACE_SYSCALL_TABLE(pselect6, pselect6, 270, 6) -#endif -#ifndef OVERRIDE_TABLE_64_ppoll -TRACE_SYSCALL_TABLE(ppoll, ppoll, 271, 5) -#endif -#ifndef OVERRIDE_TABLE_64_set_robust_list -TRACE_SYSCALL_TABLE(set_robust_list, set_robust_list, 273, 2) -#endif -#ifndef OVERRIDE_TABLE_64_get_robust_list -TRACE_SYSCALL_TABLE(get_robust_list, get_robust_list, 274, 3) -#endif -#ifndef OVERRIDE_TABLE_64_splice -TRACE_SYSCALL_TABLE(splice, splice, 275, 6) -#endif -#ifndef OVERRIDE_TABLE_64_vmsplice -TRACE_SYSCALL_TABLE(vmsplice, vmsplice, 278, 4) -#endif -#ifndef OVERRIDE_TABLE_64_move_pages -TRACE_SYSCALL_TABLE(move_pages, move_pages, 279, 6) -#endif -#ifndef OVERRIDE_TABLE_64_utimensat -TRACE_SYSCALL_TABLE(utimensat, utimensat, 280, 4) -#endif -#ifndef OVERRIDE_TABLE_64_epoll_pwait -TRACE_SYSCALL_TABLE(epoll_pwait, epoll_pwait, 281, 6) -#endif -#ifndef OVERRIDE_TABLE_64_signalfd -TRACE_SYSCALL_TABLE(signalfd, signalfd, 282, 3) -#endif -#ifndef OVERRIDE_TABLE_64_timerfd_settime -TRACE_SYSCALL_TABLE(timerfd_settime, timerfd_settime, 286, 4) -#endif -#ifndef OVERRIDE_TABLE_64_timerfd_gettime -TRACE_SYSCALL_TABLE(timerfd_gettime, timerfd_gettime, 287, 2) -#endif -#ifndef OVERRIDE_TABLE_64_accept4 -TRACE_SYSCALL_TABLE(accept4, accept4, 288, 4) -#endif -#ifndef OVERRIDE_TABLE_64_signalfd4 -TRACE_SYSCALL_TABLE(signalfd4, signalfd4, 289, 4) -#endif -#ifndef OVERRIDE_TABLE_64_pipe2 -TRACE_SYSCALL_TABLE(pipe2, pipe2, 293, 2) -#endif -#ifndef OVERRIDE_TABLE_64_preadv -TRACE_SYSCALL_TABLE(preadv, preadv, 295, 5) -#endif -#ifndef OVERRIDE_TABLE_64_pwritev -TRACE_SYSCALL_TABLE(pwritev, pwritev, 296, 5) -#endif -#ifndef OVERRIDE_TABLE_64_rt_tgsigqueueinfo -TRACE_SYSCALL_TABLE(rt_tgsigqueueinfo, rt_tgsigqueueinfo, 297, 4) -#endif -#ifndef OVERRIDE_TABLE_64_perf_event_open -TRACE_SYSCALL_TABLE(perf_event_open, perf_event_open, 298, 5) -#endif -#ifndef OVERRIDE_TABLE_64_recvmmsg -TRACE_SYSCALL_TABLE(recvmmsg, recvmmsg, 299, 5) -#endif -#ifndef OVERRIDE_TABLE_64_fanotify_mark -TRACE_SYSCALL_TABLE(fanotify_mark, fanotify_mark, 301, 5) -#endif -#ifndef OVERRIDE_TABLE_64_prlimit64 -TRACE_SYSCALL_TABLE(prlimit64, prlimit64, 302, 4) -#endif -#ifndef OVERRIDE_TABLE_64_name_to_handle_at -TRACE_SYSCALL_TABLE(name_to_handle_at, name_to_handle_at, 303, 5) -#endif -#ifndef OVERRIDE_TABLE_64_open_by_handle_at -TRACE_SYSCALL_TABLE(open_by_handle_at, open_by_handle_at, 304, 3) -#endif -#ifndef OVERRIDE_TABLE_64_clock_adjtime -TRACE_SYSCALL_TABLE(clock_adjtime, clock_adjtime, 305, 2) -#endif -#ifndef OVERRIDE_TABLE_64_sendmmsg -TRACE_SYSCALL_TABLE(sendmmsg, sendmmsg, 307, 4) -#endif -#ifndef OVERRIDE_TABLE_64_getcpu -TRACE_SYSCALL_TABLE(getcpu, getcpu, 309, 3) -#endif -#ifndef OVERRIDE_TABLE_64_process_vm_readv -TRACE_SYSCALL_TABLE(process_vm_readv, process_vm_readv, 310, 6) -#endif -#ifndef OVERRIDE_TABLE_64_process_vm_writev -TRACE_SYSCALL_TABLE(process_vm_writev, process_vm_writev, 311, 6) -#endif -#ifndef OVERRIDE_TABLE_64_finit_module -TRACE_SYSCALL_TABLE(finit_module, finit_module, 313, 3) -#endif - -#endif /* CREATE_SYSCALL_TABLE */ diff --git a/instrumentation/syscalls/headers/x86-64-syscalls_pointers_override.h b/instrumentation/syscalls/headers/x86-64-syscalls_pointers_override.h deleted file mode 100644 index bd889451..00000000 --- a/instrumentation/syscalls/headers/x86-64-syscalls_pointers_override.h +++ /dev/null @@ -1,176 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ - -#ifndef CREATE_SYSCALL_TABLE - -#define OVERRIDE_64_connect -SC_LTTNG_TRACEPOINT_EVENT_CODE(connect, - TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr __user * uservaddr, int addrlen), - TP_ARGS(sc_exit(ret,) fd, uservaddr, addrlen), - TP_locvar( - __typeof__(uservaddr->sa_family) sa_family; - uint16_t dport; - uint32_t v4addr; - uint16_t v6addr[8]; - unsigned int v4addr_len, v6addr_len; - ), - TP_code_pre( - sc_in( - memset(tp_locvar, 0, sizeof(*tp_locvar)); - if (addrlen < sizeof(tp_locvar->sa_family)) - goto skip_code; - (void) lib_ring_buffer_copy_from_user_check_nofault(&tp_locvar->sa_family, - &uservaddr->sa_family, sizeof(tp_locvar->sa_family)); - switch (tp_locvar->sa_family) { - case AF_INET: - if (addrlen < sizeof(struct sockaddr_in)) - goto skip_code; - (void) lib_ring_buffer_copy_from_user_check_nofault(&tp_locvar->dport, - &((struct sockaddr_in __user *) uservaddr)->sin_port, - sizeof(tp_locvar->dport)); - (void) lib_ring_buffer_copy_from_user_check_nofault(&tp_locvar->v4addr, - &((struct sockaddr_in __user *) uservaddr)->sin_addr.s_addr, - sizeof(tp_locvar->v4addr)); - tp_locvar->v4addr_len = 4; - break; - case AF_INET6: - if (addrlen < sizeof(struct sockaddr_in6)) - goto skip_code; - (void) lib_ring_buffer_copy_from_user_check_nofault(&tp_locvar->dport, - &((struct sockaddr_in6 __user *) uservaddr)->sin6_port, - sizeof(tp_locvar->dport)); - if (lib_ring_buffer_copy_from_user_check_nofault(tp_locvar->v6addr, - &((struct sockaddr_in6 __user *) uservaddr)->sin6_addr.in6_u.u6_addr8, - sizeof(tp_locvar->v6addr))) - memset(tp_locvar->v6addr, 0, sizeof(tp_locvar->v6addr)); - tp_locvar->v6addr_len = 8; - break; - } - skip_code: - ) - ), - TP_FIELDS( - sc_exit(ctf_integer(long, ret, ret)) - sc_in(ctf_integer(int, fd, fd)) - sc_in(ctf_integer_hex(struct sockaddr *, uservaddr, uservaddr)) - sc_in(ctf_integer_hex(int, addrlen, addrlen)) - sc_in(ctf_integer(unsigned short, family, tp_locvar->sa_family)) - sc_in(ctf_integer_network(uint16_t, dport, tp_locvar->dport)) - sc_in(ctf_sequence_network(uint8_t, v4addr, &tp_locvar->v4addr, unsigned int, tp_locvar->v4addr_len)) - sc_in(ctf_sequence_network(uint16_t, v6addr, &tp_locvar->v6addr, unsigned int, tp_locvar->v6addr_len)) - ), - TP_code_post() -) - -#define LTTNG_SYSCALL_ACCEPT_locvar \ - __typeof__(upeer_sockaddr->sa_family) sa_family;\ - uint16_t sport; \ - uint32_t v4addr; \ - uint16_t v6addr[8]; \ - int v4addr_len, v6addr_len; \ - int uaddr_len; - -#define LTTNG_SYSCALL_ACCEPT_code_pre \ - sc_inout( \ - memset(tp_locvar, 0, sizeof(*tp_locvar)); \ - (void) lib_ring_buffer_copy_from_user_check_nofault(&tp_locvar->uaddr_len, \ - upeer_addrlen, sizeof(tp_locvar->uaddr_len)); \ - ) \ - sc_out( \ - if (tp_locvar->uaddr_len < sizeof(tp_locvar->sa_family)) \ - goto skip_code; \ - (void) lib_ring_buffer_copy_from_user_check_nofault(&tp_locvar->sa_family, \ - &upeer_sockaddr->sa_family, sizeof(tp_locvar->sa_family)); \ - switch (tp_locvar->sa_family) { \ - case AF_INET: \ - if (tp_locvar->uaddr_len < sizeof(struct sockaddr_in)) \ - goto skip_code; \ - (void) lib_ring_buffer_copy_from_user_check_nofault(&tp_locvar->sport, \ - &((struct sockaddr_in __user *) upeer_sockaddr)->sin_port, \ - sizeof(tp_locvar->sport)); \ - (void) lib_ring_buffer_copy_from_user_check_nofault(&tp_locvar->v4addr, \ - &((struct sockaddr_in __user *) upeer_sockaddr)->sin_addr.s_addr, \ - sizeof(tp_locvar->v4addr)); \ - tp_locvar->v4addr_len = 4; \ - break; \ - case AF_INET6: \ - if (tp_locvar->uaddr_len < sizeof(struct sockaddr_in6)) \ - goto skip_code; \ - (void) lib_ring_buffer_copy_from_user_check_nofault(&tp_locvar->sport, \ - &((struct sockaddr_in6 __user *) upeer_sockaddr)->sin6_port, \ - sizeof(tp_locvar->sport)); \ - if (lib_ring_buffer_copy_from_user_check_nofault(tp_locvar->v6addr, \ - &((struct sockaddr_in6 __user *) upeer_sockaddr)->sin6_addr.in6_u.u6_addr8, \ - sizeof(tp_locvar->v6addr))) \ - memset(tp_locvar->v6addr, 0, sizeof(tp_locvar->v6addr)); \ - tp_locvar->v6addr_len = 8; \ - break; \ - } \ - skip_code: \ - ) - -#define OVERRIDE_64_accept -SC_LTTNG_TRACEPOINT_EVENT_CODE(accept, - TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr __user * upeer_sockaddr, int __user * upeer_addrlen), - TP_ARGS(sc_exit(ret,) fd, upeer_sockaddr, upeer_addrlen), - TP_locvar( - LTTNG_SYSCALL_ACCEPT_locvar - ), - TP_code_pre( - LTTNG_SYSCALL_ACCEPT_code_pre - ), - TP_FIELDS( - sc_exit(ctf_integer(long, ret, ret)) - sc_in(ctf_integer(int, fd, fd)) - sc_in(ctf_integer_hex(struct sockaddr *, upeer_sockaddr, upeer_sockaddr)) - sc_inout(ctf_integer(int, upeer_addrlen, tp_locvar->uaddr_len)) - sc_out(ctf_integer(unsigned short, family, tp_locvar->sa_family)) - sc_out(ctf_integer_network(uint16_t, sport, tp_locvar->sport)) - sc_out(ctf_sequence_network(uint8_t, v4addr, &tp_locvar->v4addr, unsigned int, tp_locvar->v4addr_len)) - sc_out(ctf_sequence_network(uint16_t, v6addr, &tp_locvar->v6addr, unsigned int, tp_locvar->v6addr_len)) - ), - TP_code_post() -) - -#define OVERRIDE_64_accept4 -SC_LTTNG_TRACEPOINT_EVENT_CODE(accept4, - TP_PROTO(sc_exit(long ret,) int fd, struct sockaddr __user * upeer_sockaddr, int __user * upeer_addrlen, int flags), - TP_ARGS(sc_exit(ret,) fd, upeer_sockaddr, upeer_addrlen, flags), - TP_locvar( - LTTNG_SYSCALL_ACCEPT_locvar - ), - TP_code_pre( - LTTNG_SYSCALL_ACCEPT_code_pre - ), - TP_FIELDS( - sc_exit(ctf_integer(long, ret, ret)) - sc_in(ctf_integer(int, fd, fd)) - sc_in(ctf_integer_hex(struct sockaddr *, upeer_sockaddr, upeer_sockaddr)) - sc_inout(ctf_integer(int, upeer_addrlen, tp_locvar->uaddr_len)) - sc_in(ctf_integer_hex(int, flags, flags)) - sc_out(ctf_integer(unsigned short, family, tp_locvar->sa_family)) - sc_out(ctf_integer_network(uint16_t, sport, tp_locvar->sport)) - sc_out(ctf_sequence_network(uint8_t, v4addr, &tp_locvar->v4addr, unsigned int, tp_locvar->v4addr_len)) - sc_out(ctf_sequence_network(uint16_t, v6addr, &tp_locvar->v6addr, unsigned int, tp_locvar->v6addr_len)) - ), - TP_code_post() -) - -#define OVERRIDE_64_pipe -SC_LTTNG_TRACEPOINT_EVENT(pipe, - TP_PROTO(sc_exit(long ret,) int * fildes), - TP_ARGS(sc_exit(ret,) fildes), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) - sc_out(ctf_user_array(int, fildes, fildes, 2)) - ) -) - -#else /* CREATE_SYSCALL_TABLE */ - -#define OVERRIDE_TABLE_64_clone -TRACE_SYSCALL_TABLE(clone, clone, 56, 5) -#define OVERRIDE_TABLE_64_execve -TRACE_SYSCALL_TABLE(execve, execve, 59, 3) -#define OVERRIDE_TABLE_64_getcpu -TRACE_SYSCALL_TABLE(getcpu, getcpu, 309, 3) - -#endif /* CREATE_SYSCALL_TABLE */ diff --git a/instrumentation/syscalls/lttng-get-syscall-inout.sh b/instrumentation/syscalls/lttng-get-syscall-inout.sh deleted file mode 100755 index 8ddaad8d..00000000 --- a/instrumentation/syscalls/lttng-get-syscall-inout.sh +++ /dev/null @@ -1,95 +0,0 @@ -#!/bin/bash -# SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) - -# example usage: -# lttng-get-syscall-inout.sh table-syscall-inout.txt select 1 - -FILENAME=$1 -SYSCALL_NAME=$2 -ARG_NR=$3 -TMPFILE=$(mktemp) - -# Delete temp file on exit -trap 'rm -f "$TMPFILE"' EXIT - - -if [ x"${FILENAME}" = x"" ]; then - echo "Error: Please specify input file name as first argument" >&2 - exit 1 -fi - -if [ x"${SYSCALL_NAME}" = x"" ]; then - echo "Error: Please specify system call name as second argument" >&2 - exit 1 -fi - -if [[ x"${ARG_NR}" = x"" || ${ARG_NR} == 0 ]]; then - echo "Error: Please specify argument number larger than 0 as third argument" >&2 - exit 1 -fi - -# Abort on error and undefined variable -set -eu - -# Get the required syscall -grep "syscall ${SYSCALL_NAME} " "${FILENAME}" > "${TMPFILE}" || true - -# Error out if we got more than one syscall -NR_MATCH=$(wc -l < "${TMPFILE}") -if [ "${NR_MATCH}" -gt 1 ]; then - echo "Error: more than one system call match" >&2 - exit 1 -fi - -# Default to sc_inout for unknown syscalls -if [ "${NR_MATCH}" -eq 0 ]; then - echo "Warning: no match for syscall '${SYSCALL_NAME}', set to 'inout'" >&2 - # no match, default to inout - echo "sc_inout" - exit 0 -fi - -# Get the number of argument -SC_ARGS=$(sed 's/^syscall \([^ ]*\) nbargs \([^ ]*\) .*/\2/g' "${TMPFILE}") - -if [ "${ARG_NR}" -gt "${SC_ARGS}" ]; then - echo "Error: argument number (${ARG_NR}) is larger than number of syscall arguments (${SC_ARGS})" >&2 - exit 1 -fi - -if [ "${ARG_NR}" == 1 ]; then - SC_ARG_TYPE=$(sed 's/^syscall \([^ ]*\) nbargs \([^ ]*\) rw: (\([^,)]*\).*/\3/g' "${TMPFILE}") -fi - -if [ "${ARG_NR}" == 2 ]; then - SC_ARG_TYPE=$(sed 's/^syscall \([^ ]*\) nbargs \([^ ]*\) rw: ([^,]*, \([^,)]*\).*/\3/g' "${TMPFILE}") -fi - -if [ "${ARG_NR}" == 3 ]; then - SC_ARG_TYPE=$(sed 's/^syscall \([^ ]*\) nbargs \([^ ]*\) rw: ([^,]*, [^,]*, \([^,)]*\).*/\3/g' "${TMPFILE}") -fi - -if [ "${ARG_NR}" == 4 ]; then - SC_ARG_TYPE=$(sed 's/^syscall \([^ ]*\) nbargs \([^ ]*\) rw: ([^,]*, [^,]*, [^,]*, \([^,)]*\).*/\3/g' "${TMPFILE}") -fi - -if [ "${ARG_NR}" == 5 ]; then - SC_ARG_TYPE=$(sed 's/^syscall \([^ ]*\) nbargs \([^ ]*\) rw: ([^,]*, [^,]*, [^,]*, [^,]*, \([^,)]*\).*/\3/g' "${TMPFILE}") -fi - -if [ "${ARG_NR}" == 6 ]; then - SC_ARG_TYPE=$(sed 's/^syscall \([^ ]*\) nbargs \([^ ]*\) rw: ([^,]*, [^,]*, [^,]*, [^,]*, [^,]*, \([^,)]*\).*/\3/g' "${TMPFILE}") -fi - - -if [ "${SC_ARG_TYPE}" = "r" ]; then - echo "sc_in" -fi -if [ "${SC_ARG_TYPE}" = "w" ]; then - echo "sc_out" -fi -if [ "${SC_ARG_TYPE}" = "rw" ]; then - echo "sc_inout" -fi - -# EOF diff --git a/instrumentation/syscalls/lttng-syscalls-extract.sh b/instrumentation/syscalls/lttng-syscalls-extract.sh deleted file mode 100755 index d68baa96..00000000 --- a/instrumentation/syscalls/lttng-syscalls-extract.sh +++ /dev/null @@ -1,37 +0,0 @@ -#!/bin/bash -# SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) - -set -eu - -outfile="${1:-}" - -if [ "x$outfile" = "x" ]; then - echo "Specify an output file as first argument, it will be overwritten." - exit 1 -fi - -cd lttng-syscalls-extractor || exit 1 -make -cd - || exit 1 - -# Generate a random string to use as an identifier -ident=$(tr -dc 'a-zA-Z0-9' < /dev/urandom | fold -w 8 | head -n1) - -sudo insmod ./lttng-syscalls-extractor/lttng-syscalls-extractor.ko ident="$ident" || true - -sudo dmesg | sed -n -e 's/\(\[.*\] \)\?'"$ident"'//p' > "$outfile" - -# Make sure we have both the start and end markers -if grep -q -- '---START---' "$outfile"; then - sed -i '/^---START---/d' "$outfile" -else - echo "Error: Start marker missing from dmesg output, your kernel log buffer is probably too small, set CONFIG_LOG_BUF_SHIFT to a bigger value." - exit 1 -fi - -if grep -q -- '---END---' "$outfile"; then - sed -i '/^---END---/d' "$outfile" -else - echo "Error: End marker missing from dmesg output, something went wrong." - exit 1 -fi diff --git a/instrumentation/syscalls/lttng-syscalls-extractor/Makefile b/instrumentation/syscalls/lttng-syscalls-extractor/Makefile deleted file mode 100644 index b3e9c431..00000000 --- a/instrumentation/syscalls/lttng-syscalls-extractor/Makefile +++ /dev/null @@ -1,31 +0,0 @@ -# SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) - -ifneq ($(KERNELRELEASE),) - - # This part of the Makefile is used when called by the kernel build system - # and defines the modules to be built. - - obj-m += lttng-syscalls-extractor.o - -else # KERNELRELEASE - -# This part of the Makefile is used when the 'make' command is runned in the -# base directory of the lttng-modules sources. It sets some environment and -# calls the kernel build system to build the actual modules. - -KERNELDIR ?= /lib/modules/$(shell uname -r)/build -PWD := $(shell pwd) -CFLAGS = $(EXTCFLAGS) - -default: modules - -modules: - $(MAKE) -C $(KERNELDIR) M=$(PWD) modules - -clean: - $(MAKE) -C $(KERNELDIR) M=$(PWD) clean - -%.i: %.c - $(MAKE) -C $(KERNELDIR) M=$(PWD) $@ - -endif # KERNELRELEASE diff --git a/instrumentation/syscalls/lttng-syscalls-extractor/linux-link-trace-syscalls-as-data.patch b/instrumentation/syscalls/lttng-syscalls-extractor/linux-link-trace-syscalls-as-data.patch deleted file mode 100644 index 5269071f..00000000 --- a/instrumentation/syscalls/lttng-syscalls-extractor/linux-link-trace-syscalls-as-data.patch +++ /dev/null @@ -1,26 +0,0 @@ -Linux: link syscalls metadata as data (for LTTng syscall extraction) - -* NOT for mainline * - -Signed-off-by: Mathieu Desnoyers - -diff --git a/include/asm-generic/vmlinux.lds.h b/include/asm-generic/vmlinux.lds.h -index e00f41aa8ec4..13f51fa7c3f3 100644 ---- a/include/asm-generic/vmlinux.lds.h -+++ b/include/asm-generic/vmlinux.lds.h -@@ -318,6 +318,7 @@ - __end_once = .; \ - STRUCT_ALIGN(); \ - *(__tracepoints) \ -+ TRACE_SYSCALLS() \ - /* implement dynamic printk debug */ \ - . = ALIGN(8); \ - __start___verbose = .; \ -@@ -650,7 +651,6 @@ - MCOUNT_REC() \ - *(.init.rodata .init.rodata.*) \ - FTRACE_EVENTS() \ -- TRACE_SYSCALLS() \ - KPROBE_BLACKLIST() \ - ERROR_INJECT_WHITELIST() \ - MEM_DISCARD(init.rodata) \ diff --git a/instrumentation/syscalls/lttng-syscalls-extractor/lttng-syscalls-extractor.c b/instrumentation/syscalls/lttng-syscalls-extractor/lttng-syscalls-extractor.c deleted file mode 100644 index 0f683750..00000000 --- a/instrumentation/syscalls/lttng-syscalls-extractor/lttng-syscalls-extractor.c +++ /dev/null @@ -1,98 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) - * - * lttng-syscalls-extractor.c - * - * Dump syscall metadata to console. - * - * Copyright 2011 Mathieu Desnoyers - * Copyright 2011 Julien Desfossez - */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#ifndef CONFIG_FTRACE_SYSCALLS -#error "You need to set CONFIG_FTRACE_SYSCALLS=y" -#endif - -#ifndef CONFIG_KALLSYMS_ALL -#error "You need to set CONFIG_KALLSYMS_ALL=y" -#endif - -/* - * The 'ident' parameter is prepended to each printk line to help - * extract the proper lines from dmesg. - */ -static char *ident = ""; -module_param(ident, charp, 0); - -static struct syscall_metadata **__start_syscalls_metadata; -static struct syscall_metadata **__stop_syscalls_metadata; - -static __init -struct syscall_metadata *find_syscall_meta(unsigned long syscall) -{ - struct syscall_metadata **iter; - - for (iter = __start_syscalls_metadata; - iter < __stop_syscalls_metadata; iter++) { - if ((*iter)->syscall_nr == syscall) - return (*iter); - } - return NULL; -} - -int init_module(void) -{ - struct syscall_metadata *meta; - int i; - - __start_syscalls_metadata = (void *) kallsyms_lookup_name("__start_syscalls_metadata"); - __stop_syscalls_metadata = (void *) kallsyms_lookup_name("__stop_syscalls_metadata"); - - printk("%s---START---\n", ident); - for (i = 0; i < NR_syscalls; i++) { - int j; - - meta = find_syscall_meta(i); - if (!meta) - continue; - printk("%ssyscall %s nr %d nbargs %d ", - ident, meta->name, meta->syscall_nr, meta->nb_args); - printk(KERN_CONT "types: ("); - for (j = 0; j < meta->nb_args; j++) { - if (j > 0) - printk(KERN_CONT ", "); - printk(KERN_CONT "%s", meta->types[j]); - } - printk(KERN_CONT ") "); - printk(KERN_CONT "args: ("); - for (j = 0; j < meta->nb_args; j++) { - if (j > 0) - printk(KERN_CONT ", "); - printk(KERN_CONT "%s", meta->args[j]); - } - printk(KERN_CONT ")\n"); - } - printk("%s---END---\n", ident); - - /* - * This module always fails to load. - */ - return -1; -} - -void cleanup_module(void) -{ -} - -MODULE_LICENSE("GPL"); diff --git a/instrumentation/syscalls/lttng-syscalls-generate-headers.sh b/instrumentation/syscalls/lttng-syscalls-generate-headers.sh deleted file mode 100755 index 863f390e..00000000 --- a/instrumentation/syscalls/lttng-syscalls-generate-headers.sh +++ /dev/null @@ -1,351 +0,0 @@ -#!/bin/bash - -# Generate system call probe description macros from syscall metadata dump file. -# The resulting header will be written in the headers subdirectory, in a file name -# based on the name of the input file. -# -# example usage: -# -# lttng-syscalls-generate-headers.sh -# lttng-syscalls-generate-headers.sh integers 3.0.4 x86-64-syscalls 64 -# lttng-syscalls-generate-headers.sh pointers 3.0.4 x86-64-syscalls 64 - -CLASS=$1 -VERSIONDIR=$2 -INPUTFILE=$3 -BITNESS=$4 -INPUT=${VERSIONDIR}/${INPUTFILE} -HEADER=headers/${INPUTFILE}_${CLASS}.h - -if [ x"$VERSIONDIR" = x"" ]; then - echo "Error: Please specify input directory as second argument" >&2 - exit 1 -fi - -if [ x"$INPUTFILE" = x"" ]; then - echo "Error: Please specify input file as third argument" >&2 - exit 1 -fi - -if [ x"$BITNESS" != x"32" ] && [ x"$BITNESS" != x"64" ]; then - echo "Error: Please specify bitness as fourth argument (\"32\" or \"64\")" >&2 - exit 1 -fi - -# Abort on error and undefined variable -set -eu - -# Create temp files -SRCFILE=$(mktemp) -TMPFILE=$(mktemp) - -# Delete temp files on exit -trap 'rm -f "${SRCFILE}" "${TMPFILE}"' EXIT - -cp "${INPUT}" "${SRCFILE}" - -## Cleanup the input file -# Remove the dmesg timestamp if present -perl -pi -e 's/^\[.*\] //g' "${SRCFILE}" -# Remove the 'sys_' prefix from syscall names -perl -pi -e 's/^syscall sys_([^ ]*)/syscall $1/g' "${SRCFILE}" -# Remove the user attribute from arguments -sed -i 's/ __attribute__((user))//g' "${SRCFILE}" - -#Filter - -if [ "$CLASS" = integers ]; then - #select integers and no-args. - CLASSCAP=INTEGERS - grep -v "\\*\|cap_user_header_t" "${SRCFILE}" > "${TMPFILE}" - mv "${TMPFILE}" "${SRCFILE}" -elif [ "$CLASS" = pointers ]; then - #select system calls using pointers. - CLASSCAP=POINTERS - grep "\\*\|cap_#user_header_t" "${SRCFILE}" > "${TMPFILE}" - mv "${TMPFILE}" "${SRCFILE}" -else - echo "Error: Please specify \"integers\" or \"pointers\" as first argument" >&2 - exit 1 -fi - - -echo "/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ - -/* THIS FILE IS AUTO-GENERATED. DO NOT EDIT */ - -/* Generated from ${INPUTFILE} ${VERSIONDIR} */ - -#ifndef CREATE_SYSCALL_TABLE - -#if !defined(_TRACE_SYSCALLS_${CLASSCAP}_H) || defined(TRACE_HEADER_MULTI_READ) -#define _TRACE_SYSCALLS_${CLASSCAP}_H - -#include -#include -#include \"${INPUTFILE}_${CLASS}_override.h\" -#include \"syscalls_${CLASS}_override.h\" -" > "${HEADER}" - -if [ "$CLASS" = integers ]; then - - NRARGS=0 - - # shellcheck disable=SC2129 - printf \ -'#ifdef SC_ENTER -SC_LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(syscalls_noargs, - TP_FIELDS() -) -' >> "${HEADER}" - - # shellcheck disable=SC2026 - grep "^syscall [^ ]* nr [^ ]* nbargs ${NRARGS} " "${SRCFILE}" | \ - perl -p -e 's/^syscall ([^ ]*) nr ([^ ]*) nbargs ([^ ]*) '\ -'types: \(([^)]*)\) '\ -'args: \(([^)]*)\)/'\ -'#ifndef OVERRIDE_'"${BITNESS}"'_$1\n'\ -'SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscalls_noargs, $1)\n'\ -'#endif/g' >> "${HEADER}" - - printf '#else /* #ifdef SC_ENTER */\n' >> "${HEADER}" - - # shellcheck disable=SC2026 - grep "^syscall [^ ]* nr [^ ]* nbargs ${NRARGS} " "${SRCFILE}" | \ - perl -p -e 's/^syscall ([^ ]*) nr ([^ ]*) nbargs ([^ ]*) '\ -'types: \(([^)]*)\) '\ -'args: \(([^)]*)\)/'\ -'#ifndef OVERRIDE_'"${BITNESS}"'_$1\n'\ -'SC_LTTNG_TRACEPOINT_EVENT($1,\n'\ -' TP_PROTO(sc_exit(long ret)),\n'\ -' TP_ARGS(sc_exit(ret)),\n'\ -' TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)))\n'\ -')\n'\ -'#endif/g' >> "${HEADER}" - - printf '#endif /* else #ifdef SC_ENTER */\n' >> "${HEADER}" - -fi - - -# types: 4 -# args 5 - -NRARGS=1 -grep "^syscall [^ ]* nr [^ ]* nbargs ${NRARGS} " "${SRCFILE}" | while read -r LINE; do - SC_NAME=$(echo "${LINE}" | perl -p -e 's/^syscall ([^ ]*) .*/$1/g') - ARG1=$(./lttng-get-syscall-inout.sh table-syscall-inout.txt "${SC_NAME}" 1) - - echo Syscall: "${SC_NAME}" "${ARG1}" - - # shellcheck disable=SC2026 - echo "${LINE}" | perl -p -e 's/^syscall ([^ ]*) nr ([^ ]*) nbargs ([^ ]*) '\ -'types: \(([^)]*)\) '\ -'args: \(([^)]*)\)/'\ -'#ifndef OVERRIDE_'"${BITNESS}"'_$1\n'\ -'SC_LTTNG_TRACEPOINT_EVENT($1,\n'\ -' TP_PROTO(sc_exit(long ret,) $4 $5),\n'\ -' TP_ARGS(sc_exit(ret,) $5),\n'\ -' TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) '"${ARG1}"'(ctf_integer($4, $5, $5)))\n'\ -')\n'\ -'#endif/g' >> "${HEADER}" -done - -# types: 4 5 -# args 6 7 - -NRARGS=2 -grep "^syscall [^ ]* nr [^ ]* nbargs ${NRARGS} " "${SRCFILE}" | while read -r LINE; do - SC_NAME=$(echo "${LINE}" | perl -p -e 's/^syscall ([^ ]*) .*/$1/g') - ARG1=$(./lttng-get-syscall-inout.sh table-syscall-inout.txt "${SC_NAME}" 1) - ARG2=$(./lttng-get-syscall-inout.sh table-syscall-inout.txt "${SC_NAME}" 2) - - echo Syscall: "${SC_NAME}" "${ARG1}" "${ARG2}" - - # shellcheck disable=SC2026 - echo "${LINE}" | perl -p -e 's/^syscall ([^ ]*) nr ([^ ]*) nbargs ([^ ]*) '\ -'types: \(([^,]*), ([^)]*)\) '\ -'args: \(([^,]*), ([^)]*)\)/'\ -'#ifndef OVERRIDE_'"${BITNESS}"'_$1\n'\ -'SC_LTTNG_TRACEPOINT_EVENT($1,\n'\ -' TP_PROTO(sc_exit(long ret,) $4 $6, $5 $7),\n'\ -' TP_ARGS(sc_exit(ret,) $6, $7),\n'\ -' TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) '"${ARG1}"'(ctf_integer($4, $6, $6)) '"${ARG2}"'(ctf_integer($5, $7, $7)))\n'\ -')\n'\ -'#endif/g' >> "${HEADER}" -done - -# types: 4 5 6 -# args 7 8 9 - -NRARGS=3 -grep "^syscall [^ ]* nr [^ ]* nbargs ${NRARGS} " "${SRCFILE}" | while read -r LINE; do - SC_NAME=$(echo "${LINE}" | perl -p -e 's/^syscall ([^ ]*) .*/$1/g') - ARG1=$(./lttng-get-syscall-inout.sh table-syscall-inout.txt "${SC_NAME}" 1) - ARG2=$(./lttng-get-syscall-inout.sh table-syscall-inout.txt "${SC_NAME}" 2) - ARG3=$(./lttng-get-syscall-inout.sh table-syscall-inout.txt "${SC_NAME}" 3) - - echo Syscall: "${SC_NAME}" "${ARG1}" "${ARG2}" "${ARG3}" - - # shellcheck disable=SC2026 - echo "${LINE}" | perl -p -e 's/^syscall ([^ ]*) nr ([^ ]*) nbargs ([^ ]*) '\ -'types: \(([^,]*), ([^,]*), ([^)]*)\) '\ -'args: \(([^,]*), ([^,]*), ([^)]*)\)/'\ -'#ifndef OVERRIDE_'"${BITNESS}"'_$1\n'\ -'SC_LTTNG_TRACEPOINT_EVENT($1,\n'\ -' TP_PROTO(sc_exit(long ret,) $4 $7, $5 $8, $6 $9),\n'\ -' TP_ARGS(sc_exit(ret,) $7, $8, $9),\n'\ -' TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) '"${ARG1}"'(ctf_integer($4, $7, $7)) '"${ARG2}"'(ctf_integer($5, $8, $8)) '"${ARG3}"'(ctf_integer($6, $9, $9)))\n'\ -')\n'\ -'#endif/g' >> "${HEADER}" -done - - -# types: 4 5 6 7 -# args 8 9 10 11 - -NRARGS=4 -grep "^syscall [^ ]* nr [^ ]* nbargs ${NRARGS} " "${SRCFILE}" | while read -r LINE; do - SC_NAME=$(echo "${LINE}" | perl -p -e 's/^syscall ([^ ]*) .*/$1/g') - ARG1=$(./lttng-get-syscall-inout.sh table-syscall-inout.txt "${SC_NAME}" 1) - ARG2=$(./lttng-get-syscall-inout.sh table-syscall-inout.txt "${SC_NAME}" 2) - ARG3=$(./lttng-get-syscall-inout.sh table-syscall-inout.txt "${SC_NAME}" 3) - ARG4=$(./lttng-get-syscall-inout.sh table-syscall-inout.txt "${SC_NAME}" 4) - - echo Syscall: "${SC_NAME}" "${ARG1}" "${ARG2}" "${ARG3}" "${ARG4}" - - # shellcheck disable=SC2026 - echo "${LINE}" | perl -p -e 's/^syscall ([^ ]*) nr ([^ ]*) nbargs ([^ ]*) '\ -'types: \(([^,]*), ([^,]*), ([^,]*), ([^)]*)\) '\ -'args: \(([^,]*), ([^,]*), ([^,]*), ([^)]*)\)/'\ -'#ifndef OVERRIDE_'"${BITNESS}"'_$1\n'\ -'SC_LTTNG_TRACEPOINT_EVENT($1,\n'\ -' TP_PROTO(sc_exit(long ret,) $4 $8, $5 $9, $6 $10, $7 $11),\n'\ -' TP_ARGS(sc_exit(ret,) $8, $9, $10, $11),\n'\ -' TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) '"${ARG1}"'(ctf_integer($4, $8, $8)) '"${ARG2}"'(ctf_integer($5, $9, $9)) '"${ARG3}"'(ctf_integer($6, $10, $10)) '"${ARG4}"'(ctf_integer($7, $11, $11)))\n'\ -')\n'\ -'#endif/g' >> "${HEADER}" -done - -# types: 4 5 6 7 8 -# args 9 10 11 12 13 - -NRARGS=5 -grep "^syscall [^ ]* nr [^ ]* nbargs ${NRARGS} " "${SRCFILE}" | while read -r LINE; do - SC_NAME=$(echo "${LINE}" | perl -p -e 's/^syscall ([^ ]*) .*/$1/g') - ARG1=$(./lttng-get-syscall-inout.sh table-syscall-inout.txt "${SC_NAME}" 1) - ARG2=$(./lttng-get-syscall-inout.sh table-syscall-inout.txt "${SC_NAME}" 2) - ARG3=$(./lttng-get-syscall-inout.sh table-syscall-inout.txt "${SC_NAME}" 3) - ARG4=$(./lttng-get-syscall-inout.sh table-syscall-inout.txt "${SC_NAME}" 4) - ARG5=$(./lttng-get-syscall-inout.sh table-syscall-inout.txt "${SC_NAME}" 5) - - echo Syscall: "${SC_NAME}" "${ARG1}" "${ARG2}" "${ARG3}" "${ARG4}" "${ARG5}" - - # shellcheck disable=SC2026 - echo "${LINE}" | perl -p -e 's/^syscall ([^ ]*) nr ([^ ]*) nbargs ([^ ]*) '\ -'types: \(([^,]*), ([^,]*), ([^,]*), ([^,]*), ([^)]*)\) '\ -'args: \(([^,]*), ([^,]*), ([^,]*), ([^,]*), ([^)]*)\)/'\ -'#ifndef OVERRIDE_'"${BITNESS}"'_$1\n'\ -'SC_LTTNG_TRACEPOINT_EVENT($1,\n'\ -' TP_PROTO(sc_exit(long ret,) $4 $9, $5 $10, $6 $11, $7 $12, $8 $13),\n'\ -' TP_ARGS(sc_exit(ret,) $9, $10, $11, $12, $13),\n'\ -' TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) '"${ARG1}"'(ctf_integer($4, $9, $9)) '"${ARG2}"'(ctf_integer($5, $10, $10)) '"${ARG3}"'(ctf_integer($6, $11, $11)) '"${ARG4}"'(ctf_integer($7, $12, $12)) '"${ARG5}"'(ctf_integer($8, $13, $13)))\n'\ -')\n'\ -'#endif/g' >> "${HEADER}" -done - - -# types: 4 5 6 7 8 9 -# args 10 11 12 13 14 15 - -NRARGS=6 -grep "^syscall [^ ]* nr [^ ]* nbargs ${NRARGS} " "${SRCFILE}" | while read -r LINE; do - SC_NAME=$(echo "${LINE}" | perl -p -e 's/^syscall ([^ ]*) .*/$1/g') - ARG1=$(./lttng-get-syscall-inout.sh table-syscall-inout.txt "${SC_NAME}" 1) - ARG2=$(./lttng-get-syscall-inout.sh table-syscall-inout.txt "${SC_NAME}" 2) - ARG3=$(./lttng-get-syscall-inout.sh table-syscall-inout.txt "${SC_NAME}" 3) - ARG4=$(./lttng-get-syscall-inout.sh table-syscall-inout.txt "${SC_NAME}" 4) - ARG5=$(./lttng-get-syscall-inout.sh table-syscall-inout.txt "${SC_NAME}" 5) - ARG6=$(./lttng-get-syscall-inout.sh table-syscall-inout.txt "${SC_NAME}" 6) - - echo Syscall: "${SC_NAME}" "${ARG1}" "${ARG2}" "${ARG3}" "${ARG4}" "${ARG5}" "${ARG6}" - - # shellcheck disable=SC2026 - echo "${LINE}" | perl -p -e 's/^syscall ([^ ]*) nr ([^ ]*) nbargs ([^ ]*) '\ -'types: \(([^,]*), ([^,]*), ([^,]*), ([^,]*), ([^,]*), ([^\)]*)\) '\ -'args: \(([^,]*), ([^,]*), ([^,]*), ([^,]*), ([^,]*), ([^\)]*)\)/'\ -'#ifndef OVERRIDE_'"${BITNESS}"'_$1\n'\ -'SC_LTTNG_TRACEPOINT_EVENT($1,\n'\ -' TP_PROTO(sc_exit(long ret,) $4 $10, $5 $11, $6 $12, $7 $13, $8 $14, $9 $15),\n'\ -' TP_ARGS(sc_exit(ret,) $10, $11, $12, $13, $14, $15),\n'\ -' TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) '"${ARG1}"'(ctf_integer($4, $10, $10)) '"${ARG2}"'(ctf_integer($5, $11, $11)) '"${ARG3}"'(ctf_integer($6, $12, $12)) '"${ARG4}"'(ctf_integer($7, $13, $13)) '"${ARG5}"'(ctf_integer($8, $14, $14)) '"${ARG6}"'(ctf_integer($9, $15, $15)))\n'\ -')\n'\ -'#endif/g' >> "${HEADER}" -done - -# Macro for tracing syscall table - -echo \ -" -#endif /* _TRACE_SYSCALLS_${CLASSCAP}_H */ - -/* This part must be outside protection */ -#include - -#else /* CREATE_SYSCALL_TABLE */ - -#include \"${INPUTFILE}_${CLASS}_override.h\" -#include \"syscalls_${CLASS}_override.h\" -" >> "${HEADER}" - -NRARGS=0 - -if [ "$CLASS" = integers ]; then - #noargs - - # shellcheck disable=SC2129 - printf '#ifdef SC_ENTER\n' >> "${HEADER}" - - # shellcheck disable=SC2026 - grep "^syscall [^ ]* nr [^ ]* nbargs ${NRARGS} " "${SRCFILE}" | \ - perl -p -e 's/^syscall ([^ ]*) nr ([^ ]*) nbargs ([^ ]*) .*$/'\ -'#ifndef OVERRIDE_TABLE_'"${BITNESS}"'_$1\n'\ -'TRACE_SYSCALL_TABLE\(syscalls_noargs, $1, $2, $3\)\n'\ -'#endif/g' >> "${HEADER}" - - printf '#else /* #ifdef SC_ENTER */\n' >> "${HEADER}" - - # shellcheck disable=SC2026 - grep "^syscall [^ ]* nr [^ ]* nbargs ${NRARGS} " "${SRCFILE}" | \ - perl -p -e 's/^syscall ([^ ]*) nr ([^ ]*) nbargs ([^ ]*) .*$/'\ -'#ifndef OVERRIDE_TABLE_'"${BITNESS}"'_$1\n'\ -'TRACE_SYSCALL_TABLE($1, $1, $2, $3)\n'\ -'#endif/g' >> "${HEADER}" - - printf '#endif /* else #ifdef SC_ENTER */\n' >> "${HEADER}" -fi - -#others. -# shellcheck disable=SC2026 -grep -v "^syscall [^ ]* nr [^ ]* nbargs ${NRARGS} " "${SRCFILE}" | \ - perl -p -e 's/^syscall ([^ ]*) nr ([^ ]*) nbargs ([^ ]*) .*$/'\ -'#ifndef OVERRIDE_TABLE_'"${BITNESS}"'_$1\n'\ -'TRACE_SYSCALL_TABLE($1, $1, $2, $3)\n'\ -'#endif/g' >> "${HEADER}" - -printf '\n#endif /* CREATE_SYSCALL_TABLE */\n' >> "${HEADER}" - -#fields names: ...char * type with *name* or *file* or *path* or *root* -# or *put_old* or *type* -perl -pi -e 's/ctf_integer\(([^,)]*char \*), ([^\)]*)(name|file|path|root|put_old|type)([^\)]*)\)/ctf_user_string($2$3$4)/g' \ - "${HEADER}" - -#prettify addresses heuristics. -#field names with addr or ptr -perl -pi -e 's/ctf_integer\(([^,)]*), ([^,)]*addr|[^,)]*ptr)([^),]*)\)/ctf_integer_hex($1, $2$3, $2$3)/g' \ - "${HEADER}" - -#field types ending with '*' -perl -pi -e 's/ctf_integer\(([^,)]*\*), ([^),]*)\)/ctf_integer_hex($1, $2, $2)/g' "${HEADER}" - -# EOF diff --git a/instrumentation/syscalls/table-syscall-inout.txt b/instrumentation/syscalls/table-syscall-inout.txt deleted file mode 100644 index cb835a52..00000000 --- a/instrumentation/syscalls/table-syscall-inout.txt +++ /dev/null @@ -1,289 +0,0 @@ -syscall read nbargs 3 rw: (r, w, r) -syscall write nbargs 3 rw: (r, r, r) -syscall open nbargs 3 rw: (r, r, r) -syscall close nbargs 1 rw: (r) -syscall newstat nbargs 2 rw: (r, w) -syscall newfstat nbargs 2 rw: (r, w) -syscall newlstat nbargs 2 rw: (r, w) -syscall poll nbargs 3 rw: (rw, r, r) -syscall lseek nbargs 3 rw: (r, r, r) -syscall mmap nbargs 6 rw: (r, r, r, r, r, r) -syscall mprotect nbargs 3 rw: (r, r, r) -syscall munmap nbargs 2 rw: (r, r) -syscall brk nbargs 1 rw: (r) -syscall rt_sigaction nbargs 4 rw: (r, r, w, r) -syscall rt_sigprocmask nbargs 4 rw: (r, r, w, r) -syscall ioctl nbargs 3 rw: (r, r, rw) -syscall pread64 nbargs 4 rw: (r, w, r, r) -syscall pwrite64 nbargs 4 rw: (r, r, r, r) -syscall readv nbargs 3 rw: (r, rw, r) -syscall writev nbargs 3 rw: (r, rw, r) -syscall access nbargs 2 rw: (r, r) -syscall pipe nbargs 1 rw: (w) -syscall select nbargs 5 rw: (r, rw, rw, rw, rw) -syscall sched_yield nbargs 0 -syscall mremap nbargs 5 rw: (r, r, r, r, r) -syscall msync nbargs 3 rw: (r, r, r) -syscall mincore nbargs 3 rw: (r, r, w) -syscall madvise nbargs 3 rw: (r, r, r) -syscall shmget nbargs 3 rw: (r, r, r) -syscall shmat nbargs 3 rw: (r, r, r) -syscall shmctl nbargs 3 rw: (r, r, rw) -syscall dup nbargs 1 rw: (r) -syscall dup2 nbargs 2 rw: (r, r) -syscall pause nbargs 0 -syscall nanosleep nbargs 2 rw: (r, w) -syscall getitimer nbargs 2 rw: (r, w) -syscall alarm nbargs 1 rw: (r) -syscall setitimer nbargs 3 rw: (r, r, w) -syscall getpid nbargs 0 -syscall sendfile64 nbargs 4 rw: (r, r, rw, r) -syscall socket nbargs 3 rw: (r, r, r) -syscall connect nbargs 3 rw: (r, r, r) -syscall accept nbargs 3 rw: (r, w, rw) -syscall sendto nbargs 6 rw: (r, r, r, r, r, r) -syscall recvfrom nbargs 6 rw: (r, w, r, r, w, rw) -syscall sendmsg nbargs 3 rw: (r, r, r) -syscall recvmsg nbargs 3 rw: (r, rw, r) -syscall shutdown nbargs 2 rw: (r, r) -syscall bind nbargs 3 rw: (r, r, r) -syscall listen nbargs 2 rw: (r, r) -syscall getsockname nbargs 3 rw: (r, w, rw) -syscall getpeername nbargs 3 rw: (r, w, rw) -syscall socketpair nbargs 4 rw: (r, r, r, w) -syscall setsockopt nbargs 5 rw: (r, r, r, r, r) -syscall getsockopt nbargs 5 rw: (r, r, r, w, rw) -syscall exit nbargs 1 rw: (r) -syscall wait4 nbargs 4 rw: (r, w, r, w) -syscall kill nbargs 2 rw: (r, r) -syscall newuname nbargs 1 rw: (w) -syscall semget nbargs 3 rw: (r, r, r) -syscall semop nbargs 3 rw: (r, r, r) -syscall semctl nbargs 4 rw: (r, r, r, rw) -syscall shmdt nbargs 1 rw: (r) -syscall msgget nbargs 2 rw: (r, r) -syscall msgsnd nbargs 4 rw: (r, r, r, r) -syscall msgrcv nbargs 5 rw: (r, w, r, r, r) -syscall msgctl nbargs 3 rw: (r, r, rw) -syscall fcntl nbargs 3 rw: (r, r, rw) -syscall flock nbargs 2 rw: (r, r) -syscall fsync nbargs 1 rw: (r) -syscall fdatasync nbargs 1 rw: (r) -syscall truncate nbargs 2 rw: (r, r) -syscall ftruncate nbargs 2 rw: (r, r) -syscall getdents nbargs 3 rw: (r, w, r) -syscall getcwd nbargs 2 rw: (w, r) -syscall chdir nbargs 1 rw: (r) -syscall fchdir nbargs 1 rw: (r) -syscall rename nbargs 2 rw: (r, r) -syscall mkdir nbargs 2 rw: (r, r) -syscall rmdir nbargs 1 rw: (r) -syscall creat nbargs 2 rw: (r, r) -syscall link nbargs 2 rw: (r, r) -syscall unlink nbargs 1 rw: (r) -syscall symlink nbargs 2 rw: (r, r) -syscall readlink nbargs 3 rw: (r, w, r) -syscall chmod nbargs 2 rw: (r, r) -syscall fchmod nbargs 2 rw: (r, r) -syscall chown nbargs 3 rw: (r, r, r) -syscall fchown nbargs 3 rw: (r, r, r) -syscall lchown nbargs 3 rw: (r, r, r) -syscall umask nbargs 1 rw: (r) -syscall gettimeofday nbargs 2 rw: (w, w) -syscall getrlimit nbargs 2 rw: (r, w) -syscall getrusage nbargs 2 rw: (r, w) -syscall sysinfo nbargs 1 rw: (w) -syscall times nbargs 1 rw: (w) -syscall ptrace nbargs 4 rw: (r, r, rw, rw) -syscall getuid nbargs 0 -syscall syslog nbargs 3 rw: (r, w, r) -syscall getgid nbargs 0 -syscall setuid nbargs 1 rw: (r) -syscall setgid nbargs 1 rw: (r) -syscall geteuid nbargs 0 -syscall getegid nbargs 0 -syscall setpgid nbargs 2 rw: (r, r) -syscall getppid nbargs 0 -syscall getpgrp nbargs 0 -syscall setsid nbargs 0 -syscall setreuid nbargs 2 rw: (r, r) -syscall setregid nbargs 2 rw: (r, r) -syscall getgroups nbargs 2 rw: (r, w) -syscall setgroups nbargs 2 rw: (r, r) -syscall setresuid nbargs 3 rw: (r, r, r) -syscall getresuid nbargs 3 rw: (w, w, w) -syscall setresgid nbargs 3 rw: (r, r, r) -syscall getresgid nbargs 3 rw: (w, w, w) -syscall getpgid nbargs 1 rw: (r) -syscall setfsuid nbargs 1 rw: (r) -syscall setfsgid nbargs 1 rw: (r) -syscall getsid nbargs 1 rw: (r) -syscall capget nbargs 2 rw: (r, w) -syscall capset nbargs 2 rw: (r, r) -syscall rt_sigpending nbargs 2 rw: (w, r) -syscall rt_sigtimedwait nbargs 4 rw: (w, w, r, r) -syscall rt_sigqueueinfo nbargs 3 rw: (r, r, r) -syscall rt_sigsuspend nbargs 2 rw: (r, r) -syscall sigaltstack nbargs 2 rw: (r, rw) -syscall utime nbargs 2 rw: (r, r) -syscall mknod nbargs 3 rw: (r, r, r) -syscall personality nbargs 1 rw: (r) -syscall ustat nbargs 2 rw: (r, w) -syscall statfs nbargs 2 rw: (r, w) -syscall fstatfs nbargs 2 rw: (r, w) -syscall sysfs nbargs 3 rw: (r, r, r) -syscall getpriority nbargs 2 rw: (r, r) -syscall setpriority nbargs 3 rw: (r, r, r) -syscall sched_setparam nbargs 2 rw: (r, r) -syscall sched_getparam nbargs 2 rw: (r, w) -syscall sched_setscheduler nbargs 3 rw: (r, r, r) -syscall sched_getscheduler nbargs 1 rw: (r) -syscall sched_get_priority_max nbargs 1 rw: (r) -syscall sched_get_priority_min nbargs 1 rw: (r) -syscall sched_rr_get_interval nbargs 2 rw: (r, w) -syscall mlock nbargs 2 rw: (r, r) -syscall munlock nbargs 2 rw: (r, r) -syscall mlockall nbargs 1 rw: (r) -syscall munlockall nbargs 0 -syscall vhangup nbargs 0 -syscall pivot_root nbargs 2 rw: (r, r) -syscall sysctl nbargs 1 rw: (rw) -syscall prctl nbargs 5 rw: (r, rw, r, r, r) -syscall adjtimex nbargs 1 rw: (rw) -syscall setrlimit nbargs 2 rw: (r, r) -syscall chroot nbargs 1 rw: (r) -syscall sync nbargs 0 -syscall acct nbargs 1 rw: (r) -syscall settimeofday nbargs 2 rw: (r, r) -syscall mount nbargs 5 rw: (r, r, r, r, r) -syscall umount nbargs 2 rw: (r, r) -syscall swapon nbargs 2 rw: (r, r) -syscall swapoff nbargs 1 rw: (r) -syscall reboot nbargs 4 rw: (r, r, r, r) -syscall sethostname nbargs 2 rw: (r, r) -syscall setdomainname nbargs 2 rw: (r, r) -syscall init_module nbargs 3 rw: (r, r, r) -syscall delete_module nbargs 2 rw: (r, r) -syscall quotactl nbargs 4 rw: (r, r, r, rw) -syscall gettid nbargs 0 -syscall readahead nbargs 3 rw: (r, r, r) -syscall setxattr nbargs 5 rw: (r, r, r, r, r) -syscall lsetxattr nbargs 5 rw: (r, r, r, r, r) -syscall fsetxattr nbargs 5 rw: (r, r, r, r, r) -syscall getxattr nbargs 4 rw: (r, r, w, r) -syscall lgetxattr nbargs 4 rw: (r, r, w, r) -syscall fgetxattr nbargs 4 rw: (r, r, w, r) -syscall listxattr nbargs 3 rw: (r, w, r) -syscall llistxattr nbargs 3 rw: (r, w, r) -syscall flistxattr nbargs 3 rw: (r, w, r) -syscall removexattr nbargs 2 rw: (r, r) -syscall lremovexattr nbargs 2 rw: (r, r) -syscall fremovexattr nbargs 2 rw: (r, r) -syscall tkill nbargs 2 rw: (r, r) -syscall time nbargs 1 rw: (w) -syscall futex nbargs 6 rw: (rw, r, r, r, rw, r) -syscall sched_setaffinity nbargs 3 rw: (r, r, r) -syscall sched_getaffinity nbargs 3 rw: (r, r, w) -syscall io_setup nbargs 2 rw: (r, r) -syscall io_destroy nbargs 1 rw: (r) -syscall io_getevents nbargs 5 rw: (r, r, r, w, rw) -syscall io_submit nbargs 3 rw: (r, r, r) -syscall io_cancel nbargs 3 rw: (r, r, w) -syscall lookup_dcookie nbargs 3 rw: (r, w, r) -syscall epoll_create nbargs 1 rw: (r) -syscall remap_file_pages nbargs 5 rw: (r, r, r, r, r) -syscall getdents64 nbargs 3 rw: (r, w, r) -syscall set_tid_address nbargs 1 rw: (r) -syscall restart_syscall nbargs 0 -syscall semtimedop nbargs 4 rw: (r, r, r, rw) -syscall fadvise64 nbargs 4 rw: (r, r, r, r) -syscall timer_create nbargs 3 rw: (r, r, w) -syscall timer_settime nbargs 4 rw: (r, r, r, w) -syscall timer_gettime nbargs 2 rw: (r, w) -syscall timer_getoverrun nbargs 1 rw: (r) -syscall timer_delete nbargs 1 rw: (r) -syscall clock_settime nbargs 2 rw: (r, r) -syscall clock_gettime nbargs 2 rw: (r, w) -syscall clock_getres nbargs 2 rw: (r, w) -syscall clock_nanosleep nbargs 4 rw: (r, r, r, w) -syscall exit_group nbargs 1 rw: (r) -syscall epoll_wait nbargs 4 rw: (r, w, r, r) -syscall epoll_ctl nbargs 4 rw: (r, r, r, r) -syscall tgkill nbargs 3 rw: (r, r, r) -syscall utimes nbargs 2 rw: (r, r) -syscall mbind nbargs 6 rw: (r, r, r, r, r, r) -syscall set_mempolicy nbargs 3 rw: (r, r, r) -syscall get_mempolicy nbargs 5 rw: (w, w, r, r, r) -syscall mq_open nbargs 4 rw: (r, r, r, r) -syscall mq_unlink nbargs 1 rw: (r) -syscall mq_timedsend nbargs 5 rw: (r, r, r, r, r) -syscall mq_timedreceive nbargs 5 rw: (r, w, r, w, r) -syscall mq_notify nbargs 2 rw: (r, r) -syscall mq_getsetattr nbargs 3 rw: (r, r, w) -syscall kexec_load nbargs 4 rw: (r, r, r, r) -syscall waitid nbargs 5 rw: (r, r, w, r, w) -syscall add_key nbargs 5 rw: (r, r, r, r, r) -syscall request_key nbargs 4 rw: (r, r, r, r) -syscall keyctl nbargs 5 rw: (r, rw, rw, rw, rw) -syscall ioprio_set nbargs 3 rw: (r, r, r) -syscall ioprio_get nbargs 2 rw: (r, r) -syscall inotify_init nbargs 0 -syscall inotify_add_watch nbargs 3 rw: (r, r, r) -syscall inotify_rm_watch nbargs 2 rw: (r, r) -syscall migrate_pages nbargs 4 rw: (r, r, r, r) -syscall openat nbargs 4 rw: (r, r, r, r) -syscall mkdirat nbargs 3 rw: (r, r, r) -syscall mknodat nbargs 4 rw: (r, r, r, r) -syscall fchownat nbargs 5 rw: (r, r, r, r, r) -syscall futimesat nbargs 3 rw: (r, r, r) -syscall newfstatat nbargs 4 rw: (r, r, w, r) -syscall unlinkat nbargs 3 rw: (r, r, r) -syscall renameat nbargs 4 rw: (r, r, r, r) -syscall linkat nbargs 5 rw: (r, r, r, r, r) -syscall symlinkat nbargs 3 rw: (r, r, r) -syscall readlinkat nbargs 4 rw: (r, r, w, r) -syscall fchmodat nbargs 3 rw: (r, r, r) -syscall faccessat nbargs 3 rw: (r, r, r) -syscall pselect6 nbargs 6 rw: (r, rw, rw, rw, rw, r) -syscall ppoll nbargs 5 rw: (rw, r, r, r, r) -syscall unshare nbargs 1 rw: (r) -syscall set_robust_list nbargs 2 rw: (r, r) -syscall get_robust_list nbargs 3 rw: (r, w, w) -syscall splice nbargs 6 rw: (r, r, r, r, r, r) -syscall tee nbargs 4 rw: (r, r, r, r) -syscall sync_file_range nbargs 4 rw: (r, r, r, r) -syscall vmsplice nbargs 4 rw: (r, r, r, r) -syscall move_pages nbargs 6 rw: (r, r, r, r, w, r) -syscall utimensat nbargs 4 rw: (r, r, r, r) -syscall epoll_pwait nbargs 6 rw: (r, w, r, r, r, r) -syscall signalfd nbargs 3 rw: (r, r, r) -syscall timerfd_create nbargs 2 rw: (r, r) -syscall eventfd nbargs 1 rw: (r) -syscall fallocate nbargs 4 rw: (r, r, r, r) -syscall timerfd_settime nbargs 4 rw: (r, r, r, w) -syscall timerfd_gettime nbargs 2 rw: (r, w) -syscall accept4 nbargs 4 rw: (r, w, rw, r) -syscall signalfd4 nbargs 4 rw: (r, r, r, r) -syscall eventfd2 nbargs 2 rw: (r, r) -syscall epoll_create1 nbargs 1 rw: (r) -syscall dup3 nbargs 3 rw: (r, r, r) -syscall pipe2 nbargs 2 rw: (w, r) -syscall inotify_init1 nbargs 1 rw: (r) -syscall preadv nbargs 5 rw: (r, w, r, r, r) -syscall pwritev nbargs 5 rw: (r, r, r, r, r) -syscall rt_tgsigqueueinfo nbargs 4 rw: (r, r, r, r) -syscall perf_event_open nbargs 5 rw: (r, r, r, r, r) -syscall recvmmsg nbargs 5 rw: (r, w, r, r, rw) -syscall fanotify_init nbargs 2 rw: (r, r) -syscall fanotify_mark nbargs 5 rw: (r, r, r, r, r) -syscall prlimit64 nbargs 4 rw: (r, r, r, w) -syscall name_to_handle_at nbargs 5 rw: (r, r, rw, w, r) -syscall open_by_handle_at nbargs 3 rw: (r, r, r) -syscall clock_adjtime nbargs 2 rw: (r, rw) -syscall syncfs nbargs 1 rw: (r) -syscall sendmmsg nbargs 4 rw: (r, r, r, r) -syscall setns nbargs 2 rw: (r, r) -syscall getcpu nbargs 3 rw: (w, w, rw) -syscall process_vm_readv nbargs 6 rw: (r, w, r, r, r, r) -syscall process_vm_writev nbargs 6 rw: (r, r, r, r, r, r) -syscall finit_module nbargs 3 rw: (r, r, r) diff --git a/lib/Kbuild b/lib/Kbuild index 6c731136..c03ac4e3 100644 --- a/lib/Kbuild +++ b/lib/Kbuild @@ -4,7 +4,7 @@ TOP_LTTNG_MODULES_DIR := $(shell dirname $(lastword $(MAKEFILE_LIST)))/.. include $(TOP_LTTNG_MODULES_DIR)/Kbuild.common -ccflags-y += -I$(TOP_LTTNG_MODULES_DIR) +ccflags-y += -I$(TOP_LTTNG_MODULES_DIR)/include obj-$(CONFIG_LTTNG) += lttng-lib-ring-buffer.o diff --git a/lib/align.h b/lib/align.h deleted file mode 100644 index c0695494..00000000 --- a/lib/align.h +++ /dev/null @@ -1,60 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) - * - * lib/align.h - * - * Copyright (C) 2010-2012 Mathieu Desnoyers - */ - -#ifndef _LTTNG_ALIGN_H -#define _LTTNG_ALIGN_H - -#ifdef __KERNEL__ - -#include -#include - -#define ALIGN_FLOOR(x, a) __ALIGN_FLOOR_MASK(x, (typeof(x)) (a) - 1) -#define __ALIGN_FLOOR_MASK(x, mask) ((x) & ~(mask)) -#define PTR_ALIGN_FLOOR(p, a) \ - ((typeof(p)) ALIGN_FLOOR((unsigned long) (p), a)) - -/* - * Align pointer on natural object alignment. - */ -#define object_align(obj) PTR_ALIGN(obj, __alignof__(*(obj))) -#define object_align_floor(obj) PTR_ALIGN_FLOOR(obj, __alignof__(*(obj))) - -/** - * offset_align - Calculate the offset needed to align an object on its natural - * alignment towards higher addresses. - * @align_drift: object offset from an "alignment"-aligned address. - * @alignment: natural object alignment. Must be non-zero, power of 2. - * - * Returns the offset that must be added to align towards higher - * addresses. - */ -#define offset_align(align_drift, alignment) \ - ({ \ - BUILD_RUNTIME_BUG_ON((alignment) == 0 \ - || ((alignment) & ((alignment) - 1))); \ - (((alignment) - (align_drift)) & ((alignment) - 1)); \ - }) - -/** - * offset_align_floor - Calculate the offset needed to align an object - * on its natural alignment towards lower addresses. - * @align_drift: object offset from an "alignment"-aligned address. - * @alignment: natural object alignment. Must be non-zero, power of 2. - * - * Returns the offset that must be substracted to align towards lower addresses. - */ -#define offset_align_floor(align_drift, alignment) \ - ({ \ - BUILD_RUNTIME_BUG_ON((alignment) == 0 \ - || ((alignment) & ((alignment) - 1))); \ - (((align_drift) - (alignment)) & ((alignment) - 1)); \ - }) - -#endif /* __KERNEL__ */ - -#endif diff --git a/lib/bitfield.h b/lib/bitfield.h deleted file mode 100644 index 7d5eaeaa..00000000 --- a/lib/bitfield.h +++ /dev/null @@ -1,543 +0,0 @@ -/* SPDX-License-Identifier: MIT - * - * Copyright 2010-2019 - Mathieu Desnoyers - */ - -#ifndef _BABELTRACE_BITFIELD_H -#define _BABELTRACE_BITFIELD_H - -#include -#include - -#ifndef CHAR_BIT -#define CHAR_BIT 8 -#endif - -/* - * This header strictly follows the C99 standard, except for use of the - * compiler-specific __typeof__. - */ - -/* - * This bitfield header requires the compiler representation of signed - * integers to be two's complement. - */ -#if (-1 != ~0) -#error "bitfield.h requires the compiler representation of signed integers to be two's complement." -#endif - -/* - * _bt_is_signed_type() willingly generates comparison of unsigned - * expression < 0, which is always false. Silence compiler warnings. - * GCC versions lower than 4.6.0 do not accept diagnostic pragma inside - * functions. - */ -#if defined(__GNUC__) && (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) >= 40600 -# define _BT_DIAG_PUSH _Pragma("GCC diagnostic push") -# define _BT_DIAG_POP _Pragma("GCC diagnostic pop") - -# define _BT_DIAG_STRINGIFY_1(x) #x -# define _BT_DIAG_STRINGIFY(x) _BT_DIAG_STRINGIFY_1(x) - -# define _BT_DIAG_IGNORE(option) \ - _Pragma(_BT_DIAG_STRINGIFY(GCC diagnostic ignored option)) -# define _BT_DIAG_IGNORE_TYPE_LIMITS _BT_DIAG_IGNORE("-Wtype-limits") -#else -# define _BT_DIAG_PUSH -# define _BT_DIAG_POP -# define _BT_DIAG_IGNORE -# define _BT_DIAG_IGNORE_TYPE_LIMITS -#endif - -#define _bt_is_signed_type(type) ((type) -1 < (type) 0) - -/* - * Produce a build-time error if the condition `cond` is non-zero. - * Evaluates as a size_t expression. - */ -#ifdef __cplusplus -#define _BT_BUILD_ASSERT(cond) ([]{static_assert((cond), "");}, 0) -#else -#define _BT_BUILD_ASSERT(cond) \ - sizeof(struct { int f:(2 * !!(cond) - 1); }) -#endif - -/* - * Cast value `v` to an unsigned integer of the same size as `v`. - */ -#define _bt_cast_value_to_unsigned(v) \ - (sizeof(v) == sizeof(uint8_t) ? (uint8_t) (v) : \ - sizeof(v) == sizeof(uint16_t) ? (uint16_t) (v) : \ - sizeof(v) == sizeof(uint32_t) ? (uint32_t) (v) : \ - sizeof(v) == sizeof(uint64_t) ? (uint64_t) (v) : \ - _BT_BUILD_ASSERT(sizeof(v) <= sizeof(uint64_t))) - -/* - * Cast value `v` to an unsigned integer type of the size of type `type` - * *without* sign-extension. - * - * The unsigned cast ensures that we're not shifting a negative value, - * which is undefined in C. However, this limits the maximum type size - * of `type` to 64-bit. Generate a compile-time error if the size of - * `type` is larger than 64-bit. - */ -#define _bt_cast_value_to_unsigned_type(type, v) \ - (sizeof(type) == sizeof(uint8_t) ? \ - (uint8_t) _bt_cast_value_to_unsigned(v) : \ - sizeof(type) == sizeof(uint16_t) ? \ - (uint16_t) _bt_cast_value_to_unsigned(v) : \ - sizeof(type) == sizeof(uint32_t) ? \ - (uint32_t) _bt_cast_value_to_unsigned(v) : \ - sizeof(type) == sizeof(uint64_t) ? \ - (uint64_t) _bt_cast_value_to_unsigned(v) : \ - _BT_BUILD_ASSERT(sizeof(v) <= sizeof(uint64_t))) - -/* - * _bt_fill_mask evaluates to a "type" integer with all bits set. - */ -#define _bt_fill_mask(type) ((type) ~(type) 0) - -/* - * Left shift a value `v` of `shift` bits. - * - * The type of `v` can be signed or unsigned integer. - * The value of `shift` must be less than the size of `v` (in bits), - * otherwise the behavior is undefined. - * Evaluates to the result of the shift operation. - * - * According to the C99 standard, left shift of a left hand-side signed - * type is undefined if it has a negative value or if the result cannot - * be represented in the result type. This bitfield header discards the - * bits that are left-shifted beyond the result type representation, - * which is the behavior of an unsigned type left shift operation. - * Therefore, always perform left shift on an unsigned type. - * - * This macro should not be used if `shift` can be greater or equal than - * the bitwidth of `v`. See `_bt_safe_lshift`. - */ -#define _bt_lshift(v, shift) \ - ((__typeof__(v)) (_bt_cast_value_to_unsigned(v) << (shift))) - -/* - * Generate a mask of type `type` with the `length` least significant bits - * cleared, and the most significant bits set. - */ -#define _bt_make_mask_complement(type, length) \ - _bt_lshift(_bt_fill_mask(type), length) - -/* - * Generate a mask of type `type` with the `length` least significant bits - * set, and the most significant bits cleared. - */ -#define _bt_make_mask(type, length) \ - ((type) ~_bt_make_mask_complement(type, length)) - -/* - * Right shift a value `v` of `shift` bits. - * - * The type of `v` can be signed or unsigned integer. - * The value of `shift` must be less than the size of `v` (in bits), - * otherwise the behavior is undefined. - * Evaluates to the result of the shift operation. - * - * According to the C99 standard, right shift of a left hand-side signed - * type which has a negative value is implementation defined. This - * bitfield header relies on the right shift implementation carrying the - * sign bit. If the compiler implementation has a different behavior, - * emulate carrying the sign bit. - * - * This macro should not be used if `shift` can be greater or equal than - * the bitwidth of `v`. See `_bt_safe_rshift`. - */ -#if ((-1 >> 1) == -1) -#define _bt_rshift(v, shift) ((v) >> (shift)) -#else -#define _bt_rshift(v, shift) \ - ((__typeof__(v)) ((_bt_cast_value_to_unsigned(v) >> (shift)) | \ - ((v) < 0 ? _bt_make_mask_complement(__typeof__(v), \ - sizeof(v) * CHAR_BIT - (shift)) : 0))) -#endif - -/* - * Right shift a signed or unsigned integer with `shift` value being an - * arbitrary number of bits. `v` is modified by this macro. The shift - * is transformed into a sequence of `_nr_partial_shifts` consecutive - * shift operations, each of a number of bits smaller than the bitwidth - * of `v`, ending with a shift of the number of left over bits. - */ -#define _bt_safe_rshift(v, shift) \ -do { \ - unsigned long _nr_partial_shifts = (shift) / (sizeof(v) * CHAR_BIT - 1); \ - unsigned long _leftover_bits = (shift) % (sizeof(v) * CHAR_BIT - 1); \ - \ - for (; _nr_partial_shifts; _nr_partial_shifts--) \ - (v) = _bt_rshift(v, sizeof(v) * CHAR_BIT - 1); \ - (v) = _bt_rshift(v, _leftover_bits); \ -} while (0) - -/* - * Left shift a signed or unsigned integer with `shift` value being an - * arbitrary number of bits. `v` is modified by this macro. The shift - * is transformed into a sequence of `_nr_partial_shifts` consecutive - * shift operations, each of a number of bits smaller than the bitwidth - * of `v`, ending with a shift of the number of left over bits. - */ -#define _bt_safe_lshift(v, shift) \ -do { \ - unsigned long _nr_partial_shifts = (shift) / (sizeof(v) * CHAR_BIT - 1); \ - unsigned long _leftover_bits = (shift) % (sizeof(v) * CHAR_BIT - 1); \ - \ - for (; _nr_partial_shifts; _nr_partial_shifts--) \ - (v) = _bt_lshift(v, sizeof(v) * CHAR_BIT - 1); \ - (v) = _bt_lshift(v, _leftover_bits); \ -} while (0) - -/* - * bt_bitfield_write - write integer to a bitfield in native endianness - * - * Save integer to the bitfield, which starts at the "start" bit, has "len" - * bits. - * The inside of a bitfield is from high bits to low bits. - * Uses native endianness. - * For unsigned "v", pad MSB with 0 if bitfield is larger than v. - * For signed "v", sign-extend v if bitfield is larger than v. - * - * On little endian, bytes are placed from the less significant to the most - * significant. Also, consecutive bitfields are placed from lower bits to higher - * bits. - * - * On big endian, bytes are places from most significant to less significant. - * Also, consecutive bitfields are placed from higher to lower bits. - */ - -#define _bt_bitfield_write_le(ptr, type, start, length, v) \ -do { \ - __typeof__(v) _v = (v); \ - type *_ptr = (void *) (ptr); \ - unsigned long _start = (start), _length = (length); \ - type _mask, _cmask; \ - unsigned long _ts = sizeof(type) * CHAR_BIT; /* type size */ \ - unsigned long _start_unit, _end_unit, _this_unit; \ - unsigned long _end, _cshift; /* _cshift is "complement shift" */ \ - \ - if (!_length) \ - break; \ - \ - _end = _start + _length; \ - _start_unit = _start / _ts; \ - _end_unit = (_end + (_ts - 1)) / _ts; \ - \ - /* Trim v high bits */ \ - if (_length < sizeof(_v) * CHAR_BIT) \ - _v &= _bt_make_mask(__typeof__(_v), _length); \ - \ - /* We can now append v with a simple "or", shift it piece-wise */ \ - _this_unit = _start_unit; \ - if (_start_unit == _end_unit - 1) { \ - _mask = _bt_make_mask(type, _start % _ts); \ - if (_end % _ts) \ - _mask |= _bt_make_mask_complement(type, _end % _ts); \ - _cmask = _bt_lshift((type) (_v), _start % _ts); \ - _cmask &= ~_mask; \ - _ptr[_this_unit] &= _mask; \ - _ptr[_this_unit] |= _cmask; \ - break; \ - } \ - if (_start % _ts) { \ - _cshift = _start % _ts; \ - _mask = _bt_make_mask(type, _cshift); \ - _cmask = _bt_lshift((type) (_v), _cshift); \ - _cmask &= ~_mask; \ - _ptr[_this_unit] &= _mask; \ - _ptr[_this_unit] |= _cmask; \ - _bt_safe_rshift(_v, _ts - _cshift); \ - _start += _ts - _cshift; \ - _this_unit++; \ - } \ - for (; _this_unit < _end_unit - 1; _this_unit++) { \ - _ptr[_this_unit] = (type) _v; \ - _bt_safe_rshift(_v, _ts); \ - _start += _ts; \ - } \ - if (_end % _ts) { \ - _mask = _bt_make_mask_complement(type, _end % _ts); \ - _cmask = (type) _v; \ - _cmask &= ~_mask; \ - _ptr[_this_unit] &= _mask; \ - _ptr[_this_unit] |= _cmask; \ - } else \ - _ptr[_this_unit] = (type) _v; \ -} while (0) - -#define _bt_bitfield_write_be(ptr, type, start, length, v) \ -do { \ - __typeof__(v) _v = (v); \ - type *_ptr = (void *) (ptr); \ - unsigned long _start = (start), _length = (length); \ - type _mask, _cmask; \ - unsigned long _ts = sizeof(type) * CHAR_BIT; /* type size */ \ - unsigned long _start_unit, _end_unit, _this_unit; \ - unsigned long _end, _cshift; /* _cshift is "complement shift" */ \ - \ - if (!_length) \ - break; \ - \ - _end = _start + _length; \ - _start_unit = _start / _ts; \ - _end_unit = (_end + (_ts - 1)) / _ts; \ - \ - /* Trim v high bits */ \ - if (_length < sizeof(_v) * CHAR_BIT) \ - _v &= _bt_make_mask(__typeof__(_v), _length); \ - \ - /* We can now append v with a simple "or", shift it piece-wise */ \ - _this_unit = _end_unit - 1; \ - if (_start_unit == _end_unit - 1) { \ - _mask = _bt_make_mask(type, (_ts - (_end % _ts)) % _ts); \ - if (_start % _ts) \ - _mask |= _bt_make_mask_complement(type, _ts - (_start % _ts)); \ - _cmask = _bt_lshift((type) (_v), (_ts - (_end % _ts)) % _ts); \ - _cmask &= ~_mask; \ - _ptr[_this_unit] &= _mask; \ - _ptr[_this_unit] |= _cmask; \ - break; \ - } \ - if (_end % _ts) { \ - _cshift = _end % _ts; \ - _mask = _bt_make_mask(type, _ts - _cshift); \ - _cmask = _bt_lshift((type) (_v), _ts - _cshift); \ - _cmask &= ~_mask; \ - _ptr[_this_unit] &= _mask; \ - _ptr[_this_unit] |= _cmask; \ - _bt_safe_rshift(_v, _cshift); \ - _end -= _cshift; \ - _this_unit--; \ - } \ - for (; (long) _this_unit >= (long) _start_unit + 1; _this_unit--) { \ - _ptr[_this_unit] = (type) _v; \ - _bt_safe_rshift(_v, _ts); \ - _end -= _ts; \ - } \ - if (_start % _ts) { \ - _mask = _bt_make_mask_complement(type, _ts - (_start % _ts)); \ - _cmask = (type) _v; \ - _cmask &= ~_mask; \ - _ptr[_this_unit] &= _mask; \ - _ptr[_this_unit] |= _cmask; \ - } else \ - _ptr[_this_unit] = (type) _v; \ -} while (0) - -/* - * bt_bitfield_write - write integer to a bitfield in native endianness - * bt_bitfield_write_le - write integer to a bitfield in little endian - * bt_bitfield_write_be - write integer to a bitfield in big endian - */ - -#if (__BYTE_ORDER == __LITTLE_ENDIAN) - -#define bt_bitfield_write(ptr, type, start, length, v) \ - _bt_bitfield_write_le(ptr, type, start, length, v) - -#define bt_bitfield_write_le(ptr, type, start, length, v) \ - _bt_bitfield_write_le(ptr, type, start, length, v) - -#define bt_bitfield_write_be(ptr, type, start, length, v) \ - _bt_bitfield_write_be(ptr, unsigned char, start, length, v) - -#elif (__BYTE_ORDER == __BIG_ENDIAN) - -#define bt_bitfield_write(ptr, type, start, length, v) \ - _bt_bitfield_write_be(ptr, type, start, length, v) - -#define bt_bitfield_write_le(ptr, type, start, length, v) \ - _bt_bitfield_write_le(ptr, unsigned char, start, length, v) - -#define bt_bitfield_write_be(ptr, type, start, length, v) \ - _bt_bitfield_write_be(ptr, type, start, length, v) - -#else /* (__BYTE_ORDER == __PDP_ENDIAN) */ - -#error "Byte order not supported" - -#endif - -#define _bt_bitfield_read_le(ptr, type, start, length, vptr) \ -do { \ - __typeof__(*(vptr)) *_vptr = (vptr); \ - __typeof__(*_vptr) _v; \ - type *_ptr = (type *) (ptr); \ - unsigned long _start = (start), _length = (length); \ - type _mask, _cmask; \ - unsigned long _ts = sizeof(type) * CHAR_BIT; /* type size */ \ - unsigned long _start_unit, _end_unit, _this_unit; \ - unsigned long _end, _cshift; /* _cshift is "complement shift" */ \ - bool _is_signed_type; \ - \ - if (!_length) { \ - *_vptr = 0; \ - break; \ - } \ - \ - _end = _start + _length; \ - _start_unit = _start / _ts; \ - _end_unit = (_end + (_ts - 1)) / _ts; \ - \ - _this_unit = _end_unit - 1; \ - _BT_DIAG_PUSH \ - _BT_DIAG_IGNORE_TYPE_LIMITS \ - _is_signed_type = _bt_is_signed_type(__typeof__(_v)); \ - _BT_DIAG_POP \ - if (_is_signed_type \ - && (_ptr[_this_unit] & _bt_lshift((type) 1, (_end % _ts ? _end % _ts : _ts) - 1))) \ - _v = ~(__typeof__(_v)) 0; \ - else \ - _v = 0; \ - if (_start_unit == _end_unit - 1) { \ - _cmask = _ptr[_this_unit]; \ - _cmask = _bt_rshift(_cmask, _start % _ts); \ - if ((_end - _start) % _ts) { \ - _mask = _bt_make_mask(type, _end - _start); \ - _cmask &= _mask; \ - } \ - _bt_safe_lshift(_v, _end - _start); \ - _v |= _bt_cast_value_to_unsigned_type(__typeof__(_v), _cmask); \ - *_vptr = _v; \ - break; \ - } \ - if (_end % _ts) { \ - _cshift = _end % _ts; \ - _mask = _bt_make_mask(type, _cshift); \ - _cmask = _ptr[_this_unit]; \ - _cmask &= _mask; \ - _bt_safe_lshift(_v, _cshift); \ - _v |= _bt_cast_value_to_unsigned_type(__typeof__(_v), _cmask); \ - _end -= _cshift; \ - _this_unit--; \ - } \ - for (; (long) _this_unit >= (long) _start_unit + 1; _this_unit--) { \ - _bt_safe_lshift(_v, _ts); \ - _v |= _bt_cast_value_to_unsigned_type(__typeof__(_v), _ptr[_this_unit]); \ - _end -= _ts; \ - } \ - if (_start % _ts) { \ - _mask = _bt_make_mask(type, _ts - (_start % _ts)); \ - _cmask = _ptr[_this_unit]; \ - _cmask = _bt_rshift(_cmask, _start % _ts); \ - _cmask &= _mask; \ - _bt_safe_lshift(_v, _ts - (_start % _ts)); \ - _v |= _bt_cast_value_to_unsigned_type(__typeof__(_v), _cmask); \ - } else { \ - _bt_safe_lshift(_v, _ts); \ - _v |= _bt_cast_value_to_unsigned_type(__typeof__(_v), _ptr[_this_unit]); \ - } \ - *_vptr = _v; \ -} while (0) - -#define _bt_bitfield_read_be(ptr, type, start, length, vptr) \ -do { \ - __typeof__(*(vptr)) *_vptr = (vptr); \ - __typeof__(*_vptr) _v; \ - type *_ptr = (void *) (ptr); \ - unsigned long _start = (start), _length = (length); \ - type _mask, _cmask; \ - unsigned long _ts = sizeof(type) * CHAR_BIT; /* type size */ \ - unsigned long _start_unit, _end_unit, _this_unit; \ - unsigned long _end, _cshift; /* _cshift is "complement shift" */ \ - bool _is_signed_type; \ - \ - if (!_length) { \ - *_vptr = 0; \ - break; \ - } \ - \ - _end = _start + _length; \ - _start_unit = _start / _ts; \ - _end_unit = (_end + (_ts - 1)) / _ts; \ - \ - _this_unit = _start_unit; \ - _BT_DIAG_PUSH \ - _BT_DIAG_IGNORE_TYPE_LIMITS \ - _is_signed_type = _bt_is_signed_type(__typeof__(_v)); \ - _BT_DIAG_POP \ - if (_is_signed_type \ - && (_ptr[_this_unit] & _bt_lshift((type) 1, _ts - (_start % _ts) - 1))) \ - _v = ~(__typeof__(_v)) 0; \ - else \ - _v = 0; \ - if (_start_unit == _end_unit - 1) { \ - _cmask = _ptr[_this_unit]; \ - _cmask = _bt_rshift(_cmask, (_ts - (_end % _ts)) % _ts); \ - if ((_end - _start) % _ts) { \ - _mask = _bt_make_mask(type, _end - _start); \ - _cmask &= _mask; \ - } \ - _bt_safe_lshift(_v, _end - _start); \ - _v |= _bt_cast_value_to_unsigned_type(__typeof__(_v), _cmask); \ - *_vptr = _v; \ - break; \ - } \ - if (_start % _ts) { \ - _cshift = _start % _ts; \ - _mask = _bt_make_mask(type, _ts - _cshift); \ - _cmask = _ptr[_this_unit]; \ - _cmask &= _mask; \ - _bt_safe_lshift(_v, _ts - _cshift); \ - _v |= _bt_cast_value_to_unsigned_type(__typeof__(_v), _cmask); \ - _start += _ts - _cshift; \ - _this_unit++; \ - } \ - for (; _this_unit < _end_unit - 1; _this_unit++) { \ - _bt_safe_lshift(_v, _ts); \ - _v |= _bt_cast_value_to_unsigned_type(__typeof__(_v), _ptr[_this_unit]); \ - _start += _ts; \ - } \ - if (_end % _ts) { \ - _mask = _bt_make_mask(type, _end % _ts); \ - _cmask = _ptr[_this_unit]; \ - _cmask = _bt_rshift(_cmask, _ts - (_end % _ts)); \ - _cmask &= _mask; \ - _bt_safe_lshift(_v, _end % _ts); \ - _v |= _bt_cast_value_to_unsigned_type(__typeof__(_v), _cmask); \ - } else { \ - _bt_safe_lshift(_v, _ts); \ - _v |= _bt_cast_value_to_unsigned_type(__typeof__(_v), _ptr[_this_unit]); \ - } \ - *_vptr = _v; \ -} while (0) - -/* - * bt_bitfield_read - read integer from a bitfield in native endianness - * bt_bitfield_read_le - read integer from a bitfield in little endian - * bt_bitfield_read_be - read integer from a bitfield in big endian - */ - -#if (__BYTE_ORDER == __LITTLE_ENDIAN) - -#define bt_bitfield_read(ptr, type, start, length, vptr) \ - _bt_bitfield_read_le(ptr, type, start, length, vptr) - -#define bt_bitfield_read_le(ptr, type, start, length, vptr) \ - _bt_bitfield_read_le(ptr, type, start, length, vptr) - -#define bt_bitfield_read_be(ptr, type, start, length, vptr) \ - _bt_bitfield_read_be(ptr, unsigned char, start, length, vptr) - -#elif (__BYTE_ORDER == __BIG_ENDIAN) - -#define bt_bitfield_read(ptr, type, start, length, vptr) \ - _bt_bitfield_read_be(ptr, type, start, length, vptr) - -#define bt_bitfield_read_le(ptr, type, start, length, vptr) \ - _bt_bitfield_read_le(ptr, unsigned char, start, length, vptr) - -#define bt_bitfield_read_be(ptr, type, start, length, vptr) \ - _bt_bitfield_read_be(ptr, type, start, length, vptr) - -#else /* (__BYTE_ORDER == __PDP_ENDIAN) */ - -#error "Byte order not supported" - -#endif - -#endif /* _BABELTRACE_BITFIELD_H */ diff --git a/lib/bug.h b/lib/bug.h deleted file mode 100644 index ea73f158..00000000 --- a/lib/bug.h +++ /dev/null @@ -1,28 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) - * - * lib/bug.h - * - * Copyright (C) 2010-2012 Mathieu Desnoyers - */ - -#ifndef _LTTNG_BUG_H -#define _LTTNG_BUG_H - -/** - * BUILD_RUNTIME_BUG_ON - check condition at build (if constant) or runtime - * @condition: the condition which should be false. - * - * If the condition is a constant and true, the compiler will generate a build - * error. If the condition is not constant, a BUG will be triggered at runtime - * if the condition is ever true. If the condition is constant and false, no - * code is emitted. - */ -#define BUILD_RUNTIME_BUG_ON(condition) \ - do { \ - if (__builtin_constant_p(condition)) \ - BUILD_BUG_ON(condition); \ - else \ - BUG_ON(condition); \ - } while (0) - -#endif diff --git a/lib/prio_heap/lttng_prio_heap.c b/lib/prio_heap/lttng_prio_heap.c index 4c62782f..66bee9cc 100644 --- a/lib/prio_heap/lttng_prio_heap.c +++ b/lib/prio_heap/lttng_prio_heap.c @@ -8,7 +8,7 @@ */ #include -#include +#include #include #ifdef DEBUG_HEAP diff --git a/lib/prio_heap/lttng_prio_heap.h b/lib/prio_heap/lttng_prio_heap.h deleted file mode 100644 index f97f33f3..00000000 --- a/lib/prio_heap/lttng_prio_heap.h +++ /dev/null @@ -1,108 +0,0 @@ -/* SPDX-License-Identifier: MIT - * - * lttng_prio_heap.h - * - * Priority heap containing pointers. Based on CLRS, chapter 6. - * - * Copyright 2011 - Mathieu Desnoyers - */ - -#ifndef _LTTNG_PRIO_HEAP_H -#define _LTTNG_PRIO_HEAP_H - -#include - -struct lttng_ptr_heap { - size_t len, alloc_len; - void **ptrs; - int (*gt)(void *a, void *b); - gfp_t gfpmask; -}; - -#ifdef DEBUG_HEAP -void lttng_check_heap(const struct lttng_ptr_heap *heap); -#else -static inline -void lttng_check_heap(const struct lttng_ptr_heap *heap) -{ -} -#endif - -/** - * lttng_heap_maximum - return the largest element in the heap - * @heap: the heap to be operated on - * - * Returns the largest element in the heap, without performing any modification - * to the heap structure. Returns NULL if the heap is empty. - */ -static inline void *lttng_heap_maximum(const struct lttng_ptr_heap *heap) -{ - lttng_check_heap(heap); - return heap->len ? heap->ptrs[0] : NULL; -} - -/** - * lttng_heap_init - initialize the heap - * @heap: the heap to initialize - * @alloc_len: number of elements initially allocated - * @gfp: allocation flags - * @gt: function to compare the elements - * - * Returns -ENOMEM if out of memory. - */ -extern int lttng_heap_init(struct lttng_ptr_heap *heap, - size_t alloc_len, gfp_t gfpmask, - int gt(void *a, void *b)); - -/** - * lttng_heap_free - free the heap - * @heap: the heap to free - */ -extern void lttng_heap_free(struct lttng_ptr_heap *heap); - -/** - * lttng_heap_insert - insert an element into the heap - * @heap: the heap to be operated on - * @p: the element to add - * - * Insert an element into the heap. - * - * Returns -ENOMEM if out of memory. - */ -extern int lttng_heap_insert(struct lttng_ptr_heap *heap, void *p); - -/** - * lttng_heap_remove - remove the largest element from the heap - * @heap: the heap to be operated on - * - * Returns the largest element in the heap. It removes this element from the - * heap. Returns NULL if the heap is empty. - */ -extern void *lttng_heap_remove(struct lttng_ptr_heap *heap); - -/** - * lttng_heap_cherrypick - remove a given element from the heap - * @heap: the heap to be operated on - * @p: the element - * - * Remove the given element from the heap. Return the element if present, else - * return NULL. This algorithm has a complexity of O(n), which is higher than - * O(log(n)) provided by the rest of this API. - */ -extern void *lttng_heap_cherrypick(struct lttng_ptr_heap *heap, void *p); - -/** - * lttng_heap_replace_max - replace the the largest element from the heap - * @heap: the heap to be operated on - * @p: the pointer to be inserted as topmost element replacement - * - * Returns the largest element in the heap. It removes this element from the - * heap. The heap is rebalanced only once after the insertion. Returns NULL if - * the heap is empty. - * - * This is the equivalent of calling heap_remove() and then heap_insert(), but - * it only rebalances the heap once. It never allocates memory. - */ -extern void *lttng_heap_replace_max(struct lttng_ptr_heap *heap, void *p); - -#endif /* _LTTNG_PRIO_HEAP_H */ diff --git a/lib/ringbuffer/api.h b/lib/ringbuffer/api.h deleted file mode 100644 index 13261031..00000000 --- a/lib/ringbuffer/api.h +++ /dev/null @@ -1,24 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only OR LGPL-2.1-only) - * - * lib/ringbuffer/api.h - * - * Ring Buffer API. - * - * Copyright (C) 2010-2012 Mathieu Desnoyers - */ - -#ifndef _LIB_RING_BUFFER_API_H -#define _LIB_RING_BUFFER_API_H - -#include -#include -#include - -/* - * ring_buffer_frontend_api.h contains static inline functions that depend on - * client static inlines. Hence the inclusion of this >api> header only - * within the client. - */ -#include - -#endif /* _LIB_RING_BUFFER_API_H */ diff --git a/lib/ringbuffer/backend.h b/lib/ringbuffer/backend.h deleted file mode 100644 index 3d2abd77..00000000 --- a/lib/ringbuffer/backend.h +++ /dev/null @@ -1,463 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only OR LGPL-2.1-only) - * - * lib/ringbuffer/backend.h - * - * Ring buffer backend (API). - * - * Copyright (C) 2010-2012 Mathieu Desnoyers - * - * Credits to Steven Rostedt for proposing to use an extra-subbuffer owned by - * the reader in flight recorder mode. - */ - -#ifndef _LIB_RING_BUFFER_BACKEND_H -#define _LIB_RING_BUFFER_BACKEND_H - -#include -#include -#include -#include -#include -#include -#include -#include -#include - -/* Internal helpers */ -#include -#include - -/* Ring buffer backend API */ - -/* Ring buffer backend access (read/write) */ - -extern size_t lib_ring_buffer_read(struct lib_ring_buffer_backend *bufb, - size_t offset, void *dest, size_t len); - -extern int __lib_ring_buffer_copy_to_user(struct lib_ring_buffer_backend *bufb, - size_t offset, void __user *dest, - size_t len); - -extern int lib_ring_buffer_read_cstr(struct lib_ring_buffer_backend *bufb, - size_t offset, void *dest, size_t len); - -extern unsigned long * -lib_ring_buffer_read_get_pfn(struct lib_ring_buffer_backend *bufb, size_t offset, - void ***virt); - -/* - * Return the address where a given offset is located. - * Should be used to get the current subbuffer header pointer. Given we know - * it's never on a page boundary, it's safe to write directly to this address, - * as long as the write is never bigger than a page size. - */ -extern void * -lib_ring_buffer_offset_address(struct lib_ring_buffer_backend *bufb, - size_t offset); -extern void * -lib_ring_buffer_read_offset_address(struct lib_ring_buffer_backend *bufb, - size_t offset); - -/** - * lib_ring_buffer_write - write data to a buffer backend - * @config : ring buffer instance configuration - * @ctx: ring buffer context. (input arguments only) - * @src : source pointer to copy from - * @len : length of data to copy - * - * This function copies "len" bytes of data from a source pointer to a buffer - * backend, at the current context offset. This is more or less a buffer - * backend-specific memcpy() operation. Calls the slow path (_ring_buffer_write) - * if copy is crossing a page boundary. - */ -static inline __attribute__((always_inline)) -void lib_ring_buffer_write(const struct lib_ring_buffer_config *config, - struct lib_ring_buffer_ctx *ctx, - const void *src, size_t len) -{ - struct lib_ring_buffer_backend *bufb = &ctx->buf->backend; - struct channel_backend *chanb = &ctx->chan->backend; - size_t index, pagecpy; - size_t offset = ctx->buf_offset; - struct lib_ring_buffer_backend_pages *backend_pages; - - if (unlikely(!len)) - return; - backend_pages = - lib_ring_buffer_get_backend_pages_from_ctx(config, ctx); - offset &= chanb->buf_size - 1; - index = (offset & (chanb->subbuf_size - 1)) >> PAGE_SHIFT; - pagecpy = min_t(size_t, len, (-offset) & ~PAGE_MASK); - if (likely(pagecpy == len)) - lib_ring_buffer_do_copy(config, - backend_pages->p[index].virt - + (offset & ~PAGE_MASK), - src, len); - else - _lib_ring_buffer_write(bufb, offset, src, len, 0); - ctx->buf_offset += len; -} - -/** - * lib_ring_buffer_memset - write len bytes of c to a buffer backend - * @config : ring buffer instance configuration - * @bufb : ring buffer backend - * @offset : offset within the buffer - * @c : the byte to copy - * @len : number of bytes to copy - * - * This function writes "len" bytes of "c" to a buffer backend, at a specific - * offset. This is more or less a buffer backend-specific memset() operation. - * Calls the slow path (_ring_buffer_memset) if write is crossing a page - * boundary. - */ -static inline -void lib_ring_buffer_memset(const struct lib_ring_buffer_config *config, - struct lib_ring_buffer_ctx *ctx, int c, size_t len) -{ - - struct lib_ring_buffer_backend *bufb = &ctx->buf->backend; - struct channel_backend *chanb = &ctx->chan->backend; - size_t index, pagecpy; - size_t offset = ctx->buf_offset; - struct lib_ring_buffer_backend_pages *backend_pages; - - if (unlikely(!len)) - return; - backend_pages = - lib_ring_buffer_get_backend_pages_from_ctx(config, ctx); - offset &= chanb->buf_size - 1; - index = (offset & (chanb->subbuf_size - 1)) >> PAGE_SHIFT; - pagecpy = min_t(size_t, len, (-offset) & ~PAGE_MASK); - if (likely(pagecpy == len)) - lib_ring_buffer_do_memset(backend_pages->p[index].virt - + (offset & ~PAGE_MASK), - c, len); - else - _lib_ring_buffer_memset(bufb, offset, c, len, 0); - ctx->buf_offset += len; -} - -/* - * Copy up to @len string bytes from @src to @dest. Stop whenever a NULL - * terminating character is found in @src. Returns the number of bytes - * copied. Does *not* terminate @dest with NULL terminating character. - */ -static inline __attribute__((always_inline)) -size_t lib_ring_buffer_do_strcpy(const struct lib_ring_buffer_config *config, - char *dest, const char *src, size_t len) -{ - size_t count; - - for (count = 0; count < len; count++) { - char c; - - /* - * Only read source character once, in case it is - * modified concurrently. - */ - c = READ_ONCE(src[count]); - if (!c) - break; - lib_ring_buffer_do_copy(config, &dest[count], &c, 1); - } - return count; -} - -/* - * Copy up to @len string bytes from @src to @dest. Stop whenever a NULL - * terminating character is found in @src, or when a fault occurs. - * Returns the number of bytes copied. Does *not* terminate @dest with - * NULL terminating character. - * - * This function deals with userspace pointers, it should never be called - * directly without having the src pointer checked with access_ok() - * previously. - */ -static inline __attribute__((always_inline)) -size_t lib_ring_buffer_do_strcpy_from_user_inatomic(const struct lib_ring_buffer_config *config, - char *dest, const char __user *src, size_t len) -{ - size_t count; - - for (count = 0; count < len; count++) { - int ret; - char c; - - ret = __copy_from_user_inatomic(&c, src + count, 1); - if (ret || !c) - break; - lib_ring_buffer_do_copy(config, &dest[count], &c, 1); - } - return count; -} - -/** - * lib_ring_buffer_strcpy - write string data to a buffer backend - * @config : ring buffer instance configuration - * @ctx: ring buffer context. (input arguments only) - * @src : source pointer to copy from - * @len : length of data to copy - * @pad : character to use for padding - * - * This function copies @len - 1 bytes of string data from a source - * pointer to a buffer backend, followed by a terminating '\0' - * character, at the current context offset. This is more or less a - * buffer backend-specific strncpy() operation. If a terminating '\0' - * character is found in @src before @len - 1 characters are copied, pad - * the buffer with @pad characters (e.g. '#'). Calls the slow path - * (_ring_buffer_strcpy) if copy is crossing a page boundary. - */ -static inline -void lib_ring_buffer_strcpy(const struct lib_ring_buffer_config *config, - struct lib_ring_buffer_ctx *ctx, - const char *src, size_t len, int pad) -{ - struct lib_ring_buffer_backend *bufb = &ctx->buf->backend; - struct channel_backend *chanb = &ctx->chan->backend; - size_t index, pagecpy; - size_t offset = ctx->buf_offset; - struct lib_ring_buffer_backend_pages *backend_pages; - - if (unlikely(!len)) - return; - backend_pages = - lib_ring_buffer_get_backend_pages_from_ctx(config, ctx); - offset &= chanb->buf_size - 1; - index = (offset & (chanb->subbuf_size - 1)) >> PAGE_SHIFT; - pagecpy = min_t(size_t, len, (-offset) & ~PAGE_MASK); - if (likely(pagecpy == len)) { - size_t count; - - count = lib_ring_buffer_do_strcpy(config, - backend_pages->p[index].virt - + (offset & ~PAGE_MASK), - src, len - 1); - offset += count; - /* Padding */ - if (unlikely(count < len - 1)) { - size_t pad_len = len - 1 - count; - - lib_ring_buffer_do_memset(backend_pages->p[index].virt - + (offset & ~PAGE_MASK), - pad, pad_len); - offset += pad_len; - } - /* Ending '\0' */ - lib_ring_buffer_do_memset(backend_pages->p[index].virt - + (offset & ~PAGE_MASK), - '\0', 1); - } else { - _lib_ring_buffer_strcpy(bufb, offset, src, len, 0, pad); - } - ctx->buf_offset += len; -} - -/** - * lib_ring_buffer_copy_from_user_inatomic - write userspace data to a buffer backend - * @config : ring buffer instance configuration - * @ctx: ring buffer context. (input arguments only) - * @src : userspace source pointer to copy from - * @len : length of data to copy - * - * This function copies "len" bytes of data from a userspace pointer to a - * buffer backend, at the current context offset. This is more or less a buffer - * backend-specific memcpy() operation. Calls the slow path - * (_ring_buffer_write_from_user_inatomic) if copy is crossing a page boundary. - * Disable the page fault handler to ensure we never try to take the mmap_sem. - */ -static inline __attribute__((always_inline)) -void lib_ring_buffer_copy_from_user_inatomic(const struct lib_ring_buffer_config *config, - struct lib_ring_buffer_ctx *ctx, - const void __user *src, size_t len) -{ - struct lib_ring_buffer_backend *bufb = &ctx->buf->backend; - struct channel_backend *chanb = &ctx->chan->backend; - size_t index, pagecpy; - size_t offset = ctx->buf_offset; - struct lib_ring_buffer_backend_pages *backend_pages; - unsigned long ret; - mm_segment_t old_fs = get_fs(); - - if (unlikely(!len)) - return; - backend_pages = - lib_ring_buffer_get_backend_pages_from_ctx(config, ctx); - offset &= chanb->buf_size - 1; - index = (offset & (chanb->subbuf_size - 1)) >> PAGE_SHIFT; - pagecpy = min_t(size_t, len, (-offset) & ~PAGE_MASK); - - set_fs(KERNEL_DS); - pagefault_disable(); - if (unlikely(!access_ok(src, len))) - goto fill_buffer; - - if (likely(pagecpy == len)) { - ret = lib_ring_buffer_do_copy_from_user_inatomic( - backend_pages->p[index].virt + (offset & ~PAGE_MASK), - src, len); - if (unlikely(ret > 0)) { - /* Copy failed. */ - goto fill_buffer; - } - } else { - _lib_ring_buffer_copy_from_user_inatomic(bufb, offset, src, len, 0); - } - pagefault_enable(); - set_fs(old_fs); - ctx->buf_offset += len; - - return; - -fill_buffer: - pagefault_enable(); - set_fs(old_fs); - /* - * In the error path we call the slow path version to avoid - * the pollution of static inline code. - */ - _lib_ring_buffer_memset(bufb, offset, 0, len, 0); -} - -/** - * lib_ring_buffer_strcpy_from_user_inatomic - write userspace string data to a buffer backend - * @config : ring buffer instance configuration - * @ctx: ring buffer context (input arguments only) - * @src : userspace source pointer to copy from - * @len : length of data to copy - * @pad : character to use for padding - * - * This function copies @len - 1 bytes of string data from a userspace - * source pointer to a buffer backend, followed by a terminating '\0' - * character, at the current context offset. This is more or less a - * buffer backend-specific strncpy() operation. If a terminating '\0' - * character is found in @src before @len - 1 characters are copied, pad - * the buffer with @pad characters (e.g. '#'). Calls the slow path - * (_ring_buffer_strcpy_from_user_inatomic) if copy is crossing a page - * boundary. Disable the page fault handler to ensure we never try to - * take the mmap_sem. - */ -static inline -void lib_ring_buffer_strcpy_from_user_inatomic(const struct lib_ring_buffer_config *config, - struct lib_ring_buffer_ctx *ctx, - const void __user *src, size_t len, int pad) -{ - struct lib_ring_buffer_backend *bufb = &ctx->buf->backend; - struct channel_backend *chanb = &ctx->chan->backend; - size_t index, pagecpy; - size_t offset = ctx->buf_offset; - struct lib_ring_buffer_backend_pages *backend_pages; - mm_segment_t old_fs = get_fs(); - - if (unlikely(!len)) - return; - backend_pages = - lib_ring_buffer_get_backend_pages_from_ctx(config, ctx); - offset &= chanb->buf_size - 1; - index = (offset & (chanb->subbuf_size - 1)) >> PAGE_SHIFT; - pagecpy = min_t(size_t, len, (-offset) & ~PAGE_MASK); - - set_fs(KERNEL_DS); - pagefault_disable(); - if (unlikely(!access_ok(src, len))) - goto fill_buffer; - - if (likely(pagecpy == len)) { - size_t count; - - count = lib_ring_buffer_do_strcpy_from_user_inatomic(config, - backend_pages->p[index].virt - + (offset & ~PAGE_MASK), - src, len - 1); - offset += count; - /* Padding */ - if (unlikely(count < len - 1)) { - size_t pad_len = len - 1 - count; - - lib_ring_buffer_do_memset(backend_pages->p[index].virt - + (offset & ~PAGE_MASK), - pad, pad_len); - offset += pad_len; - } - /* Ending '\0' */ - lib_ring_buffer_do_memset(backend_pages->p[index].virt - + (offset & ~PAGE_MASK), - '\0', 1); - } else { - _lib_ring_buffer_strcpy_from_user_inatomic(bufb, offset, src, - len, 0, pad); - } - pagefault_enable(); - set_fs(old_fs); - ctx->buf_offset += len; - - return; - -fill_buffer: - pagefault_enable(); - set_fs(old_fs); - /* - * In the error path we call the slow path version to avoid - * the pollution of static inline code. - */ - _lib_ring_buffer_memset(bufb, offset, pad, len - 1, 0); - offset += len - 1; - _lib_ring_buffer_memset(bufb, offset, '\0', 1, 0); -} - -/* - * This accessor counts the number of unread records in a buffer. - * It only provides a consistent value if no reads not writes are performed - * concurrently. - */ -static inline -unsigned long lib_ring_buffer_get_records_unread( - const struct lib_ring_buffer_config *config, - struct lib_ring_buffer *buf) -{ - struct lib_ring_buffer_backend *bufb = &buf->backend; - struct lib_ring_buffer_backend_pages *pages; - unsigned long records_unread = 0, sb_bindex, id; - unsigned int i; - - for (i = 0; i < bufb->chan->backend.num_subbuf; i++) { - id = bufb->buf_wsb[i].id; - sb_bindex = subbuffer_id_get_index(config, id); - pages = bufb->array[sb_bindex]; - records_unread += v_read(config, &pages->records_unread); - } - if (config->mode == RING_BUFFER_OVERWRITE) { - id = bufb->buf_rsb.id; - sb_bindex = subbuffer_id_get_index(config, id); - pages = bufb->array[sb_bindex]; - records_unread += v_read(config, &pages->records_unread); - } - return records_unread; -} - -/* - * We use __copy_from_user_inatomic to copy userspace data after - * checking with access_ok() and disabling page faults. - * - * Return 0 if OK, nonzero on error. - */ -static inline -unsigned long lib_ring_buffer_copy_from_user_check_nofault(void *dest, - const void __user *src, - unsigned long len) -{ - unsigned long ret; - mm_segment_t old_fs; - - if (!access_ok(src, len)) - return 1; - old_fs = get_fs(); - set_fs(KERNEL_DS); - pagefault_disable(); - ret = __copy_from_user_inatomic(dest, src, len); - pagefault_enable(); - set_fs(old_fs); - return ret; -} - -#endif /* _LIB_RING_BUFFER_BACKEND_H */ diff --git a/lib/ringbuffer/backend_internal.h b/lib/ringbuffer/backend_internal.h deleted file mode 100644 index 3a2ce26f..00000000 --- a/lib/ringbuffer/backend_internal.h +++ /dev/null @@ -1,531 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only OR LGPL-2.1-only) - * - * lib/ringbuffer/backend_internal.h - * - * Ring buffer backend (internal helpers). - * - * Copyright (C) 2008-2012 Mathieu Desnoyers - */ - -#ifndef _LIB_RING_BUFFER_BACKEND_INTERNAL_H -#define _LIB_RING_BUFFER_BACKEND_INTERNAL_H - -#include -#include -#include -#include -#include - -/* Ring buffer backend API presented to the frontend */ - -/* Ring buffer and channel backend create/free */ - -int lib_ring_buffer_backend_create(struct lib_ring_buffer_backend *bufb, - struct channel_backend *chan, int cpu); -void channel_backend_unregister_notifiers(struct channel_backend *chanb); -void lib_ring_buffer_backend_free(struct lib_ring_buffer_backend *bufb); -int channel_backend_init(struct channel_backend *chanb, - const char *name, - const struct lib_ring_buffer_config *config, - void *priv, size_t subbuf_size, - size_t num_subbuf); -void channel_backend_free(struct channel_backend *chanb); - -void lib_ring_buffer_backend_reset(struct lib_ring_buffer_backend *bufb); -void channel_backend_reset(struct channel_backend *chanb); - -int lib_ring_buffer_backend_init(void); -void lib_ring_buffer_backend_exit(void); - -extern void _lib_ring_buffer_write(struct lib_ring_buffer_backend *bufb, - size_t offset, const void *src, size_t len, - size_t pagecpy); -extern void _lib_ring_buffer_memset(struct lib_ring_buffer_backend *bufb, - size_t offset, int c, size_t len, - size_t pagecpy); -extern void _lib_ring_buffer_strcpy(struct lib_ring_buffer_backend *bufb, - size_t offset, const char *src, size_t len, - size_t pagecpy, int pad); -extern void _lib_ring_buffer_copy_from_user_inatomic(struct lib_ring_buffer_backend *bufb, - size_t offset, const void *src, - size_t len, size_t pagecpy); -extern void _lib_ring_buffer_strcpy_from_user_inatomic(struct lib_ring_buffer_backend *bufb, - size_t offset, const char __user *src, size_t len, - size_t pagecpy, int pad); - -/* - * Subbuffer ID bits for overwrite mode. Need to fit within a single word to be - * exchanged atomically. - * - * Top half word, except lowest bit, belongs to "offset", which is used to keep - * to count the produced buffers. For overwrite mode, this provides the - * consumer with the capacity to read subbuffers in order, handling the - * situation where producers would write up to 2^15 buffers (or 2^31 for 64-bit - * systems) concurrently with a single execution of get_subbuf (between offset - * sampling and subbuffer ID exchange). - */ - -#define HALF_ULONG_BITS (BITS_PER_LONG >> 1) - -#define SB_ID_OFFSET_SHIFT (HALF_ULONG_BITS + 1) -#define SB_ID_OFFSET_COUNT (1UL << SB_ID_OFFSET_SHIFT) -#define SB_ID_OFFSET_MASK (~(SB_ID_OFFSET_COUNT - 1)) -/* - * Lowest bit of top word half belongs to noref. Used only for overwrite mode. - */ -#define SB_ID_NOREF_SHIFT (SB_ID_OFFSET_SHIFT - 1) -#define SB_ID_NOREF_COUNT (1UL << SB_ID_NOREF_SHIFT) -#define SB_ID_NOREF_MASK SB_ID_NOREF_COUNT -/* - * In overwrite mode: lowest half of word is used for index. - * Limit of 2^16 subbuffers per buffer on 32-bit, 2^32 on 64-bit. - * In producer-consumer mode: whole word used for index. - */ -#define SB_ID_INDEX_SHIFT 0 -#define SB_ID_INDEX_COUNT (1UL << SB_ID_INDEX_SHIFT) -#define SB_ID_INDEX_MASK (SB_ID_NOREF_COUNT - 1) - -/* - * Construct the subbuffer id from offset, index and noref. Use only the index - * for producer-consumer mode (offset and noref are only used in overwrite - * mode). - */ -static inline -unsigned long subbuffer_id(const struct lib_ring_buffer_config *config, - unsigned long offset, unsigned long noref, - unsigned long index) -{ - if (config->mode == RING_BUFFER_OVERWRITE) - return (offset << SB_ID_OFFSET_SHIFT) - | (noref << SB_ID_NOREF_SHIFT) - | index; - else - return index; -} - -/* - * Compare offset with the offset contained within id. Return 1 if the offset - * bits are identical, else 0. - */ -static inline -int subbuffer_id_compare_offset(const struct lib_ring_buffer_config *config, - unsigned long id, unsigned long offset) -{ - return (id & SB_ID_OFFSET_MASK) == (offset << SB_ID_OFFSET_SHIFT); -} - -static inline -unsigned long subbuffer_id_get_index(const struct lib_ring_buffer_config *config, - unsigned long id) -{ - if (config->mode == RING_BUFFER_OVERWRITE) - return id & SB_ID_INDEX_MASK; - else - return id; -} - -static inline -unsigned long subbuffer_id_is_noref(const struct lib_ring_buffer_config *config, - unsigned long id) -{ - if (config->mode == RING_BUFFER_OVERWRITE) - return !!(id & SB_ID_NOREF_MASK); - else - return 1; -} - -/* - * Only used by reader on subbuffer ID it has exclusive access to. No volatile - * needed. - */ -static inline -void subbuffer_id_set_noref(const struct lib_ring_buffer_config *config, - unsigned long *id) -{ - if (config->mode == RING_BUFFER_OVERWRITE) - *id |= SB_ID_NOREF_MASK; -} - -static inline -void subbuffer_id_set_noref_offset(const struct lib_ring_buffer_config *config, - unsigned long *id, unsigned long offset) -{ - unsigned long tmp; - - if (config->mode == RING_BUFFER_OVERWRITE) { - tmp = *id; - tmp &= ~SB_ID_OFFSET_MASK; - tmp |= offset << SB_ID_OFFSET_SHIFT; - tmp |= SB_ID_NOREF_MASK; - /* Volatile store, read concurrently by readers. */ - WRITE_ONCE(*id, tmp); - } -} - -/* No volatile access, since already used locally */ -static inline -void subbuffer_id_clear_noref(const struct lib_ring_buffer_config *config, - unsigned long *id) -{ - if (config->mode == RING_BUFFER_OVERWRITE) - *id &= ~SB_ID_NOREF_MASK; -} - -/* - * For overwrite mode, cap the number of subbuffers per buffer to: - * 2^16 on 32-bit architectures - * 2^32 on 64-bit architectures - * This is required to fit in the index part of the ID. Return 0 on success, - * -EPERM on failure. - */ -static inline -int subbuffer_id_check_index(const struct lib_ring_buffer_config *config, - unsigned long num_subbuf) -{ - if (config->mode == RING_BUFFER_OVERWRITE) - return (num_subbuf > (1UL << HALF_ULONG_BITS)) ? -EPERM : 0; - else - return 0; -} - -static inline -void lib_ring_buffer_backend_get_pages(const struct lib_ring_buffer_config *config, - struct lib_ring_buffer_ctx *ctx, - struct lib_ring_buffer_backend_pages **backend_pages) -{ - struct lib_ring_buffer_backend *bufb = &ctx->buf->backend; - struct channel_backend *chanb = &ctx->chan->backend; - size_t sbidx, offset = ctx->buf_offset; - unsigned long sb_bindex, id; - struct lib_ring_buffer_backend_pages *rpages; - - offset &= chanb->buf_size - 1; - sbidx = offset >> chanb->subbuf_size_order; - id = bufb->buf_wsb[sbidx].id; - sb_bindex = subbuffer_id_get_index(config, id); - rpages = bufb->array[sb_bindex]; - CHAN_WARN_ON(ctx->chan, - config->mode == RING_BUFFER_OVERWRITE - && subbuffer_id_is_noref(config, id)); - *backend_pages = rpages; -} - -/* Get backend pages from cache. */ -static inline -struct lib_ring_buffer_backend_pages * - lib_ring_buffer_get_backend_pages_from_ctx(const struct lib_ring_buffer_config *config, - struct lib_ring_buffer_ctx *ctx) -{ - return ctx->backend_pages; -} - -/* - * The ring buffer can count events recorded and overwritten per buffer, - * but it is disabled by default due to its performance overhead. - */ -#ifdef LTTNG_RING_BUFFER_COUNT_EVENTS -static inline -void subbuffer_count_record(const struct lib_ring_buffer_config *config, - struct lib_ring_buffer_backend *bufb, - unsigned long idx) -{ - unsigned long sb_bindex; - - sb_bindex = subbuffer_id_get_index(config, bufb->buf_wsb[idx].id); - v_inc(config, &bufb->array[sb_bindex]->records_commit); -} -#else /* LTTNG_RING_BUFFER_COUNT_EVENTS */ -static inline -void subbuffer_count_record(const struct lib_ring_buffer_config *config, - struct lib_ring_buffer_backend *bufb, - unsigned long idx) -{ -} -#endif /* #else LTTNG_RING_BUFFER_COUNT_EVENTS */ - -/* - * Reader has exclusive subbuffer access for record consumption. No need to - * perform the decrement atomically. - */ -static inline -void subbuffer_consume_record(const struct lib_ring_buffer_config *config, - struct lib_ring_buffer_backend *bufb) -{ - unsigned long sb_bindex; - - sb_bindex = subbuffer_id_get_index(config, bufb->buf_rsb.id); - CHAN_WARN_ON(bufb->chan, - !v_read(config, &bufb->array[sb_bindex]->records_unread)); - /* Non-atomic decrement protected by exclusive subbuffer access */ - _v_dec(config, &bufb->array[sb_bindex]->records_unread); - v_inc(config, &bufb->records_read); -} - -static inline -unsigned long subbuffer_get_records_count( - const struct lib_ring_buffer_config *config, - struct lib_ring_buffer_backend *bufb, - unsigned long idx) -{ - unsigned long sb_bindex; - - sb_bindex = subbuffer_id_get_index(config, bufb->buf_wsb[idx].id); - return v_read(config, &bufb->array[sb_bindex]->records_commit); -} - -/* - * Must be executed at subbuffer delivery when the writer has _exclusive_ - * subbuffer access. See lib_ring_buffer_check_deliver() for details. - * lib_ring_buffer_get_records_count() must be called to get the records - * count before this function, because it resets the records_commit - * count. - */ -static inline -unsigned long subbuffer_count_records_overrun( - const struct lib_ring_buffer_config *config, - struct lib_ring_buffer_backend *bufb, - unsigned long idx) -{ - struct lib_ring_buffer_backend_pages *pages; - unsigned long overruns, sb_bindex; - - sb_bindex = subbuffer_id_get_index(config, bufb->buf_wsb[idx].id); - pages = bufb->array[sb_bindex]; - overruns = v_read(config, &pages->records_unread); - v_set(config, &pages->records_unread, - v_read(config, &pages->records_commit)); - v_set(config, &pages->records_commit, 0); - - return overruns; -} - -static inline -void subbuffer_set_data_size(const struct lib_ring_buffer_config *config, - struct lib_ring_buffer_backend *bufb, - unsigned long idx, - unsigned long data_size) -{ - struct lib_ring_buffer_backend_pages *pages; - unsigned long sb_bindex; - - sb_bindex = subbuffer_id_get_index(config, bufb->buf_wsb[idx].id); - pages = bufb->array[sb_bindex]; - pages->data_size = data_size; -} - -static inline -unsigned long subbuffer_get_read_data_size( - const struct lib_ring_buffer_config *config, - struct lib_ring_buffer_backend *bufb) -{ - struct lib_ring_buffer_backend_pages *pages; - unsigned long sb_bindex; - - sb_bindex = subbuffer_id_get_index(config, bufb->buf_rsb.id); - pages = bufb->array[sb_bindex]; - return pages->data_size; -} - -static inline -unsigned long subbuffer_get_data_size( - const struct lib_ring_buffer_config *config, - struct lib_ring_buffer_backend *bufb, - unsigned long idx) -{ - struct lib_ring_buffer_backend_pages *pages; - unsigned long sb_bindex; - - sb_bindex = subbuffer_id_get_index(config, bufb->buf_wsb[idx].id); - pages = bufb->array[sb_bindex]; - return pages->data_size; -} - -static inline -void subbuffer_inc_packet_count(const struct lib_ring_buffer_config *config, - struct lib_ring_buffer_backend *bufb, - unsigned long idx) -{ - bufb->buf_cnt[idx].seq_cnt++; -} - -/** - * lib_ring_buffer_clear_noref - Clear the noref subbuffer flag, called by - * writer. - */ -static inline -void lib_ring_buffer_clear_noref(const struct lib_ring_buffer_config *config, - struct lib_ring_buffer_backend *bufb, - unsigned long idx) -{ - unsigned long id, new_id; - - if (config->mode != RING_BUFFER_OVERWRITE) - return; - - /* - * Performing a volatile access to read the sb_pages, because we want to - * read a coherent version of the pointer and the associated noref flag. - */ - id = READ_ONCE(bufb->buf_wsb[idx].id); - for (;;) { - /* This check is called on the fast path for each record. */ - if (likely(!subbuffer_id_is_noref(config, id))) { - /* - * Store after load dependency ordering the writes to - * the subbuffer after load and test of the noref flag - * matches the memory barrier implied by the cmpxchg() - * in update_read_sb_index(). - */ - return; /* Already writing to this buffer */ - } - new_id = id; - subbuffer_id_clear_noref(config, &new_id); - new_id = cmpxchg(&bufb->buf_wsb[idx].id, id, new_id); - if (likely(new_id == id)) - break; - id = new_id; - } -} - -/** - * lib_ring_buffer_set_noref_offset - Set the noref subbuffer flag and offset, - * called by writer. - */ -static inline -void lib_ring_buffer_set_noref_offset(const struct lib_ring_buffer_config *config, - struct lib_ring_buffer_backend *bufb, - unsigned long idx, unsigned long offset) -{ - if (config->mode != RING_BUFFER_OVERWRITE) - return; - - /* - * Because ring_buffer_set_noref() is only called by a single thread - * (the one which updated the cc_sb value), there are no concurrent - * updates to take care of: other writers have not updated cc_sb, so - * they cannot set the noref flag, and concurrent readers cannot modify - * the pointer because the noref flag is not set yet. - * The smp_wmb() in ring_buffer_commit() takes care of ordering writes - * to the subbuffer before this set noref operation. - * subbuffer_set_noref() uses a volatile store to deal with concurrent - * readers of the noref flag. - */ - CHAN_WARN_ON(bufb->chan, - subbuffer_id_is_noref(config, bufb->buf_wsb[idx].id)); - /* - * Memory barrier that ensures counter stores are ordered before set - * noref and offset. - */ - smp_mb(); - subbuffer_id_set_noref_offset(config, &bufb->buf_wsb[idx].id, offset); -} - -/** - * update_read_sb_index - Read-side subbuffer index update. - */ -static inline -int update_read_sb_index(const struct lib_ring_buffer_config *config, - struct lib_ring_buffer_backend *bufb, - struct channel_backend *chanb, - unsigned long consumed_idx, - unsigned long consumed_count) -{ - unsigned long old_id, new_id; - - if (config->mode == RING_BUFFER_OVERWRITE) { - /* - * Exchange the target writer subbuffer with our own unused - * subbuffer. No need to use READ_ONCE() here to read the - * old_wpage, because the value read will be confirmed by the - * following cmpxchg(). - */ - old_id = bufb->buf_wsb[consumed_idx].id; - if (unlikely(!subbuffer_id_is_noref(config, old_id))) - return -EAGAIN; - /* - * Make sure the offset count we are expecting matches the one - * indicated by the writer. - */ - if (unlikely(!subbuffer_id_compare_offset(config, old_id, - consumed_count))) - return -EAGAIN; - CHAN_WARN_ON(bufb->chan, - !subbuffer_id_is_noref(config, bufb->buf_rsb.id)); - subbuffer_id_set_noref_offset(config, &bufb->buf_rsb.id, - consumed_count); - new_id = cmpxchg(&bufb->buf_wsb[consumed_idx].id, old_id, - bufb->buf_rsb.id); - if (unlikely(old_id != new_id)) - return -EAGAIN; - bufb->buf_rsb.id = new_id; - } else { - /* No page exchange, use the writer page directly */ - bufb->buf_rsb.id = bufb->buf_wsb[consumed_idx].id; - } - return 0; -} - -static inline __attribute__((always_inline)) -void lttng_inline_memcpy(void *dest, const void *src, - unsigned long len) -{ - switch (len) { - case 1: - *(uint8_t *) dest = *(const uint8_t *) src; - break; - case 2: - *(uint16_t *) dest = *(const uint16_t *) src; - break; - case 4: - *(uint32_t *) dest = *(const uint32_t *) src; - break; - case 8: - *(uint64_t *) dest = *(const uint64_t *) src; - break; - default: - memcpy(dest, src, len); - } -} - -/* - * Use the architecture-specific memcpy implementation for constant-sized - * inputs, but rely on an inline memcpy for length statically unknown. - * The function call to memcpy is just way too expensive for a fast path. - */ -#define lib_ring_buffer_do_copy(config, dest, src, len) \ -do { \ - size_t __len = (len); \ - if (__builtin_constant_p(len)) \ - memcpy(dest, src, __len); \ - else \ - lttng_inline_memcpy(dest, src, __len); \ -} while (0) - -/* - * We use __copy_from_user_inatomic to copy userspace data since we already - * did the access_ok for the whole range. - * - * Return 0 if OK, nonzero on error. - */ -static inline -unsigned long lib_ring_buffer_do_copy_from_user_inatomic(void *dest, - const void __user *src, - unsigned long len) -{ - return __copy_from_user_inatomic(dest, src, len); -} - -/* - * write len bytes to dest with c - */ -static inline -void lib_ring_buffer_do_memset(char *dest, int c, - unsigned long len) -{ - unsigned long i; - - for (i = 0; i < len; i++) - dest[i] = c; -} - -#endif /* _LIB_RING_BUFFER_BACKEND_INTERNAL_H */ diff --git a/lib/ringbuffer/backend_types.h b/lib/ringbuffer/backend_types.h deleted file mode 100644 index 3766d8bd..00000000 --- a/lib/ringbuffer/backend_types.h +++ /dev/null @@ -1,100 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only OR LGPL-2.1-only) - * - * lib/ringbuffer/backend_types.h - * - * Ring buffer backend (types). - * - * Copyright (C) 2008-2012 Mathieu Desnoyers - */ - -#ifndef _LIB_RING_BUFFER_BACKEND_TYPES_H -#define _LIB_RING_BUFFER_BACKEND_TYPES_H - -#include -#include -#include -#include - -struct lib_ring_buffer_backend_page { - void *virt; /* page virtual address (cached) */ - unsigned long pfn; /* page frame number */ -}; - -struct lib_ring_buffer_backend_pages { - unsigned long mmap_offset; /* offset of the subbuffer in mmap */ - union v_atomic records_commit; /* current records committed count */ - union v_atomic records_unread; /* records to read */ - unsigned long data_size; /* Amount of data to read from subbuf */ - struct lib_ring_buffer_backend_page p[]; -}; - -struct lib_ring_buffer_backend_subbuffer { - /* Identifier for subbuf backend pages. Exchanged atomically. */ - unsigned long id; /* backend subbuffer identifier */ -}; - -struct lib_ring_buffer_backend_counts { - /* - * Counter specific to the sub-buffer location within the ring buffer. - * The actual sequence number of the packet within the entire ring - * buffer can be derived from the formula nr_subbuffers * seq_cnt + - * subbuf_idx. - */ - uint64_t seq_cnt; /* packet sequence number */ -}; - -/* - * Forward declaration of frontend-specific channel and ring_buffer. - */ -struct channel; -struct lib_ring_buffer; - -struct lib_ring_buffer_backend { - /* Array of ring_buffer_backend_subbuffer for writer */ - struct lib_ring_buffer_backend_subbuffer *buf_wsb; - /* ring_buffer_backend_subbuffer for reader */ - struct lib_ring_buffer_backend_subbuffer buf_rsb; - /* Array of lib_ring_buffer_backend_counts for the packet counter */ - struct lib_ring_buffer_backend_counts *buf_cnt; - /* - * Pointer array of backend pages, for whole buffer. - * Indexed by ring_buffer_backend_subbuffer identifier (id) index. - */ - struct lib_ring_buffer_backend_pages **array; - unsigned int num_pages_per_subbuf; - - struct channel *chan; /* Associated channel */ - int cpu; /* This buffer's cpu. -1 if global. */ - union v_atomic records_read; /* Number of records read */ - unsigned int allocated:1; /* is buffer allocated ? */ -}; - -struct channel_backend { - unsigned long buf_size; /* Size of the buffer */ - unsigned long subbuf_size; /* Sub-buffer size */ - unsigned int subbuf_size_order; /* Order of sub-buffer size */ - unsigned int num_subbuf_order; /* - * Order of number of sub-buffers/buffer - * for writer. - */ - unsigned int buf_size_order; /* Order of buffer size */ - unsigned int extra_reader_sb:1; /* has extra reader subbuffer ? */ - struct lib_ring_buffer *buf; /* Channel per-cpu buffers */ - - unsigned long num_subbuf; /* Number of sub-buffers for writer */ - u64 start_tsc; /* Channel creation TSC value */ - void *priv; /* Client-specific information */ - void *priv_ops; /* Client-specific ops pointer */ - void (*release_priv_ops)(void *priv_ops); - struct lttng_cpuhp_node cpuhp_prepare; /* CPU hotplug prepare */ - /* - * We need to copy config because the module containing the - * source config can vanish before the last reference to this - * channel's streams is released. - */ - struct lib_ring_buffer_config config; /* Ring buffer configuration */ - cpumask_var_t cpumask; /* Allocated per-cpu buffers cpumask */ - char name[NAME_MAX]; /* Channel name */ -}; - -#endif /* _LIB_RING_BUFFER_BACKEND_TYPES_H */ diff --git a/lib/ringbuffer/config.h b/lib/ringbuffer/config.h deleted file mode 100644 index 15259239..00000000 --- a/lib/ringbuffer/config.h +++ /dev/null @@ -1,306 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only OR LGPL-2.1-only) - * - * lib/ringbuffer/config.h - * - * Ring buffer configuration header. Note: after declaring the standard inline - * functions, clients should also include linux/ringbuffer/api.h. - * - * Copyright (C) 2010-2012 Mathieu Desnoyers - */ - -#ifndef _LIB_RING_BUFFER_CONFIG_H -#define _LIB_RING_BUFFER_CONFIG_H - -#include -#include -#include -#include - -struct lib_ring_buffer; -struct channel; -struct lib_ring_buffer_config; -struct lib_ring_buffer_ctx; - -/* - * Ring buffer client callbacks. Only used by slow path, never on fast path. - * For the fast path, record_header_size(), ring_buffer_clock_read() should be - * provided as inline functions too. These may simply return 0 if not used by - * the client. - */ -struct lib_ring_buffer_client_cb { - /* Mandatory callbacks */ - - /* A static inline version is also required for fast path */ - u64 (*ring_buffer_clock_read) (struct channel *chan); - size_t (*record_header_size) (const struct lib_ring_buffer_config *config, - struct channel *chan, size_t offset, - size_t *pre_header_padding, - struct lib_ring_buffer_ctx *ctx, - void *client_ctx); - - /* Slow path only, at subbuffer switch */ - size_t (*subbuffer_header_size) (void); - void (*buffer_begin) (struct lib_ring_buffer *buf, u64 tsc, - unsigned int subbuf_idx); - void (*buffer_end) (struct lib_ring_buffer *buf, u64 tsc, - unsigned int subbuf_idx, unsigned long data_size); - - /* Optional callbacks (can be set to NULL) */ - - /* Called at buffer creation/finalize */ - int (*buffer_create) (struct lib_ring_buffer *buf, void *priv, - int cpu, const char *name); - /* - * Clients should guarantee that no new reader handle can be opened - * after finalize. - */ - void (*buffer_finalize) (struct lib_ring_buffer *buf, void *priv, int cpu); - - /* - * Extract header length, payload length and timestamp from event - * record. Used by buffer iterators. Timestamp is only used by channel - * iterator. - */ - void (*record_get) (const struct lib_ring_buffer_config *config, - struct channel *chan, struct lib_ring_buffer *buf, - size_t offset, size_t *header_len, - size_t *payload_len, u64 *timestamp); -}; - -/* - * Ring buffer instance configuration. - * - * Declare as "static const" within the client object to ensure the inline fast - * paths can be optimized. - * - * alloc/sync pairs: - * - * RING_BUFFER_ALLOC_PER_CPU and RING_BUFFER_SYNC_PER_CPU : - * Per-cpu buffers with per-cpu synchronization. Tracing must be performed - * with preemption disabled (lib_ring_buffer_get_cpu() and - * lib_ring_buffer_put_cpu()). - * - * RING_BUFFER_ALLOC_PER_CPU and RING_BUFFER_SYNC_GLOBAL : - * Per-cpu buffer with global synchronization. Tracing can be performed with - * preemption enabled, statistically stays on the local buffers. - * - * RING_BUFFER_ALLOC_GLOBAL and RING_BUFFER_SYNC_PER_CPU : - * Should only be used for buffers belonging to a single thread or protected - * by mutual exclusion by the client. Note that periodical sub-buffer switch - * should be disabled in this kind of configuration. - * - * RING_BUFFER_ALLOC_GLOBAL and RING_BUFFER_SYNC_GLOBAL : - * Global shared buffer with global synchronization. - * - * wakeup: - * - * RING_BUFFER_WAKEUP_BY_TIMER uses per-cpu timers to poll the - * buffers and wake up readers if data is ready. Mainly useful for tracers which - * don't want to call into the wakeup code on the tracing path. Use in - * combination with "read_timer_interval" channel_create() argument. - * - * RING_BUFFER_WAKEUP_BY_WRITER directly wakes up readers when a subbuffer is - * ready to read. Lower latencies before the reader is woken up. Mainly suitable - * for drivers. - * - * RING_BUFFER_WAKEUP_NONE does not perform any wakeup whatsoever. The client - * has the responsibility to perform wakeups. - */ -struct lib_ring_buffer_config { - enum { - RING_BUFFER_ALLOC_PER_CPU, - RING_BUFFER_ALLOC_GLOBAL, - } alloc; - enum { - RING_BUFFER_SYNC_PER_CPU, /* Wait-free */ - RING_BUFFER_SYNC_GLOBAL, /* Lock-free */ - } sync; - enum { - RING_BUFFER_OVERWRITE, /* Overwrite when buffer full */ - RING_BUFFER_DISCARD, /* Discard when buffer full */ - } mode; - enum { - RING_BUFFER_SPLICE, - RING_BUFFER_MMAP, - RING_BUFFER_READ, /* TODO */ - RING_BUFFER_ITERATOR, - RING_BUFFER_NONE, - } output; - enum { - RING_BUFFER_PAGE, - RING_BUFFER_VMAP, /* TODO */ - RING_BUFFER_STATIC, /* TODO */ - } backend; - enum { - RING_BUFFER_NO_OOPS_CONSISTENCY, - RING_BUFFER_OOPS_CONSISTENCY, - } oops; - enum { - RING_BUFFER_IPI_BARRIER, - RING_BUFFER_NO_IPI_BARRIER, - } ipi; - enum { - RING_BUFFER_WAKEUP_BY_TIMER, /* wake up performed by timer */ - RING_BUFFER_WAKEUP_BY_WRITER, /* - * writer wakes up reader, - * not lock-free - * (takes spinlock). - */ - } wakeup; - /* - * tsc_bits: timestamp bits saved at each record. - * 0 and 64 disable the timestamp compression scheme. - */ - unsigned int tsc_bits; - struct lib_ring_buffer_client_cb cb; -}; - -/* - * ring buffer context - * - * Context passed to lib_ring_buffer_reserve(), lib_ring_buffer_commit(), - * lib_ring_buffer_try_discard_reserve(), lib_ring_buffer_align_ctx() and - * lib_ring_buffer_write(). - */ -struct lib_ring_buffer_ctx { - /* input received by lib_ring_buffer_reserve(), saved here. */ - struct channel *chan; /* channel */ - void *priv; /* client private data */ - size_t data_size; /* size of payload */ - int largest_align; /* - * alignment of the largest element - * in the payload - */ - int cpu; /* processor id */ - - /* output from lib_ring_buffer_reserve() */ - struct lib_ring_buffer *buf; /* - * buffer corresponding to processor id - * for this channel - */ - size_t slot_size; /* size of the reserved slot */ - unsigned long buf_offset; /* offset following the record header */ - unsigned long pre_offset; /* - * Initial offset position _before_ - * the record is written. Positioned - * prior to record header alignment - * padding. - */ - u64 tsc; /* time-stamp counter value */ - unsigned int rflags; /* reservation flags */ - /* Cache backend pages pointer chasing. */ - struct lib_ring_buffer_backend_pages *backend_pages; -}; - -/** - * lib_ring_buffer_ctx_init - initialize ring buffer context - * @ctx: ring buffer context to initialize - * @chan: channel - * @priv: client private data - * @data_size: size of record data payload. It must be greater than 0. - * @largest_align: largest alignment within data payload types - * @cpu: processor id - */ -static inline -void lib_ring_buffer_ctx_init(struct lib_ring_buffer_ctx *ctx, - struct channel *chan, void *priv, - size_t data_size, int largest_align, - int cpu) -{ - ctx->chan = chan; - ctx->priv = priv; - ctx->data_size = data_size; - ctx->largest_align = largest_align; - ctx->cpu = cpu; - ctx->rflags = 0; - ctx->backend_pages = NULL; -} - -/* - * Reservation flags. - * - * RING_BUFFER_RFLAG_FULL_TSC - * - * This flag is passed to record_header_size() and to the primitive used to - * write the record header. It indicates that the full 64-bit time value is - * needed in the record header. If this flag is not set, the record header needs - * only to contain "tsc_bits" bit of time value. - * - * Reservation flags can be added by the client, starting from - * "(RING_BUFFER_FLAGS_END << 0)". It can be used to pass information from - * record_header_size() to lib_ring_buffer_write_record_header(). - */ -#define RING_BUFFER_RFLAG_FULL_TSC (1U << 0) -#define RING_BUFFER_RFLAG_END (1U << 1) - -#ifndef LTTNG_TRACER_CORE_H -#error "lttng-tracer-core.h is needed for RING_BUFFER_ALIGN define" -#endif - -/* - * We need to define RING_BUFFER_ALIGN_ATTR so it is known early at - * compile-time. We have to duplicate the "config->align" information and the - * definition here because config->align is used both in the slow and fast - * paths, but RING_BUFFER_ALIGN_ATTR is only available for the client code. - */ -#ifdef RING_BUFFER_ALIGN - -# define RING_BUFFER_ALIGN_ATTR /* Default arch alignment */ - -/* - * Calculate the offset needed to align the type. - * size_of_type must be non-zero. - */ -static inline -unsigned int lib_ring_buffer_align(size_t align_drift, size_t size_of_type) -{ - return offset_align(align_drift, size_of_type); -} - -#else - -# define RING_BUFFER_ALIGN_ATTR __attribute__((packed)) - -/* - * Calculate the offset needed to align the type. - * size_of_type must be non-zero. - */ -static inline -unsigned int lib_ring_buffer_align(size_t align_drift, size_t size_of_type) -{ - return 0; -} - -#endif - -/** - * lib_ring_buffer_align_ctx - Align context offset on "alignment" - * @ctx: ring buffer context. - */ -static inline -void lib_ring_buffer_align_ctx(struct lib_ring_buffer_ctx *ctx, - size_t alignment) -{ - ctx->buf_offset += lib_ring_buffer_align(ctx->buf_offset, - alignment); -} - -/* - * lib_ring_buffer_check_config() returns 0 on success. - * Used internally to check for valid configurations at channel creation. - */ -static inline -int lib_ring_buffer_check_config(const struct lib_ring_buffer_config *config, - unsigned int switch_timer_interval, - unsigned int read_timer_interval) -{ - if (config->alloc == RING_BUFFER_ALLOC_GLOBAL - && config->sync == RING_BUFFER_SYNC_PER_CPU - && switch_timer_interval) - return -EINVAL; - return 0; -} - -#include - -#endif /* _LIB_RING_BUFFER_CONFIG_H */ diff --git a/lib/ringbuffer/frontend.h b/lib/ringbuffer/frontend.h deleted file mode 100644 index ae1c1aaf..00000000 --- a/lib/ringbuffer/frontend.h +++ /dev/null @@ -1,234 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only OR LGPL-2.1-only) - * - * lib/ringbuffer/frontend.h - * - * Ring Buffer Library Synchronization Header (API). - * - * Copyright (C) 2005-2012 Mathieu Desnoyers - * - * See ring_buffer_frontend.c for more information on wait-free algorithms. - */ - -#ifndef _LIB_RING_BUFFER_FRONTEND_H -#define _LIB_RING_BUFFER_FRONTEND_H - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include -#include - -/* Internal helpers */ -#include - -/* Max ring buffer nesting count, see lib_ring_buffer_get_cpu(). */ -#define RING_BUFFER_MAX_NESTING 4 - -/* Buffer creation/removal and setup operations */ - -/* - * switch_timer_interval is the time interval (in us) to fill sub-buffers with - * padding to let readers get those sub-buffers. Used for live streaming. - * - * read_timer_interval is the time interval (in us) to wake up pending readers. - * - * buf_addr is a pointer the the beginning of the preallocated buffer contiguous - * address mapping. It is used only by RING_BUFFER_STATIC configuration. It can - * be set to NULL for other backends. - */ - -extern -struct channel *channel_create(const struct lib_ring_buffer_config *config, - const char *name, void *priv, - void *buf_addr, - size_t subbuf_size, size_t num_subbuf, - unsigned int switch_timer_interval, - unsigned int read_timer_interval); - -/* - * channel_destroy returns the private data pointer. It finalizes all channel's - * buffers, waits for readers to release all references, and destroys the - * channel. - */ -extern -void *channel_destroy(struct channel *chan); - - -/* Buffer read operations */ - -/* - * Iteration on channel cpumask needs to issue a read barrier to match the write - * barrier in cpu hotplug. It orders the cpumask read before read of per-cpu - * buffer data. The per-cpu buffer is never removed by cpu hotplug; teardown is - * only performed at channel destruction. - */ -#define for_each_channel_cpu(cpu, chan) \ - for ((cpu) = -1; \ - ({ (cpu) = cpumask_next(cpu, (chan)->backend.cpumask); \ - smp_read_barrier_depends(); (cpu) < nr_cpu_ids; });) - -extern struct lib_ring_buffer *channel_get_ring_buffer( - const struct lib_ring_buffer_config *config, - struct channel *chan, int cpu); -extern int lib_ring_buffer_open_read(struct lib_ring_buffer *buf); -extern void lib_ring_buffer_release_read(struct lib_ring_buffer *buf); - -/* - * Read sequence: snapshot, many get_subbuf/put_subbuf, move_consumer. - */ -extern int lib_ring_buffer_snapshot(struct lib_ring_buffer *buf, - unsigned long *consumed, - unsigned long *produced); -extern int lib_ring_buffer_snapshot_sample_positions( - struct lib_ring_buffer *buf, - unsigned long *consumed, - unsigned long *produced); -extern void lib_ring_buffer_move_consumer(struct lib_ring_buffer *buf, - unsigned long consumed_new); - -extern int lib_ring_buffer_get_subbuf(struct lib_ring_buffer *buf, - unsigned long consumed); -extern void lib_ring_buffer_put_subbuf(struct lib_ring_buffer *buf); - -void lib_ring_buffer_set_quiescent_channel(struct channel *chan); -void lib_ring_buffer_clear_quiescent_channel(struct channel *chan); - -/* - * lib_ring_buffer_get_next_subbuf/lib_ring_buffer_put_next_subbuf are helpers - * to read sub-buffers sequentially. - */ -static inline int lib_ring_buffer_get_next_subbuf(struct lib_ring_buffer *buf) -{ - int ret; - - ret = lib_ring_buffer_snapshot(buf, &buf->cons_snapshot, - &buf->prod_snapshot); - if (ret) - return ret; - ret = lib_ring_buffer_get_subbuf(buf, buf->cons_snapshot); - return ret; -} - -static inline void lib_ring_buffer_put_next_subbuf(struct lib_ring_buffer *buf) -{ - lib_ring_buffer_put_subbuf(buf); - lib_ring_buffer_move_consumer(buf, subbuf_align(buf->cons_snapshot, - buf->backend.chan)); -} - -extern void channel_reset(struct channel *chan); -extern void lib_ring_buffer_reset(struct lib_ring_buffer *buf); - -static inline -unsigned long lib_ring_buffer_get_offset(const struct lib_ring_buffer_config *config, - struct lib_ring_buffer *buf) -{ - return v_read(config, &buf->offset); -} - -static inline -unsigned long lib_ring_buffer_get_consumed(const struct lib_ring_buffer_config *config, - struct lib_ring_buffer *buf) -{ - return atomic_long_read(&buf->consumed); -} - -/* - * Must call lib_ring_buffer_is_finalized before reading counters (memory - * ordering enforced with respect to trace teardown). - */ -static inline -int lib_ring_buffer_is_finalized(const struct lib_ring_buffer_config *config, - struct lib_ring_buffer *buf) -{ - int finalized = READ_ONCE(buf->finalized); - /* - * Read finalized before counters. - */ - smp_rmb(); - return finalized; -} - -static inline -int lib_ring_buffer_channel_is_finalized(const struct channel *chan) -{ - return chan->finalized; -} - -static inline -int lib_ring_buffer_channel_is_disabled(const struct channel *chan) -{ - return atomic_read(&chan->record_disabled); -} - -static inline -unsigned long lib_ring_buffer_get_read_data_size( - const struct lib_ring_buffer_config *config, - struct lib_ring_buffer *buf) -{ - return subbuffer_get_read_data_size(config, &buf->backend); -} - -static inline -unsigned long lib_ring_buffer_get_records_count( - const struct lib_ring_buffer_config *config, - struct lib_ring_buffer *buf) -{ - return v_read(config, &buf->records_count); -} - -static inline -unsigned long lib_ring_buffer_get_records_overrun( - const struct lib_ring_buffer_config *config, - struct lib_ring_buffer *buf) -{ - return v_read(config, &buf->records_overrun); -} - -static inline -unsigned long lib_ring_buffer_get_records_lost_full( - const struct lib_ring_buffer_config *config, - struct lib_ring_buffer *buf) -{ - return v_read(config, &buf->records_lost_full); -} - -static inline -unsigned long lib_ring_buffer_get_records_lost_wrap( - const struct lib_ring_buffer_config *config, - struct lib_ring_buffer *buf) -{ - return v_read(config, &buf->records_lost_wrap); -} - -static inline -unsigned long lib_ring_buffer_get_records_lost_big( - const struct lib_ring_buffer_config *config, - struct lib_ring_buffer *buf) -{ - return v_read(config, &buf->records_lost_big); -} - -static inline -unsigned long lib_ring_buffer_get_records_read( - const struct lib_ring_buffer_config *config, - struct lib_ring_buffer *buf) -{ - return v_read(config, &buf->backend.records_read); -} - -#endif /* _LIB_RING_BUFFER_FRONTEND_H */ diff --git a/lib/ringbuffer/frontend_api.h b/lib/ringbuffer/frontend_api.h deleted file mode 100644 index 252aedc2..00000000 --- a/lib/ringbuffer/frontend_api.h +++ /dev/null @@ -1,358 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only OR LGPL-2.1-only) - * - * lib/ringbuffer/frontend_api.h - * - * Ring Buffer Library Synchronization Header (buffer write API). - * - * Copyright (C) 2005-2012 Mathieu Desnoyers - * - * See ring_buffer_frontend.c for more information on wait-free algorithms. - * See linux/ringbuffer/frontend.h for channel allocation and read-side API. - */ - -#ifndef _LIB_RING_BUFFER_FRONTEND_API_H -#define _LIB_RING_BUFFER_FRONTEND_API_H - -#include -#include -#include -#include - -/** - * lib_ring_buffer_get_cpu - Precedes ring buffer reserve/commit. - * - * Disables preemption (acts as a RCU read-side critical section) and keeps a - * ring buffer nesting count as supplementary safety net to ensure tracer client - * code will never trigger an endless recursion. Returns the processor ID on - * success, -EPERM on failure (nesting count too high). - * - * asm volatile and "memory" clobber prevent the compiler from moving - * instructions out of the ring buffer nesting count. This is required to ensure - * that probe side-effects which can cause recursion (e.g. unforeseen traps, - * divisions by 0, ...) are triggered within the incremented nesting count - * section. - */ -static inline -int lib_ring_buffer_get_cpu(const struct lib_ring_buffer_config *config) -{ - int cpu, nesting; - - rcu_read_lock_sched_notrace(); - cpu = smp_processor_id(); - nesting = ++per_cpu(lib_ring_buffer_nesting, cpu); - barrier(); - - if (unlikely(nesting > RING_BUFFER_MAX_NESTING)) { - WARN_ON_ONCE(1); - per_cpu(lib_ring_buffer_nesting, cpu)--; - rcu_read_unlock_sched_notrace(); - return -EPERM; - } else - return cpu; -} - -/** - * lib_ring_buffer_put_cpu - Follows ring buffer reserve/commit. - */ -static inline -void lib_ring_buffer_put_cpu(const struct lib_ring_buffer_config *config) -{ - barrier(); - (*this_cpu_ptr(&lib_ring_buffer_nesting))--; - rcu_read_unlock_sched_notrace(); -} - -/* - * lib_ring_buffer_try_reserve is called by lib_ring_buffer_reserve(). It is not - * part of the API per se. - * - * returns 0 if reserve ok, or 1 if the slow path must be taken. - */ -static inline -int lib_ring_buffer_try_reserve(const struct lib_ring_buffer_config *config, - struct lib_ring_buffer_ctx *ctx, - void *client_ctx, - unsigned long *o_begin, unsigned long *o_end, - unsigned long *o_old, size_t *before_hdr_pad) -{ - struct channel *chan = ctx->chan; - struct lib_ring_buffer *buf = ctx->buf; - *o_begin = v_read(config, &buf->offset); - *o_old = *o_begin; - - ctx->tsc = lib_ring_buffer_clock_read(chan); - if ((int64_t) ctx->tsc == -EIO) - return 1; - - /* - * Prefetch cacheline for read because we have to read the previous - * commit counter to increment it and commit seq value to compare it to - * the commit counter. - */ - prefetch(&buf->commit_hot[subbuf_index(*o_begin, chan)]); - - if (last_tsc_overflow(config, buf, ctx->tsc)) - ctx->rflags |= RING_BUFFER_RFLAG_FULL_TSC; - - if (unlikely(subbuf_offset(*o_begin, chan) == 0)) - return 1; - - ctx->slot_size = record_header_size(config, chan, *o_begin, - before_hdr_pad, ctx, client_ctx); - ctx->slot_size += - lib_ring_buffer_align(*o_begin + ctx->slot_size, - ctx->largest_align) + ctx->data_size; - if (unlikely((subbuf_offset(*o_begin, chan) + ctx->slot_size) - > chan->backend.subbuf_size)) - return 1; - - /* - * Record fits in the current buffer and we are not on a switch - * boundary. It's safe to write. - */ - *o_end = *o_begin + ctx->slot_size; - - if (unlikely((subbuf_offset(*o_end, chan)) == 0)) - /* - * The offset_end will fall at the very beginning of the next - * subbuffer. - */ - return 1; - - return 0; -} - -/** - * lib_ring_buffer_reserve - Reserve space in a ring buffer. - * @config: ring buffer instance configuration. - * @ctx: ring buffer context. (input and output) Must be already initialized. - * - * Atomic wait-free slot reservation. The reserved space starts at the context - * "pre_offset". Its length is "slot_size". The associated time-stamp is "tsc". - * - * Return : - * 0 on success. - * -EAGAIN if channel is disabled. - * -ENOSPC if event size is too large for packet. - * -ENOBUFS if there is currently not enough space in buffer for the event. - * -EIO if data cannot be written into the buffer for any other reason. - */ - -static inline -int lib_ring_buffer_reserve(const struct lib_ring_buffer_config *config, - struct lib_ring_buffer_ctx *ctx, - void *client_ctx) -{ - struct channel *chan = ctx->chan; - struct lib_ring_buffer *buf; - unsigned long o_begin, o_end, o_old; - size_t before_hdr_pad = 0; - - if (unlikely(atomic_read(&chan->record_disabled))) - return -EAGAIN; - - if (config->alloc == RING_BUFFER_ALLOC_PER_CPU) - buf = per_cpu_ptr(chan->backend.buf, ctx->cpu); - else - buf = chan->backend.buf; - if (unlikely(atomic_read(&buf->record_disabled))) - return -EAGAIN; - ctx->buf = buf; - - /* - * Perform retryable operations. - */ - if (unlikely(lib_ring_buffer_try_reserve(config, ctx, client_ctx, &o_begin, - &o_end, &o_old, &before_hdr_pad))) - goto slow_path; - - if (unlikely(v_cmpxchg(config, &ctx->buf->offset, o_old, o_end) - != o_old)) - goto slow_path; - - /* - * Atomically update last_tsc. This update races against concurrent - * atomic updates, but the race will always cause supplementary full TSC - * record headers, never the opposite (missing a full TSC record header - * when it would be needed). - */ - save_last_tsc(config, ctx->buf, ctx->tsc); - - /* - * Push the reader if necessary - */ - lib_ring_buffer_reserve_push_reader(ctx->buf, chan, o_end - 1); - - /* - * Clear noref flag for this subbuffer. - */ - lib_ring_buffer_clear_noref(config, &ctx->buf->backend, - subbuf_index(o_end - 1, chan)); - - ctx->pre_offset = o_begin; - ctx->buf_offset = o_begin + before_hdr_pad; - return 0; -slow_path: - return lib_ring_buffer_reserve_slow(ctx, client_ctx); -} - -/** - * lib_ring_buffer_switch - Perform a sub-buffer switch for a per-cpu buffer. - * @config: ring buffer instance configuration. - * @buf: buffer - * @mode: buffer switch mode (SWITCH_ACTIVE or SWITCH_FLUSH) - * - * This operation is completely reentrant : can be called while tracing is - * active with absolutely no lock held. - * - * Note, however, that as a v_cmpxchg is used for some atomic operations and - * requires to be executed locally for per-CPU buffers, this function must be - * called from the CPU which owns the buffer for a ACTIVE flush, with preemption - * disabled, for RING_BUFFER_SYNC_PER_CPU configuration. - */ -static inline -void lib_ring_buffer_switch(const struct lib_ring_buffer_config *config, - struct lib_ring_buffer *buf, enum switch_mode mode) -{ - lib_ring_buffer_switch_slow(buf, mode); -} - -/* See ring_buffer_frontend_api.h for lib_ring_buffer_reserve(). */ - -/** - * lib_ring_buffer_commit - Commit an record. - * @config: ring buffer instance configuration. - * @ctx: ring buffer context. (input arguments only) - * - * Atomic unordered slot commit. Increments the commit count in the - * specified sub-buffer, and delivers it if necessary. - */ -static inline -void lib_ring_buffer_commit(const struct lib_ring_buffer_config *config, - const struct lib_ring_buffer_ctx *ctx) -{ - struct channel *chan = ctx->chan; - struct lib_ring_buffer *buf = ctx->buf; - unsigned long offset_end = ctx->buf_offset; - unsigned long endidx = subbuf_index(offset_end - 1, chan); - unsigned long commit_count; - struct commit_counters_hot *cc_hot = &buf->commit_hot[endidx]; - - /* - * Must count record before incrementing the commit count. - */ - subbuffer_count_record(config, &buf->backend, endidx); - - /* - * Order all writes to buffer before the commit count update that will - * determine that the subbuffer is full. - */ - if (config->ipi == RING_BUFFER_IPI_BARRIER) { - /* - * Must write slot data before incrementing commit count. This - * compiler barrier is upgraded into a smp_mb() by the IPI sent - * by get_subbuf(). - */ - barrier(); - } else - smp_wmb(); - - v_add(config, ctx->slot_size, &cc_hot->cc); - - /* - * commit count read can race with concurrent OOO commit count updates. - * This is only needed for lib_ring_buffer_check_deliver (for - * non-polling delivery only) and for - * lib_ring_buffer_write_commit_counter. The race can only cause the - * counter to be read with the same value more than once, which could - * cause : - * - Multiple delivery for the same sub-buffer (which is handled - * gracefully by the reader code) if the value is for a full - * sub-buffer. It's important that we can never miss a sub-buffer - * delivery. Re-reading the value after the v_add ensures this. - * - Reading a commit_count with a higher value that what was actually - * added to it for the lib_ring_buffer_write_commit_counter call - * (again caused by a concurrent committer). It does not matter, - * because this function is interested in the fact that the commit - * count reaches back the reserve offset for a specific sub-buffer, - * which is completely independent of the order. - */ - commit_count = v_read(config, &cc_hot->cc); - - lib_ring_buffer_check_deliver(config, buf, chan, offset_end - 1, - commit_count, endidx, ctx->tsc); - /* - * Update used size at each commit. It's needed only for extracting - * ring_buffer buffers from vmcore, after crash. - */ - lib_ring_buffer_write_commit_counter(config, buf, chan, - offset_end, commit_count, cc_hot); -} - -/** - * lib_ring_buffer_try_discard_reserve - Try discarding a record. - * @config: ring buffer instance configuration. - * @ctx: ring buffer context. (input arguments only) - * - * Only succeeds if no other record has been written after the record to - * discard. If discard fails, the record must be committed to the buffer. - * - * Returns 0 upon success, -EPERM if the record cannot be discarded. - */ -static inline -int lib_ring_buffer_try_discard_reserve(const struct lib_ring_buffer_config *config, - const struct lib_ring_buffer_ctx *ctx) -{ - struct lib_ring_buffer *buf = ctx->buf; - unsigned long end_offset = ctx->pre_offset + ctx->slot_size; - - /* - * We need to ensure that if the cmpxchg succeeds and discards the - * record, the next record will record a full TSC, because it cannot - * rely on the last_tsc associated with the discarded record to detect - * overflows. The only way to ensure this is to set the last_tsc to 0 - * (assuming no 64-bit TSC overflow), which forces to write a 64-bit - * timestamp in the next record. - * - * Note: if discard fails, we must leave the TSC in the record header. - * It is needed to keep track of TSC overflows for the following - * records. - */ - save_last_tsc(config, buf, 0ULL); - - if (likely(v_cmpxchg(config, &buf->offset, end_offset, ctx->pre_offset) - != end_offset)) - return -EPERM; - else - return 0; -} - -static inline -void channel_record_disable(const struct lib_ring_buffer_config *config, - struct channel *chan) -{ - atomic_inc(&chan->record_disabled); -} - -static inline -void channel_record_enable(const struct lib_ring_buffer_config *config, - struct channel *chan) -{ - atomic_dec(&chan->record_disabled); -} - -static inline -void lib_ring_buffer_record_disable(const struct lib_ring_buffer_config *config, - struct lib_ring_buffer *buf) -{ - atomic_inc(&buf->record_disabled); -} - -static inline -void lib_ring_buffer_record_enable(const struct lib_ring_buffer_config *config, - struct lib_ring_buffer *buf) -{ - atomic_dec(&buf->record_disabled); -} - -#endif /* _LIB_RING_BUFFER_FRONTEND_API_H */ diff --git a/lib/ringbuffer/frontend_internal.h b/lib/ringbuffer/frontend_internal.h deleted file mode 100644 index eb17c5da..00000000 --- a/lib/ringbuffer/frontend_internal.h +++ /dev/null @@ -1,334 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only OR LGPL-2.1-only) - * - * linux/ringbuffer/frontend_internal.h - * - * Ring Buffer Library Synchronization Header (internal helpers). - * - * Copyright (C) 2005-2012 Mathieu Desnoyers - * - * See ring_buffer_frontend.c for more information on wait-free algorithms. - */ - -#ifndef _LIB_RING_BUFFER_FRONTEND_INTERNAL_H -#define _LIB_RING_BUFFER_FRONTEND_INTERNAL_H - -#include -#include -#include -#include /* For per-CPU read-side iterator */ - -/* Buffer offset macros */ - -/* buf_trunc mask selects only the buffer number. */ -static inline -unsigned long buf_trunc(unsigned long offset, struct channel *chan) -{ - return offset & ~(chan->backend.buf_size - 1); - -} - -/* Select the buffer number value (counter). */ -static inline -unsigned long buf_trunc_val(unsigned long offset, struct channel *chan) -{ - return buf_trunc(offset, chan) >> chan->backend.buf_size_order; -} - -/* buf_offset mask selects only the offset within the current buffer. */ -static inline -unsigned long buf_offset(unsigned long offset, struct channel *chan) -{ - return offset & (chan->backend.buf_size - 1); -} - -/* subbuf_offset mask selects the offset within the current subbuffer. */ -static inline -unsigned long subbuf_offset(unsigned long offset, struct channel *chan) -{ - return offset & (chan->backend.subbuf_size - 1); -} - -/* subbuf_trunc mask selects the subbuffer number. */ -static inline -unsigned long subbuf_trunc(unsigned long offset, struct channel *chan) -{ - return offset & ~(chan->backend.subbuf_size - 1); -} - -/* subbuf_align aligns the offset to the next subbuffer. */ -static inline -unsigned long subbuf_align(unsigned long offset, struct channel *chan) -{ - return (offset + chan->backend.subbuf_size) - & ~(chan->backend.subbuf_size - 1); -} - -/* subbuf_index returns the index of the current subbuffer within the buffer. */ -static inline -unsigned long subbuf_index(unsigned long offset, struct channel *chan) -{ - return buf_offset(offset, chan) >> chan->backend.subbuf_size_order; -} - -/* - * Last TSC comparison functions. Check if the current TSC overflows tsc_bits - * bits from the last TSC read. When overflows are detected, the full 64-bit - * timestamp counter should be written in the record header. Reads and writes - * last_tsc atomically. - */ - -#if (BITS_PER_LONG == 32) -static inline -void save_last_tsc(const struct lib_ring_buffer_config *config, - struct lib_ring_buffer *buf, u64 tsc) -{ - if (config->tsc_bits == 0 || config->tsc_bits == 64) - return; - - /* - * Ensure the compiler performs this update in a single instruction. - */ - v_set(config, &buf->last_tsc, (unsigned long)(tsc >> config->tsc_bits)); -} - -static inline -int last_tsc_overflow(const struct lib_ring_buffer_config *config, - struct lib_ring_buffer *buf, u64 tsc) -{ - unsigned long tsc_shifted; - - if (config->tsc_bits == 0 || config->tsc_bits == 64) - return 0; - - tsc_shifted = (unsigned long)(tsc >> config->tsc_bits); - if (unlikely(tsc_shifted - - (unsigned long)v_read(config, &buf->last_tsc))) - return 1; - else - return 0; -} -#else -static inline -void save_last_tsc(const struct lib_ring_buffer_config *config, - struct lib_ring_buffer *buf, u64 tsc) -{ - if (config->tsc_bits == 0 || config->tsc_bits == 64) - return; - - v_set(config, &buf->last_tsc, (unsigned long)tsc); -} - -static inline -int last_tsc_overflow(const struct lib_ring_buffer_config *config, - struct lib_ring_buffer *buf, u64 tsc) -{ - if (config->tsc_bits == 0 || config->tsc_bits == 64) - return 0; - - if (unlikely((tsc - v_read(config, &buf->last_tsc)) - >> config->tsc_bits)) - return 1; - else - return 0; -} -#endif - -extern -int lib_ring_buffer_reserve_slow(struct lib_ring_buffer_ctx *ctx, - void *client_ctx); - -extern -void lib_ring_buffer_switch_slow(struct lib_ring_buffer *buf, - enum switch_mode mode); - -extern -void lib_ring_buffer_check_deliver_slow(const struct lib_ring_buffer_config *config, - struct lib_ring_buffer *buf, - struct channel *chan, - unsigned long offset, - unsigned long commit_count, - unsigned long idx, - u64 tsc); - -extern -void lib_ring_buffer_switch_remote(struct lib_ring_buffer *buf); -extern -void lib_ring_buffer_switch_remote_empty(struct lib_ring_buffer *buf); -extern -void lib_ring_buffer_clear(struct lib_ring_buffer *buf); - -/* Buffer write helpers */ - -static inline -void lib_ring_buffer_reserve_push_reader(struct lib_ring_buffer *buf, - struct channel *chan, - unsigned long offset) -{ - unsigned long consumed_old, consumed_new; - - do { - consumed_old = atomic_long_read(&buf->consumed); - /* - * If buffer is in overwrite mode, push the reader consumed - * count if the write position has reached it and we are not - * at the first iteration (don't push the reader farther than - * the writer). This operation can be done concurrently by many - * writers in the same buffer, the writer being at the farthest - * write position sub-buffer index in the buffer being the one - * which will win this loop. - */ - if (unlikely(subbuf_trunc(offset, chan) - - subbuf_trunc(consumed_old, chan) - >= chan->backend.buf_size)) - consumed_new = subbuf_align(consumed_old, chan); - else - return; - } while (unlikely(atomic_long_cmpxchg(&buf->consumed, consumed_old, - consumed_new) != consumed_old)); -} - -/* - * Move consumed position to the beginning of subbuffer in which the - * write offset is. Should only be used on ring buffers that are not - * actively being written into, because clear_reader does not take into - * account the commit counters when moving the consumed position, which - * can make concurrent trace producers or consumers observe consumed - * position further than the write offset, which breaks ring buffer - * algorithm guarantees. - */ -static inline -void lib_ring_buffer_clear_reader(struct lib_ring_buffer *buf, - struct channel *chan) -{ - const struct lib_ring_buffer_config *config = &chan->backend.config; - unsigned long offset, consumed_old, consumed_new; - - do { - offset = v_read(config, &buf->offset); - consumed_old = atomic_long_read(&buf->consumed); - CHAN_WARN_ON(chan, (long) (subbuf_trunc(offset, chan) - - subbuf_trunc(consumed_old, chan)) - < 0); - consumed_new = subbuf_trunc(offset, chan); - } while (unlikely(atomic_long_cmpxchg(&buf->consumed, consumed_old, - consumed_new) != consumed_old)); -} - -static inline -int lib_ring_buffer_pending_data(const struct lib_ring_buffer_config *config, - struct lib_ring_buffer *buf, - struct channel *chan) -{ - return !!subbuf_offset(v_read(config, &buf->offset), chan); -} - -static inline -unsigned long lib_ring_buffer_get_data_size(const struct lib_ring_buffer_config *config, - struct lib_ring_buffer *buf, - unsigned long idx) -{ - return subbuffer_get_data_size(config, &buf->backend, idx); -} - -/* - * Check if all space reservation in a buffer have been committed. This helps - * knowing if an execution context is nested (for per-cpu buffers only). - * This is a very specific ftrace use-case, so we keep this as "internal" API. - */ -static inline -int lib_ring_buffer_reserve_committed(const struct lib_ring_buffer_config *config, - struct lib_ring_buffer *buf, - struct channel *chan) -{ - unsigned long offset, idx, commit_count; - - CHAN_WARN_ON(chan, config->alloc != RING_BUFFER_ALLOC_PER_CPU); - CHAN_WARN_ON(chan, config->sync != RING_BUFFER_SYNC_PER_CPU); - - /* - * Read offset and commit count in a loop so they are both read - * atomically wrt interrupts. By deal with interrupt concurrency by - * restarting both reads if the offset has been pushed. Note that given - * we only have to deal with interrupt concurrency here, an interrupt - * modifying the commit count will also modify "offset", so it is safe - * to only check for offset modifications. - */ - do { - offset = v_read(config, &buf->offset); - idx = subbuf_index(offset, chan); - commit_count = v_read(config, &buf->commit_hot[idx].cc); - } while (offset != v_read(config, &buf->offset)); - - return ((buf_trunc(offset, chan) >> chan->backend.num_subbuf_order) - - (commit_count & chan->commit_count_mask) == 0); -} - -/* - * Receive end of subbuffer TSC as parameter. It has been read in the - * space reservation loop of either reserve or switch, which ensures it - * progresses monotonically with event records in the buffer. Therefore, - * it ensures that the end timestamp of a subbuffer is <= begin - * timestamp of the following subbuffers. - */ -static inline -void lib_ring_buffer_check_deliver(const struct lib_ring_buffer_config *config, - struct lib_ring_buffer *buf, - struct channel *chan, - unsigned long offset, - unsigned long commit_count, - unsigned long idx, - u64 tsc) -{ - unsigned long old_commit_count = commit_count - - chan->backend.subbuf_size; - - /* Check if all commits have been done */ - if (unlikely((buf_trunc(offset, chan) >> chan->backend.num_subbuf_order) - - (old_commit_count & chan->commit_count_mask) == 0)) - lib_ring_buffer_check_deliver_slow(config, buf, chan, offset, - commit_count, idx, tsc); -} - -/* - * lib_ring_buffer_write_commit_counter - * - * For flight recording. must be called after commit. - * This function increments the subbuffer's commit_seq counter each time the - * commit count reaches back the reserve offset (modulo subbuffer size). It is - * useful for crash dump. - */ -static inline -void lib_ring_buffer_write_commit_counter(const struct lib_ring_buffer_config *config, - struct lib_ring_buffer *buf, - struct channel *chan, - unsigned long buf_offset, - unsigned long commit_count, - struct commit_counters_hot *cc_hot) -{ - unsigned long commit_seq_old; - - if (config->oops != RING_BUFFER_OOPS_CONSISTENCY) - return; - - /* - * subbuf_offset includes commit_count_mask. We can simply - * compare the offsets within the subbuffer without caring about - * buffer full/empty mismatch because offset is never zero here - * (subbuffer header and record headers have non-zero length). - */ - if (unlikely(subbuf_offset(buf_offset - commit_count, chan))) - return; - - commit_seq_old = v_read(config, &cc_hot->seq); - if (likely((long) (commit_seq_old - commit_count) < 0)) - v_set(config, &cc_hot->seq, commit_count); -} - -extern int lib_ring_buffer_create(struct lib_ring_buffer *buf, - struct channel_backend *chanb, int cpu); -extern void lib_ring_buffer_free(struct lib_ring_buffer *buf); - -/* Keep track of trap nesting inside ring buffer code */ -DECLARE_PER_CPU(unsigned int, lib_ring_buffer_nesting); - -#endif /* _LIB_RING_BUFFER_FRONTEND_INTERNAL_H */ diff --git a/lib/ringbuffer/frontend_types.h b/lib/ringbuffer/frontend_types.h deleted file mode 100644 index 75e602f4..00000000 --- a/lib/ringbuffer/frontend_types.h +++ /dev/null @@ -1,188 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only OR LGPL-2.1-only) - * - * lib/ringbuffer/frontend_types.h - * - * Ring Buffer Library Synchronization Header (types). - * - * Copyright (C) 2010-2012 Mathieu Desnoyers - * - * See ring_buffer_frontend.c for more information on wait-free algorithms. - */ - -#ifndef _LIB_RING_BUFFER_FRONTEND_TYPES_H -#define _LIB_RING_BUFFER_FRONTEND_TYPES_H - -#include -#include -#include -#include /* For per-CPU read-side iterator */ -#include - -/* - * A switch is done during tracing or as a final flush after tracing (so it - * won't write in the new sub-buffer). - */ -enum switch_mode { SWITCH_ACTIVE, SWITCH_FLUSH }; - -/* channel-level read-side iterator */ -struct channel_iter { - /* Prio heap of buffers. Lowest timestamps at the top. */ - struct lttng_ptr_heap heap; /* Heap of struct lib_ring_buffer ptrs */ - struct list_head empty_head; /* Empty buffers linked-list head */ - int read_open; /* Opened for reading ? */ - u64 last_qs; /* Last quiescent state timestamp */ - u64 last_timestamp; /* Last timestamp (for WARN_ON) */ - int last_cpu; /* Last timestamp cpu */ - /* - * read() file operation state. - */ - unsigned long len_left; -}; - -/* channel: collection of per-cpu ring buffers. */ -struct channel { - atomic_t record_disabled; - unsigned long commit_count_mask; /* - * Commit count mask, removing - * the MSBs corresponding to - * bits used to represent the - * subbuffer index. - */ - - struct channel_backend backend; /* Associated backend */ - - unsigned long switch_timer_interval; /* Buffer flush (jiffies) */ - unsigned long read_timer_interval; /* Reader wakeup (jiffies) */ - struct lttng_cpuhp_node cpuhp_prepare; - struct lttng_cpuhp_node cpuhp_online; - struct lttng_cpuhp_node cpuhp_iter_online; - struct notifier_block tick_nohz_notifier; /* CPU nohz notifier */ - wait_queue_head_t read_wait; /* reader wait queue */ - wait_queue_head_t hp_wait; /* CPU hotplug wait queue */ - int finalized; /* Has channel been finalized */ - struct channel_iter iter; /* Channel read-side iterator */ - struct kref ref; /* Reference count */ -}; - -/* Per-subbuffer commit counters used on the hot path */ -struct commit_counters_hot { - union v_atomic cc; /* Commit counter */ - union v_atomic seq; /* Consecutive commits */ -}; - -/* Per-subbuffer commit counters used only on cold paths */ -struct commit_counters_cold { - union v_atomic cc_sb; /* Incremented _once_ at sb switch */ -}; - -/* Per-buffer read iterator */ -struct lib_ring_buffer_iter { - u64 timestamp; /* Current record timestamp */ - size_t header_len; /* Current record header length */ - size_t payload_len; /* Current record payload length */ - - struct list_head empty_node; /* Linked list of empty buffers */ - unsigned long consumed, read_offset, data_size; - enum { - ITER_GET_SUBBUF = 0, - ITER_TEST_RECORD, - ITER_NEXT_RECORD, - ITER_PUT_SUBBUF, - } state; - unsigned int allocated:1; - unsigned int read_open:1; /* Opened for reading ? */ -}; - -/* ring buffer state */ -struct lib_ring_buffer { - /* First 32 bytes cache-hot cacheline */ - union v_atomic offset; /* Current offset in the buffer */ - struct commit_counters_hot *commit_hot; - /* Commit count per sub-buffer */ - atomic_long_t consumed; /* - * Current offset in the buffer - * standard atomic access (shared) - */ - atomic_t record_disabled; - /* End of first 32 bytes cacheline */ - union v_atomic last_tsc; /* - * Last timestamp written in the buffer. - */ - - struct lib_ring_buffer_backend backend; /* Associated backend */ - - struct commit_counters_cold *commit_cold; - /* Commit count per sub-buffer */ - u64 *ts_end; /* - * timestamp_end per sub-buffer. - * Time is sampled by the - * switch_*_end() callbacks which - * are the last space reservation - * performed in the sub-buffer - * before it can be fully - * committed and delivered. This - * time value is then read by - * the deliver callback, - * performed by the last commit - * before the buffer becomes - * readable. - */ - atomic_long_t active_readers; /* - * Active readers count - * standard atomic access (shared) - */ - /* Dropped records */ - union v_atomic records_lost_full; /* Buffer full */ - union v_atomic records_lost_wrap; /* Nested wrap-around */ - union v_atomic records_lost_big; /* Events too big */ - union v_atomic records_count; /* Number of records written */ - union v_atomic records_overrun; /* Number of overwritten records */ - wait_queue_head_t read_wait; /* reader buffer-level wait queue */ - wait_queue_head_t write_wait; /* writer buffer-level wait queue (for metadata only) */ - int finalized; /* buffer has been finalized */ - struct timer_list switch_timer; /* timer for periodical switch */ - struct timer_list read_timer; /* timer for read poll */ - raw_spinlock_t raw_tick_nohz_spinlock; /* nohz entry lock/trylock */ - struct lib_ring_buffer_iter iter; /* read-side iterator */ - unsigned long get_subbuf_consumed; /* Read-side consumed */ - unsigned long prod_snapshot; /* Producer count snapshot */ - unsigned long cons_snapshot; /* Consumer count snapshot */ - unsigned int get_subbuf:1, /* Sub-buffer being held by reader */ - switch_timer_enabled:1, /* Protected by ring_buffer_nohz_lock */ - read_timer_enabled:1, /* Protected by ring_buffer_nohz_lock */ - quiescent:1; -}; - -static inline -void *channel_get_private(struct channel *chan) -{ - return chan->backend.priv; -} - -void lib_ring_buffer_lost_event_too_big(struct channel *chan); - -/* - * Issue warnings and disable channels upon internal error. - * Can receive struct lib_ring_buffer or struct lib_ring_buffer_backend - * parameters. - */ -#define CHAN_WARN_ON(c, cond) \ - ({ \ - struct channel *__chan; \ - int _____ret = unlikely(cond); \ - if (_____ret) { \ - if (__same_type(*(c), struct channel_backend)) \ - __chan = container_of((void *) (c), \ - struct channel, \ - backend); \ - else if (__same_type(*(c), struct channel)) \ - __chan = (void *) (c); \ - else \ - BUG_ON(1); \ - atomic_inc(&__chan->record_disabled); \ - WARN_ON(1); \ - } \ - _____ret; \ - }) - -#endif /* _LIB_RING_BUFFER_FRONTEND_TYPES_H */ diff --git a/lib/ringbuffer/iterator.h b/lib/ringbuffer/iterator.h deleted file mode 100644 index 8064e42a..00000000 --- a/lib/ringbuffer/iterator.h +++ /dev/null @@ -1,67 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only OR LGPL-2.1-only) - * - * lib/ringbuffer/iterator.h - * - * Ring buffer and channel iterators. - * - * Copyright (C) 2010-2012 Mathieu Desnoyers - */ - -#ifndef _LIB_RING_BUFFER_ITERATOR_H -#define _LIB_RING_BUFFER_ITERATOR_H - -#include -#include -#include - -/* - * lib_ring_buffer_get_next_record advances the buffer read position to the next - * record. It returns either the size of the next record, -EAGAIN if there is - * currently no data available, or -ENODATA if no data is available and buffer - * is finalized. - */ -extern ssize_t lib_ring_buffer_get_next_record(struct channel *chan, - struct lib_ring_buffer *buf); - -/* - * channel_get_next_record advances the buffer read position to the next record. - * It returns either the size of the next record, -EAGAIN if there is currently - * no data available, or -ENODATA if no data is available and buffer is - * finalized. - * Returns the current buffer in ret_buf. - */ -extern ssize_t channel_get_next_record(struct channel *chan, - struct lib_ring_buffer **ret_buf); - -/** - * read_current_record - copy the buffer current record into dest. - * @buf: ring buffer - * @dest: destination where the record should be copied - * - * dest should be large enough to contain the record. Returns the number of - * bytes copied. - */ -static inline size_t read_current_record(struct lib_ring_buffer *buf, void *dest) -{ - return lib_ring_buffer_read(&buf->backend, buf->iter.read_offset, - dest, buf->iter.payload_len); -} - -extern int lib_ring_buffer_iterator_open(struct lib_ring_buffer *buf); -extern void lib_ring_buffer_iterator_release(struct lib_ring_buffer *buf); -extern int channel_iterator_open(struct channel *chan); -extern void channel_iterator_release(struct channel *chan); - -extern const struct file_operations channel_payload_file_operations; -extern const struct file_operations lib_ring_buffer_payload_file_operations; - -/* - * Used internally. - */ -int channel_iterator_init(struct channel *chan); -void channel_iterator_unregister_notifiers(struct channel *chan); -void channel_iterator_free(struct channel *chan); -void channel_iterator_reset(struct channel *chan); -void lib_ring_buffer_iterator_reset(struct lib_ring_buffer *buf); - -#endif /* _LIB_RING_BUFFER_ITERATOR_H */ diff --git a/lib/ringbuffer/nohz.h b/lib/ringbuffer/nohz.h deleted file mode 100644 index 1d28d279..00000000 --- a/lib/ringbuffer/nohz.h +++ /dev/null @@ -1,29 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only OR LGPL-2.1-only) - * - * lib/ringbuffer/nohz.h - * - * Copyright (C) 2011-2012 Mathieu Desnoyers - */ - -#ifndef _LIB_RING_BUFFER_NOHZ_H -#define _LIB_RING_BUFFER_NOHZ_H - -#ifdef CONFIG_LIB_RING_BUFFER -void lib_ring_buffer_tick_nohz_flush(void); -void lib_ring_buffer_tick_nohz_stop(void); -void lib_ring_buffer_tick_nohz_restart(void); -#else -static inline void lib_ring_buffer_tick_nohz_flush(void) -{ -} - -static inline void lib_ring_buffer_tick_nohz_stop(void) -{ -} - -static inline void lib_ring_buffer_tick_nohz_restart(void) -{ -} -#endif - -#endif /* _LIB_RING_BUFFER_NOHZ_H */ diff --git a/lib/ringbuffer/ring_buffer_backend.c b/lib/ringbuffer/ring_buffer_backend.c index ec331232..ec819703 100644 --- a/lib/ringbuffer/ring_buffer_backend.c +++ b/lib/ringbuffer/ring_buffer_backend.c @@ -17,9 +17,9 @@ #include #include -#include -#include -#include +#include +#include +#include /** * lib_ring_buffer_backend_allocate - allocate a channel buffer diff --git a/lib/ringbuffer/ring_buffer_frontend.c b/lib/ringbuffer/ring_buffer_frontend.c index 8ffb702e..28f19cd4 100644 --- a/lib/ringbuffer/ring_buffer_frontend.c +++ b/lib/ringbuffer/ring_buffer_frontend.c @@ -45,11 +45,11 @@ #include #include -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include /* * Internal structure representing offsets to use at a sub-buffer switch. diff --git a/lib/ringbuffer/ring_buffer_iterator.c b/lib/ringbuffer/ring_buffer_iterator.c index 96f4c3b2..eecf24fb 100644 --- a/lib/ringbuffer/ring_buffer_iterator.c +++ b/lib/ringbuffer/ring_buffer_iterator.c @@ -9,7 +9,7 @@ * Copyright (C) 2010-2012 Mathieu Desnoyers */ -#include +#include #include #include #include diff --git a/lib/ringbuffer/ring_buffer_mmap.c b/lib/ringbuffer/ring_buffer_mmap.c index def29b18..ad672888 100644 --- a/lib/ringbuffer/ring_buffer_mmap.c +++ b/lib/ringbuffer/ring_buffer_mmap.c @@ -13,9 +13,9 @@ #include #include -#include -#include -#include +#include +#include +#include /* * fault() vm_op implementation for ring buffer file mapping. diff --git a/lib/ringbuffer/ring_buffer_splice.c b/lib/ringbuffer/ring_buffer_splice.c index 581e2ef3..db1f8867 100644 --- a/lib/ringbuffer/ring_buffer_splice.c +++ b/lib/ringbuffer/ring_buffer_splice.c @@ -14,9 +14,9 @@ #include #include -#include -#include -#include +#include +#include +#include #if 0 #define printk_dbg(fmt, args...) printk(fmt, args) diff --git a/lib/ringbuffer/ring_buffer_vfs.c b/lib/ringbuffer/ring_buffer_vfs.c index 99000613..896543e3 100644 --- a/lib/ringbuffer/ring_buffer_vfs.c +++ b/lib/ringbuffer/ring_buffer_vfs.c @@ -11,10 +11,10 @@ #include #include -#include -#include -#include -#include +#include +#include +#include +#include static int put_ulong(unsigned long val, unsigned long arg) { diff --git a/lib/ringbuffer/vatomic.h b/lib/ringbuffer/vatomic.h deleted file mode 100644 index 6fdc4d1b..00000000 --- a/lib/ringbuffer/vatomic.h +++ /dev/null @@ -1,84 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only OR LGPL-2.1-only) - * - * lib/ringbuffer/vatomic.h - * - * Copyright (C) 2010-2012 Mathieu Desnoyers - */ - -#ifndef _LIB_RING_BUFFER_VATOMIC_H -#define _LIB_RING_BUFFER_VATOMIC_H - -#include -#include - -/* - * Same data type (long) accessed differently depending on configuration. - * v field is for non-atomic access (protected by mutual exclusion). - * In the fast-path, the ring_buffer_config structure is constant, so the - * compiler can statically select the appropriate branch. - * local_t is used for per-cpu and per-thread buffers. - * atomic_long_t is used for globally shared buffers. - */ -union v_atomic { - local_t l; - atomic_long_t a; - long v; -}; - -static inline -long v_read(const struct lib_ring_buffer_config *config, union v_atomic *v_a) -{ - if (config->sync == RING_BUFFER_SYNC_PER_CPU) - return local_read(&v_a->l); - else - return atomic_long_read(&v_a->a); -} - -static inline -void v_set(const struct lib_ring_buffer_config *config, union v_atomic *v_a, - long v) -{ - if (config->sync == RING_BUFFER_SYNC_PER_CPU) - local_set(&v_a->l, v); - else - atomic_long_set(&v_a->a, v); -} - -static inline -void v_add(const struct lib_ring_buffer_config *config, long v, union v_atomic *v_a) -{ - if (config->sync == RING_BUFFER_SYNC_PER_CPU) - local_add(v, &v_a->l); - else - atomic_long_add(v, &v_a->a); -} - -static inline -void v_inc(const struct lib_ring_buffer_config *config, union v_atomic *v_a) -{ - if (config->sync == RING_BUFFER_SYNC_PER_CPU) - local_inc(&v_a->l); - else - atomic_long_inc(&v_a->a); -} - -/* - * Non-atomic decrement. Only used by reader, apply to reader-owned subbuffer. - */ -static inline -void _v_dec(const struct lib_ring_buffer_config *config, union v_atomic *v_a) -{ - --v_a->v; -} - -static inline -long v_cmpxchg(const struct lib_ring_buffer_config *config, union v_atomic *v_a, - long old, long _new) -{ - if (config->sync == RING_BUFFER_SYNC_PER_CPU) - return local_cmpxchg(&v_a->l, old, _new); - else - return atomic_long_cmpxchg(&v_a->a, old, _new); -} - -#endif /* _LIB_RING_BUFFER_VATOMIC_H */ diff --git a/lib/ringbuffer/vfs.h b/lib/ringbuffer/vfs.h deleted file mode 100644 index ee23a624..00000000 --- a/lib/ringbuffer/vfs.h +++ /dev/null @@ -1,166 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only OR LGPL-2.1-only) - * - * lib/ringbuffer/vfs.h - * - * Wait-free ring buffer VFS file operations. - * - * Copyright (C) 2005-2012 Mathieu Desnoyers - */ - -#ifndef _LIB_RING_BUFFER_VFS_H -#define _LIB_RING_BUFFER_VFS_H - -#include -#include - -/* VFS API */ - -extern const struct file_operations lib_ring_buffer_file_operations; - -/* - * Internal file operations. - */ - -struct lib_ring_buffer; - -int lib_ring_buffer_open(struct inode *inode, struct file *file, - struct lib_ring_buffer *buf); -int lib_ring_buffer_release(struct inode *inode, struct file *file, - struct lib_ring_buffer *buf); -unsigned int lib_ring_buffer_poll(struct file *filp, poll_table *wait, - struct lib_ring_buffer *buf); -ssize_t lib_ring_buffer_splice_read(struct file *in, loff_t *ppos, - struct pipe_inode_info *pipe, size_t len, - unsigned int flags, struct lib_ring_buffer *buf); -int lib_ring_buffer_mmap(struct file *filp, struct vm_area_struct *vma, - struct lib_ring_buffer *buf); - -/* Ring Buffer ioctl() and ioctl numbers */ -long lib_ring_buffer_ioctl(struct file *filp, unsigned int cmd, - unsigned long arg, struct lib_ring_buffer *buf); -#ifdef CONFIG_COMPAT -long lib_ring_buffer_compat_ioctl(struct file *filp, unsigned int cmd, - unsigned long arg, struct lib_ring_buffer *buf); -#endif - -ssize_t vfs_lib_ring_buffer_file_splice_read(struct file *in, loff_t *ppos, - struct pipe_inode_info *pipe, size_t len, unsigned int flags); -loff_t vfs_lib_ring_buffer_no_llseek(struct file *file, loff_t offset, - int origin); -int vfs_lib_ring_buffer_mmap(struct file *filp, struct vm_area_struct *vma); -ssize_t vfs_lib_ring_buffer_splice_read(struct file *in, loff_t *ppos, - struct pipe_inode_info *pipe, size_t len, - unsigned int flags); - -/* - * Use RING_BUFFER_GET_NEXT_SUBBUF / RING_BUFFER_PUT_NEXT_SUBBUF to read and - * consume sub-buffers sequentially. - * - * Reading sub-buffers without consuming them can be performed with: - * - * RING_BUFFER_SNAPSHOT - * RING_BUFFER_SNAPSHOT_GET_CONSUMED - * RING_BUFFER_SNAPSHOT_GET_PRODUCED - * - * to get the offset range to consume, and then by passing each sub-buffer - * offset to RING_BUFFER_GET_SUBBUF, read the sub-buffer, and then release it - * with RING_BUFFER_PUT_SUBBUF. - * - * Note that the "snapshot" API can be used to read the sub-buffer in reverse - * order, which is useful for flight recorder snapshots. - */ - -/* Get a snapshot of the current ring buffer producer and consumer positions */ -#define RING_BUFFER_SNAPSHOT _IO(0xF6, 0x00) -/* Get the consumer position (iteration start) */ -#define RING_BUFFER_SNAPSHOT_GET_CONSUMED _IOR(0xF6, 0x01, unsigned long) -/* Get the producer position (iteration end) */ -#define RING_BUFFER_SNAPSHOT_GET_PRODUCED _IOR(0xF6, 0x02, unsigned long) -/* Get exclusive read access to the specified sub-buffer position */ -#define RING_BUFFER_GET_SUBBUF _IOW(0xF6, 0x03, unsigned long) -/* Release exclusive sub-buffer access */ -#define RING_BUFFER_PUT_SUBBUF _IO(0xF6, 0x04) - -/* Get exclusive read access to the next sub-buffer that can be read. */ -#define RING_BUFFER_GET_NEXT_SUBBUF _IO(0xF6, 0x05) -/* Release exclusive sub-buffer access, move consumer forward. */ -#define RING_BUFFER_PUT_NEXT_SUBBUF _IO(0xF6, 0x06) -/* returns the size of the current sub-buffer, without padding (for mmap). */ -#define RING_BUFFER_GET_SUBBUF_SIZE _IOR(0xF6, 0x07, unsigned long) -/* returns the size of the current sub-buffer, with padding (for splice). */ -#define RING_BUFFER_GET_PADDED_SUBBUF_SIZE _IOR(0xF6, 0x08, unsigned long) -/* returns the maximum size for sub-buffers. */ -#define RING_BUFFER_GET_MAX_SUBBUF_SIZE _IOR(0xF6, 0x09, unsigned long) -/* returns the length to mmap. */ -#define RING_BUFFER_GET_MMAP_LEN _IOR(0xF6, 0x0A, unsigned long) -/* returns the offset of the subbuffer belonging to the mmap reader. */ -#define RING_BUFFER_GET_MMAP_READ_OFFSET _IOR(0xF6, 0x0B, unsigned long) -/* Flush the current sub-buffer, if non-empty. */ -#define RING_BUFFER_FLUSH _IO(0xF6, 0x0C) -/* Get the current version of the metadata cache (after a get_next). */ -#define RING_BUFFER_GET_METADATA_VERSION _IOR(0xF6, 0x0D, uint64_t) -/* - * Get a snapshot of the current ring buffer producer and consumer positions, - * regardless of whether or not the two positions are contained within the same - * sub-buffer. - */ -#define RING_BUFFER_SNAPSHOT_SAMPLE_POSITIONS _IO(0xF6, 0x0E) -/* Flush the current sub-buffer, even if empty. */ -#define RING_BUFFER_FLUSH_EMPTY _IO(0xF6, 0x0F) -/* - * Reset the position of what has been consumed from the metadata cache to 0 - * so it can be read again. - */ -#define RING_BUFFER_METADATA_CACHE_DUMP _IO(0xF6, 0x10) -/* Clear ring buffer content. */ -#define RING_BUFFER_CLEAR _IO(0xF6, 0x11) - -#ifdef CONFIG_COMPAT -/* Get a snapshot of the current ring buffer producer and consumer positions */ -#define RING_BUFFER_COMPAT_SNAPSHOT RING_BUFFER_SNAPSHOT -/* Get the consumer position (iteration start) */ -#define RING_BUFFER_COMPAT_SNAPSHOT_GET_CONSUMED \ - _IOR(0xF6, 0x01, compat_ulong_t) -/* Get the producer position (iteration end) */ -#define RING_BUFFER_COMPAT_SNAPSHOT_GET_PRODUCED \ - _IOR(0xF6, 0x02, compat_ulong_t) -/* Get exclusive read access to the specified sub-buffer position */ -#define RING_BUFFER_COMPAT_GET_SUBBUF _IOW(0xF6, 0x03, compat_ulong_t) -/* Release exclusive sub-buffer access */ -#define RING_BUFFER_COMPAT_PUT_SUBBUF RING_BUFFER_PUT_SUBBUF - -/* Get exclusive read access to the next sub-buffer that can be read. */ -#define RING_BUFFER_COMPAT_GET_NEXT_SUBBUF RING_BUFFER_GET_NEXT_SUBBUF -/* Release exclusive sub-buffer access, move consumer forward. */ -#define RING_BUFFER_COMPAT_PUT_NEXT_SUBBUF RING_BUFFER_PUT_NEXT_SUBBUF -/* returns the size of the current sub-buffer, without padding (for mmap). */ -#define RING_BUFFER_COMPAT_GET_SUBBUF_SIZE _IOR(0xF6, 0x07, compat_ulong_t) -/* returns the size of the current sub-buffer, with padding (for splice). */ -#define RING_BUFFER_COMPAT_GET_PADDED_SUBBUF_SIZE \ - _IOR(0xF6, 0x08, compat_ulong_t) -/* returns the maximum size for sub-buffers. */ -#define RING_BUFFER_COMPAT_GET_MAX_SUBBUF_SIZE _IOR(0xF6, 0x09, compat_ulong_t) -/* returns the length to mmap. */ -#define RING_BUFFER_COMPAT_GET_MMAP_LEN _IOR(0xF6, 0x0A, compat_ulong_t) -/* returns the offset of the subbuffer belonging to the mmap reader. */ -#define RING_BUFFER_COMPAT_GET_MMAP_READ_OFFSET _IOR(0xF6, 0x0B, compat_ulong_t) -/* Flush the current sub-buffer, if non-empty. */ -#define RING_BUFFER_COMPAT_FLUSH RING_BUFFER_FLUSH -/* Get the current version of the metadata cache (after a get_next). */ -#define RING_BUFFER_COMPAT_GET_METADATA_VERSION RING_BUFFER_GET_METADATA_VERSION -/* - * Get a snapshot of the current ring buffer producer and consumer positions, - * regardless of whether or not the two positions are contained within the same - * sub-buffer. - */ -#define RING_BUFFER_COMPAT_SNAPSHOT_SAMPLE_POSITIONS \ - RING_BUFFER_SNAPSHOT_SAMPLE_POSITIONS -/* Flush the current sub-buffer, even if empty. */ -#define RING_BUFFER_COMPAT_FLUSH_EMPTY \ - RING_BUFFER_FLUSH_EMPTY -/* Clear ring buffer content. */ -#define RING_BUFFER_COMPAT_CLEAR \ - RING_BUFFER_CLEAR -#endif /* CONFIG_COMPAT */ - -#endif /* _LIB_RING_BUFFER_VFS_H */ diff --git a/lttng-abi-old.h b/lttng-abi-old.h deleted file mode 100644 index 0b1c7b11..00000000 --- a/lttng-abi-old.h +++ /dev/null @@ -1,128 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) - * - * lttng-abi-old.h - * - * LTTng old ABI header (without support for compat 32/64 bits) - * - * Copyright (C) 2010-2012 Mathieu Desnoyers - */ - -#ifndef _LTTNG_ABI_OLD_H -#define _LTTNG_ABI_OLD_H - -#include -#include - -/* - * LTTng DebugFS ABI structures. - */ -#define LTTNG_KERNEL_OLD_CHANNEL_PADDING LTTNG_KERNEL_SYM_NAME_LEN + 32 -struct lttng_kernel_old_channel { - int overwrite; /* 1: overwrite, 0: discard */ - uint64_t subbuf_size; /* in bytes */ - uint64_t num_subbuf; - unsigned int switch_timer_interval; /* usecs */ - unsigned int read_timer_interval; /* usecs */ - enum lttng_kernel_output output; /* splice, mmap */ - char padding[LTTNG_KERNEL_OLD_CHANNEL_PADDING]; -}; - -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]; -}; - -struct lttng_kernel_old_function_tracer { - char symbol_name[LTTNG_KERNEL_SYM_NAME_LEN]; -}; - -/* - * For syscall tracing, name = '\0' means "enable all". - */ -#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]; /* event name */ - 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_tracer 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) */ -}; - -struct lttng_kernel_old_perf_counter_ctx { - uint32_t type; - uint64_t config; - char name[LTTNG_KERNEL_SYM_NAME_LEN]; -}; - -#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; -}; - -/* 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) - -/* 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) - -#endif /* _LTTNG_ABI_OLD_H */ diff --git a/lttng-abi.c b/lttng-abi.c index a32f419a..386c4e31 100644 --- a/lttng-abi.c +++ b/lttng-abi.c @@ -31,16 +31,16 @@ #include #include #include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include /* * This is LTTng's own personal way to create a system call as an external diff --git a/lttng-abi.h b/lttng-abi.h deleted file mode 100644 index a26c7ee0..00000000 --- a/lttng-abi.h +++ /dev/null @@ -1,354 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) - * - * lttng-abi.h - * - * LTTng ABI header - * - * Copyright (C) 2010-2012 Mathieu Desnoyers - */ - -#ifndef _LTTNG_ABI_H -#define _LTTNG_ABI_H - -#include - -/* - * Major/minor version of ABI exposed to lttng tools. Major number - * should be increased when an incompatible ABI change is done. - */ -#define LTTNG_MODULES_ABI_MAJOR_VERSION 2 -#define LTTNG_MODULES_ABI_MINOR_VERSION 5 - -#define LTTNG_KERNEL_SYM_NAME_LEN 256 -#define LTTNG_KERNEL_SESSION_NAME_LEN 256 -#define LTTNG_KERNEL_SESSION_CREATION_TIME_ISO8601_LEN 26 - -enum lttng_kernel_instrumentation { - LTTNG_KERNEL_TRACEPOINT = 0, - LTTNG_KERNEL_KPROBE = 1, - LTTNG_KERNEL_FUNCTION = 2, - LTTNG_KERNEL_KRETPROBE = 3, - LTTNG_KERNEL_NOOP = 4, /* not hooked */ - LTTNG_KERNEL_SYSCALL = 5, - LTTNG_KERNEL_UPROBE = 6, -}; - -/* - * LTTng consumer mode - */ -enum lttng_kernel_output { - LTTNG_KERNEL_SPLICE = 0, - LTTNG_KERNEL_MMAP = 1, -}; - -/* - * LTTng DebugFS ABI structures. - */ -#define LTTNG_KERNEL_CHANNEL_PADDING LTTNG_KERNEL_SYM_NAME_LEN + 32 -struct lttng_kernel_channel { - uint64_t subbuf_size; /* in bytes */ - uint64_t num_subbuf; - unsigned int switch_timer_interval; /* usecs */ - unsigned int read_timer_interval; /* usecs */ - enum lttng_kernel_output output; /* splice, mmap */ - int overwrite; /* 1: overwrite, 0: discard */ - char padding[LTTNG_KERNEL_CHANNEL_PADDING]; -} __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. - */ -struct lttng_kernel_kprobe { - uint64_t addr; - - uint64_t offset; - char symbol_name[LTTNG_KERNEL_SYM_NAME_LEN]; -} __attribute__((packed)); - -struct lttng_kernel_function_tracer { - char symbol_name[LTTNG_KERNEL_SYM_NAME_LEN]; -} __attribute__((packed)); - -struct lttng_kernel_uprobe { - int fd; -} __attribute__((packed)); - -struct lttng_kernel_event_callsite_uprobe { - uint64_t offset; -} __attribute__((packed)); - -struct lttng_kernel_event_callsite { - union { - struct lttng_kernel_event_callsite_uprobe uprobe; - } u; -} __attribute__((packed)); - -/* - * For syscall tracing, name = "*" means "enable all". - */ -#define LTTNG_KERNEL_EVENT_PADDING1 16 -#define LTTNG_KERNEL_EVENT_PADDING2 LTTNG_KERNEL_SYM_NAME_LEN + 32 -struct lttng_kernel_event { - char name[LTTNG_KERNEL_SYM_NAME_LEN]; /* event name */ - enum lttng_kernel_instrumentation instrumentation; - char padding[LTTNG_KERNEL_EVENT_PADDING1]; - - /* Per instrumentation type configuration */ - union { - struct lttng_kernel_kretprobe kretprobe; - struct lttng_kernel_kprobe kprobe; - struct lttng_kernel_function_tracer ftrace; - struct lttng_kernel_uprobe uprobe; - 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)); - -struct lttng_kernel_tracer_abi_version { - uint32_t major; - uint32_t minor; -} __attribute__((packed)); - -struct lttng_kernel_session_name { - char name[LTTNG_KERNEL_SESSION_NAME_LEN]; -} __attribute__((packed)); - -struct lttng_kernel_session_creation_time { - char iso8601[LTTNG_KERNEL_SESSION_CREATION_TIME_ISO8601_LEN]; -} __attribute__((packed)); - -enum lttng_kernel_calibrate_type { - LTTNG_KERNEL_CALIBRATE_KRETPROBE, -}; - -struct lttng_kernel_calibrate { - enum lttng_kernel_calibrate_type type; /* type (input) */ -} __attribute__((packed)); - -struct lttng_kernel_syscall_mask { - uint32_t len; /* in bits */ - char mask[]; -} __attribute__((packed)); - -enum lttng_kernel_context_type { - LTTNG_KERNEL_CONTEXT_PID = 0, - LTTNG_KERNEL_CONTEXT_PERF_COUNTER = 1, - LTTNG_KERNEL_CONTEXT_PROCNAME = 2, - LTTNG_KERNEL_CONTEXT_PRIO = 3, - LTTNG_KERNEL_CONTEXT_NICE = 4, - LTTNG_KERNEL_CONTEXT_VPID = 5, - LTTNG_KERNEL_CONTEXT_TID = 6, - LTTNG_KERNEL_CONTEXT_VTID = 7, - LTTNG_KERNEL_CONTEXT_PPID = 8, - LTTNG_KERNEL_CONTEXT_VPPID = 9, - LTTNG_KERNEL_CONTEXT_HOSTNAME = 10, - LTTNG_KERNEL_CONTEXT_CPU_ID = 11, - LTTNG_KERNEL_CONTEXT_INTERRUPTIBLE = 12, - LTTNG_KERNEL_CONTEXT_PREEMPTIBLE = 13, - LTTNG_KERNEL_CONTEXT_NEED_RESCHEDULE = 14, - LTTNG_KERNEL_CONTEXT_MIGRATABLE = 15, - LTTNG_KERNEL_CONTEXT_CALLSTACK_KERNEL = 16, - LTTNG_KERNEL_CONTEXT_CALLSTACK_USER = 17, - LTTNG_KERNEL_CONTEXT_CGROUP_NS = 18, - LTTNG_KERNEL_CONTEXT_IPC_NS = 19, - LTTNG_KERNEL_CONTEXT_MNT_NS = 20, - LTTNG_KERNEL_CONTEXT_NET_NS = 21, - LTTNG_KERNEL_CONTEXT_PID_NS = 22, - LTTNG_KERNEL_CONTEXT_USER_NS = 23, - LTTNG_KERNEL_CONTEXT_UTS_NS = 24, - LTTNG_KERNEL_CONTEXT_UID = 25, - LTTNG_KERNEL_CONTEXT_EUID = 26, - LTTNG_KERNEL_CONTEXT_SUID = 27, - LTTNG_KERNEL_CONTEXT_GID = 28, - LTTNG_KERNEL_CONTEXT_EGID = 29, - LTTNG_KERNEL_CONTEXT_SGID = 30, - LTTNG_KERNEL_CONTEXT_VUID = 31, - LTTNG_KERNEL_CONTEXT_VEUID = 32, - LTTNG_KERNEL_CONTEXT_VSUID = 33, - LTTNG_KERNEL_CONTEXT_VGID = 34, - LTTNG_KERNEL_CONTEXT_VEGID = 35, - LTTNG_KERNEL_CONTEXT_VSGID = 36, -}; - -struct lttng_kernel_perf_counter_ctx { - uint32_t type; - uint64_t config; - char name[LTTNG_KERNEL_SYM_NAME_LEN]; -} __attribute__((packed)); - -#define LTTNG_KERNEL_CONTEXT_PADDING1 16 -#define LTTNG_KERNEL_CONTEXT_PADDING2 LTTNG_KERNEL_SYM_NAME_LEN + 32 -struct lttng_kernel_context { - enum lttng_kernel_context_type ctx; - char padding[LTTNG_KERNEL_CONTEXT_PADDING1]; - - union { - struct lttng_kernel_perf_counter_ctx perf_counter; - char padding[LTTNG_KERNEL_CONTEXT_PADDING2]; - } u; -} __attribute__((packed)); - -#define LTTNG_KERNEL_FILTER_BYTECODE_MAX_LEN 65536 -struct lttng_kernel_filter_bytecode { - uint32_t len; - uint32_t reloc_offset; - uint64_t seqnum; - char data[0]; -} __attribute__((packed)); - -enum lttng_kernel_tracker_type { - LTTNG_KERNEL_TRACKER_UNKNOWN = -1, - - LTTNG_KERNEL_TRACKER_PID = 0, - LTTNG_KERNEL_TRACKER_VPID = 1, - LTTNG_KERNEL_TRACKER_UID = 2, - LTTNG_KERNEL_TRACKER_VUID = 3, - LTTNG_KERNEL_TRACKER_GID = 4, - LTTNG_KERNEL_TRACKER_VGID = 5, -}; - -struct lttng_kernel_tracker_args { - enum lttng_kernel_tracker_type type; - int32_t id; -}; - -/* LTTng file descriptor ioctl */ -/* lttng-abi-old.h reserve 0x40, 0x41, 0x42, 0x43, and 0x44. */ -#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, 0x49, struct lttng_kernel_calibrate) -#define LTTNG_KERNEL_SYSCALL_LIST _IO(0xF6, 0x4A) -#define LTTNG_KERNEL_TRACER_ABI_VERSION \ - _IOR(0xF6, 0x4B, struct lttng_kernel_tracer_abi_version) - -/* Session FD ioctl */ -/* lttng-abi-old.h reserve 0x50, 0x51, 0x52, and 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) -#define LTTNG_KERNEL_SESSION_TRACK_PID \ - _IOR(0xF6, 0x58, int32_t) -#define LTTNG_KERNEL_SESSION_UNTRACK_PID \ - _IOR(0xF6, 0x59, int32_t) - -/* - * ioctl 0x58 and 0x59 are duplicated here. It works, since _IOR vs _IO - * are generating two different ioctl numbers, but this was not done on - * purpose. We should generally try to avoid those duplications. - */ -#define LTTNG_KERNEL_SESSION_LIST_TRACKER_PIDS _IO(0xF6, 0x58) -#define LTTNG_KERNEL_SESSION_METADATA_REGEN _IO(0xF6, 0x59) - -/* lttng-abi-old.h reserve 0x5A and 0x5B. */ -#define LTTNG_KERNEL_SESSION_STATEDUMP _IO(0xF6, 0x5C) -#define LTTNG_KERNEL_SESSION_SET_NAME \ - _IOR(0xF6, 0x5D, struct lttng_kernel_session_name) -#define LTTNG_KERNEL_SESSION_SET_CREATION_TIME \ - _IOR(0xF6, 0x5E, struct lttng_kernel_session_creation_time) - -/* Channel FD ioctl */ -/* lttng-abi-old.h reserve 0x60 and 0x61. */ -#define LTTNG_KERNEL_STREAM _IO(0xF6, 0x62) -#define LTTNG_KERNEL_EVENT \ - _IOW(0xF6, 0x63, struct lttng_kernel_event) -#define LTTNG_KERNEL_SYSCALL_MASK \ - _IOWR(0xF6, 0x64, struct lttng_kernel_syscall_mask) - -/* Event and Channel FD ioctl */ -/* lttng-abi-old.h reserve 0x70. */ -#define LTTNG_KERNEL_CONTEXT \ - _IOW(0xF6, 0x71, struct lttng_kernel_context) - -/* Event, Channel and Session ioctl */ -/* lttng-abi-old.h reserve 0x80 and 0x81. */ -#define LTTNG_KERNEL_ENABLE _IO(0xF6, 0x82) -#define LTTNG_KERNEL_DISABLE _IO(0xF6, 0x83) - -/* Event FD ioctl */ -#define LTTNG_KERNEL_FILTER _IO(0xF6, 0x90) -#define LTTNG_KERNEL_ADD_CALLSITE _IO(0xF6, 0x91) - -/* Session FD ioctl (continued) */ -#define LTTNG_KERNEL_SESSION_LIST_TRACKER_IDS \ - _IOR(0xF6, 0xA0, struct lttng_kernel_tracker_args) -#define LTTNG_KERNEL_SESSION_TRACK_ID \ - _IOR(0xF6, 0xA1, struct lttng_kernel_tracker_args) -#define LTTNG_KERNEL_SESSION_UNTRACK_ID \ - _IOR(0xF6, 0xA2, struct lttng_kernel_tracker_args) - -/* - * LTTng-specific ioctls for the lib ringbuffer. - * - * Operations applying to the current sub-buffer need to occur between - * a get/put or get_next/put_next ioctl pair. - */ - -/* returns the timestamp begin of the current sub-buffer */ -#define LTTNG_RING_BUFFER_GET_TIMESTAMP_BEGIN _IOR(0xF6, 0x20, uint64_t) -/* returns the timestamp end of the current sub-buffer */ -#define LTTNG_RING_BUFFER_GET_TIMESTAMP_END _IOR(0xF6, 0x21, uint64_t) -/* returns the number of events discarded of the current sub-buffer */ -#define LTTNG_RING_BUFFER_GET_EVENTS_DISCARDED _IOR(0xF6, 0x22, uint64_t) -/* returns the packet payload size of the current sub-buffer */ -#define LTTNG_RING_BUFFER_GET_CONTENT_SIZE _IOR(0xF6, 0x23, uint64_t) -/* returns the packet size of the current sub-buffer*/ -#define LTTNG_RING_BUFFER_GET_PACKET_SIZE _IOR(0xF6, 0x24, uint64_t) -/* returns the stream id (invariant for the stream) */ -#define LTTNG_RING_BUFFER_GET_STREAM_ID _IOR(0xF6, 0x25, uint64_t) -/* returns the current timestamp as perceived from the tracer */ -#define LTTNG_RING_BUFFER_GET_CURRENT_TIMESTAMP _IOR(0xF6, 0x26, uint64_t) -/* returns the packet sequence number of the current sub-buffer */ -#define LTTNG_RING_BUFFER_GET_SEQ_NUM _IOR(0xF6, 0x27, uint64_t) -/* returns the stream instance id (invariant for the stream) */ -#define LTTNG_RING_BUFFER_INSTANCE_ID _IOR(0xF6, 0x28, uint64_t) - -#ifdef CONFIG_COMPAT -/* returns the timestamp begin of the current sub-buffer */ -#define LTTNG_RING_BUFFER_COMPAT_GET_TIMESTAMP_BEGIN \ - LTTNG_RING_BUFFER_GET_TIMESTAMP_BEGIN -/* returns the timestamp end of the current sub-buffer */ -#define LTTNG_RING_BUFFER_COMPAT_GET_TIMESTAMP_END \ - LTTNG_RING_BUFFER_GET_TIMESTAMP_END -/* returns the number of events discarded of the current sub-buffer */ -#define LTTNG_RING_BUFFER_COMPAT_GET_EVENTS_DISCARDED \ - LTTNG_RING_BUFFER_GET_EVENTS_DISCARDED -/* returns the packet payload size of the current sub-buffer */ -#define LTTNG_RING_BUFFER_COMPAT_GET_CONTENT_SIZE \ - LTTNG_RING_BUFFER_GET_CONTENT_SIZE -/* returns the packet size of the current sub-buffer */ -#define LTTNG_RING_BUFFER_COMPAT_GET_PACKET_SIZE \ - LTTNG_RING_BUFFER_GET_PACKET_SIZE -/* returns the stream id (invariant for the stream) */ -#define LTTNG_RING_BUFFER_COMPAT_GET_STREAM_ID \ - LTTNG_RING_BUFFER_GET_STREAM_ID -/* returns the current timestamp as perceived from the tracer */ -#define LTTNG_RING_BUFFER_COMPAT_GET_CURRENT_TIMESTAMP \ - LTTNG_RING_BUFFER_GET_CURRENT_TIMESTAMP -/* returns the packet sequence number of the current sub-buffer */ -#define LTTNG_RING_BUFFER_COMPAT_GET_SEQ_NUM \ - LTTNG_RING_BUFFER_GET_SEQ_NUM -/* returns the stream instance id (invariant for the stream) */ -#define LTTNG_RING_BUFFER_COMPAT_INSTANCE_ID \ - LTTNG_RING_BUFFER_INSTANCE_ID -#endif /* CONFIG_COMPAT */ - -#endif /* _LTTNG_ABI_H */ diff --git a/lttng-calibrate.c b/lttng-calibrate.c index ef6c6121..d137f801 100644 --- a/lttng-calibrate.c +++ b/lttng-calibrate.c @@ -7,8 +7,8 @@ * Copyright (C) 2010-2012 Mathieu Desnoyers */ -#include -#include +#include +#include noinline void lttng_calibrate_kretprobe(void) diff --git a/lttng-clock.c b/lttng-clock.c index 1fe37b80..0d11e839 100644 --- a/lttng-clock.c +++ b/lttng-clock.c @@ -10,8 +10,8 @@ #include #include -#include -#include +#include +#include struct lttng_trace_clock *lttng_trace_clock; EXPORT_SYMBOL_GPL(lttng_trace_clock); diff --git a/lttng-clock.h b/lttng-clock.h deleted file mode 100644 index cac3c72e..00000000 --- a/lttng-clock.h +++ /dev/null @@ -1,28 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) - * - * lttng-clock.h - * - * Copyright (C) 2014 Mathieu Desnoyers - */ - -#ifndef _LTTNG_CLOCK_H -#define _LTTNG_CLOCK_H - -#include - -#define LTTNG_MODULES_UUID_STR_LEN 37 - -struct lttng_trace_clock { - u64 (*read64)(void); - u64 (*freq)(void); - int (*uuid)(char *uuid); - const char *(*name)(void); - const char *(*description)(void); -}; - -int lttng_clock_register_plugin(struct lttng_trace_clock *ltc, - struct module *mod); -void lttng_clock_unregister_plugin(struct lttng_trace_clock *ltc, - struct module *mod); - -#endif /* _LTTNG_TRACE_CLOCK_H */ diff --git a/lttng-context-callstack.c b/lttng-context-callstack.c index ec7bd62a..e747e19a 100644 --- a/lttng-context-callstack.c +++ b/lttng-context-callstack.c @@ -43,11 +43,11 @@ #include #include #include -#include "lttng-events.h" -#include "include/ringbuffer/backend.h" -#include "include/ringbuffer/frontend.h" -#include "lttng-tracer.h" -#include "lttng-endian.h" +#include +#include +#include +#include +#include #ifdef CONFIG_ARCH_STACKWALK #include "lttng-context-callstack-stackwalk-impl.h" diff --git a/lttng-context-cgroup-ns.c b/lttng-context-cgroup-ns.c index 1c0fc436..b2f20c4f 100644 --- a/lttng-context-cgroup-ns.c +++ b/lttng-context-cgroup-ns.c @@ -13,9 +13,9 @@ #include #include #include -#include -#include -#include +#include +#include +#include #if defined(CONFIG_CGROUPS) diff --git a/lttng-context-cpu-id.c b/lttng-context-cpu-id.c index dbd01234..ef4f912b 100644 --- a/lttng-context-cpu-id.c +++ b/lttng-context-cpu-id.c @@ -10,9 +10,9 @@ #include #include #include -#include -#include -#include +#include +#include +#include static size_t cpu_id_get_size(size_t offset) diff --git a/lttng-context-egid.c b/lttng-context-egid.c index 4921ff4a..e4b70816 100644 --- a/lttng-context-egid.c +++ b/lttng-context-egid.c @@ -11,9 +11,9 @@ #include #include -#include -#include -#include +#include +#include +#include #include static diff --git a/lttng-context-euid.c b/lttng-context-euid.c index 48df6e1c..fb13d027 100644 --- a/lttng-context-euid.c +++ b/lttng-context-euid.c @@ -11,9 +11,9 @@ #include #include -#include -#include -#include +#include +#include +#include #include static diff --git a/lttng-context-gid.c b/lttng-context-gid.c index 58859c23..d573082e 100644 --- a/lttng-context-gid.c +++ b/lttng-context-gid.c @@ -11,9 +11,9 @@ #include #include -#include -#include -#include +#include +#include +#include #include static diff --git a/lttng-context-hostname.c b/lttng-context-hostname.c index 5f31d513..94cb7e5e 100644 --- a/lttng-context-hostname.c +++ b/lttng-context-hostname.c @@ -11,9 +11,9 @@ #include #include #include -#include -#include -#include +#include +#include +#include #define LTTNG_HOSTNAME_CTX_LEN (__NEW_UTS_LEN + 1) diff --git a/lttng-context-interruptible.c b/lttng-context-interruptible.c index d354a088..3f80450b 100644 --- a/lttng-context-interruptible.c +++ b/lttng-context-interruptible.c @@ -11,9 +11,9 @@ #include #include #include -#include -#include -#include +#include +#include +#include /* * Interruptible at value -1 means "unknown". diff --git a/lttng-context-ipc-ns.c b/lttng-context-ipc-ns.c index e5e7d6ee..13470f50 100644 --- a/lttng-context-ipc-ns.c +++ b/lttng-context-ipc-ns.c @@ -13,9 +13,9 @@ #include #include #include -#include -#include -#include +#include +#include +#include #if defined(CONFIG_IPC_NS) diff --git a/lttng-context-migratable.c b/lttng-context-migratable.c index 607d6ef3..68983bcd 100644 --- a/lttng-context-migratable.c +++ b/lttng-context-migratable.c @@ -11,9 +11,9 @@ #include #include #include -#include -#include -#include +#include +#include +#include static size_t migratable_get_size(size_t offset) diff --git a/lttng-context-mnt-ns.c b/lttng-context-mnt-ns.c index 2ede85af..7a2e0605 100644 --- a/lttng-context-mnt-ns.c +++ b/lttng-context-mnt-ns.c @@ -12,10 +12,10 @@ #include #include #include -#include +#include #include -#include -#include +#include +#include #if !defined(LTTNG_MNT_NS_MISSING_HEADER) diff --git a/lttng-context-need-reschedule.c b/lttng-context-need-reschedule.c index 9bbb43ed..275b00d0 100644 --- a/lttng-context-need-reschedule.c +++ b/lttng-context-need-reschedule.c @@ -11,9 +11,9 @@ #include #include #include -#include -#include -#include +#include +#include +#include static size_t need_reschedule_get_size(size_t offset) diff --git a/lttng-context-net-ns.c b/lttng-context-net-ns.c index 79207301..490ea6f0 100644 --- a/lttng-context-net-ns.c +++ b/lttng-context-net-ns.c @@ -14,9 +14,9 @@ #include #include #include -#include -#include -#include +#include +#include +#include #if defined(CONFIG_NET_NS) diff --git a/lttng-context-nice.c b/lttng-context-nice.c index 0c7911c1..58a8d96e 100644 --- a/lttng-context-nice.c +++ b/lttng-context-nice.c @@ -10,9 +10,9 @@ #include #include #include -#include -#include -#include +#include +#include +#include static size_t nice_get_size(size_t offset) diff --git a/lttng-context-perf-counters.c b/lttng-context-perf-counters.c index 2365d03f..9fa6db50 100644 --- a/lttng-context-perf-counters.c +++ b/lttng-context-perf-counters.c @@ -14,9 +14,9 @@ #include #include #include -#include -#include -#include +#include +#include +#include static size_t perf_counter_get_size(size_t offset) diff --git a/lttng-context-pid-ns.c b/lttng-context-pid-ns.c index b22d4460..ae4def74 100644 --- a/lttng-context-pid-ns.c +++ b/lttng-context-pid-ns.c @@ -13,9 +13,9 @@ #include #include #include -#include -#include -#include +#include +#include +#include #if defined(CONFIG_PID_NS) diff --git a/lttng-context-pid.c b/lttng-context-pid.c index 3e88eb82..dc196ee1 100644 --- a/lttng-context-pid.c +++ b/lttng-context-pid.c @@ -10,9 +10,9 @@ #include #include #include -#include -#include -#include +#include +#include +#include static size_t pid_get_size(size_t offset) diff --git a/lttng-context-ppid.c b/lttng-context-ppid.c index 78d14c27..799246d7 100644 --- a/lttng-context-ppid.c +++ b/lttng-context-ppid.c @@ -11,9 +11,9 @@ #include #include #include -#include -#include -#include +#include +#include +#include static size_t ppid_get_size(size_t offset) diff --git a/lttng-context-preemptible.c b/lttng-context-preemptible.c index 336c582a..72e30eff 100644 --- a/lttng-context-preemptible.c +++ b/lttng-context-preemptible.c @@ -11,9 +11,9 @@ #include #include #include -#include -#include -#include +#include +#include +#include /* * We nest twice in preempt disabling within LTTng: one nesting is done diff --git a/lttng-context-prio.c b/lttng-context-prio.c index e23115ef..6050d475 100644 --- a/lttng-context-prio.c +++ b/lttng-context-prio.c @@ -10,9 +10,9 @@ #include #include #include -#include -#include -#include +#include +#include +#include static size_t prio_get_size(size_t offset) diff --git a/lttng-context-procname.c b/lttng-context-procname.c index dfd5ab9b..d950096a 100644 --- a/lttng-context-procname.c +++ b/lttng-context-procname.c @@ -10,10 +10,10 @@ #include #include #include -#include -#include -#include -#include +#include +#include +#include +#include static size_t procname_get_size(size_t offset) diff --git a/lttng-context-sgid.c b/lttng-context-sgid.c index 464dd911..8703f966 100644 --- a/lttng-context-sgid.c +++ b/lttng-context-sgid.c @@ -11,9 +11,9 @@ #include #include -#include -#include -#include +#include +#include +#include #include static diff --git a/lttng-context-suid.c b/lttng-context-suid.c index a7a1b22e..878eaec0 100644 --- a/lttng-context-suid.c +++ b/lttng-context-suid.c @@ -11,9 +11,9 @@ #include #include -#include -#include -#include +#include +#include +#include #include static diff --git a/lttng-context-tid.c b/lttng-context-tid.c index b08ffbfe..91ea655b 100644 --- a/lttng-context-tid.c +++ b/lttng-context-tid.c @@ -10,9 +10,9 @@ #include #include #include -#include -#include -#include +#include +#include +#include static size_t tid_get_size(size_t offset) diff --git a/lttng-context-uid.c b/lttng-context-uid.c index 43198184..4dd754d4 100644 --- a/lttng-context-uid.c +++ b/lttng-context-uid.c @@ -11,9 +11,9 @@ #include #include -#include -#include -#include +#include +#include +#include #include static diff --git a/lttng-context-user-ns.c b/lttng-context-user-ns.c index 1dc3f7eb..51cb6b52 100644 --- a/lttng-context-user-ns.c +++ b/lttng-context-user-ns.c @@ -13,9 +13,9 @@ #include #include #include -#include -#include -#include +#include +#include +#include #if defined(CONFIG_USER_NS) diff --git a/lttng-context-uts-ns.c b/lttng-context-uts-ns.c index 684c3216..7141f617 100644 --- a/lttng-context-uts-ns.c +++ b/lttng-context-uts-ns.c @@ -13,9 +13,9 @@ #include #include #include -#include -#include -#include +#include +#include +#include #if defined(CONFIG_UTS_NS) diff --git a/lttng-context-vegid.c b/lttng-context-vegid.c index fa707a41..d0db2f8c 100644 --- a/lttng-context-vegid.c +++ b/lttng-context-vegid.c @@ -11,9 +11,9 @@ #include #include -#include -#include -#include +#include +#include +#include #include static diff --git a/lttng-context-veuid.c b/lttng-context-veuid.c index 1db2283d..19d6e1bc 100644 --- a/lttng-context-veuid.c +++ b/lttng-context-veuid.c @@ -11,9 +11,9 @@ #include #include -#include -#include -#include +#include +#include +#include #include static diff --git a/lttng-context-vgid.c b/lttng-context-vgid.c index 7aacf5e4..ec5f9965 100644 --- a/lttng-context-vgid.c +++ b/lttng-context-vgid.c @@ -11,9 +11,9 @@ #include #include -#include -#include -#include +#include +#include +#include #include static diff --git a/lttng-context-vpid.c b/lttng-context-vpid.c index eb0bcbd9..8d9b33c1 100644 --- a/lttng-context-vpid.c +++ b/lttng-context-vpid.c @@ -10,9 +10,9 @@ #include #include #include -#include -#include -#include +#include +#include +#include static size_t vpid_get_size(size_t offset) diff --git a/lttng-context-vppid.c b/lttng-context-vppid.c index c370d372..c379b726 100644 --- a/lttng-context-vppid.c +++ b/lttng-context-vppid.c @@ -11,9 +11,9 @@ #include #include #include -#include -#include -#include +#include +#include +#include static size_t vppid_get_size(size_t offset) diff --git a/lttng-context-vsgid.c b/lttng-context-vsgid.c index c98a03a5..a2256249 100644 --- a/lttng-context-vsgid.c +++ b/lttng-context-vsgid.c @@ -11,9 +11,9 @@ #include #include -#include -#include -#include +#include +#include +#include #include static diff --git a/lttng-context-vsuid.c b/lttng-context-vsuid.c index e85a9170..1299b3d0 100644 --- a/lttng-context-vsuid.c +++ b/lttng-context-vsuid.c @@ -11,9 +11,9 @@ #include #include -#include -#include -#include +#include +#include +#include #include static diff --git a/lttng-context-vtid.c b/lttng-context-vtid.c index 7f482b07..6fd6bfc5 100644 --- a/lttng-context-vtid.c +++ b/lttng-context-vtid.c @@ -10,9 +10,9 @@ #include #include #include -#include -#include -#include +#include +#include +#include static size_t vtid_get_size(size_t offset) diff --git a/lttng-context-vuid.c b/lttng-context-vuid.c index 95360521..cd20606a 100644 --- a/lttng-context-vuid.c +++ b/lttng-context-vuid.c @@ -11,9 +11,9 @@ #include #include -#include -#include -#include +#include +#include +#include #include static diff --git a/lttng-context.c b/lttng-context.c index 9f841727..7c8f5d92 100644 --- a/lttng-context.c +++ b/lttng-context.c @@ -11,8 +11,8 @@ #include #include #include -#include -#include +#include +#include /* * The filter implementation requires that two consecutive "get" for the diff --git a/lttng-cpuhotplug.h b/lttng-cpuhotplug.h deleted file mode 100644 index 0de6f88f..00000000 --- a/lttng-cpuhotplug.h +++ /dev/null @@ -1,48 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) - * - * lttng-cpuhotplug.h - * - * Copyright (C) 2016 Mathieu Desnoyers - */ - -#ifndef LTTNG_CPUHOTPLUG_H -#define LTTNG_CPUHOTPLUG_H - -struct lttng_cpuhp_node; - -#include - -enum lttng_cpuhp_component { - LTTNG_RING_BUFFER_FRONTEND, - LTTNG_RING_BUFFER_BACKEND, - LTTNG_RING_BUFFER_ITER, - LTTNG_CONTEXT_PERF_COUNTERS, -}; - -struct lttng_cpuhp_node { - enum lttng_cpuhp_component component; - struct hlist_node node; -}; - -extern enum cpuhp_state lttng_hp_prepare; -extern enum cpuhp_state lttng_hp_online; - -int lttng_cpuhp_rb_backend_prepare(unsigned int cpu, - struct lttng_cpuhp_node *node); -int lttng_cpuhp_rb_frontend_dead(unsigned int cpu, - struct lttng_cpuhp_node *node); -int lttng_cpuhp_rb_frontend_online(unsigned int cpu, - struct lttng_cpuhp_node *node); -int lttng_cpuhp_rb_frontend_offline(unsigned int cpu, - struct lttng_cpuhp_node *node); -int lttng_cpuhp_rb_iter_online(unsigned int cpu, - struct lttng_cpuhp_node *node); - -/* Ring buffer is a separate library. */ -void lttng_rb_set_hp_prepare(enum cpuhp_state val); -void lttng_rb_set_hp_online(enum cpuhp_state val); - -extern enum cpuhp_state lttng_rb_hp_prepare; -extern enum cpuhp_state lttng_rb_hp_online; - -#endif /* LTTNG_CPUHOTPLUG_H */ diff --git a/lttng-endian.h b/lttng-endian.h deleted file mode 100644 index 12f55d17..00000000 --- a/lttng-endian.h +++ /dev/null @@ -1,30 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ -#ifndef _LTTNG_ENDIAN_H -#define _LTTNG_ENDIAN_H - -/* - * lttng-endian.h - * - * Copyright (C) 2010-2012 Mathieu Desnoyers - */ - -#ifdef __KERNEL__ -# include -# ifdef __BIG_ENDIAN -# define __BYTE_ORDER __BIG_ENDIAN -# elif defined(__LITTLE_ENDIAN) -# define __BYTE_ORDER __LITTLE_ENDIAN -# else -# error "unknown endianness" -# endif -#ifndef __BIG_ENDIAN -# define __BIG_ENDIAN 4321 -#endif -#ifndef __LITTLE_ENDIAN -# define __LITTLE_ENDIAN 1234 -#endif -#else -# include -#endif - -#endif /* _LTTNG_ENDIAN_H */ diff --git a/lttng-events.c b/lttng-events.c index 5ecdd732..fb45c612 100644 --- a/lttng-events.c +++ b/lttng-events.c @@ -25,15 +25,15 @@ #include #include -#include -#include -#include -#include -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include +#include +#include +#include +#include #define METADATA_CACHE_DEFAULT_SIZE 4096 diff --git a/lttng-events.h b/lttng-events.h deleted file mode 100644 index 69775307..00000000 --- a/lttng-events.h +++ /dev/null @@ -1,969 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) - * - * lttng-events.h - * - * Holds LTTng per-session event registry. - * - * Copyright (C) 2010-2012 Mathieu Desnoyers - */ - -#ifndef _LTTNG_EVENTS_H -#define _LTTNG_EVENTS_H - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#define lttng_is_signed_type(type) (((type)(-1)) < 0) - -struct lttng_channel; -struct lttng_session; -struct lttng_metadata_cache; -struct lib_ring_buffer_ctx; -struct perf_event; -struct perf_event_attr; -struct lib_ring_buffer_config; - -/* Type description */ - -enum abstract_types { - atype_integer, - atype_string, - atype_enum_nestable, - atype_array_nestable, - atype_sequence_nestable, - atype_struct_nestable, - atype_variant_nestable, - NR_ABSTRACT_TYPES, -}; - -enum lttng_string_encodings { - lttng_encode_none = 0, - lttng_encode_UTF8 = 1, - lttng_encode_ASCII = 2, - NR_STRING_ENCODINGS, -}; - -enum channel_type { - PER_CPU_CHANNEL, - METADATA_CHANNEL, -}; - -struct lttng_enum_value { - unsigned long long value; - unsigned int signedness:1; -}; - -struct lttng_enum_entry { - struct lttng_enum_value start, end; /* start and end are inclusive */ - const char *string; - struct { - unsigned int is_auto:1; - } options; -}; - -#define __type_integer(_type, _size, _alignment, _signedness, \ - _byte_order, _base, _encoding) \ - { \ - .atype = atype_integer, \ - .u.integer = \ - { \ - .size = (_size) ? : sizeof(_type) * CHAR_BIT, \ - .alignment = (_alignment) ? : lttng_alignof(_type) * CHAR_BIT, \ - .signedness = (_signedness) >= 0 ? (_signedness) : lttng_is_signed_type(_type), \ - .reverse_byte_order = _byte_order != __BYTE_ORDER, \ - .base = _base, \ - .encoding = lttng_encode_##_encoding, \ - }, \ - } \ - -struct lttng_integer_type { - unsigned int size; /* in bits */ - unsigned short alignment; /* in bits */ - unsigned int signedness:1, - reverse_byte_order:1; - unsigned int base; /* 2, 8, 10, 16, for pretty print */ - enum lttng_string_encodings encoding; -}; - -struct lttng_type { - enum abstract_types atype; - union { - struct lttng_integer_type integer; - struct { - enum lttng_string_encodings encoding; - } string; - struct { - const struct lttng_enum_desc *desc; /* Enumeration mapping */ - const struct lttng_type *container_type; - } enum_nestable; - struct { - const struct lttng_type *elem_type; - unsigned int length; /* Num. elems. */ - unsigned int alignment; - } array_nestable; - struct { - const char *length_name; /* Length field name. */ - const struct lttng_type *elem_type; - unsigned int alignment; /* Alignment before elements. */ - } sequence_nestable; - struct { - unsigned int nr_fields; - const struct lttng_event_field *fields; /* Array of fields. */ - unsigned int alignment; - } struct_nestable; - struct { - const char *tag_name; - const struct lttng_event_field *choices; /* Array of fields. */ - unsigned int nr_choices; - unsigned int alignment; - } variant_nestable; - } u; -}; - -struct lttng_enum_desc { - const char *name; - const struct lttng_enum_entry *entries; - unsigned int nr_entries; -}; - -/* Event field description */ - -struct lttng_event_field { - const char *name; - struct lttng_type type; - unsigned int nowrite:1, /* do not write into trace */ - user:1, /* fetch from user-space */ - nofilter:1; /* do not consider for filter */ -}; - -union lttng_ctx_value { - int64_t s64; - const char *str; - double d; -}; - -/* - * We need to keep this perf counter field separately from struct - * lttng_ctx_field because cpu hotplug needs fixed-location addresses. - */ -struct lttng_perf_counter_field { - struct lttng_cpuhp_node cpuhp_prepare; - struct lttng_cpuhp_node cpuhp_online; - struct perf_event_attr *attr; - struct perf_event **e; /* per-cpu array */ -}; - -struct lttng_probe_ctx { - struct lttng_event *event; - uint8_t interruptible; -}; - -struct lttng_ctx_field { - struct lttng_event_field event_field; - size_t (*get_size)(size_t offset); - size_t (*get_size_arg)(size_t offset, struct lttng_ctx_field *field, - struct lib_ring_buffer_ctx *ctx, - struct lttng_channel *chan); - void (*record)(struct lttng_ctx_field *field, - struct lib_ring_buffer_ctx *ctx, - struct lttng_channel *chan); - void (*get_value)(struct lttng_ctx_field *field, - struct lttng_probe_ctx *lttng_probe_ctx, - union lttng_ctx_value *value); - union { - struct lttng_perf_counter_field *perf_counter; - } u; - void (*destroy)(struct lttng_ctx_field *field); - /* - * Private data to keep state between get_size and record. - * User must perform its own synchronization to protect against - * concurrent and reentrant contexts. - */ - void *priv; -}; - -struct lttng_ctx { - struct lttng_ctx_field *fields; - unsigned int nr_fields; - unsigned int allocated_fields; - size_t largest_align; /* in bytes */ -}; - -struct lttng_event_desc { - const char *name; /* lttng-modules name */ - const char *kname; /* Linux kernel name (tracepoints) */ - void *probe_callback; - const struct lttng_event_ctx *ctx; /* context */ - const struct lttng_event_field *fields; /* event payload */ - unsigned int nr_fields; - struct module *owner; -}; - -struct lttng_probe_desc { - const char *provider; - const struct lttng_event_desc **event_desc; - unsigned int nr_events; - struct list_head head; /* chain registered probes */ - struct list_head lazy_init_head; - int lazy; /* lazy registration */ -}; - -struct lttng_krp; /* Kretprobe handling */ - -enum lttng_event_type { - LTTNG_TYPE_EVENT = 0, - LTTNG_TYPE_ENABLER = 1, -}; - -struct lttng_filter_bytecode_node { - struct list_head node; - struct lttng_enabler *enabler; - /* - * struct lttng_kernel_filter_bytecode has var. sized array, must be - * last field. - */ - struct lttng_kernel_filter_bytecode bc; -}; - -/* - * Filter return value masks. - */ -enum lttng_filter_ret { - LTTNG_FILTER_DISCARD = 0, - LTTNG_FILTER_RECORD_FLAG = (1ULL << 0), - /* Other bits are kept for future use. */ -}; - -struct lttng_bytecode_runtime { - /* Associated bytecode */ - struct lttng_filter_bytecode_node *bc; - uint64_t (*filter)(void *filter_data, struct lttng_probe_ctx *lttng_probe_ctx, - const char *filter_stack_data); - int link_failed; - struct list_head node; /* list of bytecode runtime in event */ - struct lttng_event *event; -}; - -/* - * Objects in a linked-list of enablers, owned by an event. - */ -struct lttng_enabler_ref { - struct list_head node; /* enabler ref list */ - struct lttng_enabler *ref; /* backward ref */ -}; - -struct lttng_uprobe_handler { - struct lttng_event *event; - loff_t offset; - struct uprobe_consumer up_consumer; - struct list_head node; -}; - -/* - * lttng_event structure is referred to by the tracing fast path. It must be - * kept small. - */ -struct lttng_event { - enum lttng_event_type evtype; /* First field. */ - unsigned int id; - struct lttng_channel *chan; - int enabled; - const struct lttng_event_desc *desc; - void *filter; - struct lttng_ctx *ctx; - enum lttng_kernel_instrumentation instrumentation; - union { - struct { - struct kprobe kp; - char *symbol_name; - } kprobe; - struct { - struct lttng_krp *lttng_krp; - char *symbol_name; - } kretprobe; - struct { - struct inode *inode; - struct list_head head; - } uprobe; - } u; - struct list_head list; /* Event list in session */ - unsigned int metadata_dumped:1; - - /* Backward references: list of lttng_enabler_ref (ref to enablers) */ - struct list_head enablers_ref_head; - struct hlist_node hlist; /* session ht of events */ - int registered; /* has reg'd tracepoint probe */ - /* list of struct lttng_bytecode_runtime, sorted by seqnum */ - struct list_head bytecode_runtime_head; - int has_enablers_without_bytecode; -}; - -enum lttng_enabler_type { - LTTNG_ENABLER_STAR_GLOB, - LTTNG_ENABLER_NAME, -}; - -/* - * Enabler field, within whatever object is enabling an event. Target of - * backward reference. - */ -struct lttng_enabler { - enum lttng_event_type evtype; /* First field. */ - - enum lttng_enabler_type type; - - struct list_head node; /* per-session list of enablers */ - /* head list of struct lttng_ust_filter_bytecode_node */ - struct list_head filter_bytecode_head; - - struct lttng_kernel_event event_param; - struct lttng_channel *chan; - struct lttng_ctx *ctx; - unsigned int enabled:1; -}; - -struct lttng_channel_ops { - struct channel *(*channel_create)(const char *name, - struct lttng_channel *lttng_chan, - void *buf_addr, - size_t subbuf_size, size_t num_subbuf, - unsigned int switch_timer_interval, - unsigned int read_timer_interval); - void (*channel_destroy)(struct channel *chan); - struct lib_ring_buffer *(*buffer_read_open)(struct channel *chan); - int (*buffer_has_read_closed_stream)(struct channel *chan); - void (*buffer_read_close)(struct lib_ring_buffer *buf); - int (*event_reserve)(struct lib_ring_buffer_ctx *ctx, - uint32_t event_id); - void (*event_commit)(struct lib_ring_buffer_ctx *ctx); - void (*event_write)(struct lib_ring_buffer_ctx *ctx, const void *src, - size_t len); - void (*event_write_from_user)(struct lib_ring_buffer_ctx *ctx, - const void *src, size_t len); - void (*event_memset)(struct lib_ring_buffer_ctx *ctx, - int c, size_t len); - void (*event_strcpy)(struct lib_ring_buffer_ctx *ctx, const char *src, - size_t len); - void (*event_strcpy_from_user)(struct lib_ring_buffer_ctx *ctx, - const char __user *src, size_t len); - /* - * packet_avail_size returns the available size in the current - * packet. Note that the size returned is only a hint, since it - * may change due to concurrent writes. - */ - size_t (*packet_avail_size)(struct channel *chan); - wait_queue_head_t *(*get_writer_buf_wait_queue)(struct channel *chan, int cpu); - wait_queue_head_t *(*get_hp_wait_queue)(struct channel *chan); - int (*is_finalized)(struct channel *chan); - int (*is_disabled)(struct channel *chan); - int (*timestamp_begin) (const struct lib_ring_buffer_config *config, - struct lib_ring_buffer *bufb, - uint64_t *timestamp_begin); - int (*timestamp_end) (const struct lib_ring_buffer_config *config, - struct lib_ring_buffer *bufb, - uint64_t *timestamp_end); - int (*events_discarded) (const struct lib_ring_buffer_config *config, - struct lib_ring_buffer *bufb, - uint64_t *events_discarded); - int (*content_size) (const struct lib_ring_buffer_config *config, - struct lib_ring_buffer *bufb, - uint64_t *content_size); - int (*packet_size) (const struct lib_ring_buffer_config *config, - struct lib_ring_buffer *bufb, - uint64_t *packet_size); - int (*stream_id) (const struct lib_ring_buffer_config *config, - struct lib_ring_buffer *bufb, - uint64_t *stream_id); - int (*current_timestamp) (const struct lib_ring_buffer_config *config, - struct lib_ring_buffer *bufb, - uint64_t *ts); - int (*sequence_number) (const struct lib_ring_buffer_config *config, - struct lib_ring_buffer *bufb, - uint64_t *seq); - int (*instance_id) (const struct lib_ring_buffer_config *config, - struct lib_ring_buffer *bufb, - uint64_t *id); -}; - -struct lttng_transport { - char *name; - struct module *owner; - struct list_head node; - struct lttng_channel_ops ops; -}; - -struct lttng_syscall_filter; - -#define LTTNG_EVENT_HT_BITS 12 -#define LTTNG_EVENT_HT_SIZE (1U << LTTNG_EVENT_HT_BITS) - -struct lttng_event_ht { - struct hlist_head table[LTTNG_EVENT_HT_SIZE]; -}; - -struct lttng_channel { - unsigned int id; - struct channel *chan; /* Channel buffers */ - int enabled; - struct lttng_ctx *ctx; - /* Event ID management */ - struct lttng_session *session; - struct file *file; /* File associated to channel */ - unsigned int free_event_id; /* Next event ID to allocate */ - struct list_head list; /* Channel list */ - struct lttng_channel_ops *ops; - struct lttng_transport *transport; - struct lttng_event **sc_table; /* for syscall tracing */ - struct lttng_event **compat_sc_table; - struct lttng_event **sc_exit_table; /* for syscall exit tracing */ - struct lttng_event **compat_sc_exit_table; - struct lttng_event *sc_unknown; /* for unknown syscalls */ - struct lttng_event *sc_compat_unknown; - struct lttng_event *sc_exit_unknown; - struct lttng_event *compat_sc_exit_unknown; - struct lttng_syscall_filter *sc_filter; - int header_type; /* 0: unset, 1: compact, 2: large */ - enum channel_type channel_type; - unsigned int metadata_dumped:1, - sys_enter_registered:1, - sys_exit_registered:1, - syscall_all:1, - tstate:1; /* Transient enable state */ -}; - -struct lttng_metadata_stream { - void *priv; /* Ring buffer private data */ - struct lttng_metadata_cache *metadata_cache; - unsigned int metadata_in; /* Bytes read from the cache */ - unsigned int metadata_out; /* Bytes consumed from stream */ - int finalized; /* Has channel been finalized */ - wait_queue_head_t read_wait; /* Reader buffer-level wait queue */ - struct list_head list; /* Stream list */ - struct lttng_transport *transport; - uint64_t version; /* Current version of the metadata cache */ -}; - -#define LTTNG_DYNAMIC_LEN_STACK_SIZE 128 - -struct lttng_dynamic_len_stack { - size_t stack[LTTNG_DYNAMIC_LEN_STACK_SIZE]; - size_t offset; -}; - -DECLARE_PER_CPU(struct lttng_dynamic_len_stack, lttng_dynamic_len_stack); - -/* - * struct lttng_id_tracker declared in header due to deferencing of *v - * in RCU_INITIALIZER(v). - */ -#define LTTNG_ID_HASH_BITS 6 -#define LTTNG_ID_TABLE_SIZE (1 << LTTNG_ID_HASH_BITS) - -enum tracker_type { - TRACKER_PID, - TRACKER_VPID, - TRACKER_UID, - TRACKER_VUID, - TRACKER_GID, - TRACKER_VGID, - - TRACKER_UNKNOWN, -}; - -struct lttng_id_tracker_rcu { - struct hlist_head id_hash[LTTNG_ID_TABLE_SIZE]; -}; - -struct lttng_id_tracker { - struct lttng_session *session; - enum tracker_type tracker_type; - struct lttng_id_tracker_rcu *p; /* RCU dereferenced. */ -}; - -struct lttng_id_hash_node { - struct hlist_node hlist; - int id; -}; - -struct lttng_session { - int active; /* Is trace session active ? */ - int been_active; /* Has trace session been active ? */ - struct file *file; /* File associated to session */ - struct list_head chan; /* Channel list head */ - struct list_head events; /* Event list head */ - struct list_head list; /* Session list */ - unsigned int free_chan_id; /* Next chan ID to allocate */ - uuid_le uuid; /* Trace session unique ID */ - struct lttng_metadata_cache *metadata_cache; - struct lttng_id_tracker pid_tracker; - struct lttng_id_tracker vpid_tracker; - struct lttng_id_tracker uid_tracker; - struct lttng_id_tracker vuid_tracker; - struct lttng_id_tracker gid_tracker; - struct lttng_id_tracker vgid_tracker; - unsigned int metadata_dumped:1, - tstate:1; /* Transient enable state */ - /* List of enablers */ - struct list_head enablers_head; - /* Hash table of events */ - struct lttng_event_ht events_ht; - char name[LTTNG_KERNEL_SESSION_NAME_LEN]; - char creation_time[LTTNG_KERNEL_SESSION_CREATION_TIME_ISO8601_LEN]; -}; - -struct lttng_metadata_cache { - char *data; /* Metadata cache */ - unsigned int cache_alloc; /* Metadata allocated size (bytes) */ - unsigned int metadata_written; /* Number of bytes written in metadata cache */ - struct kref refcount; /* Metadata cache usage */ - struct list_head metadata_stream; /* Metadata stream list */ - uuid_le uuid; /* Trace session unique ID (copy) */ - struct mutex lock; /* Produce/consume lock */ - uint64_t version; /* Current version of the metadata */ -}; - -void lttng_lock_sessions(void); -void lttng_unlock_sessions(void); - -struct list_head *lttng_get_probe_list_head(void); - -struct lttng_enabler *lttng_enabler_create(enum lttng_enabler_type type, - struct lttng_kernel_event *event_param, - struct lttng_channel *chan); - -int lttng_enabler_enable(struct lttng_enabler *enabler); -int lttng_enabler_disable(struct lttng_enabler *enabler); -int lttng_fix_pending_events(void); -int lttng_session_active(void); - -struct lttng_session *lttng_session_create(void); -int lttng_session_enable(struct lttng_session *session); -int lttng_session_disable(struct lttng_session *session); -void lttng_session_destroy(struct lttng_session *session); -int lttng_session_metadata_regenerate(struct lttng_session *session); -int lttng_session_statedump(struct lttng_session *session); -void metadata_cache_destroy(struct kref *kref); - -struct lttng_channel *lttng_channel_create(struct lttng_session *session, - const char *transport_name, - void *buf_addr, - size_t subbuf_size, size_t num_subbuf, - unsigned int switch_timer_interval, - unsigned int read_timer_interval, - enum channel_type channel_type); -struct lttng_channel *lttng_global_channel_create(struct lttng_session *session, - int overwrite, void *buf_addr, - size_t subbuf_size, size_t num_subbuf, - unsigned int switch_timer_interval, - unsigned int read_timer_interval); - -void lttng_metadata_channel_destroy(struct lttng_channel *chan); -struct lttng_event *lttng_event_create(struct lttng_channel *chan, - struct lttng_kernel_event *event_param, - void *filter, - const struct lttng_event_desc *event_desc, - enum lttng_kernel_instrumentation itype); -struct lttng_event *_lttng_event_create(struct lttng_channel *chan, - struct lttng_kernel_event *event_param, - void *filter, - const struct lttng_event_desc *event_desc, - enum lttng_kernel_instrumentation itype); -struct lttng_event *lttng_event_compat_old_create(struct lttng_channel *chan, - struct lttng_kernel_old_event *old_event_param, - void *filter, - const struct lttng_event_desc *internal_desc); - -int lttng_channel_enable(struct lttng_channel *channel); -int lttng_channel_disable(struct lttng_channel *channel); -int lttng_event_enable(struct lttng_event *event); -int lttng_event_disable(struct lttng_event *event); - -void lttng_transport_register(struct lttng_transport *transport); -void lttng_transport_unregister(struct lttng_transport *transport); - -void synchronize_trace(void); -int lttng_abi_init(void); -int lttng_abi_compat_old_init(void); -void lttng_abi_exit(void); -void lttng_abi_compat_old_exit(void); - -int lttng_probe_register(struct lttng_probe_desc *desc); -void lttng_probe_unregister(struct lttng_probe_desc *desc); -const struct lttng_event_desc *lttng_event_get(const char *name); -void lttng_event_put(const struct lttng_event_desc *desc); -int lttng_probes_init(void); -void lttng_probes_exit(void); - -int lttng_metadata_output_channel(struct lttng_metadata_stream *stream, - struct channel *chan); - -int lttng_id_tracker_get_node_id(const struct lttng_id_hash_node *node); -int lttng_id_tracker_empty_set(struct lttng_id_tracker *lf); -void lttng_id_tracker_destroy(struct lttng_id_tracker *lf, bool rcu); -bool lttng_id_tracker_lookup(struct lttng_id_tracker_rcu *p, int id); -int lttng_id_tracker_add(struct lttng_id_tracker *lf, int id); -int lttng_id_tracker_del(struct lttng_id_tracker *lf, int id); - -int lttng_session_track_id(struct lttng_session *session, - enum tracker_type tracker_type, int id); -int lttng_session_untrack_id(struct lttng_session *session, - enum tracker_type tracker_type, int id); - -int lttng_session_list_tracker_ids(struct lttng_session *session, - enum tracker_type tracker_type); - -void lttng_clock_ref(void); -void lttng_clock_unref(void); - -#if defined(CONFIG_HAVE_SYSCALL_TRACEPOINTS) -int lttng_syscalls_register(struct lttng_channel *chan, void *filter); -int lttng_syscalls_unregister(struct lttng_channel *chan); -int lttng_syscall_filter_enable(struct lttng_channel *chan, - const char *name); -int lttng_syscall_filter_disable(struct lttng_channel *chan, - const char *name); -long lttng_channel_syscall_mask(struct lttng_channel *channel, - struct lttng_kernel_syscall_mask __user *usyscall_mask); -#else -static inline int lttng_syscalls_register(struct lttng_channel *chan, void *filter) -{ - return -ENOSYS; -} - -static inline int lttng_syscalls_unregister(struct lttng_channel *chan) -{ - return 0; -} - -static inline int lttng_syscall_filter_enable(struct lttng_channel *chan, - const char *name) -{ - return -ENOSYS; -} - -static inline int lttng_syscall_filter_disable(struct lttng_channel *chan, - const char *name) -{ - return -ENOSYS; -} - -static inline long lttng_channel_syscall_mask(struct lttng_channel *channel, - struct lttng_kernel_syscall_mask __user *usyscall_mask) -{ - return -ENOSYS; -} -#endif - -void lttng_filter_sync_state(struct lttng_bytecode_runtime *runtime); -int lttng_enabler_attach_bytecode(struct lttng_enabler *enabler, - struct lttng_kernel_filter_bytecode __user *bytecode); -void lttng_enabler_event_link_bytecode(struct lttng_event *event, - struct lttng_enabler *enabler); - -int lttng_probes_init(void); - -extern struct lttng_ctx *lttng_static_ctx; - -int lttng_context_init(void); -void lttng_context_exit(void); -struct lttng_ctx_field *lttng_append_context(struct lttng_ctx **ctx); -void lttng_context_update(struct lttng_ctx *ctx); -int lttng_find_context(struct lttng_ctx *ctx, const char *name); -int lttng_get_context_index(struct lttng_ctx *ctx, const char *name); -void lttng_remove_context_field(struct lttng_ctx **ctx, - struct lttng_ctx_field *field); -void lttng_destroy_context(struct lttng_ctx *ctx); -int lttng_add_pid_to_ctx(struct lttng_ctx **ctx); -int lttng_add_cpu_id_to_ctx(struct lttng_ctx **ctx); -int lttng_add_procname_to_ctx(struct lttng_ctx **ctx); -int lttng_add_prio_to_ctx(struct lttng_ctx **ctx); -int lttng_add_nice_to_ctx(struct lttng_ctx **ctx); -int lttng_add_vpid_to_ctx(struct lttng_ctx **ctx); -int lttng_add_tid_to_ctx(struct lttng_ctx **ctx); -int lttng_add_vtid_to_ctx(struct lttng_ctx **ctx); -int lttng_add_ppid_to_ctx(struct lttng_ctx **ctx); -int lttng_add_vppid_to_ctx(struct lttng_ctx **ctx); -int lttng_add_hostname_to_ctx(struct lttng_ctx **ctx); -int lttng_add_interruptible_to_ctx(struct lttng_ctx **ctx); -int lttng_add_need_reschedule_to_ctx(struct lttng_ctx **ctx); -#if defined(CONFIG_PREEMPT_RT_FULL) || defined(CONFIG_PREEMPT) -int lttng_add_preemptible_to_ctx(struct lttng_ctx **ctx); -#else -static inline -int lttng_add_preemptible_to_ctx(struct lttng_ctx **ctx) -{ - return -ENOSYS; -} -#endif -#ifdef CONFIG_PREEMPT_RT_FULL -int lttng_add_migratable_to_ctx(struct lttng_ctx **ctx); -#else -static inline -int lttng_add_migratable_to_ctx(struct lttng_ctx **ctx) -{ - return -ENOSYS; -} -#endif - -int lttng_add_callstack_to_ctx(struct lttng_ctx **ctx, int type); - -#if defined(CONFIG_CGROUPS) -int lttng_add_cgroup_ns_to_ctx(struct lttng_ctx **ctx); -#else -static inline -int lttng_add_cgroup_ns_to_ctx(struct lttng_ctx **ctx) -{ - return -ENOSYS; -} -#endif - -#if defined(CONFIG_IPC_NS) -int lttng_add_ipc_ns_to_ctx(struct lttng_ctx **ctx); -#else -static inline -int lttng_add_ipc_ns_to_ctx(struct lttng_ctx **ctx) -{ - return -ENOSYS; -} -#endif - -#if !defined(LTTNG_MNT_NS_MISSING_HEADER) -int lttng_add_mnt_ns_to_ctx(struct lttng_ctx **ctx); -#else -static inline -int lttng_add_mnt_ns_to_ctx(struct lttng_ctx **ctx) -{ - return -ENOSYS; -} -#endif - -#if defined(CONFIG_NET_NS) -int lttng_add_net_ns_to_ctx(struct lttng_ctx **ctx); -#else -static inline -int lttng_add_net_ns_to_ctx(struct lttng_ctx **ctx) -{ - return -ENOSYS; -} -#endif - -#if defined(CONFIG_PID_NS) -int lttng_add_pid_ns_to_ctx(struct lttng_ctx **ctx); -#else -static inline -int lttng_add_pid_ns_to_ctx(struct lttng_ctx **ctx) -{ - return -ENOSYS; -} -#endif - -#if defined(CONFIG_USER_NS) -int lttng_add_user_ns_to_ctx(struct lttng_ctx **ctx); -#else -static inline -int lttng_add_user_ns_to_ctx(struct lttng_ctx **ctx) -{ - return -ENOSYS; -} -#endif - -#if defined(CONFIG_UTS_NS) -int lttng_add_uts_ns_to_ctx(struct lttng_ctx **ctx); -#else -static inline -int lttng_add_uts_ns_to_ctx(struct lttng_ctx **ctx) -{ - return -ENOSYS; -} -#endif - -int lttng_add_uid_to_ctx(struct lttng_ctx **ctx); -int lttng_add_euid_to_ctx(struct lttng_ctx **ctx); -int lttng_add_suid_to_ctx(struct lttng_ctx **ctx); -int lttng_add_gid_to_ctx(struct lttng_ctx **ctx); -int lttng_add_egid_to_ctx(struct lttng_ctx **ctx); -int lttng_add_sgid_to_ctx(struct lttng_ctx **ctx); -int lttng_add_vuid_to_ctx(struct lttng_ctx **ctx); -int lttng_add_veuid_to_ctx(struct lttng_ctx **ctx); -int lttng_add_vsuid_to_ctx(struct lttng_ctx **ctx); -int lttng_add_vgid_to_ctx(struct lttng_ctx **ctx); -int lttng_add_vegid_to_ctx(struct lttng_ctx **ctx); -int lttng_add_vsgid_to_ctx(struct lttng_ctx **ctx); - -#if defined(CONFIG_PERF_EVENTS) -int lttng_add_perf_counter_to_ctx(uint32_t type, - uint64_t config, - const char *name, - struct lttng_ctx **ctx); -int lttng_cpuhp_perf_counter_online(unsigned int cpu, - struct lttng_cpuhp_node *node); -int lttng_cpuhp_perf_counter_dead(unsigned int cpu, - struct lttng_cpuhp_node *node); -#else -static inline -int lttng_add_perf_counter_to_ctx(uint32_t type, - uint64_t config, - const char *name, - struct lttng_ctx **ctx) -{ - return -ENOSYS; -} -static inline -int lttng_cpuhp_perf_counter_online(unsigned int cpu, - struct lttng_cpuhp_node *node) -{ - return 0; -} -static inline -int lttng_cpuhp_perf_counter_dead(unsigned int cpu, - struct lttng_cpuhp_node *node) -{ - return 0; -} -#endif - -int lttng_logger_init(void); -void lttng_logger_exit(void); - -extern int lttng_statedump_start(struct lttng_session *session); - -#ifdef CONFIG_KPROBES -int lttng_kprobes_register(const char *name, - const char *symbol_name, - uint64_t offset, - uint64_t addr, - struct lttng_event *event); -void lttng_kprobes_unregister(struct lttng_event *event); -void lttng_kprobes_destroy_private(struct lttng_event *event); -#else -static inline -int lttng_kprobes_register(const char *name, - const char *symbol_name, - uint64_t offset, - uint64_t addr, - struct lttng_event *event) -{ - return -ENOSYS; -} - -static inline -void lttng_kprobes_unregister(struct lttng_event *event) -{ -} - -static inline -void lttng_kprobes_destroy_private(struct lttng_event *event) -{ -} -#endif - -int lttng_event_add_callsite(struct lttng_event *event, - struct lttng_kernel_event_callsite *callsite); - -#ifdef CONFIG_UPROBES -int lttng_uprobes_register(const char *name, - int fd, struct lttng_event *event); -int lttng_uprobes_add_callsite(struct lttng_event *event, - struct lttng_kernel_event_callsite *callsite); -void lttng_uprobes_unregister(struct lttng_event *event); -void lttng_uprobes_destroy_private(struct lttng_event *event); -#else -static inline -int lttng_uprobes_register(const char *name, - int fd, struct lttng_event *event) -{ - return -ENOSYS; -} - -static inline -int lttng_uprobes_add_callsite(struct lttng_event *event, - struct lttng_kernel_event_callsite *callsite) -{ - return -ENOSYS; -} - -static inline -void lttng_uprobes_unregister(struct lttng_event *event) -{ -} - -static inline -void lttng_uprobes_destroy_private(struct lttng_event *event) -{ -} -#endif - -#ifdef CONFIG_KRETPROBES -int lttng_kretprobes_register(const char *name, - const char *symbol_name, - uint64_t offset, - uint64_t addr, - struct lttng_event *event_entry, - struct lttng_event *event_exit); -void lttng_kretprobes_unregister(struct lttng_event *event); -void lttng_kretprobes_destroy_private(struct lttng_event *event); -int lttng_kretprobes_event_enable_state(struct lttng_event *event, - int enable); -#else -static inline -int lttng_kretprobes_register(const char *name, - const char *symbol_name, - uint64_t offset, - uint64_t addr, - struct lttng_event *event_entry, - struct lttng_event *event_exit) -{ - return -ENOSYS; -} - -static inline -void lttng_kretprobes_unregister(struct lttng_event *event) -{ -} - -static inline -void lttng_kretprobes_destroy_private(struct lttng_event *event) -{ -} - -static inline -int lttng_kretprobes_event_enable_state(struct lttng_event *event, - int enable) -{ - return -ENOSYS; -} -#endif - -int lttng_calibrate(struct lttng_kernel_calibrate *calibrate); - -extern const struct file_operations lttng_tracepoint_list_fops; -extern const struct file_operations lttng_syscall_list_fops; - -#define TRACEPOINT_HAS_DATA_ARG - -static inline bool lttng_is_bytewise_integer(const struct lttng_type *type) -{ - if (type->atype != atype_integer) - return false; - switch (type->u.integer.size) { - case 8: /* Fall-through. */ - case 16: /* Fall-through. */ - case 32: /* Fall-through. */ - case 64: - break; - default: - return false; - } - return true; -} - -#endif /* _LTTNG_EVENTS_H */ diff --git a/lttng-filter-interpreter.c b/lttng-filter-interpreter.c index 671f8b8a..15f4747d 100644 --- a/lttng-filter-interpreter.c +++ b/lttng-filter-interpreter.c @@ -12,8 +12,8 @@ #include #include -#include -#include +#include +#include STACK_FRAME_NON_STANDARD(lttng_filter_interpret_bytecode); diff --git a/lttng-filter-specialize.c b/lttng-filter-specialize.c index 3dc82d84..02aef150 100644 --- a/lttng-filter-specialize.c +++ b/lttng-filter-specialize.c @@ -8,8 +8,8 @@ */ #include -#include -#include "lib/align.h" +#include +#include static ssize_t bytecode_reserve_data(struct bytecode_runtime *runtime, size_t align, size_t len) diff --git a/lttng-filter-validator.c b/lttng-filter-validator.c index c9094547..e27f6b91 100644 --- a/lttng-filter-validator.c +++ b/lttng-filter-validator.c @@ -11,7 +11,7 @@ #include #include -#include +#include #define MERGE_POINT_TABLE_BITS 7 #define MERGE_POINT_TABLE_SIZE (1U << MERGE_POINT_TABLE_BITS) diff --git a/lttng-filter.c b/lttng-filter.c index 45319d6f..71479336 100644 --- a/lttng-filter.c +++ b/lttng-filter.c @@ -10,7 +10,7 @@ #include #include -#include +#include static const char *opnames[] = { [ FILTER_OP_UNKNOWN ] = "UNKNOWN", diff --git a/lttng-filter.h b/lttng-filter.h deleted file mode 100644 index fec2db1f..00000000 --- a/lttng-filter.h +++ /dev/null @@ -1,248 +0,0 @@ -/* SPDX-License-Identifier: MIT - * - * lttng-filter.h - * - * LTTng modules filter header. - * - * Copyright (C) 2010-2016 Mathieu Desnoyers - */ - -#ifndef _LTTNG_FILTER_H -#define _LTTNG_FILTER_H - -#include - -#include -#include - -/* Filter stack length, in number of entries */ -#define FILTER_STACK_LEN 10 /* includes 2 dummy */ -#define FILTER_STACK_EMPTY 1 - -#define FILTER_MAX_DATA_LEN 65536 - -#ifdef DEBUG -#define dbg_printk(fmt, args...) \ - printk(KERN_DEBUG "[debug bytecode in %s:%s@%u] " fmt, \ - __FILE__, __func__, __LINE__, ## args) -#else -#define dbg_printk(fmt, args...) \ -do { \ - /* do nothing but check printf format */ \ - if (0) \ - printk(KERN_DEBUG "[debug bytecode in %s:%s@%u] " fmt, \ - __FILE__, __func__, __LINE__, ## args); \ -} while (0) -#endif - -/* Linked bytecode. Child of struct lttng_bytecode_runtime. */ -struct bytecode_runtime { - struct lttng_bytecode_runtime p; - size_t data_len; - size_t data_alloc_len; - char *data; - uint16_t len; - char code[0]; -}; - -enum entry_type { - REG_S64, - REG_DOUBLE, - REG_STRING, - REG_STAR_GLOB_STRING, - REG_TYPE_UNKNOWN, - REG_PTR, -}; - -enum load_type { - LOAD_ROOT_CONTEXT, - LOAD_ROOT_APP_CONTEXT, - LOAD_ROOT_PAYLOAD, - LOAD_OBJECT, -}; - -enum object_type { - OBJECT_TYPE_S8, - OBJECT_TYPE_S16, - OBJECT_TYPE_S32, - OBJECT_TYPE_S64, - OBJECT_TYPE_U8, - OBJECT_TYPE_U16, - OBJECT_TYPE_U32, - OBJECT_TYPE_U64, - - OBJECT_TYPE_DOUBLE, - OBJECT_TYPE_STRING, - OBJECT_TYPE_STRING_SEQUENCE, - - OBJECT_TYPE_SEQUENCE, - OBJECT_TYPE_ARRAY, - OBJECT_TYPE_STRUCT, - OBJECT_TYPE_VARIANT, - - OBJECT_TYPE_DYNAMIC, -}; - -struct filter_get_index_data { - uint64_t offset; /* in bytes */ - size_t ctx_index; - size_t array_len; - struct { - size_t len; - enum object_type type; - bool rev_bo; /* reverse byte order */ - } elem; -}; - -/* Validation stack */ -struct vstack_load { - enum load_type type; - enum object_type object_type; - const struct lttng_event_field *field; - bool rev_bo; /* reverse byte order */ -}; - -struct vstack_entry { - enum entry_type type; - struct vstack_load load; -}; - -struct vstack { - int top; /* top of stack */ - struct vstack_entry e[FILTER_STACK_LEN]; -}; - -static inline -void vstack_init(struct vstack *stack) -{ - stack->top = -1; -} - -static inline -struct vstack_entry *vstack_ax(struct vstack *stack) -{ - if (unlikely(stack->top < 0)) - return NULL; - return &stack->e[stack->top]; -} - -static inline -struct vstack_entry *vstack_bx(struct vstack *stack) -{ - if (unlikely(stack->top < 1)) - return NULL; - return &stack->e[stack->top - 1]; -} - -static inline -int vstack_push(struct vstack *stack) -{ - if (stack->top >= FILTER_STACK_LEN - 1) { - printk(KERN_WARNING "Stack full\n"); - return -EINVAL; - } - ++stack->top; - return 0; -} - -static inline -int vstack_pop(struct vstack *stack) -{ - if (unlikely(stack->top < 0)) { - printk(KERN_WARNING "Stack empty\n"); - return -EINVAL; - } - stack->top--; - return 0; -} - -/* Execution stack */ -enum estack_string_literal_type { - ESTACK_STRING_LITERAL_TYPE_NONE, - ESTACK_STRING_LITERAL_TYPE_PLAIN, - ESTACK_STRING_LITERAL_TYPE_STAR_GLOB, -}; - -struct load_ptr { - enum load_type type; - enum object_type object_type; - const void *ptr; - bool rev_bo; - /* Temporary place-holders for contexts. */ - union { - int64_t s64; - uint64_t u64; - double d; - } u; - /* - * "field" is only needed when nested under a variant, in which - * case we cannot specialize the nested operations. - */ - const struct lttng_event_field *field; -}; - -struct estack_entry { - union { - int64_t v; - - struct { - const char *str; - const char __user *user_str; - size_t seq_len; - enum estack_string_literal_type literal_type; - int user; /* is string from userspace ? */ - } s; - struct load_ptr ptr; - } u; -}; - -struct estack { - int top; /* top of stack */ - struct estack_entry e[FILTER_STACK_LEN]; -}; - -#define estack_ax_v ax -#define estack_bx_v bx - -#define estack_ax(stack, top) \ - ({ \ - BUG_ON((top) <= FILTER_STACK_EMPTY); \ - &(stack)->e[top]; \ - }) - -#define estack_bx(stack, top) \ - ({ \ - BUG_ON((top) <= FILTER_STACK_EMPTY + 1); \ - &(stack)->e[(top) - 1]; \ - }) - -#define estack_push(stack, top, ax, bx) \ - do { \ - BUG_ON((top) >= FILTER_STACK_LEN - 1); \ - (stack)->e[(top) - 1].u.v = (bx); \ - (bx) = (ax); \ - ++(top); \ - } while (0) - -#define estack_pop(stack, top, ax, bx) \ - do { \ - BUG_ON((top) <= FILTER_STACK_EMPTY); \ - (ax) = (bx); \ - (bx) = (stack)->e[(top) - 2].u.v; \ - (top)--; \ - } while (0) - -const char *lttng_filter_print_op(enum filter_op op); - -int lttng_filter_validate_bytecode(struct bytecode_runtime *bytecode); -int lttng_filter_specialize_bytecode(struct lttng_event *event, - struct bytecode_runtime *bytecode); - -uint64_t lttng_filter_false(void *filter_data, - struct lttng_probe_ctx *lttng_probe_ctx, - const char *filter_stack_data); -uint64_t lttng_filter_interpret_bytecode(void *filter_data, - struct lttng_probe_ctx *lttng_probe_ctx, - const char *filter_stack_data); - -#endif /* _LTTNG_FILTER_H */ diff --git a/lttng-kernel-version.h b/lttng-kernel-version.h deleted file mode 100644 index cb96a325..00000000 --- a/lttng-kernel-version.h +++ /dev/null @@ -1,138 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) - * - * lttng-kernel-version.h - * - * Contains helpers to check more complex kernel version conditions. - * - * Copyright (C) 2012 Mathieu Desnoyers - */ - -#ifndef _LTTNG_KERNEL_VERSION_H -#define _LTTNG_KERNEL_VERSION_H - -#include -#include - -/* - * This macro checks if the kernel version is between the two specified - * versions (lower limit inclusive, upper limit exclusive). - */ -#define LTTNG_KERNEL_RANGE(a_low, b_low, c_low, a_high, b_high, c_high) \ - (LINUX_VERSION_CODE >= KERNEL_VERSION(a_low, b_low, c_low) && \ - LINUX_VERSION_CODE < KERNEL_VERSION(a_high, b_high, c_high)) - -/* Ubuntu */ - -#define LTTNG_UBUNTU_KERNEL_VERSION(a, b, c, d) \ - (((a) << 24) + ((b) << 16) + ((c) << 8) + (d)) - -#ifdef UTS_UBUNTU_RELEASE_ABI -#define LTTNG_UBUNTU_VERSION_CODE \ - ((LINUX_VERSION_CODE << 8) + UTS_UBUNTU_RELEASE_ABI) -#else -#define LTTNG_UBUNTU_VERSION_CODE 0 -#endif - -#define LTTNG_UBUNTU_KERNEL_RANGE(a_low, b_low, c_low, d_low, \ - a_high, b_high, c_high, d_high) \ - (LTTNG_UBUNTU_VERSION_CODE >= \ - LTTNG_UBUNTU_KERNEL_VERSION(a_low, b_low, c_low, d_low) && \ - LTTNG_UBUNTU_VERSION_CODE < \ - LTTNG_UBUNTU_KERNEL_VERSION(a_high, b_high, c_high, d_high)) - -/* Debian */ - -#define LTTNG_DEBIAN_KERNEL_VERSION(a, b, c, d, e, f) \ - (((((a) << 16) + ((b) << 8) + (c)) * 1000000ULL) + ((d) * 10000) + ((e) * 100) + (f)) - -#ifdef DEBIAN_API_VERSION -#define LTTNG_DEBIAN_VERSION_CODE \ - ((LINUX_VERSION_CODE * 1000000ULL) + DEBIAN_API_VERSION) -#else -#define LTTNG_DEBIAN_VERSION_CODE 0 -#endif - -#define LTTNG_DEBIAN_KERNEL_RANGE(a_low, b_low, c_low, d_low, e_low, f_low, \ - a_high, b_high, c_high, d_high, e_high, f_high) \ - (LTTNG_DEBIAN_VERSION_CODE >= \ - LTTNG_DEBIAN_KERNEL_VERSION(a_low, b_low, c_low, d_low, e_low, f_low) && \ - LTTNG_DEBIAN_VERSION_CODE < \ - LTTNG_DEBIAN_KERNEL_VERSION(a_high, b_high, c_high, d_high, e_high, f_high)) - -#define LTTNG_RHEL_KERNEL_VERSION(a, b, c, d, e, f) \ - (((((a) << 16) + ((b) << 8) + (c)) * 10000000ULL) + ((d) * 10000) + ((e) * 100) + (f)) - -/* RHEL */ - -#ifdef RHEL_API_VERSION -#define LTTNG_RHEL_VERSION_CODE \ - ((LINUX_VERSION_CODE * 10000000ULL) + RHEL_API_VERSION) -#else -#define LTTNG_RHEL_VERSION_CODE 0 -#endif - -#define LTTNG_RHEL_KERNEL_RANGE(a_low, b_low, c_low, d_low, e_low, f_low, \ - a_high, b_high, c_high, d_high, e_high, f_high) \ - (LTTNG_RHEL_VERSION_CODE >= \ - LTTNG_RHEL_KERNEL_VERSION(a_low, b_low, c_low, d_low, e_low, f_low) && \ - LTTNG_RHEL_VERSION_CODE < \ - LTTNG_RHEL_KERNEL_VERSION(a_high, b_high, c_high, d_high, e_high, f_high)) - -/* SUSE Linux enterprise */ - -#define LTTNG_SLE_KERNEL_VERSION(a, b, c, d, e, f) \ - (((((a) << 16) + ((b) << 8) + (c)) * 10000000ULL) + ((d) * 10000) + ((e) * 100) + (f)) - -#ifdef SLE_API_VERSION -#define LTTNG_SLE_VERSION_CODE \ - ((LINUX_VERSION_CODE * 10000000ULL) + SLE_API_VERSION) -#else -#define LTTNG_SLE_VERSION_CODE 0 -#endif - -#define LTTNG_SLE_KERNEL_RANGE(a_low, b_low, c_low, d_low, e_low, f_low, \ - a_high, b_high, c_high, d_high, e_high, f_high) \ - (LTTNG_SLE_VERSION_CODE >= \ - LTTNG_SLE_KERNEL_VERSION(a_low, b_low, c_low, d_low, e_low, f_low) && \ - LTTNG_SLE_VERSION_CODE < \ - LTTNG_SLE_KERNEL_VERSION(a_high, b_high, c_high, d_high, e_high, f_high)) - -/* Fedora */ - -#define LTTNG_FEDORA_KERNEL_VERSION(a, b, c, d) \ - (((((a) << 16) + ((b) << 8) + (c)) * 10000ULL) + (d)) - -#ifdef FEDORA_REVISION_VERSION -#define LTTNG_FEDORA_VERSION_CODE \ - ((LINUX_VERSION_CODE * 10000ULL) + FEDORA_REVISION_VERSION) -#else -#define LTTNG_FEDORA_VERSION_CODE 0 -#endif - -#define LTTNG_FEDORA_KERNEL_RANGE(a_low, b_low, c_low, d_low, \ - a_high, b_high, c_high, d_high) \ - (LTTNG_FEDORA_VERSION_CODE >= \ - LTTNG_FEDORA_KERNEL_VERSION(a_low, b_low, c_low, d_low) && \ - LTTNG_FEDORA_VERSION_CODE < \ - LTTNG_FEDORA_KERNEL_VERSION(a_high, b_high, c_high, d_high)) - -/* RT patch */ - -#define LTTNG_RT_KERNEL_VERSION(a, b, c, d) \ - (((a) << 24) + ((b) << 16) + ((c) << 8) + (d)) - -#ifdef RT_PATCH_VERSION -#define LTTNG_RT_VERSION_CODE \ - ((LINUX_VERSION_CODE << 8) + RT_PATCH_VERSION) -#else -#define LTTNG_RT_VERSION_CODE 0 -#endif - -#define LTTNG_RT_KERNEL_RANGE(a_low, b_low, c_low, d_low, \ - a_high, b_high, c_high, d_high) \ - (LTTNG_RT_VERSION_CODE >= \ - LTTNG_RT_KERNEL_VERSION(a_low, b_low, c_low, d_low) && \ - LTTNG_RT_VERSION_CODE < \ - LTTNG_RT_KERNEL_VERSION(a_high, b_high, c_high, d_high)) - -#endif /* _LTTNG_KERNEL_VERSION_H */ diff --git a/lttng-probes.c b/lttng-probes.c index bf6615b7..c6ab3fcd 100644 --- a/lttng-probes.c +++ b/lttng-probes.c @@ -12,7 +12,7 @@ #include #include -#include +#include /* * probe list is protected by sessions lock. diff --git a/lttng-ring-buffer-client-discard.c b/lttng-ring-buffer-client-discard.c index 64d7e9ec..d8553259 100644 --- a/lttng-ring-buffer-client-discard.c +++ b/lttng-ring-buffer-client-discard.c @@ -8,7 +8,7 @@ */ #include -#include +#include #define RING_BUFFER_MODE_TEMPLATE RING_BUFFER_DISCARD #define RING_BUFFER_MODE_TEMPLATE_STRING "discard" diff --git a/lttng-ring-buffer-client-mmap-discard.c b/lttng-ring-buffer-client-mmap-discard.c index 9147e58b..4a0b5628 100644 --- a/lttng-ring-buffer-client-mmap-discard.c +++ b/lttng-ring-buffer-client-mmap-discard.c @@ -8,7 +8,7 @@ */ #include -#include +#include #define RING_BUFFER_MODE_TEMPLATE RING_BUFFER_DISCARD #define RING_BUFFER_MODE_TEMPLATE_STRING "discard-mmap" diff --git a/lttng-ring-buffer-client-mmap-overwrite.c b/lttng-ring-buffer-client-mmap-overwrite.c index 4494ac4b..293328dc 100644 --- a/lttng-ring-buffer-client-mmap-overwrite.c +++ b/lttng-ring-buffer-client-mmap-overwrite.c @@ -8,7 +8,7 @@ */ #include -#include +#include #define RING_BUFFER_MODE_TEMPLATE RING_BUFFER_OVERWRITE #define RING_BUFFER_MODE_TEMPLATE_STRING "overwrite-mmap" diff --git a/lttng-ring-buffer-client-overwrite.c b/lttng-ring-buffer-client-overwrite.c index d4566296..973573a6 100644 --- a/lttng-ring-buffer-client-overwrite.c +++ b/lttng-ring-buffer-client-overwrite.c @@ -8,7 +8,7 @@ */ #include -#include +#include #define RING_BUFFER_MODE_TEMPLATE RING_BUFFER_OVERWRITE #define RING_BUFFER_MODE_TEMPLATE_STRING "overwrite" diff --git a/lttng-ring-buffer-client.h b/lttng-ring-buffer-client.h index ffbb1f46..94d3a64a 100644 --- a/lttng-ring-buffer-client.h +++ b/lttng-ring-buffer-client.h @@ -9,11 +9,11 @@ #include #include -#include +#include #include -#include -#include -#include +#include +#include +#include #define LTTNG_COMPACT_EVENT_BITS 5 #define LTTNG_COMPACT_TSC_BITS 27 @@ -190,7 +190,7 @@ size_t record_header_size(const struct lib_ring_buffer_config *config, return offset - orig_offset; } -#include +#include static void lttng_write_event_header_slow(const struct lib_ring_buffer_config *config, diff --git a/lttng-ring-buffer-metadata-client.c b/lttng-ring-buffer-metadata-client.c index 7a785677..6032a903 100644 --- a/lttng-ring-buffer-metadata-client.c +++ b/lttng-ring-buffer-metadata-client.c @@ -8,7 +8,7 @@ */ #include -#include +#include #define RING_BUFFER_MODE_TEMPLATE RING_BUFFER_DISCARD #define RING_BUFFER_MODE_TEMPLATE_STRING "metadata" diff --git a/lttng-ring-buffer-metadata-client.h b/lttng-ring-buffer-metadata-client.h index 50cd3779..3dbf3f0a 100644 --- a/lttng-ring-buffer-metadata-client.h +++ b/lttng-ring-buffer-metadata-client.h @@ -9,8 +9,8 @@ #include #include -#include -#include +#include +#include static struct lttng_transport lttng_relay_transport; @@ -50,7 +50,7 @@ size_t record_header_size(const struct lib_ring_buffer_config *config, return 0; } -#include +#include static u64 client_ring_buffer_clock_read(struct channel *chan) { diff --git a/lttng-ring-buffer-metadata-mmap-client.c b/lttng-ring-buffer-metadata-mmap-client.c index fc33f99b..6fc6156d 100644 --- a/lttng-ring-buffer-metadata-mmap-client.c +++ b/lttng-ring-buffer-metadata-mmap-client.c @@ -8,7 +8,7 @@ */ #include -#include +#include #define RING_BUFFER_MODE_TEMPLATE RING_BUFFER_DISCARD #define RING_BUFFER_MODE_TEMPLATE_STRING "metadata-mmap" diff --git a/lttng-statedump-impl.c b/lttng-statedump-impl.c index 4635feb0..3d010ca6 100644 --- a/lttng-statedump-impl.c +++ b/lttng-statedump-impl.c @@ -36,8 +36,8 @@ #include #include -#include -#include +#include +#include /* Define the tracepoints, but do not build the probes */ #define CREATE_TRACE_POINTS diff --git a/lttng-string-utils.c b/lttng-string-utils.c index 1f126185..53457a8a 100644 --- a/lttng-string-utils.c +++ b/lttng-string-utils.c @@ -5,7 +5,7 @@ #include -#include +#include enum star_glob_pattern_type_flags { STAR_GLOB_PATTERN_TYPE_FLAG_NONE = 0, diff --git a/lttng-string-utils.h b/lttng-string-utils.h deleted file mode 100644 index 3e7267e9..00000000 --- a/lttng-string-utils.h +++ /dev/null @@ -1,23 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ -#ifndef _LTTNG_STRING_UTILS_H -#define _LTTNG_STRING_UTILS_H - -/* - * Copyright (C) 2017 Philippe Proulx - */ - -#include - -typedef char (*strutils_get_char_at_cb)(size_t, void *); - -bool strutils_is_star_glob_pattern(const char *pattern); -bool strutils_is_star_at_the_end_only_glob_pattern(const char *pattern); -bool strutils_star_glob_match(const char *pattern, size_t pattern_len, - const char *candidate, size_t candidate_len); -bool strutils_star_glob_match_char_cb( - strutils_get_char_at_cb pattern_get_char_at_cb, - void *pattern_get_char_at_cb_data, - strutils_get_char_at_cb candidate_get_char_at_cb, - void *candidate_get_char_at_cb_data); - -#endif /* _LTTNG_STRING_UTILS_H */ diff --git a/lttng-syscalls.c b/lttng-syscalls.c index 41fc2e3d..5fcbe6fc 100644 --- a/lttng-syscalls.c +++ b/lttng-syscalls.c @@ -22,9 +22,9 @@ #include #include -#include -#include -#include "lttng-tracepoint.h" +#include +#include +#include #define LTTNG_SYSCALL_NR_ARGS 6 diff --git a/lttng-tp-mempool.c b/lttng-tp-mempool.c index 7e1b51d3..27919891 100644 --- a/lttng-tp-mempool.c +++ b/lttng-tp-mempool.c @@ -8,7 +8,7 @@ #include #include -#include +#include struct lttng_tp_buf_entry { int cpu; /* To make sure we return the entry to the right pool. */ diff --git a/lttng-tp-mempool.h b/lttng-tp-mempool.h deleted file mode 100644 index f925efa9..00000000 --- a/lttng-tp-mempool.h +++ /dev/null @@ -1,50 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) - * - * lttng-tp-mempool.h - * - * Copyright (C) 2018 Julien Desfossez - */ - -#ifndef LTTNG_TP_MEMPOOL_H -#define LTTNG_TP_MEMPOOL_H - -#include - -#define LTTNG_TP_MEMPOOL_NR_BUF_PER_CPU 4 -#define LTTNG_TP_MEMPOOL_BUF_SIZE 4096 - -/* - * Initialize the pool, only performed once. The pool is a set of - * LTTNG_TP_MEMPOOL_NR_BUF_PER_CPU buffers of size LTTNG_TP_MEMPOOL_BUF_SIZE - * per-cpu. - * - * Returns 0 on success, a negative value on error. - */ -int lttng_tp_mempool_init(void); - -/* - * Destroy the pool and free all the memory allocated. - */ -void lttng_tp_mempool_destroy(void); - -/* - * Ask for a buffer on the current cpu. - * - * The pool is per-cpu, but there is no exclusive access guarantee on the - * per-cpu free-list, the caller needs to ensure it cannot get preempted or - * interrupted while performing the allocation. - * - * The maximum size that can be allocated is LTTNG_TP_MEMPOOL_BUF_SIZE, and the - * maximum number of buffers allocated simultaneously on the same CPU is - * LTTNG_TP_MEMPOOL_NR_BUF_PER_CPU. - * - * Return a pointer to a buffer on success, NULL on error. - */ -void *lttng_tp_mempool_alloc(size_t size); - -/* - * Release the memory reserved. Same concurrency limitations as the allocation. - */ -void lttng_tp_mempool_free(void *ptr); - -#endif /* LTTNG_TP_MEMPOOL_H */ diff --git a/lttng-tracepoint.c b/lttng-tracepoint.c index 3d0cafd7..797a5ac2 100644 --- a/lttng-tracepoint.c +++ b/lttng-tracepoint.c @@ -15,7 +15,7 @@ #include #include -#include +#include /* * Protect the tracepoint table. lttng_tracepoint_mutex nests within diff --git a/lttng-tracepoint.h b/lttng-tracepoint.h deleted file mode 100644 index 12cc5954..00000000 --- a/lttng-tracepoint.h +++ /dev/null @@ -1,18 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) - * - * lttng-tracepoint.h - * - * LTTng adaptation layer for Linux kernel 3.15+ tracepoints. - * - * Copyright (C) 2014 Mathieu Desnoyers - */ - -#ifndef _LTTNG_TRACEPOINT_H -#define _LTTNG_TRACEPOINT_H - -int lttng_tracepoint_probe_register(const char *name, void *probe, void *data); -int lttng_tracepoint_probe_unregister(const char *name, void *probe, void *data); -int lttng_tracepoint_init(void); -void lttng_tracepoint_exit(void); - -#endif /* _LTTNG_TRACEPOINT_H */ diff --git a/lttng-tracer-core.h b/lttng-tracer-core.h deleted file mode 100644 index ad82ae2c..00000000 --- a/lttng-tracer-core.h +++ /dev/null @@ -1,28 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) - * - * lttng-tracer-core.h - * - * This contains the core definitions for the Linux Trace Toolkit Next - * Generation tracer. - * - * Copyright (C) 2005-2012 Mathieu Desnoyers - */ - -#ifndef LTTNG_TRACER_CORE_H -#define LTTNG_TRACER_CORE_H - -#include -#include - -#ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS -/* Align data on its natural alignment */ -#define RING_BUFFER_ALIGN -#endif - -#include - -struct lttng_session; -struct lttng_channel; -struct lttng_event; - -#endif /* LTTNG_TRACER_CORE_H */ diff --git a/lttng-tracer.h b/lttng-tracer.h deleted file mode 100644 index 1712d031..00000000 --- a/lttng-tracer.h +++ /dev/null @@ -1,69 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ -#ifndef _LTTNG_TRACER_H -#define _LTTNG_TRACER_H - -/* - * lttng-tracer.h - * - * This contains the definitions for the Linux Trace Toolkit Next - * Generation tracer. - * - * Copyright (C) 2005-2012 Mathieu Desnoyers - */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include -#include -#include - -#define LTTNG_MODULES_MAJOR_VERSION 2 -#define LTTNG_MODULES_MINOR_VERSION 12 -#define LTTNG_MODULES_PATCHLEVEL_VERSION 0 -#define LTTNG_MODULES_EXTRAVERSION "-rc1" - -#define LTTNG_VERSION_NAME "(Ta) Meilleure" -#define LTTNG_VERSION_DESCRIPTION "Ta Meilleure is a Northeast IPA beer brewed by Lagabière. Translating to \"Your best one\", this beer gives out strong aromas of passion fruit, lemon, and peaches. Tastewise, expect a lot of fruit, a creamy texture, and a smooth lingering hop bitterness." - -#ifndef CHAR_BIT -#define CHAR_BIT 8 -#endif - -/* Number of bytes to log with a read/write event */ -#define LTTNG_LOG_RW_SIZE 32L -#define LTTNG_MAX_SMALL_SIZE 0xFFFFU - -#ifdef RING_BUFFER_ALIGN -#define lttng_alignof(type) __alignof__(type) -#else -#define lttng_alignof(type) 1 -#endif - -/* Tracer properties */ -#define CTF_MAGIC_NUMBER 0xC1FC1FC1 -#define TSDL_MAGIC_NUMBER 0x75D11D57 - -/* CTF specification version followed */ -#define CTF_SPEC_MAJOR 1 -#define CTF_SPEC_MINOR 8 - -/* - * Number of milliseconds to retry before failing metadata writes on buffer full - * condition. (10 seconds) - */ -#define LTTNG_METADATA_TIMEOUT_MSEC 10000 - -#define LTTNG_RFLAG_EXTENDED RING_BUFFER_RFLAG_END -#define LTTNG_RFLAG_END (LTTNG_RFLAG_EXTENDED << 1) - -#define __LTTNG_COMPOUND_LITERAL(type, ...) (type[]) { __VA_ARGS__ } - -#endif /* _LTTNG_TRACER_H */ diff --git a/lttng-tracker-id.c b/lttng-tracker-id.c index a789e7c4..fac0ab70 100644 --- a/lttng-tracker-id.c +++ b/lttng-tracker-id.c @@ -15,7 +15,7 @@ #include #include -#include +#include /* * Hash table is allocated and freed when there are no possible diff --git a/probes/Kbuild b/probes/Kbuild index 9f0c1a6d..e3bb7a53 100644 --- a/probes/Kbuild +++ b/probes/Kbuild @@ -4,7 +4,7 @@ TOP_LTTNG_MODULES_DIR := $(shell dirname $(lastword $(MAKEFILE_LIST)))/.. include $(TOP_LTTNG_MODULES_DIR)/Kbuild.common -ccflags-y += -I$(TOP_LTTNG_MODULES_DIR) +ccflags-y += -I$(TOP_LTTNG_MODULES_DIR)/include obj-$(CONFIG_LTTNG) += lttng-probe-sched.o obj-$(CONFIG_LTTNG) += lttng-probe-irq.o diff --git a/probes/define_trace.h b/probes/define_trace.h deleted file mode 100644 index f8f9d342..00000000 --- a/probes/define_trace.h +++ /dev/null @@ -1,121 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) - * - * define_trace.h - * - * Copyright (C) 2009 Steven Rostedt - * Copyright (C) 2010-2012 Mathieu Desnoyers - */ - -/* - * Trace files that want to automate creationg of all tracepoints defined - * in their file should include this file. The following are macros that the - * trace file may define: - * - * TRACE_SYSTEM defines the system the tracepoint is for - * - * TRACE_INCLUDE_FILE if the file name is something other than TRACE_SYSTEM.h - * This macro may be defined to tell define_trace.h what file to include. - * Note, leave off the ".h". - * - * TRACE_INCLUDE_PATH if the path is something other than core kernel include/trace - * then this macro can define the path to use. Note, the path is relative to - * define_trace.h, not the file including it. Full path names for out of tree - * modules must be used. - */ - -#ifdef CREATE_TRACE_POINTS - -/* Prevent recursion */ -#undef CREATE_TRACE_POINTS - -#include - -#undef LTTNG_TRACEPOINT_EVENT_MAP -#define LTTNG_TRACEPOINT_EVENT_MAP(name, map, proto, args, fields) - -#undef LTTNG_TRACEPOINT_EVENT_MAP_NOARGS -#define LTTNG_TRACEPOINT_EVENT_MAP_NOARGS(name, map, fields) - -#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP -#define LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(template, name, map, proto, args) - -#undef LTTNG_TRACEPOINT_EVENT -#define LTTNG_TRACEPOINT_EVENT(name, proto, args, fields) - -#undef LTTNG_TRACEPOINT_EVENT_CODE -#define LTTNG_TRACEPOINT_EVENT_CODE(name, proto, args, _locvar, _code_pre, fields, _code_post) - -#undef LTTNG_TRACEPOINT_EVENT_CODE_MAP -#define LTTNG_TRACEPOINT_EVENT_CODE_MAP(name, map, proto, args, _locvar, _code_pre, fields, _code_post) - -#undef LTTNG_TRACEPOINT_EVENT_INSTANCE -#define LTTNG_TRACEPOINT_EVENT_INSTANCE(template, name, proto, args) - -#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS -#define LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(template, name) - -#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS -#define LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS(template, name, map) - -#undef TRACE_INCLUDE -#undef __TRACE_INCLUDE - -#ifndef TRACE_INCLUDE_FILE -# define TRACE_INCLUDE_FILE TRACE_SYSTEM -# define UNDEF_TRACE_INCLUDE_FILE -#endif - -#ifndef TRACE_INCLUDE_PATH -# define __TRACE_INCLUDE(system) -# define UNDEF_TRACE_INCLUDE_PATH -#else -# define __TRACE_INCLUDE(system) __stringify(TRACE_INCLUDE_PATH/system.h) -#endif - -# define TRACE_INCLUDE(system) __TRACE_INCLUDE(system) - -/* Let the trace headers be reread */ -#define TRACE_HEADER_MULTI_READ - -#include TRACE_INCLUDE(TRACE_INCLUDE_FILE) - -/* Make all open coded DECLARE_TRACE nops */ -#undef DECLARE_TRACE -#define DECLARE_TRACE(name, proto, args) - -#ifdef LTTNG_PACKAGE_BUILD -#include -#endif - -#undef LTTNG_TRACEPOINT_EVENT -#undef LTTNG_TRACEPOINT_EVENT_INSTANCE -#undef LTTNG_TRACEPOINT_EVENT_MAP -#undef LTTNG_TRACEPOINT_EVENT_CLASS -#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP -#undef LTTNG_TRACEPOINT_EVENT_CODE_MAP -#undef LTTNG_TRACEPOINT_EVENT_CODE -#undef LTTNG_TRACEPOINT_EVENT_MAP_NOARGS -#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS -#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS -#undef TRACE_HEADER_MULTI_READ - -/* Only undef what we defined in this file */ -#ifdef UNDEF_TRACE_INCLUDE_FILE -# undef TRACE_INCLUDE_FILE -# undef UNDEF_TRACE_INCLUDE_FILE -#endif - -#ifdef UNDEF_TRACE_INCLUDE_PATH -# undef TRACE_INCLUDE_PATH -# undef UNDEF_TRACE_INCLUDE_PATH -#endif - -/* - * We want to re-include lttng-tracepoint-event.h for a following probe. - */ -#undef LTTNG_TRACEPOINT_EVENT_H - -/* We may be processing more files */ -#define CREATE_TRACE_POINTS - -#endif /* CREATE_TRACE_POINTS */ diff --git a/probes/lttng-events-nowrite.h b/probes/lttng-events-nowrite.h deleted file mode 100644 index 5f6b64c7..00000000 --- a/probes/lttng-events-nowrite.h +++ /dev/null @@ -1,137 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) - * - * lttng-events-write.h - * - * Copyright (C) 2014 Mathieu Desnoyers - */ - -#undef ctf_integer_nowrite -#define ctf_integer_nowrite(_type, _item, _user_src) \ - _ctf_integer_ext(_type, _item, _user_src, __BYTE_ORDER, 10, 0, 1) - -#undef ctf_integer_hex_nowrite -#define ctf_integer_hex_nowrite(_type, _item, _user_src) \ - _ctf_integer_ext(_type, _item, _user_src, __BYTE_ORDER, 16, 0, 1) - -#undef ctf_integer_oct_nowrite -#define ctf_integer_oct_nowrite(_type, _item, _user_src) \ - _ctf_integer_ext(_type, _item, _user_src, __BYTE_ORDER, 8, 0, 1) - -#undef ctf_integer_network_nowrite -#define ctf_integer_network_nowrite(_type, _item, _user_src) \ - _ctf_integer_ext(_type, _item, _user_src, __BIG_ENDIAN, 10, 0, 1) - -#undef ctf_integer_network_hex_nowrite -#define ctf_integer_network_hex_nowrite(_type, _item, _user_src) \ - _ctf_integer_ext(_type, _item, _user_src, __BIG_ENDIAN, 16, 0, 1) - -#undef ctf_array_nowrite -#define ctf_array_nowrite(_type, _item, _src, _length) \ - _ctf_array_encoded(_type, _item, _src, \ - _length, none, __BYTE_ORDER, 10, 0, 1) - -#undef ctf_array_network_nowrite -#define ctf_array_network_nowrite(_type, _item, _src, _length) \ - _ctf_array_encoded(_type, _item, _src, \ - _length, none, __BIG_ENDIAN, 10, 0, 1) - -#undef ctf_array_text_nowrite -#define ctf_array_text_nowrite(_type, _item, _src, _length) \ - _ctf_array_encoded(_type, _item, _src, \ - _length, UTF8, __BYTE_ORDER, 10, 0, 1) - -#undef ctf_array_bitfield_nowrite -#define ctf_array_bitfield_nowrite(_type, _item, _src, _length) \ - _ctf_array_bitfield(_type, _item, _src, _length, 0, 1) - -#undef ctf_sequence_nowrite -#define ctf_sequence_nowrite(_type, _item, _user_src, _length_type, _user_src_length) \ - _ctf_sequence_encoded(_type, _item, _user_src, \ - _length_type, _user_src_length, none, __BYTE_ORDER, 10, 0, 1) - -#undef ctf_sequence_network_nowrite -#define ctf_sequence_network_nowrite(_type, _item, _user_src, _length_type, _user_src_length) \ - _ctf_sequence_encoded(_type, _item, _user_src, \ - _length_type, _user_src_length, none, __BIG_ENDIAN, 10, 0, 1) - -#undef ctf_sequence_text_nowrite -#define ctf_sequence_text_nowrite(_type, _item, _user_src, _length_type, _user_src_length) \ - _ctf_sequence_encoded(_type, _item, _user_src, \ - _length_type, _user_src_length, UTF8, __BYTE_ORDER, 10, 0, 1) - -#undef ctf_sequence_bitfield_nowrite -#define ctf_sequence_bitfield_nowrite(_type, _item, _src, _length_type, _src_length) \ - _ctf_sequence_bitfield(_type, _item, _src, \ - _length_type, _src_length, 0, 1) - -#undef ctf_string_nowrite -#define ctf_string_nowrite(_item, _user_src) \ - _ctf_string(_item, _user_src, 0, 1) - -#undef ctf_enum_nowrite -#define ctf_enum_nowrite(_name, _type, _item, _src) \ - _ctf_enum(_name, _type, _item, _src, 0, 1) - -/* user src */ -#undef ctf_user_integer_nowrite -#define ctf_user_integer_nowrite(_type, _item, _user_src) \ - _ctf_integer_ext(_type, _item, _user_src, __BYTE_ORDER, 10, 1, 1) - -#undef ctf_user_integer_hex_nowrite -#define ctf_user_integer_hex_nowrite(_type, _item, _user_src) \ - _ctf_integer_ext(_type, _item, _user_src, __BYTE_ORDER, 16, 1, 1) - -#undef ctf_user_integer_network_nowrite -#define ctf_user_integer_network_nowrite(_type, _item, _user_src) \ - _ctf_integer_ext(_type, _item, _user_src, __BIG_ENDIAN, 10, 1, 1) - -#undef ctf_user_integer_network_hex_nowrite -#define ctf_user_integer_network_hex_nowrite(_type, _item, _user_src) \ - _ctf_integer_ext(_type, _item, _user_src, __BIG_ENDIAN, 16, 1, 1) - -#undef ctf_user_array_nowrite -#define ctf_user_array_nowrite(_type, _item, _src, _length) \ - _ctf_array_encoded(_type, _item, _src, \ - _length, none, __BYTE_ORDER, 10, 1, 1) - -#undef ctf_user_array_network_nowrite -#define ctf_user_array_network_nowrite(_type, _item, _src, _length) \ - _ctf_array_encoded(_type, _item, _src, \ - _length, none, __BIG_ENDIAN, 10, 1, 1) - -#undef ctf_user_array_text_nowrite -#define ctf_user_array_text_nowrite(_type, _item, _src, _length) \ - _ctf_array_encoded(_type, _item, _src, \ - _length, UTF8, __BYTE_ORDER, 10, 1, 1) - -#undef ctf_user_array_bitfield_nowrite -#define ctf_user_array_bitfield_nowrite(_type, _item, _src, _length) \ - _ctf_array_bitfield(_type, _item, _src, _length, 1, 1) - -#undef ctf_user_sequence_nowrite -#define ctf_user_sequence_nowrite(_type, _item, _user_src, _length_type, _user_src_length) \ - _ctf_sequence_encoded(_type, _item, _user_src, \ - _length_type, _user_src_length, none, __BYTE_ORDER, 10, 1, 1) - -#undef ctf_user_sequence_network_nowrite -#define ctf_user_sequence_network_nowrite(_type, _item, _user_src, _length_type, _user_src_length) \ - _ctf_sequence_encoded(_type, _item, _user_src, \ - _length_type, _user_src_length, none, __BIG_ENDIAN, 10, 1, 1) - -#undef ctf_user_sequence_text_nowrite -#define ctf_user_sequence_text_nowrite(_type, _item, _user_src, _length_type, _user_src_length) \ - _ctf_sequence_encoded(_type, _item, _user_src, \ - _length_type, _user_src_length, UTF8, __BYTE_ORDER, 10, 1, 1) - -#undef ctf_user_sequence_bitfield_nowrite -#define ctf_user_sequence_bitfield_nowrite(_type, _item, _src, _length_type, _src_length) \ - _ctf_sequence_bitfield(_type, _item, _src, \ - _length_type, _src_length, 1, 1) - -#undef ctf_user_string_nowrite -#define ctf_user_string_nowrite(_item, _user_src) \ - _ctf_string(_item, _user_src, 1, 1) - -#undef ctf_user_enum_nowrite -#define ctf_user_enum_nowrite(_name, _type, _item, _src) \ - _ctf_enum(_name, _type, _item, _src, 1, 1) diff --git a/probes/lttng-events-reset.h b/probes/lttng-events-reset.h deleted file mode 100644 index 91ddab48..00000000 --- a/probes/lttng-events-reset.h +++ /dev/null @@ -1,283 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) - * - * lttng-events-reset.h - * - * Copyright (C) 2010-2012 Mathieu Desnoyers - */ - -/* Reset macros used within LTTNG_TRACEPOINT_EVENT to "nothing" */ - -#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE -#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE(_name, _proto, _args, _locvar, _code_pre, _fields, _code_post) - -#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS -#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS(_name, _locvar, _code_pre, _fields, _code_post) - -#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP -#define LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(_template, _name, _map, _proto, _args) - -#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS -#define LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS(_template, _name, _map) - -#undef LTTNG_TRACEPOINT_ENUM -#define LTTNG_TRACEPOINT_ENUM(_name, _values) - -#undef TP_PROTO -#define TP_PROTO(args...) - -#undef TP_ARGS -#define TP_ARGS(args...) - -#undef TP_locvar -#define TP_locvar(...) - -#undef TP_code_pre -#define TP_code_pre(...) - -#undef TP_code_post -#define TP_code_post(...) - -#undef TP_FIELDS -#define TP_FIELDS(args...) - -#undef _ctf_integer_ext -#define _ctf_integer_ext(_type, _item, _src, _byte_order, _base, \ - _user, _nowrite) - -#undef _ctf_integer_ext_isuser0 -#define _ctf_integer_ext_isuser0(_type, _item, _src, _byte_order, _base, \ - _nowrite) - -#undef _ctf_integer_ext_isuser1 -#define _ctf_integer_ext_isuser1(_type, _item, _src, _byte_order, _base, \ - _nowrite) - -#undef _ctf_integer_ext_fetched -#define _ctf_integer_ext_fetched(_type, _item, _src, _byte_order, _base, \ - _nowrite) - -#undef _ctf_array_encoded -#define _ctf_array_encoded(_type, _item, _src, _length, _encoding, \ - _byte_order, _base, _user, _nowrite) - -#undef _ctf_array_bitfield -#define _ctf_array_bitfield(_type, _item, _src, _length, _user, _nowrite) - -#undef _ctf_sequence_encoded -#define _ctf_sequence_encoded(_type, _item, _src, _length_type, \ - _src_length, _encoding, _byte_order, _base, _user, _nowrite) - -#undef _ctf_sequence_bitfield -#define _ctf_sequence_bitfield(_type, _item, _src, _length_type, \ - _src_length, _byte_order, _user, _nowrite) - -#undef _ctf_string -#define _ctf_string(_item, _src, _user, _nowrite) - -#undef _ctf_enum -#define _ctf_enum(_name, _type, _item, _src, _nowrite) - -/* "write" */ -#undef ctf_integer -#define ctf_integer(_type, _item, _src) - -#undef ctf_integer_hex -#define ctf_integer_hex(_type, _item, _src) - -#undef ctf_integer_oct -#define ctf_integer_oct(_type, _item, _src) - -#undef ctf_integer_network -#define ctf_integer_network(_type, _item, _src) - -#undef ctf_integer_network_hex -#define ctf_integer_network_hex(_type, _item, _src) - -#undef ctf_float -#define ctf_float(_type, _item, _src) - -#undef ctf_array -#define ctf_array(_type, _item, _src, _length) - -#undef ctf_array_hex -#define ctf_array_hex(_type, _item, _src, _length) - -#undef ctf_array_network -#define ctf_array_network(_type, _item, _src, _length) - -#undef ctf_array_network_hex -#define ctf_array_network_hex(_type, _item, _src, _length) - -#undef ctf_array_text -#define ctf_array_text(_type, _item, _src, _length) - -#undef ctf_array_bitfield -#define ctf_array_bitfield(_type, _item, _src, _length) - -#undef ctf_sequence -#define ctf_sequence(_type, _item, _src, _length_type, _src_length) - -#undef ctf_sequence_hex -#define ctf_sequence_hex(_type, _item, _src, _length_type, _src_length) - -#undef ctf_sequence_network -#define ctf_sequence_network(_type, _item, _src, _length_type, _src_length) - -#undef ctf_sequence_network_hex -#define ctf_sequence_network_hex(_type, _item, _src, _length_type, _src_length) - -#undef ctf_sequence_text -#define ctf_sequence_text(_type, _item, _src, _length_type, _src_length) - -#undef ctf_sequence_bitfield -#define ctf_sequence_bitfield(_type, _item, _src, _length_type, _src_length) - -#undef ctf_string -#define ctf_string(_item, _src) - -#undef ctf_enum -#define ctf_enum(_name, _type, _item, _src) - -#undef ctf_custom_field -#define ctf_custom_field(_type, _item, _code) - -#undef ctf_custom_type -#define ctf_custom_type(...) - -#undef ctf_custom_code -#define ctf_custom_code(...) - -#undef ctf_align -#define ctf_align(_type) - -/* "nowrite" */ -#undef ctf_integer_nowrite -#define ctf_integer_nowrite(_type, _item, _src) - -#undef ctf_float_nowrite -#define ctf_float_nowrite(_type, _item, _src) - -#undef ctf_array_nowrite -#define ctf_array_nowrite(_type, _item, _src, _length) - -#undef ctf_array_network_nowrite -#define ctf_array_network_nowrite(_type, _item, _src, _length) - -#undef ctf_array_text_nowrite -#define ctf_array_text_nowrite(_type, _item, _src, _length) - -#undef ctf_array_bitfield_nowrite -#define ctf_array_bitfield_nowrite(_type, _item, _src, _length) - -#undef ctf_sequence_nowrite -#define ctf_sequence_nowrite(_type, _item, _src, _length_type, _src_length) - -#undef ctf_sequence_network_nowrite -#define ctf_sequence_network_nowrite(_type, _item, _src, _length_type, _src_length) - -#undef ctf_sequence_text_nowrite -#define ctf_sequence_text_nowrite(_type, _item, _src, _length_type, _src_length) - -#undef ctf_sequence_bitfield_nowrite -#define ctf_sequence_bitfield_nowrite(_type, _item, _src, _length_type, _src_length) - -#undef ctf_string_nowrite -#define ctf_string_nowrite(_item, _src) - -#undef ctf_enum_nowrite -#define ctf_enum_nowrite(_name, _type, _item, _src) - -/* "user" - "write" */ -#undef ctf_user_integer -#define ctf_user_integer(_type, _item, _user_src) - -#undef ctf_user_integer_hex -#define ctf_user_integer_hex(_type, _item, _user_src) - -#undef ctf_user_integer_network -#define ctf_user_integer_network(_type, _item, _user_src) - -#undef ctf_user_integer_network_hex -#define ctf_user_integer_network_hex(_type, _item, _user_src) - -#undef ctf_user_float -#define ctf_user_float(_type, _item, _user_src) - -#undef ctf_user_array -#define ctf_user_array(_type, _item, _user_src, _length) - -#undef ctf_user_array_hex -#define ctf_user_array_hex(_type, _item, _user_src, _length) - -#undef ctf_user_array_network -#define ctf_user_array_network(_type, _item, _user_src, _length) - -#undef ctf_user_array_network_hex -#define ctf_user_array_network_hex(_type, _item, _user_src, _length) - -#undef ctf_user_array_text -#define ctf_user_array_text(_type, _item, _user_src, _length) - -#undef ctf_user_array_bitfield -#define ctf_user_array_bitfield(_type, _item, _src, _length) - -#undef ctf_user_sequence -#define ctf_user_sequence(_type, _item, _user_src, _length_type, _user_src_length) - -#undef ctf_user_sequence_hex -#define ctf_user_sequence_hex(_type, _item, _user_src, _length_type, _user_src_length) - -#undef ctf_user_sequence_network -#define ctf_user_sequence_network(_type, _item, _user_src, _length_type, _user_src_length) - -#undef ctf_user_sequence_network_hex -#define ctf_user_sequence_network_hex(_type, _item, _user_src, _length_type, _user_src_length) - -#undef ctf_user_sequence_text -#define ctf_user_sequence_text(_type, _item, _user_src, _length_type, _user_src_length) - -#undef ctf_user_sequence_bitfield -#define ctf_user_sequence_bitfield(_type, _item, _src, _length_type, _src_length) - -#undef ctf_user_string -#define ctf_user_string(_item, _user_src) - -#undef ctf_user_enum -#define ctf_user_enum(_name, _type, _item, _src) - -/* "user" - "nowrite" */ -#undef ctf_user_integer_nowrite -#define ctf_user_integer_nowrite(_type, _item, _user_src) - -#undef ctf_user_float_nowrite -#define ctf_user_float_nowrite(_type, _item, _user_src) - -#undef ctf_user_array_nowrite -#define ctf_user_array_nowrite(_type, _item, _user_src, _length) - -#undef ctf_user_array_network_nowrite -#define ctf_user_array_network_nowrite(_type, _item, _user_src, _length) - -#undef ctf_user_array_text_nowrite -#define ctf_user_array_text_nowrite(_type, _item, _user_src, _length) - -#undef ctf_user_array_bitfield_nowrite -#define ctf_user_array_bitfield_nowrite(_type, _item, _src, _length) - -#undef ctf_user_sequence_nowrite -#define ctf_user_sequence_nowrite(_type, _item, _user_src, _length_type, _user_src_length) - -#undef ctf_user_sequence_network_nowrite -#define ctf_user_sequence_network_nowrite(_type, _item, _user_src, _length_type, _user_src_length) - -#undef ctf_user_sequence_text_nowrite -#define ctf_user_sequence_text_nowrite(_type, _item, _user_src, _length_type, _user_src_length) - -#undef ctf_user_sequence_bitfield_nowrite -#define ctf_user_sequence_bitfield_nowrite(_type, _item, _src, _length_type, _src_length) - -#undef ctf_user_string_nowrite -#define ctf_user_string_nowrite(_item, _user_src) - -#undef ctf_user_enum_nowrite -#define ctf_user_enum_nowrite(_name, _type, _item, _src) diff --git a/probes/lttng-events-write.h b/probes/lttng-events-write.h deleted file mode 100644 index c0732a54..00000000 --- a/probes/lttng-events-write.h +++ /dev/null @@ -1,339 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) - * - * lttng-events-write.h - * - * Copyright (C) 2014 Mathieu Desnoyers - */ - -#undef ctf_integer -#define ctf_integer(_type, _item, _src) \ - _ctf_integer_ext(_type, _item, _src, __BYTE_ORDER, 10, 0, 0) - -#undef ctf_integer_bitfield -#define ctf_integer_bitfield(_type, _item, _src) \ - _ctf_integer_ext(_type, _item, _src, __LITTLE_ENDIAN, 10, 0, 0) - -#undef ctf_integer_hex -#define ctf_integer_hex(_type, _item, _src) \ - _ctf_integer_ext(_type, _item, _src, __BYTE_ORDER, 16, 0, 0) - -#undef ctf_integer_oct -#define ctf_integer_oct(_type, _item, _src) \ - _ctf_integer_ext(_type, _item, _src, __BYTE_ORDER, 8, 0, 0) - -#undef ctf_integer_network -#define ctf_integer_network(_type, _item, _src) \ - _ctf_integer_ext(_type, _item, _src, __BIG_ENDIAN, 10, 0, 0) - -#undef ctf_integer_network_hex -#define ctf_integer_network_hex(_type, _item, _src) \ - _ctf_integer_ext(_type, _item, _src, __BIG_ENDIAN, 16, 0, 0) - -#undef ctf_array -#define ctf_array(_type, _item, _src, _length) \ - _ctf_array_encoded(_type, _item, _src, \ - _length, none, __BYTE_ORDER, 10, 0, 0) - -#undef ctf_array_hex -#define ctf_array_hex(_type, _item, _src, _length) \ - _ctf_array_encoded(_type, _item, _src, \ - _length, none, __BYTE_ORDER, 16, 0, 0) - -#undef ctf_array_network -#define ctf_array_network(_type, _item, _src, _length) \ - _ctf_array_encoded(_type, _item, _src, \ - _length, none, __BIG_ENDIAN, 10, 0, 0) - -#undef ctf_array_network_hex -#define ctf_array_network_hex(_type, _item, _src, _length) \ - _ctf_array_encoded(_type, _item, _src, \ - _length, none, __BIG_ENDIAN, 16, 0, 0) - -#undef ctf_array_text -#define ctf_array_text(_type, _item, _src, _length) \ - _ctf_array_encoded(_type, _item, _src, \ - _length, UTF8, __BYTE_ORDER, 10, 0, 0) - -#undef ctf_array_bitfield -#define ctf_array_bitfield(_type, _item, _src, _length) \ - _ctf_array_bitfield(_type, _item, _src, _length, 0, 0) - -#undef ctf_sequence -#define ctf_sequence(_type, _item, _src, _length_type, _src_length) \ - _ctf_sequence_encoded(_type, _item, _src, \ - _length_type, _src_length, none, __BYTE_ORDER, 10, 0, 0) - -#undef ctf_sequence_hex -#define ctf_sequence_hex(_type, _item, _src, _length_type, _src_length) \ - _ctf_sequence_encoded(_type, _item, _src, \ - _length_type, _src_length, none, __BYTE_ORDER, 16, 0, 0) - -#undef ctf_sequence_network -#define ctf_sequence_network(_type, _item, _src, _length_type, _src_length) \ - _ctf_sequence_encoded(_type, _item, _src, \ - _length_type, _src_length, none, __BIG_ENDIAN, 10, 0, 0) - -#undef ctf_sequence_network_hex -#define ctf_sequence_network_hex(_type, _item, _src, _length_type, _src_length) \ - _ctf_sequence_encoded(_type, _item, _src, \ - _length_type, _src_length, none, __BIG_ENDIAN, 16, 0, 0) - -#undef ctf_sequence_text -#define ctf_sequence_text(_type, _item, _src, _length_type, _src_length) \ - _ctf_sequence_encoded(_type, _item, _src, \ - _length_type, _src_length, UTF8, __BYTE_ORDER, 10, 0, 0) - -#undef ctf_sequence_bitfield -#define ctf_sequence_bitfield(_type, _item, _src, _length_type, _src_length) \ - _ctf_sequence_bitfield(_type, _item, _src, \ - _length_type, _src_length, 0, 0) - -#undef ctf_string -#define ctf_string(_item, _src) \ - _ctf_string(_item, _src, 0, 0) - -#undef ctf_enum -#define ctf_enum(_name, _type, _item, _src) \ - _ctf_enum(_name, _type, _item, _src, 0, 0) - -/* user src */ -#undef ctf_user_integer -#define ctf_user_integer(_type, _item, _src) \ - _ctf_integer_ext(_type, _item, _src, __BYTE_ORDER, 10, 1, 0) - -#undef ctf_user_integer_hex -#define ctf_user_integer_hex(_type, _item, _src) \ - _ctf_integer_ext(_type, _item, _src, __BYTE_ORDER, 16, 1, 0) - -#undef ctf_user_integer_network -#define ctf_user_integer_network(_type, _item, _src) \ - _ctf_integer_ext(_type, _item, _src, __BIG_ENDIAN, 10, 1, 0) - -#undef ctf_user_integer_network_hex -#define ctf_user_integer_network_hex(_type, _item, _src) \ - _ctf_integer_ext(_type, _item, _src, __BIG_ENDIAN, 16, 1, 0) - -#undef ctf_user_array -#define ctf_user_array(_type, _item, _src, _length) \ - _ctf_array_encoded(_type, _item, _src, \ - _length, none, __BYTE_ORDER, 10, 1, 0) - -#undef ctf_user_array_hex -#define ctf_user_array_hex(_type, _item, _src, _length) \ - _ctf_array_encoded(_type, _item, _src, \ - _length, none, __BYTE_ORDER, 16, 1, 0) - -#undef ctf_user_array_network -#define ctf_user_array_network(_type, _item, _src, _length) \ - _ctf_array_encoded(_type, _item, _src, \ - _length, none, __BIG_ENDIAN, 10, 1, 0) - -#undef ctf_user_array_network_hex -#define ctf_user_array_network_hex(_type, _item, _src, _length) \ - _ctf_array_encoded(_type, _item, _src, \ - _length, none, __BIG_ENDIAN, 16, 1, 0) - -#undef ctf_user_array_text -#define ctf_user_array_text(_type, _item, _src, _length) \ - _ctf_array_encoded(_type, _item, _src, \ - _length, UTF8, __BYTE_ORDER, 10, 1, 0) - -#undef ctf_user_array_bitfield -#define ctf_user_array_bitfield(_type, _item, _src, _length) \ - _ctf_array_bitfield(_type, _item, _src, _length, 1, 0) - -#undef ctf_user_sequence -#define ctf_user_sequence(_type, _item, _src, _length_type, _src_length) \ - _ctf_sequence_encoded(_type, _item, _src, \ - _length_type, _src_length, none, __BYTE_ORDER, 10, 1, 0) - -#undef ctf_user_sequence_hex -#define ctf_user_sequence_hex(_type, _item, _src, _length_type, _src_length) \ - _ctf_sequence_encoded(_type, _item, _src, \ - _length_type, _src_length, none, __BYTE_ORDER, 16, 1, 0) - -#undef ctf_user_sequence_network -#define ctf_user_sequence_network(_type, _item, _src, _length_type, _src_length) \ - _ctf_sequence_encoded(_type, _item, _src, \ - _length_type, _src_length, none, __BIG_ENDIAN, 10, 1, 0) - -#undef ctf_user_sequence_network_hex -#define ctf_user_sequence_network_hex(_type, _item, _src, _length_type, _src_length) \ - _ctf_sequence_encoded(_type, _item, _src, \ - _length_type, _src_length, none, __BIG_ENDIAN, 16, 1, 0) - -#undef ctf_user_sequence_text -#define ctf_user_sequence_text(_type, _item, _src, _length_type, _src_length) \ - _ctf_sequence_encoded(_type, _item, _src, \ - _length_type, _src_length, UTF8, __BYTE_ORDER, 10, 1, 0) - -#undef ctf_user_sequence_bitfield -#define ctf_user_sequence_bitfield(_type, _item, _src, _length_type, _src_length) \ - _ctf_sequence_bitfield(_type, _item, _src, \ - _length_type, _src_length, 1, 0) - -#undef ctf_user_string -#define ctf_user_string(_item, _src) \ - _ctf_string(_item, _src, 1, 0) - -#undef ctf_user_enum -#define ctf_user_enum(_name, _type, _item, _src) \ - _ctf_enum(_name, _type, _item, _src, 1, 0) - -/* types */ -#undef ctf_integer_type -#define ctf_integer_type(_type, _src) \ - ctf_integer(_type, unused, _src) - -#undef ctf_integer_bitfield_type -#define ctf_integer_bitfield_type(_type, _src) \ - ctf_integer_bitfield(_type, unused, _src) - -#undef ctf_integer_hex_type -#define ctf_integer_hex_type(_type, _src) \ - ctf_integer_hex(_type, unused, _src) - -#undef ctf_integer_oct_type -#define ctf_integer_oct_type(_type, _item, _src) \ - ctf_integer_oct(_type, unused, _src) - -#undef ctf_integer_network_type -#define ctf_integer_network_type(_type, _src) \ - ctf_integer_network(_type, unused, _src) - -#undef ctf_integer_network_hex_type -#define ctf_integer_network_hex_type(_type, _src) \ - ctf_integer_network_hex(_type, unused, _src) - -#undef ctf_array_type -#define ctf_array_type(_type, _src, _length) \ - ctf_array(_type, unused, _src, _length) - -#undef ctf_array_hex_type -#define ctf_array_hex_type(_type, _src, _length) \ - ctf_array_hex(_type, unused, _src, _length) - -#undef ctf_array_network_type -#define ctf_array_network_type(_type, _src, _length) \ - ctf_array_network(_type, unused, _src, _length) - -#undef ctf_array_network_hex_type -#define ctf_array_network_hex_type(_type, _src, _length) \ - ctf_array_network_hex(_type, unused, _src, _length) - -#undef ctf_array_text_type -#define ctf_array_text_type(_type, _src, _length) \ - ctf_array_text(_type, unused, _src, _length) - -#undef ctf_array_bitfield_type -#define ctf_array_bitfield_type(_type, _src, _length) \ - ctf_array_bitfield(_type, unused, _src, _length) - -#undef ctf_sequence_type -#define ctf_sequence_type(_type, _src, _length_type, _src_length) \ - ctf_sequence(_type, unused, _src, _length_type, _src_length) - -#undef ctf_sequence_hex_type -#define ctf_sequence_hex_type(_type, _src, _length_type, _src_length) \ - ctf_sequence_hex(_type, unused, _src, _length_type, _src_length) - -#undef ctf_sequence_network_type -#define ctf_sequence_network_type(_type, _src, _length_type, _src_length) \ - ctf_sequence_network(_type, unused, _src, _length_type, _src_length) - -#undef ctf_sequence_network_hex_type -#define ctf_sequence_network_hex_type(_type, _src, _length_type, _src_length) \ - ctf_sequence_network_hex(_type, unused, _src, _length_type, _src_length) - -#undef ctf_sequence_text_type -#define ctf_sequence_text_type(_type, _src, _length_type, _src_length) \ - ctf_sequence_text(_type, unused, _src, _length_type, _src_length) - -#undef ctf_sequence_bitfield_type -#define ctf_sequence_bitfield_type(_type, _src, _length_type, _src_length) \ - ctf_sequence_bitfield(_type, unused, _src, _length_type, _src_length) - -#undef ctf_string_type -#define ctf_string_type(_src) \ - ctf_string(unused, _src) - -#undef ctf_enum_type -#define ctf_enum_type(_name, _type, _src) \ - ctf_enum(_name, _type, unused, _src) - -/* user src types */ -#undef ctf_user_integer_type -#define ctf_user_integer_type(_type, _src) \ - ctf_user_integer(_type, unused, _src) - -#undef ctf_user_integer_hex_type -#define ctf_user_integer_hex_type(_type, _src) \ - ctf_user_integer_hex(_type, unused, _src) - -#undef ctf_user_integer_oct_type -#define ctf_user_integer_oct_type(_type, _item, _src) \ - ctf_user_integer_oct(_type, unused, _src) - -#undef ctf_user_integer_network_type -#define ctf_user_integer_network_type(_type, _src) \ - ctf_user_integer_network(_type, unused, _src) - -#undef ctf_user_integer_network_hex_type -#define ctf_user_integer_network_hex_type(_type, _src) \ - ctf_user_integer_network_hex(_type, unused, _src) - -#undef ctf_user_array_type -#define ctf_user_array_type(_type, _src, _length) \ - ctf_user_array(_type, unused, _src, _length) - -#undef ctf_user_array_hex_type -#define ctf_user_array_hex_type(_type, _src, _length) \ - ctf_user_array_hex(_type, unused, _src, _length) - -#undef ctf_user_array_network_type -#define ctf_user_array_network_type(_type, _src, _length) \ - ctf_user_array_network(_type, unused, _src, _length) - -#undef ctf_user_array_network_hex_type -#define ctf_user_array_network_hex_type(_type, _src, _length) \ - ctf_user_array_network_hex(_type, unused, _src, _length) - -#undef ctf_user_array_text_type -#define ctf_user_array_text_type(_type, _src, _length) \ - ctf_user_array_text(_type, unused, _src, _length) - -#undef ctf_user_array_bitfield_type -#define ctf_user_array_bitfield_type(_type, _src, _length) \ - ctf_user_array_bitfield(_type, unused, _src, _length) - -#undef ctf_user_sequence_type -#define ctf_user_sequence_type(_type, _src, _length_type, _src_length) \ - ctf_user_sequence(_type, unused, _src, _length_type, _src_length) - -#undef ctf_user_sequence_hex_type -#define ctf_user_sequence_hex_type(_type, _src, _length_type, _src_length) \ - ctf_user_sequence_hex(_type, unused, _src, _length_type, _src_length) - -#undef ctf_user_sequence_network_type -#define ctf_user_sequence_network_type(_type, _src, _length_type, _src_length) \ - ctf_user_sequence_network(_type, unused, _src, _length_type, _src_length) - -#undef ctf_user_sequence_network_hex_type -#define ctf_user_sequence_network_hex_type(_type, _src, _length_type, _src_length) \ - ctf_user_sequence_network_hex(_type, unused, _src, _length_type, _src_length) - -#undef ctf_user_sequence_text_type -#define ctf_user_sequence_text_type(_type, _src, _length_type, _src_length) \ - ctf_user_sequence_text(_type, unused, _src, _length_type, _src_length) - -#undef ctf_user_sequence_bitfield_type -#define ctf_user_sequence_bitfield_type(_type, _src, _length_type, _src_length) \ - ctf_user_sequence_bitfield(_type, unused, _src, _length_type, _src_length) - -#undef ctf_user_string_type -#define ctf_user_string_type(_src) \ - ctf_user_string(unused, _src) - -#undef ctf_user_enum_type -#define ctf_user_enum_type(_name, _type, _src) \ - ctf_user_enum(_name, _type, unused, _src) diff --git a/probes/lttng-kprobes.c b/probes/lttng-kprobes.c index 650db1fa..a6e96d7a 100644 --- a/probes/lttng-kprobes.c +++ b/probes/lttng-kprobes.c @@ -10,10 +10,10 @@ #include #include #include -#include -#include +#include +#include #include -#include +#include static int lttng_kprobes_handler_pre(struct kprobe *p, struct pt_regs *regs) diff --git a/probes/lttng-kretprobes.c b/probes/lttng-kretprobes.c index 83c26ab1..72b3a971 100644 --- a/probes/lttng-kretprobes.c +++ b/probes/lttng-kretprobes.c @@ -11,10 +11,10 @@ #include #include #include -#include -#include +#include +#include #include -#include +#include enum lttng_kretprobe_type { EVENT_ENTRY = 0, diff --git a/probes/lttng-probe-9p.c b/probes/lttng-probe-9p.c index 7d464104..8bd5c0e2 100644 --- a/probes/lttng-probe-9p.c +++ b/probes/lttng-probe-9p.c @@ -11,7 +11,7 @@ #include #include #include -#include +#include /* * Create the tracepoint static inlines from the kernel to validate that our diff --git a/probes/lttng-probe-block.c b/probes/lttng-probe-block.c index f6e9aa94..730607e4 100644 --- a/probes/lttng-probe-block.c +++ b/probes/lttng-probe-block.c @@ -9,8 +9,8 @@ #include #include -#include -#include +#include +#include /* * Create the tracepoint static inlines from the kernel to validate that our @@ -18,7 +18,7 @@ */ #include -#include "lttng-tracepoint.h" +#include /* * Create LTTng tracepoint probes. diff --git a/probes/lttng-probe-btrfs.c b/probes/lttng-probe-btrfs.c index 54bce99d..93cb740a 100644 --- a/probes/lttng-probe-btrfs.c +++ b/probes/lttng-probe-btrfs.c @@ -15,7 +15,7 @@ #include <../fs/btrfs/volumes.h> #include <../fs/btrfs/block-group.h> #include -#include +#include /* * Create the tracepoint static inlines from the kernel to validate that our diff --git a/probes/lttng-probe-compaction.c b/probes/lttng-probe-compaction.c index b7d5052e..7d229dbe 100644 --- a/probes/lttng-probe-compaction.c +++ b/probes/lttng-probe-compaction.c @@ -9,7 +9,7 @@ */ #include -#include +#include /* * Create the tracepoint static inlines from the kernel to validate that our diff --git a/probes/lttng-probe-ext4.c b/probes/lttng-probe-ext4.c index a8f1795b..31c1ad3e 100644 --- a/probes/lttng-probe-ext4.c +++ b/probes/lttng-probe-ext4.c @@ -14,7 +14,7 @@ #include <../fs/ext4/mballoc.h> #include <../fs/ext4/ext4_extents.h> #include -#include +#include /* * Create the tracepoint static inlines from the kernel to validate that our @@ -22,8 +22,8 @@ */ #include -#include -#include "lttng-tracepoint.h" +#include +#include /* * Create LTTng tracepoint probes. diff --git a/probes/lttng-probe-gpio.c b/probes/lttng-probe-gpio.c index 0b90c864..ec33e3db 100644 --- a/probes/lttng-probe-gpio.c +++ b/probes/lttng-probe-gpio.c @@ -9,7 +9,7 @@ */ #include -#include +#include /* * Create the tracepoint static inlines from the kernel to validate that our diff --git a/probes/lttng-probe-i2c.c b/probes/lttng-probe-i2c.c index 2867d173..29a49555 100644 --- a/probes/lttng-probe-i2c.c +++ b/probes/lttng-probe-i2c.c @@ -10,7 +10,7 @@ #include #include -#include +#include /* * Create the tracepoint static inlines from the kernel to validate that our diff --git a/probes/lttng-probe-irq.c b/probes/lttng-probe-irq.c index 15b029dd..983e6824 100644 --- a/probes/lttng-probe-irq.c +++ b/probes/lttng-probe-irq.c @@ -9,7 +9,7 @@ #include #include -#include +#include /* * Create the tracepoint static inlines from the kernel to validate that our @@ -17,7 +17,7 @@ */ #include -#include "lttng-tracepoint.h" +#include /* * Create LTTng tracepoint probes. diff --git a/probes/lttng-probe-jbd2.c b/probes/lttng-probe-jbd2.c index 095043c4..01b1eab9 100644 --- a/probes/lttng-probe-jbd2.c +++ b/probes/lttng-probe-jbd2.c @@ -9,7 +9,7 @@ */ #include -#include +#include /* * Create the tracepoint static inlines from the kernel to validate that our @@ -17,7 +17,7 @@ */ #include -#include "lttng-tracepoint.h" +#include /* * Create LTTng tracepoint probes. diff --git a/probes/lttng-probe-kmem.c b/probes/lttng-probe-kmem.c index 01f2d9f1..43437afc 100644 --- a/probes/lttng-probe-kmem.c +++ b/probes/lttng-probe-kmem.c @@ -10,7 +10,7 @@ #include #include -#include +#include /* * Create the tracepoint static inlines from the kernel to validate that our @@ -18,7 +18,7 @@ */ #include -#include "lttng-tracepoint.h" +#include /* * Create LTTng tracepoint probes. diff --git a/probes/lttng-probe-kvm-x86-mmu.c b/probes/lttng-probe-kvm-x86-mmu.c index d731708b..9efd105c 100644 --- a/probes/lttng-probe-kvm-x86-mmu.c +++ b/probes/lttng-probe-kvm-x86-mmu.c @@ -9,7 +9,7 @@ #include #include -#include +#include #include @@ -17,7 +17,7 @@ * Create the tracepoint static inlines from the kernel to validate that our * trace event macros match the kernel we run on. */ -#include "lttng-tracepoint.h" +#include #include <../../arch/x86/kvm/mmutrace.h> diff --git a/probes/lttng-probe-kvm-x86.c b/probes/lttng-probe-kvm-x86.c index 2eb10ae7..0317c095 100644 --- a/probes/lttng-probe-kvm-x86.c +++ b/probes/lttng-probe-kvm-x86.c @@ -9,7 +9,7 @@ #include #include -#include +#include /* TODO: check for header availability in Makefile */ #include <../../arch/x86/kvm/kvm_emulate.h> @@ -22,7 +22,7 @@ */ #include -#include "lttng-tracepoint.h" +#include /* * Create LTTng tracepoint probes. diff --git a/probes/lttng-probe-kvm.c b/probes/lttng-probe-kvm.c index 4c6d04c1..796bd8fb 100644 --- a/probes/lttng-probe-kvm.c +++ b/probes/lttng-probe-kvm.c @@ -9,7 +9,7 @@ #include #include -#include +#include /* * Create the tracepoint static inlines from the kernel to validate that our @@ -17,7 +17,7 @@ */ #include -#include "lttng-tracepoint.h" +#include /* * Create LTTng tracepoint probes. diff --git a/probes/lttng-probe-lock.c b/probes/lttng-probe-lock.c index 3d0a68d6..f9045bc8 100644 --- a/probes/lttng-probe-lock.c +++ b/probes/lttng-probe-lock.c @@ -10,14 +10,14 @@ #include #include -#include +#include /* * Create the tracepoint static inlines from the kernel to validate that our * trace event macros match the kernel we run on. */ #include -#include "lttng-tracepoint.h" +#include /* * Create LTTng tracepoint probes. diff --git a/probes/lttng-probe-module.c b/probes/lttng-probe-module.c index e99ee482..cd26cfca 100644 --- a/probes/lttng-probe-module.c +++ b/probes/lttng-probe-module.c @@ -9,7 +9,7 @@ */ #include -#include +#include /* * Create the tracepoint static inlines from the kernel to validate that our @@ -17,7 +17,7 @@ */ #include -#include "lttng-tracepoint.h" +#include /* * Create LTTng tracepoint probes. diff --git a/probes/lttng-probe-napi.c b/probes/lttng-probe-napi.c index c53003bd..7771f876 100644 --- a/probes/lttng-probe-napi.c +++ b/probes/lttng-probe-napi.c @@ -9,7 +9,7 @@ */ #include -#include +#include /* * Create the tracepoint static inlines from the kernel to validate that our @@ -17,7 +17,7 @@ */ #include -#include "lttng-tracepoint.h" +#include /* * Create LTTng tracepoint probes. diff --git a/probes/lttng-probe-net.c b/probes/lttng-probe-net.c index c69bc1ab..f1e5a695 100644 --- a/probes/lttng-probe-net.c +++ b/probes/lttng-probe-net.c @@ -9,7 +9,7 @@ */ #include -#include +#include /* * Create the tracepoint static inlines from the kernel to validate that our diff --git a/probes/lttng-probe-power.c b/probes/lttng-probe-power.c index 6133e52f..ba00a367 100644 --- a/probes/lttng-probe-power.c +++ b/probes/lttng-probe-power.c @@ -9,7 +9,7 @@ */ #include -#include +#include /* * Create the tracepoint static inlines from the kernel to validate that our @@ -17,7 +17,7 @@ */ #include -#include "lttng-tracepoint.h" +#include /* * Create LTTng tracepoint probes. diff --git a/probes/lttng-probe-preemptirq.c b/probes/lttng-probe-preemptirq.c index 73ea22bd..cca9970e 100644 --- a/probes/lttng-probe-preemptirq.c +++ b/probes/lttng-probe-preemptirq.c @@ -10,7 +10,7 @@ #include #include -#include +#include /* * Create the tracepoint static inlines from the kernel to validate that our diff --git a/probes/lttng-probe-printk.c b/probes/lttng-probe-printk.c index 3476bed8..cae8918f 100644 --- a/probes/lttng-probe-printk.c +++ b/probes/lttng-probe-printk.c @@ -9,7 +9,7 @@ */ #include -#include +#include /* * Create the tracepoint static inlines from the kernel to validate that our diff --git a/probes/lttng-probe-random.c b/probes/lttng-probe-random.c index 918b4c20..1353b168 100644 --- a/probes/lttng-probe-random.c +++ b/probes/lttng-probe-random.c @@ -9,7 +9,7 @@ */ #include -#include +#include /* * Create the tracepoint static inlines from the kernel to validate that our diff --git a/probes/lttng-probe-rcu.c b/probes/lttng-probe-rcu.c index df7ddcbf..9b7fa652 100644 --- a/probes/lttng-probe-rcu.c +++ b/probes/lttng-probe-rcu.c @@ -10,7 +10,7 @@ #include #include -#include +#include /* * Create the tracepoint static inlines from the kernel to validate that our diff --git a/probes/lttng-probe-regmap.c b/probes/lttng-probe-regmap.c index 24a03e03..47052cea 100644 --- a/probes/lttng-probe-regmap.c +++ b/probes/lttng-probe-regmap.c @@ -10,8 +10,8 @@ #include #include -#include -#include +#include +#include /* * Create the tracepoint static inlines from the kernel to validate that our diff --git a/probes/lttng-probe-regulator.c b/probes/lttng-probe-regulator.c index 51a1e04b..94c97a01 100644 --- a/probes/lttng-probe-regulator.c +++ b/probes/lttng-probe-regulator.c @@ -9,7 +9,7 @@ */ #include -#include +#include /* * Create the tracepoint static inlines from the kernel to validate that our diff --git a/probes/lttng-probe-rpm.c b/probes/lttng-probe-rpm.c index 00ccd91a..c21c3d9a 100644 --- a/probes/lttng-probe-rpm.c +++ b/probes/lttng-probe-rpm.c @@ -10,7 +10,7 @@ #include #include -#include +#include /* * Create the tracepoint static inlines from the kernel to validate that our diff --git a/probes/lttng-probe-sched.c b/probes/lttng-probe-sched.c index 495374d8..854595a3 100644 --- a/probes/lttng-probe-sched.c +++ b/probes/lttng-probe-sched.c @@ -8,7 +8,7 @@ */ #include -#include +#include /* * Create the tracepoint static inlines from the kernel to validate that our @@ -16,7 +16,7 @@ */ #include -#include "lttng-tracepoint.h" +#include /* * Create LTTng tracepoint probes. diff --git a/probes/lttng-probe-scsi.c b/probes/lttng-probe-scsi.c index 89e43273..786f29a6 100644 --- a/probes/lttng-probe-scsi.c +++ b/probes/lttng-probe-scsi.c @@ -10,7 +10,7 @@ #include #include -#include +#include /* * Create the tracepoint static inlines from the kernel to validate that our diff --git a/probes/lttng-probe-signal.c b/probes/lttng-probe-signal.c index fcbfca13..d6d72ca4 100644 --- a/probes/lttng-probe-signal.c +++ b/probes/lttng-probe-signal.c @@ -8,7 +8,7 @@ */ #include -#include +#include /* * Create the tracepoint static inlines from the kernel to validate that our diff --git a/probes/lttng-probe-skb.c b/probes/lttng-probe-skb.c index ec0469ab..0e0d89ce 100644 --- a/probes/lttng-probe-skb.c +++ b/probes/lttng-probe-skb.c @@ -9,7 +9,7 @@ */ #include -#include +#include /* * Create the tracepoint static inlines from the kernel to validate that our @@ -17,7 +17,7 @@ */ #include -#include "lttng-tracepoint.h" +#include /* * Create LTTng tracepoint probes. diff --git a/probes/lttng-probe-sock.c b/probes/lttng-probe-sock.c index 1d3a4939..6f90f100 100644 --- a/probes/lttng-probe-sock.c +++ b/probes/lttng-probe-sock.c @@ -9,7 +9,7 @@ */ #include -#include +#include /* * Create the tracepoint static inlines from the kernel to validate that our diff --git a/probes/lttng-probe-statedump.c b/probes/lttng-probe-statedump.c index cade8471..5e93d5ba 100644 --- a/probes/lttng-probe-statedump.c +++ b/probes/lttng-probe-statedump.c @@ -15,8 +15,8 @@ #include #include #include -#include -#include +#include +#include /* * Create LTTng tracepoint probes. diff --git a/probes/lttng-probe-sunrpc.c b/probes/lttng-probe-sunrpc.c index bd911a9c..43d657dd 100644 --- a/probes/lttng-probe-sunrpc.c +++ b/probes/lttng-probe-sunrpc.c @@ -9,7 +9,7 @@ */ #include -#include +#include /* * Create the tracepoint static inlines from the kernel to validate that our diff --git a/probes/lttng-probe-timer.c b/probes/lttng-probe-timer.c index ef036a64..e262db42 100644 --- a/probes/lttng-probe-timer.c +++ b/probes/lttng-probe-timer.c @@ -8,7 +8,7 @@ */ #include -#include +#include /* * Create the tracepoint static inlines from the kernel to validate that our @@ -18,7 +18,7 @@ #include #include -#include "lttng-tracepoint.h" +#include /* * Create LTTng tracepoint probes. diff --git a/probes/lttng-probe-udp.c b/probes/lttng-probe-udp.c index a9fa382b..4968f473 100644 --- a/probes/lttng-probe-udp.c +++ b/probes/lttng-probe-udp.c @@ -9,7 +9,7 @@ */ #include -#include +#include /* * Create the tracepoint static inlines from the kernel to validate that our diff --git a/probes/lttng-probe-user.c b/probes/lttng-probe-user.c index 411899d1..4f5728ac 100644 --- a/probes/lttng-probe-user.c +++ b/probes/lttng-probe-user.c @@ -7,7 +7,7 @@ #include #include -#include +#include /* * Calculate string length. Include final null terminating character if there is diff --git a/probes/lttng-probe-user.h b/probes/lttng-probe-user.h deleted file mode 100644 index d85bb6f7..00000000 --- a/probes/lttng-probe-user.h +++ /dev/null @@ -1,17 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) - * - * lttng-probe-user.h - * - * Copyright (C) 2012 Mathieu Desnoyers - */ - -#ifndef _LTTNG_PROBE_USER_H -#define _LTTNG_PROBE_USER_H - -/* - * Calculate string length. Include final null terminating character if there is - * one, or ends at first fault. - */ -long lttng_strlen_user_inatomic(const char *addr); - -#endif /* _LTTNG_PROBE_USER_H */ diff --git a/probes/lttng-probe-v4l2.c b/probes/lttng-probe-v4l2.c index 78334477..d14a89db 100644 --- a/probes/lttng-probe-v4l2.c +++ b/probes/lttng-probe-v4l2.c @@ -12,7 +12,7 @@ #include #include #include -#include +#include /* * Create the tracepoint static inlines from the kernel to validate that our * trace event macros match the kernel we run on. diff --git a/probes/lttng-probe-vmscan.c b/probes/lttng-probe-vmscan.c index 2cafb965..41204420 100644 --- a/probes/lttng-probe-vmscan.c +++ b/probes/lttng-probe-vmscan.c @@ -9,7 +9,7 @@ */ #include -#include +#include /* * Create the tracepoint static inlines from the kernel to validate that our @@ -17,7 +17,7 @@ */ #include -#include +#include /* * Create LTTng tracepoint probes. diff --git a/probes/lttng-probe-workqueue.c b/probes/lttng-probe-workqueue.c index 66b19f74..15b49cdf 100644 --- a/probes/lttng-probe-workqueue.c +++ b/probes/lttng-probe-workqueue.c @@ -10,7 +10,7 @@ #include #include -#include +#include struct cpu_workqueue_struct; struct pool_workqueue; @@ -21,7 +21,7 @@ struct pool_workqueue; */ #include -#include "lttng-tracepoint.h" +#include /* * Create LTTng tracepoint probes. diff --git a/probes/lttng-probe-writeback.c b/probes/lttng-probe-writeback.c index 14495db9..17f8a0da 100644 --- a/probes/lttng-probe-writeback.c +++ b/probes/lttng-probe-writeback.c @@ -11,7 +11,7 @@ #include #include #include -#include +#include /* * Create the tracepoint static inlines from the kernel to validate that our @@ -19,7 +19,7 @@ */ #include -#include +#include /* #if */ diff --git a/probes/lttng-probe-x86-exceptions.c b/probes/lttng-probe-x86-exceptions.c index 92603b95..33f16d26 100644 --- a/probes/lttng-probe-x86-exceptions.c +++ b/probes/lttng-probe-x86-exceptions.c @@ -8,7 +8,7 @@ */ #include -#include +#include /* * Create the tracepoint static inlines from the kernel to validate that our @@ -16,7 +16,7 @@ */ #include -#include "lttng-tracepoint.h" +#include #undef TRACE_INCLUDE_PATH #undef TRACE_INCLUDE_FILE diff --git a/probes/lttng-probe-x86-irq-vectors.c b/probes/lttng-probe-x86-irq-vectors.c index a7c8c2a0..52526a44 100644 --- a/probes/lttng-probe-x86-irq-vectors.c +++ b/probes/lttng-probe-x86-irq-vectors.c @@ -8,7 +8,7 @@ */ #include -#include +#include /* * Create the tracepoint static inlines from the kernel to validate that our @@ -16,7 +16,7 @@ */ #include -#include "lttng-tracepoint.h" +#include #undef TRACE_INCLUDE_PATH #undef TRACE_INCLUDE_FILE diff --git a/probes/lttng-tracepoint-event-impl.h b/probes/lttng-tracepoint-event-impl.h deleted file mode 100644 index 8584fbe0..00000000 --- a/probes/lttng-tracepoint-event-impl.h +++ /dev/null @@ -1,1436 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) - * - * lttng-tracepoint-event-impl.h - * - * Copyright (C) 2009 Steven Rostedt - * Copyright (C) 2009-2014 Mathieu Desnoyers - */ - -#include -#include -#include -#include -#include - -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#define __LTTNG_NULL_STRING "(null)" - -/* - * Macro declarations used for all stages. - */ - -/* - * LTTng name mapping macros. LTTng remaps some of the kernel events to - * enforce name-spacing. - */ -#undef LTTNG_TRACEPOINT_EVENT_MAP -#define LTTNG_TRACEPOINT_EVENT_MAP(name, map, proto, args, fields) \ - LTTNG_TRACEPOINT_EVENT_CLASS(map, \ - PARAMS(proto), \ - PARAMS(args), \ - PARAMS(fields)) \ - LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(map, name, map, PARAMS(proto), PARAMS(args)) - -#undef LTTNG_TRACEPOINT_EVENT_MAP_NOARGS -#define LTTNG_TRACEPOINT_EVENT_MAP_NOARGS(name, map, fields) \ - LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(map, \ - PARAMS(fields)) \ - LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS(map, name, map) - -#undef LTTNG_TRACEPOINT_EVENT_CODE_MAP -#define LTTNG_TRACEPOINT_EVENT_CODE_MAP(name, map, proto, args, _locvar, _code_pre, fields, _code_post) \ - LTTNG_TRACEPOINT_EVENT_CLASS_CODE(map, \ - PARAMS(proto), \ - PARAMS(args), \ - PARAMS(_locvar), \ - PARAMS(_code_pre), \ - PARAMS(fields), \ - PARAMS(_code_post)) \ - LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(map, name, map, PARAMS(proto), PARAMS(args)) - -#undef LTTNG_TRACEPOINT_EVENT_CODE -#define LTTNG_TRACEPOINT_EVENT_CODE(name, proto, args, _locvar, _code_pre, fields, _code_post) \ - LTTNG_TRACEPOINT_EVENT_CODE_MAP(name, name, \ - PARAMS(proto), \ - PARAMS(args), \ - PARAMS(_locvar), \ - PARAMS(_code_pre), \ - PARAMS(fields), \ - PARAMS(_code_post)) - -/* - * LTTNG_TRACEPOINT_EVENT_CLASS can be used to add a generic function - * handlers for events. That is, if all events have the same parameters - * and just have distinct trace points. Each tracepoint can be defined - * with LTTNG_TRACEPOINT_EVENT_INSTANCE and that will map the - * LTTNG_TRACEPOINT_EVENT_CLASS to the tracepoint. - * - * LTTNG_TRACEPOINT_EVENT is a one to one mapping between tracepoint and - * template. - */ - -#undef LTTNG_TRACEPOINT_EVENT -#define LTTNG_TRACEPOINT_EVENT(name, proto, args, fields) \ - LTTNG_TRACEPOINT_EVENT_MAP(name, name, \ - PARAMS(proto), \ - PARAMS(args), \ - PARAMS(fields)) - -#undef LTTNG_TRACEPOINT_EVENT_NOARGS -#define LTTNG_TRACEPOINT_EVENT_NOARGS(name, fields) \ - LTTNG_TRACEPOINT_EVENT_MAP_NOARGS(name, name, PARAMS(fields)) - -#undef LTTNG_TRACEPOINT_EVENT_INSTANCE -#define LTTNG_TRACEPOINT_EVENT_INSTANCE(template, name, proto, args) \ - LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(template, name, name, PARAMS(proto), PARAMS(args)) - -#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS -#define LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(template, name) \ - LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS(template, name, name) - -#undef LTTNG_TRACEPOINT_EVENT_CLASS -#define LTTNG_TRACEPOINT_EVENT_CLASS(_name, _proto, _args, _fields) \ - LTTNG_TRACEPOINT_EVENT_CLASS_CODE(_name, PARAMS(_proto), PARAMS(_args), , , \ - PARAMS(_fields), ) - -#undef LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS -#define LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(_name, _fields) \ - LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS(_name, , , PARAMS(_fields), ) - - -/* - * Stage 1 of the trace events. - * - * Create dummy trace calls for each events, verifying that the LTTng module - * instrumentation headers match the kernel arguments. Will be optimized - * out by the compiler. - */ - -/* Reset all macros within TRACEPOINT_EVENT */ -#include - -#undef TP_PROTO -#define TP_PROTO(...) __VA_ARGS__ - -#undef TP_ARGS -#define TP_ARGS(...) __VA_ARGS__ - -#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP -#define LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(_template, _name, _map, _proto, _args) \ -void trace_##_name(_proto); - -#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS -#define LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS(_template, _name, _map) \ -void trace_##_name(void); - -#include TRACE_INCLUDE(TRACE_INCLUDE_FILE) - -/* - * Stage 1.1 of the trace events. - * - * Create dummy trace prototypes for each event class, and for each used - * template. This will allow checking whether the prototypes from the - * class and the instance using the class actually match. - */ - -#include /* Reset all macros within TRACE_EVENT */ - -#undef TP_PROTO -#define TP_PROTO(...) __VA_ARGS__ - -#undef TP_ARGS -#define TP_ARGS(...) __VA_ARGS__ - -#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP -#define LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(_template, _name, _map, _proto, _args) \ -void __event_template_proto___##_template(_proto); - -#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS -#define LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS(_template, _name, _map) \ -void __event_template_proto___##_template(void); - -#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE -#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE(_name, _proto, _args, _locvar, _code_pre, _fields, _code_post) \ -void __event_template_proto___##_name(_proto); - -#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS -#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS(_name, _locvar, _code_pre, _fields, _code_post) \ -void __event_template_proto___##_name(void); - -#include TRACE_INCLUDE(TRACE_INCLUDE_FILE) - -/* - * Stage 1.2 of tracepoint event generation - * - * Unfolding the enums - */ -#include /* Reset all macros within TRACE_EVENT */ - -/* Enumeration entry (single value) */ -#undef ctf_enum_value -#define ctf_enum_value(_string, _value) \ - { \ - .start = { \ - .signedness = lttng_is_signed_type(__typeof__(_value)), \ - .value = lttng_is_signed_type(__typeof__(_value)) ? \ - (long long) (_value) : (_value), \ - }, \ - .end = { \ - .signedness = lttng_is_signed_type(__typeof__(_value)), \ - .value = lttng_is_signed_type(__typeof__(_value)) ? \ - (long long) (_value) : (_value), \ - }, \ - .string = (_string), \ - }, - -/* Enumeration entry (range) */ -#undef ctf_enum_range -#define ctf_enum_range(_string, _range_start, _range_end) \ - { \ - .start = { \ - .signedness = lttng_is_signed_type(__typeof__(_range_start)), \ - .value = lttng_is_signed_type(__typeof__(_range_start)) ? \ - (long long) (_range_start) : (_range_start), \ - }, \ - .end = { \ - .signedness = lttng_is_signed_type(__typeof__(_range_end)), \ - .value = lttng_is_signed_type(__typeof__(_range_end)) ? \ - (long long) (_range_end) : (_range_end), \ - }, \ - .string = (_string), \ - }, - -/* Enumeration entry (automatic value; follows the rules of CTF) */ -#undef ctf_enum_auto -#define ctf_enum_auto(_string) \ - { \ - .start = { \ - .signedness = -1, \ - .value = -1, \ - }, \ - .end = { \ - .signedness = -1, \ - .value = -1, \ - }, \ - .string = (_string), \ - .options = { \ - .is_auto = 1, \ - } \ - }, - -#undef TP_ENUM_VALUES -#define TP_ENUM_VALUES(...) \ - __VA_ARGS__ - -#undef LTTNG_TRACEPOINT_ENUM -#define LTTNG_TRACEPOINT_ENUM(_name, _values) \ - const struct lttng_enum_entry __enum_values__##_name[] = { \ - _values \ - }; - -#include TRACE_INCLUDE(TRACE_INCLUDE_FILE) - -/* - * Stage 2 of the trace events. - * - * Create event field type metadata section. - * Each event produce an array of fields. - */ - -/* Reset all macros within TRACEPOINT_EVENT */ -#include -#include -#include - -#undef _ctf_integer_ext -#define _ctf_integer_ext(_type, _item, _src, _byte_order, _base, _user, _nowrite) \ - { \ - .name = #_item, \ - .type = __type_integer(_type, 0, 0, -1, _byte_order, _base, none), \ - .nowrite = _nowrite, \ - .user = _user, \ - .nofilter = 0, \ - }, - -#undef _ctf_array_encoded -#define _ctf_array_encoded(_type, _item, _src, _length, \ - _encoding, _byte_order, _elem_type_base, _user, _nowrite) \ - { \ - .name = #_item, \ - .type = \ - { \ - .atype = atype_array_nestable, \ - .u = \ - { \ - .array_nestable = \ - { \ - .elem_type = __LTTNG_COMPOUND_LITERAL(struct lttng_type, \ - __type_integer(_type, 0, 0, -1, _byte_order, _elem_type_base, _encoding)), \ - .length = _length, \ - .alignment = 0, \ - } \ - } \ - }, \ - .nowrite = _nowrite, \ - .user = _user, \ - .nofilter = 0, \ - }, - -#undef _ctf_array_bitfield -#define _ctf_array_bitfield(_type, _item, _src, _length, _user, _nowrite) \ - { \ - .name = #_item, \ - .type = \ - { \ - .atype = atype_array_nestable, \ - .u = \ - { \ - .array_nestable = \ - { \ - .elem_type = __LTTNG_COMPOUND_LITERAL(struct lttng_type, \ - __type_integer(_type, 1, 1, 0, __LITTLE_ENDIAN, 10, none)), \ - .length = (_length) * sizeof(_type) * CHAR_BIT, \ - .alignment = lttng_alignof(_type), \ - } \ - } \ - }, \ - .nowrite = _nowrite, \ - .user = _user, \ - .nofilter = 0, \ - }, - - -#undef _ctf_sequence_encoded -#define _ctf_sequence_encoded(_type, _item, _src, \ - _length_type, _src_length, _encoding, \ - _byte_order, _elem_type_base, _user, _nowrite) \ - { \ - .name = "_" #_item "_length", \ - .type = __type_integer(_length_type, 0, 0, -1, __BYTE_ORDER, 10, none), \ - .nowrite = _nowrite, \ - .nofilter = 1, \ - }, \ - { \ - .name = #_item, \ - .type = \ - { \ - .atype = atype_sequence_nestable, \ - .u = \ - { \ - .sequence_nestable = \ - { \ - .length_name = "_" #_item "_length", \ - .elem_type = __LTTNG_COMPOUND_LITERAL(struct lttng_type, \ - __type_integer(_type, 0, 0, -1, _byte_order, _elem_type_base, _encoding)), \ - .alignment = 0, \ - }, \ - }, \ - }, \ - .nowrite = _nowrite, \ - .user = _user, \ - .nofilter = 0, \ - }, - -#undef _ctf_sequence_bitfield -#define _ctf_sequence_bitfield(_type, _item, _src, \ - _length_type, _src_length, \ - _user, _nowrite) \ - { \ - .name = "_" #_item "_length", \ - .type = __type_integer(_length_type, 0, 0, -1, __BYTE_ORDER, 10, none), \ - .nowrite = _nowrite, \ - .nofilter = 1, \ - }, \ - { \ - .name = #_item, \ - .type = \ - { \ - .atype = atype_sequence_nestable, \ - .u = \ - { \ - .sequence_nestable = \ - { \ - .length_name = "_" #_item "_length", \ - .elem_type = __LTTNG_COMPOUND_LITERAL(struct lttng_type, \ - __type_integer(_type, 1, 1, 0, __LITTLE_ENDIAN, 10, none)), \ - .alignment = lttng_alignof(_type), \ - }, \ - }, \ - }, \ - .nowrite = _nowrite, \ - .user = _user, \ - .nofilter = 0, \ - }, - -#undef _ctf_string -#define _ctf_string(_item, _src, _user, _nowrite) \ - { \ - .name = #_item, \ - .type = \ - { \ - .atype = atype_string, \ - .u = \ - { \ - .string = { .encoding = lttng_encode_UTF8 }, \ - }, \ - }, \ - .nowrite = _nowrite, \ - .user = _user, \ - .nofilter = 0, \ - }, - -#undef _ctf_enum -#define _ctf_enum(_name, _type, _item, _src, _user, _nowrite) \ - { \ - .name = #_item, \ - .type = { \ - .atype = atype_enum_nestable, \ - .u = { \ - .enum_nestable = { \ - .desc = &__enum_##_name, \ - .container_type = __LTTNG_COMPOUND_LITERAL(struct lttng_type, \ - __type_integer(_type, 0, 0, -1, __BYTE_ORDER, 10, none)), \ - }, \ - }, \ - }, \ - .nowrite = _nowrite, \ - .user = _user, \ - .nofilter = 0, \ - }, - -#undef ctf_custom_field -#define ctf_custom_field(_type, _item, _code) \ - { \ - .name = #_item, \ - .type = _type, \ - .nowrite = 0, \ - .user = 0, \ - .nofilter = 1, \ - }, - -#undef ctf_custom_type -#define ctf_custom_type(...) __VA_ARGS__ - -#undef TP_FIELDS -#define TP_FIELDS(...) __VA_ARGS__ /* Only one used in this phase */ - -#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS -#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS(_name, _locvar, _code_pre, _fields, _code_post) \ - static const struct lttng_event_field __event_fields___##_name[] = { \ - _fields \ - }; - -#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE -#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE(_name, _proto, _args, _locvar, _code_pre, _fields, _code_post) \ - LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS(_name, _locvar, _code_pre, PARAMS(_fields), _code_post) - -#undef LTTNG_TRACEPOINT_ENUM -#define LTTNG_TRACEPOINT_ENUM(_name, _values) \ - static const struct lttng_enum_desc __enum_##_name = { \ - .name = #_name, \ - .entries = __enum_values__##_name, \ - .nr_entries = ARRAY_SIZE(__enum_values__##_name), \ - }; - -#include TRACE_INCLUDE(TRACE_INCLUDE_FILE) - -/* - * Stage 3 of the trace events. - * - * Create probe callback prototypes. - */ - -/* Reset all macros within TRACEPOINT_EVENT */ -#include - -#undef TP_PROTO -#define TP_PROTO(...) __VA_ARGS__ - -#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE -#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE(_name, _proto, _args, _locvar, _code_pre, _fields, _code_post) \ -static void __event_probe__##_name(void *__data, _proto); - -#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS -#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS(_name, _locvar, _code_pre, _fields, _code_post) \ -static void __event_probe__##_name(void *__data); - -#include TRACE_INCLUDE(TRACE_INCLUDE_FILE) - -/* - * Stage 4 of the trace events. - * - * Create static inline function that calculates event size. - */ - -/* Reset all macros within TRACEPOINT_EVENT */ -#include -#include - -#undef _ctf_integer_ext -#define _ctf_integer_ext(_type, _item, _src, _byte_order, _base, _user, _nowrite) \ - __event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_type)); \ - __event_len += sizeof(_type); - -#undef _ctf_array_encoded -#define _ctf_array_encoded(_type, _item, _src, _length, _encoding, _byte_order, _base, _user, _nowrite) \ - __event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_type)); \ - __event_len += sizeof(_type) * (_length); - -#undef _ctf_array_bitfield -#define _ctf_array_bitfield(_type, _item, _src, _length, _user, _nowrite) \ - _ctf_array_encoded(_type, _item, _src, _length, none, __LITTLE_ENDIAN, 0, _user, _nowrite) - -#undef _ctf_sequence_encoded -#define _ctf_sequence_encoded(_type, _item, _src, _length_type, \ - _src_length, _encoding, _byte_order, _base, _user, _nowrite) \ - __event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_length_type)); \ - __event_len += sizeof(_length_type); \ - __event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_type)); \ - { \ - size_t __seqlen = (_src_length); \ - \ - if (unlikely(++this_cpu_ptr(<tng_dynamic_len_stack)->offset >= LTTNG_DYNAMIC_LEN_STACK_SIZE)) \ - goto error; \ - barrier(); /* reserve before use. */ \ - this_cpu_ptr(<tng_dynamic_len_stack)->stack[this_cpu_ptr(<tng_dynamic_len_stack)->offset - 1] = __seqlen; \ - __event_len += sizeof(_type) * __seqlen; \ - } - -#undef _ctf_sequence_bitfield -#define _ctf_sequence_bitfield(_type, _item, _src, \ - _length_type, _src_length, \ - _user, _nowrite) \ - _ctf_sequence_encoded(_type, _item, _src, _length_type, _src_length, \ - none, __LITTLE_ENDIAN, 10, _user, _nowrite) - -/* - * ctf_user_string includes \0. If returns 0, it faulted, so we set size to - * 1 (\0 only). - */ -#undef _ctf_string -#define _ctf_string(_item, _src, _user, _nowrite) \ - if (unlikely(++this_cpu_ptr(<tng_dynamic_len_stack)->offset >= LTTNG_DYNAMIC_LEN_STACK_SIZE)) \ - goto error; \ - barrier(); /* reserve before use. */ \ - if (_user) { \ - __event_len += this_cpu_ptr(<tng_dynamic_len_stack)->stack[this_cpu_ptr(<tng_dynamic_len_stack)->offset - 1] = \ - max_t(size_t, lttng_strlen_user_inatomic(_src), 1); \ - } else { \ - __event_len += this_cpu_ptr(<tng_dynamic_len_stack)->stack[this_cpu_ptr(<tng_dynamic_len_stack)->offset - 1] = \ - strlen((_src) ? (_src) : __LTTNG_NULL_STRING) + 1; \ - } - -#undef _ctf_enum -#define _ctf_enum(_name, _type, _item, _src, _user, _nowrite) \ - _ctf_integer_ext(_type, _item, _src, __BYTE_ORDER, 10, _user, _nowrite) - -#undef ctf_align -#define ctf_align(_type) \ - __event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_type)); - -#undef ctf_custom_field -#define ctf_custom_field(_type, _item, _code) \ - { \ - _code \ - } - -#undef ctf_custom_code -#define ctf_custom_code(...) __VA_ARGS__ - -#undef TP_PROTO -#define TP_PROTO(...) __VA_ARGS__ - -#undef TP_FIELDS -#define TP_FIELDS(...) __VA_ARGS__ - -#undef TP_locvar -#define TP_locvar(...) __VA_ARGS__ - -#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE -#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE(_name, _proto, _args, _locvar, _code_pre, _fields, _code_post) \ -static inline ssize_t __event_get_size__##_name(void *__tp_locvar, _proto) \ -{ \ - size_t __event_len = 0; \ - unsigned int __dynamic_len_idx __attribute__((unused)) = 0; \ - struct { _locvar } *tp_locvar __attribute__((unused)) = __tp_locvar; \ - \ - _fields \ - return __event_len; \ - \ -error: \ - __attribute__((unused)); \ - return -1; \ -} - -#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS -#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS(_name, _locvar, _code_pre, _fields, _code_post) \ -static inline ssize_t __event_get_size__##_name(void *__tp_locvar) \ -{ \ - size_t __event_len = 0; \ - unsigned int __dynamic_len_idx __attribute__((unused)) = 0; \ - struct { _locvar } *tp_locvar __attribute__((unused)) = __tp_locvar; \ - \ - _fields \ - return __event_len; \ - \ -error: \ - __attribute__((unused)); \ - return -1; \ -} - -#include TRACE_INCLUDE(TRACE_INCLUDE_FILE) - - -/* - * Stage 4.1 of tracepoint event generation. - * - * Create static inline function that layout the filter stack data. - * We make both write and nowrite data available to the filter. - */ - -/* Reset all macros within TRACEPOINT_EVENT */ -#include -#include -#include - -#undef _ctf_integer_ext_fetched -#define _ctf_integer_ext_fetched(_type, _item, _src, _byte_order, _base, _nowrite) \ - if (lttng_is_signed_type(_type)) { \ - int64_t __ctf_tmp_int64; \ - switch (sizeof(_type)) { \ - case 1: \ - { \ - union { _type t; int8_t v; } __tmp = { (_type) (_src) }; \ - __ctf_tmp_int64 = (int64_t) __tmp.v; \ - break; \ - } \ - case 2: \ - { \ - union { _type t; int16_t v; } __tmp = { (_type) (_src) }; \ - if (_byte_order != __BYTE_ORDER) \ - __swab16s(&__tmp.v); \ - __ctf_tmp_int64 = (int64_t) __tmp.v; \ - break; \ - } \ - case 4: \ - { \ - union { _type t; int32_t v; } __tmp = { (_type) (_src) }; \ - if (_byte_order != __BYTE_ORDER) \ - __swab32s(&__tmp.v); \ - __ctf_tmp_int64 = (int64_t) __tmp.v; \ - break; \ - } \ - case 8: \ - { \ - union { _type t; int64_t v; } __tmp = { (_type) (_src) }; \ - if (_byte_order != __BYTE_ORDER) \ - __swab64s(&__tmp.v); \ - __ctf_tmp_int64 = (int64_t) __tmp.v; \ - break; \ - } \ - default: \ - BUG_ON(1); \ - }; \ - memcpy(__stack_data, &__ctf_tmp_int64, sizeof(int64_t)); \ - } else { \ - uint64_t __ctf_tmp_uint64; \ - switch (sizeof(_type)) { \ - case 1: \ - { \ - union { _type t; uint8_t v; } __tmp = { (_type) (_src) }; \ - __ctf_tmp_uint64 = (uint64_t) __tmp.v; \ - break; \ - } \ - case 2: \ - { \ - union { _type t; uint16_t v; } __tmp = { (_type) (_src) }; \ - if (_byte_order != __BYTE_ORDER) \ - __swab16s(&__tmp.v); \ - __ctf_tmp_uint64 = (uint64_t) __tmp.v; \ - break; \ - } \ - case 4: \ - { \ - union { _type t; uint32_t v; } __tmp = { (_type) (_src) }; \ - if (_byte_order != __BYTE_ORDER) \ - __swab32s(&__tmp.v); \ - __ctf_tmp_uint64 = (uint64_t) __tmp.v; \ - break; \ - } \ - case 8: \ - { \ - union { _type t; uint64_t v; } __tmp = { (_type) (_src) }; \ - if (_byte_order != __BYTE_ORDER) \ - __swab64s(&__tmp.v); \ - __ctf_tmp_uint64 = (uint64_t) __tmp.v; \ - break; \ - } \ - default: \ - BUG_ON(1); \ - }; \ - memcpy(__stack_data, &__ctf_tmp_uint64, sizeof(uint64_t)); \ - } \ - __stack_data += sizeof(int64_t); - -#undef _ctf_integer_ext_isuser0 -#define _ctf_integer_ext_isuser0(_type, _item, _src, _byte_order, _base, _nowrite) \ - _ctf_integer_ext_fetched(_type, _item, _src, _byte_order, _base, _nowrite) - -#undef _ctf_integer_ext_isuser1 -#define _ctf_integer_ext_isuser1(_type, _item, _user_src, _byte_order, _base, _nowrite) \ -{ \ - union { \ - char __array[sizeof(_user_src)]; \ - __typeof__(_user_src) __v; \ - } __tmp_fetch; \ - if (lib_ring_buffer_copy_from_user_check_nofault(__tmp_fetch.__array, \ - &(_user_src), sizeof(_user_src))) \ - memset(__tmp_fetch.__array, 0, sizeof(__tmp_fetch.__array)); \ - _ctf_integer_ext_fetched(_type, _item, __tmp_fetch.__v, _byte_order, _base, _nowrite) \ -} - -#undef _ctf_integer_ext -#define _ctf_integer_ext(_type, _item, _user_src, _byte_order, _base, _user, _nowrite) \ - _ctf_integer_ext_isuser##_user(_type, _item, _user_src, _byte_order, _base, _nowrite) - -#undef _ctf_array_encoded -#define _ctf_array_encoded(_type, _item, _src, _length, _encoding, _byte_order, _base, _user, _nowrite) \ - { \ - unsigned long __ctf_tmp_ulong = (unsigned long) (_length); \ - const void *__ctf_tmp_ptr = (_src); \ - memcpy(__stack_data, &__ctf_tmp_ulong, sizeof(unsigned long)); \ - __stack_data += sizeof(unsigned long); \ - memcpy(__stack_data, &__ctf_tmp_ptr, sizeof(void *)); \ - __stack_data += sizeof(void *); \ - } - -#undef _ctf_array_bitfield -#define _ctf_array_bitfield(_type, _item, _src, _length, _user, _nowrite) \ - _ctf_array_encoded(_type, _item, _src, _length, none, __LITTLE_ENDIAN, 0, _user, _nowrite) - -#undef _ctf_sequence_encoded -#define _ctf_sequence_encoded(_type, _item, _src, _length_type, \ - _src_length, _encoding, _byte_order, _base, _user, _nowrite) \ - { \ - unsigned long __ctf_tmp_ulong = (unsigned long) (_src_length); \ - const void *__ctf_tmp_ptr = (_src); \ - memcpy(__stack_data, &__ctf_tmp_ulong, sizeof(unsigned long)); \ - __stack_data += sizeof(unsigned long); \ - memcpy(__stack_data, &__ctf_tmp_ptr, sizeof(void *)); \ - __stack_data += sizeof(void *); \ - } - -#undef _ctf_sequence_bitfield -#define _ctf_sequence_bitfield(_type, _item, _src, \ - _length_type, _src_length, \ - _user, _nowrite) \ - _ctf_sequence_encoded(_type, _item, _src, _length_type, _src_length, \ - none, __LITTLE_ENDIAN, 10, _user, _nowrite) - -#undef _ctf_string -#define _ctf_string(_item, _src, _user, _nowrite) \ - { \ - const void *__ctf_tmp_ptr = \ - ((_src) ? (_src) : __LTTNG_NULL_STRING); \ - memcpy(__stack_data, &__ctf_tmp_ptr, sizeof(void *)); \ - __stack_data += sizeof(void *); \ - } - -#undef _ctf_enum -#define _ctf_enum(_name, _type, _item, _src, _user, _nowrite) \ - _ctf_integer_ext(_type, _item, _src, __BYTE_ORDER, 10, _user, _nowrite) - -#undef TP_PROTO -#define TP_PROTO(...) __VA_ARGS__ - -#undef TP_FIELDS -#define TP_FIELDS(...) __VA_ARGS__ - -#undef TP_locvar -#define TP_locvar(...) __VA_ARGS__ - -#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS -#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS(_name, _locvar, _code_pre, _fields, _code_post) \ -static inline \ -void __event_prepare_filter_stack__##_name(char *__stack_data, \ - void *__tp_locvar) \ -{ \ - struct { _locvar } *tp_locvar __attribute__((unused)) = __tp_locvar; \ - \ - _fields \ -} - -#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE -#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE(_name, _proto, _args, _locvar, _code_pre, _fields, _code_post) \ -static inline \ -void __event_prepare_filter_stack__##_name(char *__stack_data, \ - void *__tp_locvar, _proto) \ -{ \ - struct { _locvar } *tp_locvar __attribute__((unused)) = __tp_locvar; \ - \ - _fields \ -} - -#include TRACE_INCLUDE(TRACE_INCLUDE_FILE) - -/* - * Stage 5 of the trace events. - * - * Create static inline function that calculates event payload alignment. - */ - -/* Reset all macros within TRACEPOINT_EVENT */ -#include -#include - -#undef _ctf_integer_ext -#define _ctf_integer_ext(_type, _item, _src, _byte_order, _base, _user, _nowrite) \ - __event_align = max_t(size_t, __event_align, lttng_alignof(_type)); - -#undef _ctf_array_encoded -#define _ctf_array_encoded(_type, _item, _src, _length, _encoding, _byte_order, _base, _user, _nowrite) \ - __event_align = max_t(size_t, __event_align, lttng_alignof(_type)); - -#undef _ctf_array_bitfield -#define _ctf_array_bitfield(_type, _item, _src, _length, _user, _nowrite) \ - _ctf_array_encoded(_type, _item, _src, _length, none, __LITTLE_ENDIAN, 0, _user, _nowrite) - -#undef _ctf_sequence_encoded -#define _ctf_sequence_encoded(_type, _item, _src, _length_type, \ - _src_length, _encoding, _byte_order, _base, _user, _nowrite) \ - __event_align = max_t(size_t, __event_align, lttng_alignof(_length_type)); \ - __event_align = max_t(size_t, __event_align, lttng_alignof(_type)); - -#undef _ctf_sequence_bitfield -#define _ctf_sequence_bitfield(_type, _item, _src, \ - _length_type, _src_length, \ - _user, _nowrite) \ - _ctf_sequence_encoded(_type, _item, _src, _length_type, _src_length, \ - none, __LITTLE_ENDIAN, 10, _user, _nowrite) - -#undef _ctf_string -#define _ctf_string(_item, _src, _user, _nowrite) - -#undef _ctf_enum -#define _ctf_enum(_name, _type, _item, _src, _user, _nowrite) \ - _ctf_integer_ext(_type, _item, _src, __BYTE_ORDER, 10, _user, _nowrite) - -#undef ctf_align -#define ctf_align(_type) \ - __event_align = max_t(size_t, __event_align, lttng_alignof(_type)); - -#undef TP_PROTO -#define TP_PROTO(...) __VA_ARGS__ - -#undef TP_FIELDS -#define TP_FIELDS(...) __VA_ARGS__ - -#undef TP_locvar -#define TP_locvar(...) __VA_ARGS__ - -#undef ctf_custom_field -#define ctf_custom_field(_type, _item, _code) _code - -#undef ctf_custom_code -#define ctf_custom_code(...) \ - { \ - __VA_ARGS__ \ - } - -#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE -#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE(_name, _proto, _args, _locvar, _code_pre, _fields, _code_post) \ -static inline size_t __event_get_align__##_name(void *__tp_locvar, _proto) \ -{ \ - size_t __event_align = 1; \ - struct { _locvar } *tp_locvar __attribute__((unused)) = __tp_locvar; \ - \ - _fields \ - return __event_align; \ -} - -#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS -#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS(_name, _locvar, _code_pre, _fields, _code_post) \ -static inline size_t __event_get_align__##_name(void *__tp_locvar) \ -{ \ - size_t __event_align = 1; \ - struct { _locvar } *tp_locvar __attribute__((unused)) = __tp_locvar; \ - \ - _fields \ - return __event_align; \ -} - -#include TRACE_INCLUDE(TRACE_INCLUDE_FILE) - -/* - * Stage 6 of tracepoint event generation. - * - * Create the probe function. This function calls event size calculation - * and writes event data into the buffer. - */ - -/* Reset all macros within TRACEPOINT_EVENT */ -#include -#include - -#undef _ctf_integer_ext_fetched -#define _ctf_integer_ext_fetched(_type, _item, _src, _byte_order, _base, _nowrite) \ - { \ - _type __tmp = _src; \ - lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(__tmp));\ - __chan->ops->event_write(&__ctx, &__tmp, sizeof(__tmp));\ - } - -#undef _ctf_integer_ext_isuser0 -#define _ctf_integer_ext_isuser0(_type, _item, _src, _byte_order, _base, _nowrite) \ - _ctf_integer_ext_fetched(_type, _item, _src, _byte_order, _base, _nowrite) - -#undef _ctf_integer_ext_isuser1 -#define _ctf_integer_ext_isuser1(_type, _item, _user_src, _byte_order, _base, _nowrite) \ -{ \ - union { \ - char __array[sizeof(_user_src)]; \ - __typeof__(_user_src) __v; \ - } __tmp_fetch; \ - if (lib_ring_buffer_copy_from_user_check_nofault(__tmp_fetch.__array, \ - &(_user_src), sizeof(_user_src))) \ - memset(__tmp_fetch.__array, 0, sizeof(__tmp_fetch.__array)); \ - _ctf_integer_ext_fetched(_type, _item, __tmp_fetch.__v, _byte_order, _base, _nowrite) \ -} - -#undef _ctf_integer_ext -#define _ctf_integer_ext(_type, _item, _user_src, _byte_order, _base, _user, _nowrite) \ - _ctf_integer_ext_isuser##_user(_type, _item, _user_src, _byte_order, _base, _nowrite) - -#undef _ctf_array_encoded -#define _ctf_array_encoded(_type, _item, _src, _length, _encoding, _byte_order, _base, _user, _nowrite) \ - lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(_type)); \ - if (_user) { \ - __chan->ops->event_write_from_user(&__ctx, _src, sizeof(_type) * (_length)); \ - } else { \ - __chan->ops->event_write(&__ctx, _src, sizeof(_type) * (_length)); \ - } - -#if (__BYTE_ORDER == __LITTLE_ENDIAN) -#undef _ctf_array_bitfield -#define _ctf_array_bitfield(_type, _item, _src, _length, _user, _nowrite) \ - lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(_type)); \ - if (_user) { \ - __chan->ops->event_write_from_user(&__ctx, _src, sizeof(_type) * (_length)); \ - } else { \ - __chan->ops->event_write(&__ctx, _src, sizeof(_type) * (_length)); \ - } -#else /* #if (__BYTE_ORDER == __LITTLE_ENDIAN) */ -/* - * For big endian, we need to byteswap into little endian. - */ -#undef _ctf_array_bitfield -#define _ctf_array_bitfield(_type, _item, _src, _length, _user, _nowrite) \ - lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(_type)); \ - { \ - size_t _i; \ - \ - for (_i = 0; _i < (_length); _i++) { \ - _type _tmp; \ - \ - if (_user) { \ - if (get_user(_tmp, (_type *) _src + _i)) \ - _tmp = 0; \ - } else { \ - _tmp = ((_type *) _src)[_i]; \ - } \ - switch (sizeof(_type)) { \ - case 1: \ - break; \ - case 2: \ - _tmp = cpu_to_le16(_tmp); \ - break; \ - case 4: \ - _tmp = cpu_to_le32(_tmp); \ - break; \ - case 8: \ - _tmp = cpu_to_le64(_tmp); \ - break; \ - default: \ - BUG_ON(1); \ - } \ - __chan->ops->event_write(&__ctx, &_tmp, sizeof(_type)); \ - } \ - } -#endif /* #else #if (__BYTE_ORDER == __LITTLE_ENDIAN) */ - -#undef _ctf_sequence_encoded -#define _ctf_sequence_encoded(_type, _item, _src, _length_type, \ - _src_length, _encoding, _byte_order, _base, _user, _nowrite) \ - { \ - _length_type __tmpl = this_cpu_ptr(<tng_dynamic_len_stack)->stack[__dynamic_len_idx]; \ - lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(_length_type));\ - __chan->ops->event_write(&__ctx, &__tmpl, sizeof(_length_type));\ - } \ - lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(_type)); \ - if (_user) { \ - __chan->ops->event_write_from_user(&__ctx, _src, \ - sizeof(_type) * __get_dynamic_len(dest)); \ - } else { \ - __chan->ops->event_write(&__ctx, _src, \ - sizeof(_type) * __get_dynamic_len(dest)); \ - } - -#if (__BYTE_ORDER == __LITTLE_ENDIAN) -#undef _ctf_sequence_bitfield -#define _ctf_sequence_bitfield(_type, _item, _src, \ - _length_type, _src_length, \ - _user, _nowrite) \ - { \ - _length_type __tmpl = this_cpu_ptr(<tng_dynamic_len_stack)->stack[__dynamic_len_idx] * sizeof(_type) * CHAR_BIT; \ - lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(_length_type));\ - __chan->ops->event_write(&__ctx, &__tmpl, sizeof(_length_type));\ - } \ - lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(_type)); \ - if (_user) { \ - __chan->ops->event_write_from_user(&__ctx, _src, \ - sizeof(_type) * __get_dynamic_len(dest)); \ - } else { \ - __chan->ops->event_write(&__ctx, _src, \ - sizeof(_type) * __get_dynamic_len(dest)); \ - } -#else /* #if (__BYTE_ORDER == __LITTLE_ENDIAN) */ -/* - * For big endian, we need to byteswap into little endian. - */ -#undef _ctf_sequence_bitfield -#define _ctf_sequence_bitfield(_type, _item, _src, \ - _length_type, _src_length, \ - _user, _nowrite) \ - { \ - _length_type __tmpl = this_cpu_ptr(<tng_dynamic_len_stack)->stack[__dynamic_len_idx] * sizeof(_type) * CHAR_BIT; \ - lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(_length_type));\ - __chan->ops->event_write(&__ctx, &__tmpl, sizeof(_length_type));\ - } \ - lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(_type)); \ - { \ - size_t _i, _length; \ - \ - _length = __get_dynamic_len(dest); \ - for (_i = 0; _i < _length; _i++) { \ - _type _tmp; \ - \ - if (_user) { \ - if (get_user(_tmp, (_type *) _src + _i)) \ - _tmp = 0; \ - } else { \ - _tmp = ((_type *) _src)[_i]; \ - } \ - switch (sizeof(_type)) { \ - case 1: \ - break; \ - case 2: \ - _tmp = cpu_to_le16(_tmp); \ - break; \ - case 4: \ - _tmp = cpu_to_le32(_tmp); \ - break; \ - case 8: \ - _tmp = cpu_to_le64(_tmp); \ - break; \ - default: \ - BUG_ON(1); \ - } \ - __chan->ops->event_write(&__ctx, &_tmp, sizeof(_type)); \ - } \ - } -#endif /* #else #if (__BYTE_ORDER == __LITTLE_ENDIAN) */ - -#undef _ctf_string -#define _ctf_string(_item, _src, _user, _nowrite) \ - if (_user) { \ - lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(*(_src))); \ - __chan->ops->event_strcpy_from_user(&__ctx, _src, \ - __get_dynamic_len(dest)); \ - } else { \ - const char *__ctf_tmp_string = \ - ((_src) ? (_src) : __LTTNG_NULL_STRING); \ - lib_ring_buffer_align_ctx(&__ctx, \ - lttng_alignof(*__ctf_tmp_string)); \ - __chan->ops->event_strcpy(&__ctx, __ctf_tmp_string, \ - __get_dynamic_len(dest)); \ - } - -#undef _ctf_enum -#define _ctf_enum(_name, _type, _item, _src, _user, _nowrite) \ - _ctf_integer_ext(_type, _item, _src, __BYTE_ORDER, 10, _user, _nowrite) - -#undef ctf_align -#define ctf_align(_type) \ - lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(_type)); - -#undef ctf_custom_field -#define ctf_custom_field(_type, _item, _code) _code - -#undef ctf_custom_code -#define ctf_custom_code(...) \ - { \ - __VA_ARGS__ \ - } - -/* Beware: this get len actually consumes the len value */ -#undef __get_dynamic_len -#define __get_dynamic_len(field) this_cpu_ptr(<tng_dynamic_len_stack)->stack[__dynamic_len_idx++] - -#undef TP_PROTO -#define TP_PROTO(...) __VA_ARGS__ - -#undef TP_ARGS -#define TP_ARGS(...) __VA_ARGS__ - -#undef TP_FIELDS -#define TP_FIELDS(...) __VA_ARGS__ - -#undef TP_locvar -#define TP_locvar(...) __VA_ARGS__ - -#undef TP_code_pre -#define TP_code_pre(...) __VA_ARGS__ - -#undef TP_code_post -#define TP_code_post(...) __VA_ARGS__ - -/* - * For state dump, check that "session" argument (mandatory) matches the - * session this event belongs to. Ensures that we write state dump data only - * into the started session, not into all sessions. - */ -#ifdef TP_SESSION_CHECK -#define _TP_SESSION_CHECK(session, csession) (session == csession) -#else /* TP_SESSION_CHECK */ -#define _TP_SESSION_CHECK(session, csession) 1 -#endif /* TP_SESSION_CHECK */ - -/* - * Using twice size for filter stack data to hold size and pointer for - * each field (worse case). For integers, max size required is 64-bit. - * Same for double-precision floats. Those fit within - * 2*sizeof(unsigned long) for all supported architectures. - * Perform UNION (||) of filter runtime list. - */ -#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE -#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE(_name, _proto, _args, _locvar, _code_pre, _fields, _code_post) \ -static void __event_probe__##_name(void *__data, _proto) \ -{ \ - struct probe_local_vars { _locvar }; \ - struct lttng_event *__event = __data; \ - struct lttng_probe_ctx __lttng_probe_ctx = { \ - .event = __event, \ - .interruptible = !irqs_disabled(), \ - }; \ - struct lttng_channel *__chan = __event->chan; \ - struct lttng_session *__session = __chan->session; \ - struct lib_ring_buffer_ctx __ctx; \ - ssize_t __event_len; \ - size_t __event_align; \ - size_t __orig_dynamic_len_offset, __dynamic_len_idx __attribute__((unused)); \ - union { \ - size_t __dynamic_len_removed[ARRAY_SIZE(__event_fields___##_name)]; \ - char __filter_stack_data[2 * sizeof(unsigned long) * ARRAY_SIZE(__event_fields___##_name)]; \ - } __stackvar; \ - int __ret; \ - struct probe_local_vars __tp_locvar; \ - struct probe_local_vars *tp_locvar __attribute__((unused)) = \ - &__tp_locvar; \ - struct lttng_id_tracker_rcu *__lf; \ - \ - if (!_TP_SESSION_CHECK(session, __session)) \ - return; \ - if (unlikely(!READ_ONCE(__session->active))) \ - return; \ - if (unlikely(!READ_ONCE(__chan->enabled))) \ - return; \ - if (unlikely(!READ_ONCE(__event->enabled))) \ - return; \ - __lf = rcu_dereference_raw_check(__session->pid_tracker.p); \ - if (__lf && likely(!lttng_id_tracker_lookup(__lf, current->tgid))) \ - return; \ - __lf = rcu_dereference_raw_check(__session->vpid_tracker.p); \ - if (__lf && likely(!lttng_id_tracker_lookup(__lf, task_tgid_vnr(current)))) \ - return; \ - __lf = rcu_dereference_raw_check(__session->uid_tracker.p); \ - if (__lf && likely(!lttng_id_tracker_lookup(__lf, \ - lttng_current_uid()))) \ - return; \ - __lf = rcu_dereference_raw_check(__session->vuid_tracker.p); \ - if (__lf && likely(!lttng_id_tracker_lookup(__lf, \ - lttng_current_vuid()))) \ - return; \ - __lf = rcu_dereference_raw_check(__session->gid_tracker.p); \ - if (__lf && likely(!lttng_id_tracker_lookup(__lf, \ - lttng_current_gid()))) \ - return; \ - __lf = rcu_dereference_raw_check(__session->vgid_tracker.p); \ - if (__lf && likely(!lttng_id_tracker_lookup(__lf, \ - lttng_current_vgid()))) \ - return; \ - __orig_dynamic_len_offset = this_cpu_ptr(<tng_dynamic_len_stack)->offset; \ - __dynamic_len_idx = __orig_dynamic_len_offset; \ - _code_pre \ - if (unlikely(!list_empty(&__event->bytecode_runtime_head))) { \ - struct lttng_bytecode_runtime *bc_runtime; \ - int __filter_record = __event->has_enablers_without_bytecode; \ - \ - __event_prepare_filter_stack__##_name(__stackvar.__filter_stack_data, \ - tp_locvar, _args); \ - list_for_each_entry_rcu_notrace(bc_runtime, &__event->bytecode_runtime_head, node) { \ - if (unlikely(bc_runtime->filter(bc_runtime, &__lttng_probe_ctx, \ - __stackvar.__filter_stack_data) & LTTNG_FILTER_RECORD_FLAG)) { \ - __filter_record = 1; \ - break; \ - } \ - } \ - if (likely(!__filter_record)) \ - goto __post; \ - } \ - __event_len = __event_get_size__##_name(tp_locvar, _args); \ - if (unlikely(__event_len < 0)) { \ - lib_ring_buffer_lost_event_too_big(__chan->chan); \ - goto __post; \ - } \ - __event_align = __event_get_align__##_name(tp_locvar, _args); \ - lib_ring_buffer_ctx_init(&__ctx, __chan->chan, &__lttng_probe_ctx, __event_len, \ - __event_align, -1); \ - __ret = __chan->ops->event_reserve(&__ctx, __event->id); \ - if (__ret < 0) \ - goto __post; \ - _fields \ - __chan->ops->event_commit(&__ctx); \ -__post: \ - _code_post \ - barrier(); /* use before un-reserve. */ \ - this_cpu_ptr(<tng_dynamic_len_stack)->offset = __orig_dynamic_len_offset; \ - return; \ -} - -#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS -#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS(_name, _locvar, _code_pre, _fields, _code_post) \ -static void __event_probe__##_name(void *__data) \ -{ \ - struct probe_local_vars { _locvar }; \ - struct lttng_event *__event = __data; \ - struct lttng_probe_ctx __lttng_probe_ctx = { \ - .event = __event, \ - .interruptible = !irqs_disabled(), \ - }; \ - struct lttng_channel *__chan = __event->chan; \ - struct lttng_session *__session = __chan->session; \ - struct lib_ring_buffer_ctx __ctx; \ - ssize_t __event_len; \ - size_t __event_align; \ - size_t __orig_dynamic_len_offset, __dynamic_len_idx __attribute__((unused)); \ - union { \ - size_t __dynamic_len_removed[ARRAY_SIZE(__event_fields___##_name)]; \ - char __filter_stack_data[2 * sizeof(unsigned long) * ARRAY_SIZE(__event_fields___##_name)]; \ - } __stackvar; \ - int __ret; \ - struct probe_local_vars __tp_locvar; \ - struct probe_local_vars *tp_locvar __attribute__((unused)) = \ - &__tp_locvar; \ - struct lttng_id_tracker_rcu *__lf; \ - \ - if (!_TP_SESSION_CHECK(session, __session)) \ - return; \ - if (unlikely(!READ_ONCE(__session->active))) \ - return; \ - if (unlikely(!READ_ONCE(__chan->enabled))) \ - return; \ - if (unlikely(!READ_ONCE(__event->enabled))) \ - return; \ - __lf = rcu_dereference_raw_check(__session->pid_tracker.p); \ - if (__lf && likely(!lttng_id_tracker_lookup(__lf, current->tgid))) \ - return; \ - __lf = rcu_dereference_raw_check(__session->vpid_tracker.p); \ - if (__lf && likely(!lttng_id_tracker_lookup(__lf, task_tgid_vnr(current)))) \ - return; \ - __lf = rcu_dereference_raw_check(__session->uid_tracker.p); \ - if (__lf && likely(!lttng_id_tracker_lookup(__lf, \ - lttng_current_uid()))) \ - return; \ - __lf = rcu_dereference_raw_check(__session->vuid_tracker.p); \ - if (__lf && likely(!lttng_id_tracker_lookup(__lf, \ - lttng_current_vuid()))) \ - return; \ - __lf = rcu_dereference_raw_check(__session->gid_tracker.p); \ - if (__lf && likely(!lttng_id_tracker_lookup(__lf, \ - lttng_current_gid()))) \ - return; \ - __lf = rcu_dereference_raw_check(__session->vgid_tracker.p); \ - if (__lf && likely(!lttng_id_tracker_lookup(__lf, \ - lttng_current_vgid()))) \ - return; \ - __orig_dynamic_len_offset = this_cpu_ptr(<tng_dynamic_len_stack)->offset; \ - __dynamic_len_idx = __orig_dynamic_len_offset; \ - _code_pre \ - if (unlikely(!list_empty(&__event->bytecode_runtime_head))) { \ - struct lttng_bytecode_runtime *bc_runtime; \ - int __filter_record = __event->has_enablers_without_bytecode; \ - \ - __event_prepare_filter_stack__##_name(__stackvar.__filter_stack_data, \ - tp_locvar); \ - list_for_each_entry_rcu_notrace(bc_runtime, &__event->bytecode_runtime_head, node) { \ - if (unlikely(bc_runtime->filter(bc_runtime, &__lttng_probe_ctx, \ - __stackvar.__filter_stack_data) & LTTNG_FILTER_RECORD_FLAG)) { \ - __filter_record = 1; \ - break; \ - } \ - } \ - if (likely(!__filter_record)) \ - goto __post; \ - } \ - __event_len = __event_get_size__##_name(tp_locvar); \ - if (unlikely(__event_len < 0)) { \ - lib_ring_buffer_lost_event_too_big(__chan->chan); \ - goto __post; \ - } \ - __event_align = __event_get_align__##_name(tp_locvar); \ - lib_ring_buffer_ctx_init(&__ctx, __chan->chan, &__lttng_probe_ctx, __event_len, \ - __event_align, -1); \ - __ret = __chan->ops->event_reserve(&__ctx, __event->id); \ - if (__ret < 0) \ - goto __post; \ - _fields \ - __chan->ops->event_commit(&__ctx); \ -__post: \ - _code_post \ - barrier(); /* use before un-reserve. */ \ - this_cpu_ptr(<tng_dynamic_len_stack)->offset = __orig_dynamic_len_offset; \ - return; \ -} - -#include TRACE_INCLUDE(TRACE_INCLUDE_FILE) - -#undef __get_dynamic_len - -/* - * Stage 7 of the trace events. - * - * Create event descriptions. - */ - -/* Named field types must be defined in lttng-types.h */ - -#include /* Reset all macros within LTTNG_TRACEPOINT_EVENT */ - -#ifndef TP_PROBE_CB -#define TP_PROBE_CB(_template) &__event_probe__##_template -#endif - -#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS -#define LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS(_template, _name, _map) \ -static const struct lttng_event_desc __event_desc___##_map = { \ - .fields = __event_fields___##_template, \ - .name = #_map, \ - .kname = #_name, \ - .probe_callback = (void *) TP_PROBE_CB(_template), \ - .nr_fields = ARRAY_SIZE(__event_fields___##_template), \ - .owner = THIS_MODULE, \ -}; - -#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP -#define LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(_template, _name, _map, _proto, _args) \ - LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS(_template, _name, _map) - -#include TRACE_INCLUDE(TRACE_INCLUDE_FILE) - -/* - * Stage 8 of the trace events. - * - * Create an array of event description pointers. - */ - -#include /* Reset all macros within LTTNG_TRACEPOINT_EVENT */ - -#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS -#define LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS(_template, _name, _map) \ - &__event_desc___##_map, - -#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP -#define LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(_template, _name, _map, _proto, _args) \ - LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS(_template, _name, _map) - -#define TP_ID1(_token, _system) _token##_system -#define TP_ID(_token, _system) TP_ID1(_token, _system) - -static const struct lttng_event_desc *TP_ID(__event_desc___, TRACE_SYSTEM)[] = { -#include TRACE_INCLUDE(TRACE_INCLUDE_FILE) -}; - -#undef TP_ID1 -#undef TP_ID - -/* - * Stage 9 of the trace events. - * - * Create a toplevel descriptor for the whole probe. - */ - -#define TP_ID1(_token, _system) _token##_system -#define TP_ID(_token, _system) TP_ID1(_token, _system) - -/* non-const because list head will be modified when registered. */ -static __used struct lttng_probe_desc TP_ID(__probe_desc___, TRACE_SYSTEM) = { - .provider = __stringify(TRACE_SYSTEM), - .event_desc = TP_ID(__event_desc___, TRACE_SYSTEM), - .nr_events = ARRAY_SIZE(TP_ID(__event_desc___, TRACE_SYSTEM)), - .head = { NULL, NULL }, - .lazy_init_head = { NULL, NULL }, - .lazy = 0, -}; - -#undef TP_ID1 -#undef TP_ID - -/* - * Stage 10 of the trace events. - * - * Register/unregister probes at module load/unload. - */ - -#include /* Reset all macros within LTTNG_TRACEPOINT_EVENT */ - -#define TP_ID1(_token, _system) _token##_system -#define TP_ID(_token, _system) TP_ID1(_token, _system) -#define module_init_eval1(_token, _system) module_init(_token##_system) -#define module_init_eval(_token, _system) module_init_eval1(_token, _system) -#define module_exit_eval1(_token, _system) module_exit(_token##_system) -#define module_exit_eval(_token, _system) module_exit_eval1(_token, _system) - -#ifndef TP_MODULE_NOINIT -static int TP_ID(__lttng_events_init__, TRACE_SYSTEM)(void) -{ - return lttng_probe_register(&TP_ID(__probe_desc___, TRACE_SYSTEM)); -} - -static void TP_ID(__lttng_events_exit__, TRACE_SYSTEM)(void) -{ - lttng_probe_unregister(&TP_ID(__probe_desc___, TRACE_SYSTEM)); -} - -#ifndef TP_MODULE_NOAUTOLOAD -module_init_eval(__lttng_events_init__, TRACE_SYSTEM); -module_exit_eval(__lttng_events_exit__, TRACE_SYSTEM); -#endif - -#endif - -#undef module_init_eval -#undef module_exit_eval -#undef TP_ID1 -#undef TP_ID - -#undef TP_PROTO -#undef TP_ARGS diff --git a/probes/lttng-tracepoint-event.h b/probes/lttng-tracepoint-event.h deleted file mode 100644 index 1a66245e..00000000 --- a/probes/lttng-tracepoint-event.h +++ /dev/null @@ -1,51 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) - * - * lttng-tracepoint-event.h - * - * Copyright (C) 2014 Mathieu Desnoyers - */ - -#ifndef LTTNG_TRACEPOINT_EVENT_H -#define LTTNG_TRACEPOINT_EVENT_H - -#include - -/* - * If code defines LTTNG_INSTRUMENTATION before including the instrumentation - * header, generate the instrumentation static inlines. Else, it means - * we are a probe for the Linux kernel, and it is the probe responsibility - * to have already included the Linux kernel instrumentation header. - */ -#ifdef LTTNG_INSTRUMENTATION -#define _LTTNG_INSTRUMENTATION(...) __VA_ARGS__ -#else -#define _LTTNG_INSTRUMENTATION(...) -#endif - -#define LTTNG_TRACEPOINT_EVENT(name, proto, args, fields) \ - _LTTNG_INSTRUMENTATION(DECLARE_TRACE(name, PARAMS(proto), PARAMS(args))) -#define LTTNG_TRACEPOINT_EVENT_CODE(name, proto, args, _locvar, _code_pre, fields, _code_post) \ - _LTTNG_INSTRUMENTATION(DECLARE_TRACE(name, PARAMS(proto), PARAMS(args))) -#define LTTNG_TRACEPOINT_EVENT_CODE_MAP(name, map, proto, args, _locvar, _code_pre, fields, _code_post) \ - _LTTNG_INSTRUMENTATION(DECLARE_TRACE(name, PARAMS(proto), PARAMS(args))) -#define LTTNG_TRACEPOINT_EVENT_MAP(name, map, proto, args, fields) \ - _LTTNG_INSTRUMENTATION(DECLARE_TRACE(name, PARAMS(proto), PARAMS(args))) -#define LTTNG_TRACEPOINT_EVENT_MAP_NOARGS(name, map, fields) \ - _LTTNG_INSTRUMENTATION(DECLARE_TRACE_NOARGS(name)) - -#define LTTNG_TRACEPOINT_EVENT_CLASS(name, proto, args, fields) -#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE(_name, _proto, _args, _locvar, _code_pre, _fields, _code_post) -#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS(_name, _locvar, _code_pre, _fields, _code_post) - -#define LTTNG_TRACEPOINT_EVENT_INSTANCE(template, name, proto, args) \ - _LTTNG_INSTRUMENTATION(DECLARE_TRACE(name, PARAMS(proto), PARAMS(args))) -#define LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(template, name) \ - _LTTNG_INSTRUMENTATION(DECLARE_TRACE_NOARGS(name)) -#define LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(_template, _name, _map, _proto, _args) \ - _LTTNG_INSTRUMENTATION(DECLARE_TRACE(name, PARAMS(proto), PARAMS(args))) -#define LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS(_template, _name, _map) \ - _LTTNG_INSTRUMENTATION(DECLARE_TRACE_NOARGS(name)) - -#define LTTNG_TRACEPOINT_ENUM(_name, _values) - -#endif /* LTTNG_TRACEPOINT_EVENT_H */ diff --git a/probes/lttng-types.h b/probes/lttng-types.h deleted file mode 100644 index f6b4785f..00000000 --- a/probes/lttng-types.h +++ /dev/null @@ -1,71 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) - * - * probes/lttng-types.h - * - * LTTng types. - * - * Copyright (C) 2010-2012 Mathieu Desnoyers - */ - -/* - * Protect against multiple inclusion of structure declarations, but run the - * stages below each time. - */ -#ifndef _LTTNG_PROBES_LTTNG_TYPES_H -#define _LTTNG_PROBES_LTTNG_TYPES_H - -#include -#include -#include -#include -#include - -#endif /* _LTTNG_PROBES_LTTNG_TYPES_H */ - -/* Export enumerations */ - -#ifdef STAGE_EXPORT_ENUMS - -#undef TRACE_EVENT_TYPE -#define TRACE_EVENT_TYPE(_name, _abstract_type, args...) - -#undef TRACE_EVENT_ENUM -#define TRACE_EVENT_ENUM(_name, _entries...) \ - const struct lttng_enum_entry __trace_event_enum_##_name[] = { \ - PARAMS(_entries) \ - }; - -/* Enumeration entry (single value) */ -#undef V -#define V(_string) { _string, _string, #_string} - -/* Enumeration entry (range) */ -#undef R -#define R(_string, _range_start, _range_end) \ - { _range_start, _range_end, #_string } - -#endif /* STAGE_EXPORT_ENUMS */ - - -/* Export named types */ - -#ifdef STAGE_EXPORT_TYPES - -#undef TRACE_EVENT_TYPE___enum -#define TRACE_EVENT_TYPE___enum(_name, _container_type) \ - { \ - .name = #_name, \ - .container_type = __type_integer(_container_type, 0, 0, -1, __BYTE_ORDER, 10, none), \ - .entries = __trace_event_enum_##_name, \ - .len = ARRAY_SIZE(__trace_event_enum_##_name), \ - }, - -/* Local declaration */ -#undef TRACE_EVENT_TYPE -#define TRACE_EVENT_TYPE(_name, _abstract_type, args...) \ - TRACE_EVENT_TYPE___##_abstract_type(_name, args) - -#undef TRACE_EVENT_ENUM -#define TRACE_EVENT_ENUM(_name, _entries...) - -#endif /* STAGE_EXPORT_TYPES */ diff --git a/probes/lttng-uprobes.c b/probes/lttng-uprobes.c index 268b5638..2cc23bb6 100644 --- a/probes/lttng-uprobes.c +++ b/probes/lttng-uprobes.c @@ -16,10 +16,10 @@ #include #include #include -#include -#include +#include +#include #include -#include +#include static int lttng_uprobes_handler_pre(struct uprobe_consumer *uc, struct pt_regs *regs) diff --git a/probes/lttng.c b/probes/lttng.c index ae7dce64..735b167d 100644 --- a/probes/lttng.c +++ b/probes/lttng.c @@ -16,7 +16,7 @@ #include #include #include -#include +#include #define TP_MODULE_NOAUTOLOAD #define LTTNG_PACKAGE_BUILD diff --git a/probes/lttng.h b/probes/lttng.h deleted file mode 100644 index 7d153be3..00000000 --- a/probes/lttng.h +++ /dev/null @@ -1,14 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) - * - * lttng.h - * - * Copyright (C) 2010-2012 Mathieu Desnoyers - */ - -#ifndef _LTTNG_PROBES_LTTNG_H -#define _LTTNG_PROBES_LTTNG_H - -#undef PARAMS -#define PARAMS(args...) args - -#endif /* _LTTNG_PROBES_LTTNG_H */ diff --git a/tests/Kbuild b/tests/Kbuild index 3e2edf5b..906cbac8 100644 --- a/tests/Kbuild +++ b/tests/Kbuild @@ -4,7 +4,7 @@ TOP_LTTNG_MODULES_DIR := $(shell dirname $(lastword $(MAKEFILE_LIST)))/.. include $(TOP_LTTNG_MODULES_DIR)/Kbuild.common -ccflags-y += -I$(TOP_LTTNG_MODULES_DIR) +ccflags-y += -I$(TOP_LTTNG_MODULES_DIR)/include obj-$(CONFIG_LTTNG) += lttng-test.o lttng-test-objs := probes/lttng-test.o diff --git a/tests/clock-plugin/lttng-clock-plugin-test.c b/tests/clock-plugin/lttng-clock-plugin-test.c index f0ae2211..d35ecc4a 100644 --- a/tests/clock-plugin/lttng-clock-plugin-test.c +++ b/tests/clock-plugin/lttng-clock-plugin-test.c @@ -10,8 +10,8 @@ #include #include -#include -#include /* From lttng-modules */ +#include +#include /* From lttng-modules */ static u64 trace_clock_read64_example(void) { diff --git a/tests/probes/lttng-test.c b/tests/probes/lttng-test.c index 7654d1fb..5f29fb92 100644 --- a/tests/probes/lttng-test.c +++ b/tests/probes/lttng-test.c @@ -13,8 +13,8 @@ #include #include -#include -#include +#include +#include #define TP_MODULE_NOAUTOLOAD #define LTTNG_PACKAGE_BUILD diff --git a/trace-clock.c b/trace-clock.c new file mode 100644 index 00000000..74995fef --- /dev/null +++ b/trace-clock.c @@ -0,0 +1,20 @@ +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) + * + * wrapper/trace-clock.c + * + * Contains LTTng trace clock mapping to LTTng trace clock or mainline monotonic + * clock. This wrapper depends on CONFIG_HIGH_RES_TIMERS=y. + * + * Copyright (C) 2011-2012 Mathieu Desnoyers + */ + +#include + +#ifdef LTTNG_USE_NMI_SAFE_CLOCK +DEFINE_PER_CPU(u64, lttng_last_tsc); +EXPORT_PER_CPU_SYMBOL(lttng_last_tsc); +#endif /* #ifdef LTTNG_USE_NMI_SAFE_CLOCK */ + +#ifdef LTTNG_CLOCK_NMI_SAFE_BROKEN +#warning "Your kernel implements a bogus nmi-safe clock source. Falling back to the non-nmi-safe clock source, which discards events traced from NMI context. Upgrade your kernel to resolve this situation." +#endif diff --git a/wrapper/irqflags.h b/wrapper/irqflags.h deleted file mode 100644 index 3037eaea..00000000 --- a/wrapper/irqflags.h +++ /dev/null @@ -1,40 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) - * - * wrapper/irqflags.h - * - * wrapper around IRQ flags. - * - * Copyright (C) 2015 Mathieu Desnoyers - */ - -#ifndef _LTTNG_WRAPPER_IRQFLAGS_H -#define _LTTNG_WRAPPER_IRQFLAGS_H - -#include -#include - -#ifdef CONFIG_X86 - -static inline -int lttng_regs_irqs_disabled(struct pt_regs *regs) -{ - unsigned long flags = regs->flags; - - return raw_irqs_disabled_flags(flags); -} - -#else -/* - * lttng_regs_irqs_disabled() returns -1 if irqoff state is unknown. - * TODO: should implement lttng_regs_irqs_disabled for each architecture - * to add interruptible context for kprobes and kretprobes. - */ - -static inline -int lttng_regs_irqs_disabled(struct pt_regs *regs) -{ - return -1; -} -#endif - -#endif /* _LTTNG_WRAPPER_IRQFLAGS_H */ diff --git a/wrapper/trace-clock.c b/wrapper/trace-clock.c deleted file mode 100644 index 74995fef..00000000 --- a/wrapper/trace-clock.c +++ /dev/null @@ -1,20 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) - * - * wrapper/trace-clock.c - * - * Contains LTTng trace clock mapping to LTTng trace clock or mainline monotonic - * clock. This wrapper depends on CONFIG_HIGH_RES_TIMERS=y. - * - * Copyright (C) 2011-2012 Mathieu Desnoyers - */ - -#include - -#ifdef LTTNG_USE_NMI_SAFE_CLOCK -DEFINE_PER_CPU(u64, lttng_last_tsc); -EXPORT_PER_CPU_SYMBOL(lttng_last_tsc); -#endif /* #ifdef LTTNG_USE_NMI_SAFE_CLOCK */ - -#ifdef LTTNG_CLOCK_NMI_SAFE_BROKEN -#warning "Your kernel implements a bogus nmi-safe clock source. Falling back to the non-nmi-safe clock source, which discards events traced from NMI context. Upgrade your kernel to resolve this situation." -#endif diff --git a/wrapper/trace-clock.h b/wrapper/trace-clock.h deleted file mode 100644 index 28ee90eb..00000000 --- a/wrapper/trace-clock.h +++ /dev/null @@ -1,212 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) - * - * wrapper/trace-clock.h - * - * Contains LTTng trace clock mapping to LTTng trace clock or mainline monotonic - * clock. This wrapper depends on CONFIG_HIGH_RES_TIMERS=y. - * - * Copyright (C) 2011-2012 Mathieu Desnoyers - */ - -#ifndef _LTTNG_TRACE_CLOCK_H -#define _LTTNG_TRACE_CLOCK_H - -#ifdef CONFIG_HAVE_TRACE_CLOCK -#include -#else /* CONFIG_HAVE_TRACE_CLOCK */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -extern struct lttng_trace_clock *lttng_trace_clock; - -/* - * We need clock values to be monotonically increasing per-cpu, which is - * not strictly guaranteed by ktime_get_mono_fast_ns(). It is - * straightforward to do on architectures with a 64-bit cmpxchg(), but - * not so on architectures without 64-bit cmpxchg. For now, only enable - * this feature on 64-bit architectures. - */ - -#if BITS_PER_LONG == 64 -#define LTTNG_USE_NMI_SAFE_CLOCK -#endif - -#ifdef LTTNG_USE_NMI_SAFE_CLOCK - -DECLARE_PER_CPU(u64, lttng_last_tsc); - -/* - * Sometimes called with preemption enabled. Can be interrupted. - */ -static inline u64 trace_clock_monotonic_wrapper(void) -{ - u64 now, last, result; - u64 *last_tsc_ptr; - - /* Use fast nmi-safe monotonic clock provided by the Linux kernel. */ - preempt_disable(); - last_tsc_ptr = this_cpu_ptr(<tng_last_tsc); - last = *last_tsc_ptr; - /* - * Read "last" before "now". It is not strictly required, but it ensures - * that an interrupt coming in won't artificially trigger a case where - * "now" < "last". This kind of situation should only happen if the - * mono_fast time source goes slightly backwards. - */ - barrier(); - now = ktime_get_mono_fast_ns(); - if (U64_MAX / 2 < now - last) - now = last; - result = cmpxchg64_local(last_tsc_ptr, last, now); - preempt_enable(); - if (result == last) { - /* Update done. */ - return now; - } else { - /* - * Update not done, due to concurrent update. We can use - * "result", since it has been sampled concurrently with our - * time read, so it should not be far from "now". - */ - return result; - } -} - -#else /* #ifdef LTTNG_USE_NMI_SAFE_CLOCK */ -static inline u64 trace_clock_monotonic_wrapper(void) -{ - ktime_t ktime; - - /* - * Refuse to trace from NMIs with this wrapper, because an NMI could - * nest over the xtime write seqlock and deadlock. - */ - if (in_nmi()) - return (u64) -EIO; - - ktime = ktime_get(); - return ktime_to_ns(ktime); -} -#endif /* #else #ifdef LTTNG_USE_NMI_SAFE_CLOCK */ - -static inline u64 trace_clock_read64_monotonic(void) -{ - return (u64) trace_clock_monotonic_wrapper(); -} - -static inline u64 trace_clock_freq_monotonic(void) -{ - return (u64) NSEC_PER_SEC; -} - -static inline int trace_clock_uuid_monotonic(char *uuid) -{ - unsigned char *boot_id; - - boot_id = get_kernel_boot_id(); - sprintf(uuid, "%pU", boot_id); - return 0; -} - -static inline const char *trace_clock_name_monotonic(void) -{ - return "monotonic"; -} - -static inline const char *trace_clock_description_monotonic(void) -{ - return "Monotonic Clock"; -} - -#ifdef LTTNG_USE_NMI_SAFE_CLOCK -static inline int get_trace_clock(void) -{ - printk_once(KERN_WARNING "LTTng: Using mainline kernel monotonic fast clock, which is NMI-safe.\n"); - return 0; -} -#else /* #ifdef LTTNG_USE_NMI_SAFE_CLOCK */ -static inline int get_trace_clock(void) -{ - printk_once(KERN_WARNING "LTTng: Using mainline kernel monotonic clock. NMIs will not be traced.\n"); - return 0; -} -#endif /* #else #ifdef LTTNG_USE_NMI_SAFE_CLOCK */ - -static inline void put_trace_clock(void) -{ -} - -static inline u64 trace_clock_read64(void) -{ - struct lttng_trace_clock *ltc = READ_ONCE(lttng_trace_clock); - - if (likely(!ltc)) { - return trace_clock_read64_monotonic(); - } else { - read_barrier_depends(); /* load ltc before content */ - return ltc->read64(); - } -} - -static inline u64 trace_clock_freq(void) -{ - struct lttng_trace_clock *ltc = READ_ONCE(lttng_trace_clock); - - if (!ltc) { - return trace_clock_freq_monotonic(); - } else { - read_barrier_depends(); /* load ltc before content */ - return ltc->freq(); - } -} - -static inline int trace_clock_uuid(char *uuid) -{ - struct lttng_trace_clock *ltc = READ_ONCE(lttng_trace_clock); - - read_barrier_depends(); /* load ltc before content */ - /* Use default UUID cb when NULL */ - if (!ltc || !ltc->uuid) { - return trace_clock_uuid_monotonic(uuid); - } else { - return ltc->uuid(uuid); - } -} - -static inline const char *trace_clock_name(void) -{ - struct lttng_trace_clock *ltc = READ_ONCE(lttng_trace_clock); - - if (!ltc) { - return trace_clock_name_monotonic(); - } else { - read_barrier_depends(); /* load ltc before content */ - return ltc->name(); - } -} - -static inline const char *trace_clock_description(void) -{ - struct lttng_trace_clock *ltc = READ_ONCE(lttng_trace_clock); - - if (!ltc) { - return trace_clock_description_monotonic(); - } else { - read_barrier_depends(); /* load ltc before content */ - return ltc->description(); - } -} - -#endif /* CONFIG_HAVE_TRACE_CLOCK */ - -#endif /* _LTTNG_TRACE_CLOCK_H */ diff --git a/wrapper/user_namespace.h b/wrapper/user_namespace.h deleted file mode 100644 index 8cc60207..00000000 --- a/wrapper/user_namespace.h +++ /dev/null @@ -1,70 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) - * - * wrapper/user_namespace.h - * - * Copyright (C) 2019 Michael Jeanson - * - */ - -#ifndef _LTTNG_WRAPPER_USER_NAMESPACE_H -#define _LTTNG_WRAPPER_USER_NAMESPACE_H - -#include -#include - - -#define lttng_current_xxuid(xxx) \ - (from_kuid_munged(&init_user_ns, current_##xxx())) - -#define lttng_current_vxxuid(xxx) \ - (from_kuid_munged(current_user_ns(), current_##xxx())) - -#define lttng_current_xxgid(xxx) \ - (from_kgid_munged(&init_user_ns, current_##xxx())) - -#define lttng_current_vxxgid(xxx) \ - (from_kgid_munged(current_user_ns(), current_##xxx())) - -static inline -uid_t lttng_task_vuid(struct task_struct *p, struct user_namespace *ns) -{ - uid_t uid; - kuid_t kuid; - - kuid = task_cred_xxx(p, uid); - uid = from_kuid_munged(ns, kuid); - - return uid; -} - -static inline -gid_t lttng_task_vgid(struct task_struct *p, struct user_namespace *ns) -{ - gid_t gid; - kgid_t kgid; - - kgid = task_cred_xxx(p, gid); - gid = from_kgid_munged(ns, kgid); - - return gid; -} - -#define lttng_current_uid() (lttng_current_xxuid(uid)) -#define lttng_current_euid() (lttng_current_xxuid(euid)) -#define lttng_current_suid() (lttng_current_xxuid(suid)) -#define lttng_current_fsuid() (lttng_current_xxuid(fsuid)) -#define lttng_current_gid() (lttng_current_xxgid(gid)) -#define lttng_current_egid() (lttng_current_xxgid(egid)) -#define lttng_current_sgid() (lttng_current_xxgid(sgid)) -#define lttng_current_fsgid() (lttng_current_xxgid(fsgid)) - -#define lttng_current_vuid() (lttng_current_vxxuid(uid)) -#define lttng_current_veuid() (lttng_current_vxxuid(euid)) -#define lttng_current_vsuid() (lttng_current_vxxuid(suid)) -#define lttng_current_vfsuid() (lttng_current_vxxuid(fsuid)) -#define lttng_current_vgid() (lttng_current_vxxgid(gid)) -#define lttng_current_vegid() (lttng_current_vxxgid(egid)) -#define lttng_current_vsgid() (lttng_current_vxxgid(sgid)) -#define lttng_current_vfsgid() (lttng_current_vxxgid(fsgid)) - -#endif /* _LTTNG_WRAPPER_USER_NAMESPACE_H */