add signal trace hooks.

eliminates the global stap variable to syscall tapset for faster speed

7 files changed, 463 insertions, 6 deletions

diff --git a/tapset/ChangeLog b/tapset/ChangeLog
index 6031a705..26af7d31 100644
--- a/tapset/ChangeLog
+++ b/tapset/ChangeLog
@@ -1,7 +1,9 @@
 2006-08-22  Li Guanglei <guanglei@cn.ibm.com>
 
 	* signal.stp: More variables for signal.do_action and
-	signal.procmask.
+	signal.procmask. New function of get_sigset(). Minor
+	changes to naming of signal.pend and its comments
+
 	
 2006-08-21  Martin Hunt  <hunt@redhat.com>
 
diff --git a/tapset/LKET/Changelog b/tapset/LKET/Changelog
index a81cb0cd..6c4445cd 100644
--- a/tapset/LKET/Changelog
+++ b/tapset/LKET/Changelog
@@ -1,3 +1,10 @@
+2006-08-22  Li Guanglei <guanglei@cn.ibm.com>
+	
+	* signal.stp, hookid_defs.stp, register_event.stp:
+	add signal trace hooks.
+	* syscall.stp: eliminates global stap variable of
+	HOOKID_SYSCALL_* for faster speed
+	
 2006-08-09  Josh Stone  <joshua.i.stone@intel.com>
 
 	* pagefault.stp: move pagefault to vm.* namespace
diff --git a/tapset/LKET/hookid_defs.stp b/tapset/LKET/hookid_defs.stp
index 36ddeb33..efcf6489 100755
--- a/tapset/LKET/hookid_defs.stp
+++ b/tapset/LKET/hookid_defs.stp
@@ -104,8 +104,33 @@ global
 	HOOKID_AIO_IO_DESTROY_ENTRY,
 	HOOKID_AIO_IO_DESTROY_RETURN,
 	HOOKID_AIO_IO_CANCEL_ENTRY,
-	HOOKID_AIO_IO_CANCEL_RETURN
+	HOOKID_AIO_IO_CANCEL_RETURN,
 
+	/* signal */
+	GROUP_SIGNAL,
+
+	HOOKID_SIGNAL_SEND_ENTRY,
+	HOOKID_SIGNAL_SEND_RETURN,
+
+	HOOKID_SIGNAL_SYSKILL_ENTRY,
+	HOOKID_SIGNAL_SYSKILL_RETURN,
+
+	HOOKID_SIGNAL_SYSTGKILL_ENTRY,
+	HOOKID_SIGNAL_SYSTGKILL_RETURN,
+
+	HOOKID_SIGNAL_SYSTKILL_ENTRY,
+	HOOKID_SIGNAL_SYSTKILL_RETURN,
+
+	HOOKID_SIGNAL_PENDING_ENTRY,
+	HOOKID_SIGNAL_PENDING_RETURN,
+
+	HOOKID_SIGNAL_DOACTION_ENTRY,
+	HOOKID_SIGNAL_DOACTION_RETURN,
+
+	HOOKID_SIGNAL_PROC_MASK_ENTRY,
+	HOOKID_SIGNAL_PROC_MASK_RETURN,
+
+	HOOKID_SIGNAL_FLUSH_ENTRY
 	
 %{
 /* used in embedded c codes */
@@ -121,6 +146,7 @@ int _GROUP_PAGEFAULT = 7;
 int _GROUP_NETDEV = 8;
 int _GROUP_IOSYSCALL = 9;
 int _GROUP_AIO = 10;
+int _GROUP_SIGNAL = 11;
 
 /* hookIDs defined inside each group */
 int _HOOKID_REGSYSEVT = 1;
@@ -211,6 +237,22 @@ int _HOOKID_AIO_IO_DESTROY_RETURN = 10;
 int _HOOKID_AIO_IO_CANCEL_ENTRY = 11;
 int _HOOKID_AIO_IO_CANCEL_RETURN = 12;
 
+int _HOOKID_SIGNAL_SEND_ENTRY = 1;
+int _HOOKID_SIGNAL_SEND_RETURN = 2;
+int _HOOKID_SIGNAL_SYSKILL_ENTRY = 3;
+int _HOOKID_SIGNAL_SYSKILL_RETURN = 4;
+int _HOOKID_SIGNAL_SYSTGKILL_ENTRY= 5; 
+int _HOOKID_SIGNAL_SYSTGKILL_RETURN = 6;
+int _HOOKID_SIGNAL_SYSTKILL_ENTRY = 7;
+int _HOOKID_SIGNAL_SYSTKILL_RETURN = 8;
+int _HOOKID_SIGNAL_PENDING_ENTRY = 9;
+int _HOOKID_SIGNAL_PENDING_RETURN = 10;
+int _HOOKID_SIGNAL_DOACTION_ENTRY = 11;
+int _HOOKID_SIGNAL_DOACTION_RETURN = 12;
+int _HOOKID_SIGNAL_PROC_MASK_ENTRY = 13;
+int _HOOKID_SIGNAL_PROC_MASK_RETURN = 14;
+int _HOOKID_SIGNAL_FLUSH_ENTRY = 15;
+
 %}
 
 function hookid_init()
