Scheduler Tapset based on kernel tracepoints

This patch adds kernel tracepoints based probes to the scheduler tapset
along with the testcase, scheduler-test-tracepoints.stp and an example
script, sched_switch.stp.

Signed-off-by: Kiran Prakash <kiran@linux.vnet.ibm.com>
Signed-off-by: Josh Stone <jistone@redhat.com>

1 files changed, 302 insertions, 51 deletions

diff --git a/tapset/scheduler.stp b/tapset/scheduler.stp
index 3c3d504e..b1911ac2 100644
--- a/tapset/scheduler.stp
+++ b/tapset/scheduler.stp
@@ -20,7 +20,7 @@ function __is_idle:long()
 %}
 
 
-/* probe scheduler.cpu_off
+/** probe scheduler.cpu_off
  *
  *  Fires when a process is about to stop running on a cpu.
  *
@@ -41,7 +41,7 @@ probe scheduler.cpu_off
 }
 
 
-/* probe scheduler.cpu_on
+/** probe scheduler.cpu_on
  *
  *  Fires when a process is beginning execution on a cpu.
  *
@@ -76,26 +76,6 @@ probe scheduler.tick = kernel.function("scheduler_tick")
     idle = __is_idle()
 }
 
-
-/* probe scheduler.migrate
- *
- *  Fires whenever a task is moved to a different cpu's runqueue.
- *
- * Context:
- *  Unknown (sometimes migration thread, sometimes cpu_to)
- *
- * Arguments:
- *  task - the process that is being migrated
- *  cpu_from - the cpu that is losing the task
- *  cpu_to - the cpu that is claiming the task
- */
-probe scheduler.migrate = kernel.function("pull_task")? {
-    task = $p
-    cpu_from = task_cpu($p) /*thread_info renamed to stack since 2.6.22*/
-    cpu_to = $this_cpu
-}
-
-
 /* probe scheduler.balance
  *
  *  Fires when a cpu attempts to find more work.
@@ -107,43 +87,314 @@ probe scheduler.migrate = kernel.function("pull_task")? {
 probe scheduler.balance = kernel.function("idle_balance")? {}
 
 
-/* probe scheduler.ctxswitch 
- * 
- *  Fires when there is a context switch
+/** 
+ * probe scheduler.ctxswitch - Fires when there is a context switch. Currently
+ *			       systemTap can't access arguments of inline 
+ *			       functions. So we choose to probe __switch_to instead 
+ *			       of context_switch()       
+ * @prev_pid: The pid of the process to be switched out
+ * @next_pid: The pid of the process to be switched in
+ * @prev_tid: The tid of the process to be switched out
+ * @next_tid: The tid of the process to be switched in	 
+ * @prev_task_name: The name of the process to be switched out
+ * @next_task_name: The name of the process to be switched in
+ * @prev_priority: The priority of the process to be switched out
+ * @next_priority: The priority of the process to be switched in
+ * @prevtsk_state: the state of the process to be switched out
+ * @nexttsk_state: the state of the process to be switched in
+ */
 
- *  Currently systemTap can't access arguments of inline
- *  functions. So we choose to probe __switch_to instead
- *  of context_switch()       
+probe __scheduler.ctxswitch.tp = kernel.trace("sched_switch") 
+{
+	next_pid =  $next->tgid
+	next_tid = $next->pid
+	next_task = $next
+	next_task_name = task_execname($next)
+	nexttsk_state = $next->state
+	next_priority = $next->prio
+	prev_priority = $prev->prio
+	prev_pid = $prev->tgid
+	prev_tid = $prev->pid
+	prev_task	=	$prev
+	prev_task_name	=	task_execname($prev)
+	prevtsk_state = $prev->state
+}
 
