Merge lp:~f-turgis/ubuntu/natty/systemtap/systemtap.2.6.38 into lp:ubuntu/natty/systemtap

[Frederic Turgis]

Backporting of Redhat patches to get systemtap working on 2.6.38 (Redhat has currently ported to 2.6.37 but fixing 2.6.38 issues mentioned to them). Patches identified by running systemtap testsuite

=== added directory '.pc/01-Add-irq.stp-to-Tapset-Reference-manual.patch'
=== added directory '.pc/01-Add-irq.stp-to-Tapset-Reference-manual.patch/doc'
=== added directory '.pc/01-Add-irq.stp-to-Tapset-Reference-manual.patch/doc/SystemTap_Tapset_Reference'
=== added file '.pc/01-Add-irq.stp-to-Tapset-Reference-manual.patch/doc/SystemTap_Tapset_Reference/tapsets.tmpl'
--- .pc/01-Add-irq.stp-to-Tapset-Reference-manual.patch/doc/SystemTap_Tapset_Reference/tapsets.tmpl	1970-01-01 00:00:00 +0000
+++ .pc/01-Add-irq.stp-to-Tapset-Reference-manual.patch/doc/SystemTap_Tapset_Reference/tapsets.tmpl	2011-03-22 12:11:00 +0000
@@ -0,0 +1,286 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.1.2//EN"
+	"http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd" []>
+
+<book id="TapsetRef">
+ <bookinfo>
+  <title>SystemTap Tapset Reference Manual</title>
+<!--starthere-->
+  <copyright>
+   <year>2008-2009</year>
+   <holder>Red Hat, Inc. and others</holder>
+  </copyright>
+
+  <authorgroup>
+   <author>
+    <othername>SystemTap</othername>
+    <contrib>Hackers</contrib>
+   </author>
+  </authorgroup>
+
+
+  <legalnotice>
+   <para>
+     This documentation is free software; you can redistribute
+     it and/or modify it under the terms of the GNU General Public
+     License version 2 as published by the Free Software Foundation.
+   </para>
+      
+   <para>
+     This program is distributed in the hope that it will be
+     useful, but WITHOUT ANY WARRANTY; without even the implied
+     warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+     See the GNU General Public License for more details.
+   </para>
+      
+   <para>
+     You should have received a copy of the GNU General Public
+     License along with this program; if not, write to the Free
+     Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+     MA 02111-1307 USA
+   </para>
+      
+   <para>
+     For more details see the file COPYING in the source
+     distribution of Linux.
+   </para>
+  </legalnotice>
+ </bookinfo>
+<!-- pls dont remove marker comments, as they are used in publican conversion-->
+<toc></toc>
+<chapter id="introduction">
+  <title>Introduction</title>
+  <para>
+    SystemTap provides free software (GPL) infrastructure to simplify the
+    gathering of information about the running Linux system. This assists
+    diagnosis of a performance or functional problem. SystemTap eliminates the
+    need for the developer to go through the tedious and disruptive instrument,
+    recompile, install, and reboot sequence that may be otherwise required to
+    collect data.
+  </para>
+
+  <para>
+    SystemTap provides a simple command line interface and scripting language
+    for writing instrumentation for a live running kernel. The instrumentation
+    makes extensive use of the probe points and functions provided in the
+    <firstterm>tapset</firstterm> library. This document describes the various
+    probe points and functions.
+  </para>
+  
+    <section id="format">
+      <title>Tapset Name Format</title>
+	
+      <para>In this guide, tapset definitions appear in the following format:</para>
+
+      <screen>
+	name:return (parameters)
+	definition
+      </screen>
+	
+      <para>
+	The <replaceable>return</replaceable> field specifies what data type the
+	tapset extracts and returns from the kernel during a probe (and thus,
+	returns).  Tapsets use 2 data types for
+	<replaceable>return</replaceable>: <literal>long</literal> (tapset
+	extracts and returns an integer) and <literal>string</literal> (tapset
+	extracts and returns a string).
+      </para>
+
+      <para>
+	In some cases, tapsets do not have a <replaceable>return</replaceable>
+	value. This simply means that the tapset does not extract anything from
+	the kernel.  This is common among asynchronous events such as timers,
+	exit functions, and print functions.
+      </para>
+<!--
+<varlistentry>
+<term></term>
+<listitem>
+	<para></para>
+</listitem>
+</varlistentry>
+-->
+
+    </section>
+  
+  </chapter>
+<!--endhere-->
+<!--markerforxi-->
+<!-- pls dont remove marker comments, as they are used in publican conversion-->
+  <chapter id="context_stp">
+    <title>Context Functions</title>
+    <para>
+      The context functions provide additional information about where
+      an event occurred.
+      These functions can provide information such as a backtrace to 
+      where the event occurred
+      and the current register values for the processor.
+    </para>
+!Itapset/context.stp
+!Itapset/context-symbols.stp
+!Itapset/ucontext-symbols.stp
+!Itapset/context-unwind.stp
+!Itapset/ucontext-unwind.stp
+!Itapset/task.stp
+!Itapset/pn.stp
+  </chapter>
+
+  <chapter id="timestamp_stp">
+    <title>Timestamp Functions</title>
+    <para>
+      Each timestamp function returns a value to indicate when
+      a function is executed.
+      These returned values can then be used to indicate
+      when an event occurred, provide an ordering for events, or compute
+      the amount of time elapsed between two time stamps.
+    </para>
+!Itapset/timestamp.stp
+!Itapset/timestamp_gtod.stp
+  </chapter>
+
+  <chapter id="ctime.stp">
+    <title>Time string utility function</title>
+    <para>
+      Utility function to turn seconds since the epoch (as returned by
+      the timestamp function gettimeofday_s()) into a human readable
+      date/time string.
+    </para>
+!Itapset/ctime.stp
+  </chapter>
+
+  <chapter id="memory_stp">
+    <title>Memory Tapset</title>
+ <para>
+      This family of probe points is used to probe memory-related events
+      or query the memory usage of the current process.
+      It contains the following probe points:
+    </para>
+!Itapset/memory.stp
+!Itapset/proc_mem.stp
+  </chapter>
+
+  <chapter id="task_time_stp">
+    <title>Task Time Tapset</title>
+    <para>
+      This tapset defines utility functions to query time related
+      properties of the current tasks, translate those in miliseconds
+      and human readable strings.
+    </para>
+!Itapset/task_time.stp
+  </chapter>
+
+  <chapter id="iosched.stp">
+    <title>IO Scheduler and block IO Tapset</title>
+    <para>
+      This family of probe points is used to probe block IO layer and IO scheduler activities.
+      It contains the following probe points:
+    </para>
+!Itapset/ioscheduler.stp
+!Itapset/ioblock.stp
+  </chapter>
+
+  <chapter id="scsi.stp">
+    <title>SCSI Tapset</title>
+    <para>
+      This family of probe points is used to probe SCSI activities.  
+      It contains the following probe points:
+    </para>
+!Itapset/scsi.stp
+  </chapter>
+
+  <chapter id="tty.stp">
+    <title>TTY Tapset</title>
+    <para>
+      This family of probe points is used to probe TTY (Teletype) activities.
+      It contains the following probe points:
+    </para>
+!Itapset/tty.stp
+  </chapter>
+
+  <chapter id="networking.stp">
+    <title>Networking Tapset</title>
+    <para>
+      This family of probe points is used to probe the activities of
+      the network device and protocol layers.
+    </para>
+!Itapset/networking.stp
+!Itapset/tcp.stp
+!Itapset/udp.stp
+!Itapset/ip.stp
+  </chapter>
+
+  <chapter id="socket.stp">
+    <title>Socket Tapset</title>
+    <para>
+      This family of probe points is used to probe socket activities.
+      It contains the following probe points:
+   </para>
+!Itapset/socket.stp
+  </chapter>
+  <chapter id="kprocess.stp">
+    <title>Kernel Process Tapset</title>
+    <para>
+      This family of probe points is used to probe process-related activities.
+      It contains the following probe points:
+    </para>
+!Itapset/kprocess.stp
+  </chapter>
+  <chapter id="signal.stp">
+    <title>Signal Tapset</title>
+    <para>
+      This family of probe points is used to probe signal activities.
+      It contains the following probe points:
+    </para>
+!Itapset/signal.stp
+  </chapter>
+  <chapter id="dentry.stp">
+    <title>Directory-entry (dentry) Tapset</title>
+    <para>
+      This family of functions is used to map kernel VFS
+      directory entry pointers to file or full path names.
+    </para>
+!Itapset/dentry.stp
+    </chapter>
+  <chapter id="logging.stp">
+    <title>Logging Tapset</title>
+    <para>
+      This family of functions is used to send simple
+      message strings to various destinations.
+    </para>
+!Itapset/logging.stp
+    </chapter>
+  <chapter id="random.stp">
+    <title>Random functions Tapset</title>
+    <para>
+      These functions deal with random number generation.
+    </para>
+!Itapset/random.stp
+    </chapter>
+  <chapter id="conversions.stp">
+    <title>String and data retrieving functions Tapset</title>
+    <para>
+      Functions to retrieve strings and other primitive types from
+      the kernel or a user space programs based on addresses. All
+      strings are of a maximum length given by MAXSTRINGLEN.
+    </para>
+!Itapset/conversions.stp
+    </chapter>
+  <chapter id="string.stp">
+    <title>A collection of standard string functions</title>
+    <para>
+      Functions to get the length, a substring, getting at individual
+      characters, string seaching, escaping, tokenizing, and converting
+      strings to longs.
+    </para>
+!Itapset/string.stp
+    </chapter>
+  <chapter id="ansi.stp">
+    <title>Utility functions for using ansi control chars in logs</title>
+    <para>
+      Utility functions for logging using ansi control characters. This
+      lets you manipulate the cursor position and character color output
+      and attributes of log messages.
+    </para>
+!Itapset/ansi.stp
+    </chapter>
+</book>

=== added directory '.pc/01-Add-irq.stp-to-Tapset-Reference-manual.patch/tapset'
=== added file '.pc/01-Add-irq.stp-to-Tapset-Reference-manual.patch/tapset/irq.stp'
--- .pc/01-Add-irq.stp-to-Tapset-Reference-manual.patch/tapset/irq.stp	1970-01-01 00:00:00 +0000
+++ .pc/01-Add-irq.stp-to-Tapset-Reference-manual.patch/tapset/irq.stp	2011-03-22 12:11:00 +0000
@@ -0,0 +1,172 @@
+/*
+ *      Copyright (C) 2009 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.
+ *
+ *      Version 1.0     [e-mail]     2009-10-28
+ *
+ * Tracepoint based tapset for IRQs, Workqueues, etc
+ *
+ */
+// Probes for workqueues.
+
+/**
+ * probe workqueue.create : probes creation of a new workqueue
+ * @wq_thread : task_struct of the workqueue thread.
+ * @cpu	  : cpu for which the worker thread is created.
+ */
+probe workqueue.create = kernel.trace("workqueue_creation") ?
+{
+	wq_thread = $wq_thread
+	cpu = $cpu
+}
+
+/**
+ * probe workqueue.insert : probes queuing of work on a workqueue
+ * @wq_thread : task_struct of the workqueue thread.
+ * @work : work_struct* being queued.
+ * @work_func :	pointer to handler func.
+ */
+probe workqueue.insert = kernel.trace("workqueue_insertion") ?
+{
+	wq_thread = $wq_thread
+	work = $work
+	work_func = $work->func
+}
+
+/**
+ * probe workqueue.execute : probes execution of deferred work.
+ * @wq_thread :	task_struct of the workqueue thread.
+ * @work : work_struct* being executed.
+ * @work_func :	pointer to handler func.
+ */
+probe workqueue.execute = kernel.trace("workqueue_execution") ?
+{
+	wq_thread = $wq_thread
+	work = $work
+	work_func = $work->func
+}
+
+/**
+ * probe workqueue.destroy : probes destruction of each worker thread of each cpu for a workqueue.
+ * @wq_thread : task_struct of the workqueue thread.
+ */
+probe workqueue.destroy = kernel.trace("workqueue_destruction") ?
+{
+	wq_thread = $wq_thread
+}
+
+// Probes for IRQ handlers.
+
+/**
+ * probe irq_handler.entry : Fires prior to execution of interrupt handler.
+ * @irq	: irq number.
+ * @action : struct irqaction* for this interrupt num.
+ * @handler : interrupt handler function.
+ * @flags : Flags for IRQ handler
+ *			IRQF_DISABLED [0x00000020]	: keep irqs disabled when calling action handler.
+ *			IRQF_SAMPLE_RANDOM [0x00000040]	: irq is used to feed the random generator
+ *			IRQF_SHARED [0x00000080]	: allow sharing the irq among several devices
+ *			IRQF_PROBE_SHARED [0x00000100]	: set by callers when they expect sharing mismatches to occur
+ *			IRQF_TIMER [0x00000200]		: Flag to mark this interrupt as timer interrupt
+ *			IRQF_PERCPU [0x00000400]	: Interrupt is per cpu.
+ *			IRQF_NOBALANCING [0x00000800]	: Flag to exclude this interrupt from irq balancing
+ *			IRQF_IRQPOLL [0x00001000]	: Interrupt is used for polling.
+ *			IRQF_ONESHOT [0x00002000]	: Interrupt is not reenabled after the hardirq handler finished.
+ * @flags_str : symbolic string representation of IRQ flags.
+ * @dev_name : name of device.
+ * @dev_id : Cookie to identify device.
+ * @next_irqaction : pointer to next irqaction for shared interrupts.
+ * @dir	: pointer to the proc/irq/NN/name entry
+ * @thread_fn : interupt handler function for threaded interrupts.
+ * @thread : thread pointer for threaded interrupts.
+ * @thread_flags : Flags related to thread.
+ */
+probe irq_handler.entry = kernel.trace("irq_handler_entry") ?
+{
+	irq = $irq
+	action = $action
+	handler = $action->handler
+	flags = $action->flags
+	flags_str = irqflags_str(flags)
+	dev_name = $action->name
+	dev_id = $action->dev_id
+	next_irqaction = $action->next
+	dir = $action->dir
+	thread_fn = $action->thread_fn
+	thread = $action->thread
+	thread_flags = $action->thread_flags
+}
+
+/**
+ * probe irq_handler.exit : Fires just after execution of interrupt handler.
+ * @irq : interrupt number
+ * @action : struct irqaction*
+ * @ret	: return value of the handler
+ * @handler : interrupt handler function that was executed.
+ * @flags : flags for IRQ handler
+ *			IRQF_DISABLED	[0x00000020]	: keep irqs disabled when calling action handler.
+ *			IRQF_SAMPLE_RANDOM [0x00000040]	: irq is used to feed the random generator
+ *			IRQF_SHARED [0x00000080]	: allow sharing the irq among several devices
+ *			IRQF_PROBE_SHARED [0x00000100]	: set by callers when they expect sharing mismatches to occur
+ *			IRQF_TIMER [0x00000200]		: Flag to mark this interrupt as timer interrupt
+ *			IRQF_PERCPU [0x00000400]	: Interrupt is per cpu.
+ *			IRQF_NOBALANCING [0x00000800]	: Flag to exclude this interrupt from irq balancing
+ *			IRQF_IRQPOLL [0x00001000]	: Interrupt is used for polling.
+ *			IRQF_ONESHOT [0x00002000]	: Interrupt is not reenabled after the hardirq handler finished.
+ * @flags_str : symbolic string representation of IRQ flags.
+ * @dev_name : name of device.
+ * @dev_id : Cookie to identify device.
+ * @next_irqaction : pointer to next irqaction for shared interrupts.
+ * @dir	: pointer to the proc/irq/NN/name entry
+ * @thread_fn : interupt handler function for threaded interrupts.
+ * @thread : thread pointer for threaded interrupts.
+ * @thread_flags : Flags related to thread.
+ */
+probe irq_handler.exit = kernel.trace("irq_handler_exit") ?
+{
+	irq = $irq
+	action = $action
+	ret = $ret
+	handler = $action->handler
+	flags = $action->flags
+	flags_str = irqflags_str(flags)
+	dev_name = $action->name
+	dev_id = $action->dev_id
+	next_irqaction = $action->next
+	dir = $action->dir
+	thread_fn = $action->thread_fn
+	thread = $action->thread
+	thread_flags = $action->thread_flags
+}
+
+// Softirq based probes.
+/**
+ * probe softirq.entry 	: triggered just before executing handler
+ *			  for a pending softirq.
+ * @h : struct softirq_action* for current pending softirq.
+ * @vec	: softirq_action vector.
+ * @action : pointer to softirq handler just about to execute.
+ */
+probe softirq.entry = kernel.trace("softirq_entry") ?
+{
+	h = $h
+	vec = $vec
+	action = $h->action
+}
+
+/**
+ * probe softirq.exit 	: triggered just after executing handler for a pending
+ *			  softirq.
+ * @h : struct softirq_action* for just executed softirq.
+ * @vec	: softirq_action vector.
+ * @action : pointer to softirq handler that just finished execution.
+ */
+probe softirq.exit = kernel.trace("softirq_exit") ?
+{
+	h = $h
+	vec = $vec
+	action = $h->action
+}

=== added directory '.pc/02-Fixed-PR12338-by-updating-softirq.entry-softirq.exit.patch'
=== added directory '.pc/02-Fixed-PR12338-by-updating-softirq.entry-softirq.exit.patch/tapset'
=== added file '.pc/02-Fixed-PR12338-by-updating-softirq.entry-softirq.exit.patch/tapset/irq.stp'
--- .pc/02-Fixed-PR12338-by-updating-softirq.entry-softirq.exit.patch/tapset/irq.stp	1970-01-01 00:00:00 +0000
+++ .pc/02-Fixed-PR12338-by-updating-softirq.entry-softirq.exit.patch/tapset/irq.stp	2011-03-22 12:11:00 +0000
@@ -0,0 +1,152 @@
+/*
+ *      Copyright (C) 2009 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.
+ *
+ *      Version 1.0     [e-mail]     2009-10-28
+ *
+ * Tracepoint based tapset for IRQs, Workqueues, etc
+ *
+ */
+// Probes for workqueues.
+
+/**
+ * probe workqueue.create - Creating a new workqueue
+ * @wq_thread: task_struct of the workqueue thread
+ * @cpu: cpu for which the worker thread is created
+ */
+probe workqueue.create = kernel.trace("workqueue_creation") ?
+{
+	wq_thread = $wq_thread
+	cpu = $cpu
+}
+
+/**
+ * probe workqueue.insert - Queuing work on a workqueue
+ * @wq_thread: task_struct of the workqueue thread
+ * @work: work_struct* being queued
+ * @work_func: pointer to handler function
+ */
+probe workqueue.insert = kernel.trace("workqueue_insertion") ?
+{
+	wq_thread = $wq_thread
+	work = $work
+	work_func = $work->func
+}
+
+/**
+ * probe workqueue.execute - Executing deferred work
+ * @wq_thread:	task_struct of the workqueue thread
+ * @work: work_struct* being executed
+ * @work_func:	pointer to handler function
+ */
+probe workqueue.execute = kernel.trace("workqueue_execution") ?
+{
+	wq_thread = $wq_thread
+	work = $work
+	work_func = $work->func
+}
+
+/**
+ * probe workqueue.destroy - Destroying workqueue
+ * @wq_thread: task_struct of the workqueue thread
+ */
+probe workqueue.destroy = kernel.trace("workqueue_destruction") ?
+{
+	wq_thread = $wq_thread
+}
+
+// Probes for IRQ handlers.
+
+/**
+ * probe irq_handler.entry - Execution of interrupt handler starting
+ * @irq: irq number
+ * @action: struct irqaction* for this interrupt num
+ * @handler: interrupt handler function
+ * @flags: Flags for IRQ handler
+ * @flags_str: symbolic string representation of IRQ flags
+ * @dev_name: name of device
+ * @dev_id: Cookie to identify device
+ * @next_irqaction: pointer to next irqaction for shared interrupts
+ * @dir: pointer to the proc/irq/NN/name entry
+ * @thread_fn: interrupt handler function for threaded interrupts
+ * @thread: thread pointer for threaded interrupts
+ * @thread_flags: Flags related to thread
+ */
+probe irq_handler.entry = kernel.trace("irq_handler_entry") ?
+{
+	irq = $irq
+	action = $action
+	handler = $action->handler
+	flags = $action->flags
+	flags_str = irqflags_str(flags)
+	dev_name = $action->name
+	dev_id = $action->dev_id
+	next_irqaction = $action->next
+	dir = $action->dir
+	thread_fn = $action->thread_fn
+	thread = $action->thread
+	thread_flags = $action->thread_flags
+}
+
+/**
+ * probe irq_handler.exit - Execution of interrupt handler completed
+ * @irq: interrupt number
+ * @action: struct irqaction*
+ * @ret: return value of the handler
+ * @handler: interrupt handler function that was executed
+ * @flags: flags for IRQ handler
+ * @flags_str: symbolic string representation of IRQ flags
+ * @dev_name: name of device
+ * @dev_id: Cookie to identify device
+ * @next_irqaction: pointer to next irqaction for shared interrupts
+ * @dir: pointer to the proc/irq/NN/name entry
+ * @thread_fn: interrupt handler function for threaded interrupts
+ * @thread: thread pointer for threaded interrupts
+ * @thread_flags: Flags related to thread
+ */
+probe irq_handler.exit = kernel.trace("irq_handler_exit") ?
+{
+	irq = $irq
+	action = $action
+	ret = $ret
+	handler = $action->handler
+	flags = $action->flags
+	flags_str = irqflags_str(flags)
+	dev_name = $action->name
+	dev_id = $action->dev_id
+	next_irqaction = $action->next
+	dir = $action->dir
+	thread_fn = $action->thread_fn
+	thread = $action->thread
+	thread_flags = $action->thread_flags
+}
+
+// Softirq based probes.
+/**
+ * probe softirq.entry - Execution of handler for a pending softirq starting
+ * @h: struct softirq_action* for current pending softirq
+ * @vec: softirq_action vector
+ * @action: pointer to softirq handler just about to execute
+ */
+probe softirq.entry = kernel.trace("softirq_entry") ?
+{
+	h = $h
+	vec = $vec
+	action = $h->action
+}
+
+/**
+ * probe softirq.exit - Execution of handler for a pending softirq completed
+ * @h: struct softirq_action* for just executed softirq
+ * @vec: softirq_action vector
+ * @action: pointer to softirq handler that just finished execution
+ */
+probe softirq.exit = kernel.trace("softirq_exit") ?
+{
+	h = $h
+	vec = $vec
+	action = $h->action
+}