@@ -319,6 +361,24 @@ function hookid_init()
 
 	HOOKID_AIO_IO_CANCEL_ENTRY = 11
 	HOOKID_AIO_IO_CANCEL_RETURN = 12
+
+	GROUP_SIGNAL = 11
+
+	HOOKID_SIGNAL_SEND_ENTRY = 1
+	HOOKID_SIGNAL_SEND_RETURN = 2
+	HOOKID_SIGNAL_SYSKILL_ENTRY = 3
+	HOOKID_SIGNAL_SYSKILL_RETURN = 4
+	HOOKID_SIGNAL_SYSTGKILL_ENTRY = 5
+	HOOKID_SIGNAL_SYSTGKILL_RETURN = 6
+	HOOKID_SIGNAL_SYSTKILL_ENTRY = 7
+	HOOKID_SIGNAL_SYSTKILL_RETURN = 8
+	HOOKID_SIGNAL_PENDING_ENTRY = 9
+	HOOKID_SIGNAL_PENDING_RETURN = 10
+	HOOKID_SIGNAL_DOACTION_ENTRY = 11
+	HOOKID_SIGNAL_DOACTION_RETURN = 12
+	HOOKID_SIGNAL_PROC_MASK_ENTRY = 13
+	HOOKID_SIGNAL_PROC_MASK_RETURN = 14
+	HOOKID_SIGNAL_FLUSH_ENTRY = 15
 }
 
 
diff --git a/tapset/LKET/register_event.stp b/tapset/LKET/register_event.stp
index 1a41bd1d..322be40b 100755
--- a/tapset/LKET/register_event.stp
+++ b/tapset/LKET/register_event.stp
@@ -279,6 +279,45 @@ function register_sys_events()
 		"ctx_id:iocb_uaddr:result_uaddr")
 	register_sys_event(GROUP_AIO, HOOKID_AIO_IO_CANCEL_RETURN,
 		"INT64", "return")
+
+	register_sys_event(GROUP_SIGNAL, HOOKID_SIGNAL_SEND_ENTRY,
+		"INT8:INT8:INT8:INT32", "sig:shared:send2queue:pid")
+	register_sys_event(GROUP_SIGNAL, HOOKID_SIGNAL_SEND_RETURN,
+		"INT8", "return")
+
+	register_sys_event(GROUP_SIGNAL, HOOKID_SIGNAL_SYSKILL_ENTRY,
+		"INT32:INT8", "pid:sig")
+	register_sys_event(GROUP_SIGNAL, HOOKID_SIGNAL_SYSKILL_RETURN,
+		"INT8", "return")
+
+	register_sys_event(GROUP_SIGNAL, HOOKID_SIGNAL_SYSTGKILL_ENTRY,
+		"INT32:INT32:INT8", "tid:pid:sig")
+	register_sys_event(GROUP_SIGNAL, HOOKID_SIGNAL_SYSTGKILL_RETURN,
+		"INT8", "return")
+
+	register_sys_event(GROUP_SIGNAL, HOOKID_SIGNAL_SYSTKILL_ENTRY,
+		"INT32:INT8", "pid:sig")
+	register_sys_event(GROUP_SIGNAL, HOOKID_SIGNAL_SYSTKILL_RETURN,
+		"INT8", "return")
+
+	register_sys_event(GROUP_SIGNAL, HOOKID_SIGNAL_PENDING_ENTRY,
+		"INT32:INT32", "sigset_addr:setsize");
+	register_sys_event(GROUP_SIGNAL, HOOKID_SIGNAL_PENDING_RETURN,
+		"INT8", "return")
+
+	register_sys_event(GROUP_SIGNAL, HOOKID_SIGNAL_DOACTION_ENTRY,
+		"INT8:INT64", "sig:handler")
+	register_sys_event(GROUP_SIGNAL, HOOKID_SIGNAL_DOACTION_RETURN,
+		"INT16", "return")
+
+	register_sys_event(GROUP_SIGNAL, HOOKID_SIGNAL_PROC_MASK_ENTRY,
+		"INT8:INT64", "how:sigset")
+	register_sys_event(GROUP_SIGNAL, HOOKID_SIGNAL_PROC_MASK_RETURN,
+		"INT8", "return")
+
+	register_sys_event(GROUP_SIGNAL, HOOKID_SIGNAL_FLUSH_ENTRY,
+		"INT32", "pid")
+			
 }
 
 
