lkml.org 
[lkml]   [2005]   [Jan]   [14]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
Patch in this message
/
Date
From
Subject[PATCH 2/8 ] ltt for 2.6.10 : core headers

signed-off-by: Karim Yaghmour (karim@opersys.com)

--- linux-2.6.10-relayfs/include/linux/ltt-core.h 1969-12-31 19:00:00.000000000 -0500
+++ linux-2.6.10-relayfs-ltt/include/linux/ltt-core.h 2005-01-13 22:21:56.000000000 -0500
@@ -0,0 +1,430 @@
+/*
+ * linux/include/linux/ltt-core.h
+ *
+ * Copyright (C) 1999-2004 Karim Yaghmour (karim@opersys.com)
+ *
+ * This contains the core definitions for the Linux Trace Toolkit.
+ */
+
+#ifndef _LTT_CORE_H
+#define _LTT_CORE_H
+
+#include <linux/config.h>
+#include <linux/types.h>
+
+#include <linux/relayfs_fs.h>
+
+/* Is kernel tracing enabled */
+#if defined(CONFIG_LTT)
+
+#define LTT_CUSTOM_EV_MAX_SIZE 8192
+#define LTT_CUSTOM_EV_TYPE_STR_LEN 20
+#define LTT_CUSTOM_EV_DESC_STR_LEN 100
+#define LTT_CUSTOM_EV_FORM_STR_LEN 256
+#define LTT_CUSTOM_EV_FINAL_STR_LEN 200
+
+#define LTT_CUSTOM_EV_FORMAT_TYPE_NONE 0
+#define LTT_CUSTOM_EV_FORMAT_TYPE_STR 1
+#define LTT_CUSTOM_EV_FORMAT_TYPE_HEX 2
+#define LTT_CUSTOM_EV_FORMAT_TYPE_XML 3
+#define LTT_CUSTOM_EV_FORMAT_TYPE_IBM 4
+
+#define LTT_MAX_HANDLES 256
+
+/* In the ltt root directory lives the trace control file, used for
+ kernel-user communication. */
+#define LTT_RELAYFS_ROOT "ltt"
+#define LTT_CONTROL_FILE "control"
+
+/* We currently support 2 traces, normal trace and flight recorder */
+#define NR_TRACES 2
+#define TRACE_HANDLE 0
+#define FLIGHT_HANDLE 1
+
+/* System types */
+#define LTT_SYS_TYPE_VANILLA_LINUX 1
+
+/* Architecture types */
+#define LTT_ARCH_TYPE_I386 1
+#define LTT_ARCH_TYPE_PPC 2
+#define LTT_ARCH_TYPE_SH 3
+#define LTT_ARCH_TYPE_S390 4
+#define LTT_ARCH_TYPE_MIPS 5
+#define LTT_ARCH_TYPE_ARM 6
+
+/* Standard definitions for variants */
+#define LTT_ARCH_VARIANT_NONE 0 /* Main architecture implementation */
+
+typedef u64 ltt_event_mask;
+
+/* Per-CPU channel information */
+struct ltt_channel_data
+{
+ int channel_handle;
+ struct rchan_reader *reader;
+ atomic_t waiting_for_cpu_async;
+ u32 events_lost;
+};
+
+/* Per-trace status info */
+struct ltt_trace_info
+{
+ int active;
+ unsigned int trace_handle;
+ int paused;
+ int flight_recorder;
+ int use_locking;
+ int using_tsc;
+ u32 n_buffers;
+ u32 buf_size;
+ ltt_event_mask traced_events;
+ ltt_event_mask log_event_details_mask;
+ u32 buffers_produced[NR_CPUS];
+};
+
+/* Status info for all traces */
+struct ltt_tracer_status
+{
+ int num_cpus;
+ struct ltt_trace_info traces[NR_TRACES];
+};
+
+/* Per-trace information - each trace/flight recorder represented by one */
+struct ltt_trace_struct
+{
+ unsigned int trace_handle; /* For convenience */
+ struct ltt_trace_struct *active; /* 'this' if active, or NULL */
+ int paused; /* Not currently logging */
+ struct ltt_channel_data relay_data[NR_CPUS];/* Relayfs handles, by CPU */
+ int flight_recorder;/* i.e. this is not a trace */
+ struct task_struct *daemon_task_struct;/* Daemon associated with trace */
+ struct _ltt_trace_start *trace_start_data; /* Trace start event data, for flight recorder */
+ int tracer_started;
+ int tracer_stopping;
+ struct proc_dir_entry *proc_dir_entry; /* proc/ltt/0..1 */
+ ltt_event_mask traced_events;
+ ltt_event_mask log_event_details_mask;
+ u32 n_buffers; /* Number of sub-buffers */
+ u32 buf_size; /* Size of sub-buffer */
+ int use_locking;
+ int using_tsc;
+ int log_cpuid;
+ int tracing_pid;
+ int tracing_pgrp;
+ int tracing_gid;
+ int tracing_uid;
+ pid_t traced_pid;
+ pid_t traced_pgrp;
+ gid_t traced_gid;
+ uid_t traced_uid;
+ unsigned long buffer_switches_pending;/* For trace */
+ struct work_struct work; /* stop work struct */
+};
+
+extern int ltt_set_trace_config(
+ int do_syscall_depth,
+ int do_syscall_bounds,
+ int eip_depth,
+ void *eip_lower_bound,
+ void *eip_upper_bound);
+extern void ltt_set_flight_recorder_config(
+ struct ltt_trace_struct *trace);
+extern int ltt_get_trace_config(
+ int *do_syscall_depth,
+ int *do_syscall_bounds,
+ int *eip_depth,
+ void **eip_lower_bound,
+ void **eip_upper_bound);
+extern int ltt_get_status(
+ struct ltt_tracer_status *tracer_status);
+extern int ltt_create_event(
+ char *event_type,
+ char *event_desc,
+ int format_type,
+ char *format_data);
+extern int ltt_create_owned_event(
+ char *event_type,
+ char *event_desc,
+ int format_type,
+ char *format_data,
+ pid_t owner_pid);
+extern void ltt_destroy_event(
+ int event_id);
+extern void ltt_destroy_owners_events(
+ pid_t owner_pid);
+extern void ltt_reregister_custom_events(void);
+extern int ltt_log_std_formatted_event(
+ int event_id,
+ ...);
+extern int ltt_log_raw_event(
+ int event_id,
+ int event_size,
+ void *event_data);
+extern int _ltt_log_event(
+ struct ltt_trace_struct *trace,
+ u8 event_id,
+ void *event_struct,
+ u8 cpu_id);
+extern int ltt_log_event(
+ u8 event_id,
+ void *event_struct);
+extern int ltt_valid_trace_handle(
+ unsigned int tracer_handle);
+extern int ltt_alloc_trace_handle(
+ unsigned int tracer_handle);
+extern int ltt_free_trace_handle(
+ unsigned int tracer_handle);
+extern int ltt_free_daemon_handle(
+ struct ltt_trace_struct *trace);
+extern void ltt_free_all_handles(
+ struct task_struct* task_ptr);
+extern int ltt_set_buffer_size(
+ struct ltt_trace_struct *trace,
+ int buffers_size,
+ char *dirname);
+extern int ltt_set_n_buffers(
+ struct ltt_trace_struct *trace,
+ int no_buffers);
+extern int ltt_set_default_config(
+ struct ltt_trace_struct *trace);
+extern int ltt_syscall_active(
+ int syscall_type);
+extern void ltt_flight_pause(
+ void);
+extern void ltt_flight_unpause(
+ void);
+
+/* Tracer properties */
+#define LTT_TRACER_DEFAULT_BUF_SIZE 50000
+#define LTT_TRACER_MIN_BUF_SIZE 1000
+#define LTT_TRACER_MAX_BUF_SIZE 500000
+#define LTT_TRACER_MIN_BUFFERS 2
+#define LTT_TRACER_MAX_BUFFERS 256
+#define LTT_TRACER_MAGIC_NUMBER 0x00D6B7ED
+#define LTT_TRACER_VERSION_MAJOR 2
+#define LTT_TRACER_VERSION_MINOR 2
+
+#define LTT_TRACER_FIRST_EVENT_SIZE (sizeof(u8) + sizeof(u32) + sizeof(ltt_buffer_start) + sizeof(uint16_t))
+#define LTT_TRACER_START_TRACE_EVENT_SIZE (sizeof(u8) + sizeof(u32) + sizeof(ltt_trace_start) + sizeof(uint16_t))
+#define LTT_TRACER_LAST_EVENT_SIZE (sizeof(u8) \
+ + sizeof(u8) \
+ + sizeof(u32) \
+ + sizeof(ltt_buffer_end) \
+ + sizeof(uint16_t) \
+ + sizeof(u32))
+
+/* The configurations possible */
+enum {
+ LTT_TRACER_START = LTT_TRACER_MAGIC_NUMBER, /* Start tracing events using the current configuration */
+ LTT_TRACER_STOP, /* Stop tracing */
+ LTT_TRACER_CONFIG_DEFAULT, /* Set the tracer to the default configuration */
+ LTT_TRACER_CONFIG_MEMORY_BUFFERS, /* Set the memory buffers the daemon wants us to use */
+ LTT_TRACER_CONFIG_EVENTS, /* Trace the given events */
+ LTT_TRACER_CONFIG_DETAILS, /* Record the details of the event, or not */
+ LTT_TRACER_CONFIG_CPUID, /* Record the CPUID associated with the event */
+ LTT_TRACER_CONFIG_PID, /* Trace only one process */
+ LTT_TRACER_CONFIG_PGRP, /* Trace only the given process group */
+ LTT_TRACER_CONFIG_GID, /* Trace the processes of a given group of users */
+ LTT_TRACER_CONFIG_UID, /* Trace the processes of a given user */
+ LTT_TRACER_CONFIG_SYSCALL_EIP_DEPTH, /* Set the call depth at which the EIP should be fetched on syscall */
+ LTT_TRACER_CONFIG_SYSCALL_EIP_LOWER, /* Set the lowerbound address from which EIP is recorded on syscall */
+ LTT_TRACER_CONFIG_SYSCALL_EIP_UPPER, /* Set the upperbound address from which EIP is recorded on syscall */
+ LTT_TRACER_DATA_COMITTED, /* The daemon has comitted the last trace */
+ LTT_TRACER_GET_EVENTS_LOST, /* Get the number of events lost */
+ LTT_TRACER_CREATE_USER_EVENT, /* Create a user tracable event */
+ LTT_TRACER_DESTROY_USER_EVENT, /* Destroy a user tracable event */
+ LTT_TRACER_TRACE_USER_EVENT, /* Trace a user event */
+ LTT_TRACER_SET_EVENT_MASK, /* Set the trace event mask */
+ LTT_TRACER_GET_EVENT_MASK, /* Get the trace event mask */
+ LTT_TRACER_GET_BUFFER_CONTROL, /* Get the buffer control data for the lockless schem*/
+ LTT_TRACER_CONFIG_N_MEMORY_BUFFERS, /* Set the number of memory buffers the daemon wants us to use */
+ LTT_TRACER_CONFIG_USE_LOCKING, /* Set the locking scheme to use */
+ LTT_TRACER_CONFIG_TIMESTAMP, /* Set the timestamping method to use */
+ LTT_TRACER_GET_ARCH_INFO, /* Get information about the CPU configuration */
+ LTT_TRACER_ALLOC_HANDLE, /* Allocate a tracer handle */
+ LTT_TRACER_FREE_HANDLE, /* Free a single handle */
+ LTT_TRACER_FREE_DAEMON_HANDLE, /* Free the daemon's handle */
+ LTT_TRACER_FREE_ALL_HANDLES, /* Free all handles */
+ LTT_TRACER_MAP_BUFFER, /* Map buffer to process-space */
+ LTT_TRACER_PAUSE, /* Pause tracing */
+ LTT_TRACER_UNPAUSE, /* Unpause tracing */
+ LTT_TRACER_GET_START_INFO, /* trace start data */
+ LTT_TRACER_GET_STATUS /* status of traces */
+};
+
+/* Lockless scheme definitions */
+#define LTT_TRACER_LOCKLESS_MIN_BUF_SIZE LTT_CUSTOM_EV_MAX_SIZE + 8192
+#define LTT_TRACER_LOCKLESS_MAX_BUF_SIZE 0x1000000
+
+/* Flags used for per-CPU tasks */
+#define LTT_NOTHING_TO_DO 0x00
+#define LTT_FINALIZE_TRACE 0x02
+#define LTT_TRACE_HEARTBEAT 0x08
+
+/* How often the LTT per-CPU timers fire */
+#define LTT_PERCPU_TIMER_FREQ (HZ/10);
+
+/* Convenience accessors */
+#define waiting_for_cpu_async(trace_handle, cpu) (current_traces[trace_handle].relay_data[cpu].waiting_for_cpu_async)
+#define trace_channel_handle(trace_handle, cpu) (current_traces[trace_handle].relay_data[cpu].channel_handle)
+#define trace_channel_reader(trace_handle, cpu) (current_traces[trace_handle].relay_data[cpu].reader)
+#define trace_buffers_full(cpu) (daemon_relay_data[cpu].buffers_full)
+#define events_lost(trace_handle, cpu) (current_traces[trace_handle].relay_data[cpu].events_lost)
+
+/* Used for sharing per-buffer information between driver and daemon */
+struct ltt_buf_control_info
+{
+ s16 cpu_id;
+ u32 buffer_switches_pending;
+ u32 buffer_control_valid;
+
+ u32 buf_size;
+ u32 n_buffers;
+ u32 cur_idx;
+ u32 buffers_produced;
+ u32 buffers_consumed;
+ int buffer_complete[LTT_TRACER_MAX_BUFFERS];
+};
+
+/* Used for sharing buffer-commit information between driver and daemon */
+struct ltt_buffers_committed
+{
+ u8 cpu_id;
+ u32 buffers_consumed;
+};
+
+/* Used for specifying size/cpu id pair between driver and daemon */
+struct ltt_cpu_mmap_data
+{
+ u8 cpu_id;
+ unsigned long map_size;
+};
+
+/* Used for sharing architecture-specific info between driver and daemon */
+struct ltt_arch_info
+{
+ int n_cpus;
+ int page_shift;
+};
+
+extern __inline__ int ltt_set_bit(int nr, void *addr)
+{
+ unsigned char *p = addr;
+ unsigned char mask = 1 << (nr & 7);
+ unsigned char old;
+
+ p += nr >> 3;
+ old = *p;
+ *p |= mask;
+
+ return ((old & mask) != 0);
+}
+
+extern __inline__ int ltt_clear_bit(int nr, void *addr)
+{
+ unsigned char *p = addr;
+ unsigned char mask = 1 << (nr & 7);
+ unsigned char old;
+
+ p += nr >> 3;
+ old = *p;
+ *p &= ~mask;
+
+ return ((old & mask) != 0);
+}
+
+extern __inline__ int ltt_test_bit(int nr, void *addr)
+{
+ unsigned char *p = addr;
+ unsigned char mask = 1 << (nr & 7);
+
+ p += nr >> 3;
+
+ return ((*p & mask) != 0);
+}
+
+#if !defined(CONFIG_X86)
+# define cpu_has_tsc 0 /* FIXME: cpu_has_tsc isn't set except on x86 */
+#endif
+
+/**
+ * switch_time_delta: - Utility function getting buffer switch time delta.
+ * @time_delta: previously calculated or retrieved time delta
+ *
+ * Returns the time_delta passed in if we're using TSC or 0 otherwise.
+ */
+static inline u32 switch_time_delta(u32 time_delta,
+ int using_tsc)
+{
+ if((using_tsc == 1) && cpu_has_tsc)
+ return time_delta;
+ else
+ return 0;
+}
+
+#else /* defined(CONFIG_LTT) */
+static inline int ltt_create_event(char *event_type,
+ char *event_desc,
+ int format_type,
+ char *format_data)
+{
+ return 0;
+}
+
+static inline int ltt_create_owned_event(char *event_type,
+ char *event_desc,
+ int format_type,
+ char *format_data,
+ pid_t owner_pid)
+{
+ return 0;
+}
+
+static inline void ltt_destroy_event(int event_id)
+{
+}
+
+static inline void ltt_destroy_owners_events(pid_t owner_pid)
+{
+}
+
+static inline void ltt_reregister_custom_events(void)
+{
+}
+
+static inline int ltt_log_std_formatted_event(int event_id, ...)
+{
+ return 0;
+}
+
+
+static inline int ltt_log_raw_event(int event_id,
+ int event_size,
+ void *event_data)
+{
+ return 0;
+}
+
+static inline int _ltt_log_event(u8 event_id,
+ void *event_struct,
+ u8 cpu_id)
+{
+ return 0;
+}
+
+static inline int ltt_log_event(u8 event_id,
+ void *event_struct)
+{
+ return 0;
+}
+
+static inline void ltt_flight_pause(void)
+{
+}
+
+static inline void ltt_flight_unpause(void)
+{
+}
+
+#endif /* defined(CONFIG_LTT) */
+#endif /* _LTT_CORE_H */
--- linux-2.6.10-relayfs/include/linux/ltt-events.h 1969-12-31 19:00:00.000000000 -0500
+++ linux-2.6.10-relayfs-ltt/include/linux/ltt-events.h 2005-01-13 22:21:56.000000000 -0500
@@ -0,0 +1,424 @@
+/*
+ * linux/include/linux/ltt-events.h
+ *
+ * Copyright (C) 1999-2004 Karim Yaghmour (karim@opersys.com)
+ *
+ * This contains the event definitions for the Linux Trace Toolkit.
+ */
+
+#ifndef _LTT_EVENTS_H
+#define _LTT_EVENTS_H
+
+#include <linux/ltt-core.h>
+#include <linux/sched.h>
+
+/* Is kernel tracing enabled */
+#if defined(CONFIG_LTT)
+
+/* Don't set this to "1" unless you really know what you're doing */
+#define LTT_UNPACKED_STRUCTS 0
+
+/* Structure packing within the trace */
+#if LTT_UNPACKED_STRUCTS
+#define LTT_PACKED_STRUCT
+#else
+#define LTT_PACKED_STRUCT __attribute__ ((packed))
+#endif
+
+extern unsigned int ltt_syscall_entry_trace_active;
+extern unsigned int ltt_syscall_exit_trace_active;
+
+static inline void ltt_ev(u8 event_id, void* data)
+{
+ ltt_log_event(event_id, data);
+}
+
+/* Traced events */
+enum {
+ LTT_EV_START = 0, /* This is to mark the trace's start */
+ LTT_EV_SYSCALL_ENTRY, /* Entry in a given system call */
+ LTT_EV_SYSCALL_EXIT, /* Exit from a given system call */
+ LTT_EV_TRAP_ENTRY, /* Entry in a trap */
+ LTT_EV_TRAP_EXIT, /* Exit from a trap */
+ LTT_EV_IRQ_ENTRY, /* Entry in an irq */
+ LTT_EV_IRQ_EXIT, /* Exit from an irq */
+ LTT_EV_SCHEDCHANGE, /* Scheduling change */
+ LTT_EV_KERNEL_TIMER, /* The kernel timer routine has been called */
+ LTT_EV_SOFT_IRQ, /* Hit key part of soft-irq management */
+ LTT_EV_PROCESS, /* Hit key part of process management */
+ LTT_EV_FILE_SYSTEM, /* Hit key part of file system */
+ LTT_EV_TIMER, /* Hit key part of timer management */
+ LTT_EV_MEMORY, /* Hit key part of memory management */
+ LTT_EV_SOCKET, /* Hit key part of socket communication */
+ LTT_EV_IPC, /* Hit key part of System V IPC */
+ LTT_EV_NETWORK, /* Hit key part of network communication */
+ LTT_EV_BUFFER_START, /* Mark the begining of a trace buffer */
+ LTT_EV_BUFFER_END, /* Mark the ending of a trace buffer */
+ LTT_EV_NEW_EVENT, /* New event type */
+ LTT_EV_CUSTOM, /* Custom event */
+ LTT_EV_CHANGE_MASK, /* Change in event mask */
+ LTT_EV_HEARTBEAT /* Heartbeat event */
+};
+
+/* Number of traced events */
+#define LTT_EV_MAX LTT_EV_HEARTBEAT
+
+/* Information logged when a trace is started */
+typedef struct _ltt_trace_start {
+ u32 magic_number;
+ u32 arch_type;
+ u32 arch_variant;
+ u32 system_type;
+ u8 major_version;
+ u8 minor_version;
+
+ u32 buffer_size;
+ ltt_event_mask event_mask;
+ ltt_event_mask details_mask;
+ u8 log_cpuid;
+ u8 use_tsc;
+ u8 flight_recorder;
+} LTT_PACKED_STRUCT ltt_trace_start;
+
+/* LTT_SYSCALL_ENTRY */
+typedef struct _ltt_syscall_entry {
+ u8 syscall_id; /* Syscall entry number in entry.S */
+ u32 address; /* Address from which call was made */
+} LTT_PACKED_STRUCT ltt_syscall_entry;
+
+/* LTT_TRAP_ENTRY */
+#ifndef __s390__
+typedef struct _ltt_trap_entry {
+ u16 trap_id; /* Trap number */
+ u32 address; /* Address where trap occured */
+} LTT_PACKED_STRUCT ltt_trap_entry;
+static inline void ltt_ev_trap_entry(u16 trap_id, u32 address)
+#else
+typedef u64 trapid_t;
+typedef struct _ltt_trap_entry {
+ trapid_t trap_id; /* Trap number */
+ u32 address; /* Address where trap occured */
+} LTT_PACKED_STRUCT ltt_trap_entry;
+static inline void ltt_ev_trap_entry(trapid_t trap_id, u32 address)
+#endif
+{
+ ltt_trap_entry trap_event;
+
+ trap_event.trap_id = trap_id;
+ trap_event.address = address;
+
+ ltt_log_event(LTT_EV_TRAP_ENTRY, &trap_event);
+}
+
+/* LTT_TRAP_EXIT */
+static inline void ltt_ev_trap_exit(void)
+{
+ ltt_log_event(LTT_EV_TRAP_EXIT, NULL);
+}
+
+/* LTT_IRQ_ENTRY */
+typedef struct _ltt_irq_entry {
+ u8 irq_id; /* IRQ number */
+ u8 kernel; /* Are we executing kernel code */
+} LTT_PACKED_STRUCT ltt_irq_entry;
+static inline void ltt_ev_irq_entry(u8 irq_id, u8 in_kernel)
+{
+ ltt_irq_entry irq_entry;
+
+ irq_entry.irq_id = irq_id;
+ irq_entry.kernel = in_kernel;
+
+ ltt_log_event(LTT_EV_IRQ_ENTRY, &irq_entry);
+}
+
+/* LTT_IRQ_EXIT */
+static inline void ltt_ev_irq_exit(void)
+{
+ ltt_log_event(LTT_EV_IRQ_EXIT, NULL);
+}
+
+/* LTT_SCHEDCHANGE */
+typedef struct _ltt_schedchange {
+ u32 out; /* Outgoing process */
+ u32 in; /* Incoming process */
+ u32 out_state; /* Outgoing process' state */
+} LTT_PACKED_STRUCT ltt_schedchange;
+static inline void ltt_ev_schedchange(task_t * task_out, task_t * task_in)
+{
+ ltt_schedchange sched_event;
+
+ sched_event.out = (u32) task_out->pid;
+ sched_event.in = (u32) task_in;
+ sched_event.out_state = (u32) task_out->state;
+
+ ltt_log_event(LTT_EV_SCHEDCHANGE, &sched_event);
+}
+
+/* LTT_SOFT_IRQ */
+enum {
+ LTT_EV_SOFT_IRQ_BOTTOM_HALF = 1, /* Conventional bottom-half */
+ LTT_EV_SOFT_IRQ_SOFT_IRQ, /* Real soft-irq */
+ LTT_EV_SOFT_IRQ_TASKLET_ACTION, /* Tasklet action */
+ LTT_EV_SOFT_IRQ_TASKLET_HI_ACTION /* Tasklet hi-action */
+};
+typedef struct _ltt_soft_irq {
+ u8 event_sub_id; /* Soft-irq event Id */
+ u32 event_data;
+} LTT_PACKED_STRUCT ltt_soft_irq;
+static inline void ltt_ev_soft_irq(u8 ev_id, u32 data)
+{
+ ltt_soft_irq soft_irq_event;
+
+ soft_irq_event.event_sub_id = ev_id;
+ soft_irq_event.event_data = data;
+
+ ltt_log_event(LTT_EV_SOFT_IRQ, &soft_irq_event);
+}
+
+/* LTT_PROCESS */
+enum {
+ LTT_EV_PROCESS_KTHREAD = 1, /* Creation of a kernel thread */
+ LTT_EV_PROCESS_FORK, /* A fork or clone occured */
+ LTT_EV_PROCESS_EXIT, /* An exit occured */
+ LTT_EV_PROCESS_WAIT, /* A wait occured */
+ LTT_EV_PROCESS_SIGNAL, /* A signal has been sent */
+ LTT_EV_PROCESS_WAKEUP /* Wake up a process */
+};
+typedef struct _ltt_process {
+ u8 event_sub_id; /* Process event ID */
+ u32 event_data1;
+ u32 event_data2;
+} LTT_PACKED_STRUCT ltt_process;
+static inline void ltt_ev_process(u8 ev_id, u32 data1, u32 data2)
+{
+ ltt_process proc_event;
+
+ proc_event.event_sub_id = ev_id;
+ proc_event.event_data1 = data1;
+ proc_event.event_data2 = data2;
+
+ ltt_log_event(LTT_EV_PROCESS, &proc_event);
+}
+static inline void ltt_ev_process_exit(u32 data1, u32 data2)
+{
+ ltt_process proc_event;
+
+ proc_event.event_sub_id = LTT_EV_PROCESS_EXIT;
+
+ /**** WARNING ****/
+ /* Regardless of whether this trace statement is active or not, these
+ two function must be called, otherwise there will be inconsistencies
+ in the kernel's structures. */
+ ltt_destroy_owners_events(current->pid);
+ ltt_free_all_handles(current);
+
+ ltt_log_event(LTT_EV_PROCESS, &proc_event);
+}
+
+/* LTT_FILE_SYSTEM */
+enum {
+ LTT_EV_FILE_SYSTEM_BUF_WAIT_START = 1, /* Starting to wait for a data buffer */
+ LTT_EV_FILE_SYSTEM_BUF_WAIT_END, /* End to wait for a data buffer */
+ LTT_EV_FILE_SYSTEM_EXEC, /* An exec occured */
+ LTT_EV_FILE_SYSTEM_OPEN, /* An open occured */
+ LTT_EV_FILE_SYSTEM_CLOSE, /* A close occured */
+ LTT_EV_FILE_SYSTEM_READ, /* A read occured */
+ LTT_EV_FILE_SYSTEM_WRITE, /* A write occured */
+ LTT_EV_FILE_SYSTEM_SEEK, /* A seek occured */
+ LTT_EV_FILE_SYSTEM_IOCTL, /* An ioctl occured */
+ LTT_EV_FILE_SYSTEM_SELECT, /* A select occured */
+ LTT_EV_FILE_SYSTEM_POLL /* A poll occured */
+};
+typedef struct _ltt_file_system {
+ u8 event_sub_id; /* File system event ID */
+ u32 event_data1;
+ u32 event_data2;
+ char *file_name; /* Name of file operated on */
+} LTT_PACKED_STRUCT ltt_file_system;
+static inline void ltt_ev_file_system(u8 ev_id, u32 data1, u32 data2, const unsigned char *file_name)
+{
+ ltt_file_system fs_event;
+
+ fs_event.event_sub_id = ev_id;
+ fs_event.event_data1 = data1;
+ fs_event.event_data2 = data2;
+ fs_event.file_name = (char*) file_name;
+
+ ltt_log_event(LTT_EV_FILE_SYSTEM, &fs_event);
+}
+
+/* LTT_TIMER */
+enum {
+ LTT_EV_TIMER_EXPIRED = 1, /* Timer expired */
+ LTT_EV_TIMER_SETITIMER, /* Setting itimer occurred */
+ LTT_EV_TIMER_SETTIMEOUT /* Setting sched timeout occurred */
+};
+typedef struct _ltt_timer {
+ u8 event_sub_id; /* Timer event ID */
+ u8 event_sdata; /* Short data */
+ u32 event_data1;
+ u32 event_data2;
+} LTT_PACKED_STRUCT ltt_timer;
+static inline void ltt_ev_timer(u8 ev_id, u8 sdata, u32 data1, u32 data2)
+{
+ ltt_timer timer_event;
+
+ timer_event.event_sub_id = ev_id;
+ timer_event.event_sdata = sdata;
+ timer_event.event_data1 = data1;
+ timer_event.event_data2 = data2;
+
+ ltt_log_event(LTT_EV_TIMER, &timer_event);
+}
+
+/* LTT_MEMORY */
+enum {
+ LTT_EV_MEMORY_PAGE_ALLOC = 1, /* Allocating pages */
+ LTT_EV_MEMORY_PAGE_FREE, /* Freing pages */
+ LTT_EV_MEMORY_SWAP_IN, /* Swaping pages in */
+ LTT_EV_MEMORY_SWAP_OUT, /* Swaping pages out */
+ LTT_EV_MEMORY_PAGE_WAIT_START, /* Start to wait for page */
+ LTT_EV_MEMORY_PAGE_WAIT_END /* End to wait for page */
+};
+typedef struct _ltt_memory {
+ u8 event_sub_id; /* Memory event ID */
+ u32 event_data;
+} LTT_PACKED_STRUCT ltt_memory;
+static inline void ltt_ev_memory(u8 ev_id, u32 data)
+{
+ ltt_memory memory_event;
+
+ memory_event.event_sub_id = ev_id;
+ memory_event.event_data = data;
+
+ ltt_log_event(LTT_EV_MEMORY, &memory_event);
+}
+
+/* LTT_SOCKET */
+enum {
+ LTT_EV_SOCKET_CALL = 1, /* A socket call occured */
+ LTT_EV_SOCKET_CREATE, /* A socket has been created */
+ LTT_EV_SOCKET_SEND, /* Data was sent to a socket */
+ LTT_EV_SOCKET_RECEIVE /* Data was read from a socket */
+};
+typedef struct _ltt_socket {
+ u8 event_sub_id; /* Socket event ID */
+ u32 event_data1;
+ u32 event_data2;
+} LTT_PACKED_STRUCT ltt_socket;
+static inline void ltt_ev_socket(u8 ev_id, u32 data1, u32 data2)
+{
+ ltt_socket socket_event;
+
+ socket_event.event_sub_id = ev_id;
+ socket_event.event_data1 = data1;
+ socket_event.event_data2 = data2;
+
+ ltt_log_event(LTT_EV_SOCKET, &socket_event);
+}
+
+/* LTT_IPC */
+enum {
+ LTT_EV_IPC_CALL = 1, /* A System V IPC call occured */
+ LTT_EV_IPC_MSG_CREATE, /* A message queue has been created */
+ LTT_EV_IPC_SEM_CREATE, /* A semaphore was created */
+ LTT_EV_IPC_SHM_CREATE /* A shared memory segment has been created */
+};
+typedef struct _ltt_ipc {
+ u8 event_sub_id; /* IPC event ID */
+ u32 event_data1;
+ u32 event_data2;
+} LTT_PACKED_STRUCT ltt_ipc;
+static inline void ltt_ev_ipc(u8 ev_id, u32 data1, u32 data2)
+{
+ ltt_ipc ipc_event;
+
+ ipc_event.event_sub_id = ev_id;
+ ipc_event.event_data1 = data1;
+ ipc_event.event_data2 = data2;
+
+ ltt_log_event(LTT_EV_IPC, &ipc_event);
+}
+
+/* LTT_NETWORK */
+enum {
+ LTT_EV_NETWORK_PACKET_IN = 1, /* A packet came in */
+ LTT_EV_NETWORK_PACKET_OUT /* A packet was sent */
+};
+typedef struct _ltt_network {
+ u8 event_sub_id; /* Network event ID */
+ u32 event_data;
+} LTT_PACKED_STRUCT ltt_network;
+static inline void ltt_ev_network(u8 ev_id, u32 data)
+{
+ ltt_network net_event;
+
+ net_event.event_sub_id = ev_id;
+ net_event.event_data = data;
+
+ ltt_log_event(LTT_EV_NETWORK, &net_event);
+}
+
+/* Start of trace buffer information */
+typedef struct _ltt_buffer_start {
+ struct timeval time; /* Time stamp of this buffer */
+ u32 tsc; /* TSC of this buffer, if applicable */
+ u32 id; /* Unique buffer ID */
+} LTT_PACKED_STRUCT ltt_buffer_start;
+
+/* End of trace buffer information */
+typedef struct _ltt_buffer_end {
+ struct timeval time; /* Time stamp of this buffer */
+ u32 tsc; /* TSC of this buffer, if applicable */
+} LTT_PACKED_STRUCT ltt_buffer_end;
+
+/* Custom declared events */
+/* ***WARNING*** These structures should never be used as is, use the
+ provided custom event creation and logging functions. */
+typedef struct _ltt_new_event {
+ /* Basics */
+ u32 id; /* Custom event ID */
+ char type[LTT_CUSTOM_EV_TYPE_STR_LEN]; /* Event type description */
+ char desc[LTT_CUSTOM_EV_DESC_STR_LEN]; /* Detailed event description */
+
+ /* Custom formatting */
+ u32 format_type; /* Type of formatting */
+ char form[LTT_CUSTOM_EV_FORM_STR_LEN]; /* Data specific to format */
+} LTT_PACKED_STRUCT ltt_new_event;
+typedef struct _ltt_custom {
+ u32 id; /* Event ID */
+ u32 data_size; /* Size of data recorded by event */
+ void *data; /* Data recorded by event */
+} LTT_PACKED_STRUCT ltt_custom;
+
+/* LTT_CHANGE_MASK */
+typedef struct _ltt_change_mask {
+ ltt_event_mask mask; /* Event mask */
+} LTT_PACKED_STRUCT ltt_change_mask;
+
+
+/* LTT_HEARTBEAT */
+static inline void ltt_ev_heartbeat(void)
+{
+ ltt_log_event(LTT_EV_HEARTBEAT, NULL);
+}
+
+#else /* defined(CONFIG_LTT) */
+#define ltt_ev(ID, DATA)
+#define ltt_ev_trap_entry(ID, EIP)
+#define ltt_ev_trap_exit()
+#define ltt_ev_irq_entry(ID, KERNEL)
+#define ltt_ev_irq_exit()
+#define ltt_ev_schedchange(OUT, IN)
+#define ltt_ev_soft_irq(ID, DATA)
+#define ltt_ev_process(ID, DATA1, DATA2)
+#define ltt_ev_process_exit(DATA1, DATA2)
+#define ltt_ev_file_system(ID, DATA1, DATA2, FILE_NAME)
+#define ltt_ev_timer(ID, SDATA, DATA1, DATA2)
+#define ltt_ev_memory(ID, DATA)
+#define ltt_ev_socket(ID, DATA1, DATA2)
+#define ltt_ev_ipc(ID, DATA1, DATA2)
+#define ltt_ev_network(ID, DATA)
+#define ltt_ev_heartbeat()
+#endif /* defined(CONFIG_LTT) */
+#endif /* _LTT_EVENTS_H */
--- linux-2.6.10-relayfs/init/Kconfig 2004-12-24 16:35:24.000000000 -0500
+++ linux-2.6.10-relayfs-ltt/init/Kconfig 2005-01-13 22:21:56.000000000 -0500
@@ -315,6 +315,38 @@ config CC_OPTIMIZE_FOR_SIZE