- *  Arguments:
- *    prev_pid: The pid of the process to be switched out
- *    next_pid: The pid of the process to be switched in
- *    prevtsk_state: the state of the process to be switched out
- */
-probe scheduler.ctxswitch =
+probe __scheduler.ctxswitch.kp =
 %( arch != "x86_64" && arch != "ia64" %?
-	kernel.trace("sched_switch") !, kernel.function("__switch_to")
+	kernel.function("__switch_to")
 %:
-	kernel.trace("sched_switch") !, kernel.function("context_switch")
+	kernel.function("context_switch")
 %)
 {
 %( arch == "powerpc" %?
-        prev_pid = $prev->pid
-        next_pid =  $new->pid
-        prev_task = $prev
-        next_task = $new
-        prevtsk_state = $prev->state
+	prev_pid = $prev->tgid
+	next_pid = $new->tgid
+	prev_tid = $prev->pid
+	next_tid = $new->pid
+	prev_task = $prev
+	next_task = $new
+	next_priority = $new->prio
+	prev_priority = $prev->prio
+	prev_task_name = task_execname($prev)
+	next_task_name = task_execname($new)
+	prevtsk_state = $prev->state
+	nexttsk_state = $new->state
+
 %: %( arch == "x86_64" || arch == "ia64" %?
-        prev_pid = $prev->pid
-        next_pid =  $next->pid
-        prev_task = $prev
-        next_task = $next
-        prevtsk_state = $prev->state
+	prev_pid = $prev->tgid
+	next_pid = $next->tgid
+	prev_tid = $prev->pid
+	next_tid = $next->pid
+	prev_task = $prev
+	next_task = $next
+	next_priority = $next->prio
+	prev_priority = $prev->prio
+	prev_task_name = task_execname($prev)
+	next_task_name = task_execname($next)
+	prevtsk_state = $prev->state
+	nexttsk_state = $next->state
 %:
-        prev_pid = $prev_p->pid
-        next_pid = $next_p->pid
-        prev_task = $prev_p
-        next_task = $next_p
-        prevtsk_state = $prev_p->state
+	prev_pid = $prev_p->tgid
+	next_pid = $next_p->tgid
+	prev_tid = $prev_p->pid
+	next_tid = $next_p->pid
+	prev_task = $prev_p
+	next_task = $next_p
+	next_priority = $next_p->prio
+	prev_priority = $prev_p->prio
+	prev_task_name = task_execname($prev_p)
+	next_task_name = task_execname($next_p)
+	prevtsk_state = $prev_p->state
+	nexttsk_state = $next_p->state
 %) %)
 }