diff --git a/tapset/LKET/signal.stp b/tapset/LKET/signal.stp
new file mode 100755
index 00000000..b475473c
--- /dev/null
+++ b/tapset/LKET/signal.stp
@@ -0,0 +1,348 @@
+// signal trace hooks
+// 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.
+
+probe never 
+{
+	printf("%d", GROUP_SIGNAL)
+}
+
+probe addevent.signal
+	= 
+	addevent.signal.send.entry,
+	addevent.signal.send.return,
+	addevent.signal.syskill.entry,
+	addevent.signal.syskill.return,
+	addevent.signal.systgkill.entry,
+	addevent.signal.systgkill.return,
+	addevent.signal.systkill.entry,
+	addevent.signal.systkill.return,
+	addevent.signal.pending.entry,
+	addevent.signal.pending.return,
+	addevent.signal.do_action.entry,
+	addevent.signal.do_action.return,
+	addevent.signal.procmask.entry,
+	addevent.signal.procmask.return,
+	addevent.signal.flush.entry
+{}
+
+/* Fires when a signal is sent to a process */
+probe addevent.signal.send.entry
+	+= _addevent.signal.send.entry
+{
+	update_record()
+}
+
+probe _addevent.signal.send.entry
+	= signal.send
+{
+	log_signal_send(sig, sig_pid, shared, send2queue)
+}
+
+function log_signal_send(sig:long, pid:long, shared:long, send2queue:long)
+%{
+	/* sig | shared | send2queue | pid 
+		shared: indicate whether the signal is send to a process
+			group or to a single process
+		send2queue: indicate whether the event is triggered by 
+			send_group_sigqueue or send_sigqueue
+	*/
+	_lket_trace(_GROUP_SIGNAL, _HOOKID_SIGNAL_SEND_ENTRY, "%1b%1b%1b%4b", 
+		THIS->sig, THIS->shared, THIS->send2queue, THIS->pid);
+%}
+
+probe addevent.signal.send.return
+	+= _addevent.signal.send.return
+{
+	update_record()
+}
+probe _addevent.signal.send.return
+	= signal.send.return
+{
+	log_signal_send_return($return)
+}
+
+function log_signal_send_return(ret:long)
+%{
+	_lket_trace(_GROUP_SIGNAL, _HOOKID_SIGNAL_SEND_RETURN, "%1b", THIS->ret);
+%}
+
+
+/* Triggered by calling kill() from user app */
+probe addevent.signal.syskill.entry
+	+= _addevent.signal.syskill.entry
+{
+	update_record()
+}
+
+probe _addevent.signal.syskill.entry = signal.syskill
+{
+	log_signal_syskill(pid, sig)
+}
+
+function log_signal_syskill(pid:long, sig:long)
+%{
+	_lket_trace(_GROUP_SIGNAL, _HOOKID_SIGNAL_SYSKILL_ENTRY,
+		"%4b%1b", THIS->pid, THIS->sig);
+%}
+
+probe addevent.signal.syskill.return
+	+= _addevent.signal.syskill.return
+{
+	update_record()
+}
+
+probe _addevent.signal.syskill.return 
+	= signal.syskill.return
+{
+	log_signal_syskill_return($return)
+}
+
+function log_signal_syskill_return(ret:long)
+%{
+	_lket_trace(_GROUP_SIGNAL, _HOOKID_SIGNAL_SYSKILL_RETURN,
+		"%1b", THIS->ret);
+%}
+
+/* triggered by calling sys_tgkill() from user app */
+probe addevent.signal.systgkill.entry
+	+= _addevent.signal.systgkill.entry
+{
+	update_record()
+}
+
+probe _addevent.signal.systgkill.entry = signal.systgkill
+{
+	log_signal_systgkill(pid, tgid, sig)
+}
+
+function log_signal_systgkill(pid:long, tgid:long, sig:long)
+%{
+	_lket_trace(_GROUP_SIGNAL, _HOOKID_SIGNAL_SYSTGKILL_ENTRY,
+		"%4b%4b%1b", THIS->pid, THIS->tgid, THIS->sig);
+%}
+
+probe addevent.signal.systgkill.return
+	+= _addevent.signal.systgkill.return
+{
+	update_record()
+}
+
+probe _addevent.signal.systgkill.return 
+	= signal.systgkill.return
+{
+	log_signal_systgkill_return($return)
+}
+
+function log_signal_systgkill_return(ret:long)
+%{
+	_lket_trace(_GROUP_SIGNAL, _HOOKID_SIGNAL_SYSTGKILL_RETURN,
+		"%1b", THIS->ret);
+%}
+
+/* Triggered by calling tkill() from user app */
+probe addevent.signal.systkill.entry
+	+= _addevent.signal.systkill.entry
+{
+	update_record()
+}
+
+probe _addevent.signal.systkill.entry = signal.systkill
+{
+	log_signal_systkill(pid, sig)
+}
+
+function log_signal_systkill(pid:long, sig:long)
+%{
+	_lket_trace(_GROUP_SIGNAL, _HOOKID_SIGNAL_SYSTKILL_ENTRY,
+		"%4b%1b", THIS->pid, THIS->sig);
+%}
+
+probe addevent.signal.systkill.return
+	+= _addevent.signal.systkill.return
+{
+	update_record()
+}
+
+probe _addevent.signal.systkill.return 
+	= signal.systkill.return
+{
+	log_signal_systkill_return($return)
+}
+
+function log_signal_systkill_return(ret:long)
+%{
+	_lket_trace(_GROUP_SIGNAL, _HOOKID_SIGNAL_SYSTKILL_RETURN,
+		"%1b", THIS->ret);
+%}
+
+/* Fires when examining current pending signals */
+probe addevent.signal.pending.entry
+	+= _addevent.signal.pending.entry
+{
+	update_record()
+}
+
+probe _addevent.signal.pending.entry = signal.pending
+{
+	log_signal_pending(uspace_add, sset_size)
+}
+
+function log_signal_pending(sigset_addr:long, setsize:long)
+%{
+	/* sigset_addr | setsize */
+	_lket_trace(_GROUP_SIGNAL, _HOOKID_SIGNAL_PENDING_ENTRY,
+		"%8b%8b", THIS->sigset_addr, THIS->setsize);
+%}
+
+probe addevent.signal.pending.return
+	+= _addevent.signal.pending.return
+{
+	update_record()
+}
+
+probe _addevent.signal.pending.return = signal.pending.return
+{
+	log_signal_pending_return($return)
+}
+
+function log_signal_pending_return(ret:long)
+%{
+	_lket_trace(_GROUP_SIGNAL, _HOOKID_SIGNAL_PENDING_RETURN,
+		"%1b", THIS->ret);
+%}
+
+/* probe signal.handle
+ *
+ * Used to invoke signals
+ *
+ * static int handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
+ *					sigset_t *oldset, struct pt_regs * regs)
+ * Argument :-
+ *  sig    : Signal number
+ *  info   : address of siginfo table.
+ *  ka     : Address of the k_sigaction table associated with the signal
+ *  oldset : Address of a bit mask array of blocked signals
+ *  regs   : Address in the Kernel Mode stack area 
+ *  
+ */
+/*
+probe signal.handle = kernel.function("handle_signal")?,
+        kernel.inline("handle_signal")?
+{
+    sig = $sig
+    sig_name = _signal_name($sig)
+    sinfo_addr = $info
+    sig_code = $info->si_code
+    sig_stack_add=$ka
+    bitmask_add=$oldset
+    kernmode_stack_add=$regs
+
+    // Check whether the signal is a User Mode or Kernel mode Signal.
+    
+    if (sinfo_addr == 0 && sig_code <= 0)
+        sig_mode = "User Mode Signal"
+    else if (sinfo_addr >=  1)
+        sig_mode = "Kernel Mode Signal"
+}
+
+probe signal.handle.return = kernel.function("handle_signal").return
+{
+    retstr = returnstr(1)
+}
+*/
+/* Fires when examing and change a signal action */
+probe addevent.signal.do_action.entry
+	+= _addevent.signal.do_action.entry
+{
+	update_record()
+}
+
+probe _addevent.signal.do_action.entry = signal.do_action
+{
+	log_signal_doaction(sig, sa_handler)
+}
+
+function log_signal_doaction(sig:long, handler:long)
+%{
+	/* sig | sa_handler | sa_mask */
+	_lket_trace(_GROUP_SIGNAL, _HOOKID_SIGNAL_DOACTION_ENTRY,
+		"%1b%8b", THIS->sig, THIS->handler);
+%}
+
+
+probe addevent.signal.do_action.return
+	+= _addevent.signal.do_action.return
+{
+	update_record()
+}
+
+probe _addevent.signal.do_action.return = signal.do_action.return
+{
+	log_signal_doaction_return($return)
+}
+
+function log_signal_doaction_return(ret:long)
+%{
+	_lket_trace(_GROUP_SIGNAL, _HOOKID_SIGNAL_DOACTION_RETURN,
+		"%2b", THIS->ret);
+%}
+
+/* Fires when examine and change blocked signals */
+
+probe addevent.signal.procmask.entry
+	+= _addevent.signal.procmask.entry
+{
+	update_record()
+}
+
+probe _addevent.signal.procmask.entry = signal.procmask
+{
+	log_signal_procmask($how, sigset)
+}
+
+function log_signal_procmask(how:long, set:long)
+%{
+	_lket_trace(_GROUP_SIGNAL, _HOOKID_SIGNAL_PROC_MASK_ENTRY,
+		"%1b%8b", THIS->how, THIS->set);
+%}
+	
+probe addevent.signal.procmask.return
+	+= _addevent.signal.procmask.return
+{
+	update_record()
+}
+
+probe _addevent.signal.procmask.return = signal.procmask.return
+{
+	log_signal_procmask_return($return)
+}
+
+function log_signal_procmask_return(ret:long)
+%{
+	_lket_trace(_GROUP_SIGNAL, _HOOKID_SIGNAL_PROC_MASK_RETURN,
+		"%1b", THIS->ret);
+%}
+
+/* Flush all pending signals for a task */
+probe addevent.signal.flush.entry
+	+= _addevent.signal.flush.entry
+{
+	update_record()
+}
+
+probe _addevent.signal.flush.entry = signal.flush
+{
+	log_signal_flush(sig_pid)
+}
+
+function log_signal_flush(pid:long)
+%{
+	_lket_trace(_GROUP_SIGNAL, _HOOKID_SIGNAL_FLUSH_ENTRY,
+		"%4b", THIS->pid);
+%}
+
diff --git a/tapset/LKET/syscalls.stp b/tapset/LKET/syscalls.stp
index e6e1d1b8..09db8df0 100755
--- a/tapset/LKET/syscalls.stp
+++ b/tapset/LKET/syscalls.stp
@@ -20,7 +20,7 @@ probe _addevent.syscall.entry
 	= syscall.*
 {
 	if(filter_by_pid() == 1 )
-		log_syscall_tracedata(HOOKID_SYSCALL_ENTRY, name)
+		log_syscall_tracedata(1, name)
 }
 
 probe addevent.syscall.return
@@ -33,7 +33,7 @@ probe _addevent.syscall.return
 	= syscall.*.return
 {
 	if(filter_by_pid() == 1 ) {
-		log_syscall_tracedata(HOOKID_SYSCALL_RETURN, name)
+		log_syscall_tracedata(2, name)
 	}
 }
 
diff --git a/tapset/signal.stp b/tapset/signal.stp
index 84731a46..1e568ae5 100644
--- a/tapset/signal.stp
+++ b/tapset/signal.stp
@@ -327,9 +327,10 @@ probe signal.send_sig_queue.return =
 }
 
 
-/* probe signal.pend
+/* probe signal.pending
  *
- * Used to Suspend signals
+ * Used to examine the set of signals that are pending for 
+ * delivery to the calling thread
  *
  * long do_sigpending(void __user *set, unsigned long sigsetsize)
  */