=== added directory '.pc/02-Fixed-PR12338-by-updating-softirq.entry-softirq.exit.patch/testsuite'
=== added directory '.pc/02-Fixed-PR12338-by-updating-softirq.entry-softirq.exit.patch/testsuite/buildok'
=== added file '.pc/02-Fixed-PR12338-by-updating-softirq.entry-softirq.exit.patch/testsuite/buildok/irq-detailed.stp'
--- .pc/02-Fixed-PR12338-by-updating-softirq.entry-softirq.exit.patch/testsuite/buildok/irq-detailed.stp	1970-01-01 00:00:00 +0000
+++ .pc/02-Fixed-PR12338-by-updating-softirq.entry-softirq.exit.patch/testsuite/buildok/irq-detailed.stp	2011-03-22 12:11:00 +0000
@@ -0,0 +1,46 @@
+#! stap -p4
+
+#
+# workqueue probes
+#
+
+probe workqueue.create ?
+{
+	printf("%p %d\n", wq_thread, cpu)
+}
+
+probe workqueue.insert ?, workqueue.execute ?
+{
+	printf("%p %p %p\n", wq_thread, work, work_func)
+}
+
+probe workqueue.destroy ?
+{
+	printf("%p\n", wq_thread)
+}
+
+#
+# irq_handler probes
+#
+
+probe irq_handler.entry ?, irq_handler.exit ?
+{
+	printf("%d %p %p %d(%s)\n", irq, action, handler, flags, flags_str)
+	printf("%d %d %p %p\n", dev_name, dev_id, next_irqaction, dir)
+	printf("%p %p %d\n", thread_fn, thread, thread_flags)
+}
+
+#
+# softirq probes
+#
+
+probe softirq.entry ?, softirq.exit ?
+{
+	printf("%p %p %p\n", h, vec, action)
+}
+
+# Make sure we've got at least one probe.
+probe never
+{
+	printf("never\n")
+}

=== added directory '.pc/Fix-for-undefined-STAPCONF_PERF_STRUCTPID.patch'
=== added directory '.pc/Fix-for-undefined-STAPCONF_PERF_STRUCTPID.patch/runtime'
=== added file '.pc/Fix-for-undefined-STAPCONF_PERF_STRUCTPID.patch/runtime/perf.c'
--- .pc/Fix-for-undefined-STAPCONF_PERF_STRUCTPID.patch/runtime/perf.c	1970-01-01 00:00:00 +0000
+++ .pc/Fix-for-undefined-STAPCONF_PERF_STRUCTPID.patch/runtime/perf.c	2011-03-22 12:11:00 +0000
@@ -0,0 +1,86 @@
+/* -*- linux-c -*- 
+ * Perf Functions
+ * Copyright (C) 2006 Red Hat Inc.
+ * Copyright (C) 2010 Red Hat Inc.
+ *
+ * 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.
+ */
+
+#ifndef _PERF_C_
+#define _PERF_C_
+
+#include <linux/perf_event.h>
+
+#include "perf.h"
+
+/** @file perf.c
+ * @brief Implements performance monitoring hardware support
+ */
+
+/** Initialize performance sampling
+ * Call this during probe initialization to set up performance event sampling
+ * for all online cpus.  Returns non-zero on error.
+ *
+ * @param stp Handle for the event to be registered.
+ */
+static long _stp_perf_init (struct stap_perf_probe *stp)
+{
+	int cpu;
+
+	/* allocate space for the event descriptor for each cpu */
+	stp->events = _stp_alloc_percpu (sizeof(struct perf_event*));
+	if (stp->events == NULL) {
+		return -ENOMEM;
+	}
+
+	/* initialize event on each processor */
+	stp_for_each_cpu(cpu) {
+		struct perf_event **event = per_cpu_ptr (stp->events, cpu);
+		if (cpu_is_offline(cpu)) {
+			*event = NULL;
+			continue;
+		}
+		*event = perf_event_create_kernel_counter(&stp->attr,
+							  cpu,
+#if STAPCONF_PERF_STRUCTPID
+                                                          NULL,
+#else
+                                                          -1,
+#endif
+							  stp->callback);
+
+		if (IS_ERR(*event)) {
+			long rc = PTR_ERR(*event);
+			*event = NULL;
+			_stp_perf_del(stp);
+			return rc;
+		}
+	}
+	return 0;
+}
+
+/** Delete performance event.
+ * Call this to shutdown performance event sampling
+ *
+ * @param stp Handle for the event to be unregistered.
+ */
+static void _stp_perf_del (struct stap_perf_probe *stp)
+{
+	if (stp && stp->events) {
+		int cpu;
+		/* shut down performance event sampling */
+		stp_for_each_cpu(cpu) {
+			struct perf_event **event = per_cpu_ptr (stp->events, cpu);
+			if (*event) {
+				perf_event_release_kernel(*event);
+			}
+		}
+		_stp_free_percpu (stp->events);
+		stp->events = NULL;
+	}
+}
+
+#endif /* _PERF_C_ */

=== added directory '.pc/Fixed-PR11940-by-getting-scripts-w-global-variables-.patch'
=== added directory '.pc/Fixed-PR11940-by-getting-scripts-w-global-variables-.patch/runtime'
=== added file '.pc/Fixed-PR11940-by-getting-scripts-w-global-variables-.patch/runtime/runtime.h'
--- .pc/Fixed-PR11940-by-getting-scripts-w-global-variables-.patch/runtime/runtime.h	1970-01-01 00:00:00 +0000
+++ .pc/Fixed-PR11940-by-getting-scripts-w-global-variables-.patch/runtime/runtime.h	2011-03-22 12:11:00 +0000
@@ -0,0 +1,204 @@
+/* main header file
+ * Copyright (C) 2005-2008 Red Hat Inc.
+ * Copyright (C) 2005, 2006 Intel Corporation.
+ *
+ * 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.
+ */
+
+#ifndef _RUNTIME_H_
+#define _RUNTIME_H_
+
+#include <linux/module.h>
+#include <linux/ctype.h>
+#include <linux/kernel.h>
+#include <linux/miscdevice.h>
+#include <linux/init.h>
+#include <linux/hash.h>
+#include <linux/string.h>
+#include <linux/kprobes.h>
+#include <linux/proc_fs.h>
+#include <linux/vmalloc.h>
+#include <linux/time.h>
+#include <linux/spinlock.h>
+#include <linux/hardirq.h>
+#include <asm/uaccess.h>
+#include <linux/kallsyms.h>
+#include <linux/version.h>
+#include <linux/compat.h>
+#include <linux/sched.h>
+#include <linux/mm.h>
+
+
+#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15)
+#if !defined (CONFIG_DEBUG_FS)  && !defined (CONFIG_DEBUG_FS_MODULE)
+#error "DebugFS is required and was not found in the kernel."
+#endif
+#ifdef CONFIG_RING_BUFFER
+#define STP_TRANSPORT_VERSION 3
+#else
+#define STP_TRANSPORT_VERSION 2
+#endif
+#else
+/* older kernels have no debugfs and older version of relayfs. */
+#define STP_TRANSPORT_VERSION 1
+#endif
+
+#ifndef stp_for_each_cpu
+#define stp_for_each_cpu(cpu)  for_each_cpu_mask((cpu), cpu_possible_map)
+#endif
+
+#ifndef clamp
+#define clamp(val, low, high)     min(max(low, val), high)
+#endif
+
+#ifndef clamp_t
+#define clamp_t(type, val, low, high)   min_t(type, max_t(type, low, val), high)
+#endif
+
+static void _stp_dbug (const char *func, int line, const char *fmt, ...) __attribute__ ((format (printf, 3, 4)));
+static void _stp_error (const char *fmt, ...) __attribute__ ((format (printf, 1, 2)));
+static void _stp_warn (const char *fmt, ...) __attribute__ ((format (printf, 1, 2)));
+
+static void _stp_exit(void);
+
+
+
+/* unprivileged user support */
+
+#ifdef STAPCONF_TASK_UID
+#define STP_CURRENT_EUID (current->euid)
+#else
+#define STP_CURRENT_EUID (task_euid(current))
+#endif
+
+#define is_myproc() (STP_CURRENT_EUID == _stp_uid)
+
+#ifndef STP_PRIVILEGED
+#define assert_is_myproc() do { \
+  if (! is_myproc()) { \
+    snprintf (CONTEXT->error_buffer, MAXSTRINGLEN, "semi-privileged tapset function called without is_myproc checking for pid %d (euid %d)", \
+             current->tgid, STP_CURRENT_EUID); \
+    CONTEXT->last_error = CONTEXT->error_buffer; \
+    goto out; \
+  } } while (0)
+#else
+#define assert_is_myproc() do {} while (0)
+#endif
+
+
+
+#include "debug.h"
+
+/* atomic globals */
+static atomic_t _stp_transport_failures = ATOMIC_INIT (0);
+
+static struct
+{
+	atomic_t ____cacheline_aligned_in_smp seq;
+} _stp_seq = { ATOMIC_INIT (0) };
+
+#define _stp_seq_inc() (atomic_inc_return(&_stp_seq.seq))
+
+#ifndef MAXSTRINGLEN
+#define MAXSTRINGLEN 128
+#endif
+
+#ifndef MAXTRACE
+#define MAXTRACE 20
+#endif
+
+/* dwarf unwinder only tested so far on i386 and x86_64. */
+#if (defined(__i386__) || defined(__x86_64__))
+#ifndef STP_USE_DWARF_UNWINDER
+#define STP_USE_DWARF_UNWINDER
+#endif
+#endif
+
+#ifdef CONFIG_FRAME_POINTER
+/* Just because frame pointers are available does not mean we can trust them. */
+#ifndef STP_USE_DWARF_UNWINDER
+#define STP_USE_FRAME_POINTER
+#endif
+#endif
+
+#include "alloc.c"
+#include "print.c"
+#include "string.c"
+#include "io.c"
+#include "arith.c"
+#include "copy.c"
+#include "regs.c"
+#include "regs-ia64.c"
+#include "time.c"
+
+#include "task_finder.c"
+
+#include "sym.c"
+#ifdef STP_PERFMON
+#include "perf.c"
+#endif
+#include "addr-map.c"
+
+
+
+/* Support functions for int64_t module parameters. */
+static int param_set_int64_t(const char *val, struct kernel_param *kp)
+{
+  char *endp;
+  long long ll;
+
+  if (!val)
+    return -EINVAL;
+
+  /* simple_strtoll isn't exported... */
+  if (*val == '-')
+    ll = -simple_strtoull(val+1, &endp, 0);
+  else
+    ll = simple_strtoull(val, &endp, 0);
+
+  if ((endp == val) || ((int64_t)ll != ll))
+    return -EINVAL;
+
+  *((int64_t *)kp->arg) = ll;
+  return 0;
+}
+
+static int param_get_int64_t(char *buffer, struct kernel_param *kp)
+{
+  return sprintf(buffer, "%lli", (long long)*((int64_t *)kp->arg));
+}
+
+#define param_check_int64_t(name, p) __param_check(name, p, int64_t)
+
+
+/************* Module Stuff ********************/
+
+int init_module (void)
+{
+  return _stp_transport_init();
+}
+
+static int probe_start(void);
+
+void cleanup_module(void)
+{
+  _stp_transport_close();
+}
+
+#define pseudo_atomic_cmpxchg(v, old, new) ({\
+	int ret;\
+	unsigned long flags;\
+	local_irq_save(flags);\
+	ret = atomic_read(v);\
+	if (likely(ret == old))\
+		atomic_set(v, new);\
+	local_irq_restore(flags);\
+	ret; })
+
+
+MODULE_LICENSE("GPL");
+
+#endif /* _RUNTIME_H_ */

=== added directory '.pc/Local-definitions-of-NIPQUAD-and-NIPQUAD_FMT-when-re.patch'
=== added directory '.pc/Local-definitions-of-NIPQUAD-and-NIPQUAD_FMT-when-re.patch/tapset'
=== added file '.pc/Local-definitions-of-NIPQUAD-and-NIPQUAD_FMT-when-re.patch/tapset/ip.stp'
--- .pc/Local-definitions-of-NIPQUAD-and-NIPQUAD_FMT-when-re.patch/tapset/ip.stp	1970-01-01 00:00:00 +0000
+++ .pc/Local-definitions-of-NIPQUAD-and-NIPQUAD_FMT-when-re.patch/tapset/ip.stp	2011-03-22 12:11:00 +0000
@@ -0,0 +1,86 @@
+// IP tapset
+//
+// Copyright (C) 2009, IBM Inc.
+// Copyright (C) 2010, Red Hat Inc.
+//
+// Author : Breno Leitao <[e-mail]>
+//
+// This file is free software.  You can redistribute it and/or modify it under
+// the terms of the GNU General Public License (GPL), version 2.
+//
+// Based on previous work done by Arnaldo Carvalho de Melo <[e-mail]>
+
+%{
+#include <linux/skbuff.h>
+%}
+
+/**
+ * sfunction ip_ntop - returns a string representation from an integer IP number
+ * @addr: the ip represented as an integer
+ */
+function ip_ntop:string (addr:long)
+%{
+        __be32 ip;
+
+        ip = THIS->addr;
+        snprintf(THIS->__retvalue, MAXSTRINGLEN, NIPQUAD_FMT, NIPQUAD(ip));
+%}
+
+/* return the source IP address for a given sock */
+function __ip_sock_saddr:long (sock:long)
+{
+    return (@defined(@cast(sock, "inet_sock")->inet_saddr)
+	    ? @cast(sock, "inet_sock")->inet_saddr # kernel >= 2.6.33
+	    : (@defined(@cast(sock, "inet_sock")->saddr)
+	       ? @cast(sock, "inet_sock", "kernel")->saddr # kernel >= 2.6.11
+	       : @cast(sock, "inet_sock", "kernel<net/ip.h>")->inet->saddr))
+}
+
+/* return the destination IP address for a given sock */
+function __ip_sock_daddr:long (sock:long)
+{
+    return (@defined(@cast(sock, "inet_sock")->inet_daddr)
+	    ? @cast(sock, "inet_sock")->inet_daddr # kernel >= 2.6.33
+	    : (@defined(@cast(sock, "inet_sock")->daddr)
+	       ? @cast(sock, "inet_sock", "kernel")->daddr # kernel >= 2.6.11
+	       : @cast(sock, "inet_sock", "kernel<net/ip.h>")->inet->daddr))
+}
+
+/* Get the IP header from a sk_buff struct */
+function __get_skb_iphdr:long(skb:long)
+%( kernel_v < "2.6.21" %?
+{
+	iphdr = @cast(skb, "sk_buff")->nh->raw
+	return iphdr
+}
+%:
+%{ /* pure */
+	struct sk_buff *skb;
+	skb = (struct sk_buff *)(long)THIS->skb;
+	/* as done by skb_network_header() */
+	#ifdef NET_SKBUFF_DATA_USES_OFFSET
+		THIS->__retvalue = (long)(kread(&(skb->head)) + kread(&(skb->network_header)));
+	#else
+		THIS->__retvalue = (long)kread(&(skb->network_header));
+	#endif
+	CATCH_DEREF_FAULT();
+%}
+%)
+
+/* return the source next layer protocol for a given sk_buff structure */
+function __ip_skb_proto:long (iphdr)
+{
+	return @cast(iphdr, "iphdr")->protocol
+}
+
+/* return the source IP address for a given sk_buff structure */
+function __ip_skb_saddr:long (iphdr)
+{
+	return @cast(iphdr, "iphdr")->saddr
+}
+
+/* return the destination IP address for a given skb */
+function __ip_skb_daddr:long (iphdr)
+{
+	return @cast(iphdr, "iphdr")->daddr
+}