+
+probe scheduler.ctxswitch
+ = __scheduler.ctxswitch.tp !, __scheduler.ctxswitch.kp
+{}
+
+
+/**
+ * probe scheduler.kthread_stop - Fires when a thread created by kthread_create is stopped.
+ * @thread_pid: pid of the thread being stopped.
+ * @thread_priority: priority of the thread.
+ */
+probe __scheduler.kthread_stop.kp = kernel.function("kthread_stop")
+{
+	thread_pid = $k->tgid
+	thread_priority = $k->priority
+}
+probe __scheduler.kthread_stop.tp = kernel.trace("sched_kthread_stop") 
+{
+	thread_pid = $t->tgid
+	thread_priority = $t->prio
+}
+probe scheduler.kthread_stop 
+   = __scheduler.kthread_stop.tp !,
+     __scheduler.kthread_stop.kp
+{}
+
+
+/**
+ * probe scheduler.kthread_stop.return - Fires once the kthread is stopped and gets the return value
+ * @return_value: return value after stopping the thread.
+ */
+
+probe __scheduler.kthread_stop.return.kp = kernel.function("kthread_stop").return
+{
+	return_value = $k->exit_code
+}
+probe __scheduler.kthread_stop.return.tp = kernel.trace("sched_kthread_stop_ret")
+{
+	return_value = $ret
+}
+
+probe scheduler.kthread_stop.return 
+ = __scheduler.kthread_stop.return.tp !,
+   __scheduler.kthread_stop.return.kp
+{}
+
+/**
+ * probe scheduler.wait_task - Fires when waiting on a task to unschedule. 
+ *                             It waits till the task becomes inactive.
+ * @task_pid: pid of the task the scheduler is waiting on.
+ * @task_priority: priority of the task
+ */
+
+probe scheduler.wait_task
+ = kernel.trace("sched_wait_task") !,
+   kernel.function("wait_task_inactive")
+{
+	task_pid = $p->tgid
+	task_priority = $p->prio
+}
+
+/**
+ * probe scheduler.wakeup - Fires when a task is woken up 
+ * @task_pid: pid of the task being woken up
+ * @task_priority: priority of the task being woken up
+ * @task_cpu: cpu of the task being woken up
+ * @task_state: state of the task being woken up
+ * @task_tid: tid of the task being woken up
+ */
+
+probe scheduler.wakeup
+ = kernel.trace("sched_wakeup") !,
+   kernel.function("try_to_wake_up")
+{
+	task = $p
+	task_pid = $p->tgid
+	task_tid = $p->pid
+	task_priority = $p->prio
+	task_cpu = task_cpu($p)
+	task_state = task_state($p)
+}
+
+/**
+ * probe scheduler.wakeup_new - Fires when a newly created task is woken up for the first time
+ * @task_pid: pid of the new task woken up
+ * @task_priority: priority of the new task
+ * @task_tid: tid of the new task woken up
+ * @task_state: state of the task woken up
+ * @task_cpu: cpu of the task woken up
+ */
+probe scheduler.wakeup_new
+ = kernel.trace("sched_wakeup_new") !,
+   kernel.function("wake_up_new_task")
+{
+	task_pid = $p->tgid
+	task_priority = $p->prio
+	task_cpu = task_cpu($p)
+	task_state = task_state($p)
+	task = $p
+	task_tid = $p->pid
+}
+
+/**
+ * probe scheduler.migrate - Traces the migration of the tasks across cpus by the scheduler.
+ * @task: the process that is being migrated.
+ * @pid: pid of the task being migrated.
+ * @priority: priority of the task being migrated.
+ * @cpu_from: the original cpu
+ * @cpu_to: the destination cpu
+ */
+probe __scheduler.migrate.kp1 = kernel.function("pull_task")
+{
+	cpu_to = $this_cpu
+}
+probe __scheduler.migrate.kp = kernel.function("set_task_cpu")
+{
+	cpu_to = $new_cpu
+}
+probe __scheduler.migrate.tp = kernel.trace("sched_migrate_task")
+{
+	cpu_to = $dest_cpu
+}
+probe scheduler.migrate
+ = __scheduler.migrate.tp !,
+   __scheduler.migrate.kp !,
+   __scheduler.migrate.kp1
+{
+	task = $p
+	pid = $p->tgid
+	priority = $p->prio
+	cpu_from = task_cpu($p)
+}
+/**
+ * probe scheduler.process_free - Traces the process of freeing up of a process
+ * @pid: PID of the process getting freed
+ * @priority: priority of the process getting freed
+ */
+probe __scheduler.process_free.kp = kernel.function("delayed_put_task_struct")
+{
+	pid = $tsk->tgid
+	priority = $tsk->prio
+}
+probe __scheduler.process_free.tp = kernel.trace("sched_process_free")
+{
+	pid = $p->tgid
+	priority = $p->prio
+}
+probe scheduler.process_free
+ = __scheduler.process_free.tp !,
+   __scheduler.process_free.kp
+{}
+
+/**
+ * probe scheduler.process_exit - Fires when a process exits
+ * @pid: pid of the process exiting
+ * @priority: priority of the process exiting
+ */
+probe __scheduler.process_exit.kp = kernel.function("do_exit")
+{
+	pid = $tsk->tgid
+	priority = $tsk->priority
+}
+probe __scheduler.process_exit.tp = kernel.trace("sched_process_exit")
+{
+	pid = $p->tgid
+	priority = $p->prio
+}
+
+probe scheduler.process_exit 
+ = __scheduler.process_exit.tp !,
+   __scheduler.process_exit.kp
+{}
+
+/**
+ * probe scheduler.process_wait - Fires when scheduler waits on a process
+ * @pid: PID of the process scheduler is waiting on
+ */
+probe __scheduler.process_wait.kp = kernel.function("do_wait")
+{
+	pid = $wo->wo_pid
+}
+probe __scheduler.process_wait.tp = kernel.trace("sched_process_wait")
+{
+	pid = $pid
+}
+probe scheduler.process_wait
+ = __scheduler.process_wait.tp !,
+   __scheduler.process_wait.kp
+{}
+
+/**
+ * probe scheduler.process_fork - Probes the tracepoint for forking a process
+ * @parent_pid: PID of the parent process
+ * @child_pid: PID of the child process
+ */
+probe __scheduler.process_fork.kp = kernel.function("do_fork")
+{
+	parent_pid = $current->tgid
+	child_pid = $p->tgid
+}
+probe __scheduler.process_fork.tp = kernel.trace("sched_process_fork")
+{
+	parent_pid = $parent->tgid
+	child_pid = $child->tgid
+}
+
+probe scheduler.process_fork
+ = __scheduler.process_fork.tp !,
+   __scheduler.process_fork.kp
+{}
+/**
+ * probe scheduler.signal_send - Probes the tracepoint for sending a signal
+ * @pid: pid of the process sending signal
+ * @signal_number: signal number
+ */
+probe __scheduler.signal_send.kp = kernel.function("__send_signal")
+{
+	pid = $t->tgid
+}
+probe __scheduler.signal_send.tp = kernel.trace("sched_signal_send")
+{
+	pid = $p->tgid
+}
+probe scheduler.signal_send
+ = __scheduler.signal_send.tp !,
+   __scheduler.signal_send.kp
+{
+	signal_number = $sig
+}