Revert my former changes to lket_trace_extra() in translator.

a new way of allowing user add arbitrary trace data. And also provide
a way of letting user write the trace data format.

11 files changed, 339 insertions, 64 deletions

diff --git a/tapset/LKET/Changelog b/tapset/LKET/Changelog
index dbad033f..8680b91a 100644
--- a/tapset/LKET/Changelog
+++ b/tapset/LKET/Changelog
@@ -1,3 +1,9 @@
+2006-06-09  Li Guanglei <guanglei@cn.ibm.com>
+	
+	* *.stp: New design of making user able to append extra trace data.
+	lket_backtrace() is deleted.
+	* register_event.stp: write the metainfo of trace data.
+	
 2006-06-01  Li Guanglei <guanglei@cn.ibm.com>
 	
 	* *.stp: make user able to append extra trace data. The
diff --git a/tapset/LKET/hookid_defs.stp b/tapset/LKET/hookid_defs.stp
index dc6f7749..70801484 100755
--- a/tapset/LKET/hookid_defs.stp
+++ b/tapset/LKET/hookid_defs.stp
@@ -1,4 +1,9 @@
 global 
+	/* register event */
+	GROUP_REGEVT,
+	HOOKID_REGSYSEVT,
+	HOOKID_REGUSREVT,
+
 	/* syscall */
 	GROUP_SYSCALL,
 	HOOKID_SYSCALL_ENTRY, HOOKID_SYSCALL_RETURN, 
@@ -33,15 +38,19 @@ global
 /* used in embedded c codes */
 
 /* Group ID Definitions */
-int _GROUP_SYSCALL = 1;
-int _GROUP_PROCESS = 2;
-int _GROUP_IOSCHED = 3;
-int _GROUP_TASK = 4;
-int _GROUP_SCSI = 5;
-int _GROUP_PAGEFAULT = 6;
-int _GROUP_NETDEV = 7;
+int _GROUP_REGEVT = 1;
+int _GROUP_SYSCALL = 2;
+int _GROUP_PROCESS = 3;
+int _GROUP_IOSCHED = 4;
+int _GROUP_TASK = 5;
+int _GROUP_SCSI = 6;
+int _GROUP_PAGEFAULT = 7;
+int _GROUP_NETDEV = 8;
 
 /* hookIDs defined inside each group */
+int _HOOKID_REGSYSEVT = 1;
+int _HOOKID_REGUSREVT = 2;
+
 int _HOOKID_SYSCALL_ENTRY = 1;
 int _HOOKID_SYSCALL_RETURN = 2;
 
@@ -68,40 +77,50 @@ int _HOOKID_NETDEV_TRANSMIT = 2;
 
 %}
 
-probe begin
+function hookid_init()
 {
-	GROUP_SYSCALL = 1
+	GROUP_REGEVT = 1
+	HOOKID_REGSYSEVT = 1
+	HOOKID_REGUSREVT = 2
+
+	GROUP_SYSCALL = 2
 	HOOKID_SYSCALL_ENTRY = 1
 	HOOKID_SYSCALL_RETURN = 2
 
-	GROUP_PROCESS = 2
+	GROUP_PROCESS = 3
 	HOOKID_PROCESS_SNAPSHOT = 1
  	HOOKID_PROCESS_EXECVE = 2
 	HOOKID_PROCESS_FORK = 3
 
-	GROUP_IOSCHED = 3
+	GROUP_IOSCHED = 4
 	HOOKID_IOSCHED_NEXT_REQ = 1
 	HOOKID_IOSCHED_ADD_REQ = 2
 	HOOKID_IOSCHED_REMOVE_REQ = 3
 
-	GROUP_TASK = 4
+	GROUP_TASK = 5
 	HOOKID_TASK_CTXSWITCH = 1
 	HOOKID_TASK_CPUIDLE = 2
 
-	GROUP_SCSI = 5
+	GROUP_SCSI = 6
 	HOOKID_SCSI_IOENTRY = 1
 	HOOKID_SCSI_IO_TO_LLD = 2
 	HOOKID_SCSI_IODONE_BY_LLD = 3
 	HOOKID_SCSI_IOCOMP_BY_MIDLEVEL = 4
 
-	GROUP_PAGEFAULT = 6
+	GROUP_PAGEFAULT = 7
 	HOOKID_PAGEFAULT = 1
 
-	GROUP_NETDEV = 7
+	GROUP_NETDEV = 8
 	HOOKID_NETDEV_RECEIVE = 1
 	HOOKID_NETDEV_TRANSMIT = 2
+}
 