=== added directory '.pc/Local-definitions-of-NIPQUAD-and-NIPQUAD_FMT-when-re.patch/testsuite'
=== added directory '.pc/Local-definitions-of-NIPQUAD-and-NIPQUAD_FMT-when-re.patch/testsuite/systemtap.examples'
=== added directory '.pc/Local-definitions-of-NIPQUAD-and-NIPQUAD_FMT-when-re.patch/testsuite/systemtap.examples/process'
=== added file '.pc/Local-definitions-of-NIPQUAD-and-NIPQUAD_FMT-when-re.patch/testsuite/systemtap.examples/process/pfiles.stp'
--- .pc/Local-definitions-of-NIPQUAD-and-NIPQUAD_FMT-when-re.patch/testsuite/systemtap.examples/process/pfiles.stp	1970-01-01 00:00:00 +0000
+++ .pc/Local-definitions-of-NIPQUAD-and-NIPQUAD_FMT-when-re.patch/testsuite/systemtap.examples/process/pfiles.stp	2011-03-22 12:11:00 +0000
@@ -0,0 +1,612 @@
+#! /bin/sh
+
+//bin/true && exec stap -g $0 ${1+"$@"}
+
+# pfiles
+# Copyright (C) 2007-2010 Red Hat, Inc., Eugene Teo <[e-mail]>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as
+# published by the Free Software Foundation.
+#
+# pfiles report information for all open files by the process id.
+#
+# pfiles is not a port of Solaris' pfiles tool. It was written based on the
+# example outputs in:
+# - https://bugzilla.redhat.com/show_bug.cgi?id=223489
+# - http://blogs.sun.com/peteh/entry/pfiles_1_locked_files_and
+# - http://lists.samba.org/archive/samba-technical/2001-May/014293.html
+# - http://mail.gnome.org/archives/gconf-list/2004-December/msg00005.html
+#
+# systemtap SNAPSHOT c9116e9980ad6e417697737f8d54a4a625811245
+# on kernel 2.6.18-128.1.13.el5
+# and on kernel 2.6.27.21-170.2.56.fc10.i686.PAE
+#
+# Last updated: Thu May 28 20:37:57 SGT 2009
+#
+# pfiles is able to:
+# - report locked open files
+# - report pathname information
+# - report socket information (thanks Luis Henriques)
+# - report sk_userlocks (thanks Arnaldo Carvalho de Melo)
+# - report socket options
+#
+# Example:
+# $ ./pfiles.stp `pgrep udevd`
+#    787: udevd
+#   Current rlimit: 32 file descriptors
+#    0: S_IFCHR mode:0666 dev:0,15 ino:396 uid:0 gid:0 rdev:1,3
+#       O_RDWR|O_LARGEFILE 
+#       /dev/null
+#    1: S_IFCHR mode:0666 dev:0,15 ino:396 uid:0 gid:0 rdev:1,3
+#       O_RDWR|O_LARGEFILE 
+#       /dev/null
+#    2: S_IFCHR mode:0666 dev:0,15 ino:396 uid:0 gid:0 rdev:1,3
+#       O_RDWR|O_LARGEFILE 
+#       /dev/null
+#    3: S_IFDIR mode:0600 dev:0,9 ino:1 uid:0 gid:0 rdev:0,0
+#       O_RDONLY 
+#       inotify
+#    4: S_IFSOCK mode:0777 dev:0,4 ino:2353 uid:0 gid:0 rdev:0,0
+#       O_RDWR 
+#       socket:[2353]
+#       SO_PASSCRED,SO_TYPE(2),SO_SNDBUF(111616),SO_RCVBUF(111616)
+#         sockname: AF_UNIX
+#    5: S_IFSOCK mode:0777 dev:0,4 ino:2354 uid:0 gid:0 rdev:0,0
+#       O_RDWR 
+#       socket:[2354]
+#       SO_TYPE(2),SO_SNDBUF(111616),SO_RCVBUF(33554432)
+#         ulocks: rcv
+#    6: S_IFIFO mode:0600 dev:0,6 ino:2355 uid:0 gid:0 rdev:0,0
+#       O_RDONLY|O_NONBLOCK 
+#       pipe:[2355]
+#    7: S_IFIFO mode:0600 dev:0,6 ino:2355 uid:0 gid:0 rdev:0,0
+#       O_WRONLY|O_NONBLOCK 
+#       pipe:[2355]
+#
+# I used Andrew Tridgell's locktst.c to test the advisory lock code.
+# You can download it at http://samba.org/ftp/unpacked/junkcode/locktst.c
+#
+# $ ./locktst file &
+# fcntl_lock 3 6 1 1 1
+# $ pfiles 10126 | grep advisory -A1 -B2
+#   3: S_IFREG mode:0644 dev:253,0 ino:15237159 uid:500 gid:500 rdev:0,0
+#      O_RDWR 
+#      advisory write lock set by process 10126
+#      /home/eteo/pfiles/file
+#
+
+%{
+#include <linux/file.h>
+#include <net/sock.h>
+#include <linux/un.h>
+#include <linux/tcp.h>
+%}
+
+function task_valid_file_handle:long (task:long, fd:long) %{ /* pure */
+	struct task_struct *p = (struct task_struct *)((long)THIS->task);
+	struct files_struct *files = kread(&p->files);
+	struct file *filp;
+
+	rcu_read_lock();
+	filp = fcheck_files(files, THIS->fd);
+	if (!filp) {
+		THIS->__retvalue = 0;
+		rcu_read_unlock();
+		return;
+	}
+	THIS->__retvalue = (long)filp;
+	rcu_read_unlock();
+
+	CATCH_DEREF_FAULT();
+%}
+
+function i_mode2str:string (i_mode:long) %{ /* pure */
+	snprintf(THIS->__retvalue, MAXSTRINGLEN, "%d", (int)THIS->i_mode);
+	THIS->i_mode = simple_strtol(THIS->__retvalue, NULL, 10);
+
+	if (S_ISLNK(THIS->i_mode)) strlcpy (THIS->__retvalue, "S_IFLNK", MAXSTRINGLEN);
+	else if (S_ISREG(THIS->i_mode)) strlcpy (THIS->__retvalue, "S_IFREG", MAXSTRINGLEN);
+	else if (S_ISDIR(THIS->i_mode)) strlcpy (THIS->__retvalue, "S_IFDIR", MAXSTRINGLEN);
+	else if (S_ISCHR(THIS->i_mode)) strlcpy (THIS->__retvalue, "S_IFCHR", MAXSTRINGLEN);
+	else if (S_ISBLK(THIS->i_mode)) strlcpy (THIS->__retvalue, "S_IFBLK", MAXSTRINGLEN);
+	else if (S_ISFIFO(THIS->i_mode)) strlcpy (THIS->__retvalue, "S_IFIFO", MAXSTRINGLEN);
+	else if (S_ISSOCK(THIS->i_mode)) strlcpy (THIS->__retvalue, "S_IFSOCK", MAXSTRINGLEN);
+%}
+
+function task_file_handle_i_mode:long (task:long, fd:long) %{ /* pure */
+	struct task_struct *p = (struct task_struct *)((long)THIS->task);
+	struct files_struct *files = kread(&p->files);
+	struct file *filp;
+
+	rcu_read_lock();
+	filp = fcheck_files(files, THIS->fd);
+	THIS->__retvalue = kread(&filp->f_dentry->d_inode->i_mode);
+	rcu_read_unlock();
+
+	CATCH_DEREF_FAULT();
+%}
+
+function task_file_handle_majmin_dev:string (task:long, fd:long) %{ /* pure */
+	struct task_struct *p = (struct task_struct *)((long)THIS->task);
+	struct files_struct *files = kread(&p->files);
+	struct file *filp;
+	int dev_nr;
+
+	rcu_read_lock();
+	filp = fcheck_files(files, THIS->fd);
+	dev_nr = kread(&filp->f_dentry->d_inode->i_sb->s_dev);
+	snprintf(THIS->__retvalue, MAXSTRINGLEN,
+		"%d,%d", MAJOR(dev_nr), MINOR(dev_nr));
+	rcu_read_unlock();
+
+	CATCH_DEREF_FAULT();
+%}
+
+function task_file_handle_majmin_rdev:string (task:long, fd:long) %{ /* pure */
+	struct task_struct *p = (struct task_struct *)((long)THIS->task);
+	struct files_struct *files = kread(&p->files);
+	struct file *filp;
+	int rdev_nr;
+
+	rcu_read_lock();
+	filp = fcheck_files(files, THIS->fd);
+	rdev_nr = kread(&filp->f_dentry->d_inode->i_rdev);
+	snprintf(THIS->__retvalue, MAXSTRINGLEN,
+		"%d,%d", MAJOR(rdev_nr), MINOR(rdev_nr));
+	rcu_read_unlock();
+
+	CATCH_DEREF_FAULT();	
+%}
+
+function task_file_handle_i_node:long (task:long, fd:long) %{ /* pure */
+	struct task_struct *p = (struct task_struct *)((long)THIS->task);
+	struct files_struct *files = kread(&p->files);
+	struct file *filp;
+	
+	rcu_read_lock();
+	filp = fcheck_files(files, THIS->fd);
+	THIS->__retvalue = kread(&filp->f_dentry->d_inode->i_ino);
+	rcu_read_unlock();
+
+	CATCH_DEREF_FAULT();
+%}
+
+function task_file_handle_uid:long (task:long, fd:long) %{ /* pure */
+	struct task_struct *p = (struct task_struct *)((long)THIS->task);
+	struct files_struct *files = kread(&p->files);
+	struct file *filp;
+	
+	rcu_read_lock();
+	filp = fcheck_files(files, THIS->fd);
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,29)
+	/* git commit d76b0d9b */
+	THIS->__retvalue = kread(&filp->f_cred->fsuid);
+#else
+	THIS->__retvalue = kread(&filp->f_uid);
+#endif
+	rcu_read_unlock();
+
+	CATCH_DEREF_FAULT();
+%}
+
+function task_file_handle_gid:long (task:long, fd:long) %{ /* pure */
+	struct task_struct *p = (struct task_struct *)((long)THIS->task);
+	struct files_struct *files = kread(&p->files);
+	struct file *filp;
+	
+	rcu_read_lock();
+	filp = fcheck_files(files, THIS->fd);
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,29)
+	/* git commit d76b0d9b */
+	THIS->__retvalue = kread(&filp->f_cred->fsgid);
+#else
+	THIS->__retvalue = kread(&filp->f_gid);
+#endif
+	rcu_read_unlock();
+
+	CATCH_DEREF_FAULT();
+%}
+
+function task_file_handle_f_flags:long (task:long, fd:long) %{ /* pure */
+	struct task_struct *p = (struct task_struct *)((long)THIS->task);
+	struct files_struct *files = kread(&p->files);
+	struct file *filp;
+	
+	rcu_read_lock();
+	filp = fcheck_files(files, THIS->fd);
+	THIS->__retvalue = kread(&filp->f_flags);
+	rcu_read_unlock();
+
+	CATCH_DEREF_FAULT();
+%}
+
+function task_file_handle_fd_flags:string (task:long, fd:long) %{ /* pure */
+	struct task_struct *p = (struct task_struct *)((long)THIS->task);
+	struct files_struct *files = kread(&p->files);
+	struct fdtable *fdt;
+	int gcoe;
+	
+	rcu_read_lock();
+	fdt = files_fdtable(files);
+	gcoe = FD_ISSET(THIS->fd, kread(&fdt->close_on_exec));
+	snprintf(THIS->__retvalue, MAXSTRINGLEN,
+		"%s", gcoe ? "FD_CLOEXEC" : "");
+	rcu_read_unlock();
+
+	CATCH_DEREF_FAULT();
+%}
+
+function task_file_handle_flock:string (task:long, fd:long) %{ /* pure */
+	struct task_struct *p = (struct task_struct *)((long)THIS->task);
+	struct files_struct *files = kread(&p->files);
+	struct file_lock *flock;
+	int fl_type, fl_pid;
+	struct file *filp;
+
+	rcu_read_lock();
+	filp = fcheck_files(files, THIS->fd);
+	flock = kread(&filp->f_dentry->d_inode->i_flock);
+	fl_type = fl_pid = -1;
+	if (flock) {
+		fl_type = kread(&flock->fl_type);
+		fl_pid = kread(&flock->fl_pid);
+	}
+
+	if (fl_type != -1) /* !flock */
+		snprintf(THIS->__retvalue, MAXSTRINGLEN,
+			"      advisory %s lock set by process %d",
+			fl_type ? "write" : "read", fl_pid);
+	else
+		snprintf(THIS->__retvalue, MAXSTRINGLEN, "NULL");
+	rcu_read_unlock();
+
+	CATCH_DEREF_FAULT();
+%}
+
+function task_file_handle_d_path:string (task:long, fd:long) %{ /* pure */
+	struct task_struct *p = (struct task_struct *)((long)THIS->task);
+	struct files_struct *files = kread(&p->files);
+	char *page = (char *)__get_free_page(GFP_KERNEL);
+	struct file *filp;
+	struct dentry *dentry;
+	struct vfsmount *vfsmnt;
+
+	/* TODO: handle !page */
+	if (!page)
+		return;
+
+	rcu_read_lock();
+	filp = fcheck_files(files, THIS->fd);
+	dentry = kread(&filp->f_dentry);
+	vfsmnt = kread(&filp->f_vfsmnt);
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26)
+	/* git commit 9d1bc601 */
+    snprintf(THIS->__retvalue, MAXSTRINGLEN, "%s",
+        d_path(&filp->f_path, page, PAGE_SIZE));
+#else
+	snprintf(THIS->__retvalue, MAXSTRINGLEN, "%s",
+		d_path(dentry, vfsmnt, page, PAGE_SIZE));
+#endif	
+	free_page((unsigned long)page);
+	rcu_read_unlock();
+
+	CATCH_DEREF_FAULT();
+%}
+
+function task_file_handle_socket:long (task:long, fd:long) %{ /* pure */
+	struct task_struct *p = (struct task_struct *)((long)THIS->task);
+	struct files_struct *files = kread(&p->files);
+	struct inode *inode;
+	struct file *filp;
+
+	rcu_read_lock();
+	filp = fcheck_files(files, THIS->fd);
+	if (!filp) {
+		THIS->__retvalue = 0;
+	    rcu_read_unlock();
+		return;
+	}
+	inode = kread(&filp->f_dentry->d_inode);
+	if (S_ISSOCK(kread(&inode->i_mode)))
+		THIS->__retvalue = (long)SOCKET_I(inode);
+	rcu_read_unlock();
+
+	CATCH_DEREF_FAULT();
+%}
+
+function socket_userlocks:string (sock:long) %{ /* pure */
+	struct socket *sock = (struct socket *)((long)THIS->sock);
+	struct sock *sk = (struct sock *)kread(&sock->sk);
+	unsigned char locks = sk->sk_userlocks;
+	int printed = 0;
+
+	THIS->__retvalue[0] = '\0';
+
+	if (locks & SOCK_RCVBUF_LOCK)
+		printed = snprintf(THIS->__retvalue, MAXSTRINGLEN,
+			"ulocks: rcv");
+	
+	if (locks & SOCK_SNDBUF_LOCK)
+		snprintf(THIS->__retvalue, MAXSTRINGLEN,
+			"ulocks: %ssnd",
+			printed ? "rcv, " : "");
+
+	CATCH_DEREF_FAULT();
+%}
+
+function socket_optname:string (sock:long) %{ /* pure */
+    struct socket *sock = (struct socket *)((long)THIS->sock);
+    int optval;
+    int optlen;
+    int ret, a;
+    char str[30];
+    struct linger ling;
+    struct optname_item {
+        int optfam;
+        int optnum;
+        const char *optname;
+        int show_val;
+    } *p;
+    struct optname_item optname_entries[] = {
+        { SOL_SOCKET, SO_DEBUG,     "SO_DEBUG",     0 },
+        { SOL_SOCKET, SO_REUSEADDR, "SO_REUSEADDR", 0 },
+        { SOL_SOCKET, SO_DONTROUTE, "SO_DONTROUTE", 0 },
+        { SOL_SOCKET, SO_BROADCAST, "SO_BROADCAST", 0 },
+        { SOL_SOCKET, SO_KEEPALIVE, "SO_KEEPALIVE", 0 },
+        { SOL_SOCKET, SO_OOBINLINE, "SO_OOBINLINE", 0 },
+        { SOL_SOCKET, SO_PASSCRED,  "SO_PASSCRED",  0 },
+/*      { SOL_SOCKET, SO_SNDLOWAT,  "SO_SNDLOWAT",  0 },*/
+        { SOL_SOCKET, SO_TYPE,      "SO_TYPE",      1 },
+        { SOL_SOCKET, SO_ERROR,     "SO_ERROR",     1 },
+        { SOL_SOCKET, SO_SNDBUF,    "SO_SNDBUF",    1 },
+        { SOL_SOCKET, SO_RCVBUF,    "SO_RCVBUF",    1 },
+        { SOL_SOCKET, SO_NO_CHECK,  "SO_NO_CHECK",  1 },
+        { SOL_TCP,    TCP_NODELAY,  "TCP_NODELAY",  0 },
+        { 0, 0, NULL, 0 },
+    };
+
+    for (p = optname_entries; p->optname; ++p) {
+       optlen = sizeof(optval);
+       ret = kernel_getsockopt(sock, p->optfam, p->optnum, (char *)&optval, &optlen);
+       if (ret == 0 && optval != 0) {
+           if (!p->show_val)
+               snprintf(str, MAXSTRINGLEN, "%s,", p->optname);
+           else
+               snprintf(str, MAXSTRINGLEN, "%s(%d),", p->optname, optval);
+           strcat(THIS->__retvalue, str);
+       }
+    }
+
+    optlen = sizeof(ling);
+    ret = kernel_getsockopt(sock, SOL_SOCKET, SO_LINGER, (void *)&ling, &optlen);
+    if (ret == 0 && ling.l_onoff != 0) {
+        snprintf(str, MAXSTRINGLEN, "SO_LINGER(%d),", ling.l_linger);
+        strcat(THIS->__retvalue, str);
+    }
+
+    THIS->__retvalue[strlen(THIS->__retvalue) - 1] = '\0';
+	CATCH_DEREF_FAULT();
+%}
+
+function socket_family:long (sock:long) %{ /* pure */
+	struct socket *sock = (struct socket *)((long)THIS->sock);
+	THIS->__retvalue = (long)kread(&sock->ops->family);
+	CATCH_DEREF_FAULT();
+%}
+
+function socket_unix_sockname:string (sock:long) %{ /* pure */
+	struct socket *sock = (struct socket *)((long)THIS->sock);
+	struct sockaddr_un un_addr;
+	int err, len;
+
+	err = sock->ops->getname(sock, (struct sockaddr *)(&un_addr), &len, 0);
+//	err = kernel_getsockname(kread(&sock), (struct sockaddr *)(&un_addr), &len);
+	if (!err) {
+		if (kread(&un_addr.sun_path[0]) != 0)
+			snprintf(THIS->__retvalue, MAXSTRINGLEN,
+				"        sockname: AF_UNIX %s", un_addr.sun_path);
+		else
+			snprintf(THIS->__retvalue, MAXSTRINGLEN, "        sockname: AF_UNIX");
+	}
+	CATCH_DEREF_FAULT();
+%}
+
+function socket_unix_peername:string (sock:long) %{ /* pure */
+	struct socket *sock = (struct socket *)((long)THIS->sock);
+	struct sockaddr_un un_addr;
+	int err, len;
+
+	err = sock->ops->getname(sock, (struct sockaddr *)(&un_addr), &len, 1);
+//	err = kernel_getpeername(kread(&sock), (struct sockaddr *)(&un_addr), &len);
+	if (!err) {
+		if (kread(&un_addr.sun_path[0]) != 0)
+			snprintf(THIS->__retvalue, MAXSTRINGLEN,
+				"        peername: AF_UNIX %s", un_addr.sun_path);
+		else
+			snprintf(THIS->__retvalue, MAXSTRINGLEN, "        peername: AF_UNIX");
+	}
+	CATCH_DEREF_FAULT();
+%}
+
+function socket_ipv4_sockname:string (sock:long) %{ /* pure */
+	struct socket *sock = (struct socket *)((long)THIS->sock);
+	struct sockaddr_in in_addr;
+	__be32 addr, port;
+	int err, len;
+
+	err = sock->ops->getname (sock, (struct sockaddr*)(&in_addr), &len, 0);
+	if (!err) {
+		addr = kread(&in_addr.sin_addr.s_addr);
+		port = htons(kread(&in_addr.sin_port));
+		snprintf(THIS->__retvalue, MAXSTRINGLEN,
+			"        sockname: AF_INET " NIPQUAD_FMT "  port: %d",
+			NIPQUAD(addr), port);
+	}
+	CATCH_DEREF_FAULT();
+%}
+
+function socket_ipv4_peername:string (sock:long) %{ /* pure */
+	struct socket *sock = (struct socket *)((long)THIS->sock);
+	struct sockaddr_in in_addr;
+	__be32 addr, port;
+	int err, len;
+
+	err = sock->ops->getname (sock, (struct sockaddr*)(&in_addr), &len, 1);
+	if (!err) {
+		addr = kread(&in_addr.sin_addr.s_addr);
+		port = htons(kread(&in_addr.sin_port));
+		snprintf(THIS->__retvalue, MAXSTRINGLEN,
+			"        peername: AF_INET " NIPQUAD_FMT "  port: %d",
+			NIPQUAD(addr), port);
+	}
+	CATCH_DEREF_FAULT();
+%}
+
+%{
+#ifndef NIP6_FMT
+#define NIP6_FMT "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x"
+#endif
+#ifndef NIP6
+#define NIP6(addr) \
+    ntohs((addr).s6_addr16[0]), \
+    ntohs((addr).s6_addr16[1]), \
+    ntohs((addr).s6_addr16[2]), \
+    ntohs((addr).s6_addr16[3]), \
+    ntohs((addr).s6_addr16[4]), \
+    ntohs((addr).s6_addr16[5]), \
+    ntohs((addr).s6_addr16[6]), \
+    ntohs((addr).s6_addr16[7])
+#endif
+
+%}
+
+function socket_ipv6_sockname:string (sock:long) %{ /* pure */
+	struct socket *sock = (struct socket *)((long)THIS->sock);
+	struct sockaddr_in6 in_addr;
+	__be32 port;
+	int err, len;
+
+	err = sock->ops->getname (sock, (struct sockaddr*)(&in_addr), &len, 0);
+	if (!err) {
+		port = htons(kread(&in_addr.sin6_port));
+		snprintf(THIS->__retvalue, MAXSTRINGLEN,
+			"        sockname: AF_INET6 " NIP6_FMT "  port: %d",
+			NIP6(in_addr.sin6_addr), port);
+	}
+	CATCH_DEREF_FAULT();
+%}
+
+function socket_ipv6_peername:string (sock:long) %{ /* pure */
+	struct socket *sock = (struct socket *)((long)THIS->sock);
+	struct sockaddr_in6 in_addr;
+	__be32 port;
+	int err, len;
+
+	err = sock->ops->getname (sock, (struct sockaddr*)(&in_addr), &len, 1);
+	if (!err) {
+		port = htons(kread(&in_addr.sin6_port));
+		snprintf(THIS->__retvalue, MAXSTRINGLEN,
+			"        peername: AF_INET6 " NIP6_FMT "  port: %d",
+			NIP6(in_addr.sin6_addr), port);
+	}
+	CATCH_DEREF_FAULT();
+%}
+
+function print_file_handle_general(task, fd) {
+	printf("%4d: %s mode:%04o dev:%s ino:%d uid:%d gid:%d rdev:%s\n",
+		fd, i_mode2str(task_file_handle_i_mode(task, fd)),
+		task_file_handle_i_mode(task, fd) & 0777,
+		task_file_handle_majmin_dev(task, fd),
+		task_file_handle_i_node(task, fd),
+		task_file_handle_uid(task, fd),
+		task_file_handle_gid(task, fd),
+		task_file_handle_majmin_rdev(task, fd));
+}
+
+function print_file_handle_flags(task, fd) {
+	printf("      %s %s\n",
+		_sys_open_flag_str(task_file_handle_f_flags(task, fd)),
+		task_file_handle_fd_flags(task, fd));
+}
+
+function print_file_handle_flock(task, fd) {
+	flock = task_file_handle_flock(task, fd)
+	if (!isinstr(flock, "NULL"))
+		printf("%s\n", flock)
+}
+
+function print_file_handle_d_path(task, fd) {
+	printf("      %s\n", task_file_handle_d_path(task, fd))
+}
+
+function print_socket_userlocks(sock) {
+	slocks = socket_userlocks(sock)
+	if (strlen(slocks) > 0)
+		printf("        %s\n", slocks)
+}
+
+function print_unix_socket(sock) {
+	sockname = socket_unix_sockname(sock)
+	peername = socket_unix_peername(sock)
+	printf("%s%s", strlen(sockname) > 0 ? sockname . "\n" : "",
+		strlen(peername) > 0 ? peername . "\n" : "")
+}
+
+function print_ipv4_socket(sock) {
+	sockname = socket_ipv4_sockname(sock)
+	peername = socket_ipv4_peername(sock)
+	printf("%s%s", strlen(sockname) > 0 ? sockname . "\n" : "",
+		strlen(peername) > 0 ? peername . "\n" : "")
+}
+
+function print_ipv6_socket(sock) {
+	sockname = socket_ipv6_sockname(sock)
+	peername = socket_ipv6_peername(sock)
+	printf("%s%s", strlen(sockname) > 0 ? sockname . "\n" : "",
+		strlen(peername) > 0 ? peername . "\n" : "")
+}
+
+function print_socket_optname(sock) {
+    str = socket_optname(sock)
+    printf("      %s", strlen(str) > 0 ? str . "\n" : "")
+}
+
+probe begin {
+%( $# < 1
+        %? pid = target()
+        %: pid = $1
+%)
+        # if (pid == 0) error ("Please provide valid target process-id as $1 or -x PID");
+	task = pid2task(pid)
+        if (task == 0) error (sprintf("Process-id %d is invalid, please provide valid PID as $1 or -x PID", pid))
+
+	max_fds = task_max_file_handles(task)
+
+	printf("%6d: %s\n", pid, pid2execname(pid))
+	printf("  Current rlimit: %d file descriptors\n", max_fds)
+
+	for (fd = 0; fd < max_fds; fd++) {
+		if (task_valid_file_handle(task, fd)) {
+			print_file_handle_general(task, fd)
+			print_file_handle_flags(task, fd)
+			print_file_handle_flock(task, fd)
+			print_file_handle_d_path(task, fd)
+			sock = task_file_handle_socket(task, fd)
+			if (sock) {
+                print_socket_optname(sock)
+				fam = socket_family(sock)
+				if (fam == 1) { /* AF_UNIX */
+					print_unix_socket(sock)
+				} else if (fam == 2) { /* AF_INET */
+					print_ipv4_socket(sock)
+				} else if (fam == 10) { /* AF_INET6 */
+					print_ipv6_socket(sock)
+				}
+				print_socket_userlocks(sock)
+			}
+		}
+	}
+
+	exit()
+}

=== added directory '.pc/Updated-__ip_sock_daddr-for-2.6.38-kernels.patch'
=== added directory '.pc/Updated-__ip_sock_daddr-for-2.6.38-kernels.patch/tapset'
=== added file '.pc/Updated-__ip_sock_daddr-for-2.6.38-kernels.patch/tapset/ip.stp'
--- .pc/Updated-__ip_sock_daddr-for-2.6.38-kernels.patch/tapset/ip.stp	1970-01-01 00:00:00 +0000
+++ .pc/Updated-__ip_sock_daddr-for-2.6.38-kernels.patch/tapset/ip.stp	2011-03-22 12:11:00 +0000
@@ -0,0 +1,96 @@
+// IP tapset
+//
+// Copyright (C) 2009, IBM Inc.
+// Copyright (C) 2010, Red Hat Inc.
+//
+// Author : Breno Leitao <[e-mail]>
+//
+// This file is free software.  You can redistribute it and/or modify it under
+// the terms of the GNU General Public License (GPL), version 2.
+//
+// Based on previous work done by Arnaldo Carvalho de Melo <[e-mail]>
+
+%{
+#include <linux/skbuff.h>
+#ifndef NIPQUAD
+#define NIPQUAD(addr) \
+	((unsigned char *)&addr)[0], \
+	((unsigned char *)&addr)[1], \
+	((unsigned char *)&addr)[2], \
+	((unsigned char *)&addr)[3]
+#endif
+#ifndef NIPQUAD_FMT
+#define NIPQUAD_FMT "%u.%u.%u.%u"
+#endif
+%}
+
+/**
+ * sfunction ip_ntop - returns a string representation from an integer IP number
+ * @addr: the ip represented as an integer
+ */
+function ip_ntop:string (addr:long)
+%{
+        __be32 ip;
+
+        ip = THIS->addr;
+        snprintf(THIS->__retvalue, MAXSTRINGLEN, NIPQUAD_FMT, NIPQUAD(ip));
+%}
+
+/* return the source IP address for a given sock */
+function __ip_sock_saddr:long (sock:long)
+{
+    return (@defined(@cast(sock, "inet_sock")->inet_saddr)
+	    ? @cast(sock, "inet_sock")->inet_saddr # kernel >= 2.6.33
+	    : (@defined(@cast(sock, "inet_sock")->saddr)
+	       ? @cast(sock, "inet_sock", "kernel")->saddr # kernel >= 2.6.11
+	       : @cast(sock, "inet_sock", "kernel<net/ip.h>")->inet->saddr))
+}
+
+/* return the destination IP address for a given sock */
+function __ip_sock_daddr:long (sock:long)
+{
+    return (@defined(@cast(sock, "inet_sock")->inet_daddr)
+	    ? @cast(sock, "inet_sock")->inet_daddr # kernel >= 2.6.33
+	    : (@defined(@cast(sock, "inet_sock")->daddr)
+	       ? @cast(sock, "inet_sock", "kernel")->daddr # kernel >= 2.6.11
+	       : @cast(sock, "inet_sock", "kernel<net/ip.h>")->inet->daddr))
+}
+
+/* Get the IP header from a sk_buff struct */
+function __get_skb_iphdr:long(skb:long)
+%( kernel_v < "2.6.21" %?
+{
+	iphdr = @cast(skb, "sk_buff")->nh->raw
+	return iphdr
+}
+%:
+%{ /* pure */
+	struct sk_buff *skb;
+	skb = (struct sk_buff *)(long)THIS->skb;
+	/* as done by skb_network_header() */
+	#ifdef NET_SKBUFF_DATA_USES_OFFSET
+		THIS->__retvalue = (long)(kread(&(skb->head)) + kread(&(skb->network_header)));
+	#else
+		THIS->__retvalue = (long)kread(&(skb->network_header));
+	#endif
+	CATCH_DEREF_FAULT();
+%}
+%)
+
+/* return the source next layer protocol for a given sk_buff structure */
+function __ip_skb_proto:long (iphdr)
+{
+	return @cast(iphdr, "iphdr")->protocol
+}
+
+/* return the source IP address for a given sk_buff structure */
+function __ip_skb_saddr:long (iphdr)
+{
+	return @cast(iphdr, "iphdr")->saddr
+}
+
+/* return the destination IP address for a given skb */
+function __ip_skb_daddr:long (iphdr)
+{
+	return @cast(iphdr, "iphdr")->daddr
+}

