-#if !defined(_TRACE_KVMMMU_H) || defined(TRACE_HEADER_MULTI_READ)
-#define _TRACE_KVMMMU_H
+#if !defined(LTTNG_TRACE_KVMMMU_H) || defined(TRACE_HEADER_MULTI_READ)
+#define LTTNG_TRACE_KVMMMU_H
-#include <linux/tracepoint.h>
+#include "../../../../../../probes/lttng-tracepoint-event.h"
#include <linux/ftrace_event.h>
#undef TRACE_SYSTEM
/*
* A pagetable walk has started
*/
-TRACE_EVENT(
+LTTNG_TRACEPOINT_EVENT(
kvm_mmu_pagetable_walk,
TP_PROTO(u64 addr, u32 pferr),
TP_ARGS(addr, pferr),
/* We just walked a paging element */
-TRACE_EVENT(
+LTTNG_TRACEPOINT_EVENT(
kvm_mmu_paging_element,
TP_PROTO(u64 pte, int level),
TP_ARGS(pte, level),
TP_printk("pte %llx level %u", __entry->pte, __entry->level)
)
-DECLARE_EVENT_CLASS(kvm_mmu_set_bit_class,
+LTTNG_TRACEPOINT_EVENT_CLASS(kvm_mmu_set_bit_class,
TP_PROTO(unsigned long table_gfn, unsigned index, unsigned size),
)
/* We set a pte accessed bit */
-DEFINE_EVENT(kvm_mmu_set_bit_class, kvm_mmu_set_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),
)
/* We set a pte dirty bit */
-DEFINE_EVENT(kvm_mmu_set_bit_class, kvm_mmu_set_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)
)
-TRACE_EVENT(
+LTTNG_TRACEPOINT_EVENT(
kvm_mmu_walker_error,
TP_PROTO(u32 pferr),
TP_ARGS(pferr),
__print_flags(__entry->pferr, "|", kvm_mmu_trace_pferr_flags))
)
-TRACE_EVENT(
+LTTNG_TRACEPOINT_EVENT(
kvm_mmu_get_page,
TP_PROTO(struct kvm_mmu_page *sp, bool created),
TP_ARGS(sp, created),
__entry->created ? "new" : "existing")
)
-DECLARE_EVENT_CLASS(kvm_mmu_page_class,
+LTTNG_TRACEPOINT_EVENT_CLASS(kvm_mmu_page_class,
TP_PROTO(struct kvm_mmu_page *sp),
TP_ARGS(sp),
TP_printk("%s", KVM_MMU_PAGE_PRINTK())
)
-DEFINE_EVENT(kvm_mmu_page_class, kvm_mmu_sync_page,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(kvm_mmu_page_class, kvm_mmu_sync_page,
TP_PROTO(struct kvm_mmu_page *sp),
TP_ARGS(sp)
)
-DEFINE_EVENT(kvm_mmu_page_class, kvm_mmu_unsync_page,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(kvm_mmu_page_class, kvm_mmu_unsync_page,
TP_PROTO(struct kvm_mmu_page *sp),
TP_ARGS(sp)
)
-DEFINE_EVENT(kvm_mmu_page_class, kvm_mmu_prepare_zap_page,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(kvm_mmu_page_class, kvm_mmu_prepare_zap_page,
TP_PROTO(struct kvm_mmu_page *sp),
TP_ARGS(sp)
)
-TRACE_EVENT(
+LTTNG_TRACEPOINT_EVENT(
mark_mmio_spte,
TP_PROTO(u64 *sptep, gfn_t gfn, unsigned access),
TP_ARGS(sptep, gfn, access),
__entry->access)
)
-TRACE_EVENT(
+LTTNG_TRACEPOINT_EVENT(
handle_mmio_page_fault,
TP_PROTO(u64 addr, gfn_t gfn, unsigned access),
TP_ARGS(addr, gfn, access),
#define __spte_satisfied(__spte) \
(__entry->retry && is_writable_pte(__entry->__spte))
-TRACE_EVENT(
+LTTNG_TRACEPOINT_EVENT(
fast_page_fault,
TP_PROTO(struct kvm_vcpu *vcpu, gva_t gva, u32 error_code,
u64 *sptep, u64 old_spte, bool retry),
__spte_satisfied(old_spte), __spte_satisfied(new_spte)
)
)
-#endif /* _TRACE_KVMMMU_H */
+#endif /* LTTNG_TRACE_KVMMMU_H */
#undef TRACE_INCLUDE_PATH
#define TRACE_INCLUDE_PATH ../instrumentation/events/lttng-module/arch/x86/kvm
-#if !defined(_TRACE_KVM_H) || defined(TRACE_HEADER_MULTI_READ)
-#define _TRACE_KVM_H
+#if !defined(LTTNG_TRACE_KVM_H) || defined(TRACE_HEADER_MULTI_READ)
+#define LTTNG_TRACE_KVM_H
-#include <linux/tracepoint.h>
+#include "../../../../../../probes/lttng-tracepoint-event.h"
#include <asm/vmx.h>
#include <asm/svm.h>
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,8,0))
/*
* Tracepoint for guest mode entry.
*/
-TRACE_EVENT(kvm_entry,
+LTTNG_TRACEPOINT_EVENT(kvm_entry,
TP_PROTO(unsigned int vcpu_id),
TP_ARGS(vcpu_id),
/*
* Tracepoint for hypercall.
*/
-TRACE_EVENT(kvm_hypercall,
+LTTNG_TRACEPOINT_EVENT(kvm_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),
/*
* Tracepoint for hypercall.
*/
-TRACE_EVENT(kvm_hv_hypercall,
+LTTNG_TRACEPOINT_EVENT(kvm_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),
/*
* Tracepoint for PIO.
*/
-TRACE_EVENT(kvm_pio,
+LTTNG_TRACEPOINT_EVENT(kvm_pio,
TP_PROTO(unsigned int rw, unsigned int port, unsigned int size,
unsigned int count),
TP_ARGS(rw, port, size, count),
/*
* Tracepoint for cpuid.
*/
-TRACE_EVENT(kvm_cpuid,
+LTTNG_TRACEPOINT_EVENT(kvm_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),
/*
* Tracepoint for apic access.
*/
-TRACE_EVENT(kvm_apic,
+LTTNG_TRACEPOINT_EVENT(kvm_apic,
TP_PROTO(unsigned int rw, unsigned int reg, unsigned int val),
TP_ARGS(rw, reg, val),
/*
* Tracepoint for kvm guest exit:
*/
-TRACE_EVENT(kvm_exit,
+LTTNG_TRACEPOINT_EVENT(kvm_exit,
TP_PROTO(unsigned int exit_reason, struct kvm_vcpu *vcpu, u32 isa, u64 info1, u64 info2),
TP_ARGS(exit_reason, vcpu, isa, info1, info2),
/*
* Tracepoint for kvm interrupt injection:
*/
-TRACE_EVENT(kvm_inj_virq,
+LTTNG_TRACEPOINT_EVENT(kvm_inj_virq,
TP_PROTO(unsigned int irq),
TP_ARGS(irq),
/*
* Tracepoint for kvm interrupt injection:
*/
-TRACE_EVENT(kvm_inj_exception,
+LTTNG_TRACEPOINT_EVENT(kvm_inj_exception,
TP_PROTO(unsigned exception, bool has_error, unsigned error_code),
TP_ARGS(exception, has_error, error_code),
/*
* Tracepoint for page fault.
*/
-TRACE_EVENT(kvm_page_fault,
+LTTNG_TRACEPOINT_EVENT(kvm_page_fault,
TP_PROTO(unsigned long fault_address, unsigned int error_code),
TP_ARGS(fault_address, error_code),
/*
* Tracepoint for guest MSR access.
*/
-TRACE_EVENT(kvm_msr,
+LTTNG_TRACEPOINT_EVENT(kvm_msr,
TP_PROTO(unsigned write, u32 ecx, u64 data, bool exception),
TP_ARGS(write, ecx, data, exception),
/*
* Tracepoint for guest CR access.
*/
-TRACE_EVENT(kvm_cr,
+LTTNG_TRACEPOINT_EVENT(kvm_cr,
TP_PROTO(unsigned int rw, unsigned int cr, unsigned long val),
TP_ARGS(rw, cr, 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)
-TRACE_EVENT(kvm_pic_set_irq,
+LTTNG_TRACEPOINT_EVENT(kvm_pic_set_irq,
TP_PROTO(__u8 chip, __u8 pin, __u8 elcr, __u8 imr, bool coalesced),
TP_ARGS(chip, pin, elcr, imr, coalesced),
{0x2, "all"}, \
{0x3, "all-but-self"}
-TRACE_EVENT(kvm_apic_ipi,
+LTTNG_TRACEPOINT_EVENT(kvm_apic_ipi,
TP_PROTO(__u32 icr_low, __u32 dest_id),
TP_ARGS(icr_low, dest_id),
kvm_apic_dst_shorthand))
)
-TRACE_EVENT(kvm_apic_accept_irq,
+LTTNG_TRACEPOINT_EVENT(kvm_apic_accept_irq,
TP_PROTO(__u32 apicid, __u16 dm, __u8 tm, __u8 vec, bool coalesced),
TP_ARGS(apicid, dm, tm, vec, coalesced),
__entry->coalesced ? " (coalesced)" : "")
)
-TRACE_EVENT(kvm_eoi,
+LTTNG_TRACEPOINT_EVENT(kvm_eoi,
TP_PROTO(struct kvm_lapic *apic, int vector),
TP_ARGS(apic, vector),
TP_printk("apicid %x vector %d", __entry->apicid, __entry->vector)
)
-TRACE_EVENT(kvm_pv_eoi,
+LTTNG_TRACEPOINT_EVENT(kvm_pv_eoi,
TP_PROTO(struct kvm_lapic *apic, int vector),
TP_ARGS(apic, vector),
/*
* Tracepoint for nested VMRUN
*/
-TRACE_EVENT(kvm_nested_vmrun,
+LTTNG_TRACEPOINT_EVENT(kvm_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),
__entry->npt ? "on" : "off")
)
-TRACE_EVENT(kvm_nested_intercepts,
+LTTNG_TRACEPOINT_EVENT(kvm_nested_intercepts,
TP_PROTO(__u16 cr_read, __u16 cr_write, __u32 exceptions, __u64 intercept),
TP_ARGS(cr_read, cr_write, exceptions, intercept),
/*
* Tracepoint for #VMEXIT while nested
*/
-TRACE_EVENT(kvm_nested_vmexit,
+LTTNG_TRACEPOINT_EVENT(kvm_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),
/*
* Tracepoint for #VMEXIT reinjected to the guest
*/
-TRACE_EVENT(kvm_nested_vmexit_inject,
+LTTNG_TRACEPOINT_EVENT(kvm_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),
/*
* Tracepoint for nested #vmexit because of interrupt pending
*/
-TRACE_EVENT(kvm_nested_intr_vmexit,
+LTTNG_TRACEPOINT_EVENT(kvm_nested_intr_vmexit,
TP_PROTO(__u64 rip),
TP_ARGS(rip),
/*
* Tracepoint for nested #vmexit because of interrupt pending
*/
-TRACE_EVENT(kvm_invlpga,
+LTTNG_TRACEPOINT_EVENT(kvm_invlpga,
TP_PROTO(__u64 rip, int asid, u64 address),
TP_ARGS(rip, asid, address),
/*
* Tracepoint for nested #vmexit because of interrupt pending
*/
-TRACE_EVENT(kvm_skinit,
+LTTNG_TRACEPOINT_EVENT(kvm_skinit,
TP_PROTO(__u64 rip, __u32 slb),
TP_ARGS(rip, slb),
flags; \
})
-TRACE_EVENT(kvm_emulate_insn,
+LTTNG_TRACEPOINT_EVENT(kvm_emulate_insn,
TP_PROTO(struct kvm_vcpu *vcpu, __u8 failed),
TP_ARGS(vcpu, 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)
-TRACE_EVENT(
+LTTNG_TRACEPOINT_EVENT(
vcpu_match_mmio,
TP_PROTO(gva_t gva, gpa_t gpa, bool write, bool gpa_match),
TP_ARGS(gva, gpa, write, gpa_match),
)
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,11,0))
-TRACE_EVENT(kvm_write_tsc_offset,
+LTTNG_TRACEPOINT_EVENT(kvm_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),
{VCLOCK_TSC, "tsc"}, \
{VCLOCK_HPET, "hpet"} \
-TRACE_EVENT(kvm_update_master_clock,
+LTTNG_TRACEPOINT_EVENT(kvm_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),
__entry->offset_matched)
)
-TRACE_EVENT(kvm_track_tsc,
+LTTNG_TRACEPOINT_EVENT(kvm_track_tsc,
TP_PROTO(unsigned int vcpu_id, unsigned int nr_matched,
unsigned int online_vcpus, bool use_master_clock,
unsigned int host_clock),
#endif /* CONFIG_X86_64 */
#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(3,8,0) */
-#endif /* _TRACE_KVM_H */
+#endif /* LTTNG_TRACE_KVM_H */
#undef TRACE_INCLUDE_PATH
#define TRACE_INCLUDE_PATH ../instrumentation/events/lttng-module/arch/x86/kvm
#undef TRACE_SYSTEM
#define TRACE_SYSTEM asoc
-#if !defined(_TRACE_ASOC_H) || defined(TRACE_HEADER_MULTI_READ)
-#define _TRACE_ASOC_H
+#if !defined(LTTNG_TRACE_ASOC_H) || defined(TRACE_HEADER_MULTI_READ)
+#define LTTNG_TRACE_ASOC_H
+#include "../../../probes/lttng-tracepoint-event.h"
#include <linux/ktime.h>
-#include <linux/tracepoint.h>
#include <linux/version.h>
#define DAPM_DIRECT "(direct)"
/*
* Log register events
*/
-DECLARE_EVENT_CLASS(snd_soc_reg,
+LTTNG_TRACEPOINT_EVENT_CLASS(snd_soc_reg,
TP_PROTO(struct snd_soc_codec *codec, unsigned int reg,
unsigned int val),
(unsigned int)__entry->val)
)
-DEFINE_EVENT(snd_soc_reg, snd_soc_reg_write,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(snd_soc_reg, snd_soc_reg_write,
TP_PROTO(struct snd_soc_codec *codec, unsigned int reg,
unsigned int val),
)
-DEFINE_EVENT(snd_soc_reg, snd_soc_reg_read,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(snd_soc_reg, snd_soc_reg_read,
TP_PROTO(struct snd_soc_codec *codec, unsigned int reg,
unsigned int val),
)
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,1,0))
-DECLARE_EVENT_CLASS(snd_soc_preg,
+LTTNG_TRACEPOINT_EVENT_CLASS(snd_soc_preg,
TP_PROTO(struct snd_soc_platform *platform, unsigned int reg,
unsigned int val),
(unsigned int)__entry->val)
)
-DEFINE_EVENT(snd_soc_preg, snd_soc_preg_write,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(snd_soc_preg, snd_soc_preg_write,
TP_PROTO(struct snd_soc_platform *platform, unsigned int reg,
unsigned int val),
)
-DEFINE_EVENT(snd_soc_preg, snd_soc_preg_read,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(snd_soc_preg, snd_soc_preg_read,
TP_PROTO(struct snd_soc_platform *platform, unsigned int reg,
unsigned int val),
)
#endif
-DECLARE_EVENT_CLASS(snd_soc_card,
+LTTNG_TRACEPOINT_EVENT_CLASS(snd_soc_card,
TP_PROTO(struct snd_soc_card *card, int val),
TP_printk("card=%s val=%d", __get_str(name), (int)__entry->val)
)
-DEFINE_EVENT(snd_soc_card, snd_soc_bias_level_start,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(snd_soc_card, snd_soc_bias_level_start,
TP_PROTO(struct snd_soc_card *card, int val),
)
-DEFINE_EVENT(snd_soc_card, snd_soc_bias_level_done,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(snd_soc_card, snd_soc_bias_level_done,
TP_PROTO(struct snd_soc_card *card, int val),
)
-DECLARE_EVENT_CLASS(snd_soc_dapm_basic,
+LTTNG_TRACEPOINT_EVENT_CLASS(snd_soc_dapm_basic,
TP_PROTO(struct snd_soc_card *card),
TP_printk("card=%s", __get_str(name))
)
-DEFINE_EVENT(snd_soc_dapm_basic, snd_soc_dapm_start,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(snd_soc_dapm_basic, snd_soc_dapm_start,
TP_PROTO(struct snd_soc_card *card),
)
-DEFINE_EVENT(snd_soc_dapm_basic, snd_soc_dapm_done,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(snd_soc_dapm_basic, snd_soc_dapm_done,
TP_PROTO(struct snd_soc_card *card),
)
-DECLARE_EVENT_CLASS(snd_soc_dapm_widget,
+LTTNG_TRACEPOINT_EVENT_CLASS(snd_soc_dapm_widget,
TP_PROTO(struct snd_soc_dapm_widget *w, int val),
(int)__entry->val)
)
-DEFINE_EVENT(snd_soc_dapm_widget, snd_soc_dapm_widget_power,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(snd_soc_dapm_widget, snd_soc_dapm_widget_power,
TP_PROTO(struct snd_soc_dapm_widget *w, int val),
)
-DEFINE_EVENT(snd_soc_dapm_widget, snd_soc_dapm_widget_event_start,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(snd_soc_dapm_widget, snd_soc_dapm_widget_event_start,
TP_PROTO(struct snd_soc_dapm_widget *w, int val),
)
-DEFINE_EVENT(snd_soc_dapm_widget, snd_soc_dapm_widget_event_done,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(snd_soc_dapm_widget, snd_soc_dapm_widget_event_done,
TP_PROTO(struct snd_soc_dapm_widget *w, int val),
)
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
-TRACE_EVENT(snd_soc_dapm_walk_done,
+LTTNG_TRACEPOINT_EVENT(snd_soc_dapm_walk_done,
TP_PROTO(struct snd_soc_card *card),
#endif
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,5,0))
-TRACE_EVENT(snd_soc_dapm_output_path,
+LTTNG_TRACEPOINT_EVENT(snd_soc_dapm_output_path,
TP_PROTO(struct snd_soc_dapm_widget *widget,
struct snd_soc_dapm_path *path),
__get_str(wname), __get_str(pname), __get_str(psname))
)
-TRACE_EVENT(snd_soc_dapm_input_path,
+LTTNG_TRACEPOINT_EVENT(snd_soc_dapm_input_path,
TP_PROTO(struct snd_soc_dapm_widget *widget,
struct snd_soc_dapm_path *path),
__get_str(wname), __get_str(pname), __get_str(psname))
)
-TRACE_EVENT(snd_soc_dapm_connected,
+LTTNG_TRACEPOINT_EVENT(snd_soc_dapm_connected,
TP_PROTO(int paths, int stream),
)
#endif
-TRACE_EVENT(snd_soc_jack_irq,
+LTTNG_TRACEPOINT_EVENT(snd_soc_jack_irq,
TP_PROTO(const char *name),
TP_printk("%s", __get_str(name))
)
-TRACE_EVENT(snd_soc_jack_report,
+LTTNG_TRACEPOINT_EVENT(snd_soc_jack_report,
TP_PROTO(struct snd_soc_jack *jack, int mask, int val),
(int)__entry->mask)
)
-TRACE_EVENT(snd_soc_jack_notify,
+LTTNG_TRACEPOINT_EVENT(snd_soc_jack_notify,
TP_PROTO(struct snd_soc_jack *jack, int val),
TP_printk("jack=%s %x", __get_str(name), (int)__entry->val)
)
-TRACE_EVENT(snd_soc_cache_sync,
+LTTNG_TRACEPOINT_EVENT(snd_soc_cache_sync,
TP_PROTO(struct snd_soc_codec *codec, const char *type,
const char *status),
(int)__entry->id, __get_str(type), __get_str(status))
)
-#endif /* _TRACE_ASOC_H */
+#endif /* LTTNG_TRACE_ASOC_H */
/* This part must be outside protection */
#include "../../../probes/define_trace.h"
#undef TRACE_SYSTEM
#define TRACE_SYSTEM block
-#if !defined(_TRACE_BLOCK_H) || defined(TRACE_HEADER_MULTI_READ)
-#define _TRACE_BLOCK_H
+#if !defined(LTTNG_TRACE_BLOCK_H) || defined(TRACE_HEADER_MULTI_READ)
+#define LTTNG_TRACE_BLOCK_H
+#include "../../../probes/lttng-tracepoint-event.h"
#include <linux/blktrace_api.h>
#include <linux/blkdev.h>
-#include <linux/tracepoint.h>
#include <linux/trace_seq.h>
#include <linux/version.h>
#endif
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,9,0))
-DECLARE_EVENT_CLASS(block_buffer,
+LTTNG_TRACEPOINT_EVENT_CLASS(block_buffer,
TP_PROTO(struct buffer_head *bh),
*
* Called from touch_buffer().
*/
-DEFINE_EVENT(block_buffer, block_touch_buffer,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(block_buffer, block_touch_buffer,
TP_PROTO(struct buffer_head *bh),
*
* Called from mark_buffer_dirty().
*/
-DEFINE_EVENT(block_buffer, block_dirty_buffer,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(block_buffer, block_dirty_buffer,
TP_PROTO(struct buffer_head *bh),
)
#endif
-DECLARE_EVENT_CLASS(block_rq_with_error,
+LTTNG_TRACEPOINT_EVENT_CLASS(block_rq_with_error,
TP_PROTO(struct request_queue *q, struct request *rq),
* can be examined to determine which device and sectors the pending
* operation would access.
*/
-DEFINE_EVENT(block_rq_with_error, block_rq_abort,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(block_rq_with_error, block_rq_abort,
TP_PROTO(struct request_queue *q, struct request *rq),
* @q. For some reason the request was not completed and needs to be
* put back in the queue.
*/
-DEFINE_EVENT(block_rq_with_error, block_rq_requeue,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(block_rq_with_error, block_rq_requeue,
TP_PROTO(struct request_queue *q, struct request *rq),
* do for the request. If @rq->bio is non-NULL then there is
* additional work required to complete the request.
*/
-TRACE_EVENT(block_rq_complete,
+LTTNG_TRACEPOINT_EVENT(block_rq_complete,
TP_PROTO(struct request_queue *q, struct request *rq,
unsigned int nr_bytes),
* do for the request. If @rq->bio is non-NULL then there is
* additional work required to complete the request.
*/
-DEFINE_EVENT(block_rq_with_error, block_rq_complete,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(block_rq_with_error, block_rq_complete,
TP_PROTO(struct request_queue *q, struct request *rq),
#endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,15,0)) */
-DECLARE_EVENT_CLASS(block_rq,
+LTTNG_TRACEPOINT_EVENT_CLASS(block_rq,
TP_PROTO(struct request_queue *q, struct request *rq),
* be examined to determine which device and sectors the pending
* operation would access.
*/
-DEFINE_EVENT(block_rq, block_rq_insert,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(block_rq, block_rq_insert,
TP_PROTO(struct request_queue *q, struct request *rq),
* Called when block operation request @rq from queue @q is sent to a
* device driver for processing.
*/
-DEFINE_EVENT(block_rq, block_rq_issue,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(block_rq, block_rq_issue,
TP_PROTO(struct request_queue *q, struct request *rq),
* bounce buffer requires extra copying of data and decreases
* performance.
*/
-TRACE_EVENT(block_bio_bounce,
+LTTNG_TRACEPOINT_EVENT(block_bio_bounce,
TP_PROTO(struct request_queue *q, struct bio *bio),
* This tracepoint indicates there is no further work to do on this
* block IO operation @bio.
*/
-TRACE_EVENT(block_bio_complete,
+LTTNG_TRACEPOINT_EVENT(block_bio_complete,
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,38))
TP_PROTO(struct request_queue *q, struct bio *bio, int error),
)
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,9,0))
-DECLARE_EVENT_CLASS(block_bio_merge,
+LTTNG_TRACEPOINT_EVENT_CLASS(block_bio_merge,
TP_PROTO(struct request_queue *q, struct request *rq, struct bio *bio),
* Merging block request @bio to the end of an existing block request
* in queue @q.
*/
-DEFINE_EVENT(block_bio_merge, block_bio_backmerge,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(block_bio_merge, block_bio_backmerge,
TP_PROTO(struct request_queue *q, struct request *rq, struct bio *bio),
* Merging block IO operation @bio to the beginning of an existing block
* operation in queue @q.
*/
-DEFINE_EVENT(block_bio_merge, block_bio_frontmerge,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(block_bio_merge, block_bio_frontmerge,
TP_PROTO(struct request_queue *q, struct request *rq, struct bio *bio),
*
* About to place the block IO operation @bio into queue @q.
*/
-TRACE_EVENT(block_bio_queue,
+LTTNG_TRACEPOINT_EVENT(block_bio_queue,
TP_PROTO(struct request_queue *q, struct bio *bio),
__entry->nr_sector, __entry->comm, __entry->tid)
)
#else
-DECLARE_EVENT_CLASS(block_bio,
+LTTNG_TRACEPOINT_EVENT_CLASS(block_bio,
TP_PROTO(struct request_queue *q, struct bio *bio),
* Merging block request @bio to the end of an existing block request
* in queue @q.
*/
-DEFINE_EVENT(block_bio, block_bio_backmerge,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(block_bio, block_bio_backmerge,
TP_PROTO(struct request_queue *q, struct bio *bio),
* Merging block IO operation @bio to the beginning of an existing block
* operation in queue @q.
*/
-DEFINE_EVENT(block_bio, block_bio_frontmerge,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(block_bio, block_bio_frontmerge,
TP_PROTO(struct request_queue *q, struct bio *bio),
*
* About to place the block IO operation @bio into queue @q.
*/
-DEFINE_EVENT(block_bio, block_bio_queue,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(block_bio, block_bio_queue,
TP_PROTO(struct request_queue *q, struct bio *bio),
)
#endif
-DECLARE_EVENT_CLASS(block_get_rq,
+LTTNG_TRACEPOINT_EVENT_CLASS(block_get_rq,
TP_PROTO(struct request_queue *q, struct bio *bio, int rw),
* A request struct for queue @q has been allocated to handle the
* block IO operation @bio.
*/
-DEFINE_EVENT(block_get_rq, block_getrq,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(block_get_rq, block_getrq,
TP_PROTO(struct request_queue *q, struct bio *bio, int rw),
* available. This tracepoint event is generated each time the
* process goes to sleep waiting for request struct become available.
*/
-DEFINE_EVENT(block_get_rq, block_sleeprq,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(block_get_rq, block_sleeprq,
TP_PROTO(struct request_queue *q, struct bio *bio, int rw),
* to be sent to the device driver. Instead, accumulate requests in
* the queue to improve throughput performance of the block device.
*/
-TRACE_EVENT(block_plug,
+LTTNG_TRACEPOINT_EVENT(block_plug,
TP_PROTO(struct request_queue *q),
TP_printk("[%s] %d", __entry->comm, __entry->tid)
)
-DECLARE_EVENT_CLASS(block_unplug,
+LTTNG_TRACEPOINT_EVENT_CLASS(block_unplug,
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39))
TP_PROTO(struct request_queue *q, unsigned int depth, bool explicit),
* Unplug the request queue @q because a timer expired and allow block
* operation requests to be sent to the device driver.
*/
-DEFINE_EVENT(block_unplug, block_unplug_timer,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(block_unplug, block_unplug_timer,
TP_PROTO(struct request_queue *q),
* on elements in the request queue.
*/
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39))
-DEFINE_EVENT(block_unplug, block_unplug,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(block_unplug, block_unplug,
#else
-DEFINE_EVENT(block_unplug, block_unplug_io,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(block_unplug, block_unplug_io,
#endif
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39))
* @new_sector. This split may be required due to hardware limitation
* such as operation crossing device boundaries in a RAID system.
*/
-TRACE_EVENT(block_split,
+LTTNG_TRACEPOINT_EVENT(block_split,
TP_PROTO(struct request_queue *q, struct bio *bio,
unsigned int new_sector),
* raw block device.
*/
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,38))
-TRACE_EVENT(block_bio_remap,
+LTTNG_TRACEPOINT_EVENT(block_bio_remap,
#else
-TRACE_EVENT(block_remap,
+LTTNG_TRACEPOINT_EVENT(block_remap,
#endif
TP_PROTO(struct request_queue *q, struct bio *bio, dev_t dev,
* operation request @rq holds the current information and @from hold
* the original sector.
*/
-TRACE_EVENT(block_rq_remap,
+LTTNG_TRACEPOINT_EVENT(block_rq_remap,
TP_PROTO(struct request_queue *q, struct request *rq, dev_t dev,
sector_t from),
#undef __print_rwbs_flags
#undef blk_fill_rwbs
-#endif /* _TRACE_BLOCK_H */
+#endif /* LTTNG_TRACE_BLOCK_H */
/* This part must be outside protection */
#include "../../../probes/define_trace.h"
#undef TRACE_SYSTEM
#define TRACE_SYSTEM btrfs
-#if !defined(_TRACE_BTRFS_H) || defined(TRACE_HEADER_MULTI_READ)
-#define _TRACE_BTRFS_H
+#if !defined(LTTNG_TRACE_BTRFS_H) || defined(TRACE_HEADER_MULTI_READ)
+#define LTTNG_TRACE_BTRFS_H
+#include "../../../probes/lttng-tracepoint-event.h"
#include <linux/writeback.h>
-#include <linux/tracepoint.h>
#include <trace/events/gfpflags.h>
#include <linux/version.h>
#endif
-TRACE_EVENT(btrfs_transaction_commit,
+LTTNG_TRACEPOINT_EVENT(btrfs_transaction_commit,
TP_PROTO(struct btrfs_root *root),
(unsigned long long)__entry->generation)
)
-DECLARE_EVENT_CLASS(btrfs__inode,
+LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__inode,
TP_PROTO(struct inode *inode),
(unsigned long long)__entry->logged_trans)
)
-DEFINE_EVENT(btrfs__inode, btrfs_inode_new,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__inode, btrfs_inode_new,
TP_PROTO(struct inode *inode),
TP_ARGS(inode)
)
-DEFINE_EVENT(btrfs__inode, btrfs_inode_request,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__inode, btrfs_inode_request,
TP_PROTO(struct inode *inode),
TP_ARGS(inode)
)
-DEFINE_EVENT(btrfs__inode, btrfs_inode_evict,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__inode, btrfs_inode_evict,
TP_PROTO(struct inode *inode),
#endif
-TRACE_EVENT(btrfs_get_extent,
+LTTNG_TRACEPOINT_EVENT(btrfs_get_extent,
TP_PROTO(struct btrfs_root *root, struct extent_map *map),
#endif
-DECLARE_EVENT_CLASS(btrfs__ordered_extent,
+LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__ordered_extent,
TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
__entry->compress_type, __entry->refs)
)
-DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_add,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__ordered_extent, btrfs_ordered_extent_add,
TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
TP_ARGS(inode, ordered)
)
-DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_remove,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__ordered_extent, btrfs_ordered_extent_remove,
TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
TP_ARGS(inode, ordered)
)
-DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_start,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__ordered_extent, btrfs_ordered_extent_start,
TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
TP_ARGS(inode, ordered)
)
-DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_put,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__ordered_extent, btrfs_ordered_extent_put,
TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
TP_ARGS(inode, ordered)
)
-DECLARE_EVENT_CLASS(btrfs__writepage,
+LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__writepage,
TP_PROTO(struct page *page, struct inode *inode,
struct writeback_control *wbc),
#endif
)
-DEFINE_EVENT(btrfs__writepage, __extent_writepage,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__writepage, __extent_writepage,
TP_PROTO(struct page *page, struct inode *inode,
struct writeback_control *wbc),
TP_ARGS(page, inode, wbc)
)
-TRACE_EVENT(btrfs_writepage_end_io_hook,
+LTTNG_TRACEPOINT_EVENT(btrfs_writepage_end_io_hook,
TP_PROTO(struct page *page, u64 start, u64 end, int uptodate),
(unsigned long long)__entry->end, __entry->uptodate)
)
-TRACE_EVENT(btrfs_sync_file,
+LTTNG_TRACEPOINT_EVENT(btrfs_sync_file,
TP_PROTO(struct file *file, int datasync),
__entry->datasync)
)
-TRACE_EVENT(btrfs_sync_fs,
+LTTNG_TRACEPOINT_EVENT(btrfs_sync_fs,
TP_PROTO(int wait),
{ BTRFS_UPDATE_DELAYED_HEAD, "UPDATE_DELAYED_HEAD" })
-TRACE_EVENT(btrfs_delayed_tree_ref,
+LTTNG_TRACEPOINT_EVENT(btrfs_delayed_tree_ref,
TP_PROTO(struct btrfs_delayed_ref_node *ref,
struct btrfs_delayed_tree_ref *full_ref,
#endif
)
-TRACE_EVENT(btrfs_delayed_data_ref,
+LTTNG_TRACEPOINT_EVENT(btrfs_delayed_data_ref,
TP_PROTO(struct btrfs_delayed_ref_node *ref,
struct btrfs_delayed_data_ref *full_ref,
#endif
)
-TRACE_EVENT(btrfs_delayed_ref_head,
+LTTNG_TRACEPOINT_EVENT(btrfs_delayed_ref_head,
TP_PROTO(struct btrfs_delayed_ref_node *ref,
struct btrfs_delayed_ref_head *head_ref,
#endif
-DECLARE_EVENT_CLASS(btrfs__chunk,
+LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__chunk,
TP_PROTO(struct btrfs_root *root, struct map_lookup *map,
u64 offset, u64 size),
show_chunk_type(__entry->type))
)
-DEFINE_EVENT(btrfs__chunk, btrfs_chunk_alloc,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__chunk, btrfs_chunk_alloc,
TP_PROTO(struct btrfs_root *root, struct map_lookup *map,
u64 offset, u64 size),
TP_ARGS(root, map, offset, size)
)
-DEFINE_EVENT(btrfs__chunk, btrfs_chunk_free,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__chunk, btrfs_chunk_free,
TP_PROTO(struct btrfs_root *root, struct map_lookup *map,
u64 offset, u64 size),
TP_ARGS(root, map, offset, size)
)
-TRACE_EVENT(btrfs_cow_block,
+LTTNG_TRACEPOINT_EVENT(btrfs_cow_block,
TP_PROTO(struct btrfs_root *root, struct extent_buffer *buf,
struct extent_buffer *cow),
)
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
-TRACE_EVENT(btrfs_space_reservation,
+LTTNG_TRACEPOINT_EVENT(btrfs_space_reservation,
TP_PROTO(struct btrfs_fs_info *fs_info, char *type, u64 val,
u64 bytes, int reserve),
)
#endif
-DECLARE_EVENT_CLASS(btrfs__reserved_extent,
+LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__reserved_extent,
TP_PROTO(struct btrfs_root *root, u64 start, u64 len),
(unsigned long long)__entry->len)
)
-DEFINE_EVENT(btrfs__reserved_extent, btrfs_reserved_extent_alloc,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserved_extent, btrfs_reserved_extent_alloc,
TP_PROTO(struct btrfs_root *root, u64 start, u64 len),
TP_ARGS(root, start, len)
)
-DEFINE_EVENT(btrfs__reserved_extent, btrfs_reserved_extent_free,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserved_extent, btrfs_reserved_extent_free,
TP_PROTO(struct btrfs_root *root, u64 start, u64 len),
)
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
-TRACE_EVENT_MAP(find_free_extent,
+LTTNG_TRACEPOINT_EVENT_MAP(find_free_extent,
btrfs_find_free_extent,
BTRFS_GROUP_FLAGS))
)
-DECLARE_EVENT_CLASS(btrfs__reserve_extent,
+LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__reserve_extent,
TP_PROTO(struct btrfs_root *root,
struct btrfs_block_group_cache *block_group, u64 start,
__entry->start, __entry->len)
)
-DEFINE_EVENT(btrfs__reserve_extent, btrfs_reserve_extent,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserve_extent, btrfs_reserve_extent,
TP_PROTO(struct btrfs_root *root,
struct btrfs_block_group_cache *block_group, u64 start,
TP_ARGS(root, block_group, start, len)
)
-DEFINE_EVENT(btrfs__reserve_extent, btrfs_reserve_extent_cluster,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserve_extent, btrfs_reserve_extent_cluster,
TP_PROTO(struct btrfs_root *root,
struct btrfs_block_group_cache *block_group, u64 start,
TP_ARGS(root, block_group, start, len)
)
-TRACE_EVENT(btrfs_find_cluster,
+LTTNG_TRACEPOINT_EVENT(btrfs_find_cluster,
TP_PROTO(struct btrfs_block_group_cache *block_group, u64 start,
u64 bytes, u64 empty_size, u64 min_bytes),
__entry->bytes, __entry->empty_size, __entry->min_bytes)
)
-TRACE_EVENT(btrfs_failed_cluster_setup,
+LTTNG_TRACEPOINT_EVENT(btrfs_failed_cluster_setup,
TP_PROTO(struct btrfs_block_group_cache *block_group),
TP_printk("block_group = %Lu", __entry->bg_objectid)
)
-TRACE_EVENT(btrfs_setup_cluster,
+LTTNG_TRACEPOINT_EVENT(btrfs_setup_cluster,
TP_PROTO(struct btrfs_block_group_cache *block_group,
struct btrfs_free_cluster *cluster, u64 size, int bitmap),
#endif
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,4,0))
-TRACE_EVENT_MAP(alloc_extent_state,
+LTTNG_TRACEPOINT_EVENT_MAP(alloc_extent_state,
btrfs_alloc_extent_state,
show_gfp_flags(__entry->mask), (void *)__entry->ip)
)
-TRACE_EVENT_MAP(free_extent_state,
+LTTNG_TRACEPOINT_EVENT_MAP(free_extent_state,
btrfs_free_extent_state,
)
#endif
-#endif /* _TRACE_BTRFS_H */
+#endif /* LTTNG_TRACE_BTRFS_H */
/* This part must be outside protection */
#include "../../../probes/define_trace.h"
#undef TRACE_SYSTEM
#define TRACE_SYSTEM compaction
-#if !defined(_TRACE_COMPACTION_H) || defined(TRACE_HEADER_MULTI_READ)
-#define _TRACE_COMPACTION_H
+#if !defined(LTTNG_TRACE_COMPACTION_H) || defined(TRACE_HEADER_MULTI_READ)
+#define LTTNG_TRACE_COMPACTION_H
+#include "../../../probes/lttng-tracepoint-event.h"
#include <linux/types.h>
-#include <linux/tracepoint.h>
#include <linux/version.h>
#include <trace/events/gfpflags.h>
-DECLARE_EVENT_CLASS(mm_compaction_isolate_template,
+LTTNG_TRACEPOINT_EVENT_CLASS(mm_compaction_isolate_template,
TP_PROTO(unsigned long nr_scanned,
unsigned long nr_taken),
__entry->nr_taken)
)
-DEFINE_EVENT(mm_compaction_isolate_template, mm_compaction_isolate_migratepages,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(mm_compaction_isolate_template, mm_compaction_isolate_migratepages,
TP_PROTO(unsigned long nr_scanned,
unsigned long nr_taken),
TP_ARGS(nr_scanned, nr_taken)
)
-DEFINE_EVENT(mm_compaction_isolate_template, mm_compaction_isolate_freepages,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(mm_compaction_isolate_template, mm_compaction_isolate_freepages,
TP_PROTO(unsigned long nr_scanned,
unsigned long nr_taken),
)
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,16,0))
-TRACE_EVENT(mm_compaction_migratepages,
+LTTNG_TRACEPOINT_EVENT(mm_compaction_migratepages,
TP_PROTO(unsigned long nr_all,
int migrate_rc,
__entry->nr_failed)
)
#else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,16,0)) */
-TRACE_EVENT(mm_compaction_migratepages,
+LTTNG_TRACEPOINT_EVENT(mm_compaction_migratepages,
TP_PROTO(unsigned long nr_migrated,
unsigned long nr_failed),
)
#endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,16,0)) */
-#endif /* _TRACE_COMPACTION_H */
+#endif /* LTTNG_TRACE_COMPACTION_H */
/* This part must be outside protection */
#include "../../../probes/define_trace.h"
#undef TRACE_SYSTEM
#define TRACE_SYSTEM ext3
-#if !defined(_TRACE_EXT3_H) || defined(TRACE_HEADER_MULTI_READ)
-#define _TRACE_EXT3_H
+#if !defined(LTTNG_TRACE_EXT3_H) || defined(TRACE_HEADER_MULTI_READ)
+#define LTTNG_TRACE_EXT3_H
-#include <linux/tracepoint.h>
+#include "../../../probes/lttng-tracepoint-event.h"
#include <linux/version.h>
-TRACE_EVENT(ext3_free_inode,
+LTTNG_TRACEPOINT_EVENT(ext3_free_inode,
TP_PROTO(struct inode *inode),
TP_ARGS(inode),
(unsigned long) __entry->blocks)
)
-TRACE_EVENT(ext3_request_inode,
+LTTNG_TRACEPOINT_EVENT(ext3_request_inode,
TP_PROTO(struct inode *dir, int mode),
TP_ARGS(dir, mode),
(unsigned long) __entry->dir, __entry->mode)
)
-TRACE_EVENT(ext3_allocate_inode,
+LTTNG_TRACEPOINT_EVENT(ext3_allocate_inode,
TP_PROTO(struct inode *inode, struct inode *dir, int mode),
TP_ARGS(inode, dir, mode),
(unsigned long) __entry->dir, __entry->mode)
)
-TRACE_EVENT(ext3_evict_inode,
+LTTNG_TRACEPOINT_EVENT(ext3_evict_inode,
TP_PROTO(struct inode *inode),
TP_ARGS(inode),
(unsigned long) __entry->ino, __entry->nlink)
)
-TRACE_EVENT(ext3_drop_inode,
+LTTNG_TRACEPOINT_EVENT(ext3_drop_inode,
TP_PROTO(struct inode *inode, int drop),
TP_ARGS(inode, drop),
(unsigned long) __entry->ino, __entry->drop)
)
-TRACE_EVENT(ext3_mark_inode_dirty,
+LTTNG_TRACEPOINT_EVENT(ext3_mark_inode_dirty,
TP_PROTO(struct inode *inode, unsigned long IP),
TP_ARGS(inode, IP),
(unsigned long) __entry->ino, (void *)__entry->ip)
)
-TRACE_EVENT(ext3_write_begin,
+LTTNG_TRACEPOINT_EVENT(ext3_write_begin,
TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
unsigned int flags),
__entry->flags)
)
-DECLARE_EVENT_CLASS(ext3__write_end,
+LTTNG_TRACEPOINT_EVENT_CLASS(ext3__write_end,
TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
unsigned int copied),
__entry->copied)
)
-DEFINE_EVENT(ext3__write_end, ext3_ordered_write_end,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(ext3__write_end, ext3_ordered_write_end,
TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
unsigned int copied),
TP_ARGS(inode, pos, len, copied)
)
-DEFINE_EVENT(ext3__write_end, ext3_writeback_write_end,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(ext3__write_end, ext3_writeback_write_end,
TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
unsigned int copied),
TP_ARGS(inode, pos, len, copied)
)
-DEFINE_EVENT(ext3__write_end, ext3_journalled_write_end,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(ext3__write_end, ext3_journalled_write_end,
TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
unsigned int copied),
TP_ARGS(inode, pos, len, copied)
)
-DECLARE_EVENT_CLASS(ext3__page_op,
+LTTNG_TRACEPOINT_EVENT_CLASS(ext3__page_op,
TP_PROTO(struct page *page),
TP_ARGS(page),
(unsigned long) __entry->ino, __entry->index)
)
-DEFINE_EVENT(ext3__page_op, ext3_ordered_writepage,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(ext3__page_op, ext3_ordered_writepage,
TP_PROTO(struct page *page),
TP_ARGS(page)
)
-DEFINE_EVENT(ext3__page_op, ext3_writeback_writepage,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(ext3__page_op, ext3_writeback_writepage,
TP_PROTO(struct page *page),
TP_ARGS(page)
)
-DEFINE_EVENT(ext3__page_op, ext3_journalled_writepage,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(ext3__page_op, ext3_journalled_writepage,
TP_PROTO(struct page *page),
TP_ARGS(page)
)
-DEFINE_EVENT(ext3__page_op, ext3_readpage,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(ext3__page_op, ext3_readpage,
TP_PROTO(struct page *page),
TP_ARGS(page)
)
-DEFINE_EVENT(ext3__page_op, ext3_releasepage,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(ext3__page_op, ext3_releasepage,
TP_PROTO(struct page *page),
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,11,0))
-TRACE_EVENT(ext3_invalidatepage,
+LTTNG_TRACEPOINT_EVENT(ext3_invalidatepage,
TP_PROTO(struct page *page, unsigned int offset, unsigned int length),
TP_ARGS(page, offset, length),
#else
-TRACE_EVENT(ext3_invalidatepage,
+LTTNG_TRACEPOINT_EVENT(ext3_invalidatepage,
TP_PROTO(struct page *page, unsigned long offset),
TP_ARGS(page, offset),
#endif
-TRACE_EVENT(ext3_discard_blocks,
+LTTNG_TRACEPOINT_EVENT(ext3_discard_blocks,
TP_PROTO(struct super_block *sb, unsigned long blk,
unsigned long count),
__entry->blk, __entry->count)
)
-TRACE_EVENT(ext3_request_blocks,
+LTTNG_TRACEPOINT_EVENT(ext3_request_blocks,
TP_PROTO(struct inode *inode, unsigned long goal,
unsigned long count),
__entry->count, __entry->goal)
)
-TRACE_EVENT(ext3_allocate_blocks,
+LTTNG_TRACEPOINT_EVENT(ext3_allocate_blocks,
TP_PROTO(struct inode *inode, unsigned long goal,
unsigned long count, unsigned long block),
__entry->goal)
)
-TRACE_EVENT(ext3_free_blocks,
+LTTNG_TRACEPOINT_EVENT(ext3_free_blocks,
TP_PROTO(struct inode *inode, unsigned long block,
unsigned long count),
__entry->mode, __entry->block, __entry->count)
)
-TRACE_EVENT(ext3_sync_file_enter,
+LTTNG_TRACEPOINT_EVENT(ext3_sync_file_enter,
TP_PROTO(struct file *file, int datasync),
TP_ARGS(file, datasync),
(unsigned long) __entry->parent, __entry->datasync)
)
-TRACE_EVENT(ext3_sync_file_exit,
+LTTNG_TRACEPOINT_EVENT(ext3_sync_file_exit,
TP_PROTO(struct inode *inode, int ret),
TP_ARGS(inode, ret),
__entry->ret)
)
-TRACE_EVENT(ext3_sync_fs,
+LTTNG_TRACEPOINT_EVENT(ext3_sync_fs,
TP_PROTO(struct super_block *sb, int wait),
TP_ARGS(sb, wait),
__entry->wait)
)
-TRACE_EVENT(ext3_rsv_window_add,
+LTTNG_TRACEPOINT_EVENT(ext3_rsv_window_add,
TP_PROTO(struct super_block *sb,
struct ext3_reserve_window_node *rsv_node),
__entry->start, __entry->end)
)
-TRACE_EVENT(ext3_discard_reservation,
+LTTNG_TRACEPOINT_EVENT(ext3_discard_reservation,
TP_PROTO(struct inode *inode,
struct ext3_reserve_window_node *rsv_node),
__entry->end)
)
-TRACE_EVENT(ext3_alloc_new_reservation,
+LTTNG_TRACEPOINT_EVENT(ext3_alloc_new_reservation,
TP_PROTO(struct super_block *sb, unsigned long goal),
TP_ARGS(sb, goal),
__entry->goal)
)
-TRACE_EVENT(ext3_reserved,
+LTTNG_TRACEPOINT_EVENT(ext3_reserved,
TP_PROTO(struct super_block *sb, unsigned long block,
struct ext3_reserve_window_node *rsv_node),
__entry->block, __entry->start, __entry->end)
)
-TRACE_EVENT(ext3_forget,
+LTTNG_TRACEPOINT_EVENT(ext3_forget,
TP_PROTO(struct inode *inode, int is_metadata, unsigned long block),
TP_ARGS(inode, is_metadata, block),
__entry->mode, __entry->is_metadata, __entry->block)
)
-TRACE_EVENT(ext3_read_block_bitmap,
+LTTNG_TRACEPOINT_EVENT(ext3_read_block_bitmap,
TP_PROTO(struct super_block *sb, unsigned int group),
TP_ARGS(sb, group),
__entry->group)
)
-TRACE_EVENT(ext3_direct_IO_enter,
+LTTNG_TRACEPOINT_EVENT(ext3_direct_IO_enter,
TP_PROTO(struct inode *inode, loff_t offset, unsigned long len, int rw),
TP_ARGS(inode, offset, len, rw),
__entry->rw)
)
-TRACE_EVENT(ext3_direct_IO_exit,
+LTTNG_TRACEPOINT_EVENT(ext3_direct_IO_exit,
TP_PROTO(struct inode *inode, loff_t offset, unsigned long len,
int rw, int ret),
__entry->rw, __entry->ret)
)
-TRACE_EVENT(ext3_unlink_enter,
+LTTNG_TRACEPOINT_EVENT(ext3_unlink_enter,
TP_PROTO(struct inode *parent, struct dentry *dentry),
TP_ARGS(parent, dentry),
(unsigned long) __entry->parent)
)
-TRACE_EVENT(ext3_unlink_exit,
+LTTNG_TRACEPOINT_EVENT(ext3_unlink_exit,
TP_PROTO(struct dentry *dentry, int ret),
TP_ARGS(dentry, ret),
__entry->ret)
)
-DECLARE_EVENT_CLASS(ext3__truncate,
+LTTNG_TRACEPOINT_EVENT_CLASS(ext3__truncate,
TP_PROTO(struct inode *inode),
TP_ARGS(inode),
(unsigned long) __entry->ino, (unsigned long) __entry->blocks)
)
-DEFINE_EVENT(ext3__truncate, ext3_truncate_enter,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(ext3__truncate, ext3_truncate_enter,
TP_PROTO(struct inode *inode),
TP_ARGS(inode)
)
-DEFINE_EVENT(ext3__truncate, ext3_truncate_exit,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(ext3__truncate, ext3_truncate_exit,
TP_PROTO(struct inode *inode),
TP_ARGS(inode)
)
-TRACE_EVENT(ext3_get_blocks_enter,
+LTTNG_TRACEPOINT_EVENT(ext3_get_blocks_enter,
TP_PROTO(struct inode *inode, unsigned long lblk,
unsigned long len, int create),
__entry->lblk, __entry->len, __entry->create)
)
-TRACE_EVENT(ext3_get_blocks_exit,
+LTTNG_TRACEPOINT_EVENT(ext3_get_blocks_exit,
TP_PROTO(struct inode *inode, unsigned long lblk,
unsigned long pblk, unsigned long len, int ret),
__entry->len, __entry->ret)
)
-TRACE_EVENT(ext3_load_inode,
+LTTNG_TRACEPOINT_EVENT(ext3_load_inode,
TP_PROTO(struct inode *inode),
TP_ARGS(inode),
(unsigned long) __entry->ino)
)
-#endif /* _TRACE_EXT3_H */
+#endif /* LTTNG_TRACE_EXT3_H */
/* This part must be outside protection */
#include "../../../probes/define_trace.h"
#undef TRACE_SYSTEM
#define TRACE_SYSTEM ext4
-#if !defined(_TRACE_EXT4_H) || defined(TRACE_HEADER_MULTI_READ)
-#define _TRACE_EXT4_H
+#if !defined(LTTNG_TRACE_EXT4_H) || defined(TRACE_HEADER_MULTI_READ)
+#define LTTNG_TRACE_EXT4_H
+#include "../../../probes/lttng-tracepoint-event.h"
#include <linux/writeback.h>
-#include <linux/tracepoint.h>
#include <linux/version.h>
#ifndef _TRACE_EXT4_DEF_
#define TP_MODE_T umode_t
#endif
-TRACE_EVENT(ext4_free_inode,
+LTTNG_TRACEPOINT_EVENT(ext4_free_inode,
TP_PROTO(struct inode *inode),
TP_ARGS(inode),
__entry->uid, __entry->gid, __entry->blocks)
)
-TRACE_EVENT(ext4_request_inode,
+LTTNG_TRACEPOINT_EVENT(ext4_request_inode,
TP_PROTO(struct inode *dir, int mode),
TP_ARGS(dir, mode),
(unsigned long) __entry->dir, __entry->mode)
)
-TRACE_EVENT(ext4_allocate_inode,
+LTTNG_TRACEPOINT_EVENT(ext4_allocate_inode,
TP_PROTO(struct inode *inode, struct inode *dir, int mode),
TP_ARGS(inode, dir, mode),
)
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37))
-TRACE_EVENT(ext4_evict_inode,
+LTTNG_TRACEPOINT_EVENT(ext4_evict_inode,
TP_PROTO(struct inode *inode),
TP_ARGS(inode),
(unsigned long) __entry->ino, __entry->nlink)
)
-TRACE_EVENT(ext4_drop_inode,
+LTTNG_TRACEPOINT_EVENT(ext4_drop_inode,
TP_PROTO(struct inode *inode, int drop),
TP_ARGS(inode, drop),
(unsigned long) __entry->ino, __entry->drop)
)
-TRACE_EVENT(ext4_mark_inode_dirty,
+LTTNG_TRACEPOINT_EVENT(ext4_mark_inode_dirty,
TP_PROTO(struct inode *inode, unsigned long IP),
TP_ARGS(inode, IP),
(unsigned long) __entry->ino, (void *)__entry->ip)
)
-TRACE_EVENT(ext4_begin_ordered_truncate,
+LTTNG_TRACEPOINT_EVENT(ext4_begin_ordered_truncate,
TP_PROTO(struct inode *inode, loff_t new_size),
TP_ARGS(inode, new_size),
)
#endif
-DECLARE_EVENT_CLASS(ext4__write_begin,
+LTTNG_TRACEPOINT_EVENT_CLASS(ext4__write_begin,
TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
unsigned int flags),
__entry->pos, __entry->len, __entry->flags)
)
-DEFINE_EVENT(ext4__write_begin, ext4_write_begin,
+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)
)
-DEFINE_EVENT(ext4__write_begin, ext4_da_write_begin,
+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)
)
-DECLARE_EVENT_CLASS(ext4__write_end,
+LTTNG_TRACEPOINT_EVENT_CLASS(ext4__write_end,
TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
unsigned int copied),
__entry->pos, __entry->len, __entry->copied)
)
-DEFINE_EVENT(ext4__write_end, ext4_ordered_write_end,
+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)
)
-DEFINE_EVENT(ext4__write_end, ext4_writeback_write_end,
+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)
)
-DEFINE_EVENT(ext4__write_end, ext4_journalled_write_end,
+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)
)
-DEFINE_EVENT(ext4__write_end, ext4_da_write_end,
+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),
)
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,40))
-TRACE_EVENT(ext4_writepage,
+LTTNG_TRACEPOINT_EVENT(ext4_writepage,
TP_PROTO(struct inode *inode, struct page *page),
TP_ARGS(inode, page),
)
#endif
-TRACE_EVENT(ext4_da_writepages,
+LTTNG_TRACEPOINT_EVENT(ext4_da_writepages,
TP_PROTO(struct inode *inode, struct writeback_control *wbc),
TP_ARGS(inode, wbc),
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,11,0))
-TRACE_EVENT(ext4_da_write_pages,
+LTTNG_TRACEPOINT_EVENT(ext4_da_write_pages,
TP_PROTO(struct inode *inode, pgoff_t first_page,
struct writeback_control *wbc),
#else
-TRACE_EVENT(ext4_da_write_pages,
+LTTNG_TRACEPOINT_EVENT(ext4_da_write_pages,
TP_PROTO(struct inode *inode, struct mpage_da_data *mpd),
TP_ARGS(inode, mpd),
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,11,0))
-TRACE_EVENT(ext4_da_write_pages_extent,
+LTTNG_TRACEPOINT_EVENT(ext4_da_write_pages_extent,
TP_PROTO(struct inode *inode, struct ext4_map_blocks *map),
TP_ARGS(inode, map),
#endif
-TRACE_EVENT(ext4_da_writepages_result,
+LTTNG_TRACEPOINT_EVENT(ext4_da_writepages_result,
TP_PROTO(struct inode *inode, struct writeback_control *wbc,
int ret, int pages_written),
)
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39))
-DECLARE_EVENT_CLASS(ext4__page_op,
+LTTNG_TRACEPOINT_EVENT_CLASS(ext4__page_op,
TP_PROTO(struct page *page),
TP_ARGS(page),
)
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,40))
-DEFINE_EVENT(ext4__page_op, ext4_writepage,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__page_op, ext4_writepage,
TP_PROTO(struct page *page),
)
#endif
-DEFINE_EVENT(ext4__page_op, ext4_readpage,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__page_op, ext4_readpage,
TP_PROTO(struct page *page),
TP_ARGS(page)
)
-DEFINE_EVENT(ext4__page_op, ext4_releasepage,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__page_op, ext4_releasepage,
TP_PROTO(struct page *page),
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,11,0))
-DECLARE_EVENT_CLASS(ext4_invalidatepage_op,
+LTTNG_TRACEPOINT_EVENT_CLASS(ext4_invalidatepage_op,
TP_PROTO(struct page *page, unsigned int offset, unsigned int length),
TP_ARGS(page, offset, length),
__entry->offset, __entry->length)
)
-DEFINE_EVENT(ext4_invalidatepage_op, ext4_invalidatepage,
+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)
)
-DEFINE_EVENT(ext4_invalidatepage_op, ext4_journalled_invalidatepage,
+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)
#else
-TRACE_EVENT(ext4_invalidatepage,
+LTTNG_TRACEPOINT_EVENT(ext4_invalidatepage,
TP_PROTO(struct page *page, unsigned long offset),
TP_ARGS(page, offset),
#endif
-TRACE_EVENT(ext4_discard_blocks,
+LTTNG_TRACEPOINT_EVENT(ext4_discard_blocks,
TP_PROTO(struct super_block *sb, unsigned long long blk,
unsigned long long count),
__entry->blk, __entry->count)
)
-DECLARE_EVENT_CLASS(ext4__mb_new_pa,
+LTTNG_TRACEPOINT_EVENT_CLASS(ext4__mb_new_pa,
TP_PROTO(struct ext4_allocation_context *ac,
struct ext4_prealloc_space *pa),
__entry->pa_pstart, __entry->pa_len, __entry->pa_lstart)
)
-DEFINE_EVENT(ext4__mb_new_pa, ext4_mb_new_inode_pa,
+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)
)
-DEFINE_EVENT(ext4__mb_new_pa, ext4_mb_new_group_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)
)
-TRACE_EVENT(ext4_mb_release_inode_pa,
+LTTNG_TRACEPOINT_EVENT(ext4_mb_release_inode_pa,
TP_PROTO(
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,40))
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37))
__entry->block, __entry->count)
)
-TRACE_EVENT(ext4_mb_release_group_pa,
+LTTNG_TRACEPOINT_EVENT(ext4_mb_release_group_pa,
#if (LTTNG_KERNEL_RANGE(2,6,40, 3,3,0))
TP_PROTO(struct ext4_prealloc_space *pa),
__entry->pa_pstart, __entry->pa_len)
)
-TRACE_EVENT(ext4_discard_preallocations,
+LTTNG_TRACEPOINT_EVENT(ext4_discard_preallocations,
TP_PROTO(struct inode *inode),
TP_ARGS(inode),
(unsigned long) __entry->ino)
)
-TRACE_EVENT(ext4_mb_discard_preallocations,
+LTTNG_TRACEPOINT_EVENT(ext4_mb_discard_preallocations,
TP_PROTO(struct super_block *sb, int needed),
TP_ARGS(sb, needed),
__entry->needed)
)
-TRACE_EVENT(ext4_request_blocks,
+LTTNG_TRACEPOINT_EVENT(ext4_request_blocks,
TP_PROTO(struct ext4_allocation_request *ar),
TP_ARGS(ar),
__entry->pright)
)
-TRACE_EVENT(ext4_allocate_blocks,
+LTTNG_TRACEPOINT_EVENT(ext4_allocate_blocks,
TP_PROTO(struct ext4_allocation_request *ar, unsigned long long block),
TP_ARGS(ar, block),
__entry->pleft, __entry->pright)
)
-TRACE_EVENT(ext4_free_blocks,
+LTTNG_TRACEPOINT_EVENT(ext4_free_blocks,
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,33))
TP_PROTO(struct inode *inode, __u64 block, unsigned long count,
int flags),
)
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39))
-TRACE_EVENT(ext4_sync_file_enter,
+LTTNG_TRACEPOINT_EVENT(ext4_sync_file_enter,
#else
-TRACE_EVENT(ext4_sync_file,
+LTTNG_TRACEPOINT_EVENT(ext4_sync_file,
#endif
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,35))
TP_PROTO(struct file *file, int datasync),
)
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39))
-TRACE_EVENT(ext4_sync_file_exit,
+LTTNG_TRACEPOINT_EVENT(ext4_sync_file_exit,
TP_PROTO(struct inode *inode, int ret),
TP_ARGS(inode, ret),
)
#endif
-TRACE_EVENT(ext4_sync_fs,
+LTTNG_TRACEPOINT_EVENT(ext4_sync_fs,
TP_PROTO(struct super_block *sb, int wait),
TP_ARGS(sb, wait),
__entry->wait)
)
-TRACE_EVENT(ext4_alloc_da_blocks,
+LTTNG_TRACEPOINT_EVENT(ext4_alloc_da_blocks,
TP_PROTO(struct inode *inode),
TP_ARGS(inode),
__entry->data_blocks, __entry->meta_blocks)
)
-TRACE_EVENT(ext4_mballoc_alloc,
+LTTNG_TRACEPOINT_EVENT(ext4_mballoc_alloc,
TP_PROTO(struct ext4_allocation_context *ac),
TP_ARGS(ac),
__entry->buddy ? 1 << __entry->buddy : 0)
)
-TRACE_EVENT(ext4_mballoc_prealloc,
+LTTNG_TRACEPOINT_EVENT(ext4_mballoc_prealloc,
TP_PROTO(struct ext4_allocation_context *ac),
TP_ARGS(ac),
__entry->result_len, __entry->result_logical)
)
-DECLARE_EVENT_CLASS(ext4__mballoc,
+LTTNG_TRACEPOINT_EVENT_CLASS(ext4__mballoc,
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37))
TP_PROTO(struct super_block *sb,
struct inode *inode,
)
)
-DEFINE_EVENT(ext4__mballoc, ext4_mballoc_discard,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__mballoc, ext4_mballoc_discard,
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37))
TP_PROTO(struct super_block *sb,
#endif
)
-DEFINE_EVENT(ext4__mballoc, ext4_mballoc_free,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__mballoc, ext4_mballoc_free,
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37))
TP_PROTO(struct super_block *sb,
)
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,33))
-TRACE_EVENT(ext4_forget,
+LTTNG_TRACEPOINT_EVENT(ext4_forget,
TP_PROTO(struct inode *inode, int is_metadata, __u64 block),
TP_ARGS(inode, is_metadata, block),
#endif
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,34))
-TRACE_EVENT(ext4_da_update_reserve_space,
+LTTNG_TRACEPOINT_EVENT(ext4_da_update_reserve_space,
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
TP_PROTO(struct inode *inode, int used_blocks, int quota_claim),
#endif
)
-TRACE_EVENT(ext4_da_reserve_space,
+LTTNG_TRACEPOINT_EVENT(ext4_da_reserve_space,
TP_PROTO(struct inode *inode, int md_needed),
TP_ARGS(inode, md_needed),
__entry->reserved_meta_blocks)
)
-TRACE_EVENT(ext4_da_release_space,
+LTTNG_TRACEPOINT_EVENT(ext4_da_release_space,
TP_PROTO(struct inode *inode, int freed_blocks),
TP_ARGS(inode, freed_blocks),
#endif
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,35))
-DECLARE_EVENT_CLASS(ext4__bitmap_load,
+LTTNG_TRACEPOINT_EVENT_CLASS(ext4__bitmap_load,
TP_PROTO(struct super_block *sb, unsigned long group),
TP_ARGS(sb, group),
__entry->group)
)
-DEFINE_EVENT(ext4__bitmap_load, ext4_mb_bitmap_load,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__bitmap_load, ext4_mb_bitmap_load,
TP_PROTO(struct super_block *sb, unsigned long group),
TP_ARGS(sb, group)
)
-DEFINE_EVENT(ext4__bitmap_load, ext4_mb_buddy_bitmap_load,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__bitmap_load, ext4_mb_buddy_bitmap_load,
TP_PROTO(struct super_block *sb, unsigned long group),
#endif
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39))
-DEFINE_EVENT(ext4__bitmap_load, ext4_read_block_bitmap_load,
+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)
)
-DEFINE_EVENT(ext4__bitmap_load, ext4_load_inode_bitmap,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__bitmap_load, ext4_load_inode_bitmap,
TP_PROTO(struct super_block *sb, unsigned long group),
TP_ARGS(sb, group)
)
-TRACE_EVENT(ext4_direct_IO_enter,
+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),
__entry->pos, __entry->len, __entry->rw)
)
-TRACE_EVENT(ext4_direct_IO_exit,
+LTTNG_TRACEPOINT_EVENT(ext4_direct_IO_exit,
TP_PROTO(struct inode *inode, loff_t offset, unsigned long len,
int rw, int ret),
__entry->rw, __entry->ret)
)
-TRACE_EVENT(ext4_fallocate_exit,
+LTTNG_TRACEPOINT_EVENT(ext4_fallocate_exit,
TP_PROTO(struct inode *inode, loff_t offset,
unsigned int max_blocks, int ret),
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,15,0))
-DECLARE_EVENT_CLASS(ext4__fallocate_mode,
+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),
show_falloc_mode(__entry->mode))
)
-DEFINE_EVENT(ext4__fallocate_mode, ext4_fallocate_enter,
+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)
)
-DEFINE_EVENT(ext4__fallocate_mode, ext4_punch_hole,
+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)
)
-DEFINE_EVENT(ext4__fallocate_mode, ext4_zero_range,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__fallocate_mode, ext4_zero_range,
TP_PROTO(struct inode *inode, loff_t offset, loff_t len, int mode),
#else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,15,0)) */
-TRACE_EVENT(ext4_fallocate_enter,
+LTTNG_TRACEPOINT_EVENT(ext4_fallocate_enter,
TP_PROTO(struct inode *inode, loff_t offset, loff_t len, int mode),
TP_ARGS(inode, offset, len, mode),
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,11,0))
-TRACE_EVENT(ext4_punch_hole,
+LTTNG_TRACEPOINT_EVENT(ext4_punch_hole,
TP_PROTO(struct inode *inode, loff_t offset, loff_t len),
TP_ARGS(inode, offset, len),
#endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,15,0)) */
-TRACE_EVENT(ext4_unlink_enter,
+LTTNG_TRACEPOINT_EVENT(ext4_unlink_enter,
TP_PROTO(struct inode *parent, struct dentry *dentry),
TP_ARGS(parent, dentry),
(unsigned long) __entry->parent)
)
-TRACE_EVENT(ext4_unlink_exit,
+LTTNG_TRACEPOINT_EVENT(ext4_unlink_exit,
TP_PROTO(struct dentry *dentry, int ret),
TP_ARGS(dentry, ret),
__entry->ret)
)
-DECLARE_EVENT_CLASS(ext4__truncate,
+LTTNG_TRACEPOINT_EVENT_CLASS(ext4__truncate,
TP_PROTO(struct inode *inode),
TP_ARGS(inode),
(unsigned long) __entry->ino, __entry->blocks)
)
-DEFINE_EVENT(ext4__truncate, ext4_truncate_enter,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__truncate, ext4_truncate_enter,
TP_PROTO(struct inode *inode),
TP_ARGS(inode)
)
-DEFINE_EVENT(ext4__truncate, ext4_truncate_exit,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__truncate, ext4_truncate_exit,
TP_PROTO(struct inode *inode),
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
/* 'ux' is the uninitialized extent. */
-TRACE_EVENT(ext4_ext_convert_to_initialized_enter,
+LTTNG_TRACEPOINT_EVENT(ext4_ext_convert_to_initialized_enter,
TP_PROTO(struct inode *inode, struct ext4_map_blocks *map,
struct ext4_extent *ux),
* 'ux' is the uninitialized extent.
* 'ix' is the initialized extent to which blocks are transferred.
*/
-TRACE_EVENT(ext4_ext_convert_to_initialized_fastpath,
+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),
)
#endif
-DECLARE_EVENT_CLASS(ext4__map_blocks_enter,
+LTTNG_TRACEPOINT_EVENT_CLASS(ext4__map_blocks_enter,
TP_PROTO(struct inode *inode, ext4_lblk_t lblk,
unsigned int len, unsigned int flags),
__entry->lblk, __entry->len, __entry->flags)
)
-DEFINE_EVENT(ext4__map_blocks_enter, ext4_ext_map_blocks_enter,
+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)
)
-DEFINE_EVENT(ext4__map_blocks_enter, ext4_ind_map_blocks_enter,
+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),
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,11,0))
-DECLARE_EVENT_CLASS(ext4__map_blocks_exit,
+LTTNG_TRACEPOINT_EVENT_CLASS(ext4__map_blocks_exit,
TP_PROTO(struct inode *inode, unsigned flags, struct ext4_map_blocks *map,
int ret),
__entry->len, show_mflags(__entry->mflags), __entry->ret)
)
-DEFINE_EVENT(ext4__map_blocks_exit, ext4_ext_map_blocks_exit,
+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)
)
-DEFINE_EVENT(ext4__map_blocks_exit, ext4_ind_map_blocks_exit,
+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),
#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,8,0))
-DECLARE_EVENT_CLASS(ext4__map_blocks_exit,
+LTTNG_TRACEPOINT_EVENT_CLASS(ext4__map_blocks_exit,
TP_PROTO(struct inode *inode, struct ext4_map_blocks *map, int ret),
TP_ARGS(inode, map, ret),
__entry->len, __entry->flags, __entry->ret)
)
-DEFINE_EVENT(ext4__map_blocks_exit, ext4_ext_map_blocks_exit,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__map_blocks_exit, ext4_ext_map_blocks_exit,
TP_PROTO(struct inode *inode, struct ext4_map_blocks *map, int ret),
TP_ARGS(inode, map, ret)
)
-DEFINE_EVENT(ext4__map_blocks_exit, ext4_ind_map_blocks_exit,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__map_blocks_exit, ext4_ind_map_blocks_exit,
TP_PROTO(struct inode *inode, struct ext4_map_blocks *map, int ret),
TP_ARGS(inode, map, ret)
#else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,8,0)) */
-DECLARE_EVENT_CLASS(ext4__map_blocks_exit,
+LTTNG_TRACEPOINT_EVENT_CLASS(ext4__map_blocks_exit,
TP_PROTO(struct inode *inode, ext4_lblk_t lblk,
ext4_fsblk_t pblk, unsigned int len, int ret),
__entry->len, __entry->ret)
)
-DEFINE_EVENT(ext4__map_blocks_exit, ext4_ext_map_blocks_exit,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__map_blocks_exit, ext4_ext_map_blocks_exit,
TP_PROTO(struct inode *inode, ext4_lblk_t lblk,
ext4_fsblk_t pblk, unsigned len, int ret),
TP_ARGS(inode, lblk, pblk, len, ret)
)
-DEFINE_EVENT(ext4__map_blocks_exit, ext4_ind_map_blocks_exit,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__map_blocks_exit, ext4_ind_map_blocks_exit,
TP_PROTO(struct inode *inode, ext4_lblk_t lblk,
ext4_fsblk_t pblk, unsigned len, int ret),
#endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,8,0)) */
-TRACE_EVENT(ext4_ext_load_extent,
+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),
__entry->lblk, __entry->pblk)
)
-TRACE_EVENT(ext4_load_inode,
+LTTNG_TRACEPOINT_EVENT(ext4_load_inode,
TP_PROTO(struct inode *inode),
TP_ARGS(inode),
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,11,0))
-TRACE_EVENT(ext4_journal_start,
+LTTNG_TRACEPOINT_EVENT(ext4_journal_start,
TP_PROTO(struct super_block *sb, int blocks, int rsv_blocks,
unsigned long IP),
__entry->blocks, __entry->rsv_blocks, (void *)__entry->ip)
)
-TRACE_EVENT(ext4_journal_start_reserved,
+LTTNG_TRACEPOINT_EVENT(ext4_journal_start_reserved,
TP_PROTO(struct super_block *sb, int blocks, unsigned long IP),
TP_ARGS(sb, blocks, IP),
#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,1,0))
-TRACE_EVENT(ext4_journal_start,
+LTTNG_TRACEPOINT_EVENT(ext4_journal_start,
TP_PROTO(struct super_block *sb, int nblocks, unsigned long IP),
TP_ARGS(sb, nblocks, IP),
__entry->nblocks, (void *)__entry->ip)
)
-DECLARE_EVENT_CLASS(ext4__trim,
+LTTNG_TRACEPOINT_EVENT_CLASS(ext4__trim,
TP_PROTO(struct super_block *sb,
ext4_group_t group,
ext4_grpblk_t start,
__entry->group, __entry->start, __entry->len)
)
-DEFINE_EVENT(ext4__trim, ext4_trim_extent,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__trim, ext4_trim_extent,
TP_PROTO(struct super_block *sb,
ext4_group_t group,
TP_ARGS(sb, group, start, len)
)
-DEFINE_EVENT(ext4__trim, ext4_trim_all_free,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__trim, ext4_trim_all_free,
TP_PROTO(struct super_block *sb,
ext4_group_t group,
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
-TRACE_EVENT(ext4_ext_handle_uninitialized_extents,
+LTTNG_TRACEPOINT_EVENT(ext4_ext_handle_uninitialized_extents,
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,8,0))
TP_PROTO(struct inode *inode, struct ext4_map_blocks *map, int flags,
unsigned int allocated, ext4_fsblk_t newblock),
(unsigned long long) __entry->newblk)
)
-TRACE_EVENT(ext4_get_implied_cluster_alloc_exit,
+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),
__entry->len, __entry->flags, __entry->ret)
)
-TRACE_EVENT(ext4_ext_put_in_cache,
+LTTNG_TRACEPOINT_EVENT(ext4_ext_put_in_cache,
TP_PROTO(struct inode *inode, ext4_lblk_t lblk, unsigned int len,
ext4_fsblk_t start),
(unsigned long long) __entry->start)
)
-TRACE_EVENT(ext4_ext_in_cache,
+LTTNG_TRACEPOINT_EVENT(ext4_ext_in_cache,
TP_PROTO(struct inode *inode, ext4_lblk_t lblk, int ret),
TP_ARGS(inode, lblk, ret),
)
-TRACE_EVENT(ext4_find_delalloc_range,
+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),
(unsigned) __entry->found_blk)
)
-TRACE_EVENT(ext4_get_reserved_cluster_alloc,
+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),
__entry->len)
)
-TRACE_EVENT(ext4_ext_show_extent,
+LTTNG_TRACEPOINT_EVENT(ext4_ext_show_extent,
TP_PROTO(struct inode *inode, ext4_lblk_t lblk, ext4_fsblk_t pblk,
unsigned short len),
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,11,0))
-TRACE_EVENT(ext4_remove_blocks,
+LTTNG_TRACEPOINT_EVENT(ext4_remove_blocks,
TP_PROTO(struct inode *inode, struct ext4_extent *ex,
ext4_lblk_t from, ext4_fsblk_t to,
long long partial_cluster),
#else
-TRACE_EVENT(ext4_remove_blocks,
+LTTNG_TRACEPOINT_EVENT(ext4_remove_blocks,
TP_PROTO(struct inode *inode, struct ext4_extent *ex,
ext4_lblk_t from, ext4_fsblk_t to,
ext4_fsblk_t partial_cluster),
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,11,0))
-TRACE_EVENT(ext4_ext_rm_leaf,
+LTTNG_TRACEPOINT_EVENT(ext4_ext_rm_leaf,
TP_PROTO(struct inode *inode, ext4_lblk_t start,
struct ext4_extent *ex,
long long partial_cluster),
#else
-TRACE_EVENT(ext4_ext_rm_leaf,
+LTTNG_TRACEPOINT_EVENT(ext4_ext_rm_leaf,
TP_PROTO(struct inode *inode, ext4_lblk_t start,
struct ext4_extent *ex, ext4_fsblk_t partial_cluster),
#endif
-TRACE_EVENT(ext4_ext_rm_idx,
+LTTNG_TRACEPOINT_EVENT(ext4_ext_rm_idx,
TP_PROTO(struct inode *inode, ext4_fsblk_t pblk),
TP_ARGS(inode, pblk),
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,11,0))
-TRACE_EVENT(ext4_ext_remove_space,
+LTTNG_TRACEPOINT_EVENT(ext4_ext_remove_space,
TP_PROTO(struct inode *inode, ext4_lblk_t start,
ext4_lblk_t end, int depth),
#else
-TRACE_EVENT(ext4_ext_remove_space,
+LTTNG_TRACEPOINT_EVENT(ext4_ext_remove_space,
TP_PROTO(struct inode *inode, ext4_lblk_t start, int depth),
TP_ARGS(inode, start, depth),
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,11,0))
-TRACE_EVENT(ext4_ext_remove_space_done,
+LTTNG_TRACEPOINT_EVENT(ext4_ext_remove_space_done,
TP_PROTO(struct inode *inode, ext4_lblk_t start, ext4_lblk_t end,
int depth, long long partial, __le16 eh_entries),
#else
-TRACE_EVENT(ext4_ext_remove_space_done,
+LTTNG_TRACEPOINT_EVENT(ext4_ext_remove_space_done,
TP_PROTO(struct inode *inode, ext4_lblk_t start, int depth,
ext4_lblk_t partial, unsigned short eh_entries),
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,12,0))
-DECLARE_EVENT_CLASS(ext4__es_extent,
+LTTNG_TRACEPOINT_EVENT_CLASS(ext4__es_extent,
TP_PROTO(struct inode *inode, struct extent_status *es),
TP_ARGS(inode, es),
__entry->pblk, show_extent_status(__entry->status))
)
-DEFINE_EVENT(ext4__es_extent, ext4_es_insert_extent,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__es_extent, ext4_es_insert_extent,
TP_PROTO(struct inode *inode, struct extent_status *es),
TP_ARGS(inode, es)
)
-DEFINE_EVENT(ext4__es_extent, ext4_es_cache_extent,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__es_extent, ext4_es_cache_extent,
TP_PROTO(struct inode *inode, struct extent_status *es),
TP_ARGS(inode, es)
#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,11,0))
-TRACE_EVENT(ext4_es_insert_extent,
+LTTNG_TRACEPOINT_EVENT(ext4_es_insert_extent,
TP_PROTO(struct inode *inode, struct extent_status *es),
TP_ARGS(inode, es),
__entry->pblk, show_extent_status(__entry->status))
)
-TRACE_EVENT(ext4_es_remove_extent,
+LTTNG_TRACEPOINT_EVENT(ext4_es_remove_extent,
TP_PROTO(struct inode *inode, ext4_lblk_t lblk, ext4_lblk_t len),
TP_ARGS(inode, lblk, len),
__entry->lblk, __entry->len)
)
-TRACE_EVENT(ext4_es_find_delayed_extent_range_enter,
+LTTNG_TRACEPOINT_EVENT(ext4_es_find_delayed_extent_range_enter,
TP_PROTO(struct inode *inode, ext4_lblk_t lblk),
TP_ARGS(inode, lblk),
(unsigned long) __entry->ino, __entry->lblk)
)
-TRACE_EVENT(ext4_es_find_delayed_extent_range_exit,
+LTTNG_TRACEPOINT_EVENT(ext4_es_find_delayed_extent_range_exit,
TP_PROTO(struct inode *inode, struct extent_status *es),
TP_ARGS(inode, es),
__entry->pblk, show_extent_status(__entry->status))
)
-TRACE_EVENT(ext4_es_lookup_extent_enter,
+LTTNG_TRACEPOINT_EVENT(ext4_es_lookup_extent_enter,
TP_PROTO(struct inode *inode, ext4_lblk_t lblk),
TP_ARGS(inode, lblk),
(unsigned long) __entry->ino, __entry->lblk)
)
-TRACE_EVENT(ext4_es_lookup_extent_exit,
+LTTNG_TRACEPOINT_EVENT(ext4_es_lookup_extent_exit,
TP_PROTO(struct inode *inode, struct extent_status *es,
int found),
show_extent_status(__entry->found ? __entry->status : 0))
)
-TRACE_EVENT(ext4_es_shrink_enter,
+LTTNG_TRACEPOINT_EVENT(ext4_es_shrink_enter,
TP_PROTO(struct super_block *sb, int nr_to_scan, int cache_cnt),
TP_ARGS(sb, nr_to_scan, cache_cnt),
__entry->nr_to_scan, __entry->cache_cnt)
)
-TRACE_EVENT(ext4_es_shrink_exit,
+LTTNG_TRACEPOINT_EVENT(ext4_es_shrink_exit,
TP_PROTO(struct super_block *sb, int shrunk_nr, int cache_cnt),
TP_ARGS(sb, shrunk_nr, cache_cnt),
#endif
-#endif /* _TRACE_EXT4_H */
+#endif /* LTTNG_TRACE_EXT4_H */
/* This part must be outside protection */
#include "../../../probes/define_trace.h"
#undef TRACE_SYSTEM
#define TRACE_SYSTEM gpio
-#if !defined(_TRACE_GPIO_H) || defined(TRACE_HEADER_MULTI_READ)
-#define _TRACE_GPIO_H
+#if !defined(LTTNG_TRACE_GPIO_H) || defined(TRACE_HEADER_MULTI_READ)
+#define LTTNG_TRACE_GPIO_H
-#include <linux/tracepoint.h>
+#include "../../../probes/lttng-tracepoint-event.h"
-TRACE_EVENT(gpio_direction,
+LTTNG_TRACEPOINT_EVENT(gpio_direction,
TP_PROTO(unsigned gpio, int in, int err),
__entry->in ? "in" : "out", __entry->err)
)
-TRACE_EVENT(gpio_value,
+LTTNG_TRACEPOINT_EVENT(gpio_value,
TP_PROTO(unsigned gpio, int get, int value),
__entry->get ? "get" : "set", __entry->value)
)
-#endif /* if !defined(_TRACE_GPIO_H) || defined(TRACE_HEADER_MULTI_READ) */
+#endif /* if !defined(LTTNG_TRACE_GPIO_H) || defined(TRACE_HEADER_MULTI_READ) */
/* This part must be outside protection */
#include "../../../probes/define_trace.h"
#undef TRACE_SYSTEM
#define TRACE_SYSTEM irq
-#if !defined(_TRACE_IRQ_H) || defined(TRACE_HEADER_MULTI_READ)
-#define _TRACE_IRQ_H
+#if !defined(LTTNG_TRACE_IRQ_H) || defined(TRACE_HEADER_MULTI_READ)
+#define LTTNG_TRACE_IRQ_H
-#include <linux/tracepoint.h>
+#include "../../../probes/lttng-tracepoint-event.h"
#ifndef _TRACE_IRQ_DEF_
#define _TRACE_IRQ_DEF_
* conjunction with the irq_handler_exit tracepoint, we can figure
* out irq handler latencies.
*/
-TRACE_EVENT(irq_handler_entry,
+LTTNG_TRACEPOINT_EVENT(irq_handler_entry,
TP_PROTO(int irq, struct irqaction *action),
* 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.
*/
-TRACE_EVENT(irq_handler_exit,
+LTTNG_TRACEPOINT_EVENT(irq_handler_exit,
TP_PROTO(int irq, struct irqaction *action, int ret),
)
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37))
-DECLARE_EVENT_CLASS(softirq,
+LTTNG_TRACEPOINT_EVENT_CLASS(softirq,
TP_PROTO(unsigned int vec_nr),
* When used in combination with the softirq_exit tracepoint
* we can determine the softirq handler runtine.
*/
-DEFINE_EVENT(softirq, softirq_entry,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(softirq, softirq_entry,
TP_PROTO(unsigned int vec_nr),
* When used in combination with the softirq_entry tracepoint
* we can determine the softirq handler runtine.
*/
-DEFINE_EVENT(softirq, softirq_exit,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(softirq, softirq_exit,
TP_PROTO(unsigned int vec_nr),
* When used in combination with the softirq_entry tracepoint
* we can determine the softirq raise to run latency.
*/
-DEFINE_EVENT(softirq, softirq_raise,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(softirq, softirq_raise,
TP_PROTO(unsigned int vec_nr),
TP_ARGS(vec_nr)
)
#else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37)) */
-DECLARE_EVENT_CLASS(softirq,
+LTTNG_TRACEPOINT_EVENT_CLASS(softirq,
TP_PROTO(struct softirq_action *h, struct softirq_action *vec),
* When used in combination with the softirq_exit tracepoint
* we can determine the softirq handler runtine.
*/
-DEFINE_EVENT(softirq, softirq_entry,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(softirq, softirq_entry,
TP_PROTO(struct softirq_action *h, struct softirq_action *vec),
* When used in combination with the softirq_entry tracepoint
* we can determine the softirq handler runtine.
*/
-DEFINE_EVENT(softirq, softirq_exit,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(softirq, softirq_exit,
TP_PROTO(struct softirq_action *h, struct softirq_action *vec),
* When used in combination with the softirq_entry tracepoint
* we can determine the softirq raise to run latency.
*/
-DEFINE_EVENT(softirq, softirq_raise,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(softirq, softirq_raise,
TP_PROTO(struct softirq_action *h, struct softirq_action *vec),
)
#endif /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37)) */
-#endif /* _TRACE_IRQ_H */
+#endif /* LTTNG_TRACE_IRQ_H */
/* This part must be outside protection */
#include "../../../probes/define_trace.h"
#undef TRACE_SYSTEM
#define TRACE_SYSTEM jbd
-#if !defined(_TRACE_JBD_H) || defined(TRACE_HEADER_MULTI_READ)
-#define _TRACE_JBD_H
+#if !defined(LTTNG_TRACE_JBD_H) || defined(TRACE_HEADER_MULTI_READ)
+#define LTTNG_TRACE_JBD_H
+#include "../../../probes/lttng-tracepoint-event.h"
#include <linux/jbd.h>
-#include <linux/tracepoint.h>
#include <linux/version.h>
-TRACE_EVENT(jbd_checkpoint,
+LTTNG_TRACEPOINT_EVENT(jbd_checkpoint,
TP_PROTO(journal_t *journal, int result),
__entry->result)
)
-DECLARE_EVENT_CLASS(jbd_commit,
+LTTNG_TRACEPOINT_EVENT_CLASS(jbd_commit,
TP_PROTO(journal_t *journal, transaction_t *commit_transaction),
#endif
)
-DEFINE_EVENT(jbd_commit, jbd_start_commit,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(jbd_commit, jbd_start_commit,
TP_PROTO(journal_t *journal, transaction_t *commit_transaction),
TP_ARGS(journal, commit_transaction)
)
-DEFINE_EVENT(jbd_commit, jbd_commit_locking,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(jbd_commit, jbd_commit_locking,
TP_PROTO(journal_t *journal, transaction_t *commit_transaction),
TP_ARGS(journal, commit_transaction)
)
-DEFINE_EVENT(jbd_commit, jbd_commit_flushing,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(jbd_commit, jbd_commit_flushing,
TP_PROTO(journal_t *journal, transaction_t *commit_transaction),
TP_ARGS(journal, commit_transaction)
)
-DEFINE_EVENT(jbd_commit, jbd_commit_logging,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(jbd_commit, jbd_commit_logging,
TP_PROTO(journal_t *journal, transaction_t *commit_transaction),
TP_ARGS(journal, commit_transaction)
)
-TRACE_EVENT(jbd_drop_transaction,
+LTTNG_TRACEPOINT_EVENT(jbd_drop_transaction,
TP_PROTO(journal_t *journal, transaction_t *commit_transaction),
#endif
)
-TRACE_EVENT(jbd_end_commit,
+LTTNG_TRACEPOINT_EVENT(jbd_end_commit,
TP_PROTO(journal_t *journal, transaction_t *commit_transaction),
TP_ARGS(journal, commit_transaction),
#endif
)
-TRACE_EVENT(jbd_do_submit_data,
+LTTNG_TRACEPOINT_EVENT(jbd_do_submit_data,
TP_PROTO(journal_t *journal, transaction_t *commit_transaction),
TP_ARGS(journal, commit_transaction),
#endif
)
-TRACE_EVENT(jbd_cleanup_journal_tail,
+LTTNG_TRACEPOINT_EVENT(jbd_cleanup_journal_tail,
TP_PROTO(journal_t *journal, tid_t first_tid,
unsigned long block_nr, unsigned long freed),
)
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,5,0))
-TRACE_EVENT_MAP(journal_write_superblock,
+LTTNG_TRACEPOINT_EVENT_MAP(journal_write_superblock,
jbd_journal_write_superblock,
MINOR(__entry->dev), __entry->write_op)
)
#else
-TRACE_EVENT(jbd_update_superblock_end,
+LTTNG_TRACEPOINT_EVENT(jbd_update_superblock_end,
TP_PROTO(journal_t *journal, int wait),
TP_ARGS(journal, wait),
)
#endif
-#endif /* _TRACE_JBD_H */
+#endif /* LTTNG_TRACE_JBD_H */
/* This part must be outside protection */
#include "../../../probes/define_trace.h"
#undef TRACE_SYSTEM
#define TRACE_SYSTEM jbd2
-#if !defined(_TRACE_JBD2_H) || defined(TRACE_HEADER_MULTI_READ)
-#define _TRACE_JBD2_H
+#if !defined(LTTNG_TRACE_JBD2_H) || defined(TRACE_HEADER_MULTI_READ)
+#define LTTNG_TRACE_JBD2_H
+#include "../../../probes/lttng-tracepoint-event.h"
#include <linux/jbd2.h>
-#include <linux/tracepoint.h>
#include <linux/version.h>
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,32))
#endif
#endif
-TRACE_EVENT(jbd2_checkpoint,
+LTTNG_TRACEPOINT_EVENT(jbd2_checkpoint,
TP_PROTO(journal_t *journal, int result),
MAJOR(__entry->dev), MINOR(__entry->dev), __entry->result)
)
-DECLARE_EVENT_CLASS(jbd2_commit,
+LTTNG_TRACEPOINT_EVENT_CLASS(jbd2_commit,
TP_PROTO(journal_t *journal, transaction_t *commit_transaction),
__entry->transaction, __entry->sync_commit)
)
-DEFINE_EVENT(jbd2_commit, jbd2_start_commit,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(jbd2_commit, jbd2_start_commit,
TP_PROTO(journal_t *journal, transaction_t *commit_transaction),
TP_ARGS(journal, commit_transaction)
)
-DEFINE_EVENT(jbd2_commit, jbd2_commit_locking,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(jbd2_commit, jbd2_commit_locking,
TP_PROTO(journal_t *journal, transaction_t *commit_transaction),
TP_ARGS(journal, commit_transaction)
)
-DEFINE_EVENT(jbd2_commit, jbd2_commit_flushing,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(jbd2_commit, jbd2_commit_flushing,
TP_PROTO(journal_t *journal, transaction_t *commit_transaction),
TP_ARGS(journal, commit_transaction)
)
-DEFINE_EVENT(jbd2_commit, jbd2_commit_logging,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(jbd2_commit, jbd2_commit_logging,
TP_PROTO(journal_t *journal, transaction_t *commit_transaction),
)
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,4,0))
-DEFINE_EVENT(jbd2_commit, jbd2_drop_transaction,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(jbd2_commit, jbd2_drop_transaction,
TP_PROTO(journal_t *journal, transaction_t *commit_transaction),
)
#endif
-TRACE_EVENT(jbd2_end_commit,
+LTTNG_TRACEPOINT_EVENT(jbd2_end_commit,
TP_PROTO(journal_t *journal, transaction_t *commit_transaction),
TP_ARGS(journal, commit_transaction),
__entry->transaction, __entry->sync_commit, __entry->head)
)
-TRACE_EVENT(jbd2_submit_inode_data,
+LTTNG_TRACEPOINT_EVENT(jbd2_submit_inode_data,
TP_PROTO(struct inode *inode),
TP_ARGS(inode),
)
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,32))
-TRACE_EVENT(jbd2_run_stats,
+LTTNG_TRACEPOINT_EVENT(jbd2_run_stats,
TP_PROTO(dev_t dev, unsigned long tid,
struct transaction_run_stats_s *stats),
__entry->blocks_logged)
)
-TRACE_EVENT(jbd2_checkpoint_stats,
+LTTNG_TRACEPOINT_EVENT(jbd2_checkpoint_stats,
TP_PROTO(dev_t dev, unsigned long tid,
struct transaction_chp_stats_s *stats),
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,34))
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,4,0))
-TRACE_EVENT(jbd2_update_log_tail,
+LTTNG_TRACEPOINT_EVENT(jbd2_update_log_tail,
#else
-TRACE_EVENT(jbd2_cleanup_journal_tail,
+LTTNG_TRACEPOINT_EVENT(jbd2_cleanup_journal_tail,
#endif
TP_PROTO(journal_t *journal, tid_t first_tid,
#endif
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,4,0))
-TRACE_EVENT(jbd2_write_superblock,
+LTTNG_TRACEPOINT_EVENT(jbd2_write_superblock,
TP_PROTO(journal_t *journal, int write_op),
)
#endif
-#endif /* _TRACE_JBD2_H */
+#endif /* LTTNG_TRACE_JBD2_H */
/* This part must be outside protection */
#include "../../../probes/define_trace.h"
#undef TRACE_SYSTEM
#define TRACE_SYSTEM kmem
-#if !defined(_TRACE_KMEM_H) || defined(TRACE_HEADER_MULTI_READ)
-#define _TRACE_KMEM_H
+#if !defined(LTTNG_TRACE_KMEM_H) || defined(TRACE_HEADER_MULTI_READ)
+#define LTTNG_TRACE_KMEM_H
+#include "../../../probes/lttng-tracepoint-event.h"
#include <linux/types.h>
-#include <linux/tracepoint.h>
#include <linux/version.h>
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,36))
#include <trace/events/gfpflags.h>
#endif
-DECLARE_EVENT_CLASS(kmem_alloc,
+LTTNG_TRACEPOINT_EVENT_CLASS(kmem_alloc,
TP_PROTO(unsigned long call_site,
const void *ptr,
show_gfp_flags(__entry->gfp_flags))
)
-DEFINE_EVENT_MAP(kmem_alloc, kmalloc,
+LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(kmem_alloc, kmalloc,
kmem_kmalloc,
TP_ARGS(call_site, ptr, bytes_req, bytes_alloc, gfp_flags)
)
-DEFINE_EVENT(kmem_alloc, kmem_cache_alloc,
+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)
)
-DECLARE_EVENT_CLASS(kmem_alloc_node,
+LTTNG_TRACEPOINT_EVENT_CLASS(kmem_alloc_node,
TP_PROTO(unsigned long call_site,
const void *ptr,
__entry->node)
)
-DEFINE_EVENT_MAP(kmem_alloc_node, kmalloc_node,
+LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(kmem_alloc_node, kmalloc_node,
kmem_kmalloc_node,
TP_ARGS(call_site, ptr, bytes_req, bytes_alloc, gfp_flags, node)
)
-DEFINE_EVENT(kmem_alloc_node, kmem_cache_alloc_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,
TP_ARGS(call_site, ptr, bytes_req, bytes_alloc, gfp_flags, node)
)
-DECLARE_EVENT_CLASS(kmem_free,
+LTTNG_TRACEPOINT_EVENT_CLASS(kmem_free,
TP_PROTO(unsigned long call_site, const void *ptr),
TP_printk("call_site=%lx ptr=%p", __entry->call_site, __entry->ptr)
)
-DEFINE_EVENT_MAP(kmem_free, kfree,
+LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(kmem_free, kfree,
kmem_kfree,
TP_ARGS(call_site, ptr)
)
-DEFINE_EVENT(kmem_free, kmem_cache_free,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(kmem_free, kmem_cache_free,
TP_PROTO(unsigned long call_site, const void *ptr),
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,32))
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
-TRACE_EVENT(mm_page_free,
+LTTNG_TRACEPOINT_EVENT(mm_page_free,
#else
-TRACE_EVENT(mm_page_free_direct,
+LTTNG_TRACEPOINT_EVENT(mm_page_free_direct,
#endif
TP_PROTO(struct page *page, unsigned int order),
)
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
-TRACE_EVENT(mm_page_free_batched,
+LTTNG_TRACEPOINT_EVENT(mm_page_free_batched,
#else
-TRACE_EVENT(mm_pagevec_free,
+LTTNG_TRACEPOINT_EVENT(mm_pagevec_free,
#endif
TP_PROTO(struct page *page, int cold),
__entry->cold)
)
-TRACE_EVENT(mm_page_alloc,
+LTTNG_TRACEPOINT_EVENT(mm_page_alloc,
TP_PROTO(struct page *page, unsigned int order,
gfp_t gfp_flags, int migratetype),
show_gfp_flags(__entry->gfp_flags))
)
-DECLARE_EVENT_CLASS(mm_page,
+LTTNG_TRACEPOINT_EVENT_CLASS(mm_page,
TP_PROTO(struct page *page, unsigned int order, int migratetype),
__entry->order == 0)
)
-DEFINE_EVENT(mm_page, mm_page_alloc_zone_locked,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(mm_page, mm_page_alloc_zone_locked,
TP_PROTO(struct page *page, unsigned int order, int migratetype),
TP_ARGS(page, order, migratetype)
)
-DEFINE_EVENT_PRINT(mm_page, mm_page_pcpu_drain,
+LTTNG_TRACEPOINT_EVENT_INSTANCE_PRINT(mm_page, mm_page_pcpu_drain,
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,33))
TP_PROTO(struct page *page, unsigned int order, int migratetype),
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,12,0))
-TRACE_EVENT(mm_page_alloc_extfrag,
+LTTNG_TRACEPOINT_EVENT(mm_page_alloc_extfrag,
TP_PROTO(struct page *page,
int alloc_order, int fallback_order,
#else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,12,0)) */
-TRACE_EVENT(mm_page_alloc_extfrag,
+LTTNG_TRACEPOINT_EVENT(mm_page_alloc_extfrag,
TP_PROTO(struct page *page,
int alloc_order, int fallback_order,
#endif
-#endif /* _TRACE_KMEM_H */
+#endif /* LTTNG_TRACE_KMEM_H */
/* This part must be outside protection */
#include "../../../probes/define_trace.h"
-#if !defined(_TRACE_KVM_MAIN_H) || defined(TRACE_HEADER_MULTI_READ)
-#define _TRACE_KVM_MAIN_H
+#if !defined(LTTNG_TRACE_KVM_MAIN_H) || defined(TRACE_HEADER_MULTI_READ)
+#define LTTNG_TRACE_KVM_MAIN_H
-#include <linux/tracepoint.h>
+#include "../../../probes/lttng-tracepoint-event.h"
#include <linux/version.h>
#undef TRACE_SYSTEM
#endif
-TRACE_EVENT(kvm_userspace_exit,
+LTTNG_TRACEPOINT_EVENT(kvm_userspace_exit,
TP_PROTO(__u32 reason, int errno),
TP_ARGS(reason, errno),
#endif
#if defined(__KVM_HAVE_IRQ_LINE)
-TRACE_EVENT(kvm_set_irq,
+LTTNG_TRACEPOINT_EVENT(kvm_set_irq,
TP_PROTO(unsigned int gsi, int level, int irq_source_id),
TP_ARGS(gsi, level, irq_source_id),
{0x6, "SIPI"}, \
{0x7, "ExtINT"}
-TRACE_EVENT(kvm_ioapic_set_irq,
+LTTNG_TRACEPOINT_EVENT(kvm_ioapic_set_irq,
TP_PROTO(__u64 e, int pin, bool coalesced),
TP_ARGS(e, pin, coalesced),
__entry->coalesced ? " (coalesced)" : "")
)
-TRACE_EVENT(kvm_msi_set_irq,
+LTTNG_TRACEPOINT_EVENT(kvm_msi_set_irq,
TP_PROTO(__u64 address, __u64 data),
TP_ARGS(address, data),
{KVM_IRQCHIP_PIC_SLAVE, "PIC slave"}, \
{KVM_IRQCHIP_IOAPIC, "IOAPIC"}
-TRACE_EVENT(kvm_ack_irq,
+LTTNG_TRACEPOINT_EVENT(kvm_ack_irq,
TP_PROTO(unsigned int irqchip, unsigned int pin),
TP_ARGS(irqchip, pin),
{ KVM_TRACE_MMIO_READ, "read" }, \
{ KVM_TRACE_MMIO_WRITE, "write" }
-TRACE_EVENT(kvm_mmio,
+LTTNG_TRACEPOINT_EVENT(kvm_mmio,
TP_PROTO(int type, int len, u64 gpa, u64 val),
TP_ARGS(type, len, gpa, val),
{0, "unload"}, \
{1, "load"}
-TRACE_EVENT(kvm_fpu,
+LTTNG_TRACEPOINT_EVENT(kvm_fpu,
TP_PROTO(int load),
TP_ARGS(load),
TP_printk("%s", __print_symbolic(__entry->load, kvm_fpu_load_symbol))
)
-TRACE_EVENT(kvm_age_page,
+LTTNG_TRACEPOINT_EVENT(kvm_age_page,
TP_PROTO(ulong hva, struct kvm_memory_slot *slot, int ref),
TP_ARGS(hva, slot, ref),
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,38))
#ifdef CONFIG_KVM_ASYNC_PF
-DECLARE_EVENT_CLASS(kvm_async_get_page_class,
+LTTNG_TRACEPOINT_EVENT_CLASS(kvm_async_get_page_class,
TP_PROTO(u64 gva, u64 gfn),
TP_printk("gva = %#llx, gfn = %#llx", __entry->gva, __entry->gfn)
)
-DEFINE_EVENT(kvm_async_get_page_class, kvm_try_async_get_page,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(kvm_async_get_page_class, kvm_try_async_get_page,
TP_PROTO(u64 gva, u64 gfn),
TP_ARGS(gva, gfn)
)
-DEFINE_EVENT(kvm_async_get_page_class, kvm_async_pf_doublefault,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(kvm_async_get_page_class, kvm_async_pf_doublefault,
TP_PROTO(u64 gva, u64 gfn),
TP_ARGS(gva, gfn)
)
-DECLARE_EVENT_CLASS(kvm_async_pf_nopresent_ready,
+LTTNG_TRACEPOINT_EVENT_CLASS(kvm_async_pf_nopresent_ready,
TP_PROTO(u64 token, u64 gva),
)
-DEFINE_EVENT(kvm_async_pf_nopresent_ready, kvm_async_pf_not_present,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(kvm_async_pf_nopresent_ready, kvm_async_pf_not_present,
TP_PROTO(u64 token, u64 gva),
TP_ARGS(token, gva)
)
-DEFINE_EVENT(kvm_async_pf_nopresent_ready, kvm_async_pf_ready,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(kvm_async_pf_nopresent_ready, kvm_async_pf_ready,
TP_PROTO(u64 token, u64 gva),
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,13,0))
-TRACE_EVENT(
+LTTNG_TRACEPOINT_EVENT(
kvm_async_pf_completed,
TP_PROTO(unsigned long address, u64 gva),
TP_ARGS(address, gva),
#else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,13,0)) */
-TRACE_EVENT(
+LTTNG_TRACEPOINT_EVENT(
kvm_async_pf_completed,
TP_PROTO(unsigned long address, struct page *page, u64 gva),
TP_ARGS(address, page, gva),
#endif
-#endif /* _TRACE_KVM_MAIN_H */
+#endif /* LTTNG_TRACE_KVM_MAIN_H */
/* This part must be outside protection */
#include "../../../probes/define_trace.h"
#define TRACE_SYSTEM lockdep
#define TRACE_INCLUDE_FILE lock
#if defined(_TRACE_LOCKDEP_H)
-#define _TRACE_LOCK_H
+#define LTTNG_TRACE_LOCK_H
#endif
#endif
-#if !defined(_TRACE_LOCK_H) || defined(TRACE_HEADER_MULTI_READ)
-#define _TRACE_LOCK_H
+#if !defined(LTTNG_TRACE_LOCK_H) || defined(TRACE_HEADER_MULTI_READ)
+#define LTTNG_TRACE_LOCK_H
#include <linux/lockdep.h>
-#include <linux/tracepoint.h>
+#include "../../../probes/lttng-tracepoint-event.h"
#ifdef CONFIG_LOCKDEP
-TRACE_EVENT(lock_acquire,
+LTTNG_TRACEPOINT_EVENT(lock_acquire,
TP_PROTO(struct lockdep_map *lock, unsigned int subclass,
int trylock, int read, int check,
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,35))
-DECLARE_EVENT_CLASS(lock,
+LTTNG_TRACEPOINT_EVENT_CLASS(lock,
TP_PROTO(struct lockdep_map *lock, unsigned long ip),
TP_printk("%p %s", __entry->lockdep_addr, __get_str(name))
)
-DEFINE_EVENT(lock, lock_release,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(lock, lock_release,
TP_PROTO(struct lockdep_map *lock, unsigned long ip),
#ifdef CONFIG_LOCK_STAT
-DEFINE_EVENT(lock, lock_contended,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(lock, lock_contended,
TP_PROTO(struct lockdep_map *lock, unsigned long ip),
TP_ARGS(lock, ip)
)
-DEFINE_EVENT(lock, lock_acquired,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(lock, lock_acquired,
TP_PROTO(struct lockdep_map *lock, unsigned long ip),
#else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,35)) */
-TRACE_EVENT(lock_release,
+LTTNG_TRACEPOINT_EVENT(lock_release,
TP_PROTO(struct lockdep_map *lock, int nested, unsigned long ip),
#ifdef CONFIG_LOCK_STAT
-TRACE_EVENT(lock_contended,
+LTTNG_TRACEPOINT_EVENT(lock_contended,
TP_PROTO(struct lockdep_map *lock, unsigned long ip),
#endif
)
-TRACE_EVENT(lock_acquired,
+LTTNG_TRACEPOINT_EVENT(lock_acquired,
TP_PROTO(struct lockdep_map *lock, unsigned long ip, s64 waittime),
#endif
-#endif /* _TRACE_LOCK_H */
+#endif /* LTTNG_TRACE_LOCK_H */
/* This part must be outside protection */
#include "../../../probes/define_trace.h"
#undef TRACE_SYSTEM
#define TRACE_SYSTEM lttng_statedump
-#if !defined(_TRACE_LTTNG_STATEDUMP_H) || defined(TRACE_HEADER_MULTI_READ)
-#define _TRACE_LTTNG_STATEDUMP_H
+#if !defined(LTTNG_TRACE_LTTNG_STATEDUMP_H) || defined(TRACE_HEADER_MULTI_READ)
+#define LTTNG_TRACE_LTTNG_STATEDUMP_H
-#include <linux/tracepoint.h>
+#include "../../../probes/lttng-tracepoint-event.h"
#include <linux/nsproxy.h>
#include <linux/pid_namespace.h>
#include <linux/types.h>
-TRACE_EVENT(lttng_statedump_start,
+LTTNG_TRACEPOINT_EVENT(lttng_statedump_start,
TP_PROTO(struct lttng_session *session),
TP_ARGS(session),
TP_STRUCT__entry(
TP_printk("")
)
-TRACE_EVENT(lttng_statedump_end,
+LTTNG_TRACEPOINT_EVENT(lttng_statedump_end,
TP_PROTO(struct lttng_session *session),
TP_ARGS(session),
TP_STRUCT__entry(
TP_printk("")
)
-TRACE_EVENT(lttng_statedump_process_state,
+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,
TP_printk("")
)
-TRACE_EVENT(lttng_statedump_file_descriptor,
+LTTNG_TRACEPOINT_EVENT(lttng_statedump_file_descriptor,
TP_PROTO(struct lttng_session *session,
struct task_struct *p, int fd, const char *filename,
unsigned int flags, fmode_t fmode),
TP_printk("")
)
-TRACE_EVENT(lttng_statedump_vm_map,
+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_printk("")
)
-TRACE_EVENT(lttng_statedump_network_interface,
+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_printk("")
)
-TRACE_EVENT(lttng_statedump_block_device,
+LTTNG_TRACEPOINT_EVENT(lttng_statedump_block_device,
TP_PROTO(struct lttng_session *session,
dev_t dev, const char *diskname),
TP_ARGS(session, dev, diskname),
)
/* Called with desc->lock held */
-TRACE_EVENT(lttng_statedump_interrupt,
+LTTNG_TRACEPOINT_EVENT(lttng_statedump_interrupt,
TP_PROTO(struct lttng_session *session,
unsigned int irq, const char *chip_name,
struct irqaction *action),
TP_printk("")
)
-#endif /* _TRACE_LTTNG_STATEDUMP_H */
+#endif /* LTTNG_TRACE_LTTNG_STATEDUMP_H */
/* This part must be outside protection */
#include "../../../probes/define_trace.h"
#undef TRACE_SYSTEM
#define TRACE_SYSTEM lttng
-#if !defined(_TRACE_LTTNG_H) || defined(TRACE_HEADER_MULTI_READ)
-#define _TRACE_LTTNG_H
+#if !defined(LTTNG_TRACE_LTTNG_H) || defined(TRACE_HEADER_MULTI_READ)
+#define LTTNG_TRACE_LTTNG_H
-#include <linux/tracepoint.h>
+#include "../../../probes/lttng-tracepoint-event.h"
-TRACE_EVENT(lttng_logger,
+LTTNG_TRACEPOINT_EVENT(lttng_logger,
TP_PROTO(const char __user *text, size_t len),
TP_ARGS(text, len),
TP_STRUCT__entry(
TP_printk("")
)
-#endif /* _TRACE_LTTNG_H */
+#endif /* LTTNG_TRACE_LTTNG_H */
/* This part must be outside protection */
#include "../../../probes/define_trace.h"
#define TRACE_SYSTEM module
#endif
-#if !defined(_TRACE_MODULE_H) || defined(TRACE_HEADER_MULTI_READ)
-#define _TRACE_MODULE_H
+#if !defined(LTTNG_TRACE_MODULE_H) || defined(TRACE_HEADER_MULTI_READ)
+#define LTTNG_TRACE_MODULE_H
-#include <linux/tracepoint.h>
+#include "../../../probes/lttng-tracepoint-event.h"
#include <linux/version.h>
#ifdef CONFIG_MODULES
#endif
-TRACE_EVENT(module_load,
+LTTNG_TRACEPOINT_EVENT(module_load,
TP_PROTO(struct module *mod),
TP_printk("%s %s", __get_str(name), show_module_flags(__entry->taints))
)
-TRACE_EVENT(module_free,
+LTTNG_TRACEPOINT_EVENT(module_free,
TP_PROTO(struct module *mod),
#ifdef CONFIG_MODULE_UNLOAD
/* trace_module_get/put are only used if CONFIG_MODULE_UNLOAD is defined */
-DECLARE_EVENT_CLASS(module_refcnt,
+LTTNG_TRACEPOINT_EVENT_CLASS(module_refcnt,
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,35))
TP_PROTO(struct module *mod, unsigned long ip),
__get_str(name), (void *)__entry->ip, __entry->refcnt)
)
-DEFINE_EVENT(module_refcnt, module_get,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(module_refcnt, module_get,
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,35))
TP_PROTO(struct module *mod, unsigned long ip),
#endif
)
-DEFINE_EVENT(module_refcnt, module_put,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(module_refcnt, module_put,
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,35))
TP_PROTO(struct module *mod, unsigned long ip),
)
#endif /* CONFIG_MODULE_UNLOAD */
-TRACE_EVENT(module_request,
+LTTNG_TRACEPOINT_EVENT(module_request,
TP_PROTO(char *name, bool wait, unsigned long ip),
#endif /* CONFIG_MODULES */
-#endif /* _TRACE_MODULE_H */
+#endif /* LTTNG_TRACE_MODULE_H */
/* This part must be outside protection */
#include "../../../probes/define_trace.h"
#undef TRACE_SYSTEM
#define TRACE_SYSTEM napi
-#if !defined(_TRACE_NAPI_H_) || defined(TRACE_HEADER_MULTI_READ)
-#define _TRACE_NAPI_H_
+#if !defined(LTTNG_TRACE_NAPI_H) || defined(TRACE_HEADER_MULTI_READ)
+#define LTTNG_TRACE_NAPI_H
+#include "../../../probes/lttng-tracepoint-event.h"
#include <linux/netdevice.h>
-#include <linux/tracepoint.h>
#include <linux/ftrace.h>
#define NO_DEV "(no_device)"
-TRACE_EVENT(napi_poll,
+LTTNG_TRACEPOINT_EVENT(napi_poll,
TP_PROTO(struct napi_struct *napi),
#undef NO_DEV
-#endif /* _TRACE_NAPI_H_ */
+#endif /* LTTNG_TRACE_NAPI_H */
/* This part must be outside protection */
#include "../../../probes/define_trace.h"
#undef TRACE_SYSTEM
#define TRACE_SYSTEM net
-#if !defined(_TRACE_NET_H) || defined(TRACE_HEADER_MULTI_READ)
-#define _TRACE_NET_H
+#if !defined(LTTNG_TRACE_NET_H) || defined(TRACE_HEADER_MULTI_READ)
+#define LTTNG_TRACE_NET_H
+#include "../../../probes/lttng-tracepoint-event.h"
#include <linux/skbuff.h>
#include <linux/netdevice.h>
#include <linux/ip.h>
-#include <linux/tracepoint.h>
#include <linux/version.h>
-TRACE_EVENT(net_dev_xmit,
+LTTNG_TRACEPOINT_EVENT(net_dev_xmit,
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,40))
TP_PROTO(struct sk_buff *skb,
__get_str(name), __entry->skbaddr, __entry->len, __entry->rc)
)
-DECLARE_EVENT_CLASS(net_dev_template,
+LTTNG_TRACEPOINT_EVENT_CLASS(net_dev_template,
TP_PROTO(struct sk_buff *skb),
__get_str(name), __entry->skbaddr, __entry->len)
)
-DEFINE_EVENT(net_dev_template, net_dev_queue,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(net_dev_template, net_dev_queue,
TP_PROTO(struct sk_buff *skb),
TP_ARGS(skb)
)
-DEFINE_EVENT(net_dev_template, netif_receive_skb,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(net_dev_template, netif_receive_skb,
TP_PROTO(struct sk_buff *skb),
TP_ARGS(skb)
)
-DEFINE_EVENT(net_dev_template, netif_rx,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(net_dev_template, netif_rx,
TP_PROTO(struct sk_buff *skb),
TP_ARGS(skb)
)
-#endif /* _TRACE_NET_H */
+#endif /* LTTNG_TRACE_NET_H */
/* This part must be outside protection */
#include "../../../probes/define_trace.h"
#undef TRACE_SYSTEM
#define TRACE_SYSTEM power
-#if !defined(_TRACE_POWER_H) || defined(TRACE_HEADER_MULTI_READ)
-#define _TRACE_POWER_H
+#if !defined(LTTNG_TRACE_POWER_H) || defined(TRACE_HEADER_MULTI_READ)
+#define LTTNG_TRACE_POWER_H
+#include "../../../probes/lttng-tracepoint-event.h"
#include <linux/ktime.h>
-#include <linux/tracepoint.h>
#include <linux/version.h>
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,38))
-DECLARE_EVENT_CLASS(power_cpu,
+LTTNG_TRACEPOINT_EVENT_CLASS(power_cpu,
TP_PROTO(unsigned int state, unsigned int cpu_id),
(unsigned long)__entry->cpu_id)
)
-DEFINE_EVENT_MAP(power_cpu, cpu_idle,
+LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(power_cpu, cpu_idle,
power_cpu_idle,
#define PWR_EVENT_EXIT -1
#endif
-DEFINE_EVENT_MAP(power_cpu, cpu_frequency,
+LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(power_cpu, cpu_frequency,
power_cpu_frequency,
TP_ARGS(frequency, cpu_id)
)
-TRACE_EVENT_MAP(machine_suspend,
+LTTNG_TRACEPOINT_EVENT_MAP(machine_suspend,
power_machine_suspend,
#endif
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,5,0))
-DECLARE_EVENT_CLASS(power_wakeup_source,
+LTTNG_TRACEPOINT_EVENT_CLASS(power_wakeup_source,
TP_PROTO(const char *name, unsigned int state),
(unsigned long)__entry->state)
)
-DEFINE_EVENT_MAP(power_wakeup_source, wakeup_source_activate,
+LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(power_wakeup_source, wakeup_source_activate,
power_wakeup_source_activate,
TP_ARGS(name, state)
)
-DEFINE_EVENT_MAP(power_wakeup_source, wakeup_source_deactivate,
+LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(power_wakeup_source, wakeup_source_deactivate,
power_wakeup_source_deactivate,
* The power events are used for cpuidle & suspend (power_start, power_end)
* and for cpufreq (power_frequency)
*/
-DECLARE_EVENT_CLASS(power,
+LTTNG_TRACEPOINT_EVENT_CLASS(power,
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,36))
TP_PROTO(unsigned int type, unsigned int state, unsigned int cpu_id),
#endif
)
-DEFINE_EVENT(power, power_start,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(power, power_start,
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,36))
TP_PROTO(unsigned int type, unsigned int state, unsigned int cpu_id),
#endif
)
-DEFINE_EVENT(power, power_frequency,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(power, power_frequency,
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,36))
TP_PROTO(unsigned int type, unsigned int state, unsigned int cpu_id),
#endif
)
-TRACE_EVENT(power_end,
+LTTNG_TRACEPOINT_EVENT(power_end,
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,36))
TP_PROTO(unsigned int cpu_id),
* The clock events are used for clock enable/disable and for
* clock rate change
*/
-DECLARE_EVENT_CLASS(power_clock,
+LTTNG_TRACEPOINT_EVENT_CLASS(power_clock,
TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id),
(unsigned long)__entry->state, (unsigned long)__entry->cpu_id)
)
-DEFINE_EVENT_MAP(power_clock, clock_enable,
+LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(power_clock, clock_enable,
power_clock_enable,
TP_ARGS(name, state, cpu_id)
)
-DEFINE_EVENT_MAP(power_clock, clock_disable,
+LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(power_clock, clock_disable,
power_clock_disable,
TP_ARGS(name, state, cpu_id)
)
-DEFINE_EVENT_MAP(power_clock, clock_set_rate,
+LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(power_clock, clock_set_rate,
power_clock_set_rate,
/*
* The power domain events are used for power domains transitions
*/
-DECLARE_EVENT_CLASS(power_domain,
+LTTNG_TRACEPOINT_EVENT_CLASS(power_domain,
TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id),
(unsigned long)__entry->state, (unsigned long)__entry->cpu_id)
)
-DEFINE_EVENT(power_domain, power_domain_target,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(power_domain, power_domain_target,
TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id),
)
#endif
-#endif /* _TRACE_POWER_H */
+#endif /* LTTNG_TRACE_POWER_H */
/* This part must be outside protection */
#include "../../../probes/define_trace.h"
#undef TRACE_SYSTEM
#define TRACE_SYSTEM printk
-#if !defined(_TRACE_PRINTK_H) || defined(TRACE_HEADER_MULTI_READ)
-#define _TRACE_PRINTK_H
+#if !defined(LTTNG_TRACE_PRINTK_H) || defined(TRACE_HEADER_MULTI_READ)
+#define LTTNG_TRACE_PRINTK_H
-#include <linux/tracepoint.h>
+#include "../../../probes/lttng-tracepoint-event.h"
#include <linux/version.h>
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,10,0))
-TRACE_EVENT(console,
+LTTNG_TRACEPOINT_EVENT(console,
TP_PROTO(const char *text, size_t len),
TP_ARGS(text, len),
#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,5,0))
-TRACE_EVENT_CONDITION(console,
+LTTNG_TRACEPOINT_EVENT_CONDITION(console,
TP_PROTO(const char *log_buf, unsigned start, unsigned end,
unsigned log_buf_len),
#else /* (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0)) */
-TRACE_EVENT_CONDITION(console,
+LTTNG_TRACEPOINT_EVENT_CONDITION(console,
TP_PROTO(const char *log_buf, unsigned start, unsigned end,
unsigned log_buf_len),
#endif
-#endif /* _TRACE_PRINTK_H */
+#endif /* LTTNG_TRACE_PRINTK_H */
/* This part must be outside protection */
#include "../../../probes/define_trace.h"
#undef TRACE_SYSTEM
#define TRACE_SYSTEM random
-#if !defined(_TRACE_RANDOM_H) || defined(TRACE_HEADER_MULTI_READ)
-#define _TRACE_RANDOM_H
+#if !defined(LTTNG_TRACE_RANDOM_H) || defined(TRACE_HEADER_MULTI_READ)
+#define LTTNG_TRACE_RANDOM_H
+#include "../../../probes/lttng-tracepoint-event.h"
#include <linux/writeback.h>
-#include <linux/tracepoint.h>
-DECLARE_EVENT_CLASS(random__mix_pool_bytes,
+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),
__get_str(pool_name), __entry->bytes, (void *)__entry->IP)
)
-DEFINE_EVENT_MAP(random__mix_pool_bytes, mix_pool_bytes,
+LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(random__mix_pool_bytes, mix_pool_bytes,
random_mix_pool_bytes,
TP_ARGS(pool_name, bytes, IP)
)
-DEFINE_EVENT_MAP(random__mix_pool_bytes, mix_pool_bytes_nolock,
+LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(random__mix_pool_bytes, mix_pool_bytes_nolock,
random_mix_pool_bytes_nolock,
TP_ARGS(pool_name, bytes, IP)
)
-TRACE_EVENT_MAP(credit_entropy_bits,
+LTTNG_TRACEPOINT_EVENT_MAP(credit_entropy_bits,
random_credit_entropy_bits,
(void *)__entry->IP)
)
-TRACE_EVENT_MAP(get_random_bytes,
+LTTNG_TRACEPOINT_EVENT_MAP(get_random_bytes,
random_get_random_bytes,
TP_printk("nbytes %d caller %pF", __entry->nbytes, (void *)__entry->IP)
)
-DECLARE_EVENT_CLASS(random__extract_entropy,
+LTTNG_TRACEPOINT_EVENT_CLASS(random__extract_entropy,
TP_PROTO(const char *pool_name, int nbytes, int entropy_count,
unsigned long IP),
)
-DEFINE_EVENT_MAP(random__extract_entropy, extract_entropy,
+LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(random__extract_entropy, extract_entropy,
random_extract_entropy,
TP_ARGS(pool_name, nbytes, entropy_count, IP)
)
-DEFINE_EVENT_MAP(random__extract_entropy, extract_entropy_user,
+LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(random__extract_entropy, extract_entropy_user,
random_extract_entropy_user,
-#endif /* _TRACE_RANDOM_H */
+#endif /* LTTNG_TRACE_RANDOM_H */
/* This part must be outside protection */
#include "../../../probes/define_trace.h"
#undef TRACE_SYSTEM
#define TRACE_SYSTEM rcu
-#if !defined(_TRACE_RCU_H) || defined(TRACE_HEADER_MULTI_READ)
-#define _TRACE_RCU_H
+#if !defined(LTTNG_TRACE_RCU_H) || defined(TRACE_HEADER_MULTI_READ)
+#define LTTNG_TRACE_RCU_H
-#include <linux/tracepoint.h>
+#include "../../../probes/lttng-tracepoint-event.h"
#include <linux/version.h>
/*
* An "@" character within "<activity>" is a comment character: Data
* reduction scripts will ignore the "@" and the remainder of the line.
*/
-TRACE_EVENT(rcu_utilization,
+LTTNG_TRACEPOINT_EVENT(rcu_utilization,
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,12,0))
TP_PROTO(const char *s),
* and "cpuofl", respectively), and a CPU being kicked for being too
* long in dyntick-idle mode ("kick").
*/
-TRACE_EVENT(rcu_grace_period,
+LTTNG_TRACEPOINT_EVENT(rcu_grace_period,
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,12,0))
TP_PROTO(const char *rcuname, unsigned long gpnum, const char *gpevent),
* 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.
*/
-TRACE_EVENT(rcu_grace_period_init,
+LTTNG_TRACEPOINT_EVENT(rcu_grace_period_init,
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,12,0))
TP_PROTO(const char *rcuname, unsigned long gpnum, u8 level,
* include SRCU), the grace-period number that the task is blocking
* (the current or the next), and the task's PID.
*/
-TRACE_EVENT(rcu_preempt_task,
+LTTNG_TRACEPOINT_EVENT(rcu_preempt_task,
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,12,0))
TP_PROTO(const char *rcuname, int pid, unsigned long gpnum),
* read-side critical section exiting that critical section. Track the
* type of RCU (which one day might include SRCU) and the task's PID.
*/
-TRACE_EVENT(rcu_unlock_preempted_task,
+LTTNG_TRACEPOINT_EVENT(rcu_unlock_preempted_task,
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,12,0))
TP_PROTO(const char *rcuname, unsigned long gpnum, int pid),
* whether there are any blocked tasks blocking the current grace period.
* All but the type of RCU are extracted from the rcu_node structure.
*/
-TRACE_EVENT(rcu_quiescent_state_report,
+LTTNG_TRACEPOINT_EVENT(rcu_quiescent_state_report,
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,12,0))
TP_PROTO(const char *rcuname, unsigned long gpnum,
* or "kick" when kicking a CPU that has been in dyntick-idle mode for
* too long.
*/
-TRACE_EVENT(rcu_fqs,
+LTTNG_TRACEPOINT_EVENT(rcu_fqs,
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,12,0))
TP_PROTO(const char *rcuname, unsigned long gpnum, int cpu, const char *qsevent),
* events use the upper bits of each number, while interrupt-related
* events use the lower bits.
*/
-TRACE_EVENT(rcu_dyntick,
+LTTNG_TRACEPOINT_EVENT(rcu_dyntick,
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,12,0))
* "Demigrate": Timer fired on wrong CPU, woke up correct CPU.
* "Cleanup after idle": Idle exited, timer canceled.
*/
-TRACE_EVENT(rcu_prep_idle,
+LTTNG_TRACEPOINT_EVENT(rcu_prep_idle,
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,12,0))
TP_PROTO(const char *reason),
* number of lazy callbacks queued, and the fourth element is the
* total number of callbacks queued.
*/
-TRACE_EVENT(rcu_callback,
+LTTNG_TRACEPOINT_EVENT(rcu_callback,
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,12,0))
TP_PROTO(const char *rcuname, struct rcu_head *rhp, long qlen_lazy,
* the fourth argument is the number of lazy callbacks queued, and the
* fifth argument is the total number of callbacks queued.
*/
-TRACE_EVENT(rcu_kfree_callback,
+LTTNG_TRACEPOINT_EVENT(rcu_kfree_callback,
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,12,0))
* the total number of callbacks queued, and the fourth argument is
* the current RCU-callback batch limit.
*/
-TRACE_EVENT(rcu_batch_start,
+LTTNG_TRACEPOINT_EVENT(rcu_batch_start,
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,12,0))
TP_PROTO(const char *rcuname, long qlen_lazy, long qlen, long blimit),
* The first argument is the type of RCU, and the second argument is
* a pointer to the RCU callback itself.
*/
-TRACE_EVENT(rcu_invoke_callback,
+LTTNG_TRACEPOINT_EVENT(rcu_invoke_callback,
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,12,0))
TP_PROTO(const char *rcuname, struct rcu_head *rhp),
* is the offset of the callback within the enclosing RCU-protected
* data structure.
*/
-TRACE_EVENT(rcu_invoke_kfree_callback,
+LTTNG_TRACEPOINT_EVENT(rcu_invoke_kfree_callback,
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,12,0))
TP_PROTO(const char *rcuname, struct rcu_head *rhp, unsigned long offset),
* and the sixth argument (risk) is the return value from
* rcu_is_callbacks_kthread().
*/
-TRACE_EVENT(rcu_batch_end,
+LTTNG_TRACEPOINT_EVENT(rcu_batch_end,
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,13,0))
TP_PROTO(const char *rcuname, int callbacks_invoked,
* of the RCU flavor from rcutorture's viewpoint and the second argument
* is the callback address.
*/
-TRACE_EVENT(rcu_torture_read,
+LTTNG_TRACEPOINT_EVENT(rcu_torture_read,
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,12,0))
TP_PROTO(const char *rcutorturename, struct rcu_head *rhp,
* 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.
*/
-TRACE_EVENT(rcu_barrier,
+LTTNG_TRACEPOINT_EVENT(rcu_barrier,
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,12,0))
TP_PROTO(const char *rcuname, const char *s, int cpu, int cnt, unsigned long done),
#endif
#endif /* #else #ifdef CONFIG_RCU_TRACE */
-#endif /* _TRACE_RCU_H */
+#endif /* LTTNG_TRACE_RCU_H */
/* This part must be outside protection */
#include "../../../probes/define_trace.h"
#undef TRACE_SYSTEM
#define TRACE_SYSTEM regmap
-#if !defined(_TRACE_REGMAP_H) || defined(TRACE_HEADER_MULTI_READ)
-#define _TRACE_REGMAP_H
+#if !defined(LTTNG_TRACE_REGMAP_H) || defined(TRACE_HEADER_MULTI_READ)
+#define LTTNG_TRACE_REGMAP_H
+#include "../../../probes/lttng-tracepoint-event.h"
#include <linux/ktime.h>
-#include <linux/tracepoint.h>
#include <linux/version.h>
#ifndef _TRACE_REGMAP_DEF_
/*
* Log register events
*/
-DECLARE_EVENT_CLASS(regmap_reg,
+LTTNG_TRACEPOINT_EVENT_CLASS(regmap_reg,
TP_PROTO(struct device *dev, unsigned int reg,
unsigned int val),
(unsigned int)__entry->val)
)
-DEFINE_EVENT(regmap_reg, regmap_reg_write,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(regmap_reg, regmap_reg_write,
TP_PROTO(struct device *dev, unsigned int reg,
unsigned int val),
)
-DEFINE_EVENT(regmap_reg, regmap_reg_read,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(regmap_reg, regmap_reg_read,
TP_PROTO(struct device *dev, unsigned int reg,
unsigned int val),
)
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
-DEFINE_EVENT(regmap_reg, regmap_reg_read_cache,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(regmap_reg, regmap_reg_read_cache,
TP_PROTO(struct device *dev, unsigned int reg,
unsigned int val),
)
#endif
-DECLARE_EVENT_CLASS(regmap_block,
+LTTNG_TRACEPOINT_EVENT_CLASS(regmap_block,
TP_PROTO(struct device *dev, unsigned int reg, int count),
(int)__entry->count)
)
-DEFINE_EVENT(regmap_block, regmap_hw_read_start,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(regmap_block, regmap_hw_read_start,
TP_PROTO(struct device *dev, unsigned int reg, int count),
TP_ARGS(dev, reg, count)
)
-DEFINE_EVENT(regmap_block, regmap_hw_read_done,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(regmap_block, regmap_hw_read_done,
TP_PROTO(struct device *dev, unsigned int reg, int count),
TP_ARGS(dev, reg, count)
)
-DEFINE_EVENT(regmap_block, regmap_hw_write_start,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(regmap_block, regmap_hw_write_start,
TP_PROTO(struct device *dev, unsigned int reg, int count),
TP_ARGS(dev, reg, count)
)
-DEFINE_EVENT(regmap_block, regmap_hw_write_done,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(regmap_block, regmap_hw_write_done,
TP_PROTO(struct device *dev, unsigned int reg, int count),
TP_ARGS(dev, reg, count)
)
-TRACE_EVENT(regcache_sync,
+LTTNG_TRACEPOINT_EVENT(regcache_sync,
TP_PROTO(struct device *dev, const char *type,
const char *status),
)
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,4,0))
-DECLARE_EVENT_CLASS(regmap_bool,
+LTTNG_TRACEPOINT_EVENT_CLASS(regmap_bool,
TP_PROTO(struct device *dev, bool flag),
(int)__entry->flag)
)
-DEFINE_EVENT(regmap_bool, regmap_cache_only,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(regmap_bool, regmap_cache_only,
TP_PROTO(struct device *dev, bool flag),
)
-DEFINE_EVENT(regmap_bool, regmap_cache_bypass,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(regmap_bool, regmap_cache_bypass,
TP_PROTO(struct device *dev, bool flag),
)
#endif
-#endif /* _TRACE_REGMAP_H */
+#endif /* LTTNG_TRACE_REGMAP_H */
/* This part must be outside protection */
#include "../../../probes/define_trace.h"
#undef TRACE_SYSTEM
#define TRACE_SYSTEM regulator
-#if !defined(_TRACE_REGULATOR_H) || defined(TRACE_HEADER_MULTI_READ)
-#define _TRACE_REGULATOR_H
+#if !defined(LTTNG_TRACE_REGULATOR_H) || defined(TRACE_HEADER_MULTI_READ)
+#define LTTNG_TRACE_REGULATOR_H
+#include "../../../probes/lttng-tracepoint-event.h"
#include <linux/ktime.h>
-#include <linux/tracepoint.h>
/*
* Events which just log themselves and the regulator name for enable/disable
* type tracking.
*/
-DECLARE_EVENT_CLASS(regulator_basic,
+LTTNG_TRACEPOINT_EVENT_CLASS(regulator_basic,
TP_PROTO(const char *name),
)
-DEFINE_EVENT(regulator_basic, regulator_enable,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(regulator_basic, regulator_enable,
TP_PROTO(const char *name),
)
-DEFINE_EVENT(regulator_basic, regulator_enable_delay,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(regulator_basic, regulator_enable_delay,
TP_PROTO(const char *name),
)
-DEFINE_EVENT(regulator_basic, regulator_enable_complete,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(regulator_basic, regulator_enable_complete,
TP_PROTO(const char *name),
)
-DEFINE_EVENT(regulator_basic, regulator_disable,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(regulator_basic, regulator_disable,
TP_PROTO(const char *name),
)
-DEFINE_EVENT(regulator_basic, regulator_disable_complete,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(regulator_basic, regulator_disable_complete,
TP_PROTO(const char *name),
* Events that take a range of numerical values, mostly for voltages
* and so on.
*/
-DECLARE_EVENT_CLASS(regulator_range,
+LTTNG_TRACEPOINT_EVENT_CLASS(regulator_range,
TP_PROTO(const char *name, int min, int max),
(int)__entry->min, (int)__entry->max)
)
-DEFINE_EVENT(regulator_range, regulator_set_voltage,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(regulator_range, regulator_set_voltage,
TP_PROTO(const char *name, int min, int max),
/*
* Events that take a single value, mostly for readback and refcounts.
*/
-DECLARE_EVENT_CLASS(regulator_value,
+LTTNG_TRACEPOINT_EVENT_CLASS(regulator_value,
TP_PROTO(const char *name, unsigned int val),
(int)__entry->val)
)
-DEFINE_EVENT(regulator_value, regulator_set_voltage_complete,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(regulator_value, regulator_set_voltage_complete,
TP_PROTO(const char *name, unsigned int value),
#undef TRACE_SYSTEM
#define TRACE_SYSTEM rpm
-#if !defined(_TRACE_RUNTIME_POWER_H) || defined(TRACE_HEADER_MULTI_READ)
-#define _TRACE_RUNTIME_POWER_H
+#if !defined(LTTNG_TRACE_RUNTIME_POWER_H) || defined(TRACE_HEADER_MULTI_READ)
+#define LTTNG_TRACE_RUNTIME_POWER_H
+#include "../../../probes/lttng-tracepoint-event.h"
#include <linux/ktime.h>
-#include <linux/tracepoint.h>
#ifndef _TRACE_RPM_DEF_
#define _TRACE_RPM_DEF_
* The rpm_internal events are used for tracing some important
* runtime pm internal functions.
*/
-DECLARE_EVENT_CLASS(rpm_internal,
+LTTNG_TRACEPOINT_EVENT_CLASS(rpm_internal,
TP_PROTO(struct device *dev, int flags),
__entry->child_count
)
)
-DEFINE_EVENT(rpm_internal, rpm_suspend,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(rpm_internal, rpm_suspend,
TP_PROTO(struct device *dev, int flags),
TP_ARGS(dev, flags)
)
-DEFINE_EVENT(rpm_internal, rpm_resume,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(rpm_internal, rpm_resume,
TP_PROTO(struct device *dev, int flags),
TP_ARGS(dev, flags)
)
-DEFINE_EVENT(rpm_internal, rpm_idle,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(rpm_internal, rpm_idle,
TP_PROTO(struct device *dev, int flags),
TP_ARGS(dev, flags)
)
-TRACE_EVENT(rpm_return_int,
+LTTNG_TRACEPOINT_EVENT(rpm_return_int,
TP_PROTO(struct device *dev, unsigned long ip, int ret),
TP_ARGS(dev, ip, ret),
__entry->ret)
)
-#endif /* _TRACE_RUNTIME_POWER_H */
+#endif /* LTTNG_TRACE_RUNTIME_POWER_H */
/* This part must be outside protection */
#include "../../../probes/define_trace.h"
#undef TRACE_SYSTEM
#define TRACE_SYSTEM sched
-#if !defined(_TRACE_SCHED_H) || defined(TRACE_HEADER_MULTI_READ)
-#define _TRACE_SCHED_H
+#if !defined(LTTNG_TRACE_SCHED_H) || defined(TRACE_HEADER_MULTI_READ)
+#define LTTNG_TRACE_SCHED_H
+#include "../../../probes/lttng-tracepoint-event.h"
#include <linux/sched.h>
-#include <linux/tracepoint.h>
#include <linux/binfmts.h>
#include <linux/version.h>
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,9,0))
/*
* Tracepoint for calling kthread_stop, performed to end a kthread:
*/
-TRACE_EVENT(sched_kthread_stop,
+LTTNG_TRACEPOINT_EVENT(sched_kthread_stop,
TP_PROTO(struct task_struct *t),
/*
* Tracepoint for the return value of the kthread stopping:
*/
-TRACE_EVENT(sched_kthread_stop_ret,
+LTTNG_TRACEPOINT_EVENT(sched_kthread_stop_ret,
TP_PROTO(int ret),
/*
* Tracepoint for waking up a task:
*/
-DECLARE_EVENT_CLASS(sched_wakeup_template,
+LTTNG_TRACEPOINT_EVENT_CLASS(sched_wakeup_template,
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,35))
TP_PROTO(struct task_struct *p, int success),
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,35))
-DEFINE_EVENT(sched_wakeup_template, sched_wakeup,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(sched_wakeup_template, sched_wakeup,
TP_PROTO(struct task_struct *p, int success),
TP_ARGS(p, success))
/*
* Tracepoint for waking up a new task:
*/
-DEFINE_EVENT(sched_wakeup_template, sched_wakeup_new,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(sched_wakeup_template, sched_wakeup_new,
TP_PROTO(struct task_struct *p, int success),
TP_ARGS(p, success))
#else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,35)) */
-DEFINE_EVENT(sched_wakeup_template, sched_wakeup,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(sched_wakeup_template, sched_wakeup,
TP_PROTO(struct rq *rq, struct task_struct *p, int success),
TP_ARGS(rq, p, success))
/*
* Tracepoint for waking up a new task:
*/
-DEFINE_EVENT(sched_wakeup_template, sched_wakeup_new,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(sched_wakeup_template, sched_wakeup_new,
TP_PROTO(struct rq *rq, struct task_struct *p, int success),
TP_ARGS(rq, p, success))
/*
* Tracepoint for task switches, performed by the scheduler:
*/
-TRACE_EVENT(sched_switch,
+LTTNG_TRACEPOINT_EVENT(sched_switch,
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,35))
TP_PROTO(struct task_struct *prev,
/*
* Tracepoint for a task being migrated:
*/
-TRACE_EVENT(sched_migrate_task,
+LTTNG_TRACEPOINT_EVENT(sched_migrate_task,
TP_PROTO(struct task_struct *p, int dest_cpu),
__entry->orig_cpu, __entry->dest_cpu)
)
-DECLARE_EVENT_CLASS(sched_process_template,
+LTTNG_TRACEPOINT_EVENT_CLASS(sched_process_template,
TP_PROTO(struct task_struct *p),
/*
* Tracepoint for freeing a task:
*/
-DEFINE_EVENT(sched_process_template, sched_process_free,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(sched_process_template, sched_process_free,
TP_PROTO(struct task_struct *p),
TP_ARGS(p))
/*
* Tracepoint for a task exiting:
*/
-DEFINE_EVENT(sched_process_template, sched_process_exit,
+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:
*/
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,35))
-DEFINE_EVENT(sched_process_template, sched_wait_task,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(sched_process_template, sched_wait_task,
TP_PROTO(struct task_struct *p),
TP_ARGS(p))
#else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,35)) */
-DEFINE_EVENT(sched_process_template, sched_wait_task,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(sched_process_template, sched_wait_task,
TP_PROTO(struct rq *rq, struct task_struct *p),
TP_ARGS(rq, p))
#endif /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,35)) */
/*
* Tracepoint for a waiting task:
*/
-TRACE_EVENT(sched_process_wait,
+LTTNG_TRACEPOINT_EVENT(sched_process_wait,
TP_PROTO(struct pid *pid),
* == child_pid, while creation of a thread yields to child_tid !=
* child_pid.
*/
-TRACE_EVENT(sched_process_fork,
+LTTNG_TRACEPOINT_EVENT(sched_process_fork,
TP_PROTO(struct task_struct *parent, struct task_struct *child),
/*
* Tracepoint for sending a signal:
*/
-TRACE_EVENT(sched_signal_send,
+LTTNG_TRACEPOINT_EVENT(sched_signal_send,
TP_PROTO(int sig, struct task_struct *p),
/*
* Tracepoint for exec:
*/
-TRACE_EVENT(sched_process_exec,
+LTTNG_TRACEPOINT_EVENT(sched_process_exec,
TP_PROTO(struct task_struct *p, pid_t old_pid,
struct linux_binprm *bprm),
* XXX the below sched_stat tracepoints only apply to SCHED_OTHER/BATCH/IDLE
* adding sched_stat support to SCHED_FIFO/RR would be welcome.
*/
-DECLARE_EVENT_CLASS(sched_stat_template,
+LTTNG_TRACEPOINT_EVENT_CLASS(sched_stat_template,
TP_PROTO(struct task_struct *tsk, u64 delay),
* Tracepoint for accounting wait time (time the task is runnable
* but not actually running due to scheduler contention).
*/
-DEFINE_EVENT(sched_stat_template, sched_stat_wait,
+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).
*/
-DEFINE_EVENT(sched_stat_template, sched_stat_sleep,
+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).
*/
-DEFINE_EVENT(sched_stat_template, sched_stat_iowait,
+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).
*/
-DEFINE_EVENT(sched_stat_template, sched_stat_blocked,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(sched_stat_template, sched_stat_blocked,
TP_PROTO(struct task_struct *tsk, u64 delay),
TP_ARGS(tsk, delay))
#endif
* Tracepoint for accounting runtime (time the task is executing
* on a CPU).
*/
-TRACE_EVENT(sched_stat_runtime,
+LTTNG_TRACEPOINT_EVENT(sched_stat_runtime,
TP_PROTO(struct task_struct *tsk, u64 runtime, u64 vruntime),
* Tracepoint for showing priority inheritance modifying a tasks
* priority.
*/
-TRACE_EVENT(sched_pi_setprio,
+LTTNG_TRACEPOINT_EVENT(sched_pi_setprio,
TP_PROTO(struct task_struct *tsk, int newprio),
)
#endif
-#endif /* _TRACE_SCHED_H */
+#endif /* LTTNG_TRACE_SCHED_H */
/* This part must be outside protection */
#include "../../../probes/define_trace.h"
#undef TRACE_SYSTEM
#define TRACE_SYSTEM scsi
-#if !defined(_TRACE_SCSI_H) || defined(TRACE_HEADER_MULTI_READ)
-#define _TRACE_SCSI_H
+#if !defined(LTTNG_TRACE_SCSI_H) || defined(TRACE_HEADER_MULTI_READ)
+#define LTTNG_TRACE_SCSI_H
+#include "../../../probes/lttng-tracepoint-event.h"
#include <scsi/scsi_cmnd.h>
#include <scsi/scsi_host.h>
-#include <linux/tracepoint.h>
#include <linux/trace_seq.h>
#include <linux/version.h>
#define __parse_cdb(cdb, len) scsi_trace_parse_cdb(p, cdb, len)
#endif
-TRACE_EVENT(scsi_dispatch_cmd_start,
+LTTNG_TRACEPOINT_EVENT(scsi_dispatch_cmd_start,
TP_PROTO(struct scsi_cmnd *cmd),
__print_hex(__get_dynamic_array(cmnd), __entry->cmd_len))
)
-TRACE_EVENT(scsi_dispatch_cmd_error,
+LTTNG_TRACEPOINT_EVENT(scsi_dispatch_cmd_error,
TP_PROTO(struct scsi_cmnd *cmd, int rtn),
__entry->rtn)
)
-DECLARE_EVENT_CLASS(scsi_cmd_done_timeout_template,
+LTTNG_TRACEPOINT_EVENT_CLASS(scsi_cmd_done_timeout_template,
TP_PROTO(struct scsi_cmnd *cmd),
show_statusbyte_name(__entry->result & 0xff))
)
-DEFINE_EVENT(scsi_cmd_done_timeout_template, scsi_dispatch_cmd_done,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(scsi_cmd_done_timeout_template, scsi_dispatch_cmd_done,
TP_PROTO(struct scsi_cmnd *cmd),
TP_ARGS(cmd))
-DEFINE_EVENT(scsi_cmd_done_timeout_template, scsi_dispatch_cmd_timeout,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(scsi_cmd_done_timeout_template, scsi_dispatch_cmd_timeout,
TP_PROTO(struct scsi_cmnd *cmd),
TP_ARGS(cmd))
-TRACE_EVENT(scsi_eh_wakeup,
+LTTNG_TRACEPOINT_EVENT(scsi_eh_wakeup,
TP_PROTO(struct Scsi_Host *shost),
TP_printk("host_no=%u", __entry->host_no)
)
-#endif /* _TRACE_SCSI_H */
+#endif /* LTTNG_TRACE_SCSI_H */
/* This part must be outside protection */
#include "../../../probes/define_trace.h"
#undef TRACE_SYSTEM
#define TRACE_SYSTEM signal
-#if !defined(_TRACE_SIGNAL_H) || defined(TRACE_HEADER_MULTI_READ)
-#define _TRACE_SIGNAL_H
+#if !defined(LTTNG_TRACE_SIGNAL_H) || defined(TRACE_HEADER_MULTI_READ)
+#define LTTNG_TRACE_SIGNAL_H
-#include <linux/tracepoint.h>
+#include "../../../probes/lttng-tracepoint-event.h"
#include <linux/version.h>
#ifndef _TRACE_SIGNAL_DEF
* means that si_code is SI_KERNEL.
*/
#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,4,0))
-TRACE_EVENT(signal_generate,
+LTTNG_TRACEPOINT_EVENT(signal_generate,
TP_PROTO(int sig, struct siginfo *info, struct task_struct *task),
__entry->comm, __entry->pid)
)
#else
-TRACE_EVENT(signal_generate,
+LTTNG_TRACEPOINT_EVENT(signal_generate,
TP_PROTO(int sig, struct siginfo *info, struct task_struct *task,
int group, int result),
* This means, this can show which signals are actually delivered, but
* matching generated signals and delivered signals may not be correct.
*/
-TRACE_EVENT(signal_deliver,
+LTTNG_TRACEPOINT_EVENT(signal_deliver,
TP_PROTO(int sig, struct siginfo *info, struct k_sigaction *ka),
)
#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,4,0))
-DECLARE_EVENT_CLASS(signal_queue_overflow,
+LTTNG_TRACEPOINT_EVENT_CLASS(signal_queue_overflow,
TP_PROTO(int sig, int group, struct siginfo *info),
* 'group' is not 0 if the signal will be sent to a process group.
* 'sig' is always one of RT signals.
*/
-DEFINE_EVENT(signal_queue_overflow, signal_overflow_fail,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(signal_queue_overflow, signal_overflow_fail,
TP_PROTO(int sig, int group, struct siginfo *info),
* 'group' is not 0 if the signal will be sent to a process group.
* 'sig' is always one of non-RT signals.
*/
-DEFINE_EVENT(signal_queue_overflow, signal_lose_info,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(signal_queue_overflow, signal_lose_info,
TP_PROTO(int sig, int group, struct siginfo *info),
)
#endif
-#endif /* _TRACE_SIGNAL_H */
+#endif /* LTTNG_TRACE_SIGNAL_H */
/* This part must be outside protection */
#include "../../../probes/define_trace.h"
#undef TRACE_SYSTEM
#define TRACE_SYSTEM skb
-#if !defined(_TRACE_SKB_H) || defined(TRACE_HEADER_MULTI_READ)
-#define _TRACE_SKB_H
+#if !defined(LTTNG_TRACE_SKB_H) || defined(TRACE_HEADER_MULTI_READ)
+#define LTTNG_TRACE_SKB_H
+#include "../../../probes/lttng-tracepoint-event.h"
#include <linux/skbuff.h>
#include <linux/netdevice.h>
-#include <linux/tracepoint.h>
#include <linux/version.h>
/*
* Tracepoint for free an sk_buff:
*/
-TRACE_EVENT_MAP(kfree_skb,
+LTTNG_TRACEPOINT_EVENT_MAP(kfree_skb,
skb_kfree,
)
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37))
-TRACE_EVENT_MAP(consume_skb,
+LTTNG_TRACEPOINT_EVENT_MAP(consume_skb,
skb_consume,
#endif
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,32))
-TRACE_EVENT(skb_copy_datagram_iovec,
+LTTNG_TRACEPOINT_EVENT(skb_copy_datagram_iovec,
TP_PROTO(const struct sk_buff *skb, int len),
)
#endif
-#endif /* _TRACE_SKB_H */
+#endif /* LTTNG_TRACE_SKB_H */
/* This part must be outside protection */
#include "../../../probes/define_trace.h"
#undef TRACE_SYSTEM
#define TRACE_SYSTEM sock
-#if !defined(_TRACE_SOCK_H) || defined(TRACE_HEADER_MULTI_READ)
-#define _TRACE_SOCK_H
+#if !defined(LTTNG_TRACE_SOCK_H) || defined(TRACE_HEADER_MULTI_READ)
+#define LTTNG_TRACE_SOCK_H
+#include "../../../probes/lttng-tracepoint-event.h"
#include <net/sock.h>
-#include <linux/tracepoint.h>
-TRACE_EVENT(sock_rcvqueue_full,
+LTTNG_TRACEPOINT_EVENT(sock_rcvqueue_full,
TP_PROTO(struct sock *sk, struct sk_buff *skb),
__entry->rmem_alloc, __entry->truesize, __entry->sk_rcvbuf)
)
-TRACE_EVENT(sock_exceed_buf_limit,
+LTTNG_TRACEPOINT_EVENT(sock_exceed_buf_limit,
TP_PROTO(struct sock *sk, struct proto *prot, long allocated),
__entry->rmem_alloc)
)
-#endif /* _TRACE_SOCK_H */
+#endif /* LTTNG_TRACE_SOCK_H */
/* This part must be outside protection */
#include "../../../probes/define_trace.h"
#undef TRACE_SYSTEM
#define TRACE_SYSTEM sunrpc
-#if !defined(_TRACE_SUNRPC_H) || defined(TRACE_HEADER_MULTI_READ)
-#define _TRACE_SUNRPC_H
+#if !defined(LTTNG_TRACE_SUNRPC_H) || defined(TRACE_HEADER_MULTI_READ)
+#define LTTNG_TRACE_SUNRPC_H
+#include "../../../probes/lttng-tracepoint-event.h"
#include <linux/sunrpc/sched.h>
#include <linux/sunrpc/clnt.h>
-#include <linux/tracepoint.h>
-DECLARE_EVENT_CLASS(rpc_task_status,
+LTTNG_TRACEPOINT_EVENT_CLASS(rpc_task_status,
TP_PROTO(struct rpc_task *task),
TP_printk("task:%p@%p, status %d",__entry->task, __entry->clnt, __entry->status)
)
-DEFINE_EVENT(rpc_task_status, rpc_call_status,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(rpc_task_status, rpc_call_status,
TP_PROTO(struct rpc_task *task),
TP_ARGS(task)
)
-DEFINE_EVENT(rpc_task_status, rpc_bind_status,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(rpc_task_status, rpc_bind_status,
TP_PROTO(struct rpc_task *task),
TP_ARGS(task)
)
-TRACE_EVENT(rpc_connect_status,
+LTTNG_TRACEPOINT_EVENT(rpc_connect_status,
TP_PROTO(struct rpc_task *task, int status),
TP_ARGS(task, status),
TP_printk("task:%p@%p, status %d",__entry->task, __entry->clnt, __entry->status)
)
-DECLARE_EVENT_CLASS(rpc_task_running,
+LTTNG_TRACEPOINT_EVENT_CLASS(rpc_task_running,
TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action),
)
)
-DEFINE_EVENT(rpc_task_running, rpc_task_begin,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(rpc_task_running, rpc_task_begin,
TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action),
)
-DEFINE_EVENT(rpc_task_running, rpc_task_run_action,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(rpc_task_running, rpc_task_run_action,
TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action),
)
-DEFINE_EVENT(rpc_task_running, rpc_task_complete,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(rpc_task_running, rpc_task_complete,
TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action),
)
-DECLARE_EVENT_CLASS(rpc_task_queued,
+LTTNG_TRACEPOINT_EVENT_CLASS(rpc_task_queued,
TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const struct rpc_wait_queue *q),
)
)
-DEFINE_EVENT(rpc_task_queued, rpc_task_sleep,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(rpc_task_queued, rpc_task_sleep,
TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const struct rpc_wait_queue *q),
)
-DEFINE_EVENT(rpc_task_queued, rpc_task_wakeup,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(rpc_task_queued, rpc_task_wakeup,
TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const struct rpc_wait_queue *q),
)
-#endif /* _TRACE_SUNRPC_H */
+#endif /* LTTNG_TRACE_SUNRPC_H */
#include "../../../probes/define_trace.h"
#define TRACE_SYSTEM raw_syscalls
#define TRACE_INCLUDE_FILE syscalls
-#if !defined(_TRACE_EVENTS_SYSCALLS_H) || defined(TRACE_HEADER_MULTI_READ)
-#define _TRACE_EVENTS_SYSCALLS_H
+#if !defined(LTTNG_TRACE_EVENTS_SYSCALLS_H) || defined(TRACE_HEADER_MULTI_READ)
+#define LTTNG_TRACE_EVENTS_SYSCALLS_H
-#include <linux/tracepoint.h>
+#include "../../../probes/lttng-tracepoint-event.h"
#ifdef CONFIG_HAVE_SYSCALL_TRACEPOINTS
#endif /* _TRACE_SYSCALLS_DEF_ */
-TRACE_EVENT(sys_enter,
+LTTNG_TRACEPOINT_EVENT(sys_enter,
TP_PROTO(struct pt_regs *regs, long id),
__entry->args[3], __entry->args[4], __entry->args[5])
)
-TRACE_EVENT(sys_exit,
+LTTNG_TRACEPOINT_EVENT(sys_exit,
TP_PROTO(struct pt_regs *regs, long ret),
#endif /* CONFIG_HAVE_SYSCALL_TRACEPOINTS */
-#endif /* _TRACE_EVENTS_SYSCALLS_H */
+#endif /* LTTNG_TRACE_EVENTS_SYSCALLS_H */
/* This part must be outside protection */
#include "../../../probes/define_trace.h"
#undef TRACE_SYSTEM
#define TRACE_SYSTEM timer
-#if !defined(_TRACE_TIMER_H) || defined(TRACE_HEADER_MULTI_READ)
-#define _TRACE_TIMER_H
+#if !defined(LTTNG_TRACE_TIMER_H) || defined(TRACE_HEADER_MULTI_READ)
+#define LTTNG_TRACE_TIMER_H
-#include <linux/tracepoint.h>
+#include "../../../probes/lttng-tracepoint-event.h"
#ifndef _TRACE_TIMER_DEF_
#define _TRACE_TIMER_DEF_
#endif /* _TRACE_TIMER_DEF_ */
-DECLARE_EVENT_CLASS(timer_class,
+LTTNG_TRACEPOINT_EVENT_CLASS(timer_class,
TP_PROTO(struct timer_list *timer),
* timer_init - called when the timer is initialized
* @timer: pointer to struct timer_list
*/
-DEFINE_EVENT(timer_class, timer_init,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(timer_class, timer_init,
TP_PROTO(struct timer_list *timer),
* @timer: pointer to struct timer_list
* @expires: the timers expiry time
*/
-TRACE_EVENT(timer_start,
+LTTNG_TRACEPOINT_EVENT(timer_start,
TP_PROTO(struct timer_list *timer, unsigned long expires),
*
* Allows to determine the timer latency.
*/
-TRACE_EVENT(timer_expire_entry,
+LTTNG_TRACEPOINT_EVENT(timer_expire_entry,
TP_PROTO(struct timer_list *timer),
* NOTE: Do NOT derefernce timer in TP_fast_assign. The pointer might
* be invalid. We solely track the pointer.
*/
-DEFINE_EVENT(timer_class, timer_expire_exit,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(timer_class, timer_expire_exit,
TP_PROTO(struct timer_list *timer),
* timer_cancel - called when the timer is canceled
* @timer: pointer to struct timer_list
*/
-DEFINE_EVENT(timer_class, timer_cancel,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(timer_class, timer_cancel,
TP_PROTO(struct timer_list *timer),
* @clockid: the hrtimers clock
* @mode: the hrtimers mode
*/
-TRACE_EVENT(hrtimer_init,
+LTTNG_TRACEPOINT_EVENT(hrtimer_init,
TP_PROTO(struct hrtimer *hrtimer, clockid_t clockid,
enum hrtimer_mode mode),
* hrtimer_start - called when the hrtimer is started
* @timer: pointer to struct hrtimer
*/
-TRACE_EVENT(hrtimer_start,
+LTTNG_TRACEPOINT_EVENT(hrtimer_start,
TP_PROTO(struct hrtimer *hrtimer),
*
* Allows to determine the timer latency.
*/
-TRACE_EVENT(hrtimer_expire_entry,
+LTTNG_TRACEPOINT_EVENT(hrtimer_expire_entry,
TP_PROTO(struct hrtimer *hrtimer, ktime_t *now),
(unsigned long long)ktime_to_ns((ktime_t) { .tv64 = __entry->now }))
)
-DECLARE_EVENT_CLASS(hrtimer_class,
+LTTNG_TRACEPOINT_EVENT_CLASS(hrtimer_class,
TP_PROTO(struct hrtimer *hrtimer),
* When used in combination with the hrtimer_expire_entry tracepoint we can
* determine the runtime of the callback function.
*/
-DEFINE_EVENT(hrtimer_class, hrtimer_expire_exit,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(hrtimer_class, hrtimer_expire_exit,
TP_PROTO(struct hrtimer *hrtimer),
* hrtimer_cancel - called when the hrtimer is canceled
* @hrtimer: pointer to struct hrtimer
*/
-DEFINE_EVENT(hrtimer_class, hrtimer_cancel,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(hrtimer_class, hrtimer_cancel,
TP_PROTO(struct hrtimer *hrtimer),
* zero, otherwise it is started
* @expires: the itimers expiry time
*/
-TRACE_EVENT(itimer_state,
+LTTNG_TRACEPOINT_EVENT(itimer_state,
TP_PROTO(int which, const struct itimerval *const value,
cputime_t expires),
* @pid: pid of the process which owns the timer
* @now: current time, used to calculate the latency of itimer
*/
-TRACE_EVENT(itimer_expire,
+LTTNG_TRACEPOINT_EVENT(itimer_expire,
TP_PROTO(int which, struct pid *pid, cputime_t now),
(int) __entry->pid, (unsigned long long)__entry->now)
)
-#endif /* _TRACE_TIMER_H */
+#endif /* LTTNG_TRACE_TIMER_H */
/* This part must be outside protection */
#include "../../../probes/define_trace.h"
#undef TRACE_SYSTEM
#define TRACE_SYSTEM udp
-#if !defined(_TRACE_UDP_H) || defined(TRACE_HEADER_MULTI_READ)
-#define _TRACE_UDP_H
+#if !defined(LTTNG_TRACE_UDP_H) || defined(TRACE_HEADER_MULTI_READ)
+#define LTTNG_TRACE_UDP_H
+#include "../../../probes/lttng-tracepoint-event.h"
#include <linux/udp.h>
-#include <linux/tracepoint.h>
-TRACE_EVENT(udp_fail_queue_rcv_skb,
+LTTNG_TRACEPOINT_EVENT(udp_fail_queue_rcv_skb,
TP_PROTO(int rc, struct sock *sk),
TP_printk("rc=%d port=%hu", __entry->rc, __entry->lport)
)
-#endif /* _TRACE_UDP_H */
+#endif /* LTTNG_TRACE_UDP_H */
/* This part must be outside protection */
#include "../../../probes/define_trace.h"
#undef TRACE_SYSTEM
#define TRACE_SYSTEM v4l2
-#if !defined(_TRACE_V4L2_H) || defined(TRACE_HEADER_MULTI_READ)
-#define _TRACE_V4L2_H
+#if !defined(LTTNG_TRACE_V4L2_H) || defined(TRACE_HEADER_MULTI_READ)
+#define LTTNG_TRACE_V4L2_H
-#include <linux/tracepoint.h>
+#include "../../../probes/lttng-tracepoint-event.h"
#define show_field(field) \
__print_symbolic(field, \
{ V4L2_TC_USERBITS_USERDEFINED, "USERBITS_USERDEFINED" }, \
{ V4L2_TC_USERBITS_8BITCHARS, "USERBITS_8BITCHARS" })
-#define LTTNG_V4L2_TRACE_EVENT(event_name) \
- TRACE_EVENT(event_name, \
+#define LTTNG_TRACEPOINT_EVENT_V4L2(event_name) \
+ LTTNG_TRACEPOINT_EVENT(event_name, \
TP_PROTO(int minor, struct v4l2_buffer *buf), \
\
TP_ARGS(minor, buf), \
) \
)
-LTTNG_V4L2_TRACE_EVENT(v4l2_dqbuf)
-LTTNG_V4L2_TRACE_EVENT(v4l2_qbuf)
+LTTNG_TRACEPOINT_EVENT_V4L2(v4l2_dqbuf)
+LTTNG_TRACEPOINT_EVENT_V4L2(v4l2_qbuf)
-#endif /* if !defined(_TRACE_V4L2_H) || defined(TRACE_HEADER_MULTI_READ) */
+#endif /* if !defined(LTTNG_TRACE_V4L2_H) || defined(TRACE_HEADER_MULTI_READ) */
/* This part must be outside protection */
#include "../../../probes/define_trace.h"
#undef TRACE_SYSTEM
#define TRACE_SYSTEM vmscan
-#if !defined(_TRACE_VMSCAN_H) || defined(TRACE_HEADER_MULTI_READ)
-#define _TRACE_VMSCAN_H
+#if !defined(LTTNG_TRACE_VMSCAN_H) || defined(TRACE_HEADER_MULTI_READ)
+#define LTTNG_TRACE_VMSCAN_H
+#include "../../../probes/lttng-tracepoint-event.h"
#include <linux/types.h>
-#include <linux/tracepoint.h>
#include <linux/mm.h>
#include <linux/memcontrol.h>
#include <trace/events/gfpflags.h>
#endif
-TRACE_EVENT(mm_vmscan_kswapd_sleep,
+LTTNG_TRACEPOINT_EVENT(mm_vmscan_kswapd_sleep,
TP_PROTO(int nid),
TP_printk("nid=%d", __entry->nid)
)
-TRACE_EVENT(mm_vmscan_kswapd_wake,
+LTTNG_TRACEPOINT_EVENT(mm_vmscan_kswapd_wake,
TP_PROTO(int nid, int order),
TP_printk("nid=%d order=%d", __entry->nid, __entry->order)
)
-TRACE_EVENT(mm_vmscan_wakeup_kswapd,
+LTTNG_TRACEPOINT_EVENT(mm_vmscan_wakeup_kswapd,
TP_PROTO(int nid, int zid, int order),
__entry->order)
)
-DECLARE_EVENT_CLASS(mm_vmscan_direct_reclaim_begin_template,
+LTTNG_TRACEPOINT_EVENT_CLASS(mm_vmscan_direct_reclaim_begin_template,
TP_PROTO(int order, int may_writepage, gfp_t gfp_flags),
show_gfp_flags(__entry->gfp_flags))
)
-DEFINE_EVENT(mm_vmscan_direct_reclaim_begin_template, mm_vmscan_direct_reclaim_begin,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(mm_vmscan_direct_reclaim_begin_template, mm_vmscan_direct_reclaim_begin,
TP_PROTO(int order, int may_writepage, gfp_t gfp_flags),
TP_ARGS(order, may_writepage, gfp_flags)
)
-DEFINE_EVENT(mm_vmscan_direct_reclaim_begin_template, mm_vmscan_memcg_reclaim_begin,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(mm_vmscan_direct_reclaim_begin_template, mm_vmscan_memcg_reclaim_begin,
TP_PROTO(int order, int may_writepage, gfp_t gfp_flags),
TP_ARGS(order, may_writepage, gfp_flags)
)
-DEFINE_EVENT(mm_vmscan_direct_reclaim_begin_template, mm_vmscan_memcg_softlimit_reclaim_begin,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(mm_vmscan_direct_reclaim_begin_template, mm_vmscan_memcg_softlimit_reclaim_begin,
TP_PROTO(int order, int may_writepage, gfp_t gfp_flags),
TP_ARGS(order, may_writepage, gfp_flags)
)
-DECLARE_EVENT_CLASS(mm_vmscan_direct_reclaim_end_template,
+LTTNG_TRACEPOINT_EVENT_CLASS(mm_vmscan_direct_reclaim_end_template,
TP_PROTO(unsigned long nr_reclaimed),
TP_printk("nr_reclaimed=%lu", __entry->nr_reclaimed)
)
-DEFINE_EVENT(mm_vmscan_direct_reclaim_end_template, mm_vmscan_direct_reclaim_end,
+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)
)
-DEFINE_EVENT(mm_vmscan_direct_reclaim_end_template, mm_vmscan_memcg_reclaim_end,
+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)
)
-DEFINE_EVENT(mm_vmscan_direct_reclaim_end_template, mm_vmscan_memcg_softlimit_reclaim_end,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(mm_vmscan_direct_reclaim_end_template, mm_vmscan_memcg_softlimit_reclaim_end,
TP_PROTO(unsigned long nr_reclaimed),
)
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,1,0))
-TRACE_EVENT(mm_shrink_slab_start,
+LTTNG_TRACEPOINT_EVENT(mm_shrink_slab_start,
TP_PROTO(struct shrinker *shr, struct shrink_control *sc,
long nr_objects_to_shrink, unsigned long pgs_scanned,
unsigned long lru_pgs, unsigned long cache_items,
)
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,16,0))
-TRACE_EVENT(mm_shrink_slab_end,
+LTTNG_TRACEPOINT_EVENT(mm_shrink_slab_end,
TP_PROTO(struct shrinker *shr, int nid, int shrinker_retval,
long unused_scan_cnt, long new_scan_cnt, long total_scan),
__entry->retval)
)
#else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,16,0)) */
-TRACE_EVENT(mm_shrink_slab_end,
+LTTNG_TRACEPOINT_EVENT(mm_shrink_slab_end,
TP_PROTO(struct shrinker *shr, int shrinker_retval,
long unused_scan_cnt, long new_scan_cnt),
#endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,16,0)) */
#endif
-DECLARE_EVENT_CLASS(mm_vmscan_lru_isolate_template,
+LTTNG_TRACEPOINT_EVENT_CLASS(mm_vmscan_lru_isolate_template,
TP_PROTO(int order,
unsigned long nr_requested,
#endif
)
-DEFINE_EVENT(mm_vmscan_lru_isolate_template, mm_vmscan_lru_isolate,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(mm_vmscan_lru_isolate_template, mm_vmscan_lru_isolate,
TP_PROTO(int order,
unsigned long nr_requested,
)
-DEFINE_EVENT(mm_vmscan_lru_isolate_template, mm_vmscan_memcg_isolate,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(mm_vmscan_lru_isolate_template, mm_vmscan_memcg_isolate,
TP_PROTO(int order,
unsigned long nr_requested,
)
)
-TRACE_EVENT(mm_vmscan_writepage,
+LTTNG_TRACEPOINT_EVENT(mm_vmscan_writepage,
TP_PROTO(struct page *page,
int reclaim_flags),
)
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37))
-TRACE_EVENT(mm_vmscan_lru_shrink_inactive,
+LTTNG_TRACEPOINT_EVENT(mm_vmscan_lru_shrink_inactive,
TP_PROTO(int nid, int zid,
unsigned long nr_scanned, unsigned long nr_reclaimed,
#endif
#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0))
-TRACE_EVENT_MAP(replace_swap_token,
+LTTNG_TRACEPOINT_EVENT_MAP(replace_swap_token,
mm_vmscan_replace_swap_token,
__entry->new_mm, __entry->new_prio)
)
-DECLARE_EVENT_CLASS(mm_vmscan_put_swap_token_template,
+LTTNG_TRACEPOINT_EVENT_CLASS(mm_vmscan_put_swap_token_template,
TP_PROTO(struct mm_struct *swap_token_mm),
TP_ARGS(swap_token_mm),
TP_printk("token_mm=%p", __entry->swap_token_mm)
)
-DEFINE_EVENT_MAP(mm_vmscan_put_swap_token_template, put_swap_token,
+LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(mm_vmscan_put_swap_token_template, put_swap_token,
mm_vmscan_put_swap_token,
TP_ARGS(swap_token_mm)
)
-DEFINE_EVENT_CONDITION_MAP(mm_vmscan_put_swap_token_template, disable_swap_token,
+LTTNG_TRACEPOINT_EVENT_INSTANCE_CONDITION_MAP(mm_vmscan_put_swap_token_template, disable_swap_token,
mm_vmscan_disable_swap_token,
TP_CONDITION(swap_token_mm != NULL)
)
-TRACE_EVENT_CONDITION_MAP(update_swap_token_priority,
+LTTNG_TRACEPOINT_EVENT_CONDITION_MAP(update_swap_token_priority,
mm_vmscan_update_swap_token_priority,
)
#endif
-#endif /* _TRACE_VMSCAN_H */
+#endif /* LTTNG_TRACE_VMSCAN_H */
/* This part must be outside protection */
#include "../../../probes/define_trace.h"
#undef TRACE_SYSTEM
#define TRACE_SYSTEM workqueue
-#if !defined(_TRACE_WORKQUEUE_H) || defined(TRACE_HEADER_MULTI_READ)
-#define _TRACE_WORKQUEUE_H
+#if !defined(LTTNG_TRACE_WORKQUEUE_H) || defined(TRACE_HEADER_MULTI_READ)
+#define LTTNG_TRACE_WORKQUEUE_H
-#include <linux/tracepoint.h>
+#include "../../../probes/lttng-tracepoint-event.h"
#include <linux/workqueue.h>
#include <linux/version.h>
#endif
-DECLARE_EVENT_CLASS(workqueue_work,
+LTTNG_TRACEPOINT_EVENT_CLASS(workqueue_work,
TP_PROTO(struct work_struct *work),
* delayed work is actually queued on a workqueue (ie: once the delay
* has been reached).
*/
-TRACE_EVENT(workqueue_queue_work,
+LTTNG_TRACEPOINT_EVENT(workqueue_queue_work,
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,9,0))
TP_PROTO(unsigned int req_cpu, struct pool_workqueue *pwq,
* which happens immediately after queueing unless @max_active limit
* is reached.
*/
-DEFINE_EVENT(workqueue_work, workqueue_activate_work,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(workqueue_work, workqueue_activate_work,
TP_PROTO(struct work_struct *work),
*
* Allows to track workqueue execution.
*/
-TRACE_EVENT(workqueue_execute_start,
+LTTNG_TRACEPOINT_EVENT(workqueue_execute_start,
TP_PROTO(struct work_struct *work),
*
* Allows to track workqueue execution.
*/
-DEFINE_EVENT(workqueue_work, workqueue_execute_end,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(workqueue_work, workqueue_execute_end,
TP_PROTO(struct work_struct *work),
#else
-DECLARE_EVENT_CLASS(workqueue,
+LTTNG_TRACEPOINT_EVENT_CLASS(workqueue,
TP_PROTO(struct task_struct *wq_thread, struct work_struct *work),
__entry->thread_pid, __entry->func)
)
-DEFINE_EVENT(workqueue, workqueue_insertion,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(workqueue, workqueue_insertion,
TP_PROTO(struct task_struct *wq_thread, struct work_struct *work),
TP_ARGS(wq_thread, work)
)
-DEFINE_EVENT(workqueue, workqueue_execution,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(workqueue, workqueue_execution,
TP_PROTO(struct task_struct *wq_thread, struct work_struct *work),
)
/* Trace the creation of one workqueue thread on a cpu */
-TRACE_EVENT(workqueue_creation,
+LTTNG_TRACEPOINT_EVENT(workqueue_creation,
TP_PROTO(struct task_struct *wq_thread, int cpu),
__entry->thread_pid, __entry->cpu)
)
-TRACE_EVENT(workqueue_destruction,
+LTTNG_TRACEPOINT_EVENT(workqueue_destruction,
TP_PROTO(struct task_struct *wq_thread),
#endif
-#endif /* _TRACE_WORKQUEUE_H */
+#endif /* LTTNG_TRACE_WORKQUEUE_H */
/* This part must be outside protection */
#include "../../../probes/define_trace.h"
#undef TRACE_SYSTEM
#define TRACE_SYSTEM writeback
-#if !defined(_TRACE_WRITEBACK_H) || defined(TRACE_HEADER_MULTI_READ)
-#define _TRACE_WRITEBACK_H
+#if !defined(LTTNG_TRACE_WRITEBACK_H) || defined(TRACE_HEADER_MULTI_READ)
+#define LTTNG_TRACE_WRITEBACK_H
+#include "../../../probes/lttng-tracepoint-event.h"
#include <linux/backing-dev.h>
#include <linux/writeback.h>
#include <linux/version.h>
{WB_REASON_FORKER_THREAD, "forker_thread"}
#endif
-DECLARE_EVENT_CLASS(writeback_work_class,
+LTTNG_TRACEPOINT_EVENT_CLASS(writeback_work_class,
TP_PROTO(struct backing_dev_info *bdi, struct wb_writeback_work *work),
TP_ARGS(bdi, work),
TP_STRUCT__entry(
__entry->name
)
)
-#define DEFINE_WRITEBACK_WORK_EVENT(name) \
-DEFINE_EVENT(writeback_work_class, name, \
+#define LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(name) \
+LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_work_class, name, \
TP_PROTO(struct backing_dev_info *bdi, struct wb_writeback_work *work), \
TP_ARGS(bdi, work))
-DEFINE_WRITEBACK_WORK_EVENT(writeback_nothread)
-DEFINE_WRITEBACK_WORK_EVENT(writeback_queue)
-DEFINE_WRITEBACK_WORK_EVENT(writeback_exec)
+LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(writeback_nothread)
+LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(writeback_queue)
+LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(writeback_exec)
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,1,0))
-DEFINE_WRITEBACK_WORK_EVENT(writeback_start)
-DEFINE_WRITEBACK_WORK_EVENT(writeback_written)
-DEFINE_WRITEBACK_WORK_EVENT(writeback_wait)
+LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(writeback_start)
+LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(writeback_written)
+LTTNG_TRACEPOINT_EVENT_WRITEBACK_WORK_INSTANCE(writeback_wait)
#endif
-TRACE_EVENT(writeback_pages_written,
+LTTNG_TRACEPOINT_EVENT(writeback_pages_written,
TP_PROTO(long pages_written),
TP_ARGS(pages_written),
TP_STRUCT__entry(
TP_printk("%ld", __entry->pages)
)
-DECLARE_EVENT_CLASS(writeback_class,
+LTTNG_TRACEPOINT_EVENT_CLASS(writeback_class,
TP_PROTO(struct backing_dev_info *bdi),
TP_ARGS(bdi),
TP_STRUCT__entry(
)
)
#define DEFINE_WRITEBACK_EVENT(name) \
-DEFINE_EVENT(writeback_class, name, \
+LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_class, name, \
TP_PROTO(struct backing_dev_info *bdi), \
TP_ARGS(bdi))
#define DEFINE_WRITEBACK_EVENT_MAP(name, map) \
-DEFINE_EVENT_MAP(writeback_class, name, map, \
+LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(writeback_class, name, map, \
TP_PROTO(struct backing_dev_info *bdi), \
TP_ARGS(bdi))
DEFINE_WRITEBACK_EVENT_MAP(balance_dirty_start, writeback_balance_dirty_start)
DEFINE_WRITEBACK_EVENT_MAP(balance_dirty_wait, writeback_balance_dirty_wait)
-TRACE_EVENT_MAP(balance_dirty_written,
+LTTNG_TRACEPOINT_EVENT_MAP(balance_dirty_written,
writeback_balance_dirty_written,
)
#endif
-DECLARE_EVENT_CLASS(writeback_wbc_class,
+LTTNG_TRACEPOINT_EVENT_CLASS(writeback_wbc_class,
TP_PROTO(struct writeback_control *wbc, struct backing_dev_info *bdi),
TP_ARGS(wbc, bdi),
TP_STRUCT__entry(
)
#undef DEFINE_WBC_EVENT
-#define DEFINE_WBC_EVENT(name, map) \
-DEFINE_EVENT_MAP(writeback_wbc_class, name, map, \
+#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))
#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0))
-DEFINE_WBC_EVENT(wbc_writeback_start, writeback_wbc_writeback_start)
-DEFINE_WBC_EVENT(wbc_writeback_written, writeback_wbc_writeback_written)
-DEFINE_WBC_EVENT(wbc_writeback_wait, writeback_wbc_writeback_wait)
-DEFINE_WBC_EVENT(wbc_balance_dirty_start, writeback_wbc_balance_dirty_start)
-DEFINE_WBC_EVENT(wbc_balance_dirty_written, writeback_wbc_balance_dirty_written)
-DEFINE_WBC_EVENT(wbc_balance_dirty_wait, writeback_wbc_balance_dirty_wait)
+LTTNG_TRACEPOINT_EVENT_WBC_INSTANCE(wbc_writeback_start, writeback_wbc_writeback_start)
+LTTNG_TRACEPOINT_EVENT_WBC_INSTANCE(wbc_writeback_written, writeback_wbc_writeback_written)
+LTTNG_TRACEPOINT_EVENT_WBC_INSTANCE(wbc_writeback_wait, writeback_wbc_writeback_wait)
+LTTNG_TRACEPOINT_EVENT_WBC_INSTANCE(wbc_balance_dirty_start, writeback_wbc_balance_dirty_start)
+LTTNG_TRACEPOINT_EVENT_WBC_INSTANCE(wbc_balance_dirty_written, writeback_wbc_balance_dirty_written)
+LTTNG_TRACEPOINT_EVENT_WBC_INSTANCE(wbc_balance_dirty_wait, writeback_wbc_balance_dirty_wait)
#endif
-DEFINE_WBC_EVENT(wbc_writepage, writeback_wbc_writepage)
+LTTNG_TRACEPOINT_EVENT_WBC_INSTANCE(wbc_writepage, writeback_wbc_writepage)
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,1,0))
-TRACE_EVENT(writeback_queue_io,
+LTTNG_TRACEPOINT_EVENT(writeback_queue_io,
TP_PROTO(struct bdi_writeback *wb,
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
struct wb_writeback_work *work,
#endif
)
-TRACE_EVENT_MAP(global_dirty_state,
+LTTNG_TRACEPOINT_EVENT_MAP(global_dirty_state,
writeback_global_dirty_state,
#define KBps(x) ((x) << (PAGE_SHIFT - 10))
-TRACE_EVENT_MAP(bdi_dirty_ratelimit,
+LTTNG_TRACEPOINT_EVENT_MAP(bdi_dirty_ratelimit,
writeback_bdi_dirty_ratelimit,
)
)
-TRACE_EVENT_MAP(balance_dirty_pages,
+LTTNG_TRACEPOINT_EVENT_MAP(balance_dirty_pages,
writeback_balance_dirty_pages,
#endif
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,5,0))
-TRACE_EVENT(writeback_sb_inodes_requeue,
+LTTNG_TRACEPOINT_EVENT(writeback_sb_inodes_requeue,
TP_PROTO(struct inode *inode),
TP_ARGS(inode),
#endif
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37))
-DECLARE_EVENT_CLASS(writeback_congest_waited_template,
+LTTNG_TRACEPOINT_EVENT_CLASS(writeback_congest_waited_template,
TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed),
__entry->usec_delayed)
)
-DEFINE_EVENT(writeback_congest_waited_template, writeback_congestion_wait,
+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)
)
-DEFINE_EVENT(writeback_congest_waited_template, writeback_wait_iff_congested,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_congest_waited_template, writeback_wait_iff_congested,
TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed),
#endif
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,1,0))
-DECLARE_EVENT_CLASS(writeback_single_inode_template,
+LTTNG_TRACEPOINT_EVENT_CLASS(writeback_single_inode_template,
TP_PROTO(struct inode *inode,
struct writeback_control *wbc,
)
#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0))
-DEFINE_EVENT(writeback_single_inode_template, writeback_single_inode_requeue,
+LTTNG_TRACEPOINT_EVENT_INSTANCE(writeback_single_inode_template, writeback_single_inode_requeue,
TP_PROTO(struct inode *inode,
struct writeback_control *wbc,
unsigned long nr_to_write),
)
#endif
-DEFINE_EVENT(writeback_single_inode_template, writeback_single_inode,
+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),
)
#endif
-#endif /* _TRACE_WRITEBACK_H */
+#endif /* LTTNG_TRACE_WRITEBACK_H */
/* This part must be outside protection */
#include "../../../probes/define_trace.h"
#if !defined(_TRACE_SYSCALLS_INTEGERS_H) || defined(TRACE_HEADER_MULTI_READ)
#define _TRACE_SYSCALLS_INTEGERS_H
-#include <linux/tracepoint.h>
+#include "../../../probes/lttng-tracepoint-event.h"
#include <linux/syscalls.h>
#include "arm-32-syscalls-3.4.25_integers_override.h"
#include "syscalls_integers_override.h"
#if !defined(_TRACE_SYSCALLS_POINTERS_H) || defined(TRACE_HEADER_MULTI_READ)
#define _TRACE_SYSCALLS_POINTERS_H
-#include <linux/tracepoint.h>
+#include "../../../probes/lttng-tracepoint-event.h"
#include <linux/syscalls.h>
#include "arm-32-syscalls-3.4.25_pointers_override.h"
#include "syscalls_pointers_override.h"
#if !defined(_TRACE_SYSCALLS_INTEGERS_H) || defined(TRACE_HEADER_MULTI_READ)
#define _TRACE_SYSCALLS_INTEGERS_H
-#include <linux/tracepoint.h>
+#include "../../../probes/lttng-tracepoint-event.h"
#include <linux/syscalls.h>
#include "mips-32-syscalls-3.13.0_integers_override.h"
#include "syscalls_integers_override.h"
#if !defined(_TRACE_SYSCALLS_POINTERS_H) || defined(TRACE_HEADER_MULTI_READ)
#define _TRACE_SYSCALLS_POINTERS_H
-#include <linux/tracepoint.h>
+#include "../../../probes/lttng-tracepoint-event.h"
#include <linux/syscalls.h>
#include "mips-32-syscalls-3.13.0_pointers_override.h"
#include "syscalls_pointers_override.h"
#if !defined(_TRACE_SYSCALLS_INTEGERS_H) || defined(TRACE_HEADER_MULTI_READ)
#define _TRACE_SYSCALLS_INTEGERS_H
-#include <linux/tracepoint.h>
+#include "../../../probes/lttng-tracepoint-event.h"
#include <linux/syscalls.h>
#include "mips-32-syscalls-3.5.0_integers_override.h"
#include "syscalls_integers_override.h"
#if !defined(_TRACE_SYSCALLS_POINTERS_H) || defined(TRACE_HEADER_MULTI_READ)
#define _TRACE_SYSCALLS_POINTERS_H
-#include <linux/tracepoint.h>
+#include "../../../probes/lttng-tracepoint-event.h"
#include <linux/syscalls.h>
#include "mips-32-syscalls-3.5.0_pointers_override.h"
#include "syscalls_pointers_override.h"
#if !defined(_TRACE_SYSCALLS_INTEGERS_H) || defined(TRACE_HEADER_MULTI_READ)
#define _TRACE_SYSCALLS_INTEGERS_H
-#include <linux/tracepoint.h>
+#include "../../../probes/lttng-tracepoint-event.h"
#include <linux/syscalls.h>
#include "mips-64-syscalls-3.5.0_integers_override.h"
#include "syscalls_integers_override.h"
#if !defined(_TRACE_SYSCALLS_POINTERS_H) || defined(TRACE_HEADER_MULTI_READ)
#define _TRACE_SYSCALLS_POINTERS_H
-#include <linux/tracepoint.h>
+#include "../../../probes/lttng-tracepoint-event.h"
#include <linux/syscalls.h>
#include "mips-64-syscalls-3.5.0_pointers_override.h"
#include "syscalls_pointers_override.h"
#if !defined(_TRACE_SYSCALLS_INTEGERS_H) || defined(TRACE_HEADER_MULTI_READ)
#define _TRACE_SYSCALLS_INTEGERS_H
-#include <linux/tracepoint.h>
+#include "../../../probes/lttng-tracepoint-event.h"
#include <linux/syscalls.h>
#include "powerpc-32-syscalls-3.0.34_integers_override.h"
#include "syscalls_integers_override.h"
#if !defined(_TRACE_SYSCALLS_POINTERS_H) || defined(TRACE_HEADER_MULTI_READ)
#define _TRACE_SYSCALLS_POINTERS_H
-#include <linux/tracepoint.h>
+#include "../../../probes/lttng-tracepoint-event.h"
#include <linux/syscalls.h>
#include "powerpc-32-syscalls-3.0.34_pointers_override.h"
#include "syscalls_pointers_override.h"
#if !defined(_TRACE_SYSCALLS_UNKNOWN_H) || defined(TRACE_HEADER_MULTI_READ)
#define _TRACE_SYSCALLS_UNKNOWN_H
-#include <linux/tracepoint.h>
+#include "../../../probes/lttng-tracepoint-event.h"
#include <linux/syscalls.h>
#define UNKNOWN_SYSCALL_NRARGS 6
#undef TP_PROBE_CB
#define TP_PROBE_CB(_template) &syscall_entry_probe
-TRACE_EVENT(syscall_enter_unknown,
+LTTNG_TRACEPOINT_EVENT(syscall_enter_unknown,
TP_PROTO(unsigned int id, unsigned long *args),
TP_ARGS(id, args),
TP_STRUCT__entry(
),
TP_printk()
)
-TRACE_EVENT(compat_syscall_enter_unknown,
+LTTNG_TRACEPOINT_EVENT(compat_syscall_enter_unknown,
TP_PROTO(unsigned int id, unsigned long *args),
TP_ARGS(id, args),
TP_STRUCT__entry(
#undef TP_PROBE_CB
#define TP_PROBE_CB(_template) &syscall_exit_probe
-TRACE_EVENT(syscall_exit_unknown,
+LTTNG_TRACEPOINT_EVENT(syscall_exit_unknown,
TP_PROTO(unsigned int id, long ret, unsigned long *args),
TP_ARGS(id, ret, args),
TP_STRUCT__entry(
),
TP_printk()
)
-TRACE_EVENT(compat_syscall_exit_unknown,
+LTTNG_TRACEPOINT_EVENT(compat_syscall_exit_unknown,
TP_PROTO(unsigned int id, long ret, unsigned long *args),
TP_ARGS(id, ret, args),
TP_STRUCT__entry(
#if !defined(_TRACE_SYSCALLS_INTEGERS_H) || defined(TRACE_HEADER_MULTI_READ)
#define _TRACE_SYSCALLS_INTEGERS_H
-#include <linux/tracepoint.h>
+#include "../../../probes/lttng-tracepoint-event.h"
#include <linux/syscalls.h>
#include "x86-32-syscalls-3.1.0-rc6_integers_override.h"
#include "syscalls_integers_override.h"
#if !defined(_TRACE_SYSCALLS_POINTERS_H) || defined(TRACE_HEADER_MULTI_READ)
#define _TRACE_SYSCALLS_POINTERS_H
-#include <linux/tracepoint.h>
+#include "../../../probes/lttng-tracepoint-event.h"
#include <linux/syscalls.h>
#include "x86-32-syscalls-3.1.0-rc6_pointers_override.h"
#include "syscalls_pointers_override.h"
#if !defined(_TRACE_SYSCALLS_INTEGERS_H) || defined(TRACE_HEADER_MULTI_READ)
#define _TRACE_SYSCALLS_INTEGERS_H
-#include <linux/tracepoint.h>
+#include "../../../probes/lttng-tracepoint-event.h"
#include <linux/syscalls.h>
#include "x86-64-syscalls-3.10.0-rc7_integers_override.h"
#include "syscalls_integers_override.h"
#if !defined(_TRACE_SYSCALLS_POINTERS_H) || defined(TRACE_HEADER_MULTI_READ)
#define _TRACE_SYSCALLS_POINTERS_H
-#include <linux/tracepoint.h>
+#include "../../../probes/lttng-tracepoint-event.h"
#include <linux/syscalls.h>
#include "x86-64-syscalls-3.10.0-rc7_pointers_override.h"
#include "syscalls_pointers_override.h"
#if !defined(_TRACE_SYSCALLS_${CLASSCAP}_H) || defined(TRACE_HEADER_MULTI_READ)
#define _TRACE_SYSCALLS_${CLASSCAP}_H
-#include <linux/tracepoint.h>
+#include "../../../probes/lttng-tracepoint-event.h"
#include <linux/syscalls.h>
#include \"${INPUTFILE}_${CLASS}_override.h\"
#include \"syscalls_${CLASS}_override.h\"
#define CREATE_TRACE_POINTS
#define TRACE_INCLUDE_PATH ../instrumentation/events/lttng-module
#define TRACE_INCLUDE_FILE lttng-statedump
+#define LTTNG_INSTRUMENTATION
#include "instrumentation/events/lttng-module/lttng-statedump.h"
DEFINE_TRACE(lttng_statedump_block_device);
#define NR_compat_syscalls NR_syscalls
#endif
-/*
- * Take care of NOARGS not supported by mainline.
- */
-#define DECLARE_EVENT_CLASS_NOARGS(name, tstruct, assign, print)
-#define DEFINE_EVENT_NOARGS(template, name)
-#define TRACE_EVENT_NOARGS(name, struct, assign, print)
-
/*
* Create LTTng tracepoint probes.
*/
#undef TP_PROBE_CB
#define TP_PROBE_CB(_template) &syscall_entry_probe
#define SC_TRACE_EVENT(_name, _proto, _args, _struct, _assign, _printk) \
- TRACE_EVENT(syscall_enter_##_name, PARAMS(_proto), PARAMS(_args),\
+ LTTNG_TRACEPOINT_EVENT(syscall_enter_##_name, PARAMS(_proto), PARAMS(_args), \
PARAMS(_struct), PARAMS(_assign), PARAMS(_printk))
#define SC_LTTNG_TRACE_EVENT(_name, _proto, _args, _locvar, _code, _struct, _assign, _printk) \
- LTTNG_TRACE_EVENT(syscall_enter_##_name, PARAMS(_proto), PARAMS(_args),\
+ LTTNG_TRACEPOINT_EVENT_CODE(syscall_enter_##_name, PARAMS(_proto), PARAMS(_args),\
PARAMS(_locvar), PARAMS(_code),\
PARAMS(_struct), PARAMS(_assign), PARAMS(_printk))
#define SC_DECLARE_EVENT_CLASS_NOARGS(_name, _struct, _assign, _printk) \
- DECLARE_EVENT_CLASS_NOARGS(syscall_enter_##_name, PARAMS(_struct), PARAMS(_assign),\
+ LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(syscall_enter_##_name, PARAMS(_struct), PARAMS(_assign), \
PARAMS(_printk))
#define SC_DEFINE_EVENT_NOARGS(_template, _name) \
- DEFINE_EVENT_NOARGS(syscall_enter_##_template, syscall_enter_##_name)
+ LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscall_enter_##_template, syscall_enter_##_name)
#undef TRACE_SYSTEM
#define TRACE_SYSTEM syscall_enter_integers
#define TRACE_INCLUDE_FILE syscalls_integers
#undef SC_DECLARE_EVENT_CLASS_NOARGS
#undef SC_DEFINE_EVENT_NOARGS
#undef TP_PROBE_CB
-#undef _TRACE_SYSCALLS_integers_H
-#undef _TRACE_SYSCALLS_pointers_H
-
+#undef _TRACE_SYSCALLS_INTEGERS_H
+#undef _TRACE_SYSCALLS_POINTERS_H
/* Hijack probe callback for compat system call enter */
#define TP_PROBE_CB(_template) &syscall_entry_probe
#define SC_TRACE_EVENT(_name, _proto, _args, _struct, _assign, _printk) \
- TRACE_EVENT(compat_syscall_enter_##_name, PARAMS(_proto), PARAMS(_args), \
+ LTTNG_TRACEPOINT_EVENT(compat_syscall_enter_##_name, PARAMS(_proto), PARAMS(_args), \
PARAMS(_struct), PARAMS(_assign), \
PARAMS(_printk))
#define SC_LTTNG_TRACE_EVENT(_name, _proto, _args, _locvar, _code, _struct, _assign, _printk) \
- LTTNG_TRACE_EVENT(compat_syscall_enter_##_name, PARAMS(_proto), PARAMS(_args),\
+ LTTNG_TRACEPOINT_EVENT_CODE(compat_syscall_enter_##_name, PARAMS(_proto), PARAMS(_args), \
PARAMS(_locvar), PARAMS(_code),\
PARAMS(_struct), PARAMS(_assign), PARAMS(_printk))
#define SC_DECLARE_EVENT_CLASS_NOARGS(_name, _struct, _assign, _printk) \
- DECLARE_EVENT_CLASS_NOARGS(compat_syscall_enter_##_name, PARAMS(_struct), \
+ LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(compat_syscall_enter_##_name, PARAMS(_struct), \
PARAMS(_assign), PARAMS(_printk))
#define SC_DEFINE_EVENT_NOARGS(_template, _name) \
- DEFINE_EVENT_NOARGS(compat_syscall_enter_##_template, \
+ LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(compat_syscall_enter_##_template, \
compat_syscall_enter_##_name)
#define TRACE_SYSTEM compat_syscall_enter_integers
#define TRACE_INCLUDE_FILE compat_syscalls_integers
#undef SC_DECLARE_EVENT_CLASS_NOARGS
#undef SC_DEFINE_EVENT_NOARGS
#undef TP_PROBE_CB
-#undef _TRACE_SYSCALLS_integers_H
-#undef _TRACE_SYSCALLS_pointers_H
+#undef _TRACE_SYSCALLS_INTEGERS_H
+#undef _TRACE_SYSCALLS_POINTERS_H
#undef SC_ENTER
/* Hijack probe callback for system call exit */
#define TP_PROBE_CB(_template) &syscall_exit_probe
#define SC_TRACE_EVENT(_name, _proto, _args, _struct, _assign, _printk) \
- TRACE_EVENT(syscall_exit_##_name, PARAMS(_proto), PARAMS(_args),\
+ LTTNG_TRACEPOINT_EVENT(syscall_exit_##_name, PARAMS(_proto), PARAMS(_args), \
PARAMS(_struct), PARAMS(_assign), PARAMS(_printk))
#define SC_LTTNG_TRACE_EVENT(_name, _proto, _args, _locvar, _code, _struct, _assign, _printk) \
- LTTNG_TRACE_EVENT(syscall_exit_##_name, PARAMS(_proto), PARAMS(_args),\
- PARAMS(_locvar), PARAMS(_code),\
+ LTTNG_TRACEPOINT_EVENT_CODE(syscall_exit_##_name, PARAMS(_proto), PARAMS(_args), \
+ PARAMS(_locvar), PARAMS(_code), \
PARAMS(_struct), PARAMS(_assign), PARAMS(_printk))
#define SC_DECLARE_EVENT_CLASS_NOARGS(_name, _struct, _assign, _printk) \
- DECLARE_EVENT_CLASS_NOARGS(syscall_exit_##_name, PARAMS(_struct), \
+ LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(syscall_exit_##_name, PARAMS(_struct), \
PARAMS(_assign), PARAMS(_printk))
#define SC_DEFINE_EVENT_NOARGS(_template, _name) \
- DEFINE_EVENT_NOARGS(syscall_exit_##_template, \
+ LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscall_exit_##_template, \
syscall_exit_##_name)
#define TRACE_SYSTEM syscall_exit_integers
#define TRACE_INCLUDE_FILE syscalls_integers
#undef SC_DECLARE_EVENT_CLASS_NOARGS
#undef SC_DEFINE_EVENT_NOARGS
#undef TP_PROBE_CB
-#undef _TRACE_SYSCALLS_integers_H
-#undef _TRACE_SYSCALLS_pointers_H
+#undef _TRACE_SYSCALLS_INTEGERS_H
+#undef _TRACE_SYSCALLS_POINTERS_H
/* Hijack probe callback for compat system call exit */
#define TP_PROBE_CB(_template) &syscall_exit_probe
#define SC_TRACE_EVENT(_name, _proto, _args, _struct, _assign, _printk) \
- TRACE_EVENT(compat_syscall_exit_##_name, PARAMS(_proto), PARAMS(_args), \
+ LTTNG_TRACEPOINT_EVENT(compat_syscall_exit_##_name, PARAMS(_proto), PARAMS(_args), \
PARAMS(_struct), PARAMS(_assign), PARAMS(_printk))
#define SC_LTTNG_TRACE_EVENT(_name, _proto, _args, _locvar, _code, _struct, _assign, _printk) \
- LTTNG_TRACE_EVENT(compat_syscall_exit_##_name, PARAMS(_proto), PARAMS(_args),\
- PARAMS(_locvar), PARAMS(_code),\
+ LTTNG_TRACEPOINT_EVENT_CODE(compat_syscall_exit_##_name, PARAMS(_proto), PARAMS(_args), \
+ PARAMS(_locvar), PARAMS(_code), \
PARAMS(_struct), PARAMS(_assign), PARAMS(_printk))
#define SC_DECLARE_EVENT_CLASS_NOARGS(_name, _struct, _assign, _printk) \
- DECLARE_EVENT_CLASS_NOARGS(compat_syscall_exit_##_name, PARAMS(_struct), \
+ LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(compat_syscall_exit_##_name, PARAMS(_struct), \
PARAMS(_assign), PARAMS(_printk))
#define SC_DEFINE_EVENT_NOARGS(_template, _name) \
- DEFINE_EVENT_NOARGS(compat_syscall_exit_##_template, \
+ LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(compat_syscall_exit_##_template, \
compat_syscall_exit_##_name)
#define TRACE_SYSTEM compat_syscall_exit_integers
#define TRACE_INCLUDE_FILE compat_syscalls_integers
#undef SC_DECLARE_EVENT_CLASS_NOARGS
#undef SC_DEFINE_EVENT_NOARGS
#undef TP_PROBE_CB
-#undef _TRACE_SYSCALLS_integers_H
-#undef _TRACE_SYSCALLS_pointers_H
+#undef _TRACE_SYSCALLS_INTEGERS_H
+#undef _TRACE_SYSCALLS_POINTERS_H
#undef SC_EXIT
#undef CREATE_TRACE_POINTS
#include <linux/stringify.h>
-/*
- * module.h includes tracepoints, and because ftrace.h
- * pulls in module.h:
- * trace/ftrace.h -> linux/ftrace_event.h -> linux/perf_event.h ->
- * linux/ftrace.h -> linux/module.h
- * we must include module.h here before we play with any of
- * the TRACE_EVENT() macros, otherwise the tracepoints included
- * by module.h may break the build.
- */
-#include <linux/module.h>
-#undef TRACE_EVENT_MAP
-#define TRACE_EVENT_MAP(name, map, proto, args, tstruct, assign, print)
+#undef LTTNG_TRACEPOINT_EVENT_MAP
+#define LTTNG_TRACEPOINT_EVENT_MAP(name, map, proto, args, tstruct, assign, print)
+
+#undef LTTNG_TRACEPOINT_EVENT_MAP_NOARGS
+#define LTTNG_TRACEPOINT_EVENT_MAP_NOARGS(name, map, tstruct, assign, print)
-#undef TRACE_EVENT_CONDITION_MAP
-#define TRACE_EVENT_CONDITION_MAP(name, map, proto, args, cond, tstruct, assign, print) \
- TRACE_EVENT(name, \
+#undef LTTNG_TRACEPOINT_EVENT_CONDITION_MAP
+#define LTTNG_TRACEPOINT_EVENT_CONDITION_MAP(name, map, proto, args, cond, tstruct, assign, print) \
+ LTTNG_TRACEPOINT_EVENT(name, \
PARAMS(proto), \
PARAMS(args), \
PARAMS(tstruct), \
PARAMS(assign), \
PARAMS(print))
-#undef TRACE_EVENT_FN_MAP
-#define TRACE_EVENT_FN_MAP(name, map, proto, args, tstruct, \
+#undef LTTNG_TRACEPOINT_EVENT_FN_MAP
+#define LTTNG_TRACEPOINT_EVENT_FN_MAP(name, map, proto, args, tstruct, \
assign, print, reg, unreg)
-#undef DEFINE_EVENT_MAP
-#define DEFINE_EVENT_MAP(template, name, map, proto, args)
+#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP
+#define LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(template, name, map, proto, args)
-#undef DEFINE_EVENT_PRINT_MAP
-#define DEFINE_EVENT_PRINT_MAP(template, name, map, proto, args, print)
+#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_PRINT_MAP
+#define LTTNG_TRACEPOINT_EVENT_INSTANCE_PRINT_MAP(template, name, map, proto, args, print)
-#undef DEFINE_EVENT_CONDITION_MAP
-#define DEFINE_EVENT_CONDITION_MAP(template, name, map, proto, args, cond) \
- DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args))
+#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_CONDITION_MAP
+#define LTTNG_TRACEPOINT_EVENT_INSTANCE_CONDITION_MAP(template, name, map, proto, args, cond) \
+ LTTNG_TRACEPOINT_EVENT_INSTANCE(template, name, PARAMS(proto), PARAMS(args))
+#undef LTTNG_TRACEPOINT_EVENT
+#define LTTNG_TRACEPOINT_EVENT(name, proto, args, tstruct, assign, print)
-#undef TRACE_EVENT
-#define TRACE_EVENT(name, proto, args, tstruct, assign, print)
-
-#undef TRACE_EVENT_CONDITION
-#define TRACE_EVENT_CONDITION(name, proto, args, cond, tstruct, assign, print) \
- TRACE_EVENT(name, \
+#undef LTTNG_TRACEPOINT_EVENT_CONDITION
+#define LTTNG_TRACEPOINT_EVENT_CONDITION(name, proto, args, cond, tstruct, assign, print) \
+ LTTNG_TRACEPOINT_EVENT(name, \
PARAMS(proto), \
PARAMS(args), \
PARAMS(tstruct), \
PARAMS(assign), \
PARAMS(print))
-#undef LTTNG_TRACE_EVENT
-#define LTTNG_TRACE_EVENT(name, proto, args, _locvar, _code, tstruct, assign, print)
+#undef LTTNG_TRACEPOINT_EVENT_CODE
+#define LTTNG_TRACEPOINT_EVENT_CODE(name, proto, args, _locvar, _code, tstruct, assign, print)
-#undef TRACE_EVENT_FN
-#define TRACE_EVENT_FN(name, proto, args, tstruct, \
+#undef LTTNG_TRACEPOINT_EVENT_FN
+#define LTTNG_TRACEPOINT_EVENT_FN(name, proto, args, tstruct, \
assign, print, reg, unreg)
-#undef DEFINE_EVENT
-#define DEFINE_EVENT(template, name, proto, args)
+#undef LTTNG_TRACEPOINT_EVENT_INSTANCE
+#define LTTNG_TRACEPOINT_EVENT_INSTANCE(template, name, proto, args)
-#undef DEFINE_EVENT_PRINT
-#define DEFINE_EVENT_PRINT(template, name, proto, args, print)
+#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS
+#define LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(template, name)
-#undef DEFINE_EVENT_CONDITION
-#define DEFINE_EVENT_CONDITION(template, name, proto, args, cond) \
- DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args))
+#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS
+#define LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS(template, name, map)
-#undef DECLARE_TRACE
-#define DECLARE_TRACE(name, proto, args)
+#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_PRINT
+#define LTTNG_TRACEPOINT_EVENT_INSTANCE_PRINT(template, name, proto, args, print)
+
+#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_CONDITION
+#define LTTNG_TRACEPOINT_EVENT_INSTANCE_CONDITION(template, name, proto, args, cond) \
+ LTTNG_TRACEPOINT_EVENT_INSTANCE(template, name, PARAMS(proto), PARAMS(args))
#undef TRACE_INCLUDE
#undef __TRACE_INCLUDE
#include "lttng-events.h"
#endif
-#undef TRACE_EVENT
-#undef TRACE_EVENT_FN
-#undef TRACE_EVENT_CONDITION
-#undef DEFINE_EVENT
-#undef DEFINE_EVENT_PRINT
-#undef DEFINE_EVENT_CONDITION
-#undef TRACE_EVENT_MAP
-#undef TRACE_EVENT_FN_MAP
-#undef TRACE_EVENT_CONDITION_MAP
-#undef DECLARE_EVENT_CLASS
-#undef DEFINE_EVENT_MAP
-#undef DEFINE_EVENT_PRINT_MAP
-#undef DEFINE_EVENT_CONDITION_MAP
+#undef LTTNG_TRACEPOINT_EVENT
+#undef LTTNG_TRACEPOINT_EVENT_FN
+#undef LTTNG_TRACEPOINT_EVENT_CONDITION
+#undef LTTNG_TRACEPOINT_EVENT_INSTANCE
+#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_PRINT
+#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_CONDITION
+#undef LTTNG_TRACEPOINT_EVENT_MAP
+#undef LTTNG_TRACEPOINT_EVENT_FN_MAP
+#undef LTTNG_TRACEPOINT_EVENT_CONDITION_MAP
+#undef LTTNG_TRACEPOINT_EVENT_CLASS
+#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP
+#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_PRINT_MAP
+#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_CONDITION_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
-#undef LTTNG_TRACE_EVENT
-#define LTTNG_TRACE_EVENT(name, proto, args, _locvar, _code, tstruct, assign, print)
-
/* Only undef what we defined in this file */
#ifdef UNDEF_TRACE_INCLUDE_FILE
# undef TRACE_INCLUDE_FILE
# 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
#undef TP_printk
#define TP_printk(args...)
-#undef LTTNG_DECLARE_EVENT_CLASS
-#define LTTNG_DECLARE_EVENT_CLASS(_name, _proto, _args, _locvar, _code, _tstruct, _assign, _print)
+#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE
+#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE(_name, _proto, _args, _locvar, _code, _tstruct, _assign, _print)
-#undef LTTNG_DECLARE_EVENT_CLASS_NOARGS
-#define LTTNG_DECLARE_EVENT_CLASS_NOARGS(_name, _locvar, _code, _tstruct, _assign, _print)
+#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS
+#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS(_name, _locvar, _code, _tstruct, _assign, _print)
-#undef DEFINE_EVENT_MAP
-#define DEFINE_EVENT_MAP(_template, _name, _map, _proto, _args)
+#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP
+#define LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(_template, _name, _map, _proto, _args)
-#undef DEFINE_EVENT_MAP_NOARGS
-#define DEFINE_EVENT_MAP_NOARGS(_template, _name, _map)
-
-#undef TRACE_EVENT_FLAGS
-#define TRACE_EVENT_FLAGS(name, value)
+#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS
+#define LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS(_template, _name, _map)
* LTTng name mapping macros. LTTng remaps some of the kernel events to
* enforce name-spacing.
*/
-#undef TRACE_EVENT_MAP
-#define TRACE_EVENT_MAP(name, map, proto, args, tstruct, assign, print) \
- DECLARE_EVENT_CLASS(map, \
+#undef LTTNG_TRACEPOINT_EVENT_MAP
+#define LTTNG_TRACEPOINT_EVENT_MAP(name, map, proto, args, tstruct, assign, print) \
+ LTTNG_TRACEPOINT_EVENT_CLASS(map, \
PARAMS(proto), \
PARAMS(args), \
PARAMS(tstruct), \
PARAMS(assign), \
PARAMS(print)) \
- DEFINE_EVENT_MAP(map, name, map, PARAMS(proto), PARAMS(args))
+ LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(map, name, map, PARAMS(proto), PARAMS(args))
-#undef TRACE_EVENT_MAP_NOARGS
-#define TRACE_EVENT_MAP_NOARGS(name, map, tstruct, assign, print) \
- DECLARE_EVENT_CLASS_NOARGS(map, \
+#undef LTTNG_TRACEPOINT_EVENT_MAP_NOARGS
+#define LTTNG_TRACEPOINT_EVENT_MAP_NOARGS(name, map, tstruct, assign, print) \
+ LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(map, \
PARAMS(tstruct), \
PARAMS(assign), \
PARAMS(print)) \
- DEFINE_EVENT_MAP_NOARGS(map, name, map)
+ LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS(map, name, map)
-#undef LTTNG_TRACE_EVENT
-#define LTTNG_TRACE_EVENT(name, proto, args, _locvar, _code, tstruct, assign, print) \
- LTTNG_DECLARE_EVENT_CLASS(name, \
+#undef LTTNG_TRACEPOINT_EVENT_CODE
+#define LTTNG_TRACEPOINT_EVENT_CODE(name, proto, args, _locvar, _code, tstruct, assign, print) \
+ LTTNG_TRACEPOINT_EVENT_CLASS_CODE(name, \
PARAMS(proto), \
PARAMS(args), \
PARAMS(_locvar), \
PARAMS(tstruct), \
PARAMS(assign), \
PARAMS(print)) \
- DEFINE_EVENT_MAP(name, name, name, PARAMS(proto), PARAMS(args))
+ LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(name, name, name, PARAMS(proto), PARAMS(args))
-#undef DEFINE_EVENT_PRINT_MAP
-#define DEFINE_EVENT_PRINT_MAP(template, name, map, proto, args, print) \
- DEFINE_EVENT_MAP(template, name, map, PARAMS(proto), PARAMS(args))
+
+#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_PRINT_MAP
+#define LTTNG_TRACEPOINT_EVENT_INSTANCE_PRINT_MAP(template, name, map, proto, args, print) \
+ LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(template, name, map, PARAMS(proto), PARAMS(args))
/* Callbacks are meaningless to LTTng. */
-#undef TRACE_EVENT_FN_MAP
-#define TRACE_EVENT_FN_MAP(name, map, proto, args, tstruct, \
+#undef LTTNG_TRACEPOINT_EVENT_FN_MAP
+#define LTTNG_TRACEPOINT_EVENT_FN_MAP(name, map, proto, args, tstruct, \
assign, print, reg, unreg) \
- TRACE_EVENT_MAP(name, map, PARAMS(proto), PARAMS(args), \
- PARAMS(tstruct), PARAMS(assign), PARAMS(print)) \
+ LTTNG_TRACEPOINT_EVENT_MAP(name, map, PARAMS(proto), PARAMS(args), \
+ PARAMS(tstruct), PARAMS(assign), PARAMS(print))
-#undef TRACE_EVENT_CONDITION_MAP
-#define TRACE_EVENT_CONDITION_MAP(name, map, proto, args, cond, tstruct, assign, print) \
- TRACE_EVENT_MAP(name, map, \
+#undef LTTNG_TRACEPOINT_EVENT_CONDITION_MAP
+#define LTTNG_TRACEPOINT_EVENT_CONDITION_MAP(name, map, proto, args, cond, tstruct, assign, print) \
+ LTTNG_TRACEPOINT_EVENT_MAP(name, map, \
PARAMS(proto), \
PARAMS(args), \
PARAMS(tstruct), \
PARAMS(print))
/*
- * DECLARE_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 DEFINE_EVENT and that
- * will map the DECLARE_EVENT_CLASS to the tracepoint.
+ * 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.
*
- * TRACE_EVENT is a one to one mapping between tracepoint and template.
+ * LTTNG_TRACEPOINT_EVENT is a one to one mapping between tracepoint and
+ * template.
*/
-#undef TRACE_EVENT
-#define TRACE_EVENT(name, proto, args, tstruct, assign, print) \
- TRACE_EVENT_MAP(name, name, \
- PARAMS(proto), \
- PARAMS(args), \
- PARAMS(tstruct), \
- PARAMS(assign), \
+#undef LTTNG_TRACEPOINT_EVENT
+#define LTTNG_TRACEPOINT_EVENT(name, proto, args, tstruct, assign, print) \
+ LTTNG_TRACEPOINT_EVENT_MAP(name, name, \
+ PARAMS(proto), \
+ PARAMS(args), \
+ PARAMS(tstruct), \
+ PARAMS(assign), \
PARAMS(print))
-#undef TRACE_EVENT_NOARGS
-#define TRACE_EVENT_NOARGS(name, tstruct, assign, print) \
- TRACE_EVENT_MAP_NOARGS(name, name, \
- PARAMS(tstruct), \
- PARAMS(assign), \
+#undef LTTNG_TRACEPOINT_EVENT_NOARGS
+#define LTTNG_TRACEPOINT_EVENT_NOARGS(name, tstruct, assign, print) \
+ LTTNG_TRACEPOINT_EVENT_MAP_NOARGS(name, name, \
+ PARAMS(tstruct), \
+ PARAMS(assign), \
PARAMS(print))
-#undef DEFINE_EVENT_PRINT
-#define DEFINE_EVENT_PRINT(template, name, proto, args, print) \
- DEFINE_EVENT_PRINT_MAP(template, name, name, \
+#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_PRINT
+#define LTTNG_TRACEPOINT_EVENT_INSTANCE_PRINT(template, name, proto, args, print) \
+ LTTNG_TRACEPOINT_EVENT_INSTANCE_PRINT_MAP(template, name, name, \
PARAMS(proto), PARAMS(args), PARAMS(print_))
-#undef TRACE_EVENT_FN
-#define TRACE_EVENT_FN(name, proto, args, tstruct, \
+#undef LTTNG_TRACEPOINT_EVENT_FN
+#define LTTNG_TRACEPOINT_EVENT_FN(name, proto, args, tstruct, \
assign, print, reg, unreg) \
- TRACE_EVENT_FN_MAP(name, name, PARAMS(proto), PARAMS(args), \
+ LTTNG_TRACEPOINT_EVENT_FN_MAP(name, name, PARAMS(proto), PARAMS(args), \
PARAMS(tstruct), PARAMS(assign), PARAMS(print), \
PARAMS(reg), PARAMS(unreg)) \
-#undef DEFINE_EVENT
-#define DEFINE_EVENT(template, name, proto, args) \
- DEFINE_EVENT_MAP(template, name, name, PARAMS(proto), PARAMS(args))
+#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 DEFINE_EVENT_NOARGS
-#define DEFINE_EVENT_NOARGS(template, name) \
- DEFINE_EVENT_MAP_NOARGS(template, name, name)
+#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS
+#define LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(template, name) \
+ LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS(template, name, name)
-#undef TRACE_EVENT_CONDITION
-#define TRACE_EVENT_CONDITION(name, proto, args, cond, tstruct, assign, print) \
- TRACE_EVENT_CONDITION_MAP(name, name, \
+#undef LTTNG_TRACEPOINT_EVENT_CONDITION
+#define LTTNG_TRACEPOINT_EVENT_CONDITION(name, proto, args, cond, tstruct, assign, print) \
+ LTTNG_TRACEPOINT_EVENT_CONDITION_MAP(name, name, \
PARAMS(proto), \
PARAMS(args), \
PARAMS(cond), \
PARAMS(assign), \
PARAMS(print))
-#undef DECLARE_EVENT_CLASS
-#define DECLARE_EVENT_CLASS(_name, _proto, _args, _tstruct, _assign, _print) \
- LTTNG_DECLARE_EVENT_CLASS(_name, PARAMS(_proto), PARAMS(_args), , , \
+#undef LTTNG_TRACEPOINT_EVENT_CLASS
+#define LTTNG_TRACEPOINT_EVENT_CLASS(_name, _proto, _args, _tstruct, _assign, _print) \
+ LTTNG_TRACEPOINT_EVENT_CLASS_CODE(_name, PARAMS(_proto), PARAMS(_args), , , \
PARAMS(_tstruct), PARAMS(_assign), PARAMS(_print))
-#undef DECLARE_EVENT_CLASS_NOARGS
-#define DECLARE_EVENT_CLASS_NOARGS(_name, _tstruct, _assign, _print) \
- LTTNG_DECLARE_EVENT_CLASS_NOARGS(_name, , , PARAMS(_tstruct), \
+#undef LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS
+#define LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(_name, _tstruct, _assign, _print) \
+ LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS(_name, , , PARAMS(_tstruct), \
PARAMS(_assign), PARAMS(_print))
* Stage 1 of the trace events.
*
* Create dummy trace calls for each events, verifying that the LTTng module
- * TRACE_EVENT headers match the kernel arguments. Will be optimized out by the
- * compiler.
+ * instrumentation headers match the kernel arguments. Will be optimized
+ * out by the compiler.
*/
#include "lttng-events-reset.h" /* Reset all macros within TRACE_EVENT */
#undef TP_ARGS
#define TP_ARGS(args...) args
-#undef DEFINE_EVENT_MAP
-#define DEFINE_EVENT_MAP(_template, _name, _map, _proto, _args) \
+#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP
+#define LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(_template, _name, _map, _proto, _args) \
void trace_##_name(_proto);
-#undef DEFINE_EVENT_MAP_NOARGS
-#define DEFINE_EVENT_MAP_NOARGS(_template, _name, _map) \
+#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS
+#define LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS(_template, _name, _map) \
void trace_##_name(void *__data);
#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
#undef TP_STRUCT__entry
#define TP_STRUCT__entry(args...) args /* Only one used in this phase */
-#undef LTTNG_DECLARE_EVENT_CLASS_NOARGS
-#define LTTNG_DECLARE_EVENT_CLASS_NOARGS(_name, _locvar, _code, _tstruct, _assign, _print) \
+#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS
+#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS(_name, _locvar, _code, _tstruct, _assign, _print) \
static const struct lttng_event_field __event_fields___##_name[] = { \
_tstruct \
};
-#undef LTTNG_DECLARE_EVENT_CLASS
-#define LTTNG_DECLARE_EVENT_CLASS(_name, _proto, _args, _locvar, _code, _tstruct, _assign, _print) \
- LTTNG_DECLARE_EVENT_CLASS_NOARGS(_name, _locvar, _code, PARAMS(_tstruct), PARAMS(_assign), \
+#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE
+#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE(_name, _proto, _args, _locvar, _code, _tstruct, _assign, _print) \
+ LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS(_name, _locvar, _code, PARAMS(_tstruct), PARAMS(_assign), \
PARAMS(_print))
#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
#undef TP_PROTO
#define TP_PROTO(args...) args
-#undef LTTNG_DECLARE_EVENT_CLASS
-#define LTTNG_DECLARE_EVENT_CLASS(_name, _proto, _args, _locvar, _code, _tstruct, _assign, _print) \
+#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE
+#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE(_name, _proto, _args, _locvar, _code, _tstruct, _assign, _print) \
static void __event_probe__##_name(void *__data, _proto);
-#undef LTTNG_DECLARE_EVENT_CLASS_NOARGS
-#define LTTNG_DECLARE_EVENT_CLASS_NOARGS(_name, _locvar, _code, _tstruct, _assign, _print) \
+#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS
+#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS(_name, _locvar, _code, _tstruct, _assign, _print) \
static void __event_probe__##_name(void *__data);
#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
#define TP_PROBE_CB(_template) &__event_probe__##_template
#endif
-#undef DEFINE_EVENT_MAP_NOARGS
-#define DEFINE_EVENT_MAP_NOARGS(_template, _name, _map) \
+#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, \
.owner = THIS_MODULE, \
};
-#undef DEFINE_EVENT_MAP
-#define DEFINE_EVENT_MAP(_template, _name, _map, _proto, _args) \
- DEFINE_EVENT_MAP_NOARGS(_template, _name, _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)
#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
#include "lttng-events-reset.h" /* Reset all macros within TRACE_EVENT */
-#undef DEFINE_EVENT_MAP_NOARGS
-#define DEFINE_EVENT_MAP_NOARGS(_template, _name, _map) \
+#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS
+#define LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS(_template, _name, _map) \
&__event_desc___##_map,
-#undef DEFINE_EVENT_MAP
-#define DEFINE_EVENT_MAP(_template, _name, _map, _proto, _args) \
- DEFINE_EVENT_MAP_NOARGS(_template, _name, _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)
#undef TP_locvar
#define TP_locvar(...) __VA_ARGS__
-#undef LTTNG_DECLARE_EVENT_CLASS
-#define LTTNG_DECLARE_EVENT_CLASS(_name, _proto, _args, _locvar, _code, _tstruct, _assign, _print) \
+#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE
+#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE(_name, _proto, _args, _locvar, _code, _tstruct, _assign, _print) \
static inline size_t __event_get_size__##_name(size_t *__dynamic_len, \
void *__tp_locvar, _proto) \
{ \
return __event_len; \
}
-#undef LTTNG_DECLARE_EVENT_CLASS_NOARGS
-#define LTTNG_DECLARE_EVENT_CLASS_NOARGS(_name, _locvar, _code, _tstruct, _assign, _print) \
+#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS
+#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS(_name, _locvar, _code, _tstruct, _assign, _print) \
static inline size_t __event_get_size__##_name(size_t *__dynamic_len, \
void *__tp_locvar) \
{ \
#undef TP_locvar
#define TP_locvar(...) __VA_ARGS__
-#undef LTTNG_DECLARE_EVENT_CLASS
-#define LTTNG_DECLARE_EVENT_CLASS(_name, _proto, _args, _locvar, _code, _tstruct, _assign, _print) \
-static inline size_t __event_get_align__##_name(void *__tp_locvar, _proto) \
+#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE
+#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE(_name, _proto, _args, _locvar, _code, _tstruct, _assign, _print) \
+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; \
return __event_align; \
}
-#undef LTTNG_DECLARE_EVENT_CLASS_NOARGS
-#define LTTNG_DECLARE_EVENT_CLASS_NOARGS(_name, _locvar, _code, _tstruct, _assign, _print) \
+#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS
+#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS(_name, _locvar, _code, _tstruct, _assign, _print) \
static inline size_t __event_get_align__##_name(void *__tp_locvar) \
{ \
size_t __event_align = 1; \
#undef TP_STRUCT__entry
#define TP_STRUCT__entry(args...) args
-#undef LTTNG_DECLARE_EVENT_CLASS_NOARGS
-#define LTTNG_DECLARE_EVENT_CLASS_NOARGS(_name, _locvar, _code, _tstruct, _assign, _print) \
+#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS
+#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS(_name, _locvar, _code, _tstruct, _assign, _print) \
struct __event_typemap__##_name { \
_tstruct \
};
-#undef LTTNG_DECLARE_EVENT_CLASS
-#define LTTNG_DECLARE_EVENT_CLASS(_name, _proto, _args, _locvar, _code, _tstruct, _assign, _print) \
- LTTNG_DECLARE_EVENT_CLASS_NOARGS(_name, _locvar, _code, _tstruct, _assign, _print)
+#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE
+#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE(_name, _proto, _args, _locvar, _code, _tstruct, _assign, _print) \
+ LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS(_name, _locvar, _code, _tstruct, _assign, _print)
#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
* __dynamic_array_enc_ext_2() and tp_memcpy_dyn_2(), which are the
* worse case, needing 2 entries per field.
*/
-#undef LTTNG_DECLARE_EVENT_CLASS
-#define LTTNG_DECLARE_EVENT_CLASS(_name, _proto, _args, _locvar, _code, _tstruct, _assign, _print) \
+#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE
+#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE(_name, _proto, _args, _locvar, _code, _tstruct, _assign, _print) \
static void __event_probe__##_name(void *__data, _proto) \
{ \
struct probe_local_vars { _locvar }; \
_assign \
}
-#undef LTTNG_DECLARE_EVENT_CLASS_NOARGS
-#define LTTNG_DECLARE_EVENT_CLASS_NOARGS(_name, _locvar, _code, _tstruct, _assign, _print) \
+#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS
+#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS(_name, _locvar, _code, _tstruct, _assign, _print) \
static void __event_probe__##_name(void *__data) \
{ \
struct probe_local_vars { _locvar }; \
#undef TP_PROTO
#undef TP_ARGS
-#undef TRACE_EVENT_FLAGS
--- /dev/null
+#ifndef LTTNG_TRACEPOINT_EVENT_H
+#define LTTNG_TRACEPOINT_EVENT_H
+
+/*
+ * lttng-tracepoint-event.h
+ *
+ * Copyright (C) 2014 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; only
+ * version 2.1 of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <linux/tracepoint.h>
+
+/*
+ * 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, struct, assign, print) \
+ _LTTNG_INSTRUMENTATION(DECLARE_TRACE(name, PARAMS(proto), PARAMS(args)))
+#define LTTNG_TRACEPOINT_EVENT_CODE(name, proto, args, _locvar, _code, tstruct, assign, print) \
+ _LTTNG_INSTRUMENTATION(DECLARE_TRACE(name, PARAMS(proto), PARAMS(args)))
+#define LTTNG_TRACEPOINT_EVENT_MAP(name, map, proto, args, tstruct, assign, print) \
+ _LTTNG_INSTRUMENTATION(DECLARE_TRACE(name, PARAMS(proto), PARAMS(args)))
+#define LTTNG_TRACEPOINT_EVENT_FN(name, proto, args, struct, assign, print, reg, unreg) \
+ _LTTNG_INSTRUMENTATION(DECLARE_TRACE(name, PARAMS(proto), PARAMS(args)))
+#define LTTNG_TRACEPOINT_EVENT_FN_MAP(name, map, proto, args, tstruct, assign, print, reg, unreg) \
+ _LTTNG_INSTRUMENTATION(DECLARE_TRACE(name, PARAMS(proto), PARAMS(args)))
+#define LTTNG_TRACEPOINT_EVENT_CONDITION(name, proto, args, cond, struct, assign, print) \
+ _LTTNG_INSTRUMENTATION(DECLARE_TRACE(name, PARAMS(proto), PARAMS(args)))
+#define LTTNG_TRACEPOINT_EVENT_MAP_NOARGS(name, map, struct, assign, print) \
+ _LTTNG_INSTRUMENTATION(DECLARE_TRACE_NOARGS(name))
+
+#define LTTNG_TRACEPOINT_EVENT_CLASS(name, proto, args, tstruct, assign, print)
+#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE(_name, _proto, _args, _locvar, _code, _tstruct, _assign, _print)
+#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS(_name, _locvar, _code, _tstruct, _assign, _print)
+
+#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_PRINT(template, name, proto, args, print) \
+ _LTTNG_INSTRUMENTATION(DECLARE_TRACE(name, PARAMS(proto), PARAMS(args)))
+#define LTTNG_TRACEPOINT_EVENT_INSTANCE_PRINT_MAP(template, name, map, proto, args, print) \
+ _LTTNG_INSTRUMENTATION(DECLARE_TRACE(name, PARAMS(proto), PARAMS(args)))
+#define LTTNG_TRACEPOINT_EVENT_INSTANCE_CONDITION(template, name, proto, args, cond) \
+ _LTTNG_INSTRUMENTATION(DECLARE_TRACE(name, PARAMS(proto), PARAMS(args)))
+#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))
+
+#endif /* LTTNG_TRACEPOINT_EVENT_H */
#define CREATE_TRACE_POINTS
#define TRACE_INCLUDE_PATH ../instrumentation/events/lttng-module
#define TRACE_INCLUDE_FILE lttng
+#define LTTNG_INSTRUMENTATION
#include "../instrumentation/events/lttng-module/lttng.h"
projects / lttng-modules.git / commitdiff