If unsure, say N.

+config LTT
+ bool "Linux Trace Toolkit support"
+ depends on RELAYFS_FS=y
+ default n
+ ---help---
+ It is possible for the kernel to log important events to a trace
+ facility. Doing so, enables the use of the generated traces in order
+ to reconstruct the dynamic behavior of the kernel, and hence the
+ whole system.
+
+ The tracing process contains 4 parts :
+ 1) The logging of events by key parts of the kernel.
+ 2) The tracer that keeps the events in a data buffer (uses
+ relayfs).
+ 3) A trace daemon that interacts with the tracer and is
+ notified every time there is a certain quantity of data to
+ read from the tracer.
+ 4) A trace event data decoder that reads the accumulated data
+ and formats it in a human-readable format.
+
+ If you say Y, the first two components will be built into the kernel.
+ Critical parts of the kernel will call upon the kernel tracing
+ function. The data is then recorded by the tracer if a trace daemon
+ is running in user-space and has issued a "start" command.
+
+ In order to enable LTT support you must first select relayfs as
+ built-in.
+
+ For more information on kernel tracing, the trace daemon or the event
+ decoder, please check the following address :
+ http://www.opersys.com/ltt
+
config SHMEM
default y
bool "Use full shmem filesystem" if EMBEDDED && MMU
--- linux-2.6.10-relayfs/kernel/Makefile 2004-12-24 16:34:26.000000000 -0500
+++ linux-2.6.10-relayfs-ltt/kernel/Makefile 2005-01-13 22:21:56.000000000 -0500
@@ -17,6 +17,7 @@ obj-$(CONFIG_MODULES) += module.o
obj-$(CONFIG_KALLSYMS) += kallsyms.o
obj-$(CONFIG_PM) += power/
obj-$(CONFIG_BSD_PROCESS_ACCT) += acct.o
+obj-$(CONFIG_LTT) += ltt-core.o
obj-$(CONFIG_COMPAT) += compat.o
obj-$(CONFIG_IKCONFIG) += configs.o
obj-$(CONFIG_IKCONFIG_PROC) += configs.o
--- linux-2.6.10-relayfs/MAINTAINERS 2004-12-24 16:35:00.000000000 -0500
+++ linux-2.6.10-relayfs-ltt/MAINTAINERS 2005-01-13 22:21:56.000000000 -0500
@@ -1363,6 +1363,13 @@ L: linux-security-module@wirex.com
W: http://lsm.immunix.org
S: Supported

+LINUX TRACE TOOLKIT
+P: Karim Yaghmour
+M: karim@opersys.com
+W: http://www.opersys.com/LTT
+L: ltt-dev@listserv.shafik.org
+S: Maintained
+
LM83 HARDWARE MONITOR DRIVER
P: Jean Delvare
M: khali@linux-fr.org

-
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/

\
 
 \ /
  Last update: 2005-03-22 14:09    [W:0.148 / U:0.096 seconds]
©2003-2011 Jasper Spaans. Advertise on this site