=== added directory '.pc/Updated-memory.stp-rpc.stp-task.stp-and-vfs.stp-for-.patch'
=== added directory '.pc/Updated-memory.stp-rpc.stp-task.stp-and-vfs.stp-for-.patch/tapset'
=== added file '.pc/Updated-memory.stp-rpc.stp-task.stp-and-vfs.stp-for-.patch/tapset/memory.stp'
--- .pc/Updated-memory.stp-rpc.stp-task.stp-and-vfs.stp-for-.patch/tapset/memory.stp	1970-01-01 00:00:00 +0000
+++ .pc/Updated-memory.stp-rpc.stp-task.stp-and-vfs.stp-for-.patch/tapset/memory.stp	2011-03-22 12:11:00 +0000
@@ -0,0 +1,635 @@
+// memory/vm related tapset
+// Copyright (C) 2005, 2006 IBM Corp.
+// Copyright (C) 2006 Intel Corporation.
+// Copyright (C) 2010 Red Hat Inc.
+//
+// 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.
+// <tapsetdescription>
+// This family of probe points is used to probe memory-related events. 
+// </tapsetdescription>
+%{
+#include <linux/mm.h>
+%}
+
+global VM_FAULT_OOM=0, VM_FAULT_SIGBUS=1, VM_FAULT_MINOR=2, VM_FAULT_MAJOR=3
+global VM_FAULT_NOPAGE=4, VM_FAULT_LOCKED=5, VM_FAULT_ERROR=6
+global FAULT_FLAG_WRITE=1
+
+/**
+ * sfunction vm_fault_contains - Test return value for page fault reason
+ * @value: The fault_type returned by vm.page_fault.return
+ * @test: The type of fault to test for (VM_FAULT_OOM or similar)
+ */
+function vm_fault_contains:long (value:long, test:long)
+%{
+	int res;
+	switch (THIS->test){
+	case 0: res = THIS->value & VM_FAULT_OOM; break;
+	case 1: res = THIS->value & VM_FAULT_SIGBUS; break;
+#if defined(VM_FAULT_MINOR) && VM_FAULT_MINOR != 0
+	case 2: /* VM_FAULT_MINOR infered by that flags off */
+		res = !((VM_FAULT_OOM | VM_FAULT_SIGBUS | VM_FAULT_MAJOR) & 
+				 THIS->value);
+		break;
+#else
+	case 2: res = THIS->value == VM_FAULT_MINOR; break;
+#endif
+	case 3: res = THIS->value & VM_FAULT_MAJOR; break;
+#ifdef VM_FAULT_NOPAGE
+	case 4: res = THIS->value & VM_FAULT_NOPAGE; break;
+#endif
+#ifdef VM_FAULT_LOCKED
+	case 5: res = THIS->value & VM_FAULT_LOCKED; break;
+#endif
+#ifdef VM_FAULT_ERROR
+	case 6: res = THIS->value & VM_FAULT_ERROR; break;
+#endif
+	default: res = 0; break;
+	}
+	THIS->__retvalue = (res != 0);
+	return;
+%}
+
+/**
+ * probe vm.pagefault - Records that a page fault occurred.
+ * @name: Name of the probe point
+ * @address: The address of the faulting memory access; i.e. the address that caused the page fault.
+ * @write_access: Indicates whether this was a write or read access; 1 indicates a write, 
+ * while 0 indicates a read.
+ *
+ * Context: The process which triggered the fault
+ */
+probe vm.pagefault = kernel.function("__handle_mm_fault@mm/memory.c") ?,
+                     kernel.function("handle_mm_fault@mm/memory.c") ?
+{
+	name = "pagefault"
+	write_access = (@defined($flags)
+			? $flags & FAULT_FLAG_WRITE : $write_access)
+	address =  $address
+}
+
+/**
+ * probe vm.pagefault.return - Indicates what type of fault occurred.
+ * @name: Name of the probe point
+ * @fault_type: Returns either 
+ * 0 (VM_FAULT_OOM) for out of memory faults, 
+ * 2 (VM_FAULT_MINOR) for minor faults, 3 (VM_FAULT_MAJOR) for 
+ * major faults, or 1 (VM_FAULT_SIGBUS) if the fault was neither OOM, minor fault, 
+ * nor major fault.
+ */
+probe vm.pagefault.return =
+		kernel.function("__handle_mm_fault@mm/memory.c").return ?,
+		kernel.function("handle_mm_fault@mm/memory.c").return ?
+{
+	name = "pagefault"
+	fault_type = $return
+}
+
+/**
+ * sfunction addr_to_node - Returns which node a given address belongs to within a NUMA system.
+ *
+ * General Syntax: addr_to_node:long(addr:long)
+ *
+ * @addr: The address of the faulting memory access.
+ *
+ * Description: This function accepts an address, and returns the 
+ * node that the given address belongs to in a NUMA system.
+ */
+function addr_to_node:long(addr:long) %{ /* pure */ 
+	int pfn = __pa(THIS->addr) >> PAGE_SHIFT;
+	int nid;
+#ifdef for_each_online_node
+	for_each_online_node(nid)
+#else
+	for (nid=0; nid<MAX_NUMNODES; nid++)  /* if (node_online(nid)) */
+#endif
+		if ( NODE_DATA(nid)->node_start_pfn <= pfn &&
+			pfn < (NODE_DATA(nid)->node_start_pfn +
+			NODE_DATA(nid)->node_spanned_pages) )
+		{
+			THIS->__retvalue = nid;
+			break;
+		}
+%}
+
+// Return whether a page to be copied is a zero page.
+function _IS_ZERO_PAGE:long(from:long, vaddr:long) %{ /* pure */
+    THIS->__retvalue = (THIS->from == (long) ZERO_PAGE(THIS->vaddr));
+%}
+
+
+/**
+ * probe vm.write_shared - Attempts at writing to a shared page.
+ * @name: Name of the probe point
+ * @address: The address of the shared write.
+ *
+ * Context:
+ *  The context is the process attempting the write.
+ *
+ *  Fires when a process attempts to write to a shared page. 
+ *  If a copy is necessary, this will be followed by a 
+ *  vm.write_shared_copy.
+ */
+probe vm.write_shared = kernel.function("do_wp_page") {
+    name = "write_shared"
+    address = $address
+}
+
+/**
+ * probe vm.write_shared_copy - Page copy for shared page write.
+ * @name: Name of the probe point
+ * @address: The address of the shared write.
+ * @zero: Boolean indicating whether it is a zero page
+ *         (can do a clear instead of a copy).
+ *
+ * Context:
+ *  The process attempting the write.
+ *
+ *  Fires when a write to a shared page requires a page copy.  This is
+ *  always preceded by a vm.shared_write.
+ */
+probe vm.write_shared_copy = kernel.function("copy_cow_page") ?
+{
+    name = "write_shared_copy"
+    address = $address
+    zero = _IS_ZERO_PAGE($from, $address);
+}
+
+
+/**
+ * probe vm.mmap - Fires when an mmap is requested.
+ * @name: Name of the probe point
+ * @address: The requested address
+ * @length: The length of the memory segment 
+ *
+ * Context:
+ *  The process calling mmap.
+ */
+probe vm.mmap = kernel.function("do_mmap"), kernel.function("do_mmap2") ?
+{
+    name = "mmap"
+    address = $addr
+    length = $len
+}
+
+
+/**
+ * probe vm.munmap - Fires when an munmap is requested.
+ * @name: Name of the probe point
+ * @address: The requested address
+ * @length: The length of the memory segment 
+ *
+ * Context:
+ *  The process calling munmap.
+ */
+probe vm.munmap = kernel.function("do_munmap") {
+    name = "munmap"
+    address = $start
+    length = $len
+}
+
+/**
+ * probe vm.brk - Fires when a brk is requested (i.e. the heap will be resized).
+ * @name: Name of the probe point
+ * @address: The requested address
+ * @length: The length of the memory segment 
+ *
+ * Context:
+ *  The process calling brk.
+ */
+probe vm.brk = kernel.function("do_brk") {
+    name = "brk"
+    address = $addr
+    length = $len
+}
+
+/**
+ * probe vm.oom_kill - Fires when a thread is selected for termination by the OOM killer.
+ * @name: Name of the probe point
+ * @task: The task being killed
+ *
+ * Context:
+ *  The process that tried to consume excessive memory, and thus
+ *  triggered the OOM.
+ */
+probe vm.oom_kill = kernel.function("__oom_kill_task")
+{
+    name = "oom_kill"
+    task = $p
+}
+
+function GFP_KERNEL:long()
+%{ /* pure */ /* unprivileged */
+	THIS->__retvalue = GFP_KERNEL;
+%}
+
+function __gfp_flag_str:string(gfp_flag:long)
+%{
+	long gfp_flag = THIS->gfp_flag;
+	THIS->__retvalue[0] = '\0';
+
+/* Older kernels < 2.6.32 didn't have some of these GFP defines yet. */
+#ifndef __GFP_DMA32
+#define __GFP_DMA32	((__force gfp_t)0x04u)
+#endif
+#ifndef GFP_DMA32
+#define GFP_DMA32	__GFP_DMA32
+#endif
+
+#ifndef __GFP_MOVABLE
+#define __GFP_MOVABLE  ((__force gfp_t)0x08u)  /* Page is movable */
+#endif
+
+#ifndef GFP_ZONEMASK
+#define GFP_ZONEMASK   (__GFP_DMA|__GFP_HIGHMEM|__GFP_DMA32|__GFP_MOVABLE)
+#endif
+
+#ifndef __GFP_NOTRACK
+#ifdef CONFIG_KMEMCHECK
+#define __GFP_NOTRACK  ((__force gfp_t)0x200000u)  /* Don't track with kmemcheck */
+#else
+#define __GFP_NOTRACK  ((__force gfp_t)0)
+#endif
+#endif
+
+#ifndef __GFP_THISNODE
+#define __GFP_THISNODE  ((__force gfp_t)0x40000u)
+#endif
+
+#ifndef __GFP_RECLAIMABLE
+#define __GFP_RECLAIMABLE ((__force gfp_t)0x80000u)
+#endif
+
+#ifndef __GFP_ZERO
+#define __GFP_ZERO	((__force gfp_t)0x8000u)
+#endif
+
+#ifndef __GFP_NOMEMALLOC
+#define __GFP_NOMEMALLOC ((__force gfp_t)0x10000u)
+#endif
+
+#ifndef __GFP_HARDWALL
+#define __GFP_HARDWALL   ((__force gfp_t)0x20000u)
+#endif
+
+#ifndef GFP_TEMPORARY
+#define GFP_TEMPORARY  (__GFP_WAIT | __GFP_IO | __GFP_FS | \
+                        __GFP_RECLAIMABLE)
+#endif
+
+#ifndef GFP_HIGHUSER_MOVABLE
+#define GFP_HIGHUSER_MOVABLE   (__GFP_WAIT | __GFP_IO | __GFP_FS | \
+                                __GFP_HARDWALL | __GFP_HIGHMEM | \
+                                __GFP_MOVABLE)
+#endif
+
+#ifndef GFP_THISNODE
+#ifdef CONFIG_NUMA
+#define GFP_THISNODE    (__GFP_THISNODE | __GFP_NOWARN | __GFP_NORETRY)
+#else
+#define GFP_THISNODE    ((__force gfp_t)0)
+#endif
+#endif
+
+/* Macro for GFP Bitmasks. */
+/* The resulted GFP_FLAGS may be either single or concatenation of the multiple bitmasks. */
+
+
+#define __GFP_BITMASKS(FLAG)  if(gfp_flag & FLAG) { if(THIS->__retvalue[0] != '\0') \
+                strlcat(THIS->__retvalue, " | "#FLAG, MAXSTRINGLEN); \
+                else strlcat(THIS->__retvalue, #FLAG, MAXSTRINGLEN); }
+
+
+/* Macro for Composite Flags. */
+/* Each Composite GFP_FLAG is the combination of multiple bitmasks. */
+
+
+#define __GFP_COMPOSITE_FLAG(FLAG)  if(gfp_flag == FLAG) { \
+                strlcat(THIS->__retvalue, #FLAG, MAXSTRINGLEN); return; }
+
+
+/* Composite GFP FLAGS of the BitMasks. */
+
+	__GFP_COMPOSITE_FLAG(GFP_ZONEMASK)
+	__GFP_COMPOSITE_FLAG(GFP_ATOMIC)
+	__GFP_COMPOSITE_FLAG(GFP_NOIO)
+	__GFP_COMPOSITE_FLAG(GFP_NOFS)
+	__GFP_COMPOSITE_FLAG(GFP_KERNEL)
+	__GFP_COMPOSITE_FLAG(GFP_TEMPORARY)
+	__GFP_COMPOSITE_FLAG(GFP_USER)
+	__GFP_COMPOSITE_FLAG(GFP_HIGHUSER)
+	__GFP_COMPOSITE_FLAG(GFP_HIGHUSER_MOVABLE)
+	__GFP_COMPOSITE_FLAG(GFP_THISNODE)
+	__GFP_COMPOSITE_FLAG(GFP_DMA)
+	__GFP_COMPOSITE_FLAG(GFP_DMA32)
+
+/* GFP BitMasks */
+
+	__GFP_BITMASKS(__GFP_DMA)
+	__GFP_BITMASKS(__GFP_HIGHMEM)
+	__GFP_BITMASKS(__GFP_MOVABLE)
+	__GFP_BITMASKS(__GFP_WAIT)
+	__GFP_BITMASKS(__GFP_HIGH)
+	__GFP_BITMASKS(__GFP_IO)
+	__GFP_BITMASKS(__GFP_FS)
+	__GFP_BITMASKS(__GFP_COLD)
+	__GFP_BITMASKS(__GFP_NOWARN)
+	__GFP_BITMASKS(__GFP_REPEAT)
+	__GFP_BITMASKS(__GFP_NOFAIL)
+	__GFP_BITMASKS(__GFP_COMP)
+	__GFP_BITMASKS(__GFP_ZERO)
+	__GFP_BITMASKS(__GFP_NOMEMALLOC)
+	__GFP_BITMASKS(__GFP_HARDWALL)
+	__GFP_BITMASKS(__GFP_THISNODE)
+	__GFP_BITMASKS(__GFP_RECLAIMABLE)
+	__GFP_BITMASKS(__GFP_NOTRACK)
+
+
+#undef __GFP_BITMASKS
+#undef __GFP_COMPOSITE_FLAG
+%}
+
+/* The Formal Parameters will be displayed if available, otherwise \
+		 "0" or "unknown" will be displayed */
+
+probe __vm.kmalloc.tp = kernel.trace("kmalloc")
+{
+	call_site = $call_site
+	caller_function = symname(call_site)
+	bytes_req = $bytes_req
+	bytes_alloc = $bytes_alloc
+	gfp_flags = $gfp_flags
+	gfp_flag_name = __gfp_flag_str($gfp_flags)
+	ptr = $ptr
+}
+
+/*
+ * It is unsafe to invoke __builtin_return_address() presently (to get
+ * call_site for kprobe based probes) and that it can be improved
+ * later when fix for bugs bz#6961 and bz#6580 is available.
+ */ 
+
+probe __vm.kmalloc.kp = kernel.function("kmem_cache_alloc_notrace").return !,
+			kernel.function("kmem_cache_alloc").return
+{
+	call_site = 0
+	caller_function = "unknown"
+	// Note that 'bytes_req' could be wrong.  By the time
+	// kmem_cache_alloc* gets called the requested size could have
+	// rounded up to the nearest cache alloc size.
+	if (@defined($s)) {
+		bytes_req = $s->size
+		bytes_alloc = $s->size
+	}
+	else if (@defined($cachep->buffer_size)) {
+		bytes_req = $cachep->buffer_size
+		bytes_alloc = $cachep->buffer_size
+	}
+	else {
+		bytes_req = $cachep->objsize
+		bytes_alloc = $cachep->objsize
+	}
+	if (@defined($gfpflags)) {
+		gfp_flags = $gfpflags
+		gfp_flag_name = __gfp_flag_str($gfpflags)
+	}
+	else {
+		gfp_flags = $flags
+		gfp_flag_name = __gfp_flag_str($flags)
+	}
+	ptr = $return
+}
+
+/**
+ * probe vm.kmalloc - Fires when kmalloc is requested.
+ * @name: Name of the probe point
+ * @call_site: Address of the kmemory function.
+ * @caller_function: Name of the caller function.
+ * @bytes_req: Requested Bytes
+ * @bytes_alloc: Allocated Bytes
+ * @gfp_flags: type of kmemory to allocate
+ * @gfp_flag_name: type of kmemory to allocate (in String format)
+ * @ptr: Pointer to the kmemory allocated
+ */
+probe vm.kmalloc = __vm.kmalloc.tp !, __vm.kmalloc.kp
+{
+	name = "kmalloc"
+}
+
+
+probe __vm.kmem_cache_alloc.tp = kernel.trace("kmem_cache_alloc")
+{
+	call_site = $call_site
+	caller_function = symname(call_site)
+	bytes_req = $bytes_req
+	bytes_alloc = $bytes_alloc
+	gfp_flags = $gfp_flags
+	gfp_flag_name = __gfp_flag_str($gfp_flags)
+	ptr = $ptr
+}
+
+probe __vm.kmem_cache_alloc.kp = kernel.function("kmem_cache_alloc").return
+{
+	call_site = 0
+	caller_function = "unknown"
+	// Note that 'bytes_req' could be wrong.  By the time
+	// kmem_cache_alloc* gets called the requested size could have
+	// rounded up to the nearest cache alloc size.
+	if (@defined($s)) {
+		bytes_req = $s->size
+		bytes_alloc = $s->size
+	}
+	else if (@defined($cachep->buffer_size)) {
+		bytes_req = $cachep->buffer_size
+		bytes_alloc = $cachep->buffer_size
+	}
+	else {
+		bytes_req = $cachep->objsize
+		bytes_alloc = $cachep->objsize
+	}
+	if (@defined($gfpflags)) {
+		gfp_flags = $gfpflags
+		gfp_flag_name = __gfp_flag_str($gfpflags)
+	}
+	else {
+		gfp_flags = $flags
+		gfp_flag_name = __gfp_flag_str($flags)
+	}
+	ptr = $return
+}
+
+/**
+ * probe vm.kmem_cache_alloc - Fires when \
+ *              kmem_cache_alloc is requested.
+ * @name: Name of the probe point
+ * @call_site: Address of the function calling this kmemory function.
+ * @caller_function: Name of the caller function.
+ * @bytes_req: Requested Bytes
+ * @bytes_alloc: Allocated Bytes
+ * @gfp_flags: type of kmemory to allocate
+ * @gfp_flag_name: Type of kmemory to allocate(in string format)
+ * @ptr: Pointer to the kmemory allocated
+ */
+
+probe vm.kmem_cache_alloc = __vm.kmem_cache_alloc.tp !,
+			    __vm.kmem_cache_alloc.kp
+{
+	name = "kmem_cache_alloc"
+}
+
+probe __vm.kmalloc_node.tp = kernel.trace("kmalloc_node") ?
+{
+	call_site = $call_site
+	caller_function = symname(call_site)
+	bytes_req = $bytes_req
+	bytes_alloc = $bytes_alloc
+	gfp_flags = $gfp_flags
+	gfp_flag_name = __gfp_flag_str($gfp_flags)
+	ptr = $ptr
+}
+
+probe __vm.kmalloc_node.kp = kernel.function("kmalloc_node").return ?
+{
+	call_site = 0
+	caller_function = "unknown"
+	bytes_req = $size
+	bytes_alloc = bytes_req // pretend they are always the same
+
+	# Unfortunately, on i686 f11 (2.6.29.4-167.fc11.i686.PAE), we
+	# can't see the '$flags' argument (even though we can see the
+	# '$size' argument above).  Note that we can see the '$flags'
+	# argument on x86_64 f11 (2.6.29.4-167.fc11.x86_64).  So, the
+	# best we can do here is just use 0 when $flags isn't defined.
+	gfp_flags = (@defined($flags) ? $flags : 0)
+	gfp_flag_name = __gfp_flag_str(@defined($flags) ? $flags : 0)
+
+	ptr = $return
+}
+
+/**
+ * probe vm.kmalloc_node - Fires when kmalloc_node is requested.
+ * @name: Name of the probe point
+ * @call_site: Address of the function caling this  kmemory function.
+ * @caller_function: Name of the caller function.
+ * @bytes_req: Requested Bytes
+ * @bytes_alloc: Allocated Bytes
+ * @gfp_flags: type of kmemory to allocate
+ * @gfp_flag_name: Type of kmemory to allocate(in string format)
+ * @ptr: Pointer to the kmemory allocated
+ */
+probe vm.kmalloc_node = __vm.kmalloc_node.tp !, __vm.kmalloc_node.kp ?
+{
+	name = "kmalloc_node"
+}
+
+probe __vm.kmem_cache_alloc_node.tp = kernel.trace("kmem_cache_alloc_node") ?
+{
+	call_site = $call_site
+	caller_function = symname(call_site)
+	bytes_req = $bytes_req
+	bytes_alloc = $bytes_alloc
+	gfp_flags = $gfp_flags
+	gfp_flag_name = __gfp_flag_str($gfp_flags)
+	ptr = $ptr
+}
+
+probe __vm.kmem_cache_alloc_node.kp =
+		kernel.function("kmem_cache_alloc_node").return ?
+{
+	call_site = 0
+	caller_function = "unknown"
+	// Note that 'bytes_req' could be wrong.  By the time
+	// kmem_cache_alloc* gets called the requested size could have
+	// rounded up to the nearest cache alloc size.
+	if (@defined($s)) {
+		bytes_req = $s->size
+		bytes_alloc = $s->size
+	}
+	else if (@defined($cachep->buffer_size)) {
+		bytes_req = $cachep->buffer_size
+		bytes_alloc = $cachep->buffer_size
+	}
+	else {
+		bytes_req = $cachep->objsize
+		bytes_alloc = $cachep->objsize
+	}
+
+	// kmem_cache_alloc_node() doesn't get a flags argument.  But,
+	// internally it uses GFP_KERNEL().
+	gfp_flags = GFP_KERNEL()
+	gfp_flag_name = __gfp_flag_str(gfp_flags)
+	ptr = $return
+}
+
+/**
+ * probe vm.kmem_cache_alloc_node - Fires when \
+ *              kmem_cache_alloc_node is requested.
+ * @name: Name of the probe point
+ * @call_site: Address of the function calling this kmemory function.
+ * @caller_function: Name of the caller function.
+ * @bytes_req: Requested Bytes
+ * @bytes_alloc: Allocated Bytes
+ * @gfp_flags: type of kmemory to allocate
+ * @gfp_flag_name: Type of kmemory to allocate(in string format)
+ * @ptr: Pointer to the kmemory allocated
+ */
+probe vm.kmem_cache_alloc_node = __vm.kmem_cache_alloc_node.tp !,
+				 __vm.kmem_cache_alloc_node.kp ?
+{
+	name = "kmem_cache_alloc_node"
+}
+
+probe __vm.kfree.tp = kernel.trace("kfree")
+{
+	call_site = $call_site
+	caller_function = symname(call_site)
+	ptr = $ptr
+}
+
+probe __vm.kfree.kp = kernel.function("kfree").return
+{
+	call_site = 0
+	caller_function = "unknown"
+	ptr = (@defined($x) ? $x : $objp)
+}
+
+/**
+ * probe vm.kfree - Fires when kfree is requested.
+ * @name: Name of the probe point
+ * @call_site: Address of the function calling this kmemory function.
+ * @caller_function: Name of the caller function.
+ * @ptr: Pointer to the kmemory allocated which is returned by kmalloc
+ */
+probe vm.kfree = __vm.kfree.tp !, __vm.kfree.kp
+{
+	name = "kfree"
+}
+
+probe __vm.kmem_cache_free.tp = kernel.trace("kmem_cache_free")
+{
+	call_site = $call_site
+	caller_function = symname(call_site)
+	ptr = $ptr
+}
+probe __vm.kmem_cache_free.kp = kernel.function("kmem_cache_free").return
+{
+	call_site = 0
+	caller_function = "unknown"
+	ptr = (@defined($x) ? $x : $objp)
+}
+
+/**
+ * probe vm.kmem_cache_free - Fires when \
+ *              kmem_cache_free is requested.
+ * @name: Name of the probe point
+ * @call_site: Address of the function calling this kmemory function.
+ * @caller_function: Name of the caller function.
+ * @ptr: Pointer to the kmemory allocated which is returned by kmem_cache
+ */
+probe vm.kmem_cache_free = __vm.kmem_cache_free.tp !, __vm.kmem_cache_free.kp
+{
+	name = "kmem_cache_free"
+}

=== added file '.pc/Updated-memory.stp-rpc.stp-task.stp-and-vfs.stp-for-.patch/tapset/rpc.stp'
--- .pc/Updated-memory.stp-rpc.stp-task.stp-and-vfs.stp-for-.patch/tapset/rpc.stp	1970-01-01 00:00:00 +0000
+++ .pc/Updated-memory.stp-rpc.stp-task.stp-and-vfs.stp-for-.patch/tapset/rpc.stp	2011-03-22 12:11:00 +0000
@@ -0,0 +1,1185 @@
+// rpc tapset
+// Copyright (C) 2006 IBM Corp.
+// Copyright (C) 2007 Bull S.A.S
+// Copyright (C) 2008, 2010 Red Hat
+//
+// 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.
+
+%{
+// Includes everything needed for __rpc_prot_from_protocol().
+#include <linux/sunrpc/clnt.h>
+%}
+
+probe sunrpc.entry =
+	sunrpc.clnt.entry,
+	sunrpc.svc.entry,
+	sunrpc.sched.entry
+{}
+
+probe sunrpc.return = 
+	sunrpc.clnt.return,
+	sunrpc.svc.return,
+	sunrpc.sched.return
+{}
+
+/******************************************************************
+ *                Probe points on RPC client functions            *  
+ ******************************************************************/
+
+probe sunrpc.clnt.entry = 
+	sunrpc.clnt.create_client,
+	sunrpc.clnt.clone_client,
+	sunrpc.clnt.bind_new_program,
+	sunrpc.clnt.shutdown_client,
+	sunrpc.clnt.call_sync,
+	sunrpc.clnt.call_async,
+	sunrpc.clnt.restart_call
+{}
+
+probe sunrpc.clnt.return = 
+	sunrpc.clnt.create_client.return,
+	sunrpc.clnt.clone_client.return,
+	sunrpc.clnt.bind_new_program.return,
+	sunrpc.clnt.shutdown_client.return,
+	sunrpc.clnt.call_sync.return,
+	sunrpc.clnt.call_async.return,
+	sunrpc.clnt.restart_call.return
+{}
+
+/*
+ * Fires when an RPC client is to be created
+ * 
+ * kernels > 2.6.18
+ *
+ *  struct rpc_clnt *
+ *  rpc_create(struct rpc_create_args *args)
+ *	The rpc_create() function is used to create an RPC client.  It
+ *	calculates some arguments (such as args->servername), then
+ *	calls rpc_new_client().  We need the calculated arguments, so
+ *	we'll probe rpc_new_client().  But, see discussion of
+ *	sunrpc.clnt.create_client.return below.
+ *
+ *  static struct rpc_clnt *
+ *  rpc_new_client(const struct rpc_create_args *args, struct rpc_xprt *xprt)
+ *
+ * kernels <= 2.6.18
+ *
+ *  static struct rpc_clnt * 
+ *  rpc_new_client(struct rpc_xprt *xprt, char *servname, 
+ *	struct rpc_program *program, u32 vers, 
+ *	rpc_authflavor_t flavor)
+ * 
+ *  struct rpc_clnt * 
+ *  rpc_create_client(struct rpc_xprt *xprt, char *servname, 
+ *  	struct rpc_program *info, u32 version, 
+ * 	rpc_authflavor_t authflavor)
+ *
+ *  @servername: the server machine name
+ *  @progname:   the RPC program name
+ *  @prog:       the RPC program number
+ *  @vers:	 the RPC program version number
+ *  @prot:	 the IP protocol number
+ *  @port:	 the port number
+ *  @authflavor: the authentication flavor
+ */
+probe sunrpc.clnt.create_client =
+	_sunrpc.clnt.create_client.rpc_new_client_inline !,
+	_sunrpc.clnt.create_client.rpc_new_client ?,
+	_sunrpc.clnt.create_client.rpc_create_client ?
+{
+	name = "sunrpc.clnt.create_client"
+	argstr = sprintf("%s %s %d %d %d %d %d", servername, progname, 
+		prog, vers, prot, port, authflavor)
+}
+
+/*
+ * Newer kernels (> 2.6.18) compiled with gcc less than version
+ * 4.4.3-16, tend to have debuginfo that doesn't include location
+ * information for inline function arguments.  This is a problem, since
+ * we need the arguments to rpc_new_client(), which is inline.  Since
+ * we can't get them for those kernels, we stash (and delete) the value
+ * of the 'args' parameter of rpc_create().  We then use this value
+ * when probing the inline version of rpc_new_client() (if we don't
+ * have the real arguments to that inline function).
+ */
+
+global __rpc_create_args
+
+probe kernel.function("rpc_create") !,
+	module("sunrpc").function("rpc_create") ?
+{
+	__rpc_create_args[tid()] = $args
+}
+	
+probe kernel.function("rpc_create").return !,
+	module("sunrpc").function("rpc_create").return ?
+{
+	delete __rpc_create_args[tid()]
+}
+
+
+/*
+ * This function could be written in script language, but we'd need
+ * embedded-C functions for XPRT_TRANSPORT_{UDP,TCP,BC_TCP} and
+ * IPPROTO_{UDP,TCP}.  So, do it all in embedded-C.
+ */
+
+function __rpc_prot_from_protocol:long(protocol:long)
+%{
+	switch (THIS->protocol) {
+#ifdef XPRT_TRANSPORT_BC
+	case XPRT_TRANSPORT_UDP:
+		THIS->__retvalue = IPPROTO_UDP;
+		break;
+	case XPRT_TRANSPORT_TCP:
+	case XPRT_TRANSPORT_BC_TCP:
+		THIS->__retvalue = IPPROTO_TCP;
+		break;
+#endif
+	default:
+		THIS->__retvalue = -1;
+		break;
+	}
+%}
+
+/*
+ * The probe for the inline version of "rpc_new_client" (kernels >
+ * 2.6.18) and the non-inline version of "rpc_new_client" (kernels <=
+ * 2.6.18) could be combined.  However, the optimizer isn't smart
+ * enough to optimize away the '__rpc_create_args' global then.
+ */
+
+probe _sunrpc.clnt.create_client.rpc_new_client_inline =
+	kernel.function("rpc_new_client").inline !,
+	module("sunrpc").function("rpc_new_client").inline
+{
+	if (@defined($args)) {		# kernel > 2.6.18 (with good debuginfo)
+		servername = kernel_string($args->servername)
+		progname = kernel_string($args->program->name)
+		prog = $args->prognumber
+		vers = vers_from_prog($args->program, $args->version)
+		authflavor = $args->authflavor
+
+		prot = $xprt->prot
+		port = (@defined($xprt->port)
+			? $xprt->port : port_from_xprt($xprt))
+	}
+	else {				# kernel > 2.6.18 (with bad debuginfo)
+		args = __rpc_create_args[tid()]
+		servername = kernel_string(@cast(args, "rpc_create_args", "kernel:sunrpc")->servername)
+		progname = kernel_string(@cast(args, "rpc_create_args", "kernel:sunrpc")->program->name)
+		prog = @cast(args, "rpc_create_args", "kernel:sunrpc")->prognumber
+		vers = vers_from_prog(@cast(args, "rpc_create_args", "kernel:sunrpc")->program, @cast(args, "rpc_create_args", "kernel:sunrpc")->version)
+		authflavor = @cast(args, "rpc_create_args", "kernel:sunrpc")->authflavor
+
+		prot = __rpc_prot_from_protocol(@cast(args, "rpc_create_args", "kernel:sunrpc")->protocol)
+		# Since we can't find $xprt, we can't know the port
+		port = -1
+	}
+}
+
+probe _sunrpc.clnt.create_client.rpc_new_client =
+	kernel.function("rpc_new_client").call !,
+	module("sunrpc").function("rpc_new_client").call
+{
+	# kernel <= 2.6.18
+	servername = kernel_string($servname)
+	progname = kernel_string($program->name)
+	prog = $program->number
+	vers = vers = vers_from_prog($program, $vers)
+	authflavor = $flavor
+
+	prot = $xprt->prot
+	port = (@defined($xprt->port)
+		? $xprt->port : port_from_xprt($xprt))
+}
+
+probe _sunrpc.clnt.create_client.rpc_create_client =
+	kernel.function("rpc_create_client") !,
+	module("sunrpc").function("rpc_create_client")
+{
+	servername = kernel_string($servname)
+	if (@defined($info)) {
+		progname = kernel_string($info->name)
+		prog = $info->number
+		vers = vers_from_prog($info, $version)
+		authflavor = $authflavor
+	}
+	else {
+		progname = kernel_string($program->name)
+		prog = $program->number
+		vers = vers_from_prog($program, $vers)
+		authflavor = $flavor
+	}
+
+	prot = $xprt->prot
+	port = (@defined($xprt->port)
+		? $xprt->port : port_from_xprt($xprt))
+}
+
+/*
+ * On newer kernels, we want to probe the return of rpc_new_client()
+ * here.  But because of problems with return probes on inline
+ * functions (PR 4413), we have to probe the return of rpc_create()
+ * instead.  So, if we find the return of rpc_create() (the only
+ * caller of rpc_new_client()), we're done.
+ */
+probe sunrpc.clnt.create_client.return =
+	_sunrpc.clnt.create_client.return.rpc_create !,
+	_sunrpc.clnt.create_client.return.rpc_new_client ?,
+	_sunrpc.clnt.create_client.return.rpc_create_client ?
+{
+	name = "sunrpc.clnt.create_client.return"
+	retstr = returnstr(2)
+}
+
+probe _sunrpc.clnt.create_client.return.rpc_create =
+	kernel.function("rpc_create").return !,
+	module("sunrpc").function("rpc_create").return
+{
+}
+
+probe _sunrpc.clnt.create_client.return.rpc_new_client =
+	kernel.function("rpc_new_client").return !,
+	module("sunrpc").function("rpc_new_client").return
+{
+}
+
+probe _sunrpc.clnt.create_client.return.rpc_create_client = 
+	kernel.function("rpc_create_client").return !,
+	module("sunrpc").function("rpc_create_client").return
+{
+}
+
+/*
+ * Fires when the RPC client structure is to be cloned
+ * 
+ * struct rpc_clnt * rpc_clone_client(struct rpc_clnt *clnt)
+ * 
+ *  @servername: the server machine name
+ *  @progname:   the RPC program name
+ *  @prog:       the RPC program number
+ *  @vers:	 the RPC program version number
+ *  @prot:	 the IP protocol number
+ *  @port:	 the port number
+ *  @authflavor: the authentication flavor
+ */
+probe sunrpc.clnt.clone_client = kernel.function("rpc_clone_client") !,
+      	module("sunrpc").function("rpc_clone_client")
+{
+	servername = kernel_string($clnt->cl_server)
+	progname = kernel_string($clnt->cl_protname)
+	prog = prog_from_clnt($clnt)
+	vers = vers_from_clnt($clnt)
+	prot = prot_from_clnt($clnt)
+	port = port_from_clnt($clnt)
+	authflavor = $clnt->cl_auth->au_flavor
+	
+	name = "sunrpc.clnt.clone_client"
+	argstr = sprintf("%s %s %d %d %d %d %d", servername, progname, 
+			prog, vers, prot, port, authflavor)
+}
+
+probe sunrpc.clnt.clone_client.return = 
+	kernel.function("rpc_clone_client").return !,
+      	module("sunrpc").function("rpc_clone_client").return
+{
+	name = "sunrpc.clnt.clone_client.return"
+	retstr = returnstr(2)
+}
+
+/*
+ * Fires when an RPC client is to be shut down.
+ *
+ * int rpc_shutdown_client(struct rpc_clnt *clnt)
+ *
+ *  @servername: the server machine name
+ *  @progname:   the RPC program name
+ *  @prog:       the RPC program number
+ *  @vers:	 the RPC program version number
+ *  @prot:	 the IP protocol number
+ *  @port:	 the port number
+ *  @authflavor: the authentication flavor
+ *  
+ *  @clones:     the number of clones
+ *  @tasks:      the number of references
+ *  
+ *  @netreconn:  the count of reconnections
+ *  @rpccnt:     the count of RPC calls
+ *  @om_ops:      the count of operations
+ *  @om_ntrans:   the count of RPC transmissions
+ *  @om_bytes_sent: the count of bytes out
+ *  @om_bytes_recv: the count of bytes in
+ *  @om_queue:    the jiffies queued for xmit
+ *  @om_rtt:      the RPC RTT jiffies
+ *  @om_execute:  the RPC execution jiffies
+ */
+probe sunrpc.clnt.shutdown_client = kernel.function("rpc_shutdown_client") !,
+      	module("sunrpc").function("rpc_shutdown_client")
+{
+	servername = kernel_string($clnt->cl_server)
+	progname = kernel_string($clnt->cl_protname)
+	prog = prog_from_clnt($clnt)
+	vers = vers_from_clnt($clnt)
+	prot = prot_from_clnt($clnt)
+	port = port_from_clnt($clnt)
+	authflavor = $clnt->cl_auth->au_flavor
+	clones = clones_from_clnt($clnt)
+	tasks = tasks_from_clnt($clnt)
+
+	/* per-program statistics */
+	netreconn = $clnt->cl_stats->netreconn
+	rpccnt = $clnt->cl_stats->rpccnt
+
+	/* per-client statistics */
+	if (@defined($clnt->cl_metrics)) {
+		om_ops = $clnt->cl_metrics->om_ops
+		om_ntrans = $clnt->cl_metrics->om_ntrans
+		om_bytes_sent = $clnt->cl_metrics->om_bytes_sent
+		om_bytes_recv = $clnt->cl_metrics->om_bytes_recv
+		if (@defined($clnt->cl_metrics->om_queue->tv64)) {
+  		      om_queue = $clnt->cl_metrics->om_queue->tv64
+		      om_rtt = $clnt->cl_metrics->om_rtt->tv64
+		      om_execute = $clnt->cl_metrics->om_execute->tv64
+		}
+		else
+		{
+  		      om_queue = $clnt->cl_metrics->om_queue
+		      om_rtt = $clnt->cl_metrics->om_rtt
+		      om_execute = $clnt->cl_metrics->om_execute
+		}
+	}
+	else {
+		om_ops = -1
+		om_ntrans = -1
+		om_bytes_sent = -1
+		om_bytes_recv = -1
+		om_queue = -1
+		om_rtt = -1
+		om_execute = -1
+	}
+
+	name = "sunrpc.clnt.shutdown_client"
+	argstr = sprintf("%s %s %d %d %d %d %d %d %d", servername, progname, 
+			prog, vers, prot, port, authflavor, clones, tasks)
+}
+
+probe sunrpc.clnt.shutdown_client.return = 
+	kernel.function("rpc_shutdown_client").return !,
+      	module("sunrpc").function("rpc_shutdown_client").return
+{
+	name = "sunrpc.clnt.shutdown_client.return"
+	retstr = returnstr(1)
+}
+
+/*
+ * Fires when a new RPC program is to be bound an existing client
+ *
+ * struct rpc_clnt * rpc_bind_new_program(struct rpc_clnt *old, 
+ * 	struct rpc_program *program, int vers)
+ *
+ *  @servername:     the server machine name
+ *  @old_progname:   the name of old RPC program
+ *  @old_prog:       the number of old RPC program
+ *  @old_vers:	     the version of old RPC program 
+ *  @progname:       the name of new RPC program
+ *  @prog:           the number of new RPC program
+ *  @vers:	     the version of new RPC program 
+ */
+probe sunrpc.clnt.bind_new_program = 
+	kernel.function("rpc_bind_new_program") !,
+      	module("sunrpc").function("rpc_bind_new_program")
+{
+	servername = kernel_string($old->cl_server)
+	old_progname = kernel_string($old->cl_protname)
+	old_prog = prog_from_clnt($old)
+	old_vers = vers_from_clnt($old)
+	progname = kernel_string($program->name)
+	prog = $program->number
+	vers = vers_from_prog($program, $vers)
+
+	name = "sunrpc.clnt.bind_new_program"
+	argstr = sprintf("%s %s %d %s %d", servername, old_progname, 
+			old_vers, progname, vers)
+}
+
+probe sunrpc.clnt.bind_new_program.return = 
+	kernel.function("rpc_bind_new_program").return !,
+      	module("sunrpc").function("rpc_bind_new_program").return
+{
+	name = "sunrpc.clnt.bind_new_program.return"
+	retstr = returnstr(2)
+}
+
+/*
+ * int rpc_call_sync(struct rpc_clnt *clnt, struct rpc_message *msg, 
+ * 	int flags)
+ *
+ *  @servername: the server machine name
+ *  @progname:   the RPC program name
+ *  @prog:       the RPC program number
+ *  @vers:	 the RPC program version number
+ *  @prot:	 the IP protocol number
+ *  @port:	 the port number
+ *  @xid:        current transmission id
+ *  @dead:       whether this client is abandoned
+ *  @procname:   the procedure name in this RPC call
+ *  @proc:       the procedure number in this RPC call
+ *  @flags:      flags
+ */
+probe sunrpc.clnt.call_sync = kernel.function("rpc_call_sync") !,
+      	module("sunrpc").function("rpc_call_sync")
+{
+	servername = kernel_string($clnt->cl_server)
+	progname = kernel_string($clnt->cl_protname)
+	prog = prog_from_clnt($clnt)
+	vers = vers_from_clnt($clnt)
+	prot = prot_from_clnt($clnt)
+	port = port_from_clnt($clnt)
+	xid  = xid_from_clnt($clnt)
+	dead = (! @defined($clnt->cl_dead)
+		? (atomic_read(&$clnt->cl_kref->refcount) == 0)
+		: $clnt->cl_dead)
+
+	proc = proc_from_msg($msg)
+	procname = (@defined($msg->rpc_proc->p_name)
+		    ? ($msg->rpc_proc->p_name
+		       ? kernel_string($msg->rpc_proc->p_name) : "NULL")
+		    : "NULL")
+	flags = $flags
+	
+	name = "sunrpc.clnt.call_sync"
+	argstr = sprintf("%s %d %s %d %s %d", servername, xid, progname, 
+			vers, procname, flags)
+}
+
+probe sunrpc.clnt.call_sync.return = kernel.function("rpc_call_sync").return !,
+      	module("sunrpc").function("rpc_call_sync").return
+{
+	name = "sunrpc.clnt.call_sync.return"
+	retstr = returnstr(1)
+}
+
+/*
+ * int rpc_call_async(struct rpc_clnt *clnt, struct rpc_message *msg, 
+ * 	int flags, const struct rpc_call_ops *tk_ops, void *data)
+ *
+ *  @servername: the server machine name
+ *  @progname:   the RPC program name
+ *  @prog:       the RPC program number
+ *  @vers:	 the RPC program version number
+ *  @prot:	 the IP protocol number
+ *  @port:	 the port number
+ *  @xid:        current transmission id
+ *  @dead:       whether this client is abandoned
+ *  @procname:   the procedure name in this RPC call
+ *  @proc:       the procedure number in this RPC call
+ *  @flags:      flags
+ */
+probe sunrpc.clnt.call_async = kernel.function("rpc_call_async") !,
+      	module("sunrpc").function("rpc_call_async")
+{
+	servername = kernel_string($clnt->cl_server)
+	progname = kernel_string($clnt->cl_protname)
+	prog = prog_from_clnt($clnt)
+	vers = vers_from_clnt($clnt)
+	prot = prot_from_clnt($clnt)
+	port = port_from_clnt($clnt)
+	xid  = xid_from_clnt($clnt)
+	dead = (! @defined($clnt->cl_dead)
+		? (atomic_read(&$clnt->cl_kref->refcount) == 0)
+		: $clnt->cl_dead)
+
+	proc = proc_from_msg($msg)
+	procname = (@defined($msg->rpc_proc->p_name)
+		    ? ($msg->rpc_proc->p_name
+		       ? kernel_string($msg->rpc_proc->p_name) : "NULL")
+		    : "NULL")
+	flags = $flags
+	
+	name = "sunrpc.clnt.call_async"
+	argstr = sprintf("%s %d %s %d %s %d", servername, xid, progname, 
+			vers, procname, flags)
+}
+
+probe sunrpc.clnt.call_async.return = 
+	kernel.function("rpc_call_async").return !,
+      	module("sunrpc").function("rpc_call_async").return
+{
+	name = "sunrpc.clnt.call_async.return"
+	retstr = returnstr(1)
+}
+
+/*
+ * Fires when an (async) RPC call is to be restarted
+ *
+ * void rpc_restart_call(struct rpc_task *task)
+ *
+ * @servername:   the server machine name
+ * @prog:         the RPC program number
+ * @xid:          the transmission id
+ * @tk_pid:	  the debugging aid of task
+ * @tk_flags:     the task flags
+ * @tk_priority:  the task priority
+ * @tk_runstate:  the task run status
+ */
+probe sunrpc.clnt.restart_call = kernel.function("rpc_restart_call") !,
+      	module("sunrpc").function("rpc_restart_call")
+{
+	servername = kernel_string($task->tk_client->cl_server)
+	prog = prog_from_clnt($task->tk_client)
+	xid = $task->tk_rqstp->rq_xid
+	tk_pid = $task->tk_pid
+	tk_flags = $task->tk_flags
+	tk_priority = $task->tk_priority
+	tk_runstate = $task->tk_runstate
+
+	name = "sunrpc.clnt.restart_call"
+	argstr = sprintf("%s %d %d %d %d %d %d", servername, prog, xid, tk_pid, 
+			tk_flags, tk_priority, tk_runstate)
+}
+
+probe sunrpc.clnt.restart_call.return = 
+	kernel.function("rpc_restart_call").return !,
+      	module("sunrpc").function("rpc_restart_call").return
+{
+	name = "sunrpc.clnt.restart_call.return"
+	retstr = "N/A"
+}
+
+/*********************************************
+ *    Probe points on RPC server interface   *
+ ********************************************/
+probe sunrpc.svc.entry =
+	sunrpc.svc.register,
+	sunrpc.svc.create,
+	sunrpc.svc.destroy,
+	sunrpc.svc.process,
+	sunrpc.svc.authorise,
+	sunrpc.svc.recv,
+	sunrpc.svc.send,
+	sunrpc.svc.drop
+{}
+
+probe sunrpc.svc.return =
+	sunrpc.svc.register.return,
+	sunrpc.svc.create.return,
+	sunrpc.svc.destroy.return,
+	sunrpc.svc.process.return,
+	sunrpc.svc.authorise.return,
+	sunrpc.svc.recv.return,
+	sunrpc.svc.send.return,
+	sunrpc.svc.drop.return
+{}
+
+/*
+ * Fires when an RPC service is to be registered with the local portmapper.
+ * If proto and port == 0, it means to unregister a service.
+ *
+ * int svc_register(struct svc_serv *serv, int proto, unsigned short port)
+ *
+ * @sv_name:     the service name
+ * @progname:    the name of the program
+ * @prog:        the number of the program
+ * @prot:	 the IP protocol number
+ * @port:	 the port number
+ */
+probe sunrpc.svc.register = kernel.function("svc_register") !,
+      	module("sunrpc").function("svc_register")
+{
+	sv_name = kernel_string($serv->sv_name)
+	progname = kernel_string($serv->sv_program->pg_name)
+	prog = $serv->sv_program->pg_prog
+	prot = $proto
+	port = $port
+
+	name = "sunrpc.svc.register"
+	argstr = sprintf("%s %s %d %d", sv_name, progname, prot, port)
+}
+
+probe sunrpc.svc.register.return = kernel.function("svc_register").return !,
+      	module("sunrpc").function("svc_register").return
+{
+	name = "sunrpc.svc.register.return"
+	retstr = returnstr(1)
+}
+
+/*
+ * Fires when an RPC service is to be created
+ *
+ * struct svc_serv * 
+ * svc_create(struct svc_program *prog, unsigned int bufsize)
+ *
+ * @progname:    the name of the program
+ * @prog:        the number of the program
+ * @pg_nvers:	 the number of supported versions
+ * @bufsize:     the buffer size
+ */
+probe sunrpc.svc.create = kernel.function("svc_create") !,
+      	module("sunrpc").function("svc_create")
+{
+	progname = kernel_string($prog->pg_name)
+	prog = $prog->pg_prog
+	pg_nvers  = $prog->pg_nvers
+	bufsize = $bufsize
+	
+	name = "sunrpc.svc.create"
+	argstr = sprintf("%s %d %d %d", progname, prog, pg_nvers, bufsize)
+}
+
+probe sunrpc.svc.create.return = kernel.function("svc_create").return !,
+      	module("sunrpc").function("svc_create").return
+{
+	name = "sunrpc.svc.create.return"
+	retstr = returnstr(2)
+}
+
+/*
+ * Fires when an RPC service is to be destroyed
+ *
+ * void svc_destroy(struct svc_serv *serv)
+ *
+ * @sv_name:     the service name
+ * @sv_progname: the name of the program
+ * @sv_prog:     the number of the program
+ * @sv_nrthreads:the number of concurrent threads
+ * @netcnt:      the count of received RPC requests
+ * @nettcpconn:  the count of accepted TCP connections
+ * @rpccnt:      the count of valid RPC requests
+ * @rpcbadfmt:   the count of requests dropped for bad formats
+ * @rpcbadauth:  the count of requests drooped for authentication failure
+ */
+probe sunrpc.svc.destroy = kernel.function("svc_destroy") !,
+      	module("sunrpc").function("svc_destroy")
+{
+	sv_name = kernel_string($serv->sv_name) /* service name */
+	sv_progname = kernel_string($serv->sv_program->pg_name)
+	sv_prog = $serv->sv_program->pg_prog
+	sv_nrthreads = $serv->sv_nrthreads
+
+	/* RPC statistics */
+	netcnt = $serv->sv_stats->netcnt
+	netcpconn = $serv->sv_stats->nettcpconn
+	rpccnt = $serv->sv_stats->rpccnt
+	rpcbadfmt = $serv->sv_stats->rpcbadfmt
+	rpcbadauth = $serv->sv_stats->rpcbadauth
+	
+	name = "sunrpc.svc.destroy"
+	argstr = sprintf("%s %d %d", sv_name, sv_prog, sv_nrthreads)
+}
+
+probe sunrpc.svc.destroy.return = kernel.function("svc_destroy").return !,
+      	module("sunrpc").function("svc_destroy").return
+{
+	name = "sunrpc.svc.destroy.return"
+	retstr = "N/A"
+}
+
+/*
+ * Fires when an RPC request is to be processed
+ *
+ * int svc_process(struct svc_serv *serv, struct svc_rqst *rqstp)
+ *
+ * @sv_name:     the service name
+ * @sv_prog:     the number of the program
+ * @sv_nrthreads:the number of concurrent threads
+ * @peer_ip:     the peer address where the request is from
+ * @rq_xid:      the transmission id in the request
+ * @rq_prog:     the program number in the request
+ * @rq_vers:     the program version in the request
+ * @rq_proc:     the procedure number in the request
+ * @rq_prot:     the IP protocol of the reqeust
+ */
+probe sunrpc.svc.process = kernel.function("svc_process") !,
+      	module("sunrpc").function("svc_process")
+{
+	if (! @defined($serv)) {
+		sv_name = kernel_string($rqstp->rq_server->sv_name)
+		sv_prog = $rqstp->rq_server->sv_program->pg_prog
+		sv_nrthreads = $rqstp->rq_server->sv_nrthreads
+	}
+	else {
+		sv_name = kernel_string($serv->sv_name) /* service name */
+		sv_prog = $serv->sv_program->pg_prog
+		sv_nrthreads = $serv->sv_nrthreads
+	}
+	peer_ip = addr_from_rqst($rqstp)
+	rq_xid = $rqstp->rq_xid
+	rq_prog = $rqstp->rq_prog
+	rq_vers = $rqstp->rq_vers
+	rq_proc = $rqstp->rq_proc
+	rq_prot = $rqstp->rq_prot
+	
+	name = "sunrpc.svc.process"
+	argstr = sprintf("%s %d %d %d %d %d %d", sv_name, sv_prog, peer_ip,
+			rq_xid, rq_prog, rq_vers, rq_proc)
+}
+
+probe sunrpc.svc.process.return = kernel.function("svc_process").return !,
+      	module("sunrpc").function("svc_process").return
+{
+	name = "sunrpc.svc.process.return"
+	retstr = returnstr(1)
+}
+
+/* 
+ * Fires when an RPC request is to be authorised
+ *
+ * int svc_authorise(struct svc_rqst *rqstp)
+ *
+ * @sv_name:     the service name
+ * @peer_ip:     the peer address where the request is from
+ * @rq_xid:      the transmission id in the request
+ * @rq_prog:     the program number in the request
+ * @rq_vers:     the program version in the request
+ * @rq_proc:     the procedure number in the request
+ * @rq_prot:     the IP protocol of the reqeust
+ */
+probe sunrpc.svc.authorise = kernel.function("svc_authorise") !,
+      	module("sunrpc").function("svc_authorise")
+{
+	sv_name = kernel_string($rqstp->rq_server->sv_name)
+	peer_ip = addr_from_rqst($rqstp)
+	rq_xid  = $rqstp->rq_xid
+	rq_prog = $rqstp->rq_prog
+	rq_vers = $rqstp->rq_vers
+	rq_proc = $rqstp->rq_proc
+	rq_prot = $rqstp->rq_prot
+
+	name = "sunrpc.svc.authorise"
+	argstr = sprintf("%d %d %d %d %d %d", peer_ip, rq_xid, rq_prog, 
+			rq_vers, rq_proc, rq_prot)
+}
+
+probe sunrpc.svc.authorise.return = kernel.function("svc_authorise").return !,
+      	module("sunrpc").function("svc_authorise").return
+{
+	name = "sunrpc.svc.authorise.return"
+	retstr = returnstr(1)
+}
+
+/*
+ * Fires when the server is to receive the next request on any socket.
+ *
+ * int svc_recv(struct svc_serv *serv, struct svc_rqst *rqstp, long timeout)
+ *
+ * @sv_name:     the service name
+ * @sv_prog:     the number of the program
+ * @sv_nrthreads:the number of concurrent threads
+ * @timeout:     the timeout of waiting for data
+ */
+probe sunrpc.svc.recv = kernel.function("svc_recv") !,
+      	module("sunrpc").function("svc_recv")
+{
+	if (! @defined($serv)) {
+	        sv_name = kernel_string($rqstp->rq_server->sv_name) 
+        	sv_prog = $rqstp->rq_server->sv_program->pg_prog
+	        sv_nrthreads = $rqstp->rq_server->sv_nrthreads
+	}
+	else {
+		sv_name = kernel_string($serv->sv_name)	
+		sv_prog = $serv->sv_program->pg_prog
+		sv_nrthreads = $serv->sv_nrthreads
+	}
+	timeout = $timeout
+
+	name = "sunrpc.svc.recv"
+	argstr = sprintf("%s %d", sv_name, timeout)
+}
+
+probe sunrpc.svc.recv.return = kernel.function("svc_recv").return !,
+      	module("sunrpc").function("svc_recv").return
+{
+	name = "sunrpc.svc.recv.return"
+	retstr = returnstr(1)
+}
+
+/*
+ * Fires when want to return reply to client.
+ *
+ * int svc_send(struct svc_rqst *rqstp)
+ *
+ * @sv_name:     the service name
+ * @peer_ip:     the peer address where the request is from
+ * @rq_xid:      the transmission id in the request
+ * @rq_prog:     the program number in the request
+ * @rq_vers:     the program version in the request
+ * @rq_proc:     the procedure number in the request
+ * @rq_prot:     the IP protocol of the reqeust
+ */
+probe sunrpc.svc.send = kernel.function("svc_send") !,
+      	module("sunrpc").function("svc_send")
+{
+	sv_name = kernel_string($rqstp->rq_server->sv_name)
+	peer_ip = addr_from_rqst($rqstp)
+	rq_xid  = $rqstp->rq_xid
+	rq_prog = $rqstp->rq_prog
+	rq_vers = $rqstp->rq_vers
+	rq_proc = $rqstp->rq_proc
+	rq_prot = $rqstp->rq_prot
+	
+	name = "sunrpc.svc.send"
+	argstr = sprintf("%s %d %d %d %d %d %d", sv_name, peer_ip, 
+			rq_xid, rq_prog, rq_vers, rq_proc, rq_prot)
+}
+
+probe sunrpc.svc.send.return = kernel.function("svc_send").return !,
+      	module("sunrpc").function("svc_send").return
+{
+	name = "sunrpc.svc.send.return"
+	retstr = returnstr(1)
+}
+
+/*
+ * Fires when a request is to be dropped
+ *
+ * void svc_drop(struct svc_rqst *rqstp)
+ *
+ * @sv_name:     the service name
+ * @peer_ip:     the peer address where the request is from
+ * @rq_xid:      the transmission id in the request
+ * @rq_prog:     the program number in the request
+ * @rq_vers:     the program version in the request
+ * @rq_proc:     the procedure number in the request
+ * @rq_prot:     the IP protocol of the reqeust
+ */
+probe sunrpc.svc.drop = kernel.function("svc_drop") !,
+      	module("sunrpc").function("svc_drop")
+{
+	sv_name = kernel_string($rqstp->rq_server->sv_name)
+	peer_ip = addr_from_rqst($rqstp)
+	rq_xid  = $rqstp->rq_xid
+	rq_prog = $rqstp->rq_prog
+	rq_vers = $rqstp->rq_vers
+	rq_proc = $rqstp->rq_proc
+	rq_prot = $rqstp->rq_prot
+	
+	name = "sunrpc.svc.drop"
+	argstr = sprintf("%s %d %d %d %d %d %d", sv_name, peer_ip, 
+			rq_xid, rq_prog, rq_vers, rq_proc, rq_prot)
+}
+
+probe sunrpc.svc.drop.return = kernel.function("svc_drop").return !,
+      	module("sunrpc").function("svc_drop").return
+{
+	name = "sunrpc.svc.drop.return"
+	retstr = "N/A"
+}
+
+/*******************************************************************
+ *                  Probe points on RPC scheduler                  *
+ ******************************************************************/
+probe sunrpc.sched.entry =
+	sunrpc.sched.new_task,
+	sunrpc.sched.release_task ?,
+	sunrpc.sched.execute,
+	sunrpc.sched.delay
+{}
+
+probe sunrpc.sched.return =
+	sunrpc.sched.new_task.return,
+	sunrpc.sched.release_task.return ?,
+	sunrpc.sched.execute.return,
+	sunrpc.sched.delay.return
+{}
+
+/*
+ * Fires when a new task is to be created for the specified client.
+ * 
+ * struct rpc_task * rpc_new_task(struct rpc_clnt *clnt, int flags, 
+ * 	const struct rpc_call_ops *tk_ops, void *calldata)
+ *
+ * @xid:         the transmission id in the RPC call
+ * @prog:        the program number in the RPC call
+ * @vers:        the program version in the RPC call
+ * @prot:        the IP protocol in the RPC call
+ * @tk_flags:    the flags of the task
+ */
+probe sunrpc.sched.new_task = kernel.function("rpc_new_task") !,
+      	module("sunrpc").function("rpc_new_task")
+{
+	if (@defined($setup_data)) {
+		xid = xid_from_clnt($setup_data->rpc_client)
+		prog = prog_from_clnt($setup_data->rpc_client)
+		vers = vers_from_clnt($setup_data->rpc_client)
+		prot = prot_from_clnt($setup_data->rpc_client)
+		flags = $setup_data->flags
+	}
+	else {
+		xid = xid_from_clnt($clnt)
+		prog = prog_from_clnt($clnt)
+		vers = vers_from_clnt($clnt)
+		prot = prot_from_clnt($clnt)
+		flags = $flags
+	}
+
+	name = "sunrpc.sched.new_task"
+	argstr = sprintf("%d %d %d %d %d", xid, prog, vers, prot, flags)
+}
+
+probe sunrpc.sched.new_task.return = kernel.function("rpc_new_task").return !,
+      	module("sunrpc").function("rpc_new_task").return
+{
+	name = "sunrpc.sched.new_task.return"
+	retstr = returnstr(2)
+}
+
+/*
+ * Fires when all resources associated with a task are to be released
+ * 
+ * void rpc_release_task(struct rpc_task *task)
+ *
+ * @xid:         the transmission id in the RPC call
+ * @prog:        the program number in the RPC call
+ * @vers:        the program version in the RPC call
+ * @prot:        the IP protocol in the RPC call
+ * @tk_flags:    the flags of the task
+ *
+ * rpc_release_task() might not be found for a particular kernel.  So,
+ * if we can't find it, just return '-1' for everything.
+ *
+ * The '.call' here is so that we're sure to grab the non-inline
+ * version of rpc_release_task() (assuming it exists).  We can't find
+ * the return of rpc_release_task() if it is inline (PR 4413).
+ */
+
+probe sunrpc.sched.release_task = kernel.function("rpc_release_task").call !,
+      	module("sunrpc").function("rpc_release_task").call !,
+	never
+{
+	if (@defined($task)) {
+		xid = xid_from_clnt($task->tk_client)
+		prog = prog_from_clnt($task->tk_client)
+		vers = vers_from_clnt($task->tk_client)
+		prot = prot_from_clnt($task->tk_client)
+		tk_flags  = $task->tk_flags
+	}
+	else {
+		xid = -1
+		prog = -1
+		vers = -1
+		prot = -1
+		tk_flags  = -1
+	}
+	name = "sunrpc.sched.release_task"
+	argstr = sprintf("%d %d %d %d %d", xid, prog, vers, prot, tk_flags)
+}
+
+probe sunrpc.sched.release_task.return = 
+	kernel.function("rpc_release_task").return !,
+      	module("sunrpc").function("rpc_release_task").return ?
+{
+	name = "sunrpc.sched.release_task.return"
+	retstr = "N/A"
+}
+
+/*
+ * Fires when the RPC `scheduler'(or rather, the finite state machine) 
+ * is to be executed 
+ *
+ * static int __rpc_execute(struct rpc_task *task)
+ *
+ * @xid:         the transmission id in the RPC call
+ * @prog:        the program number in the RPC call
+ * @vers:        the program version in the RPC call
+ * @prot:        the IP protocol in the RPC call
+ * @tk_pid:      the debugging id of the task
+ * @tk_flags:    the flags of the task
+ */
+probe sunrpc.sched.execute = kernel.function("__rpc_execute") !,
+      	module("sunrpc").function("__rpc_execute")
+{
+	xid = xid_from_clnt($task->tk_client)
+	prog = prog_from_clnt($task->tk_client)
+	vers = vers_from_clnt($task->tk_client)
+	prot = prot_from_clnt($task->tk_client)
+	tk_pid = $task->tk_pid
+	tk_flags = $task->tk_flags
+
+	name = "sunrpc.sched.execute"
+	argstr = sprintf("%d %d %d %d %d %d", xid, prog, vers, prot, 
+			tk_pid, tk_flags)
+}
+
+probe sunrpc.sched.execute.return = kernel.function("__rpc_execute").return !,
+      	module("sunrpc").function("__rpc_execute").return
+{
+	name = "sunrpc.sched.execute.return"
+
+	# On kernels > 2.6.20, __rpc_execute() is a void function.
+	if (@defined($return)) {
+		retstr = returnstr(1)
+	}
+	else {
+		retstr = "N/A"
+	}
+}
+
+/*
+ * Fires when a task is to be delayed
+ * 
+ * void rpc_delay(struct rpc_task *task, unsigned long delay)
+ *
+ * @xid:         the transmission id in the RPC call
+ * @prog:        the program number in the RPC call
+ * @vers:        the program version in the RPC call
+ * @prot:        the IP protocol in the RPC call
+ * @tk_pid:      the debugging id of the task
+ * @tk_flags:    the flags of the task
+ * @delay:       the time delayed
+ */
+probe sunrpc.sched.delay = kernel.function("rpc_delay") !,
+      module("sunrpc").function("rpc_delay") 
+{
+	xid = xid_from_clnt($task->tk_client)
+	prog = prog_from_clnt($task->tk_client)
+	vers = vers_from_clnt($task->tk_client)
+	prot = prot_from_clnt($task->tk_client)
+	tk_pid = $task->tk_pid
+	tk_flags = $task->tk_flags
+	delay = $delay
+
+	name = "sunrpc.sched.delay"
+	argstr = sprintf("%d %d %d %d %d %d %d", xid, prog, vers, 
+			prot, tk_pid, tk_flags, delay)
+}
+
+probe sunrpc.sched.delay.return = kernel.function("rpc_delay").return !,
+      module("sunrpc").function("rpc_delay").return
+{
+	name = "sunrpc.sched.delay.return"
+	retstr = "N/A"
+}
+
+/******************************************************************
+ *                       Helper functions                        *
+ *****************************************************************/
+
+function xid_from_clnt:long(clnt:long)
+{
+	if (clnt == 0)
+		return 0
+	return @cast(clnt, "rpc_clnt", "kernel:sunrpc")->cl_xprt->xid
+}
+
+function prog_from_clnt:long(clnt:long)
+{
+	if (clnt == 0)
+		return 0
+	if (@defined(@cast(clnt, "rpc_clnt", "kernel:sunrpc")->cl_prog))
+		return @cast(clnt, "rpc_clnt", "kernel:sunrpc")->cl_prog
+	else
+		return @cast(clnt, "rpc_clnt", "kernel:sunrpc")->cl_pmap->pm_prog
+}
+
+function vers_from_clnt:long(clnt:long)
+{
+	if (clnt == 0)
+		return 0
+	if (@defined(@cast(clnt, "rpc_clnt", "kernel:sunrpc")->cl_vers))
+		return @cast(clnt, "rpc_clnt", "kernel:sunrpc")->cl_vers
+	else
+		return @cast(clnt, "rpc_clnt", "kernel:sunrpc")->cl_pmap->pm_vers
+}
+
+function prot_from_clnt:long(clnt:long)
+{
+	if (clnt == 0)
+		return 0
+	return @cast(clnt, "rpc_clnt", "kernel:sunrpc")->cl_xprt->prot
+}
+
+function port_from_xprt:long(cl_xprt:long)
+{
+	if (cl_xprt == 0)
+		return 0
+
+	addr = &@cast(cl_xprt, "rpc_xprt", "kernel:sunrpc")->addr
+	if (addr == 0)
+		return 0
+
+	/* In reality, 'cl_xprt->addr' is of 'sockaddr_storage' type
+	 * (since 2.6.19). But when used, you cast it to what is
+	 * inside that buffer. */
+	if (@cast(addr, "sockaddr_in")->sin_family == AF_INET()) {
+		/* Now consider ipv4 only */ 
+		return ntohs(@cast(addr, "sockaddr_in")->sin_port)
+	}
+	return 0
+}
+
+function port_from_clnt:long(clnt:long)
+{
+	if (clnt == 0)
+		return 0
+
+	cl_xprt = @cast(clnt, "rpc_clnt", "kernel:sunrpc")->cl_xprt
+	return port_from_xprt(cl_xprt)
+}
+
+function clones_from_clnt:long(clnt:long)
+{
+    return (@defined(@cast(clnt, "rpc_clnt", "kernel:sunrpc")->cl_count)
+	    ? atomic_read(&@cast(clnt, "rpc_clnt", "kernel:sunrpc")->cl_count)
+	    : -1)
+}
+
+function tasks_from_clnt:long(clnt:long)
+{
+    return (@defined(@cast(clnt, "rpc_clnt", "kernel:sunrpc")->cl_users)
+	    ? atomic_read(&@cast(clnt, "rpc_clnt", "kernel:sunrpc")->cl_users)
+	    : -1)
+}
+
+function proc_from_msg:long(msg:long)
+{
+	if (msg == 0)
+		return 0
+	return @cast(msg, "rpc_message", "kernel:sunrpc")->rpc_proc->p_proc
+}
+
+function vers_from_prog:long(program:long, vers:long)
+{
+    if (program
+	&& vers < @cast(program, "rpc_program", "kernel:sunrpc")->nrvers)
+	return @cast(program, "rpc_program", "kernel:sunrpc")->version[vers]->number
+    return 0
+}
+
+function addr_from_rqst:long(rqstp:long)
+{
+    if (rqstp) {
+	addr = &@cast(rqstp, "svc_rqst", "kernel:nfs")->rq_addr
+	if (addr == 0)
+		return 0
+
+	/* In reality, 'rq_addr' is of 'sockaddr_storage' type
+	 * (since 2.6.19). But when used, you cast it to what is
+	 * inside that buffer. */
+	if (@cast(addr, "sockaddr_in")->sin_family == AF_INET()) {
+		/* Now consider ipv4 only */ 
+		return @cast(addr, "sockaddr_in")->sin_addr->s_addr
+	}
+    }
+    return 0
+}
+
+function addr_from_rqst_str:string(rqstp:long)
+{
+	if (rqstp == 0)
+		return "Null"
+
+	addr = &@cast(rqstp, "svc_rqst", "kernel:nfs")->rq_addr
+	if (addr == 0)
+		return "Null"
+
+	s_addr = addr_from_rqst(rqstp)
+	if (s_addr == 0)
+		return "Unsupported Address Family"
+	return sprintf("%s:%d", daddr_to_string(s_addr),
+		       @cast(addr, "sockaddr_in")->sin_port)
+}
+

=== added file '.pc/Updated-memory.stp-rpc.stp-task.stp-and-vfs.stp-for-.patch/tapset/task.stp'
--- .pc/Updated-memory.stp-rpc.stp-task.stp-and-vfs.stp-for-.patch/tapset/task.stp	1970-01-01 00:00:00 +0000
+++ .pc/Updated-memory.stp-rpc.stp-task.stp-and-vfs.stp-for-.patch/tapset/task.stp	2011-03-22 12:11:00 +0000
@@ -0,0 +1,384 @@
+// task information tapset
+// Copyright (C) 2006 Intel Corporation.
+// Copyright (C) 2010 Red Hat Inc.
+//
+// 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.
+
+%{
+#include <linux/version.h>
+#include <linux/file.h>
+#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,25)
+#include <linux/fdtable.h>
+#endif
+#ifndef STAPCONF_TASK_UID
+#include <linux/cred.h>
+#endif
+%}
+
+/**
+ * sfunction task_current - The current task_struct of the current task.
+ * 
+ * General Syntax: task_current:long()
+ *
+ * Description: This function returns the task_struct representing the current process.
+ * This address can be passed to the various task_*() functions to extract
+ * more task-specific data.
+ */
+function task_current:long () %{ /* pure */
+    THIS->__retvalue = (long)current;
+%}
+
+/**
+ * sfunction task_parent - The task_struct of the parent task.
+ *
+ * General Syntax: task_parent:long(task:long)
+ *
+ * @task: task_struct pointer.
+ *
+ * Description: This function returns the parent task_struct of
+ * the given task. This address can be passed to the various 
+ * task_*() functions to extract more task-specific data.
+ */
+function task_parent:long(task:long)
+{
+    return (@defined(@cast(task, "task_struct",
+			   "kernel<linux/sched.h>")->real_parent)
+	    ? @cast(task, "task_struct", "kernel<linux/sched.h>")->real_parent
+	    : @cast(task, "task_struct", "kernel<linux/sched.h>")->parent)
+}
+
+/**
+ * sfunction task_state - The state of the task.
+ *
+ * General Syntax: task_state:long(task:long)
+ *
+ * @task: task_struct pointer.
+ *
+ * Description: Return the state of the given task, one of:
+ * TASK_RUNNING (0), TASK_INTERRUPTIBLE (1), TASK_UNINTERRUPTIBLE (2),
+ * TASK_STOPPED (4), TASK_TRACED (8), EXIT_ZOMBIE (16), EXIT_DEAD (32).
+ */
+function task_state:long (task:long)
+{
+    return @cast(task, "task_struct", "kernel<linux/sched.h>")->state
+}
+
+/**
+ * sfunction task_execname - The name of the task.
+ *
+ * General Syntax: task_execname:string(task:long)
+ *
+ * @task: task_struct pointer.
+ *
+ * Description: Return the name of the given task.
+ */
+function task_execname:string (task:long)
+{
+    return kernel_string(@cast(task, "task_struct", "kernel<linux/sched.h>")->comm)
+}
+
+/**
+ * sfunction task_pid - The process identifier of the task.
+ *
+ * General Syntax: task_pid:long (task:long)
+ *
+ * @task: task_struct pointer.
+ *
+ * Description: This fucntion returns the process id of the given task.
+ */
+function task_pid:long (task:long)
+{
+    return @cast(task, "task_struct", "kernel<linux/sched.h>")->tgid
+}
+
+/**
+ * sfunction pid2task - The task_struct of the given process identifier.
+ * @pid: Process identifier.
+ *
+ * Description: Return the task struct of the given process id.
+ */
+function pid2task:long (pid:long) %{ /* pure */
+    struct task_struct *t = NULL;
+    pid_t t_pid  = (pid_t)(long)THIS->pid;
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,31)
+    struct pid *p_pid = find_get_pid(t_pid);
+    t = pid_task(p_pid, PIDTYPE_PID);
+    put_pid(p_pid);
+#else
+    rcu_read_lock();
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
+    t = find_task_by_vpid (t_pid);
+#else
+    t = find_task_by_pid (t_pid);
+#endif /* 2.6.24 */
+    rcu_read_unlock();
+#endif /* 2.6.31 */
+    THIS->__retvalue = (long)t;
+%}
+
+/**
+ * sfunction pid2execname - The name of the given process identifier.
+ * @pid: Process identifier.
+ *
+ * Description: Return the name of the given process id.
+ */
+function pid2execname:string (pid:long) { 
+    tsk = pid2task(pid)
+    if (tsk)
+	return task_execname(tsk)
+    return ""
+}
+
+/**
+ * sfunction task_tid - The thread identifier of the task.
+ *
+ * General Syntax: task_tid:long(task:long)
+ *
+ * @task: task_struct pointer.
+ *
+ * Description: This function returns the thread id of the given task.
+ */
+function task_tid:long (task:long)
+{
+    return @cast(task, "task_struct", "kernel<linux/sched.h>")->pid
+}
+
+
+/**
+ * sfunction task_gid - The group identifier of the task.
+ *
+ * General Syntax: task_gid:long(task:long)
+ *
+ * @task: task_struct pointer.
+ *
+ * Description: This function returns the group id of the given task.
+ */
+function task_gid:long (task:long) %{ /* pure */
+    struct task_struct *t = (struct task_struct *)(long)THIS->task;
+#ifdef STAPCONF_TASK_UID
+    THIS->__retvalue = kread(&(t->gid));
+    CATCH_DEREF_FAULT();
+#else
+    /* XXX: We can't easily kread this rcu-protected field. */
+    /* XXX: no task_gid() in 2.6.28 */
+    struct cred *cred;
+    rcu_read_lock();
+    cred = get_task_cred (t);
+    rcu_read_unlock();
+    THIS->__retvalue = cred->gid;
+#endif
+%}
+
+
+/**
+ * sfunction task_egid - The effective group identifier of the task.
+ *
+ * General Syntax: task_egid:long(task:long)
+ *
+ * @task: task_struct pointer.
+ *
+ * Description: This function returns the effective group id of the given task.
+ */
+function task_egid:long (task:long) %{ /* pure */
+    struct task_struct *t = (struct task_struct *)(long)THIS->task;
+#ifdef STAPCONF_TASK_UID
+    THIS->__retvalue = kread(&(t->egid));
+    CATCH_DEREF_FAULT();
+#else
+    /* XXX: We can't easily kread this rcu-protected field. */
+    /* XXX: no task_egid() in 2.6.28 */
+    struct cred *cred;
+    rcu_read_lock();
+    cred = get_task_cred (t);
+    rcu_read_unlock();
+    THIS->__retvalue = cred->egid;
+#endif
+%}
+
+/**
+ * sfunction task_uid - The user identifier of the task.
+ *
+ * General Syntax: task_uid:long(task:long)
+ * 
+ * @task: task_struct pointer.
+ *
+ * Description: This function returns the user id of the given task.
+ */
+function task_uid:long (task:long) %{ /* pure */
+    struct task_struct *t = (struct task_struct *)(long)THIS->task;
+#ifdef STAPCONF_TASK_UID
+    THIS->__retvalue = kread(&(t->uid));
+    CATCH_DEREF_FAULT();
+#else
+    /* XXX: We can't easily kread this rcu-protected field. */
+    THIS->__retvalue = task_uid (t);
+#endif
+%}
+
+/**
+ * sfunction task_euid - The effective user identifier of the task.
+ *
+ * General Syntax: task_euid:long(task:long)
+ * 
+ * @task: task_struct pointer.
+ *
+ * Description: This function returns the effective user id of the given task.
+ */
+function task_euid:long (task:long) %{ /* pure */
+    struct task_struct *t = (struct task_struct *)(long)THIS->task;
+#ifdef STAPCONF_TASK_UID
+    THIS->__retvalue = kread(&(t->euid));
+    CATCH_DEREF_FAULT();
+#else
+    /* XXX: We can't easily kread this rcu-protected field. */
+    THIS->__retvalue = task_euid (t);
+#endif
+%}
+
+
+/**
+ * sfunction task_prio - The priority value of the task.
+ *
+ * General Syntax: task_prio:long(task:long)
+ *
+ * @task: task_struct pointer.
+ *
+ * Description: This function returns the priority value of the given task.
+ */
+function task_prio:long (task:long) %{ /* pure */
+    struct task_struct *t = (struct task_struct *)(long)THIS->task;
+    THIS->__retvalue =  kread(&(t->prio)) - MAX_RT_PRIO;
+    CATCH_DEREF_FAULT();
+%}
+
+
+/**
+ * sfunction task_nice - The nice value of the task.
+ *
+ * General Syntax: task_nice:long(task:long)
+ *
+ * @task: task_struct pointer.
+ *
+ * Description: This function returns the nice value of the given task.
+ */
+function task_nice:long (task:long) %{ /* pure */
+    struct task_struct *t = (struct task_struct *)(long)THIS->task;
+    THIS->__retvalue = kread(&(t->static_prio)) - MAX_RT_PRIO - 20;
+    CATCH_DEREF_FAULT();
+%}
+
+/**
+ * sfunction task_cpu - The scheduled cpu of the task.
+ *
+ * General Syntax: task_cpu:long(task:long)
+ *
+ * @task: task_struct pointer.
+ *
+ * Description: This function returns the scheduled cpu for the given task.
+ */
+function task_cpu:long (task:long)
+{
+    ti = (@defined(@cast(task, "task_struct", "kernel<linux/sched.h>")->stack)
+	  ? @cast(task, "task_struct", "kernel<linux/sched.h>")->stack
+	  : @cast(task, "task_struct", "kernel<linux/sched.h>")->thread_info);
+    return @cast(ti, "thread_info", "kernel<linux/sched.h>")->cpu
+}
+
+/**
+ * sfunction task_open_file_handles - The number of open files of the task.
+ *
+ * General Syntax: task_open_file_handles:long(task:long)
+ *
+ * @task: task_struct pointer.
+ *
+ * Description: This function returns the number of open file handlers for the given task.
+ */
+function task_open_file_handles:long (task:long)
+%( kernel_v >= "2.6.15" %?
+%{ /* pure */
+    int locked = 0;
+    unsigned int count=0, fd, max;
+    struct task_struct *t;
+    struct files_struct *fs;
+    struct fdtable *f;
+    t = (struct task_struct *)(long)THIS->task;
+    fs = kread(&(t->files));
+    f = kread(&(fs->fdt));
+    rcu_read_lock();
+    locked = 1;
+    max = kread(&(f->max_fds));
+    for (fd = 0; fd < max; fd++) {
+                if ( kread(&(f->fd[fd])) != NULL)
+                        count ++;
+        }
+    THIS->__retvalue = count;
+    CATCH_DEREF_FAULT();
+    if (locked)
+        rcu_read_unlock();
+%}
+%:
+%{ /* pure */
+    int locked = 0;
+    unsigned int count=0, fd, max;
+    struct task_struct *t;
+    struct files_struct *f;
+    t = (struct task_struct *)(long)THIS->task;
+    f = kread(&(t->files));
+    rcu_read_lock();
+    locked = 1;
+    max = kread(&(f->max_fds));
+    for (fd = 0; fd < max; fd++) {
+                if ( kread(&(f->fd[fd])) != NULL)
+                        count ++;
+        }
+    THIS->__retvalue = count;
+    CATCH_DEREF_FAULT();
+    if (locked)
+        rcu_read_unlock();
+%}
+%)
+
+/**
+ * sfunction task_max_file_handles - The max number of open files for the task.
+ * 
+ * General Syntax: task_max_file_handles:long(task:long)
+ *
+ * @task: task_struct pointer.
+ *
+ * Description: This function returns the maximum number of file handlers for the given task.
+ */
+function task_max_file_handles:long (task:long)
+%( kernel_v >= "2.6.15" %?
+%{ /* pure */
+    int locked = 0;
+    struct task_struct *t;
+    struct files_struct *fs;
+    struct fdtable *f;
+    t = (struct task_struct *)(long)THIS->task;
+    fs = kread (&(t->files));
+    f = kread(&(fs->fdt));
+    rcu_read_lock();
+    locked = 1;
+    THIS->__retvalue = kread(&(f->max_fds));
+    CATCH_DEREF_FAULT();
+    if (locked)
+        rcu_read_unlock();
+%}
+%:
+%{ /* pure */
+    int locked = 0;
+    struct task_struct *t;
+    struct files_struct *f;
+    t = (struct task_struct *)(long)THIS->task;
+    f = kread(&(t->files));
+    rcu_read_lock();
+    locked = 1;
+    THIS->__retvalue = kread(&(f->max_fds));
+    CATCH_DEREF_FAULT();
+    if (locked)
+        rcu_read_unlock();
+%}
+%)

=== added file '.pc/Updated-memory.stp-rpc.stp-task.stp-and-vfs.stp-for-.patch/tapset/vfs.stp'
--- .pc/Updated-memory.stp-rpc.stp-task.stp-and-vfs.stp-for-.patch/tapset/vfs.stp	1970-01-01 00:00:00 +0000
+++ .pc/Updated-memory.stp-rpc.stp-task.stp-and-vfs.stp-for-.patch/tapset/vfs.stp	2011-03-22 12:11:00 +0000
@@ -0,0 +1,1018 @@
+// vfs tapset
+// Copyright (C) 2006-2007 IBM Corp.
+// Copyright (C) 2007 Intel Corporation.
+// Copyright (C) 2007 Bull S.A.S
+// Copyright (c) 2008, 2010 Red Hat Inc.
+//
+// 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.
+
+/* generic vfs probes */
+
+/*
+  We don't want to have to do a bdevname() call every time
+  we want a devname, so we'll hash them here.
+*/
+/* XXX: Is this hashing really that helpful?  The call to bdevname()
+ * isn't very involved... */
+global __devnames
+function __find_bdevname:string(dev:long, bdev:long)
+{
+	if (dev in __devnames)
+		return __devnames[dev]
+	else
+		return __devnames[dev] = bdevname(bdev)
+}
+
+/* deprecated */
+function ppos_pos:long (ppos:long)
+{
+	return kernel_pointer(ppos)
+}
+
+function __address_inode:long (page:long)
+{
+	mapping = page? @cast(page, "page", "kernel")->mapping : 0
+	if (mapping == 0)
+		return -1
+	else
+		return @cast(mapping, "address_space", "kernel")->host
+}
+
+function __page_ino:long (page:long)
+{
+	host = __address_inode(page)
+	if (host == -1)
+		return -1
+	else
+		return @cast(host, "inode", "kernel")->i_ino
+}
+
+function __page_dev:long (page:long)
+{
+	host = __address_inode(page)
+	if (host == -1)
+		return -1
+	return @cast(host, "inode", "kernel")->i_sb->s_dev
+}
+
+function __page_bdev:long (page:long)
+{
+	host = __address_inode(page)
+	if (host == -1)
+		return 0
+	return @cast(host, "inode", "kernel")->i_sb->s_bdev
+}
+
+function __page_index:long (page:long)
+{
+	return @cast(page, "page", "kernel")->index
+}
+
+function __file_dev:long (file:long)
+{
+	d_inode = __file_inode(file)
+	if (d_inode == 0)
+		return 0
+	return @cast(d_inode, "inode", "kernel")->i_sb->s_dev
+}
+
+function __file_bdev:long (file:long)
+{
+	d_inode = __file_inode(file)
+	if (d_inode == 0)
+		return 0
+	return @cast(d_inode, "inode", "kernel")->i_sb->s_bdev
+}
+
+function __file_ino:long (file:long)
+{
+	d_inode = __file_inode(file)
+	if (d_inode == 0)
+		return 0
+	return @cast(d_inode, "inode", "kernel")->i_ino
+}
+
+function __file_maxbytes:long (file:long)
+{
+	d_inode = __file_inode(file)
+	if (d_inode == 0)
+		return 0
+	return @cast(d_inode, "inode", "kernel")->i_sb->s_maxbytes
+}
+
+function __file_filename:string (file:long)
+{
+	dentry = file
+		? (@defined(@cast(file, "file", "kernel")->f_path->dentry)
+			? @cast(file, "file", "kernel")->f_path->dentry
+			: @cast(file, "file", "kernel")->f_dentry)
+		: 0
+	name = dentry? @cast(dentry, "dentry", "kernel")->d_name->name : 0
+	if (name == 0)
+		return "NULL"
+	else
+		return kernel_string(name)
+}
+
+function _get_fopv_size:long (iovp:long, nr_segs:long)
+{
+	if (iovp) {
+		val = 0
+		for (i = 0; i < nr_segs; i++)
+			val += @cast(iovp, "iovec")[i]->iov_len
+		return val
+	}
+	return -1
+}
+
+/* deprecated */
+function _dev_minor:long (dev:long)
+{
+	return MINOR(dev)
+}
+
+/* deprecated */
+function _dev_major:long (dev:long)
+{
+	return MAJOR(dev)
+}
+
+probe generic.fop.llseek = kernel.function("generic_file_llseek")
+{
+	dev = __file_dev($file)
+	devname = __find_bdevname(dev, __file_bdev($file))
+	ino = __file_ino($file)
+	file = $file
+
+	offset = $offset
+	origin = $origin
+        maxbyte = __file_maxbytes($file)
+
+	name = "generic_file_llseek"
+	argstr = sprintf("%d, %d", $offset, $origin)
+}
+probe generic.fop.llseek.return = kernel.function("generic_file_llseek").return
+{
+	name = "generic_file_llseek"
+	retstr = sprintf("%d", $return)
+	file = $file
+	offset = $offset
+	origin = $origin
+
+	error = $return < 0 ? $return : 0
+	error_str = error ? errno_str(error) : ""
+}
+
+probe generic.fop.aio_read =
+	kernel.function("__generic_file_aio_read") !,
+	kernel.function("generic_file_aio_read")
+{
+	file = $iocb->ki_filp
+	dev = __file_dev($iocb->ki_filp)
+	devname = __find_bdevname(dev, __file_bdev($iocb->ki_filp))
+	ino = __file_ino($iocb->ki_filp)
+        
+	pos = (@defined($pos) ? $pos : kernel_pointer($ppos))
+	buf = $iov->iov_base
+	count = __iov_length($iov,$nr_segs,1,1) /*FIX ME: should be VERIFY_WRITE instead of 1*/
+	name = "generic_file_aio_read"
+	argstr = sprintf("%d, %d, %p", count, pos, buf)
+
+	size = count
+	units = "bytes"
+}
+
+probe generic.fop.aio_read.return =
+	kernel.function("__generic_file_aio_read").return !,
+	kernel.function("generic_file_aio_read").return
+{
+	file = $iocb->ki_filp
+	nr_segs = $nr_segs
+	name = "generic_file_aio_read"
+	retstr = sprintf("%d", $return)
+
+	bytes_read = $return > 0 ? $return : 0
+	error = $return < 0 ? $return : 0
+ 	error_str = error ? errno_str(error) : ""
+
+	if ($return > 0) {
+		size = $return
+		units = "bytes"
+	}
+}
+
+probe generic.fop.aio_write = kernel.function("generic_file_aio_write")
+{
+	file = $iocb->ki_filp
+	dev = __file_dev($iocb->ki_filp)
+	devname = __find_bdevname(dev, __file_bdev($iocb->ki_filp))
+	ino = __file_ino($iocb->ki_filp)
+
+        pos = $pos
+
+        count = (@defined($iov)
+		? __iov_length($iov,$nr_segs,1,0) /*FIX ME: should be VERIFY_READ instead of 0*/
+		: $count)
+	buf = (@defined($iov->iov_base) ? $iov->iov_base : $buf)
+	name = "generic_file_aio_write"
+	argstr = sprintf("%d, %d, %p", count, pos, buf)
+
+	size = count
+	units = "bytes"
+}
+probe generic.fop.aio_write.return =
+	kernel.function("generic_file_aio_write").return
+{
+	file = $iocb->ki_filp
+	name = "generic_file_aio_write"
+	retstr = sprintf("%d", $return)
+
+	if ($return > 0) {
+		size = $return
+		units = "bytes"
+	}
+}
+
+probe generic.fop.readv = kernel.function("generic_file_readv") ?
+{
+	dev = __file_dev($filp)
+	devname = __find_bdevname(dev, __file_bdev($filp))
+	ino = __file_ino($filp)
+	file = $filp
+
+	nr_segs = $nr_segs
+	pos = kernel_pointer($ppos)
+
+	name = "generic_file_readv"
+	argstr = sprintf("%d, %d", $nr_segs, pos)
+
+	size = nr_segs
+	units = "segs"
+}
+probe generic.fop.readv.return = kernel.function("generic_file_readv").return ?
+{
+	file = $filp
+	name = "generic_file_readv"
+	retstr = sprintf("%d", $return)
+
+	bytes_read = $return > 0 ? $return : 0
+	error = $return < 0 ? $return : 0
+	error_str = error ? errno_str(error) : ""
+
+	if ($return > 0) {
+		size = $return
+		units = "bytes"
+	}
+}
+
+/* calls __generic_file_write_nolock */
+probe generic.fop.writev = kernel.function("generic_file_writev") ?
+{
+	dev = __file_dev($file)
+	devname = __find_bdevname(dev, __file_bdev($file))
+	ino = __file_ino($file)
+	file = $file
+
+	nr_segs = $nr_segs
+	pos = kernel_pointer($ppos)
+
+	name = "generic_file_writev"
+	argstr = sprintf("%d, %d", $nr_segs, pos)
+
+	size = nr_segs
+	units = "segs"
+}
+probe generic.fop.writev.return =
+	kernel.function("generic_file_writev").return ?
+{
+	file = $file
+	name = "generic_file_writev"
+	retstr = sprintf("%d", $return)
+
+	bytes_written = $return > 0 ? $return : 0
+	error = $return < 0 ? $return : 0
+	error_str = error ? errno_str(error) : ""
+
+	if ($return > 0) {
+		size = $return
+		units = "bytes"
+	}
+}
+
+/* checks for aops->readpage, if not defined, return -ENOEXEC
+   else assigns generic_file_vm_ops to vma
+   add filemap_nopage, filemap_populate */
+probe generic.fop.mmap = kernel.function("generic_file_mmap")
+{
+	file = $file
+	dev = __file_dev($file)
+	devname = __find_bdevname(dev, __file_bdev($file))
+	ino = __file_ino($file)
+
+	vm_start = $vma->vm_start
+	vm_end = $vma->vm_end
+	vm_flags = $vma->vm_flags
+
+	name = "generic_file_mmap"
+	argstr = sprintf("0x%x, 0x%x, 0x%x", $vma->vm_start,
+		$vma->vm_end, $vma->vm_flags)
+}
+probe generic.fop.mmap.return = kernel.function("generic_file_mmap").return
+{
+	file = $file
+	name = "generic_file_mmap"
+	retstr = sprintf("%d", $return)
+
+	error = $return < 0 ? $return : 0
+	error_str = error ? errno_str(error) : ""
+}
+
+probe generic.fop.open = kernel.function("generic_file_open")
+{
+	dev = __file_dev($filp)
+	devname = __find_bdevname(dev, __file_bdev($filp))
+	ino = $inode->i_ino
+	file = $filp
+
+	filename = __file_filename($filp)
+        flag = $filp->f_flags
+        size = $inode->i_size
+
+	name = "generic_file_open"
+	argstr = sprintf("%d, %d, %s", $inode->i_ino, $filp->f_flags, filename)
+}
+probe generic.fop.open.return = kernel.function("generic_file_open").return
+{
+	name = "generic_file_open"
+	retstr = sprintf("%d", $return)
+}
+
+probe generic.fop.sendfile = kernel.function("generic_file_sendfile") ?
+{
+	dev = __file_dev($in_file)
+	devname = __find_bdevname($in_file, __file_bdev($in_file))
+	ino = __file_ino($in_file)
+	file = $in_file
+
+	count = $count
+        ppos = $ppos
+
+	name = "generic_file_sendfile"
+	argstr = sprintf("%d", $count)
+
+	size = $count
+	units = "bytes"
+}
+probe generic.fop.sendfile.return =
+	kernel.function("generic_file_sendfile").return ?
+{
+	name = "generic_file_sendfile"
+	retstr = sprintf("%d", $return)
+
+	if ($return > 0) {
+		size = $return
+		units = "bytes"
+	}
+}
+
+probe generic.fop.splice_read = kernel.function("generic_file_splice_read") ?
+{
+	dev = __file_dev($in)
+	devname = __find_bdevname(dev, __file_bdev($in))
+	ino = __file_ino($in)
+	file = $in
+	dev_major = MAJOR(dev)
+	dev_minor = MINOR(dev)
+
+	len = $len
+	flags = $flags
+
+	name = "generic_file_splice_read"
+	argstr = sprintf("%d, %x", $len, $flags)
+
+	size = $len
+	units = "bytes"
+}
+probe generic.fop.splice_read.return =
+	kernel.function("generic_file_splice_read").return ?
+{
+	name = "generic_file_splice_read"
+	retstr = sprintf("%d", $return)
+	file = $in
+	ino = __file_ino($in)
+	dev = __file_dev($in)
+	dev_major = MAJOR(dev)
+	dev_minor = MINOR(dev)
+
+	ret = $return
+	error = $return < 0 ? $return : 0
+	error_str = error ? errno_str(error) : ""
+
+	if ($return > 0) {
+		size = $return
+		units = "bytes"
+	}
+}
+
+probe generic.fop.splice_write = kernel.function("generic_file_splice_write") ?
+{
+	dev = __file_dev($out)
+	devname = __find_bdevname(dev, __file_bdev($out))
+	ino = __file_ino($out)
+	file = $out
+
+	len = $len
+	flags = $flags
+
+	name = "generic_file_splice_write"
+	argstr = sprintf("%d, %x", $len, $flags)
+
+	size = $len
+	units = "bytes"
+}
+probe generic.fop.splice_write.return =
+	kernel.function("generic_file_splice_write").return ?
+{
+	name = "generic_file_splice_write"
+	retstr = sprintf("%d", $return)
+
+	file = $out
+
+	error = $return < 0 ? $return : 0
+	error_str = error ? errno_str(error) : ""
+
+	if (error) {
+		size = $return
+		units = "bytes"
+	}
+}
+
+probe generic.fop.read = kernel.function("generic_file_read") ?
+{
+	dev = __file_dev($filp)
+	devname = __find_bdevname(dev, __file_bdev($filp))
+	ino = __file_ino($filp)
+	file = $filp
+
+	count = $count
+
+	name = "generic_file_read"
+	argstr = sprintf("%d", $count)
+
+	size = $count
+	units = "bytes"
+}
+probe generic.fop.read.return = kernel.function("generic_file_read").return ?
+{
+	name = "generic_file_read"
+	retstr = sprintf("%d", $return)
+
+	if ($return > 0) {
+		size = $return
+		units = "bytes"
+	}
+}
+
+probe generic.fop.write = kernel.function("generic_file_write") ?
+{
+	dev = __file_dev($file)
+	devname = __find_bdevname(dev, __file_bdev($file))
+	ino = __file_ino($file)
+	file = $file
+
+	count = $count
+
+	name = "generic_file_write"
+	argstr = sprintf("%d", $count)
+
+	size = $count
+	units = "bytes"
+}
+probe generic.fop.write.return = kernel.function("generic_file_write").return ?
+{
+	name = "generic_file_write"
+	retstr = sprintf("%d", $return)
+
+	if ($return > 0) {
+		size = $return
+		units = "bytes"
+	}
+}
+
+/* generic_writepages calls mpage_writepages(mapping, wbc, NULL) */
+probe generic.aop.writepages = kernel.function("mpage_writepages")
+{
+	dev = $mapping->host->i_sb->s_dev
+	devname = __find_bdevname(dev, $mapping->host->i_sb->s_bdev)
+	ino = $mapping->host->i_ino
+
+	nr_to_write = $wbc->nr_to_write
+
+	name = "generic_writepages"
+	argstr = sprintf("%d", $wbc->nr_to_write)
+
+	size = $wbc->nr_to_write
+	units = "pages"
+}
+probe generic.aop.writepages.return = kernel.function("mpage_writepages").return
+{
+	name = "generic_writepages"
+	retstr = sprintf("%d", $return)
+}
+
+probe vfs.do_sync_read = kernel.function("do_sync_read")
+{
+	dev = __file_dev($filp)
+	devname = __find_bdevname(dev, __file_bdev($filp))
+	ino = __file_ino($filp)
+	file = $filp
+
+	len = $len
+	pos = kernel_pointer($ppos)
+        buf = $buf
+
+	name = "do_sync_read"
+	argstr = sprintf("%d, %d, %p", $len, pos, $buf)
+
+	size = $len
+	units = "bytes"
+	bytes_to_read = $len
+}
+probe vfs.do_sync_read.return = kernel.function("do_sync_read").return
+{
+	name = "do_sync_read"
+	retstr = sprintf("%d", $return)
+
+	bytes_to_read = $len
+	ret = $return
+	bytes_read = $return > 0 ? $return : 0
+	error = $return < 0 ? $return : 0
+	error_str = error ? errno_str(error) : ""
+
+	if ($return > 0) {
+		size = $return
+		units = "bytes"
+	}
+}
+
+probe vfs.do_sync_write = kernel.function("do_sync_write")
+{
+	dev = __file_dev($filp)
+	devname = __find_bdevname(dev, __file_bdev($filp))
+	ino = __file_ino($filp)
+	file = $filp
+
+	len = $len
+	pos = kernel_pointer($ppos)
+	buf = $buf
+	bytes_to_write = $len
+
+	name = "do_sync_write"
+	argstr = sprintf("%d, %d , %p", $len, pos, $buf)
+
+	size = $len
+	units = "bytes"
+}
+probe vfs.do_sync_write.return = kernel.function("do_sync_write").return
+{
+	name = "do_sync_write"
+	retstr = sprintf("%d", $return)
+
+	bytes_to_write = $len
+	pos = kernel_pointer($ppos)
+	ret = $return
+	bytes_written = $return > 0 ? $return : 0
+	error = $return < 0 ? $return : 0
+ 	error_str = error ? errno_str(error) : ""
+
+	if (error) {
+		size = $return
+		units = "bytes"
+	}
+}
+
+probe vfs.block_sync_page = kernel.function("block_sync_page")
+{
+	dev = __page_dev($page)
+	devname = __find_bdevname(dev, __page_bdev($page))
+	ino = __page_ino($page)
+
+	# 'page_index' is deprecated
+	page_index = __page_index($page)
+	index = __page_index($page)
+
+	name = "block_sync_page"
+	argstr = sprintf("%d", index)
+
+	size = 1
+	units = "pages"
+}
+probe vfs.block_sync_page.return = kernel.function("block_sync_page").return
+{
+	name = "block_sync_page"
+	retstr = sprintf("N/A")
+}
+
+probe vfs.buffer_migrate_page = kernel.function("buffer_migrate_page") ?
+{
+	dev = __page_dev($page)
+        ino = __page_ino($page)
+	devname = __find_bdevname(dev,__page_bdev($page))
+
+	# 'page_index' is deprecated
+	page_index = __page_index($page)
+	index = __page_index($page)
+
+	name = "buffer_migrate_page"
+	argstr = sprintf("%d", index)
+
+	size = 1
+	units = "pages"
+}
+probe vfs.buffer_migrate_page.return =
+	kernel.function("buffer_migrate_page").return ?
+{
+	name = "buffer_migrate_page"
+	retstr = sprintf("%d", $return)
+
+	if ($return == 0) {
+		size = 1
+		units = "pages"
+	}
+}
+
+/* default if aop not set, __set_page_dirty_nobuffers usually used if set */
+probe vfs.__set_page_dirty_buffers = kernel.function("__set_page_dirty_buffers")
+{
+	dev = __page_dev($page)
+	devname = __find_bdevname(dev, __page_bdev($page))
+	ino = __page_ino($page)
+
+	index = __page_index($page)
+
+	name = "__set_page_dirty_buffers"
+	argstr = sprintf("%d", index)
+
+	size = 1
+	units = "pages"
+}
+probe vfs.__set_page_dirty_buffers.return =
+	kernel.function("__set_page_dirty_buffers").return
+{
+	name = "__set_page_dirty_buffers"
+	retstr = sprintf("%d", $return)
+
+%( kernel_v >= "2.6.17" %?
+	if ($return == 1) 
+%:
+	if ($return == 0) 
+%)
+	{
+		size = 1
+		units = "pages"
+	}
+}
+
+probe vfs.do_mpage_readpage = kernel.function("do_mpage_readpage")
+{
+	dev = __page_dev($page)
+	devname = __find_bdevname(dev, __page_bdev($page))
+	ino = __page_ino($page)
+
+	index = __page_index($page)
+
+	name = "do_mpage_readpage"
+	argstr = sprintf("%d", index)
+
+	size = 1
+	units = "pages"
+}
+probe vfs.do_mpage_readpage.return = kernel.function("do_mpage_readpage").return
+{
+	name = "do_mpage_readpage"
+	retstr = sprintf("0x%x", $return)
+
+	size = 1
+	units = "pages"
+}
+
+probe vfs.add_to_page_cache =
+	kernel.function("add_to_page_cache_locked") !,
+	kernel.function("add_to_page_cache")
+{
+	dev = $mapping->host->i_sb->s_dev
+	devname = __find_bdevname(dev, $mapping->host->i_sb->s_bdev)
+	ino = $mapping->host->i_ino
+
+	index = $offset
+	nrpages = $mapping->nrpages
+	size = $mapping->nrpages
+	units = "pages"
+
+	name = "vfs.add_to_page_cache"
+	argstr = sprintf("%d, %d", ino, $offset)
+}
+
+probe vfs.add_to_page_cache.return =
+	kernel.function("add_to_page_cache_locked").return !,
+	kernel.function("add_to_page_cache").return
+{
+	name = "vfs.add_to_page_cache"
+	retstr = sprintf("%d", $return)
+
+	if ($return == 0) {
+		size = 1
+		units = "pages"
+	}
+}
+
+probe vfs.remove_from_page_cache = kernel.function("__remove_from_page_cache")
+{
+	dev = __page_dev($page)
+	devname = __find_bdevname(dev, __page_bdev($page))
+	ino = __page_ino($page)
+
+	index = __page_index($page)
+
+	name = "vfs.remove_from_page_cache"
+	argstr = sprintf("%d", ino)
+}
+probe vfs.remove_from_page_cache.return =
+	kernel.function("__remove_from_page_cache").return
+{
+	name = "vfs.remove_from_page_cache"
+	retstr = sprintf("N/A")
+}
+
+probe vfs.read = kernel.function("vfs_read")
+{
+	file = $file
+	pos = $pos
+	buf = $buf
+	bytes_to_read = $count
+	dev = __file_dev($file)
+	devname = __find_bdevname(dev, __file_bdev($file))
+	ino = __file_ino($file)
+
+	name = "vfs.read"
+	argstr = sprintf("%d, %d, %p", $count, $pos, $buf)
+}
+
+probe vfs.read.return = kernel.function("vfs_read").return
+{
+	name = "vfs.read"
+	retstr = sprintf("%d", $return)
+
+	file = $file
+	pos = $pos
+	buf = $buf
+	bytes_to_read = $count
+	dev = __file_dev($file)
+	devname = __find_bdevname(dev, __file_bdev($file))
+	ino = __file_ino($file)
+
+	ret = $return
+	bytes_read = $return > 0 ? $return : 0
+	error = $return < 0 ? $return : 0
+	error_str = error ? errno_str(error) : ""
+}
+
+probe vfs.readv = kernel.function("vfs_readv")
+{
+	file = $file
+	dev = __file_dev($file)
+	devname = __find_bdevname(dev, __file_bdev($file))
+	ino = __file_ino($file)
+	pos = $pos
+	vec = $vec
+	vlen = $vlen
+	bytes_to_read = _get_fopv_size($vec, $vlen)
+
+	name = "vfs.read"
+	argstr = sprintf("%d, %d, %p", bytes_to_read, $pos, $vec)
+}
+
+probe vfs.readv.return = kernel.function("vfs_readv").return
+{
+	name = "vfs.readv"
+	retstr = sprintf("%d", $return)
+
+	file = $file
+	dev = __file_dev($file)
+	devname = __find_bdevname(dev, __file_bdev($file))
+	ino = __file_ino($file)
+	pos = $pos
+	vec = $vec
+	vlen = $vlen
+	bytes_to_read = _get_fopv_size($vec, $vlen)
+
+	ret = $return
+	bytes_read = $return > 0 ? $return : 0
+	error = $return < 0 ? $return : 0
+	error_str = error ? errno_str(error) : ""
+}
+
+probe vfs.write = kernel.function("vfs_write")
+{
+	file = $file
+	pos = $pos
+	buf = $buf
+	bytes_to_write = $count
+	dev = __file_dev($file)
+	devname = __find_bdevname(dev, __file_bdev($file))
+	ino = __file_ino($file)
+
+	name = "vfs.write"
+	argstr = sprintf("%d, %d, %p", $count, $pos, $buf)
+}
+
+probe vfs.write.return = kernel.function("vfs_write").return
+{
+	name = "vfs.write"
+	retstr = sprintf("%d", $return)
+
+	file = $file
+	pos = $pos
+	buf = $buf
+	bytes_to_write = $count
+	dev = __file_dev($file)
+	devname = __find_bdevname(dev, __file_bdev($file))
+	ino = __file_ino($file)
+
+	ret = $return
+	bytes_written = $return > 0 ? $return : 0
+	error = $return < 0 ? $return : 0
+	error_str = error ? errno_str(error) : ""
+}
+
+probe vfs.writev = kernel.function("vfs_writev")
+{
+	file = $file
+	dev = __file_dev($file)
+	devname = __find_bdevname(dev, __file_bdev($file))
+	ino = __file_ino($file)
+	pos = $pos
+	vlen = $vlen
+	vec = $vec
+	bytes_to_write = _get_fopv_size($vec, $vlen)
+
+	name = "vfs.writev"
+	argstr = sprintf("%d, %d, %p", bytes_to_write, $pos, $vec)
+}
+
+probe vfs.writev.return = kernel.function("vfs_writev").return
+{
+	name = "vfs.writev"
+	retstr = sprintf("%d", $return)
+
+	file = $file
+	dev = __file_dev($file)
+	devname = __find_bdevname(dev, __file_bdev($file))
+	ino = __file_ino($file)
+	pos = $pos
+	vlen = $vlen
+	vec = $vec
+	bytes_to_write = _get_fopv_size($vec, $vlen)
+
+	ret = $return
+	bytes_written = $return > 0 ? $return : 0
+	error = $return < 0 ? $return : 0
+	error_str = error ? errno_str(error) : ""
+}
+
+probe _vfs.generic_file_readonly_mmap =
+	kernel.function("generic_file_readonly_mmap")
+{
+	file = $file
+	vma = $vma
+
+	name = "_vfs.generic_file_readonly_mmap"
+	argstr = sprintf("%p, %p", $file, $vma)
+}
+
+probe _vfs.generic_file_readonly_mmap.return =
+	kernel.function("generic_file_readonly_mmap").return
+{
+	name = "_vfs.generic_file_readonly_mmap"
+	retstr = sprintf("%d", $return)
+
+	file = $file
+	vma = $vma
+
+	ret = $return
+	error = $return < 0 ? $return : 0
+	error_str = error ? errno_str(error) : ""
+}
+
+probe _vfs.generic_block_bmap = kernel.function("generic_block_bmap")
+{
+	mapping = $mapping
+	block = $block
+	get_block = $get_block
+
+	name = "_vfs.generic_block_bmap"
+	argstr = sprintf("%p, %p, %p", $mapping, $block, $get_block)
+}
+
+probe _vfs.generic_commit_write = kernel.function("generic_commit_write") ?
+{
+	file = $file
+	page = $page
+	from = $from
+	to = $to
+
+	name = "_vfs.generic_commit_write"
+	argstr = sprintf("%p, %p, %d, %d", $file, $page, $from, $to)
+}
+
+probe _vfs.block_prepare_write = kernel.function("__block_prepare_write")
+{
+	_inode = $inode
+	page = $page
+	# write_from and write_upto are deprecated
+	write_from = $from
+	write_upto = $to
+	from = $from
+	to = $to
+
+	name = "_vfs.generic_commit_write"
+	argstr = sprintf("%p, %d, %d", $page, $from, $to)
+}
+
+probe _vfs.block_prepare_write.return =
+	kernel.function("__block_prepare_write").return
+{
+	name = "_vfs.block_prepare_write"
+	retstr = sprintf("%d", $return)
+
+	_inode = $inode
+	page = $page
+	# write_from and write_upto are deprecated
+	write_from = $from
+	write_upto = $to
+	from = $from
+	to = $to
+
+	ret = $return
+	error = ret < 0 ? ret : 0
+	error_str = error ? errno_str(error) : ""
+}
+
+probe _vfs.block_write_begin = kernel.function("block_write_begin") ?
+{
+	file = $file
+	pos = $pos
+	len = $len
+	flags = $flags
+
+	_inode = __address_inode($mapping)