Add the bkl.stp and bkl_stats.stp examples.

4 files changed, 162 insertions, 0 deletions

diff --git a/testsuite/systemtap.examples/locks/bkl.meta b/testsuite/systemtap.examples/locks/bkl.meta
new file mode 100644
index 00000000..ff232ec7
--- /dev/null
+++ b/testsuite/systemtap.examples/locks/bkl.meta
@@ -0,0 +1,10 @@
+title: Tracing Contention on Big Kernel Lock (BKL)
+name: bkl.stp
+keywords: locking 
+subsystem: kernel
+author: Flavio Leitner
+status: production
+exit: user-controlled
+description: The bkl.stp script can help determine whether the Big Kernel Lock (BKL) is causing serialization on a multiprocessor system due to excessive contention of the BKL. The bkl.stp script takes one argument which is the number of processes waiting for the Big Kernel Lock (BKL). When the number of processes waiting for the BKL is reached or exceeded, the script will print a time stamp, the number of processes waiting for the BKL, the holder of the BKL, and the amount of time the BKL was held.
+test_check: stap -p4 bkl.stp
+test_installcheck: stap bkl.stp -c "sleep 1"
diff --git a/testsuite/systemtap.examples/locks/bkl.stp b/testsuite/systemtap.examples/locks/bkl.stp
new file mode 100644
index 00000000..5dd26e18
--- /dev/null
+++ b/testsuite/systemtap.examples/locks/bkl.stp
@@ -0,0 +1,54 @@
+#! /usr/bin/env stap
+
+/*
+ * Copyright (C) 2009 Red Hat Inc.
+ * 
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * 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
+ *
+ *
+ * Description: displays which task is holding big kernel lock (BKL) when the 
+ *              number of waiting processes reaches a certain number.
+ *
+ * Run: stap bkl.stp <number_of_processes_waiting>
+ *
+ * Author: Flavio Leitner <fbl@redhat.com>
+ */
+
+# how many tasks waiting on big lock
+global waiting = 0
+# who is holding big lock
+global holder = 0
+global holder_time
+
+probe begin { printf("stap ready\n"); }
+
+probe end { printf("stap exiting\n"); }
+
+probe kernel.function("lock_kernel") {
+  ++waiting;
+}
+
+probe kernel.function("lock_kernel").return {
+  # under biglock
+  holder_time = gettimeofday_us();
+  holder = task_current();
+  --waiting;
+}
+
+probe kernel.function("unlock_kernel") {
+  # under biglock
+  if (waiting >= $1) {
+    printf("%-25s: waiting(%d), holder: %s(%d) %dus\n",
+           ctime(gettimeofday_s()),
+           waiting,
+           task_execname(holder),
+           task_pid(holder),
+           gettimeofday_us() - holder_time);
+  }
+}
diff --git a/testsuite/systemtap.examples/locks/bkl_stats.meta b/testsuite/systemtap.examples/locks/bkl_stats.meta
new file mode 100644
index 00000000..00d55c68
--- /dev/null
+++ b/testsuite/systemtap.examples/locks/bkl_stats.meta
@@ -0,0 +1,13 @@
+title: Per Process Statistics on Big Kernel Lock (BKL) Use
+name: bkl_stats.stp
+version: 1.0
+author: William Cohen
+keywords: locking
+subsystem: kernel
+status: production
+exit: user-controlled
+output: sorted-list
+scope: system-wide
+description: The bkl_stats.stp script can indicate which processes have excessive waits for the Big Kernel Lock (BKL) and which processes are taking the BKL for long periods of time. The bkl_stats.stp script prints lists of all the processes that require the BKL. Every five seconds two tables are printed out. The first table lists the processes that waited for the BKL followed by the number of times that the process waited, the minimum time of the wait, the average and the maximum time waited. The second table lists has similar information for the time spent holding the lock for each of the processes.
+test_check: stap -p4 bkl_stats.stp
+test_installcheck: stap bkl_stats.stp -c "sleep 1"
diff --git a/testsuite/systemtap.examples/locks/bkl_stats.stp b/testsuite/systemtap.examples/locks/bkl_stats.stp
new file mode 100644
index 00000000..4481e493
--- /dev/null
+++ b/testsuite/systemtap.examples/locks/bkl_stats.stp
@@ -0,0 +1,85 @@
+#! /usr/bin/env stap
+
+/*
+ * Copyright (C) 2009 Red Hat Inc.
+ * 
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * 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
+ *
+ * Print out the amount of time spent in the read and write systemcall
+ * when a process closes each file is closed. Note that the systemtap 
+ * script needs to be running before the open operations occur for
+ * the script to record data.
+ *
+ * Description: displays statisics for waiting and holding big kernel lock (BKL)
+ *
+ * Run: stap bkl_stats.stap
+ *
+ * Author: William Cohen <wcohen@redhat.com> 
+ */
+
+global holder_time, wait_time
+global holder_stats, wait_stats
+global names
+
+probe begin { printf("biglock_stats running\n"); }
+
+probe end, timer.s(5) {
+  print_stats()
+}
+
+function print_stats() {
+  # print out time waiting and time lock held
+  printf("big kernel lock waiting statistics\n");
+  printf("%-16s %6s %6s %6s %6s %6s\n",
+         "name", "tid", "count", "min", "avg", "max");
+  foreach (p+ in names) {
+    if (@count(wait_stats[p]))
+      printf("%16s %6d %6d %6d %6d %6d\n", names[p], p,
+            @count(wait_stats[p]), @min(wait_stats[p]),
+            @avg(wait_stats[p]), @max(wait_stats[p]));
+  }
+
+  printf("\n\nbig kernel lock holder statistics\n");
+  printf("%-16s %6s %6s %6s %6s %6s\n",
+         "name", "tid", "count", "min", "avg", "max");
+  foreach (p+ in names) {
+    if (@count(holder_stats[p]))
+      printf("%16s %6d %6d %6d %6d %6d\n", names[p], p,
+            @count(holder_stats[p]), @min(holder_stats[p]),
+            @avg(holder_stats[p]), @max(holder_stats[p]));
+  }
+}
+
+probe kernel.function("lock_kernel") {
+  t = gettimeofday_us()
+  wait_time[tid()] = t
+}
+
+probe kernel.function("lock_kernel").return {
+  t = gettimeofday_us()
+  s = wait_time[tid()]
+  holder_time[tid()] = t
+  # record the amount of time waiting for the lock
+  if (s) {
+     wait_stats[tid()] <<< t - s
+     names[tid()] = execname()
+  }
+}
+
+probe kernel.function("unlock_kernel") {
+  # record the amount of time the process held the lock
+  t = gettimeofday_us()
+  s = holder_time[tid()]
+  holder_time[tid()] = t
+  # record the amount of time waiting for the lock
+  if (s) {
+     holder_stats[tid()] <<< t - s
+     names[tid()] = execname()
+  }
+}