diff options
| author | Dave Brolley <brolley@redhat.com> | 2009-10-13 11:55:11 -0400 |
|---|---|---|
| committer | Dave Brolley <brolley@redhat.com> | 2009-10-13 11:55:11 -0400 |
| commit | f990359bd63bd4fc21e600e71c6a513d5b5b2ccb (patch) | |
| tree | 16fb7638f2089476b2994ec7d8b2131e4a7b0b69 | |
| parent | 8f6d8c2bd3e5c1d2881e2ebe1c7ad5deb389e581 (diff) | |
| parent | ba9abf303e1bed196668f103b2a17c48e3df70aa (diff) | |
| download | systemtap-steved-f990359bd63bd4fc21e600e71c6a513d5b5b2ccb.tar.gz systemtap-steved-f990359bd63bd4fc21e600e71c6a513d5b5b2ccb.tar.xz systemtap-steved-f990359bd63bd4fc21e600e71c6a513d5b5b2ccb.zip | |
Merge branch 'master' of ssh://sources.redhat.com/git/systemtap
51 files changed, 2069 insertions, 778 deletions
@@ -1,5 +1,8 @@ * What's new +- Preprocessor conditional for kernel configuration testing: + %( CONFIG_foo == "y" %? ... %) + - ftrace(msg:string) tapset function to send strings to the system-wide ftrace ring-buffer (if any). @@ -9327,7 +9327,7 @@ _ACEOF ac_config_headers="$ac_config_headers config.h:config.in" -ac_config_files="$ac_config_files Makefile doc/Makefile doc/SystemTap_Tapset_Reference/Makefile grapher/Makefile stap.1 stapprobes.3stap stapfuncs.3stap stapvars.3stap stapex.3stap staprun.8 stap-server.8 man/stapprobes.iosched.3stap man/stapprobes.netdev.3stap man/stapprobes.nfs.3stap man/stapprobes.nfsd.3stap man/stapprobes.pagefault.3stap man/stapprobes.kprocess.3stap man/stapprobes.rpc.3stap man/stapprobes.scsi.3stap man/stapprobes.signal.3stap man/stapprobes.socket.3stap man/stapprobes.tcp.3stap man/stapprobes.udp.3stap man/stapprobes.snmp.3stap initscript/systemtap" +ac_config_files="$ac_config_files Makefile doc/Makefile doc/SystemTap_Tapset_Reference/Makefile grapher/Makefile grapher/stapgraph.1 stap.1 stapprobes.3stap stapfuncs.3stap stapvars.3stap stapex.3stap staprun.8 stap-server.8 man/stapprobes.iosched.3stap man/stapprobes.netdev.3stap man/stapprobes.nfs.3stap man/stapprobes.nfsd.3stap man/stapprobes.pagefault.3stap man/stapprobes.kprocess.3stap man/stapprobes.rpc.3stap man/stapprobes.scsi.3stap man/stapprobes.signal.3stap man/stapprobes.socket.3stap man/stapprobes.tcp.3stap man/stapprobes.udp.3stap man/stapprobes.snmp.3stap initscript/systemtap" @@ -10065,6 +10065,7 @@ do "doc/Makefile") CONFIG_FILES="$CONFIG_FILES doc/Makefile" ;; "doc/SystemTap_Tapset_Reference/Makefile") CONFIG_FILES="$CONFIG_FILES doc/SystemTap_Tapset_Reference/Makefile" ;; "grapher/Makefile") CONFIG_FILES="$CONFIG_FILES grapher/Makefile" ;; + "grapher/stapgraph.1") CONFIG_FILES="$CONFIG_FILES grapher/stapgraph.1" ;; "stap.1") CONFIG_FILES="$CONFIG_FILES stap.1" ;; "stapprobes.3stap") CONFIG_FILES="$CONFIG_FILES stapprobes.3stap" ;; "stapfuncs.3stap") CONFIG_FILES="$CONFIG_FILES stapfuncs.3stap" ;; diff --git a/configure.ac b/configure.ac index f255bcff..2f206f3d 100644 --- a/configure.ac +++ b/configure.ac @@ -625,7 +625,7 @@ dnl Don't use this directly (when not given it is set to NONE). AC_DEFINE_UNQUOTED(STAP_PREFIX, "$prefix", [configure prefix location]) AC_CONFIG_HEADERS([config.h:config.in]) -AC_CONFIG_FILES(Makefile doc/Makefile doc/SystemTap_Tapset_Reference/Makefile grapher/Makefile stap.1 stapprobes.3stap stapfuncs.3stap stapvars.3stap stapex.3stap staprun.8 stap-server.8 man/stapprobes.iosched.3stap man/stapprobes.netdev.3stap man/stapprobes.nfs.3stap man/stapprobes.nfsd.3stap man/stapprobes.pagefault.3stap man/stapprobes.kprocess.3stap man/stapprobes.rpc.3stap man/stapprobes.scsi.3stap man/stapprobes.signal.3stap man/stapprobes.socket.3stap man/stapprobes.tcp.3stap man/stapprobes.udp.3stap man/stapprobes.snmp.3stap initscript/systemtap) +AC_CONFIG_FILES(Makefile doc/Makefile doc/SystemTap_Tapset_Reference/Makefile grapher/Makefile grapher/stapgraph.1 stap.1 stapprobes.3stap stapfuncs.3stap stapvars.3stap stapex.3stap staprun.8 stap-server.8 man/stapprobes.iosched.3stap man/stapprobes.netdev.3stap man/stapprobes.nfs.3stap man/stapprobes.nfsd.3stap man/stapprobes.pagefault.3stap man/stapprobes.kprocess.3stap man/stapprobes.rpc.3stap man/stapprobes.scsi.3stap man/stapprobes.signal.3stap man/stapprobes.socket.3stap man/stapprobes.tcp.3stap man/stapprobes.udp.3stap man/stapprobes.snmp.3stap initscript/systemtap) AC_CONFIG_SUBDIRS(testsuite) if test $enable_translator == "yes"; then AC_CONFIG_FILES([run-stap], [chmod +x run-stap]) diff --git a/doc/SystemTap_Tapset_Reference/tapsets.tmpl b/doc/SystemTap_Tapset_Reference/tapsets.tmpl index 705cd3b5..c8c5ed72 100644 --- a/doc/SystemTap_Tapset_Reference/tapsets.tmpl +++ b/doc/SystemTap_Tapset_Reference/tapsets.tmpl @@ -146,6 +146,16 @@ !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 Tapset</title> <para> diff --git a/doc/langref.tex b/doc/langref.tex index 523deb1b..3afe6128 100644 --- a/doc/langref.tex +++ b/doc/langref.tex @@ -1816,6 +1816,17 @@ probe kernel.function ( %( arch == "ia64" %? probe syscall.vliw = kernel.function("vliw_widget") {} %) + +\end{verbatim} +\end{vindent} + +The following code adapts to the presence of a kernel CONFIG option. + +\begin{vindent} +\begin{verbatim} +%( CONFIG_UTRACE == "y" %? + probe process.syscall {} +%) \end{verbatim} \end{vindent} diff --git a/elaborate.cxx b/elaborate.cxx index 22a39c3e..1d7f1e0b 100644 --- a/elaborate.cxx +++ b/elaborate.cxx @@ -56,7 +56,7 @@ expression* add_condition (expression* a, expression* b) derived_probe::derived_probe (probe *p): - base (p) + base (p), sdt_semaphore_addr(0) { assert (p); this->locations = p->locations; @@ -67,7 +67,7 @@ derived_probe::derived_probe (probe *p): derived_probe::derived_probe (probe *p, probe_point *l): - base (p) + base (p), sdt_semaphore_addr(0) { assert (p); this->tok = p->tok; diff --git a/elaborate.h b/elaborate.h index 2da4fa1e..bee71a50 100644 --- a/elaborate.h +++ b/elaborate.h @@ -18,6 +18,10 @@ #include <sstream> #include <map> +extern "C" { +#include <elfutils/libdw.h> +} + // ------------------------------------------------------------------------ struct derived_probe; @@ -164,6 +168,9 @@ public: virtual bool needs_global_locks () { return true; } // by default, probes need locks around global variables + + // Location of semaphores to activate sdt probes + Dwarf_Addr sdt_semaphore_addr; }; // ------------------------------------------------------------------------ diff --git a/grapher/Makefile.am b/grapher/Makefile.am index 7f6b56fd..21ebd256 100644 --- a/grapher/Makefile.am +++ b/grapher/Makefile.am @@ -1,5 +1,6 @@ if BUILD_GRAPHER bin_PROGRAMS = stapgraph +man_MANS = stapgraph.1 stapgraph_CPPFLAGS = -DPKGDATADIR='"${pkgdatadir}"' stapgraph_CXXFLAGS = $(gtkmm_CFLAGS) -Wall -Werror diff --git a/grapher/Makefile.in b/grapher/Makefile.in index 44dddf48..c2df5752 100644 --- a/grapher/Makefile.in +++ b/grapher/Makefile.in @@ -36,16 +36,17 @@ POST_UNINSTALL = : @BUILD_GRAPHER_TRUE@bin_PROGRAMS = stapgraph$(EXEEXT) subdir = grapher DIST_COMMON = $(am__dist_pkgdata_DATA_DIST) $(srcdir)/Makefile.am \ - $(srcdir)/Makefile.in + $(srcdir)/Makefile.in $(srcdir)/stapgraph.1.in ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/configure.ac am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ $(ACLOCAL_M4) mkinstalldirs = $(install_sh) -d CONFIG_HEADER = $(top_builddir)/config.h -CONFIG_CLEAN_FILES = +CONFIG_CLEAN_FILES = stapgraph.1 CONFIG_CLEAN_VPATH_FILES = -am__installdirs = "$(DESTDIR)$(bindir)" "$(DESTDIR)$(pkgdatadir)" +am__installdirs = "$(DESTDIR)$(bindir)" "$(DESTDIR)$(man1dir)" \ + "$(DESTDIR)$(pkgdatadir)" PROGRAMS = $(bin_PROGRAMS) am__stapgraph_SOURCES_DIST = grapher.cxx StapParser.cxx Graph.cxx \ GraphWidget.cxx CairoWidget.cxx @@ -71,7 +72,6 @@ CXXLINK = $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) \ -o $@ SOURCES = $(stapgraph_SOURCES) DIST_SOURCES = $(am__stapgraph_SOURCES_DIST) -am__dist_pkgdata_DATA_DIST = graph-dialog.glade stap-start.glade am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; am__vpath_adj = case $$p in \ $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ @@ -93,6 +93,10 @@ am__nobase_list = $(am__nobase_strip_setup); \ am__base_list = \ sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' +man1dir = $(mandir)/man1 +NROFF = nroff +MANS = $(man_MANS) +am__dist_pkgdata_DATA_DIST = graph-dialog.glade stap-start.glade DATA = $(dist_pkgdata_DATA) ETAGS = etags CTAGS = ctags @@ -215,6 +219,7 @@ target_alias = @target_alias@ top_build_prefix = @top_build_prefix@ top_builddir = @top_builddir@ top_srcdir = @top_srcdir@ +@BUILD_GRAPHER_TRUE@man_MANS = stapgraph.1 @BUILD_GRAPHER_TRUE@stapgraph_CPPFLAGS = -DPKGDATADIR='"${pkgdatadir}"' @BUILD_GRAPHER_TRUE@stapgraph_CXXFLAGS = $(gtkmm_CFLAGS) -Wall -Werror @BUILD_GRAPHER_TRUE@stapgraph_SOURCES = grapher.cxx StapParser.cxx Graph.cxx GraphWidget.cxx CairoWidget.cxx @@ -254,6 +259,8 @@ $(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps) $(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps) cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh $(am__aclocal_m4_deps): +stapgraph.1: $(top_builddir)/config.status $(srcdir)/stapgraph.1.in + cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ install-binPROGRAMS: $(bin_PROGRAMS) @$(NORMAL_INSTALL) test -z "$(bindir)" || $(MKDIR_P) "$(DESTDIR)$(bindir)" @@ -390,6 +397,44 @@ stapgraph-CairoWidget.obj: CairoWidget.cxx @AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='CairoWidget.cxx' object='stapgraph-CairoWidget.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCXX_FALSE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(stapgraph_CPPFLAGS) $(CPPFLAGS) $(stapgraph_CXXFLAGS) $(CXXFLAGS) -c -o stapgraph-CairoWidget.obj `if test -f 'CairoWidget.cxx'; then $(CYGPATH_W) 'CairoWidget.cxx'; else $(CYGPATH_W) '$(srcdir)/CairoWidget.cxx'; fi` +install-man1: $(man_MANS) + @$(NORMAL_INSTALL) + test -z "$(man1dir)" || $(MKDIR_P) "$(DESTDIR)$(man1dir)" + @list=''; test -n "$(man1dir)" || exit 0; \ + { for i in $$list; do echo "$$i"; done; \ + l2='$(man_MANS)'; for i in $$l2; do echo "$$i"; done | \ + sed -n '/\.1[a-z]*$$/p'; \ + } | while read p; do \ + if test -f $$p; then d=; else d="$(srcdir)/"; fi; \ + echo "$$d$$p"; echo "$$p"; \ + done | \ + sed -e 'n;s,.*/,,;p;h;s,.*\.,,;s,^[^1][0-9a-z]*$$,1,;x' \ + -e 's,\.[0-9a-z]*$$,,;$(transform);G;s,\n,.,' | \ + sed 'N;N;s,\n, ,g' | { \ + list=; while read file base inst; do \ + if test "$$base" = "$$inst"; then list="$$list $$file"; else \ + echo " $(INSTALL_DATA) '$$file' '$(DESTDIR)$(man1dir)/$$inst'"; \ + $(INSTALL_DATA) "$$file" "$(DESTDIR)$(man1dir)/$$inst" || exit $$?; \ + fi; \ + done; \ + for i in $$list; do echo "$$i"; done | $(am__base_list) | \ + while read files; do \ + test -z "$$files" || { \ + echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(man1dir)'"; \ + $(INSTALL_DATA) $$files "$(DESTDIR)$(man1dir)" || exit $$?; }; \ + done; } + +uninstall-man1: + @$(NORMAL_UNINSTALL) + @list=''; test -n "$(man1dir)" || exit 0; \ + files=`{ for i in $$list; do echo "$$i"; done; \ + l2='$(man_MANS)'; for i in $$l2; do echo "$$i"; done | \ + sed -n '/\.1[a-z]*$$/p'; \ + } | sed -e 's,.*/,,;h;s,.*\.,,;s,^[^1][0-9a-z]*$$,1,;x' \ + -e 's,\.[0-9a-z]*$$,,;$(transform);G;s,\n,.,'`; \ + test -z "$$files" || { \ + echo " ( cd '$(DESTDIR)$(man1dir)' && rm -f" $$files ")"; \ + cd "$(DESTDIR)$(man1dir)" && rm -f $$files; } install-dist_pkgdataDATA: $(dist_pkgdata_DATA) @$(NORMAL_INSTALL) test -z "$(pkgdatadir)" || $(MKDIR_P) "$(DESTDIR)$(pkgdatadir)" @@ -464,6 +509,19 @@ distclean-tags: -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags distdir: $(DISTFILES) + @list='$(MANS)'; if test -n "$$list"; then \ + list=`for p in $$list; do \ + if test -f $$p; then d=; else d="$(srcdir)/"; fi; \ + if test -f "$$d$$p"; then echo "$$d$$p"; else :; fi; done`; \ + if test -n "$$list" && \ + grep 'ab help2man is required to generate this page' $$list >/dev/null; then \ + echo "error: found man pages containing the \`missing help2man' replacement text:" >&2; \ + grep -l 'ab help2man is required to generate this page' $$list | sed 's/^/ /' >&2; \ + echo " to fix them, install help2man, remove and regenerate the man pages;" >&2; \ + echo " typically \`make maintainer-clean' will remove them" >&2; \ + exit 1; \ + else :; fi; \ + else :; fi @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ list='$(DISTFILES)'; \ @@ -495,9 +553,9 @@ distdir: $(DISTFILES) done check-am: all-am check: check-am -all-am: Makefile $(PROGRAMS) $(DATA) +all-am: Makefile $(PROGRAMS) $(MANS) $(DATA) installdirs: - for dir in "$(DESTDIR)$(bindir)" "$(DESTDIR)$(pkgdatadir)"; do \ + for dir in "$(DESTDIR)$(bindir)" "$(DESTDIR)$(man1dir)" "$(DESTDIR)$(pkgdatadir)"; do \ test -z "$$dir" || $(MKDIR_P) "$$dir"; \ done install: install-am @@ -547,7 +605,7 @@ info: info-am info-am: -install-data-am: install-dist_pkgdataDATA +install-data-am: install-dist_pkgdataDATA install-man install-dvi: install-dvi-am @@ -563,7 +621,7 @@ install-info: install-info-am install-info-am: -install-man: +install-man: install-man1 install-pdf: install-pdf-am @@ -592,7 +650,10 @@ ps: ps-am ps-am: -uninstall-am: uninstall-binPROGRAMS uninstall-dist_pkgdataDATA +uninstall-am: uninstall-binPROGRAMS uninstall-dist_pkgdataDATA \ + uninstall-man + +uninstall-man: uninstall-man1 .MAKE: install-am install-strip @@ -603,12 +664,12 @@ uninstall-am: uninstall-binPROGRAMS uninstall-dist_pkgdataDATA install-data install-data-am install-dist_pkgdataDATA \ install-dvi install-dvi-am install-exec install-exec-am \ install-html install-html-am install-info install-info-am \ - install-man install-pdf install-pdf-am install-ps \ + install-man install-man1 install-pdf install-pdf-am install-ps \ install-ps-am install-strip installcheck installcheck-am \ installdirs maintainer-clean maintainer-clean-generic \ mostlyclean mostlyclean-compile mostlyclean-generic pdf pdf-am \ ps ps-am tags uninstall uninstall-am uninstall-binPROGRAMS \ - uninstall-dist_pkgdataDATA + uninstall-dist_pkgdataDATA uninstall-man uninstall-man1 # Tell versions [3.59,3.63) of GNU make to not export all variables. diff --git a/grapher/stapgraph.1.in b/grapher/stapgraph.1.in new file mode 100644 index 00000000..42ca054d --- /dev/null +++ b/grapher/stapgraph.1.in @@ -0,0 +1,129 @@ +.\" -*- nroff -*- +.TH STAP 1 @DATE@ "Red Hat" +.SH NAME +stapgraph \- systemtap grapher + +.\" macros +.de SAMPLE +.br +.RS +.nf +.nh +.. +.de ESAMPLE +.hy +.fi +.RE +.. + +.SH SYNOPSIS + +.br +.B stapgraph +[ +.I OPTIONS +] +.I FILENAME +[ +.I ARGUMENTS +] +.br +.B stapgraph +[ +.I OPTIONS +] +.B \- +[ +.I ARGUMENTS +] +.br +.B stapgraph +[ +.I OPTIONS +] +.BI \-e " SCRIPT" +[ +.I ARGUMENTS +] + +.SH DESCRIPTION + +The +.IR stapgraph +program is a simple frontend to +.IR stap +that produces graphs from the output of +.IR stap +scripts. +.PP +This manual corresponds to version @VERSION@. + +.SH OPTIONS +.IR stapgraph +accepts all options accepted by +.IR stap. +They are passed through to the +.IR stap +process running the script or probe points. + +.SH USER INTERFACE + +The script that produces results can be started from a dialog within +the program, in addition to being launched using the program's command line +arguments. This dialog allows arguments to be passed to +.IR stap +and to the script. +.PP +When running, a mouse left click on a graph pauses the display of +data, even though it is still collected by the program. Dragging the +mouse scrolls the graph backwards and forwards in time; clicking the +displayed pause button restarts the display of new data. +.PP +The scroll wheel can be used to zoom in and out on the graph. + +.SH SCRIPT OUTPUT SYNTAX +Scripts can output Comma Seperated Values (CSV) which will be interpreted by +.IR stapgraph. +The first value is the X coordinate of the graph, usually a time value. +.IR stapgraph +assumes that this value is constantly increasing. +.PP +A different syntax allows the script to specify many details of the +graph's appearance. +.TP +.BR %DataSet: " DATA-SET-NAME " " SCALE " " COLOR " " GRAPHSTYLE " +.PP +The data set name identifies a data set that will be emitted by the script. +"SCALE" is the overall vertical scale of the graph for this data +set. "COLOR" is a red-green-blue hex color. "GRAPHSTYLE" is one of +bar - a traditional bar graph +dot - plotted points +discreet - An event style timeline that records that an event +happened at a certain time. +.TP +.BR %Title: " TITLE " +A title for the whole graph. +.TP +.BR %XAxisTitle: " TITLE " +The legend for the X axis +.TP +.BR %YAxisTitle: " TITLE " +The legend for the Y axis. +.TP +.BR %YMax: " MAX VALUE " +The maximum value displayed on the graph. + +.SH GRAPH DATA +.BR " DATA SET " " TIME " " VALUE " +Each data point that is to be plotted is tagged with the data set +name, followed by the time and value of the point. + +.SH SEE ALSO +.IR stap (3stap), +.IR staprun (3stap), + +.SH BUGS +Use the Bugzilla link off of the project web page or our mailing list. +.nh +.BR http://sources.redhat.com/systemtap/ , <systemtap@sources.redhat.com> . +.hy @@ -335,8 +335,8 @@ setup_signals (sighandler_t handler) sigaction (SIGTERM, &sa, NULL); } -void -setup_kernel_release (systemtap_session &s, const char* kstr) { +void setup_kernel_release (systemtap_session &s, const char* kstr) +{ if (kstr[0] == '/') // fully specified path { s.kernel_build_tree = kstr; @@ -364,6 +364,29 @@ setup_kernel_release (systemtap_session &s, const char* kstr) { } } + +void parse_kernel_config (systemtap_session &s) +{ + // PR10702: pull config options + string kernel_config_file = s.kernel_build_tree + "/.config"; + ifstream kcf (kernel_config_file.c_str()); + string line; + while (getline (kcf, line)) + { + if (line.substr(0, 7) != "CONFIG_") continue; + size_t off = line.find('='); + if (off == string::npos) continue; + string key = line.substr(0, off); + string value = line.substr(off+1, string::npos); + s.kernel_config[key] = value; + } + if (s.verbose > 2) + clog << "Parsed kernel \"" << kernel_config_file << "\", number of tuples: " << s.kernel_config.size() << endl; + + kcf.close(); +} + + static void checkOptions (systemtap_session &s) { @@ -945,6 +968,9 @@ main (int argc, char * const argv []) clog << "Created temporary directory \"" << s.tmpdir << "\"" << endl; } + // Now that no further changes to s.kernel_build_tree can occur, let's use it. + parse_kernel_config (s); + // Create the name of the C source file within the temporary // directory. s.translated_source = string(s.tmpdir) + "/" + s.module_name + ".c"; @@ -1028,7 +1054,7 @@ main (int argc, char * const argv []) // GLOB_NOMATCH is acceptable if (s.verbose>1 && globbuf.gl_pathc > 0) - clog << "Searched '" << dir << "', " + clog << "Searched \"" << dir << "\", " << "found " << globbuf.gl_pathc << endl; for (unsigned j=0; j<globbuf.gl_pathc; j++) @@ -183,12 +183,14 @@ bool eval_comparison (const OPERAND& lhs, const token* op, const OPERAND& rhs) // The basic form is %( CONDITION %? THEN-TOKENS %: ELSE-TOKENS %) // where CONDITION is: kernel_v[r] COMPARISON-OP "version-string" // or: arch COMPARISON-OP "arch-string" +// or: CONFIG_foo COMPARISON-OP "config-string" // or: "string1" COMPARISON-OP "string2" // or: number1 COMPARISON-OP number2 // The %: ELSE-TOKENS part is optional. // // e.g. %( kernel_v > "2.5" %? "foo" %: "baz" %) // e.g. %( arch != "i?86" %? "foo" %: "baz" %) +// e.g. %( CONFIG_foo %? "foo" %: "baz" %) // // Up to an entire %( ... %) expression is processed by a single call // to this function. Tokens included by any nested conditions are @@ -270,6 +272,23 @@ bool eval_pp_conditional (systemtap_session& s, return result; } + else if (l->type == tok_identifier && l->content.substr(0,7) == "CONFIG_" && r->type == tok_string) + { + string lhs = s.kernel_config[l->content]; // may be empty + string rhs = r->content; + + int nomatch = fnmatch (rhs.c_str(), lhs.c_str(), FNM_NOESCAPE); // still spooky + + bool result; + if (op->type == tok_operator && op->content == "==") + result = !nomatch; + else if (op->type == tok_operator && op->content == "!=") + result = nomatch; + else + throw parse_error ("expected '==' or '!='", op); + + return result; + } else if (l->type == tok_string && r->type == tok_string) { string lhs = l->content; @@ -291,10 +310,8 @@ bool eval_pp_conditional (systemtap_session& s, && op->type == tok_operator) throw parse_error ("expected number literal as right value", r); - // XXX: support other forms? "CONFIG_SMP" ? - else - throw parse_error ("expected 'arch' or 'kernel_v' or 'kernel_vr'\n" + throw parse_error ("expected 'arch' or 'kernel_v' or 'kernel_vr' or 'CONFIG_...'\n" " or comparison between strings or integers", l); } diff --git a/runtime/staprun/mainloop.c b/runtime/staprun/mainloop.c index 45b142bc..513a9569 100644 --- a/runtime/staprun/mainloop.c +++ b/runtime/staprun/mainloop.c @@ -60,12 +60,15 @@ static void chld_proc(int signum) } #if WORKAROUND_BZ467568 -/* Used for pause()-based synchronization. */ -static void signal_dontcare(int signum) +/* When a SIGUSR1 signal arrives, set this variable. */ +volatile sig_atomic_t usr1_interrupt = 0; + +static void signal_usr1(int signum) { (void) signum; + usr1_interrupt = 1; } -#endif +#endif /* WORKAROUND_BZ467568 */ static void setup_main_signals(void) { @@ -115,6 +118,10 @@ void start_cmd(void) { pid_t pid; struct sigaction a; +#if WORKAROUND_BZ467568 + struct sigaction usr1_action, old_action; + sigset_t blockmask, oldmask; +#endif /* WORKAROUND_BZ467568 */ /* if we are execing a target cmd, ignore ^C in stapio */ /* and let the target cmd get it. */ @@ -123,6 +130,21 @@ void start_cmd(void) a.sa_handler = SIG_IGN; sigaction(SIGINT, &a, NULL); +#if WORKAROUND_BZ467568 + /* Set up the mask of signals to temporarily block. */ + sigemptyset (&blockmask); + sigaddset (&blockmask, SIGUSR1); + + /* Establish the SIGUSR1 signal handler. */ + sigfillset (&usr1_action.sa_mask); + usr1_action.sa_flags = 0; + usr1_action.sa_handler = signal_usr1; + sigaction (SIGUSR1, &usr1_action, &old_action); + + /* Block SIGUSR1 */ + sigprocmask(SIG_BLOCK, &blockmask, &oldmask); +#endif /* WORKAROUND_BZ467568 */ + if ((pid = fork()) < 0) { _perr("fork"); exit(1); @@ -175,22 +197,21 @@ void start_cmd(void) dbug(1, "blocking briefly\n"); #if WORKAROUND_BZ467568 { - /* We use SIGUSR1 here, since pause() only returns if a - handled signal was received. */ - struct sigaction sa; - memset(&sa, 0, sizeof(sa)); - sigfillset(&sa.sa_mask); - sa.sa_handler = signal_dontcare; - sigaction(SIGUSR1, &sa, NULL); - pause (); - sa.sa_handler = SIG_DFL; - sigaction(SIGUSR1, &sa, NULL); + /* Wait for the SIGUSR1 */ + while (!usr1_interrupt) + sigsuspend(&oldmask); + + /* Restore the old SIGUSR1 signal handler. */ + sigaction (SIGUSR1, &old_action, NULL); + + /* Restore the original signal mask */ + sigprocmask(SIG_SETMASK, &oldmask, NULL); } -#else +#else /* !WORKAROUND_BZ467568 */ rc = ptrace (PTRACE_TRACEME, 0, 0, 0); if (rc < 0) perror ("ptrace me"); raise (SIGCONT); /* Harmless; just passes control to parent. */ -#endif +#endif /* !WORKAROUND_BZ467568 */ dbug(1, "execing target_cmd %s\n", target_cmd); @@ -217,12 +238,16 @@ void start_cmd(void) us to release it. */ target_pid = pid; #if WORKAROUND_BZ467568 - /* Do nothing else here; see stp_main_loop's handling of a received STP_START. */ -#else + /* Restore the old SIGUSR1 signal handler. */ + sigaction (SIGUSR1, &old_action, NULL); + + /* Restore the original signal mask */ + sigprocmask(SIG_SETMASK, &oldmask, NULL); +#else /* !WORKAROUND_BZ467568 */ int status; waitpid (target_pid, &status, 0); dbug(1, "waited for target_cmd %s pid %d status %x\n", target_cmd, target_pid, (unsigned) status); -#endif +#endif /* !WORKAROUND_BZ467568 */ } } diff --git a/runtime/staprun/staprun_funcs.c b/runtime/staprun/staprun_funcs.c index e4ccc8da..aef8a2da 100644 --- a/runtime/staprun/staprun_funcs.c +++ b/runtime/staprun/staprun_funcs.c @@ -453,12 +453,11 @@ void assert_permissions( off_t module_size __attribute__ ((unused)) ) { int check_groups_rc; - int check_signature_rc = 0; #if HAVE_NSS /* Attempt to verify the module against its signature. Return failure if the module has been tampered with (altered). */ - check_signature_rc = check_signature (module_data, module_size); + int check_signature_rc = check_signature (module_data, module_size); if (check_signature_rc == MODULE_ALTERED) exit(-1); #endif @@ -87,6 +87,7 @@ struct systemtap_session std::string kernel_release; std::string kernel_base_release; std::string kernel_build_tree; + std::map<std::string,std::string> kernel_config; std::string architecture; std::string runtime_path; std::string data_path; @@ -221,10 +222,6 @@ struct systemtap_session void print_error_source (std::ostream&, std::string&, const token* tok); void print_warning (const std::string& w, const token* tok = 0); - - // Location of semaphores to activate sdt probes - std::map<derived_probe*, Dwarf_Addr> sdt_semaphore_addr; - // NB: It is very important for all of the above (and below) fields // to be cleared in the systemtap_session ctor (elaborate.cxx) // and/or main.cxx(main). @@ -340,12 +340,21 @@ by If, on the other hand, the first part is the identifier .BR arch to refer to the processor architecture (as named by the kernel -build system ARCH/SUBARCH), then the second part then the second +build system ARCH/SUBARCH), then the second part is one of the two string comparison operators .BR == " or " != , and the third part is a string literal for matching it. This comparison is a wildcard (mis)match. .PP +Similarly, if the first part is an identifier like +.BR CONFIG_something +to refer to a kernel configuration option, then the second part is +.BR == " or " != , +and the third part is a string literal for matching the value +(commonly "y" or "m"). Nonexistent or unset kernel configuration +options are represented by the empty string. This comparison is also +a wildcard (mis)match. +.PP Otherwise, the CONDITION is expected to be a comparison between two string literals or two numeric literals. In this case, the arguments are the only variables usable. diff --git a/tapset-itrace.cxx b/tapset-itrace.cxx index cdd7ac19..cd041a54 100644 --- a/tapset-itrace.cxx +++ b/tapset-itrace.cxx @@ -75,6 +75,8 @@ itrace_derived_probe::itrace_derived_probe (systemtap_session &s, ): derived_probe(p, l), has_path(hp), path(pn), pid(pd), single_step(ss) { + if (s.kernel_config["CONFIG_UTRACE"] != string("y")) + throw semantic_error ("process probes not available without kernel CONFIG_UTRACE"); } diff --git a/tapset-utrace.cxx b/tapset-utrace.cxx index a8500493..b731293c 100644 --- a/tapset-utrace.cxx +++ b/tapset-utrace.cxx @@ -121,6 +121,9 @@ utrace_derived_probe::utrace_derived_probe (systemtap_session &s, has_path(hp), path(pn), pid(pd), flags(f), target_symbol_seen(false) { + if (s.kernel_config["CONFIG_UTRACE"] != string("y")) + throw semantic_error ("process probes not available without kernel CONFIG_UTRACE"); + // Expand local variables in the probe body utrace_var_expanding_visitor v (s, l, name, flags); v.replace (this->body); @@ -753,12 +756,9 @@ utrace_derived_probe_group::emit_probe_decl (systemtap_session& s, } s.op->line() << " .engine_attached=0,"; - map<derived_probe*, Dwarf_Addr>::iterator its = s.sdt_semaphore_addr.find(p); - if (its == s.sdt_semaphore_addr.end()) - s.op->line() << " .sdt_sem_address=(unsigned long)0x0,"; - else + if (p->sdt_semaphore_addr != 0) s.op->line() << " .sdt_sem_address=(unsigned long)0x" - << hex << its->second << dec << "ULL,"; + << hex << p->sdt_semaphore_addr << dec << "ULL,"; s.op->line() << " .tsk=0,"; s.op->line() << " },"; diff --git a/tapset/proc_mem.stp b/tapset/proc_mem.stp index 1493bd92..7641ffe2 100644 --- a/tapset/proc_mem.stp +++ b/tapset/proc_mem.stp @@ -134,6 +134,7 @@ function _stp_number_to_string_postfix:string (x:long, y:long, p:string) /** * sfunction bytes_to_string - Human readable string for given bytes. + * @bytes: Number of bytes to translate. * * Description: Returns a string representing the number of bytes (up * to 1024 bytes), the number of kilobytes (when less than 1024K) @@ -166,6 +167,7 @@ function bytes_to_string:string (bytes:long) /** * sfunction pages_to_string - Turns pages into a human readable string. + * @pages: Number of pages to translate. * * Description: Multiplies pages by page_size() to get the number of * bytes and returns the result of bytes_to_string(). diff --git a/tapset/syscalls.stp b/tapset/syscalls.stp index 0886deeb..825842a6 100644 --- a/tapset/syscalls.stp +++ b/tapset/syscalls.stp @@ -28,8 +28,8 @@ # accept _____________________________________________________ # long sys_accept(int fd, struct sockaddr __user *upeer_sockaddr, # int __user *upeer_addrlen) -probe syscall.accept = kernel.function("SyS_accept") !, - kernel.function("sys_accept") ? +probe syscall.accept = kernel.function("SyS_accept").call !, + kernel.function("sys_accept").call ? { name = "accept" sockfd = $fd @@ -46,8 +46,8 @@ probe syscall.accept.return = kernel.function("SyS_accept").return !, # access _____________________________________________________ # long sys_access(const char __user * filename, int mode) -probe syscall.access = kernel.function("SyS_access") !, - kernel.function("sys_access") +probe syscall.access = kernel.function("SyS_access").call !, + kernel.function("sys_access").call { name = "access" pathname = user_string($filename) @@ -64,7 +64,7 @@ probe syscall.access.return = kernel.function("SyS_access").return !, # acct _______________________________________________________ # long sys_acct(const char __user *name) -probe syscall.acct = kernel.function("sys_acct") ? +probe syscall.acct = kernel.function("sys_acct").call ? { name = "acct" filename = user_string($name) @@ -83,8 +83,8 @@ probe syscall.acct.return = kernel.function("sys_acct").return ? # size_t plen, # key_serial_t ringid) # -probe syscall.add_key = kernel.function("SyS_add_key") !, - kernel.function("sys_add_key") ? +probe syscall.add_key = kernel.function("SyS_add_key").call !, + kernel.function("sys_add_key").call ? { name = "add_key" type_uaddr = $_type @@ -107,8 +107,8 @@ probe syscall.add_key.return = kernel.function("SyS_add_key").return !, # adjtimex ___________________________________________________ # long sys_adjtimex(struct timex __user *txc_p) -probe syscall.adjtimex = kernel.function("SyS_adjtimex") !, - kernel.function("sys_adjtimex") +probe syscall.adjtimex = kernel.function("SyS_adjtimex").call !, + kernel.function("sys_adjtimex").call { name = "adjtimex" @@ -134,7 +134,7 @@ probe syscall.adjtimex.return = kernel.function("SyS_adjtimex").return !, retstr = _adjtimex_return_str($return) } # long compat_sys_adjtimex(struct compat_timex __user *utp) -probe syscall.compat_adjtimex = kernel.function("compat_sys_adjtimex") ? +probe syscall.compat_adjtimex = kernel.function("compat_sys_adjtimex").call ? { name = "compat_adjtimex" argstr = sprintf("%p", $utp) @@ -149,9 +149,9 @@ probe syscall.compat_adjtimex.return = kernel.function("compat_sys_adjtimex").re # unsigned long sys_alarm (unsigned int seconds) # long sys32_alarm(unsigned int seconds) # -probe syscall.alarm = kernel.function("sys32_alarm") ?, - kernel.function("SyS_alarm") !, - kernel.function("sys_alarm") ? +probe syscall.alarm = kernel.function("sys32_alarm").call ?, + kernel.function("SyS_alarm").call !, + kernel.function("sys_alarm").call ? { name = "alarm" seconds = $seconds @@ -167,8 +167,8 @@ probe syscall.alarm.return = kernel.function("sys32_alarm").return ?, # bdflush ____________________________________________________ # long sys_bdflush(int func, long data) -probe syscall.bdflush = kernel.function("SyS_bdflush") !, - kernel.function("sys_bdflush") ? +probe syscall.bdflush = kernel.function("SyS_bdflush").call !, + kernel.function("sys_bdflush").call ? { name = "bdflush" func = $func @@ -188,8 +188,8 @@ probe syscall.bdflush.return = kernel.function("SyS_bdflush").return !, # bind _______________________________________________________ # long sys_bind(int fd, struct sockaddr __user *umyaddr, int addrlen) -probe syscall.bind = kernel.function("SyS_bind") !, - kernel.function("sys_bind") ? +probe syscall.bind = kernel.function("SyS_bind").call !, + kernel.function("sys_bind").call ? { name = "bind" sockfd = $fd @@ -206,9 +206,9 @@ probe syscall.bind.return = kernel.function("SyS_bind").return !, # brk ________________________________________________________ # unsigned long sys_brk(unsigned long brk) -probe syscall.brk = kernel.function("ia64_brk") ?, - kernel.function("SyS_brk") !, - kernel.function("sys_brk") +probe syscall.brk = kernel.function("ia64_brk").call ?, + kernel.function("SyS_brk").call !, + kernel.function("sys_brk").call { name = "brk" brk = $brk @@ -235,8 +235,8 @@ probe syscall.brk.return = kernel.function("ia64_brk").return ?, * functions to export. */ # long sys_capget(cap_user_header_t header, cap_user_data_t dataptr) -probe syscall.capget = kernel.function("SyS_capget") !, - kernel.function("sys_capget") +probe syscall.capget = kernel.function("SyS_capget").call !, + kernel.function("sys_capget").call { name = "capget" header_uaddr = $header @@ -262,8 +262,8 @@ probe syscall.capget.return = kernel.function("SyS_capget").return !, * functions to export. */ # long sys_capset(cap_user_header_t header, const cap_user_data_t data) -probe syscall.capset = kernel.function("SyS_capset") !, - kernel.function("sys_capset") +probe syscall.capset = kernel.function("SyS_capset").call !, + kernel.function("sys_capset").call { name = "capset" header_uaddr = $header @@ -279,8 +279,8 @@ probe syscall.capset.return = kernel.function("SyS_capset").return !, # chdir ______________________________________________________ # long sys_chdir(const char __user * filename) -probe syscall.chdir = kernel.function("SyS_chdir") !, - kernel.function("sys_chdir") +probe syscall.chdir = kernel.function("SyS_chdir").call !, + kernel.function("sys_chdir").call { name = "chdir" path = user_string($filename) @@ -295,8 +295,8 @@ probe syscall.chdir.return = kernel.function("SyS_chdir").return !, # chmod ______________________________________________________ # long sys_chmod(const char __user * filename, mode_t mode) -probe syscall.chmod = kernel.function("SyS_chmod") !, - kernel.function("sys_chmod") +probe syscall.chmod = kernel.function("SyS_chmod").call !, + kernel.function("sys_chmod").call { name = "chmod" path = user_string($filename) @@ -312,8 +312,8 @@ probe syscall.chmod.return = kernel.function("SyS_chmod").return !, # chown ______________________________________________________ # long sys_chown(const char __user * filename, uid_t user, gid_t group) -probe syscall.chown = kernel.function("SyS_chown") !, - kernel.function("sys_chown") +probe syscall.chown = kernel.function("SyS_chown").call !, + kernel.function("sys_chown").call { name = "chown" path = user_string($filename) @@ -331,7 +331,7 @@ probe syscall.chown.return = kernel.function("SyS_chown").return !, # long sys_chown16(const char __user * filename, old_uid_t user, # old_gid_t group) # -probe syscall.chown16 = kernel.function("sys_chown16") ? +probe syscall.chown16 = kernel.function("sys_chown16").call ? { name = "chown16" path = user_string($filename) @@ -347,8 +347,8 @@ probe syscall.chown16.return = kernel.function("sys_chown16").return ? # chroot _____________________________________________________ # long sys_chroot(const char __user * filename) -probe syscall.chroot = kernel.function("SyS_chroot") !, - kernel.function("sys_chroot") +probe syscall.chroot = kernel.function("SyS_chroot").call !, + kernel.function("sys_chroot").call { name = "chroot" path = user_string($filename) @@ -365,9 +365,9 @@ probe syscall.chroot.return = kernel.function("SyS_chroot").return !, # long sys_clock_getres(clockid_t which_clock, struct timespec __user *tp) # long compat_clock_getres(clockid_t which_clock, struct compat_timespec __user *tp) # -probe syscall.clock_getres = kernel.function("compat_clock_getres") ?, - kernel.function("SyS_clock_getres") !, - kernel.function("sys_clock_getres") +probe syscall.clock_getres = kernel.function("compat_clock_getres").call ?, + kernel.function("SyS_clock_getres").call !, + kernel.function("sys_clock_getres").call { name = "clock_getres" clk_id = $which_clock @@ -386,8 +386,8 @@ probe syscall.clock_getres.return = kernel.function("compat_clock_getres").retur # clock_gettime ______________________________________________ # long sys_clock_gettime(clockid_t which_clock, struct timespec __user *tp) # -probe syscall.clock_gettime = kernel.function("SyS_clock_gettime") !, - kernel.function("sys_clock_gettime") +probe syscall.clock_gettime = kernel.function("SyS_clock_gettime").call !, + kernel.function("sys_clock_gettime").call { name = "clock_gettime" clk_id = $which_clock @@ -407,8 +407,8 @@ probe syscall.clock_gettime.return = kernel.function("SyS_clock_gettime").return # const struct timespec __user *rqtp, # struct timespec __user *rmtp) # -probe syscall.clock_nanosleep = kernel.function("SyS_clock_nanosleep") !, - kernel.function("sys_clock_nanosleep") +probe syscall.clock_nanosleep = kernel.function("SyS_clock_nanosleep").call !, + kernel.function("sys_clock_nanosleep").call { name = "clock_nanosleep" if ($flags == 1) @@ -430,8 +430,8 @@ probe syscall.clock_nanosleep.return = kernel.function("SyS_clock_nanosleep").re # struct compat_timespec __user *rqtp, # struct compat_timespec __user *rmtp) # -probe syscall.compat_clock_nanosleep = kernel.function("compat_clock_nanosleep") ?, - kernel.function("compat_sys_clock_nanosleep") ? +probe syscall.compat_clock_nanosleep = kernel.function("compat_clock_nanosleep").call ?, + kernel.function("compat_sys_clock_nanosleep").call ? { name = "compat_clock_nanosleep" if ($flags == 1) @@ -452,8 +452,8 @@ probe syscall.compat_clock_nanosleep.return = kernel.function("compat_clock_nano # long sys_clock_settime(clockid_t which_clock, # const struct timespec __user *tp) # -probe syscall.clock_settime = kernel.function("SyS_clock_settime") !, - kernel.function("sys_clock_settime") +probe syscall.clock_settime = kernel.function("SyS_clock_settime").call !, + kernel.function("sys_clock_settime").call { name = "clock_settime" clk_id = $which_clock @@ -470,8 +470,8 @@ probe syscall.clock_settime.return = kernel.function("SyS_clock_settime").return # close ______________________________________________________ # long sys_close(unsigned int fd) -probe syscall.close = kernel.function("SyS_close") !, - kernel.function("sys_close") +probe syscall.close = kernel.function("SyS_close").call !, + kernel.function("sys_close").call { name = "close" fd = $fd @@ -485,8 +485,8 @@ probe syscall.close.return = kernel.function("SyS_close").return !, } # connect ____________________________________________________ # long sys_connect(int fd, struct sockaddr __user *uservaddr, int addrlen) -probe syscall.connect = kernel.function("SyS_connect") !, - kernel.function("sys_connect") ? +probe syscall.connect = kernel.function("SyS_connect").call !, + kernel.function("sys_connect").call ? { name = "connect" sockfd = $fd @@ -503,8 +503,8 @@ probe syscall.connect.return = kernel.function("SyS_connect").return !, # creat # long sys_creat(const char __user * pathname, int mode) -probe syscall.creat = kernel.function("SyS_creat") !, - kernel.function("sys_creat") ? +probe syscall.creat = kernel.function("SyS_creat").call !, + kernel.function("sys_creat").call ? { name = "creat" mode = $mode @@ -520,8 +520,8 @@ probe syscall.creat.return = kernel.function("SyS_creat").return !, # delete_module ______________________________________________ # long sys_delete_module(const char __user *name_user, unsigned int flags) -probe syscall.delete_module = kernel.function("SyS_delete_module") !, - kernel.function("sys_delete_module") ? +probe syscall.delete_module = kernel.function("SyS_delete_module").call !, + kernel.function("sys_delete_module").call ? { name = "delete_module" name_user = user_string($name_user) @@ -537,8 +537,8 @@ probe syscall.delete_module.return = kernel.function("SyS_delete_module").return # dup ________________________________________________________ # long sys_dup(unsigned int fildes) -probe syscall.dup = kernel.function("SyS_dup") !, - kernel.function("sys_dup") +probe syscall.dup = kernel.function("SyS_dup").call !, + kernel.function("sys_dup").call { name = "dup" oldfd = $fildes @@ -553,8 +553,8 @@ probe syscall.dup.return = kernel.function("SyS_dup").return !, # dup2 _______________________________________________________ # long sys_dup2(unsigned int oldfd, unsigned int newfd) -probe syscall.dup2 = kernel.function("SyS_dup2") !, - kernel.function("sys_dup2") +probe syscall.dup2 = kernel.function("SyS_dup2").call !, + kernel.function("sys_dup2").call { name = "dup2" oldfd = $oldfd @@ -570,8 +570,8 @@ probe syscall.dup2.return = kernel.function("SyS_dup2").return !, # epoll_create _______________________________________________ # long sys_epoll_create(int size) -probe syscall.epoll_create = kernel.function("SyS_epoll_create") !, - kernel.function("sys_epoll_create") ? +probe syscall.epoll_create = kernel.function("SyS_epoll_create").call !, + kernel.function("sys_epoll_create").call ? { name = "epoll_create" size = $size @@ -590,9 +590,9 @@ probe syscall.epoll_create.return = kernel.function("SyS_epoll_create").return ! # long compat_sys_epoll_ctl(int epfd, int op, int fd, # struct compat_epoll_event __user *event) # -probe syscall.epoll_ctl = kernel.function("compat_sys_epoll_ctl") ?, - kernel.function("SyS_epoll_ctl") !, - kernel.function("sys_epoll_ctl") ? +probe syscall.epoll_ctl = kernel.function("compat_sys_epoll_ctl").call ?, + kernel.function("SyS_epoll_ctl").call !, + kernel.function("sys_epoll_ctl").call ? { name = "epoll_ctl" epfd = $epfd @@ -621,9 +621,9 @@ probe syscall.epoll_ctl.return = kernel.function("compat_sys_epoll_ctl").return # const compat_sigset_t __user *sigmask, # compat_size_t sigsetsize) # -probe syscall.epoll_pwait = kernel.function("compat_sys_epoll_pwait") ?, - kernel.function("SyS_epoll_pwait") !, - kernel.function("sys_epoll_pwait") ? +probe syscall.epoll_pwait = kernel.function("compat_sys_epoll_pwait").call ?, + kernel.function("SyS_epoll_pwait").call !, + kernel.function("sys_epoll_pwait").call ? { name = "epoll_pwait" argstr = sprintf("%d, %p, %d, %d, %p, %d", @@ -645,9 +645,9 @@ probe syscall.epoll_pwait.return = kernel.function("compat_sys_epoll_pwait").ret # struct compat_epoll_event __user *events, # int maxevents, int timeout) # -probe syscall.epoll_wait = kernel.function("compat_sys_epoll_wait") ?, - kernel.function("SyS_epoll_wait") !, - kernel.function("sys_epoll_wait") ? +probe syscall.epoll_wait = kernel.function("compat_sys_epoll_wait").call ?, + kernel.function("SyS_epoll_wait").call !, + kernel.function("sys_epoll_wait").call ? { name = "epoll_wait" epfd = $epfd @@ -667,8 +667,8 @@ probe syscall.epoll_wait.return = kernel.function("compat_sys_epoll_wait").retur # eventfd _____________________________________________________ # long sys_eventfd(unsigned int count) # -probe syscall.eventfd = kernel.function("SyS_eventfd") !, - kernel.function("sys_eventfd") ? +probe syscall.eventfd = kernel.function("SyS_eventfd").call !, + kernel.function("sys_eventfd").call ? { name = "eventfd" argstr = sprint($count) @@ -687,7 +687,7 @@ probe syscall.eventfd.return = kernel.function("SyS_eventfd").return !, # char __user *__user *argv, # char __user *__user *envp, # struct pt_regs * regs) -probe syscall.execve = kernel.function("do_execve") +probe syscall.execve = kernel.function("do_execve").call { name = "execve" filename = kernel_string($filename) @@ -705,7 +705,7 @@ probe syscall.execve.return = kernel.function("do_execve").return # compat_uptr_t __user *argv, # compat_uptr_t __user *envp, # struct pt_regs * regs) -probe syscall.compat_execve = kernel.function("compat_do_execve") ? +probe syscall.compat_execve = kernel.function("compat_do_execve").call ? { name = "compat_execve" filename = kernel_string($filename) @@ -720,7 +720,7 @@ probe syscall.compat_execve.return = kernel.function("compat_do_execve").return # exit _______________________________________________________ # long sys_exit(int error_code) -probe syscall.exit = kernel.function("do_exit") +probe syscall.exit = kernel.function("do_exit").call { name = "exit" status = $code @@ -732,8 +732,8 @@ probe syscall.exit = kernel.function("do_exit") # exit_group _________________________________________________ # void sys_exit_group(int error_code) # -probe syscall.exit_group = kernel.function("SyS_exit_group") !, - kernel.function("sys_exit_group") +probe syscall.exit_group = kernel.function("SyS_exit_group").call !, + kernel.function("sys_exit_group").call { name = "exit_group" status = $error_code @@ -745,8 +745,8 @@ probe syscall.exit_group = kernel.function("SyS_exit_group") !, # faccessat __________________________________________________ # new function with 2.6.16 # long sys_faccessat(int dfd, const char __user *filename, int mode) -probe syscall.faccessat = kernel.function("SyS_faccessat") !, - kernel.function("sys_faccessat") ? +probe syscall.faccessat = kernel.function("SyS_faccessat").call !, + kernel.function("sys_faccessat").call ? { name = "faccessat" dirfd = $dfd @@ -767,8 +767,8 @@ probe syscall.faccessat.return = kernel.function("SyS_faccessat").return !, # fadvise64 __________________________________________________ # long sys_fadvise64(int fd, loff_t offset, size_t len, int advice) # -probe syscall.fadvise64 = kernel.function("SyS_fadvise64") !, - kernel.function("sys_fadvise64") ? +probe syscall.fadvise64 = kernel.function("SyS_fadvise64").call !, + kernel.function("sys_fadvise64").call ? { name = "fadvise64" fd = $fd @@ -787,8 +787,8 @@ probe syscall.fadvise64.return = kernel.function("SyS_fadvise64").return !, # fadvise64_64 _______________________________________________ # long sys_fadvise64_64(int fd, loff_t offset, loff_t len, int advice) # -probe syscall.fadvise64_64 = kernel.function("SyS_fadvise64_64") !, - kernel.function("sys_fadvise64_64") ? +probe syscall.fadvise64_64 = kernel.function("SyS_fadvise64_64").call !, + kernel.function("sys_fadvise64_64").call ? { name = "fadvise64_64" fd = $fd @@ -809,8 +809,8 @@ probe syscall.fadvise64_64.return = kernel.function("SyS_fadvise64_64").return ! # fadvise64 __________________________________________________ # long sys_fadvise64(int fd, loff_t offset, size_t len, int advice) # -probe syscall.fadvise64 = kernel.function("SyS_fadvise64") !, - kernel.function("sys_fadvise64") +probe syscall.fadvise64 = kernel.function("SyS_fadvise64").call !, + kernel.function("sys_fadvise64").call { name = "fadvise64" fd = 0 @@ -829,8 +829,8 @@ probe syscall.fadvise64.return = kernel.function("SyS_fadvise64").return !, # fadvise64_64 _______________________________________________ # long sys_fadvise64_64(int fd, loff_t offset, loff_t len, int advice) # -probe syscall.fadvise64_64 = kernel.function("SyS_fadvise64_64") !, - kernel.function("sys_fadvise64_64") +probe syscall.fadvise64_64 = kernel.function("SyS_fadvise64_64").call !, + kernel.function("sys_fadvise64_64").call { name = "fadvise64_64" fd = 0 @@ -849,8 +849,8 @@ probe syscall.fadvise64_64.return = kernel.function("SyS_fadvise64_64").return ! # fchdir _____________________________________________________ # long sys_fchdir(unsigned int fd) -probe syscall.fchdir = kernel.function("SyS_fchdir") !, - kernel.function("sys_fchdir") +probe syscall.fchdir = kernel.function("SyS_fchdir").call !, + kernel.function("sys_fchdir").call { name = "fchdir" fd = $fd @@ -865,8 +865,8 @@ probe syscall.fchdir.return = kernel.function("SyS_fchdir").return !, # fchmod _____________________________________________________ # long sys_fchmod(unsigned int fd, mode_t mode) -probe syscall.fchmod = kernel.function("SyS_fchmod") !, - kernel.function("sys_fchmod") +probe syscall.fchmod = kernel.function("SyS_fchmod").call !, + kernel.function("sys_fchmod").call { name = "fchmod" fildes = $fd @@ -884,8 +884,8 @@ probe syscall.fchmod.return = kernel.function("SyS_fchmod").return !, # new function with 2.6.16 # long sys_fchmodat(int dfd, const char __user *filename, # mode_t mode) -probe syscall.fchmodat = kernel.function("SyS_fchmodat") !, - kernel.function("sys_fchmodat") ? +probe syscall.fchmodat = kernel.function("SyS_fchmodat").call !, + kernel.function("sys_fchmodat").call ? { name = "fchmodat" dirfd = $dfd @@ -903,8 +903,8 @@ probe syscall.fchmodat.return = kernel.function("SyS_fchmodat").return !, # fchown _____________________________________________________ # long sys_fchown(unsigned int fd, uid_t user, gid_t group) -probe syscall.fchown = kernel.function("SyS_fchown") !, - kernel.function("sys_fchown") +probe syscall.fchown = kernel.function("SyS_fchown").call !, + kernel.function("sys_fchown").call { name = "fchown" fd = $fd @@ -921,7 +921,7 @@ probe syscall.fchown.return = kernel.function("SyS_fchown").return !, # fchown16 ___________________________________________________ # long sys_fchown16(unsigned int fd, old_uid_t user, old_gid_t group) -probe syscall.fchown16 = kernel.function("sys_fchown16") ? +probe syscall.fchown16 = kernel.function("sys_fchown16").call ? { name = "fchown16" fd = $fd @@ -939,8 +939,8 @@ probe syscall.fchown16.return = kernel.function("sys_fchown16").return ? # new function with 2.6.16 # long sys_fchownat(int dfd, const char __user *filename, # uid_t user, gid_t group, int flag) -probe syscall.fchownat = kernel.function("SyS_fchownat") !, - kernel.function("sys_fchownat") ? +probe syscall.fchownat = kernel.function("SyS_fchownat").call !, + kernel.function("sys_fchownat").call ? { name = "fchownat" dirfd = $dfd @@ -966,11 +966,11 @@ probe syscall.fchownat.return = kernel.function("SyS_fchownat").return !, # long compat_sys_fcntl64(unsigned int fd, unsigned int cmd, unsigned long arg) # long compat_sys_fcntl(unsigned int fd, unsigned int cmd, unsigned long arg) # -probe syscall.fcntl = kernel.function("compat_sys_fcntl") ?, - kernel.function("compat_sys_fcntl64") ?, - kernel.function("sys_fcntl64") ?, - kernel.function("SyS_fcntl") !, - kernel.function("sys_fcntl") ? +probe syscall.fcntl = kernel.function("compat_sys_fcntl").call ?, + kernel.function("compat_sys_fcntl64").call ?, + kernel.function("sys_fcntl64").call ?, + kernel.function("SyS_fcntl").call !, + kernel.function("sys_fcntl").call ? { name = "fcntl" fd = $fd @@ -991,8 +991,8 @@ probe syscall.fcntl.return = kernel.function("compat_sys_fcntl").return ?, # fdatasync __________________________________________________ # long sys_fdatasync(unsigned int fd) -probe syscall.fdatasync = kernel.function("SyS_fdatasync") !, - kernel.function("sys_fdatasync") +probe syscall.fdatasync = kernel.function("SyS_fdatasync").call !, + kernel.function("sys_fdatasync").call { name = "fdatasync" fd = $fd @@ -1008,8 +1008,8 @@ probe syscall.fdatasync.return = kernel.function("SyS_fdatasync").return !, # fgetxattr __________________________________________________ # ssize_t sys_fgetxattr(int fd, char __user *name, # void __user *value, size_t size) -probe syscall.fgetxattr = kernel.function("SyS_fgetxattr") !, - kernel.function("sys_fgetxattr") +probe syscall.fgetxattr = kernel.function("SyS_fgetxattr").call !, + kernel.function("sys_fgetxattr").call { name = "fgetxattr" filedes = $fd @@ -1027,8 +1027,8 @@ probe syscall.fgetxattr.return = kernel.function("SyS_fgetxattr").return !, } # flistxattr _________________________________________________ # ssize_t sys_flistxattr(int fd, char __user *list, size_t size) -probe syscall.flistxattr = kernel.function("SyS_flistxattr") !, - kernel.function("sys_flistxattr") +probe syscall.flistxattr = kernel.function("SyS_flistxattr").call !, + kernel.function("sys_flistxattr").call { name = "flistxattr" filedes = $fd @@ -1045,8 +1045,8 @@ probe syscall.flistxattr.return = kernel.function("SyS_flistxattr").return !, # flock ______________________________________________________ # long sys_flock(unsigned int fd, unsigned int cmd) -probe syscall.flock = kernel.function("SyS_flock") !, - kernel.function("sys_flock") +probe syscall.flock = kernel.function("SyS_flock").call !, + kernel.function("sys_flock").call { name = "flock" fd = $fd @@ -1100,7 +1100,7 @@ CATCH_DEREF_FAULT(); # unsigned long stack_size, # int __user *parent_tidptr, # int __user *child_tidptr) -probe syscall.fork = kernel.function("do_fork") +probe syscall.fork = kernel.function("do_fork").call { clone_flags = $clone_flags stack_start = $stack_start @@ -1128,8 +1128,8 @@ probe syscall.fork.return = kernel.function("do_fork").return } # fremovexattr _______________________________________________ # long sys_fremovexattr(int fd, char __user *name) -probe syscall.fremovexattr = kernel.function("SyS_fremovexattr") !, - kernel.function("sys_fremovexattr") +probe syscall.fremovexattr = kernel.function("SyS_fremovexattr").call !, + kernel.function("sys_fremovexattr").call { name = "fremovexattr" filedes = $fd @@ -1152,8 +1152,8 @@ probe syscall.fremovexattr.return = kernel.function("SyS_fremovexattr").return ! * size_t size, * int flags) */ -probe syscall.fsetxattr = kernel.function("SyS_fsetxattr") !, - kernel.function("sys_fsetxattr") +probe syscall.fsetxattr = kernel.function("SyS_fsetxattr").call !, + kernel.function("sys_fsetxattr").call { name = "fsetxattr" filedes = $fd @@ -1180,14 +1180,14 @@ probe syscall.fsetxattr.return = kernel.function("SyS_fsetxattr").return !, # struct oldabi_stat64 __user * statbuf) # long compat_sys_newfstat(unsigned int fd, struct compat_stat __user * statbuf) # -probe syscall.fstat = kernel.function("sys_fstat") ?, - kernel.function("SyS_fstat64") ?, - kernel.function("sys_fstat64") ?, - kernel.function("sys32_fstat64") ?, - kernel.function("SyS_newfstat") ?, - kernel.function("sys_newfstat") ?, - kernel.function("sys_oabi_fstat64") ?, - kernel.function("compat_sys_newfstat") ? +probe syscall.fstat = kernel.function("sys_fstat").call ?, + kernel.function("SyS_fstat64").call ?, + kernel.function("sys_fstat64").call ?, + kernel.function("sys32_fstat64").call ?, + kernel.function("SyS_newfstat").call ?, + kernel.function("sys_newfstat").call ?, + kernel.function("sys_oabi_fstat64").call ?, + kernel.function("compat_sys_newfstat").call ? { name = "fstat" filedes = $fd @@ -1212,12 +1212,12 @@ probe syscall.fstat.return = kernel.function("sys_fstat").return ?, # long sys_newfstatat(int dfd, char __user *filename, struct stat __user *statbuf, int flag) # long sys_fstatat64(int dfd, char __user *filename, struct stat64 __user *statbuf, int flag) # long compat_sys_newfstatat(unsigned int dfd, char __user *filename, struct compat_stat __user *statbuf, int flag) -probe syscall.fstatat = kernel.function("SyS_fstatat64") ?, - kernel.function("sys_fstatat64") ?, - kernel.function("SyS_newfstatat") ?, - kernel.function("sys_newfstatat") ?, - kernel.function("compat_sys_newfstatat") ?, - kernel.function("sys32_fstatat64") ? +probe syscall.fstatat = kernel.function("SyS_fstatat64").call ?, + kernel.function("sys_fstatat64").call ?, + kernel.function("SyS_newfstatat").call ?, + kernel.function("sys_newfstatat").call ?, + kernel.function("compat_sys_newfstatat").call ?, + kernel.function("sys32_fstatat64").call ? { name = "fstatat" dirfd = $dfd @@ -1240,9 +1240,9 @@ probe syscall.fstatat.return = kernel.function("SyS_fstatat64").return ?, # long sys_fstatfs(unsigned int fd, struct statfs __user * buf) # long compat_sys_fstatfs(unsigned int fd, struct compat_statfs __user *buf) # -probe syscall.fstatfs = kernel.function("compat_sys_fstatfs") ?, - kernel.function("SyS_fstatfs") !, - kernel.function("sys_fstatfs") +probe syscall.fstatfs = kernel.function("compat_sys_fstatfs").call ?, + kernel.function("SyS_fstatfs").call !, + kernel.function("sys_fstatfs").call { name = "fstatfs" fd = $fd @@ -1261,9 +1261,9 @@ probe syscall.fstatfs.return = kernel.function("compat_sys_fstatfs").return ?, # long sys_fstatfs64(unsigned int fd, size_t sz, struct statfs64 __user *buf) # long compat_sys_fstatfs64(unsigned int fd, compat_size_t sz, struct compat_statfs64 __user *buf) # -probe syscall.fstatfs64 = kernel.function("compat_sys_fstatfs64") ?, - kernel.function("SyS_fstatfs64") !, - kernel.function("sys_fstatfs64") ? +probe syscall.fstatfs64 = kernel.function("compat_sys_fstatfs64").call ?, + kernel.function("SyS_fstatfs64").call !, + kernel.function("sys_fstatfs64").call ? { name = "fstatfs" fd = $fd @@ -1281,8 +1281,8 @@ probe syscall.fstatfs64.return = kernel.function("compat_sys_fstatfs64").return # fsync ______________________________________________________ # long sys_fsync(unsigned int fd) -probe syscall.fsync = kernel.function("SyS_fsync") !, - kernel.function("sys_fsync") +probe syscall.fsync = kernel.function("SyS_fsync").call !, + kernel.function("sys_fsync").call { name = "fsync" fd = $fd @@ -1296,8 +1296,8 @@ probe syscall.fsync.return = kernel.function("SyS_fsync").return !, } # ftruncate __________________________________________________ # long sys_ftruncate(unsigned int fd, unsigned long length) -probe syscall.ftruncate = kernel.function("SyS_ftruncate") !, - kernel.function("sys_ftruncate") +probe syscall.ftruncate = kernel.function("SyS_ftruncate").call !, + kernel.function("sys_ftruncate").call { name = "ftruncate" fd = $fd @@ -1313,7 +1313,7 @@ probe syscall.ftruncate.return = kernel.function("SyS_ftruncate").return !, # ftruncate64 ________________________________________________ # long sys_ftruncate64(unsigned int fd, loff_t length) -probe syscall.ftruncate64 = kernel.function("sys_ftruncate64") ? +probe syscall.ftruncate64 = kernel.function("sys_ftruncate64").call ? { name = "ftruncate" fd = $fd @@ -1337,8 +1337,8 @@ probe syscall.ftruncate64.return = kernel.function("sys_ftruncate64").return ? # struct compat_timespec __user *utime, u32 __user *uaddr2, # u32 val3) # -probe syscall.futex = kernel.function("SyS_futex") !, - kernel.function("sys_futex") ? +probe syscall.futex = kernel.function("SyS_futex").call !, + kernel.function("sys_futex").call ? { name = "futex" futex_uaddr = $uaddr @@ -1360,7 +1360,7 @@ probe syscall.futex.return = kernel.function("SyS_futex").return !, name = "futex" retstr = returnstr(1) } -probe syscall.compat_futex = kernel.function("compat_sys_futex") ? +probe syscall.compat_futex = kernel.function("compat_sys_futex").call ? { name = "futex" futex_uaddr = $uaddr @@ -1388,8 +1388,8 @@ probe syscall.compat_futex.return = kernel.function("compat_sys_futex").return ? # long compat_sys_futimesat(unsigned int dfd, char __user *filename, struct compat_timeval __user *t) # -probe syscall.futimesat = kernel.function("SyS_futimesat") !, - kernel.function("sys_futimesat") ? +probe syscall.futimesat = kernel.function("SyS_futimesat").call !, + kernel.function("sys_futimesat").call ? { name = "futimesat" dirfd = $dfd @@ -1399,7 +1399,7 @@ probe syscall.futimesat = kernel.function("SyS_futimesat") !, argstr = sprintf("%s, %s, %s", _dfd_str($dfd), user_string_quoted($filename), _struct_timeval_u($utimes, 2)) } -probe syscall.compat_futimesat = kernel.function("compat_sys_futimesat") ? +probe syscall.compat_futimesat = kernel.function("compat_sys_futimesat").call ? { name = "futimesat" dirfd = $dfd @@ -1423,8 +1423,8 @@ probe syscall.compat_futimesat.return = kernel.function("compat_sys_futimesat"). # getcwd _____________________________________________________ # long sys_getcwd(char __user *buf, unsigned long size) -probe syscall.getcwd = kernel.function("SyS_getcwd") !, - kernel.function("sys_getcwd") +probe syscall.getcwd = kernel.function("SyS_getcwd").call !, + kernel.function("sys_getcwd").call { name = "getcwd" buf_uaddr = $buf @@ -1444,12 +1444,12 @@ probe syscall.getcwd.return = kernel.function("SyS_getcwd").return !, # long sys_getdents64(unsigned int fd, struct linux_dirent64 __user * dirent, unsigned int count) # long compat_sys_getdents64(unsigned int fd, struct linux_dirent64 __user * dirent, unsigned int count) # -probe syscall.getdents = kernel.function("SyS_getdents") ?, - kernel.function("sys_getdents") ?, - kernel.function("SyS_getdents64") ?, - kernel.function("sys_getdents64") ?, - kernel.function("compat_sys_getdents") ?, - kernel.function("compat_sys_getdents64") ? +probe syscall.getdents = kernel.function("SyS_getdents").call ?, + kernel.function("sys_getdents").call ?, + kernel.function("SyS_getdents64").call ?, + kernel.function("sys_getdents64").call ?, + kernel.function("compat_sys_getdents").call ?, + kernel.function("compat_sys_getdents64").call ? { name = "getdents" fd = $fd @@ -1473,9 +1473,9 @@ probe syscall.getdents.return = kernel.function("SyS_getdents").return ?, # long sys_getegid16(void) # long sys32_getegid16(void) # -probe syscall.getegid = kernel.function("sys_getegid16") ?, - kernel.function("sys32_getegid16") ?, - kernel.function("sys_getegid") +probe syscall.getegid = kernel.function("sys_getegid16").call ?, + kernel.function("sys32_getegid16").call ?, + kernel.function("sys_getegid").call { name = "getegid" argstr = "" @@ -1492,9 +1492,9 @@ probe syscall.getegid.return = kernel.function("sys_getegid16").return ?, # long sys_geteuid(void) # long sys32_geteuid16(void) # -probe syscall.geteuid = kernel.function("sys_geteuid16") ?, - kernel.function("sys32_geteuid16") ?, - kernel.function("sys_geteuid") +probe syscall.geteuid = kernel.function("sys_geteuid16").call ?, + kernel.function("sys32_geteuid16").call ?, + kernel.function("sys_geteuid").call { name = "geteuid" argstr = "" @@ -1511,9 +1511,9 @@ probe syscall.geteuid.return = kernel.function("sys_geteuid16").return ?, # long sys_getgid(void) # long sys32_getgid16(void) # -probe syscall.getgid = kernel.function("sys_getgid16") ?, - kernel.function("sys32_getgid16") ?, - kernel.function("sys_getgid") +probe syscall.getgid = kernel.function("sys_getgid16").call ?, + kernel.function("sys32_getgid16").call ?, + kernel.function("sys_getgid").call { name = "getgid" argstr = "" @@ -1531,10 +1531,10 @@ probe syscall.getgid.return = kernel.function("sys_getgid16").return ?, # long sys_getgroups16(int gidsetsize, old_gid_t __user *grouplist) # long sys32_getgroups16(int gidsetsize, u16 __user *grouplist) # -probe syscall.getgroups = kernel.function("sys_getgroups16") ?, - kernel.function("sys32_getgroups16") ?, - kernel.function("SyS_getgroups") !, - kernel.function("sys_getgroups") ? +probe syscall.getgroups = kernel.function("sys_getgroups16").call ?, + kernel.function("sys32_getgroups16").call ?, + kernel.function("SyS_getgroups").call !, + kernel.function("sys_getgroups").call ? { name = "getgroups" size = $gidsetsize @@ -1552,8 +1552,8 @@ probe syscall.getgroups.return = kernel.function("sys_getgroups16").return ?, # gethostname ________________________________________________ # long sys_gethostname(char __user *name, int len) -probe syscall.gethostname = kernel.function("SyS_gethostname") !, - kernel.function("sys_gethostname") ? +probe syscall.gethostname = kernel.function("SyS_gethostname").call !, + kernel.function("sys_gethostname").call ? { name = "gethostname" name_uaddr = $name @@ -1570,8 +1570,8 @@ probe syscall.gethostname.return = kernel.function("SyS_gethostname").return !, # getitimer __________________________________________________ # sys_getitimer(int which, struct itimerval __user *value) # -probe syscall.getitimer = kernel.function("SyS_getitimer") !, - kernel.function("sys_getitimer") +probe syscall.getitimer = kernel.function("SyS_getitimer").call !, + kernel.function("sys_getitimer").call { name = "getitimer" which = $which @@ -1585,7 +1585,7 @@ probe syscall.getitimer.return = kernel.function("SyS_getitimer").return !, retstr = returnstr(1) } # long compat_sys_getitimer(int which, struct compat_itimerval __user *it -probe syscall.compat_getitimer = kernel.function("compat_sys_getitimer") ? +probe syscall.compat_getitimer = kernel.function("compat_sys_getitimer").call ? { name = "getitimer" which = $which @@ -1609,9 +1609,9 @@ probe syscall.compat_getitimer.return = kernel.function("compat_sys_getitimer"). # compat_ulong_t maxnode, # compat_ulong_t addr, compat_ulong_t flags) # -probe syscall.get_mempolicy = kernel.function("compat_sys_get_mempolicy") ?, - kernel.function("SyS_get_mempolicy") !, - kernel.function("sys_get_mempolicy") ? +probe syscall.get_mempolicy = kernel.function("compat_sys_get_mempolicy").call ?, + kernel.function("SyS_get_mempolicy").call !, + kernel.function("sys_get_mempolicy").call ? { name = "get_mempolicy" policy_uaddr = $policy @@ -1633,8 +1633,8 @@ probe syscall.get_mempolicy.return = kernel.function("compat_sys_get_mempolicy") # getpeername ________________________________________________ # long sys_getpeername(int fd, struct sockaddr __user *usockaddr, int __user *usockaddr_len) # -probe syscall.getpeername = kernel.function("SyS_getpeername") !, - kernel.function("sys_getpeername") ? +probe syscall.getpeername = kernel.function("SyS_getpeername").call !, + kernel.function("sys_getpeername").call ? { name = "getpeername" s = $fd @@ -1651,8 +1651,8 @@ probe syscall.getpeername.return = kernel.function("SyS_getpeername").return !, # getpgid ____________________________________________________ # long sys_getpgid(pid_t pid) -probe syscall.getpgid = kernel.function("SyS_getpgid") !, - kernel.function("sys_getpgid") +probe syscall.getpgid = kernel.function("SyS_getpgid").call !, + kernel.function("sys_getpgid").call { name = "getpgid" pid = $pid @@ -1667,7 +1667,7 @@ probe syscall.getpgid.return = kernel.function("SyS_getpgid").return !, # getpgrp ____________________________________________________ # long sys_getpgrp(void) -probe syscall.getpgrp = kernel.function("sys_getpgrp") ? +probe syscall.getpgrp = kernel.function("sys_getpgrp").call ? { name = "getpgrp" argstr = "" @@ -1680,7 +1680,7 @@ probe syscall.getpgrp.return = kernel.function("sys_getpgrp").return ? # getpid _____________________________________________________ # long sys_getpid(void) -probe syscall.getpid = kernel.function("sys_getpid") +probe syscall.getpid = kernel.function("sys_getpid").call { name = "getpid" argstr = "" @@ -1693,7 +1693,7 @@ probe syscall.getpid.return = kernel.function("sys_getpid").return # getppid ____________________________________________________ # long sys_getppid(void) -probe syscall.getppid = kernel.function("sys_getppid") +probe syscall.getppid = kernel.function("sys_getppid").call { name = "getppid" argstr = "" @@ -1706,8 +1706,8 @@ probe syscall.getppid.return = kernel.function("sys_getppid").return # getpriority ________________________________________________ # long sys_getpriority(int which, int who) -probe syscall.getpriority = kernel.function("SyS_getpriority") !, - kernel.function("sys_getpriority") +probe syscall.getpriority = kernel.function("SyS_getpriority").call !, + kernel.function("sys_getpriority").call { name = "getpriority" which = $which @@ -1728,9 +1728,9 @@ probe syscall.getpriority.return = kernel.function("SyS_getpriority").return !, # long sys_getresgid16(old_uid_t __user *rgid, # old_uid_t __user *egid, # old_uid_t __user *sgid) -probe syscall.getresgid = kernel.function("sys_getresgid16") ?, - kernel.function("SyS_getresgid") !, - kernel.function("sys_getresgid") +probe syscall.getresgid = kernel.function("sys_getresgid16").call ?, + kernel.function("SyS_getresgid").call !, + kernel.function("sys_getresgid").call { name = "getresgid" rgid_uaddr = $rgid @@ -1750,9 +1750,9 @@ probe syscall.getresgid.return = kernel.function("sys_getresgid16").return ?, # long sys_getresuid(uid_t __user *ruid, # uid_t __user *euid, # uid_t __user *suid) -probe syscall.getresuid = kernel.function("sys_getresuid16") ?, - kernel.function("SyS_getresuid") !, - kernel.function("sys_getresuid") +probe syscall.getresuid = kernel.function("sys_getresuid16").call ?, + kernel.function("SyS_getresuid").call !, + kernel.function("sys_getresuid").call { name = "getresuid" ruid_uaddr = $ruid @@ -1772,11 +1772,11 @@ probe syscall.getresuid.return = kernel.function("sys_getresuid16").return ?, # long sys_getrlimit(unsigned int resource, struct rlimit __user *rlim) # long sys_old_getrlimit(unsigned int resource, struct rlimit __user *rlim) # long compat_sys_getrlimit (unsigned int resource, struct compat_rlimit __user *rlim) -probe syscall.getrlimit = kernel.function("SyS_getrlimit") ?, - kernel.function("sys_getrlimit") ?, - kernel.function("SyS_old_getrlimit") ?, - kernel.function("sys_old_getrlimit") ?, - kernel.function("compat_sys_getrlimit") ? +probe syscall.getrlimit = kernel.function("SyS_getrlimit").call ?, + kernel.function("sys_getrlimit").call ?, + kernel.function("SyS_old_getrlimit").call ?, + kernel.function("sys_old_getrlimit").call ?, + kernel.function("compat_sys_getrlimit").call ? { name = "getrlimit" resource = $resource @@ -1795,8 +1795,8 @@ probe syscall.getrlimit.return = kernel.function("SyS_getrlimit").return ?, # getrusage __________________________________________________ # long sys_getrusage(int who, struct rusage __user *ru) -probe syscall.getrusage = kernel.function("SyS_getrusage") !, - kernel.function("sys_getrusage") +probe syscall.getrusage = kernel.function("SyS_getrusage").call !, + kernel.function("sys_getrusage").call { name = "getrusage" who = $who @@ -1817,8 +1817,8 @@ probe syscall.getrusage.return = kernel.function("SyS_getrusage").return !, # getsid _____________________________________________________ # long sys_getsid(pid_t pid) -probe syscall.getsid = kernel.function("SyS_getsid") !, - kernel.function("sys_getsid") +probe syscall.getsid = kernel.function("SyS_getsid").call !, + kernel.function("sys_getsid").call { name = "getsid" pid = $pid @@ -1835,8 +1835,8 @@ probe syscall.getsid.return = kernel.function("SyS_getsid").return !, # long sys_getsockname(int fd, # struct sockaddr __user *usockaddr, # int __user *usockaddr_len) -probe syscall.getsockname = kernel.function("SyS_getsockname") !, - kernel.function("sys_getsockname") ? +probe syscall.getsockname = kernel.function("SyS_getsockname").call !, + kernel.function("sys_getsockname").call ? { name = "getsockname" s = $fd @@ -1858,9 +1858,9 @@ probe syscall.getsockname.return = kernel.function("SyS_getsockname").return !, # char __user *optval, # int __user *optlen) # -probe syscall.getsockopt = kernel.function("compat_sys_getsockopt") ?, - kernel.function("SyS_getsockopt") !, - kernel.function("sys_getsockopt") ? +probe syscall.getsockopt = kernel.function("compat_sys_getsockopt").call ?, + kernel.function("SyS_getsockopt").call !, + kernel.function("sys_getsockopt").call ? { name = "getsockopt" fd = $fd @@ -1883,7 +1883,7 @@ probe syscall.getsockopt.return = kernel.function("compat_sys_getsockopt").retur # gettid _____________________________________________________ # long sys_gettid(void) -probe syscall.gettid = kernel.function("sys_gettid") +probe syscall.gettid = kernel.function("sys_gettid").call { name = "gettid" argstr = "" @@ -1901,10 +1901,10 @@ probe syscall.gettid.return = kernel.function("sys_gettid").return # struct timezone __user *tz) # long compat_sys_gettimeofday(struct compat_timeval __user *tv, # struct timezone __user *tz) -probe syscall.gettimeofday = kernel.function("compat_sys_gettimeofday") ?, - kernel.function("sys32_gettimeofday") ?, - kernel.function("SyS_gettimeofday") !, - kernel.function("sys_gettimeofday") +probe syscall.gettimeofday = kernel.function("compat_sys_gettimeofday").call ?, + kernel.function("sys32_gettimeofday").call ?, + kernel.function("SyS_gettimeofday").call !, + kernel.function("sys_gettimeofday").call { name = "gettimeofday" tv_uaddr = $tv @@ -1926,9 +1926,9 @@ probe syscall.gettimeofday.return = kernel.function("compat_sys_gettimeofday").r # long sys_getuid16(void) # long sys32_getuid16(void) # -probe syscall.getuid = kernel.function("sys_getuid16") ?, - kernel.function("sys32_getuid16") ?, - kernel.function("sys_getuid") +probe syscall.getuid = kernel.function("sys_getuid16").call ?, + kernel.function("sys32_getuid16").call ?, + kernel.function("sys_getuid").call { name = "getuid" argstr = "" @@ -1944,8 +1944,8 @@ probe syscall.getuid.return = kernel.function("sys_getuid16").return ?, # getxattr ___________________________________________________ # ssize_t sys_getxattr(char __user *path, char __user *name, # void __user *value, size_t size) -probe syscall.getxattr = kernel.function("SyS_getxattr") !, - kernel.function("sys_getxattr") +probe syscall.getxattr = kernel.function("SyS_getxattr").call !, + kernel.function("sys_getxattr").call { name = "getxattr" %( kernel_v >= "2.6.27" %? @@ -1978,8 +1978,8 @@ probe syscall.getxattr.return = kernel.function("SyS_getxattr").return !, # unsigned long len, # const char __user *uargs) # -probe syscall.init_module = kernel.function("SyS_init_module") !, - kernel.function("sys_init_module") ? +probe syscall.init_module = kernel.function("SyS_init_module").call !, + kernel.function("sys_init_module").call ? { name = "init_module" umod_uaddr = $umod @@ -1998,8 +1998,8 @@ probe syscall.init_module.return = kernel.function("SyS_init_module").return !, # # long sys_inotify_add_watch(int fd, const char __user *path, u32 mask) # -probe syscall.inotify_add_watch = kernel.function("SyS_inotify_add_watch") !, - kernel.function("sys_inotify_add_watch") ? +probe syscall.inotify_add_watch = kernel.function("SyS_inotify_add_watch").call !, + kernel.function("sys_inotify_add_watch").call ? { name = "inotify_add_watch" fd = $fd @@ -2026,7 +2026,7 @@ probe syscall.inotify_add_watch.return = kernel.function("SyS_inotify_add_watch" # # long sys_inotify_init(void) # -probe syscall.inotify_init = kernel.function("sys_inotify_init") ? +probe syscall.inotify_init = kernel.function("sys_inotify_init").call ? { name = "inotify_init" argstr = "" @@ -2041,8 +2041,8 @@ probe syscall.inotify_init.return = kernel.function("sys_inotify_init").return ? # # long sys_inotify_rm_watch(int fd, u32 wd) # -probe syscall.inotify_rm_watch = kernel.function("SyS_inotify_rm_watch") !, - kernel.function("sys_inotify_rm_watch") ? +probe syscall.inotify_rm_watch = kernel.function("SyS_inotify_rm_watch").call !, + kernel.function("sys_inotify_rm_watch").call ? { name = "inotify_rm_watch" fd = $fd @@ -2060,8 +2060,8 @@ probe syscall.inotify_rm_watch.return = kernel.function("SyS_inotify_rm_watch"). # long sys_io_cancel(aio_context_t ctx_id, # struct iocb __user *iocb, # struct io_event __user *result) -probe syscall.io_cancel = kernel.function("SyS_io_cancel") !, - kernel.function("sys_io_cancel") +probe syscall.io_cancel = kernel.function("SyS_io_cancel").call !, + kernel.function("sys_io_cancel").call { name = "io_cancel" ctx_id = $ctx_id @@ -2080,9 +2080,9 @@ probe syscall.io_cancel.return = kernel.function("SyS_io_cancel").return !, # long sys_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg) # long compat_sys_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg) # -probe syscall.ioctl = kernel.function("compat_sys_ioctl") ?, - kernel.function("SyS_ioctl") !, - kernel.function("sys_ioctl") ? +probe syscall.ioctl = kernel.function("compat_sys_ioctl").call ?, + kernel.function("SyS_ioctl").call !, + kernel.function("sys_ioctl").call ? { name = "ioctl" fd = $fd @@ -2100,8 +2100,8 @@ probe syscall.ioctl.return = kernel.function("compat_sys_ioctl").return ?, # io_destroy _________________________________________________ # long sys_io_destroy(aio_context_t ctx) -probe syscall.io_destroy = kernel.function("SyS_io_destroy") !, - kernel.function("sys_io_destroy") +probe syscall.io_destroy = kernel.function("SyS_io_destroy").call !, + kernel.function("sys_io_destroy").call { name = "io_destroy" ctx = $ctx @@ -2126,9 +2126,9 @@ probe syscall.io_destroy.return = kernel.function("SyS_io_destroy").return !, # struct io_event __user *events, # struct compat_timespec __user *timeout) # -probe syscall.io_getevents = kernel.function("compat_sys_io_getevents") ?, - kernel.function("SyS_io_getevents") !, - kernel.function("sys_io_getevents") ? +probe syscall.io_getevents = kernel.function("compat_sys_io_getevents").call ?, + kernel.function("SyS_io_getevents").call !, + kernel.function("sys_io_getevents").call ? { name = "io_getevents" ctx_id = $ctx_id @@ -2151,7 +2151,7 @@ probe syscall.io_getevents.return = kernel.function("compat_sys_io_getevents").r # ioperm _____________________________________________________ # long sys_ioperm(unsigned long from, unsigned long num, int turn_on) # -probe syscall.ioperm = kernel.function("sys_ioperm") ? +probe syscall.ioperm = kernel.function("sys_ioperm").call ? { name = "ioperm" from = $from @@ -2168,8 +2168,8 @@ probe syscall.ioperm.return = kernel.function("sys_ioperm").return ? # io_setup ___________________________________________________ # long sys_io_setup(unsigned nr_events, aio_context_t __user *ctxp) # -probe syscall.io_setup = kernel.function("SyS_io_setup") !, - kernel.function("sys_io_setup") +probe syscall.io_setup = kernel.function("SyS_io_setup").call !, + kernel.function("sys_io_setup").call { name = "io_setup" maxevents = $nr_events @@ -2185,7 +2185,7 @@ probe syscall.io_setup.return = kernel.function("SyS_io_setup").return !, } # long compat_sys_io_setup(unsigned nr_reqs, u32 __user *ctx32p) # -probe syscall.compat_io_setup = kernel.function("compat_sys_io_setup") ? +probe syscall.compat_io_setup = kernel.function("compat_sys_io_setup").call ? { name = "io_setup" maxevents = $nr_reqs @@ -2202,8 +2202,8 @@ probe syscall.compat_io_setup.return = kernel.function("compat_sys_io_setup").re # io_submit __________________________________________________ # long sys_io_submit(aio_context_t ctx_id, long nr, struct iocb __user * __user *iocbpp) # -probe syscall.io_submit = kernel.function("SyS_io_submit") !, - kernel.function("sys_io_submit") +probe syscall.io_submit = kernel.function("SyS_io_submit").call !, + kernel.function("sys_io_submit").call { name = "io_submit" ctx_id = $ctx_id @@ -2219,7 +2219,7 @@ probe syscall.io_submit.return = kernel.function("SyS_io_submit").return !, } # long compat_sys_io_submit(aio_context_t ctx_id, int nr, u32 __user *iocb) # -probe syscall.compat_io_submit = kernel.function("compat_sys_io_submit") ? +probe syscall.compat_io_submit = kernel.function("compat_sys_io_submit").call ? { name = "io_submit" ctx_id = $ctx_id @@ -2236,8 +2236,8 @@ probe syscall.compat_io_submit.return = kernel.function("compat_sys_io_submit"). # ioprio_get _________________________________________________ # long sys_ioprio_get(int which, int who) # -probe syscall.ioprio_get = kernel.function("SyS_ioprio_get") !, - kernel.function("sys_ioprio_get") ? +probe syscall.ioprio_get = kernel.function("SyS_ioprio_get").call !, + kernel.function("sys_ioprio_get").call ? { name = "ioprio_get" which = $which @@ -2254,8 +2254,8 @@ probe syscall.ioprio_get.return = kernel.function("SyS_ioprio_get").return !, # ioprio_set _________________________________________________ # long sys_ioprio_set(int which, int who, int ioprio) # -probe syscall.ioprio_set = kernel.function("SyS_ioprio_set") !, - kernel.function("sys_ioprio_set") ? +probe syscall.ioprio_set = kernel.function("SyS_ioprio_set").call !, + kernel.function("sys_ioprio_set").call ? { name = "ioprio_set" which = $which @@ -2280,9 +2280,9 @@ probe syscall.ioprio_set.return = kernel.function("SyS_ioprio_set").return !, # struct compat_kexec_segment __user *segments, # unsigned long flags) # -probe syscall.kexec_load = kernel.function("compat_sys_kexec_load") ?, - kernel.function("SyS_kexec_load") !, - kernel.function("sys_kexec_load") ? +probe syscall.kexec_load = kernel.function("compat_sys_kexec_load").call ?, + kernel.function("SyS_kexec_load").call !, + kernel.function("sys_kexec_load").call ? { name = "kexec_load" entry = $entry @@ -2307,9 +2307,9 @@ probe syscall.kexec_load.return = kernel.function("compat_sys_kexec_load").retur # unsigned long arg5) # long compat_sys_keyctl(u32 option, u32 arg2, u32 arg3, u32 arg4, u32 arg5) # -probe syscall.keyctl = kernel.function("compat_sys_keyctl") ?, - kernel.function("SyS_keyctl") !, - kernel.function("sys_keyctl") ? +probe syscall.keyctl = kernel.function("compat_sys_keyctl").call ?, + kernel.function("SyS_keyctl").call !, + kernel.function("sys_keyctl").call ? { name = "keyctl" argstr = sprintf("%d, ...", $option) @@ -2325,8 +2325,8 @@ probe syscall.keyctl.return = kernel.function("compat_sys_keyctl").return ?, # kill _______________________________________________________ # long sys_kill(int pid, int sig) -probe syscall.kill = kernel.function("SyS_kill") !, - kernel.function("sys_kill") +probe syscall.kill = kernel.function("SyS_kill").call !, + kernel.function("sys_kill").call { name = "kill" pid = $pid @@ -2343,8 +2343,8 @@ probe syscall.kill.return = kernel.function("SyS_kill").return !, # lchown _____________________________________________________ # long sys_lchown(const char __user * filename, uid_t user, gid_t group) # -probe syscall.lchown = kernel.function("SyS_lchown") !, - kernel.function("sys_lchown") +probe syscall.lchown = kernel.function("SyS_lchown").call !, + kernel.function("sys_lchown").call { name = "lchown" path = user_string($filename) @@ -2363,7 +2363,7 @@ probe syscall.lchown.return = kernel.function("SyS_lchown").return !, # long sys_lchown16(const char __user * filename, old_uid_t user, # old_gid_t group) # -probe syscall.lchown16 = kernel.function("sys_lchown16") ? +probe syscall.lchown16 = kernel.function("sys_lchown16").call ? { name = "lchown16" path = user_string($filename) @@ -2383,8 +2383,8 @@ probe syscall.lchown16.return = kernel.function("sys_lchown16").return ? # void __user *value, # size_t size) # -probe syscall.lgetxattr = kernel.function("SyS_lgetxattr") !, - kernel.function("sys_lgetxattr") +probe syscall.lgetxattr = kernel.function("SyS_lgetxattr").call !, + kernel.function("sys_lgetxattr").call { name = "lgetxattr" %( kernel_v >= "2.6.27" %? @@ -2415,8 +2415,8 @@ probe syscall.lgetxattr.return = kernel.function("SyS_lgetxattr").return !, # link _______________________________________________________ # long sys_link(const char __user * oldname, # const char __user * newname) -probe syscall.link = kernel.function("SyS_link") !, - kernel.function("sys_link") +probe syscall.link = kernel.function("SyS_link").call !, + kernel.function("sys_link").call { name = "link" oldpath = user_string($oldname) @@ -2436,8 +2436,8 @@ probe syscall.link.return = kernel.function("SyS_link").return !, # new function with 2.6.16 # long sys_linkat(int olddfd, const char __user *oldname, # int newdfd, const char __user *newname, int flags) -probe syscall.linkat = kernel.function("SyS_linkat") !, - kernel.function("sys_linkat") ? +probe syscall.linkat = kernel.function("SyS_linkat").call !, + kernel.function("sys_linkat").call ? { name = "linkat" olddirfd = $olddfd @@ -2462,8 +2462,8 @@ probe syscall.linkat.return = kernel.function("SyS_linkat").return !, # listen _____________________________________________________ # long sys_listen(int fd, int backlog) -probe syscall.listen = kernel.function("SyS_listen") !, - kernel.function("sys_listen") ? +probe syscall.listen = kernel.function("SyS_listen").call !, + kernel.function("sys_listen").call ? { name = "listen" sockfd = $fd @@ -2480,8 +2480,8 @@ probe syscall.listen.return = kernel.function("SyS_listen").return !, # listxattr __________________________________________________ # ssize_t sys_listxattr(char __user *path, char __user *list, size_t size) # -probe syscall.listxattr = kernel.function("SyS_listxattr") !, - kernel.function("sys_listxattr") +probe syscall.listxattr = kernel.function("SyS_listxattr").call !, + kernel.function("sys_listxattr").call { name = "listxattr" list_uaddr = $list @@ -2506,8 +2506,8 @@ probe syscall.listxattr.return = kernel.function("SyS_listxattr").return !, # llistxattr _________________________________________________ # ssize_t sys_llistxattr(char __user *path, char __user *list, size_t size) # -probe syscall.llistxattr = kernel.function("SyS_llistxattr") !, - kernel.function("sys_llistxattr") +probe syscall.llistxattr = kernel.function("SyS_llistxattr").call !, + kernel.function("sys_llistxattr").call { name = "llistxattr" list_uaddr = $list @@ -2535,8 +2535,8 @@ probe syscall.llistxattr.return = kernel.function("SyS_llistxattr").return !, # unsigned long offset_low, # loff_t __user * result, # unsigned int origin) -probe syscall.llseek = kernel.function("SyS_llseek") !, - kernel.function("sys_llseek") ? +probe syscall.llseek = kernel.function("SyS_llseek").call !, + kernel.function("sys_llseek").call ? { name = "llseek" fd = $fd @@ -2558,8 +2558,8 @@ probe syscall.llseek.return = kernel.function("SyS_llseek").return !, # lookup_dcookie _____________________________________________ # long sys_lookup_dcookie(u64 cookie64, char __user * buf, size_t len) # -probe syscall.lookup_dcookie = kernel.function("SyS_lookup_dcookie") !, - kernel.function("sys_lookup_dcookie") ? +probe syscall.lookup_dcookie = kernel.function("SyS_lookup_dcookie").call !, + kernel.function("sys_lookup_dcookie").call ? { name = "lookup_dcookie" cookie = $cookie64 @@ -2577,8 +2577,8 @@ probe syscall.lookup_dcookie.return = kernel.function("SyS_lookup_dcookie").retu # lremovexattr _______________________________________________ # long sys_lremovexattr(char __user *path, char __user *name) # -probe syscall.lremovexattr = kernel.function("SyS_lremovexattr") !, - kernel.function("sys_lremovexattr") +probe syscall.lremovexattr = kernel.function("SyS_lremovexattr").call !, + kernel.function("sys_lremovexattr").call { name = "lremovexattr" name_uaddr = $name @@ -2602,8 +2602,8 @@ probe syscall.lremovexattr.return = kernel.function("SyS_lremovexattr").return ! # lseek ______________________________________________________ # off_t sys_lseek(unsigned int fd, off_t offset, unsigned int origin) -probe syscall.lseek = kernel.function("SyS_lseek") !, - kernel.function("sys_lseek") +probe syscall.lseek = kernel.function("SyS_lseek").call !, + kernel.function("sys_lseek").call { name = "lseek" fildes = $fd @@ -2627,8 +2627,8 @@ probe syscall.lseek.return = kernel.function("SyS_lseek").return !, # size_t size, # int flags) # -probe syscall.lsetxattr = kernel.function("SyS_lsetxattr") !, - kernel.function("sys_lsetxattr") +probe syscall.lsetxattr = kernel.function("SyS_lsetxattr").call !, + kernel.function("sys_lsetxattr").call { name = "lsetxattr" %( kernel_v >= "2.6.27" %? @@ -2668,14 +2668,14 @@ probe syscall.lsetxattr.return = kernel.function("SyS_lsetxattr").return !, # long sys_oabi_lstat64(char __user * filename, # struct oldabi_stat64 __user * statbuf) # -probe syscall.lstat = kernel.function("sys_lstat") ?, - kernel.function("SyS_newlstat") ?, - kernel.function("sys_newlstat") ?, - kernel.function("compat_sys_newlstat") ?, - kernel.function("sys32_lstat64") ?, - kernel.function("SyS_lstat64") ?, - kernel.function("sys_lstat64") ?, - kernel.function("sys_oabi_lstat64") ? +probe syscall.lstat = kernel.function("sys_lstat").call ?, + kernel.function("SyS_newlstat").call ?, + kernel.function("sys_newlstat").call ?, + kernel.function("compat_sys_newlstat").call ?, + kernel.function("sys32_lstat64").call ?, + kernel.function("SyS_lstat64").call ?, + kernel.function("sys_lstat64").call ?, + kernel.function("sys_oabi_lstat64").call ? { name = "lstat" path = user_string($filename) @@ -2698,8 +2698,8 @@ probe syscall.lstat.return = kernel.function("sys_lstat").return ?, # madvise ____________________________________________________ # long sys_madvise(unsigned long start, size_t len_in, int behavior) # -probe syscall.madvise = kernel.function("SyS_madvise") !, - kernel.function("sys_madvise") ? +probe syscall.madvise = kernel.function("SyS_madvise").call !, + kernel.function("sys_madvise").call ? { name = "madvise" start = $start @@ -2730,9 +2730,9 @@ probe syscall.madvise.return = kernel.function("SyS_madvise").return !, # compat_ulong_t maxnode, # compat_ulong_t flags) # -probe syscall.mbind = kernel.function("compat_sys_mbind") ?, - kernel.function("SyS_mbind") !, - kernel.function("sys_mbind") ? +probe syscall.mbind = kernel.function("compat_sys_mbind").call ?, + kernel.function("SyS_mbind").call !, + kernel.function("sys_mbind").call ? { name = "mbind" start = $start @@ -2756,8 +2756,8 @@ probe syscall.mbind.return = kernel.function("compat_sys_mbind").return ?, # long sys_migrate_pages(pid_t pid, unsigned long maxnode, # const unsigned long __user *old_nodes, # const unsigned long __user *new_nodes) -probe syscall.migrate_pages = kernel.function("SyS_migrate_pages") !, - kernel.function("sys_migrate_pages") ? +probe syscall.migrate_pages = kernel.function("SyS_migrate_pages").call !, + kernel.function("sys_migrate_pages").call ? { name = "migrate_pages" argstr = sprintf("%d, %d, %p, %p", $pid, $maxnode, $old_nodes, $new_nodes) @@ -2772,8 +2772,8 @@ probe syscall.migrate_pages.return = kernel.function("SyS_migrate_pages").return # mincore ____________________________________________________ # long sys_mincore(unsigned long start, size_t len, unsigned char __user * vec) # -probe syscall.mincore = kernel.function("SyS_mincore") !, - kernel.function("sys_mincore") ? +probe syscall.mincore = kernel.function("SyS_mincore").call !, + kernel.function("sys_mincore").call ? { name = "mincore" start = $start @@ -2790,8 +2790,8 @@ probe syscall.mincore.return = kernel.function("SyS_mincore").return !, # mkdir ______________________________________________________ # long sys_mkdir(const char __user * pathname, int mode) -probe syscall.mkdir = kernel.function("SyS_mkdir") !, - kernel.function("sys_mkdir") +probe syscall.mkdir = kernel.function("SyS_mkdir").call !, + kernel.function("sys_mkdir").call { name = "mkdir" pathname_uaddr = $pathname @@ -2809,8 +2809,8 @@ probe syscall.mkdir.return = kernel.function("SyS_mkdir").return !, # mkdirat ____________________________________________________ # new function with 2.6.16 # long sys_mkdirat(int dfd, const char __user *pathname, int mode) -probe syscall.mkdirat = kernel.function("SyS_mkdirat") !, - kernel.function("sys_mkdirat") ? +probe syscall.mkdirat = kernel.function("SyS_mkdirat").call !, + kernel.function("sys_mkdirat").call ? { name = "mkdirat" dirfd = $dfd @@ -2827,8 +2827,8 @@ probe syscall.mkdirat.return = kernel.function("SyS_mkdirat").return !, # mknod # long sys_mknod(const char __user * filename, int mode, unsigned dev) -probe syscall.mknod = kernel.function("SyS_mknod") !, - kernel.function("sys_mknod") +probe syscall.mknod = kernel.function("SyS_mknod").call !, + kernel.function("sys_mknod").call { name = "mknod" pathname = user_string($filename) @@ -2848,8 +2848,8 @@ probe syscall.mknod.return = kernel.function("SyS_mknod").return !, # new function with 2.6.16 # long sys_mknodat(int dfd, const char __user *filename, # int mode, unsigned dev) -probe syscall.mknodat = kernel.function("SyS_mknodat") !, - kernel.function("sys_mknodat") ? +probe syscall.mknodat = kernel.function("SyS_mknodat").call !, + kernel.function("sys_mknodat").call ? { name = "mknodat" dirfd = $dfd @@ -2872,8 +2872,8 @@ probe syscall.mknodat.return = kernel.function("SyS_mknodat").return !, # # long sys_mlock(unsigned long start, size_t len) # -probe syscall.mlock = kernel.function("SyS_mlock") !, - kernel.function("sys_mlock") ? +probe syscall.mlock = kernel.function("SyS_mlock").call !, + kernel.function("sys_mlock").call ? { name = "mlock" addr = $start @@ -2890,8 +2890,8 @@ probe syscall.mlock.return = kernel.function("SyS_mlock").return !, # # long sys_mlockall(int flags) # -probe syscall.mlockall = kernel.function("SyS_mlockall") !, - kernel.function("sys_mlockall") ? +probe syscall.mlockall = kernel.function("SyS_mlockall").call !, + kernel.function("sys_mlockall").call ? { name = "mlockall" flags = $flags @@ -2907,7 +2907,7 @@ probe syscall.mlockall.return = kernel.function("SyS_mlockall").return !, # modify_ldt _________________________________________________ # int sys_modify_ldt(int func, void __user *ptr, unsigned long bytecount) # -probe syscall.modify_ldt = kernel.function("sys_modify_ldt") ? +probe syscall.modify_ldt = kernel.function("sys_modify_ldt").call ? { name = "modify_ldt" func = $func @@ -2934,9 +2934,9 @@ probe syscall.modify_ldt.return = kernel.function("sys_modify_ldt").return ? # int __user *status, # int flags) # -probe syscall.move_pages = kernel.function("compat_sys_move_pages") ?, - kernel.function("SyS_move_pages") !, - kernel.function("sys_move_pages") ? +probe syscall.move_pages = kernel.function("compat_sys_move_pages").call ?, + kernel.function("SyS_move_pages").call !, + kernel.function("sys_move_pages").call ? { name = "move_pages" argstr = sprintf("%d, %d, %p, %p, 0x%x", $pid, $nr_pages, $nodes, $status, $flags) @@ -2960,9 +2960,9 @@ probe syscall.move_pages.return = kernel.function("compat_sys_move_pages").retur # char __user * type, # unsigned long flags, # void __user * data) -probe syscall.mount = kernel.function("compat_sys_mount") ?, - kernel.function("SyS_mount") !, - kernel.function("sys_mount") +probe syscall.mount = kernel.function("compat_sys_mount").call ?, + kernel.function("SyS_mount").call !, + kernel.function("sys_mount").call { name = "mount" source = user_string($dev_name) @@ -2988,8 +2988,8 @@ probe syscall.mount.return = kernel.function("compat_sys_mount").return ?, # mprotect ___________________________________________________ # long sys_mprotect(unsigned long start, size_t len, unsigned long prot) # -probe syscall.mprotect = kernel.function("SyS_mprotect") !, - kernel.function("sys_mprotect") ? +probe syscall.mprotect = kernel.function("SyS_mprotect").call !, + kernel.function("sys_mprotect").call ? { name = "mprotect" addr = $start @@ -3013,9 +3013,9 @@ probe syscall.mprotect.return = kernel.function("SyS_mprotect").return !, # const struct compat_mq_attr __user *u_mqstat, # struct compat_mq_attr __user *u_omqstat) # -probe syscall.mq_getsetattr = kernel.function("compat_sys_mq_getsetattr") ?, - kernel.function("SyS_mq_getsetattr") !, - kernel.function("sys_mq_getsetattr") ? +probe syscall.mq_getsetattr = kernel.function("compat_sys_mq_getsetattr").call ?, + kernel.function("SyS_mq_getsetattr").call !, + kernel.function("sys_mq_getsetattr").call ? { name = "mq_getsetattr" mqdes = $mqdes @@ -3035,9 +3035,9 @@ probe syscall.mq_getsetattr.return = kernel.function("compat_sys_mq_getsetattr") # long sys_mq_notify(mqd_t mqdes, const struct sigevent __user *u_notification) # long compat_sys_mq_notify(mqd_t mqdes, const struct compat_sigevent __user *u_notification) # -probe syscall.mq_notify = kernel.function("compat_sys_mq_notify") ?, - kernel.function("SyS_mq_notify") !, - kernel.function("sys_mq_notify") ? +probe syscall.mq_notify = kernel.function("compat_sys_mq_notify").call ?, + kernel.function("SyS_mq_notify").call !, + kernel.function("sys_mq_notify").call ? { name = "mq_notify" mqdes = $mqdes @@ -3061,9 +3061,9 @@ probe syscall.mq_notify.return = kernel.function("compat_sys_mq_notify").return # int oflag, compat_mode_t mode, # struct compat_mq_attr __user *u_attr) # -probe syscall.mq_open = kernel.function("compat_sys_mq_open") ?, - kernel.function("SyS_mq_open") !, - kernel.function("sys_mq_open") ? +probe syscall.mq_open = kernel.function("compat_sys_mq_open").call ?, + kernel.function("SyS_mq_open").call !, + kernel.function("sys_mq_open").call ? { name = "mq_open" name_uaddr = $u_name @@ -3096,9 +3096,9 @@ probe syscall.mq_open.return = kernel.function("compat_sys_mq_open").return ?, # size_t msg_len, unsigned int __user *u_msg_prio, # const struct compat_timespec __user *u_abs_timeout) # -probe syscall.mq_timedreceive = kernel.function("compat_sys_mq_timedreceive") ?, - kernel.function("SyS_mq_timedreceive") !, - kernel.function("sys_mq_timedreceive") ? +probe syscall.mq_timedreceive = kernel.function("compat_sys_mq_timedreceive").call ?, + kernel.function("SyS_mq_timedreceive").call !, + kernel.function("sys_mq_timedreceive").call ? { name = "mq_timedreceive" mqdes = $mqdes @@ -3128,9 +3128,9 @@ probe syscall.mq_timedreceive.return = kernel.function("compat_sys_mq_timedrecei # size_t msg_len, unsigned int msg_prio, # const struct compat_timespec __user *u_abs_timeout) # -probe syscall.mq_timedsend = kernel.function("compat_sys_mq_timedsend") ?, - kernel.function("SyS_mq_timedsend") !, - kernel.function("sys_mq_timedsend") ? +probe syscall.mq_timedsend = kernel.function("compat_sys_mq_timedsend").call ?, + kernel.function("SyS_mq_timedsend").call !, + kernel.function("sys_mq_timedsend").call ? { name = "mq_timedsend" mqdes = $mqdes @@ -3152,8 +3152,8 @@ probe syscall.mq_timedsend.return = kernel.function("compat_sys_mq_timedsend").r # mq_unlink __________________________________________________ # long sys_mq_unlink(const char __user *u_name) # -probe syscall.mq_unlink = kernel.function("SyS_mq_unlink") !, - kernel.function("sys_mq_unlink") ? +probe syscall.mq_unlink = kernel.function("SyS_mq_unlink").call !, + kernel.function("sys_mq_unlink").call ? { name = "mq_unlink" u_name_uaddr = $u_name @@ -3174,9 +3174,9 @@ probe syscall.mq_unlink.return = kernel.function("SyS_mq_unlink").return !, # unsigned long flags, # unsigned long new_addr) # -probe syscall.mremap = kernel.function("ia64_mremap") ?, - kernel.function("SyS_mremap") !, - kernel.function("sys_mremap") ? +probe syscall.mremap = kernel.function("ia64_mremap").call ?, + kernel.function("SyS_mremap").call !, + kernel.function("sys_mremap").call ? { name = "mremap" old_address = $addr @@ -3198,8 +3198,8 @@ probe syscall.mremap.return = kernel.function("ia64_mremap").return ?, # msgctl _____________________________________________________ # long sys_msgctl (int msqid, int cmd, struct msqid_ds __user *buf) # -probe syscall.msgctl = kernel.function("SyS_msgctl") !, - kernel.function("sys_msgctl") ? +probe syscall.msgctl = kernel.function("SyS_msgctl").call !, + kernel.function("sys_msgctl").call ? { name = "msgctl" msqid = $msqid @@ -3217,7 +3217,7 @@ probe syscall.msgctl.return = kernel.function("SyS_msgctl").return !, # # long compat_sys_msgctl(int first, int second, void __user *uptr) # -probe syscall.compat_sys_msgctl = kernel.function("compat_sys_msgctl") ? +probe syscall.compat_sys_msgctl = kernel.function("compat_sys_msgctl").call ? { name = "compat_sys_msgctl" argstr = sprintf("%d, %d, %p", $first, $second, $uptr) @@ -3231,8 +3231,8 @@ probe syscall.compat_sys_msgctl.return = kernel.function("compat_sys_msgctl").re # msgget _____________________________________________________ # long sys_msgget (key_t key, int msgflg) # -probe syscall.msgget = kernel.function("SyS_msgget") !, - kernel.function("sys_msgget") ? +probe syscall.msgget = kernel.function("SyS_msgget").call !, + kernel.function("sys_msgget").call ? { name = "msgget" key = $key @@ -3254,8 +3254,8 @@ probe syscall.msgget.return = kernel.function("SyS_msgget").return !, # long msgtyp, # int msgflg) # -probe syscall.msgrcv = kernel.function("SyS_msgrcv") !, - kernel.function("sys_msgrcv") ? +probe syscall.msgrcv = kernel.function("SyS_msgrcv").call !, + kernel.function("sys_msgrcv").call ? { name = "msgrcv" msqid = $msqid @@ -3276,7 +3276,7 @@ probe syscall.msgrcv.return = kernel.function("SyS_msgrcv").return !, # long compat_sys_msgrcv(int first, int second, int msgtyp, int third, # int version, void __user *uptr) # -probe syscall.compat_sys_msgrcv = kernel.function("compat_sys_msgrcv") ? +probe syscall.compat_sys_msgrcv = kernel.function("compat_sys_msgrcv").call ? { name = "compat_sys_msgrcv" argstr = sprintf("%d, %d, %d, %p", $first, $second, $third, $uptr) @@ -3293,8 +3293,8 @@ probe syscall.compat_sys_msgrcv.return = kernel.function("compat_sys_msgrcv").re # size_t msgsz, # int msgflg) # -probe syscall.msgsnd = kernel.function("SyS_msgsnd") !, - kernel.function("sys_msgsnd") ? +probe syscall.msgsnd = kernel.function("SyS_msgsnd").call !, + kernel.function("sys_msgsnd").call ? { name = "msgsnd" msqid = $msqid @@ -3313,7 +3313,7 @@ probe syscall.msgsnd.return = kernel.function("SyS_msgsnd").return !, # # long compat_sys_msgsnd(int first, int second, int third, void __user *uptr) # -probe syscall.compat_sys_msgsnd = kernel.function("compat_sys_msgsnd") ? +probe syscall.compat_sys_msgsnd = kernel.function("compat_sys_msgsnd").call ? { name = "compat_sys_msgsnd" argstr = sprintf("%d, %d, %d, %p", $first, $second, $third, $uptr) @@ -3326,8 +3326,8 @@ probe syscall.compat_sys_msgsnd.return = kernel.function("compat_sys_msgsnd").re # msync ______________________________________________________ # long sys_msync(unsigned long start, size_t len, int flags) -probe syscall.msync = kernel.function("SyS_msync") !, - kernel.function("sys_msync") ? +probe syscall.msync = kernel.function("SyS_msync").call !, + kernel.function("sys_msync").call ? { name = "msync" start = $start @@ -3344,8 +3344,8 @@ probe syscall.msync.return = kernel.function("SyS_msync").return !, # munlock ____________________________________________________ # long sys_munlock(unsigned long start, size_t len) -probe syscall.munlock = kernel.function("SyS_munlock") !, - kernel.function("sys_munlock") ? +probe syscall.munlock = kernel.function("SyS_munlock").call !, + kernel.function("sys_munlock").call ? { name = "munlock" addr = $start @@ -3361,7 +3361,7 @@ probe syscall.munlock.return = kernel.function("SyS_munlock").return !, # munlockall _________________________________________________ # long sys_munlockall(void) -probe syscall.munlockall = kernel.function("sys_munlockall") ? +probe syscall.munlockall = kernel.function("sys_munlockall").call ? { name = "munlockall" argstr = "" @@ -3374,8 +3374,8 @@ probe syscall.munlockall.return = kernel.function("sys_munlockall").return ? # munmap _____________________________________________________ # long sys_munmap(unsigned long addr, size_t len) -probe syscall.munmap = kernel.function("SyS_munmap") !, - kernel.function("sys_munmap") +probe syscall.munmap = kernel.function("SyS_munmap").call !, + kernel.function("sys_munmap").call { name = "munmap" start = $addr diff --git a/tapset/syscalls2.stp b/tapset/syscalls2.stp index e2be10fc..5e97aef5 100644 --- a/tapset/syscalls2.stp +++ b/tapset/syscalls2.stp @@ -28,8 +28,8 @@ # long compat_sys_nanosleep(struct compat_timespec __user *rqtp, # struct compat_timespec __user *rmtp) # -probe syscall.nanosleep = kernel.function("SyS_nanosleep") !, - kernel.function("sys_nanosleep") +probe syscall.nanosleep = kernel.function("SyS_nanosleep").call !, + kernel.function("sys_nanosleep").call { name = "nanosleep" req_uaddr = $rqtp @@ -42,7 +42,7 @@ probe syscall.nanosleep.return = kernel.function("SyS_nanosleep").return !, name = "nanosleep" retstr = returnstr(1) } -probe syscall.compat_nanosleep = kernel.function("compat_sys_nanosleep") ? +probe syscall.compat_nanosleep = kernel.function("compat_sys_nanosleep").call ? { name = "nanosleep" req_uaddr = $rqtp @@ -61,8 +61,8 @@ probe syscall.compat_nanosleep.return = kernel.function("compat_sys_nanosleep"). # long compat_sys_nfsservctl(int cmd, struct compat_nfsctl_arg __user *arg, # union compat_nfsctl_res __user *res) # -probe syscall.nfsservctl = kernel.function("sys_nfsservctl") ?, - kernel.function("compat_sys_nfsservctl") ? +probe syscall.nfsservctl = kernel.function("sys_nfsservctl").call ?, + kernel.function("compat_sys_nfsservctl").call ? { name = "nfsservctl" cmd = $cmd @@ -80,8 +80,8 @@ probe syscall.nfsservctl.return = kernel.function("sys_nfsservctl").return ?, # nice _______________________________________________________ # long sys_nice(int increment) # -probe syscall.nice = kernel.function("SyS_nice") !, - kernel.function("sys_nice") ? +probe syscall.nice = kernel.function("SyS_nice").call !, + kernel.function("sys_nice").call ? { name = "nice" inc = $increment @@ -98,7 +98,7 @@ probe syscall.nice.return = kernel.function("SyS_nice").return !, # # long sys_ni_syscall(void) # -probe syscall.ni_syscall = kernel.function("sys_ni_syscall") +probe syscall.ni_syscall = kernel.function("sys_ni_syscall").call { name = "ni_syscall" argstr = "" @@ -113,10 +113,10 @@ probe syscall.ni_syscall.return = kernel.function("sys_ni_syscall").return # long sys_open(const char __user * filename, int flags, int mode) # (obsolete) long sys32_open(const char * filename, int flags, int mode) # -probe syscall.open = kernel.function("compat_sys_open") ?, - kernel.function("sys32_open") ?, - kernel.function("SyS_open") !, - kernel.function("sys_open") ? +probe syscall.open = kernel.function("compat_sys_open").call ?, + kernel.function("sys32_open").call ?, + kernel.function("SyS_open").call !, + kernel.function("sys_open").call ? { name = "open" filename = user_string($filename) @@ -142,9 +142,9 @@ probe syscall.open.return = kernel.function("compat_sys_open").return ?, # long sys_openat(int dfd, const char __user *filename, int flags, int mode) # long compat_sys_openat(unsigned int dfd, const char __user *filename, int flags, int mode) # -probe syscall.openat = kernel.function("compat_sys_openat") ?, - kernel.function("SyS_openat") !, - kernel.function("sys_openat") ? +probe syscall.openat = kernel.function("compat_sys_openat").call ?, + kernel.function("SyS_openat").call !, + kernel.function("sys_openat").call ? { name = "openat" filename = user_string($filename) @@ -171,9 +171,9 @@ probe syscall.openat.return = kernel.function("compat_sys_openat").return ?, # # sys_pause(void) # -probe syscall.pause = kernel.function("sys_pause") ?, - kernel.function("sys32_pause") ?, - kernel.function("compat_sys_pause") ? +probe syscall.pause = kernel.function("sys_pause").call ?, + kernel.function("sys32_pause").call ?, + kernel.function("compat_sys_pause").call ? { name = "pause" argstr = "" @@ -194,7 +194,7 @@ probe syscall.pause.return = kernel.function("sys_pause").return ?, # unsigned long dfn) # # -#probe syscall.pciconfig_iobase = kernel.function("sys_pciconfig_iobase") +#probe syscall.pciconfig_iobase = kernel.function("sys_pciconfig_iobase").call #{ # name = "pciconfig_iobase" # which = $which @@ -218,7 +218,7 @@ probe syscall.pause.return = kernel.function("sys_pause").return ?, # { return 0; } # # -#probe syscall.pciconfig_read = kernel.function("sys_pciconfig_read") +#probe syscall.pciconfig_read = kernel.function("sys_pciconfig_read").call #{ # name = "pciconfig_read" # bus = $bus @@ -244,7 +244,7 @@ probe syscall.pause.return = kernel.function("sys_pause").return ?, # unsigned char *buf) # # -#probe syscall.pciconfig_write = kernel.function("sys_pciconfig_write") +#probe syscall.pciconfig_write = kernel.function("sys_pciconfig_write").call #{ # name = "pciconfig_write" # bus = $bus @@ -265,8 +265,8 @@ probe syscall.pause.return = kernel.function("sys_pause").return ?, # asmlinkage long # sys_personality(u_long personality) # -probe syscall.personality = kernel.function("SyS_personality") !, - kernel.function("sys_personality") +probe syscall.personality = kernel.function("SyS_personality").call !, + kernel.function("sys_personality").call { name = "personality" persona = $personality @@ -285,15 +285,15 @@ probe syscall.personality.return = kernel.function("SyS_personality").return !, # %(arch == "x86_64" %? # x86_64 gcc 4.1 problem -probe syscall.pipe = kernel.function("SyS_pipe") !, - kernel.function("sys_pipe") +probe syscall.pipe = kernel.function("SyS_pipe").call !, + kernel.function("sys_pipe").call { name = "pipe" argstr = "" } %: -probe syscall.pipe = kernel.function("SyS_pipe") !, - kernel.function("sys_pipe") +probe syscall.pipe = kernel.function("SyS_pipe").call !, + kernel.function("sys_pipe").call { name = "pipe" %( arch == "ia64" %? @@ -316,8 +316,8 @@ probe syscall.pipe.return = kernel.function("SyS_pipe").return !, # # long sys_pivot_root(const char __user *new_root, const char __user *put_old) # -probe syscall.pivot_root = kernel.function("SyS_pivot_root") !, - kernel.function("sys_pivot_root") +probe syscall.pivot_root = kernel.function("SyS_pivot_root").call !, + kernel.function("sys_pivot_root").call { name = "pivot_root" new_root_str = user_string($new_root) @@ -336,8 +336,8 @@ probe syscall.pivot_root.return = kernel.function("SyS_pivot_root").return !, # # long sys_poll(struct pollfd __user * ufds, unsigned int nfds, long timeout) # -probe syscall.poll = kernel.function("SyS_poll") !, - kernel.function("sys_poll") +probe syscall.poll = kernel.function("SyS_poll").call !, + kernel.function("sys_poll").call { name = "poll" ufds_uaddr = $ufds @@ -362,8 +362,8 @@ probe syscall.poll.return = kernel.function("SyS_poll").return !, # struct timespec __user *tsp, const sigset_t __user *sigmask, # size_t sigsetsize) # -probe syscall.ppoll = kernel.function("SyS_ppoll") !, - kernel.function("sys_ppoll") ? +probe syscall.ppoll = kernel.function("SyS_ppoll").call !, + kernel.function("sys_ppoll").call ? { name = "ppoll" argstr = sprintf("%p, %d, %s, %p, %d", @@ -383,7 +383,7 @@ probe syscall.ppoll.return = kernel.function("SyS_ppoll").return !, # unsigned int nfds, struct compat_timespec __user *tsp, # const compat_sigset_t __user *sigmask, compat_size_t sigsetsize) # -probe syscall.compat_ppoll = kernel.function("compat_sys_ppoll") ? +probe syscall.compat_ppoll = kernel.function("compat_sys_ppoll").call ? { name = "ppoll" argstr = sprintf("%p, %d, %s, %p, %d", @@ -408,8 +408,8 @@ probe syscall.compat_ppoll.return = kernel.function("compat_sys_ppoll").return ? # unsigned long arg4, # unsigned long arg5) # -probe syscall.prctl = kernel.function("SyS_prctl") !, - kernel.function("sys_prctl") +probe syscall.prctl = kernel.function("SyS_prctl").call !, + kernel.function("sys_prctl").call { name = "prctl" option = $option @@ -433,8 +433,8 @@ probe syscall.prctl.return = kernel.function("SyS_prctl").return !, # size_t count, # loff_t pos) # -probe syscall.pread = kernel.function("SyS_pread64") !, - kernel.function("sys_pread64") +probe syscall.pread = kernel.function("SyS_pread64").call !, + kernel.function("sys_pread64").call { name = "pread" fd = $fd @@ -455,8 +455,8 @@ probe syscall.pread.return = kernel.function("SyS_pread64").return !, # long sys_pselect6(int n, fd_set __user *inp, fd_set __user *outp, # fd_set __user *exp, struct timespec __user *tsp, void __user *sig) # -probe syscall.pselect6 = kernel.function("SyS_pselect6") !, - kernel.function("sys_pselect6") ? +probe syscall.pselect6 = kernel.function("SyS_pselect6").call !, + kernel.function("sys_pselect6").call ? { name = "pselect6" argstr = sprintf("%d, %p, %p, %p, %s, %p", $n, $inp, $outp, $exp, @@ -468,7 +468,7 @@ probe syscall.pselect6.return = kernel.function("SyS_pselect6").return !, name = "pselect6" retstr = returnstr(1) } -probe syscall.compat_pselect6 = kernel.function("compat_sys_pselect6") ? +probe syscall.compat_pselect6 = kernel.function("compat_sys_pselect6").call ? { name = "pselect6" argstr = sprintf("%d, %p, %p, %p, %s, %p", $n, $inp, $outp, $exp, @@ -486,7 +486,7 @@ probe syscall.compat_pselect6.return = kernel.function("compat_sys_pselect6").re # fd_set __user *exp, struct timespec __user *tsp, # const sigset_t __user *sigmask, size_t sigsetsize) # -probe syscall.pselect7 = kernel.function("sys_pselect7") ? +probe syscall.pselect7 = kernel.function("sys_pselect7").call ? { name = "pselect7" argstr = sprintf("%d, %p, %p, %p, %s, %p, %d", $n, $inp, $outp, $exp, @@ -497,7 +497,7 @@ probe syscall.pselect7.return = kernel.function("sys_pselect7").return ? name = "pselect7" retstr = returnstr(1) } -probe syscall.compat_pselect7a = kernel.function("compat_sys_pselect7") ? +probe syscall.compat_pselect7a = kernel.function("compat_sys_pselect7").call ? { name = "pselect7" argstr = sprintf("%d, %p, %p, %p, %s, %p, %d", $n, $inp, $outp, $exp, @@ -516,8 +516,8 @@ probe syscall.compat_pselect7.return = kernel.function("compat_sys_pselect7").re # long addr, # long data) # -probe syscall.ptrace = kernel.function("SyS_ptrace") !, - kernel.function("sys_ptrace") ? +probe syscall.ptrace = kernel.function("SyS_ptrace").call !, + kernel.function("sys_ptrace").call ? { name = "ptrace" request = $request @@ -540,8 +540,8 @@ probe syscall.ptrace.return = kernel.function("SyS_ptrace").return !, # size_t count, # loff_t pos) # -probe syscall.pwrite = kernel.function("SyS_pwrite64") !, - kernel.function("sys_pwrite64") +probe syscall.pwrite = kernel.function("SyS_pwrite64").call !, + kernel.function("sys_pwrite64").call { name = "pwrite" fd = $fd @@ -560,7 +560,7 @@ probe syscall.pwrite.return = kernel.function("SyS_pwrite64").return !, } # long sys32_pwrite64(unsigned int fd, const char __user *ubuf, # size_t count, u32 poshi, u32 poslo) -probe syscall.pwrite32 = kernel.function("sys32_pwrite64") ? +probe syscall.pwrite32 = kernel.function("sys32_pwrite64").call ? { name = "pwrite" fd = $fd @@ -592,8 +592,8 @@ probe syscall.pwrite32.return = kernel.function("sys32_pwrite64").return ? # qid_t id, # void __user *addr) # -probe syscall.quotactl = kernel.function("SyS_quotactl") !, - kernel.function("sys_quotactl") ? +probe syscall.quotactl = kernel.function("SyS_quotactl").call !, + kernel.function("sys_quotactl").call ? { name = "quotactl" cmd = $cmd @@ -614,8 +614,8 @@ probe syscall.quotactl.return = kernel.function("SyS_quotactl").return !, # read _______________________________________________________ # ssize_t sys_read(unsigned int fd, char __user * buf, size_t count) -probe syscall.read = kernel.function("SyS_read") !, - kernel.function("sys_read") +probe syscall.read = kernel.function("SyS_read").call !, + kernel.function("sys_read").call { name = "read" fd = $fd @@ -637,8 +637,8 @@ probe syscall.read.return = kernel.function("SyS_read").return !, # loff_t offset, # size_t count) # -probe syscall.readahead = kernel.function("SyS_readahead") !, - kernel.function("sys_readahead") +probe syscall.readahead = kernel.function("SyS_readahead").call !, + kernel.function("sys_readahead").call { name = "readahead" fd = $fd @@ -658,8 +658,8 @@ probe syscall.readahead.return = kernel.function("SyS_readahead").return !, # long compat_sys_old_readdir(unsigned int fd, struct compat_old_linux_dirent __user *dirent, unsigned int count) # int old32_readdir(unsigned int fd, struct old_linux_dirent32 *dirent, unsigned int count) # -probe syscall.readdir = kernel.function("compat_sys_old_readdir") ?, - kernel.function("old32_readdir") ? +probe syscall.readdir = kernel.function("compat_sys_old_readdir").call ?, + kernel.function("old32_readdir").call ? { name = "readdir" argstr = sprintf("%d, %p, %d", $fd, $dirent, $count) @@ -677,8 +677,8 @@ probe syscall.readdir.return = kernel.function("compat_sys_old_readdir").return # char __user * buf, # int bufsiz) # -probe syscall.readlink = kernel.function("SyS_readlink") !, - kernel.function("sys_readlink") +probe syscall.readlink = kernel.function("SyS_readlink").call !, + kernel.function("sys_readlink").call { name = "readlink" path = user_string($path) @@ -700,8 +700,8 @@ probe syscall.readlink.return = kernel.function("SyS_readlink").return !, # char __user * buf, # int bufsiz) # -probe syscall.readlinkat = kernel.function("SyS_readlinkat") !, - kernel.function("sys_readlinkat") ? +probe syscall.readlinkat = kernel.function("SyS_readlinkat").call !, + kernel.function("sys_readlinkat").call ? { name = "readlinkat" dfd = $dfd @@ -732,9 +732,9 @@ probe syscall.readlinkat.return = kernel.function("SyS_readlinkat").return !, # const struct compat_iovec __user *vec, # unsigned long vlen) # -probe syscall.readv = kernel.function("compat_sys_readv") ?, - kernel.function("SyS_readv") !, - kernel.function("sys_readv") +probe syscall.readv = kernel.function("compat_sys_readv").call ?, + kernel.function("SyS_readv").call !, + kernel.function("sys_readv").call { name = "readv" vector_uaddr = $vec @@ -762,8 +762,8 @@ probe syscall.readv.return = kernel.function("compat_sys_readv").return ?, # unsigned int cmd, # void __user * arg) # -probe syscall.reboot = kernel.function("SyS_reboot") !, - kernel.function("sys_reboot") +probe syscall.reboot = kernel.function("SyS_reboot").call !, + kernel.function("sys_reboot").call { name = "reboot" magic = $magic1 @@ -787,7 +787,7 @@ probe syscall.reboot.return = kernel.function("SyS_reboot").return !, # # long sys_recv(int fd, void __user *ubuf, size_t size, unsigned flags) # -probe syscall.recv = kernel.function("sys_recv") ? +probe syscall.recv = kernel.function("sys_recv").call ? { name = "recv" s = $fd @@ -812,8 +812,8 @@ probe syscall.recv.return = kernel.function("sys_recv").return ? # struct sockaddr __user *addr, # int __user *addr_len) # -probe syscall.recvfrom = kernel.function("SyS_recvfrom") !, - kernel.function("sys_recvfrom") ? +probe syscall.recvfrom = kernel.function("SyS_recvfrom").call !, + kernel.function("sys_recvfrom").call ? { name = "recvfrom" s = $fd @@ -839,8 +839,8 @@ probe syscall.recvfrom.return = kernel.function("SyS_recvfrom").return !, # struct msghdr __user *msg, # unsigned int flags) # -probe syscall.recvmsg = kernel.function("SyS_recvmsg") !, - kernel.function("sys_recvmsg") ? +probe syscall.recvmsg = kernel.function("SyS_recvmsg").call !, + kernel.function("sys_recvmsg").call ? { name = "recvmsg" s = $fd @@ -861,7 +861,7 @@ probe syscall.recvmsg.return = kernel.function("SyS_recvmsg").return !, # struct compat_msghdr __user *msg, # unsigned int flags) # -probe syscall.compat_sys_recvmsg = kernel.function("compat_sys_recvmsg") ? +probe syscall.compat_sys_recvmsg = kernel.function("compat_sys_recvmsg").call ? { name = "compat_sys_recvmsg" s = $fd @@ -883,8 +883,8 @@ probe syscall.compat_sys_recvmsg.return = kernel.function("compat_sys_recvmsg"). # unsigned long pgoff, # unsigned long flags) # -probe syscall.remap_file_pages = kernel.function("SyS_remap_file_pages") !, - kernel.function("sys_remap_file_pages") ? +probe syscall.remap_file_pages = kernel.function("SyS_remap_file_pages").call !, + kernel.function("sys_remap_file_pages").call ? { name = "remap_file_pages" start = $start @@ -912,8 +912,8 @@ probe syscall.remap_file_pages.return = kernel.function("SyS_remap_file_pages"). # sys_removexattr(char __user *path, # char __user *name) # -probe syscall.removexattr = kernel.function("SyS_removexattr") !, - kernel.function("sys_removexattr") +probe syscall.removexattr = kernel.function("SyS_removexattr").call !, + kernel.function("sys_removexattr").call { name = "removexattr" name_str = user_string($name) @@ -940,8 +940,8 @@ probe syscall.removexattr.return = kernel.function("SyS_removexattr").return !, # sys_rename(const char __user * oldname, # const char __user * newname) # -probe syscall.rename = kernel.function("SyS_rename") !, - kernel.function("sys_rename") +probe syscall.rename = kernel.function("SyS_rename").call !, + kernel.function("sys_rename").call { name = "rename" oldpath = user_string($oldname) @@ -960,8 +960,8 @@ probe syscall.rename.return = kernel.function("SyS_rename").return !, # new function with 2.6.16 # long sys_renameat(int olddfd, const char __user *oldname, # int newdfd, const char __user *newname) -probe syscall.renameat = kernel.function("SyS_renameat") !, - kernel.function("sys_renameat") ? +probe syscall.renameat = kernel.function("SyS_renameat").call !, + kernel.function("sys_renameat").call ? { name = "renameat" olddfd = $olddfd @@ -991,8 +991,8 @@ probe syscall.renameat.return = kernel.function("SyS_renameat").return !, # key_serial_t destringid) # compat_sys_request_key() calls sys_request_key, so don't need probe there. # -probe syscall.request_key = kernel.function("SyS_request_key") !, - kernel.function("sys_request_key") ? +probe syscall.request_key = kernel.function("SyS_request_key").call !, + kernel.function("sys_request_key").call ? { name = "request_key" type_uaddr = $_type @@ -1013,7 +1013,7 @@ probe syscall.request_key.return = kernel.function("SyS_request_key").return !, # asmlinkage long # sys_restart_syscall(void) # -probe syscall.restart_syscall = kernel.function("sys_restart_syscall") +probe syscall.restart_syscall = kernel.function("sys_restart_syscall").call { name = "restart_syscall" argstr = "" @@ -1028,8 +1028,8 @@ probe syscall.restart_syscall.return = kernel.function("sys_restart_syscall").re # asmlinkage long # sys_rmdir(const char __user * pathname) # -probe syscall.rmdir = kernel.function("SyS_rmdir") !, - kernel.function("sys_rmdir") +probe syscall.rmdir = kernel.function("SyS_rmdir").call !, + kernel.function("sys_rmdir").call { name = "rmdir" pathname = user_string($pathname) @@ -1049,8 +1049,8 @@ probe syscall.rmdir.return = kernel.function("SyS_rmdir").return !, # struct sigaction __user *oact, # size_t sigsetsize) # -probe syscall.rt_sigaction = kernel.function("SyS_rt_sigaction") !, - kernel.function("sys_rt_sigaction") ? +probe syscall.rt_sigaction = kernel.function("SyS_rt_sigaction").call !, + kernel.function("sys_rt_sigaction").call ? { name = "rt_sigaction" sig = $sig @@ -1078,8 +1078,8 @@ probe syscall.rt_sigaction.return = kernel.function("SyS_rt_sigaction").return ! # struct sigaction32 __user *oact, # size_t sigsetsize) -probe syscall.rt_sigaction32 = kernel.function("sys32_rt_sigaction") ?, - kernel.function("compat_sys_rt_sigaction") ? +probe syscall.rt_sigaction32 = kernel.function("sys32_rt_sigaction").call ?, + kernel.function("compat_sys_rt_sigaction").call ? { name = "rt_sigaction" sig = $sig @@ -1100,8 +1100,8 @@ probe syscall.rt_sigaction32.return = kernel.function("sys32_rt_sigaction").retu # # long sys_rt_sigpending(sigset_t __user *set, size_t sigsetsize) # -probe syscall.rt_sigpending = kernel.function("SyS_rt_sigpending") !, - kernel.function("sys_rt_sigpending") ? +probe syscall.rt_sigpending = kernel.function("SyS_rt_sigpending").call !, + kernel.function("sys_rt_sigpending").call ? { name = "rt_sigpending" set_uaddr = $set @@ -1120,10 +1120,10 @@ probe syscall.rt_sigpending.return = kernel.function("SyS_rt_sigpending").return # long compat_sys_rt_sigprocmask(int how, compat_sigset_t __user *set, compat_sigset_t __user *oset, compat_size_t sigsetsize) # long sys_rt_sigprocmask(int how, sigset_t __user *set, sigset_t __user *oset, size_t sigsetsize) # -probe syscall.rt_sigprocmask = kernel.function("sys32_rt_sigprocmask") ?, - kernel.function("compat_sys_rt_sigprocmask") ?, - kernel.function("SyS_rt_sigprocmask") !, - kernel.function("sys_rt_sigprocmask") ? +probe syscall.rt_sigprocmask = kernel.function("sys32_rt_sigprocmask").call ?, + kernel.function("compat_sys_rt_sigprocmask").call ?, + kernel.function("SyS_rt_sigprocmask").call !, + kernel.function("sys_rt_sigprocmask").call ? { name = "rt_sigprocmask" how = $how @@ -1146,8 +1146,8 @@ probe syscall.rt_sigprocmask.return = kernel.function("sys32_rt_sigprocmask").re # # long sys_rt_sigqueueinfo(int pid, int sig, siginfo_t __user *uinfo) # -probe syscall.rt_sigqueueinfo = kernel.function("SyS_rt_sigqueueinfo") !, - kernel.function("sys_rt_sigqueueinfo") +probe syscall.rt_sigqueueinfo = kernel.function("SyS_rt_sigqueueinfo").call !, + kernel.function("sys_rt_sigqueueinfo").call { name = "rt_sigqueueinfo" pid = $pid @@ -1165,8 +1165,8 @@ probe syscall.rt_sigqueueinfo.return = kernel.function("SyS_rt_sigqueueinfo").re # rt_sigreturn _______________________________________________ # int sys_rt_sigreturn(unsigned long __unused) # -probe syscall.rt_sigreturn = kernel.function("sys_rt_sigreturn") ?, - kernel.function("sys32_rt_sigreturn") ? +probe syscall.rt_sigreturn = kernel.function("sys_rt_sigreturn").call ?, + kernel.function("sys32_rt_sigreturn").call ? { name = "rt_sigreturn" argstr = "" @@ -1182,10 +1182,10 @@ probe syscall.rt_sigreturn.return = kernel.function("sys_rt_sigreturn").return ? # # sys_rt_sigsuspend(struct pt_regs regs) # -probe syscall.rt_sigsuspend = kernel.function("compat_sys_rt_sigsuspend") ?, - kernel.function("ia64_rt_sigsuspend") ?, - kernel.function("SyS_rt_sigsuspend") !, - kernel.function("sys_rt_sigsuspend") ? +probe syscall.rt_sigsuspend = kernel.function("compat_sys_rt_sigsuspend").call ?, + kernel.function("ia64_rt_sigsuspend").call ?, + kernel.function("SyS_rt_sigsuspend").call !, + kernel.function("sys_rt_sigsuspend").call ? { name = "rt_sigsuspend" argstr = "" @@ -1209,9 +1209,9 @@ probe syscall.rt_sigsuspend.return = kernel.function("compat_sys_rt_sigsuspend") # struct compat_siginfo __user *uinfo, # struct compat_timespec __user *uts, compat_size_t sigsetsize) # -probe syscall.rt_sigtimedwait = kernel.function("compat_sys_rt_sigtimedwait") ?, - kernel.function("SyS_rt_sigtimedwait") !, - kernel.function("sys_rt_sigtimedwait") +probe syscall.rt_sigtimedwait = kernel.function("compat_sys_rt_sigtimedwait").call ?, + kernel.function("SyS_rt_sigtimedwait").call !, + kernel.function("sys_rt_sigtimedwait").call { name = "rt_sigtimedwait" uthese_uaddr = $uthese @@ -1235,8 +1235,8 @@ probe syscall.rt_sigtimedwait.return = kernel.function("compat_sys_rt_sigtimedwa # unsigned int len, # unsigned long __user *user_mask_ptr) # -probe syscall.sched_getaffinity = kernel.function("SyS_sched_getaffinity") !, - kernel.function("sys_sched_getaffinity") +probe syscall.sched_getaffinity = kernel.function("SyS_sched_getaffinity").call !, + kernel.function("sys_sched_getaffinity").call { name = "sched_getaffinity" pid = $pid @@ -1256,8 +1256,8 @@ probe syscall.sched_getaffinity.return = kernel.function("SyS_sched_getaffinity" # sys_sched_getparam(pid_t pid, # struct sched_param __user *param) # -probe syscall.sched_getparam = kernel.function("SyS_sched_getparam") !, - kernel.function("sys_sched_getparam") +probe syscall.sched_getparam = kernel.function("SyS_sched_getparam").call !, + kernel.function("sys_sched_getparam").call { name = "sched_getparam" pid = $pid @@ -1275,8 +1275,8 @@ probe syscall.sched_getparam.return = kernel.function("SyS_sched_getparam").retu # asmlinkage long # sys_sched_get_priority_max(int policy) # -probe syscall.sched_get_priority_max = kernel.function("SyS_sched_get_priority_max") !, - kernel.function("sys_sched_get_priority_max") +probe syscall.sched_get_priority_max = kernel.function("SyS_sched_get_priority_max").call !, + kernel.function("sys_sched_get_priority_max").call { name = "sched_get_priority_max" policy = $policy @@ -1293,8 +1293,8 @@ probe syscall.sched_get_priority_max.return = kernel.function("SyS_sched_get_pri # asmlinkage long # sys_sched_get_priority_min(int policy) # -probe syscall.sched_get_priority_min = kernel.function("SyS_sched_get_priority_min") !, - kernel.function("sys_sched_get_priority_min") +probe syscall.sched_get_priority_min = kernel.function("SyS_sched_get_priority_min").call !, + kernel.function("sys_sched_get_priority_min").call { name = "sched_get_priority_min" policy = $policy @@ -1310,8 +1310,8 @@ probe syscall.sched_get_priority_min.return = kernel.function("SyS_sched_get_pri # # long sys_sched_getscheduler(pid_t pid) # -probe syscall.sched_getscheduler = kernel.function("SyS_sched_getscheduler") !, - kernel.function("sys_sched_getscheduler") +probe syscall.sched_getscheduler = kernel.function("SyS_sched_getscheduler").call !, + kernel.function("sys_sched_getscheduler").call { name = "sched_getscheduler" pid = $pid @@ -1327,8 +1327,8 @@ probe syscall.sched_getscheduler.return = kernel.function("SyS_sched_getschedule # # long sys_sched_rr_get_interval(pid_t pid, struct timespec __user *interval) # -probe syscall.sched_rr_get_interval = kernel.function("SyS_sched_rr_get_interval") !, - kernel.function("sys_sched_rr_get_interval") +probe syscall.sched_rr_get_interval = kernel.function("SyS_sched_rr_get_interval").call !, + kernel.function("sys_sched_rr_get_interval").call { name = "sched_rr_get_interval" pid = $pid @@ -1349,8 +1349,8 @@ probe syscall.sched_rr_get_interval.return = kernel.function("SyS_sched_rr_get_i # FIXME: why the problem with x86_64? # %( arch != "x86_64" %? -probe syscall.sched_setaffinity = kernel.function("SyS_sched_setaffinity") !, - kernel.function("sys_sched_setaffinity") +probe syscall.sched_setaffinity = kernel.function("SyS_sched_setaffinity").call !, + kernel.function("sys_sched_setaffinity").call { name = "sched_setaffinity" pid = $pid @@ -1359,8 +1359,8 @@ probe syscall.sched_setaffinity = kernel.function("SyS_sched_setaffinity") !, argstr = sprintf("%d, %d, %p", $pid, $len, $user_mask_ptr) } %: -probe syscall.sched_setaffinity = kernel.function("SyS_sched_setaffinity") !, - kernel.function("sys_sched_setaffinity") +probe syscall.sched_setaffinity = kernel.function("SyS_sched_setaffinity").call !, + kernel.function("sys_sched_setaffinity").call { name = "sched_setaffinity" pid = $pid @@ -1380,8 +1380,8 @@ probe syscall.sched_setaffinity.return = kernel.function("SyS_sched_setaffinity" # # long sys_sched_setparam(pid_t pid, struct sched_param __user *param) # -probe syscall.sched_setparam = kernel.function("SyS_sched_setparam") !, - kernel.function("sys_sched_setparam") ? +probe syscall.sched_setparam = kernel.function("SyS_sched_setparam").call !, + kernel.function("sys_sched_setparam").call ? { name = "sched_setparam" pid = $pid @@ -1399,8 +1399,8 @@ probe syscall.sched_setparam.return = kernel.function("SyS_sched_setparam").retu # # long sys_sched_setscheduler(pid_t pid, int policy, struct sched_param __user *param) # -probe syscall.sched_setscheduler = kernel.function("SyS_sched_setscheduler") !, - kernel.function("sys_sched_setscheduler") ? +probe syscall.sched_setscheduler = kernel.function("SyS_sched_setscheduler").call !, + kernel.function("sys_sched_setscheduler").call ? { name = "sched_setscheduler" pid = $pid @@ -1419,7 +1419,7 @@ probe syscall.sched_setscheduler.return = kernel.function("SyS_sched_setschedule # sched_yield ________________________________________________ # long sys_sched_yield(void) # -probe syscall.sched_yield = kernel.function("sys_sched_yield") +probe syscall.sched_yield = kernel.function("sys_sched_yield").call { name = "sched_yield" argstr = "" @@ -1437,8 +1437,8 @@ probe syscall.sched_yield.return = kernel.function("sys_sched_yield").return # fd_set __user *exp, # struct timeval __user *tvp) # -probe syscall.select = kernel.function("SyS_select") !, - kernel.function("sys_select") +probe syscall.select = kernel.function("SyS_select").call !, + kernel.function("sys_select").call { name = "select" n = $n @@ -1461,7 +1461,7 @@ probe syscall.select.return = kernel.function("SyS_select").return !, # compat_ulong_t __user *exp, # struct compat_timeval __user *tvp) # -probe syscall.compat_select = kernel.function("compat_sys_select") ? +probe syscall.compat_select = kernel.function("compat_sys_select").call ? { name = "select" n = $n @@ -1484,8 +1484,8 @@ probe syscall.compat_select.return = kernel.function("compat_sys_select").return # int cmd, # union semun arg) # -probe syscall.semctl = kernel.function("SyS_semctl") !, - kernel.function("sys_semctl") ? +probe syscall.semctl = kernel.function("SyS_semctl").call !, + kernel.function("sys_semctl").call ? { name = "semctl" semid = $semid @@ -1507,7 +1507,7 @@ probe syscall.semctl.return = kernel.function("SyS_semctl").return !, # # long compat_sys_semctl(int first, int second, int third, void __user *uptr) # -probe syscall.compat_sys_semctl = kernel.function("compat_sys_semctl") ? +probe syscall.compat_sys_semctl = kernel.function("compat_sys_semctl").call ? { name = "compat_sys_semctl" argstr = sprintf("%d, %d, %d, %p", $first, $second, $third, $uptr) @@ -1521,8 +1521,8 @@ probe syscall.compat_sys_semctl.return = kernel.function("compat_sys_semctl").re # semget _____________________________________________________ # long sys_semget (key_t key, int nsems, int semflg) # -probe syscall.semget = kernel.function("SyS_semget") !, - kernel.function("sys_semget") ? +probe syscall.semget = kernel.function("SyS_semget").call !, + kernel.function("sys_semget").call ? { name = "semget" key = $key @@ -1543,8 +1543,8 @@ probe syscall.semget.return = kernel.function("SyS_semget").return !, # struct sembuf __user *tsops, # unsigned nsops) # -probe syscall.semop = kernel.function("SyS_semtimedop") !, - kernel.function("sys_semtimedop") ? +probe syscall.semop = kernel.function("SyS_semtimedop").call !, + kernel.function("sys_semtimedop").call ? { name = "semop" semid = $semid @@ -1566,8 +1566,8 @@ probe syscall.semop.return = kernel.function("SyS_semtimedop").return !, # unsigned nsops, # const struct timespec __user *timeout) # -probe syscall.semtimedop = kernel.function("SyS_semtimedop") !, - kernel.function("sys_semtimedop") ? +probe syscall.semtimedop = kernel.function("SyS_semtimedop").call !, + kernel.function("sys_semtimedop").call ? { name = "semtimedop" semid = $semid @@ -1588,7 +1588,7 @@ probe syscall.semtimedop.return = kernel.function("SyS_semtimedop").return !, # long compat_sys_semtimedop(int semid, struct sembuf __user *tsems, # unsigned nsops, const struct compat_timespec __user *timeout) # -probe syscall.compat_sys_semtimedop = kernel.function("compat_sys_semtimedop") ? +probe syscall.compat_sys_semtimedop = kernel.function("compat_sys_semtimedop").call ? { name = "compat_sys_semtimedop" semid = $semid @@ -1611,8 +1611,8 @@ probe syscall.compat_sys_semtimedop.return = kernel.function("compat_sys_semtime # size_t len, # unsigned flags) # -probe syscall.send = kernel.function("SyS_send") !, - kernel.function("sys_send") ? +probe syscall.send = kernel.function("SyS_send").call !, + kernel.function("sys_send").call ? { name = "send" s = $fd @@ -1636,10 +1636,10 @@ probe syscall.send.return = kernel.function("SyS_send").return !, # off_t __user *offset, # size_t count) # -probe syscall.sendfile = kernel.function("SyS_sendfile") ?, - kernel.function("sys_sendfile") ?, - kernel.function("SyS_sendfile64") ?, - kernel.function("sys_sendfile64") ? +probe syscall.sendfile = kernel.function("SyS_sendfile").call ?, + kernel.function("sys_sendfile").call ?, + kernel.function("SyS_sendfile64").call ?, + kernel.function("sys_sendfile64").call ? { name = "sendfile" out_fd = $out_fd @@ -1662,8 +1662,8 @@ probe syscall.sendfile.return = kernel.function("SyS_sendfile").return ?, # # long sys_sendmsg(int fd, struct msghdr __user *msg, unsigned flags) # -probe syscall.sendmsg = kernel.function("SyS_sendmsg") !, - kernel.function("sys_sendmsg") ? +probe syscall.sendmsg = kernel.function("SyS_sendmsg").call !, + kernel.function("sys_sendmsg").call ? { name = "sendmsg" s = $fd @@ -1682,7 +1682,7 @@ probe syscall.sendmsg.return = kernel.function("SyS_sendmsg").return !, # # long compat_sys_sendmsg(int fd, struct compat_msghdr __user *msg, unsigned flags) # -probe syscall.compat_sys_sendmsg = kernel.function("compat_sys_sendmsg") ? +probe syscall.compat_sys_sendmsg = kernel.function("compat_sys_sendmsg").call ? { name = "compat_sys_sendmsg" s = $fd @@ -1705,8 +1705,8 @@ probe syscall.compat_sys_sendmsg.return = kernel.function("compat_sys_sendmsg"). # struct sockaddr __user *addr, # int addr_len) # -probe syscall.sendto = kernel.function("SyS_sendto") !, - kernel.function("sys_sendto") ? +probe syscall.sendto = kernel.function("SyS_sendto").call !, + kernel.function("sys_sendto").call ? { name = "sendto" s = $fd @@ -1732,8 +1732,8 @@ probe syscall.sendto.return = kernel.function("SyS_sendto").return !, # sys_setdomainname(char __user *name, # int len) # -probe syscall.setdomainname = kernel.function("SyS_setdomainname") !, - kernel.function("sys_setdomainname") +probe syscall.setdomainname = kernel.function("SyS_setdomainname").call !, + kernel.function("sys_setdomainname").call { name = "setdomainname" hostname_uaddr = $name @@ -1751,9 +1751,9 @@ probe syscall.setdomainname.return = kernel.function("SyS_setdomainname").return # long sys_setfsgid(gid_t gid) # long sys_setfsgid16(old_gid_t gid) # -probe syscall.setfsgid = kernel.function("sys_setfsgid16") ?, - kernel.function("SyS_setfsgid") !, - kernel.function("sys_setfsgid") ? +probe syscall.setfsgid = kernel.function("sys_setfsgid16").call ?, + kernel.function("SyS_setfsgid").call !, + kernel.function("sys_setfsgid").call ? { name = "setfsgid" fsgid = $gid @@ -1771,9 +1771,9 @@ probe syscall.setfsgid.return = kernel.function("sys_setfsgid16").return ?, # long sys_setfsuid(uid_t uid) # long sys_setfsuid16(old_uid_t uid) # -probe syscall.setfsuid = kernel.function("sys_setfsuid16") ?, - kernel.function("SyS_setfsuid") !, - kernel.function("sys_setfsuid") ? +probe syscall.setfsuid = kernel.function("sys_setfsuid16").call ?, + kernel.function("SyS_setfsuid").call !, + kernel.function("sys_setfsuid").call ? { name = "setfsuid" fsuid = $uid @@ -1792,9 +1792,9 @@ probe syscall.setfsuid.return = kernel.function("sys_setfsuid16").return ?, # long sys_setgid(gid_t gid) # long sys_setgid16(old_gid_t gid) # -probe syscall.setgid = kernel.function("sys_setgid16") ?, - kernel.function("SyS_setgid") !, - kernel.function("sys_setgid") ? +probe syscall.setgid = kernel.function("sys_setgid16").call ?, + kernel.function("SyS_setgid").call !, + kernel.function("sys_setgid").call ? { name = "setgid" gid = $gid @@ -1814,10 +1814,10 @@ probe syscall.setgid.return = kernel.function("sys_setgid16").return ?, # long sys_setgroups16(int gidsetsize, old_gid_t __user *grouplist) # long sys32_setgroups16(int gidsetsize, u16 __user *grouplist) # -probe syscall.setgroups = kernel.function("sys_setgroups16") ?, - kernel.function("sys32_setgroups16") ?, - kernel.function("SyS_setgroups") !, - kernel.function("sys_setgroups") ? +probe syscall.setgroups = kernel.function("sys_setgroups16").call ?, + kernel.function("sys32_setgroups16").call ?, + kernel.function("SyS_setgroups").call !, + kernel.function("sys_setgroups").call ? { name = "setgroups" size = $gidsetsize @@ -1839,8 +1839,8 @@ probe syscall.setgroups.return = kernel.function("sys_setgroups16").return ?, # sys_sethostname(char __user *name, # int len) # -probe syscall.sethostname = kernel.function("SyS_sethostname") !, - kernel.function("sys_sethostname") +probe syscall.sethostname = kernel.function("SyS_sethostname").call !, + kernel.function("sys_sethostname").call { name = "sethostname" hostname_uaddr = $name @@ -1860,8 +1860,8 @@ probe syscall.sethostname.return = kernel.function("SyS_sethostname").return !, # struct itimerval __user *value, # struct itimerval __user *ovalue) # -probe syscall.setitimer = kernel.function("SyS_setitimer") !, - kernel.function("sys_setitimer") +probe syscall.setitimer = kernel.function("SyS_setitimer").call !, + kernel.function("sys_setitimer").call { name = "setitimer" which = $which @@ -1881,7 +1881,7 @@ probe syscall.setitimer.return = kernel.function("SyS_setitimer").return !, # struct compat_itimerval __user *in, # struct compat_itimerval __user *out) # -probe syscall.compat_setitimer = kernel.function("compat_sys_setitimer") ? +probe syscall.compat_setitimer = kernel.function("compat_sys_setitimer").call ? { name = "setitimer" which = $which @@ -1901,9 +1901,9 @@ probe syscall.compat_setitimer.return = kernel.function("compat_sys_setitimer"). # unsigned long __user *nmask, # unsigned long maxnode) # -probe syscall.set_mempolicy = kernel.function("compat_sys_set_mempolicy") ?, - kernel.function("SyS_set_mempolicy") !, - kernel.function("sys_set_mempolicy") ? +probe syscall.set_mempolicy = kernel.function("compat_sys_set_mempolicy").call ?, + kernel.function("SyS_set_mempolicy").call !, + kernel.function("sys_set_mempolicy").call ? { name = "set_mempolicy" mode = $mode @@ -1925,8 +1925,8 @@ probe syscall.set_mempolicy.return = kernel.function("compat_sys_set_mempolicy") # sys_setpgid(pid_t pid, # pid_t pgid) # -probe syscall.setpgid = kernel.function("SyS_setpgid") !, - kernel.function("sys_setpgid") +probe syscall.setpgid = kernel.function("SyS_setpgid").call !, + kernel.function("sys_setpgid").call { name = "setpgid" pid = $pid @@ -1946,8 +1946,8 @@ probe syscall.setpgid.return = kernel.function("SyS_setpgid").return !, # int who, # int niceval) # -probe syscall.setpriority = kernel.function("SyS_setpriority") !, - kernel.function("sys_setpriority") +probe syscall.setpriority = kernel.function("SyS_setpriority").call !, + kernel.function("sys_setpriority").call { name = "setpriority" which = $which @@ -1966,8 +1966,8 @@ probe syscall.setpriority.return = kernel.function("SyS_setpriority").return !, # setregid ___________________________________________________ # long sys_setregid(gid_t rgid, gid_t egid) # -probe syscall.setregid = kernel.function("SyS_setregid") !, - kernel.function("sys_setregid") +probe syscall.setregid = kernel.function("SyS_setregid").call !, + kernel.function("sys_setregid").call { name = "setregid" rgid = __int32($rgid) @@ -1983,7 +1983,7 @@ probe syscall.setregid.return = kernel.function("SyS_setregid").return !, # setregid16 _________________________________________________ # long sys_setregid16(old_gid_t rgid, old_gid_t egid) # -probe syscall.setregid16 = kernel.function("sys_setregid16") ? +probe syscall.setregid16 = kernel.function("sys_setregid16").call ? { name = "setregid" rgid = __short($rgid) @@ -1998,8 +1998,8 @@ probe syscall.setregid16.return = kernel.function("sys_setregid16").return ? # setresgid __________________________________________________ # long sys_setresgid(gid_t rgid, gid_t egid, gid_t sgid) # -probe syscall.setresgid = kernel.function("SyS_setresgid") !, - kernel.function("sys_setresgid") +probe syscall.setresgid = kernel.function("SyS_setresgid").call !, + kernel.function("sys_setresgid").call { name = "setresgid" rgid = __int32($rgid) @@ -2019,7 +2019,7 @@ probe syscall.setresgid.return = kernel.function("SyS_setresgid").return !, # old_gid_t egid, # old_gid_t sgid) # -probe syscall.setresgid16 = kernel.function("sys_setresgid16") ? +probe syscall.setresgid16 = kernel.function("sys_setresgid16").call ? { name = "setresgid" rgid = __short($rgid) @@ -2037,8 +2037,8 @@ probe syscall.setresgid16.return = kernel.function("sys_setresgid16").return ? # # long sys_setresuid(uid_t ruid, uid_t euid, uid_t suid) # -probe syscall.setresuid = kernel.function("SyS_setresuid") !, - kernel.function("sys_setresuid") +probe syscall.setresuid = kernel.function("SyS_setresuid").call !, + kernel.function("sys_setresuid").call { name = "setresuid" ruid = __int32($ruid) @@ -2057,7 +2057,7 @@ probe syscall.setresuid.return = kernel.function("SyS_setresuid").return !, # # long sys_setresuid16(old_uid_t ruid, old_uid_t euid, old_uid_t suid) # -probe syscall.setresuid16 = kernel.function("sys_setresuid16") ? +probe syscall.setresuid16 = kernel.function("sys_setresuid16").call ? { name = "setresuid" ruid = __short($ruid) @@ -2074,8 +2074,8 @@ probe syscall.setresuid16.return = kernel.function("sys_setresuid16").return ? # setreuid ___________________________________________________ # long sys_setreuid(uid_t ruid, uid_t euid) # -probe syscall.setreuid = kernel.function("SyS_setreuid") !, - kernel.function("sys_setreuid") +probe syscall.setreuid = kernel.function("SyS_setreuid").call !, + kernel.function("sys_setreuid").call { name = "setreuid" ruid = __int32($ruid) @@ -2091,7 +2091,7 @@ probe syscall.setreuid.return = kernel.function("SyS_setreuid").return !, # setreuid16 _________________________________________________ # long sys_setreuid16(old_uid_t ruid, old_uid_t euid) # -probe syscall.setreuid16 = kernel.function("sys_setreuid16") ? +probe syscall.setreuid16 = kernel.function("sys_setreuid16").call ? { name = "setreuid" ruid = __short($ruid) @@ -2109,8 +2109,8 @@ probe syscall.setreuid16.return = kernel.function("sys_setreuid16").return ? # sys_setrlimit(unsigned int resource, # struct rlimit __user *rlim) # -probe syscall.setrlimit = kernel.function("SyS_setrlimit") !, - kernel.function("sys_setrlimit") +probe syscall.setrlimit = kernel.function("SyS_setrlimit").call !, + kernel.function("sys_setrlimit").call { name = "setrlimit" resource = $resource @@ -2128,7 +2128,7 @@ probe syscall.setrlimit.return = kernel.function("SyS_setrlimit").return !, # # long sys_setsid(void) # -probe syscall.setsid = kernel.function("sys_setsid") +probe syscall.setsid = kernel.function("sys_setsid").call { name = "setsid" argstr = "" @@ -2147,9 +2147,9 @@ probe syscall.setsid.return = kernel.function("sys_setsid").return # char __user *optval, # int optlen) # -probe syscall.setsockopt = kernel.function("compat_sys_setsockopt") ?, - kernel.function("SyS_setsockopt") !, - kernel.function("sys_setsockopt") ? +probe syscall.setsockopt = kernel.function("compat_sys_setsockopt").call ?, + kernel.function("SyS_setsockopt").call !, + kernel.function("sys_setsockopt").call ? { name = "setsockopt" fd = $fd @@ -2175,8 +2175,8 @@ probe syscall.setsockopt.return = kernel.function("compat_sys_setsockopt").retur # asmlinkage long # sys_set_tid_address(int __user *tidptr) # -probe syscall.set_tid_address = kernel.function("SyS_set_tid_address") !, - kernel.function("sys_set_tid_address") +probe syscall.set_tid_address = kernel.function("SyS_set_tid_address").call !, + kernel.function("sys_set_tid_address").call { name = "set_tid_address" tidptr_uaddr = $tidptr @@ -2193,8 +2193,8 @@ probe syscall.set_tid_address.return = kernel.function("SyS_set_tid_address").re # long sys_settimeofday(struct timeval __user *tv, # struct timezone __user *tz) # -probe syscall.settimeofday = kernel.function("SyS_settimeofday") !, - kernel.function("sys_settimeofday") +probe syscall.settimeofday = kernel.function("SyS_settimeofday").call !, + kernel.function("sys_settimeofday").call { name = "settimeofday" tv_uaddr = $tv @@ -2211,8 +2211,8 @@ probe syscall.settimeofday.return = kernel.function("SyS_settimeofday").return ! # long sys32_settimeofday(struct compat_timeval __user *tv, struct timezone __user *tz) # long compat_sys_settimeofday(struct compat_timeval __user *tv, struct timezone __user *tz) # -probe syscall.settimeofday32 = kernel.function("sys32_settimeofday") ?, - kernel.function("compat_sys_settimeofday") ? +probe syscall.settimeofday32 = kernel.function("sys32_settimeofday").call ?, + kernel.function("compat_sys_settimeofday").call ? { name = "settimeofday" tv_uaddr = $tv @@ -2231,9 +2231,9 @@ probe syscall.settimeofday32.return = kernel.function("sys32_settimeofday").retu # long sys_setuid(uid_t uid) # long sys_setuid16(old_uid_t uid) # -probe syscall.setuid = kernel.function("sys_setuid16") ?, - kernel.function("SyS_setuid") !, - kernel.function("sys_setuid") +probe syscall.setuid = kernel.function("sys_setuid16").call ?, + kernel.function("SyS_setuid").call !, + kernel.function("sys_setuid").call { name = "setuid" uid = $uid @@ -2254,8 +2254,8 @@ probe syscall.setuid.return = kernel.function("sys_setuid16").return ?, # size_t size, # int flags) # -probe syscall.setxattr = kernel.function("SyS_setxattr") !, - kernel.function("sys_setxattr") +probe syscall.setxattr = kernel.function("SyS_setxattr").call !, + kernel.function("sys_setxattr").call { name = "setxattr" %( kernel_v >= "2.6.27" %? @@ -2289,7 +2289,7 @@ probe syscall.setxattr.return = kernel.function("SyS_setxattr").return !, # # sys_sgetmask(void) # -probe syscall.sgetmask = kernel.function("sys_sgetmask") ? +probe syscall.sgetmask = kernel.function("sys_sgetmask").call ? { name = "sgetmask" argstr = "" @@ -2304,8 +2304,8 @@ probe syscall.sgetmask.return = kernel.function("sys_sgetmask").return ? # # long sys_shmat(int shmid, char __user *shmaddr, int shmflg) # -probe syscall.shmat = kernel.function("SyS_shmat") !, - kernel.function("sys_shmat") ? +probe syscall.shmat = kernel.function("SyS_shmat").call !, + kernel.function("sys_shmat").call ? { name = "shmat" shmid = $shmid @@ -2324,7 +2324,7 @@ probe syscall.shmat.return = kernel.function("SyS_shmat").return !, # long compat_sys_shmat(int first, int second, compat_uptr_t third, # int version, void __user *uptr) # -probe syscall.compat_sys_shmat = kernel.function("compat_sys_shmat") ? +probe syscall.compat_sys_shmat = kernel.function("compat_sys_shmat").call ? { name = "compat_sys_shmat" first = $first @@ -2345,8 +2345,8 @@ probe syscall.compat_sys_shmat.return = kernel.function("compat_sys_shmat").retu # int cmd, # struct shmid_ds __user *buf) # -probe syscall.shmctl = kernel.function("SyS_shmctl") !, - kernel.function("sys_shmctl") ? +probe syscall.shmctl = kernel.function("SyS_shmctl").call !, + kernel.function("sys_shmctl").call ? { name = "shmctl" shmid = $shmid @@ -2364,7 +2364,7 @@ probe syscall.shmctl.return = kernel.function("SyS_shmctl").return !, # # long compat_sys_shmctl(int first, int second, void __user *uptr) # -probe syscall.compat_sys_shmctl = kernel.function("compat_sys_shmctl") ? +probe syscall.compat_sys_shmctl = kernel.function("compat_sys_shmctl").call ? { name = "compat_sys_shmctl" first = $first @@ -2382,8 +2382,8 @@ probe syscall.compat_sys_shmctl.return = kernel.function("compat_sys_shmctl").re # # long sys_shmdt(char __user *shmaddr) # -probe syscall.shmdt = kernel.function("SyS_shmdt") !, - kernel.function("sys_shmdt") ? +probe syscall.shmdt = kernel.function("SyS_shmdt").call !, + kernel.function("sys_shmdt").call ? { name = "shmdt" shmaddr_uaddr = $shmaddr @@ -2402,8 +2402,8 @@ probe syscall.shmdt.return = kernel.function("SyS_shmdt").return !, # size_t size, # int shmflg) # -probe syscall.shmget = kernel.function("SyS_shmget") !, - kernel.function("sys_shmget") ? +probe syscall.shmget = kernel.function("SyS_shmget").call !, + kernel.function("sys_shmget").call ? { name = "shmget" key = $key @@ -2422,8 +2422,8 @@ probe syscall.shmget.return = kernel.function("SyS_shmget").return !, # # long sys_shutdown(int fd, int how) # -probe syscall.shutdown = kernel.function("SyS_shutdown") !, - kernel.function("sys_shutdown") ? +probe syscall.shutdown = kernel.function("SyS_shutdown").call !, + kernel.function("sys_shutdown").call ? { name = "shutdown" s = $fd @@ -2442,7 +2442,7 @@ probe syscall.shutdown.return = kernel.function("SyS_shutdown").return !, # sys_sigaction(int sig, const struct old_sigaction __user *act, struct old_sigaction __user *oact) # sys32_sigaction(int sig, struct old_sigaction32 __user *act, struct old_sigaction32 __user *oact) # -probe syscall.sigaction = kernel.function("sys_sigaction") ? +probe syscall.sigaction = kernel.function("sys_sigaction").call ? { name = "sigaction" sig = $sig @@ -2455,7 +2455,7 @@ probe syscall.sigaction.return = kernel.function("sys_sigaction").return ? name = "sigaction" retstr = returnstr(1) } -probe syscall.sigaction32 = kernel.function("sys32_sigaction") ? +probe syscall.sigaction32 = kernel.function("sys32_sigaction").call ? { name = "sigaction" sig = $sig @@ -2472,8 +2472,8 @@ probe syscall.sigaction32.return = kernel.function("sys32_sigaction").return ? # signal _____________________________________________________ # unsigned long sys_signal(int sig, __sighandler_t handler) # -probe syscall.signal = kernel.function("SyS_signal") !, - kernel.function("sys_signal") ? +probe syscall.signal = kernel.function("SyS_signal").call !, + kernel.function("sys_signal").call ? { name = "signal" sig = $sig @@ -2493,8 +2493,8 @@ probe syscall.signal.return = kernel.function("SyS_signal").return !, # long compat_sys_signalfd(int ufd, const compat_sigset_t __user *sigmask, # compat_size_t sigsetsize) # -probe syscall.signalfd = kernel.function("SyS_signalfd") !, - kernel.function("sys_signalfd") ? +probe syscall.signalfd = kernel.function("SyS_signalfd").call !, + kernel.function("sys_signalfd").call ? { name = "signalfd" argstr = sprintf("%d, %p, %d", $ufd, $user_mask, $sizemask) @@ -2505,7 +2505,7 @@ probe syscall.signalfd.return = kernel.function("SyS_signalfd").return !, name = "signalfd" retstr = returnstr(1) } -probe syscall.compat_signalfd = kernel.function("compat_sys_signalfd") ? +probe syscall.compat_signalfd = kernel.function("compat_sys_signalfd").call ? { name = "compat_signalfd" argstr = sprintf("%d, %p, %d", $ufd, $sigmask, $sigsetsize) @@ -2519,8 +2519,8 @@ probe syscall.compat_signalfd.return = kernel.function("compat_sys_signalfd").re # sigpending _________________________________________________ # long sys_sigpending(old_sigset_t __user *set) # -probe syscall.sigpending = kernel.function("SyS_sigpending") !, - kernel.function("sys_sigpending") ? +probe syscall.sigpending = kernel.function("SyS_sigpending").call !, + kernel.function("sys_sigpending").call ? { name = "sigpending" argstr = sprintf("%p", $set) @@ -2535,8 +2535,8 @@ probe syscall.sigpending.return = kernel.function("SyS_sigpending").return !, # sigprocmask ________________________________________________ # long sys_sigprocmask(int how, old_sigset_t __user *set, old_sigset_t __user *oset) # -probe syscall.sigprocmask = kernel.function("SyS_sigprocmask") !, - kernel.function("sys_sigprocmask") ? +probe syscall.sigprocmask = kernel.function("SyS_sigprocmask").call !, + kernel.function("sys_sigprocmask").call ? { name = "sigprocmask" how = $how @@ -2555,8 +2555,8 @@ probe syscall.sigprocmask.return = kernel.function("SyS_sigprocmask").return !, # sigreturn __________________________________________________ # int sys_sigreturn(unsigned long __unused) # -probe syscall.sigreturn = kernel.function("sys_sigreturn") ?, - kernel.function("sys32_sigreturn") ? +probe syscall.sigreturn = kernel.function("sys_sigreturn").call ?, + kernel.function("sys32_sigreturn").call ? { name = "sigreturn" argstr = "" @@ -2570,8 +2570,8 @@ probe syscall.sigreturn.return = kernel.function("sys_sigreturn").return ?, # sigsuspend _________________________________________________ # -probe syscall.sigsuspend = kernel.function("sys_sigsuspend") ?, - kernel.function("sys32_sigsuspend") ? +probe syscall.sigsuspend = kernel.function("sys_sigsuspend").call ?, + kernel.function("sys32_sigsuspend").call ? { name = "sigsuspend" argstr = "" @@ -2586,8 +2586,8 @@ probe syscall.sigsuspend.return = kernel.function("sys_sigsuspend").return ?, # socket _____________________________________________________ # long sys_socket(int family, int type, int protocol) # -probe syscall.socket = kernel.function("SyS_socket") !, - kernel.function("sys_socket") ? +probe syscall.socket = kernel.function("SyS_socket").call !, + kernel.function("sys_socket").call ? { name = "socket" family = $family @@ -2609,7 +2609,7 @@ probe syscall.socket.return = kernel.function("SyS_socket").return !, # # long sys_socketcall(int call, unsigned long __user *args) # -#probe syscall.socketcall = kernel.function("sys_socketcall") ? +#probe syscall.socketcall = kernel.function("sys_socketcall").call ? #{ # name = "socketcall" # call = $call @@ -2628,8 +2628,8 @@ probe syscall.socket.return = kernel.function("SyS_socket").return !, # int protocol, # int __user *usockvec) # -probe syscall.socketpair = kernel.function("SyS_socketpair") !, - kernel.function("sys_socketpair") ? +probe syscall.socketpair = kernel.function("SyS_socketpair").call !, + kernel.function("sys_socketpair").call ? { name = "socketpair" family = $family @@ -2654,8 +2654,8 @@ probe syscall.socketpair.return = kernel.function("SyS_socketpair").return !, # int fd_out, loff_t __user *off_out, # size_t len, unsigned int flags) # -probe syscall.splice = kernel.function("SyS_splice") !, - kernel.function("sys_splice") ? +probe syscall.splice = kernel.function("SyS_splice").call !, + kernel.function("sys_splice").call ? { name = "splice" argstr = sprintf("%d, %p, %d, %p, %d, 0x%x", @@ -2672,8 +2672,8 @@ probe syscall.splice.return = kernel.function("SyS_splice").return !, # # long sys_ssetmask(int newmask) # -probe syscall.ssetmask = kernel.function("SyS_ssetmask") !, - kernel.function("sys_ssetmask") ? +probe syscall.ssetmask = kernel.function("SyS_ssetmask").call !, + kernel.function("sys_ssetmask").call ? { name = "ssetmask" newmask = $newmask @@ -2692,14 +2692,14 @@ probe syscall.ssetmask.return = kernel.function("SyS_ssetmask").return !, # long sys_stat64(char __user * filename, struct stat64 __user * statbuf) # long sys_oabi_stat64(char __user * filename, struct oldabi_stat64 __user * statbuf) # long compat_sys_newstat(char __user * filename, struct compat_stat __user *statbuf) -probe syscall.stat = kernel.function("sys_stat") ?, - kernel.function("SyS_newstat") ?, - kernel.function("sys_newstat") ?, - kernel.function("sys32_stat64") ?, - kernel.function("SyS_stat64") ?, - kernel.function("sys_stat64") ?, - kernel.function("sys_oabi_stat64") ?, - kernel.function("compat_sys_newstat") ? +probe syscall.stat = kernel.function("sys_stat").call ?, + kernel.function("SyS_newstat").call ?, + kernel.function("sys_newstat").call ?, + kernel.function("sys32_stat64").call ?, + kernel.function("SyS_stat64").call ?, + kernel.function("sys_stat64").call ?, + kernel.function("sys_oabi_stat64").call ?, + kernel.function("compat_sys_newstat").call ? { name = "stat" filename_uaddr = $filename @@ -2724,9 +2724,9 @@ probe syscall.stat.return = kernel.function("sys_stat").return ?, # long sys_statfs(const char __user * path, struct statfs __user * buf) # long compat_sys_statfs(const char __user *path, struct compat_statfs __user *buf) # -probe syscall.statfs = kernel.function("compat_sys_statfs") ?, - kernel.function("SyS_statfs") !, - kernel.function("sys_statfs") ? +probe syscall.statfs = kernel.function("compat_sys_statfs").call ?, + kernel.function("SyS_statfs").call !, + kernel.function("sys_statfs").call ? { name = "statfs" buf_uaddr = $buf @@ -2752,9 +2752,9 @@ probe syscall.statfs.return = kernel.function("compat_sys_statfs").return ?, # long sys_statfs64(const char __user *path, size_t sz, struct statfs64 __user *buf) # long compat_sys_statfs64(const char __user *path, compat_size_t sz, struct compat_statfs64 __user *buf) # -probe syscall.statfs64 = kernel.function("compat_sys_statfs64") ?, - kernel.function("SyS_statfs64") !, - kernel.function("sys_statfs64") ? +probe syscall.statfs64 = kernel.function("compat_sys_statfs64").call ?, + kernel.function("SyS_statfs64").call !, + kernel.function("sys_statfs64").call ? { name = "statfs" sz = $sz @@ -2781,9 +2781,9 @@ probe syscall.statfs64.return = kernel.function("compat_sys_statfs64").return ?, # long sys_stime(time_t __user *tptr) # long compat_sys_stime(compat_time_t __user *tptr) # -probe syscall.stime = kernel.function("compat_sys_stime") ?, - kernel.function("SyS_stime") !, - kernel.function("sys_stime") ? +probe syscall.stime = kernel.function("compat_sys_stime").call ?, + kernel.function("SyS_stime").call !, + kernel.function("sys_stime").call ? { name = "stime" t_uaddr = $tptr @@ -2803,8 +2803,8 @@ probe syscall.stime.return = kernel.function("compat_sys_stime").return ?, # asmlinkage long # sys_swapoff(const char __user * specialfile) # -probe syscall.swapoff = kernel.function("SyS_swapoff") !, - kernel.function("sys_swapoff") ? +probe syscall.swapoff = kernel.function("SyS_swapoff").call !, + kernel.function("sys_swapoff").call ? { name = "swapoff" path = user_string($specialfile) @@ -2822,8 +2822,8 @@ probe syscall.swapoff.return = kernel.function("SyS_swapoff").return !, # sys_swapon(const char __user * specialfile, # int swap_flags) # -probe syscall.swapon = kernel.function("SyS_swapon") !, - kernel.function("sys_swapon") ? +probe syscall.swapon = kernel.function("SyS_swapon").call !, + kernel.function("sys_swapon").call ? { name = "swapon" path = user_string($specialfile) @@ -2840,8 +2840,8 @@ probe syscall.swapon.return = kernel.function("SyS_swapon").return !, # symlink ____________________________________________________ # long sys_symlink(const char __user * oldname, # const char __user * newname) -probe syscall.symlink = kernel.function("SyS_symlink") !, - kernel.function("sys_symlink") +probe syscall.symlink = kernel.function("SyS_symlink").call !, + kernel.function("sys_symlink").call { name = "symlink" oldpath = user_string($oldname) @@ -2860,8 +2860,8 @@ probe syscall.symlink.return = kernel.function("SyS_symlink").return !, # new function with 2.6.16 # long sys_symlinkat(const char __user *oldname, int newdfd, # const char __user *newname) -probe syscall.symlinkat = kernel.function("SyS_symlinkat") !, - kernel.function("sys_symlinkat") ? +probe syscall.symlinkat = kernel.function("SyS_symlinkat").call !, + kernel.function("sys_symlinkat").call ? { name = "symlinkat" oldname = $oldname @@ -2884,7 +2884,7 @@ probe syscall.symlinkat.return = kernel.function("SyS_symlinkat").return !, # # sys_sync(void) # -probe syscall.sync = kernel.function("sys_sync") +probe syscall.sync = kernel.function("sys_sync").call { name = "sync" argstr = "" @@ -2899,9 +2899,9 @@ probe syscall.sync.return = kernel.function("sys_sync").return # # long sys_sysctl(struct __sysctl_args __user *args) # -probe syscall.sysctl = kernel.function("compat_sys_sysctl") ?, - kernel.function("SyS_sysctl") !, - kernel.function("sys_sysctl") ? +probe syscall.sysctl = kernel.function("compat_sys_sysctl").call ?, + kernel.function("SyS_sysctl").call !, + kernel.function("sys_sysctl").call ? { name = "sysctl" argstr = sprintf("%p", $args) @@ -2921,8 +2921,8 @@ probe syscall.sysctl.return = kernel.function("compat_sys_sysctl").return ?, # unsigned long arg1, # unsigned long arg2) # -probe syscall.sysfs = kernel.function("SyS_sysfs") !, - kernel.function("sys_sysfs") +probe syscall.sysfs = kernel.function("SyS_sysfs").call !, + kernel.function("sys_sysfs").call { name = "sysfs" option = $option @@ -2947,9 +2947,9 @@ probe syscall.sysfs.return = kernel.function("SyS_sysfs").return !, # # long sys_sysinfo(struct sysinfo __user *info) # long compat_sys_sysinfo(struct compat_sysinfo __user *info) -probe syscall.sysinfo = kernel.function("compat_sys_sysinfo") ?, - kernel.function("SyS_sysinfo") !, - kernel.function("sys_sysinfo") +probe syscall.sysinfo = kernel.function("compat_sys_sysinfo").call ?, + kernel.function("SyS_sysinfo").call !, + kernel.function("sys_sysinfo").call { name = "sysinfo" info_uaddr = $info @@ -2967,8 +2967,8 @@ probe syscall.sysinfo.return = kernel.function("compat_sys_sysinfo").return ?, # # long sys_syslog(int type, char __user * buf, int len) # -probe syscall.syslog = kernel.function("SyS_syslog") !, - kernel.function("sys_syslog") +probe syscall.syslog = kernel.function("SyS_syslog").call !, + kernel.function("sys_syslog").call { name = "syslog" type = $type @@ -2987,8 +2987,8 @@ probe syscall.syslog.return = kernel.function("SyS_syslog").return !, # # long sys_tee(int fdin, int fdout, size_t len, unsigned int flags) # -probe syscall.tee = kernel.function("SyS_tee") !, - kernel.function("sys_tee") ? +probe syscall.tee = kernel.function("SyS_tee").call !, + kernel.function("sys_tee").call ? { name = "tee" argstr = sprintf("%d, %d, %d, 0x%x", $fdin, $fdout, $len, $flags) @@ -3007,8 +3007,8 @@ probe syscall.tee.return = kernel.function("SyS_tee").return !, # int pid, # int sig) # -probe syscall.tgkill = kernel.function("SyS_tgkill") !, - kernel.function("sys_tgkill") +probe syscall.tgkill = kernel.function("SyS_tgkill").call !, + kernel.function("sys_tgkill").call { name = "tgkill" tgid = $tgid @@ -3029,11 +3029,11 @@ probe syscall.tgkill.return = kernel.function("SyS_tgkill").return !, # long sys32_time(compat_time_t __user * tloc) # long compat_sys_time(compat_time_t __user * tloc) # -probe syscall.time = kernel.function("sys32_time") ?, - kernel.function("sys_time64") ?, - kernel.function("compat_sys_time") ?, - kernel.function("SyS_time") !, - kernel.function("sys_time") ? +probe syscall.time = kernel.function("sys32_time").call ?, + kernel.function("sys_time64").call ?, + kernel.function("compat_sys_time").call ?, + kernel.function("SyS_time").call !, + kernel.function("sys_time").call ? { name = "time" t_uaddr = $tloc @@ -3055,8 +3055,8 @@ probe syscall.time.return = kernel.function("sys32_time").return ?, # struct sigevent __user *timer_event_spec, # timer_t __user * created_timer_id) # -probe syscall.timer_create = kernel.function("SyS_timer_create") !, - kernel.function("sys_timer_create") +probe syscall.timer_create = kernel.function("SyS_timer_create").call !, + kernel.function("sys_timer_create").call { name = "timer_create" clockid = $which_clock @@ -3076,8 +3076,8 @@ probe syscall.timer_create.return = kernel.function("SyS_timer_create").return ! # # long sys_timer_delete(timer_t timer_id) # -probe syscall.timer_delete = kernel.function("SyS_timer_delete") !, - kernel.function("sys_timer_delete") +probe syscall.timer_delete = kernel.function("SyS_timer_delete").call !, + kernel.function("sys_timer_delete").call { name = "timer_delete" timerid = $timer_id @@ -3094,8 +3094,8 @@ probe syscall.timer_delete.return = kernel.function("SyS_timer_delete").return ! # # long sys_timer_getoverrun(timer_t timer_id) # -probe syscall.timer_getoverrun = kernel.function("SyS_timer_getoverrun") !, - kernel.function("sys_timer_getoverrun") +probe syscall.timer_getoverrun = kernel.function("SyS_timer_getoverrun").call !, + kernel.function("sys_timer_getoverrun").call { name = "timer_getoverrun" timerid = $timer_id @@ -3113,8 +3113,8 @@ probe syscall.timer_getoverrun.return = kernel.function("SyS_timer_getoverrun"). # long sys_timer_gettime(timer_t timer_id, # struct itimerspec __user *setting) # -probe syscall.timer_gettime = kernel.function("SyS_timer_gettime") !, - kernel.function("sys_timer_gettime") +probe syscall.timer_gettime = kernel.function("SyS_timer_gettime").call !, + kernel.function("sys_timer_gettime").call { name = "timer_gettime" timerid = $timer_id @@ -3135,8 +3135,8 @@ probe syscall.timer_gettime.return = kernel.function("SyS_timer_gettime").return # const struct itimerspec __user *new_setting, # struct itimerspec __user *old_setting) # -probe syscall.timer_settime = kernel.function("SyS_timer_settime") !, - kernel.function("sys_timer_settime") +probe syscall.timer_settime = kernel.function("SyS_timer_settime").call !, + kernel.function("sys_timer_settime").call { name = "timer_settime" timerid = $timer_id @@ -3161,8 +3161,8 @@ probe syscall.timer_settime.return = kernel.function("SyS_timer_settime").return # long compat_sys_timerfd(int ufd, int clockid, int flags, # const struct compat_itimerspec __user *utmr) # -probe syscall.timerfd = kernel.function("sys_timerfd") ?, - kernel.function("compat_sys_timerfd") ? +probe syscall.timerfd = kernel.function("sys_timerfd").call ?, + kernel.function("compat_sys_timerfd").call ? { name = "timerfd" argstr = sprintf("%d, %d, 0x%x", $ufd, $clockid, $flags) @@ -3178,9 +3178,9 @@ probe syscall.timerfd.return = kernel.function("sys_timerfd").return ?, # # long sys_times(struct tms __user * tbuf) # long compat_sys_times(struct compat_tms __user *tbuf) -probe syscall.times = kernel.function("compat_sys_times") ?, - kernel.function("SyS_times") !, - kernel.function("sys_times") ? +probe syscall.times = kernel.function("compat_sys_times").call ?, + kernel.function("SyS_times").call !, + kernel.function("sys_times").call ? { name = "times" argstr = sprintf("%p", $tbuf) @@ -3199,8 +3199,8 @@ probe syscall.times.return = kernel.function("compat_sys_times").return ?, # sys_tkill(int pid, # int sig) # -probe syscall.tkill = kernel.function("SyS_tkill") !, - kernel.function("sys_tkill") +probe syscall.tkill = kernel.function("SyS_tkill").call !, + kernel.function("sys_tkill").call { name = "tkill" pid = $pid @@ -3219,9 +3219,9 @@ probe syscall.tkill.return = kernel.function("SyS_tkill").return !, # sys_truncate(const char __user * path, unsigned long length) # sys_truncate64(const char __user * path, loff_t length) # -probe syscall.truncate = kernel.function("SyS_truncate") !, - kernel.function("sys_truncate") ?, - kernel.function("sys_truncate64") ? +probe syscall.truncate = kernel.function("SyS_truncate").call !, + kernel.function("sys_truncate").call ?, + kernel.function("sys_truncate64").call ? { name = "truncate" path_uaddr = $path @@ -3240,7 +3240,7 @@ probe syscall.truncate.return = kernel.function("SyS_truncate").return !, # tux ________________________________________________________ # long sys_tux (unsigned int action, user_req_t *u_info) # -probe syscall.tux = kernel.function("sys_tux") ? +probe syscall.tux = kernel.function("sys_tux").call ? { name = "tux" action = $action @@ -3256,8 +3256,8 @@ probe syscall.tux.return = kernel.function("sys_tux").return ? # umask ______________________________________________________ # long sys_umask(int mask) # -probe syscall.umask = kernel.function("SyS_umask") !, - kernel.function("sys_umask") +probe syscall.umask = kernel.function("SyS_umask").call !, + kernel.function("sys_umask").call { name = "umask" mask = $mask @@ -3273,8 +3273,8 @@ probe syscall.umask.return = kernel.function("SyS_umask").return !, # umount _____________________________________________________ # long sys_umount(char __user * name, int flags) # -probe syscall.umount = kernel.function("SyS_umount") !, - kernel.function("sys_umount") +probe syscall.umount = kernel.function("SyS_umount").call !, + kernel.function("sys_umount").call { name = "umount" target = user_string($name) @@ -3296,12 +3296,12 @@ probe syscall.umount.return = kernel.function("SyS_umount").return !, # int sys32_olduname(struct oldold_utsname __user * name) # long sys32_uname(struct old_utsname __user * name) # -probe syscall.uname = kernel.function("sys_uname") ?, - kernel.function("sys_olduname") ?, - kernel.function("sys32_olduname") ?, - kernel.function("sys32_uname") ?, - kernel.function("SyS_newuname") !, - kernel.function("sys_newuname") ? +probe syscall.uname = kernel.function("sys_uname").call ?, + kernel.function("sys_olduname").call ?, + kernel.function("sys32_olduname").call ?, + kernel.function("sys32_uname").call ?, + kernel.function("SyS_newuname").call !, + kernel.function("sys_newuname").call ? { name = "uname" argstr = sprintf("%p", $name) @@ -3321,8 +3321,8 @@ probe syscall.uname.return = kernel.function("sys_uname").return ?, # unlink _____________________________________________________ # long sys_unlink(const char __user * pathname) # -probe syscall.unlink = kernel.function("SyS_unlink") !, - kernel.function("sys_unlink") +probe syscall.unlink = kernel.function("SyS_unlink").call !, + kernel.function("sys_unlink").call { name = "unlink" pathname_uaddr = $pathname @@ -3340,8 +3340,8 @@ probe syscall.unlink.return = kernel.function("SyS_unlink").return !, # new function with 2.6.16 # long sys_unlinkat(int dfd, const char __user *pathname, # int flag) -probe syscall.unlinkat = kernel.function("SyS_unlinkat") !, - kernel.function("sys_unlinkat") ? +probe syscall.unlinkat = kernel.function("SyS_unlinkat").call !, + kernel.function("sys_unlinkat").call ? { name = "unlinkat" dfd = $dfd @@ -3362,8 +3362,8 @@ probe syscall.unlinkat.return = kernel.function("SyS_unlinkat").return !, # unshare ____________________________________________________ # new function with 2.6.16 # long sys_unshare(unsigned long unshare_flags) -probe syscall.unshare = kernel.function("SyS_unshare") !, - kernel.function("sys_unshare") ? +probe syscall.unshare = kernel.function("SyS_unshare").call !, + kernel.function("sys_unshare").call ? { name = "unshare" unshare_flags = $unshare_flags @@ -3381,8 +3381,8 @@ probe syscall.unshare.return = kernel.function("SyS_unshare").return !, # asmlinkage long # sys_uselib(const char __user * library) # -probe syscall.uselib = kernel.function("SyS_uselib") !, - kernel.function("sys_uselib") +probe syscall.uselib = kernel.function("SyS_uselib").call !, + kernel.function("sys_uselib").call { name = "uselib" library_uaddr = $library @@ -3398,8 +3398,8 @@ probe syscall.uselib.return = kernel.function("SyS_uselib").return !, # ustat ______________________________________________________ # long sys_ustat(unsigned dev, struct ustat __user * ubuf) # -probe syscall.ustat = kernel.function("SyS_ustat") !, - kernel.function("sys_ustat") +probe syscall.ustat = kernel.function("SyS_ustat").call !, + kernel.function("sys_ustat").call { name = "ustat" dev = $dev @@ -3408,7 +3408,7 @@ probe syscall.ustat = kernel.function("SyS_ustat") !, } #long sys32_ustat(unsigned dev, struct ustat32 __user *u32p) -probe syscall.ustat32 = kernel.function("sys32_ustat") ? +probe syscall.ustat32 = kernel.function("sys32_ustat").call ? { name = "ustat" dev = $dev @@ -3417,7 +3417,7 @@ probe syscall.ustat32 = kernel.function("sys32_ustat") ? # Since 2.6.30 sys32_ustat is compat_sys_ustat # Note that last argument changed name. #long compat_sys_ustat(unsigned dev, struct compat_ustat __user *u) -probe syscall.ustat32 = kernel.function("compat_sys_ustat") ? +probe syscall.ustat32 = kernel.function("compat_sys_ustat").call ? { name = "ustat" dev = $dev @@ -3435,8 +3435,8 @@ probe syscall.ustat.return = kernel.function("SyS_ustat").return ?, # utime ______________________________________________________ # long sys_utime(char __user * filename, struct utimbuf __user * times) -probe syscall.utime = kernel.function("SyS_utime") !, - kernel.function("sys_utime") ? +probe syscall.utime = kernel.function("SyS_utime").call !, + kernel.function("sys_utime").call ? { name = "utime" filename_uaddr = $filename @@ -3455,7 +3455,7 @@ probe syscall.utime.return = kernel.function("SyS_utime").return !, } # long compat_sys_utime(char __user *filename, struct compat_utimbuf __user *t) -probe syscall.compat_utime = kernel.function("compat_sys_utime") ? +probe syscall.compat_utime = kernel.function("compat_sys_utime").call ? { name = "utime" filename_uaddr = $filename @@ -3476,8 +3476,8 @@ probe syscall.compat_utime.return = kernel.function("compat_sys_utime").return ? # # long sys_utimes(char __user * filename, struct timeval __user * utimes) # -probe syscall.utimes = kernel.function("SyS_utimes") !, - kernel.function("sys_utimes") +probe syscall.utimes = kernel.function("SyS_utimes").call !, + kernel.function("sys_utimes").call { name = "utimes" filename_uaddr = $filename @@ -3496,7 +3496,7 @@ probe syscall.utimes.return = kernel.function("SyS_utimes").return !, # # long compat_sys_utimes(char __user *filename, struct compat_timeval __user *t) # -probe syscall.compat_sys_utimes = kernel.function("compat_sys_utimes") ? +probe syscall.compat_sys_utimes = kernel.function("compat_sys_utimes").call ? { name = "utimes" filename = user_string($filename) @@ -3513,14 +3513,14 @@ probe syscall.compat_sys_utimes.return = kernel.function("compat_sys_utimes").re # long sys_utimensat(int dfd, char __user *filename, struct timespec __user *utimes, int flags) # long compat_sys_utimensat(unsigned int dfd, char __user *filename, struct compat_timespec __user *t, int flags) # -probe syscall.utimensat = kernel.function("SyS_utimensat") !, - kernel.function("sys_utimensat") ? +probe syscall.utimensat = kernel.function("SyS_utimensat").call !, + kernel.function("sys_utimensat").call ? { name = "utimensat" argstr = sprintf("%s, %s, %s, %s", _dfd_str($dfd), user_string_quoted($filename), _struct_timespec_u($utimes, 2), _at_flag_str($flags)) } -probe syscall.compat_utimensat = kernel.function("compat_sys_utimensat") ? +probe syscall.compat_utimensat = kernel.function("compat_sys_utimensat").call ? { name = "utimensat" argstr = sprintf("%s, %s, %s, %s", _dfd_str($dfd), user_string_quoted($filename), _struct_compat_timespec_u($t, 2), @@ -3543,7 +3543,7 @@ probe syscall.compat_utimensat.return = kernel.function("compat_sys_utimensat") # asmlinkage long # sys_vhangup(void) # -probe syscall.vhangup = kernel.function("sys_vhangup") +probe syscall.vhangup = kernel.function("sys_vhangup").call { name = "vhangup" argstr = "" @@ -3561,13 +3561,13 @@ probe syscall.vhangup.return = kernel.function("sys_vhangup").return # long compat_sys_vmsplice(int fd, const struct compat_iovec __user *iov32, # unsigned int nr_segs, unsigned int flags) # -probe syscall.vmsplice = kernel.function("SyS_vmsplice") !, - kernel.function("sys_vmsplice") ? +probe syscall.vmsplice = kernel.function("SyS_vmsplice").call !, + kernel.function("sys_vmsplice").call ? { name = "vmsplice" argstr = sprintf("%d, %p, %d, 0x%x", $fd, $iov, $nr_segs, $flags) } -probe syscall.compat_vmsplice = kernel.function("compat_sys_vmsplice") ? +probe syscall.compat_vmsplice = kernel.function("compat_sys_vmsplice").call ? { name = "vmsplice" argstr = sprintf("%d, %p, %d, 0x%x", $fd, $iov32, $nr_segs, $flags) @@ -3591,8 +3591,8 @@ probe syscall.compat_vmsplice.return = kernel.function("compat_sys_vmsplice").re # int options, # struct rusage __user *ru) # -probe syscall.wait4 = kernel.function("SyS_wait4") !, - kernel.function("sys_wait4") +probe syscall.wait4 = kernel.function("SyS_wait4").call !, + kernel.function("sys_wait4").call { name = "wait4" pid = %( kernel_vr >= "2.6.25" %? $upid %: $pid%) @@ -3618,8 +3618,8 @@ probe syscall.wait4.return = kernel.function("SyS_wait4").return !, # int options, # struct rusage __user *ru) # -probe syscall.waitid = kernel.function("SyS_waitid") !, - kernel.function("sys_waitid") +probe syscall.waitid = kernel.function("SyS_waitid").call !, + kernel.function("sys_waitid").call { name = "waitid" pid = %( kernel_vr >= "2.6.25" %? $upid %: $pid%) @@ -3647,8 +3647,8 @@ probe syscall.waitid.return = kernel.function("SyS_waitid").return !, # int options, # struct rusage __user *ru) # -probe syscall.waitpid = kernel.function("SyS_wait4") !, - kernel.function("sys_wait4") +probe syscall.waitpid = kernel.function("SyS_wait4").call !, + kernel.function("sys_wait4").call { name = "waitpid" pid = $pid @@ -3673,8 +3673,8 @@ probe syscall.waitpid.return = kernel.function("SyS_wait4").return !, # const char __user * buf, # size_t count) # -probe syscall.write = kernel.function("SyS_write") !, - kernel.function("sys_write") +probe syscall.write = kernel.function("SyS_write").call !, + kernel.function("sys_write").call { name = "write" fd = $fd @@ -3698,9 +3698,9 @@ probe syscall.write.return = kernel.function("SyS_write").return !, # const struct compat_iovec __user *vec, # unsigned long vlen) # -probe syscall.writev = kernel.function("compat_sys_writev") ?, - kernel.function("SyS_writev") !, - kernel.function("sys_writev") +probe syscall.writev = kernel.function("compat_sys_writev").call ?, + kernel.function("SyS_writev").call !, + kernel.function("sys_writev").call { name = "writev" vector_uaddr = $vec diff --git a/tapset/task_time.stp b/tapset/task_time.stp new file mode 100644 index 00000000..55b7934c --- /dev/null +++ b/tapset/task_time.stp @@ -0,0 +1,101 @@ +// Task time query and utility functions. +// Copyright (C) 2009 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> +// Task time query and utility functions provide information about +// the time resource usage of the current task. These functions provide +// information about the user time and system time of the current +// task. And provide utility functions to turn the reported times +// into miliseconds and create human readable string representations +// of task time used. The reported times are approximates and should +// be used for "coarse grained" measurements only. The reported user +// and system time are only for the current task, not for the process +// as a whole nor of any time spend by children of the current task. +// </tapsetdescription> + +%{ +#include <asm/cputime.h> +#include <linux/time.h> +%} + +/** + * sfunction task_utime - User time of the current task. + * + * Description: Returns the user time of the current task in cputime. + * Does not include any time used by other tasks in this process, nor + * does it include any time of the children of this task. + */ +function task_utime:long () +%{ /* pure */ /* unprivileged */ + THIS->__retvalue = current->utime; +%} + +/** + * sfunction task_stime - System time of the current task. + * + * Description: Returns the system time of the current task in cputime. + * Does not include any time used by other tasks in this process, nor + * does it include any time of the children of this task. + */ +function task_stime:long () +%{ /* pure */ /* unprivileged */ + THIS->__retvalue = current->stime; +%} + +/** + * sfunction cputime_to_msecs - Translates the given cputime into milliseconds. + * @cputime: Time to convert to milliseconds. + */ +function cputime_to_msecs:long (cputime:long) +%{ /* pure */ /* unprivileged */ + THIS->__retvalue = cputime_to_msecs (THIS->cputime); +%} + +/** + * sfunction msecs_to_string - Human readable string for given milliseconds. + * @msecs: Number of milliseconds to translate. + * + * Description: Returns a string representing the number of + * milliseconds as a human readable string consisting of "XmY.ZZZs", + * where X is the number of minutes, Y is the number of seconds and + * ZZZ is the number of milliseconds. + */ +function msecs_to_string:string (msecs:long) +{ + ms = msecs % 1000; + secs = msecs / 1000; + mins = secs / 60; + secs = secs % 60; + return sprintf("%dm%d.%.3ds", mins, secs, ms); +} + +/** + * sfunction cputime_to_string - Human readable string for given cputime. + * @cputime: Time to translate. + * + * Description: Equivalent to calling: + * msec_to_string (cputime_to_msecs (cputime). + */ +function cputime_to_string:string (cputime:long) +{ + return msecs_to_string (cputime_to_msecs (cputime)); +} + +/** + * sfunction task_time_string - Human readable string of task time usage. + * + * Description: Returns a human readable string showing the user and + * system time the current task has used up to now. For example + * "usr: 0m12.908s, sys: 1m6.851s". + */ +function task_time_string:string () +{ + return sprintf ("usr: %s, sys: %s", + cputime_to_string (task_utime()), + cputime_to_string (task_stime())); +} diff --git a/tapsets.cxx b/tapsets.cxx index 290a54da..5182bdd4 100644 --- a/tapsets.cxx +++ b/tapsets.cxx @@ -3693,7 +3693,7 @@ sdt_query::record_semaphore (vector<derived_probe *> & results, unsigned start) if (dwfl_module_relocations (dw.module) > 0) dwfl_module_relocate_address (dw.module, &addr); for (unsigned i = start; i < results.size(); ++i) - sess.sdt_semaphore_addr.insert(make_pair(results[i], addr)); + results[i]->sdt_semaphore_addr = addr; } } @@ -3876,6 +3876,9 @@ dwarf_builder::build(systemtap_session & sess, { module_name = find_executable (module_name); // canonicalize it + if (sess.kernel_config["CONFIG_UTRACE"] != string("y")) + throw semantic_error ("process probes not available without kernel CONFIG_UTRACE"); + // user-space target; we use one dwflpp instance per module name // (= program or shared library) dw = get_user_dw(sess, module_name); @@ -4454,10 +4457,9 @@ uprobe_derived_probe_group::emit_module_decls (systemtap_session& s) s.op->line() << " .pp=" << lex_cast_qstring (*p->sole_location()) << ","; s.op->line() << " .ph=&" << p->name << ","; - map<derived_probe*, Dwarf_Addr>::iterator its = s.sdt_semaphore_addr.find(p); - if (its != s.sdt_semaphore_addr.end()) + if (p->sdt_semaphore_addr != 0) s.op->line() << " .sdt_sem_address=(unsigned long)0x" - << hex << its->second << dec << "ULL,"; + << hex << p->sdt_semaphore_addr << dec << "ULL,"; if (p->has_return) s.op->line() << " .return_p=1,"; diff --git a/testsuite/buildok/task_test.stp b/testsuite/buildok/task_test.stp index 792f96ea..e391377f 100755 --- a/testsuite/buildok/task_test.stp +++ b/testsuite/buildok/task_test.stp @@ -18,5 +18,13 @@ probe begin { log(sprint(task_max_file_handles(c))) log(sprint(pid2task(pid()))) log(sprint(pid2execname(pid()))) + + // task_time.stp + log(task_time_string()) + log(cputime_to_string(0)) + log(msecs_to_string(0)) + log(sprint(cputime_to_msecs(0))) + log(sprint(task_stime())) + log(sprint(task_utime())) exit() } diff --git a/testsuite/buildok/utrace.stp b/testsuite/buildok/utrace.stp new file mode 100755 index 00000000..436bf9c4 --- /dev/null +++ b/testsuite/buildok/utrace.stp @@ -0,0 +1,3 @@ +#! stap -p4 + +probe %( CONFIG_UTRACE == "y" %? process.begin %: never %) { } diff --git a/testsuite/parseok/kconfig.stp b/testsuite/parseok/kconfig.stp new file mode 100755 index 00000000..02920853 --- /dev/null +++ b/testsuite/parseok/kconfig.stp @@ -0,0 +1,3 @@ +#! stap -p2 + +%( CONFIG_NO_SUCH_CONFIG == "" %? probe never {} %: %) diff --git a/testsuite/semko/utrace.stp b/testsuite/semko/utrace.stp new file mode 100755 index 00000000..5cc649e9 --- /dev/null +++ b/testsuite/semko/utrace.stp @@ -0,0 +1,3 @@ +#! stap -p2 + +probe %( CONFIG_UTRACE != "y" %? process.begin %: never %) { } diff --git a/testsuite/systemtap.examples/README b/testsuite/systemtap.examples/README index 89586ece..cf500c54 100644 --- a/testsuite/systemtap.examples/README +++ b/testsuite/systemtap.examples/README @@ -88,9 +88,11 @@ examples. Discussions take place on the system-wide or pid arg_[0-9]+: Describe what the arguments into the script are. (optional) description: A text description what the script does. (required) - test_check: How to check that the example compiles. + test_support: How to check that the example is applicable. Run by 'sh -c COMMAND'. + (e.g. stap -l needed.probe) + test_check: How to check that the example compiles. Run by 'sh -c COMMAND'. (e.g. stap -p4 iotime.stp) - test_installcheck: How to check that the example runs. + test_installcheck: How to check that the example runs. Run by 'sh -c COMMAND'. (e.g. stap iotime.stp -c "sleep 1") diff --git a/testsuite/systemtap.examples/check.exp b/testsuite/systemtap.examples/check.exp index 0fad597d..6e606718 100644 --- a/testsuite/systemtap.examples/check.exp +++ b/testsuite/systemtap.examples/check.exp @@ -25,10 +25,11 @@ proc get_meta_data { FILE } { proc extract_tag { META_DATA TAG } { set taglines "" set value "" - set expr "^$TAG:\[^\$\]*" + set expr "^$TAG: \[^\r\n\]*" regexp -line -all $expr $META_DATA taglines - set expr "$TAG:" + set expr "^$TAG: " regsub -line $expr $taglines "" value + verbose -log "meta taglines '$taglines' tag '$TAG' value '$value'" return $value } @@ -36,10 +37,7 @@ proc run_command { test action command } { #FIXME tcl says that single quotes not dealt with if { $command != "" } then { verbose -log "attempting command $command" - # Pipe both stdout and stderr to cat, otherwise any stderr - # output results in res being set to 1 (TCL_ERROR). This breaks - # scripts that have WARNINGS about for example skipped probes. - set res [catch {eval exec "$command |& cat"} value] + set res [catch {exec sh -c $command 2>@1} value] verbose -log "OUT $value" verbose -log "RC $res" if { $res != 0 } { # allow failure for support diff --git a/testsuite/systemtap.examples/general/para-callgraph.meta b/testsuite/systemtap.examples/general/para-callgraph.meta index 84d1c93f..32f56ef2 100644 --- a/testsuite/systemtap.examples/general/para-callgraph.meta +++ b/testsuite/systemtap.examples/general/para-callgraph.meta @@ -3,5 +3,5 @@ name: para-callgraph.stp keywords: trace callgraph subsystem: general description: Print a timed per-thread callgraph, complete with function parameters and return values. The first parameter names the function probe points to trace. The optional second parameter names the probe points for trigger functions, which acts to enable tracing for only those functions that occur while the current thread is nested within the trigger. -test_check: stap -p4 para-callgraph.stp kernel.function("*@fs/proc*.c") kernel.function("vfs_read") -test_installcheck: stap para-callgraph.stp kernel.function("*@fs/proc*.c") kernel.function("vfs_read") -c "cat /proc/sys/vm/*" +test_check: stap -p4 para-callgraph.stp 'kernel.function("*@fs/proc*.c")' 'kernel.function("vfs_read")' +test_installcheck: stap para-callgraph.stp 'kernel.function("*@fs/proc*.c")' 'kernel.function("vfs_read")' -c "cat /proc/sys/vm/*" diff --git a/testsuite/systemtap.examples/index.html b/testsuite/systemtap.examples/index.html index 66118bfc..f2b7066f 100644 --- a/testsuite/systemtap.examples/index.html +++ b/testsuite/systemtap.examples/index.html @@ -82,6 +82,9 @@ keywords: <a href="keyword-index.html#SYSCALL">SYSCALL</a> <a href="keyword-inde <li><a href="io/iotop.stp">io/iotop.stp</a> - Periodically Print I/O Activity by Process Name<br> keywords: <a href="keyword-index.html#IO">IO</a> <br> <p>Every five seconds print out the top ten executables generating I/O traffic during that interval sorted in descending order.</p></li> +<li><a href="io/mbrwatch.stp">io/mbrwatch.stp</a> - Monitor read/write of MBR (boot sector) area of block devices<br> +keywords: <a href="keyword-index.html#IO">IO</a> <a href="keyword-index.html#MONITORING">MONITORING</a> <br> +<p> The mbrwatch.stp script reports any attempted reads/writes of the first few sectors of a raw block device.</p></li> <li><a href="io/traceio.stp">io/traceio.stp</a> - Track Cumulative I/O Activity by Process Name<br> keywords: <a href="keyword-index.html#IO">IO</a> <br> <p>Every second print out the top ten executables sorted in descending order based on cumulative I/O traffic observed.</p></li> @@ -139,6 +142,9 @@ keywords: <a href="keyword-index.html#NETWORK">NETWORK</a> <a href="keyword-inde <li><a href="network/tcp_connections.stp">network/tcp_connections.stp</a> - Track Creation of Incoming TCP Connections<br> keywords: <a href="keyword-index.html#NETWORK">NETWORK</a> <a href="keyword-index.html#TCP">TCP</a> <a href="keyword-index.html#SOCKET">SOCKET</a> <br> <p>The tcp_connections.stp script prints information for each new incoming TCP connection accepted by the computer. The information includes the UID, the command accepting the connection, the PID of the command, the port the connection is on, and the IP address of the originator of the request.</p></li> +<li><a href="network/tcp_trace.stp">network/tcp_trace.stp</a> - Tcp connection tracing utility.<br> +keywords: <a href="keyword-index.html#NETWORK">NETWORK</a> <a href="keyword-index.html#TRACE">TRACE</a> <br> +<p>This scripts traces a given tcp connection based on the filter parameters given by the user. The indexing is done by the 4 tuples local address, remote address, local port, remote port.</p></li> <li><a href="network/tcpdumplike.stp">network/tcpdumplike.stp</a> - Dump of Received TCP Packets<br> keywords: <a href="keyword-index.html#NETWORK">NETWORK</a> <a href="keyword-index.html#TRAFFIC">TRAFFIC</a> <br> <p>The tcpdumplike.stp prints out a line for each TCP packet received. Each line includes the source and destination IP addresses, the source and destination ports, and flags.</p></li> diff --git a/testsuite/systemtap.examples/index.txt b/testsuite/systemtap.examples/index.txt index cb2b10d3..e880c746 100644 --- a/testsuite/systemtap.examples/index.txt +++ b/testsuite/systemtap.examples/index.txt @@ -130,6 +130,13 @@ keywords: io traffic during that interval sorted in descending order. +io/mbrwatch.stp - Monitor read/write of MBR (boot sector) area of block devices +keywords: io monitoring + + The mbrwatch.stp script reports any attempted reads/writes of the + first few sectors of a raw block device. + + io/traceio.stp - Track Cumulative I/O Activity by Process Name keywords: io @@ -317,6 +324,14 @@ keywords: network tcp socket originator of the request. +network/tcp_trace.stp - Tcp connection tracing utility. +keywords: network trace + + This scripts traces a given tcp connection based on the filter + parameters given by the user. The indexing is done by the 4 tuples + local address, remote address, local port, remote port. + + network/tcpdumplike.stp - Dump of Received TCP Packets keywords: network traffic diff --git a/testsuite/systemtap.examples/io/iostat-scsi.meta b/testsuite/systemtap.examples/io/iostat-scsi.meta index a5fe7a8f..6aa4c5d9 100644 --- a/testsuite/systemtap.examples/io/iostat-scsi.meta +++ b/testsuite/systemtap.examples/io/iostat-scsi.meta @@ -9,6 +9,6 @@ exit: user-controlled output: timed scope: system-wide description: The iostat-scsi.stp script provides a breakdown of the number of blks read and written on the machine's various SCSI devices. The script takes one argument which is the number of seconds between reports. -test_support: stap -l module("st").function("st_do_scsi")!,kernel.function("st_do_scsi") +test_support: stap -l 'module("st").function("st_do_scsi")!,kernel.function("st_do_scsi")' test_check: stap -g -p4 iostat-scsi.stp 1 test_installcheck: stap -g iostat-scsi.stp 1 -c "sleep 0.2" diff --git a/testsuite/systemtap.examples/io/mbrwatch.meta b/testsuite/systemtap.examples/io/mbrwatch.meta new file mode 100644 index 00000000..0ff88b13 --- /dev/null +++ b/testsuite/systemtap.examples/io/mbrwatch.meta @@ -0,0 +1,6 @@ +title: Monitor read/write of MBR (boot sector) area of block devices +name: mbrwatch.stp +keywords: io monitoring +description: The mbrwatch.stp script reports any attempted reads/writes of the first few sectors of a raw block device. +test_check: stap -p4 mbrwatch.stp +test_installcheck: stap mbrwatch.stp -c "dd of=/dev/null count=1 if=/dev/`grep -v major /proc/partitions | grep . | awk '{print $4}' | head -1`" diff --git a/testsuite/systemtap.examples/io/mbrwatch.stp b/testsuite/systemtap.examples/io/mbrwatch.stp new file mode 100755 index 00000000..f981073e --- /dev/null +++ b/testsuite/systemtap.examples/io/mbrwatch.stp @@ -0,0 +1,9 @@ +#! /usr/bin/env stap + +probe ioblock.request { + if (bdev==bdev_contains && sector<4) { + printf("device %s sector %d %s, process %s[%d]\n", + devname, sector, (rw==BIO_READ ? "read":"write"), execname(), pid()) + print_backtrace() + } +} diff --git a/testsuite/systemtap.examples/io/ttyspy.meta b/testsuite/systemtap.examples/io/ttyspy.meta index b190eafd..ea1c9040 100644 --- a/testsuite/systemtap.examples/io/ttyspy.meta +++ b/testsuite/systemtap.examples/io/ttyspy.meta @@ -2,5 +2,6 @@ title: Monitor tty typing. name: ttyspy.stp keywords: io tty per-process monitor description: The ttyspy.stp script uses tty_audit hooks to monitor recent typing activity on the system, printing a scrolling record of recent keystrokes, on a per-tty basis. +test_support: stap -l 'kernel.function("tty_audit_add_data")' test_check: stap -gp4 ttyspy.stp test_installcheck: stap --skip-badvars -g ttyspy.stp -c "sleep 1" diff --git a/testsuite/systemtap.examples/keyword-index.html b/testsuite/systemtap.examples/keyword-index.html index 2aad9adf..f09a20b3 100644 --- a/testsuite/systemtap.examples/keyword-index.html +++ b/testsuite/systemtap.examples/keyword-index.html @@ -39,7 +39,7 @@ </ul> <h2>Examples by Keyword</h2> -<p><tt><a href="#AUTOFS">AUTOFS</a> <a href="#BACKTRACE">BACKTRACE</a> <a href="#BUFFER">BUFFER</a> <a href="#CALLGRAPH">CALLGRAPH</a> <a href="#CPU">CPU</a> <a href="#DEVICE">DEVICE</a> <a href="#DISK">DISK</a> <a href="#FILESYSTEM">FILESYSTEM</a> <a href="#FORMAT">FORMAT</a> <a href="#FREE">FREE</a> <a href="#FUNCTIONS">FUNCTIONS</a> <a href="#FUTEX">FUTEX</a> <a href="#GRAPH">GRAPH</a> <a href="#HACK">HACK</a> <a href="#INTERRUPT">INTERRUPT</a> <a href="#IO">IO</a> <a href="#LOCKING">LOCKING</a> <a href="#MEMORY">MEMORY</a> <a href="#MONITOR">MONITOR</a> <a href="#NETWORK">NETWORK</a> <a href="#NFS">NFS</a> <a href="#NUMA">NUMA</a> <a href="#PER-PROCESS">PER-PROCESS</a> <a href="#PROCESS">PROCESS</a> <a href="#PROFILING">PROFILING</a> <a href="#READ">READ</a> <a href="#SCHEDULER">SCHEDULER</a> <a href="#SCSI">SCSI</a> <a href="#SIGNALS">SIGNALS</a> <a href="#SIMPLE">SIMPLE</a> <a href="#SLEEP">SLEEP</a> <a href="#SOCKET">SOCKET</a> <a href="#STATISTICS">STATISTICS</a> <a href="#SYSCALL">SYSCALL</a> <a href="#TCP">TCP</a> <a href="#TIME">TIME</a> <a href="#TRACE">TRACE</a> <a href="#TRACEPOINT">TRACEPOINT</a> <a href="#TRAFFIC">TRAFFIC</a> <a href="#TTY">TTY</a> <a href="#USE">USE</a> <a href="#WAIT4">WAIT4</a> <a href="#WRITE">WRITE</a> </tt></p> +<p><tt><a href="#AUTOFS">AUTOFS</a> <a href="#BACKTRACE">BACKTRACE</a> <a href="#BUFFER">BUFFER</a> <a href="#CALLGRAPH">CALLGRAPH</a> <a href="#CPU">CPU</a> <a href="#DEVICE">DEVICE</a> <a href="#DISK">DISK</a> <a href="#FILESYSTEM">FILESYSTEM</a> <a href="#FORMAT">FORMAT</a> <a href="#FREE">FREE</a> <a href="#FUNCTIONS">FUNCTIONS</a> <a href="#FUTEX">FUTEX</a> <a href="#GRAPH">GRAPH</a> <a href="#HACK">HACK</a> <a href="#INTERRUPT">INTERRUPT</a> <a href="#IO">IO</a> <a href="#LOCKING">LOCKING</a> <a href="#MEMORY">MEMORY</a> <a href="#MONITOR">MONITOR</a> <a href="#MONITORING">MONITORING</a> <a href="#NETWORK">NETWORK</a> <a href="#NFS">NFS</a> <a href="#NUMA">NUMA</a> <a href="#PER-PROCESS">PER-PROCESS</a> <a href="#PROCESS">PROCESS</a> <a href="#PROFILING">PROFILING</a> <a href="#READ">READ</a> <a href="#SCHEDULER">SCHEDULER</a> <a href="#SCSI">SCSI</a> <a href="#SIGNALS">SIGNALS</a> <a href="#SIMPLE">SIMPLE</a> <a href="#SLEEP">SLEEP</a> <a href="#SOCKET">SOCKET</a> <a href="#STATISTICS">STATISTICS</a> <a href="#SYSCALL">SYSCALL</a> <a href="#TCP">TCP</a> <a href="#TIME">TIME</a> <a href="#TRACE">TRACE</a> <a href="#TRACEPOINT">TRACEPOINT</a> <a href="#TRAFFIC">TRAFFIC</a> <a href="#TTY">TTY</a> <a href="#USE">USE</a> <a href="#WAIT4">WAIT4</a> <a href="#WRITE">WRITE</a> </tt></p> <h3><a name="AUTOFS">AUTOFS</a></h3> <ul> <li><a href="network/autofs4.stp">network/autofs4.stp</a> - Watch autofs4 operations<br> @@ -168,6 +168,9 @@ keywords: <a href="keyword-index.html#SYSCALL">SYSCALL</a> <a href="keyword-inde <li><a href="io/iotop.stp">io/iotop.stp</a> - Periodically Print I/O Activity by Process Name<br> keywords: <a href="keyword-index.html#IO">IO</a> <br> <p>Every five seconds print out the top ten executables generating I/O traffic during that interval sorted in descending order.</p></li> +<li><a href="io/mbrwatch.stp">io/mbrwatch.stp</a> - Monitor read/write of MBR (boot sector) area of block devices<br> +keywords: <a href="keyword-index.html#IO">IO</a> <a href="keyword-index.html#MONITORING">MONITORING</a> <br> +<p> The mbrwatch.stp script reports any attempted reads/writes of the first few sectors of a raw block device.</p></li> <li><a href="io/traceio.stp">io/traceio.stp</a> - Track Cumulative I/O Activity by Process Name<br> keywords: <a href="keyword-index.html#IO">IO</a> <br> <p>Every second print out the top ten executables sorted in descending order based on cumulative I/O traffic observed.</p></li> @@ -226,6 +229,12 @@ keywords: <a href="keyword-index.html#NETWORK">NETWORK</a> <a href="keyword-inde keywords: <a href="keyword-index.html#IO">IO</a> <a href="keyword-index.html#TTY">TTY</a> <a href="keyword-index.html#PER-PROCESS">PER-PROCESS</a> <a href="keyword-index.html#MONITOR">MONITOR</a> <br> <p>The ttyspy.stp script uses tty_audit hooks to monitor recent typing activity on the system, printing a scrolling record of recent keystrokes, on a per-tty basis.</p></li> </ul> +<h3><a name="MONITORING">MONITORING</a></h3> +<ul> +<li><a href="io/mbrwatch.stp">io/mbrwatch.stp</a> - Monitor read/write of MBR (boot sector) area of block devices<br> +keywords: <a href="keyword-index.html#IO">IO</a> <a href="keyword-index.html#MONITORING">MONITORING</a> <br> +<p> The mbrwatch.stp script reports any attempted reads/writes of the first few sectors of a raw block device.</p></li> +</ul> <h3><a name="NETWORK">NETWORK</a></h3> <ul> <li><a href="network/autofs4.stp">network/autofs4.stp</a> - Watch autofs4 operations<br> @@ -249,6 +258,9 @@ keywords: <a href="keyword-index.html#NETWORK">NETWORK</a> <a href="keyword-inde <li><a href="network/tcp_connections.stp">network/tcp_connections.stp</a> - Track Creation of Incoming TCP Connections<br> keywords: <a href="keyword-index.html#NETWORK">NETWORK</a> <a href="keyword-index.html#TCP">TCP</a> <a href="keyword-index.html#SOCKET">SOCKET</a> <br> <p>The tcp_connections.stp script prints information for each new incoming TCP connection accepted by the computer. The information includes the UID, the command accepting the connection, the PID of the command, the port the connection is on, and the IP address of the originator of the request.</p></li> +<li><a href="network/tcp_trace.stp">network/tcp_trace.stp</a> - Tcp connection tracing utility.<br> +keywords: <a href="keyword-index.html#NETWORK">NETWORK</a> <a href="keyword-index.html#TRACE">TRACE</a> <br> +<p>This scripts traces a given tcp connection based on the filter parameters given by the user. The indexing is done by the 4 tuples local address, remote address, local port, remote port.</p></li> <li><a href="network/tcpdumplike.stp">network/tcpdumplike.stp</a> - Dump of Received TCP Packets<br> keywords: <a href="keyword-index.html#NETWORK">NETWORK</a> <a href="keyword-index.html#TRAFFIC">TRAFFIC</a> <br> <p>The tcpdumplike.stp prints out a line for each TCP packet received. Each line includes the source and destination IP addresses, the source and destination ports, and flags.</p></li> @@ -435,6 +447,9 @@ keywords: <a href="keyword-index.html#PROCESS">PROCESS</a> <a href="keyword-inde <li><a href="general/para-callgraph.stp">general/para-callgraph.stp</a> - Callgraph tracing with arguments<br> keywords: <a href="keyword-index.html#TRACE">TRACE</a> <a href="keyword-index.html#CALLGRAPH">CALLGRAPH</a> <br> <p>Print a timed per-thread callgraph, complete with function parameters and return values. The first parameter names the function probe points to trace. The optional second parameter names the probe points for trigger functions, which acts to enable tracing for only those functions that occur while the current thread is nested within the trigger.</p></li> +<li><a href="network/tcp_trace.stp">network/tcp_trace.stp</a> - Tcp connection tracing utility.<br> +keywords: <a href="keyword-index.html#NETWORK">NETWORK</a> <a href="keyword-index.html#TRACE">TRACE</a> <br> +<p>This scripts traces a given tcp connection based on the filter parameters given by the user. The indexing is done by the 4 tuples local address, remote address, local port, remote port.</p></li> </ul> <h3><a name="TRACEPOINT">TRACEPOINT</a></h3> <ul> diff --git a/testsuite/systemtap.examples/keyword-index.txt b/testsuite/systemtap.examples/keyword-index.txt index 01661cf1..853198d3 100644 --- a/testsuite/systemtap.examples/keyword-index.txt +++ b/testsuite/systemtap.examples/keyword-index.txt @@ -273,6 +273,13 @@ keywords: io traffic during that interval sorted in descending order. +io/mbrwatch.stp - Monitor read/write of MBR (boot sector) area of block devices +keywords: io monitoring + + The mbrwatch.stp script reports any attempted reads/writes of the + first few sectors of a raw block device. + + io/traceio.stp - Track Cumulative I/O Activity by Process Name keywords: io @@ -441,6 +448,15 @@ keywords: io tty per-process monitor keystrokes, on a per-tty basis. += MONITORING = + +io/mbrwatch.stp - Monitor read/write of MBR (boot sector) area of block devices +keywords: io monitoring + + The mbrwatch.stp script reports any attempted reads/writes of the + first few sectors of a raw block device. + + = NETWORK = network/autofs4.stp - Watch autofs4 operations @@ -503,6 +519,14 @@ keywords: network tcp socket originator of the request. +network/tcp_trace.stp - Tcp connection tracing utility. +keywords: network trace + + This scripts traces a given tcp connection based on the filter + parameters given by the user. The indexing is done by the 4 tuples + local address, remote address, local port, remote port. + + network/tcpdumplike.stp - Dump of Received TCP Packets keywords: network traffic @@ -974,6 +998,14 @@ keywords: trace callgraph the trigger. +network/tcp_trace.stp - Tcp connection tracing utility. +keywords: network trace + + This scripts traces a given tcp connection based on the filter + parameters given by the user. The indexing is done by the 4 tuples + local address, remote address, local port, remote port. + + = TRACEPOINT = network/dropwatch.stp - Watch Where Socket Buffers are Freed in the Kernel diff --git a/testsuite/systemtap.examples/locks/bkl.meta b/testsuite/systemtap.examples/locks/bkl.meta index 61bd4eb7..dd467fe7 100644 --- a/testsuite/systemtap.examples/locks/bkl.meta +++ b/testsuite/systemtap.examples/locks/bkl.meta @@ -6,5 +6,6 @@ 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_support: stap -l 'kernel.function("lock_kernel").return' test_check: stap -p4 bkl.stp 1 test_installcheck: stap bkl.stp -c "sleep 0.2" 1 diff --git a/testsuite/systemtap.examples/locks/bkl_stats.meta b/testsuite/systemtap.examples/locks/bkl_stats.meta index 6db6c72f..16ac2911 100644 --- a/testsuite/systemtap.examples/locks/bkl_stats.meta +++ b/testsuite/systemtap.examples/locks/bkl_stats.meta @@ -9,5 +9,6 @@ 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_support: stap -l 'kernel.function("lock_kernel").return' test_check: stap -p4 bkl_stats.stp test_installcheck: stap bkl_stats.stp -c "sleep 0.2" diff --git a/testsuite/systemtap.examples/memory/mmanonpage.meta b/testsuite/systemtap.examples/memory/mmanonpage.meta index eb2e9f57..96ddd3a3 100644 --- a/testsuite/systemtap.examples/memory/mmanonpage.meta +++ b/testsuite/systemtap.examples/memory/mmanonpage.meta @@ -9,6 +9,6 @@ exit: user-controlled output: sorted-list scope: system-wide description: The mmanonpage.stp script uses the virtual memory tracepoints available in some kernels to track the number of faults, user space frees, page ins, copy on writes and unmaps for anonymous pages. When the script is terminated the counts are printed for each process that allocated pages while the script was running. This script displays the anonymous page statistics for each process that ran while the script is active. Its useful in debugging leaks in the anonymous regions of a process. -test_support: stap -l kernel.trace("mm_page_allocation"),kernel.trace("mm_page_free"),kernel.trace("mm_anon_fault"),kernel.trace("mm_anon_pgin"),kernel.trace("mm_anon_cow"),kernel.trace("mm_anon_unmap"),kernel.trace("mm_anon_userfree") +test_support: stap -l 'kernel.trace("mm_page_allocation"),kernel.trace("mm_page_free"),kernel.trace("mm_anon_fault"),kernel.trace("mm_anon_pgin"),kernel.trace("mm_anon_cow"),kernel.trace("mm_anon_unmap"),kernel.trace("mm_anon_userfree")' test_check: stap -p4 mmanonpage.stp test_installcheck: stap mmanonpage.stp -c "sleep 0.2" diff --git a/testsuite/systemtap.examples/memory/mmfilepage.meta b/testsuite/systemtap.examples/memory/mmfilepage.meta index c26f0601..bc0e0429 100644 --- a/testsuite/systemtap.examples/memory/mmfilepage.meta +++ b/testsuite/systemtap.examples/memory/mmfilepage.meta @@ -9,6 +9,6 @@ exit: user-controlled output: sorted-list scope: system-wide description: The mmfilepage.stp script uses the virtual memory tracepoints available in some kernels to track the number of faults, copy on writes mapping, and unmapping operations for file backed pages. When the script is terminated the counts are printed for each process that allocated pages while the script was running. The mmfilepage.stp script is useful in debugging leaks in the mapped file regions of a process. -test_support: stap -l kernel.trace("mm_page_allocation"),kernel.trace("mm_page_free"),kernel.trace("mm_filemap_fault"),kernel.trace("mm_filemap_cow"),kernel.trace("mm_filemap_unmap"),kernel.trace("mm_filemap_userunmap") +test_support: stap -l 'kernel.trace("mm_page_allocation"),kernel.trace("mm_page_free"),kernel.trace("mm_filemap_fault"),kernel.trace("mm_filemap_cow"),kernel.trace("mm_filemap_unmap"),kernel.trace("mm_filemap_userunmap")' test_check: stap -p4 mmfilepage.stp test_installcheck: stap mmfilepage.stp -c "sleep 0.2" diff --git a/testsuite/systemtap.examples/memory/mmreclaim.meta b/testsuite/systemtap.examples/memory/mmreclaim.meta index c301d302..4b5c9de2 100644 --- a/testsuite/systemtap.examples/memory/mmreclaim.meta +++ b/testsuite/systemtap.examples/memory/mmreclaim.meta @@ -9,6 +9,6 @@ exit: user-controlled output: sorted-list scope: system-wide description: The mmreclaim.stp script uses the virtual memory tracepoints available in some kernels to track page reclaim activity that occurred while the script was running. Its useful is debugging performance problems that occur due to page reclamation. -test_support: stap -l kernel.trace("mm_directreclaim_reclaimall"),kernel.trace("mm_pagereclaim_shrinkinactive"),kernel.trace("mm_pagereclaim_free"),kernel.trace("mm_pagereclaim_pgout"),kernel.trace("mm_pagereclaim_shrinkactive_a2a"),kernel.trace("mm_pagereclaim_shrinkinactive_i2a"),kernel.trace("mm_pagereclaim_shrinkactive_a2i"),kernel.trace("mm_pagereclaim_shrinkinactive_i2i") +test_support: stap -l 'kernel.trace("mm_directreclaim_reclaimall"),kernel.trace("mm_pagereclaim_shrinkinactive"),kernel.trace("mm_pagereclaim_free"),kernel.trace("mm_pagereclaim_pgout"),kernel.trace("mm_pagereclaim_shrinkactive_a2a"),kernel.trace("mm_pagereclaim_shrinkinactive_i2a"),kernel.trace("mm_pagereclaim_shrinkactive_a2i"),kernel.trace("mm_pagereclaim_shrinkinactive_i2i")' test_check: stap -p4 mmreclaim.stp test_installcheck: stap mmreclaim.stp -c "sleep 0.2" diff --git a/testsuite/systemtap.examples/memory/mmwriteback.meta b/testsuite/systemtap.examples/memory/mmwriteback.meta index dbcaa476..76cc53a7 100644 --- a/testsuite/systemtap.examples/memory/mmwriteback.meta +++ b/testsuite/systemtap.examples/memory/mmwriteback.meta @@ -9,6 +9,6 @@ exit: user-controlled output: sorted-list scope: system-wide description: The mmwriteback.stp script uses the virtual memory tracepoints available in some kernels to report all of the file writebacks that occur form kupdate, pdflush and kjournald while the script is running. Its useful in determining where writes are coming from on a supposedly idle system that is experiencing unexpected IO. -test_support: stap -l kernel.trace("mm_pdflush_bgwriteout"),kernel.trace("mm_pdflush_kupdate"),kernel.trace("mm_pagereclaim_pgout") +test_support: stap -l 'kernel.trace("mm_pdflush_bgwriteout"),kernel.trace("mm_pdflush_kupdate"),kernel.trace("mm_pagereclaim_pgout")' test_check: stap -p4 mmwriteback.stp test_installcheck: stap mmwriteback.stp -c "sleep 0.2" diff --git a/testsuite/systemtap.examples/network/autofs4.meta b/testsuite/systemtap.examples/network/autofs4.meta index e0036481..4c721abf 100644 --- a/testsuite/systemtap.examples/network/autofs4.meta +++ b/testsuite/systemtap.examples/network/autofs4.meta @@ -4,6 +4,6 @@ name: autofs4.stp author: Jeff Moyer keywords: network autofs nfs subsystem: network -test_support: stap -l module("autofs4").function("autofs4_lookup"),module("autofs4").function("autofs4_follow_link"),module("autofs4").function("autofs4_expire_indirect").return,module("autofs4").function("autofs4_wait").return +test_support: stap -l 'module("autofs4").function("autofs4_lookup"),module("autofs4").function("autofs4_follow_link"),module("autofs4").function("autofs4_expire_indirect").return,module("autofs4").function("autofs4_wait").return' test_check: stap -p4 autofs4.stp test_installcheck: stap autofs4.stp -c "sleep 1" diff --git a/testsuite/systemtap.examples/network/dropwatch.meta b/testsuite/systemtap.examples/network/dropwatch.meta index 06d338c5..b75e3d33 100644 --- a/testsuite/systemtap.examples/network/dropwatch.meta +++ b/testsuite/systemtap.examples/network/dropwatch.meta @@ -9,6 +9,6 @@ exit: user-controlled output: timed scope: system-wide description: Every five seconds the dropwatch.stp script lists the number of socket buffers freed at locations in the kernel. -test_support: stap -l kernel.trace("kfree_skb") +test_support: stap -l 'kernel.trace("kfree_skb")' test_check: stap -p4 dropwatch.stp test_installcheck: stap dropwatch.stp -c "sleep 0.2" diff --git a/testsuite/systemtap.examples/network/tcp_trace.meta b/testsuite/systemtap.examples/network/tcp_trace.meta new file mode 100644 index 00000000..2783c89b --- /dev/null +++ b/testsuite/systemtap.examples/network/tcp_trace.meta @@ -0,0 +1,14 @@ +title: Tcp connection tracing utility. +name: tcp_trace.stp +version: 1.0 +author: varuncha@in.ibm.com wilder@us.ibm.com +keywords: network trace +subsystem: network +status: production +exit: user-controlled +output: timed +scope: per-socket +arg_[0-9]+: tcp_trace.stp filter=all|state|txq|rxq|srtt|snd_cwnd|snd_wnd|rexmit|pmtu|ssthresh|timer|rcvwnd [timeout=<sec>] [update=change|all] Rule +description: This scripts traces a given tcp connection based on the filter parameters given by the user. The indexing is done by the 4 tuples local address, remote address, local port, remote port. +test_check: stap -p4 tcp_trace.stp +test_installcheck: stap tcp_trace.stp 127.0.0.1:*-127.0.0.1:* timeout=1 diff --git a/testsuite/systemtap.examples/network/tcp_trace.stp b/testsuite/systemtap.examples/network/tcp_trace.stp new file mode 100755 index 00000000..4763b386 --- /dev/null +++ b/testsuite/systemtap.examples/network/tcp_trace.stp @@ -0,0 +1,744 @@ +#! /usr/bin/env stap +/* + * 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 0.1 wilder@us.ibm.com 2009-05-13 + * Version 0.3 varuncha@in.ibm.com 2009-05-20 + * Version 1.0 wilder@us.ibm.com 2009-09-24 + * Version 1.1 wilder@us.ibm.com 2009-10-08 + * + * Tcp connection tracing utility. + * + * Description: + * This script traces tcp connections and displays connection parameters. + * The filter option specifies what parameters are to be displayed. Address + * "rules" must be supplied to limit what connections are to be traced. + * + * Synopsis: + * tcp_trace.stp [filter=all|state|txq|rxq|srtt|snd_cwnd|snd_wnd|rexmit\ + * |pmtu|ssthresh|timer|rcvwnd|length]\ + * [timeout=<N sec>]\ + * [update=change|all]\ + * + * Rule format: + * <local ip-address>:<local-port>-<remote ip-address>:<remote-port> + * + * filter tcp_trace collects the socket state and other connection + * parameters from various probe points in the tcp stack; however, + * not all this data may needed when debugging a tcp problem. + * Specifying only the required parameters reduces analysis time. + * Multiple parameters can be specified by using + * ','. + * + * timeout (optional) When a timeout value (in seconds) is specified + * tcp_trace will automatically terminate it's run at the end of + * the specified time. By default the script will run until the + * user terminates it by typing a ^c. + * + * update (optional) By default the script only displays data if there + * is a value change in a parameters specified in the "filter". + * This can be changed by specifying "update=all", which will + * output parameters of every packet that hits the probe. + * Note: Changes to the packet length will not trigger an update. + * + * Rules Rules limit what connections will be traced. Multiple rules may + * be given separated by a space. A wild-card value can be used + * for any component of the filter. Rules can be used to limit + * tracing to a single socket or allow many sockets to be traced. + * Memory consumed by the tracer will increase with the number + * of connections being traced. + * + * The Rule Format is: + * <local-address>:<local-port>-<remote address>:<remote-port> + * + * -Address are specified as ipv4 dot notation address. + * -Ports are specified as decimal numbers. + * + * "*" character can be used in any field to indicate a wild-card + * value. + * + * Note: The number of active sockets that can be traced is + * limited by MAXMAPENTRIES. + * + * Examples: + * Here are some examples of using tcp_trace: + * + * Trace TCP connection from 172.16.15.160 to 172.16.15.1 on + * port 22 with state,txq,rxq,pmtu filter. + * + * tcp_trace.stp filter=state,txq,rxq,pmtu timeout=100\ + * 172.16.15.160:*-172.16.15.1:22 + * + * Trace TCP connection from any address to the local http server. + * all parameters are displayed for every packet. + * + * tcp_trace.stp filter=all update=all *.*.*.*:*-*.*.*.*:80 + */ + +global tcp_state; +global timer_info; + +global filter; +global key_list; +global lastkey; +global number_of_rules; + +global timeout = -1; +global always_update; + +global snd_cwnd_flg; +global snd_cwnd; + +global snd_wnd_flg; +global snd_wnd; + +global srtt_flg; +global srtt; + +global state_flg; +global state; + +global txq_flg; +global txq; + +global rxq_flg; +global rxq; + +global rexmit_flg; +global rexmit; + +global pmtu_flg; +global pmtu; + +global ssthresh_flg; +global ssthresh; + +global timer_flg; +global tx_timer; +global find_timer; + +global rcvwnd_flg; +global rcvwnd; + +global length_flg; +global length; + +probe begin +{ + number_of_rules = process_cmdline() + + if ( number_of_rules < 1) + usage("One or more connection rules must be specified!") + if ( number_of_rules < 0 ) + usage("Incorrect connection rule format!") + + init_tcp_state() + init_timer_info() + + printf("Start TCP Probing.....\n\n"); + print_header(); +} + +function init_tcp_state () +{ + tcp_state[1] = "ESTABLISHED" + tcp_state[2] = "SYN_SENT" + tcp_state[3] = "SYN_RECV" + tcp_state[4] = "FIN_WAIT1" + tcp_state[5] = "FIN_WAIT2" + tcp_state[6] = "TIME_WAIT" + tcp_state[7] = "CLOSE" + tcp_state[8] = "CLOSE_WAIT" + tcp_state[9] = "LAST_ACK" + tcp_state[10] = "LISTEN" + tcp_state[11] = "CLOSING" +} + +function state_num2str:string ( state:long ) +{ + return (state in tcp_state ? tcp_state[state] : "UNDEF") +} + +function init_timer_info () +{ + timer_info[0] = "" + timer_info[1] = "Rxmit" + timer_info[2] = "Delack" + timer_info[3] = "Probe" + timer_info[4] = "Keepalv" +} + +function timer_info_num2str:string ( timer:long ) +{ + return (timer in timer_info ? timer_info[timer] : "UNDEF") +} + +probe kernel.function("tcp_rcv_established"), + kernel.function("tcp_rcv_state_process") +{ + sk = $sk + key = filter_key(sk) + if ( !key ) next; + + if ( is_packet_updated(key,sk) ) { + length[key] = $skb->len; + print_packet_info(key, 0) + } +} + +probe kernel.function("tcp_transmit_skb") +{ + sk = $sk + key = filter_key(sk) + if ( !key ) next; + + if ( is_packet_updated(key,sk) ) { + length[key] = $skb->len; + print_packet_info(key, 1) + } +} + +probe kernel.function("tcp_keepalive_timer") +{ + if ( !timer_flg ) next; + + sk = $data; + key = filter_key(sk) + if ( !key ) next; + + is_packet_updated(key,sk) + length[key] = 0 + tx_timer[key] = 4; + print_packet_info(key, 1) + tx_timer[key] = 0; +} + +probe kernel.function("tcp_delack_timer") +{ + if ( !timer_flg ) next; + + sk = $data; + key = filter_key(sk) + if ( !key ) next; + + is_packet_updated(key,sk) + length[key] = 0 + tx_timer[key] = 2; + print_packet_info(key, 1) + tx_timer[key] = 0; +} + +probe kernel.function("tcp_send_probe0") +{ + if ( !timer_flg ) next; + + sk = $sk + key = filter_key(sk) + if ( !key ) next; + + if ( find_timer[key] == 3 ) { + find_timer[key] = 0 + tx_timer[key] = 3; + is_packet_updated(key,sk) + length[key] = 0 + print_packet_info(key, 1) + tx_timer[key] = 0; + } +} + +probe kernel.function("tcp_retransmit_skb") +{ + if ( !timer_flg ) next; + + sk = $sk; + key = filter_key(sk) + if ( !key ) next; + + if ( find_timer[key] == 1 ) { + find_timer[key] = 0 + tx_timer[key] = 1; + is_packet_updated(key,sk) + length[key] = $skb->len + print_packet_info(key,1) + tx_timer[key] = 0; + } +} + +probe kernel.function("tcp_write_timer") +{ + if ( !timer_flg ) next; + + sk = $data + key = filter_key(sk) + if ( !key ) next; + + /* Don't trace calls to tcp_retransmit_skb() + * or tcp_send_probe0 that were not the result of a + * write timer expiration. + */ + find_timer[key] = @cast(sk, "inet_connection_sock")->icsk_pending +} + +probe kernel.function("tcp_set_state") +{ + sk = $sk + new_state = $state + TCP_CLOSE = 7 + TCP_CLOSE_WAIT = 8 + key = filter_key(sk) + if ( key && ((new_state == TCP_CLOSE)||(new_state == TCP_CLOSE_WAIT))){ + if (state_flg && state[key]) print_close(key,new_state); + clean_up(key); + } +} + +function print_header() +{ + printf("%-22s","Source Address") + printf("%-22s","Dest Address") + if (state_flg) printf("%-12s","State") + if (timer_flg) printf("%-8s","Timer") + if (txq_flg) printf("%8s","Tx-Q") + if (rxq_flg) printf("%8s","Rx-Q") + if (pmtu_flg) printf("%8s","PMTU") + if (snd_cwnd_flg) printf("%8s","SndCwnd") + if (snd_wnd_flg) printf("%8s","SndWnd") + if (rcvwnd_flg) printf("%8s","RcvWnd") + if (srtt_flg) printf("%8s","SSRT") + if (ssthresh_flg) printf("%14s","Ssthreshold") + if (rexmit_flg) printf("%8s","Rexmit") + if (length_flg) printf("%8s","Length") + printf("\n"); +} + +function print_packet_info:long ( key:long, SourceIsLocal:long) +{ + foreach ( [laddr, raddr, lport, rport] in key_list ){ + if ( key_list[laddr, raddr, lport, rport] == key ) + break + } + + local_addr = sprintf("%s:%d",ip_ntop(htonl(laddr)), lport) + remote_addr = sprintf("%s:%d",ip_ntop(htonl(raddr)) ,rport) + + SourceIsLocal ? printf("%-22s%-22s",local_addr,remote_addr): + printf("%-22s%-22s",remote_addr,local_addr) + + if (state_flg) printf("%-12s",state_num2str(state[key])) + if (timer_flg) printf("%-8s",timer_info_num2str(tx_timer[key])) + if (txq_flg) printf("%8d",txq[key]) + if (rxq_flg) printf("%8d",rxq[key]) + if (pmtu_flg) printf("%8d",pmtu[key]) + if (snd_cwnd_flg) printf("%8d",snd_cwnd[key]) + if (snd_wnd_flg) printf("%8d",snd_wnd[key]) + if (rcvwnd_flg) printf("%8d",rcvwnd[key]) + if (srtt_flg) printf("%8d",srtt[key]) + if (ssthresh_flg) printf("%14d",ssthresh[key]) + if (rexmit_flg) printf("%8d",rexmit[key]) + if (length_flg && length[key]) printf("%8d", length[key]) + printf("\n"); +} + +function print_close:long (key:long, new_state:long) +{ + foreach ( [laddr, raddr, lport, rport] in key_list ){ + if ( key_list[laddr, raddr, lport, rport] == key ) + break + } + + local_addr = sprintf("%s:%d",ip_ntop(htonl(laddr)), lport) + remote_addr = sprintf("%s:%d",ip_ntop(htonl(raddr)) ,rport) + + printf("%-22s%-22s",local_addr,remote_addr) + printf("%-12s",state_num2str(new_state)) + printf("\n"); +} + +/* + * Update the values in the data collection arrays, returns 1 if one or more + * values have changed. + */ +function is_packet_updated:long ( key:long, sk:long ) +{ + packet_updated = 0 + + if ( !key ) return 0 + + if ( state_flg ) { + new_state = @cast(sk, "sock_common")->skc_state + if( always_update || (state[key] != new_state) ){ + state[key]= new_state + packet_updated = 1 + } + } + + if ( txq_flg ) { + if(@cast(sk, "sock_common")->skc_state == 10) + new_txq = @cast(sk, "sock")->sk_max_ack_backlog + else + new_txq = @cast(sk, "tcp_sock")->write_seq - + @cast(sk, "tcp_sock")->snd_una + if( always_update || (txq[key] != new_txq) ){ + txq[key] = new_txq + packet_updated = 1 + } + } + + if ( rxq_flg ) { + if(@cast(sk, "sock_common")->skc_state == 10) + new_rxq = @cast(sk, "sock")->sk_ack_backlog + else + new_rxq = @cast(sk, "tcp_sock")->rcv_nxt - + @cast(sk, "tcp_sock")->copied_seq + + if( always_update || (rxq[key] != new_rxq) ){ + rxq[key] = new_rxq + packet_updated = 1 + } + } + + if( rexmit_flg ) { + new_rexmit = @cast(sk, "inet_connection_sock")->icsk_retransmits + if( always_update || (rexmit[key] != new_rexmit ) ){ + rexmit[key] = new_rexmit + packet_updated = 1 + } + } + + if ( pmtu_flg ) { + new_pmtu = @cast(sk, "inet_connection_sock")->icsk_pmtu_cookie + if( always_update || (pmtu[key] != new_pmtu) ){ + pmtu[key] = new_pmtu + packet_updated = 1 + } + } + + if ( snd_cwnd_flg ) { + new_snd_cwnd = @cast(sk, "tcp_sock")->snd_cwnd + if( always_update || (snd_cwnd[key] != new_snd_cwnd) ){ + snd_cwnd[key] = new_snd_cwnd + packet_updated = 1 + } + } + + + if ( snd_wnd_flg ) { + new_snd_wnd = @cast(sk, "tcp_sock")->snd_wnd + if( always_update || (snd_wnd[key] != new_snd_wnd) ){ + snd_wnd[key] = new_snd_wnd + packet_updated = 1 + } + } + + if ( srtt_flg ) { + new_srtt = @cast(sk, "tcp_sock")->srtt + if( always_update || (srtt[key] != new_srtt) ){ + srtt[key] = new_srtt + packet_updated = 1 + } + } + + if( ssthresh_flg ) { + new_ssthresh = tcp_current_ssthresh(sk) + if( always_update || (ssthresh[key] != new_ssthresh) ){ + ssthresh[key] = new_ssthresh + packet_updated = 1 + } + } + + if ( rcvwnd_flg ) { + new_rcvwnd = @cast(sk, "tcp_sock")->rcv_wnd + if( always_update || (rcvwnd[key] != new_rcvwnd) ){ + rcvwnd[key] = new_rcvwnd + packet_updated = 1 + } + } + + return packet_updated +} + +/* + * copied from: + * include/net/tcp.h:tcp_current_ssthresh() + */ +function tcp_current_ssthresh(sk:long) +{ + if ((1 << @cast(sk, "inet_connection_sock")->icsk_ca_state) & + ((1 << 2) | (1 << 3))){ + return @cast(sk, "tcp_sock")->snd_ssthresh + }else{ + return netmax(@cast(sk, "tcp_sock")->snd_ssthresh, + ((@cast(sk, "tcp_sock")->snd_cwnd >>1)+ + (@cast(sk, "tcp_sock")->snd_cwnd >> 2))) + } +} + +function netmax:long (val1:long, val2:long) +{ + if(val1 > val2) + return val1 + else + return val2 +} + +/* All command line arguments other than the address rules are processed + * first and must be placed on the command line prior to any address rules. + */ +function process_cmdline:long () +{ + filter_number = 0 + for (i=1; i <= argc; i++) { + argument = tokenize(argv[i], "=") + + if (argument == "help") + usage("") + + if (argument == "filter") { + filter_given=1; + argv[i]="" + while(strlen(byte = tokenize(argv[i], ",")) != 0) { + argv[i] = "" + if ( byte == "snd_cwnd" ) { + snd_cwnd_flg = 1; continue }; + if ( byte == "snd_wnd" ) { + snd_wnd_flg = 1; continue }; + if ( byte == "srtt" ) { + srtt_flg = 1; continue }; + if ( byte == "state" ) { + state_flg = 1; continue }; + if ( byte == "txq" ) { + txq_flg = 1; continue }; + if ( byte == "rxq" ) { + rxq_flg = 1; continue }; + if ( byte == "rexmit" ) { + rexmit_flg = 1; continue }; + if ( byte == "pmtu" ) { + pmtu_flg = 1; continue }; + if ( byte == "ssthresh" ) { + ssthresh_flg = 1; continue }; + if ( byte == "timer" ) { + timer_flg = 1; continue }; + if ( byte == "rcvwnd" ) { + rcvwnd_flg = 1; continue }; + if ( byte == "length" ) { + length_flg = 1; continue }; + if ( byte == "all" ) { + snd_cwnd_flg = snd_wnd_flg = srtt_flg = + state_flg = txq_flg = rxq_flg = + rexmit_flg = pmtu_flg = ssthresh_flg = + timer_flg = rcvwnd_flg = length_flg = 1; + continue + }; + usage("Unknown filter value given!") + } + continue; + } + + if ( argument == "timeout" ){ + argv[i]="" + timeout=strtol(tokenize(argv[i], "="),10) + continue; + } + + if ( argument == "update") { + argv[i]="" + update_disp = tokenize(argv[i], "=") + if (update_disp == "all") + always_update = 1; + continue; + } + + /* Anything on the command line after this point must + * be an address rule. + */ + source = tokenize(argv[i], "-") + argv[i] = "" + dest = tokenize(argv[i], "-") + + source_addr = tokenize(source, ":") + source="" + source_port = tokenize(source, ":") + + dest_addr = tokenize(dest, ":") + dest="" + dest_port = tokenize(dest, ":") + + /* stap bug */ + if ( dest_port == "fobar") i=i; + + ++filter_number; + j=filter_number*6; + filter[j] = ipv4_pton(source_addr,0) // Source address + filter[j+1] = ipv4_pton(source_addr,1) // Source address mask + filter[j+2] = ipv4_portton(source_port) // Source port + filter[j+3] = ipv4_pton(dest_addr,0) // Dest address + filter[j+4] = ipv4_pton(dest_addr,1) // Dest address mask + filter[j+5] = ipv4_portton(dest_port) // Dest port + + if (filter[j]< -1 || + filter[j+1] < -1 || + filter[j+2] < -1 || + filter[j+3] < -1 || + filter[j+4] < -1 || + filter[j+5] < -1 ) return -1; + + } + + /* default filter is all */ + if ( !filter_given ) + snd_cwnd_flg = snd_wnd_flg = srtt_flg = + state_flg = txq_flg = rxq_flg = + rexmit_flg = pmtu_flg = ssthresh_flg = + timer_flg = rcvwnd_flg = length_flg = 1; + + return filter_number; +} + +/* + * Convert an ascii integer values between 0 and 65534 to a u16 port number. + * "*" are treated as wildcards and will be converted to -1. + */ +function ipv4_portton:long (port:string) +{ + if ( port == "*" ) + return -1; + + pport=strtol(port,10); + + if ( pport > 0xffff ){ + printf("Bad port number %s\n",port) + return -22; + } + + return pport +} + +/* + * Convert ipv4 dot notation address into longs. + * Supports "*" in any field treating it as a wildcard by making the byte=0. + * If make_mask is set it creates a mask based on the "*" fields. All non='*' + * bytes are set to 0xff all * fields are set to 0x0;. + */ +function ipv4_pton:long (addr:string, make_mask:long) +{ + i=32; + ip=0; + ips=addr; + while(strlen(byte = tokenize(ips, ".")) != 0) { + i-=8; + ips=""; + + if ( byte == "*" ){ + byte = "0" + } else { + if ( make_mask ) byte = "255"; + } + + j=strtol(byte,10); + if ( j > 255 ){ + printf("bad address %s\n",addr) + return -22; + } + ip=ip+(j<<i) // left shift the byte into the address + } + if ( i != 0 ){ + printf("bad address %s\n",addr) + return -22; + } + return ip; +} + +/* + * Returns a unique value (stored in the global key_list) based on the socket + * address tuple. A new value is created if one does not already exist. + */ +function build_key:long (laddr:long, raddr:long, lport:long, rport:long) +{ + if ( key_list[laddr, raddr, lport, rport] ) + return key_list[laddr, raddr, lport, rport] + else + return key_list[laddr, raddr, lport, rport] = ++lastkey +} + +/* + * Checks the tuple against the rule list. If we pass through the rule + * then return a unique key value, otherwise return zero. + */ +function filter_key:long (sk:long) +{ + laddr = tcpmib_local_addr(sk); + raddr = tcpmib_remote_addr(sk); + lport = tcpmib_local_port(sk); + rport = tcpmib_remote_port(sk); + + for (i=1; i <= number_of_rules; i++){ + j=i*6; + + // Local filter + local_filter=remote_filter=0; + if ( (laddr&filter[j+1]) == filter[j] ) { + if ( (filter[j+2] == -1 ) || (lport == filter[j+2])) + local_filter = 1; + } + // Remote filter + if ( (raddr&filter[j+4]) == filter[j+3] ) { + if ( (filter[j+5] == -1 ) || (rport == filter[j+5])) + remote_filter = 1; + } + if(local_filter && remote_filter){ + return build_key(laddr, raddr, lport, rport); + } + } + return 0; +} + +/* Free up a slot in the data arrays */ +function clean_up (key:long) +{ + foreach ( [laddr, raddr, lport, rport] in key_list ){ + if ( key_list[laddr, raddr, lport, rport] == key ){ + break + } + } + + delete key_list[laddr, raddr, lport, rport] + + if (snd_cwnd_flg) delete snd_cwnd[key]; + if (snd_wnd_flg) delete snd_wnd[key]; + if (srtt_flg) delete srtt[key]; + if (state_flg) delete state[key]; + if (txq_flg) delete txq[key]; + if (rxq_flg) delete rxq[key]; + if (rexmit_flg) delete rexmit[key]; + if (pmtu_flg) delete pmtu[key]; + if (ssthresh_flg) delete ssthresh[key]; + if ( timer_flg ) { + delete tx_timer[key]; + delete find_timer[key]; + } + if (rcvwnd_flg) delete rcvwnd[key]; + delete length[key]; +} + +/* Terminates the run in timeout seconds, using global timeout value */ +probe timer.s(1) { + if ( timeout == -1 ) next + if ( !--timeout ) exit() +} + +function usage (msg:string) +{ + printf("\nUsage:\n"); + printf("\ttcp_trace.stp filter=<list of filters>[timeout=<sec>] \n"); + printf("\t\t\t[update=change|all] Rule\n\n"); + printf("\tRule format:"); + printf("<local address>:<local-port>-<remote address>:<remote-port>\n"); + printf("\tFilter values: all|state|txq|rxq|srtt|snd_cwnd|snd_wnd|\n"); + printf("\t\t\trexmit|pmtu|ssthresh|timer|rcvwnd\n\n"); + printf("%s\n\n",msg); + error(msg); +} diff --git a/testsuite/systemtap.examples/network/tcp_trace.txt b/testsuite/systemtap.examples/network/tcp_trace.txt new file mode 100644 index 00000000..3b2da39e --- /dev/null +++ b/testsuite/systemtap.examples/network/tcp_trace.txt @@ -0,0 +1,26 @@ +$ ./tcp_trace.stp *.*.*.*:80-*.*.*.*:* +Start TCP Probing..... + +Source Address Dest Address State Timer Tx-Q Rx-Q PMTU SndCwnd SndWnd RcvWnd SSRT Ssthreshold Rexmit Length +0.0.0.0:0 0.0.0.0:80 LISTEN 128 0 0 2 0 0 0 2147483647 0 40 +192.168.1.104:41060 192.168.1.201:80 SYN_RECV 0 0 1500 2 5888 5792 0 2147483647 0 488 +192.168.1.201:80 192.168.1.104:41060 ESTABLISHED 0 456 1500 3 5888 5792 8 2147483647 0 +192.168.1.201:80 192.168.1.104:41060 ESTABLISHED 2896 0 1500 3 5888 6880 8 2147483647 0 2896 +192.168.1.201:80 192.168.1.104:41060 ESTABLISHED 4116 0 1500 3 5888 6880 8 2147483647 0 1220 +192.168.1.201:80 192.168.1.104:41060 FIN_WAIT1 4117 0 1500 3 5888 6880 8 2147483647 0 +192.168.1.104:41060 192.168.1.201:80 FIN_WAIT1 2669 0 1500 4 8832 6880 8 2147483647 0 32 +192.168.1.104:41060 192.168.1.201:80 FIN_WAIT1 1221 0 1500 5 11648 6880 8 2147483647 0 32 +192.168.1.104:41060 192.168.1.201:80 FIN_WAIT1 1 0 1500 6 14592 6880 8 2147483647 0 32 +192.168.1.201:80 192.168.1.104:41060 FIN_WAIT2 0 1 1500 6 14592 6880 8 2147483647 0 +192.168.1.104:41061 192.168.1.201:80 SYN_RECV 0 0 1500 2 5888 5792 0 2147483647 0 552 +192.168.1.201:80 192.168.1.104:41061 ESTABLISHED 0 520 1500 3 5888 5792 8 2147483647 0 +192.168.1.104:41062 192.168.1.201:80 SYN_RECV 0 0 1500 2 5888 5792 0 2147483647 0 551 +192.168.1.201:80 192.168.1.104:41062 ESTABLISHED 0 519 1500 3 5888 5792 8 2147483647 0 +192.168.1.201:80 192.168.1.104:41061 ESTABLISHED 150 0 1500 3 5888 6880 8 2147483647 0 150 +192.168.1.201:80 192.168.1.104:41062 ESTABLISHED 150 0 1500 3 5888 6880 8 2147483647 0 150 +192.168.1.201:80 192.168.1.104:41061 FIN_WAIT1 151 0 1500 3 5888 6880 8 2147483647 0 +192.168.1.201:80 192.168.1.104:41062 FIN_WAIT1 151 0 1500 3 5888 6880 8 2147483647 0 +192.168.1.104:41061 192.168.1.201:80 FIN_WAIT1 1 0 1500 4 6912 6880 8 2147483647 0 32 +192.168.1.201:80 192.168.1.104:41061 FIN_WAIT2 0 1 1500 5 6912 6880 8 2147483647 0 +192.168.1.104:41062 192.168.1.201:80 FIN_WAIT1 1 0 1500 4 6912 6880 8 2147483647 0 32 +192.168.1.201:80 192.168.1.104:41062 FIN_WAIT2 0 1 1500 5 6912 6880 8 2147483647 0 diff --git a/testsuite/systemtap.examples/network/tcpipstat.meta b/testsuite/systemtap.examples/network/tcpipstat.meta index d77d0b2f..9e97ea5b 100644 --- a/testsuite/systemtap.examples/network/tcpipstat.meta +++ b/testsuite/systemtap.examples/network/tcpipstat.meta @@ -10,5 +10,6 @@ output: timed scope: per-socket arg_[0-9]+: tcpstat.stp [index=laddr|raddr|lport|rport|tuple] [timeout=<N sec>] [nozeros=1|0] [filters...] description: tcpipstat collects and display network statistics related to individual TCP sockets or groups of sockets. The statistics that are collected are simmer to that of the command netstat -s, only sorted and grouped by individual sockets. +test_support: stap -l 'tcpmib.InSegs' test_check: stap -p4 tcpipstat.stp test_installcheck: stap tcpipstat.stp timeout=1 diff --git a/testsuite/systemtap.examples/process/schedtimes.meta b/testsuite/systemtap.examples/process/schedtimes.meta index 960d8eda..5315042a 100644 --- a/testsuite/systemtap.examples/process/schedtimes.meta +++ b/testsuite/systemtap.examples/process/schedtimes.meta @@ -9,6 +9,6 @@ exit: user-controlled output: sorted-list scope: system-wide description: The schedtimes.stp script instruments the scheduler to track the amount of time that each process spends running, sleeping, queued, and waiting for io. On exit the script prints out the accumulated time for each state of processes observed. Optionally, this script can be used with the '-c' or '-x' options to focus on a specific PID. -test_support: stap -l kernel.trace("sched_switch"),kernel.trace("sched_wakeup") +test_support: stap -l 'kernel.trace("sched_switch"),kernel.trace("sched_wakeup")' test_check: stap -p4 schedtimes.stp test_installcheck: stap schedtimes.stp -c "sleep 0.2" |