-	lket_trace_init()
 
+probe begin
+{
+	hookid_init()
+	lket_trace_init()
+	register_sys_events()
+	write_events_desc()	
 	process_snapshot()
 }
diff --git a/tapset/LKET/ioscheduler.stp b/tapset/LKET/ioscheduler.stp
index 462e3758..298ae72b 100755
--- a/tapset/LKET/ioscheduler.stp
+++ b/tapset/LKET/ioscheduler.stp
@@ -6,14 +6,21 @@
 // later version.
 
 probe addevent.ioscheduler
-	= addevent.ioscheduler.elv_next_request, 
-	addevent.ioscheduler.elv_completed_request,
-	addevent.ioscheduler.elv_add_request
+	= addevent.ioscheduler.elv_next_request,
+	addevent.ioscheduler.elv_add_request,
+	addevent.ioscheduler.elv_completed_request
 {
 }
 
+	
 /* when a request is retrieved from request queue */
 probe addevent.ioscheduler.elv_next_request
+	+= _addevent.ioscheduler.elv_next_request
+{
+	update_record()
+}
+
+probe _addevent.ioscheduler.elv_next_request
 	=  ioscheduler.elv_next_request
 {
 	if(filter_by_pid() == 1 ) {
@@ -24,6 +31,12 @@ probe addevent.ioscheduler.elv_next_request
 
 /* when a request is added to the request queue */
 probe addevent.ioscheduler.elv_add_request
+	+= _addevent.ioscheduler.elv_add_request
+{
+	update_record()
+}
+
+probe _addevent.ioscheduler.elv_add_request
 	= ioscheduler.elv_add_request
 {
 	if(filter_by_pid() == 1 ) {
@@ -33,6 +46,12 @@ probe addevent.ioscheduler.elv_add_request
 
 /* when a request is completed */
 probe addevent.ioscheduler.elv_completed_request
+	+= _addevent.ioscheduler.elv_completed_request
+{
+	update_record()
+}
+
+probe _addevent.ioscheduler.elv_completed_request
 	= ioscheduler.elv_completed_request
 {
 	if(filter_by_pid() == 1 ) {
diff --git a/tapset/LKET/lket_trace.stp b/tapset/LKET/lket_trace.stp
index 851a3163..eaab216a 100755
--- a/tapset/LKET/lket_trace.stp
+++ b/tapset/LKET/lket_trace.stp
@@ -30,10 +30,7 @@ function lket_trace_header_init()
 #define BIG_ENDIAN             0x02
 #define BITS_WIDTH             64     /* 32-bit or 64-bit environment*/
 
-#define LKET_HEADER_LEN        0   /* fake number, bin_write will fill in the
-                                     actual length of trace header */
-
-	_stp_printf("%4b%2n%1b%1b%1b%1b", (_FMT_)MAGIC_NUMBER, (_FMT_)LKET_HEADER_LEN, 
+	_stp_printf("%4b%2n%1b%1b%1b%1b", (_FMT_)MAGIC_NUMBER,
 		(_FMT_)LKET_TRACE_VER_MAJOR, (_FMT_)LKET_TRACE_VER_MINOR, 
 		(_FMT_)BIG_ENDIAN, (_FMT_)BITS_WIDTH);
 	_stp_print_flush();
@@ -50,10 +47,7 @@ function lket_trace_init()
 #ifndef __LKET_TRACE__
 #define __LKET_TRACE__
 
-#define LKET_PKT_SYS 1
 #define LKET_PKT_BT 2
-#define LKET_PKT_USER 3
-
 
 #define MAX_FMT_LEN 128
 char new_sysfmt[MAX_FMT_LEN] = "\n%d|%d|%d|%d|%d|%d|%d|%d";
@@ -140,30 +134,21 @@ static inline int this_event_len(void)
 #define _lket_trace(GroupID, hookID, fmt, args...) do { \
 	struct timeval tv; \
 	do_gettimeofday (&tv); \
-	_stp_printf("%1b%2n%1b%1b%4b%4b%4b%4b%4b%1b"fmt, \
-		(_FMT_)LKET_PKT_SYS, (_FMT_)GroupID, (_FMT_)hookID, \
+	_stp_printf("%2b%2n%1b%1b%4b%4b%4b%4b%4b%1b"fmt, \
+		(_FMT_)0, (_FMT_)GroupID, (_FMT_)hookID, \
 		(_FMT_)tv.tv_sec, (_FMT_)tv.tv_usec, (_FMT_)current->tgid, \
 		(_FMT_)current->parent->pid, (_FMT_)current->pid, \
 		(_FMT_)current->thread_info->cpu, args);\
 } while(0)
 
-#define _lket_trace_extra(fmt, args...)  do {\
-        _stp_printf("%1b%2n%0s"fmt, (_FMT_)LKET_PKT_USER, fmt, args);\
-} while(0)
-
 #endif
 #endif
 %}
 
 
-function lket_backtrace () %{
-        if (CONTEXT->regs) {
-                String str = _stp_string_init (0);
-                _stp_stack_sprint (str, CONTEXT->regs, 0);
-#if defined(ASCII_TRACE)
-                _stp_printf("|BACKTRACE: %s", _stp_string_ptr(str));
-#else
-                _stp_printf("%1b%2n%0s", (_FMT_)LKET_PKT_BT, _stp_string_ptr(str));
-#endif
-        }
+function update_record()
+%{
+	int cpu = smp_processor_id();
+	char *total_length = &_stp_pbuf[cpu][STP_PRINT_BUF_START];
+	*(int16_t *)total_length = _stp_pbuf_len[cpu] - 4;
 %}
diff --git a/tapset/LKET/netdev.stp b/tapset/LKET/netdev.stp
index 024e869c..e19c851d 100755
--- a/tapset/LKET/netdev.stp
+++ b/tapset/LKET/netdev.stp
@@ -10,12 +10,18 @@
 %}
 
 probe addevent.netdev
-	=  addevent.netdev.receive, addevent.netdev.transmit
-{
-}
+	= addevent.netdev.receive,
+	addevent.netdev.transmit
+{}
 
 /* Main device receive routine, be called when packet arrives on network device */
 probe addevent.netdev.receive
+	+= _addevent.netdev.receive
+{
+	update_record()
+}
+
+probe _addevent.netdev.receive
 	=  netdev.receive
 {
 	/* no need to filter by pid */
@@ -24,6 +30,12 @@ probe addevent.netdev.receive
 
 /* Queue a buffer for transmission to a network device */
 probe addevent.netdev.transmit
+	+= _addevent.netdev.transmit
+{
+	update_record()
+}
+
+probe _addevent.netdev.transmit
 	=  netdev.transmit
 {
 	if(filter_by_pid() == 1 ) {
diff --git a/tapset/LKET/pagefault.stp b/tapset/LKET/pagefault.stp
index 0675f4e8..3f15cf62 100755
--- a/tapset/LKET/pagefault.stp
+++ b/tapset/LKET/pagefault.stp
@@ -13,6 +13,12 @@ function log_pagefault_tracedata(var_id:long, var_addr:long, var_rwflag:long)
 
 /* Record the page fault event */
 probe addevent.pagefault
+	+= _addevent.pagefault
+{
+	update_record()
+}
+
+probe _addevent.pagefault
 	=  pagefault
 {
 	if(filter_by_pid() == 1 ) {
diff --git a/tapset/LKET/process.stp b/tapset/LKET/process.stp
index 9a8e2196..3155e5dc 100755
--- a/tapset/LKET/process.stp
+++ b/tapset/LKET/process.stp
@@ -30,6 +30,8 @@ function process_snapshot()
 %{
 	struct task_struct *tsk;
 	struct list_head *cur, *head;
+	int cpu = smp_processor_id();
+	char *total_length;
 	head = &(current->tasks);
 
 	/* iterate all the processes, and record the pid and process
@@ -38,21 +40,29 @@ function process_snapshot()
 		tsk = (struct task_struct *)(list_entry(cur, struct task_struct, tasks));
 		_lket_trace(_GROUP_PROCESS, _HOOKID_PROCESS_SNAPSHOT, "%4b%0s", 
 			(_FMT_)tsk->pid, tsk->comm);
+
+		total_length = &_stp_pbuf[cpu][STP_PRINT_BUF_START];
+		*(int16_t *)total_length = _stp_pbuf_len[cpu] - 4;
 		_stp_print_flush();
 	}
 %}
 
-
 probe addevent.process
-	=  addevent.process.fork, addevent.process.execve
-{
-}
+	= addevent.process.execve,
+	addevent.process.fork
+{}
 
 /* 
   we should capture both do_execve for 64-bit app
   and compat_do_execve for 32-bit app           
 */
 probe addevent.process.execve
+	+= _addevent.process.execve
+{
+	update_record()
+}
+
+probe _addevent.process.execve
 	=  process.exec
 {
 	if(filter_by_pid() == 1 ) {
@@ -61,6 +71,12 @@ probe addevent.process.execve
 }
 
 probe addevent.process.fork
+	+= _addevent.process.fork
+{
+	update_record()
+}
+
+probe _addevent.process.fork
 	= process.create
 {
 	if(filter_by_pid() == 1 ) {
diff --git a/tapset/LKET/register_event.stp b/tapset/LKET/register_event.stp
new file mode 100755
index 00000000..3150bf51
--- /dev/null
+++ b/tapset/LKET/register_event.stp
@@ -0,0 +1,164 @@
+// Copyright (C) 2006 IBM Corp.
+//
+// This file is part of systemtap, and is free software.  You can
+// redistribute it and/or modify it under the terms of the GNU General
+// Public License (GPL); either version 2, or (at your option) any
+// later version.
+
+global evt_name, evt_fmt
+global usr_evt_name, usr_evt_fmt
+
+%{
+
+#define _MAXGROUPID  20
+#define _MAXHOOKID   20
+
+int get_fmtcode(char *fmt)
+{
+	if(strncmp(fmt, "INT8", 4) != 0 &&
+		strncmp(fmt, "INT16", 5) != 0 &&
+		strncmp(fmt, "INT32", 5) != 0 &&
+		strncmp(fmt, "INT64", 5) != 0 &&
+		strncmp(fmt, "STRING", 6) != 0)  
+		return -1;
+	else
+		return 0;
+}
+
+%}
+
+function dummy_c_function()
+%{
+%}
+
+function register_user_event(grpid:long, hookid:long,fmt:string, name:string) 
+{
+	usr_evt_fmt[grpid, hookid] = fmt
+	usr_evt_name[grpid, hookid] = name
+	dummy_c_function() /* ensure register_user_event won't be compiled away */
+}
+
+function register_sys_event(grpid:long, hookid:long,fmt:string, name:string) 
+{
+	evt_fmt[grpid, hookid] = fmt
+	evt_name[grpid, hookid] = name
+	dummy_c_function() /* ensure register_user_event won't be compiled away */
+}
+
+
+function write_events_desc()
+{
+	foreach([grpid, hookid] in evt_fmt)
+	{
+		register_event(grpid, hookid, HOOKID_REGSYSEVT, 
+			evt_fmt[grpid, hookid], evt_name[grpid, hookid])
+	}
+	foreach([grpid, hookid] in usr_evt_fmt)
+	{
+		register_event(grpid, hookid, HOOKID_REGUSREVT,
+			usr_evt_fmt[grpid, hookid], usr_evt_name[grpid, hookid])
+	}
+
+	delete evt_name
+	delete evt_fmt
+	delete usr_evt_name
+	delete usr_evt_fmt
+}	
+
+function register_event(grpid:long, hookid:long, evt_type:long, fmt:string, names:string)
+%{
+	char in_fmt[512], in_name[512];
+	char *p_in_fmt, *p_in_name;
+	char *fmt, *name;
+        int cpu = smp_processor_id();
+	char *total_length;
+	p_in_fmt = in_fmt;
+	p_in_name = in_name;
+
+	if(THIS->fmt==NULL || THIS->names==NULL)  {
+		_stp_warn("error fmt/names in register_user_event\n");
+		_stp_exit();
+	}
+
+	if( THIS->grpid <= 0 || THIS->grpid > _MAXGROUPID ||
+		THIS->hookid <= 0 || THIS->hookid > _MAXHOOKID)  {
+		_stp_warn("wrong range in groupid/hookid\n");
+		_stp_exit();
+	}
+
+	strncpy(in_fmt, THIS->fmt, 512);
+	strncpy(in_name, THIS->names, 512);
+
+	fmt = strsep(&p_in_fmt, ":");
+	name = strsep(&p_in_name, ":");
+
+	while(fmt!=NULL && name!=NULL)  {
+		if(get_fmtcode(fmt) == -1)  {
+			_stp_warn("error in fmt string\n");
+			_stp_exit();
+		}
+		fmt = strsep(&p_in_fmt, ":");
+		name = strsep(&p_in_name, ":");
+	}
+
+	if(fmt!=NULL || name != NULL)  {
+		_stp_warn("unpaired types/names\n");
+		_stp_exit();
+	}
+
+	_lket_trace(_GROUP_REGEVT, THIS->evt_type, "%1b%1b%0s%0s", THIS->grpid,
+		THIS->hookid, THIS->fmt, THIS->names); 
+
+        total_length = &_stp_pbuf[cpu][STP_PRINT_BUF_START];
+        *(int16_t *)total_length = _stp_pbuf_len[cpu] - 4;
+
+	_stp_print_flush();
+%}
+
+function register_sys_events()
+{
+	register_sys_event(GROUP_SYSCALL, HOOKID_SYSCALL_ENTRY, "STRING", "Syscall")
+	register_sys_event(GROUP_SYSCALL, HOOKID_SYSCALL_RETURN, "STRING", "Syscall")
+		
+	register_sys_event(GROUP_PROCESS, HOOKID_PROCESS_SNAPSHOT,
+		"INT32:STRING", "PID:PNAME")
+	register_sys_event(GROUP_PROCESS, HOOKID_PROCESS_EXECVE,
+		"STRING", "PNAME")
+	register_sys_event(GROUP_PROCESS, HOOKID_PROCESS_FORK,
+		"INT32", "PID")
+
+	register_sys_event(GROUP_IOSCHED, HOOKID_IOSCHED_NEXT_REQ,
+		"STRING:INT8:INT8", "ELV_NAME:MAJOR:MINOR")
+	register_sys_event(GROUP_IOSCHED, HOOKID_IOSCHED_ADD_REQ,
+		"STRING:INT8:INT8", "ELV_NAME:MAJOR:MINOR")
+	register_sys_event(GROUP_IOSCHED, HOOKID_IOSCHED_REMOVE_REQ,
+		"STRING:INT8:INT8", "ELV_NAME:MAJOR:MINOR")
+
+	register_sys_event(GROUP_TASK, HOOKID_TASK_CTXSWITCH,
+		"INT32:INT32:INT8", "Prev_PID:Next_PID:Prev_State")
+	register_sys_event(GROUP_TASK, HOOKID_TASK_CPUIDLE,
+		"INT32", "CurrPID")
+
+	register_sys_event(GROUP_SCSI, HOOKID_SCSI_IOENTRY,
+		"INT8:INT8:INT8", "MAJOR:MINOR:SDEV_STATE")
+	register_sys_event(GROUP_SCSI, HOOKID_SCSI_IO_TO_LLD,
+		"INT8:INT32:INT8:INT64:INT32:INT64",
+		"SDEV_STATE:SCSI_INFO:Data_Dir:Req_Buf:Buf_Len:Cmd_ID")
+	register_sys_event(GROUP_SCSI, HOOKID_SCSI_IODONE_BY_LLD,
+		"INT32:INT8:INT64", "SCSI_INFO:Data_Dir:Cmd_ID")
+	register_sys_event(GROUP_SCSI, HOOKID_SCSI_IOCOMP_BY_MIDLEVEL,
+		"INT32:INT8:INT64:INT32", "SCSI_INFO:Data_Dir:Cmd_ID:Bytes");
+
+	register_sys_event(GROUP_PAGEFAULT, HOOKID_PAGEFAULT,
+		"INT64:INT8", "ADDR:WRITE")
+
+	register_sys_event(GROUP_NETDEV, HOOKID_NETDEV_RECEIVE,
+		"STRING:INT32:INT16:INT32", "DEV_NAME:Data_LEN:Protocol:Buff_Size")
+	register_sys_event(GROUP_NETDEV, HOOKID_NETDEV_TRANSMIT,
+		"STRING:INT32:INT16:INT32", "DEV_NAME:Data_LEN:Protocol:Buff_Size")
+}
+
+probe register_event = begin
+{
+	hookid_init()
+}
diff --git a/tapset/LKET/scsi.stp b/tapset/LKET/scsi.stp
index b98e4346..a9e4e4d9 100755
--- a/tapset/LKET/scsi.stp
+++ b/tapset/LKET/scsi.stp
@@ -28,11 +28,16 @@ probe addevent.scsi
 	addevent.scsi.iodispatching,
 	addevent.scsi.iodone,
 	addevent.scsi.iocompleted
-{
-}
+{}
 
 /* mid-layer prepare a IO request */
 probe addevent.scsi.ioentry
+	+= _addevent.scsi.ioentry
+{
+	update_record()
+}
+
+probe _addevent.scsi.ioentry
 	= scsi.ioentry
 {
 	log_scsi_ioentry(HOOKID_SCSI_IOENTRY, $q, $req)
@@ -40,6 +45,12 @@ probe addevent.scsi.ioentry
 
 /* Dispatch a command to the low-level driver. */
 probe addevent.scsi.iodispatching
+	+= _addevent.scsi.iodispatching
+{
+	update_record()
+}
+
+probe _addevent.scsi.iodispatching
 	= scsi.iodispatching
 {
 	log_scsi_dispatch(HOOKID_SCSI_IO_TO_LLD, $cmd)
@@ -47,6 +58,12 @@ probe addevent.scsi.iodispatching
 
 /* I/O is done by low-level driver*/
 probe addevent.scsi.iodone
+	+= _addevent.scsi.iodone
+{
+	update_record()
+}
+
+probe _addevent.scsi.iodone
 	= scsi.iodone
 {
 	/* scsi timer check. We should record the hook only
@@ -60,6 +77,12 @@ probe addevent.scsi.iodone
 
 /* mid-layer processes the completed IO */
 probe addevent.scsi.iocompleted
+	+= _addevent.scsi.iocompleted
+{
+	update_record()
+}
+
+probe _addevent.scsi.iocompleted
 	= scsi.iocompleted
 {
 	log_scsi_iocompleted(HOOKID_SCSI_IOCOMP_BY_MIDLEVEL, $cmd, $good_bytes)
diff --git a/tapset/LKET/syscalls.stp b/tapset/LKET/syscalls.stp
index 7b4f6799..cd6850aa 100755
--- a/tapset/LKET/syscalls.stp
+++ b/tapset/LKET/syscalls.stp
@@ -6,18 +6,17 @@
 // later version.
 
 probe addevent.syscall
-	= addevent.syscall.entry, addevent.syscall.return
+	= addevent.syscall.entry,
+	addevent.syscall.return
+{}
+
+probe addevent.syscall.entry
+	+= _addevent.syscall.entry
 {
+	update_record()
 }
 
-/* log the system call name */
-function log_syscall_tracedata(var_id:long, name:string)
-%{
-	_lket_trace(_GROUP_SYSCALL, THIS->var_id, "%0s", THIS->name); 
-%}
-
-
-probe addevent.syscall.entry
+probe _addevent.syscall.entry
 	= syscall.*
 {
 	if(filter_by_pid() == 1 ) {
@@ -26,9 +25,23 @@ probe addevent.syscall.entry
 }
 
 probe addevent.syscall.return
+	+= _addevent.syscall.return
+{
+	update_record()
+}
+
+probe _addevent.syscall.return
 	= syscall.*.return
 {
 	if(filter_by_pid() == 1 ) {
 		log_syscall_tracedata(HOOKID_SYSCALL_RETURN, name)
 	}
 }
+
+/* log the system call name */
+function log_syscall_tracedata(var_id:long, name:string)
+%{
+	_lket_trace(_GROUP_SYSCALL, THIS->var_id, "%0s", THIS->name); 
+%}
+
+
diff --git a/tapset/LKET/tskdispatch.stp b/tapset/LKET/tskdispatch.stp
index f75c083a..d56e69e7 100755
--- a/tapset/LKET/tskdispatch.stp
+++ b/tapset/LKET/tskdispatch.stp
@@ -15,14 +15,20 @@
 * specifying probe points by label.                       *
 *                                                         *
 **********************************************************/
+
 probe addevent.tskdispatch
-	= addevent.tskdispatch.ctxswitch, 
-	addevent.tskdispatch.cpuidle
-{
-}
+	= addevent.tskdispatch.cpuidle,
+	addevent.tskdispatch.ctxswitch
+{}
 
 /* Only applicable to SMP systems */
 probe addevent.tskdispatch.cpuidle
+	+= _addevent.tskdispatch.cpuidle
+{
+	update_record()
+}
+
+probe _addevent.tskdispatch.cpuidle
 	= scheduler.balance
 {
 	/* we didn't call filter_by_pid() here,
@@ -32,6 +38,12 @@ probe addevent.tskdispatch.cpuidle
 }
 
 probe addevent.tskdispatch.ctxswitch
+	+= _addevent.tskdispatch.ctxswitch
+{
+	update_record()
+}
+
+probe _addevent.tskdispatch.ctxswitch
 	= scheduler.ctxswitch
 {
 	target_pid = target()