+2008-08-07 Frank Ch. Eigler <fche@elastic.org>
+
+ * small_demos: Unique parts kept, others dropped.
+ * all other samples: Moved into new subdirectories.
+
2008-08-07 Mark Wielaard <mwielaard@redhat.com>
* examples-index-gen.pl: New file.
+++ /dev/null
-#!/usr/bin/env stap
-
-probe syscall.close {
- printf("%s: %s(%s) = ", execname(), name, argstr)
-}
-
-probe syscall.close.return {
- printf("%s\n", returnstr(returnp))
-}
-
-probe end {
- printf("DONE\n")
-}
-
+++ /dev/null
-> cd /root/systemtap
-
-A systemtap script can be as simple as a single line. For example,
-the following script places a probepoint on the kernel sys_read()
-function and prints all callers with the function's arguments.
-
->stap -e 'probe syscall.open {printf("%s: %s\n", execname(), argstr)}'
-
-Most scripts are a bit longer. (show top.stp)
-This script sets a probepoint on all kernel functions beginning with "sys_".
-When the probepoint is hit, it increments an entry in the map
-(or associative array) "syscalls" with the key "probefunc()" which returns
-the name of the function that was triggered. For example, "sys_read".
-
-There is a timer that is triggered every 5000ms or 5 seconds. That timer
-calls the function print_top(). print_top() sorts the syscalls map
-and prints the top 20 entries. Then it clears the map.
-
-> ./top.stp
-
-(after stopping "top" go ahead and enter "./sys.stp". It takes a minute
-to load this script. Diplay the source in another window and talk
-while it is loading.)
-
-The "top" script looked only at the functions called. If we want more
-detail about the functions, we can use systemtap to examine their local
-arguments and variables. However that would be difficult because each
-system call has different parameters. The Syscall Tapset solves
-this problem. To use it, we set probe points using the syntax "syscall.name"
-instead of kernel.function("sys_name"). The Syscall Tapset provides three
-defined variables we can use:
-name - the name of the function
-argstr - on function entry, a formatted string containing the arguments
-retstr - on function exit, the return value and possibly error code
-
-In this example, we filter out programs named "staprun" because this is
-part of the systemtap infrastructure. (It may be filtered out
-automatically in the future.)
-
-The next example shows how you can use systemtap to focus on
-specific programs or pids. (show prof.stp)
-
-Like the "top" example, this script places probes on all kernel
-functions starting with "sys_". Only the probepoint also checks to see
-if the tid/pid matches the one returned by "target()". We'll show how
-the target pid is set later.
-
-Unlike the previous examples, this script sets a probe point on all the
-system call returns. When triggered, this probepoint computes the elapsed
-time since the function entry.
-
-To run this script, we must give it a pid to use for the target, or a
-program to run, in which case target will be its pid.
-
-> ./prof.stp -c "top -n5"
-
---------------------------------
-
-Systemtap can also run in an unsafe mode where you can give
-it arbitrary C code to run at probepoints, or modify kernel variables
-and structures. This is very dangerous so only experts with root access will
-ever be permitted to do this.
-
-(show keyhack.stp)
-
-The next example will modify the local variable "keycode" in the "kdb_keycode"
-function in the kernel driver. We indicate it is a local variable by putting
-a dollar sign before the name.
-
-./keyhack.stp
-
-(prints error message)
-
-To tell systemtap we really want to run this script, we must use the "-g" flag.
-
-./keyhack.stp -g
-
-(type some keys. "m" should display as "b" in every window)
-
-This example is not something you would normally want to do. There are
-far better ways to remap a keyboard. What it demonstartes is that Systemtap
-can modify variables in a running kernel.
-
-(show kmalloc.stp)
-This next script shows the kind of statistics systemtap can collect.
-It collects information about kernel allocations.
-
-> ./kmalloc.stp
-
-Now we can refine this further
-(show kmalloc2.stp)
-
-Remember in some previous examples, we used maps or associative arrays. Maps can contain
-statistics too. So we have enhanced the previous script to collect statistics per
-program name. The output might be large so we'll redirect it to a file.
-
-> ./kmalloc2.stp > out
-
-(runs for 10 seconds)
-
-> more out
-
+++ /dev/null
-#! /usr/bin/env stap
-
-#
-# fileopen.stp
-#
-# This is based on dtrace script from
-# http://www.gnome.org/~gman/blog/2006/Jan
-#
-# stap fileopen.stp -c "zenity --about"
-# or
-# ./fileopen.stp -c "program or script"
-
-global opens
-
-probe syscall.open {
- if (target() == pid()) opens[filename] ++
-}
-
-probe end {
- foreach([name] in opens+) {
- printf("%-70s%5d\n", name, opens[name])
- }
-}
-
+++ /dev/null
-#! /usr/bin/env stap
-
-# Using statistics to examine kernel memory allocations
-
-global kmalloc
-
-probe kernel.function("__kmalloc") {
- kmalloc <<< $size
-}
-
-# Exit after 10 seconds
-probe timer.ms(10000) { exit () }
-
-probe end {
- printf("Count: %d allocations\n", @count(kmalloc))
- printf("Sum: %d Kbytes\n", @sum(kmalloc)/1000)
- printf("Average: %d bytes\n", @avg(kmalloc))
- printf("Min: %d bytes\n", @min(kmalloc))
- printf("Max: %d bytes\n", @max(kmalloc))
- print("\nAllocations by size in bytes\n")
- print(@hist_log(kmalloc))
-}
+++ /dev/null
-#! /usr/bin/env stap
-
-# Using statistics and maps to examine kernel memory allocations
-
-global kmalloc
-
-probe kernel.function("__kmalloc") {
- kmalloc[execname()] <<< $size
-}
-
-# Exit after 10 seconds
-probe timer.ms(10000) { exit () }
-
-probe end {
- foreach ([name] in kmalloc) {
- printf("Allocations for %s\n", name)
- printf("Count: %d allocations\n", @count(kmalloc[name]))
- printf("Sum: %d Kbytes\n", @sum(kmalloc[name])/1000)
- printf("Average: %d bytes\n", @avg(kmalloc[name]))
- printf("Min: %d bytes\n", @min(kmalloc[name]))
- printf("Max: %d bytes\n", @max(kmalloc[name]))
- print("\nAllocations by size in bytes\n")
- print(@hist_log(kmalloc[name]))
- printf("-------------------------------------------------------\n\n");
- }
-}
+++ /dev/null
-#!/usr/bin/env stap
-
-# This is an example of profiling a specific command or pid.
-# It works by recording the time when a system call is entered
-# exited.
-
-# Usage: prof.stp -c "top -n5"
-# Will start up "top" and after 5 iterations, will exit.
-#
-# Usage: prof.stp -x 3323
-# Will profile pid 3323 until it ^c is hit.
-#
-
-probe kernel.function("sys_*").call {
- if (target() == tid())
- calltime[tid()] = gettimeofday_us()
-}
-
-probe kernel.function("sys_*").return {
- if (target() != tid()) next
- now = gettimeofday_us()
- c = calltime[tid()]
- if (!c) next
- ttime[probefunc()] <<< now - c
- delete calltime[tid()]
-}
-
-probe end {
- printf("\n")
- foreach (x in ttime)
- printf("%-20s\tcalls:%6d\tavg time (us):%5d\ttotal(us):%7d\n",
- x, @count(ttime[x]), @avg(ttime[x]), @sum(ttime[x]))
-}
-
-global calltime, ttime
+++ /dev/null
-#! /usr/bin/env stap
-# rwtiming.stp
-#
-# This is a simple example to track the amount of time
-# spent doing reads and writes for the various programs running on the
-# system.
-
-probe begin { log("starting probe") }
-
-global names, opens, reads, writes
-global entry_opens, entry_reads, entry_writes
-global time_opens, time_reads, time_writes
-
-probe kernel.function("sys_open") {
- t=gettimeofday_us(); p=pid(); e=execname();
- names[e]=1
- opens[e] ++ # plain integer
- entry_opens[p] = t;
-}
-
-probe kernel.function("sys_open").return {
- t=gettimeofday_us(); p=pid(); e=execname();
- time_opens[e] <<< t - entry_opens[p];
-}
-
-probe kernel.function("sys_read") {
- t= gettimeofday_us(); p =pid(); e=execname();
- names[e]=1
- reads[e] <<< $count # statistics
- entry_reads[p] = t;
-}
-
-probe kernel.function("sys_read").return {
- t=gettimeofday_us(); p=pid(); e=execname();
- time_reads[e] <<< t - entry_reads[p];
-}
-
-probe kernel.function("sys_write") {
- t=gettimeofday_us(); p=pid(); e=execname();
- names[e]=1
- writes[e] <<< $count # statistics
- entry_writes[p] = t;
-}
-
-probe kernel.function("sys_write").return {
- t = gettimeofday_us(); p = pid(); e=execname();
- time_writes[e] <<< t - entry_writes[p];
-}
-
-probe end {
- foreach(name+ in names) { # sort by names
- printf ("process: %s\n", name)
- if (opens[name]) {
- printf ("opens n=%d\n", opens[name])
- print (@hist_log(time_opens[name]))
- }
- if (@count(reads[name])) {
- printf ("reads n=%d, sum=%d, avg=%d\n",
- @count(reads[name]), # extracting stat results
- @sum(reads[name]),
- @avg(reads[name]))
- print ("read timing distribution\n")
- print (@hist_log(time_reads[name]))
- }
- if (@count(writes[name])) {
- printf ("writes n=%d, sum=%d, avg=%d\n",
- @count(writes[name]), # extracting stat results
- @sum(writes[name]),
- @avg(writes[name]))
- print ("write timing distribution\n")
- print (@hist_log(time_writes[name]))
- }
- }
-}
+++ /dev/null
-#!/usr/bin/env stap
-
-global start_ts
-
-probe begin {
- start_ts = gettimeofday_us()
- printf("%12s %3s %5s %5s %-16s ACTION\n",
- "TIMESTAMP", "CPU", "PID", "TID", "EXECNAME")
-}
-
-function report(action:string) {
- printf("%3d %12d %5d %5d %-16s %s\n",
- gettimeofday_us() - start_ts, cpu(),
- pid(), tid(), execname(), action)
-}
-
-probe scheduler.cpu_off {
- report(sprintf("cpu_off%s", idle? " [idle]" : ""))
-}
-
-probe scheduler.cpu_on {
- report(sprintf("cpu_on%s", idle? " [idle]" : ""))
-}
-
-probe scheduler.tick {
- report(sprintf("tick%s", idle? " [idle]" : ""))
-}
-
-probe scheduler.migrate ? {
- report("migrate")
-}
-
-probe scheduler.balance ? {
- report("balance")
-}
+++ /dev/null
-#!/usr/bin/env stap
-
-# print all system calls on the system
-
-probe syscall.* {
- if (execname() != "staprun")
- printf("%s: %s (%s) = ", execname(), name, argstr)
-}
-
-probe syscall.*.return {
- if (execname() != "staprun")
- printf("%s\n", retstr)
-}
-
-probe end {
- printf("\n")
-}
+++ /dev/null
-#!/usr/bin/env stap
-#
-# This script continuously lists the top 20 systemcalls on the system
-#
-
-global syscalls
-
-function print_top () {
- printf ("SYSCALL\t\t\t\tCOUNT\n")
- foreach ([name] in syscalls- limit 20)
- printf("%-20s\t\t%5d\n",name, syscalls[name])
- printf("--------------------------------------\n")
- delete syscalls
-}
-
-probe syscall.* {
- syscalls[probefunc()]++
-}
-
-# print top syscalls every 5 seconds
-probe timer.ms(5000) {
- print_top ()
-}
-
git://sourceware.org / systemtap.git / commitdiff
