This is the mail archive of the
systemtap@sourceware.org
mailing list for the systemtap project.
Re: Systemtap probe for Signals
- From: Li Guanglei <guanglei at cn dot ibm dot com>
- To: Manoj S Pattabhiraman <mpattabh at in dot ibm dot com>, "systemtap at sourceware dot org" <systemtap at sourceware dot org>
- Date: Wed, 26 Jul 2006 15:13:57 +0800
- Subject: Re: Systemtap probe for Signals
- Organization: IBM CSTL
- References: <OF5B05ABF6.75FEE7A3-ON652571A1.003C3F54-652571A1.003C19A3@in.ibm.com>
Hi,
I help Manoj to forward his mail since he had trouble of posting
onto SystemTap mailinglist.
--->>
Hi,
Find below the updated tapset for signal subsystem. Please lemme know
your suggestions on the same.
Thanks & Regards, Manoj
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Manoj S Pattabhiraman, ADTools, Linux on zSeries, Ph : +91 80 51776449
T/L 92 46951, e-mail: mpattabh@in.ibm.com
Manoj S Pattabhiraman ??:
> Hi,
>
> I just started of with trying systemtap by probing on signal handling.
> Those probes are now consolidated under signal.stp.
>
> (See attached file: signal.stp)
>
> Please lemme know your suggestions on the same and how to go forward.
>
> Thanks & Regards, Manoj
> -------------------------------------------------------------------
> Manoj S Pattabhiraman, e-mail: mpattabh@in.ibm.com
> There are some signal related probes defined in process.stp, they are:
> process.signal_send, process.signal_handle,
_process.signal_send.part[1-3]
>
> Should we put all signal related probes(excluding signal related
> syscalls) into a separate stp file, say, signal.stp?
I wish it would be better to have a separate stp file for signal
subsystem.
> some comments of your stp script:
> You defined:
> probe signal.sendsig = kernel.function("send_signal")
> But should we include kernel.function("send_group_sigqueue") and
> kernel.function("send_sigqueue") into signal.sendsig?
Looking at these functions, will let you know.
> I don't think "probe signal.ignored" matches what it states in the
> comment. It's used to return the status whether a signal has been
> ignored. There is a similar function named is_ignored.
Accepted. I would rather add a return probe point for the above
mentioned function. Is that fine.
Thanks
Manoj
// Signal tapset
// 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.
//
// Note : Since there are so many signals sent to processes at any give point, Its better to filter the
// the information according to the requirements. for example, filter only for a particular
// signal (if sig==2) or filter only for a particular process ( if pid_name==stap )
//
/* probe signal.sendsig
*
* Fires when a signal is sent to a process.
*
*/
probe signal.sendsig = kernel.function("send_signal")
{
sig=$sig
sig_name = _signal_name($sig)
sinfo = $info
sig_pid = $t->pid
pid_name = kernel_string($t->comm)
if (sinfo == 2)
si_code ="SIGSTOP or SIGKILL"
else if (sinfo > 0)
si_code="SI_KERNEL (SIGFPE, SIGSEGV, SIGTRAP, SIGCHLD, SIGPOLL)"
else if (sinfo <= 0)
si_code="SI_USER or SI_TIMER or SI_ASYNCIO"
argstr = sprintf( "Signal : %s - Process name : %s (%d) - Signal Code : %s ", sig_name,sig_pid,pid_name,si_code)
}
/* probe signal.wakeup
*
* Wake up the process for new active signals.
*
*/
probe signal.wakeup =
kernel.function("signal_wake_up")
{
sig_pid = $t->pid
pid_name = kernel_string($t->comm)
state = $resume
if (state == 0) {
sig_state = "TASK_INTERRUPTIBLE"
} else
{
sig_state = "TASK_INTERRUPTIBLE | TASK_STOPPED | TASK_TRACED"
}
argstr = sprintf( "Wakeup Signal to Process %s (%d) - Process State after the signal : %s ",pid_name,sig_pid,sig_state)
}
/* probe signal.ignored
*
* Fires whenever a signal is ignored by a process.
*
*/
probe signal.ignored = kernel.function("sig_ignored")
{
sig_pid = $t->pid
pid_name = kernel_string($t->comm)
sig_info = $sig
sig_name = _signal_name($sig)
argstr = sprintf( "Signal : %s is ignored by the Process : %s (%d) ",sig_name,pid_name,sig_pid)
}
probe signal.ignored.return = kernel.function("sig_ignored").return
{
name = "sig_ignored"
retstr = returnstr(1)
}
/* probe signal.handle_stopsig
*
* Fires when a stop signal is sent to a process.
*
*/
probe signal.handle_stopsig = kernel.function("handle_stop_signal")
{
sig_pid = $p->pid
pid_name = kernel_string($p->comm)
sig_info = $sig
sig_name = _signal_name($sig)
argstr = sprintf(" Handle_Stop_Signal : %s is sent to the process %s (%d)",sig_name,pid_name,sig_pid);
}
/* probe signal.forcesig
*
* Forces SIGSEV when there are some issues while handling signals for the process.
*
*/
probe signal.forcesig = kernel.function("force_sigsegv")
{
sig_pid = $p->pid
pid_name = kernel_string($p->comm)
sig_info = $sig
sig_name = _signal_name($sig)
argstr = sprintf("Signal < %d > is forced on to the process %s (%d)",sig_name,pid_name,sig_pid);
}
probe signal.forcesig.return = kernel.function("force_sigsegv").return
{
name = "force_sigsegv"
retstr = returnstr(1)
}
/* probe signal.syskill
*
* To kill a process, Pass the pid and signal to kill the process.
*
*/
probe signal.syskill = kernel.function("sys_kill")
{
sig_pid = $pid
sig_info = $sig
argstr = sprintf("Process %d has recieved a Signal %s ",sig_pid,sig_name);
}
probe signal.syskill.return = kernel.function("sys_kill").return
{
name = "sys_kill"
retstr = returnstr(1)
}
/* probe signal.sys_tgkill
*
* Sends a signal to one specific thread.
*
*/
probe signal.systgkill = kernel.function("sys_tgkill")
{
sig_tgid = $tgid
sig_pid = $pid
sig_info = $sig
sig_name = _signal_name($sig)
argstr = sprintf(" Signal %s is sent to Process ID : %d under the Thread Group ID : %d",sig_name,sig_pid,sig_tgid);
}
probe signal.systgkill.return = kernel.function("sys_tgkill").return
{
name = "sys_tgkill"
retstr = returnstr(1)
}
/* probe signal.sys_tkill
*
* Sends a signal to one specific task.
*
*/
probe signal.systkill = kernel.function("sys_tkill")
{
sig_pid = $pid
sig_info = $sig
sig_name = _signal_name($sig)
argstr = sprintf("Signal %s is sent to Process ID : %d ",sig_name,sig_pid);
}
probe signal.systkill.return = kernel.function("sys_tkill").return
{
name = "sys_tkill"
retstr = returnstr(1)
}
/* probe signal.send_sig_queue
*
* Queue signal to a process.
*
*/
probe signal.send_sig_queue =
kernel.function("send_sigqueue"),
kernel.function("send_group_sigqueue")
{
sig_info = $sig
sig_name = _signal_name($sig)
sig_pid = $p->pid
pid_name = kernel_string($p->comm)
user_id = $q->uid
nos_process = $q->processes
nos_pending_sig = $q->sigpending
}
probe signal.send_sig_queue.return =
kernel.function("send_sigqueue").return,
kernel.function("send_group_sigqueue").return
{
retstr = returnstr(1)
}